kube_cluster 0.20.1 → 1.0.0

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

@@ -115,534 +115,534 @@ module Kube
   end
 end
 
-test do
-  require "json"
-
-  # ---------------------------------------------------------------------------
-  # Fake ctl that records every command and returns canned responses.
-  # The test wires this into the cluster → connection → ctl chain so that
-  # Persistence#kubectl goes through it without touching a real cluster.
-  # ---------------------------------------------------------------------------
-  class FakeCtl
-    attr_reader :commands
-
-    def initialize
-      @commands  = []
-      @responses = {}
-    end
+__END__
 
-    # Queue a response for the next command that includes +substring+.
-    def stub_response(substring, response)
-      @responses[substring] = response
-    end
+require "json"
 
-    def run(string)
-      @commands << string
+# ---------------------------------------------------------------------------
+# Fake ctl that records every command and returns canned responses.
+# The test wires this into the cluster → connection → ctl chain so that
+# Persistence#kubectl goes through it without touching a real cluster.
+# ---------------------------------------------------------------------------
+class FakeCtl
+  attr_reader :commands
 
-      @responses.each do |substring, response|
-        if string.include?(substring)
-          return response
-        end
-      end
+  def initialize
+    @commands  = []
+    @responses = {}
+  end
 
-      "" # default: empty response
-    end
+  # Queue a response for the next command that includes +substring+.
+  def stub_response(substring, response)
+    @responses[substring] = response
   end
 
-  # ---------------------------------------------------------------------------
-  # Minimal cluster double that provides .connection.ctl
-  # ---------------------------------------------------------------------------
-  class FakeConnection
-    attr_reader :ctl
+  def run(string)
+    @commands << string
 
-    def initialize(ctl)
-      @ctl = ctl
+    @responses.each do |substring, response|
+      if string.include?(substring)
+        return response
+      end
     end
+
+    "" # default: empty response
   end
+end
 
-  class FakeCluster
-    attr_reader :connection
+# ---------------------------------------------------------------------------
+# Minimal cluster double that provides .connection.ctl
+# ---------------------------------------------------------------------------
+class FakeConnection
+  attr_reader :ctl
 
-    def initialize(ctl)
-      @connection = FakeConnection.new(ctl)
-    end
+  def initialize(ctl)
+    @ctl = ctl
   end
+end
 
-  # ---------------------------------------------------------------------------
-  # Helper to build a resource wired to a fake cluster.
-  # ---------------------------------------------------------------------------
-  module ResourceHelper
-    def build_resource(hash = {})
-      ctl     = FakeCtl.new
-      cluster = FakeCluster.new(ctl)
-      resource = Kube::Cluster["ConfigMap"].new(hash.merge(kind: "ConfigMap", cluster: cluster))
-      [resource, ctl]
-    end
+class FakeCluster
+  attr_reader :connection
 
-    # Simulate what kubectl returns: the server adds extra fields.
-    def server_state(resource_hash, extra = {})
-      merged = resource_hash.merge(extra)
-      JSON.generate(stringify_keys(merged))
-    end
+  def initialize(ctl)
+    @connection = FakeConnection.new(ctl)
+  end
+end
 
-    private
+# ---------------------------------------------------------------------------
+# Helper to build a resource wired to a fake cluster.
+# ---------------------------------------------------------------------------
+module ResourceHelper
+  def build_resource(hash = {})
+    ctl     = FakeCtl.new
+    cluster = FakeCluster.new(ctl)
+    resource = Kube::Cluster["ConfigMap"].new(hash.merge(kind: "ConfigMap", cluster: cluster))
+    [resource, ctl]
+  end
 
-      def stringify_keys(obj)
-        case obj
-        when Hash  then obj.each_with_object({}) { |(k, v), h| h[k.to_s] = stringify_keys(v) }
-        when Array then obj.map { |v| stringify_keys(v) }
-        else obj
-        end
-      end
+  # Simulate what kubectl returns: the server adds extra fields.
+  def server_state(resource_hash, extra = {})
+    merged = resource_hash.merge(extra)
+    JSON.generate(stringify_keys(merged))
   end
 
