puppet 4.2.0 → 4.3.0

data/spec/unit/indirector/catalog/compiler_spec.rb

@@ -46,7 +46,7 @@ describe Puppet::Resource::Catalog::Compiler do
 
     it "should directly use provided nodes for a local request" do
       Puppet::Node.indirection.expects(:find).never
-      @compiler.expects(:compile).with(@node)
+      @compiler.expects(:compile).with(@node, nil)
       @request.stubs(:options).returns(:use_node => @node)
       @request.stubs(:remote?).returns(false)
       @compiler.find(@request)
@@ -63,7 +63,7 @@ describe Puppet::Resource::Catalog::Compiler do
     it "should use the authenticated node name if no request key is provided" do
       @request.stubs(:key).returns(nil)
       Puppet::Node.indirection.expects(:find).with(@name, anything).returns(@node)
-      @compiler.expects(:compile).with(@node)
+      @compiler.expects(:compile).with(@node, nil)
       @compiler.find(@request)
     end
 
@@ -71,7 +71,7 @@ describe Puppet::Resource::Catalog::Compiler do
       @request.expects(:key).returns "my_node"
 
       Puppet::Node.indirection.expects(:find).with("my_node", anything).returns @node
-      @compiler.expects(:compile).with(@node)
+      @compiler.expects(:compile).with(@node, nil)
       @compiler.find(@request)
     end
 
@@ -88,7 +88,7 @@ describe Puppet::Resource::Catalog::Compiler do
     it "should pass the found node to the compiler for compiling" do
       Puppet::Node.indirection.expects(:find).with(@name, anything).returns(@node)
       config = mock 'config'
-      Puppet::Parser::Compiler.expects(:compile).with(@node)
+      Puppet::Parser::Compiler.expects(:compile).with(@node, nil)
       @compiler.find(@request)
     end
 
@@ -119,11 +119,31 @@ describe Puppet::Resource::Catalog::Compiler do
 
     it "should return the results of compiling as the catalog" do
       Puppet::Node.indirection.stubs(:find).returns(@node)
-      config = mock 'config'
-      result = mock 'result'
+      catalog = Puppet::Resource::Catalog.new(@node.name)
+      Puppet::Parser::Compiler.stubs(:compile).returns catalog
+
+      expect(@compiler.find(@request)).to equal(catalog)
+    end
+
+    it "passes the code_id from the request to the compiler" do
+      Puppet::Node.indirection.stubs(:find).returns(@node)
+      code_id = 'b59e5df0578ef411f773ee6c33d8073c50e7b8fe'
+      @request.options[:code_id] = code_id
+
+      Puppet::Parser::Compiler.expects(:compile).with(anything, code_id)
+
+      @compiler.find(@request)
+    end
+
+    it "returns a catalog with the code_id from the request" do
+      Puppet::Node.indirection.stubs(:find).returns(@node)
+      code_id = 'b59e5df0578ef411f773ee6c33d8073c50e7b8fe'
+      @request.options[:code_id] = code_id
+
+      catalog = Puppet::Resource::Catalog.new(@node.name, @node.environment, code_id)
+      Puppet::Parser::Compiler.stubs(:compile).returns catalog
 
-      Puppet::Parser::Compiler.expects(:compile).returns result
-      expect(@compiler.find(@request)).to equal(result)
+      expect(@compiler.find(@request).code_id).to eq(code_id)
     end
   end
 

data/spec/unit/indirector/catalog/static_compiler_spec.rb

@@ -34,6 +34,10 @@ describe Puppet::Resource::Catalog::StaticCompiler do
   end
 
   describe "#find" do
+    before :each do
+      subject.stubs(:store_content)
+    end
+
     it "returns a catalog" do
       expect(subject.find(request)).to be_a_kind_of(Puppet::Resource::Catalog)
     end
@@ -45,7 +49,8 @@ describe Puppet::Resource::Catalog::StaticCompiler do
 
     describe "a catalog with file resources containing source parameters with puppet:// URIs" do
       it "filters file resource source URI's to checksums" do
