levels 0.1.0

data/test/unit/audit/values_test.rb

@@ -0,0 +1,86 @@
+require 'helper'
+
+describe Levels::Audit::Values do
+
+  let(:group_key) { :group }
+  let(:value_key) { :value }
+  let(:values)    { [] }
+
+  subject { Levels::Audit::Values.new(group_key, value_key, values) }
+
+  it "exposes the group_key" do
+    subject.group_key.must_equal group_key
+  end
+
+  it "exposes the value_key" do
+    subject.value_key.must_equal value_key
+  end
+
+  specify "#final" do
+    v1 = Levels::Audit::Value.new("a", false)
+    v2 = Levels::Audit::Value.new("a", true)
+
+    values.concat [v1, v2]
+
+    subject.final.must_equal v2
+  end
+
+  specify "#final_value" do
+    v1 = Levels::Audit::Value.new("a", false, "no")
+    v2 = Levels::Audit::Value.new("a", true, "hello")
+
+    values.concat [v1, v2]
+
+    subject.final_value.must_equal "hello"
+  end
+
+  specify "#each is Enumerable" do
+    subject.map.must_be_instance_of Enumerator
+  end
+
+  specify "#only_final?" do
+    v1 = MiniTest::Mock.new
+    v1.expect(:final?, false)
+    v2 = MiniTest::Mock.new
+    v2.expect(:final?, true)
+
+    subject.wont_be :only_final?
+
+    values << v2
+    subject.must_be :only_final?
+
+    values << v1
+    subject.wont_be :only_final?
+  end
+
+  specify "#recursive?" do
+    v1 = MiniTest::Mock.new
+    2.times { v1.expect(:recursive?, false) }
+    v2 = MiniTest::Mock.new
+    v2.expect(:recursive?, true)
+
+    subject.wont_be :recursive?
+
+    values << v1
+    subject.wont_be :recursive?
+
+    values << v2
+    subject.must_be :recursive?
+  end
+
+  specify "#size" do
+    values.size.must_equal 0
+
+    values << MiniTest::Mock.new
+
+    values.size.must_equal 1
+  end
+
+  specify "#empty?" do
+    values.must_be :empty?
+
+    values << MiniTest::Mock.new
+
+    values.wont_be :empty?
+  end
+end

data/test/unit/configuration_test.rb

@@ -0,0 +1,72 @@
+require 'helper'
+
+describe Levels::Configuration do
+
+  let(:level1) { Levels::Level.new("l1") }
+  let(:level2) { Levels::Level.new("l2") }
+
+  subject { Levels::Configuration.new([level1, level2]) }
+
+  before do
+    level1.set_group(:g1, a: 1)
+
+    level2.set_group(:g1, a: 9)
+    level2.set_group(:g2, b: 2)
+  end
+
+  specify "#to_s" do
+    subject.to_s.must_equal "<Levels::Configuration l1, l2>"
+  end
+
+  it "allows groups to be retrieved" do
+    subject.g1.must_be_instance_of Levels::ConfiguredGroup
+    subject[:g1].must_be_instance_of Levels::ConfiguredGroup
+  end
+
+  it "initializes the configured group with the right levels" do
+    subject.g1.a.must_equal 9
+    subject.g1.b?.must_equal false
+
+    subject.g2.b.must_equal 2
+    subject.g2.a?.must_equal false
+  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.defined?(:g1).must_equal true
+    subject.defined?(:g2).must_equal true
+    subject.defined?(:foo).must_equal false
+    subject.g1?.must_equal true
+    subject.g2?.must_equal true
+    subject.foo?.must_equal false
+  end
+
+  it "allows lazy evaluation" do
+    level2.set_group(:g3, sum: -> { g1.a + g2.b })
+    subject.g3.sum.must_equal 11
+  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
+      result = subject.to_enum.map do |k, v|
+        [k.to_sym, v.class]
+      end
+      expected = [
+        [:g1, Enumerator],
+        [:g2, Enumerator]
+      ]
+      result.sort.must_equal expected.sort
+    end
+  end
+end
+
+

data/test/unit/configured_group_test.rb

