hiera 2.0.0-x64-mingw32

data/spec/spec_helper.rb

@@ -0,0 +1,78 @@
+$:.insert(0, File.join([File.dirname(__FILE__), "..", "lib"]))
+
+require 'rubygems'
+require 'rspec'
+require 'mocha'
+require 'hiera'
+require 'tmpdir'
+
+RSpec.configure do |config|
+  config.mock_with :mocha
+
+  if Hiera::Util.microsoft_windows? && RUBY_VERSION =~ /^1\./
+    require 'win32console'
+    config.output_stream = $stdout
+    config.error_stream = $stderr
+    config.formatters.each { |f| f.instance_variable_set(:@output, $stdout) }
+  end
+
+  config.after :suite do
+    # Log the spec order to a file, but only if the LOG_SPEC_ORDER environment variable is
+    #  set.  This should be enabled on Jenkins runs, as it can be used with Nick L.'s bisect
+    #  script to help identify and debug order-dependent spec failures.
+    if ENV['LOG_SPEC_ORDER']
+      File.open("./spec_order.txt", "w") do |logfile|
+        config.instance_variable_get(:@files_to_run).each { |f| logfile.puts f }
+      end
+    end
+  end
+end
+
+# So everyone else doesn't have to include this base constant.
+module HieraSpec
+  FIXTURE_DIR = File.join(dir = File.expand_path(File.dirname(__FILE__)), 'unit', 'fixtures') unless defined?(FIXTURE_DIR)
+end
+
+# In ruby 1.8.5 Dir does not have mktmpdir defined, so this monkey patches
+# Dir to include the 1.8.7 definition of that method if it isn't already defined.
+# Method definition borrowed from ruby-1.8.7-p357/lib/ruby/1.8/tmpdir.rb
+unless Dir.respond_to?(:mktmpdir)
+  def Dir.mktmpdir(prefix_suffix=nil, tmpdir=nil)
+    case prefix_suffix
+    when nil
+      prefix = "d"
+      suffix = ""
+    when String
+      prefix = prefix_suffix
+      suffix = ""
+    when Array
+      prefix = prefix_suffix[0]
+      suffix = prefix_suffix[1]
+    else
+      raise ArgumentError, "unexpected prefix_suffix: #{prefix_suffix.inspect}"
+    end
+    tmpdir ||= Dir.tmpdir
+    t = Time.now.strftime("%Y%m%d")
+    n = nil
+    begin
+      path = "#{tmpdir}/#{prefix}#{t}-#{$$}-#{rand(0x100000000).to_s(36)}"
+      path << "-#{n}" if n
+      path << suffix
+      Dir.mkdir(path, 0700)
+    rescue Errno::EEXIST
+      n ||= 0
+      n += 1
+      retry
+    end
+
+    if block_given?
+      begin
+        yield path
+      ensure
+        FileUtils.remove_entry_secure path
+      end
+    else
+      path
+    end
+  end
+end

