kube_schema 1.12.0 → 2.0.0

data/lib/kube/schema/instance.rb

@@ -5,24 +5,20 @@ require "json_schemer"
 
 module Kube
   module Schema
-    # Represents a single Kubernetes version's OpenAPI schema.
-    # Lazily loads the Swagger JSON once per version (shared across instances)
-    # and builds resource classes by kind.
+    # One Kubernetes version's OpenAPI schema.
     #
+    # @example
     #   instance = Kube::Schema::Instance.new("1.34")
     #   instance["Deployment"]           # => Resource subclass
     #   instance["NetworkPolicy"]        # => Resource subclass
     #   instance.list_resources          # => sorted array of kind strings
-    #
     class Instance
       attr_reader :version
 
-      # Class-level cache so multiple Instance objects for the same version
-      # share the parsed Swagger schema.
-      @schemers = {}
+      @catalogs = {}
 
       class << self
-        attr_reader :schemers
+        attr_reader :catalogs
       end
 
       def initialize(version)
@@ -40,16 +36,14 @@ module Kube
 
       # Look up a resource by kind or full GVK string.
       #
-      # Accepts:
-      #   instance["Deployment"]                      — kind-only lookup
-      #   instance["apps/v1/Deployment"]              — group/version/kind
-      #   instance["v1/Pod"]                          — version/kind (core, empty group)
-      #   instance["networking.k8s.io/v1/Ingress"]    — fully qualified
-      #
-      # Returns a class that inherits from Kube::Schema::Resource.
+      # @example
+      #   instance["Deployment"]                      # kind-only lookup
+      #   instance["apps/v1/Deployment"]               # group/version/kind
+      #   instance["v1/Pod"]                           # version/kind, empty group
+      #   instance["networking.k8s.io/v1/Ingress"]     # fully qualified
       #
-      # Custom schemas registered via Kube::Schema.register take precedence
-      # over built-in definitions (kind-only lookups only).
+      # @parameter input [String] a kind, or a "group/version/kind" string.
+      # @returns [Class] a class that inherits from Kube::Schema::Resource.
       def [](input)
         @resource_classes[input] ||= begin
           if input.include?("/")
@@ -69,64 +63,66 @@ module Kube
             # Custom schemas take precedence on full-GVK lookups too.
             custom = find_custom_entry_by_gvk(group, version, kind)
             if custom
-              return build_resource_class(custom[:schema], custom[:defaults])
+              entry = nil
+            else
+              entry = find_gvk_entry_by_full_gvk(group, version, kind)
             end
-
-            entry = find_gvk_entry_by_full_gvk(group, version, kind)
           else
             # Kind-only lookup — custom schemas take precedence.
             custom = find_custom_entry(input)
             if custom
-              return build_resource_class(custom[:schema], custom[:defaults])
+              entry = nil
+            else
+              entry = find_gvk_entry(input)
             end
-
-            entry = find_gvk_entry(input)
           end
 
-          if entry.nil?
-            raise "No resource schema found for #{input.inspect}!" \
-              "\nUse #list_resources to see available kinds for v#{@version}."
-          end
+          if custom
+            build_resource_class(Lazy::Source.spilled(catalog, custom[:entry]), custom[:defaults])
+          else
+            if entry.nil?
+              raise "No resource schema found for #{input.inspect}!" \
+                "\nUse #list_resources to see available kinds for v#{@version}."
+            end
 
-          ref_schema = schemer.ref("#/definitions/#{entry[:definition_key]}")
-          build_resource_class(ref_schema, entry[:defaults].freeze)
+            ref_schema = Lazy::Source.indexed(catalog, entry[:definition_key])
+            build_resource_class(ref_schema, entry[:defaults].freeze)
+          end
         end
       end
 
-      # All available resource kinds for this version, including any
-      # custom schemas registered via Kube::Schema.register.
-      #
-      # @return [Array<String>] sorted kind names
+      # All resource kinds for this version, plus custom ones.
+      # @returns [Array(String)] sorted kind names.
       def list_resources
         custom_kinds = Schema.custom_schemas.values.map { |v| v[:defaults]["kind"] }
         (gvk_index.keys + custom_kinds).uniq.sort
       end
 
-      # All API groups known to this version, including any custom schemas
-      # registered via Kube::Schema.register. The core API group is the
-      # empty string.
+      # All API groups for this version, plus custom ones.
       #
