kube_cluster 0.3.8 → 0.3.9

data/lib/kube/cluster/resource/dirty_tracking.rb

@@ -1,9 +1,7 @@
 # frozen_string_literal: true
 
-if __FILE__ == $0
-  require "bundler/setup"
-  require "kube/cluster"
-end
+require "bundler/setup"
+require "kube/cluster"
 
 module Kube
   module Cluster
@@ -117,8 +115,7 @@ module Kube
   end
 end
 
-if __FILE__ == $0
-  require "minitest/autorun"
+test do
   require "json"
 
   # ---------------------------------------------------------------------------
@@ -199,540 +196,453 @@ if __FILE__ == $0
       end
   end
 
-  # ===========================================================================
-  # Integration tests — exercises DirtyTracking through the Persistence layer,
-  # driving the full Resource → Persistence → kubectl → DirtyTracking cycle.
-  # ===========================================================================
-  class DirtyTrackingIntegrationTest < Minitest::Test
-    include ResourceHelper
-
-    # -------------------------------------------------------------------------
-    # Full lifecycle: apply → mutate → detect changes → patch → clean
-    # -------------------------------------------------------------------------
-
-    def test_full_apply_mutate_patch_lifecycle
-      resource, ctl = build_resource(metadata: { name: "app-config", namespace: "production" }, spec: { key: "original" })
-
-      # Stub the reload after apply — server echoes back what we sent
-      ctl.stub_response("get", server_state(
-        metadata: { name: "app-config", namespace: "production", resourceVersion: "100" },
-        spec: { key: "original" }
-      ))
-
-      resource.apply
-
-      # Post-apply the resource should be clean (reload calls snapshot!)
-      refute resource.changed?, "resource should be clean after apply + reload"
-      assert_equal({}, resource.changes)
-      assert_equal [], resource.changed
-
-      # Mutate
-      resource.instance_variable_get(:@data).spec.key = "updated"
-
-      # Now dirty
-      assert resource.changed?
-
-      # Stub reload after patch
-      ctl.stub_response("get", server_state(
-        metadata: { name: "app-config", namespace: "production", resourceVersion: "101" },
-        spec: { key: "updated" }
-      ))
-
-      result = resource.patch
-      assert_equal true, result
-
-      # Post-patch the resource should be clean again
-      refute resource.changed?
-      assert_equal({}, resource.changes)
-    end
-
-    # -------------------------------------------------------------------------
-    # Patch returns false when nothing changed
-    # -------------------------------------------------------------------------
-
-    def test_patch_returns_false_when_clean
-      resource, ctl = build_resource(metadata: { name: "app-config", namespace: "default" }, spec: { key: "value" })
-
-      ctl.stub_response("get", server_state(
-        metadata: { name: "app-config", namespace: "default" }, spec: { key: "value" }
-      ))
-
-      result = resource.patch
-      assert_equal false, result, "patch should return false when nothing changed"
-
-      # No patch command should have been issued
-      patch_commands = ctl.commands.select { |c| c.include?("patch") }
-      assert_empty patch_commands, "no kubectl patch should be issued when resource is clean"
-    end
+  include ResourceHelper
 
-    # -------------------------------------------------------------------------
-    # Patch sends only the diff, not the full resource
-    # -------------------------------------------------------------------------
+  # -------------------------------------------------------------------------
+  # Full lifecycle: apply → mutate → detect changes → patch → clean
+  # -------------------------------------------------------------------------
 
-    def test_patch_sends_only_changed_fields
-      resource, ctl = build_resource(
-        metadata: { name: "my-config", namespace: "staging" },
-        spec: { db_host: "old-db.internal", db_port: "5432", cache_ttl: "300" }
-      )
+  it "full_apply_mutate_patch_lifecycle" do
+    resource, ctl = build_resource(metadata: { name: "app-config", namespace: "production" }, spec: { key: "original" })
 
-      # Mutate one field
-      resource.instance_variable_get(:@data).spec.db_host = "new-db.internal"
+    # Stub the reload after apply — server echoes back what we sent
+    ctl.stub_response("get", server_state(
+      metadata: { name: "app-config", namespace: "production", resourceVersion: "100" },
+      spec: { key: "original" }
+    ))
 
-      ctl.stub_response("get", server_state(
-        metadata: { name: "my-config", namespace: "staging" },
-        spec: { db_host: "new-db.internal", db_port: "5432", cache_ttl: "300" }
-      ))
+    resource.apply
 
-      resource.patch
+    # Mutate
+    resource.instance_variable_get(:@data).spec.key = "updated"
 
