hiera 2.0.0-x86-mingw32

data/spec/unit/config_spec.rb

@@ -0,0 +1,118 @@
+require 'spec_helper'
+
+class Hiera
+  describe Config do
+    describe "#load" do
+      let(:default_config) do
+        {
+          :backends  => ["yaml"],
+          :hierarchy => "common",
+          :logger    => "console",
+          :merge_behavior=>:native
+        }
+      end
+
+      it "should treat string sources as a filename" do
+        expect { Config.load("/nonexisting") }.to raise_error
+      end
+
+      it "should raise an error for missing config files" do
+        File.expects(:exist?).with("/nonexisting").returns(false)
+        YAML.expects(:load_file).with("/nonexisting").never
+
+        expect { Config.load("/nonexisting") }.to raise_error "Config file /nonexisting not found"
+      end
+
+      it "should attempt to YAML load config files" do
+        File.expects(:exist?).with("/nonexisting").returns(true)
+        YAML.expects(:load_file).with("/nonexisting").returns(YAML.load("---\n"))
+
+        Config.load("/nonexisting")
+      end
+
+      it "should use defaults on empty YAML config file" do
+        File.expects(:exist?).with("/nonexisting").returns(true)
+        YAML.expects(:load_file).with("/nonexisting").returns(YAML.load(""))
+
+        Config.load("/nonexisting").should == default_config
+      end
+
+      it "should use hash data as source if supplied" do
+        config = Config.load({"rspec" => "test"})
+        config["rspec"].should == "test"
+      end
+
+      it "should merge defaults with the loaded or supplied config" do
+        config = Config.load({})
+        config.should == {:backends => ["yaml"], :hierarchy => "common", :logger => "console", :merge_behavior=>:native}
+      end
+
+      it "should force :backends to be a flattened array" do
+        Config.load({:backends => [["foo", ["bar"]]]}).should == {:backends => ["foo", "bar"], :hierarchy => "common", :logger => "console", :merge_behavior=>:native}
+      end
+
+      it "should load the supplied logger" do
+        Hiera.expects(:logger=).with("foo")
+        Config.load({:logger => "foo"})
+      end
+
+      it "should default to the console logger" do
+        Hiera.expects(:logger=).with("console")
+        Config.load({})
+      end
+
+      context "loading '/dev/null' as spec tests do", :unless => Hiera::Util.microsoft_windows? do
+        before :each do
+          # Simulate the behavior of YAML.load_file('/dev/null') in MRI 1.9.3p194
+          Config.stubs(:yaml_load_file).
+            raises(TypeError, "no implicit conversion from nil to integer")
+        end
+
+        it "is not exceptional behavior" do
+          Config.load('/dev/null')
+        end
+      end
+
+      describe "if deep_merge can't be loaded" do
+        let(:error_message) { "Must have 'deep_merge' gem installed for the configured merge_behavior." }
+        before(:each) do
+          Config.expects(:require).with("deep_merge").raises(LoadError, "unable to load")
+        end
+
+        it "should error if merge_behavior is 'deep'" do
+          expect { Config.load(:merge_behavior => :deep) }.to raise_error(Hiera::Error, error_message)
+        end
+
+        it "should error if merge_behavior is 'deeper'" do
+          expect { Config.load(:merge_behavior => :deeper) }.to raise_error(Hiera::Error, error_message)
+        end
+      end
+    end
+
+    describe "#load_backends" do
+      it "should load each backend" do
+        Config.load(:backends => ["One", "Two"])
+        Config.expects(:require).with("hiera/backend/one_backend")
+        Config.expects(:require).with("hiera/backend/two_backend")
+        Config.load_backends
+      end
+
+      it "should warn if it cant load a backend" do
+        Config.load(:backends => ["one"])
+        Config.expects(:require).with("hiera/backend/one_backend").raises("fail")
+
+        expect {
+            Config.load_backends
+        }.to raise_error("fail")
+      end
+    end
+
+    describe "#include?" do
+      it "should correctly report inclusion" do
+        Config.load({})
+        Config.include?(:foo).should == false
+        Config.include?(:logger).should == true
+      end
+    end
+  end
+end

data/spec/unit/console_logger_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+class Hiera
+  describe Console_logger do
+    describe "#warn" do
+      it "should warn to STDERR" do
+        STDERR.expects(:puts).with("WARN: 0: foo")
+        Time.expects(:now).returns(0)
+        Console_logger.warn("foo")
+      end
+
+      it "should debug to STDERR" do
+        STDERR.expects(:puts).with("DEBUG: 0: foo")
+        Time.expects(:now).returns(0)
+        Console_logger.debug("foo")
+      end
+    end
+  end
+end

data/spec/unit/fallback_logger_spec.rb

