nugrant 1.4.2 → 2.0.0.dev1

data/lib/nugrant/version.rb

@@ -1,3 +1,3 @@
 module Nugrant
-  VERSION = "1.4.2"
+  VERSION = "2.0.0.dev1"
 end

data/nugrant.gemspec

@@ -25,11 +25,8 @@ Gem::Specification.new do |gem|
 
   gem.files         = `git ls-files`.split($/)
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
-  gem.test_files    = gem.files.grep(%r{^(test/lib)/})
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
 
-  gem.add_dependency "multi_json", "~> 1.8"
-
   gem.add_development_dependency "rake"
-  gem.add_development_dependency "minitest", "~> 5.0.8"
 end

data/test/lib/nugrant/test_bag.rb

@@ -1,23 +1,11 @@
-require 'minitest/autorun'
+require 'test/unit'
 
 require 'nugrant/bag'
 
 module Nugrant
-  class TestBag < ::Minitest::Test
-    def create_bag(elements)
-      return Bag.new(elements)
-    end
-
-    def assert_all_access_equal(value, bag, key)
-      assert_equal(value, bag.method_missing(key.to_sym), "bag.#{key.to_sym.inspect}")
-      assert_equal(value, bag[key.to_s], "bag[#{key.to_s.inspect}]")
-      assert_equal(value, bag[key.to_sym], "bag[#{key.to_sym.inspect}]")
-    end
-
-    def assert_all_access_bag(value, bag, key)
-      assert_bag(value, bag.method_missing(key.to_sym))
-      assert_bag(value, bag[key.to_s])
-      assert_bag(value, bag[key.to_sym])
+  class TestBag < Test::Unit::TestCase
+    def create_bag(parameters)
+      return Bag.new(parameters)
     end
 
     def assert_bag(parameters, bag)
@@ -25,11 +13,13 @@ module Nugrant
 
       parameters.each do |key, value|
         if not value.kind_of?(Hash)
-          assert_all_access_equal(value, bag, key)
+          assert_equal(value, bag.send(key))
+          assert_equal(value, bag[key])
           next
         end
 
-        assert_all_access_bag(value, bag, key)
+        assert_bag(value, bag.send(key))
+        assert_bag(value, bag[key])
       end
     end
 
@@ -84,17 +74,13 @@ module Nugrant
     def test_undefined_value()
       bag = create_bag({"value" => "one"})
 
-      assert_raises(KeyError) do
+      assert_raise(KeyError) do
         bag.invalid_value
       end
 
-      assert_raises(KeyError) do
+      assert_raise(KeyError) do
         bag["invalid_value"]
       end
-
-      assert_raises(KeyError) do
-        bag[:invalid_value]
-      end
     end
 
     def test_to_hash()
@@ -103,29 +89,29 @@ module Nugrant
       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])
-      assert_kind_of(String, hash[:value][:one])
-      assert_kind_of(String, hash[:value][:two])
-      assert_equal({:value => {:one => "value", :two => "value"}}, hash)
+      assert_kind_of(Hash, hash['value'])
+      assert_kind_of(String, hash['value']['one'])
+      assert_kind_of(String, hash['value']['two'])
+      assert_equal({"value" => {"one" => "value", "two" => "value"}}, hash)
     end
 
     def test_merge_array()
       bag1 = create_bag({"first" => [1, 2]})
-      bag2 = create_bag({:first => [2, 3]})
+      bag2 = create_bag({"first" => [2, 3]})
 
       bag1.__merge!(bag2);
 
-      assert_equal({:first => [1, 2, 3]}, bag1.__to_hash())
+      assert_equal({"first" => [1, 2, 3]}, bag1.__to_hash())
 
       bag1 = create_bag({"first" => [1, 2]})
-      bag2 = create_bag({:first => "string"})
+      bag2 = create_bag({"first" => "string"})
 
       bag1.__merge!(bag2);
 
-      assert_equal({:first => "string"}, bag1.__to_hash())
+      assert_equal({"first" => "string"}, bag1.__to_hash())
     end
   end
 end

data/test/lib/nugrant/test_config.rb

@@ -1,128 +1,120 @@
-require 'minitest/autorun'
-require 'tmpdir'
-
 require 'nugrant/config'
+require 'test/unit'
+require 'tmpdir'
 