-  include ResourceHelper
+  private
 
-  # -------------------------------------------------------------------------
-  # Full lifecycle: apply → mutate → detect changes → patch → clean
-  # -------------------------------------------------------------------------
+    def stringify_keys(obj)
+      case obj
+      when Hash  then obj.each_with_object({}) { |(k, v), h| h[k.to_s] = stringify_keys(v) }
+      when Array then obj.map { |v| stringify_keys(v) }
+      else obj
+      end
+    end
+end
 
-  it "full_apply_mutate_patch_lifecycle" do
-    resource, ctl = build_resource(metadata: { name: "app-config", namespace: "production" }, spec: { key: "original" })
+include ResourceHelper
 
-    # 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" }
-    ))
+# -------------------------------------------------------------------------
+# Full lifecycle: apply → mutate → detect changes → patch → clean
+# -------------------------------------------------------------------------
 
-    resource.apply
+it "full_apply_mutate_patch_lifecycle" do
+  resource, ctl = build_resource(metadata: { name: "app-config", namespace: "production" }, spec: { key: "original" })
 
-    # Mutate
-    resource.instance_variable_get(:@data).spec.key = "updated"
+  # 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" }
+  ))
 
-    # Stub reload after patch
-    ctl.stub_response("get", server_state(
-      metadata: { name: "app-config", namespace: "production", resourceVersion: "101" },
-      spec: { key: "updated" }
-    ))
+  resource.apply
 
-    result = resource.patch
-    result.should == true
-  end
+  # Mutate
+  resource.instance_variable_get(:@data).spec.key = "updated"
 
-  # -------------------------------------------------------------------------
-  # Patch returns false when nothing changed
-  # -------------------------------------------------------------------------
+  # Stub reload after patch
+  ctl.stub_response("get", server_state(
+    metadata: { name: "app-config", namespace: "production", resourceVersion: "101" },
+    spec: { key: "updated" }
+  ))
 
-  it "patch_returns_false_when_clean" do
-    resource, ctl = build_resource(metadata: { name: "app-config", namespace: "default" }, spec: { key: "value" })
+  result = resource.patch
+  result.should == true
+end
 
-    ctl.stub_response("get", server_state(
-      metadata: { name: "app-config", namespace: "default" }, spec: { key: "value" }
-    ))
+# -------------------------------------------------------------------------
+# Patch returns false when nothing changed
+# -------------------------------------------------------------------------
 
-    result = resource.patch
-    result.should == false
-  end
+it "patch_returns_false_when_clean" do
+  resource, ctl = build_resource(metadata: { name: "app-config", namespace: "default" }, spec: { key: "value" })
 
-  # -------------------------------------------------------------------------
-  # Patch sends only the diff, not the full resource
-  # -------------------------------------------------------------------------
+  ctl.stub_response("get", server_state(
+    metadata: { name: "app-config", namespace: "default" }, spec: { key: "value" }
+  ))
 
-  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" }
-    )
+  result = resource.patch
+  result.should == false
+end
 
-    # Mutate one field
-    resource.instance_variable_get(:@data).spec.db_host = "new-db.internal"
+# -------------------------------------------------------------------------
+# Patch sends only the diff, not the full resource
+# -------------------------------------------------------------------------
 
-    ctl.stub_response("get", server_state(
-      metadata: { name: "my-config", namespace: "staging" },
-      spec: { db_host: "new-db.internal", db_port: "5432", cache_ttl: "300" }
-    ))
+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" }
+  )
 
-    resource.patch
+  # Mutate one field
+  resource.instance_variable_get(:@data).spec.db_host = "new-db.internal"
 
