kube_cluster 0.4.1 → 0.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4262ae7773b1196bab5f8d93d51c30e42c4e917a2fe0eed37c4c8c14d421712e
-  data.tar.gz: 629f308c318d675cb85e18ece6b2e067d124ad3ac9964416ae40e16e2ea2ec43
+  metadata.gz: eac52e8ce0c9a435a78497095c22cdc598ccbde6d617247cd25ed00919261e46
+  data.tar.gz: 3e6147a0ab466a2cf0275ded885febb7ea9ec4bc092abdc19c39e2130c2dc517
 SHA512:
-  metadata.gz: 61b86597f77ec21690a3395db26e7ec13d365f35a9d5d371677ed28e7170f1cfb094eebdbcc2e8bdf0ca23bbee13c8f7626d0ec7cd00a1b5ff0c62b526a648f1
-  data.tar.gz: 694c11eae61670878923c8c8445a242f63334e652a4c8d8c6e4549a3a6dbff7dbe3993603b59d9b2e081dde16cd0498188e9d3233c484759c3828a49c13fb95f
+  metadata.gz: d84f7ef217ade440d364d368701e6b4e75aaf4da3628c60f65b2d71dabf33f6764d802a239628831e2107c2fa988c03f337d4615b173b5d66b125ea911c31a3e
+  data.tar.gz: 320623843a7d59d2e8716264211f9e9004bf7984e4b3eebf33bc03762297f8d64b46e4c20103085098a167199922cadb300ad6a852f3ae39ac6e4427b3a2df76

data/Gemfile.lock

@@ -1,9 +1,9 @@
 PATH
   remote: .
   specs:
-    kube_cluster (0.4.1)
+    kube_cluster (0.4.2)
       kube_kubectl (~> 2.0.9)
-      kube_schema (~> 1.4.0)
+      kube_schema (~> 1.4.1)
       scampi (~> 0.1)
 
 GEM
@@ -38,12 +38,12 @@ GEM
       rubyshell (~> 1.5)
       shellwords (~> 0.2.2)
       string_builder (~> 1.2.2)
-    kube_schema (1.4.0)
+    kube_schema (1.4.1)
       json_schemer (~> 2.5.0)
       rubyshell (~> 1.5.0)
     language_server-protocol (3.17.0.5)
     lint_roller (1.1.0)
-    parallel (2.0.1)
+    parallel (2.1.0)
     parser (3.3.11.1)
       ast (~> 2.4.1)
       racc

data/kube_cluster.gemspec

@@ -33,6 +33,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rake", "~> 13.0"
   spec.add_development_dependency "rubocop", "~> 1.21"
 
-  spec.add_dependency "kube_schema", "~> 1.4.0"
+  spec.add_dependency "kube_schema", "~> 1.4.1"
   spec.add_dependency "kube_kubectl", "~> 2.0.9"
 end

data/lib/kube/cluster/middleware/annotations.rb

@@ -17,16 +17,16 @@ module Kube
       #   end
       #
       class Annotations < Middleware
-        def initialize(**annotations)
-          @annotations = annotations.transform_keys(&:to_sym).transform_values(&:to_s)
-        end
-
         def call(manifest)
+          annotations = @opts.transform_keys(&:to_sym).transform_values(&:to_s)
+
           manifest.resources.map! do |resource|
-            h = resource.to_h
-            h[:metadata] ||= {}
-            h[:metadata][:annotations] = @annotations.merge(h[:metadata][:annotations] || {})
-            resource.rebuild(h)
+            filter(resource) do
+              h = resource.to_h
+              h[:metadata] ||= {}
+              h[:metadata][:annotations] = annotations.merge(h[:metadata][:annotations] || {})
+              resource.rebuild(h)
+            end
           end
         end
       end

data/lib/kube/cluster/middleware/hpa_for_deployment.rb

@@ -25,63 +25,57 @@ module Kube
       class HPAForDeployment < Middleware
         LABEL = :"app.kubernetes.io/autoscale"
 
-        def initialize(cpu: 75, memory: 80)
-          @cpu = cpu
-          @memory = memory
-        end
-
         def call(manifest)
           generated = []
+          cpu_target    = @opts.fetch(:cpu, 75)
+          memory_target = @opts.fetch(:memory, 80)
 
           manifest.resources.each do |resource|
