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

data/spec/unit/indirector/instrumentation_probe/local_spec.rb

@@ -1,65 +0,0 @@
-#! /usr/bin/env ruby
-require 'spec_helper'
-
-require 'puppet/util/instrumentation/indirection_probe'
-require 'puppet/indirector/instrumentation_probe/local'
-require 'puppet/util/instrumentation/instrumentable'
-
-describe Puppet::Indirector::InstrumentationProbe::Local do
-  it "should be a subclass of the Code terminus" do
-    Puppet::Indirector::InstrumentationProbe::Local.superclass.should equal(Puppet::Indirector::Code)
-  end
-
-  it "should be registered with the configuration store indirection" do
-    indirection = Puppet::Indirector::Indirection.instance(:instrumentation_probe)
-    Puppet::Indirector::InstrumentationProbe::Local.indirection.should equal(indirection)
-  end
-
-  it "should have its name set to :local" do
-    Puppet::Indirector::InstrumentationProbe::Local.name.should == :local
-  end
-end
-
-describe Puppet::Indirector::InstrumentationProbe::Local do
-  before :each do
-    Puppet::Util::Instrumentation.stubs(:listener)
-    @probe = Puppet::Indirector::InstrumentationProbe::Local.new
-    @name = "me"
-    @request = stub 'request', :key => @name
-  end
-
-  describe "when finding probes" do
-    it "should do nothing" do
-      @probe.find(@request).should be_nil
-    end
-  end
-
-  describe "when searching probes" do
-    it "should return a list of all loaded probes irregardless of the given key" do
-      instance1 = stub 'instance1', :method => "probe1", :klass => "Klass1"
-      instance2 = stub 'instance2', :method => "probe2", :klass => "Klass2"
-      Puppet::Util::Instrumentation::IndirectionProbe.expects(:new).with("Klass1.probe1").returns(:instance1)
-      Puppet::Util::Instrumentation::IndirectionProbe.expects(:new).with("Klass2.probe2").returns(:instance2)
-      Puppet::Util::Instrumentation::Instrumentable.expects(:each_probe).multiple_yields([instance1], [instance2])
-      @probe.search(@request).should == [ :instance1, :instance2 ]
-    end
-  end
-
-  describe "when saving probes" do
-    it "should enable probes" do
-      newprobe = stub 'probe', :name => @name
-      @request.stubs(:instance).returns(newprobe)
-      Puppet::Util::Instrumentation::Instrumentable.expects(:enable_probes)
-      @probe.save(@request)
-    end
-  end
-
-  describe "when destroying probes" do
-    it "should disable probes" do
-      newprobe = stub 'probe', :name => @name
-      @request.stubs(:instance).returns(newprobe)
-      Puppet::Util::Instrumentation::Instrumentable.expects(:disable_probes)
-      @probe.destroy(@request)
-    end
-  end
-end

data/spec/unit/indirector/instrumentation_probe/rest_spec.rb

@@ -1,11 +0,0 @@
-#! /usr/bin/env ruby
-require 'spec_helper'
-
-require 'puppet/util/instrumentation/indirection_probe'
-require 'puppet/indirector/instrumentation_probe/rest'
-
-describe Puppet::Indirector::InstrumentationProbe::Rest do
-  it "should be a subclass of Puppet::Indirector::REST" do
-    Puppet::Indirector::InstrumentationProbe::Rest.superclass.should equal(Puppet::Indirector::REST)
-  end
-end

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

