kube_schema 1.12.0 → 2.0.0

data/lib/kube/schema/resource.rb

@@ -7,15 +7,13 @@ module Kube
       def initialize(hash = {}, &block)
         deep_symbolize_keys(self.class.defaults.to_h).then do |defaults|
 
-          # You are NEVER allowed to change `apiVersion` or `kind`
-          # Therefore, they are ONLY ever set from the self.defaults
-          # property.
+          # apiVersion and kind are never user-settable.
+          # They come only from self.class.defaults.
           deep_symbolize_keys(hash).then do |symbolized|
             @data = defaults
 
-            # This is extracting "top-level" properties from the input hash
-            # such as [apiVersion, spec, metadata, roleRef, ...]
-            # We then ignore the rest of the attributes by design.
+            # Lift top-level properties, e.g. spec, metadata, roleRef.
+            # Any other attributes are dropped by design.
             self.class.schema_properties.each do |property|
               if symbolized.key?(property)
                 @data[property] = symbolized.delete(property)
@@ -29,7 +27,8 @@ module Kube
         end
       end
 
-      # Gets overridden by the factory in Kube::Schema::Instance
+      # Overridden by the factory in Kube::Schema::Instance.
+      # @returns [JSONSchemer::Schema, nil] the schema, once overridden.
       def self.schema
         raise "Kube::Schema::Resource should NOT be instanciated directly"
       end
@@ -38,8 +37,8 @@ module Kube
         raise "Kube::Schema::Resource should NOT be instanciated directly"
       end
 
-      # Gets overridden by the factory in Kube::Schema::Instance.
-      # Returns a frozen Hash like { "apiVersion" => "apps/v1", "kind" => "Deployment" }
+      # Overridden by the factory in Kube::Schema::Instance.
+      # @returns [Hash] a frozen Hash like { "apiVersion" => "apps/v1", "kind" => "Deployment" }.
       def self.defaults
         raise "Kube::Schema::Resource should NOT be instanciated directly"
       end
@@ -52,8 +51,9 @@ module Kube
         end
       end
 
-      # Like #valid? but raises Kube::ValidationError with details on failure.
-      # The error message includes the resource kind and name for context.
+      # Like #valid? but raises on failure.
+      # @returns [Boolean] true if the resource is valid.
+      # @raises [Kube::ValidationError] with details on failure.
       def valid!
         if self.class.schema.nil?
           true
@@ -71,9 +71,8 @@ module Kube
         end
       end
 
-      # Returns the resource data as a Hash. Defaults (apiVersion, kind)
-      # from the schema are authoritative and cannot be overridden --
-      # they are facts derived from the GVK metadata.
+      # The resource data as a Hash; apiVersion/kind are authoritative.
+      # @returns [Hash] the resource data, symbol-keyed.
       def to_h
         defaults = self.class.defaults
         data = deep_compact(@data)
@@ -81,8 +80,7 @@ module Kube
 
         if defaults
           symbolized = deep_symbolize_keys(defaults)
-          # Defaults go first (for key ordering), then user data minus
-          # any attempts to override the authoritative keys.
+          # Defaults go first, for key ordering, then the rest of the data.
           symbolized.merge(data.reject { |k, _| symbolized.key?(k) })
         else
           data
@@ -90,7 +88,8 @@ module Kube
       end
 
       # Serializes to clean Kubernetes YAML.
-      # Raises Kube::ValidationError if the resource is not valid.
+      # @returns [String] the resource as YAML.
+      # @raises [Kube::ValidationError] if the resource is not valid.
       def to_yaml
         if valid!
           deep_stringify_keys(to_h).to_yaml
@@ -101,9 +100,9 @@ module Kube
         other.is_a?(Resource) && to_h == other.to_h
       end
 
-      # Ruby pattern matching: `resource => {metadata: {name:}}`.
-      # to_h is already plain nested symbol-keyed Hashes, so nested
-      # patterns work all the way down for free.
+      # Supports pattern matching, e.g. `resource => {metadata: {name:}}`.
+      # @parameter keys [Array(Symbol), nil] the keys requested by the pattern.
+      # @returns [Hash] the same nested Hash as #to_h.
       def deconstruct_keys(keys) = to_h
 
       private
