397 lines
13 KiB
Go
397 lines
13 KiB
Go
package dbwrapper
|
|
|
|
import (
|
|
"strings"
|
|
"testing"
|
|
|
|
"git.ksdemosapps.com/kylesoda/go-migrate/internal/app/config"
|
|
"git.ksdemosapps.com/kylesoda/go-migrate/internal/app/models"
|
|
)
|
|
|
|
func TestBuildExtractQueryMssql_NoJsonColumns(t *testing.T) {
|
|
q := ExtractionQuery{
|
|
Schema: "dbo",
|
|
Table: "Users",
|
|
PrimaryKey: "ID",
|
|
Columns: []models.ColumnType{
|
|
models.NewColumnType("ID", false, false, "INT", "int", "INT", false, 0, 0, 0),
|
|
models.NewColumnType("Name", true, false, "VARCHAR", "varchar", "VARCHAR", true, 255, 0, 0),
|
|
},
|
|
FromJsonColumns: []config.FromJsonItem{},
|
|
LowerLimit: ExtractorQueryLimit{IsValid: false},
|
|
UpperLimit: ExtractorQueryLimit{IsValid: false},
|
|
}
|
|
|
|
query, err := buildExtractQueryMssql(q)
|
|
if err != nil {
|
|
t.Fatalf("Expected no error, got: %v", err)
|
|
}
|
|
|
|
if !strings.Contains(query, "SELECT [ID], [Name]") {
|
|
t.Errorf("Expected columns in query, got: %s", query)
|
|
}
|
|
|
|
if !strings.Contains(query, "FROM [dbo].[Users]") {
|
|
t.Errorf("Expected FROM clause, got: %s", query)
|
|
}
|
|
|
|
if !strings.Contains(query, "ORDER BY [ID] ASC") {
|
|
t.Errorf("Expected ORDER BY clause, got: %s", query)
|
|
}
|
|
}
|
|
|
|
func TestBuildExtractQueryMssql_WithJsonColumns_ExactColumnMatch(t *testing.T) {
|
|
// Test that the actual column name is used as alias, not a generated one
|
|
q := ExtractionQuery{
|
|
Schema: "dbo",
|
|
Table: "Events",
|
|
PrimaryKey: "EventID",
|
|
Columns: []models.ColumnType{
|
|
models.NewColumnType("EventID", false, false, "INT", "int", "INT", false, 0, 0, 0),
|
|
models.NewColumnType("EventData", true, false, "VARCHAR", "varchar", "VARCHAR", true, 500, 0, 0),
|
|
},
|
|
FromJsonColumns: []config.FromJsonItem{
|
|
{Column: "EventData", Field: ".userId"},
|
|
{Column: "EventData", Field: ".timestamp"},
|
|
},
|
|
LowerLimit: ExtractorQueryLimit{IsValid: false},
|
|
UpperLimit: ExtractorQueryLimit{IsValid: false},
|
|
}
|
|
|
|
query, err := buildExtractQueryMssql(q)
|
|
if err != nil {
|
|
t.Fatalf("Expected no error, got: %v", err)
|
|
}
|
|
|
|
if !strings.HasPrefix(query, "SELECT [EventID], JSON_VALUE([EventData], '$.userId') AS [EventData], JSON_VALUE([EventData], '$.timestamp') AS [EventData]") {
|
|
t.Errorf("Expected JSON columns to replace EventData in-order, got: %s", query)
|
|
}
|
|
|
|
if strings.Contains(query, "SELECT [EventID], [EventData]") {
|
|
t.Errorf("Expected EventData to be replaced by JSON extraction, got: %s", query)
|
|
}
|
|
|
|
// Alias should be exactly "EventData", not "EventData_userId"
|
|
if !strings.Contains(query, "JSON_VALUE([EventData], '$.userId') AS [EventData]") {
|
|
t.Errorf("Expected JSON alias to be [EventData], got: %s", query)
|
|
}
|
|
|
|
if !strings.Contains(query, "JSON_VALUE([EventData], '$.timestamp') AS [EventData]") {
|
|
t.Errorf("Expected JSON alias to be [EventData], got: %s", query)
|
|
}
|
|
|
|
// Should have comma separating them
|
|
if !strings.Contains(query, "JSON_VALUE([EventData], '$.userId') AS [EventData], JSON_VALUE([EventData], '$.timestamp') AS [EventData]") {
|
|
t.Errorf("Expected comma-separated JSON values, got: %s", query)
|
|
}
|
|
}
|
|
|
|
func TestBuildExtractQueryMssql_WithWildcardPattern(t *testing.T) {
|
|
// Test that wildcard pattern matching finds the correct column
|
|
q := ExtractionQuery{
|
|
Schema: "dbo",
|
|
Table: "Events",
|
|
PrimaryKey: "ID",
|
|
Columns: []models.ColumnType{
|
|
models.NewColumnType("ID", false, false, "INT", "int", "INT", false, 0, 0, 0),
|
|
models.NewColumnType("NodeMetadata", true, false, "VARCHAR", "varchar", "VARCHAR", true, 500, 0, 0),
|
|
},
|
|
FromJsonColumns: []config.FromJsonItem{
|
|
{Column: "NodeMeta*", Field: ".id"},
|
|
},
|
|
LowerLimit: ExtractorQueryLimit{IsValid: false},
|
|
UpperLimit: ExtractorQueryLimit{IsValid: false},
|
|
}
|
|
|
|
query, err := buildExtractQueryMssql(q)
|
|
if err != nil {
|
|
t.Fatalf("Expected no error, got: %v", err)
|
|
}
|
|
|
|
// Should find "NodeMetadata" from pattern "NodeMeta*" and use it as alias
|
|
if !strings.Contains(query, "JSON_VALUE([NodeMetadata], '$.id') AS [NodeMetadata]") {
|
|
t.Errorf("Expected to find and use NodeMetadata column by pattern, got: %s", query)
|
|
}
|
|
|
|
if strings.Contains(query, "SELECT [ID], [NodeMetadata]") {
|
|
t.Errorf("Expected NodeMetadata to be replaced by JSON extraction, got: %s", query)
|
|
}
|
|
}
|
|
|
|
func TestBuildExtractQueryMssql_ColumnNotFound_Error(t *testing.T) {
|
|
// Test that an error is returned when column is not found
|
|
q := ExtractionQuery{
|
|
Schema: "dbo",
|
|
Table: "Events",
|
|
PrimaryKey: "ID",
|
|
Columns: []models.ColumnType{
|
|
models.NewColumnType("ID", false, false, "INT", "int", "INT", false, 0, 0, 0),
|
|
},
|
|
FromJsonColumns: []config.FromJsonItem{
|
|
{Column: "NonExistentColumn", Field: ".id"},
|
|
},
|
|
LowerLimit: ExtractorQueryLimit{IsValid: false},
|
|
UpperLimit: ExtractorQueryLimit{IsValid: false},
|
|
}
|
|
|
|
query, err := buildExtractQueryMssql(q)
|
|
if err == nil {
|
|
t.Fatalf("Expected error for missing column, got no error. Query: %s", query)
|
|
}
|
|
|
|
if !strings.Contains(err.Error(), "NonExistentColumn") {
|
|
t.Errorf("Expected error message to contain column name, got: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestBuildExtractQueryMssql_WildcardPatternNotMatched_Error(t *testing.T) {
|
|
// Test that an error is returned when wildcard pattern doesn't match any column
|
|
q := ExtractionQuery{
|
|
Schema: "dbo",
|
|
Table: "Events",
|
|
PrimaryKey: "ID",
|
|
Columns: []models.ColumnType{
|
|
models.NewColumnType("ID", false, false, "INT", "int", "INT", false, 0, 0, 0),
|
|
models.NewColumnType("EventData", true, false, "VARCHAR", "varchar", "VARCHAR", true, 500, 0, 0),
|
|
},
|
|
FromJsonColumns: []config.FromJsonItem{
|
|
{Column: "NonMatching*", Field: ".id"},
|
|
},
|
|
LowerLimit: ExtractorQueryLimit{IsValid: false},
|
|
UpperLimit: ExtractorQueryLimit{IsValid: false},
|
|
}
|
|
|
|
query, err := buildExtractQueryMssql(q)
|
|
if err == nil {
|
|
t.Fatalf("Expected error for non-matching wildcard pattern, got no error. Query: %s", query)
|
|
}
|
|
|
|
if !strings.Contains(err.Error(), "NonMatching*") {
|
|
t.Errorf("Expected error message to contain pattern, got: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestBuildExtractQueryMssql_NestedJsonFields(t *testing.T) {
|
|
q := ExtractionQuery{
|
|
Schema: "dbo",
|
|
Table: "Data",
|
|
PrimaryKey: "ID",
|
|
Columns: []models.ColumnType{
|
|
models.NewColumnType("ID", false, false, "INT", "int", "INT", false, 0, 0, 0),
|
|
models.NewColumnType("NodeData", true, false, "VARCHAR", "varchar", "VARCHAR", true, 500, 0, 0),
|
|
},
|
|
FromJsonColumns: []config.FromJsonItem{
|
|
{Column: "NodeData", Field: ".user.name"},
|
|
{Column: "NodeData", Field: ".user.email"},
|
|
},
|
|
LowerLimit: ExtractorQueryLimit{IsValid: false},
|
|
UpperLimit: ExtractorQueryLimit{IsValid: false},
|
|
}
|
|
|
|
query, err := buildExtractQueryMssql(q)
|
|
if err != nil {
|
|
t.Fatalf("Expected no error, got: %v", err)
|
|
}
|
|
|
|
if !strings.Contains(query, "JSON_VALUE([NodeData], '$.user.name') AS [NodeData]") {
|
|
t.Errorf("Expected nested JSON path for user.name, got: %s", query)
|
|
}
|
|
|
|
if !strings.Contains(query, "JSON_VALUE([NodeData], '$.user.email') AS [NodeData]") {
|
|
t.Errorf("Expected nested JSON path for user.email, got: %s", query)
|
|
}
|
|
|
|
if strings.Contains(query, "SELECT [ID], [NodeData]") {
|
|
t.Errorf("Expected NodeData to be replaced by JSON extraction, got: %s", query)
|
|
}
|
|
}
|
|
|
|
func TestBuildExtractQueryMssql_WithRangeLimits(t *testing.T) {
|
|
q := ExtractionQuery{
|
|
Schema: "dbo",
|
|
Table: "Products",
|
|
PrimaryKey: "ProductID",
|
|
Columns: []models.ColumnType{
|
|
models.NewColumnType("ProductID", false, false, "INT", "int", "INT", false, 0, 0, 0),
|
|
models.NewColumnType("Details", true, false, "VARCHAR", "varchar", "VARCHAR", true, 500, 0, 0),
|
|
},
|
|
FromJsonColumns: []config.FromJsonItem{
|
|
{Column: "Details", Field: ".price"},
|
|
},
|
|
LowerLimit: ExtractorQueryLimit{IsValid: true, IsInclusive: true, Value: 100},
|
|
UpperLimit: ExtractorQueryLimit{IsValid: true, IsInclusive: false, Value: 500},
|
|
}
|
|
|
|
query, err := buildExtractQueryMssql(q)
|
|
if err != nil {
|
|
t.Fatalf("Expected no error, got: %v", err)
|
|
}
|
|
|
|
if !strings.Contains(query, "WHERE [ProductID] >= @min") {
|
|
t.Errorf("Expected WHERE clause with >=, got: %s", query)
|
|
}
|
|
|
|
if !strings.Contains(query, "[ProductID] < @max") {
|
|
t.Errorf("Expected upper limit with <, got: %s", query)
|
|
}
|
|
|
|
if !strings.Contains(query, "JSON_VALUE([Details], '$.price') AS [Details]") {
|
|
t.Errorf("Expected JSON_VALUE for Details, got: %s", query)
|
|
}
|
|
|
|
if strings.Contains(query, "SELECT [ProductID], [Details]") {
|
|
t.Errorf("Expected Details to be replaced by JSON extraction, got: %s", query)
|
|
}
|
|
}
|
|
|
|
func TestBuildJsonPathMssql(t *testing.T) {
|
|
tests := []struct {
|
|
input string
|
|
expected string
|
|
}{
|
|
{".id", "$.id"},
|
|
{"id", "$.id"},
|
|
{".user.name", "$.user.name"},
|
|
{"user.name", "$.user.name"},
|
|
{".location.coordinates.lat", "$.location.coordinates.lat"},
|
|
{"", "$."},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
result := buildJsonPathMssql(tt.input)
|
|
if result != tt.expected {
|
|
t.Errorf("buildJsonPathMssql(%q) = %q, want %q", tt.input, result, tt.expected)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestFindColumnByPattern_ExactMatch(t *testing.T) {
|
|
columns := []models.ColumnType{
|
|
models.NewColumnType("ID", false, false, "INT", "int", "INT", false, 0, 0, 0),
|
|
models.NewColumnType("Metadata", true, false, "VARCHAR", "varchar", "VARCHAR", true, 500, 0, 0),
|
|
models.NewColumnType("EventData", true, false, "VARCHAR", "varchar", "VARCHAR", true, 500, 0, 0),
|
|
}
|
|
|
|
result, err := findColumnByPattern(columns, "Metadata")
|
|
if err != nil {
|
|
t.Fatalf("Expected no error, got: %v", err)
|
|
}
|
|
|
|
if result != "Metadata" {
|
|
t.Errorf("Expected 'Metadata', got '%s'", result)
|
|
}
|
|
}
|
|
|
|
func TestFindColumnByPattern_WildcardMatch(t *testing.T) {
|
|
columns := []models.ColumnType{
|
|
models.NewColumnType("ID", false, false, "INT", "int", "INT", false, 0, 0, 0),
|
|
models.NewColumnType("NodeMetadata", true, false, "VARCHAR", "varchar", "VARCHAR", true, 500, 0, 0),
|
|
models.NewColumnType("EventData", true, false, "VARCHAR", "varchar", "VARCHAR", true, 500, 0, 0),
|
|
}
|
|
|
|
result, err := findColumnByPattern(columns, "NodeMeta*")
|
|
if err != nil {
|
|
t.Fatalf("Expected no error, got: %v", err)
|
|
}
|
|
|
|
if result != "NodeMetadata" {
|
|
t.Errorf("Expected 'NodeMetadata', got '%s'", result)
|
|
}
|
|
}
|
|
|
|
func TestFindColumnByPattern_NotFound(t *testing.T) {
|
|
columns := []models.ColumnType{
|
|
models.NewColumnType("ID", false, false, "INT", "int", "INT", false, 0, 0, 0),
|
|
models.NewColumnType("Metadata", true, false, "VARCHAR", "varchar", "VARCHAR", true, 500, 0, 0),
|
|
}
|
|
|
|
result, err := findColumnByPattern(columns, "NonExistent")
|
|
if err == nil {
|
|
t.Fatalf("Expected error, got no error. Result: %s", result)
|
|
}
|
|
|
|
if !strings.Contains(err.Error(), "NonExistent") {
|
|
t.Errorf("Expected error to contain column name, got: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestFindColumnByPattern_WildcardNotFound(t *testing.T) {
|
|
columns := []models.ColumnType{
|
|
models.NewColumnType("ID", false, false, "INT", "int", "INT", false, 0, 0, 0),
|
|
models.NewColumnType("Metadata", true, false, "VARCHAR", "varchar", "VARCHAR", true, 500, 0, 0),
|
|
}
|
|
|
|
result, err := findColumnByPattern(columns, "Event*")
|
|
if err == nil {
|
|
t.Fatalf("Expected error, got no error. Result: %s", result)
|
|
}
|
|
|
|
if !strings.Contains(err.Error(), "Event*") {
|
|
t.Errorf("Expected error to contain pattern, got: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestBuildExtractQueryMssql_OnlyJsonColumns(t *testing.T) {
|
|
// Test when all columns are used via JSON extraction
|
|
q := ExtractionQuery{
|
|
Schema: "dbo",
|
|
Table: "Data",
|
|
PrimaryKey: "ID",
|
|
Columns: []models.ColumnType{
|
|
models.NewColumnType("ID", false, false, "INT", "int", "INT", false, 0, 0, 0),
|
|
models.NewColumnType("JsonData", true, false, "VARCHAR", "varchar", "VARCHAR", true, 500, 0, 0),
|
|
},
|
|
FromJsonColumns: []config.FromJsonItem{
|
|
{Column: "JsonData", Field: ".field1"},
|
|
},
|
|
LowerLimit: ExtractorQueryLimit{IsValid: false},
|
|
UpperLimit: ExtractorQueryLimit{IsValid: false},
|
|
}
|
|
|
|
query, err := buildExtractQueryMssql(q)
|
|
if err != nil {
|
|
t.Fatalf("Expected no error, got: %v", err)
|
|
}
|
|
|
|
if !strings.HasPrefix(query, "SELECT [ID], JSON_VALUE([JsonData], '$.field1') AS [JsonData]") {
|
|
t.Errorf("Expected JsonData to be replaced by JSON extraction, got: %s", query)
|
|
}
|
|
|
|
if strings.Contains(query, "SELECT [ID], [JsonData]") {
|
|
t.Errorf("Expected JsonData to be excluded from raw selection, got: %s", query)
|
|
}
|
|
}
|
|
|
|
func TestBuildExtractQueryMssql_JsonColumnsReplaceInOrder(t *testing.T) {
|
|
q := ExtractionQuery{
|
|
Schema: "dbo",
|
|
Table: "Users",
|
|
PrimaryKey: "UserID",
|
|
Columns: []models.ColumnType{
|
|
models.NewColumnType("UserID", false, false, "INT", "int", "INT", false, 0, 0, 0),
|
|
models.NewColumnType("Name", true, false, "VARCHAR", "varchar", "VARCHAR", false, 255, 0, 0),
|
|
models.NewColumnType("Email", true, false, "VARCHAR", "varchar", "VARCHAR", false, 255, 0, 0),
|
|
models.NewColumnType("Metadata", true, false, "NVARCHAR", "nvarchar", "NVARCHAR", true, 4000, 0, 0),
|
|
models.NewColumnType("Profile", true, false, "NVARCHAR", "nvarchar", "NVARCHAR", true, 4000, 0, 0),
|
|
models.NewColumnType("Settings", true, false, "NVARCHAR", "nvarchar", "NVARCHAR", true, 4000, 0, 0),
|
|
},
|
|
FromJsonColumns: []config.FromJsonItem{
|
|
{Column: "Metadata", Field: ".id"},
|
|
{Column: "Profile", Field: ".id"},
|
|
{Column: "Settings", Field: ".id"},
|
|
},
|
|
LowerLimit: ExtractorQueryLimit{IsValid: false},
|
|
UpperLimit: ExtractorQueryLimit{IsValid: false},
|
|
}
|
|
|
|
query, err := buildExtractQueryMssql(q)
|
|
if err != nil {
|
|
t.Fatalf("Expected no error, got: %v", err)
|
|
}
|
|
|
|
expected := "SELECT [UserID], [Name], [Email], JSON_VALUE([Metadata], '$.id') AS [Metadata], JSON_VALUE([Profile], '$.id') AS [Profile], JSON_VALUE([Settings], '$.id') AS [Settings] FROM [dbo].[Users] ORDER BY [UserID] ASC"
|
|
if query != expected {
|
|
t.Errorf("Unexpected query.\nExpected: %s\nGot: %s", expected, query)
|
|
}
|
|
}
|