+      # @example
       #   instance.api_groups # => ["", "apps", "argoproj.io", "batch", ...]
       #
-      # @return [Array<String>] sorted, deduplicated group names
+      # @returns [Array(String)] sorted, deduplicated group names.
       def api_groups
         custom_groups = Schema.custom_schemas.keys.filter_map do |key|
           parts = key.split("/")
-          parts.first if parts.size == 3
+          if parts.size == 3
+            parts.first
+          end
         end
         (gvk_index.values.flatten.map { |entry| entry[:group] } + custom_groups).uniq.sort
       end
 
-      # Look up a sub-spec definition by short name (e.g. "Container",
-      # "ContainerPort", "Volume", "Probe"). Returns a class that
-      # inherits from Kube::Schema::SubSpec.
-      #
-      # Also accepts a full definition key like
-      # "io.k8s.api.core.v1.Container" for disambiguation.
+      # Look up a sub-spec definition by short or full name.
       #
+      # @example
       #   instance.sub_spec("Container")     # => SubSpec subclass
       #   instance.sub_spec("ContainerPort") # => SubSpec subclass
+      #   instance.sub_spec("io.k8s.api.core.v1.Container") # disambiguated
       #
+      # @parameter name [String] a short name or a full definition key.
+      # @returns [Class] a class that inherits from Kube::Schema::SubSpec.
       def sub_spec(name)
         @sub_spec_classes[name] ||= begin
           definition_key = find_definition_key(name)
@@ -136,31 +132,23 @@ module Kube
               "\nUse #list_definitions to see available definitions for v#{version}."
           end
 
-          ref_schema = schemer.ref("#/definitions/#{definition_key}")
+          ref_schema = Lazy::Source.indexed(catalog, definition_key)
           build_sub_spec_class(ref_schema, name)
         end
       end
 
-      # All available definition short names for this version.
-      #
-      # @return [Array<String>] sorted, deduplicated short names
+      # All definition short names for this version.
+      # @returns [Array(String)] sorted, deduplicated short names.
       def list_definitions
-        schemer.value.fetch("definitions", {}).keys
+        catalog.keys
           .map { |k| k.split(".").last }
           .uniq.sort
       end
 
       private
 
-        # The JSONSchemer instance for this version's Swagger document.
-        # Cached at the class level so it's built once per version.
-        #
-        # After loading the base Swagger JSON, merges in any extra definition
-        # files found in the schemas directory (e.g. crd-definitions.json,
-        # loft-definitions.json). These files are flat JSON objects where keys
-        # are definition names and values are OpenAPI v2 schema objects.
-        def schemer
-          self.class.schemers[@version] ||= begin
+        def catalog
+          self.class.catalogs[@version] ||= begin
             path = File.join(SCHEMAS_DIR, "v#{version}.json")
 
             unless File.exist?(path)
@@ -169,70 +157,54 @@ module Kube
                 "\nUse `Kube::Schema.schema_versions` to get a list."
             end
 
-            schema = JSON.parse(File.read(path))
+            extra = Dir.glob(File.join(SCHEMAS_DIR, "*-definitions.json")).sort
 
-            # Merge extra definition files (*-definitions.json) into the
-            # base schema so CRD and aggregated-API types (e.g. loft,
-            # gateway-api) are available alongside built-in k8s types.
-            Dir.glob(File.join(SCHEMAS_DIR, "*-definitions.json")).each do |defs_path|
-              extra = JSON.parse(File.read(defs_path))
-              schema["definitions"] ||= {}
-              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)
+            Lazy::Index.build([path] + extra)
           end
         end
 
-        # Builds a map from kind to full GVK entry:
+        # Builds a map from kind to full GVK entry.
+        # @returns [Hash] kind => Array of entry hashes, keyed by GVK.
+        #
+        # @example
         #   {
-        #     "Deployment" => {
+        #     "Deployment" => [{
         #       definition_key: "io.k8s.api.apps.v1.Deployment",
         #       group: "apps",
         #       version: "v1",
         #       kind: "Deployment",
         #       defaults: { "apiVersion" => "apps/v1", "kind" => "Deployment" }
