levels 0.1.0

data/test/unit/input/system_test.rb

@@ -0,0 +1,59 @@
+require 'helper'
+
+describe Levels::Input::System do
+
+  let(:template) { {} }
+  let(:key_formatter) { nil }
+  let(:env_hash) { {} }
+
+  subject { Levels::Input::System.new(template.to_enum, key_formatter, env_hash) }
+
+  [nil, "MY_"].each do |prefix|
+    describe "finding data in the System with #{prefix || 'no'} prefix" do
+
+      let(:key_formatter) { Levels::System::KeyFormatter.new(prefix) }
+
+      before do
+        template[:sample] = { hello: "world" }.to_enum
+        template[:settings] = { hello: "world" }.to_enum
+      end
+
+      it "finds variables that exist in the template" do
+        env_hash["#{prefix}SAMPLE_HELLO"] = "universe"
+
+        assert_input_equals_hash(
+          sample: {
+            hello: "universe"
+          }
+        )
+      end
+
+      it "does not find variables not in the template" do
+        env_hash["#{prefix}SAMPLE_WORLD"] = "this"
+        env_hash["#{prefix}OTHER_HELLO"] = "that"
+
+        assert_input_equals_hash({})
+      end
+
+      it "does not find variables with another prefix" do
+        env_hash["OTHER_SAMPLE_HELLO"] = "ok"
+
+        assert_input_equals_hash({})
+      end
+    end
+  end
+
+  describe "typecasting data from the system" do
+
+      it "converts data to the right type" do
+        env_hash["SAMPLE_NUMBER"] = "123"
+        env_hash["SAMPLE_NUMBER_TYPE"] = "integer"
+
+        assert_input_equals_hash(
+          sample: {
+            number: 123
+          }
+        )
+      end
+  end
+end

data/test/unit/input/yaml_test.rb

@@ -0,0 +1,33 @@
+require 'helper'
+
+describe Levels::Input::YAML do
+
+  let(:yaml_string) {
+    <<-STR
+---
+group1:
+  key1: string
+  key2: 123
+group2:
+  key: 
+  - 1
+  - 2
+  - 3
+    STR
+  }
+
+  subject { Levels::Input::YAML.new(yaml_string) }
+
+  it "reads data from the JSON structure" do
+    assert_input_equals_hash(
+      group1: {
+        key1: "string",
+        key2: 123
+      },
+      group2: {
+        key: [1, 2, 3]
+      }
+    )
+  end
+end
+

data/test/unit/key_test.rb

@@ -0,0 +1,45 @@
+require 'helper'
+
+describe Levels::Key do
+
+  let(:input) { "settings" }
+
+  subject { Levels::Key.new(input) }
+
+  specify "#to_sym" do
+    subject.to_sym.must_equal :settings
+  end
+
+  specify "#inspect" do
+    subject.inspect.must_equal "<Levels::Key :settings>"
+  end
+
+  specify "#to_s" do
+    subject.to_s.must_equal subject.inspect
+  end
+
+  describe "comparisons" do
+
+    let(:a) { Levels::Key.new(:a) }
+    let(:b) { Levels::Key.new(:a) }
+    let(:c) { Levels::Key.new(:b) }
+
+    specify "equality" do
+      (a == b).must_equal true
+      (b == a).must_equal true
+      (a == c).must_equal false
+      (a == :a).must_equal false
+    end
+
+    specify "hashing" do
+      hash = {}
+      hash[a] = true
+      hash[a].must_equal true
+      hash[b].must_equal true
+      hash[c].must_equal nil
+      hash[:a].must_equal nil
+    end
+  end
+end
+
+

data/test/unit/key_values_test.rb

