levels 0.1.0

data/test/bin/options_test.rb

@@ -0,0 +1,41 @@
+require 'helper'
+
+describe "bin: options" do
+
+  describe "--[no-]color" do
+
+    before do
+      w("one.rb", <<-RUBY)
+group :sample
+  set message: "hello"
+      RUBY
+    end
+
+    it "can be turned on" do
+      assert_success "levels --color #{f 'one.rb'}"
+      stderr.must_match(Levels::Colorizer::FOREGROUND[:green])
+    end
+
+    it "can be turned off" do
+      assert_success "levels --no-color #{f 'one.rb'}"
+      stderr.wont_match(Levels::Colorizer::FOREGROUND[:green])
+    end
+  end
+
+  describe "--version" do
+
+    it "works" do
+      assert_success "levels --version"
+      stdout.must_equal "Levels #{Levels::VERSION}\n"
+    end
+  end
+
+  describe "--help" do
+
+    it "works" do
+      assert_success "levels --help"
+      stdout.split("\n")[0].must_equal "Usage: levels [options] [files]"
+    end
+  end
+end
+

data/test/helper.rb

@@ -0,0 +1,12 @@
+require 'minitest/spec'
+require 'minitest/hell'
+require 'minitest/autorun'
+# fivemat isn't compatible with parallel tests right now
+#require 'fivemat/minitest/autorun'
+
+require 'levels'
+
+require 'support/tempfile_helper'
+require 'support/base_spec'
+require 'support/acceptance_spec'
+require 'support/bin_spec'

data/test/support/acceptance_spec.rb

@@ -0,0 +1,58 @@
+class AcceptanceSpec < MiniTest::Spec
+  include TempfileHelper
+
+  register_spec_type(self) do |desc|
+    desc =~ /^acceptance:/
+  end
+
+  def standard_data_types_level(name = :level)
+    level = Levels::Level.new("standard data types")
+    level.set_group(:types,
+      string: "hello",
+      integer: 123,
+      float: 1.5,
+      boolean_true: true,
+      boolean_false: false,
+      array_of_string: ["a", "b", "c"],
+      array_of_integer: [1, 2, 3],
+      null: nil
+    )
+    level.set_group(:group2,
+      message: "hello world"
+    )
+    level
+  end
+
+  def self.assert_sample_data_set
+
+    it "parses string" do
+      subject.types.string.must_equal "hello"
+    end
+
+    it "parses integer" do
+      subject.types.integer.must_equal 123
+    end
+
+    it "parses float" do
+      subject.types.float.must_equal 1.5
+    end
+
+    it "parses boolean" do
+      subject.types.boolean_true.must_equal true
+      subject.types.boolean_false.must_equal false
+    end
+
+    it "parses array" do
+      subject.types.array_of_string.must_equal ["a", "b", "c"]
+      subject.types.array_of_integer.must_equal [1, 2, 3]
+    end
+
+    it "parses null" do
+      subject.types.null.must_equal nil
+    end
+
+    it "parses all groups" do
+      subject.group2.message.must_equal "hello world"
+    end
+  end
+end

data/test/support/base_spec.rb

@@ -0,0 +1,14 @@
+class BaseSpec < MiniTest::Spec
+
+  register_spec_type(self) { true }
+
+  # Verify that when an Input is read into a Level,
+  # that the Level matches the given Hash.
+  def assert_input_equals_hash(hash)
+    level = Levels::Level.new("Test")
+    subject.read(level)
+    level.eql_hash?(hash).must_equal true
+  end
+
+end
+

data/test/support/bin_spec.rb