-        stub_the_compiler
+        subject.stubs(:compile).returns(build_catalog)
+
         resource_catalog = subject.find(request)
         resource_catalog.resources.each do |resource|
           next unless resource.type == "File"
@@ -56,7 +61,8 @@ describe Puppet::Resource::Catalog::StaticCompiler do
 
       it "does not modify file resources with non-puppet:// URI's" do
         uri = "/this/is/not/a/puppet/uri.txt"
-        stub_the_compiler(:source => uri)
+        subject.stubs(:compile).returns(build_catalog(:source => uri))
+
         resource_catalog = subject.find(request)
         resource_catalog.resources.each do |resource|
           next unless resource.type == "File"
@@ -65,16 +71,41 @@ describe Puppet::Resource::Catalog::StaticCompiler do
         end
       end
 
-      it "copies the owner, group and mode from the fileserer" do
-        stub_the_compiler
+      it "copies the owner, group and mode from the fileserver" do
+        subject.stubs(:compile).returns(build_catalog)
+
         resource_catalog = subject.find(request)
         resource_catalog.resources.each do |resource|
           next unless resource.type == "File"
-          expect(resource[:owner]).to eq(0)
-          expect(resource[:group]).to eq(0)
-          expect(resource[:mode]).to  eq(420)
+          expect(resource[:owner]).to eq("0")
+          expect(resource[:group]).to eq("0")
+          expect(resource[:mode]).to  eq("644")
         end
       end
+
+      it "ignores recurse when source refers to a file" do
+        path = File.expand_path('/tmp/foo')
+        metadata = fileserver_metadata(:path => path)
+        metadata.relative_path = '.'
+
+        Puppet::FileServing::Metadata.indirection.stubs(:search).returns([metadata])
+        Puppet::FileServing::Metadata.indirection.stubs(:find).returns(metadata)
+
+        catalog = Puppet::Resource::Catalog.new(request)
+        catalog.add_resource(
+          Puppet::Resource.new('file', path,
+            :parameters => {
+              :recurse => true,
+              :source => 'puppet:///modules/mymodule/foo'
+            }
+          )
+        )
+        subject.stubs(:compile).returns(catalog)
+
+        resource = subject.find(request).resources.first
+        expect(resource[:ensure]).to eq('file')
+        expect(resource.title).to eq(path)
+      end
     end
   end
 
@@ -120,19 +151,6 @@ describe Puppet::Resource::Catalog::StaticCompiler do
 
   # Spec helper methods
 
-  def stub_the_compiler(options = {:stub_methods => [:store_content]})
-    # Build a resource catalog suitable for specifying the behavior of the
-    # static compiler.
-    compiler = mock('indirection terminus compiler')
-    compiler.stubs(:find).returns(build_catalog(options))
-    subject.stubs(:compiler).returns(compiler)
-    # Mock the store content method to prevent copying the contents to the
-    # file bucket.
-    (options[:stub_methods] || []).each do |mthd|
-      subject.stubs(mthd)
-    end
-  end
-
   def build_catalog(options = {})
     options = options.dup
     options[:source] ||= 'puppet:///modules/mymodule/config_file.txt'

data/spec/unit/indirector/data_binding/none_spec.rb

@@ -20,9 +20,9 @@ describe Puppet::DataBinding::None do
   end
 
   describe "the behavior of the find method" do
-    it "should just return nil" do
+    it "should just throw :no_such_key" do
       data_binding = Puppet::DataBinding::None.new
-      expect(data_binding.find('fake_request')).to be_nil
+      expect { data_binding.find('fake_request') }.to throw_symbol(:no_such_key)
     end
   end
 end

data/spec/unit/indirector/file_bucket_file/file_spec.rb

@@ -109,6 +109,57 @@ describe Puppet::FileBucketFile::File, :uses_checksums => true do
         let(:not_bucketed_plaintext) { "other stuff" }
         let(:not_bucketed_checksum) { digest(not_bucketed_plaintext) }
 