@@ -0,0 +1,106 @@
+require 'helper'
+
+describe Levels::KeyValues do
+
+  let(:data) { nil }
+
+  subject { Levels::KeyValues.new(data) }
+
+  describe "in general" do
+
+    let(:data) { { "a" => 1 } }
+
+    describe "#[]" do
+
+      it "handles string keys" do
+        subject["a"].must_equal 1
+      end
+
+      it "handles symbol keys" do
+        subject[:a].must_equal 1
+      end
+
+      it "returns nil when the key does not exist" do
+        subject[:b].must_equal nil
+      end
+    end
+
+    describe "#pair" do
+
+      it "returns a Key and the value" do
+        key, value = subject.pair(:a)
+        key.must_equal Levels::Key.new(:a)
+        value.must_equal 1
+      end
+
+      it "returns a Key and nil if the key does not exist" do
+        key, value = subject.pair(:b)
+        key.must_equal Levels::Key.new(:b)
+        value.must_equal nil
+      end
+    end
+
+    describe "#[]=" do
+
+      it "handles string keys" do
+        subject["a"] = 2
+        subject[:a].must_equal 2
+      end
+
+      it "handles Symbol keys" do
+        subject[:a] = 2
+        subject[:a].must_equal 2
+      end
+
+      it "can add new keys" do
+        subject[:b] = 1
+        subject[:b].must_equal 1
+      end
+    end
+
+    describe "#key?" do
+
+      it "handles string keys" do
+        subject.key?("a").must_equal true
+      end
+
+      it "handles symbol keys" do
+        subject.key?(:a).must_equal true
+      end
+
+      it "returns false if the key does not exist" do
+        subject.key?(:b).must_equal false
+      end
+    end
+
+    specify "#inspect" do
+      subject.inspect.must_equal "<Levels::KeyValues>"
+    end
+
+    specify "#to_s" do
+      subject.to_s.must_equal subject.inspect
+    end
+  end
+
+  describe "comparisons" do
+
+    let(:a) { Levels::KeyValues.new(a: 1) }
+    let(:b) { Levels::KeyValues.new(a: 1) }
+    let(:c) { Levels::KeyValues.new(b: 1) }
+
+    specify "equality" do
+      (a == b).must_equal true
+      (a == c).must_equal false
+      (a == {a:1}).must_equal false
+    end
+
+    specify "hashing" do
+      hash = {}
+      hash[a] = true
+      hash[a].must_equal true
+      hash[b].must_equal true
+      hash[c].must_equal nil
+      hash[{a:1}].must_equal nil
+    end
+  end
+end

data/test/unit/lazy_evaluator_test.rb

@@ -0,0 +1,38 @@
+require 'helper'
+
+describe Levels::LazyEvaluator do
+
+  let(:level) { Levels::Level.new("level") }
+
+  subject { Levels::LazyEvaluator.new(level) }
+
+  it "returns a value" do
+    subject.call(123).must_equal 123
+  end
+
+  it "executes a proc" do
+    subject.call(-> { 123 }).must_equal 123
+  end
+
+  it "executes a proc recursively" do
+    subject.call(-> { -> { 123 } }).must_equal 123
+  end
+
+  it "allows the level to be accessed directly" do
+    level.set_group(:sample, message: "hello")
+    subject.call(-> { sample.message }).must_equal "hello"
+    subject.call(-> { sample[:message] }).must_equal "hello"
+    subject.call(-> { sample.defined?(:message) }).must_equal true
+    subject.call(-> { sample.message? }).must_equal true
+  end
+
+  it "evaluates values within an array" do
+    subject.call([-> { 123 }]).must_equal [123]
+  end
+
+  it "allows shell style interpolation" do
+    skip "for now"
+    level.set_group(:sample, message: "hello")
+    subject.call("${SAMPLE_HELLO} world").must_equal "hello world"
+  end
+end

data/test/unit/level_test.rb

