puppet 3.5.1-x86-mingw32 → 3.6.0.rc1-x86-mingw32

data/spec/unit/module_tool/metadata_spec.rb

@@ -2,23 +2,232 @@ require 'spec_helper'
 require 'puppet/module_tool'
 
 describe Puppet::ModuleTool::Metadata do
-  context "when using default values" do
-    it "should set license to 'Apache License, Version 2.0'" do
-      metadata = Puppet::ModuleTool::Metadata.new
-      metadata.license.should == "Apache License, Version 2.0"
+  let(:data) { {} }
+  let(:metadata) { Puppet::ModuleTool::Metadata.new }
+
+  describe "#update" do
+    subject { metadata.update(data) }
+
+    context "with a valid name" do
+      let(:data) { { 'name' => 'billgates-mymodule' } }
+
+      it "extracts the author name from the name field" do
+        subject.to_hash['author'].should == 'billgates'
+      end
+
+      it "extracts a module name from the name field" do
+        subject.module_name.should == 'mymodule'
+      end
+
+      context "and existing author" do
+        before { metadata.update('author' => 'foo') }
+
+        it "avoids overwriting the existing author" do
+          subject.to_hash['author'].should == 'foo'
+        end
+      end
+    end
+
+    context "with a valid name and author" do
+      let(:data) { { 'name' => 'billgates-mymodule', 'author' => 'foo' } }
+
+      it "use the author name from the author field" do
+        subject.to_hash['author'].should == 'foo'
+      end
+
+      context "and preexisting author" do
+        before { metadata.update('author' => 'bar') }
+
+        it "avoids overwriting the existing author" do
+          subject.to_hash['author'].should == 'foo'
+        end
+      end
+    end
+
+    context "with an invalid name" do
+      context "(short module name)" do
+        let(:data) { { 'name' => 'mymodule' } }
+
+        it "raises an exception" do
+          expect { subject }.to raise_error(ArgumentError, "Invalid 'name' field in metadata.json: the field must be a namespaced module name")
+        end
+      end
+
+      context "(missing namespace)" do
+        let(:data) { { 'name' => '/mymodule' } }
+
+        it "raises an exception" do
+          expect { subject }.to raise_error(ArgumentError, "Invalid 'name' field in metadata.json: the field must be a namespaced module name")
+        end
+      end
+
+      context "(missing module name)" do
+        let(:data) { { 'name' => 'namespace/' } }
+
+        it "raises an exception" do
+          expect { subject }.to raise_error(ArgumentError, "Invalid 'name' field in metadata.json: the field must be a namespaced module name")
+        end
+      end
+
+      context "(invalid namespace)" do
+        let(:data) { { 'name' => "dolla'bill$-mymodule" } }
+
+        it "raises an exception" do
+          expect { subject }.to raise_error(ArgumentError, "Invalid 'name' field in metadata.json: the namespace contains non-alphanumeric characters")
+        end
+      end
+
+      context "(non-alphanumeric module name)" do
+        let(:data) { { 'name' => "dollabils-fivedolla'" } }
+
+        it "raises an exception" do
+          expect { subject }.to raise_error(ArgumentError, "Invalid 'name' field in metadata.json: the module name contains non-alphanumeric (or underscore) characters")
+        end
+      end
+
+      context "(module name starts with a number)" do
+        let(:data) { { 'name' => "dollabills-5dollars" } }
+
+        it "raises an exception" do
+          expect { subject }.to raise_error(ArgumentError, "Invalid 'name' field in metadata.json: the module name must begin with a letter")
+        end
+      end
+    end
+
+
+    context "with an invalid version" do
+      let(:data) { { 'version' => '3.0' } }
+
+      it "raises an exception" do
+        expect { subject }.to raise_error(ArgumentError, "Invalid 'version' field in metadata.json: version string cannot be parsed as a valid Semantic Version")
+      end
+    end
+
+    context "with a valid source" do
+      context "which is a GitHub URL" do
+        context "with a scheme" do
+          before { metadata.update('source' => 'https://github.com/billgates/amazingness') }
+
+          it "predicts a default project_page" do
+            subject.to_hash['project_page'].should == 'https://github.com/billgates/amazingness'
+          end
+
+          it "predicts a default issues_url" do
+            subject.to_hash['issues_url'].should == 'https://github.com/billgates/amazingness/issues'
+          end
+        end
+
+        context "without a scheme" do
+          before { metadata.update('source' => 'github.com/billgates/amazingness') }
+
+          it "predicts a default project_page" do
+            subject.to_hash['project_page'].should == 'https://github.com/billgates/amazingness'
+          end
+
+          it "predicts a default issues_url" do
+            subject.to_hash['issues_url'].should == 'https://github.com/billgates/amazingness/issues'
+          end
+        end
+      end
+
+      context "which is not a GitHub URL" do
+        before { metadata.update('source' => 'https://notgithub.com/billgates/amazingness') }
+
+        it "does not predict a default project_page" do
+          subject.to_hash['project_page'].should be nil
+        end
+
+        it "does not predict a default issues_url" do
+          subject.to_hash['issues_url'].should be nil
+        end
+      end
+
+      context "which is not a URL" do
+        before { metadata.update('source' => 'my brain') }
+
+        it "does not predict a default project_page" do
+          subject.to_hash['project_page'].should be nil
+        end
+
+        it "does not predict a default issues_url" do
+          subject.to_hash['issues_url'].should be nil
+        end
+      end
+
+    end
+
+  end
+
+  describe '#dashed_name' do
+    it 'returns nil in the absence of a module name' do
+      expect(metadata.update('version' => '1.0.0').release_name).to be_nil
+    end
+
+    it 'returns a hyphenated string containing namespace and module name' do
+      data = metadata.update('name' => 'foo-bar')
+      data.dashed_name.should == 'foo-bar'
+    end
+
+    it 'properly handles slash-separated names' do
+      data = metadata.update('name' => 'foo/bar')
+      data.dashed_name.should == 'foo-bar'
+    end
+
+    it 'is unaffected by author name' do
+      data = metadata.update('name' => 'foo/bar', 'author' => 'me')
+      data.dashed_name.should == 'foo-bar'
     end
   end
 
