puppet 5.0.0 → 6.0.0

data/spec/unit/network/resolver_spec.rb

@@ -14,14 +14,21 @@ describe Puppet::Network::Resolver do
 
     # The records we should use.
     @test_records = [
-      #                                  priority,  weight, port, hostname
+      #                                  priority,  weight, port, target
       Resolv::DNS::Resource::IN::SRV.new(0,         20,     8140, "puppet1.domain.com"),
       Resolv::DNS::Resource::IN::SRV.new(0,         80,     8140, "puppet2.domain.com"),
       Resolv::DNS::Resource::IN::SRV.new(1,         1,      8140, "puppet3.domain.com"),
       Resolv::DNS::Resource::IN::SRV.new(4,         1,      8140, "puppet4.domain.com")
     ]
+
+    @test_records.each do |rec|
+      # Resources do not expose public API for setting the TTL
+      rec.instance_variable_set(:@ttl, 3600)
+    end
   end
 
+  let(:resolver) { Puppet::Network::Resolver.new }
+
   describe 'when the domain is not known' do
     before :each do
       @dns_mock_object.stubs(:getresources).returns(@test_records)
@@ -29,7 +36,7 @@ describe Puppet::Network::Resolver do
 
     describe 'because domain is nil' do
       it 'does not yield' do
-        Puppet::Network::Resolver.each_srv_record(nil) do |_,_,_|
+        resolver.each_srv_record(nil) do |_,_,_|
           raise Exception.new("nil domain caused SRV lookup")
         end
       end
@@ -37,7 +44,7 @@ describe Puppet::Network::Resolver do
 
     describe 'because domain is an empty string' do
       it 'does not yield' do
-        Puppet::Network::Resolver.each_srv_record('') do |_,_,_|
+        resolver.each_srv_record('') do |_,_,_|
           raise Exception.new("nil domain caused SRV lookup")
         end
       end
@@ -45,6 +52,7 @@ describe Puppet::Network::Resolver do
   end
 
   describe "when resolving a host without SRV records" do
+
     it "should not yield anything" do
       # No records returned for a DNS entry without any SRV records
       @dns_mock_object.expects(:getresources).with(
@@ -52,7 +60,7 @@ describe Puppet::Network::Resolver do
         @rr_type
       ).returns([])
 
-      Puppet::Network::Resolver.each_srv_record(@test_a_hostname) do |hostname, port, remaining|
+      resolver.each_srv_record(@test_a_hostname) do |hostname, port, remaining|
         raise Exception.new("host with no records passed block")
       end
     end
@@ -73,7 +81,7 @@ describe Puppet::Network::Resolver do
         @rr_type
       ).returns(@test_records)
 
-      Puppet::Network::Resolver.each_srv_record(@test_srv_domain) do |hostname, port|
+      resolver.each_srv_record(@test_srv_domain) do |hostname, port|
         expected_priority = order.keys.min
 
         expect(order[expected_priority]).to include(hostname)
@@ -106,7 +114,7 @@ describe Puppet::Network::Resolver do
         @rr_type
       ).returns(@test_records)
 
-      Puppet::Network::Resolver.each_srv_record(@test_srv_domain, :report) do |hostname, port|
+      resolver.each_srv_record(@test_srv_domain, :report) do |hostname, port|
         expected_priority = order.keys.min
 
         expect(order[expected_priority]).to include(hostname)
@@ -147,7 +155,7 @@ describe Puppet::Network::Resolver do
         @rr_type
       ).returns(bad_records)
 
-      Puppet::Network::Resolver.each_srv_record(@test_srv_domain, :report) do |hostname, port|
+      resolver.each_srv_record(@test_srv_domain, :report) do |hostname, port|
         expected_priority = order.keys.min
 
         expect(order[expected_priority]).to include(hostname)
@@ -164,11 +172,11 @@ describe Puppet::Network::Resolver do
 
   describe "when finding weighted servers" do
     it "should return nil when no records were found" do
-      expect(Puppet::Network::Resolver.find_weighted_server([])).to eq(nil)
+      expect(resolver.find_weighted_server([])).to eq(nil)
     end
 
     it "should return the first record when one record is passed" do
-      result = Puppet::Network::Resolver.find_weighted_server([@test_records.first])
+      result = resolver.find_weighted_server([@test_records.first])
       expect(result).to eq(@test_records.first)
     end
 
