r10k 3.15.0 → 4.1.0

data/spec/unit/module/forge_spec.rb

@@ -1,271 +0,0 @@
-require 'r10k/module/forge'
-require 'spec_helper'
-
-describe R10K::Module::Forge do
-  # TODO: make these *unit* tests not depend on a real module on the real Forge :(
-
-  include_context 'fail on execution'
-
-  let(:fixture_modulepath) { File.expand_path('spec/fixtures/module/forge', PROJECT_ROOT) }
-  let(:empty_modulepath) { File.expand_path('spec/fixtures/empty', PROJECT_ROOT) }
-
-  describe "statically determined version support" do
-    it 'returns explicitly released forge versions' do
-      static_version = described_class.statically_defined_version('branan/eight_hundred', { version: '8.0.0' })
-      expect(static_version).to eq('8.0.0')
-    end
-
-    it 'returns explicit pre-released forge versions' do
-      static_version = described_class.statically_defined_version('branan/eight_hundred', { version: '8.0.0-pre1' })
-      expect(static_version).to eq('8.0.0-pre1')
-    end
-
-    it 'retuns nil for latest versions' do
-      static_version = described_class.statically_defined_version('branan/eight_hundred', { version: :latest })
-      expect(static_version).to eq(nil)
-    end
-
-    it 'retuns nil for undefined versions' do
-      static_version = described_class.statically_defined_version('branan/eight_hundred', { version: nil })
-      expect(static_version).to eq(nil)
-    end
-  end
-
-  describe "implementing the Puppetfile spec" do
-    it "should implement 'branan/eight_hundred', '8.0.0'" do
-      expect(described_class).to be_implement('branan/eight_hundred', { type: 'forge', version: '8.0.0' })
-    end
-
-    it "should implement 'branan-eight_hundred', '8.0.0'" do
-      expect(described_class).to be_implement('branan-eight_hundred', { type: 'forge', version: '8.0.0' })
-    end
-  end
-
-  describe "implementing the standard options interface" do
-    it "should implement {type: forge}" do
-      expect(described_class).to be_implement('branan-eight_hundred', { type: 'forge', version: '8.0.0', source: 'not implemented' })
-    end
-  end
-
-  describe "setting attributes" do
-    subject { described_class.new('branan/eight_hundred', '/moduledir', { version: '8.0.0' }) }
-
-    it "sets the name" do
-      expect(subject.name).to eq 'eight_hundred'
-    end
-
-    it "sets the author" do
-      expect(subject.author).to eq 'branan'
-    end
-
-    it "sets the dirname" do
-      expect(subject.dirname).to eq '/moduledir'
-    end
-
-    it "sets the title" do
-      expect(subject.title).to eq 'branan-eight_hundred'
-    end
-  end
-
-  describe "invalid attributes" do
-    it "errors on invalid versions" do
-      expect { described_class.new('branan/eight_hundred', '/moduledir', { version: '_8.0.0_' }) }.to raise_error ArgumentError, /version/
-    end
-  end
-
-  describe "properties" do
-    subject { described_class.new('branan/eight_hundred', fixture_modulepath, { version: '8.0.0' }) }
-
-    it "sets the module type to :forge" do
-      expect(subject.properties).to include(:type => :forge)
-    end
-
-    it "sets the expected version" do
-      expect(subject.properties).to include(:expected => '8.0.0')
-    end
-
-    it "sets the actual version" do
-      expect(subject).to receive(:current_version).and_return('0.8.0')
-      expect(subject.properties).to include(:actual => '0.8.0')
-    end
-  end
-
-  context "when a module is deprecated" do
-    subject { described_class.new('puppetlabs/corosync', fixture_modulepath, { version: :latest }) }
-
-    it "warns on sync if module is not already insync" do
-      allow(subject).to receive(:status).and_return(:absent)
-
-      allow(R10K::Forge::ModuleRelease).to receive(:new).and_return(double('mod_release', install: true))
-
-      logger_dbl = double(Log4r::Logger)
-      allow_any_instance_of(described_class).to receive(:logger).and_return(logger_dbl)
-
-      allow(logger_dbl).to receive(:info).with(/Deploying module to.*/)
-      allow(logger_dbl).to receive(:debug2).with(/No spec dir detected/)
-      expect(logger_dbl).to receive(:warn).with(/puppet forge module.*puppetlabs-corosync.*has been deprecated/i)
-
-      subject.sync
-    end
-
-    it "does not warn on sync if module is already insync" do
-      allow(subject).to receive(:status).and_return(:insync)
-
-      logger_dbl = double(Log4r::Logger)
-      allow_any_instance_of(described_class).to receive(:logger).and_return(logger_dbl)
-
-      allow(logger_dbl).to receive(:info).with(/Deploying module to.*/)
-      allow(logger_dbl).to receive(:debug2).with(/No spec dir detected/)
-      expect(logger_dbl).to_not receive(:warn).with(/puppet forge module.*puppetlabs-corosync.*has been deprecated/i)
-
-      subject.sync
-    end
-  end
-
-  describe '#expected_version' do
-    it "returns an explicitly given expected version" do
-      subject = described_class.new('branan/eight_hundred', fixture_modulepath, { version: '8.0.0' })
-      expect(subject.expected_version).to eq '8.0.0'
-    end
-
-    it "uses the latest version from the forge when the version is :latest" do
-      subject = described_class.new('branan/eight_hundred', fixture_modulepath, { version: :latest })
-      release = double("Module Release", version: '8.8.8')
-      expect(subject.v3_module).to receive(:current_release).and_return(release).twice
-      expect(subject.expected_version).to eq '8.8.8'
-    end
-
-    it "throws when there are no available versions" do
-      subject = described_class.new('branan/eight_hundred', fixture_modulepath, { version: :latest })
-      expect(subject.v3_module).to receive(:current_release).and_return(nil)
-      expect { subject.expected_version }.to raise_error(PuppetForge::ReleaseNotFound)
-    end
-  end
-
-  describe "determining the status" do
-
-    subject { described_class.new('branan/eight_hundred', fixture_modulepath, { version: '8.0.0' }) }
-
-    it "is :absent if the module directory is absent" do
-      allow(subject).to receive(:exist?).and_return false
-      expect(subject.status).to eq :absent
-    end
-
-    it "is :mismatched if there is no module metadata" do
-      allow(subject).to receive(:exist?).and_return true
-      allow(File).to receive(:exist?).and_return false
-
-      expect(subject.status).to eq :mismatched
-    end
-
-    it "is :mismatched if module was previously a git checkout" do
-      allow(File).to receive(:directory?).and_return true
-
-      expect(subject.status).to eq :mismatched
-    end
-
-    it "is :mismatched if the metadata author doesn't match the expected author" do
-      allow(subject).to receive(:exist?).and_return true
-
-      allow(subject.instance_variable_get(:@metadata_file)).to receive(:read).and_return subject.metadata
-      allow(subject.metadata).to receive(:full_module_name).and_return 'blargh-blargh'
-
-      expect(subject.status).to eq :mismatched
-    end
-
-    it "is :outdated if the metadata version doesn't match the expected version" do
-      allow(subject).to receive(:exist?).and_return true
-
-      allow(subject.instance_variable_get(:@metadata_file)).to receive(:read).and_return subject.metadata
-      allow(subject.metadata).to receive(:version).and_return '7.0.0'
-      expect(subject.status).to eq :outdated
-    end
-
-    it "is :insync if the version and the author are in sync" do
-      allow(subject).to receive(:exist?).and_return true
-
-      expect(subject.status).to eq :insync
-    end
-  end
-
-  describe "#sync" do
-    subject { described_class.new('branan/eight_hundred', fixture_modulepath, { version: '8.0.0' }) }
-
-    context "syncing the repo" do
-      let(:module_org) { "coolorg" }
-      let(:module_name) { "coolmod" }
-      let(:title) { "#{module_org}-#{module_name}" }
-      let(:dirname) { Pathname.new(Dir.mktmpdir) }
-      let(:spec_path) { dirname + module_name + 'spec' }
-      subject { described_class.new(title, dirname, {}) }
-
-      it 'defaults to keeping the spec dir' do
-        FileUtils.mkdir_p(spec_path)
-        expect(subject).to receive(:status).and_return(:absent)
-        expect(subject).to receive(:install)
-        subject.sync
-        expect(Dir.exist?(spec_path)).to eq true
-      end
-    end
-
-    it 'does nothing when the module is in sync' do
-      allow(subject).to receive(:status).and_return :insync
-
-      expect(subject).to receive(:install).never
-      expect(subject).to receive(:upgrade).never
-      expect(subject).to receive(:reinstall).never
-      expect(subject.sync).to be false
-    end
-
-    it 'reinstalls the module when it is mismatched' do
-      allow(subject).to receive(:status).and_return :mismatched
-      expect(subject).to receive(:reinstall)
-      expect(subject.sync).to be true
-    end
-
-    it 'upgrades the module when it is outdated' do
-      allow(subject).to receive(:status).and_return :outdated
-      expect(subject).to receive(:upgrade)
-      expect(subject.sync).to be true
-    end
-
-    it 'installs the module when it is absent' do
-      allow(subject).to receive(:status).and_return :absent
-      expect(subject).to receive(:install)
-      expect(subject.sync).to be true
-    end
-
-    it 'returns false if `should_sync?` is false' do
-      # modules do not sync if they are not requested
-      mod = described_class.new('my_org/my_mod', '/path/to/mod', { overrides: { modules: { requested_modules: ['other_mod'] } } })
-      expect(mod.sync).to be false
-    end
-  end
-
-  describe '#install' do
-    it 'installs the module from the forge' do
-      subject = described_class.new('branan/eight_hundred', fixture_modulepath, { version: '8.0.0' })
-      release = instance_double('R10K::Forge::ModuleRelease')
-      expect(R10K::Forge::ModuleRelease).to receive(:new).with('branan-eight_hundred', '8.0.0').and_return(release)
-      expect(release).to receive(:install).with(subject.path)
-      subject.install
-    end
-  end
-
-  describe '#uninstall' do
-    it 'removes the module path' do
-      subject = described_class.new('branan/eight_hundred', fixture_modulepath, { version: '8.0.0' })
-      expect(FileUtils).to receive(:rm_rf).with(subject.path.to_s)
-      subject.uninstall
-    end
-  end
-
-  describe '#reinstall' do
-    it 'uninstalls and then installs the module' do
-      subject = described_class.new('branan/eight_hundred', fixture_modulepath, { version: '8.0.0' })
-      expect(subject).to receive(:uninstall)
-      expect(subject).to receive(:install)
-      subject.reinstall
-    end
-  end
-end

