adjust lint config, and fix several lint warnings (and rebuild the example wasm) (#64)

Author: robbyt

.golangci.yml

@@ -12,24 +12,27 @@ linters:
     - noctx         # Finds sending http request without context.Context
     - prealloc      # Temporarily disable until slice allocation issues are fixed
   enable:
-    - bodyclose     # Checks HTTP response body is closed
-    - contextcheck  # Check whether the function uses a non-inherited context
-    - dupl          # Find duplicate code
-    - dupword       # Find duplicate words in comments and strings
-    - errcheck
-    - errorlint     # Check error handling
-    - misspell      # Find commonly misspelled English words
-    - unconvert     # Remove unnecessary type conversions
-    - reassign      # Checks that package variables are not reassigned
-    - tagalign      # Check that struct tags are well aligned
-    - nilerr        # Finds code that returns nil even if it checks that the error is not nil
-    - nolintlint    # Checks for invalid or missing nolint directives
-    - whitespace    # Check for unnecessary whitespace
-    - thelper       # Detects test helpers which should start with t.Helper()
-    - govet         # Examines Go source code and reports suspicious constructs
-    - ineffassign   # Detects when assignments to existing variables are not used
-    - staticcheck   # Staticcheck is a go linter
-    - unused        # Checks for unused code
+    - bodyclose      # Ensure HTTP response bodies are closed
+    - contextcheck   # Ensure functions use a non-inherited context
+    - dupl           # Detect duplicate code
+    - dupword        # Detect duplicate words in comments/strings
+    - errcheck       # Check for unchecked errors
+    - errorlint      # Enforce idiomatic error handling
+    - govet          # Report suspicious constructs
+    - ineffassign    # Detect unused variable assignments
+    - misspell       # Detect misspelled English words
+    - nilerr         # Detect returning nil after error checks
+    - nolintlint     # Check for invalid/missing nolint directives
+    - reassign       # Prevent package variable reassignment
+    - staticcheck    # Advanced static analysis
+    - tagalign       # Check struct tag alignment
+    - tagliatelle    # Enforce struct tag formatting
+    - testifylint    # Avoid common testify mistakes
+    - thelper        # Ensure test helpers use t.Helper()
+    - unconvert      # Remove unnecessary type conversions
+    - usetesting     # Detects when some calls can be replaced by methods from the testing package
+    - unused         # Detect unused code
+    - whitespace     # Detect unnecessary whitespace
   settings:
     errcheck:
       check-blank: true
@@ -41,14 +44,25 @@ linters:
       errorf: true
       asserts: true
       comparison: true
+    tagalign:
+      strict: true
+      order:
+        - json
+        - toml
+        - yaml
+        - xml
+        - env_interpolation
+    usetesting:
+      os-temp-dir: true
+      context-background: true
+      context-todo: true
 
 formatters:
   enable:
     - gci
     - gofmt
     - goimports
     - gofumpt
-    - golines
 
 issues:
   max-issues-per-linter: 20

engines/extism/adapters/sdkAdapters_test.go

@@ -24,17 +24,6 @@ func TestInterfaceImplementation(t *testing.T) {
 // For the sdkCompiledPluginAdapter and sdkPluginAdapter implementations, we rely on
 // the Extism SDK's types, so we don't need exhaustive tests for this wrapper code.
 
-func TestAdapterCorrectlyImplementsInterfaces(t *testing.T) {
-	// These tests verify that the methods of the interfaces correctly match
-	// the methods of the SDK types. If there's a mismatch, Go won't compile.
-	//
-	// We don't need to test the implementation since it's just directly
-	// calling the SDK's methods. We're just verifying the types at compile time.
-
-	// Implicitly test this with the interface check above
-	assert.True(t, true, "Adapters correctly implement their interfaces")
-}
-
 func TestNilPlugin(t *testing.T) {
 	// Test that NewCompiledPluginAdapter returns nil when given a nil plugin
 	adapter := NewCompiledPluginAdapter(nil)

engines/extism/compiler/internal/compile/compile_test.go

@@ -181,12 +181,12 @@ func testFunctions(t *testing.T, instance adapters.PluginInstance) {
 			assertFunc: func(t *testing.T, output []byte) {
 				t.Helper()
 				var result struct {
-					RequestID   string         `json:"request_id"`
-					ProcessedAt string         `json:"processed_at"`
+					RequestID   string         `json:"requestId"`
+					ProcessedAt string         `json:"processedAt"`
 					Results     map[string]any `json:"results"`
-					TagCount    int            `json:"tag_count"`
-					MetaCount   int            `json:"meta_count"`
-					IsActive    bool           `json:"is_active"`
+					TagCount    int            `json:"tagCount"`
+					MetaCount   int            `json:"metaCount"`
+					IsActive    bool           `json:"isActive"`
 					Summary     string         `json:"summary"`
 				}
 				require.NoError(t, json.Unmarshal(output, &result))

engines/extism/compiler/options_test.go

@@ -53,7 +53,7 @@ func TestCompilerOptions_Options(t *testing.T) {
 
 		t.Run("empty value", func(t *testing.T) {
 			c := &Compiler{entryPointName: ""}
-			require.Equal(t, "", c.GetEntryPointName())
+			require.Empty(t, c.GetEntryPointName())
 		})
 
 		t.Run("with defaults", func(t *testing.T) {
@@ -617,7 +617,7 @@ func TestCompilerOptions(t *testing.T) {
 			c2 := &Compiler{
 				entryPointName: "",
 			}
-			require.Equal(t, "", c2.GetEntryPointName())
+			require.Empty(t, c2.GetEntryPointName())
 		})
 	})
 

engines/extism/evaluator/evaluator_test.go

@@ -178,7 +178,7 @@ func TestEvaluator_Evaluate(t *testing.T) {
 			require.Contains(t, resultMap, "result")
 			require.Equal(t, "success", resultMap["result"])
 			require.Contains(t, resultMap, "value")
-			require.Equal(t, float64(42), resultMap["value"])
+			require.InDelta(t, float64(42), resultMap["value"], 0.0001)
 		})
 
 		// Test successful string response
@@ -398,8 +398,7 @@ func TestEvaluator_Evaluate(t *testing.T) {
 			// Call Eval, which should be cancelled during execution
 			result, err := evaluator.Eval(ctx)
 
-			// Should get a cancellation error
-			assert.Error(t, err)
+			require.Error(t, err, "Expected cancellation error")
 			assert.Nil(t, result)
 			assert.Contains(t, err.Error(), "execution")
 
@@ -588,19 +587,18 @@ func TestEvaluator_Evaluate(t *testing.T) {
 						"Expected the mock instance to be called",
 					)
 
-					// Check for expected errors
 					if tt.wantErr {
-						assert.Error(t, err)
+						require.Error(t, err)
 						if tt.errContains != "" {
 							assert.Contains(t, err.Error(), tt.errContains)
 						}
 					} else {
-						assert.NoError(t, err)
+						require.NoError(t, err)
 						assert.NotNil(t, result)
 					}
 
 					// Execution time should always be measured
-					assert.Greater(t, execTime.Nanoseconds(), int64(0))
+					assert.Positive(t, execTime.Nanoseconds())
 				})
 			}
 		})

