hiera 0.1.0 → 0.1.1

data/bin/hiera

@@ -1,4 +1,4 @@
-#!/bin/env ruby
+#!/usr/bin/env ruby
 
 # CLI client for Hiera.
 #

data/spec/spec.opts

@@ -0,0 +1 @@
+--format s --colour --backtrace

data/spec/spec_helper.rb

@@ -0,0 +1,19 @@
+$:.insert(0, File.join([File.dirname(__FILE__), "..", "..", "lib"]))
+
+require 'rubygems'
+require 'rspec'
+require 'hiera'
+require 'rspec/mocks'
+require 'mocha'
+
+RSpec.configure do |config|
+    config.mock_with :mocha
+end
+
+class Puppet
+    class Parser
+        class Functions
+        end
+    end
+end
+

data/spec/unit/backend/yaml_backend_spec.rb

@@ -0,0 +1,63 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'hiera/backend/yaml_backend'
+
+class Hiera
+    module Backend
+        describe Yaml_backend do
+            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
+                before do
+                    Hiera.stubs(:debug)
+                    Hiera.stubs(:warn)
+                    @backend = Yaml_backend.new
+                end
+
+                it "should fail for missing datadir" do
+                    Backend.expects(:datadir).with(:yaml, {}).returns("/nonexisting")
+
+                    expect {
+                        @backend.lookup("key", {}, nil, nil)
+                    }.to raise_error("Cannot find data directory /nonexisting")
+                end
+
+                it "should look for data in all sources" do
+                    Backend.expects(:datadir).with(:yaml, {}).returns("/nonexisting")
+                    File.expects(:directory?).with("/nonexisting").returns(true)
+                    Backend.expects(:datasources).multiple_yields(["one"], ["two"])
+                    File.expects(:exist?).with("/nonexisting/one.yaml").returns(false)
+                    File.expects(:exist?).with("/nonexisting/two.yaml").returns(false)
+                    @backend.lookup("key", {}, nil, nil)
+                end
+
+                it "should pick data earliest source that has it" do
+                    Backend.expects(:datadir).with(:yaml, {}).returns("/nonexisting")
+                    File.expects(:directory?).with("/nonexisting").returns(true)
+                    Backend.expects(:datasources).multiple_yields(["one"], ["two"])
+                    File.expects(:exist?).with("/nonexisting/one.yaml").returns(true)
+                    YAML.expects(:load_file).with("/nonexisting/one.yaml").returns({"key" => "answer"})
+
+                    File.expects(:exist?).with("/nonexisting/two.yaml").never
+
+                    @backend.lookup("key", {}, nil, nil).should == "answer"
+                end
+
+                it "should parse the answer for scope variables" do
+                    Backend.expects(:datadir).with(:yaml, {"rspec" => "test"}).returns("/nonexisting")
+                    File.expects(:directory?).with("/nonexisting").returns(true)
+                    Backend.expects(:datasources).yields("one")
+                    File.expects(:exist?).with("/nonexisting/one.yaml").returns(true)
+                    YAML.expects(:load_file).with("/nonexisting/one.yaml").returns({"key" => "test_%{rspec}"})
+
+                    @backend.lookup("key", {"rspec" => "test"}, nil, nil).should == "test_test"
+                end
+            end
+        end
+    end
+end

data/spec/unit/backend_spec.rb

