kube_schema 1.3.2 → 1.3.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d74795f238283bb03bba7c2a82459475512cf3922704870aa2256f6235410d66
-  data.tar.gz: 19d329b7abbad3dbf5d37daa8202a457ec14c26f23a078bafaf1e1f10c67abe1
+  metadata.gz: a57b14228a491e69ae291d85208d7a4d9ab0ff4dfe0d1c8fe516dee313da896d
+  data.tar.gz: f7ca2465bc0a0867db00d3f8dd6e28235f86a626746fa6c0fad35bedc153d377
 SHA512:
-  metadata.gz: f11cfd8ce0f92d2c7b824eba56559860a95eca65e2c13ffbcd8177f296b26fabcf395fb66c16d8d4533fbb188e81698f4560d8f3a5f08d2536b2a8d36557eff7
-  data.tar.gz: 7af51b827644818da72e031e858f47697678dc8d97929c7d2e5bfcd964e2202ede1507f0f20e63ba64dec6a2bebdb0e2128a99a0085fa3562ce3fac1a8d241d0
+  metadata.gz: 05decddd173ef72baa520b33d00749bafe275c20411dda61984855b0a000446bc29731d861246b529b5d69148419631741af7e3485a1fcd2f019aa69d30840ec
+  data.tar.gz: 53aad4ff4cbc381fde9b8f41c6e2b0744c3e7427bb9e908e33d741450b15c751a8f827727ce229425bedaecf764e0572ef82915a8d9b885c46572ef6b7f57e27

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.1)
+    kube_schema (1.3.5)
       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/schema/instance.rb

@@ -101,6 +101,14 @@ module Kube
               schema["definitions"].merge!(extra)
             end
 
+            # Kubernetes OpenAPI v2 defines IntOrString as "type": "string"
+            # with "format": "int-or-string". This is a limitation of
+            # OpenAPI v2 which cannot express union types. Patch the
+            # definition so JSONSchemer accepts both integers and strings.
+            if (int_or_str = schema.dig("definitions", "io.k8s.apimachinery.pkg.util.intstr.IntOrString"))
+              int_or_str["type"] = ["string", "integer"]
+            end
+
             JSONSchemer.schema(schema)
           end
         end
@@ -184,6 +192,7 @@ module Kube
           Class.new(::Kube::Schema::Resource) do
             @schema = schema_instance
             @defaults = defaults
+            @schema_properties = @schema.value["properties"].keys.map(&:to_sym)
 
             def self.schema
               @schema || superclass.schema
@@ -192,6 +201,16 @@ module Kube
             def self.defaults
               @defaults || superclass.defaults
             end
+
+            def self.schema_properties
+              @schema_properties
+            end
+
+            schema_instance.value["properties"].keys.then do |properties|
+              properties.each do |prop|
+                define_method(prop.to_sym) { @data[prop.to_sym] }
+              end
+            end
           end
         end
 
@@ -203,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