@@ -1,48 +0,0 @@
-#! /usr/bin/env ruby
-require 'spec_helper'
-
-require 'puppet/node'
-
-describe "Puppet::Node::ActiveRecord", :if => Puppet.features.rails? && Puppet.features.sqlite? do
-  include PuppetSpec::Files
-
-  let(:nodename) { "mynode" }
-  let(:fact_values) { {:afact => "a value"} }
-  let(:facts) { Puppet::Node::Facts.new(nodename, fact_values) }
-  let(:environment) { Puppet::Node::Environment.create(:myenv, []) }
-  let(:request) { Puppet::Indirector::Request.new(:node, :find, nodename, nil, :environment => environment) }
-  let(:node_indirection) { Puppet::Node::ActiveRecord.new }
-
-  before do
-    require 'puppet/indirector/node/active_record'
-  end
-
-  it "should issue a deprecation warning" do
-    Puppet.expects(:deprecation_warning).with() { |msg| msg =~ /ActiveRecord-based storeconfigs and inventory are deprecated/ }
-    Puppet[:statedir] = tmpdir('active_record_tmp')
-    Puppet[:railslog] = '$statedir/rails.log'
-    node_indirection
-  end
-
-  it "should be a subclass of the ActiveRecord terminus class" do
-    Puppet::Node::ActiveRecord.ancestors.should be_include(Puppet::Indirector::ActiveRecord)
-  end
-
-  it "should use Puppet::Rails::Host as its ActiveRecord model" do
-    Puppet::Node::ActiveRecord.ar_model.should equal(Puppet::Rails::Host)
-  end
-
-  it "should call fact_merge when a node is found" do
-    db_instance = stub 'db_instance'
-    Puppet::Node::ActiveRecord.ar_model.expects(:find_by_name).returns db_instance
-
-    node = Puppet::Node.new(nodename)
-    db_instance.expects(:to_puppet).returns node
-
-    Puppet[:statedir] = tmpdir('active_record_tmp')
-    Puppet[:railslog] = '$statedir/rails.log'
-    Puppet::Node::Facts.indirection.expects(:find).with(nodename, :environment => environment).returns(facts)
-
-    node_indirection.find(request).parameters.should include(fact_values)
-  end
-end

data/spec/unit/indirector/queue_spec.rb

@@ -1,115 +0,0 @@
-#! /usr/bin/env ruby
-require 'spec_helper'
-require 'puppet/indirector/queue'
-
-class Puppet::Indirector::Queue::TestClient
-end
-
-class FooExampleData
-  attr_accessor :name
-
-  def self.pson_create(pson)
-    new(pson['data'].to_sym)
-  end
-
-  def initialize(name = nil)
-    @name = name if name
-  end
-
-  def render(format = :pson)
-    to_pson
-  end
-
-  def to_pson(*args)
-    {:type => self.class.to_s, :data => name}.to_pson(*args)
-  end
-end
-
-describe Puppet::Indirector::Queue do
-  before :each do
-    @model = mock 'model'
-    @indirection = stub 'indirection', :name => :my_queue, :register_terminus_type => nil, :model => @model
-    Puppet::Indirector::Indirection.stubs(:instance).with(:my_queue).returns(@indirection)
-    module MyQueue; end
-    @store_class = class MyQueue::MyType < Puppet::Indirector::Queue
-      self
-    end
-    @store = @store_class.new
-
-    @subject_class = FooExampleData
-    @subject = @subject_class.new
-    @subject.name = :me
-
-    Puppet[:queue_type] = :test_client
-    Puppet::Util::Queue.stubs(:queue_type_to_class).with(:test_client).returns(Puppet::Indirector::Queue::TestClient)
-
-    @request = stub 'request', :key => :me, :instance => @subject
-  end
-
-  it 'should use the correct client type and queue' do
-    @store.queue.should == :my_queue
-    @store.client.should be_an_instance_of(Puppet::Indirector::Queue::TestClient)
-  end
-
-  describe "when saving" do
-    it 'should render the instance using pson' do
-      @subject.expects(:render).with(:pson)
-      @store.client.stubs(:publish_message)
-      @store.save(@request)
-    end
-
-    it "should publish the rendered message to the appropriate queue on the client" do
-      @subject.expects(:render).returns "mypson"
-
-      @store.client.expects(:publish_message).with(:my_queue, "mypson")
-
-      @store.save(@request)
-    end
-
-    it "should catch any exceptions raised" do
-      @store.client.expects(:publish_message).raises ArgumentError
-
-      expect { @store.save(@request) }.to raise_error(Puppet::Error)
-    end
-  end
-
-  describe "when subscribing to the queue" do
-    before do
-      @store_class.stubs(:model).returns @model
-    end
-
-    it "should use the model's Format support to intern the message from pson" do
-      @model.expects(:convert_from).with(:pson, "mymessage")
-
-      @store_class.client.expects(:subscribe).yields("mymessage")
-      @store_class.subscribe {|o| o }
-    end
-
-    it "should yield each interned received message" do
-      @model.stubs(:convert_from).returns "something"
-
-      @subject_two = @subject_class.new
-      @subject_two.name = :too
-
-      @store_class.client.expects(:subscribe).with(:my_queue).multiple_yields(@subject, @subject_two)
-
-      received = []
-      @store_class.subscribe do |obj|
-        received.push(obj)
-      end
-
-      received.should == %w{something something}
-    end
-
-    it "should log but not propagate errors" do
-      @store_class.client.expects(:subscribe).yields("foo")
-      @store_class.expects(:intern).raises(ArgumentError)
-      expect { @store_class.subscribe {|o| o } }.to_not raise_error
-
-      @logs.length.should == 1
-      @logs.first.message.should =~ /Error occurred with subscription to queue my_queue for indirection my_queue: ArgumentError/
-      @logs.first.level.should == :err
-    end
-  end
-end
-

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