-        #     },
-        #     "Pod" => {
-        #       definition_key: "io.k8s.api.core.v1.Pod",
-        #       group: "",
-        #       version: "v1",
-        #       kind: "Pod",
-        #       defaults: { "apiVersion" => "v1", "kind" => "Pod" }
-        #     },
-        #     ...
+        #     }]
         #   }
         def gvk_index
           @gvk_index ||= begin
             index = Hash.new { |h, k| h[k] = [] }
 
-            schemer.value.fetch("definitions", {}).each do |key, definition|
-              gvks = definition["x-kubernetes-group-version-kind"]
-              next unless gvks
+            catalog.entries.each do |key, entry|
+              gvks = entry.gvks
+              unless gvks
+                next
+              end
 
               gvks.each do |gvk|
                 group = gvk["group"].to_s
                 version = gvk["version"]
                 kind = gvk["kind"]
-                api_version = group.empty? ? version : "#{group}/#{version}"
+                if group.empty?
+                  api_version = version
+                else
+                  api_version = "#{group}/#{version}"
+                end
 
                 index[kind] << {
                   definition_key: key,
-                  group: group,
-                  version: version,
-                  kind: kind,
-                  defaults: {
+                  group:          group,
+                  version:        version,
+                  kind:           kind,
+                  defaults:       {
                     "apiVersion" => api_version,
-                    "kind" => kind
-                  }
+                    "kind"       => kind,
+                  },
                 }
               end
             end
@@ -241,50 +213,66 @@ module Kube
           end
         end
 
-        # Find a GVK entry by kind name (case-insensitive).
-        # Returns the first matching entry hash or nil.
+        # Find a GVK entry by kind name, case-insensitively.
+        # @parameter kind [String] the kind name to look up.
+        # @returns [Hash, nil] the first matching entry, if any.
         def find_gvk_entry(kind)
           entries = gvk_index[kind]
-          return entries.first if entries && !entries.empty?
-
-          gvk_index.each do |k, v|
-            return v.first if k.downcase == kind.downcase
+          if entries && !entries.empty?
+            entries.first
+          else
+            match = gvk_index.find { |k, _v| k.downcase == kind.downcase }
+            match && match[1].first
           end
-
-          nil
         end
 
         # Find a GVK entry by exact group, version, and kind.
-        # Returns the matching entry hash or nil.
+        # @parameter group [String] the API group, empty for core.
+        # @parameter version [String] the API version, e.g. "v1".
+        # @parameter kind [String] the kind name.
+        # @returns [Hash, nil] the matching entry, if any.
         def find_gvk_entry_by_full_gvk(group, version, kind)
           entries = gvk_index[kind]
-          return nil if entries.nil? || entries.empty?
-
-          entries.find do |entry|
-            entry[:group] == group && entry[:version] == version
+          if entries.nil? || entries.empty?
+            nil
+          else
+            entries.find do |entry|
+              entry[:group] == group && entry[:version] == version
+            end
           end
         end
 
-        # Find a custom schema entry by kind (case-insensitive). The registry
-        # is keyed by full GVK, so match on each entry's recorded kind. When
-        # several groups register the same kind, the first registered wins.
-        # Returns the { schema:, defaults: } hash or nil.
+        # Find a custom schema entry by kind, case-insensitively.
+        # @parameter kind [String] the kind name to look up.
+        # @returns [Hash, nil] the first-registered { entry:, defaults: } hash.
         def find_custom_entry(kind)
           registry = Schema.custom_schemas
-          registry.each_value { |v| return v if v[:defaults]["kind"] == kind }
-          registry.each_value { |v| return v if v[:defaults]["kind"].casecmp?(kind) }
-
-          nil
+          exact = registry.values.find { |v| v[:defaults]["kind"] == kind }
+          if exact
+            exact
+          else
+            registry.values.find { |v| v[:defaults]["kind"].casecmp?(kind) }
+          end
         end
 
-        # Find a custom schema entry by exact group, version, and kind.
-        # Returns the { schema:, defaults: } hash or nil.
+        # Find a custom schema entry by group, version, and kind.
+        # @parameter group [String] the API group, empty for core.
+        # @parameter version [String] the API version, e.g. "v1".
+        # @parameter kind [String] the kind name.
+        # @returns [Hash, nil] the { entry:, defaults: } hash, if any.
         def find_custom_entry_by_gvk(group, version, kind)
-          api_version = group.empty? ? version : "#{group}/#{version}"
+          if group.empty?
+            api_version = version
+          else
+            api_version = "#{group}/#{version}"
+          end
           Schema.custom_schemas["#{api_version}/#{kind}"]
         end
 
