// Remove removes an item into the items collection and remove any
// corresponding quads from the graph database.
func Remove(context interface{}, db *db.DB, graph *cayley.Handle, itemID string) error {
log.Dev(context, "Remove", "Started : ID[%s]", itemID)
// Get the item from the items collection.
items, err := item.GetByIDs(context, db, []string{itemID})
if err != nil {
log.Error(context, "Remove", err, "Completed")
return err
}
// Prepare the item map data.
itmMap := map[string]interface{}{
"item_id": items[0].ID,
"type": items[0].Type,
"version": items[0].Version,
"data": items[0].Data,
}
// Remove the corresponding relationships from the graph.
if err := wire.RemoveFromGraph(context, db, graph, itmMap); err != nil {
log.Error(context, "Remove", err, "Completed")
return err
}
// Delete the item.
if err := item.Delete(context, db, itemID); err != nil {
log.Error(context, "Remove", err, "Completed")
return err
}
log.Dev(context, "Remove", "Completed")
return nil
}
// TestUpsertDelete tests if we can add/remove an item to/from the db.
func TestUpsertDelete(t *testing.T) {
tests.ResetLog()
defer tests.DisplayLog()
db, err := db.NewMGO(tests.Context, tests.TestSession)
if err != nil {
t.Fatalf("\t%s\tShould be able to get a Mongo session : %v", tests.Failed, err)
}
defer db.CloseMGO(tests.Context)
defer func() {
if err := itemfix.Remove(tests.Context, db, prefix); err != nil {
t.Fatalf("\t%s\tShould be able to remove the items : %v", tests.Failed, err)
}
t.Logf("\t%s\tShould be able to remove the items.", tests.Success)
}()
t.Log("Given the need to upsert and delete items.")
{
t.Log("\tWhen starting from an empty items collection")
{
//----------------------------------------------------------------------
// Get the fixture.
items, err := itemfix.Get()
if err != nil {
t.Fatalf("\t%s\tShould be able retrieve item fixture : %s", tests.Failed, err)
}
//----------------------------------------------------------------------
// Upsert the item.
if err := item.Upsert(tests.Context, db, &items[0]); err != nil {
t.Fatalf("\t%s\tShould be able to upsert a item : %s", tests.Failed, err)
}
t.Logf("\t%s\tShould be able to upsert a item.", tests.Success)
//----------------------------------------------------------------------
// Get the item.
itemsBack, err := item.GetByIDs(tests.Context, db, []string{items[0].ID})
if err != nil {
t.Fatalf("\t%s\tShould be able to get the item by ID : %s", tests.Failed, err)
}
t.Logf("\t%s\tShould be able to get the item by ID.", tests.Success)
//----------------------------------------------------------------------
// Check that we got the item we expected.
if items[0].ID != itemsBack[0].ID {
t.Logf("\t%+v", items[0])
t.Logf("\t%+v", itemsBack[0])
t.Fatalf("\t%s\tShould be able to get back the same item.", tests.Failed)
}
t.Logf("\t%s\tShould be able to get back the same item.", tests.Success)
//----------------------------------------------------------------------
// Check that CreatedAt and UpdatedAt were set.
if itemsBack[0].CreatedAt.IsZero() || itemsBack[0].UpdatedAt.IsZero() {
t.Fatalf("\t%s\tShould set CreatedAt and UpdatedAt on upsert.", tests.Failed)
}
t.Logf("\t%s\tShould set CreatedAt and UpdatedAt on upsert.", tests.Success)
//----------------------------------------------------------------------
// Delete the item.
if err := item.Delete(tests.Context, db, items[0].ID); err != nil {
t.Fatalf("\t%s\tShould be able to delete the item : %s", tests.Failed, err)
}
t.Logf("\t%s\tShould be able to delete the item.", tests.Success)
//----------------------------------------------------------------------
// Get the item.
itemsBack, err = item.GetByIDs(tests.Context, db, []string{items[0].ID})
if len(itemsBack) != 0 {
t.Fatalf("\t%s\tShould generate an error when getting an item with the deleted ID : %s", tests.Failed, err)
}
t.Logf("\t%s\tShould generate an error when getting an item with the deleted ID.", tests.Success)
}
}
}