@@ -0,0 +1,80 @@
+require 'hiera/fallback_logger'
+
+describe Hiera::FallbackLogger do
+  before :each do
+    InMemoryLogger.reset
+    SuitableLogger.reset
+  end
+
+  it "delegates #warn to the logger implemenation" do
+    logger = Hiera::FallbackLogger.new(InMemoryLogger)
+
+    logger.warn("the message")
+
+    InMemoryLogger.warnings.should == ["the message"]
+  end
+
+  it "delegates #debug to the logger implemenation" do
+    logger = Hiera::FallbackLogger.new(InMemoryLogger)
+
+    logger.debug("the message")
+
+    InMemoryLogger.debugs.should == ["the message"]
+  end
+
+  it "chooses the first logger that is suitable" do
+    logger = Hiera::FallbackLogger.new(UnsuitableLogger, SuitableLogger)
+
+    logger.warn("for the suitable logger")
+
+    SuitableLogger.warnings.should include("for the suitable logger")
+  end
+
+  it "raises an error if no implementation is suitable" do
+    expect do
+      Hiera::FallbackLogger.new(UnsuitableLogger)
+    end.to raise_error "No suitable logging implementation found."
+  end
+
+  it "issues a warning for each implementation that is not suitable" do
+    Hiera::FallbackLogger.new(UnsuitableLogger, UnsuitableLogger, SuitableLogger)
+
+    SuitableLogger.warnings.should == [
+      "Not using UnsuitableLogger. It does not report itself to be suitable.",
+      "Not using UnsuitableLogger. It does not report itself to be suitable."]
+  end
+
+  # Preserves log messages in memory
+  # and also serves as a "legacy" logger that has no
+  # suitable? method
+  class InMemoryLogger
+    class << self
+      attr_accessor :warnings, :debugs
+    end
+
+    def self.reset
+      self.warnings = []
+      self.debugs = []
+    end
+
+    def self.warn(message)
+      self.warnings << message
+    end
+
+    def self.debug(message)
+      self.debugs << message
+    end
+  end
+
+  class UnsuitableLogger
+    def self.suitable?
+      false
+    end
+  end
+
+  class SuitableLogger < InMemoryLogger
+    def self.suitable?
+      true
+    end
+  end
+end

data/spec/unit/filecache_spec.rb

@@ -0,0 +1,142 @@
+require 'spec_helper'
+require 'tmpdir'
+
+class Hiera
+  describe Filecache do
+    before do
+      @cache = Filecache.new
+    end
+
+    def write_file(file, contents)
+      File.open(file, 'w') do |f|
+        f.write(contents)
+      end
+    end
+
+    describe "#read" do
+      it "reads data from a file" do
+        Dir.mktmpdir do |dir|
+          file = File.join(dir, "testing")
+          write_file(file, "my data")
+
+          @cache.read(file).should == "my data"
+        end
+      end
+
+      it "rereads data when the file changes" do
+        Dir.mktmpdir do |dir|
+          file = File.join(dir, "testing")
+          write_file(file, "my data")
+          @cache.read(file).should == "my data"
+
+          write_file(file, "changed data")
+          @cache.read(file).should == "changed data"
+        end
+      end
+
+      it "uses the provided default when the type does not match the expected type" do
+        Hiera.expects(:debug).with(regexp_matches(/String.*not.*Hash, setting defaults/))
+        Dir.mktmpdir do |dir|
+          file = File.join(dir, "testing")
+          write_file(file, "my data")
+          data = @cache.read(file, Hash, { :testing => "hash" }) do |data|
+            "a string"
+          end
+
+          data.should == { :testing => "hash" }
+        end
+      end
+
+      it "traps any errors from the block and uses the default value" do
+        Hiera.expects(:debug).with(regexp_matches(/Reading data.*failed:.*testing error/))
+        Dir.mktmpdir do |dir|
+          file = File.join(dir, "testing")
+          write_file(file, "my data")
+          data = @cache.read(file, Hash, { :testing => "hash" }) do |data|
+            raise ArgumentError, "testing error"
+          end
+
+          data.should == { :testing => "hash" }
+        end
+      end
+
+      it "raises an error when there is no default given and there is a problem" do
+        Dir.mktmpdir do |dir|
+          file = File.join(dir, "testing")
+          write_file(file, "my data")
+
+          expect do
+            @cache.read(file, Hash) do |data|
+              raise ArgumentError, "testing error"
+            end
+          end.to raise_error(ArgumentError, "testing error")
+        end
+      end
+    end
+
+    describe "#read_file" do
+      it "reads data from a file" do
+        Dir.mktmpdir do |dir|
+          file = File.join(dir, "testing")
+          write_file(file, "my data")
+
+          @cache.read_file(file).should == "my data"
+        end
+      end
+
+      it "rereads data when the file changes" do
+        Dir.mktmpdir do |dir|
+          file = File.join(dir, "testing")
+          write_file(file, "my data")
+          @cache.read_file(file).should == "my data"
+
+          write_file(file, "changed data")
+          @cache.read_file(file).should == "changed data"
+        end
+      end
+
+      it "errors when the type does not match the expected type" do
+        Dir.mktmpdir do |dir|
+          file = File.join(dir, "testing")
+          write_file(file, "my data")
+
+          expect do
+            @cache.read_file(file, Hash) do |data|
+              "a string"
+            end
+          end.to raise_error(TypeError)
+        end
+      end
+
+      it "converts the read data using the block" do
+        Dir.mktmpdir do |dir|
+          file = File.join(dir, "testing")
+          write_file(file, "my data")
+
+          @cache.read_file(file, Hash) do |data|
+            { :data => data }
+          end.should == { :data => "my data" }
+        end
+      end
+
+      it "errors when the file does not exist" do
+        expect do
+          @cache.read_file("/notexist")
+        end.to raise_error(Errno::ENOENT)
+      end
+
+      it "propogates any errors from the block" do
+        Dir.mktmpdir do |dir|
+          file = File.join(dir, "testing")
+          write_file(file, "my data")
+
+          expect do
+            @cache.read_file(file) do |data|
+              raise ArgumentError, "testing error"
+            end
+          end.to raise_error(ArgumentError, "testing error")
+        end
+      end
+    end
+  end
+end