data/spec/unit/backend/json_backend_spec.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+require 'hiera/backend/json_backend'
+
+class Hiera
+  module Backend
+    describe Json_backend do
+      before do
+        Hiera.stubs(:debug)
+        Hiera.stubs(:warn)
+        Hiera::Backend.stubs(:empty_answer).returns(nil)
+        @cache = mock
+        @backend = Json_backend.new(@cache)
+      end
+
+      describe "#initialize" do
+        it "should announce its creation" do # because other specs checks this
+          Hiera.expects(:debug).with("Hiera JSON backend starting")
+          Json_backend.new
+        end
+      end
+
+      describe "#lookup" do
+        it "should look for data in all sources" do
+          Backend.expects(:datasources).multiple_yields(["one"], ["two"])
+          Backend.expects(:datafile).with(:json, {}, "one", "json").returns(nil)
+          Backend.expects(:datafile).with(:json, {}, "two", "json").returns(nil)
+
+          expect { @backend.lookup("key", {}, nil, :priority, nil) }.to throw_symbol(:no_such_key)
+        end
+
+        it "should retain the data types found in data files" do
+          Backend.expects(:datasources).yields("one").times(3)
+          Backend.expects(:datafile).with(:json, {}, "one", "json").returns("/nonexisting/one.json").times(3)
+          File.stubs(:exist?).with("/nonexisting/one.json").returns(true)
+
+          @cache.expects(:read_file).with("/nonexisting/one.json", Hash).returns({"stringval" => "string", "boolval" => true, "numericval" => 1}).times(3)
+
+          @backend.lookup("stringval", {}, nil, :priority, nil).should == "string"
+          @backend.lookup("boolval", {}, nil, :priority, nil).should == true
+          @backend.lookup("numericval", {}, nil, :priority, nil).should == 1
+        end
+
+        it "should pick data earliest source that has it for priority searches" do
+          scope = {"rspec" => "test"}
+          Backend.expects(:datasources).multiple_yields(["one"], ["two"])
+          Backend.expects(:datafile).with(:json, scope, "one", "json").returns("/nonexisting/one.json")
+          Backend.expects(:datafile).with(:json, scope, "two", "json").never
+
+          File.stubs(:exist?).with("/nonexisting/one.json").returns(true)
+          @cache.expects(:read_file).with("/nonexisting/one.json", Hash).returns({"key" => "test_%{rspec}"})
+
+          @backend.lookup("key", scope, nil, :priority, nil).should == "test_test"
+        end
+
+        it "should build an array of all data sources for array searches" do
+          Hiera::Backend.stubs(:empty_answer).returns([])
+          Backend.stubs(:parse_answer).with('answer', {}, {}, anything).returns("answer")
+          Backend.expects(:datafile).with(:json, {}, "one", "json").returns("/nonexisting/one.json")
+          Backend.expects(:datafile).with(:json, {}, "two", "json").returns("/nonexisting/two.json")
+
+          Backend.expects(:datasources).multiple_yields(["one"], ["two"])
+
+          File.expects(:exist?).with("/nonexisting/one.json").returns(true)
+          File.expects(:exist?).with("/nonexisting/two.json").returns(true)
+
+          @cache.expects(:read_file).with("/nonexisting/one.json", Hash).returns({"key" => "answer"})
+          @cache.expects(:read_file).with("/nonexisting/two.json", Hash).returns({"key" => "answer"})
+
+          @backend.lookup("key", {}, nil, :array, nil).should == ["answer", "answer"]
+        end
+
+        it "should parse the answer for scope variables" do
+          Backend.stubs(:parse_answer).with('test_%{rspec}', {'rspec' => 'test'}, {}, anything).returns("test_test")
+          Backend.expects(:datasources).yields("one")
+          Backend.expects(:datafile).with(:json, {"rspec" => "test"}, "one", "json").returns("/nonexisting/one.json")
+
+          File.expects(:exist?).with("/nonexisting/one.json").returns(true)
+          @cache.expects(:read_file).with("/nonexisting/one.json", Hash).returns({"key" => "test_%{rspec}"})
+
+          @backend.lookup("key", {"rspec" => "test"}, nil, :priority, nil).should == "test_test"
+        end
+      end
+    end
+  end
+end

data/spec/unit/backend/yaml_backend_spec.rb