@@ -1,166 +0,0 @@
-#! /usr/bin/env ruby
-require 'spec_helper'
-require 'puppet/node/facts'
-
-describe "Puppet::Resource::ActiveRecord", :if => can_use_scratch_database? do
-  include PuppetSpec::Files
-
-  before :each do
-    require 'puppet/indirector/resource/active_record'
-    setup_scratch_database
-  end
-
-  after :each do
-    Puppet::Rails.teardown
-  end
-
-  subject { Puppet::Resource.indirection.terminus(:active_record) }
-
-  it "should issue a deprecation warning" do
-    Puppet.expects(:deprecation_warning).with() { |msg| msg =~ /ActiveRecord-based storeconfigs and inventory are deprecated/ }
-    Puppet::Resource::ActiveRecord.new
-  end
-
-  describe "#search" do
-    def search(type, host = 'default.local', filter = nil)
-      args = { :host => host, :filter => filter }
-      subject.search(Puppet::Resource.indirection.request(:search, type, nil, args))
-    end
-
-    it "should return an empty array if no resources match" do
-      search("Exec").should == []
-    end
-
-    # Assert that this is a case-insensitive rule, too.
-    %w{and or AND OR And Or anD oR}.each do |op|
-      it "should fail if asked to search with #{op.inspect}" do
-        filter = [%w{tag == foo}, op, %w{title == bar}]
-        expect { search("Notify", 'localhost', filter) }.
-          to raise_error Puppet::Error, /not supported/
-      end
-    end
-
-    context "with a matching resource" do
-      before :each do
-        host = Puppet::Rails::Host.create!(:name => 'one.local')
-        Puppet::Rails::Resource.
-          create!(:host     => host,
-                  :restype  => 'Exec', :title => 'whammo',
-                  :exported => true)
-
-      end
-
-      it "should return something responding to `to_resource` if a resource matches" do
-        found = search("Exec")
-        found.length.should == 1
-        found.map do |item|
-          item.should respond_to :to_resource
-          item.restype.should == "Exec"
-        end
-      end
-
-      it "should not filter resources that have been found before" do
-        search("Exec").should == search("Exec")
-      end
-    end
-  end
-
-  describe "#build_active_record_query" do
-    let :type do 'Notify' end
-
-    def query(type, host, filter = nil)
-      subject.send :build_active_record_query, type, host, filter
-    end
-
-    it "should exclude all database resources from the host" do
-      host = Puppet::Rails::Host.create! :name => 'one.local'
-      got = query(type, host.name)
-      got.keys.should =~ [:conditions]
-      got[:conditions][0] =~ /\(host_id != \?\)/
-      got[:conditions].last.should == host.id
-    end
-
-    it "should join appropriately when filtering on parameters" do
-      filter = %w{propname == propval}
-      got = query(type, 'whatever', filter)
-      got.keys.should =~ [:conditions, :joins]
-      got[:joins].should == { :param_values => :param_name }
-      got[:conditions][0].should =~ /param_names\.name = \?/
-      got[:conditions][0].should =~ /param_values\.value = \?/
-      got[:conditions].should be_include filter.first
-      got[:conditions].should be_include filter.last
-    end
-
-    it "should join appropriately when filtering on tags" do
-      filter = %w{tag == test}
-      got = query(type, 'whatever', filter)
-      got.keys.should =~ [:conditions, :joins]
-      got[:joins].should == {:resource_tags => :puppet_tag}
-      got[:conditions].first.should =~ /puppet_tags/
-      got[:conditions].should_not be_include filter.first
-      got[:conditions].should be_include filter.last
-    end
-
-    it "should only search for exported resources with the matching type" do
-      got = query(type, 'whatever')
-      got.keys.should =~ [:conditions]
-      got[:conditions][0].should be_include "(exported=? AND restype=?)"
-      got[:conditions][1].should == true
-      got[:conditions][2].should == type.to_s.capitalize
-    end
-
-    it "should capitalize the type, since PGSQL is case sensitive" do
-      got = query(type, 'whatever')
-      got[:conditions][2].should == 'Notify'
-    end
-  end
-
-  describe "#filter_to_active_record" do
-    def filter_to_active_record(input)
-      subject.send :filter_to_active_record, input
-    end
-
-    [nil, '', 'whatever', 12].each do |input|
-      it "should fail if filter is not an array (with #{input.inspect})" do
-        expect { filter_to_active_record(input) }.
-          to raise_error ArgumentError, /must be arrays/
-      end
-    end
-
-    # Not exhaustive, just indicative.
-    ['=', '<>', '=~', '+', '-', '!'].each do |input|
-      it "should fail with unexpected comparison operators (with #{input.inspect})" do
-        expect { filter_to_active_record(["one", input, "two"]) }.
-          to raise_error ArgumentError, /unknown operator/
-      end
-    end
-
-    {
-      ["title", "==", "whatever"] => ["title = ?", ["whatever"]],
-      ["title", "!=", "whatever"] => ["title != ?", ["whatever"]],
-
-      # Technically, these are not supported by Puppet yet, but as we pay
-      # approximately zero cost other than a few minutes writing the tests,
-      # and it would be *harder* to fail on them, nested queries.
-      [["title", "==", "foo"], "or", ["title", "==", "bar"]] =>
-        ["(title = ?) OR (title = ?)", ["foo", "bar"]],
-
-      [["title", "==", "foo"], "or", ["tag", "==", "bar"]] =>
-        ["(title = ?) OR (puppet_tags.name = ?)", ["foo", "bar"]],
-
-      [["title", "==", "foo"], "or", ["param", "==", "bar"]] =>
-        ["(title = ?) OR (param_names.name = ? AND param_values.value = ?)",
-         ["foo", "param", "bar"]],
-
-      [[["title","==","foo"],"or",["tag", "==", "bar"]],"and",["param","!=","baz"]] =>
-      ["((title = ?) OR (puppet_tags.name = ?)) AND "+
-       "(param_names.name = ? AND param_values.value != ?)",
-       ["foo", "bar", "param", "baz"]]
-
-    }.each do |input, expect|
-      it "should map #{input.inspect} to #{expect.inspect}" do
-        filter_to_active_record(input).should == expect
-      end
-    end
-  end
-end

