puppet 3.8.7-x64-mingw32 → 4.0.0.rc1-x64-mingw32

data/spec/unit/hiera/backend/puppet_backend_spec.rb

@@ -1,148 +0,0 @@
-require 'spec_helper'
-require 'hiera/backend/puppet_backend'
-require 'hiera/scope'
-require 'hiera/config'
-
-describe Hiera::Backend::Puppet_backend do
-
-  before do
-    Hiera.stubs(:warn)
-    Hiera.stubs(:debug)
-    Hiera::Backend.stubs(:datasources).yields([])
-    Puppet::Parser::Functions.stubs(:function).with(:include)
-
-    @mockresource = mock
-    @mockresource.stubs(:name).returns("ntp::config")
-
-    @mockscope = mock
-    @mockscope.stubs(:resource).returns(@mockresource)
-
-    @scope = Hiera::Scope.new(@mockscope)
-
-    @backend = Hiera::Backend::Puppet_backend.new
-  end
-
-  describe "#hierarchy" do
-    it "should use the configured datasource" do
-      with_config(:puppet => {:datasource => "rspec"},
-                  :hierarchy => nil)
-
-      @backend.hierarchy(@scope, nil).should == ["rspec::ntp::config", "rspec::ntp", "ntp::config::rspec", "ntp::rspec"]
-    end
-
-    it "should not include empty class names" do
-      with_config(:puppet => {:datasource => "rspec"},
-                  :hierarchy => ["%{foo}", "common"])
-
-      @mockscope.expects(:lookupvar).at_least_once.with("foo").returns(nil)
-
-      @backend.hierarchy(@scope, nil).should == ["rspec::common", "ntp::config::rspec", "ntp::rspec"]
-    end
-
-    it "should allow for an override data source" do
-      with_config(:puppet => {:datasource => "rspec"},
-                  :hierarchy => nil)
-
-      @backend.hierarchy(@scope, "override").should == ["rspec::override", "rspec::ntp::config", "rspec::ntp", "ntp::config::rspec", "ntp::rspec"]
-    end
-  end
-
-  describe "#lookup" do
-    it "should attempt to load data from unincluded classes" do
-      with_config(:puppet => {:datasource => "rspec"},
-                  :hierarchy => ["rspec"])
-
-      catalog = mock
-      catalog.expects(:classes).returns([])
-
-      @mockscope.expects(:catalog).returns(catalog)
-      @mockscope.expects(:function_include).with(["rspec::rspec"])
-      @mockscope.expects(:lookupvar).with("rspec::rspec::key").returns("rspec")
-
-      @backend.lookup("key", @scope, nil, nil).should == "rspec"
-    end
-
-    it "should not load loaded classes" do
-      with_config(:puppet => {:datasource => "rspec"},
-                  :hierarchy => ["rspec"])
-
-      catalog = mock
-      catalog.expects(:classes).returns(["rspec::rspec"])
-      @mockscope.expects(:catalog).returns(catalog)
-      @mockscope.expects(:function_include).never
-      @mockscope.expects(:lookupvar).with("rspec::rspec::key").returns("rspec")
-
-      @backend.lookup("key", @scope, nil, nil).should == "rspec"
-    end
-
-    it "should return the first found data" do
-      with_config(:puppet => {:datasource => "rspec"},
-                  :hierarchy => ["override", "rspec"])
-
-      catalog = mock
-      catalog.expects(:classes).returns(["rspec::override", "override::override"])
-      @mockscope.expects(:catalog).returns(catalog)
-      @mockscope.expects(:function_include).never
-      @mockscope.expects(:lookupvar).with("rspec::override::key").returns("rspec")
-      @mockscope.expects(:lookupvar).with("rspec::rspec::key").never
-
-      @backend.lookup("key", @scope, "override", nil).should == "rspec"
-    end
-
-    it "should consider a value of false to be a real value" do
-      with_config(:puppet => {:datasource => "rspec"},
-                  :hierarchy => ["override", "rspec"])
-      expected_answer = false
-
-      catalog = mock
-      catalog.expects(:classes).returns(["rspec::override", "override::override"])
-      @mockscope.expects(:catalog).returns(catalog)
-      @mockscope.expects(:lookupvar).with("rspec::override::key").returns(expected_answer)
-      @mockscope.expects(:lookupvar).with("rspec::rspec::key").never
-
-      @backend.lookup("key", @scope, "override", nil).should == expected_answer
-    end
-
-    it "should return an array of found data for array searches" do
-      catalog = mock
-      catalog.expects(:classes).returns(["rspec", "test"])
-      @mockscope.expects(:catalog).returns(catalog)
-      @mockscope.expects(:function_include).never
-      @mockscope.expects(:lookupvar).with("rspec::key").returns("rspec::key")
-      @mockscope.expects(:lookupvar).with("test::key").returns("test::key")
-
-      @backend.expects(:hierarchy).with(@scope, nil).returns(["rspec", "test"])
-      @backend.lookup("key", @scope, nil, :array).should == ["rspec::key", "test::key"]
-    end
-
-    it "should return a hash of found data for hash searches" do
-      catalog = mock
-      catalog.expects(:classes).returns(["rspec", "test"])
-      @mockscope.expects(:catalog).returns(catalog)
-      @mockscope.expects(:function_include).never
-      @mockscope.expects(:lookupvar).with("rspec::key").returns({'rspec'=>'key'})
-      @mockscope.expects(:lookupvar).with("test::key").returns({'test'=>'key'})
-
-      @backend.expects(:hierarchy).with(@scope, nil).returns(["rspec", "test"])
-      @backend.lookup("key", @scope, nil, :hash).should == {'rspec'=>'key', 'test'=>'key'}
-    end
-
-    it "should return a merged hash of found data for hash searches" do
-      catalog = mock
-      catalog.expects(:classes).returns(["rspec", "test"])
-      @mockscope.expects(:catalog).returns(catalog)
-      @mockscope.expects(:function_include).never
-      @mockscope.expects(:lookupvar).with("rspec::key").returns({'rspec'=>'key', 'common'=>'rspec'})
-      @mockscope.expects(:lookupvar).with("test::key").returns({'test'=>'key', 'common'=>'rspec'})
-
-      @backend.expects(:hierarchy).with(@scope, nil).returns(["rspec", "test"])
-      @backend.lookup("key", @scope, nil, :hash).should == {'rspec'=>'key', 'common'=>'rspec', 'test'=>'key'}
-    end
-  end
-
-  def with_config(config)
-    config.each do |key, value|
-      Hiera::Config.expects("[]").with(key).returns(value)
-    end
-  end
-end