@@ -0,0 +1,138 @@
+require 'spec_helper'
+require 'hiera/backend/yaml_backend'
+
+class Hiera
+  module Backend
+    class FakeCache
+      attr_accessor :value
+      def read(path, expected_type, default, &block)
+        read_file(path, expected_type, &block)
+      rescue => e
+        default
+      end
+
+      def read_file(path, expected_type, &block)
+        output = block.call(@value)
+        if !output.is_a? expected_type
+          raise TypeError
+        end
+        output
+      end
+    end
+
+    describe Yaml_backend do
+      before do
+        Config.load({})
+        Hiera.stubs(:debug)
+        Hiera.stubs(:warn)
+        @cache = FakeCache.new
+        @backend = Yaml_backend.new(@cache)
+      end
+
+      describe "#initialize" do
+        it "should announce its creation" do # because other specs checks this
+          Hiera.expects(:debug).with("Hiera YAML backend starting")
+          Yaml_backend.new
+        end
+      end
+
+      describe "#lookup" do
+        it "should pick data earliest source that has it for priority searches" do
+          Backend.expects(:datasourcefiles).with(:yaml, {}, "yaml", nil).yields(["one", "/nonexisting/one.yaml"])
+          @cache.value = "---\nkey: answer"
+
+          @backend.lookup("key", {}, nil, :priority, nil).should == "answer"
+        end
+
+        describe "handling unexpected YAML values" do
+          before do
+            Backend.expects(:datasourcefiles).with(:yaml, {}, "yaml", nil).yields(["one", "/nonexisting/one.yaml"])
+          end
+
+          it "throws :no_such_key when key is missing in YAML" do
+            @cache.value = "---\n"
+            expect { @backend.lookup("key", {}, nil, :priority, nil) }.to throw_symbol(:no_such_key)
+          end
+
+          it "returns nil when the YAML value is nil" do
+            @cache.value = "key: ~\n"
+            @backend.lookup("key", {}, nil, :priority, nil).should be_nil
+          end
+
+          it "throws :no_such_key when the YAML file is false" do
+            @cache.value = ""
+            expect { @backend.lookup("key", {}, nil, :priority, nil) }.to throw_symbol(:no_such_key)
+          end
+
+          it "raises a TypeError when the YAML value is not a hash" do
+            @cache.value = "---\n[one, two, three]"
+            expect { @backend.lookup("key", {}, nil, :priority, nil) }.to raise_error(TypeError)
+          end
+        end
+
+        it "should build an array of all data sources for array searches" do
+          Backend.expects(:datasourcefiles).with(:yaml, {}, "yaml", nil).multiple_yields(["one", "/nonexisting/one.yaml"], ["two", "/nonexisting/two.yaml"])
+          @cache.expects(:read_file).with("/nonexisting/one.yaml", Hash).returns({"key"=>"answer"})
+          @cache.expects(:read_file).with("/nonexisting/two.yaml", Hash).returns({"key"=>"answer"})
+
+          @backend.lookup("key", {}, nil, :array, nil).should == ["answer", "answer"]
+        end
+
+        it "should ignore empty hash of data sources for hash searches" do
+          Backend.expects(:datasourcefiles).with(:yaml, {}, "yaml", nil).multiple_yields(["one", "/nonexisting/one.yaml"], ["two", "/nonexisting/two.yaml"])
+
+          @cache.expects(:read_file).with("/nonexisting/one.yaml", Hash).returns({})
+          @cache.expects(:read_file).with("/nonexisting/two.yaml", Hash).returns({"key"=>{"a"=>"answer"}})
+
+          @backend.lookup("key", {}, nil, :hash, nil).should == {"a" => "answer"}
+        end
+
+        it "should build a merged hash of data sources for hash searches" do
+          Backend.expects(:datasourcefiles).with(:yaml, {}, "yaml", nil).multiple_yields(["one", "/nonexisting/one.yaml"], ["two", "/nonexisting/two.yaml"])
+
+          @cache.expects(:read_file).with("/nonexisting/one.yaml", Hash).returns({"key"=>{"a"=>"answer"}})
+          @cache.expects(:read_file).with("/nonexisting/two.yaml", Hash).returns({"key"=>{"b"=>"answer", "a"=>"wrong"}})
+
+          @backend.lookup("key", {}, nil, :hash, nil).should == {"a" => "answer", "b" => "answer"}
+        end
+
+        it "should fail when trying to << a Hash" do
+          Backend.expects(:datasourcefiles).with(:yaml, {}, "yaml", nil).multiple_yields(["one", "/nonexisting/one.yaml"], ["two", "/nonexisting/two.yaml"])
+
+          @cache.expects(:read_file).with("/nonexisting/one.yaml", Hash).returns({"key"=>["a", "answer"]})
+          @cache.expects(:read_file).with("/nonexisting/two.yaml", Hash).returns({"key"=>{"a"=>"answer"}})
+
+          expect {@backend.lookup("key", {}, nil, :array, nil)}.to raise_error(Exception, "Hiera type mismatch for key 'key': expected Array and got Hash")
+        end
+
+        it "should fail when trying to merge an Array" do
+          Backend.expects(:datasourcefiles).with(:yaml, {}, "yaml", nil).multiple_yields(["one", "/nonexisting/one.yaml"], ["two", "/nonexisting/two.yaml"])
+
+          @cache.expects(:read_file).with("/nonexisting/one.yaml", Hash).returns({"key"=>{"a"=>"answer"}})
+          @cache.expects(:read_file).with("/nonexisting/two.yaml", Hash).returns({"key"=>["a", "wrong"]})
+
+          expect { @backend.lookup("key", {}, nil, :hash, nil) }.to raise_error(Exception, "Hiera type mismatch for key 'key': expected Hash and got Array")
+        end
+
+        it "should parse the answer for scope variables" do
+          Backend.expects(:datasourcefiles).with(:yaml, {"rspec" => "test"}, "yaml", nil).multiple_yields(["one", "/nonexisting/one.yaml"])
+
+          @cache.expects(:read_file).with("/nonexisting/one.yaml", Hash).returns({"key"=>"test_%{rspec}"})
+
+          @backend.lookup("key", {"rspec" => "test"}, nil, :priority, nil).should == "test_test"
+        end
+
+        it "should retain datatypes found in yaml files" do
+          Backend.expects(:datasourcefiles).with(:yaml, {}, "yaml", nil).multiple_yields(["one", "/nonexisting/one.yaml"]).times(3)
+
+
+          @cache.value = "---\nstringval: 'string'\nboolval: true\nnumericval: 1"
+
+          @backend.lookup("stringval", {}, nil, :priority, nil).should == "string"
+          @backend.lookup("boolval", {}, nil, :priority, nil).should == true
+          @backend.lookup("numericval", {}, nil, :priority, nil).should == 1
+        end
+      end
+    end
+  end
+end