@@ -0,0 +1,89 @@
+require 'helper'
+
+describe Levels::Level do
+
+  subject { Levels::Level.new("test") }
+
+  specify "#_level_name" do
+    subject._level_name.must_equal "test"
+  end
+
+  specify "#to_s" do
+    subject.to_s.must_equal "<Levels::Level \"test\">"
+  end
+
+  it "allows groups to be defined and accessed" do
+    subject.set_group(:test, key: 123)
+    subject.test.must_be_instance_of Levels::Group
+    subject[:test].must_be_instance_of Levels::Group
+  end
+
+  it "handls a string group name" do
+    subject.set_group("test", key: 123)
+    subject.test.must_be_instance_of Levels::Group
+    subject[:test].must_be_instance_of Levels::Group
+  end
+
+  it "raises an error if you access an unknown group" do
+    proc { subject.nothing }.must_raise Levels::UnknownGroup
+    proc { subject[:nothing] }.must_raise Levels::UnknownGroup
+  end
+
+  it "allows the existence of a group to be tested" do
+    subject.set_group(:test, key: 123)
+    subject.defined?(:test).must_equal true
+    subject.defined?(:foo).must_equal false
+    subject.test?.must_equal true
+    subject.foo?.must_equal false
+  end
+
+  it "does not allow a group to be redefined" do
+    subject.set_group(:test, key: 123)
+    proc { subject.set_group(:test, key: 123) }.must_raise Levels::DuplicateGroup
+  end
+
+  describe "#to_enum" do
+
+    it "returns an Enumerator" do
+      subject.to_enum.must_be_instance_of Enumerator
+    end
+
+    it "iterates over all groups" do
+      subject.set_group(:test1, key: 123)
+      subject.set_group(:test2, key: 123)
+      result = subject.to_enum.map do |k, v|
+        [k, v.class]
+      end
+      expected = [
+        [:test1, Enumerator],
+        [:test2, Enumerator]
+      ]
+      result.sort.must_equal expected.sort
+    end
+  end
+
+  describe "#eql_hash?" do
+
+    let(:expected) {
+      {
+        test1: {
+          key: 123
+        },
+        "test2" => {
+          "key" => 123
+        }
+      }
+    }
+
+    before do
+      subject.set_group(:test1, key: 123)
+      subject.set_group(:test2, key: 123)
+    end
+
+    it "is true if the hash matches the data" do
+      subject.eql_hash?(expected).must_equal true
+      subject.eql_hash?(a: 1).must_equal false
+    end
+  end
+end
+

data/test/unit/levels_test.rb

@@ -0,0 +1,23 @@
+require 'helper'
+
+describe Levels do
+
+  specify ".setup" do
+    Levels.setup.must_be_instance_of Levels::Setup
+  end
+
+  specify ".merge" do
+    Levels.merge.must_be_instance_of Levels::Configuration
+  end
+
+  specify ".merge with a block" do
+    block_called = false
+    configuration = Levels.merge do |setup|
+      block_called = true
+      setup.must_be_instance_of Levels::Setup
+    end
+    block_called.must_equal true
+    configuration.must_be_instance_of Levels::Configuration
+  end
+end
+

data/test/unit/output/json_test.rb

@@ -0,0 +1,55 @@
+require 'helper'
+
+describe Levels::Output::JSON do
+
+  let(:data) {
+    {
+      group1: {
+        key1: "string",
+        key2: 123
+      },
+      group2: {
+        key: [1, 2, 3]
+      }
+    }
+  }
+
+  let(:json_opts) { nil }
+
+  subject { Levels::Output::JSON.new(json_opts) }
+
+  def result
+    subject.generate(data.to_enum)
+  end
+
+  it "converts to JSON" do
+    result.must_equal <<-STR.chomp
+{
+  "group1": {
+    "key1": "string",
+    "key2": 123
+  },
+  "group2": {
+    "key": [
+      1,
+      2,
+      3
+    ]
+  }
+}
+    STR
+  end
+
+
+  describe "initialized with json opts" do
+
+    let(:json_opts) { {} }
+
+    it "changes the formatting" do
+      result.must_equal <<-STR.chomp
+{"group1":{"key1":"string","key2":123},"group2":{"key":[1,2,3]}}
+      STR
+    end
+  end
+end
+