nugrant 2.0.0.dev2 → 2.0.0.pre1

data/test/lib/nugrant/test_parameters.rb

@@ -1,240 +1,295 @@
+require 'minitest/autorun'
+
 require 'nugrant'
+require 'nugrant/helper/parameters'
 require 'nugrant/parameters'
-require 'test/unit'
 
-class Nugrant::TestParameters < Test::Unit::TestCase
-  @@FORMATS = [:json, :yaml]
-  @@INVALID_PATH = "impossible_file_path.yamljson.impossible"
+module Nugrant
+  class TestParameters < ::Minitest::Test
 
-  def create_parameters(format, current_filename, user_filename, system_filename)
-    extension = case
-      when format = :json
-        "json"
-      when format = :yaml
-        "yml"
-      else
-        raise ArgumentError, "Format [#{format}] is currently not supported"
-    end
+    @@FORMATS = [:json, :yaml]
+    @@INVALID_PATH = "impossible_file_path.yamljson.impossible"
 
-    resource_path = File.expand_path("#{File.dirname(__FILE__)}/../../resources/#{format}")
+    def create_parameters(format, current_filename, user_filename, system_filename)
+      extension = case
+        when format = :json
+          "json"
+        when format = :yaml
+          "yml"
+        else
+          raise ArgumentError, "Format [#{format}] is currently not supported"
+      end
 
-    current_path = "#{resource_path}/#{current_filename}.#{extension}" if current_filename
-    user_path = "#{resource_path}/#{user_filename}.#{extension}" if user_filename
-    system_path = "#{resource_path}/#{system_filename}.#{extension}" if system_filename
+      resource_path = File.expand_path("#{File.dirname(__FILE__)}/../../resources/#{format}")
 
-    return Nugrant::Parameters.new({
-      :config => {
+      current_path = "#{resource_path}/#{current_filename}.#{extension}" if current_filename
+      user_path = "#{resource_path}/#{user_filename}.#{extension}" if user_filename
+      system_path = "#{resource_path}/#{system_filename}.#{extension}" if system_filename
+
+      return Nugrant::Parameters.new({
         :format => format,
         :current_path => current_path,
         :user_path => user_path,
         :system_path => system_path,
-      },
-    })
-  end
+      })
+    end
 
-  def assert_level(parameters, results)
-    results.each do |key, value|
-      assert_equal(value, parameters.send(key), "array[#{key}]")
-      assert_equal(value, parameters[key], "array[#{key}]")
+    def assert_all_access_equal(expected, parameters, key)
+      assert_equal(expected, parameters.method_missing(key.to_sym), "parameters.#{key.to_s}")
+      assert_equal(expected, parameters[key.to_s], "parameters[#{key.to_s}]")
+      assert_equal(expected, parameters[key.to_sym], "parameters[#{key.to_sym}]")
     end
 
-    assert_key_error(parameters, "0.0.0")
-  end
+    def assert_level(parameters, results)
+      results.each do |key, value|
+        assert_all_access_equal(value, parameters, key)
+      end
 
-  def assert_key_error(parameters, key)
-    assert_raise(KeyError) do
-      parameters[key]
+      assert_key_error(parameters, "0.0.0")
     end
-  end
 
-  def test_params_level_1()
-    formats.each do |format|
-      parameters = create_parameters(format, "params_current_1", "params_user_1", "params_system_1")
-
-      assert_level(parameters, {
-        :'1.1.1' => "current",
-        :'1.1.0' => "current",
-        :'1.0.1' => "current",
-        :'0.1.1' => "user",
-        :'1.0.0' => "current",
-        :'0.1.0' => "user",
-        :'0.0.1' => "system",
-      })
+    def assert_key_error(parameters, key)
+      assert_raises(KeyError) do
+        parameters[key]
+      end
     end
-  end
 