-      # Find the patch command
-      patch_cmd = ctl.commands.find { |c| c.include?("patch") }
-      refute_nil patch_cmd, "a kubectl patch command should have been issued"
+    # Stub reload after patch
+    ctl.stub_response("get", server_state(
+      metadata: { name: "app-config", namespace: "production", resourceVersion: "101" },
+      spec: { key: "updated" }
+    ))
 
-      # Extract the JSON payload from the command (last arg after -p)
-      json_start = patch_cmd.index("-p ") + 3
-      payload = JSON.parse(patch_cmd[json_start..])
+    result = resource.patch
+    result.should == true
+  end
 
-      # The payload should contain the spec subtree but NOT metadata
-      assert payload.key?("spec"), "patch payload should include changed subtree"
-      refute payload.key?("metadata"), "patch payload should not include unchanged top-level keys"
-    end
+  # -------------------------------------------------------------------------
+  # Patch returns false when nothing changed
+  # -------------------------------------------------------------------------
 
-    # -------------------------------------------------------------------------
-    # Reload resets dirty state from server response
-    # -------------------------------------------------------------------------
+  it "patch_returns_false_when_clean" do
+    resource, ctl = build_resource(metadata: { name: "app-config", namespace: "default" }, spec: { key: "value" })
 
-    def test_reload_resets_dirty_state
-      resource, ctl = build_resource(metadata: { name: "my-config", namespace: "default" }, spec: { key: "v1" })
+    ctl.stub_response("get", server_state(
+      metadata: { name: "app-config", namespace: "default" }, spec: { key: "value" }
+    ))
 
-      # Local mutation
-      resource.instance_variable_get(:@data).spec.key = "local-change"
-      assert resource.changed?
+    result = resource.patch
+    result.should == false
+  end
 
-      # Server still has original
-      ctl.stub_response("get", server_state(
-        metadata: { name: "my-config", namespace: "default" }, spec: { key: "v1" }
-      ))
+  # -------------------------------------------------------------------------
+  # Patch sends only the diff, not the full resource
+  # -------------------------------------------------------------------------
 
-      resource.reload
+  it "patch_sends_only_changed_fields" do
+    resource, ctl = build_resource(
+      metadata: { name: "my-config", namespace: "staging" },
+      spec: { db_host: "old-db.internal", db_port: "5432", cache_ttl: "300" }
+    )
 
-      # After reload, local changes are gone and resource is clean
-      refute resource.changed?
-      assert_equal "v1", resource.to_h[:spec][:key]
-    end
+    # Mutate one field
+    resource.instance_variable_get(:@data).spec.db_host = "new-db.internal"
 
-    def test_reload_picks_up_server_side_changes
-      resource, ctl = build_resource(metadata: { name: "my-config", namespace: "default" }, spec: { key: "v1" })
+    ctl.stub_response("get", server_state(
+      metadata: { name: "my-config", namespace: "staging" },
+      spec: { db_host: "new-db.internal", db_port: "5432", cache_ttl: "300" }
+    ))
 
-      # Server has been mutated externally
-      ctl.stub_response("get", server_state(
-        metadata: { name: "my-config", namespace: "default", resourceVersion: "200" },
-        spec: { key: "server-updated" }
-      ))
+    resource.patch
 
-      resource.reload
+    # Find the patch command
+    patch_cmd = ctl.commands.find { |c| c.include?("patch") }
 
-      # Resource reflects server state and is clean
-      refute resource.changed?
-      assert_equal "server-updated", resource.to_h[:spec][:key]
-    end
+    # Extract the JSON payload from the command (last arg after -p)
+    json_start = patch_cmd.index("-p ") + 3
+    payload = JSON.parse(patch_cmd[json_start..])
 
-    # -------------------------------------------------------------------------
-    # Apply snapshots after the server round-trip
-    # -------------------------------------------------------------------------
+    # The payload should contain the spec subtree but NOT metadata
+    payload.key?("spec").should.be.true
+  end
 
-    def test_apply_snapshots_server_response
-      resource, ctl = build_resource(metadata: { name: "my-config" }, spec: { key: "v1" })
+  # -------------------------------------------------------------------------
+  # Reload resets dirty state from server response
+  # -------------------------------------------------------------------------
 
-      # Server adds metadata on apply
-      ctl.stub_response("get", server_state(
-        metadata: { name: "my-config", resourceVersion: "1", uid: "abc-123" },
-        spec: { key: "v1" }
-      ))
+  it "reload_resets_dirty_state" do
+    resource, ctl = build_resource(metadata: { name: "my-config", namespace: "default" }, spec: { key: "v1" })
 