-    # Find the patch command
-    patch_cmd = ctl.commands.find { |c| c.include?("patch") }
+  ctl.stub_response("get", server_state(
+    metadata: { name: "my-config", namespace: "staging" },
+    spec: { db_host: "new-db.internal", db_port: "5432", cache_ttl: "300" }
+  ))
 
-    # 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..])
+  resource.patch
 
-    # The payload should contain the spec subtree but NOT metadata
-    payload.key?("spec").should.be.true
-  end
+  # Find the patch command
+  patch_cmd = ctl.commands.find { |c| c.include?("patch") }
 
-  # -------------------------------------------------------------------------
-  # Reload resets dirty state from server response
-  # -------------------------------------------------------------------------
+  # 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..])
 
-  it "reload_resets_dirty_state" do
-    resource, ctl = build_resource(metadata: { name: "my-config", namespace: "default" }, spec: { key: "v1" })
+  # The payload should contain the spec subtree but NOT metadata
+  payload.key?("spec").should.be.true
+end
 
-    # Local mutation
-    resource.instance_variable_get(:@data).spec.key = "local-change"
+# -------------------------------------------------------------------------
+# Reload resets dirty state from server response
+# -------------------------------------------------------------------------
 
-    # Server still has original
-    ctl.stub_response("get", server_state(
-      metadata: { name: "my-config", namespace: "default" }, spec: { key: "v1" }
-    ))
+it "reload_resets_dirty_state" do
+  resource, ctl = build_resource(metadata: { name: "my-config", namespace: "default" }, spec: { key: "v1" })
 
-    resource.reload
+  # Local mutation
+  resource.instance_variable_get(:@data).spec.key = "local-change"
 
-    # After reload, local changes are gone and resource is clean
-    resource.to_h[:spec][:key].should == "v1"
-  end
+  # Server still has original
+  ctl.stub_response("get", server_state(
+    metadata: { name: "my-config", namespace: "default" }, spec: { key: "v1" }
+  ))
 
-  it "reload_picks_up_server_side_changes" do
-    resource, ctl = build_resource(metadata: { name: "my-config", namespace: "default" }, spec: { key: "v1" })
+  resource.reload
 
-    # Server has been mutated externally
-    ctl.stub_response("get", server_state(
-      metadata: { name: "my-config", namespace: "default", resourceVersion: "200" },
-      spec: { key: "server-updated" }
-    ))
+  # After reload, local changes are gone and resource is clean
+  resource.to_h[:spec][:key].should == "v1"
+end
 
-    resource.reload
+it "reload_picks_up_server_side_changes" do
+  resource, ctl = build_resource(metadata: { name: "my-config", namespace: "default" }, spec: { key: "v1" })
 
-    # Resource reflects server state and is clean
-    resource.to_h[:spec][:key].should == "server-updated"
-  end
+  # Server has been mutated externally
+  ctl.stub_response("get", server_state(
+    metadata: { name: "my-config", namespace: "default", resourceVersion: "200" },
+    spec: { key: "server-updated" }
+  ))
 
-  # -------------------------------------------------------------------------
-  # Apply snapshots after the server round-trip
-  # -------------------------------------------------------------------------
+  resource.reload
 
-  it "apply_snapshots_server_response" do
-    resource, ctl = build_resource(metadata: { name: "my-config" }, spec: { key: "v1" })
+  # Resource reflects server state and is clean
+  resource.to_h[:spec][:key].should == "server-updated"
+end
 
-    # Server adds metadata on apply
-    ctl.stub_response("get", server_state(
-      metadata: { name: "my-config", resourceVersion: "1", uid: "abc-123" },
-      spec: { key: "v1" }
-    ))
+# -------------------------------------------------------------------------
+# Apply snapshots after the server round-trip
+# -------------------------------------------------------------------------
 