+        describe "when listing the filebucket" do
+          it "should return false/nil when the bucket is empty" do
+            expect(Puppet::FileBucket::File.indirection.find("#{digest_algorithm}/#{not_bucketed_checksum}/foo/bar", :list_all => true)).to eq(nil)
+          end
+
+          it "raises when the request is remote" do
+            Puppet[:bucketdir] = tmpdir('bucket')
+
+            request = Puppet::Indirector::Request.new(:file_bucket_file, :find, "#{digest_algorithm}/#{checksum}/foo/bar", nil, :list_all => true)
+            request.node = 'client.example.com'
+
+            expect {
+              Puppet::FileBucketFile::File.new.find(request)
+            }.to raise_error(Puppet::Error, "Listing remote file buckets is not allowed")
+          end
+
+          it "should return the list of bucketed files in a human readable way" do
+            checksum1 = save_bucket_file("I'm the contents of a file", '/foo/bar1')
+            checksum2 = save_bucket_file("I'm the contents of another file", '/foo/bar2')
+            checksum3 = save_bucket_file("I'm the modified content of a existing file", '/foo/bar1')
+
+            # Use the first checksum as we know it's stored in the bucket
+            find_result = Puppet::FileBucket::File.indirection.find("#{digest_algorithm}/#{checksum1}/foo/bar1", :list_all => true)
+
+            # The list is sort order from date and file name, so first and third checksums come before the second
+            date_pattern = '\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}'
+            expect(find_result.to_s).to match(Regexp.new("^#{checksum1} #{date_pattern} foo/bar1\\n#{checksum3} #{date_pattern} foo/bar1\\n#{checksum2} #{date_pattern} foo/bar2\\n$"))
+          end
+
+          it "should fail in an informative way when provided dates are not in the right format" do
+            contents = "I'm the contents of a file"
+            save_bucket_file(contents, '/foo/bar1')
+            expect {
+              Puppet::FileBucket::File.indirection.find(
+                "#{digest_algorithm}/#{not_bucketed_checksum}/foo/bar",
+                :list_all => true,
+                :todate => "0:0:0 1-1-1970",
+                :fromdate => "WEIRD"
+              )
+            }.to raise_error(Puppet::Error, /fromdate/)
+            expect {
+              Puppet::FileBucket::File.indirection.find(
+                "#{digest_algorithm}/#{not_bucketed_checksum}/foo/bar",
+                :list_all => true,
+                :todate => "WEIRD",
+                :fromdate => Time.now
+              )
+            }.to raise_error(Puppet::Error, /todate/)
+          end
+        end
+
         describe "when supplying a path" do
           it "should return false/nil if the file isn't bucketed" do
             expect(Puppet::FileBucket::File.indirection.head("#{digest_algorithm}/#{not_bucketed_checksum}/foo/bar")).to eq(false)
@@ -177,7 +228,7 @@ describe Puppet::FileBucketFile::File, :uses_checksums => true do
           checksum2 = save_bucket_file("foo\nbiz\nbaz")
 
           diff = Puppet::FileBucket::File.indirection.find("#{digest_algorithm}/#{checksum1}", :diff_with => checksum2)
-          expect(diff).to eq("2c2\n< bar\n---\n> biz\n")
+          expect(diff).to include("-bar\n+biz\n")
         end
 
         it "should raise an exception if the hash to diff against isn't found" do

data/spec/unit/indirector/indirection_spec.rb

@@ -115,7 +115,7 @@ describe Puppet::Indirector::Indirection do
   describe "when initializing" do
     # (LAK) I've no idea how to test this, really.
     it "should store a reference to itself before it consumes its options" do
-      expect { @indirection = Puppet::Indirector::Indirection.new(Object.new, :testingness, :not_valid_option) }.to raise_error
+      expect { @indirection = Puppet::Indirector::Indirection.new(Object.new, :testingness, :not_valid_option) }.to raise_error(NoMethodError, /undefined method/)
       expect(Puppet::Indirector::Indirection.instance(:testingness)).to be_instance_of(Puppet::Indirector::Indirection)
       Puppet::Indirector::Indirection.instance(:testingness).delete
     end
@@ -393,6 +393,17 @@ describe Puppet::Indirector::Indirection do
 
           @indirection.find("/my/key")
         end