-  def test_params_level_2()
-    formats.each do |format|
-      parameters = create_parameters(format, "params_current_2", "params_user_2", "params_system_2")
-
-      run_second_level(parameters, :'1.1.1', {
-        :'1.1.1' => "current",
-        :'1.1.0' => "current",
-        :'1.0.1' => "current",
-        :'0.1.1' => "user",
-        :'1.0.0' => "current",
-        :'0.1.0' => "user",
-        :'0.0.1' => "system",
-      })
+    def test_params_level_1()
+      formats.each do |format|
+        parameters = create_parameters(format, "params_current_1", "params_user_1", "params_system_1")
+
+        assert_level(parameters, {
+          :'1.1.1' => "current",
+          :'1.1.0' => "current",
+          :'1.0.1' => "current",
+          :'0.1.1' => "user",
+          :'1.0.0' => "current",
+          :'0.1.0' => "user",
+          :'0.0.1' => "system",
+        })
+      end
+    end
 
-      run_second_level(parameters, :'1.1.0', {
-        :'1.1.1' => "current",
-        :'1.1.0' => "current",
-        :'1.0.1' => "current",
-        :'0.1.1' => "user",
-        :'1.0.0' => "current",
-        :'0.1.0' => "user",
-      })
+    def test_params_level_2()
+      formats.each do |format|
+        parameters = create_parameters(format, "params_current_2", "params_user_2", "params_system_2")
+
+        run_second_level(parameters, :'1.1.1', {
+          :'1.1.1' => "current",
+          :'1.1.0' => "current",
+          :'1.0.1' => "current",
+          :'0.1.1' => "user",
+          :'1.0.0' => "current",
+          :'0.1.0' => "user",
+          :'0.0.1' => "system",
+        })
+
+        run_second_level(parameters, :'1.1.0', {
+          :'1.1.1' => "current",
+          :'1.1.0' => "current",
+          :'1.0.1' => "current",
+          :'0.1.1' => "user",
+          :'1.0.0' => "current",
+          :'0.1.0' => "user",
+        })
+
+        run_second_level(parameters, :'1.0.1', {
+          :'1.1.1' => "current",
+          :'1.1.0' => "current",
+          :'1.0.1' => "current",
+          :'0.1.1' => "system",
+          :'1.0.0' => "current",
+          :'0.0.1' => "system",
+        })
+
+        run_second_level(parameters, :'0.1.1', {
+          :'1.1.1' => "user",
+          :'1.1.0' => "user",
+          :'1.0.1' => "system",
+          :'0.1.1' => "user",
+          :'0.1.0' => "user",
+          :'0.0.1' => "system",
+        })
+
+        run_second_level(parameters, :'1.0.0', {
+          :'1.1.1' => "current",
+          :'1.1.0' => "current",
+          :'1.0.1' => "current",
+          :'1.0.0' => "current",
+        })
+
+        run_second_level(parameters, :'0.1.0', {
+          :'1.1.1' => "user",
+          :'1.1.0' => "user",
+          :'0.1.1' => "user",
+          :'0.1.0' => "user",
+        })
+
+        run_second_level(parameters, :'0.0.1', {
+          :'1.1.1' => "system",
+          :'1.0.1' => "system",
+          :'0.1.1' => "system",
+          :'0.0.1' => "system",
+        })
+
+        assert_key_error(parameters, :'0.0.0')
+      end
+    end
 
-      run_second_level(parameters, :'1.0.1', {
-        :'1.1.1' => "current",
-        :'1.1.0' => "current",
-        :'1.0.1' => "current",
-        :'0.1.1' => "system",
-        :'1.0.0' => "current",
-        :'0.0.1' => "system",
-      })
+    def run_second_level(parameters, key, results)
+      assert_level(parameters.send(key), results)
+      assert_level(parameters[key], results)
 
-      run_second_level(parameters, :'0.1.1', {
-        :'1.1.1' => "user",
-        :'1.1.0' => "user",
-        :'1.0.1' => "system",
-        :'0.1.1' => "user",
-        :'0.1.0' => "user",
-        :'0.0.1' => "system",
-      })
+      assert_key_error(parameters, :'0.0.0')
+    end
 
-      run_second_level(parameters, :'1.0.0', {
-        :'1.1.1' => "current",
-        :'1.1.0' => "current",
-        :'1.0.1' => "current",
-        :'1.0.0' => "current",
-      })
+    def test_params_array()
+      file_path = "params_array"
+      formats.each do |format|
+        parameters = create_parameters(format, file_path, invalid_path, invalid_path)
 