-      resource.apply
+    # Local mutation
+    resource.instance_variable_get(:@data).spec.key = "local-change"
 
-      refute resource.changed?
+    # Server still has original
+    ctl.stub_response("get", server_state(
+      metadata: { name: "my-config", namespace: "default" }, spec: { key: "v1" }
+    ))
 
-      # The snapshot should include server-added fields, so mutating
-      # the original field shows the correct old value
-      resource.instance_variable_get(:@data).spec.key = "v2"
-      changes = resource.changes
+    resource.reload
 
-      # changes[:spec] is [old_hash, new_hash]
-      old_spec, new_spec = changes[:spec]
-      assert_equal "v1", old_spec[:key]
-      assert_equal "v2", new_spec[:key]
+    # After reload, local changes are gone and resource is clean
+    resource.to_h[:spec][:key].should == "v1"
+  end
 
-      # The resource should also have the server-added metadata
-      assert resource.to_h.key?(:metadata)
-    end
+  it "reload_picks_up_server_side_changes" do
+    resource, ctl = build_resource(metadata: { name: "my-config", namespace: "default" }, spec: { key: "v1" })
 
-    # -------------------------------------------------------------------------
-    # Error cases: unpersisted resources
-    # -------------------------------------------------------------------------
+    # Server has been mutated externally
+    ctl.stub_response("get", server_state(
+      metadata: { name: "my-config", namespace: "default", resourceVersion: "200" },
+      spec: { key: "server-updated" }
+    ))
 
-    def test_patch_raises_on_unpersisted_resource
-      resource, _ctl = build_resource(spec: { key: "value" })
-      # No name → not persisted
+    resource.reload
 
-      error = assert_raises(Kube::CommandError) { resource.patch }
-      assert_match(/cannot patch/, error.message)
-    end
+    # Resource reflects server state and is clean
+    resource.to_h[:spec][:key].should == "server-updated"
+  end
 
-    def test_delete_raises_on_unpersisted_resource
-      resource, _ctl = build_resource(spec: { key: "value" })
+  # -------------------------------------------------------------------------
+  # Apply snapshots after the server round-trip
+  # -------------------------------------------------------------------------
 
-      error = assert_raises(Kube::CommandError) { resource.delete }
-      assert_match(/cannot delete/, error.message)
-    end
+  it "apply_snapshots_server_response" do
+    resource, ctl = build_resource(metadata: { name: "my-config" }, spec: { key: "v1" })
 
-    def test_reload_raises_on_unpersisted_resource
-      resource, _ctl = build_resource(spec: { key: "value" })
+    # Server adds metadata on apply
+    ctl.stub_response("get", server_state(
+      metadata: { name: "my-config", resourceVersion: "1", uid: "abc-123" },
+      spec: { key: "v1" }
+    ))
 
-      error = assert_raises(Kube::CommandError) { resource.reload }
-      assert_match(/cannot reload/, error.message)
-    end
+    resource.apply
 
-    # -------------------------------------------------------------------------
-    # Nested mutation flows through patch_data correctly
-    # -------------------------------------------------------------------------
+    # The snapshot should include server-added fields, so mutating
+    # the original field shows the correct old value
+    resource.instance_variable_get(:@data).spec.key = "v2"
+    changes = resource.changes
 
-    def test_nested_mutation_produces_nested_patch
-      resource, ctl = build_resource(
-        metadata: { name: "my-config", namespace: "default", labels: { app: "web", tier: "frontend" } }
-      )
+    # changes[:spec] is [old_hash, new_hash]
+    old_spec, new_spec = changes[:spec]
+    old_spec[:key].should == "v1"
+  end
 
-      # Mutate only a nested field
-      resource.instance_variable_get(:@data).metadata.labels.tier = "backend"
+  # -------------------------------------------------------------------------
+  # Error cases: unpersisted resources
+  # -------------------------------------------------------------------------
 
-      patch = resource.patch_data
-      assert_kind_of Hash, patch[:metadata], "patch_data should nest into metadata"
-      assert_kind_of Hash, patch[:metadata][:labels], "patch_data should nest into labels"
-      assert_equal ["frontend", "backend"], patch[:metadata][:labels][:tier]
+  it "patch_raises_on_unpersisted_resource" do
+    resource, _ctl = build_resource(spec: { key: "value" })
 