+
+        it "should fail if saving to the cache fails but log the exception" do
+          @cache.stubs(:find).returns nil
+
+          @terminus.stubs(:find).returns(@instance)
+          @cache.stubs(:save).raises RuntimeError
+
+          Puppet.expects(:log_exception)
+
+          expect { @indirection.find("/my/key") }.to raise_error
+        end
       end
     end
 
@@ -509,7 +520,7 @@ describe Puppet::Indirector::Indirection do
 
           @cache.expects(:save).never
           @terminus.expects(:save).raises "eh"
-          expect { @indirection.save(@instance) }.to raise_error
+          expect { @indirection.save(@instance) }.to raise_error(RuntimeError, /eh/)
         end
       end
     end

data/spec/unit/indirector/request_spec.rb

@@ -116,32 +116,32 @@ describe Puppet::Indirector::Request do
       end
 
       it "should set the protocol to the URI scheme" do
-        expect(Puppet::Indirector::Request.new(:ind, :method, "http://host/an_environment", nil).protocol).to eq("http")
+        expect(Puppet::Indirector::Request.new(:ind, :method, "http://host/", nil).protocol).to eq("http")
       end
 
       it "should set the server if a server is provided" do
-        expect(Puppet::Indirector::Request.new(:ind, :method, "http://host/an_environment", nil).server).to eq("host")
+        expect(Puppet::Indirector::Request.new(:ind, :method, "http://host/", nil).server).to eq("host")
       end
 
       it "should set the server and port if both are provided" do
-        expect(Puppet::Indirector::Request.new(:ind, :method, "http://host:543/an_environment", nil).port).to eq(543)
+        expect(Puppet::Indirector::Request.new(:ind, :method, "http://host:543/", nil).port).to eq(543)
       end
 
       it "should default to the masterport if the URI scheme is 'puppet'" do
         Puppet[:masterport] = "321"
-        expect(Puppet::Indirector::Request.new(:ind, :method, "puppet://host/an_environment", nil).port).to eq(321)
+        expect(Puppet::Indirector::Request.new(:ind, :method, "puppet://host/", nil).port).to eq(321)
       end
 
       it "should use the provided port if the URI scheme is not 'puppet'" do
-        expect(Puppet::Indirector::Request.new(:ind, :method, "http://host/an_environment", nil).port).to eq(80)
+        expect(Puppet::Indirector::Request.new(:ind, :method, "http://host/", nil).port).to eq(80)
       end
 
-      it "should set the request key to the unescaped key part path from the URI" do
-        expect(Puppet::Indirector::Request.new(:ind, :method, "http://host/an_environment/terminus/stuff with spaces", nil).key).to eq("stuff with spaces")
+      it "should set the request key to the unescaped path from the URI" do
+        expect(Puppet::Indirector::Request.new(:ind, :method, "http://host/stuff with spaces", nil).key).to eq("stuff with spaces")
       end
 
       it "should set the :uri attribute to the full URI" do
-        expect(Puppet::Indirector::Request.new(:ind, :method, "http:///an_environment/stu ff", nil).uri).to eq('http:///an_environment/stu ff')
+        expect(Puppet::Indirector::Request.new(:ind, :method, "http:///a/path/stu ff", nil).uri).to eq('http:///a/path/stu ff')
       end
 
       it "should not parse relative URI" do

data/spec/unit/indirector/ssl_file_spec.rb

@@ -108,7 +108,7 @@ describe Puppet::Indirector::SslFile do
        "//?/c:/foo",
       ].each do |input|
         it "should resist directory traversal attacks (#{input.inspect})" do
-          expect { @searcher.path(input) }.to raise_error
+          expect { @searcher.path(input) }.to raise_error(ArgumentError, /invalid key/)
         end
       end
 

data/spec/unit/indirector/yaml_spec.rb

@@ -82,7 +82,7 @@ describe Puppet::Indirector::Yaml do
      "//?/c:/foo",
     ].each do |input|
       it "should resist directory traversal attacks (#{input.inspect})" do
