kube_cluster 0.3.8 → 0.3.9

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

@@ -1,9 +1,7 @@
 # frozen_string_literal: true
 
-if __FILE__ == $0
-  require "bundler/setup"
-  require "kube/cluster"
-end
+require "bundler/setup"
+require "kube/cluster"
 
 module Kube
   module Cluster
@@ -115,179 +113,159 @@ module Kube
   end
 end
 
-if __FILE__ == $0
-  require "minitest/autorun"
-
-  class HPAForDeploymentMiddlewareTest < Minitest::Test
-    Middleware = Kube::Cluster::Middleware
-
-    def test_generates_hpa_from_deployment
-      m = manifest(Kube::Cluster["Deployment"].new {
-        metadata.name = "web"
-        metadata.namespace = "production"
-        metadata.labels = {
-          "app.kubernetes.io/name": "web",
-          "app.kubernetes.io/autoscale": "2-10",
-        }
-        spec.selector.matchLabels = { app: "web" }
-        spec.template.metadata.labels = { app: "web" }
-        spec.template.spec.containers = [
-          { name: "web", image: "nginx" },
-        ]
-      })
+test do
+  Middleware = Kube::Cluster::Middleware
+
+  it "generates_hpa_from_deployment" do
+    m = manifest(Kube::Cluster["Deployment"].new {
+      metadata.name = "web"
+      metadata.namespace = "production"
+      metadata.labels = {
+        "app.kubernetes.io/name": "web",
+        "app.kubernetes.io/autoscale": "2-10",
+      }
+      spec.selector.matchLabels = { app: "web" }
+      spec.template.metadata.labels = { app: "web" }
+      spec.template.spec.containers = [
+        { name: "web", image: "nginx" },
+      ]
+    })
+
+    Middleware::HPAForDeployment.new.call(m)
+
+    deploy, hpa = m.resources
+    hh = hpa.to_h
+    metrics = hh.dig(:spec, :metrics)
+
+    metrics[1].dig(:resource, :target, :averageUtilization).should == 80
+  end
 
-      Middleware::HPAForDeployment.new.call(m)
+  it "custom_cpu_and_memory_targets" do
+    m = manifest(Kube::Cluster["Deployment"].new {
+      metadata.name = "web"
+      metadata.labels = { "app.kubernetes.io/autoscale": "1-3" }
+      spec.selector.matchLabels = { app: "web" }
+      spec.template.metadata.labels = { app: "web" }
+      spec.template.spec.containers = [
+        { name: "web", image: "nginx" },
+      ]
+    })
+
+    Middleware::HPAForDeployment.new(cpu: 60, memory: 70).call(m)
+    hpa = m.resources.last.to_h
+
+    hpa.dig(:spec, :metrics, 1, :resource, :target, :averageUtilization).should == 70
+  end
 
-      assert_equal 2, m.resources.size
-
-      deploy, hpa = m.resources
-      assert_equal "Deployment", deploy.to_h[:kind]
-      assert_equal "HorizontalPodAutoscaler", hpa.to_h[:kind]
-
-      hh = hpa.to_h
-      assert_equal "web", hh.dig(:metadata, :name)
-      assert_equal "production", hh.dig(:metadata, :namespace)
-      assert_equal 2, hh.dig(:spec, :minReplicas)
-      assert_equal 10, hh.dig(:spec, :maxReplicas)
-
-      ref = hh.dig(:spec, :scaleTargetRef)
-      assert_equal "apps/v1", ref[:apiVersion]
-      assert_equal "Deployment", ref[:kind]
-      assert_equal "web", ref[:name]
-
-      metrics = hh.dig(:spec, :metrics)
-      assert_equal 2, metrics.size
-      assert_equal "cpu", metrics[0].dig(:resource, :name)
-      assert_equal 75, metrics[0].dig(:resource, :target, :averageUtilization)
-      assert_equal "memory", metrics[1].dig(:resource, :name)
-      assert_equal 80, metrics[1].dig(:resource, :target, :averageUtilization)
-    end
+  it "strips_autoscale_label_from_hpa" do
+    m = manifest(Kube::Cluster["Deployment"].new {
+      metadata.name = "web"
+      metadata.labels = {
+        "app.kubernetes.io/name": "web",
+        "app.kubernetes.io/autoscale": "1-5",
+      }
+      spec.selector.matchLabels = { app: "web" }
+      spec.template.metadata.labels = { app: "web" }
+      spec.template.spec.containers = [
+        { name: "web", image: "nginx" },
+      ]
+    })
+
+    Middleware::HPAForDeployment.new.call(m)
+    hpa_labels = m.resources.last.to_h.dig(:metadata, :labels)
+
+    hpa_labels[:"app.kubernetes.io/autoscale"].should.be.nil
+  end
 