-    resource.apply
+it "apply_snapshots_server_response" do
+  resource, ctl = build_resource(metadata: { name: "my-config" }, 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
+  # Server adds metadata on apply
+  ctl.stub_response("get", server_state(
+    metadata: { name: "my-config", resourceVersion: "1", uid: "abc-123" },
+    spec: { key: "v1" }
+  ))
 
-    # changes[:spec] is [old_hash, new_hash]
-    old_spec, new_spec = changes[:spec]
-    old_spec[:key].should == "v1"
-  end
+  resource.apply
 
-  # -------------------------------------------------------------------------
-  # Error cases: unpersisted resources
-  # -------------------------------------------------------------------------
+  # 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
 
-  it "patch_raises_on_unpersisted_resource" do
-    resource, _ctl = build_resource(spec: { key: "value" })
+  # changes[:spec] is [old_hash, new_hash]
+  old_spec, new_spec = changes[:spec]
+  old_spec[:key].should == "v1"
+end
 
-    lambda { resource.patch }.should.raise Kube::CommandError
-  end
+# -------------------------------------------------------------------------
+# Error cases: unpersisted resources
+# -------------------------------------------------------------------------
 
-  it "delete_raises_on_unpersisted_resource" do
-    resource, _ctl = build_resource(spec: { key: "value" })
+it "patch_raises_on_unpersisted_resource" do
+  resource, _ctl = build_resource(spec: { key: "value" })
 
-    lambda { resource.delete }.should.raise Kube::CommandError
-  end
+  lambda { resource.patch }.should.raise Kube::CommandError
+end
 
-  it "reload_raises_on_unpersisted_resource" do
-    resource, _ctl = build_resource(spec: { key: "value" })
+it "delete_raises_on_unpersisted_resource" do
+  resource, _ctl = build_resource(spec: { key: "value" })
 
-    lambda { resource.reload }.should.raise Kube::CommandError
-  end
+  lambda { resource.delete }.should.raise Kube::CommandError
+end
 
-  # -------------------------------------------------------------------------
-  # Nested mutation flows through patch_data correctly
-  # -------------------------------------------------------------------------
+it "reload_raises_on_unpersisted_resource" do
+  resource, _ctl = build_resource(spec: { key: "value" })
 
-  it "nested_mutation_produces_nested_patch" do
-    resource, ctl = build_resource(
-      metadata: { name: "my-config", namespace: "default", labels: { app: "web", tier: "frontend" } }
-    )
+  lambda { resource.reload }.should.raise Kube::CommandError
+end
 
-    # Mutate only a nested field
-    resource.instance_variable_get(:@data).metadata.labels.tier = "backend"
+# -------------------------------------------------------------------------
+# Nested mutation flows through patch_data correctly
+# -------------------------------------------------------------------------
 
-    patch = resource.patch_data
-    patch[:metadata][:labels][:tier].should == ["frontend", "backend"]
-  end
+it "nested_mutation_produces_nested_patch" do
+  resource, ctl = build_resource(
+    metadata: { name: "my-config", namespace: "default", labels: { app: "web", tier: "frontend" } }
+  )
 
-  it "deeply_nested_no_change_produces_empty_patch" do
-    resource, _ctl = build_resource(
-      metadata: { name: "my-config", labels: { app: "web" } }
-    )
+  # Mutate only a nested field
+  resource.instance_variable_get(:@data).metadata.labels.tier = "backend"
 
-    resource.patch_data.should == {}
-  end
+  patch = resource.patch_data
+  patch[:metadata][:labels][:tier].should == ["frontend", "backend"]
+end
 
-  # -------------------------------------------------------------------------
-  # Multiple mutations before patch coalesce into a single diff
-  # -------------------------------------------------------------------------
+it "deeply_nested_no_change_produces_empty_patch" do
+  resource, _ctl = build_resource(
+    metadata: { name: "my-config", labels: { app: "web" } }
+  )
 
-  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.patch_data.should == {}
+end
 
-    d = resource.instance_variable_get(:@data).data
-    d.host = "db-2"
-    d.port = "5433"
-    d.pool = "10"
+# -------------------------------------------------------------------------
+# Multiple mutations before patch coalesce into a single diff
+# -------------------------------------------------------------------------
 
-    ctl.stub_response("get", server_state(
-      metadata: { name: "my-config", namespace: "default" },
-      data: { host: "db-2", port: "5433", pool: "10" }
-    ))
+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.patch
+  d = resource.instance_variable_get(:@data).data
+  d.host = "db-2"
+  d.port = "5433"
+  d.pool = "10"
 
-    # Exactly one patch command
-    patch_commands = ctl.commands.select { |c| c.include?("patch") }
-    patch_commands.size.should == 1
-  end
+  ctl.stub_response("get", server_state(
+    metadata: { name: "my-config", namespace: "default" },
+    data: { host: "db-2", port: "5433", pool: "10" }
+  ))
 
-  # -------------------------------------------------------------------------
-  # changes_applied mid-workflow resets the baseline
-  # -------------------------------------------------------------------------
+  resource.patch
 
-  it "changes_applied_resets_baseline_without_server_roundtrip" do
-    resource, _ctl = build_resource(metadata: { name: "my-config" }, spec: { key: "v1" })
+  # Exactly one patch command
+  patch_commands = ctl.commands.select { |c| c.include?("patch") }
+  patch_commands.size.should == 1
+end
 
-    resource.instance_variable_get(:@data).spec.key = "v2"
+# -------------------------------------------------------------------------
+# changes_applied mid-workflow resets the baseline
+# -------------------------------------------------------------------------
 
-    # Accept changes locally (no kubectl call)
-    resource.changes_applied
+it "changes_applied_resets_baseline_without_server_roundtrip" do
+  resource, _ctl = build_resource(metadata: { name: "my-config" }, spec: { key: "v1" })
 
-    resource.changes.should == {}
-  end
+  resource.instance_variable_get(:@data).spec.key = "v2"
 
-  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" }
-    )
+  # Accept changes locally (no kubectl call)
+  resource.changes_applied
 
