puppet 3.4.3 → 3.5.0.rc1

data/spec/unit/network/http/rack/rest_spec.rb

@@ -8,13 +8,6 @@ describe "Puppet::Network::HTTP::RackREST", :if => Puppet.features.rack? do
     Puppet::Network::HTTP::RackREST.ancestors.should be_include(Puppet::Network::HTTP::Handler)
   end
 
-  describe "when initializing" do
-    it "should call the Handler's initialization hook with its provided arguments" do
-      Puppet::Network::HTTP::RackREST.any_instance.expects(:initialize_for_puppet).with(:server => "my", :handler => "arguments")
-      Puppet::Network::HTTP::RackREST.new(:server => "my", :handler => "arguments")
-    end
-  end
-
   describe "when serving a request" do
     before :all do
       @model_class = stub('indirected model class')
@@ -31,25 +24,32 @@ describe "Puppet::Network::HTTP::RackREST", :if => Puppet.features.rack? do
       Rack::Request.new(env)
     end
 
+    let(:minimal_certificate) do
+        cert = OpenSSL::X509::Certificate.new
+        cert.version = 2
+        cert.serial = 0
+        cert.not_before = Time.now
+        cert.not_after = Time.now + 3600
+        cert.public_key = OpenSSL::PKey::RSA.new(512)
+        cert.subject = OpenSSL::X509::Name.parse("/CN=testing")
+        cert
+    end
+
     describe "#headers" do
       it "should return the headers (parsed from env with prefix 'HTTP_')" do
         req = mk_req('/', {'HTTP_Accept' => 'myaccept',
                            'HTTP_X_Custom_Header' => 'mycustom',
                            'NOT_HTTP_foo' => 'not an http header'})
         @handler.headers(req).should == {"accept" => 'myaccept',
-                                         "x-custom-header" => 'mycustom'}
+                                         "x-custom-header" => 'mycustom',
+                                         "content-type" => nil }
       end
     end
 
     describe "and using the HTTP Handler interface" do
-      it "should return the HTTP_ACCEPT parameter as the accept header" do
-        req = mk_req('/', 'HTTP_ACCEPT' => 'myaccept')
-        @handler.accept_header(req).should == "myaccept"
-      end
-
       it "should return the CONTENT_TYPE parameter as the content type header" do
         req = mk_req('/', 'CONTENT_TYPE' => 'mycontent')
-        @handler.content_type_header(req).should == "mycontent"
+        @handler.headers(req)['content-type'].should == "mycontent"
       end
 
       it "should use the REQUEST_METHOD as the http method" do
@@ -67,24 +67,15 @@ describe "Puppet::Network::HTTP::RackREST", :if => Puppet.features.rack? do
         @handler.body(req).should == "mybody"
       end
 
-      it "should return the an OpenSSL::X509::Certificate instance as the client_cert" do
-        cert = stub 'cert'
-        req = mk_req('/foo/bar', 'SSL_CLIENT_CERT' => 'certificate in pem format')
-        OpenSSL::X509::Certificate.expects(:new).with('certificate in pem format').returns(cert)
-        @handler.client_cert(req).should == cert
+      it "should return the an Puppet::SSL::Certificate instance as the client_cert" do
+        req = mk_req('/foo/bar', 'SSL_CLIENT_CERT' => minimal_certificate.to_pem)
+        expect(@handler.client_cert(req).content.to_pem).to eq(minimal_certificate.to_pem)
       end
 
       it "returns nil when SSL_CLIENT_CERT is empty" do
-        cert = stub 'cert'
         req = mk_req('/foo/bar', 'SSL_CLIENT_CERT' => '')
-        OpenSSL::X509::Certificate.expects(:new).never
-        @handler.client_cert(req).should be_nil
-      end
 
-      it "(#16769) does not raise error 'header too long'" do
-        cert = stub 'cert'
-        req = mk_req('/foo/bar', 'SSL_CLIENT_CERT' => '')
-        lambda { @handler.client_cert(req) }.should_not raise_error
+        @handler.client_cert(req).should be_nil
       end
 
       it "should set the response's content-type header when setting the content type" do
@@ -134,7 +125,8 @@ describe "Puppet::Network::HTTP::RackREST", :if => Puppet.features.rack? do
       it "should ensure the body has been partially read on failure" do
         req = mk_req('/production/report/foo')
         req.body.expects(:read).with(1)
