r10k 1.4.2 → 1.5.1

data/spec/unit/module/forge_spec.rb

@@ -47,19 +47,8 @@ describe R10K::Module::Forge do
     end
   end
 
-  describe "fetching the current version" do
-    subject { described_class.new('branan/eight_hundred', '/moduledir', '8.0.0') }
-
-    it "reads the metadata before returning the version from the metadata" do
-      metadata = subject.metadata
-      expect(metadata).to receive(:read)
-      expect(metadata).to receive(:version).and_return(R10K::SemVer.new('1.2.3'))
-      expect(subject.current_version).to eq(R10K::SemVer.new('1.2.3'))
-    end
-  end
-
   describe "properties" do
-    subject { described_class.new('branan/eight_hundred', '/moduledir', '8.0.0') }
+    subject { described_class.new('branan/eight_hundred', fixture_modulepath, '8.0.0') }
 
     it "sets the module type to :forge" do
       expect(subject.properties).to include(:type => :forge)
@@ -85,8 +74,6 @@ describe R10K::Module::Forge do
 
     subject { described_class.new('branan/eight_hundred', fixture_modulepath, '8.0.0') }
 
-    before { allow(R10K::Module::Metadata).to receive(:new).and_return metadata }
-
     describe "and the module is in sync" do
       before do
         allow(subject).to receive(:status).and_return :insync
@@ -184,13 +171,7 @@ describe R10K::Module::Forge do
 
   describe "determining the status" do
 
-    let(:metadata) { double 'metadata', :version => R10K::SemVer.new('8.0.0'), :author => 'branan', :exist? => true, :read => nil }
-
-    subject { described_class.new('branan/eight_hundred', '/moduledir', '8.0.0') }
-
-    before do
-      allow(R10K::Module::Metadata).to receive(:new).and_return metadata
-    end
+    subject { described_class.new('branan/eight_hundred', fixture_modulepath, '8.0.0') }
 
     it "is :absent if the module directory is absent" do
       allow(subject).to receive(:exist?).and_return false
@@ -199,7 +180,7 @@ describe R10K::Module::Forge do
 
     it "is :mismatched if there is no module metadata" do
       allow(subject).to receive(:exist?).and_return true
-      allow(metadata).to receive(:exist?).and_return false
+      allow(File).to receive(:exist?).and_return false
 
       expect(subject.status).to eq :mismatched
     end
@@ -207,7 +188,7 @@ describe R10K::Module::Forge do
     it "is :mismatched if the metadata author doesn't match the expected author" do
       allow(subject).to receive(:exist?).and_return true
 
-      allow(metadata).to receive(:author).and_return 'blargh'
+      allow(subject.metadata).to receive(:full_module_name).and_return 'blargh-blargh'
 
       expect(subject.status).to eq :mismatched
     end
@@ -215,8 +196,7 @@ describe R10K::Module::Forge do
     it "is :outdated if the metadata version doesn't match the expected version" do
       allow(subject).to receive(:exist?).and_return true
 
-      allow(metadata).to receive(:version).and_return R10K::SemVer.new('7.0.0')
-
+      allow(subject.metadata).to receive(:version).and_return '7.0.0'
       expect(subject.status).to eq :outdated
     end
 
@@ -228,22 +208,11 @@ describe R10K::Module::Forge do
   end
 
   describe "and the expected version is :latest", :vcr => true, :unless => (RUBY_VERSION == '1.8.7') do
-    subject { described_class.new('branan/eight_hundred', '/moduledir', :latest) }
-
-    let(:_metadata) do
-      double('metadata',
-             :version => R10K::SemVer.new('7.0.0'),
-             :author => 'branan',
-             :exist? => true,
-             :read   => nil)
-    end
-
-    before do
-      allow(R10K::Module::Metadata).to receive(:new).and_return _metadata
-    end
+    subject { described_class.new('branan/eight_hundred', fixture_modulepath, :latest) }
 
     it "sets the expected version based on the latest forge version" do
       allow(subject).to receive(:exist?).and_return true
+      allow(subject.metadata).to receive(:version).and_return '7.0.0'
       expect(subject.status).to eq :outdated
       expect(subject.expected_version).to eq R10K::SemVer.new('8.0.0')
     end