@@ -0,0 +1,75 @@
+require 'helper'
+
+describe Levels::ConfiguredGroup do
+
+  let(:levels) { [] }
+  let(:group_observer) { MiniTest::Mock.new }
+
+  subject { Levels::ConfiguredGroup.new(levels, :test, group_observer) }
+
+  def define_value(key, value)
+    level = Levels::Level.new("one")
+    level.set_group(:test, key => value)
+    levels << level
+  end
+
+  def observe_value(key, value)
+    observed_values = MiniTest::Mock.new
+    observed_values.expect(:final_value, value)
+    group_observer.expect(:observe_values, observed_values, [levels, :test, key])
+  end
+
+  describe "checking value existence" do
+
+    before do
+      define_value :a, nil
+    end
+
+    it "allows defined?" do
+      subject.defined?(:a).must_equal true
+    end
+
+    it "allows method access" do
+      subject.a?.must_equal true
+    end
+  end
+
+  describe "reading values" do
+
+    before do
+      define_value :a, nil
+      observe_value :a, 1
+    end
+
+    it "allows hash access to any key" do
+      subject[:a].must_equal 1
+    end
+
+    it "allows method access" do
+      subject.a.must_equal 1
+    end
+  end
+
+  describe "#to_enum" do
+
+    before do
+      define_value :a, nil
+      observe_value :a, 1
+    end
+
+    it "returns an Enumerator" do
+      subject.to_enum.must_be_instance_of Enumerator
+    end
+
+    it "iterates over all keys and values" do
+      result = subject.to_enum.map do |k, v|
+        [k.to_sym, v]
+      end
+      expected = [
+        [:a, 1],
+      ]
+      result.sort.must_equal expected.sort
+    end
+  end
+end
+

data/test/unit/group_test.rb

@@ -0,0 +1,105 @@
+require 'helper'
+
+describe Levels::Group do
+
+  let(:hash) { {} }
+  let(:value_transformer) { nil }
+
+  subject { Levels::Group.new(hash, value_transformer) }
+
+  before do
+    hash[:name] = "ok"
+    hash[:value] = 123
+    hash[:other] = nil
+  end
+
+  specify "#to_s" do
+    subject.to_s.must_equal "<Levels::Group>"
+  end
+
+  it "allows hash access" do
+    subject[:name].must_equal "ok"
+    subject[:value].must_equal 123
+    subject[:other].must_equal nil
+  end
+
+  it "allows dot access" do
+    subject.name.must_equal "ok"
+    subject.value.must_equal 123
+    subject.other.must_equal nil
+  end
+
+  it "raises an error if you access a nonexistent key" do
+    proc { subject[:foo] }.must_raise Levels::UnknownKey
+    proc { subject.foo }.must_raise Levels::UnknownKey
+  end
+
+  it "allows the existence of a key to be tested" do
+    subject.defined?(:name).must_equal true
+    subject.defined?(:foo).must_equal false
+    subject.name?.must_equal true
+    subject.foo?.must_equal false
+  end
+
+  it "makes sure you don't call it wrong" do
+    proc { subject.name("ok") }.must_raise ArgumentError
+  end
+
+  describe "initialized with string keys" do
+
+    it "converts everything to symbols" do
+      hash["string"] = 123
+      subject.string.must_equal 123
+      subject[:string].must_equal 123
+    end
+  end
+
+  describe "initialized with a value transformer" do
+
+    let(:value_transformer) {
+      -> key, value { [key, value] }
+    }
+
+    it "returns the value via the transformer" do
+      subject.name.must_equal [:name, "ok"]
+      subject[:name].must_equal [:name, "ok"]
+      subject["name"].must_equal [:name, "ok"]
+    end
+  end
+
+  describe "#to_enum" do
+
+    it "returns an Enumerator" do
+      subject.to_enum.must_be_instance_of Enumerator
+    end
+
+    it "iterates over all keys and values" do
+      result = subject.to_enum.map do |k, v|
+        [k, v]
+      end
+      expected = [
+        [:name, "ok"],
+        [:value, 123],
+        [:other, nil]
+      ]
+      result.sort.must_equal expected.sort
+    end
+  end
+
+  describe "#eql_hash?" do
+
+    let(:expected) {
+      {
+        name: "ok",
+        value: 123,
+        "other" => nil
+      }
+    }
+
+    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/input/json_test.rb

