// TestUpsertDelete tests if we can add/remove a relationship to/from the db. func TestUpsertDelete(t *testing.T) { rels, db := setup(t) defer teardown(t, db) t.Log("Given the need to upsert and delete relationships.") { t.Log("\tWhen starting from an empty relationships collection") { //---------------------------------------------------------------------- // Upsert the relationship. if err := relationship.Upsert(tests.Context, db, &rels[0]); err != nil { t.Fatalf("\t%s\tShould be able to upsert a relationship : %s", tests.Failed, err) } t.Logf("\t%s\tShould be able to upsert a relationship.", tests.Success) //---------------------------------------------------------------------- // Get the relationship. rel, err := relationship.GetByPredicate(tests.Context, db, rels[0].Predicate) if err != nil { t.Fatalf("\t%s\tShould be able to get the relationship by predicate : %s", tests.Failed, err) } t.Logf("\t%s\tShould be able to get the relationship by predicate.", tests.Success) //---------------------------------------------------------------------- // Check that we got the relationship we expected. if !reflect.DeepEqual(rels[0], *rel) { t.Logf("\t%+v", rels[0]) t.Logf("\t%+v", rel) t.Fatalf("\t%s\tShould be able to get back the same relationship.", tests.Failed) } t.Logf("\t%s\tShould be able to get back the same relationship.", tests.Success) //---------------------------------------------------------------------- // Delete the relationship. if err := relationship.Delete(tests.Context, db, rels[0].Predicate); err != nil { t.Fatalf("\t%s\tShould be able to delete the relationship : %s", tests.Failed, err) } t.Logf("\t%s\tShould be able to delete the relationship.", tests.Success) //---------------------------------------------------------------------- // Get the relationship. _, err = relationship.GetByPredicate(tests.Context, db, rels[0].Predicate) if err == nil { t.Fatalf("\t%s\tShould generate an error when getting a relationship with the deleted predicate : %s", tests.Failed, err) } t.Logf("\t%s\tShould generate an error when getting a relationship with the deleted predicate.", tests.Success) } } }
// Retrieve returns the specified Relationship from the system. // 200 Success, 400 Bad Request, 404 Not Found, 500 Internal func (relationshipHandle) Retrieve(c *web.Context) error { rel, err := relationship.GetByPredicate(c.SessionID, c.Ctx["DB"].(*db.DB), c.Params["predicate"]) if err != nil { if err == relationship.ErrNotFound { err = web.ErrNotFound } return err } c.Respond(rel, http.StatusOK) return nil }
// validateStartType verifies the start type of a view path. func validateStartType(context interface{}, db *db.DB, v *view.View) error { // Loop over paths to validate the start type for each. PathLoop: for _, path := range v.Paths { // Declare variables to track the first level relationship predicate. var firstRel string var firstDir string // Extract the first level relationship predicate. for _, segment := range path.Segments { if segment.Level == 1 { firstRel = segment.Predicate firstDir = segment.Direction } } // Get the relationship metadata. rel, err := relationship.GetByPredicate(context, db, firstRel) if err != nil { return err } // Get the relevant item types based on the direction of the // first relationship in the path. var itemTypes []string switch firstDir { case outString: itemTypes = rel.SubjectTypes case inString: itemTypes = rel.ObjectTypes } // Validate the starting type provided in the view. for _, itemType := range itemTypes { if itemType == v.StartType { continue PathLoop } } return fmt.Errorf("Start type %s does not match relationship subject types %v", v.StartType, itemTypes) } return nil }