data/spec/unit/module/git_spec.rb

@@ -63,20 +63,16 @@ describe R10K::Module::Git do
     end
 
     it "sets the expected version" do
-      expect(subject.properties).to include(:expected => instance_of(R10K::Git::Ref))
+      expect(subject.properties).to include(:expected => 'master')
     end
 
     it "sets the actual version to the revision when the revision is available" do
-      head = double('head')
-      expect(subject.working_dir).to receive(:current).and_return(head)
-      expect(head).to receive(:sha1).and_return('35d3517e67ceeb4b485b56d4a14d38fb95516c92')
+      expect(subject.repo).to receive(:head).and_return('35d3517e67ceeb4b485b56d4a14d38fb95516c92')
       expect(subject.properties).to include(:actual => '35d3517e67ceeb4b485b56d4a14d38fb95516c92')
     end
 
-    it "sets the actual version (unresolvable) when the revision is unavailable" do
-      head = double('head')
-      expect(subject.working_dir).to receive(:current).and_return(head)
-      expect(head).to receive(:sha1).and_raise(ArgumentError)
+    it "sets the actual version to (unresolvable) when the revision is unavailable" do
+      expect(subject.repo).to receive(:head).and_return(nil)
       expect(subject.properties).to include(:actual => '(unresolvable)')
     end
   end
@@ -92,36 +88,9 @@ describe R10K::Module::Git do
       )
     end
 
-    it "is absent when the working dir is absent" do
-      expect(subject.working_dir).to receive(:exist?).and_return false
-      expect(subject.status).to eq :absent
-    end
-
-    it "is mismatched Then the working dir is not a git repository" do
-      allow(subject.working_dir).to receive(:exist?).and_return true
-      expect(subject.working_dir).to receive(:git?).and_return false
-      expect(subject.status).to eq :mismatched
-    end
-
-    it "is mismatched when the expected remote does not match the actual remote" do
-      allow(subject.working_dir).to receive(:exist?).and_return true
-      expect(subject.working_dir).to receive(:git?).and_return true
-      expect(subject.working_dir).to receive(:remote).and_return 'nope'
-      expect(subject.status).to eq :mismatched
-    end
-
-    it "is outdated when the working dir is outdated" do
-      allow(subject.working_dir).to receive(:exist?).and_return true
-      expect(subject.working_dir).to receive(:git?).and_return true
-      expect(subject.working_dir).to receive(:outdated?).and_return true
-      expect(subject.status).to eq :outdated
-    end
-
-    it "is insync if all other conditions are satisfied" do
-      allow(subject.working_dir).to receive(:exist?).and_return true
-      expect(subject.working_dir).to receive(:git?).and_return true
-      expect(subject.working_dir).to receive(:outdated?).and_return false
-      expect(subject.status).to eq :insync
+    it "delegates to the repo" do
+      expect(subject.repo).to receive(:status).and_return :some_status
+      expect(subject.status).to eq(:some_status)
     end
   end
 end

data/spec/unit/module/metadata_file_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+require 'shared/puppet/module_tool/metadata'
+
+describe R10K::Module::MetadataFile do
+
+  let(:path) { double 'pathname' }
+
+  subject(:metadata_file) { described_class.new(path) }
+
+  describe "determining if the metadata file exists" do
+    it "doesn't exist if the given path isn't a file" do
+      allow(path).to receive(:file?).and_return false
+      expect(metadata_file).to_not be_exist
+    end
+
+    it "doesn't exist if the given path is an unreadable file" do
+      allow(path).to receive(:file?).and_return true
+      allow(path).to receive(:readable?).and_return false
+
+      expect(metadata_file).to_not be_exist
+    end
+
+    it "exists if the given path exists and is readable" do
+      allow(path).to receive(:file?).and_return true
+      allow(path).to receive(:readable?).and_return true
+
+      expect(metadata_file).to be_exist
+    end
+  end
+
+  describe "parsing a metadata file" do
+    let(:fixture_path) do
+      fixture_path = Pathname.new(File.expand_path('spec/fixtures/module/forge/eight_hundred/metadata.json', PROJECT_ROOT))
+    end
+
+    before do
+      a_metadata_file = R10K::Module::MetadataFile.new(fixture_path)
+      @metadata = a_metadata_file.read
+    end
+
+    it "extracts the module name" do
+      expect(@metadata.name).to eq 'eight_hundred'
+    end
+
+    it "extracts the full module name" do
+      expect(@metadata.full_module_name).to eq 'branan-eight_hundred'
+    end
+
+    it "extracts the module author" do
+      expect(@metadata.author).to eq 'Branan Purvine-Riley'
+    end
+
+    it "extracts the module version" do
+      expect(@metadata.version).to eq '8.0.0'
+    end
+  end
+
+  describe "parsing an invalid metadata file" do
+    let(:fixture_path) do
+      fixture_path = Pathname.new(File.expand_path('spec/fixtures/module/forge/bad_module/metadata.json', PROJECT_ROOT))
+    end
+
+    it "raises an error" do
+      a_metadata_file = R10K::Module::MetadataFile.new(fixture_path)
+      expect {a_metadata_file.read}.to raise_error(R10K::Error, "Could not read metadata.json")
+    end
+  end
+
+end

