nugrant 2.0.0.dev2 → 2.0.0.pre1

data/test/lib/nugrant/helper/test_bag.rb

@@ -0,0 +1,16 @@
+require 'minitest/autorun'
+
+require 'nugrant/helper/bag'
+
+module Nugrant
+  module Helper
+    class TestBag < ::Minitest::Test
+      def test_restricted_keys_contains_hash_ones
+        keys = Helper::Bag.restricted_keys()
+        Hash.instance_methods.each do |method|
+          assert_includes(keys, method, "Restricted keys must include Hash method #{method}")
+        end
+      end
+    end
+  end
+end

data/test/lib/nugrant/helper/test_parameters.rb

@@ -0,0 +1,17 @@
+require 'minitest/autorun'
+
+require 'nugrant/bag'
+require 'nugrant/helper/parameters'
+
+module Nugrant
+  module Helper
+    class TestParameters < ::Minitest::Test
+      def test_restricted_keys_contains_hash_ones
+        keys = Helper::Parameters.restricted_keys()
+        Nugrant::Bag.instance_methods.each do |method|
+          assert_includes(keys, method, "Restricted keys must include Nugrant::Bag method #{method}")
+        end
+      end
+    end
+  end
+end

data/test/lib/nugrant/helper/test_stack.rb

@@ -0,0 +1,152 @@
+require 'minitest/autorun'
+
+require 'nugrant/helper/stack'
+
+module Nugrant
+  module Helper
+    class TestStack < ::Minitest::Test
+      def create_stack(options = {})
+        pattern = options[:pattern] || "Vagrantfile:%s"
+        count = options[:count] || 4
+
+        stack = []
+        (0..count).each do |index|
+          stack << pattern.gsub("%s", index.to_s())
+        end
+
+        stack
+      end
+
+      def create_location(name, line)
+        resource_path = File.expand_path("#{File.dirname(__FILE__)}/../../../resources/vagrantfiles")
+
+        {:file => "#{resource_path}/#{name}", :line => line}
+      end
+
+      def assert_error_location(expected, entry, matcher = nil)
+        assert_equal(expected, Stack::extract_error_location(entry, :matcher => matcher), "Not exact error location")
+      end
+
+      def assert_error_region(expected, region)
+        expected_lines = expected.split("\n")
+        region_lines = region.split("\n")
+
+        expected_count = expected_lines.length()
+        actual_count = region_lines.length()
+
+        assert_equal(expected_count, actual_count, "Region different line count")
+
+        expected_lines.each_with_index do |expected_line, index|
+          assert_equal(expected_line.strip(), region_lines[index].strip(), "Line ##{index} are not equals")
+        end
+      end
+
+      def test_fetch_error_region_from_location()
+        location = create_location("v2.defaults_using_symbol", 4)
+        error_region = Stack::fetch_error_region_from_location(location)
+        expected_region = <<-EOT
+          1:     Vagrant.configure("2") do |config|
+          2:       config.user.defaults = {
+          3:         :single => 1,
+          4:>>       :local => {
+          5:           :first => "value1",
+          6:           :second => "value2"
+          7:         }
+          8:       }
+        EOT
+
+        assert_error_region(expected_region, error_region)
+      end
+
+      def test_fetch_error_region_from_location_custom_prefix()
+        location = create_location("v2.defaults_using_symbol", 4)
+        error_region = Stack::fetch_error_region_from_location(location, :prefix => "**")
+        expected_region = <<-EOT
+          **1:     Vagrant.configure(\"2\") do |config|
+          **2:       config.user.defaults = {
+          **3:         :single => 1,
+          **4:>>       :local => {
+          **5:           :first => "value1",
+          **6:           :second => "value2"
+          **7:         }
+          **8:       }
+        EOT
+
+        assert_error_region(expected_region, error_region)
+      end
+
+      def test_fetch_error_region_from_location_custom_width()
+        location = create_location("v2.defaults_using_symbol", 4)
+        error_region = Stack::fetch_error_region_from_location(location, :width => 2)
+        expected_region = <<-EOT
+          2:       config.user.defaults = {
+          3:         :single => 1,
+          4:>>       :local => {
+          5:           :first => "value1",
+          6:           :second => "value2"
+        EOT
+
+        assert_error_region(expected_region, error_region)
+      end
+
+      def test_fetch_error_region_from_location_wrong_location()
+        location = {:file => nil, :line => nil}
+        assert_equal("Unknown", Stack::fetch_error_region_from_location(location))
+        assert_equal("Failed", Stack::fetch_error_region_from_location(location, :unknown => "Failed"))
+
+        location = {:file => "Vagrantfile", :line => nil}
+        assert_equal("Vagrantfile", Stack::fetch_error_region_from_location(location))
+
+        location = {:file => "NonExistingVagrantfile", :line => 4}
+        assert_equal("NonExistingVagrantfile:4", Stack::fetch_error_region_from_location(location))
+      end
+
+      def test_find_entry()
+        entries = ["First", "Second:", "Third:a", "Fourth:4"]
+
+        assert_equal("Fourth:4", Stack::find_entry(entries))
+        assert_equal("Third:a", Stack::find_entry(entries, :matcher => /^(.+):([a-z]+)/))
+      end
+
+      def test_extract_error_location_default_matcher()
+        # Matches
+        assert_error_location({:file => "/work/irb/workspace.rb", :line => 80}, "/work/irb/workspace.rb:80:in `eval'")
+        assert_error_location({:file => "workspace.rb", :line => 80}, "workspace.rb:80:in `eval'")
+        assert_error_location({:file => "/work/irb/workspace.rb", :line => 80}, "/work/irb/workspace.rb:80")
+
+        # No match
+        assert_error_location({:file => nil, :line => nil}, "/work/irb/workspace.rb?80")
+        assert_error_location({:file => nil, :line => nil}, "/work/irb/workspace.rb")
+        assert_error_location({:file =>nil, :line => nil}, "")
+      end
+
+      def test_extract_error_location_custom_matcher()
+        # Matches
+        assert_error_location(
+          {:file => "/work/Vagrantfile", :line => 80},
+          "/work/Vagrantfile:80:in `eval'",
+          /(.*Vagrantfile):([0-9]+)/
+        )
+
+        assert_error_location(
+          {:file => "Vagrantfile", :line => 80},
+          "Vagrantfile:80:in `eval'",
+          /(.*Vagrantfile):([0-9]+)/
+        )
+
+        assert_error_location(
+          {:file => "/work/irb/Vagrantfile", :line => 80},
+          "/work/irb/Vagrantfile:80",
+          /(.*Vagrantfile):([0-9]+)/
+        )
+
+        # Partial match
+        assert_error_location(
+          {:file => "/work/Vagrantfile", :line => nil},
+          "/work/Vagrantfile:80:in `eval'",
+          /(.*Vagrantfile)/
+        )
+      end
+    end
+  end
+end

data/test/lib/nugrant/test_bag.rb

@@ -1,25 +1,36 @@
-require 'test/unit'
+require 'minitest/autorun'
 
 require 'nugrant/bag'
+require 'nugrant/helper/bag'
 
 module Nugrant
-  class TestBag < Test::Unit::TestCase
-    def create_bag(parameters)
-      return Bag.new(parameters)
+  class TestBag < ::Minitest::Test
+    def create_bag(elements, options = {})
+      return Bag.new(elements, options)
     end
 
-    def assert_bag(parameters, bag)
+    def assert_all_access_equal(expected, bag, key)
+      assert_equal(expected, bag.method_missing(key.to_sym), "bag.#{key.to_sym}")
+      assert_equal(expected, bag[key.to_s], "bag[#{key.to_s}]")
+      assert_equal(expected, bag[key.to_sym], "bag[#{key.to_sym}]")
+    end
+
+    def assert_all_access_bag(expected, bag, key)
+      assert_bag(expected, bag.method_missing(key.to_sym))
+      assert_bag(expected, bag[key.to_s])
+      assert_bag(expected, bag[key.to_sym])
+    end
+
+    def assert_bag(expected, bag)
       assert_kind_of(Bag, bag)
 
-      parameters.each do |key, value|
-        if not value.kind_of?(Hash)
-          assert_equal(value, bag.send(key))
-          assert_equal(value, bag[key])
+      expected.each do |key, expected_value|
+        if not expected_value.kind_of?(Hash)
+          assert_all_access_equal(expected_value, bag, key)
           next
         end
 
-        assert_bag(value, bag.send(key))
-        assert_bag(value, bag[key])
+        assert_all_access_bag(expected_value, bag, key)
       end
     end
 
@@ -74,22 +85,26 @@ module Nugrant
     def test_undefined_value()
       bag = create_bag({:value => "one"})
 
-      assert_raise(KeyError) do
+      assert_raises(KeyError) do
         bag.invalid_value
       end
 
-      assert_raise(KeyError) do
+      assert_raises(KeyError) do
         bag["invalid_value"]
       end
+
+      assert_raises(KeyError) do
+        bag[:invalid_value]
+      end
     end
 
     def test_to_hash()
-      hash = create_bag({}).__to_hash()
+      hash = create_bag({}).to_hash()
 
       assert_kind_of(Hash, hash)
       assert_equal({}, hash)
 
-      hash = create_bag({:value => {:one => "value", :two => "value"}}).__to_hash()
+      hash = create_bag({"value" => {:one => "value", "two" => "value"}}).to_hash()
 
       assert_kind_of(Hash, hash)
       assert_kind_of(Hash, hash[:value])
@@ -98,20 +113,115 @@ module Nugrant
       assert_equal({:value => {:one => "value", :two => "value"}}, hash)
     end
 
-    def test_merge_array()
-      bag1 = create_bag({:first => [1, 2]})
+    def test_merge_array_replace()
+      # Replace should be the default case
+      bag1 = create_bag({"first" => [1, 2]})
+      bag2 = create_bag({:first => [2, 3]})
+
+      bag1.merge!(bag2);
+
+      assert_equal({:first => [2, 3]}, bag1.to_hash())
+
+      bag1 = create_bag({"first" => [1, 2]})
+      bag2 = create_bag({:first => "string"})
+
+      bag1.merge!(bag2);
+
+      assert_equal({:first => "string"}, bag1.to_hash())
+    end
+
+    def test_merge_array_extend()
+      bag1 = create_bag({"first" => [1, 2]})
       bag2 = create_bag({:first => [2, 3]})
 
-      bag1.__merge!(bag2);
+      bag1.merge!(bag2, :array_strategy => :extend);
 
-      assert_equal({:first => [1, 2, 3]}, bag1.__to_hash())
+      assert_equal({:first => [1, 2, 3]}, bag1.to_hash())
 
-      bag1 = create_bag({:first => [1, 2]})
+      bag1 = create_bag({"first" => [1, 2]})
       bag2 = create_bag({:first => "string"})
 
-      bag1.__merge!(bag2);
+      bag1.merge!(bag2, :array_strategy => :extend);
+
+      assert_equal({:first => "string"}, bag1.to_hash())
+    end
+
+    def test_merge_array_concat()
+      bag1 = create_bag({"first" => [1, 2]})
+      bag2 = create_bag({:first => [2, 3]})
+
+      bag1.merge!(bag2, :array_strategy => :concat);
+
+      assert_equal({:first => [1, 2, 2, 3]}, bag1.to_hash())
+
+      bag1 = create_bag({"first" => [1, 2]})
+      bag2 = create_bag({:first => "string"})
+
+      bag1.merge!(bag2, :array_strategy => :concat);
+
+      assert_equal({:first => "string"}, bag1.to_hash())
+    end
+
+    def test_nil_key()
+      assert_raises(ArgumentError) do
+        create_bag({nil => "value"})
+      end
+
+      parameters = create_bag({})
+
+      assert_raises(ArgumentError) do
+        parameters[nil] = 1
+      end
+
+      assert_raises(ArgumentError) do
+        parameters[nil]
+      end
+
+      assert_raises(ArgumentError) do
+        parameters.method_missing(nil)
+      end
+    end
+
+    def test_restricted_keys_are_still_accessible
+      keys = Helper::Bag.restricted_keys()
+      bag = create_bag(Hash[
+        keys.map do |key|
+          [key, "#{key.to_s} - value"]
+        end
+      ])
+
+      keys.each do |key|
+        assert_equal("#{key.to_s} - value", bag[key.to_s], "bag[#{key.to_s}]")
+        assert_equal("#{key.to_s} - value", bag[key.to_sym], "bag[#{key.to_sym}]")
+      end
+    end
+
+    def test_custom_key_error_handler
+      bag = create_bag({:value => "one"}, :key_error => Proc.new do |key|
+        raise IndexError
+      end)
+
+      assert_raises(IndexError) do
+        bag.invalid_value
+      end
+
+      assert_raises(IndexError) do
+        bag["invalid_value"]
+      end
+
+      assert_raises(IndexError) do
+        bag[:invalid_value]
+      end
+    end
+
+    def test_custom_key_error_handler_returns_value
+      bag = create_bag({:value => "one"}, :key_error => Proc.new do |key|
+        "Some value"
+      end)
 
-      assert_equal({:first => "string"}, bag1.__to_hash())
+      assert_equal("Some value", bag.invalid_value)
+      assert_equal("Some value", bag["invalid_value"])
+      assert_equal("Some value", bag[:invalid_value])
     end
   end
 end

data/test/lib/nugrant/test_config.rb

@@ -1,120 +1,123 @@
-require 'nugrant/config'
-require 'test/unit'
+require 'minitest/autorun'
 require 'tmpdir'
 
-class Nugrant::TestConfig < Test::Unit::TestCase
-  def setup
-    @default_param_filename = Nugrant::Config::DEFAULT_PARAMS_FILENAME
+require 'nugrant/config'
 
-    @old_working_dir = Dir.getwd()
-    @user_dir = Nugrant::Config.default_user_path()
-    @system_dir = Nugrant::Config.default_system_path()
+module Nugrant
+  class TestConfig < ::Minitest::Test
+    def setup
+      @default_param_filename = Nugrant::Config::DEFAULT_PARAMS_FILENAME
 
-    Dir.chdir(Dir.tmpdir())
+      @old_working_dir = Dir.getwd()
+      @user_dir = Nugrant::Config.default_user_path()
+      @system_dir = Nugrant::Config.default_system_path()
 
-    @current_dir = Dir.getwd()
-  end
+      Dir.chdir(Dir.tmpdir())
 
-  def teardown
-    Dir.chdir(@old_working_dir)
+      @current_dir = Dir.getwd()
+    end
 
-    @old_working_dir = nil
-    @current_dir = nil
-    @user_dir = nil
-    @system_dir = nil
-  end
+    def teardown
+      Dir.chdir(@old_working_dir)
 
-  def test_default_values
-    config = Nugrant::Config.new()
+      @old_working_dir = nil
+      @current_dir = nil
+      @user_dir = nil
+      @system_dir = nil
+    end
 
-    assert_equal(@default_param_filename, config.params_filename())
-    assert_equal("#{@current_dir}/#{@default_param_filename}", config.current_path())
-    assert_equal("#{@user_dir}/#{@default_param_filename}", config.user_path())
-    assert_equal("#{@system_dir}/#{@default_param_filename}", config.system_path())
-  end
+    def test_default_values
+      config = Nugrant::Config.new()
 
-  def test_custom_params_filename
-    config = Nugrant::Config.new({:params_filename => ".customparams"})
+      assert_equal(@default_param_filename, config.params_filename())
+      assert_equal("#{@current_dir}/#{@default_param_filename}", config.current_path())
+      assert_equal("#{@user_dir}/#{@default_param_filename}", config.user_path())
+      assert_equal("#{@system_dir}/#{@default_param_filename}", config.system_path())
+    end
 
-    assert_equal(".customparams", config.params_filename())
-    assert_equal("#{@current_dir}/.customparams", config.current_path())
-    assert_equal("#{@user_dir}/.customparams", config.user_path())
-    assert_equal("#{@system_dir}/.customparams", config.system_path())
-  end
+    def test_custom_params_filename
+      config = Nugrant::Config.new({:params_filename => ".customparams"})
 
-  def test_custom_current_path
-    config = Nugrant::Config.new({
-      :params_filename => ".customparams",
-      :current_path => "#{@user_dir}/.currentcustomparams"
-    })
+      assert_equal(".customparams", config.params_filename())
+      assert_equal("#{@current_dir}/.customparams", config.current_path())
+      assert_equal("#{@user_dir}/.customparams", config.user_path())
+      assert_equal("#{@system_dir}/.customparams", config.system_path())
+    end
 
-    assert_equal(".customparams", config.params_filename())
-    assert_equal("#{@user_dir}/.currentcustomparams", config.current_path())
-  end
+    def test_custom_current_path
+      config = Nugrant::Config.new({
+        :params_filename => ".customparams",
+        :current_path => "#{@user_dir}/.currentcustomparams"
+      })
 
-  def test_custom_user_path
-    config = Nugrant::Config.new({
-      :params_filename => ".customparams",
-      :user_path => "#{@system_dir}/.usercustomparams"
-    })
+      assert_equal(".customparams", config.params_filename())
+      assert_equal("#{@user_dir}/.currentcustomparams", config.current_path())
+    end
 
-    assert_equal(".customparams", config.params_filename())
-    assert_equal("#{@system_dir}/.usercustomparams", config.user_path())  end
+    def test_custom_user_path
+      config = Nugrant::Config.new({
+        :params_filename => ".customparams",
+        :user_path => "#{@system_dir}/.usercustomparams"
+      })
 
-  def test_custom_system_path
-    config = Nugrant::Config.new({
-      :params_filename => ".customparams",
-      :system_path => "#{@current_dir}/.systemcustomparams"
-    })
+      assert_equal(".customparams", config.params_filename())
+      assert_equal("#{@system_dir}/.usercustomparams", config.user_path())  end
 
-    assert_equal(".customparams", config.params_filename())
-    assert_equal("#{@current_dir}/.systemcustomparams", config.system_path())
-  end
+    def test_custom_system_path
+      config = Nugrant::Config.new({
+        :params_filename => ".customparams",
+        :system_path => "#{@current_dir}/.systemcustomparams"
+      })
 
-  def test_custom_all
-    config = Nugrant::Config.new({
-      :params_filename => ".customparams",
-      :current_path => "#{@user_dir}/.currentcustomparams",
-      :user_path => "#{@system_dir}/.usercustomparams",
-      :system_path => "#{@current_dir}/.systemcustomparams"
-    })
-
-    assert_equal(".customparams", config.params_filename())
-    assert_equal("#{@user_dir}/.currentcustomparams", config.current_path())
-    assert_equal("#{@system_dir}/.usercustomparams", config.user_path())
-    assert_equal("#{@current_dir}/.systemcustomparams", config.system_path())
-  end
+      assert_equal(".customparams", config.params_filename())
+      assert_equal("#{@current_dir}/.systemcustomparams", config.system_path())
+    end
 
-  def test_nil_current
-    config = Nugrant::Config.new({
-      :params_filename => ".customparams",
-      :current_path => nil,
-    })
+    def test_custom_all
+      config = Nugrant::Config.new({
+        :params_filename => ".customparams",
+        :current_path => "#{@user_dir}/.currentcustomparams",
+        :user_path => "#{@system_dir}/.usercustomparams",
+        :system_path => "#{@current_dir}/.systemcustomparams"
+      })
+
+      assert_equal(".customparams", config.params_filename())
+      assert_equal("#{@user_dir}/.currentcustomparams", config.current_path())
+      assert_equal("#{@system_dir}/.usercustomparams", config.user_path())
+      assert_equal("#{@current_dir}/.systemcustomparams", config.system_path())
+    end
 
-    assert_not_nil("#{@current_dir}/.customparams", config.current_path())
-  end
+    def test_nil_current
+      config = Nugrant::Config.new({
+        :params_filename => ".customparams",
+        :current_path => nil,
+      })
 
-  def test_nil_user
-    config = Nugrant::Config.new({
-      :params_filename => ".customparams",
-      :user_path => nil,
-    })
+      assert_equal("#{@current_dir}/.customparams", config.current_path())
+    end
 
-    assert_equal("#{@user_dir}/.customparams", config.user_path())
-  end
+    def test_nil_user
+      config = Nugrant::Config.new({
+        :params_filename => ".customparams",
+        :user_path => nil,
+      })
 
-  def test_nil_system
-    config = Nugrant::Config.new({
-      :params_filename => ".customparams",
-      :system_path => nil,
-    })
+      assert_equal("#{@user_dir}/.customparams", config.user_path())
+    end
 
-    assert_equal("#{@system_dir}/.customparams", config.system_path())
-  end
+    def test_nil_system
+      config = Nugrant::Config.new({
+        :params_filename => ".customparams",
+        :system_path => nil,
+      })
+
+      assert_equal("#{@system_dir}/.customparams", config.system_path())
+    end
 
-  def test_invalid_format
-    assert_raise(ArgumentError) do
-      Nugrant::Config.new({:params_format => :invalid})
+    def test_invalid_format
+      assert_raises(ArgumentError) do
+        Nugrant::Config.new({:params_format => :invalid})
+      end
     end
   end
 end