data/spec/unit/indirector/active_record_spec.rb

@@ -1,75 +0,0 @@
-#! /usr/bin/env ruby
-require 'spec_helper'
-
-require 'puppet/rails'
-require 'puppet/indirector/active_record'
-
-describe Puppet::Indirector::ActiveRecord do
-  before do
-    Puppet::Rails.stubs(:init)
-
-    Puppet::Indirector::Terminus.stubs(:register_terminus_class)
-    @model = mock 'model'
-    @indirection = stub 'indirection', :name => :mystuff, :register_terminus_type => nil, :model => @model
-    Puppet::Indirector::Indirection.stubs(:instance).returns(@indirection)
-
-    module Testing; end
-    @active_record_class = class Testing::MyActiveRecord < Puppet::Indirector::ActiveRecord
-      self
-    end
-
-    @ar_model = mock 'ar_model'
-
-    @active_record_class.use_ar_model @ar_model
-    @terminus = @active_record_class.new
-
-    @name = "me"
-    @instance = stub 'instance', :name => @name
-
-    @request = stub 'request', :key => @name, :instance => @instance
-  end
-
-  it "should allow declaration of an ActiveRecord model to use" do
-    @active_record_class.use_ar_model "foo"
-    @active_record_class.ar_model.should == "foo"
-  end
-
-  describe "when initializing" do
-    it "should init Rails" do
-      Puppet::Rails.expects(:init)
-      @active_record_class.new
-    end
-  end
-
-  describe "when finding an instance" do
-    it "should use the ActiveRecord model to find the instance" do
-      @ar_model.expects(:find_by_name).with(@name)
-
-      @terminus.find(@request)
-    end
-
-    it "should return nil if no instance is found" do
-      @ar_model.expects(:find_by_name).with(@name).returns nil
-      @terminus.find(@request).should be_nil
-    end
-
-    it "should convert the instance to a Puppet object if it is found" do
-      instance = mock 'rails_instance'
-      instance.expects(:to_puppet).returns "mypuppet"
-
-      @ar_model.expects(:find_by_name).with(@name).returns instance
-      @terminus.find(@request).should == "mypuppet"
-    end
-  end
-
-  describe "when saving an instance" do
-    it "should use the ActiveRecord model to convert the instance into a Rails object and then save that rails object" do
-      rails_object = mock 'rails_object'
-      @ar_model.expects(:from_puppet).with(@instance).returns rails_object
-
-      rails_object.expects(:save)
-
-      @terminus.save(@request)
-    end
-  end
-end