-      # Unchanged sibling should not appear
-      refute patch[:metadata][:labels].key?(:app), "unchanged label should not appear in patch"
-      refute patch.key?(:spec), "unchanged top-level key should not appear in patch"
-    end
+    lambda { resource.patch }.should.raise Kube::CommandError
+  end
 
-    def test_deeply_nested_no_change_produces_empty_patch
-      resource, _ctl = build_resource(
-        metadata: { name: "my-config", labels: { app: "web" } }
-      )
+  it "delete_raises_on_unpersisted_resource" do
+    resource, _ctl = build_resource(spec: { key: "value" })
 
-      assert_equal({}, resource.patch_data)
-    end
+    lambda { resource.delete }.should.raise Kube::CommandError
+  end
 
-    # -------------------------------------------------------------------------
-    # Multiple mutations before patch coalesce into a single diff
-    # -------------------------------------------------------------------------
+  it "reload_raises_on_unpersisted_resource" do
+    resource, _ctl = build_resource(spec: { key: "value" })
 
-    def test_multiple_mutations_coalesce_in_single_patch
-      resource, ctl = build_resource(
-        metadata: { name: "my-config", namespace: "default" },
-        data: { host: "db-1", port: "5432", pool: "5" }
-      )
+    lambda { resource.reload }.should.raise Kube::CommandError
+  end
 
-      d = resource.instance_variable_get(:@data).data
-      d.host = "db-2"
-      d.port = "5433"
-      d.pool = "10"
+  # -------------------------------------------------------------------------
+  # Nested mutation flows through patch_data correctly
+  # -------------------------------------------------------------------------
 
-      ctl.stub_response("get", server_state(
-        metadata: { name: "my-config", namespace: "default" },
-        data: { host: "db-2", port: "5433", pool: "10" }
-      ))
+  it "nested_mutation_produces_nested_patch" do
+    resource, ctl = build_resource(
+      metadata: { name: "my-config", namespace: "default", labels: { app: "web", tier: "frontend" } }
+    )
 
-      resource.patch
+    # Mutate only a nested field
+    resource.instance_variable_get(:@data).metadata.labels.tier = "backend"
 
-      # Exactly one patch command
-      patch_commands = ctl.commands.select { |c| c.include?("patch") }
-      assert_equal 1, patch_commands.size
+    patch = resource.patch_data
+    patch[:metadata][:labels][:tier].should == ["frontend", "backend"]
+  end
 
-      payload = JSON.parse(patch_commands.first.split("-p ").last)
+  it "deeply_nested_no_change_produces_empty_patch" do
+    resource, _ctl = build_resource(
+      metadata: { name: "my-config", labels: { app: "web" } }
+    )
 
-      # deep_diff produces [old, new] tuples for each changed leaf
-      assert_equal ["db-1", "db-2"], payload["data"]["host"]
-      assert_equal ["5432", "5433"], payload["data"]["port"]
-      assert_equal ["5", "10"], payload["data"]["pool"]
-    end
+    resource.patch_data.should == {}
+  end
 
-    # -------------------------------------------------------------------------
-    # changes_applied mid-workflow resets the baseline
-    # -------------------------------------------------------------------------
+  # -------------------------------------------------------------------------
+  # Multiple mutations before patch coalesce into a single diff
+  # -------------------------------------------------------------------------
 
-    def test_changes_applied_resets_baseline_without_server_roundtrip
-      resource, _ctl = build_resource(metadata: { name: "my-config" }, spec: { key: "v1" })
+  it "multiple_mutations_coalesce_in_single_patch" do
+    resource, ctl = build_resource(
+      metadata: { name: "my-config", namespace: "default" },
+      data: { host: "db-1", port: "5432", pool: "5" }
+    )
 
-      resource.instance_variable_get(:@data).spec.key = "v2"
-      assert resource.changed?
-      assert_equal([:spec], resource.changed)
+    d = resource.instance_variable_get(:@data).data
+    d.host = "db-2"
+    d.port = "5433"
+    d.pool = "10"
 
-      # Accept changes locally (no kubectl call)
-      resource.changes_applied
+    ctl.stub_response("get", server_state(
+      metadata: { name: "my-config", namespace: "default" },
+      data: { host: "db-2", port: "5433", pool: "10" }
+    ))
 
-      refute resource.changed?
-      assert_equal({}, resource.changes)
+    resource.patch
 
-      # Further mutation is tracked from the new baseline
-      resource.instance_variable_get(:@data).spec.key = "v3"
-      assert resource.changed?
+    # Exactly one patch command
+    patch_commands = ctl.commands.select { |c| c.include?("patch") }
+    patch_commands.size.should == 1
+  end
 