-        expect { @store.path(input) }.to raise_error
+        expect { @store.path(input) }.to raise_error(ArgumentError)
       end
     end
   end

data/spec/unit/info_service_spec.rb

@@ -0,0 +1,236 @@
+require 'spec_helper'
+require 'puppet_spec/files'
+
+require 'puppet/pops'
+require 'puppet/info_service'
+require 'puppet/pops/evaluator/literal_evaluator'
+
+describe "Puppet::InfoService" do
+  context 'classes_per_environment service' do
+    include PuppetSpec::Files
+
+    let(:code_dir) do
+      dir_containing('manifests', {
+        'foo.pp' => <<-CODE,
+           class foo($foo_a, Integer $foo_b, String $foo_c = 'c default value') { }
+           class foo2($foo2_a, Integer $foo2_b, String $foo2_c = 'c default value') { }
+        CODE
+        'bar.pp' => <<-CODE,
+           class bar($bar_a, Integer $bar_b, String $bar_c = 'c default value') { }
+           class bar2($bar2_a, Integer $bar2_b, String $bar2_c = 'c default value') { }
+        CODE
+        'fee.pp' => <<-CODE,
+           class fee(Integer $fee_a = 1+1) { }
+        CODE
+        'fum.pp' => <<-CODE,
+           class fum($fum_a) { }
+        CODE
+        'nothing.pp' => <<-CODE,
+           # not much to see here, move along
+        CODE
+        'borked.pp' => <<-CODE,
+           class Borked($Herp+$Derp) {}
+        CODE
+       })
+    end
+
+    it "errors if not given a hash" do
+      expect{ Puppet::InfoService.classes_per_environment("you wassup?")}.to raise_error(ArgumentError, 'Given argument must be a Hash')
+    end
+
+    it "returns empty hash if given nothing" do
+      expect(Puppet::InfoService.classes_per_environment({})).to eq({})
+    end
+
+    it "produces classes and parameters from a given file" do
+      files = ['foo.pp'].map {|f| File.join(code_dir, f) }
+      result = Puppet::InfoService.classes_per_environment({'production' => files })
+      expect(result).to eq({
+        "production"=>{
+           "#{code_dir}/foo.pp"=>[
+             {:name=>"foo",
+               :params=>[
+                 {:name=>"foo_a"},
+                 {:name=>"foo_b", :type=>"Integer"},
+                 {:name=>"foo_c", :type=>"String", :default_literal=>"c default value"}
+               ]},
+             {:name=>"foo2",
+               :params=>[
+                 {:name=>"foo2_a"},
+                 {:name=>"foo2_b", :type=>"Integer"},
+                 {:name=>"foo2_c", :type=>"String", :default_literal=>"c default value"}
+               ]
+             }
+           ]} # end production env
+        })
+    end
+
+    it "produces classes and parameters from multiple files in same environment" do
+      files = ['foo.pp', 'bar.pp'].map {|f| File.join(code_dir, f) }
+      result = Puppet::InfoService.classes_per_environment({'production' => files })
+      expect(result).to eq({
+        "production"=>{
+           "#{code_dir}/foo.pp"=>[
+             {:name=>"foo",
+               :params=>[
+                 {:name=>"foo_a"},
+                 {:name=>"foo_b", :type=>"Integer"},
+                 {:name=>"foo_c", :type=>"String", :default_literal=>"c default value"}
+               ]},
+             {:name=>"foo2",
+               :params=>[
+                 {:name=>"foo2_a"},
+                 {:name=>"foo2_b", :type=>"Integer"},
+                 {:name=>"foo2_c", :type=>"String", :default_literal=>"c default value"}
+               ]
+             }
+           ],
+          "#{code_dir}/bar.pp"=>[
+            {:name=>"bar",
+              :params=>[
+                {:name=>"bar_a"},
+                {:name=>"bar_b", :type=>"Integer"},
+                {:name=>"bar_c", :type=>"String", :default_literal=>"c default value"}
+              ]},
+            {:name=>"bar2",
+              :params=>[
+                {:name=>"bar2_a"},
+                {:name=>"bar2_b", :type=>"Integer"},
+                {:name=>"bar2_c", :type=>"String", :default_literal=>"c default value"}
+              ]
+            }
+          ],
+
+          } # end production env
+        }
+      )
+    end
+
+    it "produces classes and parameters from multiple files in multiple environments" do
+      files_production = ['foo.pp', 'bar.pp'].map {|f| File.join(code_dir, f) }
+      files_test = ['fee.pp', 'fum.pp'].map {|f| File.join(code_dir, f) }
+      result = Puppet::InfoService.classes_per_environment({
+        'production' => files_production,
+        'test'       => files_test
+      })
+
+      expect(result).to eq({
+        "production"=>{
+           "#{code_dir}/foo.pp"=>[
+             {:name=>"foo",
+               :params=>[
+                 {:name=>"foo_a"},
+                 {:name=>"foo_b", :type=>"Integer"},
+                 {:name=>"foo_c", :type=>"String", :default_literal=>"c default value"}
+               ]},
+             {:name=>"foo2",
+               :params=>[
+                 {:name=>"foo2_a"},
+                 {:name=>"foo2_b", :type=>"Integer"},
+                 {:name=>"foo2_c", :type=>"String", :default_literal=>"c default value"}
+               ]
+             }
+           ],
+          "#{code_dir}/bar.pp"=>[
+            {:name=>"bar",
+              :params=>[
+                {:name=>"bar_a"},
+                {:name=>"bar_b", :type=>"Integer"},
+                {:name=>"bar_c", :type=>"String", :default_literal=>"c default value"}
+              ]},
+            {:name=>"bar2",
+              :params=>[
+                {:name=>"bar2_a"},
+                {:name=>"bar2_b", :type=>"Integer"},
+                {:name=>"bar2_c", :type=>"String", :default_literal=>"c default value"}
+                ]
+              }
+            ],
+          }, # end production env
+        "test"=>{
+           "#{code_dir}/fee.pp"=>[
+             {:name=>"fee",
+               :params=>[
+                 {:name=>"fee_a", :type=>"Integer", :default_source=>"1+1"}
+               ]},
+           ],
+          "#{code_dir}/fum.pp"=>[
+            {:name=>"fum",
+              :params=>[
+                {:name=>"fum_a"}
+              ]},
+          ],
+         } # end test env
+        }
+      )
+    end
+
+    it "avoids parsing file more than once when environments have same feature flag set" do
+      # in this version of puppet, all environments are equal in this respect
+      result = Puppet::Pops::Parser::EvaluatingParser.new.parse_file("#{code_dir}/fum.pp")
+      Puppet::Pops::Parser::EvaluatingParser.any_instance.expects(:parse_file).with("#{code_dir}/fum.pp").returns(result).once
+      files_production = ['fum.pp'].map {|f| File.join(code_dir, f) }
+      files_test       = files_production
+
+      result = Puppet::InfoService.classes_per_environment({
+        'production' => files_production,
+        'test'       => files_test
+        })
+       expect(result).to eq({
+        "production"=>{ "#{code_dir}/fum.pp"=>[ {:name=>"fum", :params=>[ {:name=>"fum_a"}]}]},
+        "test"      =>{ "#{code_dir}/fum.pp"=>[ {:name=>"fum", :params=>[ {:name=>"fum_a"}]}]}
+       }
+      )
+    end
+
+    it "produces expression string if a default value is not literal" do
+      files = ['fee.pp'].map {|f| File.join(code_dir, f) }
+      result = Puppet::InfoService.classes_per_environment({'production' => files })
+      expect(result).to eq({
+        "production"=>{
+           "#{code_dir}/fee.pp"=>[
+             {:name=>"fee",
+               :params=>[
+                 {:name=>"fee_a", :type=>"Integer", :default_source=>"1+1"}
+               ]},
+           ]} # end production env
+        })
+     end
+
+    it "produces no type entry if type is not given" do
+      files = ['fum.pp'].map {|f| File.join(code_dir, f) }
+      result = Puppet::InfoService.classes_per_environment({'production' => files })
+      expect(result).to eq({
+        "production"=>{
+           "#{code_dir}/fum.pp"=>[
+             {:name=>"fum",
+               :params=>[
+                 {:name=>"fum_a" }
+               ]},
+           ]} # end production env
+        })
+    end
+
+    it "produces error entry if file is broken" do
+      files = ['borked.pp'].map {|f| File.join(code_dir, f) }
+       result = Puppet::InfoService.classes_per_environment({'production' => files })
+       expect(result).to eq({
+         "production"=>{
+            "#{code_dir}/borked.pp"=>
+              {:error=>"Syntax error at '+' at #{code_dir}/borked.pp:1:30",
+              },
+            } # end production env
+         })
+    end
+
+    it "produces empty {} if parsed result has no classes" do
+      files = ['nothing.pp'].map {|f| File.join(code_dir, f) }
+       result = Puppet::InfoService.classes_per_environment({'production' => files })
+       expect(result).to eq({
+         "production"=>{
+            "#{code_dir}/nothing.pp"=> []
+              },
+         })
+    end
+  end
+end