-module Nugrant
-  class TestConfig < ::Minitest::Test
-    def setup
-      @default_param_filename = Nugrant::Config::DEFAULT_PARAMS_FILENAME
+class Nugrant::TestConfig < Test::Unit::TestCase
+  def setup
+    @default_param_filename = Nugrant::Config::DEFAULT_PARAMS_FILENAME
 
-      @old_working_dir = Dir.getwd()
-      @user_dir = Nugrant::Config.user_base_path()
-      @system_dir = Nugrant::Config.system_base_path()
+    @old_working_dir = Dir.getwd()
+    @user_dir = Nugrant::Config.default_user_path()
+    @system_dir = Nugrant::Config.default_system_path()
 
-      Dir.chdir(Dir.tmpdir())
+    Dir.chdir(Dir.tmpdir())
 
-      @project_dir = Dir.getwd()
-    end
-
-    def teardown
-      Dir.chdir(@old_working_dir)
+    @current_dir = Dir.getwd()
+  end
 
-      @old_working_dir = nil
-      @project_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("#{@project_dir}/#{@default_param_filename}", config.project_params_path())
-      assert_equal("#{@user_dir}/#{@default_param_filename}", config.user_params_path())
-      assert_equal("#{@system_dir}/#{@default_param_filename}", config.system_params_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("#{@project_dir}/.customparams", config.project_params_path())
-      assert_equal("#{@user_dir}/.customparams", config.user_params_path())
-      assert_equal("#{@system_dir}/.customparams", config.system_params_path())
-    end
+  def test_custom_params_filename
+    config = Nugrant::Config.new({:params_filename => ".customparams"})
 
-    def test_custom_params_filename_after_creation
-      config = Nugrant::Config.new({:params_filename => ".vagrantuser"})
+    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
 
-      config.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("#{@project_dir}/.customparams", config.project_params_path())
-      assert_equal("#{@user_dir}/.customparams", config.user_params_path())
-      assert_equal("#{@system_dir}/.customparams", config.system_params_path())
-    end
-
-    def test_custom_project_params_path
-      config = Nugrant::Config.new({
-        :params_filename => ".customparams",
-        :project_params_path => "#{@user_dir}/.projectcustomparams"
-      })
+    assert_equal(".customparams", config.params_filename())
+    assert_equal("#{@user_dir}/.currentcustomparams", config.current_path())
+  end
 
-      assert_equal(".customparams", config.params_filename())
-      assert_equal("#{@user_dir}/.projectcustomparams", config.project_params_path())
-    end
+  def test_custom_user_path
+    config = Nugrant::Config.new({
+      :params_filename => ".customparams",
+      :user_path => "#{@system_dir}/.usercustomparams"
+    })
 
-    def test_custom_user_params_path
-      config = Nugrant::Config.new({
-        :params_filename => ".customparams",
-        :user_params_path => "#{@system_dir}/.usercustomparams"
-      })
+    assert_equal(".customparams", config.params_filename())
+    assert_equal("#{@system_dir}/.usercustomparams", config.user_path())  end
 
-      assert_equal(".customparams", config.params_filename())
-      assert_equal("#{@system_dir}/.usercustomparams", config.user_params_path())  end
+  def test_custom_system_path
+    config = Nugrant::Config.new({
+      :params_filename => ".customparams",
+      :system_path => "#{@current_dir}/.systemcustomparams"
+    })
 
-    def test_custom_system_params_path
-      config = Nugrant::Config.new({
-        :params_filename => ".customparams",
-        :system_params_path => "#{@project_dir}/.systemcustomparams"
-      })
+    assert_equal(".customparams", config.params_filename())
+    assert_equal("#{@current_dir}/.systemcustomparams", config.system_path())
+  end
 
-      assert_equal(".customparams", config.params_filename())
-      assert_equal("#{@project_dir}/.systemcustomparams", config.system_params_path())
-    end
+  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
 
-    def test_custom_all
-      config = Nugrant::Config.new({
-        :params_filename => ".customparams",
-        :project_params_path => "#{@user_dir}/.projectcustomparams",
-        :user_params_path => "#{@system_dir}/.usercustomparams",
-        :system_params_path => "#{@project_dir}/.systemcustomparams"
-      })
-
-      assert_equal(".customparams", config.params_filename())
-      assert_equal("#{@user_dir}/.projectcustomparams", config.project_params_path())
-      assert_equal("#{@system_dir}/.usercustomparams", config.user_params_path())
-      assert_equal("#{@project_dir}/.systemcustomparams", config.system_params_path())
-    end
+  def test_nil_current
+    config = Nugrant::Config.new({
+      :params_filename => ".customparams",
+      :current_path => nil,
+    })
 
-    def test_nil_project
-      config = Nugrant::Config.new({
-        :params_filename => ".customparams",
-        :project_params_path => nil,
-      })
+    assert_not_nil("#{@current_dir}/.customparams", config.current_path())
+  end
 
-      assert_equal("#{@project_dir}/.customparams", config.project_params_path())
-    end
+  def test_nil_user
+    config = Nugrant::Config.new({
+      :params_filename => ".customparams",
+      :user_path => nil,
+    })
 
-    def test_nil_user
-      config = Nugrant::Config.new({
-        :params_filename => ".customparams",
-        :user_params_path => nil,
-      })
+    assert_equal("#{@user_dir}/.customparams", config.user_path())
+  end
 
-      assert_equal("#{@user_dir}/.customparams", config.user_params_path())
-    end
+  def test_nil_system
+    config = Nugrant::Config.new({
+      :params_filename => ".customparams",
+      :system_path => nil,
+    })
 
-    def test_nil_system
-      config = Nugrant::Config.new({
-        :params_filename => ".customparams",
-        :system_params_path => nil,
-      })
+    assert_equal("#{@system_dir}/.customparams", config.system_path())
+  end
 
-      assert_equal("#{@system_dir}/.customparams", config.system_params_path())
+  def test_invalid_format
+    assert_raise(ArgumentError) do
+      Nugrant::Config.new({:params_format => :invalid})
     end
   end
 end

data/test/lib/nugrant/test_parameters.rb

@@ -1,257 +1,240 @@
-require 'minitest/autorun'
-
 require 'nugrant'
 require 'nugrant/parameters'
+require 'test/unit'
+
+class Nugrant::TestParameters < Test::Unit::TestCase
+  @@FORMATS = [:json, :yaml]
+  @@INVALID_PATH = "impossible_file_path.yamljson.impossible"
+
+  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
+
+    resource_path = File.expand_path("#{File.dirname(__FILE__)}/../../resources/#{format}")
+
+    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({
+      :config => {
+        :format => format,
+        :current_path => current_path,
+        :user_path => user_path,
+        :system_path => system_path,
+      },
+    })
+  end
 
-module Nugrant
-  class TestParameters < ::Minitest::Test
-
-    @@PARAMS_FILETYPES = [:json, :yml]
-    @@INVALID_PATH = "impossible_file_path.yml.impossible"
+  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}]")
+    end
 
