// UpsertForm upserts the provided form into the MongoDB database collection and // creates a gallery based on it. func UpsertForm(context interface{}, db *db.DB, f *form.Form) error { log.Dev(context, "UpsertForm", "Started : Form[%s]", f.ID.Hex()) var isNewForm bool // If there was no ID provided, we should set one. UpsertForm might optionally add // a form ID to ensure that we don't duplicate the FormGallery. if f.ID.Hex() == "" { isNewForm = true } if err := form.Upsert(context, db, f); err != nil { log.Error(context, "UpsertForm", err, "Completed") return err } if isNewForm { // Create the new gallery that we will create that is based on the current // form ID. g := gallery.Gallery{ FormID: f.ID, } if err := gallery.Create(context, db, &g); err != nil { log.Error(context, "UpsertForm", err, "Completed") return err } } log.Dev(context, "UpsertForm", "Completed") return nil }
// Add inserts forms for testing. func Add(context interface{}, db *db.DB, fms []form.Form) error { for _, fm := range fms { if err := form.Upsert(context, db, &fm); err != nil { return err } } return nil }
// Add inserts forms for testing. func Add(context interface{}, db *db.DB, fm *form.Form, subs []submission.Submission) error { if err := form.Upsert(context, db, fm); err != nil { return err } for _, sub := range subs { if err := submission.Create(context, db, fm.ID.Hex(), &sub); err != nil { return err } } return nil }
func TestUpsertDelete(t *testing.T) { fms, db := setupForms(t, "form") defer teardownForms(t, db) t.Log("Given the need to upsert and delete forms.") { t.Log("\tWhen starting from an empty forms collection") { //---------------------------------------------------------------------- // Upsert the form. if err := form.Upsert(tests.Context, db, &fms[0]); err != nil { t.Fatalf("\t%s\tShould be able to upsert a form : %s", tests.Failed, err) } t.Logf("\t%s\tShould be able to upsert a form.", tests.Success) //---------------------------------------------------------------------- // Get the form. fm, err := form.Retrieve(tests.Context, db, fms[0].ID.Hex()) if err != nil { t.Fatalf("\t%s\tShould be able to get the form by id : %s", tests.Failed, err) } t.Logf("\t%s\tShould be able to get the form by id.", tests.Success) //---------------------------------------------------------------------- // Check that we got the form we expected. if fms[0].ID.Hex() != fm.ID.Hex() { t.Fatalf("\t%s\tShould be able to get back the same form.", tests.Failed) } t.Logf("\t%s\tShould be able to get back the same form.", tests.Success) //---------------------------------------------------------------------- // Delete the form. if err := form.Delete(tests.Context, db, fms[0].ID.Hex()); err != nil { t.Fatalf("\t%s\tShould be able to delete the form : %s", tests.Failed, err) } t.Logf("\t%s\tShould be able to delete the form.", tests.Success) //---------------------------------------------------------------------- // Get the form. _, err = form.Retrieve(tests.Context, db, fms[0].ID.Hex()) if err == nil { t.Fatalf("\t%s\tShould generate an error when getting a form with the deleted id : %s", tests.Failed, err) } t.Logf("\t%s\tShould generate an error when getting a form with the deleted id.", tests.Success) //---------------------------------------------------------------------- // Create a new fresh form. fms[0].ID = "" if err := form.Upsert(tests.Context, db, &fms[0]); err != nil { t.Fatalf("\t%s\tShould be able to upsert a form : %s", tests.Failed, err) } t.Logf("\t%s\tShould be able to upsert a form.", tests.Success) //---------------------------------------------------------------------- // Ensure that an ID was set. if fms[0].ID == "" { t.Fatalf("\t%s\tShould be able to add an ID when upserting a new form : ID was not assigned", tests.Failed) } t.Logf("\t%s\tShould be able to add an ID when upserting a new form.", tests.Success) //---------------------------------------------------------------------- // Get the form. fm, err = form.Retrieve(tests.Context, db, fms[0].ID.Hex()) if err != nil { t.Fatalf("\t%s\tShould be able to get the form by id : %s", tests.Failed, err) } t.Logf("\t%s\tShould be able to get the form by id.", tests.Success) //---------------------------------------------------------------------- // Check that we got the form we expected. if fms[0].ID.Hex() != fm.ID.Hex() { t.Fatalf("\t%s\tShould be able to get back the same form.", tests.Failed) } t.Logf("\t%s\tShould be able to get back the same form.", tests.Success) //---------------------------------------------------------------------- // Delete the form. if err := form.Delete(tests.Context, db, fms[0].ID.Hex()); err != nil { t.Fatalf("\t%s\tShould be able to delete the form : %s", tests.Failed, err) } t.Logf("\t%s\tShould be able to delete the form.", tests.Success) //---------------------------------------------------------------------- // Get the form. _, err = form.Retrieve(tests.Context, db, fms[0].ID.Hex()) if err == nil { t.Fatalf("\t%s\tShould generate an error when getting a form with the deleted id : %s", tests.Failed, err) } t.Logf("\t%s\tShould generate an error when getting a form with the deleted id.", tests.Success) } } }
func TestUpdateStatus(t *testing.T) { fms, db := setupForms(t, "form") defer teardownForms(t, db) t.Log("Given the need to upsert and delete forms.") { t.Log("\tWhen starting from an empty forms collection") { //---------------------------------------------------------------------- // Upsert the form. if err := form.Upsert(tests.Context, db, &fms[0]); err != nil { t.Fatalf("\t%s\tShould be able to upsert a form : %s", tests.Failed, err) } t.Logf("\t%s\tShould be able to upsert a form.", tests.Success) //---------------------------------------------------------------------- // Update it's status. newStatus := "updated_" + time.Now().String() fm, err := form.UpdateStatus(tests.Context, db, fms[0].ID.Hex(), newStatus) if err != nil { t.Logf("\t%s\tShould be able to update a forms status without error : %s", tests.Success, err.Error()) } t.Logf("\t%s\tShould be able to update a forms status without error.", tests.Success) //---------------------------------------------------------------------- // Check we got the right form. if fm.ID.Hex() != fms[0].ID.Hex() { t.Fatalf("\t%s\tShould be able to retrieve a form given it's id : ID's of retrieved forms do not match", tests.Success) } t.Logf("\t%s\tShould be able to retrieve a form given it's id.", tests.Success) //---------------------------------------------------------------------- // Check that it's status is changed. if fm.Status != newStatus { t.Fatalf("\t%s\tShould be able to set the status on the returned form : Expected %s, got %s", tests.Success, newStatus, fm.Status) } t.Logf("\t%s\tShould be able to set the status on the returned form.", tests.Success) //---------------------------------------------------------------------- // Get a copy from the DB. rfm, err := form.Retrieve(tests.Context, db, fm.ID.Hex()) if err != nil { t.Fatalf("\t%s\tShould be able to retrieve a form given it's id : %s", tests.Success, err.Error()) } t.Logf("\t%s\tShould be able to retrieve a form given it's id.", tests.Success) //---------------------------------------------------------------------- // Check that the DB copy has it's status changed. if rfm.Status != newStatus { t.Fatalf("\t%s\tShould be able to update a form's status in the database : Expected %s, got %s", tests.Failed, newStatus, rfm.Status) } t.Logf("\t%s\tShould be able to update a form's status in the database.", tests.Success) } } }
func TestList(t *testing.T) { fms, db := setupForms(t, "form") defer teardownForms(t, db) t.Log("Given the need to upsert and delete forms.") { t.Log("\tWhen starting from an empty forms collection") { //---------------------------------------------------------------------- // Upsert the forms. if err := form.Upsert(tests.Context, db, &fms[0]); err != nil { t.Fatalf("\t%s\tShould be able to upsert a form : %s", tests.Failed, err) } t.Logf("\t%s\tShould be able to upsert forms.", tests.Success) // This particular looping logic is required at the moment due to issues // with the current CI environment. limit := 10 offset := 0 for { lfms, err := form.List(tests.Context, db, limit, offset) if err != nil { t.Fatalf("\t%s\tShould be able to list forms : %s", tests.Failed, err) } t.Logf("\t%s\tShould be able to list forms", tests.Success) if len(lfms) > limit { t.Fatalf("\t%s\tShould only return a maximum of the provided limit : Expected less than %d, got %d", tests.Failed, limit, len(lfms)) } t.Logf("\t%s\tShould only return a maximum of the provided limit.", tests.Success) // If we are another page of data (we have itterated at least once) and // the length of the results is zero, then we have no more results to // paginate over. At this point, we know that we couldn't find all the // upserted records. if offset > 0 && len(lfms) == 0 { t.Fatalf("\t%s\tShould be able to find a form that was upserted : Could not an upserted form in result set", tests.Failed) } found := false for _, fm := range lfms { if fm.ID.Hex() == fms[0].ID.Hex() { found = true break } } // If not all the elements have been found yet, we need to continue the // itteration process. if !found { // Increase the offset by the limit amount. offset = offset + limit // Continue itteration. continue } // Exit the itteration in the event that all the upserted documents have // been found. break } t.Logf("\t%s\tShould be able to find a form that was upserted", tests.Success) } } }