-        # Build a Resource subclass from a JSONSchemer instance and defaults hash.
+        # Build a Resource subclass from a schema and defaults.
+        # @parameter schema_instance [JSONSchemer::Schema] the resource's schema.
+        # @parameter defaults [Hash] the frozen apiVersion/kind defaults.
+        # @returns [Class] a Resource subclass bound to the schema.
         def build_resource_class(schema_instance, defaults)
           Class.new(::Kube::Schema::Resource) do
             @schema = schema_instance
@@ -311,38 +299,45 @@ module Kube
           end
         end
 
-        # Resolve a short name like "Container" to its full definition key
-        # "io.k8s.api.core.v1.Container".
+        # Resolve a short name to its full definition key.
+        #
+        # @example
+        #   find_definition_key("Container") # => "io.k8s.api.core.v1.Container"
         #
-        # Strategy:
-        #   1. Exact match on full key (for power users)
-        #   2. Short-name match on last segment
-        #   3. Prefer stable API versions (v1 > v1beta1 > v1alpha1)
+        # @parameter name [String] a short name or a full definition key.
+        # @returns [String, nil] a full key, preferring stable API versions.
         def find_definition_key(name)
-          definitions = schemer.value.fetch("definitions", {})
+          definitions = catalog.entries
 
           # Exact full-key match
-          return name if definitions.key?(name)
-
-          # Short-name matches (last segment after final ".")
-          candidates = definitions.keys.select { |k| k.split(".").last == name }
-          return nil if candidates.empty?
-          return candidates.first if candidates.size == 1
-
-          # Disambiguation: prefer stable versions, then beta, then alpha
-          candidates.min_by { |k|
-            version_segment = k.split(".")[-2].to_s
-            case version_segment
-            when /\Av\d+\z/ then [0, version_segment]
-            when /beta/      then [1, version_segment]
-            when /alpha/     then [2, version_segment]
-            else                  [3, version_segment]
+          if definitions.key?(name)
+            name
+          else
+            candidates = definitions.keys.select { |k| k.split(".").last == name }
+            if candidates.empty?
+              nil
+            else
+              if candidates.size == 1
+                candidates.first
+              else
+                candidates.min_by { |k|
+                  version_segment = k.split(".")[-2].to_s
+                  case version_segment
+                  when /\Av\d+\z/ then [0, version_segment]
+                  when /beta/      then [1, version_segment]
+                  when /alpha/     then [2, version_segment]
+                  else                  [3, version_segment]
+                  end
+                }
+              end
             end
-          }
+          end
         end
 
-        # Build a SubSpec subclass from a JSONSchemer instance and a
-        # human-readable definition name (for error messages).
+        # Build a SubSpec subclass from a schema and definition name.
+        # @parameter schema_instance [JSONSchemer::Schema] the definition's schema.
+        # @parameter definition_name [String] the name shown in error messages.
+        # @returns [Class] a SubSpec subclass bound to the schema.
         def build_sub_spec_class(schema_instance, definition_name)
           Class.new(::Kube::Schema::SubSpec) do
             @schema = schema_instance
@@ -367,8 +362,8 @@ module Kube
           end
         end
 
-        # Called by Kube::Schema.register and reset_custom_schemas! to
-        # invalidate cached resource classes so new registrations take effect.
+        # Invalidates cached resource classes after a schema registration.
+        # @returns [void] clears the resource class cache.
         def clear_resource_cache!
           @resource_classes.clear
         end
@@ -376,266 +371,252 @@ module Kube
   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") }
+__END__
 
-    describe "#initialize" do
-      it "stores the version" do
-        expect(instance.version).to eq("1.34")
-      end
+require "kube/schema"
 
-      it "raises UnknownVersionError for a non-version string" do
-        expect { described_class.new("not-a-version") }.to raise_error(Kube::UnknownVersionError)
-      end
+instance_class = Kube::Schema::Instance
+instance = instance_class.new("1.34")
+
+describe "Kube::Schema::Instance" do
+  describe "#initialize" do
+    it "stores the version" do
+      instance.version.should == "1.34"
     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 "raises UnknownVersionError for a non-version string" do
+      lambda { instance_class.new("not-a-version") }.should.raise(Kube::UnknownVersionError)
+    end
+  end
 
