kerbi 0.0.1 → 0.0.2

data/spec/expectations/root/template.yaml

@@ -0,0 +1,31 @@
+apiVersion: v1
+kind: Pod
+metadata:
+  name: hello-kerbi
+  namespace: foo
+  annotations:
+    author: xavier
+  labels:
+    app: hello-kerbi
+spec:
+  containers:
+    - name: main
+      image: nginx:alpine
+
+---
+
+apiVersion: v1
+kind: Service
+metadata:
+  name: hello-kerbi
+  namespace: foo
+  annotations:
+    author: xavier
+  labels:
+    app: hello-kerbi
+spec:
+  type: ClusterIP
+  selector:
+    app: hello-kerbi
+  ports:
+    - port: 80

data/spec/expectations/root/values.json

@@ -0,0 +1,28 @@
+{
+  "centos": {
+    "pod": {
+      "image": "centos"
+    },
+    "service": {
+      "type": "ClusterIP"
+    }
+  },
+
+  "nginx": {
+    "pod": {
+      "image": "nginx"
+    },
+    "service": {
+      "type": "ClusterIP"
+    }
+  },
+
+  "debian": {
+    "pod": {
+      "image": "debian"
+    },
+    "service": {
+      "type": "ClusterIP"
+    }
+  }
+}

data/spec/expectations/state/delete.txt

@@ -0,0 +1 @@
+Deleted state[two]. Remaining entries: 3

data/spec/expectations/state/demote.txt

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

data/spec/expectations/state/init-already-existed.txt

@@ -0,0 +1,2 @@
+\e[1;39;49mnamespaces/kerbi-spec: \e[0m\e[1;32;49mAlready existed\e[0m
+\e[1;39;49mkerbi-spec/configmaps/kerbi-state-tracker: \e[0m\e[1;32;49mAlready existed\e[0m

data/spec/expectations/state/init-both-created.txt

@@ -0,0 +1,2 @@
+\e[1;39;49mnamespaces/kerbi-spec: \e[0m\e[1;34;49mCreated\e[0m
+\e[1;39;49mkerbi-spec/configmaps/kerbi-state-tracker: \e[0m\e[1;34;49mCreated\e[0m

data/spec/expectations/state/list.json

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

data/spec/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/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/expectations/state/promote.txt

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

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

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

data/spec/expectations/state/retag.txt

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

data/spec/expectations/state/set.txt

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

data/spec/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/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/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/expectations/state/status-all-working.txt

@@ -0,0 +1,4 @@
+\e[1;39;49m1. Create Kubernetes client: \e[0m\e[1;32;49mSuccess\e[0m
+\e[1;39;49m2. List cluster namespaces: \e[0m\e[1;32;49mSuccess\e[0m
+\e[1;39;49m3. Target namespace kerbi-spec exists: \e[0m\e[1;32;49mSuccess\e[0m
+\e[1;39;49m4. Resource kerbi-spec/cm/kerbi-state-tracker exists: \e[0m\e[1;32;49mSuccess\e[0m

data/spec/expectations/state/status-not-provisioned.txt

@@ -0,0 +1,4 @@
+\e[1;39;49m1. Create Kubernetes client: \e[0m\e[1;32;49mSuccess\e[0m
+\e[1;39;49m2. List cluster namespaces: \e[0m\e[1;32;49mSuccess\e[0m
+\e[1;39;49m3. Target namespace kerbi-spec exists: \e[0m\e[1;31;49mFailure\e[0m
+\e[1;39;49m4. Resource kerbi-spec/cm/kerbi-state-tracker exists: \e[0m\e[1;31;49mFailure\e[0m

data/spec/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,109 @@
+require_relative './../spec_helper'
+
+RSpec.describe Kerbi::State::ConfigMapBackend do
+
+  let(:namespace) { "kerbi-spec" }
+  let(:cm_name) { Kerbi::State::Consts::RESOURCE_NAME }
+
+  before :each do
+    kmd("create ns #{namespace}")
+    kmd("delete cm #{cm_name} -n #{namespace}")
+    # sleep(2) #ADD ME BACK IF WEIRD ERRORS... :/
+  end
+
+  describe "#provision_missing_resources" do
+    let(:backend) { make_backend(namespace) }
+
+    context "when the namespace does not exist" do
+      it "provisions accordingly" do
+        kmd("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
+        kmd("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
+          kmd("delete cm #{cm_name} -n #{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.read_write_ready?).to eq(true)
+      expect(backend.namespace_exists?).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([])
+        expect(result[:kind]).to eq('ConfigMap')
+        expect(result[:metadata][:name]).to eq('kerbi-state-tracker')
+        expect(result[: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)
+      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/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/spec_helper.rb

@@ -5,6 +5,93 @@ SimpleCov.start
 
 require_relative './../lib/kerbi'
 
+def kmd(command)
+  opts = { err: File::NULL, out: File::NULL }
+  system("kubectl #{command} --context kind-kind", **opts)
+end
+
+# @return [Kerbi::State::ConfigMapBackend]
+def make_backend(namespace)
+  Kerbi::State::ConfigMapBackend.new(
+    Kerbi::Utils::K8sAuth.kube_config_bundle,
+    namespace
+  )
+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__}/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)
+    expect(actual).to eq(expected)
+  else
+    actual = actual_str.gsub(/\s+/, "").gsub("\e", "\\e")
+    expect(actual).to eq(expected)
+  end
+end
+
+def hello_kerbi(cmd, namespace=nil)
+  target = "#{__dir__}/../examples/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 +120,6 @@ module Kerbi
       system "rm -rf #{TEST_YAMLS_DIR}"
       system "mkdir #{TEST_YAMLS_DIR}"
     end
-
   end
 end