kube_cluster 0.20.1 → 1.0.0

data/lib/kube/cluster/middleware.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
 require "bundler/setup"
-require "scampi"
-require "kube/cluster"
 
 require_relative "middleware/stack"
 require_relative "middleware/namespace"
@@ -121,296 +119,296 @@ module Kube
   end
 end
 
-test do
-  Middleware = Kube::Cluster::Middleware
+__END__
 
-  # --- filter helper ----------------------------------------------------------
+Middleware = Kube::Cluster::Middleware
 
-  it "filter_runs_block_when_filter_matches" do
-    mw = Middleware.new(filter: ->(r) { true })
-    resource = Kube::Cluster["ConfigMap"].new { metadata.name = "test" }
+# --- filter helper ----------------------------------------------------------
 
-    result = mw.filter(resource) { :ran }
+it "filter_runs_block_when_filter_matches" do
+  mw = Middleware.new(filter: ->(r) { true })
+  resource = Kube::Cluster["ConfigMap"].new { metadata.name = "test" }
 
-    result.should == :ran
-  end
+  result = mw.filter(resource) { :ran }
 
-  it "filter_returns_resource_when_filter_rejects" do
-    mw = Middleware.new(filter: ->(r) { false })
-    resource = Kube::Cluster["ConfigMap"].new { metadata.name = "test" }
+  result.should == :ran
+end
 
-    result = mw.filter(resource) { :should_not_run }
+it "filter_returns_resource_when_filter_rejects" do
+  mw = Middleware.new(filter: ->(r) { false })
+  resource = Kube::Cluster["ConfigMap"].new { metadata.name = "test" }
 
-    result.should == resource
-  end
+  result = mw.filter(resource) { :should_not_run }
 
-  it "filter_runs_block_by_default" do
-    mw = Middleware.new
-    resource = Kube::Cluster["ConfigMap"].new { metadata.name = "test" }
+  result.should == resource
+end
 
-    result = mw.filter(resource) { :ran }
+it "filter_runs_block_by_default" do
+  mw = Middleware.new
+  resource = Kube::Cluster["ConfigMap"].new { metadata.name = "test" }
 
-    result.should == :ran
-  end
+  result = mw.filter(resource) { :ran }
 
-  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" }
+  result.should == :ran
+end
 
-    mw.filter(resource) { :ok }
+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" }
 
-    received.should == resource
-  end
+  mw.filter(resource) { :ok }
 
-  it "filter_can_match_on_kind" do
-    only_deployments = ->(r) { r.kind == "Deployment" }
+  received.should == resource
+end
 
-    mw = Middleware.new(filter: only_deployments)
-    deploy = Kube::Cluster["Deployment"].new { metadata.name = "web" }
-    config = Kube::Cluster["ConfigMap"].new { metadata.name = "cfg" }
+it "filter_can_match_on_kind" do
+  only_deployments = ->(r) { r.kind == "Deployment" }
 
-    mw.filter(deploy) { :ran }.should == :ran
-    mw.filter(config) { :ran }.should == config
-  end
+  mw = Middleware.new(filter: only_deployments)
+  deploy = Kube::Cluster["Deployment"].new { metadata.name = "web" }
+  config = Kube::Cluster["ConfigMap"].new { metadata.name = "cfg" }
 
-  it "filter_can_match_on_label" do
-    only_labeled = ->(r) { r.label("app.kubernetes.io/name") == "web" }
+  mw.filter(deploy) { :ran }.should == :ran
+  mw.filter(config) { :ran }.should == config
+end
 
-    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" }
+it "filter_can_match_on_label" do
+  only_labeled = ->(r) { r.label("app.kubernetes.io/name") == "web" }
 
-    mw.filter(labeled) { :ran }.should == :ran
-    mw.filter(unlabeled) { :ran }.should == unlabeled
-  end
+  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" }
 
-  it "filter_can_match_on_pod_bearing" do
-    only_pods = ->(r) { r.pod_bearing? }
-    mw = Middleware.new(filter: only_pods)
+  mw.filter(labeled) { :ran }.should == :ran
+  mw.filter(unlabeled) { :ran }.should == unlabeled
+end
 
-    deploy = Kube::Cluster["Deployment"].new { metadata.name = "web" }
-    config = Kube::Cluster["ConfigMap"].new { metadata.name = "cfg" }
+it "filter_can_match_on_pod_bearing" do
+  only_pods = ->(r) { r.pod_bearing? }
+  mw = Middleware.new(filter: only_pods)
 
-    mw.filter(deploy) { :ran }.should == :ran
-    mw.filter(config) { :ran }.should == config
-  end
+  deploy = Kube::Cluster["Deployment"].new { metadata.name = "web" }
+  config = Kube::Cluster["ConfigMap"].new { metadata.name = "cfg" }
 