-      it "caches resource classes by key" do
-        a = instance["Deployment"]
-        b = instance["Deployment"]
-        expect(a).to be(b)
-      end
+  describe "#[]" do
+    it "returns a Class that subclasses Resource" do
+      klass = instance["Deployment"]
+      klass.should.be.kind_of Class
+      klass.should.be < Kube::Schema::Resource
+    end
 
-      it "raises for an unknown resource" do
-        expect { instance["ThisDoesNotExist999"] }.to raise_error(RuntimeError, /No resource schema found/)
-      end
+    it "caches resource classes by key" do
+      instance["Deployment"].should.be.identical_to instance["Deployment"]
+    end
 
-      it "returns different classes for different resources" do
-        deployment = instance["Deployment"]
-        service = instance["Service"]
-        expect(deployment).not_to eq(service)
-      end
+    it "raises for an unknown resource" do
+      error = lambda { instance["ThisDoesNotExist999"] }.should.raise(RuntimeError)
+      error.message.should.match(/No resource schema found/)
+    end
 
-      it "attaches a schema to the resource class" do
-        klass = instance["Deployment"]
-        expect(klass.schema).not_to be_nil
-      end
+    it "returns different classes for different resources" do
+      instance["Deployment"].should.not == instance["Service"]
+    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 "attaches a schema to the resource class" do
+      instance["Deployment"].schema.should.not.be.nil
+    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 "is case-insensitive" do
+      instance["Deployment"].should.be < Kube::Schema::Resource
+      instance["deployment"].should.be < Kube::Schema::Resource
+    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 "produces resources that can be instantiated with the block DSL" do
+      resource = instance["Deployment"].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 "derives correct apiVersion for core resources (empty group)" do
-        klass = instance["Pod"]
-        expect(klass.defaults).to eq({ "apiVersion" => "v1", "kind" => "Pod" })
-      end
+    it "attaches defaults (apiVersion and kind) to the resource class" do
+      instance["Deployment"].defaults.should == { "apiVersion" => "apps/v1", "kind" => "Deployment" }
+    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
+    it "derives correct apiVersion for core resources (empty group)" do
+      instance["Pod"].defaults.should == { "apiVersion" => "v1", "kind" => "Pod" }
     end
 
-    describe "#[] with full GVK string" do
-      it "resolves apps/v1/Deployment" do
-        klass = instance["apps/v1/Deployment"]
-        expect(klass).to be < Kube::Schema::Resource
-        expect(klass.defaults).to eq({ "apiVersion" => "apps/v1", "kind" => "Deployment" })
-      end
+    it "derives correct apiVersion for grouped resources" do
+      instance["Ingress"].defaults.should == { "apiVersion" => "networking.k8s.io/v1", "kind" => "Ingress" }
+    end
+  end
 
-      it "resolves v1/Pod (core resource, empty group)" do
-        klass = instance["v1/Pod"]
-        expect(klass).to be < Kube::Schema::Resource
-        expect(klass.defaults).to eq({ "apiVersion" => "v1", "kind" => "Pod" })
-      end
+  describe "#[] with full GVK string" do
+    it "resolves apps/v1/Deployment" do
+      klass = instance["apps/v1/Deployment"]
+      klass.should.be < Kube::Schema::Resource
+      klass.defaults.should == { "apiVersion" => "apps/v1", "kind" => "Deployment" }
+    end
 
-      it "resolves networking.k8s.io/v1/Ingress" do
-        klass = instance["networking.k8s.io/v1/Ingress"]
-        expect(klass).to be < Kube::Schema::Resource
-        expect(klass.defaults).to eq({ "apiVersion" => "networking.k8s.io/v1", "kind" => "Ingress" })
-      end
+    it "resolves v1/Pod (core resource, empty group)" do
+      klass = instance["v1/Pod"]
+      klass.should.be < Kube::Schema::Resource
+      klass.defaults.should == { "apiVersion" => "v1", "kind" => "Pod" }
+    end
 
-      it "resolves kubevirt.io/v1/VirtualMachine" do
-        klass = instance["kubevirt.io/v1/VirtualMachine"]
-        expect(klass).to be < Kube::Schema::Resource
-        expect(klass.defaults).to eq({ "apiVersion" => "kubevirt.io/v1", "kind" => "VirtualMachine" })
-      end
+    it "resolves networking.k8s.io/v1/Ingress" do
+      klass = instance["networking.k8s.io/v1/Ingress"]
+      klass.should.be < Kube::Schema::Resource
+      klass.defaults.should == { "apiVersion" => "networking.k8s.io/v1", "kind" => "Ingress" }
+    end
 