-        req.stubs(:check_authorization).raises(Exception)
+
+        @handler.stubs(:headers).raises(Exception)
 
         @handler.process(req, @response)
       end

data/spec/unit/network/http/route_spec.rb

@@ -0,0 +1,75 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet/indirector_testing'
+
+require 'puppet/network/http'
+
+describe Puppet::Network::HTTP::Route do
+  def request(method, path)
+    Puppet::Network::HTTP::Request.from_hash({
+      :method => method,
+      :path => path,
+      :routing_path => path })
+  end
+
+  def respond(text)
+    lambda { |req, res| res.respond_with(200, "text/plain", text) }
+  end
+
+  let(:req) { request("GET", "/vtest/foo") }
+  let(:res) { Puppet::Network::HTTP::MemoryResponse.new }
+
+  describe "an HTTP Route" do
+    it "can match a request" do
+      route = Puppet::Network::HTTP::Route.path(%r{^/vtest})
+      expect(route.matches?(req)).to be_true
+    end
+
+    it "will raise a Method Not Allowed error when no handler for the request's method is given" do
+      route = Puppet::Network::HTTP::Route.path(%r{^/vtest}).post(respond("ignored"))
+      expect do
+        route.process(req, res)
+      end.to raise_error(Puppet::Network::HTTP::Error::HTTPMethodNotAllowedError)
+    end
+
+    it "can match any HTTP method" do
+      route = Puppet::Network::HTTP::Route.path(%r{^/vtest/foo}).any(respond("used"))
+      expect(route.matches?(req)).to be_true
+
+      route.process(req, res)
+
+      expect(res.body).to eq("used")
+    end
+
+    it "calls the method handlers in turn" do
+      call_count = 0
+      handler = lambda { |request, response| call_count += 1 }
+      route = Puppet::Network::HTTP::Route.path(%r{^/vtest/foo}).get(handler, handler)
+
+      route.process(req, res)
+      expect(call_count).to eq(2)
+    end
+
+    it "stops calling handlers if one of them raises an error" do
+      ignored_called = false
+      ignored = lambda { |req, res| ignored_called = true }
+      raise_error = lambda { |req, res| raise Puppet::Network::HTTP::Error::HTTPNotAuthorizedError, "go away" }
+      route = Puppet::Network::HTTP::Route.path(%r{^/vtest/foo}).get(raise_error, ignored)
+
+      expect do
+        route.process(req, res)
+      end.to raise_error(Puppet::Network::HTTP::Error::HTTPNotAuthorizedError)
+      expect(ignored_called).to be_false
+    end
+
+    it "chains to other routes after calling its handlers" do
+      inner_route = Puppet::Network::HTTP::Route.path(%r{^/inner}).any(respond("inner"))
+      unused_inner_route = Puppet::Network::HTTP::Route.path(%r{^/unused_inner}).any(respond("unused"))
+
+      top_route = Puppet::Network::HTTP::Route.path(%r{^/vtest}).any(respond("top")).chain(unused_inner_route, inner_route)
+      top_route.process(request("GET", "/vtest/inner"), res)
+
+      expect(res.body).to eq("topinner")
+    end
+  end
+end

data/spec/unit/network/http/webrick/rest_spec.rb

@@ -9,31 +9,14 @@ describe Puppet::Network::HTTP::WEBrickREST do
     Puppet::Network::HTTP::WEBrickREST.ancestors.should be_include(Puppet::Network::HTTP::Handler)
   end
 
-  describe "when initializing" do
-    it "should call the Handler's initialization hook with its provided arguments as the server and handler" do
-      server = WEBrick::HTTPServer.new(:BindAddress => '127.0.0.1',
-                                       # Probablistically going to succeed
-                                       # even if we run more than one test
-                                       # instance at once.
-                                       :Port        => 40000 + rand(10000),
-                                       # Just discard any log output, thanks.
-                                       :Logger      => stub_everything('logger'))
-
-      Puppet::Network::HTTP::WEBrickREST.any_instance.
-        expects(:initialize_for_puppet).with(:server => server, :handler => "arguments")
-
-      Puppet::Network::HTTP::WEBrickREST.new(server, "arguments")
-    end
-  end
-
   describe "when receiving a request" do
     before do
       @request     = stub('webrick http request', :query => {}, :peeraddr => %w{eh boo host ip}, :client_cert => nil)