data/spec/unit/module/git_spec.rb

@@ -1,387 +0,0 @@
-require 'spec_helper'
-require 'r10k/module/git'
-
-describe R10K::Module::Git do
-  let(:mock_repo) do
-    instance_double("R10K::Git::StatefulRepository")
-  end
-
-  before(:each) do
-    allow(R10K::Git::StatefulRepository).to receive(:new).and_return(mock_repo)
-  end
-
-
-  describe "statically determined version support" do
-    it 'returns a given commit' do
-      static_version = described_class.statically_defined_version('branan/eight_hundred', { git: 'my/remote', commit: '123adf' })
-      expect(static_version).to eq('123adf')
-    end
-
-    it 'returns a given tag' do
-      static_version = described_class.statically_defined_version('branan/eight_hundred', { git: 'my/remote', tag: 'v1.2.3' })
-      expect(static_version).to eq('v1.2.3')
-    end
-
-    it 'returns a ref if it looks like a full commit sha' do
-      static_version = described_class.statically_defined_version('branan/eight_hundred', { git: 'my/remote', ref: '1234567890abcdef1234567890abcdef12345678' })
-      expect(static_version).to eq('1234567890abcdef1234567890abcdef12345678')
-    end
-
-    it 'returns nil for any non-sha-like ref' do
-      static_version = described_class.statically_defined_version('branan/eight_hundred', { git: 'my/remote', ref: 'refs/heads/main' })
-      expect(static_version).to eq(nil)
-    end
-
-    it 'returns nil for branches' do
-      static_version = described_class.statically_defined_version('branan/eight_hundred', { git: 'my/remote', branch: 'main' })
-      expect(static_version).to eq(nil)
-    end
-  end
-
-  describe "setting the owner and name" do
-    describe "with a title of 'branan/eight_hundred'" do
-      subject do
-        described_class.new(
-          'branan/eight_hundred',
-          '/moduledir',
-          { :git => 'https://git-server.site/branan/puppet-eight_hundred' }
-        )
-      end
-
-      it "sets the owner to 'branan'" do
-        expect(subject.owner).to eq 'branan'
-      end
-
-      it "sets the name to 'eight_hundred'" do
-        expect(subject.name).to eq 'eight_hundred'
-      end
-
-      it "sets the path to '/moduledir/eight_hundred'" do
-        expect(subject.path).to eq(Pathname.new('/moduledir/eight_hundred'))
-      end
-    end
-
-    describe "with a title of 'modulename'" do
-      subject do
-        described_class.new(
-          'eight_hundred',
-          '/moduledir',
-          { :git => 'https://git-server.site/branan/puppet-eight_hundred' }
-        )
-      end
-
-      it "sets the owner to nil" do
-        expect(subject.owner).to be_nil
-      end
-
-      it "sets the name to 'eight_hundred'" do
-        expect(subject.name).to eq 'eight_hundred'
-      end
-
-      it "sets the path to '/moduledir/eight_hundred'" do
-        expect(subject.path).to eq(Pathname.new('/moduledir/eight_hundred'))
-      end
-    end
-  end
-
-  describe "properties" do
-    subject do
-      described_class.new('boolean', '/moduledir', {:git => 'https://git.example.com/adrienthebo/puppet-boolean'})
-    end
-
-    before(:each) do
-      allow(mock_repo).to receive(:resolve).with('master').and_return('abc123')
-      allow(mock_repo).to receive(:head).and_return('abc123')
-    end
-
-    it "sets the module type to :git" do
-      expect(subject.properties).to include(:type => :git)
-    end
-
-    it "sets the expected version" do
-      expect(subject.properties).to include(:expected => 'master')
-    end
-
-    it "sets the actual version to the revision when the revision is available" do
-      expect(mock_repo).to receive(:head).and_return('35d3517e67ceeb4b485b56d4a14d38fb95516c92')
-      expect(subject.properties).to include(:actual => '35d3517e67ceeb4b485b56d4a14d38fb95516c92')
-    end
-
-    it "sets the actual version to (unresolvable) when the revision is unavailable" do
-      expect(mock_repo).to receive(:head).and_return(nil)
-      expect(subject.properties).to include(:actual => '(unresolvable)')
-    end
-  end
-
-  describe 'syncing the repo' do
-    let(:module_org) { "coolorg" }
-    let(:module_name) { "coolmod" }
-    let(:title) { "#{module_org}-#{module_name}" }
-    let(:dirname) { Pathname.new(Dir.mktmpdir) }
-    let(:spec_path) { dirname + module_name + 'spec' }
-    subject { described_class.new(title, dirname, {}) }
-
-    before(:each) do
-      allow(mock_repo).to receive(:resolve).with('master').and_return('abc123')
-    end
-
-    it 'defaults to keeping the spec dir' do
-      FileUtils.mkdir_p(spec_path)
-      allow(mock_repo).to receive(:sync)
-      subject.sync
-      expect(Dir.exist?(spec_path)).to eq true
-    end
-
-    it 'returns true if repo was updated' do
-      expect(mock_repo).to receive(:sync).and_return(true)
-      expect(subject.sync).to be true
-    end
-
-    it 'returns false if repo was not updated (in-sync)' do
-      expect(mock_repo).to receive(:sync).and_return(false)
-      expect(subject.sync).to be false
-    end
-
-    it 'returns false if `should_sync?` is false' do
-      # modules do not sync if they are not requested
-      mod = described_class.new(title, dirname, { overrides: { modules: { requested_modules: ['other_mod'] } } })
-      expect(mod.sync).to be false
-    end
-  end
-
-  describe "determining the status" do
-    subject do
-      described_class.new(
-        'boolean',
-        '/moduledir',
-        { :git => 'https://git.example.com/adrienthebo/puppet-boolean' }
-      )
-    end
-
-    it "delegates to the repo" do
-      expect(subject).to receive(:version).and_return 'master'
-      expect(mock_repo).to receive(:status).with('master').and_return :some_status
-
-      expect(subject.status).to eq(:some_status)
-    end
-  end
-
-  describe "option parsing" do
-    def test_module(extra_opts, env=nil)
-      described_class.new('boolean', '/moduledir', base_opts.merge(extra_opts), env)
-    end
-
-    let(:base_opts) { { git: 'https://git.example.com/adrienthebo/puppet-boolean' } }
-
-    before(:each) do
-      allow(mock_repo).to receive(:head).and_return('abc123')
-    end
-
-    describe "desired ref" do
-      context "when no desired ref is given" do
-        it "defaults to master" do
-          expect(mock_repo).to receive(:resolve).with('master').and_return('abc123')
-
-          expect(test_module({}).properties).to include(expected: 'master')
-        end
-      end
-
-      context "specifying a static desired branch" do
-        let(:opts) { { branch: 'banana' } }
-
-        it "sets expected to specified branch name" do
-          expect(mock_repo).to receive(:resolve).with('banana').and_return('def456')
-
-          mod = test_module(opts)
-          expect(mod.properties).to include(expected: 'banana')
-        end
-      end
-
-      context "specifying a static desired tag" do
-        let(:opts) { { tag: '1.2.3' } }
-
-        it "sets expected to specified tag" do
-          expect(mock_repo).to receive(:resolve).with('1.2.3').and_return('def456')
-
-          mod = test_module(opts)
-          expect(mod.properties).to include(expected: '1.2.3')
-        end
-      end
-
-      context "specifying a static desired commit sha" do
-        let(:opts) { { commit: 'ace789' } }
-
-        it "sets expected to specified commit sha" do
-          expect(mock_repo).to receive(:resolve).with('ace789').and_return('ace789')
-
-          mod = test_module(opts)
-          expect(mod.properties).to include(expected: 'ace789')
-        end
-      end
-
-      context "specifying a static desired ref" do
-        before(:each) do
-          expect(mock_repo).to receive(:resolve).and_return('abc123')
-        end
-
-        it "accepts a branch name" do
-          mod = test_module(ref: 'banana')
-          expect(mod.properties).to include(expected: 'banana')
-        end
-
-        it "accepts a tag name" do
-          mod = test_module(ref: '1.2.3')
-          expect(mod.properties).to include(expected: '1.2.3')
-        end
-
-        it "accepts a commit sha" do
-          mod = test_module(ref: 'abc123')
-          expect(mod.properties).to include(expected: 'abc123')
-        end
-      end
-
-      context "specifying branch to :control_branch" do
-        let(:mock_env) { instance_double("R10K::Environment::Git", ref: 'env_branch') }
-
-        context "when module belongs to an environment and matching branch is resolvable" do
-          before(:each) do
-            expect(mock_repo).to receive(:resolve).with(mock_env.ref).and_return('abc123')
-          end
-
-          it "tracks environment branch" do
-            mod = test_module({branch: :control_branch}, mock_env)
-            expect(mod.properties).to include(expected: mock_env.ref)
-          end
-        end
-
-        context "when module does not belong to an environment" do
-          it "leaves desired_ref unchanged" do
-            mod = test_module(branch: :control_branch)
-            expect(mod.desired_ref).to eq(:control_branch)
-          end
-
-          it "warns control branch may be unresolvable" do
-            logger = double("logger")
-            allow_any_instance_of(described_class).to receive(:logger).and_return(logger)
-            expect(logger).to receive(:warn).with(/Cannot track control repo branch.*boolean.*/)
-
-            test_module(branch: :control_branch)
-          end
-
-          context "when default ref is provided and resolvable" do
-            it "uses default ref" do
-              expect(mock_repo).to receive(:resolve).with('default').and_return('abc123')
-              mod = test_module({branch: :control_branch, default_branch: 'default'})
-
-              expect(mod.properties).to include(expected: 'default')
-            end
-          end
-
-          context "when default ref is provided and not resolvable" do
-            it "raises appropriate error" do
-              expect(mock_repo).to receive(:resolve).with('default').and_return(nil)
-              mod = test_module({branch: :control_branch, default_branch: 'default'})
-
-              expect { mod.properties }.to raise_error(ArgumentError, /unable to manage.*could not resolve control repo branch.*or resolve default/i)
-            end
-          end
-
-          context "when default ref is not provided" do
-            it "raises appropriate error" do
-              mod = test_module({branch: :control_branch})
-
-              expect { mod.properties }.to raise_error(ArgumentError, /unable to manage.*could not resolve control repo branch.*no default provided/i)
-            end
-          end
-        end
-
-        context "when module does not have matching branch" do
-          before(:each) do
-            allow(mock_repo).to receive(:resolve).with(mock_env.ref).and_return(nil)
-          end
-
-          context "when default ref is provided and resolvable" do
-            it "uses default ref" do
-              expect(mock_repo).to receive(:resolve).with('default').and_return('abc123')
-              mod = test_module({branch: :control_branch, default_branch: 'default'}, mock_env)
-
-              expect(mod.properties).to include(expected: 'default')
-            end
-          end
-
-          context "when default ref is provided and not resolvable" do
-            it "raises appropriate error" do
-              expect(mock_repo).to receive(:resolve).with('default').and_return(nil)
-              mod = test_module({branch: :control_branch, default_branch: 'default'}, mock_env)
-
-              expect { mod.properties }.to raise_error(ArgumentError, /unable to manage.*could not resolve desired.*or resolve default/i)
-            end
-          end
-
-          context "when default ref is not provided" do
-            it "raises appropriate error" do
-              mod = test_module({branch: :control_branch}, mock_env)
-
-              expect { mod.properties }.to raise_error(ArgumentError, /unable to manage.*no default provided/i)
-            end
-          end
-        end
-
-        context "when using default_branch_override" do
-          before(:each) do
-            allow(mock_repo).to receive(:resolve).with(mock_env.ref).and_return(nil)
-          end
-
-          context "and the default branch override is resolvable" do
-            it "uses the override" do
-              expect(mock_repo).to receive(:resolve).with('default_override').and_return('5566aabb')
-              mod = test_module({branch: :control_branch,
-                                 default_branch: 'default',
-                                 default_branch_override: 'default_override'},
-                                 mock_env)
-              expect(mod.properties).to include(expected: 'default_override')
-            end
-          end
-
-          context "and the default branch override is not resolvable" do
-            context "and default branch is provided" do
-              it "falls back to the default" do
-                expect(mock_repo).to receive(:resolve).with('default_override').and_return(nil)
-                expect(mock_repo).to receive(:resolve).with('default').and_return('5566aabb')
-                mod = test_module({branch: :control_branch,
-                                   default_branch: 'default',
-                                   default_branch_override: 'default_override'},
-                                   mock_env)
-                expect(mod.properties).to include(expected: 'default')
-              end
-            end
-
-            context "and default branch is not provided" do
-              it "raises the appropriate error" do
-                expect(mock_repo).to receive(:resolve).with('default_override').and_return(nil)
-                mod = test_module({branch: :control_branch,
-                                   default_branch_override: 'default_override'},
-                                   mock_env)
-
-                expect { mod.properties }.to raise_error(ArgumentError, /unable to manage.*or resolve the default branch override.*no default provided/i)
-              end
-            end
-
-            context "and default branch is not resolvable" do
-              it "raises the appropriate error" do
-                expect(mock_repo).to receive(:resolve).with('default_override').and_return(nil)
-                expect(mock_repo).to receive(:resolve).with('default').and_return(nil)
-                mod = test_module({branch: :control_branch,
-                                   default_branch: 'default',
-                                   default_branch_override: 'default_override'},
-                                   mock_env)
-
-                expect { mod.properties }.to raise_error(ArgumentError, /unable to manage.*or resolve the default branch override.*or resolve default/i)
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-end