-      it "raises for invalid GVK format (too many slashes)" do
-        expect { instance["a/b/c/d"] }.to raise_error(RuntimeError, /Invalid GVK format/)
-      end
+    it "resolves kubevirt.io/v1/VirtualMachine" do
+      klass = instance["kubevirt.io/v1/VirtualMachine"]
+      klass.should.be < Kube::Schema::Resource
+      klass.defaults.should == { "apiVersion" => "kubevirt.io/v1", "kind" => "VirtualMachine" }
+    end
 
-      it "raises for non-existent GVK" do
-        expect { instance["fake.io/v99/Blah"] }.to raise_error(RuntimeError, /No resource schema found/)
-      end
+    it "raises for invalid GVK format (too many slashes)" do
+      error = lambda { instance["a/b/c/d"] }.should.raise(RuntimeError)
+      error.message.should.match(/Invalid GVK format/)
+    end
 
-      it "caches GVK lookups" do
-        a = instance["apps/v1/Deployment"]
-        b = instance["apps/v1/Deployment"]
-        expect(a).to be(b)
-      end
+    it "raises for non-existent GVK" do
+      error = lambda { instance["fake.io/v99/Blah"] }.should.raise(RuntimeError)
+      error.message.should.match(/No resource schema found/)
     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
+    it "caches GVK lookups" do
+      instance["apps/v1/Deployment"].should.be.identical_to instance["apps/v1/Deployment"]
     end
+  end
 
-    describe "#api_groups" do
-      it "returns a sorted array of group names including the core group" do
-        groups = instance.api_groups
-        expect(groups).to be_an(Array)
-        expect(groups).to eq(groups.sort)
-        expect(groups).to include("")
-      end
+  describe "#list_resources" do
+    it "returns a sorted array of kind strings" do
+      kinds = instance.list_resources
+      kinds.should.be.kind_of Array
+      kinds.should.not.be.empty
+      ["Deployment", "Service", "Namespace", "Pod"].each { |kind| kinds.should.include kind }
+      kinds.should == kinds.sort
+    end
+  end
 
-      it "includes built-in groups, including ones without dots" do
-        expect(instance.api_groups).to include("apps", "batch", "rbac.authorization.k8s.io")
-      end
+  describe "#api_groups" do
+    it "returns a sorted array of group names including the core group" do
+      groups = instance.api_groups
+      groups.should.be.kind_of Array
+      groups.should == groups.sort
+      groups.should.include ""
+    end
 
-      it "includes groups from the merged CRD definition bundles" do
-        expect(instance.api_groups).to include("kubevirt.io", "argoproj.io")
-      end
+    it "includes built-in groups, including ones without dots" do
+      ["apps", "batch", "rbac.authorization.k8s.io"].each { |group| instance.api_groups.should.include group }
+    end
 
-      it "includes groups from registered custom schemas" do
-        Kube::Schema.register("TenantVmClaim",
-          schema: { "type" => "object" },
-          api_version: "tradeportal.ai/v1")
-        expect(instance.api_groups).to include("tradeportal.ai")
-      ensure
-        Kube::Schema.reset_custom_schemas!
-      end
+    it "includes groups from the merged CRD definition bundles" do
+      ["kubevirt.io", "argoproj.io"].each { |group| instance.api_groups.should.include group }
     end
 
-    describe "KubeVirt schemas" do
-      it "resolves VirtualMachine" do
-        klass = instance["VirtualMachine"]
-        expect(klass).to be_a(Class)
-        expect(klass).to be < Kube::Schema::Resource
-      end
+    it "includes groups from registered custom schemas" do
+      Kube::Schema.register("TenantVmClaim",
+        schema: { "type" => "object" },
+        api_version: "tradeportal.ai/v1")
+      instance.api_groups.should.include "tradeportal.ai"
+    ensure
+      Kube::Schema.reset_custom_schemas!
+    end
+  end
 