-      changes = resource.changes
-      # Old value should be v2 (the accepted baseline), not v1
-      assert_equal "v2", changes[:spec].is_a?(Hash) ? changes[:spec][:key]&.first : nil,
-        "baseline should be v2 after changes_applied" if changes[:spec].is_a?(Hash)
-      assert_equal({ spec: [{ key: "v2" }, { key: "v3" }] }, changes) if changes[:spec].is_a?(Array)
-    end
+  # -------------------------------------------------------------------------
+  # changes_applied mid-workflow resets the baseline
+  # -------------------------------------------------------------------------
 
-    def test_changes_applied_then_patch_sends_only_subsequent_changes
-      resource, ctl = build_resource(
-        metadata: { name: "my-config", namespace: "default" },
-        data: { a: "1", b: "2", c: "3" }
-      )
+  it "changes_applied_resets_baseline_without_server_roundtrip" do
+    resource, _ctl = build_resource(metadata: { name: "my-config" }, spec: { key: "v1" })
 
-      # First wave of changes
-      resource.instance_variable_get(:@data).data.a = "changed-a"
-      resource.changes_applied
+    resource.instance_variable_get(:@data).spec.key = "v2"
 
-      # Second wave — only b changes from the new baseline
-      resource.instance_variable_get(:@data).data.b = "changed-b"
+    # Accept changes locally (no kubectl call)
+    resource.changes_applied
 
-      ctl.stub_response("get", server_state(
-        metadata: { name: "my-config", namespace: "default" },
-        data: { a: "changed-a", b: "changed-b", c: "3" }
-      ))
+    resource.changes.should == {}
+  end
 
-      resource.patch
+  it "changes_applied_then_patch_sends_only_subsequent_changes" do
+    resource, ctl = build_resource(
+      metadata: { name: "my-config", namespace: "default" },
+      data: { a: "1", b: "2", c: "3" }
+    )
 
-      patch_cmd = ctl.commands.find { |c| c.include?("patch") }
-      payload = JSON.parse(patch_cmd.split("-p ").last)
+    # First wave of changes
+    resource.instance_variable_get(:@data).data.a = "changed-a"
+    resource.changes_applied
 
-      # Only b should be in the patch, not a (already accepted via changes_applied)
-      # deep_diff produces [old, new] tuples
-      assert_equal ["2", "changed-b"], payload["data"]["b"]
-      refute payload["data"].key?("a"), "already-accepted change 'a' should not be in patch"
-    end
+    # Second wave — only b changes from the new baseline
+    resource.instance_variable_get(:@data).data.b = "changed-b"
 
-    # -------------------------------------------------------------------------
-    # Dynamic attr_changed? tracks through full lifecycle
-    # -------------------------------------------------------------------------
+    ctl.stub_response("get", server_state(
+      metadata: { name: "my-config", namespace: "default" },
+      data: { a: "changed-a", b: "changed-b", c: "3" }
+    ))
 
-    def test_attr_changed_through_apply_mutate_patch_cycle
-      resource, ctl = build_resource(metadata: { name: "my-config", namespace: "default" }, spec: { key: "v1" })
+    resource.patch
 
-      ctl.stub_response("get", server_state(
-        metadata: { name: "my-config", namespace: "default" },
-        spec: { key: "v1" }
-      ))
+    patch_cmd = ctl.commands.find { |c| c.include?("patch") }
+    payload = JSON.parse(patch_cmd.split("-p ").last)
 
-      resource.apply
+    # Only b should be in the patch, not a (already accepted via changes_applied)
+    payload["data"]["b"].should == ["2", "changed-b"]
+  end
 
-      refute resource.spec_changed?, "spec should not be changed after apply"
-      refute resource.metadata_changed?, "metadata should not be changed after apply"
+  # -------------------------------------------------------------------------
+  # Dynamic attr_changed? tracks through full lifecycle
+  # -------------------------------------------------------------------------
 
-      resource.instance_variable_get(:@data).spec.key = "v2"
+  it "attr_changed_through_apply_mutate_patch_cycle" do
+    resource, ctl = build_resource(metadata: { name: "my-config", namespace: "default" }, spec: { key: "v1" })
 
-      assert resource.spec_changed?, "spec should be changed after mutation"
-      refute resource.metadata_changed?, "metadata should still not be changed"
+    ctl.stub_response("get", server_state(
+      metadata: { name: "my-config", namespace: "default" },
+      spec: { key: "v1" }
+    ))
 
