kube_schema 1.3.2 → 1.3.5

data/lib/kube/schema/resource.rb

@@ -11,12 +11,16 @@ module Kube
           # Therefore, they are ONLY ever set from the self.defaults
           # property.
           deep_symbolize_keys(hash).then do |symbolized|
-            config = defaults.merge({
-              metadata: symbolized.delete(:metadata) || {},
-              spec: symbolized.delete(:spec) || {},
-            })
+            @data = defaults
 
-            @data = config
+            # 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.
+            self.class.schema_properties.each do |property|
+              if symbolized.key?(property)
+                @data[property] = symbolized.delete(property)
+              end
+            end
           end
         end
 
@@ -25,17 +29,20 @@ module Kube
         end
       end
 
-      def apiVersion = @data.apiVersion
-      def kind       = @data.kind
-      def spec       = @data.spec
-      def metadata   = @data.metadata
-
       # Gets overridden by the factory in Kube::Schema::Instance
-      def self.schema = nil
+      def self.schema
+        raise "Kube::Schema::Resource should NOT be instanciated directly"
+      end
+
+      def self.schema_properties
+        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" }
-      def self.defaults = nil
+      def self.defaults
+        raise "Kube::Schema::Resource should NOT be instanciated directly"
+      end
 
       def valid?
         if self.class.schema.nil?
@@ -69,7 +76,8 @@ module Kube
       # they are facts derived from the GVK metadata.
       def to_h
         defaults = self.class.defaults
-        data = @data.reject { |_, v| v.is_a?(Hash) && v.empty? }
+        data = deep_compact(@data)
+        data = data.reject { |_, v| v.is_a?(Hash) && v.empty? }
 
         if defaults
           symbolized = deep_symbolize_keys(defaults)
@@ -95,6 +103,20 @@ module Kube
 
       private
 
+        def deep_compact(obj)
+          case obj
+          when Hash
+            obj.each_with_object({}) do |(k, v), result|
+              compacted = deep_compact(v)
+              result[k] = compacted unless compacted.nil?
+            end
+          when Array
+            obj.map { |v| deep_compact(v) }
+          else
+            obj
+          end
+        end
+
         def deep_stringify_keys(obj)
           case obj
           when Hash
@@ -123,3 +145,409 @@ module Kube
     end
   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
+
+    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
+    end
+
+    describe "#to_h" do
+      context "with a schema-bearing subclass" do
+        let(:klass) { Kube::Schema["Deployment"] }
+
+        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
+
+        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
+    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
+
+      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
+
+      it "is not equal to non-Resource objects" do
+        resource = Kube::Schema["Pod"].new
+        expect(resource).not_to eq({ "kind" => "Pod" })
+      end
+    end
+
+    describe "#valid?" do
+      context "with a schema-bearing subclass" do
+        let(:klass) { Kube::Schema["Deployment"] }
+
+        it "returns true for valid data (apiVersion/kind come from defaults)" do
+          resource = klass.new
+          expect(resource.valid?).to be true
+        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
+    end
+
+    describe "#valid!" do
+      context "with a schema-bearing subclass" do
+        let(:klass) { Kube::Schema["Deployment"] }
+
+        it "returns true for valid data" do
+          resource = klass.new
+          expect(resource.valid!).to be true
+        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
+
+        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 "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 "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 "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 "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 "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 "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
+    end
+
+    describe "#to_yaml" do
+      it "returns clean Kubernetes YAML" do
+        resource = Kube::Schema["Pod"].new
+        yaml = resource.to_yaml
+
+        expect(yaml).to include("kind: Pod")
+        expect(yaml).to include("apiVersion: v1")
+        expect(yaml).not_to include("BlackHoleStruct")
+        expect(yaml).not_to include("!ruby/object")
+      end
+
+      it "uses string keys, not symbol keys" do
+        resource = Kube::Schema["Pod"].new
+        yaml = resource.to_yaml
+
+        expect(yaml).not_to match(/:\w+:/)
+        expect(yaml).to include("kind: Pod")
+      end
+
+      it "produces parseable YAML that round-trips" do
+        resource = Kube::Schema["Pod"].new
+        parsed = YAML.safe_load(resource.to_yaml)
+
+        expect(parsed).to be_a(Hash)
+        expect(parsed["kind"]).to eq("Pod")
+        expect(parsed["apiVersion"]).to eq("v1")
+      end
+
+      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
+
+      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
+
+      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 "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
+
+        it "does not contain Ruby object serialization artifacts" do
+          yaml = deployment.to_yaml
+
+          expect(yaml).not_to include("!ruby/object")
+          expect(yaml).not_to include("BlackHoleStruct")
+          expect(yaml).not_to include("table:")
+        end
+
+        it "looks like real kubectl YAML output" do
+          yaml = 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
+
+        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:
+                  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
+    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 "refuses to serialize an incomplete Deployment to YAML" do
+        expect { incomplete_deployment.to_yaml }.to raise_error(Kube::ValidationError)
+      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
+    end
+
+    describe "instantiation via Instance lookup" do
+      let(:klass) { Kube::Schema["Deployment"] }
+
+      it "returns a Resource instance from .new" do
+        resource = klass.new
+        expect(resource).to be_a(described_class)
+      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 "has a schema attached to the class" do
+        expect(klass.schema).not_to 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
+    end
+  end
+end

