puppet 3.6.2-x86-mingw32 → 3.7.0-x86-mingw32

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

@@ -1,9 +1,8 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
-
 require 'puppet/indirector/facts/facter'
 
-module PuppetNodeFactsFacter
+module NodeFactsFacterSpec
 describe Puppet::Node::Facts::Facter do
   FS = Puppet::FileSystem
 
@@ -24,27 +23,6 @@ describe Puppet::Node::Facts::Facter do
     Puppet::Node::Facts::Facter.name.should == :facter
   end
 
-  describe "when reloading Facter" do
-    before do
-      @facter_class = Puppet::Node::Facts::Facter
-      Facter.stubs(:clear)
-      Facter.stubs(:load)
-      Facter.stubs(:loadfacts)
-    end
-
-    it "should clear Facter" do
-      Facter.expects(:clear)
-      @facter_class.reload_facter
-    end
-
-    it "should load all Facter facts" do
-      Facter.expects(:loadfacts)
-      @facter_class.reload_facter
-    end
-  end
-end
-
-describe Puppet::Node::Facts::Facter do
   before :each do
     Puppet::Node::Facts::Facter.stubs(:reload_facter)
     @facter = Puppet::Node::Facts::Facter.new
@@ -54,22 +32,31 @@ describe Puppet::Node::Facts::Facter do
     @environment = stub 'environment'
     @request.stubs(:environment).returns(@environment)
     @request.environment.stubs(:modules).returns([])
+    @request.environment.stubs(:modulepath).returns([])
   end
 
-  describe Puppet::Node::Facts::Facter, " when finding facts" do
-    it "should reset and load facts" do
-      clear = sequence 'clear'
-      Puppet::Node::Facts::Facter.expects(:reload_facter).in_sequence(clear)
-      Puppet::Node::Facts::Facter.expects(:load_fact_plugins).in_sequence(clear)
+  describe 'when finding facts' do
+    it 'should reset facts' do
+      reset = sequence 'reset'
+      Facter.expects(:reset).in_sequence(reset)
+      Puppet::Node::Facts::Facter.expects(:setup_search_paths).in_sequence(reset)
+      @facter.find(@request)
+    end
+
+    it 'should include external facts when feature is present' do
+      reset = sequence 'reset'
+      Puppet.features.stubs(:external_facts?).returns true
+      Facter.expects(:reset).in_sequence(reset)
+      Puppet::Node::Facts::Facter.expects(:setup_external_search_paths).in_sequence(reset)
+      Puppet::Node::Facts::Facter.expects(:setup_search_paths).in_sequence(reset)
       @facter.find(@request)
     end
 
-    it "should include external facts when feature is present" do
-      clear = sequence 'clear'
-      Puppet.features.stubs(:external_facts?).returns(:true)
-      Puppet::Node::Facts::Facter.expects(:setup_external_facts).in_sequence(clear)
-      Puppet::Node::Facts::Facter.expects(:reload_facter).in_sequence(clear)
-      Puppet::Node::Facts::Facter.expects(:load_fact_plugins).in_sequence(clear)
+    it 'should not include external facts when feature is not present' do
+      reset = sequence 'reset'
+      Puppet.features.stubs(:external_facts?).returns false
+      Facter.expects(:reset).in_sequence(reset)
+      Puppet::Node::Facts::Facter.expects(:setup_search_paths).in_sequence(reset)
       @facter.find(@request)
     end
 
@@ -114,89 +101,69 @@ describe Puppet::Node::Facts::Facter do
     end
   end
 
-  describe Puppet::Node::Facts::Facter, " when saving facts" do
-
-    it "should fail" do
-      proc { @facter.save(@facts) }.should raise_error(Puppet::DevError)
-    end
-  end
-
-  describe Puppet::Node::Facts::Facter, " when destroying facts" do
-
-    it "should fail" do
-      proc { @facter.destroy(@facts) }.should raise_error(Puppet::DevError)
-    end
+  it 'should fail when saving facts' do
+    proc { @facter.save(@facts) }.should raise_error(Puppet::DevError)
   end
 
-  it "should skip files when asked to load a directory" do
-    FileTest.expects(:directory?).with("myfile").returns false
-
-    Puppet::Node::Facts::Facter.load_facts_in_dir("myfile")
+  it 'should fail when destroying facts' do
+    proc { @facter.destroy(@facts) }.should raise_error(Puppet::DevError)
   end
 
