From 6864d5e5bdbec9fe0fb2e56997fd0180695e3bb8 Mon Sep 17 00:00:00 2001 From: Jinzhu Date: Fri, 13 Feb 2015 11:26:02 +0800 Subject: [PATCH] Add polymorphic_test.go --- association.go | 16 +++++------ association_test.go | 66 --------------------------------------------- main.go | 2 +- polymorphic_test.go | 56 ++++++++++++++++++++++++++++++++++++++ 4 files changed, 65 insertions(+), 75 deletions(-) create mode 100644 polymorphic_test.go diff --git a/association.go b/association.go index 4103854a..32570cf9 100644 --- a/association.go +++ b/association.go @@ -15,7 +15,7 @@ type Association struct { Field *Field } -func (association *Association) err(err error) *Association { +func (association *Association) setErr(err error) *Association { if err != nil { association.Error = err } @@ -24,7 +24,7 @@ func (association *Association) err(err error) *Association { func (association *Association) Find(value interface{}) *Association { association.Scope.related(value, association.Column) - return association.err(association.Scope.db.Error) + return association.setErr(association.Scope.db.Error) } func (association *Association) Append(values ...interface{}) *Association { @@ -53,11 +53,11 @@ func (association *Association) Append(values ...interface{}) *Association { } else if reflectvalue.Kind() == reflect.Slice && fieldType.Elem() == reflectvalue.Type().Elem() { field.Set(reflect.AppendSlice(field.Field, reflectvalue)) } else { - association.err(errors.New("invalid association type")) + association.setErr(errors.New("invalid association type")) } } scope.callCallbacks(scope.db.parent.callback.updates) - return association.err(scope.db.Error) + return association.setErr(scope.db.Error) } func (association *Association) getPrimaryKeys(values ...interface{}) []interface{} { @@ -92,7 +92,7 @@ func (association *Association) Delete(values ...interface{}) *Association { primaryKeys := association.getPrimaryKeys(values...) if len(primaryKeys) == 0 { - association.err(errors.New("no primary key found")) + association.setErr(errors.New("no primary key found")) } else { relationship := association.Field.Relationship // many to many @@ -104,7 +104,7 @@ func (association *Association) Delete(values ...interface{}) *Association { association.Scope.db.Model("").Table(relationship.JoinTable). Where(whereSql, association.PrimaryKey, primaryKeys).Delete("") } else { - association.err(errors.New("delete only support many to many")) + association.setErr(errors.New("delete only support many to many")) } } return association @@ -143,7 +143,7 @@ func (association *Association) Replace(values ...interface{}) *Association { scope.db.Model("").Table(relationship.JoinTable).Where(whereSql, association.PrimaryKey, addedPrimaryKeys).Delete("") } else { - association.err(errors.New("replace only support many to many")) + association.setErr(errors.New("replace only support many to many")) } return association } @@ -155,7 +155,7 @@ func (association *Association) Clear() *Association { whereSql := fmt.Sprintf("%v.%v = ?", relationship.JoinTable, scope.Quote(ToSnake(relationship.ForeignKey))) scope.db.Model("").Table(relationship.JoinTable).Where(whereSql, association.PrimaryKey).Delete("") } else { - association.err(errors.New("clear only support many to many")) + association.setErr(errors.New("clear only support many to many")) } return association } diff --git a/association_test.go b/association_test.go index f2873da8..51a61f09 100644 --- a/association_test.go +++ b/association_test.go @@ -2,30 +2,6 @@ package gorm_test import "testing" -import "github.com/jinzhu/gorm" - -type Cat struct { - Id int - Name string - Toy Toy `gorm:"polymorphic:Owner;"` -} - -type Dog struct { - Id int - Name string - Toys []Toy `gorm:"polymorphic:Owner;"` -} - -type Toy struct { - Id int - Name string - OwnerId int - OwnerType string - - // Define the owner type as a belongs_to so we can ensure it throws an error - Owner Dog `gorm:"foreignkey:owner_id; foreigntype:owner_type;"` -} - func TestHasOneAndHasManyAssociation(t *testing.T) { DB.DropTable(Category{}) DB.DropTable(Post{}) @@ -240,45 +216,3 @@ func TestManyToMany(t *testing.T) { t.Errorf("Relations should be cleared") } } - -func TestPolymorphic(t *testing.T) { - DB.DropTableIfExists(Cat{}) - DB.DropTableIfExists(Dog{}) - DB.DropTableIfExists(Toy{}) - - DB.AutoMigrate(&Cat{}) - DB.AutoMigrate(&Dog{}) - DB.AutoMigrate(&Toy{}) - - cat := Cat{Name: "Mr. Bigglesworth", Toy: Toy{Name: "cat nip"}} - dog := Dog{Name: "Pluto", Toys: []Toy{Toy{Name: "orange ball"}, Toy{Name: "yellow ball"}}} - DB.Save(&cat).Save(&dog) - - var catToys []Toy - if err := DB.Model(&cat).Related(&catToys, "Toy").Error; err == gorm.RecordNotFound { - t.Errorf("Did not find any has one polymorphic association") - } else if len(catToys) != 1 { - t.Errorf("Should have found only one polymorphic has one association") - } else if catToys[0].Name != cat.Toy.Name { - t.Errorf("Should have found the proper has one polymorphic association") - } - - var dogToys []Toy - if err := DB.Model(&dog).Related(&dogToys, "Toys").Error; err == gorm.RecordNotFound { - t.Errorf("Did not find any polymorphic has many associations") - } else if len(dogToys) != len(dog.Toys) { - t.Errorf("Should have found all polymorphic has many associations") - } - - if DB.Model(&cat).Association("Toy").Count() != 1 { - t.Errorf("Should return one polymorphic has one association") - } - - if DB.Model(&dog).Association("Toys").Count() != 2 { - t.Errorf("Should return two polymorphic has many associations") - } - - if DB.Model(&Toy{OwnerId: dog.Id, OwnerType: "dog"}).Related(&dog, "Owner").Error == nil { - t.Errorf("Should have thrown unsupported belongs_to error") - } -} diff --git a/main.go b/main.go index 57c7d2a0..377e0a25 100644 --- a/main.go +++ b/main.go @@ -429,7 +429,7 @@ func (s *DB) Association(column string) *Association { var field *Field var ok bool - if field, ok = scope.FieldByName(SnakeToUpperCamel(column)); ok { + if field, ok = scope.FieldByName(column); ok { if field.Relationship == nil || field.Relationship.ForeignKey == "" { scope.Err(fmt.Errorf("invalid association %v for %v", column, scope.IndirectValue().Type())) } diff --git a/polymorphic_test.go b/polymorphic_test.go new file mode 100644 index 00000000..78b99feb --- /dev/null +++ b/polymorphic_test.go @@ -0,0 +1,56 @@ +package gorm_test + +import "testing" + +type Cat struct { + Id int + Name string + Toy Toy `gorm:"polymorphic:Owner;"` +} + +type Dog struct { + Id int + Name string + Toys []Toy `gorm:"polymorphic:Owner;"` +} + +type Toy struct { + Id int + Name string + OwnerId int + OwnerType string +} + +func TestPolymorphic(t *testing.T) { + DB.AutoMigrate(&Cat{}) + DB.AutoMigrate(&Dog{}) + DB.AutoMigrate(&Toy{}) + + cat := Cat{Name: "Mr. Bigglesworth", Toy: Toy{Name: "cat nip"}} + dog := Dog{Name: "Pluto", Toys: []Toy{Toy{Name: "orange ball"}, Toy{Name: "yellow ball"}}} + DB.Save(&cat).Save(&dog) + + var catToys []Toy + if DB.Model(&cat).Related(&catToys, "Toy").RecordNotFound() { + t.Errorf("Did not find any has one polymorphic association") + } else if len(catToys) != 1 { + t.Errorf("Should have found only one polymorphic has one association") + } else if catToys[0].Name != cat.Toy.Name { + t.Errorf("Should have found the proper has one polymorphic association") + } + + var dogToys []Toy + if DB.Model(&dog).Related(&dogToys, "Toys").RecordNotFound() { + t.Errorf("Did not find any polymorphic has many associations") + } else if len(dogToys) != len(dog.Toys) { + t.Errorf("Should have found all polymorphic has many associations") + } + + if DB.Model(&cat).Association("Toy").Count() != 1 { + t.Errorf("Should return one polymorphic has one association") + } + + if DB.Model(&dog).Association("Toys").Count() != 2 { + t.Errorf("Should return two polymorphic has many associations") + } +}