@@ -0,0 +1,32 @@
+require 'helper'
+
+describe Levels::Input::JSON do
+
+  let(:json_string) {
+    <<-STR
+{
+  "group1": {
+    "key1": "string",
+    "key2": 123
+  },
+  "group2": {
+    "key": [1, 2, 3]
+  }
+}
+    STR
+  }
+
+  subject { Levels::Input::JSON.new(json_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/input/ruby_test.rb

@@ -0,0 +1,140 @@
+require 'helper'
+
+describe Levels::Input::Ruby do
+
+  let(:level) { Levels::Level.new("Ruby") }
+
+  subject { Levels::Input::Ruby.new(ruby_string, "file.rb", 1) }
+
+  describe "successfully" do
+
+    let(:ruby_string) {
+      <<-RUBY
+group :foo
+  set value: "ok"
+      RUBY
+    }
+
+    it "populates the level" do
+      subject.read(level)
+      level.eql_hash?(
+        foo: {
+          value: "ok"
+        }
+      ).must_equal true
+    end
+  end
+
+  describe "with an error" do
+
+    let(:ruby_string) {
+      <<-RUBY
+xgroup :foo
+  set value: "ok"
+      RUBY
+    }
+
+    it "provides useful information" do
+      begin
+        subject.read(level)
+      rescue => e
+        e.class.must_equal NoMethodError
+        e.message.must_equal %(undefined method `xgroup' for <Levels>:Levels::Input::Ruby::DSL)
+        e.backtrace.first.must_equal "file.rb:1:in `read'"
+      end
+    end
+  end
+end
+
+describe Levels::Input::Ruby::DSL do
+
+  let(:level) { Levels::Level.new("Ruby") }
+
+  subject { Levels::Input::Ruby::DSL.new(level) }
+
+  def define(&block)
+    subject.instance_eval(&block)
+    subject.close_current_group
+  end
+
+  it "defines an empty group" do
+    define do
+      group :one
+    end
+    level.defined?(:one).must_equal true
+  end
+
+  it "defines a group with keys" do
+    define do
+      group :one
+      set key: "value"
+    end
+    level.one.key.must_equal "value"
+  end
+
+  it "is an error to set a key outside of a group" do
+    -> {
+      define do
+        set key: "value"
+      end
+    }.must_raise(SyntaxError)
+  end
+
+  it "is an error to set a key more than once" do
+    -> {
+      define do
+        group :one
+        set key: "value"
+        set "key" => "value"
+      end
+    }.must_raise(RuntimeError)
+  end
+
+  it "is an error to define a group more than once" do
+    -> {
+      subject.group :one
+      subject.close_current_group
+      subject.group "one"
+    }.must_raise(RuntimeError)
+  end
+
+  describe "the ways to set a value" do
+
+    before do
+      subject.group :one
+    end
+
+    def assert_key
+      subject.close_current_group
+      level.one.key.must_equal "value"
+    end
+
+    it "can be set as a ruby 1.9 hash" do
+      subject.set key: "value"
+      assert_key
+    end
+
+    it "can be set as a ruby 1.8 hash" do
+      subject.set :key => "value"
+      assert_key
+    end
+
+    it "is possible to set multiple keys via a hash" do
+      subject.set :key => "value", :bar => "foo"
+      assert_key
+      level.one.bar.must_equal "foo"
+    end
+
+    it "can be set with two arguments" do
+      subject.set :key, "value"
+      assert_key
+    end
+
+    it "is an error to pass other types of args" do
+      -> { subject.set :a }.must_raise(ArgumentError)
+      -> { subject.set :a, 1, :b }.must_raise(ArgumentError)
+      -> { subject.set :a, 1, :b, 2 }.must_raise(ArgumentError)
+      -> { subject.set :b, :a => 1 }.must_raise(ArgumentError)
+    end
+  end
+end