puppet 2.7.3 → 2.7.4

data/spec/unit/node/environment_spec.rb

@@ -1,6 +1,8 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
+require 'tmpdir'
+
 require 'puppet/node/environment'
 require 'puppet/util/execution'
 
@@ -10,10 +12,6 @@ describe Puppet::Node::Environment do
     Puppet::Node::Environment.clear
   end
 
-  it "should include the Cacher module" do
-    Puppet::Node::Environment.ancestors.should be_include(Puppet::Util::Cacher)
-  end
-
   it "should use the filetimeout for the ttl for the modulepath" do
     Puppet::Node::Environment.attr_ttl(:modulepath).should == Integer(Puppet[:filetimeout])
   end
@@ -22,10 +20,6 @@ describe Puppet::Node::Environment do
     Puppet::Node::Environment.attr_ttl(:modules).should == Integer(Puppet[:filetimeout])
   end
 
-  it "should use the filetimeout for the ttl for the manifestdir" do
-    Puppet::Node::Environment.attr_ttl(:manifestdir).should == Integer(Puppet[:filetimeout])
-  end
-
   it "should use the default environment if no name is provided while initializing an environment" do
     Puppet.settings.expects(:value).with(:environment).returns("one")
     Puppet::Node::Environment.new.name.should == :one
@@ -109,27 +103,15 @@ describe Puppet::Node::Environment do
     end
   end
 
