Merge remote-tracking branch 'origin' into addScopesTest

Author: saumil-oracle

tests/distinct_test.go

@@ -138,15 +138,14 @@ func TestDistinctWithVaryingCase(t *testing.T) {
 }
 
 func TestDistinctComputedColumn(t *testing.T) {
-	t.Skip()
 	type UserWithComputationColumn struct {
 		ID   int64 `gorm:"primary_key"`
 		Name string
 		Col  int64
 	}
 
 	if err := DB.Migrator().DropTable(&UserWithComputationColumn{}); err != nil {
-		t.Fatalf("failed to drop table: %v", err)
+		t.Logf("failed to drop table: %v", err)
 	}
 	if err := DB.AutoMigrate(&UserWithComputationColumn{}); err != nil {
 		t.Fatalf("failed to migrate table: %v", err)
@@ -163,8 +162,8 @@ func TestDistinctComputedColumn(t *testing.T) {
 
 	var computedRecords []int
 	if err := DB.
-		Table("USER_WITH_COMPUTATION_COLUMNS").
-		Select("DISTINCT col * 12 as Computed_Column").
+		Table("user_with_computation_columns").
+		Select("DISTINCT \"col\" * 12 as Computed_Column").
 		Order("Computed_Column").
 		Pluck("Computed_Column", &computedRecords).Error; err != nil {
 		t.Fatalf("failed to query distinct Computed Columns: %v", err)
@@ -174,7 +173,6 @@ func TestDistinctComputedColumn(t *testing.T) {
 }
 
 func TestDistinctWithAggregation(t *testing.T) {
-	t.Skip()
 	type UserWithComputationColumn struct {
 		ID   int64 `gorm:"primaryKey"`
 		Name string
@@ -197,21 +195,21 @@ func TestDistinctWithAggregation(t *testing.T) {
 	}
 
 	if err := DB.Create(&records).Error; err != nil {
-		t.Fatalf("failed to insert test users: %v", err)
+		t.Logf("failed to insert test users: %v", err)
 	}
 
 	var result struct {
-		Sum   int64
+		Sum   float64
 		Avg   float64
-		Count int64
+		Count int
 	}
 
 	err := DB.
-		Table("USER_WITH_COMPUTATION_COLUMNS").
+		Table("user_with_computation_columns").
 		Select(`
-			SUM(DISTINCT col) AS Sum,
-			AVG(DISTINCT col) AS Avg,
-			COUNT(DISTINCT col) AS Count
+			SUM(DISTINCT "col") AS "sum",
+			AVG(DISTINCT "col") AS "avg" ,
+			COUNT(DISTINCT "col") AS "count"
 		`).Scan(&result).Error
 
 	if err != nil {

tests/query_test.go

@@ -51,6 +51,7 @@ import (
 
 	"time"
 
+	"github.com/godror/godror"
 	. "github.com/oracle-samples/gorm-oracle/tests/utils"
 
 	"gorm.io/gorm"
@@ -59,7 +60,6 @@ import (
 )
 
 func TestFind(t *testing.T) {
-	t.Skip()
 	users := []User{
 		*GetUser("find", Config{}),
 		*GetUser("find", Config{}),
@@ -114,8 +114,10 @@ func TestFind(t *testing.T) {
 							t.Errorf("invalid data type for %v, got %#v", dbName, first[dbName])
 						}
 					case "Age":
-						if _, ok := first[dbName].(uint); !ok {
-							t.Errorf("invalid data type for %v, got %#v", dbName, first[dbName])
+						val := fmt.Sprintf("%v", first[dbName])
+						expected := fmt.Sprint(users[0].Age)
+						if val != expected {
+							t.Errorf("expected %v, got %v", expected, val)
 						}
 					case "Birthday":
 						if _, ok := first[dbName].(*time.Time); !ok {
@@ -146,8 +148,10 @@ func TestFind(t *testing.T) {
 							t.Errorf("invalid data type for %v, got %v %#v", dbName, resultType, first[dbName])
 						}
 					case "Age":
-						if !strings.Contains(resultType, "int") {
-							t.Errorf("invalid data type for %v, got %v %#v", dbName, resultType, first[dbName])
+						val := fmt.Sprintf("%v", first[dbName])
+						expected := fmt.Sprint(users[0].Age)
+						if val != expected {
+							t.Errorf("expected %v, got %v", expected, val)
 						}
 					case "Birthday":
 						if !strings.Contains(resultType, "Time") {
@@ -194,8 +198,10 @@ func TestFind(t *testing.T) {
 									t.Errorf("invalid data type for %v, got %#v", dbName, allMap[idx][dbName])
 								}
 							case "Age":
-								if _, ok := allMap[idx][dbName].(uint); !ok {
-									t.Errorf("invalid data type for %v, got %#v", dbName, allMap[idx][dbName])
+								val := fmt.Sprintf("%v", allMap[idx][dbName])
+								expected := fmt.Sprint(users[0].Age)
+								if val != expected {
+									t.Errorf("expected %v, got %v", expected, val)
 								}
 							case "Birthday":
 								if _, ok := allMap[idx][dbName].(*time.Time); !ok {
@@ -230,8 +236,10 @@ func TestFind(t *testing.T) {
 									t.Errorf("invalid data type for %v, got %v %#v", dbName, resultType, allMap[idx][dbName])
 								}
 							case "Age":
-								if !strings.Contains(resultType, "int") {
-									t.Errorf("invalid data type for %v, got %v %#v", dbName, resultType, allMap[idx][dbName])
+								val := fmt.Sprintf("%v", allMap[idx][dbName])
+								expected := fmt.Sprint(users[0].Age)
+								if val != expected {
+									t.Errorf("expected %v, got %v", expected, val)
 								}
 							case "Birthday":
 								if !strings.Contains(resultType, "Time") {
@@ -714,13 +722,23 @@ func (v Int64) Value() (driver.Value, error) {
 }
 
 func (v *Int64) Scan(val interface{}) error {
-	y := val.(int64)
-	*v = Int64(y + 1)
+	switch x := val.(type) {
+	case int64:
+		*v = Int64(x + 1)
 	return nil
+	case godror.Number:
+		i, err := strconv.ParseInt(string(x), 10, 64)
+		if err != nil {
+			return fmt.Errorf("Int64.Scan: cannot parse godror.Number %q: %w", string(x), err)
+		}
+		*v = Int64(i + 1)
+		return nil
+	default:
+		return fmt.Errorf("Int64.Scan: unsupported type %T", val)
+	}
 }
 
 func TestPluck(t *testing.T) {
-	t.Skip()
 	users := []*User{
 		GetUser("pluck-user1", Config{}),
 		GetUser("pluck-user2", Config{}),
@@ -730,25 +748,25 @@ func TestPluck(t *testing.T) {
 	DB.Create(&users)
 
 	var names []string
-	if err := DB.Model(User{}).Where("name like ?", "pluck-user%").Order("name").Pluck("name", &names).Error; err != nil {
+	if err := DB.Model(User{}).Where("\"name\" like ?", "pluck-user%").Order("\"name\"").Pluck("name", &names).Error; err != nil {
 		t.Errorf("got error when pluck name: %v", err)
 	}
 
 	var names2 []string
-	if err := DB.Model(User{}).Where("name like ?", "pluck-user%").Order("name desc").Pluck("name", &names2).Error; err != nil {
+	if err := DB.Model(User{}).Where("\"name\" like ?", "pluck-user%").Order("\"name\" desc").Pluck("name", &names2).Error; err != nil {
 		t.Errorf("got error when pluck name: %v", err)
 	}
 
 	sort.Slice(names2, func(i, j int) bool { return names2[i] < names2[j] })
 	tests.AssertEqual(t, names, names2)
 
 	var ids []int
-	if err := DB.Model(User{}).Where("name like ?", "pluck-user%").Pluck("id", &ids).Error; err != nil {
+	if err := DB.Model(User{}).Where("\"name\" like ?", "pluck-user%").Pluck("id", &ids).Error; err != nil {
 		t.Errorf("got error when pluck id: %v", err)
 	}
 
 	var ids2 []Int64
-	if err := DB.Model(User{}).Where("name like ?", "pluck-user%").Pluck("id", &ids2).Error; err != nil {
+	if err := DB.Model(User{}).Where("\"name\" like ?", "pluck-user%").Pluck("id", &ids2).Error; err != nil {
 		t.Errorf("got error when pluck id: %v", err)
 	}
 
@@ -771,7 +789,7 @@ func TestPluck(t *testing.T) {
 	}
 
 	var times []time.Time
-	if err := DB.Model(User{}).Where("name like ?", "pluck-user%").Pluck("created_at", &times).Error; err != nil {
+	if err := DB.Model(User{}).Where("\"name\" like ?", "pluck-user%").Pluck("created_at", &times).Error; err != nil {
 		t.Errorf("got error when pluck time: %v", err)
 	}
 
@@ -780,7 +798,7 @@ func TestPluck(t *testing.T) {
 	}
 
 	var ptrtimes []*time.Time
-	if err := DB.Model(User{}).Where("name like ?", "pluck-user%").Pluck("created_at", &ptrtimes).Error; err != nil {
+	if err := DB.Model(User{}).Where("\"name\" like ?", "pluck-user%").Pluck("created_at", &ptrtimes).Error; err != nil {
 		t.Errorf("got error when pluck time: %v", err)
 	}
 
@@ -789,7 +807,7 @@ func TestPluck(t *testing.T) {
 	}
 
 	var nulltimes []sql.NullTime
-	if err := DB.Model(User{}).Where("name like ?", "pluck-user%").Pluck("created_at", &nulltimes).Error; err != nil {
+	if err := DB.Model(User{}).Where("\"name\" like ?", "pluck-user%").Pluck("created_at", &nulltimes).Error; err != nil {
 		t.Errorf("got error when pluck time: %v", err)
 	}
 
@@ -941,16 +959,15 @@ func TestPluckWithSelect(t *testing.T) {
 }
 
 func TestSelectWithVariables(t *testing.T) {
-	t.Skip()
 	DB.Save(&User{Name: "select_with_variables"})
 
-	rows, _ := DB.Table("users").Where("name = ?", "select_with_variables").Select("? as fake", gorm.Expr("name")).Rows()
+	rows, _ := DB.Table("users").Where("\"name\" = ?", "select_with_variables").Select("? as fake", gorm.Expr("\"name\"")).Rows()
 
 	if !rows.Next() {
 		t.Errorf("Should have returned at least one row")
 	} else {
 		columns, _ := rows.Columns()
-		tests.AssertEqual(t, columns, []string{"fake"})
+		tests.AssertEqual(t, columns, []string{"FAKE"})
 	}
 
 	rows.Close()