data/spec/unit/module/svn_spec.rb

@@ -119,10 +119,6 @@ describe R10K::Module::SVN do
     end
   end
 
-  describe "and the expected version is :latest" do
-    it "sets the expected version based on the latest SVN revision"
-  end
-
   describe "synchronizing" do
 
     subject { described_class.new('foo', '/moduledir', :svn => 'https://github.com/adrienthebo/r10k-fixture-repo', :rev => 123) }

data/spec/unit/module_repository/forge_spec.rb

@@ -6,7 +6,12 @@ describe R10K::ModuleRepository::Forge do
 
   it "uses the official forge by default" do
     forge = described_class.new
-    expect(forge.forge).to eq 'forge.puppetlabs.com'
+    expect(forge.forge).to eq 'forgeapi.puppetlabs.com'
+  end
+
+  it "replaces old forge with forgeapi" do
+    forge = described_class.new(forge='forge.puppetlabs.com')
+    expect(forge.forge).to eq 'forgeapi.puppetlabs.com'
   end
 
   it "can use a private forge" do
@@ -28,5 +33,21 @@ describe R10K::ModuleRepository::Forge do
     it "can fetch the latest version of a given module" do
       expect(forge.latest_version('adrien/boolean')).to eq "1.0.1"
     end
+
+    it "ignores deleted releases" do
+      expect(forge.latest_version('r10ktesting/spotty')).to eq "0.3.0"
+    end
+  end
+
+  describe "it handles errors from forgeapi.puppetlabs.com", :vcr => true do
+    subject(:forge) { described_class.new }
+
+    before do
+      forge.conn.builder.insert_before(Faraday::Adapter::NetHttp, VCR::Middleware::Faraday)
+    end
+
+    it "raises an error for a non-existant module" do
+      expect { forge.versions('dne/dne') }.to raise_error(R10K::Error)
+    end
   end
 end

data/spec/unit/puppet/module_tool/metadata_spec.rb