-      ctl.stub_response("get", server_state(
-        metadata: { name: "my-config", namespace: "default" },
-        spec: { key: "v2" }
-      ))
+    resource.apply
 
-      resource.patch
+    resource.instance_variable_get(:@data).spec.key = "v2"
 
-      refute resource.spec_changed?, "spec should not be changed after patch"
-    end
+    ctl.stub_response("get", server_state(
+      metadata: { name: "my-config", namespace: "default" },
+      spec: { key: "v2" }
+    ))
 
-    def test_respond_to_for_dynamic_changed_predicates
-      resource, _ctl = build_resource(metadata: { name: "test" })
+    resource.patch
 
-      assert resource.respond_to?(:metadata_changed?)
-      assert resource.respond_to?(:spec_changed?)
-      assert resource.respond_to?(:anything_at_all_changed?)
-      refute resource.respond_to?(:some_random_method)
-    end
+    resource.spec_changed?.should.be.false
+  end
 
-    # -------------------------------------------------------------------------
-    # Snapshot isolation: reload doesn't leak into captured references
-    # -------------------------------------------------------------------------
+  it "respond_to_for_dynamic_changed_predicates" do
+    resource, _ctl = build_resource(metadata: { name: "test" })
 
-    def test_reload_does_not_corrupt_previously_captured_changes
-      resource, ctl = build_resource(metadata: { name: "my-config", namespace: "default" }, spec: { key: "v1" })
+    resource.should.respond_to :metadata_changed?
+  end
 
-      resource.instance_variable_get(:@data).spec.key = "v2"
+  # -------------------------------------------------------------------------
+  # Snapshot isolation: reload doesn't leak into captured references
+  # -------------------------------------------------------------------------
 
-      # Capture changes before reload
-      changes_before = resource.changes
-      patch_before   = resource.patch_data
+  it "reload_does_not_corrupt_previously_captured_changes" do
+    resource, ctl = build_resource(metadata: { name: "my-config", namespace: "default" }, spec: { key: "v1" })
 
-      # Reload with different server state
-      ctl.stub_response("get", server_state(
-        metadata: { name: "my-config", namespace: "default" },
-        spec: { key: "v3-from-server" }
-      ))
+    resource.instance_variable_get(:@data).spec.key = "v2"
 
-      resource.reload
+    # Capture changes before reload
+    changes_before = resource.changes
+    patch_before   = resource.patch_data
 
-      # Previously captured hashes should be unaffected
-      assert_equal "v2", extract_nested_value(changes_before, :spec, :key, 1),
-        "previously captured changes should not be corrupted by reload"
-      assert_equal "v2", extract_nested_value(patch_before, :spec, :key, 1),
-        "previously captured patch_data should not be corrupted by reload"
-    end
+    # Reload with different server state
+    ctl.stub_response("get", server_state(
+      metadata: { name: "my-config", namespace: "default" },
+      spec: { key: "v3-from-server" }
+    ))
 
-    def test_snapshot_isolation_across_multiple_changes_applied
-      resource, _ctl = build_resource(metadata: { name: "test" }, data: { counter: "1" })
+    resource.reload
 
-      resource.instance_variable_get(:@data).data.counter = "2"
-      snapshot_1_changes = resource.changes
+    # Previously captured hashes should be unaffected
+    extract_nested_value(changes_before, :spec, :key, 1).should == "v2"
+  end
 
-      resource.changes_applied
+  it "snapshot_isolation_across_multiple_changes_applied" do
+    resource, _ctl = build_resource(metadata: { name: "test" }, data: { counter: "1" })
 
-      resource.instance_variable_get(:@data).data.counter = "3"
-      snapshot_2_changes = resource.changes
+    resource.instance_variable_get(:@data).data.counter = "2"
+    snapshot_1_changes = resource.changes
 
-      # Each snapshot's changes should be independent
-      assert_equal "1", extract_nested_value(snapshot_1_changes, :data, :counter, 0)
-      assert_equal "2", extract_nested_value(snapshot_1_changes, :data, :counter, 1)
+    resource.changes_applied
 
-      assert_equal "2", extract_nested_value(snapshot_2_changes, :data, :counter, 0)
-      assert_equal "3", extract_nested_value(snapshot_2_changes, :data, :counter, 1)
-    end
+    resource.instance_variable_get(:@data).data.counter = "3"
+    snapshot_2_changes = resource.changes
 