data/lib/kube/schema/version.rb

@@ -2,6 +2,6 @@
 
 module Kube
   module Schema
-    VERSION = "1.3.2"
+    VERSION = "1.3.5"
   end
 end

data/lib/kube/schema.rb

@@ -48,11 +48,11 @@ module Kube
       #     api_version: "cert-manager.io/v1"
       #   )
       #
-      # @example Register from a Hash
-      #   Kube::Schema.register("MyResource",
-      #     schema: { "type" => "object", "properties" => { ... } },
-      #     api_version: "example.com/v1"
-      #   )
+      # @example Register from Chart#crds
+      #   chart.crds.each do |crd|
+      #     s = crd.to_json_schema
+      #     Kube::Schema.register(s[:kind], schema: s[:schema], api_version: s[:api_version])
+      #   end
       #
       def register(kind, schema:, api_version:)
         require "json"
@@ -117,10 +117,26 @@ module Kube
         end
       end
 
-      # Build a Resource from a hash.
-      #   Kube::Schema.parse(Kube::Schema["Deployment"].to_h) == Kube::Schema["Deployment"]
+      # Build a typed Resource from a raw hash.
+      #
+      # Looks up the "kind" key in the hash and resolves it to the
+      # correct Resource subclass via the schema registry. The hash
+      # may use string or symbol keys.
+      #
+      #   Kube::Schema.parse("kind" => "Deployment", "apiVersion" => "apps/v1")
+      #   Kube::Schema.parse(kind: "Pod", apiVersion: "v1", metadata: { name: "web" })
+      #
+      # @param hash [Hash] a Kubernetes resource hash with at least a "kind" key
+      # @return [Resource] a schema-validated Resource instance
+      # @raise [ArgumentError] if the hash is nil, not a Hash, or missing "kind"
       def parse(hash)
-        raise NotImplementedError
+        raise ArgumentError, "Expected a Hash, got #{hash.class}" unless hash.is_a?(Hash)
+
+        kind = hash["kind"] || hash[:kind]
+        raise ArgumentError, "Hash must contain a \"kind\" key" if kind.nil?
+
+        resource_class = self[kind]
+        resource_class.new(hash)
       end
 
       # Available Kubernetes versions, read from the local schemas directory.
@@ -192,3 +208,152 @@ class BlackHoleStruct
     end
   end
 end