@@ -115,7 +114,9 @@ module Kube
           when Hash
             obj.each_with_object({}) do |(k, v), result|
               compacted = deep_compact(v)
-              result[k] = compacted unless compacted.nil?
+              unless compacted.nil?
+                result[k] = compacted
+              end
             end
           when Array
             obj.map { |v| deep_compact(v) }
@@ -153,442 +154,396 @@ module Kube
   end
 end
 
-if __FILE__ == $0
-  require "bundler/setup"
-  require "rspec/autorun"
-  require "kube/schema"
-
-  RSpec.describe Kube::Schema::Resource do
-    describe ".defaults" do
-      it "returns apiVersion and kind for a schema-bearing subclass" do
-        klass = Kube::Schema["Deployment"]
-        expect(klass.defaults).to eq({ "apiVersion" => "apps/v1", "kind" => "Deployment" })
-      end
 
-      it "returns correct apiVersion for core resources (no group)" do
-        klass = Kube::Schema["Pod"]
-        expect(klass.defaults).to eq({ "apiVersion" => "v1", "kind" => "Pod" })
-      end
-
-      it "returns correct apiVersion for grouped resources" do
-        klass = Kube::Schema["NetworkPolicy"]
-        expect(klass.defaults).to eq({ "apiVersion" => "networking.k8s.io/v1", "kind" => "NetworkPolicy" })
-      end
+__END__
+
+require "kube/schema"
+
+deployment_class = lambda { Kube::Schema["Deployment"] }
+
+full_deployment = lambda {
+  Kube::Schema["Deployment"].new {
+    metadata.name = "nginx-deployment"
+    metadata.namespace = "shopping-cart"
+    metadata.labels = { app: "nginx" }
+    spec.replicas = 3
+    spec.selector.matchLabels = { app: "nginx" }
+    spec.template.metadata.labels = { app: "nginx" }
+    spec.template.spec.containers = [
+      { name: "nginx", image: "nginx:1.19.5", ports: [{ containerPort: 80 }] }
+    ]
+  }
+}
+
+incomplete_deployment = lambda {
+  Kube::Schema["Deployment"].new {
+    metadata.namespace = "example"
+    metadata.name = "example-deployment"
+    spec.replicas = 1
+    spec.template.spec.containers = [
+      { name: "app", image: "ruby:latest" }
+    ]
+  }
+}
+
+describe "Kube::Schema::Resource" do
+  describe ".defaults" do
+    it "returns apiVersion and kind for a schema-bearing subclass" do
+      Kube::Schema["Deployment"].defaults.should == { "apiVersion" => "apps/v1", "kind" => "Deployment" }
     end
 
-    describe "#initialize" do
-      it "accepts a hash" do
-        klass = Kube::Schema["Deployment"]
-        resource = klass.new("metadata" => { "name" => "my-deploy" })
-        expect(resource.to_h).to include(kind: "Deployment")
-        expect(resource.to_h[:metadata][:name]).to eq("my-deploy")
-      end
-
-      it "creates an empty resource when no arguments are given" do
-        klass = Kube::Schema["Deployment"]
-        resource = klass.new
-        expect(resource.to_h).to include(apiVersion: "apps/v1", kind: "Deployment")
-      end
-
-      it "accepts a block for DSL-style initialization" do
-        klass = Kube::Schema["Deployment"]
-        resource = klass.new {
-          metadata.name = "test"
-        }
-        expect(resource.to_h).to include(kind: "Deployment")
-        expect(resource.to_h[:metadata][:name]).to eq("test")
-      end
+    it "returns correct apiVersion for core resources (no group)" do
+      Kube::Schema["Pod"].defaults.should == { "apiVersion" => "v1", "kind" => "Pod" }
     end
 
-    describe "#to_h" do
-      context "with a schema-bearing subclass" do
-        let(:klass) { Kube::Schema["Deployment"] }
+    it "returns correct apiVersion for grouped resources" do
+      Kube::Schema["NetworkPolicy"].defaults.should == { "apiVersion" => "networking.k8s.io/v1", "kind" => "NetworkPolicy" }
+    end
+  end
 