-    def test_custom_cpu_and_memory_targets
-      m = manifest(Kube::Cluster["Deployment"].new {
-        metadata.name = "web"
-        metadata.labels = { "app.kubernetes.io/autoscale": "1-3" }
-        spec.selector.matchLabels = { app: "web" }
-        spec.template.metadata.labels = { app: "web" }
-        spec.template.spec.containers = [
-          { name: "web", image: "nginx" },
-        ]
-      })
-
-      Middleware::HPAForDeployment.new(cpu: 60, memory: 70).call(m)
-      hpa = m.resources.last.to_h
-
-      assert_equal 60, hpa.dig(:spec, :metrics, 0, :resource, :target, :averageUtilization)
-      assert_equal 70, hpa.dig(:spec, :metrics, 1, :resource, :target, :averageUtilization)
-    end
+  it "skips_deployment_without_autoscale_label" do
+    m = manifest(Kube::Cluster["Deployment"].new {
+      metadata.name = "web"
+      spec.selector.matchLabels = { app: "web" }
+      spec.template.metadata.labels = { app: "web" }
+      spec.template.spec.containers = [
+        { name: "web", image: "nginx" },
+      ]
+    })
 
-    def test_strips_autoscale_label_from_hpa
-      m = manifest(Kube::Cluster["Deployment"].new {
-        metadata.name = "web"
-        metadata.labels = {
-          "app.kubernetes.io/name": "web",
-          "app.kubernetes.io/autoscale": "1-5",
-        }
-        spec.selector.matchLabels = { app: "web" }
-        spec.template.metadata.labels = { app: "web" }
-        spec.template.spec.containers = [
-          { name: "web", image: "nginx" },
-        ]
-      })
+    Middleware::HPAForDeployment.new.call(m)
 
-      Middleware::HPAForDeployment.new.call(m)
-      hpa_labels = m.resources.last.to_h.dig(:metadata, :labels)
+    m.resources.size.should == 1
+  end
 
-      assert_nil hpa_labels[:"app.kubernetes.io/autoscale"]
-      assert_equal "web", hpa_labels[:"app.kubernetes.io/name"]
-    end
+  it "skips_non_pod_bearing_resources" do
+    m = manifest(Kube::Cluster["ConfigMap"].new {
+      metadata.name = "config"
+      metadata.labels = { "app.kubernetes.io/autoscale": "1-5" }
+    })
 
-    def test_skips_deployment_without_autoscale_label
-      m = manifest(Kube::Cluster["Deployment"].new {
-        metadata.name = "web"
-        spec.selector.matchLabels = { app: "web" }
-        spec.template.metadata.labels = { app: "web" }
-        spec.template.spec.containers = [
-          { name: "web", image: "nginx" },
-        ]
-      })
+    Middleware::HPAForDeployment.new.call(m)
 
-      Middleware::HPAForDeployment.new.call(m)
+    m.resources.size.should == 1
+  end
 
-      assert_equal 1, m.resources.size
+  it "raises_on_invalid_range_format" do
+    m = manifest(Kube::Cluster["Deployment"].new {
+      metadata.name = "web"
+      metadata.labels = { "app.kubernetes.io/autoscale": "bad" }
+      spec.selector.matchLabels = { app: "web" }
+      spec.template.metadata.labels = { app: "web" }
+      spec.template.spec.containers = [
+        { name: "web", image: "nginx" },
+      ]
+    })
+
+    error = nil
+    begin
+      Middleware::HPAForDeployment.new.call(m)
+    rescue ArgumentError => e
+      error = e
     end
 