-  it "filter_block_has_access_to_middleware_instance" do
-    mw = Middleware.new
-    resource = Kube::Cluster["ConfigMap"].new { metadata.name = "test" }
+  mw.filter(deploy) { :ran }.should == :ran
+  mw.filter(config) { :ran }.should == config
+end
 
-    # 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 })
-    }
+it "filter_block_has_access_to_middleware_instance" do
+  mw = Middleware.new
+  resource = Kube::Cluster["ConfigMap"].new { metadata.name = "test" }
 
-    result.should == { a: 1, b: 2 }
-  end
+  # 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 }
 
-  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.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" },
+  )
 
-    result = mw.filter(resource) { :ran }
+  # A middleware that adds a label, but only to Deployments.
+  mw = Middleware.new(filter: ->(r) { r.kind == "Deployment" })
 
-    result.should == :ran
+  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
 
-  # --- filter in a transform middleware (map! pattern) ------------------------
+  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_skips_non_matching" do
-    m = manifest(
-      Kube::Cluster["Deployment"].new { metadata.name = "web" },
-      Kube::Cluster["ConfigMap"].new { metadata.name = "cfg" },
-    )
+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" },
+  )
 
-    # A middleware that adds a label, but only to Deployments.
-    mw = Middleware.new(filter: ->(r) { r.kind == "Deployment" })
+  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
+  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" })
 
-    m.resources[0].to_h.dig(:metadata, :labels, :tagged).should == "yes"
-    m.resources[1].to_h.dig(:metadata, :labels, :tagged).should.be.nil
+  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)
 
-  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" },
-    )
+  m.resources.first.to_h.dig(:metadata, :labels, :injected).should == "yes"
+end
 
-    mw = Middleware.new
+it "build_bakes_in_filter" do
+  m = manifest(
+    Kube::Cluster["Deployment"].new { metadata.name = "web" },
+    Kube::Cluster["ConfigMap"].new { metadata.name = "cfg" },
+  )
 
-    m.resources.map! do |resource|
-      mw.filter(resource) do
+  klass = Middleware.build(filter: ->(r) { r.kind == "Deployment" }) do |manifest|
+    manifest.resources.map! do |resource|
+      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
+  klass.new.call(m)
 
-  # --- Middleware.build -------------------------------------------------------
+  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_creates_middleware_from_block" do
-    m = manifest(Kube::Cluster["ConfigMap"].new { metadata.name = "test" })
+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] = { injected: "yes" }
-        resource.rebuild(h)
-      end
+  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
-    klass.new.call(m)
+  end
+  klass.new.call(m)
+
+  m.resources.first.to_h.dig(:metadata, :labels).should == { a: 1, b: 2 }
+end
 
-    m.resources.first.to_h.dig(:metadata, :labels, :injected).should == "yes"
+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)
 
-  it "build_bakes_in_filter" do
-    m = manifest(
-      Kube::Cluster["Deployment"].new { metadata.name = "web" },
-      Kube::Cluster["ConfigMap"].new { metadata.name = "cfg" },
-    )
+  m.resources.first.to_h.dig(:metadata, :labels, :team).should == "platform"
+end
 
-    klass = Middleware.build(filter: ->(r) { r.kind == "Deployment" }) do |manifest|
+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(tagged: "yes")
+          h[:metadata][:labels] = (h[:metadata][:labels] || {}).merge(custom: "from-build")
           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
+  stack.call(m)
 
-  it "build_has_access_to_deep_merge" do
-    m = manifest(Kube::Cluster["ConfigMap"].new { metadata.name = "test" })
+  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
 
-    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)
+it "build_returns_a_class" do
+  klass = Middleware.build { |manifest| }
 
-    m.resources.first.to_h.dig(:metadata, :labels).should == { a: 1, b: 2 }
-  end
+  klass.should.be.kind_of(Class)
+  (klass < Middleware).should == true
+end
 
-  it "build_bakes_in_opts" do
-    m = manifest(Kube::Cluster["ConfigMap"].new { metadata.name = "test" })
+it "build_noop_base_class_without_block" do
+  m = manifest(Kube::Cluster["ConfigMap"].new { metadata.name = "test" })
+  original = m.resources.first.to_h.dup
 
-    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)
+  Middleware.new.call(m)
 
-    m.resources.first.to_h.dig(:metadata, :labels, :team).should == "platform"
-  end
+  m.resources.first.to_h.should == original
+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
+# --- 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
-    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
+  m.resources.concat(generated)
 
-  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
+  m.resources.size.should == 3
+  m.resources.last.to_h.dig(:metadata, :name).should == "generated-for-web"
+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)
+private
 
-    m.resources.size.should == 3
-    m.resources.last.to_h.dig(:metadata, :name).should == "generated-for-web"
+  def manifest(*resources)
+    m = Kube::Cluster::Manifest.new
+    resources.each { |r| m << r }
+    m
   end
-
-  private
-
-    def manifest(*resources)
-      m = Kube::Cluster::Manifest.new
-      resources.each { |r| m << r }
-      m
-    end
-end