func testOrganismOneToOneSetOpJbrowseOrganismUsingJbrowseOrganism(t *testing.T) { var err error tx := MustTx(boil.Begin()) defer tx.Rollback() var a Organism var b, c JbrowseOrganism seed := randomize.NewSeed() if err = randomize.Struct(seed, &a, organismDBTypes, false, strmangle.SetComplement(organismPrimaryKeyColumns, organismColumnsWithoutDefault)...); err != nil { t.Fatal(err) } if err = randomize.Struct(seed, &b, jbrowseOrganismDBTypes, false, strmangle.SetComplement(jbrowseOrganismPrimaryKeyColumns, jbrowseOrganismColumnsWithoutDefault)...); err != nil { t.Fatal(err) } if err = randomize.Struct(seed, &c, jbrowseOrganismDBTypes, false, strmangle.SetComplement(jbrowseOrganismPrimaryKeyColumns, jbrowseOrganismColumnsWithoutDefault)...); err != nil { t.Fatal(err) } if err := a.Insert(tx); err != nil { t.Fatal(err) } if err = b.Insert(tx); err != nil { t.Fatal(err) } for i, x := range []*JbrowseOrganism{&b, &c} { err = a.SetJbrowseOrganism(tx, i != 0, x) if err != nil { t.Fatal(err) } if a.R.JbrowseOrganism != x { t.Error("relationship struct not set to correct value") } if x.R.Organism != &a { t.Error("failed to append to foreign relationship struct") } if a.OrganismID != x.OrganismID { t.Error("foreign key was wrong value", a.OrganismID) } zero := reflect.Zero(reflect.TypeOf(x.OrganismID)) reflect.Indirect(reflect.ValueOf(&x.OrganismID)).Set(zero) if err = x.Reload(tx); err != nil { t.Fatal("failed to reload", err) } if a.OrganismID != x.OrganismID { t.Error("foreign key was wrong value", a.OrganismID, x.OrganismID) } if err = x.Delete(tx); err != nil { t.Fatal("failed to delete x", err) } } }
func testFeatureCvtermOneToOneSetOpFeatureCvtermPubUsingFeatureCvtermPub(t *testing.T) { var err error tx := MustTx(boil.Begin()) defer tx.Rollback() var a FeatureCvterm var b, c FeatureCvtermPub seed := randomize.NewSeed() if err = randomize.Struct(seed, &a, featureCvtermDBTypes, false, strmangle.SetComplement(featureCvtermPrimaryKeyColumns, featureCvtermColumnsWithoutDefault)...); err != nil { t.Fatal(err) } if err = randomize.Struct(seed, &b, featureCvtermPubDBTypes, false, strmangle.SetComplement(featureCvtermPubPrimaryKeyColumns, featureCvtermPubColumnsWithoutDefault)...); err != nil { t.Fatal(err) } if err = randomize.Struct(seed, &c, featureCvtermPubDBTypes, false, strmangle.SetComplement(featureCvtermPubPrimaryKeyColumns, featureCvtermPubColumnsWithoutDefault)...); err != nil { t.Fatal(err) } if err := a.Insert(tx); err != nil { t.Fatal(err) } if err = b.Insert(tx); err != nil { t.Fatal(err) } for i, x := range []*FeatureCvtermPub{&b, &c} { err = a.SetFeatureCvtermPub(tx, i != 0, x) if err != nil { t.Fatal(err) } if a.R.FeatureCvtermPub != x { t.Error("relationship struct not set to correct value") } if x.R.FeatureCvterm != &a { t.Error("failed to append to foreign relationship struct") } if a.FeatureCvtermID != x.FeatureCvtermID { t.Error("foreign key was wrong value", a.FeatureCvtermID) } zero := reflect.Zero(reflect.TypeOf(x.FeatureCvtermID)) reflect.Indirect(reflect.ValueOf(&x.FeatureCvtermID)).Set(zero) if err = x.Reload(tx); err != nil { t.Fatal("failed to reload", err) } if a.FeatureCvtermID != x.FeatureCvtermID { t.Error("foreign key was wrong value", a.FeatureCvtermID, x.FeatureCvtermID) } if err = x.Delete(tx); err != nil { t.Fatal("failed to delete x", err) } } }
func testStockDbxrefOneToOneSetOpStockDbxrefpropUsingStockDbxrefprop(t *testing.T) { var err error tx := MustTx(boil.Begin()) defer tx.Rollback() var a StockDbxref var b, c StockDbxrefprop seed := randomize.NewSeed() if err = randomize.Struct(seed, &a, stockDbxrefDBTypes, false, strmangle.SetComplement(stockDbxrefPrimaryKeyColumns, stockDbxrefColumnsWithoutDefault)...); err != nil { t.Fatal(err) } if err = randomize.Struct(seed, &b, stockDbxrefpropDBTypes, false, strmangle.SetComplement(stockDbxrefpropPrimaryKeyColumns, stockDbxrefpropColumnsWithoutDefault)...); err != nil { t.Fatal(err) } if err = randomize.Struct(seed, &c, stockDbxrefpropDBTypes, false, strmangle.SetComplement(stockDbxrefpropPrimaryKeyColumns, stockDbxrefpropColumnsWithoutDefault)...); err != nil { t.Fatal(err) } if err := a.Insert(tx); err != nil { t.Fatal(err) } if err = b.Insert(tx); err != nil { t.Fatal(err) } for i, x := range []*StockDbxrefprop{&b, &c} { err = a.SetStockDbxrefprop(tx, i != 0, x) if err != nil { t.Fatal(err) } if a.R.StockDbxrefprop != x { t.Error("relationship struct not set to correct value") } if x.R.StockDbxref != &a { t.Error("failed to append to foreign relationship struct") } if a.StockDbxrefID != x.StockDbxrefID { t.Error("foreign key was wrong value", a.StockDbxrefID) } zero := reflect.Zero(reflect.TypeOf(x.StockDbxrefID)) reflect.Indirect(reflect.ValueOf(&x.StockDbxrefID)).Set(zero) if err = x.Reload(tx); err != nil { t.Fatal("failed to reload", err) } if a.StockDbxrefID != x.StockDbxrefID { t.Error("foreign key was wrong value", a.StockDbxrefID, x.StockDbxrefID) } if err = x.Delete(tx); err != nil { t.Fatal("failed to delete x", err) } } }
func testAuthRoleOneToOneSetOpAuthRolePermissionUsingAuthRolePermission(t *testing.T) { var err error tx := MustTx(boil.Begin()) defer tx.Rollback() var a AuthRole var b, c AuthRolePermission seed := randomize.NewSeed() if err = randomize.Struct(seed, &a, authRoleDBTypes, false, strmangle.SetComplement(authRolePrimaryKeyColumns, authRoleColumnsWithoutDefault)...); err != nil { t.Fatal(err) } if err = randomize.Struct(seed, &b, authRolePermissionDBTypes, false, strmangle.SetComplement(authRolePermissionPrimaryKeyColumns, authRolePermissionColumnsWithoutDefault)...); err != nil { t.Fatal(err) } if err = randomize.Struct(seed, &c, authRolePermissionDBTypes, false, strmangle.SetComplement(authRolePermissionPrimaryKeyColumns, authRolePermissionColumnsWithoutDefault)...); err != nil { t.Fatal(err) } if err := a.Insert(tx); err != nil { t.Fatal(err) } if err = b.Insert(tx); err != nil { t.Fatal(err) } for i, x := range []*AuthRolePermission{&b, &c} { err = a.SetAuthRolePermission(tx, i != 0, x) if err != nil { t.Fatal(err) } if a.R.AuthRolePermission != x { t.Error("relationship struct not set to correct value") } if x.R.AuthRole != &a { t.Error("failed to append to foreign relationship struct") } if a.AuthRoleID != x.AuthRoleID { t.Error("foreign key was wrong value", a.AuthRoleID) } zero := reflect.Zero(reflect.TypeOf(x.AuthRoleID)) reflect.Indirect(reflect.ValueOf(&x.AuthRoleID)).Set(zero) if err = x.Reload(tx); err != nil { t.Fatal("failed to reload", err) } if a.AuthRoleID != x.AuthRoleID { t.Error("foreign key was wrong value", a.AuthRoleID, x.AuthRoleID) } if err = x.Delete(tx); err != nil { t.Fatal("failed to delete x", err) } } }
func testGenotypeOneToOneSetOpPhenstatementUsingPhenstatement(t *testing.T) { var err error tx := MustTx(boil.Begin()) defer tx.Rollback() var a Genotype var b, c Phenstatement seed := randomize.NewSeed() if err = randomize.Struct(seed, &a, genotypeDBTypes, false, strmangle.SetComplement(genotypePrimaryKeyColumns, genotypeColumnsWithoutDefault)...); err != nil { t.Fatal(err) } if err = randomize.Struct(seed, &b, phenstatementDBTypes, false, strmangle.SetComplement(phenstatementPrimaryKeyColumns, phenstatementColumnsWithoutDefault)...); err != nil { t.Fatal(err) } if err = randomize.Struct(seed, &c, phenstatementDBTypes, false, strmangle.SetComplement(phenstatementPrimaryKeyColumns, phenstatementColumnsWithoutDefault)...); err != nil { t.Fatal(err) } if err := a.Insert(tx); err != nil { t.Fatal(err) } if err = b.Insert(tx); err != nil { t.Fatal(err) } for i, x := range []*Phenstatement{&b, &c} { err = a.SetPhenstatement(tx, i != 0, x) if err != nil { t.Fatal(err) } if a.R.Phenstatement != x { t.Error("relationship struct not set to correct value") } if x.R.Genotype != &a { t.Error("failed to append to foreign relationship struct") } if a.GenotypeID != x.GenotypeID { t.Error("foreign key was wrong value", a.GenotypeID) } zero := reflect.Zero(reflect.TypeOf(x.GenotypeID)) reflect.Indirect(reflect.ValueOf(&x.GenotypeID)).Set(zero) if err = x.Reload(tx); err != nil { t.Fatal("failed to reload", err) } if a.GenotypeID != x.GenotypeID { t.Error("foreign key was wrong value", a.GenotypeID, x.GenotypeID) } if err = x.Delete(tx); err != nil { t.Fatal("failed to delete x", err) } } }
func testFeatureGenotypeToOneSetOpFeatureUsingChromosome(t *testing.T) { var err error tx := MustTx(boil.Begin()) defer tx.Rollback() var a FeatureGenotype var b, c Feature seed := randomize.NewSeed() if err = randomize.Struct(seed, &a, featureGenotypeDBTypes, false, strmangle.SetComplement(featureGenotypePrimaryKeyColumns, featureGenotypeColumnsWithoutDefault)...); err != nil { t.Fatal(err) } if err = randomize.Struct(seed, &b, featureDBTypes, false, strmangle.SetComplement(featurePrimaryKeyColumns, featureColumnsWithoutDefault)...); err != nil { t.Fatal(err) } if err = randomize.Struct(seed, &c, featureDBTypes, false, strmangle.SetComplement(featurePrimaryKeyColumns, featureColumnsWithoutDefault)...); err != nil { t.Fatal(err) } if err := a.Insert(tx); err != nil { t.Fatal(err) } if err = b.Insert(tx); err != nil { t.Fatal(err) } for i, x := range []*Feature{&b, &c} { err = a.SetChromosome(tx, i != 0, x) if err != nil { t.Fatal(err) } if a.R.Chromosome != x { t.Error("relationship struct not set to correct value") } if x.R.ChromosomeFeatureGenotype != &a { t.Error("failed to append to foreign relationship struct") } if a.ChromosomeID.Int != x.FeatureID { t.Error("foreign key was wrong value", a.ChromosomeID.Int) } zero := reflect.Zero(reflect.TypeOf(a.ChromosomeID.Int)) reflect.Indirect(reflect.ValueOf(&a.ChromosomeID.Int)).Set(zero) if err = a.Reload(tx); err != nil { t.Fatal("failed to reload", err) } if a.ChromosomeID.Int != x.FeatureID { t.Error("foreign key was wrong value", a.ChromosomeID.Int, x.FeatureID) } } }
func testPubauthorToOneSetOpPubUsingPub(t *testing.T) { var err error tx := MustTx(boil.Begin()) defer tx.Rollback() var a Pubauthor var b, c Pub seed := randomize.NewSeed() if err = randomize.Struct(seed, &a, pubauthorDBTypes, false, strmangle.SetComplement(pubauthorPrimaryKeyColumns, pubauthorColumnsWithoutDefault)...); err != nil { t.Fatal(err) } if err = randomize.Struct(seed, &b, pubDBTypes, false, strmangle.SetComplement(pubPrimaryKeyColumns, pubColumnsWithoutDefault)...); err != nil { t.Fatal(err) } if err = randomize.Struct(seed, &c, pubDBTypes, false, strmangle.SetComplement(pubPrimaryKeyColumns, pubColumnsWithoutDefault)...); err != nil { t.Fatal(err) } if err := a.Insert(tx); err != nil { t.Fatal(err) } if err = b.Insert(tx); err != nil { t.Fatal(err) } for i, x := range []*Pub{&b, &c} { err = a.SetPub(tx, i != 0, x) if err != nil { t.Fatal(err) } if a.R.Pub != x { t.Error("relationship struct not set to correct value") } if x.R.Pubauthor != &a { t.Error("failed to append to foreign relationship struct") } if a.PubID != x.PubID { t.Error("foreign key was wrong value", a.PubID) } zero := reflect.Zero(reflect.TypeOf(a.PubID)) reflect.Indirect(reflect.ValueOf(&a.PubID)).Set(zero) if err = a.Reload(tx); err != nil { t.Fatal("failed to reload", err) } if a.PubID != x.PubID { t.Error("foreign key was wrong value", a.PubID, x.PubID) } } }
func testPhenotypeComparisonToOneSetOpPhenotypeUsingPhenotype2(t *testing.T) { var err error tx := MustTx(boil.Begin()) defer tx.Rollback() var a PhenotypeComparison var b, c Phenotype seed := randomize.NewSeed() if err = randomize.Struct(seed, &a, phenotypeComparisonDBTypes, false, strmangle.SetComplement(phenotypeComparisonPrimaryKeyColumns, phenotypeComparisonColumnsWithoutDefault)...); err != nil { t.Fatal(err) } if err = randomize.Struct(seed, &b, phenotypeDBTypes, false, strmangle.SetComplement(phenotypePrimaryKeyColumns, phenotypeColumnsWithoutDefault)...); err != nil { t.Fatal(err) } if err = randomize.Struct(seed, &c, phenotypeDBTypes, false, strmangle.SetComplement(phenotypePrimaryKeyColumns, phenotypeColumnsWithoutDefault)...); err != nil { t.Fatal(err) } if err := a.Insert(tx); err != nil { t.Fatal(err) } if err = b.Insert(tx); err != nil { t.Fatal(err) } for i, x := range []*Phenotype{&b, &c} { err = a.SetPhenotype2(tx, i != 0, x) if err != nil { t.Fatal(err) } if a.R.Phenotype2 != x { t.Error("relationship struct not set to correct value") } if x.R.Phenotype2PhenotypeComparisons[0] != &a { t.Error("failed to append to foreign relationship struct") } if a.Phenotype2ID.Int != x.PhenotypeID { t.Error("foreign key was wrong value", a.Phenotype2ID.Int) } zero := reflect.Zero(reflect.TypeOf(a.Phenotype2ID.Int)) reflect.Indirect(reflect.ValueOf(&a.Phenotype2ID.Int)).Set(zero) if err = a.Reload(tx); err != nil { t.Fatal("failed to reload", err) } if a.Phenotype2ID.Int != x.PhenotypeID { t.Error("foreign key was wrong value", a.Phenotype2ID.Int, x.PhenotypeID) } } }
func testEnvironmentCvtermToOneSetOpEnvironmentUsingEnvironment(t *testing.T) { var err error tx := MustTx(boil.Begin()) defer tx.Rollback() var a EnvironmentCvterm var b, c Environment seed := randomize.NewSeed() if err = randomize.Struct(seed, &a, environmentCvtermDBTypes, false, strmangle.SetComplement(environmentCvtermPrimaryKeyColumns, environmentCvtermColumnsWithoutDefault)...); err != nil { t.Fatal(err) } if err = randomize.Struct(seed, &b, environmentDBTypes, false, strmangle.SetComplement(environmentPrimaryKeyColumns, environmentColumnsWithoutDefault)...); err != nil { t.Fatal(err) } if err = randomize.Struct(seed, &c, environmentDBTypes, false, strmangle.SetComplement(environmentPrimaryKeyColumns, environmentColumnsWithoutDefault)...); err != nil { t.Fatal(err) } if err := a.Insert(tx); err != nil { t.Fatal(err) } if err = b.Insert(tx); err != nil { t.Fatal(err) } for i, x := range []*Environment{&b, &c} { err = a.SetEnvironment(tx, i != 0, x) if err != nil { t.Fatal(err) } if a.R.Environment != x { t.Error("relationship struct not set to correct value") } if x.R.EnvironmentCvterm != &a { t.Error("failed to append to foreign relationship struct") } if a.EnvironmentID != x.EnvironmentID { t.Error("foreign key was wrong value", a.EnvironmentID) } zero := reflect.Zero(reflect.TypeOf(a.EnvironmentID)) reflect.Indirect(reflect.ValueOf(&a.EnvironmentID)).Set(zero) if err = a.Reload(tx); err != nil { t.Fatal("failed to reload", err) } if a.EnvironmentID != x.EnvironmentID { t.Error("foreign key was wrong value", a.EnvironmentID, x.EnvironmentID) } } }
func testContactRelationshipToOneSetOpContactUsingSubject(t *testing.T) { var err error tx := MustTx(boil.Begin()) defer tx.Rollback() var a ContactRelationship var b, c Contact seed := randomize.NewSeed() if err = randomize.Struct(seed, &a, contactRelationshipDBTypes, false, strmangle.SetComplement(contactRelationshipPrimaryKeyColumns, contactRelationshipColumnsWithoutDefault)...); err != nil { t.Fatal(err) } if err = randomize.Struct(seed, &b, contactDBTypes, false, strmangle.SetComplement(contactPrimaryKeyColumns, contactColumnsWithoutDefault)...); err != nil { t.Fatal(err) } if err = randomize.Struct(seed, &c, contactDBTypes, false, strmangle.SetComplement(contactPrimaryKeyColumns, contactColumnsWithoutDefault)...); err != nil { t.Fatal(err) } if err := a.Insert(tx); err != nil { t.Fatal(err) } if err = b.Insert(tx); err != nil { t.Fatal(err) } for i, x := range []*Contact{&b, &c} { err = a.SetSubject(tx, i != 0, x) if err != nil { t.Fatal(err) } if a.R.Subject != x { t.Error("relationship struct not set to correct value") } if x.R.SubjectContactRelationship != &a { t.Error("failed to append to foreign relationship struct") } if a.SubjectID != x.ContactID { t.Error("foreign key was wrong value", a.SubjectID) } zero := reflect.Zero(reflect.TypeOf(a.SubjectID)) reflect.Indirect(reflect.ValueOf(&a.SubjectID)).Set(zero) if err = a.Reload(tx); err != nil { t.Fatal("failed to reload", err) } if a.SubjectID != x.ContactID { t.Error("foreign key was wrong value", a.SubjectID, x.ContactID) } } }
func testStockItemOrderToOneSetOpStockUsingItem(t *testing.T) { var err error tx := MustTx(boil.Begin()) defer tx.Rollback() var a StockItemOrder var b, c Stock seed := randomize.NewSeed() if err = randomize.Struct(seed, &a, stockItemOrderDBTypes, false, strmangle.SetComplement(stockItemOrderPrimaryKeyColumns, stockItemOrderColumnsWithoutDefault)...); err != nil { t.Fatal(err) } if err = randomize.Struct(seed, &b, stockDBTypes, false, strmangle.SetComplement(stockPrimaryKeyColumns, stockColumnsWithoutDefault)...); err != nil { t.Fatal(err) } if err = randomize.Struct(seed, &c, stockDBTypes, false, strmangle.SetComplement(stockPrimaryKeyColumns, stockColumnsWithoutDefault)...); err != nil { t.Fatal(err) } if err := a.Insert(tx); err != nil { t.Fatal(err) } if err = b.Insert(tx); err != nil { t.Fatal(err) } for i, x := range []*Stock{&b, &c} { err = a.SetItem(tx, i != 0, x) if err != nil { t.Fatal(err) } if a.R.Item != x { t.Error("relationship struct not set to correct value") } if x.R.ItemStockItemOrder != &a { t.Error("failed to append to foreign relationship struct") } if a.ItemID != x.StockID { t.Error("foreign key was wrong value", a.ItemID) } zero := reflect.Zero(reflect.TypeOf(a.ItemID)) reflect.Indirect(reflect.ValueOf(&a.ItemID)).Set(zero) if err = a.Reload(tx); err != nil { t.Fatal("failed to reload", err) } if a.ItemID != x.StockID { t.Error("foreign key was wrong value", a.ItemID, x.StockID) } } }
func testThumbnailToOneSetOpFileUsingFile(t *testing.T) { var err error tx := MustTx(boil.Begin()) defer tx.Rollback() var a Thumbnail var b, c File seed := randomize.NewSeed() if err = randomize.Struct(seed, &a, thumbnailDBTypes, false, strmangle.SetComplement(thumbnailPrimaryKeyColumns, thumbnailColumnsWithoutDefault)...); err != nil { t.Fatal(err) } if err = randomize.Struct(seed, &b, fileDBTypes, false, strmangle.SetComplement(filePrimaryKeyColumns, fileColumnsWithoutDefault)...); err != nil { t.Fatal(err) } if err = randomize.Struct(seed, &c, fileDBTypes, false, strmangle.SetComplement(filePrimaryKeyColumns, fileColumnsWithoutDefault)...); err != nil { t.Fatal(err) } if err := a.Insert(tx); err != nil { t.Fatal(err) } if err = b.Insert(tx); err != nil { t.Fatal(err) } for i, x := range []*File{&b, &c} { err = a.SetFile(tx, i != 0, x) if err != nil { t.Fatal(err) } if a.R.File != x { t.Error("relationship struct not set to correct value") } if x.R.Thumbnails[0] != &a { t.Error("failed to append to foreign relationship struct") } if a.FileID != x.ID { t.Error("foreign key was wrong value", a.FileID) } zero := reflect.Zero(reflect.TypeOf(a.FileID)) reflect.Indirect(reflect.ValueOf(&a.FileID)).Set(zero) if err = a.Reload(tx); err != nil { t.Fatal("failed to reload", err) } if a.FileID != x.ID { t.Error("foreign key was wrong value", a.FileID, x.ID) } } }
func testAnalysisfeaturepropToOneSetOpAnalysisfeatureUsingAnalysisfeature(t *testing.T) { var err error tx := MustTx(boil.Begin()) defer tx.Rollback() var a Analysisfeatureprop var b, c Analysisfeature seed := randomize.NewSeed() if err = randomize.Struct(seed, &a, analysisfeaturepropDBTypes, false, strmangle.SetComplement(analysisfeaturepropPrimaryKeyColumns, analysisfeaturepropColumnsWithoutDefault)...); err != nil { t.Fatal(err) } if err = randomize.Struct(seed, &b, analysisfeatureDBTypes, false, strmangle.SetComplement(analysisfeaturePrimaryKeyColumns, analysisfeatureColumnsWithoutDefault)...); err != nil { t.Fatal(err) } if err = randomize.Struct(seed, &c, analysisfeatureDBTypes, false, strmangle.SetComplement(analysisfeaturePrimaryKeyColumns, analysisfeatureColumnsWithoutDefault)...); err != nil { t.Fatal(err) } if err := a.Insert(tx); err != nil { t.Fatal(err) } if err = b.Insert(tx); err != nil { t.Fatal(err) } for i, x := range []*Analysisfeature{&b, &c} { err = a.SetAnalysisfeature(tx, i != 0, x) if err != nil { t.Fatal(err) } if a.R.Analysisfeature != x { t.Error("relationship struct not set to correct value") } if x.R.Analysisfeatureprop != &a { t.Error("failed to append to foreign relationship struct") } if a.AnalysisfeatureID != x.AnalysisfeatureID { t.Error("foreign key was wrong value", a.AnalysisfeatureID) } zero := reflect.Zero(reflect.TypeOf(a.AnalysisfeatureID)) reflect.Indirect(reflect.ValueOf(&a.AnalysisfeatureID)).Set(zero) if err = a.Reload(tx); err != nil { t.Fatal("failed to reload", err) } if a.AnalysisfeatureID != x.AnalysisfeatureID { t.Error("foreign key was wrong value", a.AnalysisfeatureID, x.AnalysisfeatureID) } } }
func testCvtermpathToOneSetOpCvtermUsingType(t *testing.T) { var err error tx := MustTx(boil.Begin()) defer tx.Rollback() var a Cvtermpath var b, c Cvterm seed := randomize.NewSeed() if err = randomize.Struct(seed, &a, cvtermpathDBTypes, false, strmangle.SetComplement(cvtermpathPrimaryKeyColumns, cvtermpathColumnsWithoutDefault)...); err != nil { t.Fatal(err) } if err = randomize.Struct(seed, &b, cvtermDBTypes, false, strmangle.SetComplement(cvtermPrimaryKeyColumns, cvtermColumnsWithoutDefault)...); err != nil { t.Fatal(err) } if err = randomize.Struct(seed, &c, cvtermDBTypes, false, strmangle.SetComplement(cvtermPrimaryKeyColumns, cvtermColumnsWithoutDefault)...); err != nil { t.Fatal(err) } if err := a.Insert(tx); err != nil { t.Fatal(err) } if err = b.Insert(tx); err != nil { t.Fatal(err) } for i, x := range []*Cvterm{&b, &c} { err = a.SetType(tx, i != 0, x) if err != nil { t.Fatal(err) } if a.R.Type != x { t.Error("relationship struct not set to correct value") } if x.R.TypeCvtermpath != &a { t.Error("failed to append to foreign relationship struct") } if a.TypeID.Int != x.CvtermID { t.Error("foreign key was wrong value", a.TypeID.Int) } zero := reflect.Zero(reflect.TypeOf(a.TypeID.Int)) reflect.Indirect(reflect.ValueOf(&a.TypeID.Int)).Set(zero) if err = a.Reload(tx); err != nil { t.Fatal("failed to reload", err) } if a.TypeID.Int != x.CvtermID { t.Error("foreign key was wrong value", a.TypeID.Int, x.CvtermID) } } }
func testOrganismDbxrefToOneSetOpDbxrefUsingDbxref(t *testing.T) { var err error tx := MustTx(boil.Begin()) defer tx.Rollback() var a OrganismDbxref var b, c Dbxref seed := randomize.NewSeed() if err = randomize.Struct(seed, &a, organismDbxrefDBTypes, false, strmangle.SetComplement(organismDbxrefPrimaryKeyColumns, organismDbxrefColumnsWithoutDefault)...); err != nil { t.Fatal(err) } if err = randomize.Struct(seed, &b, dbxrefDBTypes, false, strmangle.SetComplement(dbxrefPrimaryKeyColumns, dbxrefColumnsWithoutDefault)...); err != nil { t.Fatal(err) } if err = randomize.Struct(seed, &c, dbxrefDBTypes, false, strmangle.SetComplement(dbxrefPrimaryKeyColumns, dbxrefColumnsWithoutDefault)...); err != nil { t.Fatal(err) } if err := a.Insert(tx); err != nil { t.Fatal(err) } if err = b.Insert(tx); err != nil { t.Fatal(err) } for i, x := range []*Dbxref{&b, &c} { err = a.SetDbxref(tx, i != 0, x) if err != nil { t.Fatal(err) } if a.R.Dbxref != x { t.Error("relationship struct not set to correct value") } if x.R.OrganismDbxref != &a { t.Error("failed to append to foreign relationship struct") } if a.DbxrefID != x.DbxrefID { t.Error("foreign key was wrong value", a.DbxrefID) } zero := reflect.Zero(reflect.TypeOf(a.DbxrefID)) reflect.Indirect(reflect.ValueOf(&a.DbxrefID)).Set(zero) if err = a.Reload(tx); err != nil { t.Fatal("failed to reload", err) } if a.DbxrefID != x.DbxrefID { t.Error("foreign key was wrong value", a.DbxrefID, x.DbxrefID) } } }
func testCvtermpathToOneRemoveOpCvtermUsingType(t *testing.T) { var err error tx := MustTx(boil.Begin()) defer tx.Rollback() var a Cvtermpath var b Cvterm seed := randomize.NewSeed() if err = randomize.Struct(seed, &a, cvtermpathDBTypes, false, strmangle.SetComplement(cvtermpathPrimaryKeyColumns, cvtermpathColumnsWithoutDefault)...); err != nil { t.Fatal(err) } if err = randomize.Struct(seed, &b, cvtermDBTypes, false, strmangle.SetComplement(cvtermPrimaryKeyColumns, cvtermColumnsWithoutDefault)...); err != nil { t.Fatal(err) } if err = a.Insert(tx); err != nil { t.Fatal(err) } if err = a.SetType(tx, true, &b); err != nil { t.Fatal(err) } if err = a.RemoveType(tx, &b); err != nil { t.Error("failed to remove relationship") } count, err := a.Type(tx).Count() if err != nil { t.Error(err) } if count != 0 { t.Error("want no relationships remaining") } if a.R.Type != nil { t.Error("R struct entry should be nil") } if a.TypeID.Valid { t.Error("foreign key value should be nil") } if b.R.TypeCvtermpath != nil { t.Error("failed to remove a from b's relationships") } }
func testFeatureGenotypeToOneRemoveOpFeatureUsingChromosome(t *testing.T) { var err error tx := MustTx(boil.Begin()) defer tx.Rollback() var a FeatureGenotype var b Feature seed := randomize.NewSeed() if err = randomize.Struct(seed, &a, featureGenotypeDBTypes, false, strmangle.SetComplement(featureGenotypePrimaryKeyColumns, featureGenotypeColumnsWithoutDefault)...); err != nil { t.Fatal(err) } if err = randomize.Struct(seed, &b, featureDBTypes, false, strmangle.SetComplement(featurePrimaryKeyColumns, featureColumnsWithoutDefault)...); err != nil { t.Fatal(err) } if err = a.Insert(tx); err != nil { t.Fatal(err) } if err = a.SetChromosome(tx, true, &b); err != nil { t.Fatal(err) } if err = a.RemoveChromosome(tx, &b); err != nil { t.Error("failed to remove relationship") } count, err := a.Chromosome(tx).Count() if err != nil { t.Error(err) } if count != 0 { t.Error("want no relationships remaining") } if a.R.Chromosome != nil { t.Error("R struct entry should be nil") } if a.ChromosomeID.Valid { t.Error("foreign key value should be nil") } if b.R.ChromosomeFeatureGenotype != nil { t.Error("failed to remove a from b's relationships") } }
func testPhenotypeComparisonToOneRemoveOpPhenotypeUsingPhenotype2(t *testing.T) { var err error tx := MustTx(boil.Begin()) defer tx.Rollback() var a PhenotypeComparison var b Phenotype seed := randomize.NewSeed() if err = randomize.Struct(seed, &a, phenotypeComparisonDBTypes, false, strmangle.SetComplement(phenotypeComparisonPrimaryKeyColumns, phenotypeComparisonColumnsWithoutDefault)...); err != nil { t.Fatal(err) } if err = randomize.Struct(seed, &b, phenotypeDBTypes, false, strmangle.SetComplement(phenotypePrimaryKeyColumns, phenotypeColumnsWithoutDefault)...); err != nil { t.Fatal(err) } if err = a.Insert(tx); err != nil { t.Fatal(err) } if err = a.SetPhenotype2(tx, true, &b); err != nil { t.Fatal(err) } if err = a.RemovePhenotype2(tx, &b); err != nil { t.Error("failed to remove relationship") } count, err := a.Phenotype2(tx).Count() if err != nil { t.Error(err) } if count != 0 { t.Error("want no relationships remaining") } if a.R.Phenotype2 != nil { t.Error("R struct entry should be nil") } if a.Phenotype2ID.Valid { t.Error("foreign key value should be nil") } if len(b.R.Phenotype2PhenotypeComparisons) != 0 { t.Error("failed to remove a from b's relationships") } }
func testStockRelationshipCvtermToOneRemoveOpPubUsingPub(t *testing.T) { var err error tx := MustTx(boil.Begin()) defer tx.Rollback() var a StockRelationshipCvterm var b Pub seed := randomize.NewSeed() if err = randomize.Struct(seed, &a, stockRelationshipCvtermDBTypes, false, strmangle.SetComplement(stockRelationshipCvtermPrimaryKeyColumns, stockRelationshipCvtermColumnsWithoutDefault)...); err != nil { t.Fatal(err) } if err = randomize.Struct(seed, &b, pubDBTypes, false, strmangle.SetComplement(pubPrimaryKeyColumns, pubColumnsWithoutDefault)...); err != nil { t.Fatal(err) } if err = a.Insert(tx); err != nil { t.Fatal(err) } if err = a.SetPub(tx, true, &b); err != nil { t.Fatal(err) } if err = a.RemovePub(tx, &b); err != nil { t.Error("failed to remove relationship") } count, err := a.Pub(tx).Count() if err != nil { t.Error(err) } if count != 0 { t.Error("want no relationships remaining") } if a.R.Pub != nil { t.Error("R struct entry should be nil") } if a.PubID.Valid { t.Error("foreign key value should be nil") } if len(b.R.StockRelationshipCvterms) != 0 { t.Error("failed to remove a from b's relationships") } }
func testOrganismOneToOneRemoveOpStockUsingStock(t *testing.T) { var err error tx := MustTx(boil.Begin()) defer tx.Rollback() var a Organism var b Stock seed := randomize.NewSeed() if err = randomize.Struct(seed, &a, organismDBTypes, false, strmangle.SetComplement(organismPrimaryKeyColumns, organismColumnsWithoutDefault)...); err != nil { t.Fatal(err) } if err = randomize.Struct(seed, &b, stockDBTypes, false, strmangle.SetComplement(stockPrimaryKeyColumns, stockColumnsWithoutDefault)...); err != nil { t.Fatal(err) } if err = a.Insert(tx); err != nil { t.Fatal(err) } if err = a.SetStock(tx, true, &b); err != nil { t.Fatal(err) } if err = a.RemoveStock(tx, &b); err != nil { t.Error("failed to remove relationship") } count, err := a.Stock(tx).Count() if err != nil { t.Error(err) } if count != 0 { t.Error("want no relationships remaining") } if a.R.Stock != nil { t.Error("R struct entry should be nil") } if b.OrganismID.Valid { t.Error("foreign key column should be nil") } if b.R.Organism != nil { t.Error("failed to remove a from b's relationships") } }
func testStockcollectionToOneRemoveOpContactUsingContact(t *testing.T) { var err error tx := MustTx(boil.Begin()) defer tx.Rollback() var a Stockcollection var b Contact seed := randomize.NewSeed() if err = randomize.Struct(seed, &a, stockcollectionDBTypes, false, strmangle.SetComplement(stockcollectionPrimaryKeyColumns, stockcollectionColumnsWithoutDefault)...); err != nil { t.Fatal(err) } if err = randomize.Struct(seed, &b, contactDBTypes, false, strmangle.SetComplement(contactPrimaryKeyColumns, contactColumnsWithoutDefault)...); err != nil { t.Fatal(err) } if err = a.Insert(tx); err != nil { t.Fatal(err) } if err = a.SetContact(tx, true, &b); err != nil { t.Fatal(err) } if err = a.RemoveContact(tx, &b); err != nil { t.Error("failed to remove relationship") } count, err := a.Contact(tx).Count() if err != nil { t.Error(err) } if count != 0 { t.Error("want no relationships remaining") } if a.R.Contact != nil { t.Error("R struct entry should be nil") } if a.ContactID.Valid { t.Error("foreign key value should be nil") } if len(b.R.Stockcollections) != 0 { t.Error("failed to remove a from b's relationships") } }
func testDownloadToOneRemoveOpFileUsingFile(t *testing.T) { var err error tx := MustTx(boil.Begin()) defer tx.Rollback() var a Download var b File seed := randomize.NewSeed() if err = randomize.Struct(seed, &a, downloadDBTypes, false, strmangle.SetComplement(downloadPrimaryKeyColumns, downloadColumnsWithoutDefault)...); err != nil { t.Fatal(err) } if err = randomize.Struct(seed, &b, fileDBTypes, false, strmangle.SetComplement(filePrimaryKeyColumns, fileColumnsWithoutDefault)...); err != nil { t.Fatal(err) } if err = a.Insert(tx); err != nil { t.Fatal(err) } if err = a.SetFile(tx, true, &b); err != nil { t.Fatal(err) } if err = a.RemoveFile(tx, &b); err != nil { t.Error("failed to remove relationship") } count, err := a.File(tx).Count() if err != nil { t.Error(err) } if count != 0 { t.Error("want no relationships remaining") } if a.R.File != nil { t.Error("R struct entry should be nil") } if a.FileID.Valid { t.Error("foreign key value should be nil") } if len(b.R.Downloads) != 0 { t.Error("failed to remove a from b's relationships") } }
func testPubauthorsSliceUpdateAll(t *testing.T) { t.Parallel() if len(pubauthorColumns) == len(pubauthorPrimaryKeyColumns) { t.Skip("Skipping table with only primary key columns") } seed := randomize.NewSeed() var err error pubauthor := &Pubauthor{} if err = randomize.Struct(seed, pubauthor, pubauthorDBTypes, true); err != nil { t.Errorf("Unable to randomize Pubauthor struct: %s", err) } tx := MustTx(boil.Begin()) defer tx.Rollback() if err = pubauthor.Insert(tx); err != nil { t.Error(err) } count, err := Pubauthors(tx).Count() if err != nil { t.Error(err) } if count != 1 { t.Error("want one record, got:", count) } if err = randomize.Struct(seed, pubauthor, pubauthorDBTypes, true, pubauthorPrimaryKeyColumns...); err != nil { t.Errorf("Unable to randomize Pubauthor struct: %s", err) } // Remove Primary keys and unique columns from what we plan to update var fields []string if strmangle.StringSliceMatch(pubauthorColumns, pubauthorPrimaryKeyColumns) { fields = pubauthorColumns } else { fields = strmangle.SetComplement( pubauthorColumns, pubauthorPrimaryKeyColumns, ) } value := reflect.Indirect(reflect.ValueOf(pubauthor)) updateMap := M{} for _, col := range fields { updateMap[col] = value.FieldByName(strmangle.TitleCase(col)).Interface() } slice := PubauthorSlice{pubauthor} if err = slice.UpdateAll(tx, updateMap); err != nil { t.Error(err) } }
func testContactToManySetOpStockcollections(t *testing.T) { var err error tx := MustTx(boil.Begin()) defer tx.Rollback() var a Contact var b, c, d, e Stockcollection seed := randomize.NewSeed() if err = randomize.Struct(seed, &a, contactDBTypes, false, strmangle.SetComplement(contactPrimaryKeyColumns, contactColumnsWithoutDefault)...); err != nil { t.Fatal(err) } foreigners := []*Stockcollection{&b, &c, &d, &e} for _, x := range foreigners { if err = randomize.Struct(seed, x, stockcollectionDBTypes, false, strmangle.SetComplement(stockcollectionPrimaryKeyColumns, stockcollectionColumnsWithoutDefault)...); err != nil { t.Fatal(err) } } if err = a.Insert(tx); err != nil { t.Fatal(err) } if err = b.Insert(tx); err != nil { t.Fatal(err) } if err = c.Insert(tx); err != nil { t.Fatal(err) } err = a.SetStockcollections(tx, false, &b, &c) if err != nil { t.Fatal(err) } count, err := a.Stockcollections(tx).Count() if err != nil { t.Fatal(err) } if count != 2 { t.Error("count was wrong:", count) } err = a.SetStockcollections(tx, true, &d, &e) if err != nil { t.Fatal(err) } count, err = a.Stockcollections(tx).Count() if err != nil { t.Fatal(err) } if count != 2 { t.Error("count was wrong:", count) } if b.ContactID.Valid { t.Error("want b's foreign key value to be nil") } if c.ContactID.Valid { t.Error("want c's foreign key value to be nil") } if a.ContactID != d.ContactID.Int { t.Error("foreign key was wrong value", a.ContactID, d.ContactID.Int) } if a.ContactID != e.ContactID.Int { t.Error("foreign key was wrong value", a.ContactID, e.ContactID.Int) } if b.R.Contact != nil { t.Error("relationship was not removed properly from the foreign struct") } if c.R.Contact != nil { t.Error("relationship was not removed properly from the foreign struct") } if d.R.Contact != &a { t.Error("relationship was not added properly to the foreign struct") } if e.R.Contact != &a { t.Error("relationship was not added properly to the foreign struct") } if a.R.Stockcollections[0] != &d { t.Error("relationship struct slice not set to correct value") } if a.R.Stockcollections[1] != &e { t.Error("relationship struct slice not set to correct value") } }
func testFileToManySetOpDownloads(t *testing.T) { var err error tx := MustTx(boil.Begin()) defer tx.Rollback() var a File var b, c, d, e Download seed := randomize.NewSeed() if err = randomize.Struct(seed, &a, fileDBTypes, false, strmangle.SetComplement(filePrimaryKeyColumns, fileColumnsWithoutDefault)...); err != nil { t.Fatal(err) } foreigners := []*Download{&b, &c, &d, &e} for _, x := range foreigners { if err = randomize.Struct(seed, x, downloadDBTypes, false, strmangle.SetComplement(downloadPrimaryKeyColumns, downloadColumnsWithoutDefault)...); err != nil { t.Fatal(err) } } if err = a.Insert(tx); err != nil { t.Fatal(err) } if err = b.Insert(tx); err != nil { t.Fatal(err) } if err = c.Insert(tx); err != nil { t.Fatal(err) } err = a.SetDownloads(tx, false, &b, &c) if err != nil { t.Fatal(err) } count, err := a.Downloads(tx).Count() if err != nil { t.Fatal(err) } if count != 2 { t.Error("count was wrong:", count) } err = a.SetDownloads(tx, true, &d, &e) if err != nil { t.Fatal(err) } count, err = a.Downloads(tx).Count() if err != nil { t.Fatal(err) } if count != 2 { t.Error("count was wrong:", count) } if b.FileID.Valid { t.Error("want b's foreign key value to be nil") } if c.FileID.Valid { t.Error("want c's foreign key value to be nil") } if a.ID != d.FileID.String { t.Error("foreign key was wrong value", a.ID, d.FileID.String) } if a.ID != e.FileID.String { t.Error("foreign key was wrong value", a.ID, e.FileID.String) } if b.R.File != nil { t.Error("relationship was not removed properly from the foreign struct") } if c.R.File != nil { t.Error("relationship was not removed properly from the foreign struct") } if d.R.File != &a { t.Error("relationship was not added properly to the foreign struct") } if e.R.File != &a { t.Error("relationship was not added properly to the foreign struct") } if a.R.Downloads[0] != &d { t.Error("relationship struct slice not set to correct value") } if a.R.Downloads[1] != &e { t.Error("relationship struct slice not set to correct value") } }
func testContactToManyRemoveOpStockcollections(t *testing.T) { var err error tx := MustTx(boil.Begin()) defer tx.Rollback() var a Contact var b, c, d, e Stockcollection seed := randomize.NewSeed() if err = randomize.Struct(seed, &a, contactDBTypes, false, strmangle.SetComplement(contactPrimaryKeyColumns, contactColumnsWithoutDefault)...); err != nil { t.Fatal(err) } foreigners := []*Stockcollection{&b, &c, &d, &e} for _, x := range foreigners { if err = randomize.Struct(seed, x, stockcollectionDBTypes, false, strmangle.SetComplement(stockcollectionPrimaryKeyColumns, stockcollectionColumnsWithoutDefault)...); err != nil { t.Fatal(err) } } if err := a.Insert(tx); err != nil { t.Fatal(err) } err = a.AddStockcollections(tx, true, foreigners...) if err != nil { t.Fatal(err) } count, err := a.Stockcollections(tx).Count() if err != nil { t.Fatal(err) } if count != 4 { t.Error("count was wrong:", count) } err = a.RemoveStockcollections(tx, foreigners[:2]...) if err != nil { t.Fatal(err) } count, err = a.Stockcollections(tx).Count() if err != nil { t.Fatal(err) } if count != 2 { t.Error("count was wrong:", count) } if b.ContactID.Valid { t.Error("want b's foreign key value to be nil") } if c.ContactID.Valid { t.Error("want c's foreign key value to be nil") } if b.R.Contact != nil { t.Error("relationship was not removed properly from the foreign struct") } if c.R.Contact != nil { t.Error("relationship was not removed properly from the foreign struct") } if d.R.Contact != &a { t.Error("relationship to a should have been preserved") } if e.R.Contact != &a { t.Error("relationship to a should have been preserved") } if len(a.R.Stockcollections) != 2 { t.Error("should have preserved two relationships") } // Removal doesn't do a stable deletion for performance so we have to flip the order if a.R.Stockcollections[1] != &d { t.Error("relationship to d should have been preserved") } if a.R.Stockcollections[0] != &e { t.Error("relationship to e should have been preserved") } }
func testAuthProviderToManyAddOpAuthUserProviders(t *testing.T) { var err error tx := MustTx(boil.Begin()) defer tx.Rollback() var a AuthProvider var b, c, d, e AuthUserProvider seed := randomize.NewSeed() if err = randomize.Struct(seed, &a, authProviderDBTypes, false, strmangle.SetComplement(authProviderPrimaryKeyColumns, authProviderColumnsWithoutDefault)...); err != nil { t.Fatal(err) } foreigners := []*AuthUserProvider{&b, &c, &d, &e} for _, x := range foreigners { if err = randomize.Struct(seed, x, authUserProviderDBTypes, false, strmangle.SetComplement(authUserProviderPrimaryKeyColumns, authUserProviderColumnsWithoutDefault)...); err != nil { t.Fatal(err) } } if err := a.Insert(tx); err != nil { t.Fatal(err) } if err = b.Insert(tx); err != nil { t.Fatal(err) } if err = c.Insert(tx); err != nil { t.Fatal(err) } foreignersSplitByInsertion := [][]*AuthUserProvider{ {&b, &c}, {&d, &e}, } for i, x := range foreignersSplitByInsertion { err = a.AddAuthUserProviders(tx, i != 0, x...) if err != nil { t.Fatal(err) } first := x[0] second := x[1] if a.AuthProviderID != first.AuthProviderID { t.Error("foreign key was wrong value", a.AuthProviderID, first.AuthProviderID) } if a.AuthProviderID != second.AuthProviderID { t.Error("foreign key was wrong value", a.AuthProviderID, second.AuthProviderID) } if first.R.AuthProvider != &a { t.Error("relationship was not added properly to the foreign slice") } if second.R.AuthProvider != &a { t.Error("relationship was not added properly to the foreign slice") } if a.R.AuthUserProviders[i*2] != first { t.Error("relationship struct slice not set to correct value") } if a.R.AuthUserProviders[i*2+1] != second { t.Error("relationship struct slice not set to correct value") } count, err := a.AuthUserProviders(tx).Count() if err != nil { t.Fatal(err) } if want := int64((i + 1) * 2); count != want { t.Error("want", want, "got", count) } } }