-  it "should load each ruby file when asked to load a directory" do
-    FileTest.expects(:directory?).with("mydir").returns true
-    Dir.expects(:chdir).with("mydir").yields
+  describe 'when setting up search paths' do
+    let(:factpath1) { File.expand_path 'one' }
+    let(:factpath2) { File.expand_path 'two' }
+    let(:factpath) { [factpath1, factpath2].join(File::PATH_SEPARATOR) }
+    let(:modulepath) { File.expand_path 'module/foo' }
+    let(:modulelibfacter) { File.expand_path 'module/foo/lib/facter' }
+    let(:modulepluginsfacter) { File.expand_path 'module/foo/plugins/facter' }
 
-    Dir.expects(:glob).with("*.rb").returns %w{a.rb b.rb}
+    before :each do
+      FileTest.expects(:directory?).with(factpath1).returns true
+      FileTest.expects(:directory?).with(factpath2).returns true
+      @request.environment.stubs(:modulepath).returns [modulepath]
+      Dir.expects(:glob).with("#{modulepath}/*/lib/facter").returns [modulelibfacter]
+      Dir.expects(:glob).with("#{modulepath}/*/plugins/facter").returns [modulepluginsfacter]
 
-    Puppet::Node::Facts::Facter.expects(:load).with File.join('.', 'a.rb')
-    Puppet::Node::Facts::Facter.expects(:load).with File.join('.', 'b.rb')
-
-    Puppet::Node::Facts::Facter.load_facts_in_dir("mydir")
-  end
+      Puppet[:factpath] = factpath
+    end
 
-  it "should include pluginfactdest when loading external facts",
-     :if => (Puppet.features.external_facts? and not Puppet.features.microsoft_windows?) do
-    Puppet[:pluginfactdest] = "/plugin/dest"
-    @facter.find(@request)
-    Facter.search_external_path.include?("/plugin/dest")
-  end
+    it 'should skip files' do
+      FileTest.expects(:directory?).with(modulelibfacter).returns false
+      FileTest.expects(:directory?).with(modulepluginsfacter).returns false
+      Facter.expects(:search).with(factpath1, factpath2)
+      Puppet::Node::Facts::Facter.setup_search_paths @request
+    end
 
-  it "should include pluginfactdest when loading external facts",
-    :if => (Puppet.features.external_facts? and Puppet.features.microsoft_windows?) do
-    Puppet[:pluginfactdest] = "/plugin/dest"
-    @facter.find(@request)
-    Facter.search_external_path.include?("C:/plugin/dest")
+    it 'should add directories' do
+      FileTest.expects(:directory?).with(modulelibfacter).returns true
+      FileTest.expects(:directory?).with(modulepluginsfacter).returns true
+      Facter.expects(:search).with(modulelibfacter, modulepluginsfacter, factpath1, factpath2)
+      Puppet::Node::Facts::Facter.setup_search_paths @request
+    end
   end
 
-  describe "when loading fact plugins from disk" do
-    let(:one) { File.expand_path("one") }
-    let(:two) { File.expand_path("two") }
-
-    it "should load each directory in the Fact path" do
-      Puppet[:factpath] = [one, two].join(File::PATH_SEPARATOR)
-
-      Puppet::Node::Facts::Facter.expects(:load_facts_in_dir).with(one)
-      Puppet::Node::Facts::Facter.expects(:load_facts_in_dir).with(two)
+  describe 'when setting up external search paths', :if => Puppet.features.external_facts? do
+    let(:pluginfactdest) { File.expand_path 'plugin/dest' }
+    let(:modulepath) { File.expand_path 'module/foo' }
+    let(:modulefactsd) { File.expand_path 'module/foo/facts.d'  }
 
-      Puppet::Node::Facts::Facter.load_fact_plugins
+    before :each do
+      FileTest.expects(:directory?).with(pluginfactdest).returns true
+      mod = Puppet::Module.new('foo', modulepath, @request.environment)
+      @request.environment.stubs(:modules).returns [mod]
+      Puppet[:pluginfactdest] = pluginfactdest
     end
 