-    def create_parameters(params_filetype, project_params_filename, user_params_filename, system_params_filename)
-      resource_path = File.expand_path("#{File.dirname(__FILE__)}/../../resources/#{params_filetype.to_s()}")
+    assert_key_error(parameters, "0.0.0")
+  end
 
-      project_params_path = "#{resource_path}/#{project_params_filename}.#{params_filetype}" if project_params_filename
-      user_params_path = "#{resource_path}/#{user_params_filename}.#{params_filetype}" if user_params_filename
-      system_params_path = "#{resource_path}/#{system_params_filename}.#{params_filetype}" if system_params_filename
+  def assert_key_error(parameters, key)
+    assert_raise(KeyError) do
+      parameters[key]
+    end
+  end
 
-      return Nugrant::create_parameters({
-        :params_filetype => params_filetype,
-        :project_params_path => project_params_path,
-        :user_params_path => user_params_path,
-        :system_params_path => system_params_path
+  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
 
-    def assert_all_access_equal(value, parameters, key)
-      assert_equal(value, parameters.method_missing(key.to_sym), "parameters.#{key.to_sym.inspect}")
-      assert_equal(value, parameters[key.to_s], "parameters[#{key.to_s.inspect}]")
-      assert_equal(value, parameters[key.to_sym], "parameters[#{key.to_sym.inspect}]")
-    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 assert_level(parameters, results)
-      results.each do |key, value|
-        assert_all_access_equal(value, parameters, key)
-      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",
+      })
 
-      assert_key_error(parameters, "0.0.0")
-    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 assert_key_error(parameters, key)
-      assert_raises(KeyError) do
-        parameters[key]
-      end
-    end
+      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",
+      })
 