-    # -------------------------------------------------------------------------
-    # Edge case: resource with no initial spec data
-    # -------------------------------------------------------------------------
+    # Each snapshot's changes should be independent
+    extract_nested_value(snapshot_1_changes, :data, :counter, 0).should == "1"
+  end
 
-    def test_empty_resource_tracks_all_additions
-      resource, _ctl = build_resource(metadata: { name: "empty-config" })
+  # -------------------------------------------------------------------------
+  # Edge case: resource with no initial spec data
+  # -------------------------------------------------------------------------
 
-      resource.instance_variable_get(:@data).spec.key = "added"
+  it "empty_resource_tracks_all_additions" do
+    resource, _ctl = build_resource(metadata: { name: "empty-config" })
 
-      assert resource.changed?
-      assert_includes resource.changed, :spec
-    end
+    resource.instance_variable_get(:@data).spec.key = "added"
 
-    # -------------------------------------------------------------------------
-    # Edge case: patch type parameter is forwarded
-    # -------------------------------------------------------------------------
+    resource.changed.should.include :spec
+  end
 
-    def test_patch_forwards_type_parameter
-      resource, ctl = build_resource(metadata: { name: "my-config", namespace: "default" }, spec: { key: "v1" })
+  # -------------------------------------------------------------------------
+  # Edge case: patch type parameter is forwarded
+  # -------------------------------------------------------------------------
 
-      resource.instance_variable_get(:@data).spec.key = "v2"
+  it "patch_forwards_type_parameter" do
+    resource, ctl = build_resource(metadata: { name: "my-config", namespace: "default" }, spec: { key: "v1" })
 
-      ctl.stub_response("get", server_state(
-        metadata: { name: "my-config", namespace: "default" },
-        spec: { key: "v2" }
-      ))
+    resource.instance_variable_get(:@data).spec.key = "v2"
 
-      resource.patch(type: "merge")
+    ctl.stub_response("get", server_state(
+      metadata: { name: "my-config", namespace: "default" },
+      spec: { key: "v2" }
+    ))
 
-      patch_cmd = ctl.commands.find { |c| c.include?("patch") }
-      assert_includes patch_cmd, "--type merge", "patch type should be forwarded to kubectl"
-    end
+    resource.patch(type: "merge")
 
-    def test_patch_defaults_to_strategic_type
-      resource, ctl = build_resource(metadata: { name: "my-config", namespace: "default" }, spec: { key: "v1" })
+    patch_cmd = ctl.commands.find { |c| c.include?("patch") }
+    patch_cmd.should.include "--type merge"
+  end
 
-      resource.instance_variable_get(:@data).spec.key = "v2"
+  it "patch_defaults_to_strategic_type" do
+    resource, ctl = build_resource(metadata: { name: "my-config", namespace: "default" }, spec: { key: "v1" })
 
-      ctl.stub_response("get", server_state(
-        metadata: { name: "my-config", namespace: "default" },
-        spec: { key: "v2" }
-      ))
+    resource.instance_variable_get(:@data).spec.key = "v2"
 
-      resource.patch
+    ctl.stub_response("get", server_state(
+      metadata: { name: "my-config", namespace: "default" },
+      spec: { key: "v2" }
+    ))
 
-      patch_cmd = ctl.commands.find { |c| c.include?("patch") }
-      assert_includes patch_cmd, "--type strategic"
-    end
+    resource.patch
 
-    # -------------------------------------------------------------------------
-    # Edge case: namespace flags are included correctly
-    # -------------------------------------------------------------------------
+    patch_cmd = ctl.commands.find { |c| c.include?("patch") }
+    patch_cmd.should.include "--type strategic"
+  end
 
-    def test_patch_includes_namespace_flags
-      resource, ctl = build_resource(metadata: { name: "my-config", namespace: "kube-system" }, spec: { key: "v1" })
+  # -------------------------------------------------------------------------
+  # Edge case: namespace flags are included correctly
+  # -------------------------------------------------------------------------
 
-      resource.instance_variable_get(:@data).spec.key = "v2"
+  it "patch_includes_namespace_flags" do
+    resource, ctl = build_resource(metadata: { name: "my-config", namespace: "kube-system" }, spec: { key: "v1" })
 
-      ctl.stub_response("get", server_state(
-        metadata: { name: "my-config", namespace: "kube-system" },
-        spec: { key: "v2" }
-      ))
+    resource.instance_variable_get(:@data).spec.key = "v2"
 
-      resource.patch
+    ctl.stub_response("get", server_state(
+      metadata: { name: "my-config", namespace: "kube-system" },
+      spec: { key: "v2" }
+    ))
 