-  describe :to_hash do
-    it 'should merge extra_data in' do
-      metadata = Puppet::ModuleTool::Metadata.new
-      metadata.extra_metadata = {
-        'checksums' => 'badsums',
-        'special_key' => 'special'
-      }
-      meta_hash = metadata.to_hash
-      meta_hash['special_key'].should == 'special'
-      meta_hash['checksums'].should == {}
+  describe '#release_name' do
+    it 'returns nil in the absence of a module name' do
+      expect(metadata.update('version' => '1.0.0').release_name).to be_nil
+    end
+
+    it 'returns nil in the absence of a version' do
+      expect(metadata.update('name' => 'foo/bar').release_name).to be_nil
+    end
+
+    it 'returns a hyphenated string containing module name and version' do
+      data = metadata.update('name' => 'foo/bar', 'version' => '1.0.0')
+      data.release_name.should == 'foo-bar-1.0.0'
+    end
+
+    it 'is unaffected by author name' do
+      data = metadata.update('name' => 'foo/bar', 'version' => '1.0.0', 'author' => 'me')
+      data.release_name.should == 'foo-bar-1.0.0'
+    end
+  end
+
+  describe "#to_hash" do
+    subject { metadata.to_hash }
+
+    its(:keys) do
+      subject.sort.should == %w[ name version author summary license source issues_url project_page dependencies ].sort
+    end
+
+    describe "['license']" do
+      it "defaults to Apache 2" do
+        subject['license'].should == "Apache 2.0"
+      end
+    end
+
+    describe "['dependencies']" do
+      it "defaults to an empty Array" do
+        subject['dependencies'].should == []
+      end
+    end
+
+    context "when updated with non-default data" do
+      subject { metadata.update('license' => 'MIT', 'non-standard' => 'yup').to_hash }
+
+      it "overrides the defaults" do
+        subject['license'].should == 'MIT'
+      end
+
+      it 'contains unanticipated values' do
+        subject['non-standard'].should == 'yup'
+      end
     end
   end
 end

data/spec/unit/module_tool/tar/gnu_spec.rb