-      @response    = stub('webrick http response', :status= => true, :body= => true)
+      @response    = mock('webrick http response')
       @model_class = stub('indirected model class')
       @webrick     = stub('webrick http server', :mount => true, :[] => {})
       Puppet::Indirector::Indirection.stubs(:model).with(:foo).returns(@model_class)
-      @handler = Puppet::Network::HTTP::WEBrickREST.new(@webrick, :foo)
+      @handler = Puppet::Network::HTTP::WEBrickREST.new(@webrick)
     end
 
     it "should delegate its :service method to its :process method" do
@@ -56,16 +39,6 @@ describe Puppet::Network::HTTP::WEBrickREST do
     end
 
     describe "when using the Handler interface" do
-      it "should use the 'accept' request parameter as the Accept header" do
-        @request.expects(:[]).with("accept").returns "foobar"
-        @handler.accept_header(@request).should == "foobar"
-      end
-
-      it "should use the 'content-type' request header as the Content-Type header" do
-        @request.expects(:[]).with("content-type").returns "foobar"
-        @handler.content_type_header(@request).should == "foobar"
-      end
-
       it "should use the request method as the http method" do
         @request.expects(:request_method).returns "FOO"
         @handler.http_method(@request).should == "FOO"
@@ -93,32 +66,21 @@ describe Puppet::Network::HTTP::WEBrickREST do
         @handler.set_response(@response, "mybody", 200)
       end
 
-      describe "when the result is a File" do
-        before(:each) do
-          stat = stub 'stat', :size => 100
-          @file = stub 'file', :stat => stat, :path => "/tmp/path"
-          @file.stubs(:is_a?).with(File).returns(true)
-        end
-
-        it "should serve it" do
-          @response.stubs(:[]=)
-
-          @response.expects(:status=).with 200
-          @response.expects(:body=).with @file
+      it "serves a file" do
+        stat = stub 'stat', :size => 100
+        @file = stub 'file', :stat => stat, :path => "/tmp/path"
+        @file.stubs(:is_a?).with(File).returns(true)
 
-          @handler.set_response(@response, @file, 200)
-        end
-
-        it "should set the Content-Length header" do
-          @response.expects(:[]=).with('content-length', 100)
+        @response.expects(:[]=).with('content-length', 100)
+        @response.expects(:status=).with 200
+        @response.expects(:body=).with @file
 
-          @handler.set_response(@response, @file, 200)
-        end
+        @handler.set_response(@response, @file, 200)
       end
 
       it "should set the status and message on the response when setting the response for a failed query" do
         @response.expects(:status=).with 400
-        @response.expects(:reason_phrase=).with "mybody"
+        @response.expects(:body=).with "mybody"
 
         @handler.set_response(@response, "mybody", 400)
       end
@@ -135,6 +97,12 @@ describe Puppet::Network::HTTP::WEBrickREST do
         @request
       end
 
+      def certificate_with_subject(subj)
+        cert = OpenSSL::X509::Certificate.new
+        cert.subject = OpenSSL::X509::Name.parse(subj)
+        cert
+      end
+
       it "has no parameters when there is no query string" do
         only_server_side_information = [:authenticated, :ip, :node]
         @request.stubs(:query).returns(nil)
@@ -238,10 +206,8 @@ describe Puppet::Network::HTTP::WEBrickREST do
       end
 
       it "should pass the client's certificate name to model method if a certificate is present" do
-        subj = stub 'subj'
-        cert = stub 'cert', :subject => subj
-        @request.stubs(:client_cert).returns cert
-        Puppet::Util::SSL.expects(:cn_from_subject).with(subj).returns 'host.domain.com'
+        @request.stubs(:client_cert).returns(certificate_with_subject("/CN=host.domain.com"))
+
         @handler.params(@request)[:node].should == "host.domain.com"
       end
 
@@ -254,15 +220,12 @@ describe Puppet::Network::HTTP::WEBrickREST do
       end
 
       it "should resolve the node name with an ip address look-up if CN parsing fails" do
-        subj = stub 'subj'
-        cert = stub 'cert', :subject => subj
-        @request.stubs(:client_cert).returns cert
-        Puppet::Util::SSL.expects(:cn_from_subject).with(subj).returns nil
+        @request.stubs(:client_cert).returns(certificate_with_subject("/C=company"))
 
         @handler.expects(:resolve_node).returns(:resolved_node)
 
         @handler.params(@request)[:node].should == :resolved_node
       end