-    it "should load all facts from the modules" do
-      Puppet::Node::Facts::Facter.stubs(:load_facts_in_dir)
-
-      Dir.stubs(:glob).returns []
-      Dir.expects(:glob).with("#{one}/*/lib/facter").returns %w{oneA oneB}
-      Dir.expects(:glob).with("#{two}/*/lib/facter").returns %w{twoA twoB}
-
-      Puppet::Node::Facts::Facter.expects(:load_facts_in_dir).with("oneA")
-      Puppet::Node::Facts::Facter.expects(:load_facts_in_dir).with("oneB")
-      Puppet::Node::Facts::Facter.expects(:load_facts_in_dir).with("twoA")
-      Puppet::Node::Facts::Facter.expects(:load_facts_in_dir).with("twoB")
-
-      FS.overlay(FS::MemoryFile.a_directory(one), FS::MemoryFile.a_directory(two)) do
-        Puppet.override(:current_environment => Puppet::Node::Environment.create(:testing, [one, two], "")) do
-          Puppet::Node::Facts::Facter.load_fact_plugins
-        end
-      end
+    it 'should skip files' do
+      File.expects(:directory?).with(modulefactsd).returns false
+      Facter.expects(:search_external).with [pluginfactdest]
+      Puppet::Node::Facts::Facter.setup_external_search_paths @request
     end
 
-    it "should include module plugin facts when present", :if => Puppet.features.external_facts? do
-      mod = Puppet::Module.new("mymodule", "#{one}/mymodule", @request.environment)
-      @request.environment.stubs(:modules).returns([mod])
-      @facter.find(@request)
-      Facter.search_external_path.include?("#{one}/mymodule/facts.d")
+    it 'should add directories' do
+      File.expects(:directory?).with(modulefactsd).returns true
+      Facter.expects(:search_external).with [modulefactsd, pluginfactdest]
+      Puppet::Node::Facts::Facter.setup_external_search_paths @request
     end
   end
 end

data/spec/unit/indirector/hiera_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+require 'puppet/data_binding'
+require 'puppet/indirector/hiera'
+require 'hiera/backend'
+
+describe Puppet::Indirector::Hiera do
+
+  module Testing
+    module DataBinding
+      class Hiera < Puppet::Indirector::Hiera
+      end
+    end
+  end
+
+  it_should_behave_like "Hiera indirection", Testing::DataBinding::Hiera, my_fixture_dir
+end
+

data/spec/unit/indirector/request_spec.rb

@@ -232,14 +232,12 @@ describe Puppet::Indirector::Request do
     Puppet::Indirector::Request.new(:myind, :find, "my key", nil, :environment => env).environment.should equal(env)
   end
 
-  it "should use the configured environment when none is provided" do
+  it "should use the current environment when none is provided" do
     configured = Puppet::Node::Environment.create(:foo, [])
 
     Puppet[:environment] = "foo"
 
-    Puppet.override(:environments => Puppet::Environments::Static.new(configured)) do
-      Puppet::Indirector::Request.new(:myind, :find, "my key", nil).environment.should == configured
-    end
+    expect(Puppet::Indirector::Request.new(:myind, :find, "my key", nil).environment).to eq(Puppet.lookup(:current_environment))
   end
 
   it "should support converting its options to a hash" do

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

@@ -25,6 +25,11 @@ describe "Puppet::Resource::Ral" do
       Puppet::Resource::Ral.new.find(@request).should == my_resource
     end
 
+    it "should produce Puppet::Error instead of ArgumentError" do
+      @bad_request = stub 'thiswillcauseanerror', :key => "thiswill/causeanerror"
+      expect{Puppet::Resource::Ral.new.find(@bad_request)}.to raise_error(Puppet::Error)
+    end
+
     it "if there is no instance, it should create one" do
       wrong_instance = stub "wrong user", :name => "bob"
       root = mock "Root User"

data/spec/unit/indirector/resource_type/parser_spec.rb

@@ -7,9 +7,13 @@ require 'puppet_spec/files'
 describe Puppet::Indirector::ResourceType::Parser do
   include PuppetSpec::Files
 
+  let(:environmentpath) { tmpdir("envs") }
+  let(:modulepath) { "#{environmentpath}/test/modules" }
+  let(:environment) { Puppet::Node::Environment.create(:test, [modulepath]) }
   before do
     @terminus = Puppet::Indirector::ResourceType::Parser.new
     @request = Puppet::Indirector::Request.new(:resource_type, :find, "foo", nil)