@@ -188,18 +196,85 @@ describe Puppet::Network::Resolver do
 
         seen  = Hash.new(0)
         total_weight = records.inject(0) do |sum, record|
-          sum + Puppet::Network::Resolver.weight(record)
+          sum + resolver.weight(record)
         end
 
         total_weight.times do |n|
           Kernel.expects(:rand).once.with(total_weight).returns(n)
-          server = Puppet::Network::Resolver.find_weighted_server(records)
+          server = resolver.find_weighted_server(records)
           seen[server] += 1
         end
 
         expect(seen.length).to eq(records.length)
         records.each do |record|
-          expect(seen[record]).to eq(Puppet::Network::Resolver.weight(record))
+          expect(seen[record]).to eq(resolver.weight(record))
+        end
+      end
+    end
+  end
+
+  describe "caching records" do
+    it "should query DNS when no cache entry exists, then retrieve the cached value" do
+      @dns_mock_object.expects(:getresources).with(
+        "_x-puppet._tcp.#{@test_srv_domain}",
+        @rr_type
+      ).returns(@test_records).once
+
+      fetched_servers = []
+      resolver.each_srv_record(@test_srv_domain) do |server, port|
+        fetched_servers << server
+      end
+
+      cached_servers = []
+      resolver.expects(:expired?).returns false
+      resolver.each_srv_record(@test_srv_domain) do |server, port|
+        cached_servers << server
+      end
+      expect(fetched_servers).to match_array(cached_servers)
+    end
+
+    context "TTLs" do
+      before(:each) do
+        # The TTL of an SRV record cannot be set via any public API
+        ttl_record1 = Resolv::DNS::Resource::IN::SRV.new(0, 20, 8140, "puppet1.domain.com")
+        ttl_record1.instance_variable_set(:@ttl, 10)
+        ttl_record2 = Resolv::DNS::Resource::IN::SRV.new(0, 20, 8140, "puppet2.domain.com")
+        ttl_record2.instance_variable_set(:@ttl, 20)
+        records = [ttl_record1, ttl_record2]
+
+        @dns_mock_object.expects(:getresources).with(
+          "_x-puppet._tcp.#{@test_srv_domain}",
+          @rr_type
+        ).returns(records)
+      end
+
+      it "should save the shortest TTL among records for a service" do
+        resolver.each_srv_record(@test_srv_domain) { |server, port| }
+        expect(resolver.ttl(:puppet)).to eq(10)
+      end
+
+      it "should fetch records again if the TTL has expired" do
+        # Fetch from DNS
+        resolver.each_srv_record(@test_srv_domain) do |server, port|
+          expect(server).to match(/puppet.*domain\.com/)
+        end
+
+        resolver.expects(:expired?).with(:puppet).returns false
+        # Load from cache
+        resolver.each_srv_record(@test_srv_domain) do |server, port|
+          expect(server).to match(/puppet.*domain\.com/)
+        end
+
+        new_record = Resolv::DNS::Resource::IN::SRV.new(0, 20, 8140, "new.domain.com")
+        new_record.instance_variable_set(:@ttl, 10)
+        @dns_mock_object.expects(:getresources).with(
+          "_x-puppet._tcp.#{@test_srv_domain}",
+          @rr_type
+        ).returns([new_record])
+        resolver.expects(:expired?).with(:puppet).returns true
+        # Refresh from DNS
+        resolver.each_srv_record(@test_srv_domain) do |server, port|
+          expect(server).to eq("new.domain.com")
         end
       end
     end

data/spec/unit/node/environment_spec.rb

@@ -353,7 +353,7 @@ describe Puppet::Node::Environment do
           end
 
           it "does not find modules with same name by the wrong author" do