@@ -2,21 +2,24 @@ require 'spec_helper'
 require 'puppet/module_tool'
 
 describe Puppet::ModuleTool::Tar::Gnu do
-  let(:sourcefile) { '/the/module.tar.gz' }
-  let(:destdir)    { '/the/dest/dir' }
-  let(:sourcedir)  { '/the/src/dir' }
-  let(:destfile)   { '/the/dest/file.tar.gz' }
+  let(:sourcefile) { '/space path/the/module.tar.gz' }
+  let(:destdir)    { '/space path/the/dest/dir' }
+  let(:sourcedir)  { '/space path/the/src/dir' }
+  let(:destfile)   { '/space path/the/dest/file.tar.gz' }
 
   it "unpacks a tar file" do
-    Puppet::Util::Execution.expects(:execute).with("tar xzf #{sourcefile} --no-same-owner -C #{destdir}")
-    Puppet::Util::Execution.expects(:execute).with("find #{destdir} -type d -exec chmod 755 {} +")
-    Puppet::Util::Execution.expects(:execute).with("find #{destdir} -type f -exec chmod a-wst {} +")
-    Puppet::Util::Execution.expects(:execute).with("chown -R <owner:group> #{destdir}")
+    Dir.expects(:chdir).with(File.expand_path(destdir)).yields(mock)
+    Puppet::Util::Execution.expects(:execute).with(["gzip", "-dc", File.expand_path(sourcefile)])
+    Puppet::Util::Execution.expects(:execpipe).with(["tar", "xof", "-"], true, 'w+')
+    Puppet::Util::Execution.expects(:execute).with(["find", File.expand_path(destdir), "-type", "d", "-exec", "chmod", "755", "{}", "+"])
+    Puppet::Util::Execution.expects(:execute).with(["find", File.expand_path(destdir), "-type", "f", "-exec", "chmod", "a-wst", "{}", "+"])
+    Puppet::Util::Execution.expects(:execute).with(["chown", "-R", "<owner:group>", File.expand_path(destdir)])
     subject.unpack(sourcefile, destdir, '<owner:group>')
   end
 
   it "packs a tar file" do
-    Puppet::Util::Execution.expects(:execute).with("tar cf - #{sourcedir} | gzip -c > #{destfile}")
+    Puppet::Util::Execution.expects(:execute).with(["tar", "cf", "-", sourcedir])
+    Puppet::Util::Execution.expects(:execpipe).with(["gzip", "-c"], true, 'w+')
     subject.pack(sourcedir, destfile)
   end
 end

data/spec/unit/module_tool/tar/mini_spec.rb