data/spec/unit/module_tool/application_spec.rb

@@ -18,7 +18,7 @@ describe Puppet::ModuleTool::Applications::Application do
 
     bad_versions.each do |ver|
       it "should not accept version string #{ver}" do
-        expect { app.parse_filename("puppetlabs-ntp-#{ver}") }.to raise_error
+        expect { app.parse_filename("puppetlabs-ntp-#{ver}") }.to raise_error(ArgumentError, /(Invalid version format|Could not parse filename)/)
       end
     end
   end

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

@@ -319,7 +319,7 @@ symlinkfile
       end
 
       it "give an error about symlinks" do
-        expect { builder.run }.to raise_error
+        expect { builder.run }.to raise_error(Puppet::ModuleTool::Errors::ModuleToolError, /Found symlinks/)
       end
     end
 

data/spec/unit/module_tool/metadata_spec.rb

@@ -9,7 +9,7 @@ describe Puppet::ModuleTool::Metadata do
     subject { metadata }
 
     %w[ name version author summary license source project_page issues_url
-    dependencies dashed_name release_name description ].each do |prop|
+    dependencies dashed_name release_name description data_provider].each do |prop|
       describe "##{prop}" do
         it "responds to the property" do
           subject.send(prop)
@@ -224,6 +224,35 @@ describe Puppet::ModuleTool::Metadata do
         expect(subject.dependencies.size).to eq(1)
       end
     end
