kube_schema 1.3.4 → 1.3.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 193f973be41e7f42709ecf8d2407d47d7200ab399a441563b34342149f759956
-  data.tar.gz: 3a931d60cf56e1d03ed9a25eee098978a1e6f647113dc22f05f1858d0d03e045
+  metadata.gz: 40d05fe2759f67a63efc0f207fe42c311893fc35c5f40d3a8aac02a8b86c1ec7
+  data.tar.gz: de1aef2abe561eed7956296c9b471545a808f037c0e38edf7b4c1d8f3238e7b6
 SHA512:
-  metadata.gz: d789cd2fe143a465f645f73fb7d6ecc0882ace1bbaadca2513b26053efff52bd1c162aff2fe43ee25e0bd600024366db92a221b855562d3eef4b44025f691daf
-  data.tar.gz: 94642b199d333cb7da54cc324c0ee29641431bcc4884e38b7e24e6d47eb97f886ece7f680f3923c336c62a55ff171d247d8578abde94e10cee0c5eda8a8759a6
+  metadata.gz: c44beed6e0457d616a2c553282a1004ce0b58fe33698b3608c881549b4bd05d7ef603bdb7d06271f74b87c8966d45ed3334792733fae0b3ef94bec2bfaf560d7
+  data.tar.gz: a521d2724f4c293465c2357d60f8043ac743f37b26fa690e3a6a31fd7e4a29ad26fcf40adcd4452f84245fc28507ea82122cc0ca5ac2daedeeee33079a7df635

data/.gitignore

@@ -1,5 +1,6 @@
 *.gem
 .direnv
+kubeconfig.yaml
 /.bundle/
 /coverage/
 /pkg/

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    kube_schema (1.3.3)
+    kube_schema (1.3.6)
       json_schemer (~> 2.5.0)
       rubyshell (~> 1.5.0)
 

data/Rakefile

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require "rspec/core/rake_task"
+task :test do
+  Dir["lib/**/*.rb"].each { |f| sh "ruby", f }
+end
 
-RSpec::Core::RakeTask.new(:spec)
-
-task default: :spec
+task default: :test

data/bin/increment-version

@@ -40,4 +40,6 @@ result = template.result(binding)
 
 File.write(output_path, result)
 
+`bundle install`
+
 puts "#{current} -> #{version}"

data/bin/test

@@ -1,12 +1,10 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-require "bundler/setup"
-
 Dir.chdir(File.expand_path("..", __dir__))
 
-if ARGV.empty?
-  exec("bundle", "exec", "rspec")
-else
-  exec("bundle", "exec", "rspec", *ARGV)
+files = ARGV.empty? ? Dir.glob("lib/**/*.rb").sort : ARGV
+
+files.each do |f|
+  system("bundle", "exec", "ruby", f, exception: true)
 end

data/lib/kube/errors.rb

@@ -309,3 +309,453 @@ module Kube
     end
   end
 end