-    # First wave of changes
-    resource.instance_variable_get(:@data).data.a = "changed-a"
-    resource.changes_applied
+  resource.changes.should == {}
+end
 
-    # Second wave — only b changes from the new baseline
-    resource.instance_variable_get(:@data).data.b = "changed-b"
+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" }
+  )
 
-    ctl.stub_response("get", server_state(
-      metadata: { name: "my-config", namespace: "default" },
-      data: { a: "changed-a", b: "changed-b", c: "3" }
-    ))
+  # First wave of changes
+  resource.instance_variable_get(:@data).data.a = "changed-a"
+  resource.changes_applied
 
-    resource.patch
+  # Second wave — only b changes from the new baseline
+  resource.instance_variable_get(:@data).data.b = "changed-b"
 
-    patch_cmd = ctl.commands.find { |c| c.include?("patch") }
-    payload = JSON.parse(patch_cmd.split("-p ").last)
+  ctl.stub_response("get", server_state(
+    metadata: { name: "my-config", namespace: "default" },
+    data: { a: "changed-a", b: "changed-b", c: "3" }
+  ))
 
-    # Only b should be in the patch, not a (already accepted via changes_applied)
-    payload["data"]["b"].should == ["2", "changed-b"]
-  end
+  resource.patch
 
-  # -------------------------------------------------------------------------
-  # Dynamic attr_changed? tracks through full lifecycle
-  # -------------------------------------------------------------------------
+  patch_cmd = ctl.commands.find { |c| c.include?("patch") }
+  payload = JSON.parse(patch_cmd.split("-p ").last)
 
-  it "attr_changed_through_apply_mutate_patch_cycle" do
-    resource, ctl = build_resource(metadata: { name: "my-config", namespace: "default" }, spec: { key: "v1" })
+  # Only b should be in the patch, not a (already accepted via changes_applied)
+  payload["data"]["b"].should == ["2", "changed-b"]
+end
 