engines/extism/internal/converters_test.go

@@ -84,7 +84,7 @@ func TestConvertToExtismFormat(t *testing.T) {
 								// Handle type conversions that happen during JSON marshaling
 								if intVal, isInt := expectedVal.(int); isInt {
 									// JSON unmarshaling converts numbers to float64
-									assert.Equal(t, float64(intVal), checkData[k])
+									assert.InDelta(t, float64(intVal), checkData[k], 0.0001)
 								} else if _, isIntSlice := expectedVal.([]int); isIntSlice {
 									// Skip int slice checks (arrays become []any)
 								} else if _, isSlice := expectedVal.([]any); !isSlice {

engines/extism/internal/jsonHelpers_test.go

@@ -77,9 +77,9 @@ func TestFixJSONNumberTypes(t *testing.T) {
 		assert.True(t, ok, "Result should be a map")
 
 		// Check that the values were converted to float64
-		assert.Equal(t, float64(19.99), mapResult["price"])
-		assert.Equal(t, float64(4.5), mapResult["rating"])
-		assert.Equal(t, float64(75.5), mapResult["percentage"])
+		assert.InDelta(t, float64(19.99), mapResult["price"], 0.0001)
+		assert.InDelta(t, float64(4.5), mapResult["rating"], 0.0001)
+		assert.InDelta(t, float64(75.5), mapResult["percentage"], 0.0001)
 		assert.IsType(t, float64(0), mapResult["price"])
 		assert.IsType(t, float64(0), mapResult["rating"])
 		assert.IsType(t, float64(0), mapResult["percentage"])
@@ -113,7 +113,7 @@ func TestFixJSONNumberTypes(t *testing.T) {
 		stats, ok := user["stats"].(map[string]any)
 		assert.True(t, ok, "stats should be a map")
 		assert.Equal(t, int(42), stats["login_count"])
-		assert.Equal(t, float64(95.5), stats["score"])
+		assert.InDelta(t, float64(95.5), stats["score"], 0.0001)
 	})
 
 	t.Run("handles slices", func(t *testing.T) {
@@ -142,7 +142,7 @@ func TestFixJSONNumberTypes(t *testing.T) {
 		itemMap, ok := sliceResult[3].(map[string]any)
 		assert.True(t, ok, "Item at index 3 should be a map")
 		assert.Equal(t, int(123), itemMap["item_id"])
-		assert.Equal(t, float64(9.99), itemMap["price"])
+		assert.InDelta(t, float64(9.99), itemMap["price"], 0.0001)
 	})
 
 	t.Run("handles nested slices", func(t *testing.T) {
@@ -177,13 +177,13 @@ func TestFixJSONNumberTypes(t *testing.T) {
 		product1, ok := products[0].(map[string]any)
 		assert.True(t, ok, "First product should be a map")
 		assert.Equal(t, int(1), product1["product_id"])
-		assert.Equal(t, float64(19.99), product1["price"])
+		assert.InDelta(t, float64(19.99), product1["price"], 0.0001)
 
 		// Check second product
 		product2, ok := products[1].(map[string]any)
 		assert.True(t, ok, "Second product should be a map")
 		assert.Equal(t, int(2), product2["product_id"])
-		assert.Equal(t, float64(29.99), product2["price"])
+		assert.InDelta(t, float64(29.99), product2["price"], 0.0001)
 	})
 
 	t.Run("handles invalid numbers gracefully", func(t *testing.T) {

engines/extism/wasmdata/examples/main.go

@@ -22,12 +22,12 @@ type Request struct {
 
 // Response represents a complex output object
 type Response struct {
-	RequestID   string         `json:"request_id"`
-	ProcessedAt string         `json:"processed_at"`
+	RequestID   string         `json:"requestId"`
+	ProcessedAt string         `json:"processedAt"`
 	Results     map[string]any `json:"results"`
-	TagCount    int            `json:"tag_count"`
-	MetaCount   int            `json:"meta_count"`
-	IsActive    bool           `json:"is_active"`
+	TagCount    int            `json:"tagCount"`
+	MetaCount   int            `json:"metaCount"`
+	IsActive    bool           `json:"isActive"`
 	Summary     string         `json:"summary"`
 }
 

engines/extism/wasmdata/integration_test.go

@@ -209,10 +209,10 @@ func TestExtismWasmIntegration(t *testing.T) {
 		err = json.Unmarshal(output, &response)
 		require.NoError(t, err, "Failed to parse complex response")
 
-		assert.Equal(t, "test-123", response["request_id"])
-		assert.NotEmpty(t, response["processed_at"])
-		assert.Equal(t, float64(3), response["tag_count"]) // JSON numbers are float64
-		assert.Equal(t, float64(3), response["meta_count"])
+		assert.Equal(t, "test-123", response["requestId"])
+		assert.NotEmpty(t, response["processedAt"])
+		assert.InDelta(t, float64(3), response["tagCount"], 0.0001) // JSON numbers are float64
+		assert.InDelta(t, float64(3), response["metaCount"], 0.0001)
 		assert.Contains(t, response["summary"], "test-123")
 	})
 
@@ -245,7 +245,7 @@ func TestExtismWasmIntegration(t *testing.T) {
 		require.NoError(t, err, "Failed to parse vowel result")
 
 		assert.Equal(t, "Hello World", vowelResult["input"])
-		assert.Equal(t, float64(3), vowelResult["count"]) // 3 vowels in "Hello World"
+		assert.InDelta(t, float64(3), vowelResult["count"], 0.0001) // 3 vowels in "Hello World"
 	})
 
 	t.Run("reverse_string function", func(t *testing.T) {
@@ -312,7 +312,7 @@ func TestExtismWasmIntegration(t *testing.T) {
 		require.NoError(t, err, "Failed to parse vowel result")
 
 		assert.Equal(t, "Hello World", vowelResult["input"])
-		assert.Equal(t, float64(3), vowelResult["count"]) // 3 vowels in "Hello World"
+		assert.InDelta(t, float64(3), vowelResult["count"], 0.0001) // 3 vowels in "Hello World"
 	})
 
 	t.Run("reverse_string_namespaced function", func(t *testing.T) {