-      run_second_level(parameters, :'0.1.0', {
-        :'1.1.1' => "user",
-        :'1.1.0' => "user",
-        :'0.1.1' => "user",
-        :'0.1.0' => "user",
-      })
+        assert_equal(["1", "2", "3"], parameters[:level1][:level2])
+      end
+    end
 
-      run_second_level(parameters, :'0.0.1', {
-        :'1.1.1' => "system",
-        :'1.0.1' => "system",
-        :'0.1.1' => "system",
-        :'0.0.1' => "system",
-      })
+    def test_file_nil()
+      run_test_file_invalid(nil)
+    end
 
-      assert_key_error(parameters, :'0.0.0')
+    def test_file_does_not_exist()
+      run_test_file_invalid("impossible_file_path.yml.impossible")
     end
-  end
 
-  def run_second_level(parameters, key, results)
-    assert_level(parameters.send(key), results)
-    assert_level(parameters[key], results)
+    def run_test_file_invalid(invalid_value)
+      formats.each do |format|
+        parameters = create_parameters(format, "params_simple", invalid_path, invalid_path)
+        assert_all_access_equal("value", parameters, "test")
 
-    assert_key_error(parameters, :'0.0.0')
-  end
+        parameters = create_parameters(format, invalid_path, "params_simple", invalid_path)
+        assert_all_access_equal("value", parameters, "test")
 
-  def test_params_array()
-    file_path = "params_array"
-    formats.each do |format|
-      parameters = create_parameters(format, file_path, invalid_path, invalid_path)
+        parameters = create_parameters(format, invalid_path, invalid_path, "params_simple")
+        assert_all_access_equal("value", parameters, "test")
 
-      assert_equal(["1", "2", "3"], parameters[:level1][:level2])
+        parameters = create_parameters(format, invalid_path, invalid_path, invalid_path)
+        assert(parameters)
+      end
     end
-  end
 
-  def test_file_nil()
-    run_test_file_invalid(nil)
-  end
+    def test_params_windows_eol()
+      run_test_params_eol("params_windows_eol")
+    end
 
-  def test_file_does_not_exist()
-    run_test_file_invalid("impossible_file_path.yml.impossible")
-  end
+    def test_params_unix_eol()
+      run_test_params_eol("params_unix_eol")
+    end
 
-  def run_test_file_invalid(invalid_value)
-    formats.each do |format|
-      parameters = create_parameters(format, "params_simple", invalid_path, invalid_path)
-      assert_equal("value", parameters[:test])
+    def run_test_params_eol(file_path)
+      formats.each do |format|
+        parameters = create_parameters(format, file_path, invalid_path, invalid_path)
 
-      parameters = create_parameters(format, invalid_path, "params_simple", invalid_path)
-      assert_equal("value", parameters[:test])
+        assert_all_access_equal("value1", parameters, 'level1')
+        assert_all_access_equal("value2", parameters['level2'], 'first')
+      end
+    end
 
-      parameters = create_parameters(format, invalid_path, invalid_path, "params_simple")
-      assert_equal("value", parameters[:test])
+    def test_restricted_defaults_usage()
+      formats.each do |format|
+        parameters = create_parameters(format, "params_defaults_at_root", invalid_path, invalid_path)
 
-      parameters = create_parameters(format, invalid_path, invalid_path, invalid_path)
-      assert_not_nil(parameters)
-    end
-  end
+        assert_all_access_equal("value", parameters, :defaults)
+      end
 
-  def test_params_windows_eol()
-    run_test_params_eol("params_windows_eol")
-  end
+      formats.each do |format|
+        parameters = create_parameters(format, "params_defaults_not_at_root", invalid_path, invalid_path)
 
-  def test_params_unix_eol()
-    run_test_params_eol("params_unix_eol")
-  end
+        assert_all_access_equal("value", parameters.level, :defaults)
+      end
+    end
 
-  def run_test_params_eol(file_path)
-    formats.each do |format|
-      parameters = create_parameters(format, file_path, invalid_path, invalid_path)
+    def test_defaults()
+      formats.each do |format|
+        parameters = create_parameters(format, "params_simple", invalid_path, invalid_path)
+        parameters.defaults = {:test => "override1", :level => "new1"}
 