+
+if __FILE__ == $0
+  require "bundler/setup"
+  require "rspec/autorun"
+
+  RSpec.describe Kube::Schema do
+    describe "::VERSION" do
+      it "is defined" do
+        expect(Kube::Schema::VERSION).not_to be_nil
+      end
+
+      it "is a valid semver string" do
+        expect(Kube::Schema::VERSION).to match(/\A\d+\.\d+\.\d+\z/)
+      end
+    end
+
+    describe "::DEFAULT_VERSION" do
+      it "is a version present in schema_versions" do
+        expect(Kube::Schema.schema_versions).to include(Kube::Schema::DEFAULT_VERSION)
+      end
+    end
+
+    describe ".schema_versions" do
+      it "returns an array of version strings" do
+        versions = Kube::Schema.schema_versions
+        expect(versions).to be_an(Array)
+        expect(versions).not_to be_empty
+        expect(versions).to all(match(/\A\d+\.\d+/))
+      end
+
+      it "is sorted by Gem::Version" do
+        versions = Kube::Schema.schema_versions
+        sorted = versions.sort_by { |v| Gem::Version.new(v) }
+        expect(versions).to eq(sorted)
+      end
+
+      it "does not include a leading 'v' prefix" do
+        expect(Kube::Schema.schema_versions).to all(satisfy { |v| !v.start_with?("v") })
+      end
+    end
+
+    describe ".latest_version" do
+      it "returns the last element of schema_versions" do
+        expect(Kube::Schema.latest_version).to eq(Kube::Schema.schema_versions.last)
+      end
+    end
+
+    describe ".[]" do
+      context "with a version string" do
+        it "returns an Instance for a known version" do
+          instance = Kube::Schema["1.34"]
+          expect(instance).to be_a(Kube::Schema::Instance)
+          expect(instance.version).to eq("1.34")
+        end
+
+        it "caches Instance objects by version" do
+          a = Kube::Schema["1.34"]
+          b = Kube::Schema["1.34"]
+          expect(a).to be(b)
+        end
+
+        it "raises UnknownVersionError for an invalid version" do
+          expect { Kube::Schema["0.0.1"] }.to raise_error(Kube::UnknownVersionError)
+        end
+      end
+
+      context "with a resource name" do
+        it "returns a Class that subclasses Resource" do
+          klass = Kube::Schema["Deployment"]
+          expect(klass).to be_a(Class)
+          expect(klass).to be < Kube::Schema::Resource
+        end
+      end
+
+      context "with a 'v'-prefixed version string" do
+        it "raises IncorrectVersionFormat" do
+          expect { Kube::Schema["v1.34"] }.to raise_error(
+            Kube::IncorrectVersionFormat,
+            /Don't preface the version with a "v"/
+          )
+        end
+
+        it "suggests the correct format in the error message" do
+          expect { Kube::Schema["v1.34"] }.to raise_error(
+            Kube::IncorrectVersionFormat,
+            /Use Kube::Schema\["1\.34"\] instead/
+          )
+        end
+      end
+    end
+
+    describe ".parse" do
+      it "returns a typed Resource for a known kind" do
+        resource = Kube::Schema.parse("kind" => "Deployment", "apiVersion" => "apps/v1")
+        expect(resource).to be_a(Kube::Schema::Resource)
+        expect(resource.kind).to eq("Deployment")
+        expect(resource.apiVersion).to eq("apps/v1")
+      end
+
+      it "works with symbol keys" do
+        resource = Kube::Schema.parse(kind: "Pod", apiVersion: "v1", metadata: { name: "web" })
+        expect(resource).to be_a(Kube::Schema::Resource)
+        expect(resource.kind).to eq("Pod")
+        expect(resource.metadata.name).to eq("web")
+      end
+
+      it "returns a class backed by the correct schema" do
+        resource = Kube::Schema.parse("kind" => "Service", "apiVersion" => "v1")
+        expect(resource.class.schema).not_to be_nil
+        expect(resource.class.defaults).to eq({ "apiVersion" => "v1", "kind" => "Service" })
+      end
+
+      it "round-trips through to_h" do
+        original = Kube::Schema["Deployment"].new {
+          metadata.name = "web"
+          spec.replicas = 3
+          spec.selector.matchLabels = { app: "web" }
+          spec.template.metadata.labels = { app: "web" }
+          spec.template.spec.containers = [{ name: "web", image: "nginx" }]
+        }
+        parsed = Kube::Schema.parse(original.to_h)
+        expect(parsed.kind).to eq("Deployment")
+        expect(parsed.metadata.name).to eq("web")
+      end
+
+      it "raises ArgumentError for a non-Hash" do
+        expect { Kube::Schema.parse("not a hash") }.to raise_error(ArgumentError, /Expected a Hash/)
+      end
+
+      it "raises ArgumentError when kind is missing" do
+        expect { Kube::Schema.parse("apiVersion" => "v1") }.to raise_error(ArgumentError, /kind/)
+      end
+
+      it "raises RuntimeError for an unknown kind" do
+        expect { Kube::Schema.parse("kind" => "BogusKind", "apiVersion" => "v1") }.to raise_error(RuntimeError)
+      end
+    end
+
+    describe ".has_version?" do
+      it "returns true for a known version" do
+        expect(Kube::Schema.has_version?(Kube::Schema::DEFAULT_VERSION)).to be true
+      end
+
+      it "returns false for an unknown version" do
+        expect(Kube::Schema.has_version?("0.0.1")).to be false
+      end
+    end
+  end
+end