@@ -0,0 +1,301 @@
+require 'spec_helper'
+require 'shared/puppet/module_tool/metadata'
+
+describe Puppet::ModuleTool::Metadata do
+  let(:data) { {} }
+  let(:metadata) { Puppet::ModuleTool::Metadata.new }
+
+  describe 'property lookups' do
+    subject { metadata }
+
+    %w[ name version author summary license source project_page issues_url
+    dependencies dashed_name release_name description ].each do |prop|
+      describe "##{prop}" do
+        it "responds to the property" do
+          subject.send(prop)
+        end
+      end
+    end
+  end
+
+  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
+        expect(subject.to_hash['author']).to eq('billgates')
+      end
+
+      it "extracts a module name from the name field" do
+        expect(subject.module_name).to eq('mymodule')
+      end
+
+      context "and existing author" do
+        before { metadata.update('author' => 'foo') }
+
+        it "avoids overwriting the existing author" do
+          expect(subject.to_hash['author']).to eq('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
+        expect(subject.to_hash['author']).to eq('foo')
+      end
+
+      context "and preexisting author" do
+        before { metadata.update('author' => 'bar') }
+
+        it "avoids overwriting the existing author" do
+          expect(subject.to_hash['author']).to eq('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
+            expect(subject.to_hash['project_page']).to eq('https://github.com/billgates/amazingness')
+          end
+
+          it "predicts a default issues_url" do
+            expect(subject.to_hash['issues_url']).to eq('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
+            expect(subject.to_hash['project_page']).to eq('https://github.com/billgates/amazingness')
+          end
+
+          it "predicts a default issues_url" do
+            expect(subject.to_hash['issues_url']).to eq('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
+          expect(subject.to_hash['project_page']).to be nil
+        end
+
+        it "does not predict a default issues_url" do
+          expect(subject.to_hash['issues_url']).to 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
+          expect(subject.to_hash['project_page']).to be nil
+        end
+
+        it "does not predict a default issues_url" do
+          expect(subject.to_hash['issues_url']).to be nil
+        end
+      end
+
+    end
+
+    context "with a valid dependency", :pending => "dependency resolution is not yet in scope" do
+      let(:data) { {'dependencies' => [{'name' => 'puppetlabs-goodmodule'}] }}
+
+      it "adds the dependency" do
+        expect(subject.dependencies.size).to eq(1)
+      end
+    end
+
+    context "with a invalid dependency name" do
+      let(:data) { {'dependencies' => [{'name' => 'puppetlabsbadmodule'}] }}
+
+      it "raises an exception" do
+        expect { subject }.to raise_error(ArgumentError)
+      end
+    end
+
+    context "with a valid dependency version range", :pending => "dependency resolution is not yet in scope" do
+      let(:data) { {'dependencies' => [{'name' => 'puppetlabs-badmodule', 'version_requirement' => '>= 2.0.0'}] }}
+
+      it "adds the dependency" do
+        expect(subject.dependencies.size).to eq(1)
+      end
+    end
+
+    context "with a invalid version range" do
+      let(:data) { {'dependencies' => [{'name' => 'puppetlabsbadmodule', 'version_requirement' => '>= banana'}] }}
+
+      it "raises an exception" do
+        expect { subject }.to raise_error(ArgumentError)
+      end
+    end
+
+    context "with duplicate dependencies", :pending => "dependency resolution is not yet in scope" do
+      let(:data) { {'dependencies' => [{'name' => 'puppetlabs-dupmodule', 'version_requirement' => '1.0.0'},
+        {'name' => 'puppetlabs-dupmodule', 'version_requirement' => '0.0.1'}] }
+      }
+
+      it "raises an exception" do
+        expect { subject }.to raise_error(ArgumentError)
+      end
+    end
+
+    context "adding a duplicate dependency", :pending => "dependency resolution is not yet in scope" do
+      let(:data) { {'dependencies' => [{'name' => 'puppetlabs-origmodule', 'version_requirement' => '1.0.0'}] }}
+
+      it "with a different version raises an exception" do
+        metadata.add_dependency('puppetlabs-origmodule', '>= 0.0.1')
+        expect { subject }.to raise_error(ArgumentError)
+      end
+
+      it "with the same version does not add another dependency" do
+        metadata.add_dependency('puppetlabs-origmodule', '1.0.0')
+        expect(subject.dependencies.size).to eq(1)
+      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')
+      expect(data.dashed_name).to eq('foo-bar')
+    end
+
+    it 'properly handles slash-separated names' do
+      data = metadata.update('name' => 'foo/bar')
+      expect(data.dashed_name).to eq('foo-bar')
+    end
+
+    it 'is unaffected by author name' do
+      data = metadata.update('name' => 'foo/bar', 'author' => 'me')
+      expect(data.dashed_name).to eq('foo-bar')
+    end
+  end
+
+  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')
+      expect(data.release_name).to eq('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')
+      expect(data.release_name).to eq('foo-bar-1.0.0')
+    end
+  end
+
+  describe "#to_hash" 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)
+    end
+
+    describe "['license']" do
+      it "defaults to Apache 2" do
+        expect(subject['license']).to eq("Apache-2.0")
+      end
+    end
+
+    describe "['dependencies']" do
+      it "defaults to an empty set" do
+        expect(subject['dependencies']).to eq(Set.new)
+      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
+        expect(subject['license']).to eq('MIT')
+      end
+
+      it 'contains unanticipated values' do
+        expect(subject['non-standard']).to eq('yup')
+      end
+    end
+  end
+end