-      assert_equal("value1", parameters[:level1])
-      assert_equal("value2", parameters[:level2][:first])
+        assert_all_access_equal("value", parameters, 'test')
+        assert_all_access_equal("new1", parameters, 'level')
+      end
     end
-  end
 
-  def test_restricted_defaults_usage()
-    formats.each do |format|
-      parameters = create_parameters(format, "params_defaults_at_root", invalid_path, invalid_path)
+    def test_empty_file()
+      formats.each do |format|
+        parameters = create_parameters(format, "params_empty", invalid_path, invalid_path)
+        parameters.defaults = {:test => "value"}
 
-      assert_equal("value", parameters.defaults)
+        assert_all_access_equal("value", parameters, 'test')
+      end
     end
 
-    formats.each do |format|
-      parameters = create_parameters(format, "params_defaults_not_at_root", invalid_path, invalid_path)
+    def test_file_not_hash()
+      ["boolean", "list"].each do |wrong_type|
+        formats.each do |format|
+          parameters = create_parameters(format, "params_#{wrong_type}", invalid_path, invalid_path)
+          parameters.defaults = {:test => "value"}
 
-      assert_equal("value", parameters.level.defaults)
+          assert_all_access_equal("value", parameters, 'test')
+        end
+      end
     end
-  end
 
-  def test_defaults()
-    formats.each do |format|
-      parameters = create_parameters(format, "params_simple", invalid_path, invalid_path)
-      parameters.defaults = {:test => "override1", :level => "new1"}
+    def test_nil_values()
+      formats.each do |format|
+        parameters = create_parameters(format, "params_user_nil_values", invalid_path, invalid_path)
+        parameters.defaults = {:nil => "Not nil", :deep => {:nil => "Not nil", :deeper => {:nil => "Not nil"}}}
+
+        assert_all_access_equal("Not nil", parameters[:deep][:deeper], :nil)
+        assert_all_access_equal("Not nil", parameters[:deep], :nil)
+        assert_all_access_equal("Not nil", parameters, :nil)
+      end
+
+      formats.each do |format|
+        parameters = create_parameters(format, "params_user_nil_values", invalid_path, invalid_path)
 
-      assert_equal("value", parameters[:test])
-      assert_equal("new1", parameters[:level])
+        assert_all_access_equal(nil, parameters[:deep][:deeper], :nil)
+        assert_all_access_equal(nil, parameters[:deep], :nil)
+        assert_all_access_equal(nil, parameters, :nil)
+      end
     end
-  end
 
-  def test_empty_file()
-    formats.each do |format|
-      parameters = create_parameters(format, "params_empty", invalid_path, invalid_path)
-      parameters.defaults = {:test => "value"}
+    def test_restricted_keys_are_still_accessible
+      keys = Helper::Parameters.restricted_keys()
+      elements = Hash[
+        keys.map do |key|
+          [key, "#{key.to_s} - value"]
+        end
+      ]
+
+      parameters = create_parameters(:json, invalid_path, invalid_path, invalid_path)
+      parameters.defaults = elements
 
-      assert_equal("value", parameters[:test])
+      keys.each do |key|
+        assert_equal("#{key.to_s} - value", parameters[key.to_s], "parameters[#{key.to_s}]")
+        assert_equal("#{key.to_s} - value", parameters[key.to_sym], "parameters[#{key.to_sym}]")
+      end
     end
-  end
 
-  def test_file_not_hash()
-    ["boolean", "list"].each do |wrong_type|
-      formats.each do |format|
-        parameters = create_parameters(format, "params_#{wrong_type}", invalid_path, invalid_path)
-        parameters.defaults = {:test => "value"}
+    def test_hash_method_collect()
+      parameters = create_parameters(:json, "params_simple", invalid_path, invalid_path)
+      parameters.defaults = {"test" => "override1", :level => "new1"}
 
-        assert_equal("value", parameters[:test])
+      pairs = parameters.collect do |key, value|
+        [key, value]
       end
+
+      assert_equal([[:test, "value"], [:level, "new1"]], pairs)
     end
-  end
 
-  def formats()
-    @@FORMATS
-  end
+    def formats()
+      @@FORMATS
+    end
 
-  def invalid_path()
-    @@INVALID_PATH
+    def invalid_path()
+      @@INVALID_PATH
+    end
   end
 end