@@ -6,7 +6,7 @@ describe Puppet::ModuleTool::Tar::Mini, :if => (Puppet.features.minitar? and Pup
   let(:destdir)    { File.expand_path '/the/dest/dir' }
   let(:sourcedir)  { '/the/src/dir' }
   let(:destfile)   { '/the/dest/file.tar.gz' }
-  let(:minitar)    { described_class.new('nginx') }
+  let(:minitar)    { described_class.new }
 
   it "unpacks a tar file" do
     unpacks_the_entry(:file_start, 'thefile')

data/spec/unit/module_tool/tar_spec.rb

@@ -1,28 +1,14 @@
 require 'spec_helper'
-require 'puppet/module_tool'
+require 'puppet/module_tool/tar'
 
 describe Puppet::ModuleTool::Tar do
 
-  it "uses gtar when present on Solaris" do
-    Facter.stubs(:value).with('osfamily').returns 'Solaris'
-    Puppet::Util.stubs(:which).with('gtar').returns '/usr/bin/gtar'
-
-    described_class.instance(nil).should be_a_kind_of Puppet::ModuleTool::Tar::Solaris
-  end
-
-  it "uses gtar when present on OpenBSD" do
-    Facter.stubs(:value).with('osfamily').returns 'OpenBSD'
-    Puppet::Util.stubs(:which).with('gtar').returns '/usr/bin/gtar'
-
-    described_class.instance(nil).should be_a_kind_of Puppet::ModuleTool::Tar::Solaris
-  end
-
   it "uses tar when present and not on Windows" do
     Facter.stubs(:value).with('osfamily').returns 'ObscureLinuxDistro'
     Puppet::Util.stubs(:which).with('tar').returns '/usr/bin/tar'
     Puppet::Util::Platform.stubs(:windows?).returns false
 
-    described_class.instance(nil).should be_a_kind_of Puppet::ModuleTool::Tar::Gnu
+    described_class.instance.should be_a_kind_of Puppet::ModuleTool::Tar::Gnu
   end
 
   it "falls back to minitar when it and zlib are present" do
@@ -31,7 +17,7 @@ describe Puppet::ModuleTool::Tar do
     Puppet::Util::Platform.stubs(:windows?).returns true
     Puppet.stubs(:features).returns(stub(:minitar? => true, :zlib? => true))
 
-    described_class.instance(nil).should be_a_kind_of Puppet::ModuleTool::Tar::Mini
+    described_class.instance.should be_a_kind_of Puppet::ModuleTool::Tar::Mini
   end
 
   it "fails when there is no possible implementation" do
@@ -40,6 +26,6 @@ describe Puppet::ModuleTool::Tar do
     Puppet::Util::Platform.stubs(:windows?).returns true
     Puppet.stubs(:features).returns(stub(:minitar? => false, :zlib? => false))
 
-    expect { described_class.instance(nil) }.to raise_error RuntimeError, /No suitable tar/
+    expect { described_class.instance }.to raise_error RuntimeError, /No suitable tar/
   end
 end

data/spec/unit/module_tool_spec.rb

@@ -6,14 +6,25 @@ require 'puppet/module_tool'
 
 describe Puppet::ModuleTool do
   describe '.is_module_root?' do
-    it 'should return true if directory has a module file' do
+    it 'should return true if directory has a Modulefile file' do
+      FileTest.expects(:file?).with(responds_with(:to_s, '/a/b/c/metadata.json')).
+        returns(false)
       FileTest.expects(:file?).with(responds_with(:to_s, '/a/b/c/Modulefile')).
         returns(true)
 
       subject.is_module_root?(Pathname.new('/a/b/c')).should be_true
     end
 
-    it 'should return false if directory does not have a module file' do
+    it 'should return true if directory has a metadata.json file' do
+      FileTest.expects(:file?).with(responds_with(:to_s, '/a/b/c/metadata.json')).
+        returns(true)
+
+      subject.is_module_root?(Pathname.new('/a/b/c')).should be_true
+    end
+
+    it 'should return false if directory does not have a metadata.json or a Modulefile file' do
+      FileTest.expects(:file?).with(responds_with(:to_s, '/a/b/c/metadata.json')).
+        returns(false)
       FileTest.expects(:file?).with(responds_with(:to_s, '/a/b/c/Modulefile')).
         returns(false)
 
@@ -155,48 +166,133 @@ TREE
 
   describe '.set_option_defaults' do
     let(:options) { {} }
-    let(:modulepath) { [File.expand_path('/env/module/path'), File.expand_path('/global/module/path')] }
-    let(:environment) { Puppet::Node::Environment.create('current', modulepath) }
-    around(:each) do |example|
-      Puppet.override(:current_environment => environment) do
+    let(:modulepath) { ['/env/module/path', '/global/module/path'] }
+    let(:environment_name) { :current_environment }
+    let(:environment) { Puppet::Node::Environment.create(environment_name, modulepath) }
+
+    subject do
+      described_class.set_option_defaults(options)
+      options
+    end
+
+    around do |example|
+      envs = Puppet::Environments::Combined.new(
+        Puppet::Environments::Static.new(environment),
+        Puppet::Environments::Legacy.new
+      )
+
+      Puppet.override(:environments => envs) do
         example.run
       end
     end
 
-    describe 'option :environment_instance' do
-      it 'adds an environment_instance to the options hash' do
-        subject.set_option_defaults(options)
-        expect(options[:environment_instance].name).to eq(environment.name)
-        expect(options[:environment_instance].modulepath).to eq(environment.modulepath)
+    describe ':environment' do
+      context 'as String' do
+        let(:options) { { :environment => "#{environment_name}" } }
+
+        it 'assigns the environment with the given name to :environment_instance' do
+          expect(subject).to include :environment_instance => environment
+        end
+      end
+
+      context 'as Symbol' do
+        let(:options) { { :environment => :"#{environment_name}" } }
+
+        it 'assigns the environment with the given name to :environment_instance' do
+          expect(subject).to include :environment_instance => environment
+        end
+      end
+
+      context 'as Puppet::Node::Environment' do
+        let(:env) { Puppet::Node::Environment.create('anonymous', []) }
+        let(:options) { { :environment => env } }
+
+        it 'assigns the given environment to :environment_instance' do
+          expect(subject).to include :environment_instance => env
+        end
       end
     end
 
-    describe 'option :target_dir' do
-      let (:target_dir) { 'boo' }
+    describe ':modulepath' do
+      let(:options) do
+        { :modulepath => %w[bar foo baz].join(File::PATH_SEPARATOR) }
+      end
 
-      context 'passed:' do
-        let (:options) { {:target_dir => target_dir} }
+      let(:paths) { options[:modulepath].split(File::PATH_SEPARATOR).map { |dir| File.expand_path(dir) } }
 
-        it 'prepends the target_dir into the environment_instance modulepath' do
-          subject.set_option_defaults options
+      it 'is expanded to an absolute path' do
+        expect(subject[:environment_instance].full_modulepath).to eql paths
+      end
 
-          expect(options[:environment_instance].full_modulepath).
-            to eq([File.expand_path(target_dir)] + modulepath)
+      it 'is used to compute :target_dir' do
+        expect(subject).to include :target_dir => paths.first
+      end
+
+      context 'conflicts with :environment' do
+        let(:options) do
+          { :modulepath => %w[bar foo baz].join(File::PATH_SEPARATOR), :environment => environment_name }
         end
 
-        it 'expands the target dir' do
-          subject.set_option_defaults options
+        it 'replaces the modulepath of the :environment_instance' do
+          expect(subject[:environment_instance].full_modulepath).to eql paths
+        end
 
-          options[:target_dir].should == File.expand_path(target_dir)
+        it 'is used to compute :target_dir' do
+          expect(subject).to include :target_dir => paths.first
         end
       end
+    end
+
+    describe ':target_dir' do
+      let(:options) do
+        { :target_dir => 'foo' }
+      end
+
+      let(:target) { File.expand_path(options[:target_dir]) }
+
+      it 'is expanded to an absolute path' do
+        expect(subject).to include :target_dir => target
+      end
+
+      it 'is prepended to the modulepath of the :environment_instance' do
+        expect(subject[:environment_instance].full_modulepath.first).to eql target
+      end
+
+      context 'conflicts with :modulepath' do
+        let(:options) do
+          { :target_dir => 'foo', :modulepath => %w[bar foo baz].join(File::PATH_SEPARATOR) }
+        end
 
-      context 'NOT passed:' do
-        it 'the option should be set to the first component of Puppet[:modulepath]' do
-          options = Hash.new
-          subject.set_option_defaults options
+        it 'is prepended to the modulepath of the :environment_instance' do
+          expect(subject[:environment_instance].full_modulepath.first).to eql target
+        end
+
+        it 'shares the provided :modulepath via the :environment_instance' do
+          paths = %w[foo] + options[:modulepath].split(File::PATH_SEPARATOR)
+          paths.map! { |dir| File.expand_path(dir) }
+          expect(subject[:environment_instance].full_modulepath).to eql paths
+        end
+      end
+
+      context 'conflicts with :environment' do
+        let(:options) do
+          { :target_dir => 'foo', :environment => environment_name }
+        end
+
+        it 'is prepended to the modulepath of the :environment_instance' do
+          expect(subject[:environment_instance].full_modulepath.first).to eql target
+        end
+
+        it 'shares the provided :modulepath via the :environment_instance' do
+          paths = %w[foo] + environment.full_modulepath
+          paths.map! { |dir| File.expand_path(dir) }
+          expect(subject[:environment_instance].full_modulepath).to eql paths
+        end
+      end
 
-          expect(options[:target_dir]).to eq(environment.full_modulepath.first)
+      context 'when not passed' do
+        it 'is populated with the first component of the modulepath' do
+          expect(subject).to include :target_dir => subject[:environment_instance].full_modulepath.first
         end
       end
     end