fix build breaks (#274)

* fix build breaks

* skip azure tests

---------

Co-authored-by: David Shiflet (from Dev Box) <[email protected]>

Author: shueybubbles

.pipelines/TestSql2017.yml

@@ -49,14 +49,9 @@ steps:
   workingDirectory: '$(Build.SourcesDirectory)'
   displayName: 'run tests'
   env:
+# skipping Azure related tests due to lack of access
     SQLPASSWORD: $(SQLPASSWORD)
-    AZURESERVER_DSN: $(AZURESERVER_DSN)
     SQLSERVER_DSN: $(SQLSERVER_DSN)
-    AZURE_CLIENT_SECRET: $(AZURE_CLIENT_SECRET)
-    KEY_VAULT_NAME: $(KEY_VAULT_NAME)
-    AZURE_TENANT_ID: $(AZURE_TENANT_ID)
-    AZURE_CLIENT_ID: $(AZURE_CLIENT_ID)
-    COLUMNENCRYPTION: 1
   continueOnError: true
 - task: PublishTestResults@2
   displayName: "Publish junit-style results"

bulkcopy_midnight_test.go

@@ -17,35 +17,35 @@ func TestBulkCopyMidnightRounding(t *testing.T) {
 			Size:   8, // 8 bytes for datetime
 		},
 	}
-	
+
 	// Create a Bulk instance (simplified for testing)
 	bulk := &Bulk{}
-	
+
 	// Test the problematic timestamp from the issue report
 	problematicTime := time.Date(2025, 1, 1, 23, 59, 59, 998_350_000, time.UTC)
-	
+
 	// Test the makeParam function directly
 	param, err := bulk.makeParam(problematicTime, col)
 	if err != nil {
 		t.Fatalf("makeParam failed for problematic time: %v", err)
 	}
-	
+
 	// Verify the buffer is the correct size
 	if len(param.buffer) != 8 {
 		t.Fatalf("Expected buffer size 8, got %d", len(param.buffer))
 	}
-	
+
 	// Decode the buffer to verify it doesn't produce invalid data
-	decoded := decodeDateTime(param.buffer)
+	decoded := decodeDateTime(param.buffer, time.UTC)
 	t.Logf("Original time: %s", problematicTime.Format(time.RFC3339Nano))
 	t.Logf("Encoded/decoded time: %s", decoded.Format(time.RFC3339Nano))
-	
+
 	// Verify the decoded time is reasonable
 	diff := decoded.Sub(problematicTime)
 	if diff < 0 {
 		diff = -diff
 	}
-	
+
 	// Maximum acceptable difference for SQL Server datetime precision (1/300th of a second)
 	maxDiff := time.Duration(3333333) // ~3.33ms in nanoseconds
 	if diff > maxDiff {
@@ -62,9 +62,9 @@ func TestBulkCopyNearMidnightBoundaries(t *testing.T) {
 			Size:   8,
 		},
 	}
-	
+
 	bulk := &Bulk{}
-	
+
 	testCases := []struct {
 		name string
 		time time.Time
@@ -94,32 +94,32 @@ func TestBulkCopyNearMidnightBoundaries(t *testing.T) {
 			time: time.Date(2025, 1, 1, 23, 59, 59, 996_000_000, time.UTC),
 		},
 	}
-	
+
 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
 			param, err := bulk.makeParam(tc.time, col)
 			if err != nil {
 				t.Fatalf("makeParam failed: %v", err)
 			}
-			
+
 			if len(param.buffer) != 8 {
 				t.Fatalf("Expected buffer size 8, got %d", len(param.buffer))
 			}
-			
-			decoded := decodeDateTime(param.buffer)
+
+			decoded := decodeDateTime(param.buffer, time.UTC)
 			t.Logf("Original: %s", tc.time.Format(time.RFC3339Nano))
 			t.Logf("Decoded:  %s", decoded.Format(time.RFC3339Nano))
-			
+
 			// Verify the decoded time is within acceptable bounds
 			diff := decoded.Sub(tc.time)
 			if diff < 0 {
 				diff = -diff
 			}
-			
+
 			maxDiff := time.Duration(3333333) // ~3.33ms
 			if diff > maxDiff {
 				t.Errorf("Time difference too large: %v > %v", diff, maxDiff)
 			}
 		})
 	}
-}
+}

datetime_midnight_test.go

@@ -21,37 +21,37 @@ func TestDatetimeNearMidnightBoundaries(t *testing.T) {
 			time: time.Date(2025, 1, 1, 23, 59, 59, 997_000_000, time.UTC),
 		},
 	}
-	
+
 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
 			// Test encoding/decoding
 			encoded := encodeDateTime(tc.time)
-			decoded := decodeDateTime(encoded)
-			
+			decoded := decodeDateTime(encoded, time.UTC)
+
 			t.Logf("Original: %s", tc.time.Format(time.RFC3339Nano))
 			t.Logf("Decoded:  %s", decoded.Format(time.RFC3339Nano))