-        it "automatically includes apiVersion and kind from defaults" do
-          resource = klass.new {
-            metadata.name = "test"
-          }
-          expect(resource.to_h[:apiVersion]).to eq("apps/v1")
-          expect(resource.to_h[:kind]).to eq("Deployment")
-          expect(resource.to_h[:metadata][:name]).to eq("test")
-        end
+  describe "#initialize" do
+    it "accepts a hash" do
+      resource = Kube::Schema["Deployment"].new("metadata" => { "name" => "my-deploy" })
+      resource.to_h[:kind].should == "Deployment"
+      resource.to_h[:metadata][:name].should == "my-deploy"
+    end
 
-        it "cannot override apiVersion or kind -- they are authoritative" do
-          resource = klass.new {
-            self.apiVersion = "apps/v1beta1"
-            self.kind = "NotADeployment"
-          }
-          expect(resource.to_h[:apiVersion]).to eq("apps/v1")
-          expect(resource.to_h[:kind]).to eq("Deployment")
-        end
-      end
+    it "creates an empty resource when no arguments are given" do
+      resource = Kube::Schema["Deployment"].new
+      resource.to_h[:apiVersion].should == "apps/v1"
+      resource.to_h[:kind].should == "Deployment"
     end
 
-    describe "pattern matching" do
-      it "destructures nested keys" do
-        resource = Kube::Schema["Deployment"].new { metadata.name = "web" }
-        resource => {kind: "Deployment", metadata: {name: String => name}}
+    it "accepts a block for DSL-style initialization" do
+      resource = Kube::Schema["Deployment"].new {
+        metadata.name = "test"
+      }
+      resource.to_h[:kind].should == "Deployment"
+      resource.to_h[:metadata][:name].should == "test"
+    end
+  end
 
-        expect(name).to eq("web")
-      end
+  describe "#to_h with a schema-bearing subclass" do
+    it "automatically includes apiVersion and kind from defaults" do
+      resource = deployment_class.().new {
+        metadata.name = "test"
+      }
+      resource.to_h[:apiVersion].should == "apps/v1"
+      resource.to_h[:kind].should == "Deployment"
+      resource.to_h[:metadata][:name].should == "test"
+    end
 
-      it "does not match when a nested value differs" do
-        resource = Kube::Schema["Deployment"].new { metadata.name = "web" }
-        expect { resource => {metadata: {name: "other"}} }.to raise_error(NoMatchingPatternError)
-      end
+    it "cannot override apiVersion or kind -- they are authoritative" do
+      resource = deployment_class.().new {
+        self.apiVersion = "apps/v1beta1"
+        self.kind = "NotADeployment"
+      }
+      resource.to_h[:apiVersion].should == "apps/v1"
+      resource.to_h[:kind].should == "Deployment"
     end
+  end
 
-    describe "#==" do
-      it "considers two resources equal when their data matches" do
-        a = Kube::Schema["Pod"].new
-        b = Kube::Schema["Pod"].new
-        expect(a).to eq(b)
-      end
+  describe "pattern matching" do
+    it "destructures nested keys" do
+      resource = Kube::Schema["Deployment"].new { metadata.name = "web" }
+      resource => {kind: "Deployment", metadata: {name: String => deploy_name}}
 
-      it "considers two resources unequal when their data differs" do
-        a = Kube::Schema["Pod"].new
-        b = Kube::Schema["Service"].new
-        expect(a).not_to eq(b)
-      end
+      deploy_name.should == "web"
+    end
 
-      it "is not equal to non-Resource objects" do
-        resource = Kube::Schema["Pod"].new
-        expect(resource).not_to eq({ "kind" => "Pod" })
-      end
+    it "does not match when a nested value differs" do
+      resource = Kube::Schema["Deployment"].new { metadata.name = "web" }
+      lambda { resource => {metadata: {name: "other"}} }.should.raise(NoMatchingPatternError)
     end
+  end
 
-    describe "#valid?" do
-      context "with a schema-bearing subclass" do
-        let(:klass) { Kube::Schema["Deployment"] }
+  describe "#==" do
+    it "considers two resources equal when their data matches" do
+      Kube::Schema["Pod"].new.should == Kube::Schema["Pod"].new
+    end
 