-            next unless resource.pod_bearing?
-
-            value = resource.label(LABEL)
-            next unless value
-
-            min, max = parse_range(value)
-
-            h = resource.to_h
-            name      = h.dig(:metadata, :name)
-            namespace = h.dig(:metadata, :namespace)
-            labels    = h.dig(:metadata, :labels) || {}
-            api_version = h[:apiVersion] || "apps/v1"
-            resource_kind = resource.kind
-
-            # Capture ivars as locals — the block runs via instance_exec
-            # on a BlackHoleStruct, so @ivars would resolve on the BHS.
-            cpu_target    = @cpu
-            memory_target = @memory
-
-            generated << Kube::Cluster["HorizontalPodAutoscaler"].new {
-              metadata.name      = name
-              metadata.namespace = namespace if namespace
-              metadata.labels    = labels.reject { |k, _| k == LABEL }
-
-              spec.scaleTargetRef = {
-                apiVersion: api_version,
-                kind:       resource_kind,
-                name:       name,
-              }
-              spec.minReplicas = min
-              spec.maxReplicas = max
-              spec.metrics = [
-                {
-                  type: "Resource",
-                  resource: {
-                    name: "cpu",
-                    target: { type: "Utilization", averageUtilization: cpu_target },
+            filter(resource) do
+              next unless resource.pod_bearing?
+
+              value = resource.label(LABEL)
+              next unless value
+
+              min, max = parse_range(value)
+
+              h = resource.to_h
+              name      = h.dig(:metadata, :name)
+              namespace = h.dig(:metadata, :namespace)
+              labels    = h.dig(:metadata, :labels) || {}
+              api_version = h[:apiVersion] || "apps/v1"
+              resource_kind = resource.kind
+
+              generated << Kube::Cluster["HorizontalPodAutoscaler"].new {
+                metadata.name      = name
+                metadata.namespace = namespace if namespace
+                metadata.labels    = labels.reject { |k, _| k == LABEL }
+
+                spec.scaleTargetRef = {
+                  apiVersion: api_version,
+                  kind:       resource_kind,
+                  name:       name,
+                }
+                spec.minReplicas = min
+                spec.maxReplicas = max
+                spec.metrics = [
+                  {
+                    type: "Resource",
+                    resource: {
+                      name: "cpu",
+                      target: { type: "Utilization", averageUtilization: cpu_target },
+                    },
                   },
-                },
-                {
-                  type: "Resource",
-                  resource: {
-                    name: "memory",
-                    target: { type: "Utilization", averageUtilization: memory_target },
+                  {
+                    type: "Resource",
+                    resource: {
+                      name: "memory",
+                      target: { type: "Utilization", averageUtilization: memory_target },
+                    },
                   },
-                },
-              ]
-            }
+                ]
+              }
+            end
           end
 
           manifest.resources.concat(generated)

data/lib/kube/cluster/middleware/ingress_for_service.rb

@@ -28,62 +28,56 @@ module Kube
       class IngressForService < Middleware
         LABEL = :"app.kubernetes.io/expose"
 
-        def initialize(issuer: "letsencrypt-prod", ingress_class: "nginx")
-          @issuer = issuer
-          @ingress_class = ingress_class
-        end
-
         def call(manifest)
           generated = []
+          issuer        = @opts.fetch(:issuer, "letsencrypt-prod")
+          ingress_class = @opts.fetch(:ingress_class, "nginx")
 
           manifest.resources.each do |resource|
-            next unless resource.kind == "Service"
-
-            host = resource.label(LABEL)
-            next unless host
-
-            h = resource.to_h
-            name      = h.dig(:metadata, :name)
-            namespace = h.dig(:metadata, :namespace)
-            labels    = h.dig(:metadata, :labels) || {}
-
-            # Find the first port on the service
-            port_name = Array(h.dig(:spec, :ports)).first&.dig(:name) || "http"
-
-            # Use resource name as hostname fallback if label is just "true"
-            host = "#{name}.local" if host == "true"
-
-            # Capture ivars as locals — the block runs via instance_exec
-            # on a BlackHoleStruct, so @ivars would resolve on the BHS.
-            issuer        = @issuer
-            ingress_class = @ingress_class
-
-            generated << Kube::Cluster["Ingress"].new {
-              metadata.name      = name
-              metadata.namespace = namespace if namespace
-              metadata.labels    = labels.reject { |k, _| k == LABEL }
-              metadata.annotations = {
-                "cert-manager.io/cluster-issuer":           issuer,
-                "nginx.ingress.kubernetes.io/ssl-redirect": "true",
-              }
-
-              spec.ingressClassName = ingress_class
-              spec.tls = [
-                { hosts: [host], secretName: "#{name}-tls" },
-              ]
-              spec.rules = [
-                {
-                  host: host,
-                  http: {
-                    paths: [{
-                      path:     "/",
-                      pathType: "Prefix",
-                      backend:  { service: { name: name, port: { name: port_name } } },
-                    }],
+            filter(resource) do
+              next unless resource.kind == "Service"
+
+              host = resource.label(LABEL)
+              next unless host
+
+              h = resource.to_h
+              name      = h.dig(:metadata, :name)
+              namespace = h.dig(:metadata, :namespace)
+              labels    = h.dig(:metadata, :labels) || {}
+
+              # Find the first port on the service
+              port_name = Array(h.dig(:spec, :ports)).first&.dig(:name) || "http"
+
+              # Use resource name as hostname fallback if label is just "true"
+              host = "#{name}.local" if host == "true"
+
+              generated << Kube::Cluster["Ingress"].new {
+                metadata.name      = name
+                metadata.namespace = namespace if namespace
+                metadata.labels    = labels.reject { |k, _| k == LABEL }
+                metadata.annotations = {
+                  "cert-manager.io/cluster-issuer":           issuer,
+                  "nginx.ingress.kubernetes.io/ssl-redirect": "true",
+                }
+
+                spec.ingressClassName = ingress_class
+                spec.tls = [
+                  { hosts: [host], secretName: "#{name}-tls" },
+                ]
+                spec.rules = [
+                  {
+                    host: host,
+                    http: {
+                      paths: [{
+                        path:     "/",
+                        pathType: "Prefix",
+                        backend:  { service: { name: name, port: { name: port_name } } },
+                      }],
+                    },
                   },
-                },
-              ]
-            }
+                ]
+              }
+            end
           end
 
           manifest.resources.concat(generated)

data/lib/kube/cluster/middleware/labels.rb

@@ -35,16 +35,16 @@ module Kube
           managed_by: :"app.kubernetes.io/managed-by",
         }.freeze
 
-        def initialize(**labels)
-          @labels = normalize(labels)
-        end
-
         def call(manifest)
+          labels = normalize(@opts)
+
           manifest.resources.map! do |resource|
-            h = resource.to_h
-            h[:metadata] ||= {}
-            h[:metadata][:labels] = @labels.merge(h[:metadata][:labels] || {})
-            resource.rebuild(h)
+            filter(resource) do
+              h = resource.to_h
+              h[:metadata] ||= {}
+              h[:metadata][:labels] = labels.merge(h[:metadata][:labels] || {})
+              resource.rebuild(h)
+            end
           end
         end
 

data/lib/kube/cluster/middleware/namespace.rb

@@ -14,18 +14,20 @@ module Kube
       #   end
       #
       class Namespace < Middleware
-        def initialize(namespace)
+        def initialize(namespace, filter: DEFAULT_FILTER)
+          super(filter: filter)
           @namespace = namespace
         end
 
         def call(manifest)
           manifest.resources.map! do |resource|
-            next resource if resource.cluster_scoped?
-
-            h = resource.to_h
-            h[:metadata] ||= {}
-            h[:metadata][:namespace] = @namespace
-            resource.rebuild(h)
+            filter(resource) do
+              next resource if resource.cluster_scoped?
+              h = resource.to_h
+              h[:metadata] ||= {}
+              h[:metadata][:namespace] = @namespace
+              resource.rebuild(h)
+            end
           end
         end
       end
@@ -89,18 +91,17 @@ test do
 
   it "returns_new_resource_instance" do
     resource = Kube::Cluster["ConfigMap"].new { metadata.name = "test" }
-    m = manifest(resource)
-
-    Middleware::Namespace.new("production").call(m)
-
-    resource.equal?(m.resources.first).should.be.false
+    manifest(resource).tap do |m|
+      Middleware::Namespace.new("production").call(m)
+      resource.equal?(m.resources.first).should.be.false
+    end
   end
 
   private
 
     def manifest(*resources)
-      m = Kube::Cluster::Manifest.new
-      resources.each { |r| m << r }
-      m
+      Kube::Cluster::Manifest.new.tap do |manifest|
+        resources.each { |x| manifest << x }
+      end
     end
 end

data/lib/kube/cluster/middleware/pod_anti_affinity.rb

@@ -22,40 +22,40 @@ module Kube
       #   end
       #
       class PodAntiAffinity < Middleware
-        def initialize(topology_key: "kubernetes.io/hostname", weight: 1)
-          @topology_key = topology_key
-          @weight = weight
-        end
-
         def call(manifest)
+          topology_key = @opts.fetch(:topology_key, "kubernetes.io/hostname")
+          weight = @opts.fetch(:weight, 1)
+
           manifest.resources.map! do |resource|
-            next resource unless resource.pod_bearing?
-
-            h = resource.to_h
-            pod_spec = resource.pod_template(h)
-            next resource unless pod_spec
-
-            # Don't overwrite existing affinity configuration.
-            next resource if pod_spec[:affinity]
-
-            match_labels = h.dig(:spec, :selector, :matchLabels)
-            next resource unless match_labels && !match_labels.empty?
-
-            pod_spec[:affinity] = {
-              podAntiAffinity: {
-                preferredDuringSchedulingIgnoredDuringExecution: [
-                  {
-                    weight: @weight,
-                    podAffinityTerm: {
-                      labelSelector: { matchLabels: match_labels },
-                      topologyKey: @topology_key,
+            filter(resource) do
+              next resource unless resource.pod_bearing?
+
+              h = resource.to_h
+              pod_spec = resource.pod_template(h)
+              next resource unless pod_spec
+
+              # Don't overwrite existing affinity configuration.
+              next resource if pod_spec[:affinity]
+
+              match_labels = h.dig(:spec, :selector, :matchLabels)
+              next resource unless match_labels && !match_labels.empty?
+
+              pod_spec[:affinity] = {
+                podAntiAffinity: {
+                  preferredDuringSchedulingIgnoredDuringExecution: [
+                    {
+                      weight: weight,
+                      podAffinityTerm: {
+                        labelSelector: { matchLabels: match_labels },
+                        topologyKey: topology_key,
+                      },
                     },
-                  },
-                ],
-              },
-            }
+                  ],
+                },
+              }
 
-            resource.rebuild(h)
+              resource.rebuild(h)
+            end
           end
         end
       end

data/lib/kube/cluster/middleware/resource_preset.rb

@@ -41,24 +41,26 @@ module Kube
 
         def call(manifest)
           manifest.resources.map! do |resource|
-            size = resource.label(LABEL)
-            next resource unless size
-            next resource unless resource.pod_bearing?
+            filter(resource) do
+              size = resource.label(LABEL)
+              next resource unless size
+              next resource unless resource.pod_bearing?
 
-            preset = PRESETS.fetch(size.to_s) do
-              raise ArgumentError, "Unknown size preset: #{size.inspect}. " \
-                "Valid sizes: #{PRESETS.keys.join(', ')}"
-            end
+              preset = PRESETS.fetch(size.to_s) do
+                raise ArgumentError, "Unknown size preset: #{size.inspect}. " \
+                  "Valid sizes: #{PRESETS.keys.join(', ')}"
+              end
 
-            h = resource.to_h
-            pod_spec = resource.pod_template(h)
-            next resource unless pod_spec
+              h = resource.to_h
+              pod_spec = resource.pod_template(h)
+              next resource unless pod_spec
 
-            resource.each_container(pod_spec) do |container|
-              container[:resources] = deep_merge(preset, container[:resources] || {})
-            end
+              resource.each_container(pod_spec) do |container|
+                container[:resources] = deep_merge(preset, container[:resources] || {})
+              end
 
-            resource.rebuild(h)
+              resource.rebuild(h)
+            end
           end
         end
       end

data/lib/kube/cluster/middleware/security_context.rb

@@ -54,31 +54,31 @@ module Kube
           },
         }.freeze
 
-        def initialize(default: :restricted)
-          @default = default.to_s
-        end
-
         def call(manifest)
+          default = @opts.fetch(:default, :restricted).to_s
+
           manifest.resources.map! do |resource|
-            next resource unless resource.pod_bearing?
+            filter(resource) do
+              next resource unless resource.pod_bearing?
 
-            profile_name = resource.label(LABEL) || @default
-            profile = PROFILES.fetch(profile_name.to_s) do
-              raise ArgumentError, "Unknown security profile: #{profile_name.inspect}. " \
-                "Valid profiles: #{PROFILES.keys.join(', ')}"
-            end
+              profile_name = resource.label(LABEL) || default
+              profile = PROFILES.fetch(profile_name.to_s) do
+                raise ArgumentError, "Unknown security profile: #{profile_name.inspect}. " \
+                  "Valid profiles: #{PROFILES.keys.join(', ')}"
+              end
 
-            h = resource.to_h
-            pod_spec = resource.pod_template(h)
-            next resource unless pod_spec
+              h = resource.to_h
+              pod_spec = resource.pod_template(h)
+              next resource unless pod_spec
 
-            pod_spec[:securityContext] = deep_merge(profile[:pod], pod_spec[:securityContext] || {})
+              pod_spec[:securityContext] = deep_merge(profile[:pod], pod_spec[:securityContext] || {})
 
-            resource.each_container(pod_spec) do |container|
-              container[:securityContext] = deep_merge(profile[:container], container[:securityContext] || {})
-            end
+              resource.each_container(pod_spec) do |container|
+                container[:securityContext] = deep_merge(profile[:container], container[:securityContext] || {})
+              end
 
-            resource.rebuild(h)
+              resource.rebuild(h)
+            end
           end
         end
       end

data/lib/kube/cluster/middleware/service_for_deployment.rb

@@ -25,30 +25,32 @@ module Kube
           generated = []
 
           manifest.resources.each do |resource|
-            next unless resource.pod_bearing?
-
-            h = resource.to_h
-            ports = extract_ports(resource, h)
-            next if ports.empty?
-
-            match_labels = h.dig(:spec, :selector, :matchLabels)
-            next unless match_labels && !match_labels.empty?
-
-            generated << Kube::Cluster["Service"].new {
-              metadata.name      = h.dig(:metadata, :name)
-              metadata.namespace = h.dig(:metadata, :namespace) if h.dig(:metadata, :namespace)
-              metadata.labels    = h.dig(:metadata, :labels) || {}
-
-              spec.selector = match_labels
-              spec.ports = ports.map { |p|
-                {
-                  name:       p[:name],
-                  port:       p[:containerPort],
-                  targetPort: p[:name],
-                  protocol:   p.fetch(:protocol, "TCP"),
+            filter(resource) do
+              next unless resource.pod_bearing?
+
+              h = resource.to_h
+              ports = extract_ports(resource, h)
+              next if ports.empty?
+
+              match_labels = h.dig(:spec, :selector, :matchLabels)
+              next unless match_labels && !match_labels.empty?
+
+              generated << Kube::Cluster["Service"].new {
+                metadata.name      = h.dig(:metadata, :name)
+                metadata.namespace = h.dig(:metadata, :namespace) if h.dig(:metadata, :namespace)
+                metadata.labels    = h.dig(:metadata, :labels) || {}
+
+                spec.selector = match_labels
+                spec.ports = ports.map { |p|
+                  {
+                    name:       p[:name],
+                    port:       p[:containerPort],
+                    targetPort: p[:name],
+                    protocol:   p.fetch(:protocol, "TCP"),
+                  }
                 }
               }
-            }
+            end
           end
 
           manifest.resources.concat(generated)

data/lib/kube/cluster/middleware.rb

@@ -1,5 +1,9 @@
 # frozen_string_literal: true
 
+require "bundler/setup"
+require "scampi"
+require "kube/cluster"
+
 require_relative "middleware/stack"
 require_relative "middleware/namespace"
 require_relative "middleware/labels"
@@ -44,10 +48,59 @@ module Kube
     #   end
     #
     class Middleware
-      def initialize(**opts)
+      DEFAULT_FILTER = -> (x) {true}
+
+      def initialize(filter: DEFAULT_FILTER, **opts)
+        @filter = filter
         @opts = opts
       end
 
+      # Build an anonymous middleware class from a block.
+      # The block becomes the +#call+ method and runs via
+      # +instance_exec+, so +filter+, +deep_merge+, and
+      # +@opts+ are all available inside it.
+      #
+      #   Middleware.build(filter: ->(r) { r.pod_bearing? }) do |manifest|
+      #     manifest.resources.map! do |resource|
+      #       filter(resource) do
+      #         h = resource.to_h
+      #         h[:metadata][:labels][:custom] = "yes"
+      #         resource.rebuild(h)
+      #       end
+      #     end
+      #   end
+      #
+      def self.build(**defaults, &block)
+        Class.new(self) do
+          define_method(:initialize) do |**overrides|
+            super(**defaults, **overrides)
+          end
+
+          define_method(:call, &block)
+        end
+      end
+
+      def filter(resource, &block)
+        # In case super() wasn't called by the middleware.
+        unless @filter.respond_to?(:call)
+          @filter = DEFAULT_FILTER
+        end
+
+        # Usage:
+        #   def call(manifest)
+        #     manifest.resources.map! do |resource|
+        #       filter(resource) do
+        #         # ... middleware code here
+        #       end
+        #     end
+        #   end
+        if @filter.call(resource)
+          instance_exec(&block)
+        else
+          resource
+        end
+      end
+
       # Override in subclasses. Receives the full manifest,
       # mutates it in place.
       def call(manifest)
@@ -67,3 +120,297 @@ module Kube
     end
   end
 end
+
+test do
+  Middleware = Kube::Cluster::Middleware
+
+  # --- filter helper ----------------------------------------------------------
+
+  it "filter_runs_block_when_filter_matches" do
+    mw = Middleware.new(filter: ->(r) { true })
+    resource = Kube::Cluster["ConfigMap"].new { metadata.name = "test" }
+
+    result = mw.filter(resource) { :ran }
+
+    result.should == :ran
+  end
+
+  it "filter_returns_resource_when_filter_rejects" do
+    mw = Middleware.new(filter: ->(r) { false })
+    resource = Kube::Cluster["ConfigMap"].new { metadata.name = "test" }
+
+    result = mw.filter(resource) { :should_not_run }
+
+    result.should == resource
+  end
+
+  it "filter_runs_block_by_default" do
+    mw = Middleware.new
+    resource = Kube::Cluster["ConfigMap"].new { metadata.name = "test" }
+
+    result = mw.filter(resource) { :ran }
+
+    result.should == :ran
+  end
+
+  it "filter_passes_resource_to_filter_proc" do
+    received = nil
+    mw = Middleware.new(filter: ->(r) { received = r; true })
+    resource = Kube::Cluster["ConfigMap"].new { metadata.name = "test" }
+
+    mw.filter(resource) { :ok }
+
+    received.should == resource
+  end
+
+  it "filter_can_match_on_kind" do
+    only_deployments = ->(r) { r.kind == "Deployment" }
+
+    mw = Middleware.new(filter: only_deployments)
+    deploy = Kube::Cluster["Deployment"].new { metadata.name = "web" }
+    config = Kube::Cluster["ConfigMap"].new { metadata.name = "cfg" }
+
+    mw.filter(deploy) { :ran }.should == :ran
+    mw.filter(config) { :ran }.should == config
+  end
+
+  it "filter_can_match_on_label" do
+    only_labeled = ->(r) { r.label("app.kubernetes.io/name") == "web" }
+
+    mw = Middleware.new(filter: only_labeled)
+    labeled = Kube::Cluster["ConfigMap"].new {
+      metadata.name = "cm"
+      metadata.labels = { "app.kubernetes.io/name": "web" }
+    }
+    unlabeled = Kube::Cluster["ConfigMap"].new { metadata.name = "other" }
+
+    mw.filter(labeled) { :ran }.should == :ran
+    mw.filter(unlabeled) { :ran }.should == unlabeled
+  end
+
+  it "filter_can_match_on_pod_bearing" do
+    only_pods = ->(r) { r.pod_bearing? }
+    mw = Middleware.new(filter: only_pods)
+
+    deploy = Kube::Cluster["Deployment"].new { metadata.name = "web" }
+    config = Kube::Cluster["ConfigMap"].new { metadata.name = "cfg" }
+
+    mw.filter(deploy) { :ran }.should == :ran
+    mw.filter(config) { :ran }.should == config
+  end
+
+  it "filter_block_has_access_to_middleware_instance" do
+    mw = Middleware.new
+    resource = Kube::Cluster["ConfigMap"].new { metadata.name = "test" }
+
+    # deep_merge is a private method on Middleware — the block should
+    # be able to call it via instance_exec.
+    result = mw.filter(resource) {
+      deep_merge({ a: 1 }, { b: 2 })
+    }
+
+    result.should == { a: 1, b: 2 }
+  end
+
+  it "filter_recovers_when_super_was_not_called" do
+    # Simulate a subclass that overrides initialize without calling super,
+    # leaving @filter as nil.
+    mw = Middleware.allocate
+    resource = Kube::Cluster["ConfigMap"].new { metadata.name = "test" }
+
+    result = mw.filter(resource) { :ran }
+
+    result.should == :ran
+  end
+
+  # --- filter in a transform middleware (map! pattern) ------------------------
+
+  it "filter_with_transform_middleware_skips_non_matching" do
+    m = manifest(
+      Kube::Cluster["Deployment"].new { metadata.name = "web" },
+      Kube::Cluster["ConfigMap"].new { metadata.name = "cfg" },
+    )
+
+    # A middleware that adds a label, but only to Deployments.
+    mw = Middleware.new(filter: ->(r) { r.kind == "Deployment" })
+
+    m.resources.map! do |resource|
+      mw.filter(resource) do
+        h = resource.to_h
+        h[:metadata] ||= {}
+        h[:metadata][:labels] = (h[:metadata][:labels] || {}).merge(tagged: "yes")
+        resource.rebuild(h)
+      end
+    end
+
+    m.resources[0].to_h.dig(:metadata, :labels, :tagged).should == "yes"
+    m.resources[1].to_h.dig(:metadata, :labels, :tagged).should.be.nil
+  end
+
+  it "filter_with_transform_middleware_applies_to_all_by_default" do
+    m = manifest(
+      Kube::Cluster["Deployment"].new { metadata.name = "web" },
+      Kube::Cluster["ConfigMap"].new { metadata.name = "cfg" },
+    )
+
+    mw = Middleware.new
+
+    m.resources.map! do |resource|
+      mw.filter(resource) do
+        h = resource.to_h
+        h[:metadata] ||= {}
+        h[:metadata][:labels] = (h[:metadata][:labels] || {}).merge(tagged: "yes")
+        resource.rebuild(h)
+      end
+    end
+
+    m.resources[0].to_h.dig(:metadata, :labels, :tagged).should == "yes"
+    m.resources[1].to_h.dig(:metadata, :labels, :tagged).should == "yes"
+  end
+
+  # --- Middleware.build -------------------------------------------------------
+
+  it "build_creates_middleware_from_block" do
+    m = manifest(Kube::Cluster["ConfigMap"].new { metadata.name = "test" })
+
+    klass = Middleware.build do |manifest|
+      manifest.resources.map! do |resource|
+        h = resource.to_h
+        h[:metadata][:labels] = { injected: "yes" }
+        resource.rebuild(h)
+      end
+    end
+    klass.new.call(m)
+
+    m.resources.first.to_h.dig(:metadata, :labels, :injected).should == "yes"
+  end
+
+  it "build_bakes_in_filter" do
+    m = manifest(
+      Kube::Cluster["Deployment"].new { metadata.name = "web" },
+      Kube::Cluster["ConfigMap"].new { metadata.name = "cfg" },
+    )
+
+    klass = Middleware.build(filter: ->(r) { r.kind == "Deployment" }) do |manifest|
+      manifest.resources.map! do |resource|
+        filter(resource) do
+          h = resource.to_h
+          h[:metadata][:labels] = (h[:metadata][:labels] || {}).merge(tagged: "yes")
+          resource.rebuild(h)
+        end
+      end
+    end
+    klass.new.call(m)
+
+    m.resources[0].to_h.dig(:metadata, :labels, :tagged).should == "yes"
+    m.resources[1].to_h.dig(:metadata, :labels, :tagged).should.be.nil
+  end
+
+  it "build_has_access_to_deep_merge" do
+    m = manifest(Kube::Cluster["ConfigMap"].new { metadata.name = "test" })
+
+    klass = Middleware.build do |manifest|
+      manifest.resources.map! do |resource|
+        h = resource.to_h
+        h[:metadata][:labels] = deep_merge({ a: 1 }, { b: 2 })
+        resource.rebuild(h)
+      end
+    end
+    klass.new.call(m)
+
+    m.resources.first.to_h.dig(:metadata, :labels).should == { a: 1, b: 2 }
+  end
+
+  it "build_bakes_in_opts" do
+    m = manifest(Kube::Cluster["ConfigMap"].new { metadata.name = "test" })
+
+    klass = Middleware.build(team: "platform") do |manifest|
+      manifest.resources.map! do |resource|
+        h = resource.to_h
+        h[:metadata][:labels] = { team: @opts[:team] }
+        resource.rebuild(h)
+      end
+    end
+    klass.new.call(m)
+
+    m.resources.first.to_h.dig(:metadata, :labels, :team).should == "platform"
+  end
+
+  it "build_works_in_stack" do
+    m = manifest(
+      Kube::Cluster["Deployment"].new { metadata.name = "web" },
+      Kube::Cluster["ConfigMap"].new { metadata.name = "cfg" },
+    )
+
+    stack = Middleware::Stack.new do
+      use Middleware.build(filter: ->(r) { r.kind == "Deployment" }) { |manifest|
+        manifest.resources.map! do |resource|
+          filter(resource) do
+            h = resource.to_h
+            h[:metadata][:labels] = (h[:metadata][:labels] || {}).merge(custom: "from-build")
+            resource.rebuild(h)
+          end
+        end
+      }
+    end
+    stack.call(m)
+
+    m.resources[0].to_h.dig(:metadata, :labels, :custom).should == "from-build"
+    m.resources[1].to_h.dig(:metadata, :labels, :custom).should.be.nil
+  end
+
+  it "build_returns_a_class" do
+    klass = Middleware.build { |manifest| }
+
+    klass.should.be.kind_of(Class)
+    (klass < Middleware).should == true
+  end
+
+  it "build_noop_base_class_without_block" do
+    m = manifest(Kube::Cluster["ConfigMap"].new { metadata.name = "test" })
+    original = m.resources.first.to_h.dup
+
+    Middleware.new.call(m)
+
+    m.resources.first.to_h.should == original
+  end
+
+  # --- filter in a generative middleware (each pattern) -----------------------
+
+  it "filter_with_generative_middleware_skips_non_matching" do
+    m = manifest(
+      Kube::Cluster["Deployment"].new {
+        metadata.name = "web"
+        metadata.labels = { "app.kubernetes.io/name": "web" }
+      },
+      Kube::Cluster["Deployment"].new {
+        metadata.name = "worker"
+        metadata.labels = { "app.kubernetes.io/name": "worker" }
+      },
+    )
+
+    only_web = ->(r) { r.label("app.kubernetes.io/name") == "web" }
+    mw = Middleware.new(filter: only_web)
+
+    generated = []
+    m.resources.each do |resource|
+      mw.filter(resource) do
+        generated << Kube::Cluster["ConfigMap"].new {
+          metadata.name = "generated-for-#{resource.to_h.dig(:metadata, :name)}"
+        }
+      end
+    end
+    m.resources.concat(generated)
+
+    m.resources.size.should == 3
+    m.resources.last.to_h.dig(:metadata, :name).should == "generated-for-web"
+  end
+
+  private
+
+    def manifest(*resources)
+      m = Kube::Cluster::Manifest.new
+      resources.each { |r| m << r }
+      m
+    end
+end

data/lib/kube/cluster/version.rb

@@ -2,6 +2,6 @@
 
 module Kube
   module Cluster
-    VERSION = "0.4.1"
+    VERSION = "0.4.2"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: kube_cluster
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.4.2
 platform: ruby
 authors:
 - Nathan K
@@ -57,14 +57,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.4.0
+        version: 1.4.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.4.0
+        version: 1.4.1
 - !ruby/object:Gem::Dependency
   name: kube_kubectl
   requirement: !ruby/object:Gem::Requirement