-    def test_params_level_1()
-      filetypes.each do |params_filetype|
-        parameters = create_parameters(params_filetype, "params_project_1", "params_user_1", "params_system_1")
-
-        assert_level(parameters, {
-          "1.1.1" => "project",
-          "1.1.0" => "project",
-          "1.0.1" => "project",
-          "0.1.1" => "user",
-          "1.0.0" => "project",
-          "0.1.0" => "user",
-          "0.0.1" => "system",
-        })
-      end
-    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_level_2()
-      filetypes.each do |params_filetype|
-        parameters = create_parameters(params_filetype, "params_project_2", "params_user_2", "params_system_2")
-
-        run_second_level(parameters, "1.1.1", {
-          "1.1.1" => "project",
-          "1.1.0" => "project",
-          "1.0.1" => "project",
-          "0.1.1" => "user",
-          "1.0.0" => "project",
-          "0.1.0" => "user",
-          "0.0.1" => "system",
-        })
-
-        run_second_level(parameters, "1.1.0", {
-          "1.1.1" => "project",
-          "1.1.0" => "project",
-          "1.0.1" => "project",
-          "0.1.1" => "user",
-          "1.0.0" => "project",
-          "0.1.0" => "user",
-        })
-
-        run_second_level(parameters, "1.0.1", {
-          "1.1.1" => "project",
-          "1.1.0" => "project",
-          "1.0.1" => "project",
-          "0.1.1" => "system",
-          "1.0.0" => "project",
-          "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" => "project",
-          "1.1.0" => "project",
-          "1.0.1" => "project",
-          "1.0.0" => "project",
-        })
-
-        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, "0.1.0", {
+        "1.1.1" => "user",
+        "1.1.0" => "user",
+        "0.1.1" => "user",
+        "0.1.0" => "user",
+      })
 
-    def run_second_level(parameters, key, results)
-      assert_level(parameters.send(key), results)
-      assert_level(parameters[key], results)
+      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
 
-    def test_params_array()
-      file_path = "params_array"
-      filetypes.each do |params_filetype|
-        parameters = create_parameters(params_filetype, file_path, invalid_path, invalid_path)
+  def run_second_level(parameters, key, results)
+    assert_level(parameters.send(key), results)
+    assert_level(parameters[key], results)
 
-        assert_equal(["1", "2", "3"], parameters['level1']['level2'])
-      end
-    end
+    assert_key_error(parameters, "0.0.0")
+  end
 
-    def test_file_nil()
-      run_test_file_invalid(nil)
-    end
+  def test_params_array()
+    file_path = "params_array"
+    formats.each do |format|
+      parameters = create_parameters(format, file_path, invalid_path, invalid_path)
 
-    def test_file_does_not_exist()
-      run_test_file_invalid("impossible_file_path.yml.impossible")
+      assert_equal(["1", "2", "3"], parameters['level1']['level2'])
     end
+  end
 
-    def run_test_file_invalid(invalid_value)
-      filetypes.each do |params_filetype|
-        parameters = create_parameters(params_filetype, "params_simple", invalid_path, invalid_path)
-        assert_all_access_equal("value", parameters, "test")
+  def test_file_nil()
+    run_test_file_invalid(nil)
+  end
 
-        parameters = create_parameters(params_filetype, invalid_path, "params_simple", invalid_path)
-        assert_all_access_equal("value", parameters, "test")
+  def test_file_does_not_exist()
+    run_test_file_invalid("impossible_file_path.yml.impossible")
+  end
 
-        parameters = create_parameters(params_filetype, invalid_path, invalid_path, "params_simple")
-        assert_all_access_equal("value", parameters, "test")
+  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"])
 
-        parameters = create_parameters(params_filetype, invalid_path, invalid_path, invalid_path)
-        assert(parameters)
-      end
-    end
+      parameters = create_parameters(format, invalid_path, "params_simple", invalid_path)
+      assert_equal("value", parameters["test"])
 
-    def test_params_windows_eol()
-      run_test_params_eol("params_windows_eol")
-    end
+      parameters = create_parameters(format, invalid_path, invalid_path, "params_simple")
+      assert_equal("value", parameters["test"])
 