-      it "has correct defaults for VirtualMachine" do
-        klass = instance["VirtualMachine"]
-        expect(klass.defaults).to eq({ "apiVersion" => "kubevirt.io/v1", "kind" => "VirtualMachine" })
-      end
+  describe "KubeVirt schemas" do
+    it "resolves VirtualMachine" do
+      klass = instance["VirtualMachine"]
+      klass.should.be.kind_of Class
+      klass.should.be < Kube::Schema::Resource
+    end
 
-      it "includes VirtualMachine in list_resources" do
-        expect(instance.list_resources).to include("VirtualMachine")
-      end
+    it "has correct defaults for VirtualMachine" do
+      instance["VirtualMachine"].defaults.should == { "apiVersion" => "kubevirt.io/v1", "kind" => "VirtualMachine" }
+    end
 
-      it "resolves VirtualMachineInstance" do
-        klass = instance["VirtualMachineInstance"]
-        expect(klass.defaults).to eq({ "apiVersion" => "kubevirt.io/v1", "kind" => "VirtualMachineInstance" })
-      end
+    it "includes VirtualMachine in list_resources" do
+      instance.list_resources.should.include "VirtualMachine"
+    end
 
-      it "resolves KubeVirt" do
-        klass = instance["KubeVirt"]
-        expect(klass.defaults).to eq({ "apiVersion" => "kubevirt.io/v1", "kind" => "KubeVirt" })
-      end
+    it "resolves VirtualMachineInstance" do
+      instance["VirtualMachineInstance"].defaults.should == { "apiVersion" => "kubevirt.io/v1", "kind" => "VirtualMachineInstance" }
+    end
 
-      it "can instantiate a VirtualMachine with the block DSL" do
-        resource = instance["VirtualMachine"].new {
-          metadata.name = "test-vm"
-        }
-        expect(resource.to_h[:apiVersion]).to eq("kubevirt.io/v1")
-        expect(resource.to_h[:kind]).to eq("VirtualMachine")
-        expect(resource.to_h[:metadata][:name]).to eq("test-vm")
-      end
+    it "resolves KubeVirt" do
+      instance["KubeVirt"].defaults.should == { "apiVersion" => "kubevirt.io/v1", "kind" => "KubeVirt" }
+    end
 
-      it "validates a VirtualMachine without $ref resolution errors" do
-        resource = instance["VirtualMachine"].new {
-          metadata.name = "test-vm"
-          spec.runStrategy = "Always"
-          spec.template.metadata.labels = { "kubevirt.io/vm": "test-vm" }
-          spec.template.spec.domain.cpu = { cores: 1 }
-          spec.template.spec.domain.devices = {}
-          spec.template.spec.domain.memory = { guest: "1Gi" }
-          spec.template.spec.domain.resources = { requests: { memory: "1Gi" } }
-          spec.template.spec.volumes = [
-            { name: "rootdisk", containerDisk: { image: "registry.example.com/vm:latest" } }
-          ]
-        }
-        expect { resource.to_yaml }.not_to raise_error
-      end
+    it "can instantiate a VirtualMachine with the block DSL" do
+      resource = instance["VirtualMachine"].new {
+        metadata.name = "test-vm"
+      }
+      resource.to_h[:apiVersion].should == "kubevirt.io/v1"
+      resource.to_h[:kind].should == "VirtualMachine"
+      resource.to_h[:metadata][:name].should == "test-vm"
     end
 
-    describe "CloudnativePG schemas" do
-      it "resolves Cluster by kind" do
-        klass = instance["Cluster"]
-        expect(klass).to be < Kube::Schema::Resource
-        expect(klass.defaults).to eq({ "apiVersion" => "postgresql.cnpg.io/v1", "kind" => "Cluster" })
-      end
+    it "validates a VirtualMachine without $ref resolution errors" do
+      resource = instance["VirtualMachine"].new {
+        metadata.name = "test-vm"
+        spec.runStrategy = "Always"
+        spec.template.metadata.labels = { "kubevirt.io/vm": "test-vm" }
+        spec.template.spec.domain.cpu = { cores: 1 }
+        spec.template.spec.domain.devices = {}
+        spec.template.spec.domain.memory = { guest: "1Gi" }
+        spec.template.spec.domain.resources = { requests: { memory: "1Gi" } }
+        spec.template.spec.volumes = [
+          { name: "rootdisk", containerDisk: { image: "registry.example.com/vm:latest" } }
+        ]
+      }
+      lambda { resource.to_yaml }.should.not.raise(StandardError)
+    end
+  end
 