+    @request.environment = environment
     @krt = @request.environment.known_resource_types
   end
 
@@ -26,19 +30,18 @@ describe Puppet::Indirector::ResourceType::Parser do
     end
 
     it "should attempt to load the type if none is found in memory" do
-      dir = tmpdir("find_a_type")
-      FileUtils.mkdir_p(dir)
-      Puppet[:modulepath] = dir
+      FileUtils.mkdir_p(modulepath)
 
       # Make a new request, since we've reset the env
-      @request = Puppet::Indirector::Request.new(:resource_type, :find, "foo::bar", nil)
+      request = Puppet::Indirector::Request.new(:resource_type, :find, "foo::bar", nil)
+      request.environment = environment
 
-      manifest_path = File.join(dir, "foo", "manifests")
+      manifest_path = File.join(modulepath, "foo", "manifests")
       FileUtils.mkdir_p(manifest_path)
 
       File.open(File.join(manifest_path, "bar.pp"), "w") { |f| f.puts "class foo::bar {}" }
 
-      result = @terminus.find(@request)
+      result = @terminus.find(request)
       result.should be_instance_of(Puppet::Resource::Type)
       result.name.should == "foo::bar"
     end
@@ -108,10 +111,11 @@ describe Puppet::Indirector::ResourceType::Parser do
         second = File.join(dir, "second")
         FileUtils.mkdir_p(first)
         FileUtils.mkdir_p(second)
-        Puppet[:modulepath] = "#{first}#{File::PATH_SEPARATOR}#{second}"
+        environment = Puppet::Node::Environment.create(:test, [first, second])
 
         # Make a new request, since we've reset the env
-        @request = Puppet::Indirector::Request.new(:resource_type, :search, "*", nil)
+        request = Puppet::Indirector::Request.new(:resource_type, :search, "*", nil)
+        request.environment = environment
 
         onepath = File.join(first, "one", "manifests")
         FileUtils.mkdir_p(onepath)
@@ -121,7 +125,7 @@ describe Puppet::Indirector::ResourceType::Parser do
         File.open(File.join(onepath, "oneklass.pp"), "w") { |f| f.puts "class one::oneklass {}" }
         File.open(File.join(twopath, "twoklass.pp"), "w") { |f| f.puts "class two::twoklass {}" }
 
-        result = @terminus.search(@request)
+        result = @terminus.search(request)
         result.find { |t| t.name == "one::oneklass" }.should be_instance_of(Puppet::Resource::Type)
         result.find { |t| t.name == "two::twoklass" }.should be_instance_of(Puppet::Resource::Type)
       end
@@ -228,10 +232,11 @@ describe Puppet::Indirector::ResourceType::Parser do
       second = File.join(dir, "second")
       FileUtils.mkdir_p(first)
       FileUtils.mkdir_p(second)
-      Puppet[:modulepath] = "#{first}#{File::PATH_SEPARATOR}#{second}"
+      environment = Puppet::Node::Environment.create(:test, [first,second])
 
       # Make a new request, since we've reset the env
-      @request = Puppet::Indirector::Request.new(:resource_type, :search, "*", nil)
+      request = Puppet::Indirector::Request.new(:resource_type, :search, "*", nil)
+      request.environment = environment
 
       onepath = File.join(first, "one", "manifests")
       FileUtils.mkdir_p(onepath)
@@ -241,7 +246,7 @@ describe Puppet::Indirector::ResourceType::Parser do
       File.open(File.join(onepath, "oneklass.pp"), "w") { |f| f.puts "class one::oneklass {}" }
       File.open(File.join(twopath, "twoklass.pp"), "w") { |f| f.puts "class two::twoklass {}" }
 
-      result = @terminus.search(@request)
+      result = @terminus.search(request)
       result.find { |t| t.name == "one::oneklass" }.should be_instance_of(Puppet::Resource::Type)
       result.find { |t| t.name == "two::twoklass" }.should be_instance_of(Puppet::Resource::Type)
     end

data/spec/unit/indirector/rest_spec.rb

@@ -136,6 +136,12 @@ describe Puppet::Indirector::REST do
   let(:indirection) { Puppet::TestModel.indirection }
   let(:model) { Puppet::TestModel }
 