-   end
+    end
   end
 end

data/spec/unit/network/http_pool_spec.rb

@@ -32,12 +32,12 @@ describe Puppet::Network::HttpPool do
         ca_cert_file = File.expand_path('/path/to/ssl/certs/ca_cert.pem')
 
         Puppet[:ssl_client_ca_auth] = ca_cert_file
-        Puppet::FileSystem::File.stubs(:exist?).with(ca_cert_file).returns(true)
+        Puppet::FileSystem.stubs(:exist?).with(ca_cert_file).returns(true)
       end
 
       def setup_standard_hostcert
         host_cert_file = File.expand_path('/path/to/ssl/certs/host_cert.pem')
-        Puppet::FileSystem::File.stubs(:exist?).with(host_cert_file).returns(true)
+        Puppet::FileSystem.stubs(:exist?).with(host_cert_file).returns(true)
 
         Puppet[:hostcert] = host_cert_file
       end
@@ -67,7 +67,7 @@ describe Puppet::Network::HttpPool do
 
     it "should not cache http instances" do
       Puppet::Network::HttpPool.http_instance("me", 54321).
-        should_not equal Puppet::Network::HttpPool.http_instance("me", 54321)
+        should_not equal(Puppet::Network::HttpPool.http_instance("me", 54321))
     end
   end
 

data/spec/unit/network/rights_spec.rb

@@ -16,13 +16,13 @@ describe Puppet::Network::Rights do
         right.allow("*")
         right.restrict_method(allowed_method)
         right.restrict_authenticated(:any)
-        rights.is_request_forbidden_and_why?(:indirection_name, :head, "key", {}).should == nil
+        rights.is_request_forbidden_and_why?(:head, "/indirection_name/key", {}).should == nil
       end
     end
 
     it "should disallow the request if neither :find nor :save is allowed" do
       rights = Puppet::Network::Rights.new
-      why_forbidden = rights.is_request_forbidden_and_why?(:indirection_name, :head, "key", {})
+      why_forbidden = rights.is_request_forbidden_and_why?(:head, "/indirection_name/key", {})
       why_forbidden.should be_instance_of(Puppet::Network::AuthorizationError)
       why_forbidden.to_s.should == "Forbidden request:  access to /indirection_name/key [find]"
     end

data/spec/unit/node/environment_spec.rb

@@ -17,10 +17,6 @@ describe Puppet::Node::Environment do
   end
 
   shared_examples_for 'the environment' do
-    it "should use the filetimeout for the ttl for the modulepath" do
-      Puppet::Node::Environment.attr_ttl(:modulepath).should == Integer(Puppet[:filetimeout])
-    end
-
     it "should use the filetimeout for the ttl for the module list" do
       Puppet::Node::Environment.attr_ttl(:modules).should == Integer(Puppet[:filetimeout])
     end
@@ -47,6 +43,43 @@ describe Puppet::Node::Environment do
       Puppet::Node::Environment.new(one).should equal(one)
     end
 
+    describe "overriding an existing environment" do
+      let(:original_path) { [tmpdir('original')] }
+      let(:new_path) { [tmpdir('new')] }
+      let(:environment) { Puppet::Node::Environment.create(:overridden, original_path, 'orig.pp') }
+
+      it "overrides modulepath" do
+        overridden = environment.override_with(:modulepath => new_path)
+        expect(overridden).to_not be_equal(environment)
+        expect(overridden.name).to eq(:overridden)
+        expect(overridden.manifest).to eq(File.expand_path('orig.pp'))
+        expect(overridden.modulepath).to eq(new_path)
+      end
+
+      it "overrides manifest" do
+        overridden = environment.override_with(:manifest => 'new.pp')
+        expect(overridden).to_not be_equal(environment)
+        expect(overridden.name).to eq(:overridden)
+        expect(overridden.manifest).to eq(File.expand_path('new.pp'))
+        expect(overridden.modulepath).to eq(original_path)
+      end
+    end
+
+    describe "watching a file" do
+      let(:filename) { "filename" }
+
+      it "accepts a File" do
+        file = tmpfile(filename)
+        env.known_resource_types.expects(:watch_file).with(file.to_s)
+        env.watch_file(file)
+      end
+
+      it "accepts a String" do
+        env.known_resource_types.expects(:watch_file).with(filename)
+        env.watch_file(filename)
+      end
+    end
+
     describe "when managing known resource types" do
       before do
         @collection = Puppet::Resource::TypeCollection.new(env)