@@ -0,0 +1,65 @@
+require 'tmpdir'
+
+class BinSpec < MiniTest::Spec
+  include TempfileHelper
+
+  register_spec_type(self) do |desc|
+    desc =~ /^bin:/
+  end
+
+  Result = Struct.new(:stdout, :stderr, :status)
+
+  def set_env(hash)
+    @command_env = hash
+  end
+
+  def assert_success(command)
+    args = [@command_env, command].compact
+    stdout, stderr, status = Open3.capture3(*args)
+    @result = Result.new(stdout, stderr, status.exitstatus)
+    if @result.status != 0
+      raise MiniTest::Assertion, "Status: #{@result.status}\n#{@result.stderr}"
+    end
+  end
+
+  def stdout
+    @result.stdout
+  end
+
+  def stderr
+    @result.stderr
+  end
+
+  def status
+    @result.status
+  end
+
+  # Create a temporary directory. This directory will exist for the life of
+  # the spec.
+  #
+  # id - Identifier of the tmpdir (default: the default identifier).
+  #
+  # Returns a Pathname.
+  def tmpdir(id=:default)
+    @tmpdirs[id] ||= Pathname.new(Dir.mktmpdir).realdirpath
+  end
+
+  # Get a file within the tmpdir.
+  def f(name)
+    tmpdir + name
+  end
+
+  # Write a file within the tmpdir.
+  def w(name, content)
+    f(name).open("w") { |f| f.puts content }
+  end
+
+  before do
+    @tmpdirs = {}
+  end
+
+  after do
+    @tmpdirs.values.each { |dir| FileUtils.rm_rf dir.to_s }
+  end
+
+end

data/test/support/tempfile_helper.rb

@@ -0,0 +1,35 @@
+module TempfileHelper
+
+  # Create a temporary directory. This directory will exist for the life of
+  # the spec.
+  #
+  # id - Identifier of the tmpdir (default: the default identifier).
+  #
+  # Returns a Pathname.
+  def tmpdir(id=:default)
+    @tmpdirs[id] ||= Pathname.new(Dir.mktmpdir).realdirpath
+  end
+
+  # Get a file within the tmpdir.
+  def f(name)
+    tmpdir + name
+  end
+
+  # Write a file within the tmpdir.
+  def w(name, content)
+    f(name).open("w") { |f| f.print content }
+    f(name)
+  end
+
+  def self.included(base)
+    base.class_eval do
+      before do
+        @tmpdirs = {}
+      end
+      after do
+        @tmpdirs.values.each { |dir| FileUtils.rm_rf dir.to_s }
+      end
+    end
+  end
+
+end

data/test/unit/audit/group_observer_test.rb

@@ -0,0 +1,24 @@
+require 'helper'
+
+describe Levels::Audit::GroupObserver do
+
+  let(:value_observer) { MiniTest::Mock.new }
+  let(:user_observer) { MiniTest::Mock.new }
+
+  subject { Levels::Audit::GroupObserver.new(value_observer, user_observer) }
+
+  it "observes values by finding them and notifying what it found" do
+    levels = MiniTest::Mock.new
+    group_key = :group
+    value_key = :value
+
+    observed_values = "the values"
+    value_observer.expect(:observe_values, observed_values, [levels, group_key, value_key])
+    user_observer.expect(:on_values, nil, [observed_values])
+
+    returned_values = subject.observe_values(levels, group_key, value_key)
+    returned_values.must_equal observed_values
+    value_observer.verify
+    user_observer.verify
+  end
+end

data/test/unit/audit/nested_group_observer_test.rb

@@ -0,0 +1,28 @@
+require 'helper'
+
+describe Levels::Audit::NestedGroupObserver do
+
+  let(:value_observer) { MiniTest::Mock.new }
+
+  subject { Levels::Audit::NestedGroupObserver.new(value_observer) }
+
+  it "observes values by collecting them, then notifying when asked" do
+    levels = MiniTest::Mock.new
+    group_key = :group
+    value_key = :value
+
+    observed_values = "the values"
+    value_observer.expect(:observe_values, observed_values, [levels, group_key, value_key])
+
+    returned_values = subject.observe_values(levels, group_key, value_key)
+    returned_values.must_equal observed_values
+    value_observer.verify
+
+    user_observer = MiniTest::Mock.new
+    user_observer.expect(:on_nested_values, nil, [observed_values])
+
+    subject.notify_nested(user_observer)
+    user_observer.verify
+  end
+end
+

data/test/unit/audit/root_observer_test.rb