data/spec/unit/fixtures/interpolate/config/hiera.yaml

@@ -0,0 +1,6 @@
+:backends:
+  - yaml
+
+:hierarchy:
+  - recursive
+  - niltest

data/spec/unit/fixtures/interpolate/data/niltest.yaml

@@ -0,0 +1,2 @@
+niltest: 'Missing key #%{hiera("knotfound")}#. Key with nil #%{hiera("knil")}#'
+knil: null

data/spec/unit/fixtures/interpolate/data/recursive.yaml

@@ -0,0 +1,3 @@
+foo: '%{hiera("bar")}'
+
+bar: '%{hiera("foo")}'

data/spec/unit/fixtures/override/config/hiera.yaml

@@ -0,0 +1,5 @@
+:backends:
+  - yaml
+
+:hierarchy:
+  - common

data/spec/unit/fixtures/override/data/alternate.yaml

@@ -0,0 +1 @@
+bar: 'alternate'

data/spec/unit/fixtures/override/data/common.yaml

@@ -0,0 +1,2 @@
+foo: '%{hiera("bar")}'
+bar: 'common'

data/spec/unit/hiera_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+require 'hiera/util'
+
+# This is only around for the logger setup tests
+module Hiera::Foo_logger
+end
+
+describe "Hiera" do
+  describe "#logger=" do
+    it "loads the given logger" do
+      Hiera.expects(:require).with("hiera/foo_logger")
+
+      Hiera.logger = "foo"
+    end
+
+    it "falls back to the Console logger when the logger could not be loaded" do
+      Hiera.expects(:warn)
+
+      Hiera.logger = "no_such_logger"
+
+      Hiera.logger.should be Hiera::Console_logger
+    end
+
+    it "falls back to the Console logger when the logger class could not be found" do
+      Hiera.expects(:warn)
+      Hiera.expects(:require).with("hiera/no_constant_logger")
+
+      Hiera.logger = "no_constant"
+
+      Hiera.logger.should be Hiera::Console_logger
+    end
+  end
+
+  describe "#warn" do
+    it "delegates to the configured logger" do
+      Hiera.logger = 'console'
+      Hiera::Console_logger.expects(:warn).with("rspec")
+
+      Hiera.warn("rspec")
+    end
+  end
+
+  describe "#debug" do
+    it "delegates to the configured logger" do
+      Hiera.logger = 'console'
+      Hiera::Console_logger.expects(:debug).with("rspec")
+
+      Hiera.debug("rspec")
+    end
+  end
+
+  describe "#initialize" do
+    it "uses a default config file when none is provided" do
+      config_file = File.join(Hiera::Util.config_dir, 'hiera.yaml')
+      Hiera::Config.expects(:load).with(config_file)
+      Hiera::Config.stubs(:load_backends)
+      Hiera.new
+    end
+
+    it "passes the supplied config to the config class" do
+      Hiera::Config.expects(:load).with({"test" => "rspec"})
+      Hiera::Config.stubs(:load_backends)
+      Hiera.new(:config => {"test" => "rspec"})
+    end
+
+    it "loads all backends on start" do
+      Hiera::Config.stubs(:load)
+      Hiera::Config.expects(:load_backends)
+      Hiera.new
+    end
+  end
+
+  describe "#lookup" do
+    it "delegates to the Backend#lookup method" do
+      Hiera::Config.stubs(:load)
+      Hiera::Config.stubs(:load_backends)
+      Hiera::Backend.expects(:lookup).with(:key, :default, :scope, :order_override, :resolution_type)
+      Hiera.new.lookup(:key, :default, :scope, :order_override, :resolution_type)
+    end
+  end
+end