-    ctl.stub_response("get", server_state(
-      metadata: { name: "my-config", namespace: "default" },
-      spec: { key: "v1" }
-    ))
+# -------------------------------------------------------------------------
+# Dynamic attr_changed? tracks through full lifecycle
+# -------------------------------------------------------------------------
 
-    resource.apply
+it "attr_changed_through_apply_mutate_patch_cycle" do
+  resource, ctl = build_resource(metadata: { name: "my-config", namespace: "default" }, spec: { key: "v1" })
 
-    resource.instance_variable_get(:@data).spec.key = "v2"
+  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"
 
-    resource.spec_changed?.should.be.false
-  end
+  ctl.stub_response("get", server_state(
+    metadata: { name: "my-config", namespace: "default" },
+    spec: { key: "v2" }
+  ))
 
-  it "respond_to_for_dynamic_changed_predicates" do
-    resource, _ctl = build_resource(metadata: { name: "test" })
+  resource.patch
 
-    resource.should.respond_to :metadata_changed?
-  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" })
 
-  it "reload_does_not_corrupt_previously_captured_changes" do
-    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
-    extract_nested_value(changes_before, :spec, :key, 1).should == "v2"
-  end
+  # Reload with different server state
+  ctl.stub_response("get", server_state(
+    metadata: { name: "my-config", namespace: "default" },
+    spec: { key: "v3-from-server" }
+  ))
+
+  resource.reload
 
-  it "snapshot_isolation_across_multiple_changes_applied" do
-    resource, _ctl = build_resource(metadata: { name: "test" }, data: { counter: "1" })
+  # Previously captured hashes should be unaffected
+  extract_nested_value(changes_before, :spec, :key, 1).should == "v2"
+end
 
-    resource.instance_variable_get(:@data).data.counter = "2"
-    snapshot_1_changes = resource.changes
+it "snapshot_isolation_across_multiple_changes_applied" do
+  resource, _ctl = build_resource(metadata: { name: "test" }, data: { counter: "1" })
 
-    resource.changes_applied
+  resource.instance_variable_get(:@data).data.counter = "2"
+  snapshot_1_changes = resource.changes
 
-    resource.instance_variable_get(:@data).data.counter = "3"
-    snapshot_2_changes = resource.changes
+  resource.changes_applied
 
-    # Each snapshot's changes should be independent
-    extract_nested_value(snapshot_1_changes, :data, :counter, 0).should == "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
 
-  it "empty_resource_tracks_all_additions" do
-    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" })
 
-    resource.changed.should.include :spec
-  end
+  resource.instance_variable_get(:@data).spec.key = "added"
 
-  # -------------------------------------------------------------------------
-  # Edge case: patch type parameter is forwarded
-  # -------------------------------------------------------------------------
+  resource.changed.should.include :spec
+end
 
-  it "patch_forwards_type_parameter" do
-    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") }
-    patch_cmd.should.include "--type merge"
-  end
+  resource.patch(type: "merge")
 
-  it "patch_defaults_to_strategic_type" do
-    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") }
-    patch_cmd.should.include "--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
 
-  it "patch_includes_namespace_flags" do
-    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") }
-    patch_cmd.should.include "--namespace kube-system"
-  end
+  resource.patch
 
-  it "reload_includes_namespace_flags" do
-    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") }
-    get_cmd.should.include "--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
 
-  it "delete_issues_kubectl_delete" do
-    resource, ctl = build_resource(metadata: { name: "my-config", namespace: "default" })
+# -------------------------------------------------------------------------
+# Edge case: delete on persisted resource issues command
+# -------------------------------------------------------------------------
 
-    result = resource.delete
+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") }
-    delete_cmd.should.include "my-config"
-  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
 
-  it "changes_does_not_raise_name_error" do
-    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"
 
-    changes.should.be.kind_of Hash
-  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