+  around(:each) do |example|
+    Puppet.override(:current_environment => Puppet::Node::Environment.create(:production, [])) do
+      example.run
+    end
+  end
+
   def mock_response(code, body, content_type='text/plain', encoding=nil)
     obj = stub('http 200 ok', :code => code.to_s, :body => body)
     obj.stubs(:[]).with('content-type').returns(content_type)
@@ -285,17 +291,41 @@ describe Puppet::Indirector::REST do
     end
 
     context 'when fail_on_404 is used in request' do
-      let(:request) { find_request('foo', :fail_on_404 => true) }
-
       it 'raises an error for a 404 when asked to do so' do
+        request = find_request('foo', :fail_on_404 => true)
         response = mock_response('404', 'this is the notfound you are looking for')
         connection.expects(:get).returns(response)
-        expected_message = [
-          'Find /production/test_model/foo?fail_on_404=true',
-          'resulted in 404 with the message: this is the notfound you are looking for'].join( ' ')
+
+        expect do
+          terminus.find(request)
+        end.to raise_error(
+          Puppet::Error,
+          'Find /production/test_model/foo?fail_on_404=true resulted in 404 with the message: this is the notfound you are looking for')
+      end
+
+      it 'truncates the URI when it is very long' do
+        request = find_request('foo', :fail_on_404 => true, :long_param => ('A' * 100) + 'B')
+        response = mock_response('404', 'this is the notfound you are looking for')
+        connection.expects(:get).returns(response)
+
+        expect do
+          terminus.find(request)
+        end.to raise_error(
+          Puppet::Error,
+          /\/production\/test_model\/foo.*long_param=A+\.\.\..*resulted in 404 with the message/)
+      end
+
+      it 'does not truncate the URI when logging debug information' do
+        Puppet.debug = true
+        request = find_request('foo', :fail_on_404 => true, :long_param => ('A' * 100) + 'B')
+        response = mock_response('404', 'this is the notfound you are looking for')
+        connection.expects(:get).returns(response)
+
         expect do
           terminus.find(request)
-        end.to raise_error(Puppet::Error, expected_message)
+        end.to raise_error(
+          Puppet::Error,
+          /\/production\/test_model\/foo.*long_param=A+B.*resulted in 404 with the message/)
       end
     end
 

data/spec/unit/interface/face_collection_spec.rb

@@ -11,12 +11,12 @@ describe Puppet::Interface::FaceCollection do
   # the 'subject' of the specs will differ.
   before :all do
     # Save FaceCollection's global state
-    faces = subject.instance_variable_get(:@faces)
+    faces = described_class.instance_variable_get(:@faces)
     @faces = faces.dup
     faces.each do |k, v|
       @faces[k] = v.dup
     end
-    @faces_loaded = subject.instance_variable_get(:@loaded)
+    @faces_loaded = described_class.instance_variable_get(:@loaded)
 
     # Save the already required face files
     @required = []

data/spec/unit/module_tool/applications/builder_spec.rb

@@ -1,4 +1,5 @@
 require 'spec_helper'
+require 'puppet/file_system'
 require 'puppet/module_tool/applications'
 require 'puppet_spec/modules'
 
@@ -12,6 +13,330 @@ describe Puppet::ModuleTool::Applications::Builder do
   let(:tarball)      { File.join(path, 'pkg', release_name) + ".tar.gz" }
   let(:builder)      { Puppet::ModuleTool::Applications::Builder.new(path) }
 