data/spec/unit/indirector/resource/rest_spec.rb

@@ -1,10 +0,0 @@
-#! /usr/bin/env ruby
-require 'spec_helper'
-
-require 'puppet/indirector/resource/rest'
-
-describe Puppet::Resource::Rest do
-  it "should be a sublcass of Puppet::Indirector::REST" do
-    Puppet::Resource::Rest.superclass.should equal(Puppet::Indirector::REST)
-  end
-end

data/spec/unit/indirector/run/local_spec.rb

@@ -1,21 +0,0 @@
-#! /usr/bin/env ruby
-require 'spec_helper'
-
-require 'puppet/indirector/run/local'
-
-describe Puppet::Run::Local do
-  it "should be a subclass of Puppet::Indirector::Code" do
-    Puppet::Run::Local.superclass.should equal(Puppet::Indirector::Code)
-  end
-
-  it "should call runner.run on save and return the runner" do
-    Puppet::Status.indirection.stubs(:find).returns Puppet::Status.new
-
-    runner  = Puppet::Run.new
-    runner.stubs(:run).returns(runner)
-
-    request = Puppet::Indirector::Request.new(:indirection, :save, "anything", nil)
-    request.instance = runner = Puppet::Run.new
-    Puppet::Run::Local.new.save(request).should == runner
-  end
-end

data/spec/unit/indirector/run/rest_spec.rb

@@ -1,10 +0,0 @@
-#! /usr/bin/env ruby
-require 'spec_helper'
-
-require 'puppet/indirector/run/rest'
-
-describe Puppet::Run::Rest do
-  it "should be a sublcass of Puppet::Indirector::REST" do
-    Puppet::Run::Rest.superclass.should equal(Puppet::Indirector::REST)
-  end
-end