kerbi 0.0.1 → 0.0.5

data/spec/fixtures/expectations/state/list.txt

@@ -0,0 +1,6 @@
+ TAG         MESSAGE  ASSIGNMENTS  OVERRIDES  CREATED_AT
+
+ \e[0;33;49m[cand]-four\e[0m           0            0          2003-01-01 00:00:00 +0000
+ \e[0;33;49m[cand]-three\e[0m           0            0          2002-01-01 00:00:00 +0000
+ \e[0;34;49mtwo\e[0m         message  0            0          2001-01-01 00:00:00 +0000
+ \e[0;34;49mone\e[0m                  1            1          2000-01-01 00:00:00 +0000

data/spec/fixtures/expectations/state/list.yaml

@@ -0,0 +1,35 @@
+tag: "[cand]-four"
+message:
+created_at: 2003-01-01 00:00:00.000000000 +00:00
+values: {}
+default_values: {}
+overridden_keys: []
+
+---
+
+tag: "[cand]-three"
+message:
+created_at: 2002-01-01 00:00:00.000000000 +00:00
+values: {}
+default_values: {}
+overridden_keys: []
+
+---
+
+tag: two
+message: message
+created_at: 2001-01-01 00:00:00.000000000 +00:00
+values: {}
+default_values: {}
+overridden_keys: []
+
+---
+
+tag: one
+message:
+created_at: 2000-01-01 00:00:00.000000000 +00:00
+values:
+  x: x
+default_values: {}
+overridden_keys:
+  - x

data/spec/fixtures/expectations/state/promote.txt

@@ -0,0 +1 @@
+\e[0;32;49mUpdated state[four].tag from [cand]-four => four\e[0m

data/spec/fixtures/expectations/state/prune-candidates.txt

@@ -0,0 +1 @@
+Pruned 2 state entries

data/spec/fixtures/expectations/state/retag.txt

@@ -0,0 +1 @@
+\e[0;32;49mUpdated state[born-again].tag from two => born-again\e[0m

data/spec/fixtures/expectations/state/set.txt

@@ -0,0 +1 @@
+\e[0;32;49mUpdated state[two].message from message => new message\e[0m

data/spec/fixtures/expectations/state/show.json

@@ -0,0 +1,13 @@
+{
+  "tag": "one",
+  "message": null,
+  "created_at": "2000-01-01 00:00:00 +0000",
+  "values": {
+    "x": "x"
+  },
+  "default_values": {
+  },
+  "overridden_keys": [
+    "x"
+  ]
+}

data/spec/fixtures/expectations/state/show.txt

@@ -0,0 +1,13 @@
+--------------------------------------------
+ \e[1;39;49mTAG\e[0m              \e[1;34;49mone\e[0m
+--------------------------------------------
+ \e[1;39;49mMESSAGE\e[0m
+--------------------------------------------
+ \e[1;39;49mCREATED_AT\e[0m       2000-01-01 00:00:00 +0000
+--------------------------------------------
+ \e[1;39;49mVALUES\e[0m           x: x
+--------------------------------------------
+ \e[1;39;49mDEFAULT_VALUES\e[0m   {}
+--------------------------------------------
+ \e[1;39;49mOVERRIDDEN_KEYS\e[0m  x
+--------------------------------------------

data/spec/fixtures/expectations/state/show.yaml

@@ -0,0 +1,8 @@
+tag: one
+message:
+created_at: 2000-01-01 00:00:00.000000000 +00:00
+values:
+  x: x
+default_values: {}
+overridden_keys:
+  - x

data/spec/fixtures/expectations/values/order-of-precedence.yaml

@@ -0,0 +1,4 @@
+pod:
+  image: nginx:1.20
+service:
+  type: NodePort

data/spec/main/configmap_backend_spec.rb

@@ -0,0 +1,110 @@
+require_relative './../spec_helper'
+
+RSpec.describe Kerbi::State::ConfigMapBackend do
+
+  let(:namespace) { "kerbi-spec" }
+  let(:cm_name) { Kerbi::State::ConfigMapBackend.mk_cm_name(namespace) }
+
+  before :each do
+    create_ns(namespace)
+    delete_cm(cm_name, namespace)
+    # sleep(2) #ADD ME BACK IF WEIRD ERRORS... :/
+  end
+
+  describe "#provision_missing_resources" do
+    let(:backend) { make_backend(namespace, namespace) }
+
+    context "when the namespace does not exist" do
+      it "provisions accordingly" do
+        delete_ns(namespace)
+        expect(backend.read_write_ready?).to be_falsey
+        backend.provision_missing_resources
+      end
+    end
+
+    context "when the namespace does exist" do
+      before :each do
+        create_ns(namespace)
+        expect(backend.read_write_ready?).to be_falsey
+      end
+
+      context "when the configmap does not exist" do
+        it "provisions accordingly" do
+          backend.provision_missing_resources
+          delete_cm(cm_name, namespace)
+          backend.provision_missing_resources
+        end
+      end
+
+      context "when the configmap does exist" do
+        it "provisions accordingly" do
+          backend.provision_missing_resources
+          backend.provision_missing_resources
+        end
+      end
+    end
+
+    after :each do
+      expect(backend.namespace_exists?).to eq(true)
+      expect(backend.read_write_ready?).to eq(true)
+      expect(backend.resource_exists?).to eq(true)
+    end
+  end
+
+  describe "#template_resource" do
+    context "with 0 entries" do
+      it "outputs a descriptor with the right basic properties" do
+        result = make_backend("xyz").template_resource([])
+        metadata = (result || {})[:metadata] || {}
+        expect(result[:kind]).to eq('ConfigMap')
+        expect(metadata[:name]).to eq('kerbi-xyz-db')
+        expect(metadata[:namespace]).to eq('xyz')
+        expect(result[:data][:entries]).to eq("[]")
+      end
+    end
+
+    context "with some entries (for puts only, uncomment)" do
+      it "puts it" do
+        # entry = new_state("1", created_at: "2022-01-01T00:00:00+00:00")
+        # puts entry.to_h
+        # result = make_backend("xyz").template_resource([entry])
+        # puts result
+      end
+    end
+  end
+
+  describe "#namespace_exists?" do
+    context "when the namespace exists" do
+      it "returns true" do
+        expect(make_backend('', "default").namespace_exists?).to be_truthy
+      end
+    end
+    context "when the namespace does not exist" do
+      it "returns false" do
+        expect(make_backend('', "nope").namespace_exists?).to be_falsey
+      end
+    end
+  end
+
+  describe "#apply_resource and #read_entries" do
+    let(:entries) do
+      [
+        new_state("one", message: "m-one", created_at: "2022-01-01T00:00:00+00:00"),
+        new_state("two", message: "m-two", created_at: "2022-02-01T00:00:00+00:00"),
+      ]
+    end
+
+    it "creates a configmap with the right contents" do
+      subject = make_backend(namespace, namespace)
+      descriptor = subject.template_resource(entries)
+      subject.apply_resource(descriptor)
+      sleep(1)
+      actual = subject.send(:read_entries)
+      expect(actual.count).to eq(2)
+
+      actual_one = actual[0].values_at("tag", "message", "created_at")
+      expected_one = entries[0].to_h.values_at(:tag, :message, :created_at)
+      expect(actual_one).to eq(expected_one)
+    end
+  end
+end

data/spec/main/project_code_gen_spec.rb

@@ -7,6 +7,13 @@ RSpec.describe Kerbi::CodeGen::ProjectGenerator do
   let(:project_name) { "test-project" }
   let(:dir_path) { "#{root}/#{project_name}" }
 
+  subject do
+    Kerbi::CodeGen::ProjectGenerator.new(
+      project_name: project_name,
+      root_dir: root
+    )
+  end
+
   before :each do
     Kerbi::Testing.reset_test_yamls_dir
   end
@@ -15,8 +22,7 @@ RSpec.describe Kerbi::CodeGen::ProjectGenerator do
     let(:expected_files) { %w[Gemfile kerbifile.rb values.yaml] }
     it "creates a new dir and writes the files" do
       expect(File.exists?(dir_path)).to be_falsey
-      generator = klass.new(project_name: project_name, root_dir: root)
-      generator.run
+      subject.run
       expect(File.exists?(dir_path)).to be_truthy
       actual = Dir.entries(dir_path)
       expect((expected_files - actual)).to be_empty

data/spec/main/state_entry_set_spec.rb

@@ -0,0 +1,112 @@
+require_relative './../spec_helper'
+
+RSpec.describe Kerbi::State::EntrySet do
+
+  let(:set) do
+    new_state_set(
+      one: { created_at: Time.new(2000).to_s },
+      two: { created_at: Time.new(2001).to_s },
+      "[cand]-one".to_sym => { created_at: Time.new(2002).to_s },
+      "[cand]-two".to_sym => { created_at: Time.new(2003).to_s }
+    )
+  end
+
+  let(:bad_set) do
+    new_state_set(
+      "".to_sym => { },
+    )
+  end
+
+  describe "#initialize" do
+    it "sorts DESC on created_at" do
+      expect(set.entries[0].tag).to eq("[cand]-two")
+    end
+  end
+
+  describe "validate!" do
+    context "when there are no errors" do
+      it "does not raise an error" do
+        set.validate!
+      end
+    end
+
+    context "when there are errors" do
+      it "raises the right error" do
+        expect{
+          bad_set.validate!
+        }.to raise_exception(Kerbi::EntryValidationError)
+      end
+    end
+  end
+
+  describe "#latest" do
+    it "returns the correct entry" do
+      expect(set.latest.tag).to eq("two")
+    end
+  end
+
+  describe "#latest_candidate" do
+    it "returns the correct entry" do
+      expect(set.latest_candidate.tag).to eq("[cand]-two")
+    end
+  end
+
+  describe "#candidates" do
+    it "returns the right entries" do
+      expected = %w[[cand]-two [cand]-one]
+      expect(set.candidates.map(&:tag)).to eq(expected)
+    end
+  end
+
+  describe "#committed" do
+    it "returns the right entries" do
+      expected = %w[two one]
+      expect(set.committed.map(&:tag)).to eq(expected)
+    end
+  end
+
+  describe "#find_entry_for_read" do
+    context "when the substitutions work and the entry exists" do
+      it "returns the right entry" do
+        actual = set.find_entry_for_read("two")
+        expect(actual.tag).to eq("two")
+
+        actual = set.find_entry_for_read("@latest")
+        expect(actual.tag).to eq("two")
+
+        actual = set.find_entry_for_read("@candidate")
+        expect(actual.tag).to eq("[cand]-two")
+      end
+    end
+
+    context "when either the resolution fails or the entry does not exist" do
+      it "raises Kerbi::StateNotFoundError" do
+        expect {
+          set.find_entry_for_read("three")
+        }.to raise_exception(Kerbi::StateNotFoundError)
+
+        expect {
+          set.find_entry_for_read("not-@latest")
+        }.to raise_exception(Kerbi::StateNotFoundError)
+      end
+    end
+  end
+
+  describe "#find_or_init_entry_for_write" do
+    it "returns the right entry" do
+      actual = set.find_or_init_entry_for_write("two")
+      expect(actual.tag).to eq("two")
+
+      actual = set.find_or_init_entry_for_write("@latest")
+      expect(actual.tag).to eq("two")
+
+      actual = set.find_or_init_entry_for_write("@candidate")
+      expect(actual.tag).to eq("[cand]-two")
+
+      actual = set.find_or_init_entry_for_write("@new-candidate")
+      expect(actual.tag).to_not eq("[cand]-two")
+      expect(actual.tag).to_not be_falsey
+    end
+  end
+
+end

data/spec/main/state_entry_spec.rb

@@ -0,0 +1,109 @@
+require_relative './../spec_helper'
+
+RSpec.describe Kerbi::State::Entry do
+
+  let(:subject_cls) { Kerbi::State::Entry }
+  let(:cand_prefix) { subject_cls::CANDIDATE_PREFIX }
+
+  let(:default_dict) do
+    {
+      tag: "tag",
+      message: "message",
+      values: {x: {y: "z"}},
+      default_values: {y: "z"},
+      created_at: "2020-01-02T03:04:00",
+    }
+  end
+
+  describe "#candiate? and #committed?" do
+    context "when it is a candidate" do
+      it "returns true for #candidate and false for #committed" do
+        expect(new_state("[cand]-one").candidate?).to be_truthy
+        expect(new_state("[cand]-one").committed?).to be_falsey
+      end
+    end
+    context "when it is a candidate" do
+      it "returns false for #candidate and true for #committed" do
+        expect(new_state("[cant]-one").candidate?).to be_falsey
+        expect(new_state("[cant]-one").committed?).to be_truthy
+      end
+    end
+  end
+
+  describe "#validate" do
+    context "when there is a tag error" do
+      it "finds validation errors" do
+        (state = new_state("")).validate
+        expect(state.valid?).to be_falsey
+
+        (state = new_state("  ")).validate
+        expect(state.valid?).to be_falsey
+      end
+    end
+
+    context "when there are zero tag errors" do
+      it "finds validation errors" do
+        (state = new_state("a")).validate
+        expect(state.valid?).to be_truthy
+
+        (state = new_state("|")).validate
+        expect(state.valid?).to be_truthy
+      end
+    end
+  end
+
+  describe "#promote" do
+    context "when the entry is a candidate" do
+      it "removes the [cand]- flag" do
+        old = (state = new_state("#{cand_prefix}foo")).promote
+        expect(state.tag).to eq("foo")
+        expect(old).to eq("#{cand_prefix}foo")
+      end
+    end
+
+    context "when the entry is not a candidate" do
+      it "raises" do
+        expect {
+          new_state("foo").promote
+        }.to raise_exception(Kerbi::StateNotPromotable)
+      end
+    end
+  end
+
+  describe "#demote" do
+    context "when the entry is committed" do
+      it "adds the [cand]- flag" do
+        old = (state = new_state("foo")).demote
+        expect(state.tag).to eq("#{cand_prefix}foo")
+        expect(old).to eq("foo")
+      end
+    end
+
+    context "when the entry is not a candidate" do
+      it "raises" do
+        expect {
+          new_state("#{cand_prefix}foo").demote
+        }.to raise_exception(Kerbi::StateNotDemotable)
+      end
+    end
+  end
+
+  describe ".from_dict" do
+    it "parses the created_at timestamp correctly" do
+      entry = subject_cls.from_dict(nil, default_dict)
+      expected = Time.new(2020, 1, 2, 3, 4, 0)
+      expect(entry.created_at).to eq(expected)
+    end
+  end
+
+  describe "#to_h" do
+    it "returns the right dict" do
+      entry = new_state("foo", default_dict)
+      actual = entry.to_h
+      actual.delete(:created_at)
+      expect = default_dict.deep_dup
+      expect.delete(:created_at)
+      expect(actual).to eq(expect)
+    end
+  end
+end

data/spec/mini-projects/hello-kerbi/common/metadata.yaml.erb

@@ -0,0 +1,5 @@
+metadata:
+  annotations:
+    author: person
+  labels:
+    app: hello-kerbi

data/spec/mini-projects/hello-kerbi/consts.rb

@@ -0,0 +1,5 @@
+module HelloKerbi
+  module Consts
+    APP_NAME = "hello-kerbi"
+  end
+end

data/spec/mini-projects/hello-kerbi/helpers.rb

@@ -0,0 +1,8 @@
+module HelloKerbi
+  module Helpers
+    def img2alpine(img_name)
+      return img_name if img_name.include?(":")
+      "#{img_name}:alpine"
+    end
+  end
+end

data/spec/mini-projects/hello-kerbi/kerbifile.rb

@@ -0,0 +1,18 @@
+require_relative 'consts'
+require_relative 'helpers'
+
+module HelloKerbi
+  class Mixer < Kerbi::Mixer
+    include Helpers
+
+    locate_self __dir__
+
+    def mix
+      patched_with file("common/metadata") do
+        push file("pod-and-service")
+      end
+    end
+  end
+end
+
+Kerbi::Globals.mixers << HelloKerbi::Mixer

data/spec/mini-projects/hello-kerbi/pod-and-service.yaml.erb

@@ -0,0 +1,23 @@
+apiVersion: v1
+kind: Pod
+metadata:
+  name: <%= HelloKerbi::Consts::APP_NAME %>
+  namespace: <%= release_name %>
+spec:
+  containers:
+    - name: main
+      image: <%= img2alpine(values[:pod][:image]) %>
+
+---
+
+apiVersion: v1
+kind: Service
+metadata:
+  name: <%= HelloKerbi::Consts::APP_NAME %>
+  namespace: <%= release_name %>
+spec:
+  type: <%= values[:service][:type] %>
+  selector:
+    app: <%= HelloKerbi::Consts::APP_NAME %>
+  ports:
+    - port: 80

data/spec/mini-projects/hello-kerbi/values/production.yaml

@@ -0,0 +1,2 @@
+service:
+  type: LoadBalancer

data/spec/mini-projects/hello-kerbi/values/v2.yaml

@@ -0,0 +1,2 @@
+pod:
+  image: nginx:1.20

data/spec/mini-projects/hello-kerbi/values/values.yaml

@@ -0,0 +1,4 @@
+pod:
+  image: nginx
+service:
+  type: ClusterIP

data/spec/spec_helper.rb

@@ -5,6 +5,149 @@ SimpleCov.start
 
 require_relative './../lib/kerbi'
 
+def run_opts
+  Kerbi::RunOpts.new({}, Kerbi::Consts::OptionDefaults::BASE)
+end
+
+# @param [String] namespace
+# @return [Kerbi::State::ConfigMapBackend]
+def make_backend(release_name, namespace=nil)
+  auth_bundle = Kerbi::Utils::Cli.make_k8s_auth_bundle(run_opts)
+  Kerbi::State::ConfigMapBackend.new(auth_bundle, release_name, namespace)
+end
+
+# @return [Kubeclient::Client]
+def make_kube_client(api_name)
+  auth_bundle = Kerbi::Utils::Cli.make_k8s_auth_bundle(run_opts)
+  Kubeclient::Client.new(
+    auth_bundle[:endpoint],
+    api_name,
+    **auth_bundle[:options]
+  )
+end
+
+def create_ns(name)
+  dict = { metadata: { name: name } }
+  begin
+    #noinspection RubyResolve
+    make_kube_client("v1").create_namespace(dict)
+  rescue Kubeclient::HttpError
+    true
+  end
+end
+
+def delete_cm(name, namespace)
+  begin
+    #noinspection RubyResolve
+    make_kube_client("v1").delete_config_map(name, namespace)
+    begin
+      sleep(1)
+      #noinspection RubyResolve
+      exists = client.get_config_map(name, namespace) rescue nil
+    end while exists
+  rescue Kubeclient::ResourceNotFoundError
+    true
+  end
+end
+
+def delete_ns(name)
+  begin
+    #noinspection RubyResolve
+    (client = make_kube_client("v1")).delete_namespace(name)
+    begin
+      sleep(1)
+      exists = client.get_namespace(name) rescue nil
+    end while exists
+  rescue Kubeclient::ResourceNotFoundError
+    true
+  end
+end
+
+def corrupt_cm(backend)
+  cm_body = backend.template_resource([])
+  cm_body[:data][:entries] = "not json"
+  backend.send(:client).update_config_map(cm_body)
+end
+
+def new_state(tag, dict={})
+  set = dict.delete(:state)
+  dict[:tag] = tag
+  Kerbi::State::Entry.from_dict(set, dict)
+end
+
+def new_state_set(bundles)
+  dicts = bundles.map { |kv| { tag: kv[0].to_s, **kv[1] } }
+  Kerbi::State::EntrySet.new(dicts)
+end
+
+def cli(command, escaped: false)
+  $stdout = StringIO.new
+  begin
+    command = command.split(" ") if command.is_a?(String)
+    Kerbi::Cli::RootHandler.start(command)
+    output = $stdout.string
+    $stdout = STDOUT
+    escaped ? output.gsub("\e", "\\e") : output
+  ensure
+    $stdout = STDOUT
+  end
+end
+
+def load_exp_file(dir, file, ext)
+  path = "#{__dir__}/fixtures/expectations/#{dir}/#{file}.#{ext}"
+  File.read(path)
+end
+
+def read_exp_file(dir, file, ext)
+  expected_str = load_exp_file(dir, file, ext)
+  if ext == 'json'
+    JSON.parse(expected_str)
+  elsif ext == 'yaml'
+    YAML.load_stream(expected_str)
+  else
+    expected_str.gsub(/\s+/, "")
+  end
+end
+
+def exp_cli_eq_file(cmd, dir, file, ext='txt')
+  actual_str = cli(cmd)
+  expected = read_exp_file(dir, file, ext)
+
+  if ext == 'json'
+    expect(JSON.parse(actual_str)).to eq(expected)
+  elsif ext == 'yaml'
+    actual = YAML.load_stream(actual_str) rescue 0
+    if actual != 0
+      expect(actual).to eq(expected)
+    else
+      puts actual_str
+      raise "CMD #{cmd} echoed non-YAML (above)"
+    end
+  else
+    actual = actual_str.gsub(/\s+/, "").gsub("\e", "\\e")
+    expect(actual).to eq(expected)
+  end
+end
+
+def hello_kerbi(cmd, namespace=nil)
+  target = "#{__dir__}/mini-projects/hello-kerbi"
+  cmd = "#{cmd} --project-root #{target}"
+  cmd = "#{cmd} --namespace #{namespace}" if namespace
+  cmd
+end
+
+def cmd_group_spec(cmd, dir, file, opts={})
+  (opts[:formats] || %w[yaml json table]).each do |format|
+    context "with --output-format #{format} #{opts[:context_append]}" do
+      it "echos the expected text" do
+        extension = format == 'table' ? "txt" :  format
+        cmd_with_fmt = "#{cmd} -o #{format}"
+        exp_cli_eq_file(cmd_with_fmt, dir, file, extension)
+      end
+    end
+  end
+end
+
 module Kerbi
   module Testing
 
@@ -33,7 +176,6 @@ module Kerbi
       system "rm -rf #{TEST_YAMLS_DIR}"
       system "mkdir #{TEST_YAMLS_DIR}"
     end
-
   end
 end