-        it "returns true for valid data (apiVersion/kind come from defaults)" do
-          resource = klass.new
-          expect(resource.valid?).to be true
-        end
+    it "considers two resources unequal when their data differs" do
+      Kube::Schema["Pod"].new.should.not == Kube::Schema["Service"].new
+    end
 
-        it "returns false for data violating the schema" do
-          resource = klass.new {
-            spec.replicas = "not_a_number"
-          }
-          expect(resource.valid?).to be false
-        end
-      end
+    it "is not equal to non-Resource objects" do
+      Kube::Schema["Pod"].new.should.not == { "kind" => "Pod" }
     end
+  end
 
-    describe "#valid!" do
-      context "with a schema-bearing subclass" do
-        let(:klass) { Kube::Schema["Deployment"] }
+  describe "#valid? with a schema-bearing subclass" do
+    it "returns true for valid data (apiVersion/kind come from defaults)" do
+      deployment_class.().new.valid?.should.be.true
+    end
 
-        it "returns true for valid data" do
-          resource = klass.new
-          expect(resource.valid!).to be true
-        end
+    it "returns false for data violating the schema" do
+      resource = deployment_class.().new {
+        spec.replicas = "not_a_number"
+      }
+      resource.valid?.should.be.false
+    end
+  end
 
-        it "raises ValidationError for data violating the schema" do
-          resource = klass.new {
-            spec.replicas = "not_a_number"
-          }
-          expect { resource.valid! }.to raise_error(Kube::ValidationError)
-        end
+  describe "#valid! with a schema-bearing subclass" do
+    it "returns true for valid data" do
+      deployment_class.().new.valid!.should.be.true
+    end
 
-        it "includes error details in the exception" do
-          resource = klass.new {
-            spec.replicas = "not_a_number"
-          }
-          expect { resource.valid! }.to raise_error(Kube::ValidationError, /Schema validation failed/)
-        end
+    it "raises ValidationError for data violating the schema" do
+      resource = deployment_class.().new {
+        spec.replicas = "not_a_number"
+      }
+      lambda { resource.valid! }.should.raise(Kube::ValidationError)
+    end
 
-        it "shows the exact key path and value for type errors" do
-          resource = klass.new {
-            metadata.name = "web"
-            spec.replicas = "not_a_number"
-          }
-          expect { resource.valid! }.to raise_error(Kube::ValidationError) do |error|
-            expect(error.message).to include('spec.replicas = "not_a_number" — expected integer, got String')
-          end
-        end
+    it "includes error details in the exception" do
+      resource = deployment_class.().new {
+        spec.replicas = "not_a_number"
+      }
+      error = lambda { resource.valid! }.should.raise(Kube::ValidationError)
+      error.message.should.match(/Schema validation failed/)
+    end
 
-        it "shows which required keys are missing" do
-          resource = klass.new {
-            metadata.name = "example"
-            spec.replicas = 1
-            spec.template.spec.containers = [{ name: "app", image: "ruby:latest" }]
-          }
-          expect { resource.valid! }.to raise_error(Kube::ValidationError) do |error|
-            expect(error.message).to include("spec.selector is required but missing")
-          end
-        end
+    it "shows the exact key path and value for type errors" do
+      resource = deployment_class.().new {
+        metadata.name = "web"
+        spec.replicas = "not_a_number"
+      }
+      error = lambda { resource.valid! }.should.raise(Kube::ValidationError)
+      error.message.should.include 'spec.replicas = "not_a_number" — expected integer, got String'
+    end
 
-        it "includes the resource kind in the error header" do
-          resource = klass.new {
-            metadata.name = "web"
-            spec.replicas = "bad"
-          }
-          expect { resource.valid! }.to raise_error(Kube::ValidationError) do |error|
-            expect(error.message).to include("Schema validation failed for Deployment")
-          end
-        end
+    it "shows which required keys are missing" do
+      resource = deployment_class.().new {
+        metadata.name = "example"
+        spec.replicas = 1
+        spec.template.spec.containers = [{ name: "app", image: "ruby:latest" }]
+      }
+      error = lambda { resource.valid! }.should.raise(Kube::ValidationError)
+      error.message.should.include "spec.selector is required but missing"
+    end
 