-  [:modulepath, :manifestdir].each do |setting|
-    it "should validate the #{setting} directories" do
-      path = %w{/one /two}.join(File::PATH_SEPARATOR)
-
-      env = Puppet::Node::Environment.new("testing")
-      env.stubs(:[]).with(setting).returns path
-
-      env.expects(:validate_dirs).with(%w{/one /two})
-
-      env.send(setting)
-    end
+  it "should validate the modulepath directories" do
+    real_file = tmpdir('moduledir')
+    path = %W[/one /two #{real_file}].join(File::PATH_SEPARATOR)
 
-    it "should return the validated dirs for #{setting}" do
-      path = %w{/one /two}.join(File::PATH_SEPARATOR)
+    Puppet[:modulepath] = path
 
-      env = Puppet::Node::Environment.new("testing")
-      env.stubs(:[]).with(setting).returns path
-      env.stubs(:validate_dirs).returns %w{/one /two}
+    env = Puppet::Node::Environment.new("testing")
 
-      env.send(setting).should == %w{/one /two}
-    end
+    env.modulepath.should == [real_file]
   end
 
   it "should prefix the value of the 'PUPPETLIB' environment variable to the module path if present" do
@@ -144,21 +126,26 @@ describe Puppet::Node::Environment do
   end
 
   describe "when validating modulepath or manifestdir directories" do
+    before :each do
+      @path_one = make_absolute('/one')
+      @path_two = make_absolute('/two')
+    end
+
     it "should not return non-directories" do
       env = Puppet::Node::Environment.new("testing")
 
-      FileTest.expects(:directory?).with("/one").returns true
-      FileTest.expects(:directory?).with("/two").returns false
+      FileTest.expects(:directory?).with(@path_one).returns true
+      FileTest.expects(:directory?).with(@path_two).returns false
 
-      env.validate_dirs(%w{/one /two}).should == %w{/one}
+      env.validate_dirs([@path_one, @path_two]).should == [@path_one]
     end
 
     it "should use the current working directory to fully-qualify unqualified paths" do
       FileTest.stubs(:directory?).returns true
       env = Puppet::Node::Environment.new("testing")
 
-      two = File.join(Dir.getwd, "two")
-      env.validate_dirs(%w{/one two}).should == ["/one", two]
+      two = File.expand_path(File.join(Dir.getwd, "two"))
+      env.validate_dirs([@path_one, 'two']).should == [@path_one, two]
     end
   end
 

data/spec/unit/node/facts_spec.rb

@@ -68,10 +68,6 @@ describe Puppet::Node::Facts, "when indirecting" do
     before do
       @indirection = stub 'indirection', :request => mock('request'), :name => :facts
 
-      # We have to clear the cache so that the facts ask for our indirection stub,
-      # instead of anything that might be cached.
-      Puppet::Util::Cacher.expire
-
       @facts = Puppet::Node::Facts.new("me", "one" => "two")
     end
 

data/spec/unit/node_spec.rb

@@ -130,15 +130,8 @@ end
 describe Puppet::Node, "when indirecting" do
   it "should default to the 'plain' node terminus" do
     Puppet::Node.indirection.reset_terminus_class
-    Puppet::Node.indirection.terminus_class.should == :plain
-  end
 
-  it "should not have a cache class defined" do
-    Puppet::Node.indirection.cache_class.should be_nil
-  end
-
-  after do
-    Puppet::Util::Cacher.expire
+    Puppet::Node.indirection.terminus_class.should == :plain
   end
 end
 

data/spec/unit/other/selinux_spec.rb

@@ -5,11 +5,13 @@ require 'puppet/type/selboolean'
 require 'puppet/type/selmodule'
 
 describe Puppet::Type.type(:file), " when manipulating file contexts" do
+  include PuppetSpec::Files
+
   before :each do
 
           @file = Puppet::Type::File.new(
                 
-      :name => "/tmp/foo",
+      :name => make_absolute("/tmp/foo"),
       :ensure => "file",
       :seluser => "user_u",
       :selrole => "role_r",

data/spec/unit/parameter_spec.rb

@@ -25,16 +25,6 @@ describe Puppet::Parameter do
     @parameter.to_s.should == @parameter.name.to_s
   end
 
-  it "should be able to use cached attributes" do
-    Puppet::Parameter.ancestors.should be_include(Puppet::Util::Cacher)
-  end
-
-  it "should use the resource catalog for expiration" do
-    catalog = mock 'catalog'
-    @resource.stubs(:catalog).returns catalog
-    @parameter.expirer.should equal(catalog)
-  end
-
   [:line, :file, :version].each do |data|
     it "should return its resource's #{data} as its #{data}" do
       @resource.expects(data).returns "foo"

data/spec/unit/parser/ast/collexpr_spec.rb

@@ -18,14 +18,14 @@ describe Puppet::Parser::AST::CollExpr do
     end
 
     it "should evaluate both" do
-      collexpr = ast::CollExpr.new(:test1 => @test1, :test2 => @test2, :oper=>"==")
+      collexpr = ast::CollExpr.new(:test1 => @test1, :test2 => @test2, :oper => "==")
       collexpr.evaluate(@scope)
     end
 
-    it "should produce a textual representation and code of the expression" do
-      collexpr = ast::CollExpr.new(:test1 => @test1, :test2 => @test2, :oper=>"==")
+    it "should produce a data and code representation of the expression" do
+      collexpr = ast::CollExpr.new(:test1 => @test1, :test2 => @test2, :oper => "==")
       result = collexpr.evaluate(@scope)
-      result[0].should == "param_values.value = 'test2' and param_names.name = 'test1'"
+      result[0].should == ["test1", "==", "test2"]
       result[1].should be_an_instance_of(Proc)
     end
 
@@ -59,16 +59,20 @@ describe Puppet::Parser::AST::CollExpr do
       end
     end
 
-    it "should warn if this is an exported collection containing parenthesis (unsupported)" do
-      collexpr = ast::CollExpr.new(:test1 => @test1, :test2 => @test2, :oper=>"==", :parens => true, :form => :exported)
-      Puppet.expects(:warning)
-      collexpr.evaluate(@scope)
+    it "should work if this is an exported collection containing parenthesis" do
+      collexpr = ast::CollExpr.new(:test1 => @test1, :test2 => @test2,
+                                   :oper => "==", :parens => true, :form => :exported)
+      match, code = collexpr.evaluate(@scope)
+      match.should == ["test1", "==", "test2"]
+      @logs.should be_empty     # no warnings emitted
     end
 
     %w{and or}.each do |op|
-      it "should raise an error if this is an exported collection with #{op} operator (unsupported)" do
-        collexpr = ast::CollExpr.new(:test1 => @test1, :test2 => @test2, :oper=> op, :form => :exported)
-        lambda { collexpr.evaluate(@scope) }.should raise_error(Puppet::ParseError)
+      it "should parse / eval if this is an exported collection with #{op} operator" do
+        collexpr = ast::CollExpr.new(:test1 => @test1, :test2 => @test2,
+                                     :oper => op, :form => :exported)
+        match, code = collexpr.evaluate(@scope)
+        match.should == ["test1", op, "test2"]
       end
     end
   end
@@ -82,10 +86,10 @@ describe Puppet::Parser::AST::CollExpr do
       @resource.stubs(:tagged?).with("value").returns(true)
     end
 
-    it "should produce a textual representation of the expression" do
+    it "should produce a data representation of the expression" do
       collexpr = ast::CollExpr.new(:test1 => @tag, :test2 => @value, :oper=>"==")
       result = collexpr.evaluate(@scope)
-      result[0].should == "puppet_tags.name = 'value'"
+      result[0].should == ["tag", "==", "value"]
     end
 
     it "should inspect resource tags if the query term is on tags" do

data/spec/unit/parser/collector_spec.rb

@@ -1,6 +1,11 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
+begin
+  require 'sqlite3'
+rescue LoadError
+end
+
 require 'puppet/rails'
 require 'puppet/parser/collector'
 
@@ -262,294 +267,173 @@ describe Puppet::Parser::Collector, "when collecting virtual and catalog resourc
   end
 end
 
-describe Puppet::Parser::Collector, "when collecting exported resources", :if => Puppet.features.rails? do
+describe Puppet::Parser::Collector, "when collecting exported resources", :if => (Puppet.features.rails? and defined? SQLite3) do
+  include PuppetSpec::Files
+
   before do
     @compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("mynode"))
     @scope = Puppet::Parser::Scope.new :compiler => @compiler
-    @resource_type = "Mytype"
-    @equery = "test = true"
+    @resource_type = "notify"
+    @equery = ["title", "!=", ""]
     @vquery = proc { |r| true }
-
-    res = stub("resource 1")
-    res.stubs(:type).returns @resource_type
-    Puppet::Resource.stubs(:new).returns res
-
-    Puppet.settings.stubs(:value).with(:storeconfigs).returns true
-    Puppet.settings.stubs(:value).with(:environment).returns "production"
-
-    @collector = Puppet::Parser::Collector.new(@scope, @resource_type, @equery, @vquery, :exported)
-  end
-
-  # Stub most of our interface to Rails.
-  def stub_rails(everything = false)
-    ActiveRecord::Base.stubs(:connected?).returns(false)
-    Puppet::Rails.stubs(:init)
-    if everything
-      Puppet::Rails::Host.stubs(:find_by_name).returns(nil)
-      Puppet::Rails::Resource.stubs(:find).returns([])
-    end
+    @collector = Puppet::Parser::Collector.new(@scope, @resource_type,
+                                               @equery, @vquery, :exported)
   end
 
   it "should just return false if :storeconfigs is not enabled" do
-    Puppet.settings.expects(:value).with(:storeconfigs).returns false
+    Puppet[:storeconfigs] = false
     @collector.evaluate.should be_false
   end
 
-  it "should use initialize the Rails support if ActiveRecord is not connected" do
-    @compiler.stubs(:resources).returns([])
-    ActiveRecord::Base.expects(:connected?).returns(false)
-    Puppet::Rails.expects(:init)
-    Puppet::Rails::Host.stubs(:find_by_name).returns(nil)
-    Puppet::Rails::Resource.stubs(:find).returns([])
-
-    @collector.evaluate
-  end
-
-  it "should return all matching resources from the current compile and mark them non-virtual and non-exported" do
-    stub_rails(true)
-
-    one = stub 'one', :type => "Mytype", :virtual? => true, :exported? => true, :ref => "one"
-    two = stub 'two', :type => "Mytype", :virtual? => true, :exported? => true, :ref => "two"
-
-    one.stubs(:exported=)
-    one.stubs(:virtual=)
-    two.stubs(:exported=)
-    two.stubs(:virtual=)
-
-    @compiler.expects(:resources).returns([one, two])
-
-    @collector.evaluate.should == [one, two]
-  end
-
-  it "should mark all returned resources as not virtual" do
-    stub_rails(true)
-
-    one = stub 'one', :type => "Mytype", :virtual? => true, :exported? => true, :ref => "one"
-
-    one.stubs(:exported=)
-    one.expects(:virtual=).with(false)
-
-    @compiler.expects(:resources).returns([one])
-
-    @collector.evaluate.should == [one]
-  end
-
-  it "should convert all found resources into parser resources" do
-    stub_rails
-    Puppet::Rails::Host.stubs(:find_by_name).returns(nil)
-
-    one = stub 'one', :restype => "Mytype", :title => "one", :virtual? => true, :exported? => true, :ref => "one"
-    Puppet::Rails::Resource.stubs(:find).returns([one])
-
-    resource = mock 'resource'
-    one.expects(:to_resource).with(@scope).returns(resource)
-    resource.stubs(:exported=)
-    resource.stubs(:virtual=)
-    resource.stubs(:ref)
-
-    @compiler.stubs(:resources).returns([])
-    @scope.stubs(:findresource).returns(nil)
-
-    @compiler.stubs(:add_resource)
-
-    @collector.evaluate.should == [resource]
-  end
-
-  it "should override all exported collected resources if collector has an override" do
-    stub_rails
-    Puppet::Rails::Host.stubs(:find_by_name).returns(nil)
-
-    one = stub 'one', :restype => "Mytype", :title => "one", :virtual? => true, :exported? => true, :ref => "one"
-    Puppet::Rails::Resource.stubs(:find).returns([one])
-
-    resource = mock 'resource', :type => "Mytype"
-    one.expects(:to_resource).with(@scope).returns(resource)
-    resource.stubs(:exported=)
-    resource.stubs(:virtual=)
-    resource.stubs(:ref)
-    resource.stubs(:title)
-
-    @compiler.stubs(:resources).returns([])
-    @scope.stubs(:findresource).returns(nil)
-
-    param = stub 'param'
-    @compiler.stubs(:add_override)
-    @compiler.stubs(:add_resource)
-
-    @collector.add_override(:parameters => param )
-    Puppet::Parser::Resource.expects(:new).once.with { |type, title, h|
-      h[:parameters] == param
-    }
-
-    @collector.evaluate
-  end
-
-  it "should store converted resources in the compile's resource list" do
-    stub_rails
-    Puppet::Rails::Host.stubs(:find_by_name).returns(nil)
-
-    one = stub 'one', :restype => "Mytype", :title => "one", :virtual? => true, :exported? => true, :ref => "one"
-    Puppet::Rails::Resource.stubs(:find).returns([one])
-
-    resource = mock 'resource'
-    one.expects(:to_resource).with(@scope).returns(resource)
-    resource.stubs(:exported=)
-    resource.stubs(:virtual=)
-    resource.stubs(:ref)
-
-    @compiler.stubs(:resources).returns([])
-    @scope.stubs(:findresource).returns(nil)
-
-    @compiler.expects(:add_resource).with(@scope, resource)
-
-    @collector.evaluate.should == [resource]
-  end
-
-  # This way one host doesn't store another host's resources as exported.
-  it "should mark resources collected from the database as not exported" do
-    stub_rails
-    Puppet::Rails::Host.stubs(:find_by_name).returns(nil)
-
-    one = stub 'one', :restype => "Mytype", :title => "one", :virtual? => true, :exported? => true, :ref => "one"
-    Puppet::Rails::Resource.stubs(:find).returns([one])
-
-    resource = mock 'resource'
-    one.expects(:to_resource).with(@scope).returns(resource)
-    resource.expects(:exported=).with(false)
-    resource.stubs(:virtual=)
-    resource.stubs(:ref)
-
-    @compiler.stubs(:resources).returns([])
-    @scope.stubs(:findresource).returns(nil)
-
-    @compiler.stubs(:add_resource)
-
-    @collector.evaluate
-  end
-
-  it "should fail if an equivalent resource already exists in the compile" do
-    stub_rails
-    Puppet::Rails::Host.stubs(:find_by_name).returns(nil)
-
-    rails = stub 'one', :restype => "Mytype", :title => "one", :virtual? => true, :exported? => true, :id => 1, :ref => "yay"
-    inmemory = stub 'one', :type => "Mytype", :virtual? => true, :exported? => true, :rails_id => 2
-
-    Puppet::Rails::Resource.stubs(:find).returns([rails])
-
-    resource = mock 'resource'
-
-    @compiler.stubs(:resources).returns([])
-    @scope.stubs(:findresource).returns(inmemory)
-
-    @compiler.stubs(:add_resource)
-
-    proc { @collector.evaluate }.should raise_error(Puppet::ParseError)
-  end
-
-  it "should ignore exported resources that match already-collected resources" do
-    stub_rails
-    Puppet::Rails::Host.stubs(:find_by_name).returns(nil)
+  context "with storeconfigs enabled" do
+    before :each do
+      ActiveRecord::Base.remove_connection
 
-    rails = stub 'one', :restype => "Mytype", :title => "one", :virtual? => true, :exported? => true, :id => 1, :ref => "yay"
-    inmemory = stub 'one', :type => "Mytype", :virtual? => true, :exported? => true, :rails_id => 1
-
-    Puppet::Rails::Resource.stubs(:find).returns([rails])
-
-    resource = mock 'resource'
-
-    @compiler.stubs(:resources).returns([])
-    @scope.stubs(:findresource).returns(inmemory)
-
-    @compiler.stubs(:add_resource)
-
-    proc { @collector.evaluate }.should_not raise_error(Puppet::ParseError)
-  end
-end
-
-describe Puppet::Parser::Collector, "when building its ActiveRecord query for collecting exported resources", :if => Puppet.features.rails? do
-  before do
-    @scope = stub 'scope', :host => "myhost", :debug => nil
-    @compiler = mock 'compile'
-    @scope.stubs(:compiler).returns(@compiler)
-    @resource_type = "Mytype"
-    @equery = nil
-    @vquery = proc { |r| true }
-
-    @resource = stub_everything 'collected'
-
-    @collector = Puppet::Parser::Collector.new(@scope, @resource_type, @equery, @vquery, :exported)
-    @collector.stubs(:exported_resource).with(@resource).returns(@resource)
-    @compiler.stubs(:resources).returns([])
-
-    ActiveRecord::Base.stubs(:connected?).returns(false)
-
-    Puppet::Rails.stubs(:init)
-    Puppet::Rails::Host.stubs(:find_by_name).returns(nil)
-    Puppet::Rails::Resource.stubs(:find).returns([])
+      dir = Pathname(tmpdir('puppet-var'))
+      Puppet[:vardir]       = dir.to_s
+      Puppet[:dbadapter]    = 'sqlite3'
+      Puppet[:dblocation]   = (dir + 'storeconfigs.sqlite').to_s
+      Puppet[:storeconfigs] = true
+      Puppet[:environment]  = "production"
+      Puppet::Rails.init
+    end
 
-    Puppet.settings.stubs(:value).with(:storeconfigs).returns true
-  end
+    after :each do
+      ActiveRecord::Base.remove_connection
+    end
 
-  it "should exclude all resources from the host if ActiveRecord contains information for this host" do
-    @host = mock 'host'
-    @host.stubs(:id).returns 5
+    it "should return all matching resources from the current compile and mark them non-virtual and non-exported" do
+      one = Puppet::Parser::Resource.new('notify', 'one',
+                                         :virtual  => true,
+                                         :exported => true,
+                                         :scope    => @scope)
+      two = Puppet::Parser::Resource.new('notify', 'two',
+                                         :virtual  => true,
+                                         :exported => true,
+                                         :scope    => @scope)
+
+      @compiler.resources << one
+      @compiler.resources << two
+
+      @collector.evaluate.should == [one, two]
+      one.should_not be_virtual
+      two.should_not be_virtual
+
+      # REVISIT: Apparently we never actually marked local resources as
+      # non-exported.  So, this is what the previous test asserted, and checking
+      # what it claims to do causes test failures. --daniel 2011-08-23
+    end
 
-    Puppet::Rails::Host.expects(:find_by_name).with(@scope.host).returns(@host)
+    it "should mark all returned resources as not virtual" do
+      one = Puppet::Parser::Resource.new('notify', 'one',
+                                         :virtual  => true,
+                                         :exported => true,
+                                         :scope    => @scope)
 
-    Puppet::Rails::Resource.stubs(:find).with { |*arguments|
-      options = arguments[1]
-      options[:conditions][0] =~ /^host_id != \?/ and options[:conditions][1] == 5
-    }.returns([@resource])
+      @compiler.resources << one
 
-    @collector.evaluate.should == [@resource]
-  end
+      @collector.evaluate.should == [one]
+      one.should_not be_virtual
+    end
 
-  it "should join with parameter names, parameter values when querying ActiveRecord" do
-    @collector.equery = "param_names.name = title"
-    Puppet::Rails::Resource.stubs(:find).with { |*arguments|
-      options = arguments[1]
-      options[:joins] == {:param_values => :param_name}
-    }.returns([@resource])
+    it "should convert all found resources into parser resources" do
+      host = Puppet::Rails::Host.create!(:name => 'one.local')
+      Puppet::Rails::Resource.
+        create!(:host     => host,
+                :restype  => 'notify', :title => 'whammo',
+                :exported => true)
+
+      result = @collector.evaluate
+      result.length.should == 1
+      result.first.should be_an_instance_of Puppet::Parser::Resource
+      result.first.type.should == 'Notify'
+      result.first.title.should == 'whammo'
+    end
 
-    @collector.evaluate.should == [@resource]
-  end
+    it "should override all exported collected resources if collector has an override" do
+      host = Puppet::Rails::Host.create!(:name => 'one.local')
+      Puppet::Rails::Resource.
+        create!(:host     => host,
+                :restype  => 'notify', :title => 'whammo',
+                :exported => true)
 
-  it "should join with tag tables when querying ActiveRecord with a tag exported query" do
-    @collector.equery = "puppet_tags.name = test"
-    Puppet::Rails::Resource.stubs(:find).with { |*arguments|
-      options = arguments[1]
-      options[:joins] == {:resource_tags => :puppet_tag}
-    }.returns([@resource])
+      param = Puppet::Parser::Resource::Param.
+        new(:name => 'message', :value => 'howdy')
+      @collector.add_override(:parameters => [param], :scope => @scope)
 
-    @collector.evaluate.should == [@resource]
-  end
+      got = @collector.evaluate
+      got.first[:message].should == param.value
+    end
 
-  it "should not join parameters when querying ActiveRecord with a tag exported query" do
-    @collector.equery = "puppet_tags.name = test"
-    Puppet::Rails::Resource.stubs(:find).with { |*arguments|
-      options = arguments[1]
-      options[:joins] == {:param_values => :param_name}
-    }.returns([@resource])
+    it "should store converted resources in the compile's resource list" do
+      host = Puppet::Rails::Host.create!(:name => 'one.local')
+      Puppet::Rails::Resource.
+        create!(:host     => host,
+                :restype  => 'notify', :title => 'whammo',
+                :exported => true)
+
+      @compiler.expects(:add_resource).with do |scope, resource|
+        scope.should be_an_instance_of Puppet::Parser::Scope
+        resource.type.should  == 'Notify'
+        resource.title.should == 'whammo'
+        true
+      end
+
+      @collector.evaluate
+    end
 
-    @collector.evaluate.should be_false
-  end
+    # This way one host doesn't store another host's resources as exported.
+    it "should mark resources collected from the database as not exported" do
+      host = Puppet::Rails::Host.create!(:name => 'one.local')
+      Puppet::Rails::Resource.
+        create!(:host     => host,
+                :restype  => 'notify', :title => 'whammo',
+                :exported => true)
+
+      got = @collector.evaluate
+      got.length.should == 1
+      got.first.type.should == "Notify"
+      got.first.title.should == "whammo"
+      got.first.should_not be_exported
+    end
 
-  it "should only search for exported resources with the matching type" do
-    Puppet::Rails::Resource.stubs(:find).with { |*arguments|
-      options = arguments[1]
-      options[:conditions][0].include?("(exported=? AND restype=?)") and options[:conditions][1] == true and options[:conditions][2] == "Mytype"
-    }.returns([@resource])
+    it "should fail if an equivalent resource already exists in the compile" do
+      host = Puppet::Rails::Host.create!(:name => 'one.local')
+      Puppet::Rails::Resource.
+        create!(:host     => host,
+                :restype  => 'notify', :title => 'whammo',
+                :exported => true)
 
-    @collector.evaluate.should == [@resource]
-  end
+      local = Puppet::Parser::Resource.new('notify', 'whammo', :scope => @scope)
+      @compiler.add_resource(@scope, local)
 
-  it "should include the export query if one is provided" do
-    @collector.equery = "test = true"
-    Puppet::Rails::Resource.stubs(:find).with { |*arguments|
-      options = arguments[1]
-      options[:conditions][0].include?("test = true")
-    }.returns([@resource])
+      expect { @collector.evaluate }.
+        to raise_error Puppet::ParseError, /cannot override local resource/
+    end
 
-    @collector.evaluate.should == [@resource]
+    it "should ignore exported resources that match already-collected resources" do
+      host = Puppet::Rails::Host.create!(:name => 'one.local')
+      # One that we already collected...
+      db = Puppet::Rails::Resource.
+        create!(:host     => host,
+                :restype  => 'notify', :title => 'whammo',
+                :exported => true)
+      # ...and one we didn't.
+      Puppet::Rails::Resource.
+        create!(:host     => host,
+                :restype  => 'notify', :title => 'boingy-boingy',
+                :exported => true)
+
+      local = Puppet::Parser::Resource.new('notify', 'whammo',
+                                           :scope        => @scope,
+                                           :collector_id => db.id)
+      @compiler.add_resource(@scope, local)
+
+      got = nil
+      expect { got = @collector.evaluate }.not_to raise_error(Puppet::ParseError)
+      got.length.should == 1
+      got.first.type.should == "Notify"
+      got.first.title.should == "boingy-boingy"
+    end
   end
 end