+  shared_examples "a packagable module" do
+    def target_exists?(file)
+      File.exist?(File.join(path, "pkg", "#{module_name}-#{version}", file))
+    end
+
+    def build
+      tarrer = mock('tarrer')
+      Puppet::ModuleTool::Tar.expects(:instance).returns(tarrer)
+      Dir.expects(:chdir).with(File.join(path, 'pkg')).yields
+      tarrer.expects(:pack).with(release_name, tarball)
+
+      builder.run
+    end
+
+      def create_regular_files
+      Puppet::FileSystem.touch(File.join(path, '.dotfile'))
+      Puppet::FileSystem.touch(File.join(path, 'file.foo'))
+      Puppet::FileSystem.touch(File.join(path, 'REVISION'))
+      Puppet::FileSystem.touch(File.join(path, '~file'))
+      Puppet::FileSystem.touch(File.join(path, '#file'))
+      Puppet::FileSystem.mkpath(File.join(path, 'pkg'))
+      Puppet::FileSystem.mkpath(File.join(path, 'coverage'))
+      Puppet::FileSystem.mkpath(File.join(path, 'sub'))
+      Puppet::FileSystem.touch(File.join(path, 'sub/.dotfile'))
+      Puppet::FileSystem.touch(File.join(path, 'sub/file.foo'))
+      Puppet::FileSystem.touch(File.join(path, 'sub/REVISION'))
+      Puppet::FileSystem.touch(File.join(path, 'sub/~file'))
+      Puppet::FileSystem.touch(File.join(path, 'sub/#file'))
+      Puppet::FileSystem.mkpath(File.join(path, 'sub/pkg'))
+      Puppet::FileSystem.mkpath(File.join(path, 'sub/coverage'))
+    end
+
+    def create_symlinks
+      Puppet::FileSystem.touch(File.join(path, 'symlinkedfile'))
+      Puppet::FileSystem.symlink(File.join(path, 'symlinkedfile'), File.join(path, 'symlinkfile'))
+    end
+
+    def create_ignored_files
+      Puppet::FileSystem.touch(File.join(path, 'gitignored.foo'))
+      Puppet::FileSystem.mkpath(File.join(path, 'gitdirectory/sub'))
+      Puppet::FileSystem.touch(File.join(path, 'gitdirectory/gitartifact'))
+      Puppet::FileSystem.touch(File.join(path, 'gitdirectory/gitimportantfile'))
+      Puppet::FileSystem.touch(File.join(path, 'gitdirectory/sub/artifact'))
+      Puppet::FileSystem.touch(File.join(path, 'pmtignored.foo'))
+      Puppet::FileSystem.mkpath(File.join(path, 'pmtdirectory/sub'))
+      Puppet::FileSystem.touch(File.join(path, 'pmtdirectory/pmtimportantfile'))
+      Puppet::FileSystem.touch(File.join(path, 'pmtdirectory/pmtartifact'))
+      Puppet::FileSystem.touch(File.join(path, 'pmtdirectory/sub/artifact'))
+    end
+
+    def create_pmtignore_file
+      Puppet::FileSystem.open(File.join(path, '.pmtignore'), 0600, 'w') do |f|
+        f << <<-PMTIGNORE
+pmtignored.*
+pmtdirectory/sub/**
+pmtdirectory/pmt*
+!pmtimportantfile
+PMTIGNORE
+      end
+    end
+
+    def create_gitignore_file
+      Puppet::FileSystem.open(File.join(path, '.gitignore'), 0600, 'w') do |f|
+        f << <<-GITIGNORE
+gitignored.*
+gitdirectory/sub/**
+gitdirectory/git*
+!gitimportantfile
+GITIGNORE
+      end
+    end
+
+    def create_symlink_gitignore_file
+      Puppet::FileSystem.open(File.join(path, '.gitignore'), 0600, 'w') do |f|
+        f << <<-GITIGNORE
+symlinkfile
+    GITIGNORE
+      end
+    end
+
+    shared_examples "regular files are present" do
+      it "has metadata" do
+        expect(target_exists?('metadata.json')).to eq true
+      end
+
+      it "has checksums" do
+        expect(target_exists?('checksums.json')).to eq true
+      end
+
+      it "copies regular files" do
+        expect(target_exists?('file.foo')).to eq true
+      end
+    end
+
+    shared_examples "default artifacts are removed in module dir but not in subdirs" do
+      it "ignores dotfiles" do
+        expect(target_exists?('.dotfile')).to eq false
+        expect(target_exists?('sub/.dotfile')).to eq true
+      end
+
+      it "does not have .gitignore" do
+        expect(target_exists?('.gitignore')).to eq false
+      end
+
+      it "does not have .pmtignore" do
+        expect(target_exists?('.pmtignore')).to eq false
+      end
+
+      it "does not have pkg" do
+        expect(target_exists?('pkg')).to eq false
+        expect(target_exists?('sub/pkg')).to eq true
+      end
+
+      it "does not have coverage" do
+        expect(target_exists?('coverage')).to eq false
+        expect(target_exists?('sub/coverage')).to eq true
+      end
+
+      it "does not have REVISION" do
+        expect(target_exists?('REVISION')).to eq false
+        expect(target_exists?('sub/REVISION')).to eq true
+      end
+
+      it "does not have ~files" do
+        expect(target_exists?('~file')).to eq false
+        expect(target_exists?('sub/~file')).to eq true
+      end
+
+      it "does not have #files" do
+        expect(target_exists?('#file')).to eq false
+        expect(target_exists?('sub/#file')).to eq true
+      end
+    end
+
+    shared_examples "gitignored files are present" do
+      it "leaves regular files" do
+        expect(target_exists?('gitignored.foo')).to eq true
+      end
+
+      it "leaves directories" do
+        expect(target_exists?('gitdirectory')).to eq true
+      end
+
+      it "leaves files in directories" do
+        expect(target_exists?('gitdirectory/gitartifact')).to eq true
+      end
+
+      it "leaves exceptional files" do
+        expect(target_exists?('gitdirectory/gitimportantfile')).to eq true
+      end
+
+      it "leaves subdirectories" do
+        expect(target_exists?('gitdirectory/sub')).to eq true
+      end
+
+      it "leaves files in subdirectories" do
+        expect(target_exists?('gitdirectory/sub/artifact')).to eq true
+      end
+    end
+
+    shared_examples "gitignored files are not present" do
+      it "ignores regular files" do
+        expect(target_exists?('gitignored.foo')).to eq false
+      end
+
+      it "ignores directories" do
+        expect(target_exists?('gitdirectory')).to eq true
+      end
+
+      it "ignores files in directories" do
+        expect(target_exists?('gitdirectory/gitartifact')).to eq false
+      end
+
+      it "copies exceptional files" do
+        expect(target_exists?('gitdirectory/gitimportantfile')).to eq true
+      end
+
+      it "ignores subdirectories" do
+        expect(target_exists?('gitdirectory/sub')).to eq false
+      end
+
+      it "ignores files in subdirectories" do
+        expect(target_exists?('gitdirectory/sub/artifact')).to eq false
+      end
+    end
+
+    shared_examples "pmtignored files are present" do
+      it "leaves regular files" do
+        expect(target_exists?('pmtignored.foo')).to eq true
+      end
+
+      it "leaves directories" do
+        expect(target_exists?('pmtdirectory')).to eq true
+      end
+
+      it "ignores files in directories" do
+        expect(target_exists?('pmtdirectory/pmtartifact')).to eq true
+      end
+
+      it "leaves exceptional files" do
+        expect(target_exists?('pmtdirectory/pmtimportantfile')).to eq true
+      end
+
+      it "leaves subdirectories" do
+        expect(target_exists?('pmtdirectory/sub')).to eq true
+      end
+
+      it "leaves files in subdirectories" do
+        expect(target_exists?('pmtdirectory/sub/artifact')).to eq true
+      end
+    end
+
+    shared_examples "pmtignored files are not present" do
+      it "ignores regular files" do
+        expect(target_exists?('pmtignored.foo')).to eq false
+      end
+
+      it "ignores directories" do
+        expect(target_exists?('pmtdirectory')).to eq true
+      end
+
+      it "copies exceptional files" do
+        expect(target_exists?('pmtdirectory/pmtimportantfile')).to eq true
+      end
+
+      it "ignores files in directories" do
+        expect(target_exists?('pmtdirectory/pmtartifact')).to eq false
+      end
+
+      it "ignores subdirectories" do
+        expect(target_exists?('pmtdirectory/sub')).to eq false
+      end
+
+      it "ignores files in subdirectories" do
+        expect(target_exists?('pmtdirectory/sub/artifact')).to eq false
+      end
+    end
+
+    context "with no ignore files" do
+      before :each do
+        create_regular_files
+        create_ignored_files
+
+        build
+      end
+
+      it_behaves_like "regular files are present"
+      it_behaves_like "default artifacts are removed in module dir but not in subdirs"
+      it_behaves_like "pmtignored files are present"
+      it_behaves_like "gitignored files are present"
+    end
+
+    context "with .gitignore file" do
+      before :each do
+        create_regular_files
+        create_ignored_files
+        create_gitignore_file
+
+        build
+      end
+
+      it_behaves_like "regular files are present"
+      it_behaves_like "default artifacts are removed in module dir but not in subdirs"
+      it_behaves_like "pmtignored files are present"
+      it_behaves_like "gitignored files are not present"
+    end
+
+    context "with .pmtignore file" do
+      before :each do
+        create_regular_files
+        create_ignored_files
+        create_pmtignore_file
+
+        build
+      end
+
+      it_behaves_like "regular files are present"
+      it_behaves_like "default artifacts are removed in module dir but not in subdirs"
+      it_behaves_like "gitignored files are present"
+      it_behaves_like "pmtignored files are not present"
+    end
+
+    context "with .pmtignore and .gitignore file" do
+      before :each do
+        create_regular_files
+        create_ignored_files
+        create_pmtignore_file
+        create_gitignore_file
+
+        build
+      end
+
+      it_behaves_like "regular files are present"
+      it_behaves_like "default artifacts are removed in module dir but not in subdirs"
+      it_behaves_like "gitignored files are present"
+      it_behaves_like "pmtignored files are not present"
+    end
+
+    context "with unignored symlinks", :if => Puppet.features.manages_symlinks? do
+      before :each do
+        create_regular_files
+        create_symlinks
+        create_ignored_files
+      end
+
+      it "give an error about symlinks" do
+        expect { builder.run }.to raise_error
+      end
+    end
+
+    context "with .gitignore file and ignored symlinks", :if => Puppet.features.manages_symlinks? do
+      before :each do
+        create_regular_files
+        create_symlinks
+        create_ignored_files
+        create_symlink_gitignore_file
+      end
+
+      it "does not give an error about symlinks" do
+        expect { build }.not_to raise_error
+      end
+    end
+  end
+
   context 'with metadata.json' do
     before :each do
       File.open(File.join(path, 'metadata.json'), 'w') do |f|
@@ -28,16 +353,48 @@ describe Puppet::ModuleTool::Applications::Builder do
       end
     end
 
-    it "packages the module in a tarball named after the module" do
-      tarrer = mock('tarrer')
-      Puppet::ModuleTool::Tar.expects(:instance).returns(tarrer)
-      Dir.expects(:chdir).with(File.join(path, 'pkg')).yields
-      tarrer.expects(:pack).with(release_name, tarball)
+    it_behaves_like "a packagable module"
 
-      builder.run
+    it "does not package with a symlink", :if => Puppet.features.manages_symlinks? do
+      FileUtils.touch(File.join(path, 'tempfile'))
+      Puppet::FileSystem.symlink(File.join(path, 'tempfile'), File.join(path, 'tempfile2'))
+
+      expect {
+        builder.run
+      }.to raise_error Puppet::ModuleTool::Errors::ModuleToolError, /symlinks/i
+    end
+
+    it "does not package with a symlink in a subdir", :if => Puppet.features.manages_symlinks? do
+      FileUtils.mkdir(File.join(path, 'manifests'))
+      FileUtils.touch(File.join(path, 'manifests/tempfile.pp'))
+      Puppet::FileSystem.symlink(File.join(path, 'manifests/tempfile.pp'), File.join(path, 'manifests/tempfile2.pp'))
+
+      expect {
+        builder.run
+      }.to raise_error Puppet::ModuleTool::Errors::ModuleToolError, /symlinks/i
     end
   end
 
+  context 'with metadata.json containing checksums' do
+    before :each do
+      File.open(File.join(path, 'metadata.json'), 'w') do |f|
+        f.puts({
+          "name" => "#{module_name}",
+          "version" => "#{version}",
+          "source" => "http://github.com/testing/#{module_name}",
+          "author" => "testing",
+          "license" => "Apache License Version 2.0",
+          "summary" => "Puppet testing module",
+          "description" => "This module can be used for basic testing",
+          "project_page" => "http://github.com/testing/#{module_name}",
+          "checksums" => {"README.md" => "deadbeef"}
+        }.to_json)
+      end
+    end
+
+    it_behaves_like "a packagable module"
+  end
+
   context 'with Modulefile' do
     before :each do
       File.open(File.join(path, 'Modulefile'), 'w') do |f|
@@ -54,13 +411,6 @@ MODULEFILE
       end
     end
 
-    it "packages the module in a tarball named after the module" do
-      tarrer = mock('tarrer')
-      Puppet::ModuleTool::Tar.expects(:instance).returns(tarrer)
-      Dir.expects(:chdir).with(File.join(path, 'pkg')).yields
-      tarrer.expects(:pack).with(release_name, tarball)
-
-      builder.run
-    end
+    it_behaves_like "a packagable module"
   end
 end