data/spec/unit/indirector/catalog/active_record_spec.rb

@@ -1,107 +0,0 @@
-#! /usr/bin/env ruby
-require 'spec_helper'
-
-describe "Puppet::Resource::Catalog::ActiveRecord", :if => can_use_scratch_database? do
-  include PuppetSpec::Files
-
-  before :each do
-    require 'puppet/indirector/catalog/active_record'
-    setup_scratch_database
-  end
-
-  after :each do
-    Puppet::Rails.teardown
-  end
-
-  let :terminus do
-    Puppet::Resource::Catalog::ActiveRecord.new
-  end
-
-  it "should issue a deprecation warning" do
-    Puppet.expects(:deprecation_warning).with() { |msg| msg =~ /ActiveRecord-based storeconfigs and inventory are deprecated/ }
-
-    Puppet::Resource::Catalog::ActiveRecord.new
-  end
-
-  it "should be a subclass of the ActiveRecord terminus class" do
-    Puppet::Resource::Catalog::ActiveRecord.ancestors.should be_include(Puppet::Indirector::ActiveRecord)
-  end
-
-  it "should use Puppet::Rails::Host as its ActiveRecord model" do
-    Puppet::Resource::Catalog::ActiveRecord.ar_model.should equal(Puppet::Rails::Host)
-  end
-
-  describe "when finding an instance" do
-    it "should return nil" do
-      r = stub 'request', :key => "foo", :options => {:cache_integration_hack => false}
-      terminus.find(r).should be_nil
-    end
-
-    # This used to make things go to the database, but that is code that is as
-    # dead as a doornail.  This just checks we don't blow up unexpectedly, and
-    # can go away after a few releases. --daniel 2012-02-27
-    it "should always return nil" do
-      r = stub 'request', :key => "foo", :options => {:cache_integration_hack => true}
-      terminus.find(r).should be_nil
-    end
-  end
-
-  describe "when saving an instance" do
-    let :catalog do Puppet::Resource::Catalog.new("foo") end
-    let :request do Puppet::Indirector::Request.new(:active_record, :save, nil, catalog) end
-    let :node do Puppet::Node.new("foo", :environment => "environment") end
-
-    before :each do
-      Puppet::Node.indirection.stubs(:find).with("foo").returns(node)
-    end
-
-    it "should find the Rails host with the same name" do
-      Puppet::Rails::Host.expects(:find_by_name).with("foo")
-      terminus.save(request)
-    end
-
-    it "should create a new Rails host if none can be found" do
-      Puppet::Rails::Host.find_by_name('foo').should be_nil
-      terminus.save(request)
-      Puppet::Rails::Host.find_by_name('foo').should be_valid
-    end
-
-    it "should set the catalog vertices as resources on the Rails host instance" do
-      # We need to stub this so we get the same object, not just the same
-      # content, otherwise the expect can't fire. :(
-      host = Puppet::Rails::Host.create!(:name => "foo")
-      Puppet::Rails::Host.expects(:find_by_name).with("foo").returns(host)
-      catalog.expects(:vertices).returns("foo")
-      host.expects(:merge_resources).with("foo")
-
-      terminus.save(request)
-    end
-
-    it "should set host ip if we could find a matching node" do
-      node.merge("ipaddress" => "192.168.0.1")
-      terminus.save(request)
-      Puppet::Rails::Host.find_by_name("foo").ip.should == '192.168.0.1'
-    end
-
-    it "should set host environment if we could find a matching node" do
-      terminus.save(request)
-      Puppet::Rails::Host.find_by_name("foo").environment.should == "environment"
-    end
-
-    it "should set the last compile time on the host" do
-      before = Time.now
-      terminus.save(request)
-      after = Time.now
-
-      Puppet::Rails::Host.find_by_name("foo").last_compile.should be_between(before, after)
-    end
-
-    it "should save the Rails host instance" do
-      host = Puppet::Rails::Host.create!(:name => "foo")
-      Puppet::Rails::Host.expects(:find_by_name).with("foo").returns(host)
-      host.expects(:save)
-
-      terminus.save(request)
-    end
-  end
-end

data/spec/unit/indirector/catalog/queue_spec.rb