@@ -96,35 +129,14 @@ describe Puppet::Node::Environment do
     end
 
     it "should prefix the value of the 'PUPPETLIB' environment variable to the module path if present" do
-      Puppet::Util.withenv("PUPPETLIB" => %w{/l1 /l2}.join(File::PATH_SEPARATOR)) do
-        module_path = %w{/one /two}.join(File::PATH_SEPARATOR)
-        env.expects(:validate_dirs).with(%w{/l1 /l2 /one /two}).returns %w{/l1 /l2 /one /two}
-        env.expects(:[]).with(:modulepath).returns module_path
-
-        env.modulepath.should == %w{/l1 /l2 /one /two}
-      end
-    end
-
-    describe "when validating modulepath or manifestdir directories" do
-      before :each do
-        @path_one = tmpdir("path_one")
-        @path_two = tmpdir("path_one")
-        sep = File::PATH_SEPARATOR
-        Puppet[:modulepath] = "#{@path_one}#{sep}#{@path_two}"
-      end
-
-      it "should not return non-directories" do
-        FileTest.expects(:directory?).with(@path_one).returns true
-        FileTest.expects(:directory?).with(@path_two).returns false
-
-        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
-        two = File.expand_path("two")
-
-        env.validate_dirs([@path_one, 'two']).should == [@path_one, two]
+      first_puppetlib = tmpdir('puppetlib1')
+      second_puppetlib = tmpdir('puppetlib2')
+      first_moduledir = tmpdir('moduledir1')
+      second_moduledir = tmpdir('moduledir2')
+      Puppet::Util.withenv("PUPPETLIB" => [first_puppetlib, second_puppetlib].join(File::PATH_SEPARATOR)) do
+        Puppet[:modulepath] = [first_moduledir, second_moduledir].join(File::PATH_SEPARATOR)
+
+        env.modulepath.should == [first_puppetlib, second_puppetlib, first_moduledir, second_moduledir]
       end
     end
 
@@ -138,7 +150,11 @@ describe Puppet::Node::Environment do
       end
 
       it "should ask the Puppet settings instance for the setting qualified with the environment name" do
-        Puppet.settings.set_value(:server, "myval", :testing)
+        Puppet.settings.parse_config(<<-CONF)
+        [testing]
+        server = myval
+        CONF
+
         env[:server].should == "myval"
       end
 
@@ -158,7 +174,7 @@ describe Puppet::Node::Environment do
 
       it "should return nil if asked for a module that does not exist in its path" do
         modpath = tmpdir('modpath')
-        env.modulepath = [modpath]
+        env = Puppet::Node::Environment.create(:testing, [modpath], '')
 
         env.module("one").should be_nil
       end
@@ -344,99 +360,93 @@ describe Puppet::Node::Environment do
 
         end
       end
-
-      it "should cache the module list" do
-        env.modulepath = %w{/a}
-        Dir.expects(:entries).once.with("/a").returns %w{foo}
-
-        env.modules
-        env.modules
-      end
     end
 
-    describe Puppet::Node::Environment::Helper do
-      before do
-        @helper = Object.new
-        @helper.extend(Puppet::Node::Environment::Helper)
-      end
-
-      it "should be able to set and retrieve the environment as a symbol" do
-        @helper.environment = :foo
-        @helper.environment.name.should == :foo
-      end
+    describe "when performing initial import" do
+      def parser_and_environment(name)
+        env = Puppet::Node::Environment.new(name)
+        parser = Puppet::Parser::ParserFactory.parser(env)
+        Puppet::Parser::ParserFactory.stubs(:parser).returns(parser)
 
-      it "should accept an environment directly" do
-        @helper.environment = Puppet::Node::Environment.new(:foo)
-        @helper.environment.name.should == :foo
+        [parser, env]
       end
 
-      it "should accept an environment as a string" do
-        @helper.environment = 'foo'
-        @helper.environment.name.should == :foo
-      end
-    end
+      it "should set the parser's string to the 'code' setting and parse if code is available" do
+        Puppet[:code] = "my code"
+        parser, env = parser_and_environment('testing')
 