-			
+
 			// Verify the decoded time is reasonable
 			diff := decoded.Sub(tc.time)
 			if diff < 0 {
 				diff = -diff
 			}
-			
+
 			// Maximum acceptable difference for SQL Server datetime precision
 			maxDiff := time.Duration(3333333) // ~3.33ms in nanoseconds
 			if diff > maxDiff {
 				t.Errorf("Time difference too large: %v > %v", diff, maxDiff)
 			}
-			
+
 			// Ensure we don't have invalid day overflow
-			// If the original time was on Jan 1st, the decoded time should be 
+			// If the original time was on Jan 1st, the decoded time should be
 			// either Jan 1st or Jan 2nd (if it rounded up to midnight)
 			origDay := tc.time.Day()
 			decodedDay := decoded.Day()
-			
+
 			if decodedDay != origDay && decodedDay != origDay+1 {
 				t.Errorf("Invalid day change: original day %d, decoded day %d", origDay, decodedDay)
 			}
 		})
 	}
-}
+}

encode_datetime_overflow_test.go

@@ -7,7 +7,7 @@ import (
 )
 
 // TestEncodeDateTimeOverflow specifically tests that encodeDateTime
-// correctly handles day overflow when nanosToThreeHundredthsOfASecond 
+// correctly handles day overflow when nanosToThreeHundredthsOfASecond
 // returns 300 (representing 1 full second).
 func TestEncodeDateTimeOverflow(t *testing.T) {
 	testCases := []struct {
@@ -36,15 +36,15 @@ func TestEncodeDateTimeOverflow(t *testing.T) {
 			expected: time.Date(2025, 1, 2, 0, 0, 0, 0, time.UTC),
 		},
 	}
-	
+
 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
 			// Encode the time
 			encoded := encodeDateTime(tc.input)
-			
+
 			// Verify round-trip decoding gives the expected result
-			decoded := decodeDateTime(encoded)
-			
+			decoded := decodeDateTime(encoded, time.UTC)
+
 			if !decoded.Equal(tc.expected) {
 				t.Errorf("Expected decoded time %v, got %v", tc.expected, decoded)
 			}
@@ -57,13 +57,13 @@ func TestEncodeDateTimeOverflow(t *testing.T) {
 func TestEncodeDateTimeMaxDateOverflow(t *testing.T) {
 	// Test time very close to end of 9999 that might overflow
 	maxTime := time.Date(9999, 12, 31, 23, 59, 59, 998_350_000, time.UTC)
-	
+
 	// Encode the time
 	encoded := encodeDateTime(maxTime)
-	
+
 	// Decode it back
-	decoded := decodeDateTime(encoded)
-	
+	decoded := decodeDateTime(encoded, time.UTC)
+
 	// Should be clamped to the maximum possible datetime value
 	// SQL Server datetime max is 9999-12-31 23:59:59.997
 	if decoded.Year() != 9999 || decoded.Month() != 12 || decoded.Day() != 31 {
@@ -76,32 +76,32 @@ func TestEncodeDateTimeMaxDateOverflow(t *testing.T) {
 func TestEncodeDateTimeNoOverflow(t *testing.T) {
 	// Test case that should not trigger overflow: 997ms
 	normalTime := time.Date(2025, 1, 1, 23, 59, 59, 997_000_000, time.UTC)
-	
+
 	// Encode the time
 	encoded := encodeDateTime(normalTime)
-	
+
 	// Decode the days and time portions
 	days := int32(binary.LittleEndian.Uint32(encoded[0:4]))
 	tm := binary.LittleEndian.Uint32(encoded[4:8])
-	
+
 	// Calculate expected values
 	basedays := gregorianDays(1900, 1)
 	expectedDays := gregorianDays(2025, 1) - basedays // Should still be Jan 1st
-	
+
 	if days != int32(expectedDays) {
 		t.Errorf("Expected days %d, got %d", expectedDays, days)
 	}
-	
+
 	// tm should be less than a full day's worth
 	if tm >= 300*86400 {
 		t.Errorf("tm %d should be less than a full day (%d)", tm, 300*86400)
 	}
-	
+
 	// Verify round-trip decoding
-	decoded := decodeDateTime(encoded)
-	
+	decoded := decodeDateTime(encoded, time.UTC)
+
 	// The decoded time should be on the same day (Jan 1st)
 	if decoded.Day() != 1 || decoded.Month() != 1 || decoded.Year() != 2025 {
 		t.Errorf("Expected decoded time to be on 2025-01-01, got %v", decoded)
 	}
-}
+}

tds_test.go

@@ -357,6 +357,13 @@ func GetConnParams() (*msdsn.Config, error) {
 			return nil, err
 		}
 		params.LogFlags = logFlags
+		if os.Getenv("TIME_ZONE") != "" {
+			tz, err := time.LoadLocation(os.Getenv("TIME_ZONE"))
+			if err == nil {
+				params.Encoding.Timezone = tz
+			}
+		}
+
 		return &params, nil
 	}