-        it "includes the resource name in the error header when available" do
-          resource = klass.new {
-            metadata.name = "my-app"
-            spec.replicas = "bad"
-          }
-          expect { resource.valid! }.to raise_error(Kube::ValidationError) do |error|
-            expect(error.message).to include('Deployment "my-app"')
-          end
-        end
+    it "includes the resource kind in the error header" do
+      resource = deployment_class.().new {
+        metadata.name = "web"
+        spec.replicas = "bad"
+      }
+      error = lambda { resource.valid! }.should.raise(Kube::ValidationError)
+      error.message.should.include "Schema validation failed for Deployment"
+    end
 
-        it "omits the resource name when metadata.name is not set" do
-          resource = klass.new {
-            spec.replicas = "bad"
-          }
-          expect { resource.valid! }.to raise_error(Kube::ValidationError) do |error|
-            header = error.message.lines.find { |l| l.include?("Schema validation failed") }
-            expect(header).to include("Schema validation failed for Deployment")
-            expect(header).not_to match(/Deployment\s+"/)  # no quoted name after kind
-          end
-        end
+    it "includes the resource name in the error header when available" do
+      resource = deployment_class.().new {
+        metadata.name = "my-app"
+        spec.replicas = "bad"
+      }
+      error = lambda { resource.valid! }.should.raise(Kube::ValidationError)
+      error.message.should.include 'Deployment "my-app"'
+    end
 
-        it "exposes the raw errors array" do
-          resource = klass.new {
-            spec.replicas = "not_a_number"
-          }
-          begin
-            resource.valid!
-          rescue Kube::ValidationError => e
-            expect(e.errors).to be_an(Array)
-            expect(e.errors).not_to be_empty
-          end
-        end
-      end
+    it "omits the resource name when metadata.name is not set" do
+      resource = deployment_class.().new {
+        spec.replicas = "bad"
+      }
+      error = lambda { resource.valid! }.should.raise(Kube::ValidationError)
+      header = error.message.lines.find { |l| l.include?("Schema validation failed") }
+      header.should.include "Schema validation failed for Deployment"
+      header.should.not.match(/Deployment\s+"/) # no quoted name after kind
     end
 
-    describe "#to_yaml" do
-      it "returns clean Kubernetes YAML" do
-        resource = Kube::Schema["Pod"].new
-        yaml = resource.to_yaml
+    it "exposes the raw errors array" do
+      resource = deployment_class.().new {
+        spec.replicas = "not_a_number"
+      }
+      error = lambda { resource.valid! }.should.raise(Kube::ValidationError)
+      error.errors.should.be.kind_of Array
+      error.errors.should.not.be.empty
+    end
+  end
 
-        expect(yaml).to include("kind: Pod")
-        expect(yaml).to include("apiVersion: v1")
-        expect(yaml).not_to include("!ruby/object")
-      end
+  describe "#to_yaml" do
+    it "returns clean Kubernetes YAML" do
+      yaml = Kube::Schema["Pod"].new.to_yaml
 
-      it "uses string keys, not symbol keys" do
-        resource = Kube::Schema["Pod"].new
-        yaml = resource.to_yaml
+      yaml.should.include "kind: Pod"
+      yaml.should.include "apiVersion: v1"
+      yaml.should.not.include "!ruby/object"
+    end
 
-        expect(yaml).not_to match(/:\w+:/)
-        expect(yaml).to include("kind: Pod")
-      end
+    it "uses string keys, not symbol keys" do
+      yaml = Kube::Schema["Pod"].new.to_yaml
 
-      it "produces parseable YAML that round-trips" do
-        resource = Kube::Schema["Pod"].new
-        parsed = YAML.safe_load(resource.to_yaml)
+      yaml.should.not.match(/:\w+:/)
+      yaml.should.include "kind: Pod"
+    end
 
-        expect(parsed).to be_a(Hash)
-        expect(parsed["kind"]).to eq("Pod")
-        expect(parsed["apiVersion"]).to eq("v1")
-      end
+    it "produces parseable YAML that round-trips" do
+      parsed = YAML.safe_load(Kube::Schema["Pod"].new.to_yaml)
 
-      it "raises ValidationError when the resource is invalid" do
-        klass = Kube::Schema["Deployment"]
-        resource = klass.new {
-          spec.replicas = "not_a_number"
-        }
-        expect { resource.to_yaml }.to raise_error(Kube::ValidationError)
-      end
+      parsed.should.be.kind_of Hash
+      parsed["kind"].should == "Pod"
+      parsed["apiVersion"].should == "v1"
+    end
 
-      it "raises ValidationError for an incomplete Deployment missing selector" do
-        klass = Kube::Schema["Deployment"]
-        resource = klass.new {
-          metadata.namespace = "example"
-          metadata.name = "example-deployment"
-          spec.replicas = 1
-          spec.template.spec.containers = [
-            { name: "app", image: "ruby:latest" }
-          ]
-        }
-        expect { resource.to_yaml }.to raise_error(Kube::ValidationError)
-      end
+    it "raises ValidationError when the resource is invalid" do
+      resource = Kube::Schema["Deployment"].new {
+        spec.replicas = "not_a_number"
+      }
+      lambda { resource.to_yaml }.should.raise(Kube::ValidationError)
+    end
 
-      context "with a full Deployment (no manual apiVersion/kind)" do
-        let(:deployment) do
-          Kube::Schema["Deployment"].new {
-            metadata.name = "nginx-deployment"
-            metadata.namespace = "shopping-cart"
-            metadata.labels = { app: "nginx" }
-            spec.replicas = 3
-            spec.selector.matchLabels = { app: "nginx" }
-            spec.template.metadata.labels = { app: "nginx" }
-            spec.template.spec.containers = [
-              { name: "nginx", image: "nginx:1.19.5", ports: [{ containerPort: 80 }] }
-            ]
-          }
-        end
+    it "raises ValidationError for an incomplete Deployment missing selector" do
+      resource = incomplete_deployment.()
+      lambda { resource.to_yaml }.should.raise(Kube::ValidationError)
+    end
+  end
 
-        it "produces valid Kubernetes Deployment YAML" do
-          yaml = deployment.to_yaml
-          parsed = YAML.safe_load(yaml)
-
-          expect(parsed).to be_a(Hash)
-          expect(parsed["apiVersion"]).to eq("apps/v1")
-          expect(parsed["kind"]).to eq("Deployment")
-          expect(parsed["metadata"]["name"]).to eq("nginx-deployment")
-          expect(parsed["metadata"]["namespace"]).to eq("shopping-cart")
-          expect(parsed["metadata"]["labels"]).to eq({ "app" => "nginx" })
-          expect(parsed["spec"]["replicas"]).to eq(3)
-          expect(parsed["spec"]["selector"]["matchLabels"]).to eq({ "app" => "nginx" })
-          expect(parsed["spec"]["template"]["metadata"]["labels"]).to eq({ "app" => "nginx" })
-
-          containers = parsed["spec"]["template"]["spec"]["containers"]
-          expect(containers).to be_an(Array)
-          expect(containers.length).to eq(1)
-          expect(containers[0]["name"]).to eq("nginx")
-          expect(containers[0]["image"]).to eq("nginx:1.19.5")
-          expect(containers[0]["ports"]).to eq([{ "containerPort" => 80 }])
-        end
+  describe "#to_yaml with a full Deployment (no manual apiVersion/kind)" do
+    it "produces valid Kubernetes Deployment YAML" do
+      parsed = YAML.safe_load(full_deployment.().to_yaml)
+
+      parsed.should.be.kind_of Hash
+      parsed["apiVersion"].should == "apps/v1"
+      parsed["kind"].should == "Deployment"
+      parsed["metadata"]["name"].should == "nginx-deployment"
+      parsed["metadata"]["namespace"].should == "shopping-cart"
+      parsed["metadata"]["labels"].should == { "app" => "nginx" }
+      parsed["spec"]["replicas"].should == 3
+      parsed["spec"]["selector"]["matchLabels"].should == { "app" => "nginx" }
+      parsed["spec"]["template"]["metadata"]["labels"].should == { "app" => "nginx" }
+
+      containers = parsed["spec"]["template"]["spec"]["containers"]
+      containers.should.be.kind_of Array
+      containers.length.should == 1
+      containers[0]["name"].should == "nginx"
+      containers[0]["image"].should == "nginx:1.19.5"
+      containers[0]["ports"].should == [{ "containerPort" => 80 }]
+    end
 
-        it "does not contain Ruby object serialization artifacts" do
-          yaml = deployment.to_yaml
+    it "does not contain Ruby object serialization artifacts" do
+      yaml = full_deployment.().to_yaml
 
-          expect(yaml).not_to include("!ruby/object")
-          expect(yaml).not_to include("table:")
-        end
+      yaml.should.not.include "!ruby/object"
+      yaml.should.not.include "table:"
+    end
 
-        it "looks like real kubectl YAML output" do
-          yaml = deployment.to_yaml
+    it "looks like real kubectl YAML output" do
+      yaml = full_deployment.().to_yaml
 
-          expect(yaml).to include("apiVersion: apps/v1")
-          expect(yaml).to include("kind: Deployment")
-          expect(yaml).to include("name: nginx-deployment")
-          expect(yaml).to include("namespace: shopping-cart")
-          expect(yaml).to include("replicas: 3")
-          expect(yaml).to include("image: nginx:1.19.5")
-          expect(yaml).to include("containerPort: 80")
-        end
+      yaml.should.include "apiVersion: apps/v1"
+      yaml.should.include "kind: Deployment"
+      yaml.should.include "name: nginx-deployment"
+      yaml.should.include "namespace: shopping-cart"
+      yaml.should.include "replicas: 3"
+      yaml.should.include "image: nginx:1.19.5"
+      yaml.should.include "containerPort: 80"
+    end
 
-        it "exactly matches real Kubernetes Deployment YAML" do
-          expected_yaml = <<~YAML
-            ---
-            apiVersion: apps/v1
-            kind: Deployment
+    it "exactly matches real Kubernetes Deployment YAML" do
+      expected_yaml = <<~YAML
+        ---
+        apiVersion: apps/v1
+        kind: Deployment
+        metadata:
+          name: nginx-deployment
+          namespace: shopping-cart
+          labels:
+            app: nginx
+        spec:
+          replicas: 3
+          selector:
+            matchLabels:
+              app: nginx
+          template:
             metadata:
-              name: nginx-deployment
-              namespace: shopping-cart
               labels:
                 app: nginx
             spec:
-              replicas: 3
-              selector:
-                matchLabels:
-                  app: nginx
-              template:
-                metadata:
-                  labels:
-                    app: nginx
-                spec:
-                  containers:
-                  - name: nginx
-                    image: nginx:1.19.5
-                    ports:
-                    - containerPort: 80
-          YAML
-
-          expect(deployment.to_yaml).to eq(expected_yaml)
-        end
-
-        it "round-trips through YAML.safe_load" do
-          parsed = YAML.safe_load(deployment.to_yaml)
-          expect(parsed["apiVersion"]).to eq("apps/v1")
-          expect(parsed["kind"]).to eq("Deployment")
-        end
-      end
+              containers:
+              - name: nginx
+                image: nginx:1.19.5
+                ports:
+                - containerPort: 80
+      YAML
+
+      full_deployment.().to_yaml.should == expected_yaml
     end
 
-    describe "Deployment schema validation against real Kubernetes YAML" do
-      let(:klass) { Kube::Schema["Deployment"] }
-
-      let(:incomplete_deployment) do
-        klass.new {
-          metadata.namespace = "example"
-          metadata.name = "example-deployment"
-          spec.replicas = 1
-          spec.template.spec.containers = [
-            { name: "app", image: "ruby:latest" }
-          ]
-        }
-      end
-
-      it "rejects an incomplete Deployment missing selector" do
-        expect(incomplete_deployment.valid?).to be false
-      end
-
-      it "reports specific validation errors for incomplete Deployment" do
-        expect { incomplete_deployment.valid! }.to raise_error(Kube::ValidationError) do |error|
-          expect(error.message).to include("spec.selector is required but missing")
-        end
-      end
+    it "round-trips through YAML.safe_load" do
+      parsed = YAML.safe_load(full_deployment.().to_yaml)
+      parsed["apiVersion"].should == "apps/v1"
+      parsed["kind"].should == "Deployment"
+    end
+  end
 
-      it "refuses to serialize an incomplete Deployment to YAML" do
-        expect { incomplete_deployment.to_yaml }.to raise_error(Kube::ValidationError)
-      end
+  describe "Deployment schema validation against real Kubernetes YAML" do
+    it "rejects an incomplete Deployment missing selector" do
+      incomplete_deployment.().valid?.should.be.false
+    end
 
-      it "has apiVersion and kind from defaults even when incomplete" do
-        h = incomplete_deployment.to_h
-        expect(h[:apiVersion]).to eq("apps/v1")
-        expect(h[:kind]).to eq("Deployment")
-      end
+    it "reports specific validation errors for incomplete Deployment" do
+      resource = incomplete_deployment.()
+      error = lambda { resource.valid! }.should.raise(Kube::ValidationError)
+      error.message.should.include "spec.selector is required but missing"
     end
 
-    describe "pattern matching" do
-      let(:deployment) do
-        Kube::Schema["Deployment"].new {
-          metadata.name = "some-resource"
-          metadata.namespace = "prod"
-        }
-      end
+    it "refuses to serialize an incomplete Deployment to YAML" do
+      resource = incomplete_deployment.()
+      lambda { resource.to_yaml }.should.raise(Kube::ValidationError)
+    end
 
-      it "destructures with a nested hash pattern" do
-        deployment => {kind: String => kind, metadata: {name:, namespace:}}
-        expect([kind, name, namespace]).to eq(["Deployment", "some-resource", "prod"])
-      end
+    it "has apiVersion and kind from defaults even when incomplete" do
+      h = incomplete_deployment.().to_h
+      h[:apiVersion].should == "apps/v1"
+      h[:kind].should == "Deployment"
+    end
+  end
 
-      it "matches in a case/in" do
-        matched = case deployment
-                  in {metadata: {name: "some-resource"}} then true
-                  else false
-                  end
-        expect(matched).to be true
-      end
+  describe "pattern matching on a named resource" do
+    it "destructures with a nested hash pattern" do
+      resource = Kube::Schema["Deployment"].new {
+        metadata.name = "some-resource"
+        metadata.namespace = "prod"
+      }
+      resource => {kind: String => kind, metadata: {name: deploy_name, namespace: deploy_namespace}}
+      [kind, deploy_name, deploy_namespace].should == ["Deployment", "some-resource", "prod"]
     end
 
-    describe "instantiation via Instance lookup" do
-      let(:klass) { Kube::Schema["Deployment"] }
+    it "matches in a case/in" do
+      resource = Kube::Schema["Deployment"].new {
+        metadata.name = "some-resource"
+        metadata.namespace = "prod"
+      }
+      matched = case resource
+                in {metadata: {name: "some-resource"}} then true
+                else false
+                end
+      matched.should.be.true
+    end
+  end
 
-      it "returns a Resource instance from .new" do
-        resource = klass.new
-        expect(resource).to be_a(described_class)
-      end
+  describe "instantiation via Instance lookup" do
+    it "returns a Resource instance from .new" do
+      deployment_class.().new.should.be.kind_of Kube::Schema::Resource
+    end
 
-      it "supports block-based initialization" do
-        resource = klass.new {
-          metadata.name = "web"
-          metadata.namespace = "prod"
-        }
-        expect(resource.to_h[:metadata][:name]).to eq("web")
-        expect(resource.to_h[:metadata][:namespace]).to eq("prod")
-      end
+    it "supports block-based initialization" do
+      resource = deployment_class.().new {
+        metadata.name = "web"
+        metadata.namespace = "prod"
+      }
+      resource.to_h[:metadata][:name].should == "web"
+      resource.to_h[:metadata][:namespace].should == "prod"
+    end
 
-      it "has a schema attached to the class" do
-        expect(klass.schema).not_to be_nil
-      end
+    it "has a schema attached to the class" do
+      deployment_class.().schema.should.not.be.nil
+    end
 
-      it "has defaults attached to the class" do
-        expect(klass.defaults).not_to be_nil
-        expect(klass.defaults["apiVersion"]).to eq("apps/v1")
-        expect(klass.defaults["kind"]).to eq("Deployment")
-      end
+    it "has defaults attached to the class" do
+      deployment_class.().defaults.should.not.be.nil
+      deployment_class.().defaults["apiVersion"].should == "apps/v1"
+      deployment_class.().defaults["kind"].should == "Deployment"
     end
   end
 end