-      it "resolves Cluster by full GVK string" do
-        klass = instance["postgresql.cnpg.io/v1/Cluster"]
-        expect(klass).to be < Kube::Schema::Resource
-        expect(klass.defaults).to eq({ "apiVersion" => "postgresql.cnpg.io/v1", "kind" => "Cluster" })
-      end
+  describe "CloudnativePG schemas" do
+    it "resolves Cluster by kind" do
+      klass = instance["Cluster"]
+      klass.should.be < Kube::Schema::Resource
+      klass.defaults.should == { "apiVersion" => "postgresql.cnpg.io/v1", "kind" => "Cluster" }
+    end
 
-      it "includes Cluster in list_resources" do
-        expect(instance.list_resources).to include("Cluster")
-      end
+    it "resolves Cluster by full GVK string" do
+      klass = instance["postgresql.cnpg.io/v1/Cluster"]
+      klass.should.be < Kube::Schema::Resource
+      klass.defaults.should == { "apiVersion" => "postgresql.cnpg.io/v1", "kind" => "Cluster" }
+    end
 
-      it "resolves Backup" do
-        klass = instance["postgresql.cnpg.io/v1/Backup"]
-        expect(klass.defaults).to eq({ "apiVersion" => "postgresql.cnpg.io/v1", "kind" => "Backup" })
-      end
+    it "includes Cluster in list_resources" do
+      instance.list_resources.should.include "Cluster"
+    end
 
-      it "resolves ScheduledBackup" do
-        klass = instance["postgresql.cnpg.io/v1/ScheduledBackup"]
-        expect(klass.defaults).to eq({ "apiVersion" => "postgresql.cnpg.io/v1", "kind" => "ScheduledBackup" })
-      end
+    it "resolves Backup" do
+      instance["postgresql.cnpg.io/v1/Backup"].defaults.should == { "apiVersion" => "postgresql.cnpg.io/v1", "kind" => "Backup" }
+    end
 
-      it "resolves Pooler" do
-        klass = instance["postgresql.cnpg.io/v1/Pooler"]
-        expect(klass.defaults).to eq({ "apiVersion" => "postgresql.cnpg.io/v1", "kind" => "Pooler" })
-      end
+    it "resolves ScheduledBackup" do
+      instance["postgresql.cnpg.io/v1/ScheduledBackup"].defaults.should == { "apiVersion" => "postgresql.cnpg.io/v1", "kind" => "ScheduledBackup" }
+    end
 
-      it "can instantiate a Cluster with the block DSL" do
-        resource = instance["postgresql.cnpg.io/v1/Cluster"].new {
-          metadata.name = "pg-cluster"
-          metadata.namespace = "databases"
-          spec.instances = 3
-          spec.storage.size = "10Gi"
-        }
-        expect(resource.to_h[:apiVersion]).to eq("postgresql.cnpg.io/v1")
-        expect(resource.to_h[:kind]).to eq("Cluster")
-        expect(resource.to_h[:metadata][:name]).to eq("pg-cluster")
-        expect(resource.to_h[:spec][:instances]).to eq(3)
-      end
+    it "resolves Pooler" do
+      instance["postgresql.cnpg.io/v1/Pooler"].defaults.should == { "apiVersion" => "postgresql.cnpg.io/v1", "kind" => "Pooler" }
     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
+    it "can instantiate a Cluster with the block DSL" do
+      resource = instance["postgresql.cnpg.io/v1/Cluster"].new {
+        metadata.name = "pg-cluster"
+        metadata.namespace = "databases"
+        spec.instances = 3
+        spec.storage.size = "10Gi"
+      }
+      resource.to_h[:apiVersion].should == "postgresql.cnpg.io/v1"
+      resource.to_h[:kind].should == "Cluster"
+      resource.to_h[:metadata][:name].should == "pg-cluster"
+      resource.to_h[:spec][:instances].should == 3
+    end
+  end
+
+  describe "class-level catalog cache" do
+    it "shares the catalog across instances of the same version" do
+      a = instance_class.new("1.34")
+      b = instance_class.new("1.34")
+
+      a["Deployment"].should.be < Kube::Schema::Resource
+      b["Deployment"].should.be < Kube::Schema::Resource
+      instance_class.catalogs["1.34"].should.be.kind_of Kube::Schema::Lazy::Index
     end
   end
 end