[AV-128452] Migrate to claude code (#563)

Author: l0n3star

.claude/skills/tf-acceptance-test-gen/SKILL.md

@@ -0,0 +1,158 @@
+---
+name: tf-acceptance-test-gen
+description: Generate acceptance tests for a named Terraform resource or data source in the Couchbase Capella provider.
+---
+
+# Terraform Acceptance Test Generator
+
+Acceptance tests live in `acceptance_tests/` and are named `<feature>_acceptance_test.go`.
+
+## Test structure
+
+Every resource test follows this pattern:
+
+```go
+func TestAcc<Feature>Resource(t *testing.T) {
+    resourceName := randomStringWithPrefix("tf_acc_<feature>_")
+    resourceReference := "couchbase-capella_<type_name>." + resourceName
+
+    resource.ParallelTest(t, resource.TestCase{
+        ProtoV6ProviderFactories: globalProtoV6ProviderFactory,
+        Steps: []resource.TestStep{
+            // Create and Read
+            {
+                Config: testAcc<Feature>ResourceConfig(resourceName, <values...>),
+                Check: resource.ComposeAggregateTestCheckFunc(
+                    testAccExists<Feature>Resource(t, resourceReference),
+                    resource.TestCheckResourceAttr(resourceReference, "organization_id", globalOrgId),
+                    resource.TestCheckResourceAttr(resourceReference, "<required_field>", "<expected_value>"),
+                    resource.TestCheckResourceAttrSet(resourceReference, "id"),
+                    resource.TestCheckResourceAttrSet(resourceReference, "<computed_field>"),
+                ),
+            },
+            // ImportState
+            {
+                ResourceName:      resourceReference,
+                ImportStateIdFunc: generate<Feature>ImportIdForResource(resourceReference),
+                ImportState:       true,
+            },
+            // Update (omit if resource has no updatable fields)
+            {
+                Config: testAcc<Feature>ResourceConfig(resourceName, <updated_values...>),
+                Check: resource.ComposeAggregateTestCheckFunc(
+                    resource.TestCheckResourceAttr(resourceReference, "<updated_field>", "<new_value>"),
+                ),
+            },
+        },
+            // Delete testing automatically occurs in TestCase
+    })
+}
+```
+
+- Always use `resource.ParallelTest()`.
+- Always include an ImportState step.
+- Use `TestCheckResourceAttr` for fields with known values; `TestCheckResourceAttrSet` for computed fields.
+- Never hardcode IDs — use `globalOrgId`, `globalProjectId`, `globalClusterId`, `globalBucketId`, `globalAppServiceId`.
+
+## Writing meaningful assertions
+
+The goal of each assertion is to guard a specific behaviour, not to confirm the test ran. Apply these rules:
+
+**Assert values, not just presence.** Every field you set in the config must be asserted with `TestCheckResourceAttr` using the exact value you set. `TestCheckResourceAttrSet` only proves a field is non-empty — it does not prove the provider stored the right value. Reserve `TestCheckResourceAttrSet` for fields whose values are genuinely unknowable at test time (server-generated IDs, timestamps, status fields set by the API).
+
+**After an update, assert the full state.** The update step must check every field — not just the one that changed. This catches regressions where updating field A silently resets field B to its default.
+
+**Error tests must be specific.** The `ExpectError` regex must match a substring of the real error message for that specific invalid input, not a generic pattern like `"error"` or `"invalid"`. Read the resource's `Create` implementation and `internal/errors/` to find the actual message. A test that accepts any error is not guarding the right behaviour.
+
+**Optional fields need their own test.** If a resource has optional fields that change API behaviour (not just metadata), write a dedicated test that sets those fields and asserts the resulting state. Don't rely on the happy-path test covering them incidentally.
+
+**Default values must be verified.** If a field has a default, write a test that omits it and asserts the default value appears in state. This confirms the provider applies and reads back the default correctly.
+
+## Config builder
+
+```go
+func testAcc<Feature>ResourceConfig(resourceName string, field1 <type>) string {
+    return fmt.Sprintf(`
+    %[1]s
+
+    resource "couchbase-capella_<type_name>" "%[2]s" {
+        organization_id = "%[3]s"
+        project_id      = "%[4]s"
+        cluster_id      = "%[5]s"
+        <field>         = <format_verb>
+    }
+    `, globalProviderBlock, resourceName, globalOrgId, globalProjectId, globalClusterId, field1)
+}
+```
+
+Always start with `%[1]s` for `globalProviderBlock`. Number format verbs sequentially.
+
+## Import ID function
+
+Read the `ImportState()` function in `internal/resources/<feature>.go` to find the exact composite key format, then implement:
+
+```go
+func generate<Feature>ImportIdForResource(resourceReference string) resource.ImportStateIdFunc {
+    return func(state *terraform.State) (string, error) {
+        var rawState map[string]string
+        for _, m := range state.Modules {
+            if len(m.Resources) > 0 {
+                if v, ok := m.Resources[resourceReference]; ok {
+                    rawState = v.Primary.Attributes
+                }
+            }
+        }
+        return fmt.Sprintf(
+            "id=%s,cluster_id=%s,project_id=%s,organization_id=%s",
+            rawState["id"], rawState["cluster_id"], rawState["project_id"], rawState["organization_id"],
+        ), nil
+    }
+}
+```
+
+## Error-case test
+
+```go
+func TestAcc<Feature>ResourceInvalid<Field>(t *testing.T) {
+    resourceName := randomStringWithPrefix("tf_acc_<feature>_")
+    resource.ParallelTest(t, resource.TestCase{
+        ProtoV6ProviderFactories: globalProtoV6ProviderFactory,
+        Steps: []resource.TestStep{
+            {
+                Config:      testAcc<Feature>ResourceConfig(resourceName, <invalid_value>),
+                ExpectError: regexp.MustCompile("<substring of expected error>"),
+            },
+        },
+    })
+}
+```
+
+## Data source tests
+
+- Test function names for datasources should use the pattern `TestAccDatasource<Feature>`. 
+  For example: `func TestAccDatasourceCluster(t *testing.T)`
+- Omit the ImportState and Update steps.
+
+## Verifying and running the tests
+
+At session start the environment check reports which variables are set. If all three required variables (`TF_VAR_host`, `TF_VAR_auth_token`, `TF_VAR_organization_id`) are present, run only the tests for the resource you just wrote:
+
+```bash
+TF_ACC=1 go test -timeout=60m -v ./acceptance_tests/ -run TestAcc<Feature>
+```
+
+When credentials are not available the tests cannot be executed. The only verification possible is that the file compiles:
+
+```bash
+go test -c ./acceptance_tests
+```
+
+If compile errors are found fix and recompile to verify no errors. 
+
+## Reference examples
+
+| Scenario | File |
+|---|---|
+| Simple resource with update | `acceptance_tests/snapshot_backup_acceptance_test.go` |
+| Resource with many optional fields | `acceptance_tests/apikey_acceptance_test.go` |
+| Complex nested resource | `acceptance_tests/cluster_acceptance_test.go` |

.claude/skills/tf-bugfix/SKILL.md

@@ -0,0 +1,31 @@
+---
+name: tf-bugfix
+description: Diagnose and fix bugs in the Terraform Capella provider with acceptance tests.
+---
+
+# Terraform Bug Fix
+
+## Instructions
+
+0. Read the Jira ticket or GitHub issue provided by the user.
+   Summarize: what is the bug, what is the expected behavior,
+   and what is the actual behavior.
+
+1. Search the codebase for the function, file, or code path
+   mentioned in the bug report. Read the relevant source files
+   to understand the current behavior.
+
+2. Identify the root cause. Explain why the current code
+   produces the bug (e.g., missing bounds check, nil pointer,
+   incorrect logic).
+
+3. Propose a robust fix that addresses the root cause.
+
+4. Add an acceptance test in `acceptance_tests/` to
+   validate the fix end-to-end:
+   - Follow existing patterns: use `resource.ParallelTest()`,
+     `globalProtoV6ProviderFactory`, and helper functions like
+     `randomStringWithPrefix`.
+   - Name the test in this format `TestAcc<Feature>_AV_XXXXX` e.g. `TestAccProject_AV_12345`.
+
+5. Do not run the acceptance test.

.claude/skills/tf-datasource-gen/SKILL.md

@@ -0,0 +1,120 @@
+---
+name: tf-datasource-gen
+description: generate terraform datasources based on openapi spec.
+---
+
+# Terraform Datasource Generator
+
+## Instructions
+
+0.  First inspect the repo for existing datasource code, schema files, api structs, 
+    provider registrations, and acceptance tests for the feature. For each step 1 through 
+    12 if the datasource already satisfies the user request skip the step 
+    completely, make no edits and proceed to the next step. Do not make any minor edits or fixes 
+    to existing code if the datasource already satisfies the user request. 
+    
+    For example:
+    - If api structs exist, skip creating them and use the existing structs
+    - If a datasource already exists, skip recreating it unless explicitly asked to edit it. 
+    - If an acceptance test already exists, skip creating a duplicate and extend coverage only if asked. 
+
+1.  datasource code should be in internal/datasources/
+2.  schema for datasource should be in its own file with format <feature>_schema.go
+
+    add validation for organization_id, project_id and cluster_id if present.  for example with organization_id
+
+```
+capellaschema.AddAttr(attrs, "organization_id", snapshotBackupBuilder, requiredStringWithValidator())
+
+func requiredStringWithValidator() *schema.StringAttribute {
+    return &schema.StringAttribute{
+        Required:   true,
+        Validators: []validator.String{stringvalidator.LengthAtLeast(1)},
+    }
+}
+```
+
+3.  implement one or two datasources depending on the spec provided.
+
+    - the first is to get a specific resource.  use the get endpoint.  if there is no get endpoint then skip this implementation.
+    for example if the feature is Buckets then need bucket.go to get a specific bucket.
+
+    - the second datasource is to list all resources.  use the list endpoint. if there is no list endpoint then skip this implementation.
+    the file name should have a plural resource name.
+    for example if the feature is Buckets then need buckets.go to list all buckets.
+
+4.  create struct with feature name that embeds Data struct.  for example if the feature is Buckets then need this struct
+
+```
+type Buckets struct {
+    *providerschema.Data
+}
+```
+
+5.  need New function.  for example if feature is Buckets then need this function
+
+```
+func NewBuckets() datasource.DataSource {
+    return &Buckets{}
+}
+```
+
+6.  type should implement interfaces datasource.DataSource and datasource.DataSourceWithConfigure.
+    must use type conversion of nil to assert that the type implements the interfaces.
+
+    for example for Buckets
+
+```
+var (
+    _ datasource.DataSource              = (*Buckets)(nil)
+    _ datasource.DataSourceWithConfigure = (*Buckets)(nil)
+)
+```
+
+7.  need Metadata function.  for example with Buckets
+
+```
+func (d *Buckets) Metadata(_ context.Context, req datasource.MetadataRequest, resp *datasource.MetadataResponse) {
+    resp.TypeName = req.ProviderTypeName + "_buckets"
+}
+```
+
+8.  need Configure function.  for example with Buckets
+
+```
+func (d *Buckets) Configure(_ context.Context, req datasource.ConfigureRequest, resp *datasource.ConfigureResponse) {
+    if req.ProviderData == nil {
+        return
+    }
+
+    data, ok := req.ProviderData.(*providerschema.Data)
+    if !ok {
+        resp.Diagnostics.AddError(
+            "Unexpected Data Source Configure Type",
+            fmt.Sprintf("Expected *providerschema.Data, got: %T. Please report this issue to the provider developers.", req.ProviderData),
+        )
+
+        return
+    }
+
+    d.Data = data
+}
+```
+
+9.  generate necessary structs to handle API response.  put structs in internal/api/
+    use ClientV1 struct to make API calls with retry logic.  for example:
+
+```
+response, err := s.ClientV1.ExecuteWithRetry
+```
+
+10.  register the datasource in `internal/provider/provider.go` in func `(p *capellaProvider) DataSources`
+
+     for example with buckets need `datasources.NewBuckets,`
+
+11.  create acceptance tests for both datasources in acceptance_tests/ with format <feature>_test.go.
+     for example if feature is Buckets then need buckets_test.go
+
+12.  acceptance tests should run in parallel.  that is use resource.ParallelTest()
+
+