-    def test_skips_non_pod_bearing_resources
-      m = manifest(Kube::Cluster["ConfigMap"].new {
-        metadata.name = "config"
-        metadata.labels = { "app.kubernetes.io/autoscale": "1-5" }
-      })
+    error.message.should.include "Invalid autoscale label"
+  end
 
+  it "raises_on_invalid_range_values" do
+    m = manifest(Kube::Cluster["Deployment"].new {
+      metadata.name = "web"
+      metadata.labels = { "app.kubernetes.io/autoscale": "5-2" }
+      spec.selector.matchLabels = { app: "web" }
+      spec.template.metadata.labels = { app: "web" }
+      spec.template.spec.containers = [
+        { name: "web", image: "nginx" },
+      ]
+    })
+
+    error = nil
+    begin
       Middleware::HPAForDeployment.new.call(m)
-
-      assert_equal 1, m.resources.size
+    rescue ArgumentError => e
+      error = e
     end
 
-    def test_raises_on_invalid_range_format
-      m = manifest(Kube::Cluster["Deployment"].new {
-        metadata.name = "web"
-        metadata.labels = { "app.kubernetes.io/autoscale": "bad" }
-        spec.selector.matchLabels = { app: "web" }
-        spec.template.metadata.labels = { app: "web" }
-        spec.template.spec.containers = [
-          { name: "web", image: "nginx" },
-        ]
-      })
-
-      error = assert_raises(ArgumentError) do
-        Middleware::HPAForDeployment.new.call(m)
-      end
-
-      assert_includes error.message, "Invalid autoscale label"
-    end
+    error.message.should.include "Invalid autoscale range"
+  end
 
-    def test_raises_on_invalid_range_values
-      m = manifest(Kube::Cluster["Deployment"].new {
-        metadata.name = "web"
-        metadata.labels = { "app.kubernetes.io/autoscale": "5-2" }
-        spec.selector.matchLabels = { app: "web" }
-        spec.template.metadata.labels = { app: "web" }
-        spec.template.spec.containers = [
-          { name: "web", image: "nginx" },
-        ]
-      })
-
-      error = assert_raises(ArgumentError) do
-        Middleware::HPAForDeployment.new.call(m)
-      end
+  it "works_with_statefulset" do
+    m = manifest(Kube::Cluster["StatefulSet"].new {
+      metadata.name = "db"
+      metadata.labels = { "app.kubernetes.io/autoscale": "1-3" }
+      spec.selector.matchLabels = { app: "db" }
+      spec.template.metadata.labels = { app: "db" }
+      spec.template.spec.containers = [
+        { name: "postgres", image: "postgres:16" },
+      ]
+    })
 
-      assert_includes error.message, "Invalid autoscale range"
-    end
+    Middleware::HPAForDeployment.new.call(m)
 
-    def test_works_with_statefulset
-      m = manifest(Kube::Cluster["StatefulSet"].new {
-        metadata.name = "db"
-        metadata.labels = { "app.kubernetes.io/autoscale": "1-3" }
-        spec.selector.matchLabels = { app: "db" }
-        spec.template.metadata.labels = { app: "db" }
-        spec.template.spec.containers = [
-          { name: "postgres", image: "postgres:16" },
-        ]
-      })
+    m.resources.last.to_h.dig(:spec, :scaleTargetRef, :kind).should == "StatefulSet"
+  end
 
-      Middleware::HPAForDeployment.new.call(m)
+  private
 
-      assert_equal 2, m.resources.size
-      hpa = m.resources.last.to_h
-      assert_equal "StatefulSet", hpa.dig(:spec, :scaleTargetRef, :kind)
+    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
 end

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

@@ -1,9 +1,7 @@
 # frozen_string_literal: true
 
-if __FILE__ == $0
-  require "bundler/setup"
-  require "kube/cluster"
-end
+require "bundler/setup"
+require "kube/cluster"
 
 module Kube
   module Cluster