-    describe "when performing initial import" do
-      before do
-        @parser = Puppet::Parser::ParserFactory.parser("test")
-#        @parser = Puppet::Parser::EParserAdapter.new(Puppet::Parser::Parser.new("test")) # TODO: FIX PARSER FACTORY
-        Puppet::Parser::ParserFactory.stubs(:parser).returns @parser
-      end
+        parser.expects(:string=).with "my code"
+        parser.expects(:parse)
 
-      it "should set the parser's string to the 'code' setting and parse if code is available" do
-        Puppet.settings[:code] = "my code"
-        @parser.expects(:string=).with "my code"
-        @parser.expects(:parse)
         env.instance_eval { perform_initial_import }
       end
 
       it "should set the parser's file to the 'manifest' setting and parse if no code is available and the manifest is available" do
         filename = tmpfile('myfile')
-        File.open(filename, 'w'){|f| }
-        Puppet.settings[:manifest] = filename
-        @parser.expects(:file=).with filename
-        @parser.expects(:parse)
+        Puppet[:manifest] = filename
+        parser, env = parser_and_environment('testing')
+
+        parser.expects(:file=).with filename
+        parser.expects(:parse)
+
         env.instance_eval { perform_initial_import }
       end
 
       it "should pass the manifest file to the parser even if it does not exist on disk" do
         filename = tmpfile('myfile')
-        Puppet.settings[:code] = ""
-        Puppet.settings[:manifest] = filename
-        @parser.expects(:file=).with(filename).once
-        @parser.expects(:parse).once
+        Puppet[:code] = ""
+        Puppet[:manifest] = filename
+        parser, env = parser_and_environment('testing')
+
+        parser.expects(:file=).with(filename).once
+        parser.expects(:parse).once
+
         env.instance_eval { perform_initial_import }
       end
 
       it "should fail helpfully if there is an error importing" do
-        Puppet::FileSystem::File.stubs(:exist?).returns true
-        @parser.expects(:file=).once
-        @parser.expects(:parse).raises ArgumentError
-        lambda { env.known_resource_types }.should raise_error(Puppet::Error)
+        Puppet::FileSystem.stubs(:exist?).returns true
+        parser, env = parser_and_environment('testing')
+
+        parser.expects(:file=).once
+        parser.expects(:parse).raises ArgumentError
+
+        expect do
+          env.known_resource_types
+        end.to raise_error(Puppet::Error)
       end
 
       it "should not do anything if the ignore_import settings is set" do
-        Puppet.settings[:ignoreimport] = true
-        @parser.expects(:string=).never
-        @parser.expects(:file=).never
-        @parser.expects(:parse).never
+        Puppet[:ignoreimport] = true
+        parser, env = parser_and_environment('testing')
+
+        parser.expects(:string=).never
+        parser.expects(:file=).never
+        parser.expects(:parse).never
+
         env.instance_eval { perform_initial_import }
       end
 
       it "should mark the type collection as needing a reparse when there is an error parsing" do
-        @parser.expects(:parse).raises Puppet::ParseError.new("Syntax error at ...")
+        parser, env = parser_and_environment('testing')
 
-        lambda { env.known_resource_types }.should raise_error(Puppet::Error, /Syntax error at .../)
+        parser.expects(:parse).raises Puppet::ParseError.new("Syntax error at ...")
+
+        expect do
+          env.known_resource_types
+        end.to raise_error(Puppet::Error, /Syntax error at .../)
         env.known_resource_types.require_reparse?.should be_true
       end
     end
   end
+
   describe 'with classic parser' do
     before :each do
       Puppet[:parser] = 'current'
     end
     it_behaves_like 'the environment'
   end
+
   describe 'with future parser' do
     before :each do
       Puppet[:parser] = 'future'
@@ -444,4 +454,13 @@ describe Puppet::Node::Environment do
     it_behaves_like 'the environment'
   end
 
+  describe '#current' do
+    it 'should return the current context' do
+      env = Puppet::Node::Environment.new(:test)
+      Puppet::Context.any_instance.expects(:lookup).with(:current_environment).returns(env)
+      Puppet.expects(:deprecation_warning).once
+      Puppet::Node::Environment.current.should equal(env)
+    end
+  end
+
 end