-    def test_params_unix_eol()
-      run_test_params_eol("params_unix_eol")
-    end
-
-    def run_test_params_eol(file_path)
-      filetypes.each do |params_filetype|
-        parameters = create_parameters(params_filetype, file_path, invalid_path, invalid_path)
-
-        assert_all_access_equal("value1", parameters, 'level1')
-        assert_all_access_equal("value2", parameters['level2'], 'first')
-      end
+      parameters = create_parameters(format, invalid_path, invalid_path, invalid_path)
+      assert_not_nil(parameters)
     end
+  end
 
-    def test_restricted_defaults_usage()
-      filetypes.each do |params_filetype|
-        parameters = create_parameters(params_filetype, "params_defaults_at_root", invalid_path, invalid_path)
+  def test_params_windows_eol()
+    run_test_params_eol("params_windows_eol")
+  end
 
-        assert_all_access_equal("value", parameters, :defaults)
-      end
+  def test_params_unix_eol()
+    run_test_params_eol("params_unix_eol")
+  end
 
-      filetypes.each do |params_filetype|
-        parameters = create_parameters(params_filetype, "params_defaults_not_at_root", invalid_path, invalid_path)
+  def run_test_params_eol(file_path)
+    formats.each do |format|
+      parameters = create_parameters(format, file_path, invalid_path, invalid_path)
 
-        assert_all_access_equal("value", parameters.level, :defaults)
-      end
+      assert_equal("value1", parameters['level1'])
+      assert_equal("value2", parameters['level2']['first'])
     end
+  end
 
-    def test_defaults()
-      filetypes.each do |params_filetype|
-        parameters = create_parameters(params_filetype, "params_simple", invalid_path, invalid_path)
-        parameters.defaults = {"test" => "override1", "level" => "new1"}
+  def test_restricted_defaults_usage()
+    formats.each do |format|
+      parameters = create_parameters(format, "params_defaults_at_root", invalid_path, invalid_path)
 
-        assert_all_access_equal("value", parameters, 'test')
-        assert_all_access_equal("new1", parameters, 'level')
-      end
+      assert_equal("value", parameters.defaults)
     end
 
-    def test_empty_file()
-      filetypes.each do |params_filetype|
-        parameters = create_parameters(params_filetype, "params_empty", invalid_path, invalid_path)
-        parameters.defaults = {"test" => "value"}
+    formats.each do |format|
+      parameters = create_parameters(format, "params_defaults_not_at_root", invalid_path, invalid_path)
 
-        assert_all_access_equal("value", parameters, 'test')
-      end
+      assert_equal("value", parameters.level.defaults)
     end
+  end
 
-    def test_file_not_hash()
-      ["boolean", "list"].each do |wrong_type|
-        filetypes.each do |params_filetype|
-          parameters = create_parameters(params_filetype, "params_#{wrong_type}", invalid_path, invalid_path)
-          parameters.defaults = {"test" => "value"}
+  def test_defaults()
+    formats.each do |format|
+      parameters = create_parameters(format, "params_simple", invalid_path, invalid_path)
+      parameters.defaults = {"test" => "override1", "level" => "new1"}
 
-          assert_all_access_equal("value", parameters, 'test')
-        end
-      end
+      assert_equal("value", parameters['test'])
+      assert_equal("new1", parameters['level'])
     end
+  end
 
-    def test_nil_values()
-      filetypes.each do |params_filetype|
-        parameters = create_parameters(params_filetype, "params_user_nil_values", invalid_path, invalid_path)
-        parameters.defaults = {:nil => "Not nil", :deep => {:nil => "Not nil", :deeper => {:nil => "Not nil"}}}
+  def test_empty_file()
+    formats.each do |format|
+      parameters = create_parameters(format, "params_empty", invalid_path, invalid_path)
+      parameters.defaults = {"test" => "value"}
 
-        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
+      assert_equal("value", parameters['test'])
+    end
+  end
 
-      filetypes.each do |params_filetype|
-        parameters = create_parameters(params_filetype, "params_user_nil_values", 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_all_access_equal(nil, parameters[:deep][:deeper], :nil)
-        assert_all_access_equal(nil, parameters[:deep], :nil)
-        assert_all_access_equal(nil, parameters, :nil)
+        assert_equal("value", parameters['test'])
       end
     end
+  end
 
-    def filetypes()
-      @@PARAMS_FILETYPES
-    end
+  def formats()
+    @@FORMATS
+  end
 
-    def invalid_path()
-      @@INVALID_PATH
-    end
+  def invalid_path()
+    @@INVALID_PATH
   end
 end