@@ -95,124 +93,100 @@ module Kube
   end
 end
 
-if __FILE__ == $0
-  require "minitest/autorun"
-
-  class IngressForServiceMiddlewareTest < Minitest::Test
-    Middleware = Kube::Cluster::Middleware
-
-    def test_generates_ingress_from_service_with_expose_label
-      m = manifest(Kube::Cluster["Service"].new {
-        metadata.name = "web"
-        metadata.namespace = "production"
-        metadata.labels = { "app.kubernetes.io/expose": "app.example.com" }
-        spec.selector = { app: "web" }
-        spec.ports = [{ name: "http", port: 80, targetPort: "http" }]
-      })
-
-      Middleware::IngressForService.new.call(m)
-
-      assert_equal 2, m.resources.size
-
-      service, ingress = m.resources
-      assert_equal "Service", service.to_h[:kind]
-      assert_equal "Ingress", ingress.to_h[:kind]
-
-      ih = ingress.to_h
-      assert_equal "web", ih.dig(:metadata, :name)
-      assert_equal "production", ih.dig(:metadata, :namespace)
-      assert_equal "nginx", ih.dig(:spec, :ingressClassName)
-      assert_equal "letsencrypt-prod", ih.dig(:metadata, :annotations, :"cert-manager.io/cluster-issuer")
-      assert_equal "true", ih.dig(:metadata, :annotations, :"nginx.ingress.kubernetes.io/ssl-redirect")
-
-      # TLS
-      tls = ih.dig(:spec, :tls, 0)
-      assert_equal ["app.example.com"], tls[:hosts]
-      assert_equal "web-tls", tls[:secretName]
-
-      # Rules
-      rule = ih.dig(:spec, :rules, 0)
-      assert_equal "app.example.com", rule[:host]
-      assert_equal "web", rule.dig(:http, :paths, 0, :backend, :service, :name)
-      assert_equal "http", rule.dig(:http, :paths, 0, :backend, :service, :port, :name)
-    end
+test do
+  Middleware = Kube::Cluster::Middleware
 
-    def test_custom_issuer_and_ingress_class
-      m = manifest(Kube::Cluster["Service"].new {
-        metadata.name = "web"
-        metadata.labels = { "app.kubernetes.io/expose": "app.example.com" }
-        spec.ports = [{ name: "http", port: 80 }]
-      })
-
-      Middleware::IngressForService.new(
-        issuer: "letsencrypt-staging",
-        ingress_class: "traefik",
-      ).call(m)
-
-      ingress = m.resources.last.to_h
-      assert_equal "traefik", ingress.dig(:spec, :ingressClassName)
-      assert_equal "letsencrypt-staging", ingress.dig(:metadata, :annotations, :"cert-manager.io/cluster-issuer")
-    end
+  it "generates_ingress_from_service_with_expose_label" do
+    m = manifest(Kube::Cluster["Service"].new {
+      metadata.name = "web"
+      metadata.namespace = "production"
+      metadata.labels = { "app.kubernetes.io/expose": "app.example.com" }
+      spec.selector = { app: "web" }
+      spec.ports = [{ name: "http", port: 80, targetPort: "http" }]
+    })
 
-    def test_expose_true_uses_name_as_hostname
-      m = manifest(Kube::Cluster["Service"].new {
-        metadata.name = "api"
-        metadata.labels = { "app.kubernetes.io/expose": "true" }
-        spec.ports = [{ name: "http", port: 80 }]
-      })
+    Middleware::IngressForService.new.call(m)
 
-      Middleware::IngressForService.new.call(m)
-      ingress = m.resources.last.to_h
+    service, ingress = m.resources
+    ih = ingress.to_h
+    rule = ih.dig(:spec, :rules, 0)
 
-      assert_equal "api.local", ingress.dig(:spec, :rules, 0, :host)
-      assert_equal ["api.local"], ingress.dig(:spec, :tls, 0, :hosts)
-    end
+    rule.dig(:http, :paths, 0, :backend, :service, :port, :name).should == "http"
+  end
 
