added tests and ci workflow

Author: ndbroadbent

.github/workflows/test.yml

@@ -0,0 +1,25 @@
+name: CI
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - uses: actions/setup-go@v5
+        with:
+          go-version: '1.22'
+      - name: Build
+        run: go build ./...
+      - name: Vet
+        run: go vet ./...
+      - name: Test
+        run: go test ./...
+

pkg/provider/datasource_cw_filter.go

@@ -58,24 +58,39 @@ func (d *cwFilterDataSource) Read(ctx context.Context, req datasource.ReadReques
         resp.Diagnostics.AddError("Provider not configured", "Missing metadata client")
         return
     }
+    pattern, err := generatePattern(client, data)
+    if err != nil {
+        resp.Diagnostics.AddError("Pattern generation failed", err.Error())
+        return
+    }
+    data.Pattern = types.StringValue(pattern)
+
+    diags = resp.State.Set(ctx, &data)
+    resp.Diagnostics.Append(diags...)
+}
+
+func contains(arr []string, s string) bool { for _, v := range arr { if v == s { return true } }; return false }
+func escape(s string) string { return strings.ReplaceAll(s, "\"", "\\\"") }
+
+// generatePattern builds a CloudWatch filter pattern for the given model using the catalog client.
+func generatePattern(client *MetadataClient, data cwFilterModel) (string, error) {
     structName := data.Struct.ValueString()
     event := data.Event.ValueString()
     allowed, _, err := client.AllowedEventsForStruct(structName)
-    if err != nil { resp.Diagnostics.AddError("Lookup error", err.Error()); return }
+    if err != nil { return "", err }
     if !contains(allowed, event) {
-        resp.Diagnostics.AddError("Invalid event for struct", fmt.Sprintf("event %q not allowed for %s (allowed: %v)", event, structName, allowed))
-        return
+        return "", fmt.Errorf("event %q not allowed for %s (allowed: %v)", event, structName, allowed)
     }
     var parts []string
     // add evt
-    evtKey, ok := client.Keys["evt"]
-    if !ok { resp.Diagnostics.AddError("Missing key", "evt key missing from exports"); return }
+    evtKey, ok := client.Keys["event"]
+    if !ok { return "", fmt.Errorf("evt key missing from exports") }
     parts = append(parts, fmt.Sprintf("$.%s = \"%s\"", evtKey, event))
     // add source
     if src, fixed, err := client.FixedSourceForStruct(structName); err != nil {
-        resp.Diagnostics.AddError("Lookup error", err.Error()); return
+        return "", err
     } else if fixed {
-        srcKey, ok := client.Keys["src"]; if !ok { resp.Diagnostics.AddError("Missing key", "src key missing from exports"); return }
+        srcKey, ok := client.Keys["source"]; if !ok { return "", fmt.Errorf("src key missing from exports") }
         parts = append(parts, fmt.Sprintf("$.%s = \"%s\"", srcKey, src))
     }
     // add extra predicates
@@ -96,12 +111,5 @@ func (d *cwFilterDataSource) Read(ctx context.Context, req datasource.ReadReques
             }
         }
     }
-    pattern := fmt.Sprintf("{ %s }", strings.Join(parts, " && "))
-    data.Pattern = types.StringValue(pattern)
-
-    diags = resp.State.Set(ctx, &data)
-    resp.Diagnostics.Append(diags...)
+    return fmt.Sprintf("{ %s }", strings.Join(parts, " && ")), nil
 }
-
-func contains(arr []string, s string) bool { for _, v := range arr { if v == s { return true } }; return false }
-func escape(s string) string { return strings.ReplaceAll(s, "\"", "\\\"") }

pkg/provider/datasource_cw_filter_test.go

@@ -0,0 +1,19 @@
+package provider
+
+import (
+    "strings"
+    "testing"
+    "github.com/hashicorp/terraform-plugin-framework/types"
+)
+
+// minimal harness to exercise Read logic without full TF runtime
+func TestCloudWatchFilter_BuildsPattern(t *testing.T) {
+    client, err := NewMetadataClient()
+    if err != nil { t.Fatalf("client: %v", err) }
+    // Build inputs directly and call helper
+    cfg := cwFilterModel{Struct: types.StringValue("ActionMailer"), Event: types.StringValue("delivered"), Predicates: map[string][]string{"mailer_class": {"UserMailer"}}}
+    p, err := generatePattern(client, cfg)
+    if err != nil { t.Fatalf("generatePattern error: %v", err) }
+    if p == "" { t.Fatalf("expected pattern to be set") }
+    if !strings.Contains(p, "$.evt = \"delivered\"") { t.Fatalf("missing evt in pattern: %s", p) }
+}

pkg/provider/metadata_test.go

@@ -0,0 +1,22 @@
+package provider
+
+import "testing"
+
+func TestMetadataClient_Basics(t *testing.T) {
+    c, err := NewMetadataClient()
+    if err != nil { t.Fatalf("client: %v", err) }
+    if c.Keys == nil || len(c.Keys) == 0 { t.Fatalf("expected keys exported") }
+
+    // Known struct from generated catalog
+    events, fixed, err := c.AllowedEventsForStruct("ActionMailer")
+    if err != nil { t.Fatalf("allowed: %v", err) }
+    if len(events) == 0 { t.Fatalf("expected events for ActionMailer") }
+
+    // If source is fixed, ensure FixedSourceForStruct returns it
+    if fixed {
+        src, isFixed, err := c.FixedSourceForStruct("ActionMailer")
+        if err != nil { t.Fatalf("fixed source: %v", err) }
+        if !isFixed || src == "" { t.Fatalf("expected fixed source for ActionMailer") }
+    }
+}
+