+
+if __FILE__ == $0
+  require "bundler/setup"
+  require "rspec/autorun"
+  require "kube/schema"
+
+  RSpec.describe Kube::ValidationError do
+    # Helper to build a minimal JSONSchemer-style error hash.
+    def error_hash(overrides = {})
+      {
+        "data" => nil,
+        "data_pointer" => "",
+        "schema" => {},
+        "schema_pointer" => "",
+        "root_schema" => {},
+        "type" => "unknown",
+        "error" => "something went wrong"
+      }.merge(overrides)
+    end
+
+    describe "#message" do
+      context "header" do
+        it "includes kind and name when both are provided" do
+          err = described_class.new(
+            [error_hash],
+            kind: "Deployment",
+            name: "web"
+          )
+          expect(err.message).to include('Schema validation failed for Deployment "web"')
+        end
+
+        it "includes kind without name" do
+          err = described_class.new(
+            [error_hash],
+            kind: "Service"
+          )
+          expect(err.message).to include("Schema validation failed for Service")
+        end
+
+        it "shows a generic header when no kind or name" do
+          err = described_class.new([error_hash])
+          expect(err.message).to include("Schema validation failed")
+        end
+      end
+
+      context "type errors" do
+        %w[string integer number boolean array object null].each do |type|
+          it "formats #{type} type mismatch with the actual value" do
+            err = described_class.new([
+              error_hash(
+                "data_pointer" => "/spec/replicas",
+                "type" => type,
+                "data" => "bad_value"
+              )
+            ])
+            expect(err.message).to include("spec.replicas = \"bad_value\" — expected #{type}, got String")
+          end
+        end
+
+        it "shows integer value for string type error" do
+          err = described_class.new([
+            error_hash(
+              "data_pointer" => "/spec/template/image",
+              "type" => "string",
+              "data" => 2343
+            )
+          ])
+          expect(err.message).to include("spec.template.image = 2343 — expected string, got Integer")
+        end
+      end
+
+      context "required errors" do
+        it "expands each missing key onto its own line" do
+          err = described_class.new([
+            error_hash(
+              "data_pointer" => "/spec",
+              "type" => "required",
+              "details" => { "missing_keys" => %w[selector template] }
+            )
+          ])
+          expect(err.message).to include("spec.selector is required but missing")
+          expect(err.message).to include("spec.template is required but missing")
+        end
+
+        it "handles required at root level" do
+          err = described_class.new([
+            error_hash(
+              "data_pointer" => "",
+              "type" => "required",
+              "details" => { "missing_keys" => ["spec"] }
+            )
+          ])
+          expect(err.message).to include("spec is required but missing")
+        end
+
+        it "falls back gracefully if missing_keys is absent" do
+          err = described_class.new([
+            error_hash(
+              "data_pointer" => "/spec",
+              "type" => "required",
+              "details" => {}
+            )
+          ])
+          # Should not raise, should produce some message
+          expect(err.message).to include("spec")
+        end
+      end
+
+      context "numeric constraint errors" do
+        it "formats minimum violations" do
+          err = described_class.new([
+            error_hash(
+              "data_pointer" => "/spec/replicas",
+              "type" => "minimum",
+              "data" => -1,
+              "schema" => { "minimum" => 0 }
+            )
+          ])
+          expect(err.message).to include("spec.replicas = -1 — must be >= 0")
+        end
+
+        it "formats maximum violations" do
+          err = described_class.new([
+            error_hash(
+              "data_pointer" => "/spec/replicas",
+              "type" => "maximum",
+              "data" => 999,
+              "schema" => { "maximum" => 100 }
+            )
+          ])
+          expect(err.message).to include("spec.replicas = 999 — must be <= 100")
+        end
+
+        it "formats exclusiveMinimum violations" do
+          err = described_class.new([
+            error_hash(
+              "data_pointer" => "/spec/value",
+              "type" => "exclusiveMinimum",
+              "data" => 0,
+              "schema" => { "exclusiveMinimum" => 0 }
+            )
+          ])
+          expect(err.message).to include("spec.value = 0 — must be > 0")
+        end
+
+        it "formats exclusiveMaximum violations" do
+          err = described_class.new([
+            error_hash(
+              "data_pointer" => "/spec/value",
+              "type" => "exclusiveMaximum",
+              "data" => 100,
+              "schema" => { "exclusiveMaximum" => 100 }
+            )
+          ])
+          expect(err.message).to include("spec.value = 100 — must be < 100")
+        end
+
+        it "formats multipleOf violations" do
+          err = described_class.new([
+            error_hash(
+              "data_pointer" => "/spec/count",
+              "type" => "multipleOf",
+              "data" => 7,
+              "schema" => { "multipleOf" => 3 }
+            )
+          ])
+          expect(err.message).to include("spec.count = 7 — must be a multiple of 3")
+        end
+      end
+
+      context "string constraint errors" do
+        it "formats pattern violations" do
+          err = described_class.new([
+            error_hash(
+              "data_pointer" => "/metadata/name",
+              "type" => "pattern",
+              "data" => "INVALID",
+              "schema" => { "pattern" => "^[a-z0-9-]+$" }
+            )
+          ])
+          expect(err.message).to include('metadata.name = "INVALID" — does not match pattern: ^[a-z0-9-]+$')
+        end
+
+        it "formats minLength violations" do
+          err = described_class.new([
+            error_hash(
+              "data_pointer" => "/metadata/name",
+              "type" => "minLength",
+              "data" => "",
+              "schema" => { "minLength" => 1 }
+            )
+          ])
+          expect(err.message).to include('metadata.name = "" — length must be >= 1')
+        end
+
+        it "formats maxLength violations" do
+          err = described_class.new([
+            error_hash(
+              "data_pointer" => "/metadata/name",
+              "type" => "maxLength",
+              "data" => "a" * 300,
+              "schema" => { "maxLength" => 253 }
+            )
+          ])
+          expect(err.message).to include("metadata.name =")
+          expect(err.message).to include("— length must be <= 253")
+        end
+      end
+
+      context "enum errors" do
+        it "shows allowed values" do
+          err = described_class.new([
+            error_hash(
+              "data_pointer" => "/spec/type",
+              "type" => "enum",
+              "data" => "InvalidType",
+              "schema" => { "enum" => %w[ClusterIP NodePort LoadBalancer] }
+            )
+          ])
+          expect(err.message).to include('"InvalidType" — must be one of:')
+          expect(err.message).to include("ClusterIP")
+        end
+      end
+
+      context "format errors" do
+        it "shows the expected format" do
+          err = described_class.new([
+            error_hash(
+              "data_pointer" => "/spec/startTime",
+              "type" => "format",
+              "data" => "not-a-date",
+              "schema" => { "format" => "date-time" }
+            )
+          ])
+          expect(err.message).to include('spec.startTime = "not-a-date" — invalid date-time format')
+        end
+      end
+
+      context "array constraint errors" do
+        it "formats minItems violations" do
+          err = described_class.new([
+            error_hash(
+              "data_pointer" => "/spec/containers",
+              "type" => "minItems",
+              "data" => [],
+              "schema" => { "minItems" => 1 }
+            )
+          ])
+          expect(err.message).to include("spec.containers — array must have >= 1 items, got 0")
+        end
+
+        it "formats uniqueItems violations" do
+          err = described_class.new([
+            error_hash(
+              "data_pointer" => "/spec/ports",
+              "type" => "uniqueItems",
+              "data" => [80, 80]
+            )
+          ])
+          expect(err.message).to include("spec.ports — array items must be unique")
+        end
+      end
+
+      context "unknown error types" do
+        it "falls back to JSONSchemer's error message" do
+          err = described_class.new([
+            error_hash(
+              "data_pointer" => "/spec/something",
+              "type" => "oneOf",
+              "error" => "value at `/spec/something` does not match exactly one schema"
+            )
+          ])
+          expect(err.message).to include("spec.something: value at `/spec/something` does not match exactly one schema")
+        end
+
+        it "falls back to the type name when no error message exists" do
+          err = described_class.new([
+            error_hash(
+              "data_pointer" => "/spec/x",
+              "type" => "customKeyword",
+              "error" => nil
+            )
+          ])
+          expect(err.message).to include("spec.x: customKeyword")
+        end
+      end
+
+      context "value truncation" do
+        it "truncates long values" do
+          long_value = "a" * 200
+          err = described_class.new([
+            error_hash(
+              "data_pointer" => "/spec/data",
+              "type" => "integer",
+              "data" => long_value
+            )
+          ])
+          expect(err.message).to include("...")
+          expect(err.message.length).to be < 500
+        end
+      end
+
+      context "dot-notation path conversion" do
+        it "converts JSON pointers to dot notation" do
+          err = described_class.new([
+            error_hash(
+              "data_pointer" => "/spec/template/spec/containers/0/image",
+              "type" => "string",
+              "data" => 123
+            )
+          ])
+          expect(err.message).to include("spec.template.spec.containers.0.image = 123")
+        end
+
+        it "uses 'root' for empty pointer" do
+          err = described_class.new([
+            error_hash(
+              "data_pointer" => "",
+              "type" => "object",
+              "data" => "not_an_object"
+            )
+          ])
+          expect(err.message).to include("root = ")
+        end
+      end
+    end
+
+    describe "#errors" do
+      it "exposes the raw JSONSchemer error hashes" do
+        raw = [error_hash("type" => "string")]
+        err = described_class.new(raw)
+        expect(err.errors).to equal(raw)
+      end
+    end
+
+    describe "annotated manifest output" do
+      it "includes the resource YAML when manifest is provided" do
+        manifest = {
+          "apiVersion" => "apps/v1",
+          "kind" => "Deployment",
+          "metadata" => { "name" => "web", "namespace" => "prod" },
+          "spec" => { "replicas" => "bad" }
+        }
+        err = described_class.new(
+          [error_hash("data_pointer" => "/spec/replicas", "type" => "integer", "data" => "bad")],
+          kind: "Deployment",
+          name: "web",
+          manifest: manifest
+        )
+        expect(err.message).to include("apiVersion: apps/v1")
+        expect(err.message).to include("kind: Deployment")
+        expect(err.message).to include("name: web")
+        expect(err.message).to include("namespace: prod")
+        expect(err.message).to include("replicas: bad")
+      end
+
+      it "highlights error lines in red (ANSI)" do
+        manifest = {
+          "apiVersion" => "apps/v1",
+          "kind" => "Deployment",
+          "spec" => { "replicas" => "bad" }
+        }
+        err = described_class.new(
+          [error_hash("data_pointer" => "/spec/replicas", "type" => "integer", "data" => "bad")],
+          manifest: manifest
+        )
+        # The replicas line should be wrapped in red ANSI
+        expect(err.message).to include("\033[31m")
+        expect(err.message).to match(/\033\[31m\s*replicas: bad\033\[0m/)
+      end
+
+      it "appends a yellow inline comment on error lines" do
+        manifest = {
+          "apiVersion" => "v1",
+          "kind" => "Pod",
+          "spec" => { "replicas" => "bad" }
+        }
+        err = described_class.new(
+          [error_hash("data_pointer" => "/spec/replicas", "type" => "integer", "data" => "bad")],
+          manifest: manifest
+        )
+        expect(err.message).to match(/\033\[33m# expected integer, got String\033\[0m/)
+      end
+
+      it "injects missing required keys as red lines" do
+        manifest = {
+          "apiVersion" => "apps/v1",
+          "kind" => "Deployment",
+          "spec" => { "replicas" => 3 }
+        }
+        err = described_class.new(
+          [error_hash(
+            "data_pointer" => "/spec",
+            "type" => "required",
+            "details" => { "missing_keys" => ["selector"] }
+          )],
+          manifest: manifest
+        )
+        expect(err.message).to match(/\033\[31m\s*selector:\033\[0m/)
+        expect(err.message).to include("MISSING")
+      end
+
+      it "does not color lines that have no errors" do
+        manifest = {
+          "apiVersion" => "apps/v1",
+          "kind" => "Deployment",
+          "metadata" => { "name" => "web" },
+          "spec" => { "replicas" => "bad" }
+        }
+        err = described_class.new(
+          [error_hash("data_pointer" => "/spec/replicas", "type" => "integer", "data" => "bad")],
+          manifest: manifest
+        )
+        # The "name: web" line should NOT have red ANSI
+        err.message.each_line do |line|
+          next unless line.include?("name: web")
+          expect(line).not_to include("\033[31m")
+        end
+      end
+
+      it "handles array items with correct pointer mapping" do
+        manifest = {
+          "apiVersion" => "v1",
+          "kind" => "Pod",
+          "spec" => {
+            "containers" => [
+              { "name" => "app", "image" => 2343 }
+            ]
+          }
+        }
+        err = described_class.new(
+          [error_hash(
+            "data_pointer" => "/spec/containers/0/image",
+            "type" => "string",
+            "data" => 2343
+          )],
+          manifest: manifest
+        )
+        expect(err.message).to match(/\033\[31m\s*image: 2343\033\[0m/)
+      end
+
+      it "omits the manifest section when manifest is nil" do
+        err = described_class.new(
+          [error_hash("data_pointer" => "/spec/x", "type" => "string", "data" => 1)]
+        )
+        expect(err.message).not_to include("---")
+      end
+    end
+  end
+end

data/lib/kube/monkey_patches.rb

@@ -20,4 +20,17 @@ class Hash
   #def respond_to_missing(name, _priv = false)
   #  name.to_s.end_with?("=") || key?(name.to_sym)
   #end
+
+  # Build a Hash with autovivification via a block DSL.
+  #
+  #   Hash.vivify {
+  #     metadata.name = "web"
+  #     spec.replicas = 3
+  #     spec.selector.matchLabels.app = "web"
+  #   }
+  #   # => { metadata: { name: "web" }, spec: { replicas: 3, selector: { matchLabels: { app: "web" } } } }
+  #
+  def self.vivify(&block)
+    new.tap { |h| h.instance_exec(&block) }
+  end
 end

data/lib/kube/schema/instance.rb

@@ -222,3 +222,103 @@ module Kube
     end
   end
 end
+
+if __FILE__ == $0
+  require "bundler/setup"
+  require "rspec/autorun"
+  require "kube/schema"
+
+  RSpec.describe Kube::Schema::Instance do
+    subject(:instance) { described_class.new("1.34") }
+
+    describe "#initialize" do
+      it "stores the version" do
+        expect(instance.version).to eq("1.34")
+      end
+
+      it "raises UnknownVersionError for a non-version string" do
+        expect { described_class.new("not-a-version") }.to raise_error(Kube::UnknownVersionError)
+      end
+    end
+
+    describe "#[]" do
+      it "returns a Class that subclasses Resource" do
+        klass = instance["Deployment"]
+        expect(klass).to be_a(Class)
+        expect(klass).to be < Kube::Schema::Resource
+      end
+
+      it "caches resource classes by key" do
+        a = instance["Deployment"]
+        b = instance["Deployment"]
+        expect(a).to be(b)
+      end
+
+      it "raises for an unknown resource" do
+        expect { instance["ThisDoesNotExist999"] }.to raise_error(RuntimeError, /No resource schema found/)
+      end
+
+      it "returns different classes for different resources" do
+        deployment = instance["Deployment"]
+        service = instance["Service"]
+        expect(deployment).not_to eq(service)
+      end
+
+      it "attaches a schema to the resource class" do
+        klass = instance["Deployment"]
+        expect(klass.schema).not_to be_nil
+      end
+
+      it "is case-insensitive" do
+        a = instance["Deployment"]
+        b = instance["deployment"]
+        expect(a).to be < Kube::Schema::Resource
+        expect(b).to be < Kube::Schema::Resource
+      end
+
+      it "produces resources that can be instantiated with the block DSL" do
+        resource = instance["Deployment"].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 "attaches defaults (apiVersion and kind) to the resource class" do
+        klass = instance["Deployment"]
+        expect(klass.defaults).to eq({ "apiVersion" => "apps/v1", "kind" => "Deployment" })
+      end
+
+      it "derives correct apiVersion for core resources (empty group)" do
+        klass = instance["Pod"]
+        expect(klass.defaults).to eq({ "apiVersion" => "v1", "kind" => "Pod" })
+      end
+
+      it "derives correct apiVersion for grouped resources" do
+        klass = instance["Ingress"]
+        expect(klass.defaults).to eq({ "apiVersion" => "networking.k8s.io/v1", "kind" => "Ingress" })
+      end
+    end
+
+    describe "#list_resources" do
+      it "returns a sorted array of kind strings" do
+        kinds = instance.list_resources
+        expect(kinds).to be_an(Array)
+        expect(kinds).not_to be_empty
+        expect(kinds).to include("Deployment", "Service", "Namespace", "Pod")
+        expect(kinds).to eq(kinds.sort)
+      end
+    end
+
+    describe "class-level schemer cache" do
+      it "shares the schemer across instances of the same version" do
+        a = described_class.new("1.34")
+        b = described_class.new("1.34")
+        # Both should resolve without error and return equivalent classes
+        expect(a["Deployment"]).to be < Kube::Schema::Resource
+        expect(b["Deployment"]).to be < Kube::Schema::Resource
+      end
+    end
+  end
+end