@@ -0,0 +1,158 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+class Hiera
+    describe Backend do
+        describe "#datadir" do
+            it "should use the backend configured dir" do
+                Config.load({:rspec => {:datadir => "/tmp"}})
+                Backend.expects(:parse_string).with("/tmp", {})
+                Backend.datadir(:rspec, {})
+            end
+
+            it "should default to /var/lib/hiera" do
+                Config.load({})
+                Backend.expects(:parse_string).with("/var/lib/hiera", {})
+                Backend.datadir(:rspec, {})
+            end
+        end
+
+        describe "#datasources" do
+            it "should use the supplied hierarchy" do
+                expected = ["one", "two"]
+                Backend.datasources({}, nil, ["one", "two"]) do |backend|
+                    backend.should == expected.delete_at(0)
+                end
+
+                expected.empty?.should == true
+            end
+
+            it "should use the configured hierarchy if none is supplied" do
+                Config.load(:hierarchy => "test")
+
+                Backend.datasources({}) do |backend|
+                    backend.should == "test"
+                end
+            end
+
+            it "should default to common if not configured or supplied" do
+                Config.load({})
+
+                Backend.datasources({}) do |backend|
+                    backend.should == "common"
+                end
+            end
+
+            it "should insert the override if provided" do
+                Config.load({})
+
+                expected = ["override", "common"]
+                Backend.datasources({}, "override") do |backend|
+                    backend.should == expected.delete_at(0)
+                end
+
+                expected.empty?.should == true
+            end
+
+            it "should parse the sources based on scope" do
+                Backend.expects(:parse_string).with("common", {:rspec => :tests})
+                Backend.datasources({:rspec => :tests}) { }
+            end
+
+            it "should not return empty sources" do
+                Config.load({})
+
+                expected = ["common"]
+                Backend.datasources({}, "%{rspec}") do |backend|
+                    backend.should == expected.delete_at(0)
+                end
+
+                expected.empty?.should == true
+            end
+        end
+
+        describe "#parse_string" do
+            it "should not try to parse invalid data" do
+                Backend.parse_string(nil, {}).should == nil
+            end
+
+            it "should clone the supplied data" do
+                data = ""
+                data.expects(:clone).returns("")
+                Backend.parse_string(data, {})
+            end
+
+            it "should only parse string data" do
+                data = ""
+                data.expects(:is_a?).with(String)
+                Backend.parse_string(data, {})
+            end
+
+            it "should match data from scope" do
+                input = "test_%{rspec}_test"
+                Backend.parse_string(input, {"rspec" => "test"}).should == "test_test_test"
+            end
+
+            it "should match data from extra_data" do
+                input = "test_%{rspec}_test"
+                Backend.parse_string(input, {}, {"rspec" => "test"}).should == "test_test_test"
+            end
+
+            it "should prefer scope over extra_data" do
+                input = "test_%{rspec}_test"
+                Backend.parse_string(input, {"rspec" => "test"}, {"rspec" => "fail"}).should == "test_test_test"
+            end
+        end
+
+        describe "#lookup" do
+            before do
+                Hiera.stubs(:debug)
+                Hiera.stubs(:warn)
+            end
+
+            it "should cache backends" do
+                Hiera.stubs(:debug)
+                Hiera.expects(:debug).with(regexp_matches(/Hiera YAML backend starting/)).once
+
+                Config.load({:yaml => {:datadir => "/tmp"}})
+                Config.load_backends
+
+                Backend.lookup("key", "default", {}, nil, nil)
+                Backend.lookup("key", "default", {}, nil, nil)
+            end
+
+            it "should return the answer from the backend" do
+                Hiera.stubs(:debug)
+                Config.load({:yaml => {:datadir => "/tmp"}})
+                Config.load_backends
+
+                Backend::Yaml_backend.any_instance.expects(:lookup).with("key", {}, nil, nil).returns("answer")
+
+                Backend.lookup("key", "default", {}, nil, nil).should == "answer"
+            end
+
+            it "should call to all backends till an answer is found" do
+                backend = mock
+                backend.expects(:lookup).returns("answer")
+                Hiera.stubs(:debug)
+                Config.load({})
+                Config.instance_variable_set("@config", {:backends => ["yaml", "rspec"]})
+                Backend.instance_variable_set("@backends", {"rspec" => backend})
+                Backend::Yaml_backend.any_instance.expects(:lookup).with("key", {"rspec" => "test"}, nil, nil)
+                Backend.expects(:constants).returns(["Yaml_backend", "Rspec_backend"]).twice
+
+                Backend.lookup("key", "test_%{rspec}", {"rspec" => "test"}, nil, nil).should == "answer"
+
+            end
+
+            it "should return the default with variables parsed if nothing is found" do
+                Hiera.stubs(:debug)
+                Config.load({:yaml => {:datadir => "/tmp"}})
+                Config.load_backends
+
+                Backend::Yaml_backend.any_instance.expects(:lookup).with("key", {"rspec" => "test"}, nil, nil)
+
+                Backend.lookup("key", "test_%{rspec}", {"rspec" => "test"}, nil, nil).should == "test_test"
+            end
+        end
+    end
+end

data/spec/unit/config_spec.rb

@@ -0,0 +1,70 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+class Hiera
+    describe Config do
+        describe "#load" do
+            it "should treat string sources as a filename" do
+                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({})
+
+                Config.load("/nonexisting")
+            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"}
+            end
+
+            it "should force :backends to be a flattened array" do
+                Config.load({:backends => [["foo", ["bar"]]]}).should == {:backends => ["foo", "bar"], :hierarchy => "common", :logger => "console"}
+            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
+        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 File.dirname(__FILE__) + '/../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/hiera_spec.rb

@@ -0,0 +1,59 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe "Hiera" do
+    describe "#logger=" do
+        it "should attempt to load the supplied logger" do
+            Hiera.stubs(:warn)
+            Hiera.expects(:require).with("hiera/foo_logger").raises("fail")
+            Hiera.logger = "foo"
+        end
+
+        it "should fall back to the Console logger on failure" do
+            Hiera.expects(:warn).with("Failed to load foo logger: LoadError: no such file to load -- hiera/foo_logger")
+            Hiera.logger = "foo"
+        end
+    end
+
+    describe "#warn" do
+        it "should call the supplied logger" do
+            Hiera::Console_logger.expects(:warn).with("rspec")
+            Hiera.warn("rspec")
+        end
+    end
+
+    describe "#debug" do
+        it "should call the supplied logger" do
+            Hiera::Console_logger.expects(:debug).with("rspec")
+            Hiera.debug("rspec")
+        end
+    end
+
+    describe "#initialize" do
+        it "should default to /etc/hiera.yaml for config" do
+            Hiera::Config.expects(:load).with("/etc/hiera.yaml")
+            Hiera::Config.stubs(:load_backends)
+            Hiera.new
+        end
+
+        it "should pass 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 "should load all backends on start" do
+            Hiera::Config.stubs(:load)
+            Hiera::Config.expects(:load_backends)
+            Hiera.new
+        end
+    end
+
+    describe "#lookup" do
+        it "should proxy 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

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 1
-  - 0
-  version: 0.1.0
+  - 1
+  version: 0.1.1
 platform: ruby
 authors: 
 - R.I.Pienaar
@@ -34,7 +34,7 @@ files:
 - lib/hiera/console_logger.rb
 - lib/hiera/backend/yaml_backend.rb
 has_rdoc: true
-homepage: http://devco.net/
+homepage: https://github.com/ripienaar/hiera/
 licenses: []
 
 post_install_message: 
@@ -63,5 +63,11 @@ rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
 summary: Light weight hierarcical data store
-test_files: []
-
+test_files: 
+- spec/spec.opts
+- spec/spec_helper.rb
+- spec/unit/backend_spec.rb
+- spec/unit/console_logger_spec.rb
+- spec/unit/hiera_spec.rb
+- spec/unit/config_spec.rb
+- spec/unit/backend/yaml_backend_spec.rb