+
+    context 'with valid data_provider' do
+      let(:data) { {'data_provider' => 'the_name'} }
+
+      it 'validates the provider correctly' do
+        expect { subject }.not_to raise_error
+      end
+
+      it 'returns the provider' do
+        expect(subject.data_provider).to eq('the_name')
+      end
+    end
+
+    context 'with invalid data_provider' do
+      let(:data) { }
+
+      it "raises exception unless argument starts with a letter" do
+        expect { metadata.update('data_provider' => '_the_name') }.to raise_error(ArgumentError, /field 'data_provider' must begin with a letter/)
+        expect { metadata.update('data_provider' => '') }.to raise_error(ArgumentError, /field 'data_provider' must begin with a letter/)
+      end
+
+      it "raises exception if argument contains non-alphanumeric characters" do
+        expect { metadata.update('data_provider' => 'the::name') }.to raise_error(ArgumentError, /field 'data_provider' contains non-alphanumeric characters/)
+      end
+
+      it "raises exception unless argument is a string" do
+        expect { metadata.update('data_provider' => 23) }.to raise_error(ArgumentError, /field 'data_provider' must be a string/)
+      end
+    end
   end
 
   describe '#dashed_name' do
@@ -271,7 +300,7 @@ describe Puppet::ModuleTool::Metadata do
     subject { metadata.to_hash }
 
     it "contains the default set of keys" do
-      expect(subject.keys.sort).to eq(%w[ name version author summary license source issues_url project_page dependencies ].sort)
+      expect(subject.keys.sort).to eq(%w[ name version author summary license source issues_url project_page dependencies data_provider].sort)
     end
 
     describe "['license']" do