@@ -0,0 +1,54 @@
+require 'helper'
+
+describe Levels::Audit::RootObserver do
+
+  let(:lazy_evaluator) { MiniTest::Mock.new }
+  let(:user_observer)  { MiniTest::Mock.new }
+
+  subject { Levels::Audit::RootObserver.new(lazy_evaluator) }
+
+  describe "#observe_group without a current value" do
+
+    it "returns a group observer" do
+      group_observer = subject.observe_group(user_observer)
+      group_observer.must_be_instance_of Levels::Audit::GroupObserver
+    end
+  end
+
+  describe "#with_current_value" do
+
+    it "sets the current value for the life of the block, and restores each previous value" do
+      value1 = "the value 1"
+      value2 = "the value 2"
+
+      subject.current_value.must_be_nil
+
+      subject.with_current_value(value1) do
+        subject.current_value.must_equal value1
+
+        subject.with_current_value(value2) do
+          subject.current_value.must_equal value2
+        end
+
+        subject.current_value.must_equal value1
+      end
+
+      subject.current_value.must_be_nil
+    end
+  end
+
+  describe "#observe_group with a current value" do
+
+    it "returns a nested group observer, and adds that observer to the current value" do
+      value = MiniTest::Mock.new
+      value.expect(:add_nested_group_observer, nil, [Levels::Audit::NestedGroupObserver])
+
+      group_observer = nil
+      subject.with_current_value(value) do
+        group_observer = subject.observe_group(user_observer)
+      end
+
+      group_observer.must_be_instance_of Levels::Audit::NestedGroupObserver
+    end
+  end
+end

data/test/unit/audit/value_observer_test.rb

@@ -0,0 +1,63 @@
+require 'helper'
+
+describe Levels::Audit::ValueObserver do
+
+  let(:root_observer_class) {
+    Class.new do
+
+      def initialize
+        @values = []
+      end
+
+      def with_current_value(value)
+        @values << value
+        yield
+      end
+
+      def raw_values
+        @values.map { |v| v.raw }
+      end
+    end
+  }
+
+  let(:root_observer)  { root_observer_class.new }
+  let(:lazy_evaluator) { MiniTest::Mock.new }
+
+  after do
+    lazy_evaluator.verify
+  end
+
+  subject { Levels::Audit::ValueObserver.new(root_observer, lazy_evaluator) }
+
+  it "traverses all levels to find values" do
+    level1 = Levels::Level.new("one")
+    level1.set_group(:group, a: 1)
+
+    level2 = Levels::Level.new("two")
+    level2.set_group(:group, a: 2)
+
+    level3 = Levels::Level.new("two")
+    level3.set_group(:group, b: 0)
+
+    level4 = Levels::Level.new("two")
+
+    # A Level for each case, and two with applicable values.
+    levels = [level1, level2, level3, level4]
+
+    # Translate the initial values into something else.
+    lazy_evaluator.expect(:call, 11, [1])
+    lazy_evaluator.expect(:call, 22, [2])
+
+    values = subject.observe_values(levels, :group, :a)
+
+    values.must_be_instance_of Levels::Audit::Values
+    values.group_key.must_equal :group
+    values.value_key.must_equal :a
+
+    # The observer was passed each Value
+    root_observer.raw_values.must_equal [11, 22]
+
+    # The returned Values is made up of each Value.
+    values.map { |v| v.raw }.must_equal [11, 22]
+  end
+end

data/test/unit/audit/value_test.rb

@@ -0,0 +1,41 @@
+require 'helper'
+
+describe Levels::Audit::Value do
+
+  let(:level_name) { "My Level" }
+  let(:final)      { true }
+  let(:value)      { "hello" }
+
+  subject { Levels::Audit::Value.new(level_name, final) { value } }
+
+  it "exposes the level_name" do
+    subject.level_name.must_equal level_name
+  end
+
+  it "exposes the value" do
+    subject.value.must_equal "hello"
+  end
+
+  it "exposes the value as `raw`" do
+    subject.raw.must_equal "hello"
+  end
+
+  it "inspect's as the value" do
+    subject.inspect.must_equal %("hello")
+  end
+
+  it "expose finality" do
+    a = Levels::Audit::Value.new(level_name, true) { value }
+    b = Levels::Audit::Value.new(level_name, false) { value }
+    a.must_be :final?
+    b.wont_be :final?
+  end
+
+  it "exposes recursiveness" do
+    subject.wont_be :recursive?
+
+    subject.add_nested_group_observer(MiniTest::Mock.new)
+
+    subject.must_be :recursive?
+  end
+end