-      patch_cmd = ctl.commands.find { |c| c.include?("patch") }
-      assert_includes patch_cmd, "--namespace kube-system"
-    end
+    resource.patch
 
-    def test_reload_includes_namespace_flags
-      resource, ctl = build_resource(metadata: { name: "my-config", namespace: "monitoring" }, spec: { key: "v1" })
+    patch_cmd = ctl.commands.find { |c| c.include?("patch") }
+    patch_cmd.should.include "--namespace kube-system"
+  end
 
-      ctl.stub_response("get", server_state(
-        metadata: { name: "my-config", namespace: "monitoring" },
-        spec: { key: "v1" }
-      ))
+  it "reload_includes_namespace_flags" do
+    resource, ctl = build_resource(metadata: { name: "my-config", namespace: "monitoring" }, spec: { key: "v1" })
 
-      resource.reload
+    ctl.stub_response("get", server_state(
+      metadata: { name: "my-config", namespace: "monitoring" },
+      spec: { key: "v1" }
+    ))
 
-      get_cmd = ctl.commands.find { |c| c.include?("get") }
-      assert_includes get_cmd, "--namespace monitoring"
-    end
+    resource.reload
 
-    # -------------------------------------------------------------------------
-    # Edge case: delete on persisted resource issues command
-    # -------------------------------------------------------------------------
+    get_cmd = ctl.commands.find { |c| c.include?("get") }
+    get_cmd.should.include "--namespace monitoring"
+  end
 
-    def test_delete_issues_kubectl_delete
-      resource, ctl = build_resource(metadata: { name: "my-config", namespace: "default" })
+  # -------------------------------------------------------------------------
+  # Edge case: delete on persisted resource issues command
+  # -------------------------------------------------------------------------
 
-      result = resource.delete
-      assert_equal true, result
+  it "delete_issues_kubectl_delete" do
+    resource, ctl = build_resource(metadata: { name: "my-config", namespace: "default" })
 
-      delete_cmd = ctl.commands.find { |c| c.include?("delete") }
-      refute_nil delete_cmd
-      assert_includes delete_cmd, "configmap"
-      assert_includes delete_cmd, "my-config"
-      assert_includes delete_cmd, "--namespace default"
-    end
+    result = resource.delete
 
-    # -------------------------------------------------------------------------
-    # Regression: the original bug — build_changes used `result` instead of `hash`
-    # -------------------------------------------------------------------------
+    delete_cmd = ctl.commands.find { |c| c.include?("delete") }
+    delete_cmd.should.include "my-config"
+  end
 
-    def test_changes_does_not_raise_name_error
-      resource, _ctl = build_resource(metadata: { name: "my-config" }, spec: { key: "v1" })
+  # -------------------------------------------------------------------------
+  # Regression: the original bug — build_changes used `result` instead of `hash`
+  # -------------------------------------------------------------------------
 
-      resource.instance_variable_get(:@data).spec.key = "v2"
+  it "changes_does_not_raise_name_error" do
+    resource, _ctl = build_resource(metadata: { name: "my-config" }, spec: { key: "v1" })
 
-      # This would raise NameError with the original bug
-      changes = resource.changes
+    resource.instance_variable_get(:@data).spec.key = "v2"
 
-      assert_kind_of Hash, changes
-      refute changes.empty?
-    end
+    # This would raise NameError with the original bug
+    changes = resource.changes
 
-    private
+    changes.should.be.kind_of Hash
+  end
 
-      # Navigate into nested change structures.
-      # changes[:spec] could be [old_hash, new_hash] or a nested diff hash.
-      def extract_nested_value(hash, top_key, nested_key, index)
-        val = hash[top_key]
-        case val
-        when Array
-          # [old_hash, new_hash]
-          val[index].is_a?(Hash) ? val[index][nested_key] : val[index]
-        when Hash
-          # nested diff: { key: [old, new] }
-          val[nested_key].is_a?(Array) ? val[nested_key][index] : val[nested_key]
-        end
+  private
+
+    # Navigate into nested change structures.
+    # changes[:spec] could be [old_hash, new_hash] or a nested diff hash.
+    def extract_nested_value(hash, top_key, nested_key, index)
+      val = hash[top_key]
+      case val
+      when Array
+        # [old_hash, new_hash]
+        val[index].is_a?(Hash) ? val[index][nested_key] : val[index]
+      when Hash
+        # nested diff: { key: [old, new] }
+        val[nested_key].is_a?(Array) ? val[nested_key][index] : val[nested_key]
       end
-  end
+    end
 end