-            mod = PuppetSpec::Modules.create(
+            PuppetSpec::Modules.create(
               'baz',
               first_modulepath,
               :metadata => {:author => 'sneakylabs'},
@@ -430,12 +430,13 @@ describe Puppet::Node::Environment do
     describe "when performing initial import" do
       let(:loaders) { Puppet::Pops::Loaders.new(env) }
 
-      around :each do |example|
+      before(:each) do
         Puppet::Parser::Compiler.any_instance.stubs(:loaders).returns(loaders)
-        Puppet.override(:loaders => loaders, :current_environment => env) do
-          example.run
-          Puppet::Pops::Loaders.clear
-        end
+        Puppet.push_context({:loaders => loaders, :current_environment => env})
+      end
+
+      after(:each) do
+        Puppet.pop_context()
       end
 
       it "loads from Puppet[:code]" do
@@ -492,4 +493,35 @@ describe Puppet::Node::Environment do
     end
   end
 
+  describe "managing module translations" do
+    it "creates a new text domain the first time we try to use the text domain" do
+      Puppet::GettextConfig.expects(:reset_text_domain).with(env.name)
+      Puppet::ModuleTranslations.expects(:load_from_modulepath)
+      Puppet::GettextConfig.expects(:clear_text_domain)
+
+      env.with_text_domain do; end
+    end
+
+    it "uses the existing text domain once it has been created" do
+      env.with_text_domain do; end
+
+      Puppet::GettextConfig.expects(:use_text_domain).with(env.name)
+      env.with_text_domain do; end
+    end
+
+    it "yields block results" do
+      ran = false
+      expect(env.with_text_domain { ran = true; :result }).to eq(:result)
+      expect(ran).to eq(true)
+    end
+
+    it "yields block results when i18n is disabled" do
+      Puppet[:disable_i18n] = true
+
+      ran = false
+      expect(env.with_text_domain { ran = true; :result }).to eq(:result)
+      expect(ran).to eq(true)
+    end
+  end
+
 end

data/spec/unit/node/facts_spec.rb

@@ -81,6 +81,18 @@ describe Puppet::Node::Facts, "when indirecting" do
       @facts.sanitize
       expect(@facts.values["test"]).to eq({"(?-mix:foo)" => ["bar", "(?-mix:baz)"]})
     end
+
+    it "should handle alien values having a to_s that returns ascii-8bit" do
+      class Alien
+      end
+      an_alien = Alien.new
+      @facts.values["test"] = an_alien
+      @facts.sanitize
+      fact_value = @facts.values['test']
+      expect(fact_value).to eq(an_alien.to_s)
+      expect(fact_value.encoding).to eq(Encoding::UTF_8)
+    end
+
   end
 
   describe "when indirecting" do
@@ -129,8 +141,9 @@ describe Puppet::Node::Facts, "when indirecting" do
       end
 
       def deserialize_yaml_facts(facts)
+        facts.sanitize
         format = Puppet::Network::FormatHandler.format('yaml')
-        format.intern(Puppet::Node::Facts, facts.to_yaml)
+        format.intern(Puppet::Node::Facts, YAML.dump(facts.to_data_hash))
       end
 
       it 'preserves `_timestamp` value' do

data/spec/unit/node_spec.rb

@@ -1,9 +1,11 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 require 'matchers/json'
+require 'puppet_spec/files'
 
 describe Puppet::Node do
   include JSONMatchers
+  include PuppetSpec::Files
 
   let(:environment) { Puppet::Node::Environment.create(:bar, []) }
   let(:env_loader) { Puppet::Environments::Static.new(environment) }
@@ -56,7 +58,7 @@ describe Puppet::Node do
     end
 
     it "can round-trip through json" do
-      facts = Puppet::Node::Facts.new("hello", "one" => "c", "two" => "b")
+      Puppet::Node::Facts.new("hello", "one" => "c", "two" => "b")
       node = Puppet::Node.new("hello",
                               :environment => 'bar',
                               :classes => ['erth', 'aiu'],
@@ -69,8 +71,8 @@ describe Puppet::Node do
       expect(new_node.name).to eq(node.name)
     end
 
-    it "validates against the node json schema", :unless => Puppet.features.microsoft_windows? do
-      facts = Puppet::Node::Facts.new("hello", "one" => "c", "two" => "b")
+    it "validates against the node json schema" do
+      Puppet::Node::Facts.new("hello", "one" => "c", "two" => "b")
       node = Puppet::Node.new("hello",
                               :environment => 'bar',
                               :classes => ['erth', 'aiu'],
@@ -79,8 +81,8 @@ describe Puppet::Node do
       expect(node.to_json).to validate_against('api/schemas/node.json')
     end
 
-    it "when missing optional parameters validates against the node json schema", :unless => Puppet.features.microsoft_windows? do
-      facts = Puppet::Node::Facts.new("hello", "one" => "c", "two" => "b")
+    it "when missing optional parameters validates against the node json schema" do
+      Puppet::Node::Facts.new("hello", "one" => "c", "two" => "b")
       node = Puppet::Node.new("hello",
                               :environment => 'bar'
                              )
@@ -111,19 +113,23 @@ describe Puppet::Node do
     end
 
     it "a node can roundtrip" do
-      expect(YAML.load(@node.to_yaml).name).to eql("mynode")
+      expect(Puppet::Util::Yaml.safe_load(@node.to_yaml, [Puppet::Node]).name).to eql("mynode")
     end
 
     it "limits the serialization of environment to be just the name" do
-      # it is something like 138 when serializing everything in a default environment
-      expect(@node.to_yaml.size).to be < 70
+      yaml_file = file_containing("temp_yaml", @node.to_yaml)
+      expect(File.read(yaml_file)).to eq(<<~NODE)
+        --- !ruby/object:Puppet::Node
+        name: mynode
+        environment: production
+      NODE
     end
   end
 
   describe "when serializing using yaml and values classes and parameters are missing in deserialized hash" do
     it "a node can roundtrip" do
       @node = Puppet::Node.from_data_hash({'name' => "mynode"})
-      expect(YAML.load(@node.to_yaml).name).to eql("mynode")
+      expect(Puppet::Util::Yaml.safe_load(@node.to_yaml, [Puppet::Node]).name).to eql("mynode")
     end
 
     it "errors if name is nil" do
@@ -155,6 +161,13 @@ describe Puppet::Node do
       expect(@node).to set_json_attribute('parameters').to({"a" => "b", "c" => "d"})
     end
 
+    it "does not include the environment parameter in the json" do
+      @node.parameters = {"a" => "b", "c" => "d"}
+      @node.environment = environment
+      expect(@node.parameters).to eq({"a"=>"b", "c"=>"d", "environment"=>"bar"})
+      expect(@node).to set_json_attribute('parameters').to({"a" => "b", "c" => "d"})
+    end
+
     it "does not include the parameters if there are none" do
       expect(@node).to_not set_json_attribute('parameters')
     end
@@ -186,12 +199,23 @@ describe Puppet::Node do
 
     it "includes parameters if set" do
       @node.parameters = {"a" => "b", "c" => "d"}
-      expect(Puppet::Node).to read_json_attribute('parameters').from(@node.to_json).as({"a" => "b", "c" => "d"})
+      expect(Puppet::Node).to read_json_attribute('parameters').from(@node.to_json).as({"a" => "b", "c" => "d", "environment" => "production"})
     end
 
     it "deserializes environment to environment_name as a symbol" do
-      @node.environment = environment
-      expect(Puppet::Node).to read_json_attribute('environment_name').from(@node.to_json).as(:bar)
+      Puppet.override(:environments => env_loader) do
+        @node.environment = environment
+        expect(Puppet::Node).to read_json_attribute('environment_name').from(@node.to_json).as(:bar)
+      end
+    end
+
+    it "does not immediately populate the environment instance" do
+      node = described_class.from_data_hash("name" => "foo", "environment" => "production")
+
+      expect(node.environment_name).to eq(:production)
+      expect(node).not_to be_has_environment_instance
+      node.environment
+      expect(node).to be_has_environment_instance
     end
   end
 end
@@ -291,7 +315,10 @@ describe Puppet::Node, "when merging facts" do
 
   context "with an env loader" do
     let(:environment) { Puppet::Node::Environment.create(:one, []) }
-    let(:env_loader) { Puppet::Environments::Static.new(environment) }
+    let(:environment_two) { Puppet::Node::Environment.create(:two, []) }
+    let(:environment_three) { Puppet::Node::Environment.create(:three, []) }
+    let(:environment_prod) { Puppet::Node::Environment.create(:production, []) }
+    let(:env_loader) { Puppet::Environments::Static.new(environment, environment_two, environment_three, environment_prod) }
 
     around do |example|
       Puppet.override(:environments => env_loader) do
@@ -299,18 +326,89 @@ describe Puppet::Node, "when merging facts" do
       end
     end
 
-    it "adds the environment to the list of parameters" do
-      Puppet[:environment] = "one"
-      @node = Puppet::Node.new("testnode", :environment => "one")
-      @node.merge "two" => "three"
-      expect(@node.parameters["environment"]).to eq("one")
+    context "when a node is initialized from a data hash" do
+      context "when a node is initialzed with an environment" do
+        it "uses 'environment' when provided" do
+          my_node = Puppet::Node.from_data_hash("environment" => "one", "name" => "my_node")
+          expect(my_node.environment.name).to eq(:one)
+        end
+
+        it "uses the environment parameter when provided" do
+          my_node = Puppet::Node.from_data_hash("parameters" => {"environment" => "one"}, "name" => "my_node")
+          expect(my_node.environment.name).to eq(:one)
+        end
+
+        it "uses the environment when also given an environment parameter" do
+          my_node = Puppet::Node.from_data_hash("parameters" => {"environment" => "one"}, "name" => "my_node", "environment" => "two")
+          expect(my_node.environment.name).to eq(:two)
+        end
+
+        it "uses 'environment' when an environment fact has been merged" do
+          my_node = Puppet::Node.from_data_hash("environment" => "one", "name" => "my_node")
+          my_node.fact_merge Puppet::Node::Facts.new "my_node", "environment" => "two"
+          expect(my_node.environment.name).to eq(:one)
+        end
+
+        it "uses an environment parameter when an environment fact has been merged" do
+          my_node = Puppet::Node.from_data_hash("parameters" => {"environment" => "one"}, "name" => "my_node")
+          my_node.fact_merge Puppet::Node::Facts.new "my_node", "environment" => "two"
+          expect(my_node.environment.name).to eq(:one)
+        end
+
+        it "uses an environment when an environment parameter has been given and an environment fact has been merged" do
+          my_node = Puppet::Node.from_data_hash("parameters" => {"environment" => "two"}, "name" => "my_node", "environment" => "one")
+          my_node.fact_merge Puppet::Node::Facts.new "my_node", "environment" => "three"
+          expect(my_node.environment.name).to eq(:one)
+        end
+      end
+
+      context "when a node is initialized without an environment" do
+        it "should use the server's default environment" do
+          my_node = Puppet::Node.from_data_hash("name" => "my_node")
+          expect(my_node.environment.name).to eq(:production)
+        end
+
+        it "should use the server's default when an environment fact has been merged" do
+          my_node = Puppet::Node.from_data_hash("name" => "my_node")
+          my_node.fact_merge Puppet::Node::Facts.new "my_node", "environment" => "two"
+          expect(my_node.environment.name).to eq(:production)
+        end
+      end
     end
 
-    it "nots set the environment if it is already set in the parameters" do
-      Puppet[:environment] = "one"
-      @node = Puppet::Node.new("testnode", :environment => "one")
-      @node.merge "environment" => "two"
-      expect(@node.parameters["environment"]).to eq("two")
+    context "when a node is initialized from new" do
+
+      context "when a node is initialzed with an environment" do
+
+        it "adds the environment to the list of parameters" do
+          Puppet[:environment] = "one"
+          @node = Puppet::Node.new("testnode", :environment => "one")
+          @node.merge "two" => "three"
+          expect(@node.parameters["environment"]).to eq("one")
+        end
+
+        it "when merging, syncs the environment parameter to a node's existing environment" do
+          @node = Puppet::Node.new("testnode", :environment => "one")
+          @node.merge "environment" => "two"
+          expect(@node.parameters["environment"]).to eq("one")
+        end
+
+        it "merging facts does not override that environment" do
+          @node = Puppet::Node.new("testnode", :environment => "one")
+          @node.fact_merge Puppet::Node::Facts.new "testnode", "environment" => "two"
+          expect(@node.environment.name.to_s).to eq("one")
+        end
+      end
+
+      context "when a node is initialized without an environment" do
+
+        it "it perfers an environment name to an environment fact" do
+          @node = Puppet::Node.new("testnode")
+          @node.environment_name = "one"
+          @node.fact_merge Puppet::Node::Facts.new "testnode", "environment" => "two"
+          expect(@node.environment.name.to_s).to eq("one")
+        end
+      end
     end
   end
 end

data/spec/unit/other/selinux_spec.rb

@@ -1,9 +1,6 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 
-require 'puppet/type/selboolean'
-require 'puppet/type/selmodule'
-
 describe Puppet::Type.type(:file), " when manipulating file contexts" do
   include PuppetSpec::Files
 
@@ -29,71 +26,3 @@ describe Puppet::Type.type(:file), " when manipulating file contexts" do
     expect(@file[:seltype]).to eq("type_t")
   end
 end
-
-describe Puppet::Type.type(:selboolean), " when manipulating booleans" do
-  before :each do
-    provider_class = Puppet::Type::Selboolean.provider(Puppet::Type::Selboolean.providers[0])
-    Puppet::Type::Selboolean.stubs(:defaultprovider).returns provider_class
-
-    @bool = Puppet::Type::Selboolean.new(
-      :name => "foo",
-      :value => "on",
-      :persistent => true )
-  end
-
-  it "should be able to access :name" do
-    expect(@bool[:name]).to eq("foo")
-  end
-
-  it "should be able to access :value" do
-    expect(@bool.property(:value).should).to eq(:on)
-  end
-
-  it "should set :value to off" do
-    @bool[:value] = :off
-    expect(@bool.property(:value).should).to eq(:off)
-  end
-
-  it "should be able to access :persistent" do
-    expect(@bool[:persistent]).to eq(:true)
-  end
-
-  it "should set :persistent to false" do
-    @bool[:persistent] = false
-    expect(@bool[:persistent]).to eq(:false)
-  end
-end
-
-describe Puppet::Type.type(:selmodule), " when checking policy modules" do
-  before :each do
-    provider_class = Puppet::Type::Selmodule.provider(Puppet::Type::Selmodule.providers[0])
-    Puppet::Type::Selmodule.stubs(:defaultprovider).returns provider_class
-
-    @module = Puppet::Type::Selmodule.new(
-      :name => "foo",
-      :selmoduledir => "/some/path",
-      :selmodulepath => "/some/path/foo.pp",
-      :syncversion => true)
-  end
-
-  it "should be able to access :name" do
-    expect(@module[:name]).to eq("foo")
-  end
-
-  it "should be able to access :selmoduledir" do
-    expect(@module[:selmoduledir]).to eq("/some/path")
-  end
-
-  it "should be able to access :selmodulepath" do
-    expect(@module[:selmodulepath]).to eq("/some/path/foo.pp")
-  end
-
-  it "should be able to access :syncversion" do
-    expect(@module[:syncversion]).to eq(:true)
-  end
-
-  it "should set the syncversion value to false" do
-    @module[:syncversion] = :false
-    expect(@module[:syncversion]).to eq(:false)
-  end
-end

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

@@ -60,13 +60,12 @@ describe Puppet::Parser::AST::Regex do
     end
   end
 
-  it "should return the regex source with to_s" do
+  it 'should return the PRegexpType#regexp_to_s_with_delimiters with to_s' do
     regex = stub 'regex'
     Regexp.stubs(:new).returns(regex)
 
-    val = Puppet::Parser::AST::Regex.new :value => "/ab/"
-
-    regex.expects(:source)
+    val = Puppet::Parser::AST::Regex.new :value => '/ab/'
+    Puppet::Pops::Types::PRegexpType.expects(:regexp_to_s_with_delimiters)
 
     val.to_s
   end

data/spec/unit/parser/compiler_spec.rb

@@ -235,7 +235,6 @@ describe Puppet::Parser::Compiler do
     end
 
     it "should set the parent scope of the new scope to its topscope if the parent passed in is nil" do
-      scope = mock 'scope'
       newscope = @compiler.newscope(nil)
 
       expect(newscope.parent).to equal(@compiler.topscope)
@@ -279,6 +278,14 @@ describe Puppet::Parser::Compiler do
       expect(@compiler.topscope['wat']).to eq('this is how the sausage is made')
     end
 
+    it "sets the environment based on node.environment instead of the parameters" do
+      compile_stub(:set_node_parameters)
+      @node.parameters['environment'] = "Not actually #{@node.environment.name}"
+
+      @compiler.compile
+      expect(@compiler.topscope['environment']).to eq('testing')
+    end
+
     it "should set the client and server versions on the catalog" do
       params = {"clientversion" => "2", "serverversion" => "3"}
       @node.stubs(:parameters).returns(params)
@@ -725,7 +732,7 @@ describe Puppet::Parser::Compiler do
     end
 
     it "should ensure class is in catalog without params" do
-      @node.classes = klasses = {'foo'=>nil}
+      @node.classes = {'foo'=>nil}
       foo = Puppet::Resource::Type.new(:hostclass, 'foo')
       @compiler.environment.known_resource_types.add foo
       catalog = @compiler.compile