-    def test_strips_expose_label_from_ingress
-      m = manifest(Kube::Cluster["Service"].new {
-        metadata.name = "web"
-        metadata.labels = {
-          "app.kubernetes.io/expose": "app.example.com",
-          "app.kubernetes.io/name": "web",
-        }
-        spec.ports = [{ name: "http", port: 80 }]
-      })
-
-      Middleware::IngressForService.new.call(m)
-      ingress_labels = m.resources.last.to_h.dig(:metadata, :labels)
-
-      assert_nil ingress_labels[:"app.kubernetes.io/expose"]
-      assert_equal "web", ingress_labels[:"app.kubernetes.io/name"]
-    end
+  it "custom_issuer_and_ingress_class" do
+    m = manifest(Kube::Cluster["Service"].new {
+      metadata.name = "web"
+      metadata.labels = { "app.kubernetes.io/expose": "app.example.com" }
+      spec.ports = [{ name: "http", port: 80 }]
+    })
 
-    def test_skips_service_without_expose_label
-      m = manifest(Kube::Cluster["Service"].new {
-        metadata.name = "web"
-        spec.ports = [{ name: "http", port: 80 }]
-      })
+    Middleware::IngressForService.new(
+      issuer: "letsencrypt-staging",
+      ingress_class: "traefik",
+    ).call(m)
 
-      Middleware::IngressForService.new.call(m)
+    ingress = m.resources.last.to_h
 
-      assert_equal 1, m.resources.size
-    end
+    ingress.dig(:metadata, :annotations, :"cert-manager.io/cluster-issuer").should == "letsencrypt-staging"
+  end
 
-    def test_skips_non_service_resources
-      m = manifest(Kube::Cluster["Deployment"].new {
-        metadata.name = "web"
-        metadata.labels = { "app.kubernetes.io/expose": "app.example.com" }
-      })
+  it "expose_true_uses_name_as_hostname" do
+    m = manifest(Kube::Cluster["Service"].new {
+      metadata.name = "api"
+      metadata.labels = { "app.kubernetes.io/expose": "true" }
+      spec.ports = [{ name: "http", port: 80 }]
+    })
 
-      Middleware::IngressForService.new.call(m)
+    Middleware::IngressForService.new.call(m)
+    ingress = m.resources.last.to_h
 
-      assert_equal 1, m.resources.size
-    end
+    ingress.dig(:spec, :tls, 0, :hosts).should == ["api.local"]
+  end
 
-    private
+  it "strips_expose_label_from_ingress" do
+    m = manifest(Kube::Cluster["Service"].new {
+      metadata.name = "web"
+      metadata.labels = {
+        "app.kubernetes.io/expose": "app.example.com",
+        "app.kubernetes.io/name": "web",
+      }
+      spec.ports = [{ name: "http", port: 80 }]
+    })
 
-      def manifest(*resources)
-        m = Kube::Cluster::Manifest.new
-        resources.each { |r| m << r }
-        m
-      end
+    Middleware::IngressForService.new.call(m)
+    ingress_labels = m.resources.last.to_h.dig(:metadata, :labels)
+
+    ingress_labels[:"app.kubernetes.io/expose"].should.be.nil
   end
+
+  it "skips_service_without_expose_label" do
+    m = manifest(Kube::Cluster["Service"].new {
+      metadata.name = "web"
+      spec.ports = [{ name: "http", port: 80 }]
+    })
+
+    Middleware::IngressForService.new.call(m)
+
+    m.resources.size.should == 1
+  end
+
+  it "skips_non_service_resources" do
+    m = manifest(Kube::Cluster["Deployment"].new {
+      metadata.name = "web"
+      metadata.labels = { "app.kubernetes.io/expose": "app.example.com" }
+    })
+
+    Middleware::IngressForService.new.call(m)
+
+    m.resources.size.should == 1
+  end
+
+  private
+
+    def manifest(*resources)
+      m = Kube::Cluster::Manifest.new
+      resources.each { |r| m << r }
+      m
+    end
 end