Add tests for joins

tests/joins_table_test.go

@@ -152,3 +152,57 @@ func TestOverrideJoinTable(t *testing.T) {
 		t.Errorf("person's addresses expects 2, got %v", count)
 	}
 }
+
+func TestOverrideJoinTableInvalidAssociation(t *testing.T) {
+	if err := DB.SetupJoinTable(&Person{}, "Addresses", &PersonAddress{}); err != nil {
+		t.Fatalf("Failed to setup join table for person, got error %v", err)
+	}
+	if err := DB.AutoMigrate(&Person{}, &Address{}); err != nil {
+		t.Fatalf("Failed to migrate, got %v", err)
+	}
+
+	person := Person{Name: "invalid-assoc"}
+	DB.Create(&person)
+
+	err := DB.Model(&person).Association("NonExistent").Find(&[]Address{})
+	if err == nil {
+		t.Fatalf("Expected error when accessing non-existent association, got nil")
+	}
+}
+
+func TestOverrideJoinTableClearWithoutAssociations(t *testing.T) {
+	if err := DB.SetupJoinTable(&Person{}, "Addresses", &PersonAddress{}); err != nil {
+		t.Fatalf("Failed to setup join table for person, got error %v", err)
+	}
+	if err := DB.AutoMigrate(&Person{}, &Address{}); err != nil {
+		t.Fatalf("Failed to migrate, got %v", err)
+	}
+
+	person := Person{Name: "no-assoc"}
+	DB.Create(&person)
+
+	if err := DB.Model(&person).Association("Addresses").Clear(); err != nil {
+		t.Fatalf("Expected no error clearing empty associations, got %v", err)
+	}
+
+	if count := DB.Model(&person).Association("Addresses").Count(); count != 0 {
+		t.Fatalf("Expected 0 associations, got %v", count)
+	}
+}
+
+func TestOverrideJoinTableDeleteNonExistentAssociation(t *testing.T) {
+	if err := DB.SetupJoinTable(&Person{}, "Addresses", &PersonAddress{}); err != nil {
+		t.Fatalf("Failed to setup join table for person, got error %v", err)
+	}
+	if err := DB.AutoMigrate(&Person{}, &Address{}); err != nil {
+		t.Fatalf("Failed to migrate, got %v", err)
+	}
+
+	address := Address{Name: "non-existent"}
+	person := Person{Name: "test-delete"}
+	DB.Create(&person)
+
+	if err := DB.Model(&person).Association("Addresses").Delete(&address); err != nil {
+		t.Fatalf("Expected no error when deleting non-existent association, got %v", err)
+	}
+}

tests/joins_test.go

@@ -516,3 +516,90 @@ func TestJoinsPreload_Issue7013_NoEntries(t *testing.T) {
 
 	tests.AssertEqual(t, len(entries), 0)
 }
+
+type JoinCompany struct {
+    ID   int64  `gorm:"column:id;primaryKey"`
+    Name string `gorm:"column:name"`
+}
+
+type JoinUser struct {
+    ID        int64       `gorm:"column:id;primaryKey"`
+    Name      string      `gorm:"column:name"`
+    CompanyID int64       `gorm:"column:company_id"`
+    Company   JoinCompany `gorm:"foreignKey:CompanyID"`
+}
+
+func TestJoinWithOrderLimit(t *testing.T) {
+    _ = DB.Migrator().DropTable(&JoinUser{}, &JoinCompany{})
+    if err := DB.Migrator().CreateTable(&JoinCompany{}, &JoinUser{}); err != nil {
+        t.Fatalf("failed to create tables: %v", err)
+    }
+
+    company := JoinCompany{Name: "TestCompany"}
+    if err := DB.Create(&company).Error; err != nil {
+        t.Fatalf("failed to insert company: %v", err)
+    }
+
+    users := []JoinUser{
+        {Name: "order-limit-1", CompanyID: company.ID},
+        {Name: "order-limit-2", CompanyID: company.ID},
+    }
+    if err := DB.Create(&users).Error; err != nil {
+        t.Fatalf("failed to insert users: %v", err)
+    }
+
+    var result []JoinUser
+    err := DB.
+        Joins("Company").
+        Order("\"join_users\".\"id\" DESC").
+        Limit(1).
+        Find(&result).Error
+
+    if err != nil {
+        t.Fatalf("unexpected error: %v", err)
+    }
+    if len(result) != 1 {
+        t.Errorf("expected 1 result with limit, got %d", len(result))
+    }
+}
+
+func TestJoinOnNilDB(t *testing.T) {
+    var users []JoinUser
+    var nilDB *gorm.DB
+
+    defer func() {
+        if r := recover(); r == nil {
+            t.Errorf("expected panic when calling Joins on nil DB, got none")
+        }
+    }()
+
+    nilDB.Joins("Company").Find(&users)
+}
+
+func TestJoinNonExistentRelation(t *testing.T) {
+	var user JoinUser
+	err := DB.Joins("NonExistentRelation").First(&user).Error
+	if err == nil {
+		t.Errorf("expected error when joining on non-existent relation, got nil")
+	}
+}
+
+func TestJoinAmbiguousColumnError(t *testing.T) {
+	var result []JoinUser
+	err := DB.Table("join_users").
+		Select("id"). // ambiguous since multiple tables have id
+		Joins("join companies on companies.id = join_users.company_id").
+		Scan(&result).Error
+
+	if err == nil {
+		t.Errorf("expected error for ambiguous column selection, got nil")
+	}
+}
+
+func TestJoinInvalidSQL(t *testing.T) {
+	var users []JoinUser
+	err := DB.Joins("LEFT JOIN invalid_table ON").Find(&users).Error
+	if err == nil {
+		t.Errorf("expected SQL error for invalid join, got nil")
+	}
+}