@@ -1,19 +0,0 @@
-#! /usr/bin/env ruby
-require 'spec_helper'
-
-require 'puppet/indirector/catalog/queue'
-
-describe Puppet::Resource::Catalog::Queue do
-  it 'should be a subclass of the Queue terminus' do
-    Puppet::Resource::Catalog::Queue.superclass.should equal(Puppet::Indirector::Queue)
-  end
-
-  it 'should be registered with the catalog store indirection' do
-    indirection = Puppet::Indirector::Indirection.instance(:catalog)
-    Puppet::Resource::Catalog::Queue.indirection.should equal(indirection)
-  end
-
-  it 'shall be dubbed ":queue"' do
-    Puppet::Resource::Catalog::Queue.name.should == :queue
-  end
-end

data/spec/unit/indirector/facts/active_record_spec.rb

@@ -1,113 +0,0 @@
-#! /usr/bin/env ruby
-require 'spec_helper'
-
-require 'puppet/rails'
-require 'puppet/node/facts'
-
-describe "Puppet::Node::Facts::ActiveRecord", :if => Puppet.features.rails? do
-  before do
-    require 'puppet/indirector/facts/active_record'
-    Puppet.features.stubs(:rails?).returns true
-    Puppet::Rails.stubs(:init)
-  end
-
-  let :terminus do
-    Puppet::Node::Facts::ActiveRecord.new
-  end
-
-  it "should issue a deprecation warning" do
-    Puppet.expects(:deprecation_warning).with() { |msg| msg =~ /ActiveRecord-based storeconfigs and inventory are deprecated/ }
-    terminus
-  end
-
-  it "should be a subclass of the ActiveRecord terminus class" do
-    Puppet::Node::Facts::ActiveRecord.ancestors.should be_include(Puppet::Indirector::ActiveRecord)
-  end
-
-  it "should use Puppet::Rails::Host as its ActiveRecord model" do
-    Puppet::Node::Facts::ActiveRecord.ar_model.should equal(Puppet::Rails::Host)
-  end
-
-  describe "when finding an instance" do
-    let :request do
-      stub 'request', :key => "foo"
-    end
-
-    it "should use the Hosts ActiveRecord class to find the host" do
-      Puppet::Rails::Host.expects(:find_by_name).with { |key, args| key == "foo" }
-      terminus.find(request)
-    end
-
-    it "should include the fact names and values when finding the host" do
-      Puppet::Rails::Host.expects(:find_by_name).with { |key, args| args[:include] == {:fact_values => :fact_name} }
-      terminus.find(request)
-    end
-
-    it "should return nil if no host instance can be found" do
-      Puppet::Rails::Host.expects(:find_by_name).returns nil
-      terminus.find(request).should be_nil
-    end
-
-    it "should convert the node's parameters into a Facts instance if a host instance is found" do
-      host = stub 'host', :name => "foo"
-      host.expects(:get_facts_hash).returns("one" => [mock("two_value", :value => "two")], "three" => [mock("three_value", :value => "four")])
-
-      Puppet::Rails::Host.expects(:find_by_name).returns host
-
-      result = terminus.find(request)
-
-      result.should be_instance_of(Puppet::Node::Facts)
-      result.name.should == "foo"
-      result.values.should == {"one" => "two", "three" => "four"}
-    end
-
-    it "should convert all single-member arrays into non-arrays" do
-      host = stub 'host', :name => "foo"
-      host.expects(:get_facts_hash).returns("one" => [mock("two_value", :value => "two")])
-
-      Puppet::Rails::Host.expects(:find_by_name).returns host
-
-      terminus.find(request).values["one"].should == "two"
-    end
-  end
-
-  describe "when saving an instance" do
-    let :facts do
-      Puppet::Node::Facts.new("foo", "one" => "two", "three" => "four")
-    end
-
-    let :request do
-      stub 'request', :key => "foo", :instance => facts
-    end
-
-    let :host do
-      stub 'host', :name => "foo", :save => nil, :merge_facts => nil
-    end
-
-    before do
-      Puppet::Rails::Host.stubs(:find_by_name).returns host
-    end
-
-    it "should find the Rails host with the same name" do
-      Puppet::Rails::Host.expects(:find_by_name).with("foo").returns host
-      terminus.save(request)
-    end
-
-    it "should create a new Rails host if none can be found" do
-      Puppet::Rails::Host.expects(:find_by_name).with("foo").returns nil
-      Puppet::Rails::Host.expects(:create).with(:name => "foo").returns host
-      terminus.save(request)
-    end
-
-    it "should set the facts as facts on the Rails host instance" do
-      # There is other stuff added to the hash.
-      host.expects(:merge_facts).with { |args| args["one"] == "two" and args["three"] == "four" }
-      terminus.save(request)
-    end
-
-    it "should save the Rails host instance" do
-      host.expects(:save)
-      terminus.save(request)
-    end
-  end
-end