r10k 3.5.2

data/spec/unit/initializers_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+require 'r10k/initializers'
+
+describe R10K::Initializers::GitInitializer do
+  it "configures the Git provider" do
+    subject = described_class.new({:provider => :rugged})
+    expect(R10K::Git).to receive(:provider=).with(:rugged)
+    subject.call
+  end
+
+  it "configures the Git username" do
+    subject = described_class.new({:username => 'git'})
+    expect(R10K::Git.settings).to receive(:[]=).with(:username, 'git')
+    subject.call
+  end
+
+  it "configures the Git private key" do
+    subject = described_class.new({:private_key => '/etc/puppetlabs/r10k/id_rsa'})
+    expect(R10K::Git.settings).to receive(:[]=).with(:private_key, '/etc/puppetlabs/r10k/id_rsa')
+    subject.call
+  end
+end
+
+describe R10K::Initializers::ForgeInitializer do
+  it "sets the PuppetForge host" do
+    subject = described_class.new({:baseurl => 'https://my.site.forge'})
+    expect(PuppetForge).to receive(:host=).with('https://my.site.forge')
+    subject.call
+  end
+
+  it "configures PuppetForge connection proxy" do
+    subject = described_class.new({:proxy => 'http://my.site.proxy:3128'})
+    expect(PuppetForge::Connection).to receive(:proxy=).with('http://my.site.proxy:3128')
+    subject.call
+  end
+end
+
+describe R10K::Initializers::GlobalInitializer do
+  it "logs a warning if purgedirs was set" do
+    subject = described_class.new({:purgedirs => 'This setting has been deprecated for over two years :('})
+    expect(subject.logger).to receive(:warn).with('the purgedirs key in r10k.yaml is deprecated. it is currently ignored.')
+    subject.call
+  end
+
+  it "sets the Git cache_root" do
+    subject = described_class.new({:cachedir => '/var/cache/r10k'})
+    expect(R10K::Git::Cache.settings).to receive(:[]=).with(:cache_root, '/var/cache/r10k')
+    subject.call
+  end
+
+  it "delegates git settings to the Git initializer" do
+    git = instance_double('R10K::Initializers::GitInitializer')
+    expect(git).to receive(:call)
+    expect(R10K::Initializers::GitInitializer).to receive(:new).and_return(git)
+
+    subject = described_class.new({:git => {}})
+    subject.call
+  end
+
+  it "delegates forge settings to the Forge initializer" do
+    forge = instance_double('R10K::Initializers::ForgeInitializer')
+    expect(forge).to receive(:call)
+    expect(R10K::Initializers::ForgeInitializer).to receive(:new).and_return(forge)
+
+    subject = described_class.new({:forge => {}})
+    subject.call
+  end
+end

data/spec/unit/instance_cache_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+
+require 'r10k/instance_cache'
+
+describe R10K::InstanceCache do
+
+  describe "setting up a new instance cache" do
+    let(:klass) do
+      dubs = double('test class')
+      allow(dubs).to receive(:new) { |*args| args }
+      dubs
+    end
+
+    it "can create new objects" do
+      registry = described_class.new(klass)
+      expect(registry.generate).to eq []
+    end
+
+    describe "defining object arity" do
+
+      it "handles unary objects" do
+        expect(klass).to receive(:new).with(:foo)
+
+        registry = described_class.new(klass)
+        expect(registry.generate(:foo)).to eq [:foo]
+      end
+
+      it "handles ternary objects" do
+        expect(klass).to receive(:new).with(:foo, :bar, :baz)
+
+        registry = described_class.new(klass)
+        expect(registry.generate(:foo, :bar, :baz)).to eq [:foo, :bar, :baz]
+      end
+
+      it 'handles n-ary objects' do
+        args = %w[a bunch of arbitrary objects]
+        expect(klass).to receive(:new).with(*args)
+
+        registry = described_class.new(klass)
+        expect(registry.generate(*args)).to eq args
+      end
+
+      it 'fails when the required arguments are not matched' do
+        expect(klass).to receive(:new).and_raise ArgumentError, "not enough args"
+
+        registry = described_class.new(klass)
+        expect { registry.generate('arity is hard') }.to raise_error ArgumentError, "not enough args"
+      end
+    end
+
+    it "can specify the constructor method" do
+      expect(klass).to receive(:from_json).and_return "this is json, right?"
+
+      registry = described_class.new(klass, :from_json)
+      expect(registry.generate).to eq "this is json, right?"
+    end
+  end
+
+
+  it "returns a memoized object if it's been created before" do
+    registry = described_class.new(String)
+    first = registry.generate "bam!"
+    second = registry.generate "bam!"
+
+    expect(first.object_id).to eq second.object_id
+  end
+
+  it 'can clear registered objects' do
+    registry = described_class.new(String)
+
+    first = registry.generate "bam!"
+    registry.clear!
+    second = registry.generate "bam!"
+
+    expect(first.object_id).to_not eq second.object_id
+
+  end
+end

data/spec/unit/keyed_factory_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+require 'r10k/keyed_factory'
+
+describe R10K::KeyedFactory do
+
+  let(:registered) { Class.new }
+
+  describe "registering implementations" do
+    it "can register new implementations" do
+      subject.register(:klass, registered)
+      expect(subject.retrieve(:klass)).to eq registered
+    end
+
+    it "raises an error when a duplicate implementation is registered" do
+      subject.register(:klass, registered)
+
+      expect {
+        subject.register(:klass, registered)
+      }.to raise_error(R10K::KeyedFactory::DuplicateImplementationError)
+    end
+
+    it "can register classes with nil as a key" do
+      subject.register(nil, registered)
+      expect(subject.retrieve(nil)).to eq registered
+    end
+  end
+
+  describe "generating instances" do
+    before do
+      subject.register(:klass, registered)
+    end
+
+    it "generates an instance with the associated class" do
+      instance = subject.generate(:klass)
+      expect(instance).to be_a_kind_of registered
+    end
+
+    it "can generate a class with nil as a key" do
+      other = Class.new
+      subject.register(nil, other)
+      instance = subject.generate(nil)
+      expect(instance).to be_a_kind_of other
+    end
+
+    it "raises an error if no implementation was registered with the given key" do
+      expect {
+        subject.generate(:foo)
+      }.to raise_error(R10K::KeyedFactory::UnknownImplementationError)
+    end
+  end
+end

data/spec/unit/logging/terminaloutputter_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+require 'stringio'
+require 'r10k/logging/terminaloutputter'
+
+describe R10K::Logging::TerminalOutputter do
+
+  let(:stream) { StringIO.new }
+
+  let(:formatter) do
+    Class.new(Log4r::Formatter) do
+      def format(logevent)
+        logevent.data
+      end
+    end
+  end
+
+  subject do
+    described_class.new('test', stream, :level => 0, :formatter => formatter).tap do |o|
+      o.use_color = true
+    end
+  end
+
+  tests = [
+    [:debug2, :cyan],
+    [:debug1, :cyan],
+    [:debug,  :green],
+    [:info,   nil],
+    [:notice, nil],
+    [:warn,   :yellow],
+    [:error,  :red],
+    [:fatal,  :red],
+  ]
+
+  tests.each_with_index do |(level, color), index|
+    # Note for the unwary - using a loop in this manner shows strange
+    # behavior with variable closure. The describe block is needed to retain
+    # the loop variables for each test; without this the let helpers are
+    # overwritten and the last set of helpers are used for all tests.
+    describe "at level #{level}" do
+      let(:message) { "level #{level}: #{color}" }
+
+      let(:event) do
+        Log4r::LogEvent.new(index + 1, Log4r::Logger.new('test::logger'), nil, message)
+      end
+
+      it "logs messages as #{color ? color : "uncolored"}" do
+        output = color.nil? ? message : message.send(color)
+        subject.send(level, event)
+        expect(stream.string).to eq output
+      end
+    end
+  end
+end

data/spec/unit/logging_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+require 'r10k/logging'
+
+describe R10K::Logging do
+
+  describe "parsing a log level" do
+    it "parses 'true:TrueClass' as INFO" do
+      expect(described_class.parse_level(true)).to eq Log4r::INFO
+    end
+
+    it "parses 'true:String' as nil" do
+      expect(described_class.parse_level("true")).to be_nil
+    end
+
+    it "parses a numeric string as an integer" do
+      expect(described_class.parse_level('2')).to eq 2
+    end
+
+    it "parses a log level string as a log level" do
+      expect(described_class.parse_level('debug')).to eq Log4r::DEBUG
+    end
+
+    it "returns nil when given an invalid log level" do
+      expect(described_class.parse_level('deblag')).to be_nil
+    end
+  end
+
+  describe "setting the log level" do
+    after(:all) { R10K::Logging.level = 'warn' }
+
+    it "sets the outputter log level" do
+      expect(described_class.outputter).to receive(:level=).with(Log4r::DEBUG)
+      described_class.level = 'debug'
+    end
+
+    it "stores the new log level" do
+      allow(described_class.outputter).to receive(:level=)
+      described_class.level = 'debug'
+      expect(described_class.level).to eq(Log4r::DEBUG)
+    end
+
+    it "raises an exception when given an invalid log level" do
+      expect {
+        described_class.level = 'deblag'
+      }.to raise_error(ArgumentError, /Invalid log level/)
+    end
+
+    describe "switching the formatter" do
+      before do
+        allow(described_class.outputter).to receive(:level=)
+      end
+
+      it "switches to the debug formatter if the new log level is debug or greater" do
+        debug_formatter = double('debug formatter')
+        expect(described_class).to receive(:debug_formatter).and_return(debug_formatter)
+        expect(described_class.outputter).to receive(:formatter=).with(debug_formatter)
+        described_class.level = 'debug'
+      end
+
+      it "switches to the default formatter if the new log level is info or less" do
+        default_formatter = double('default formatter')
+        expect(described_class).to receive(:default_formatter).and_return(default_formatter)
+        expect(described_class.outputter).to receive(:formatter=).with(default_formatter)
+        described_class.level = 'info'
+      end
+    end
+  end
+end

data/spec/unit/module/base_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+require 'r10k/module/base'
+
+describe R10K::Module::Base do
+  describe "parsing the title" do
+    it "parses titles with no owner" do
+      m = described_class.new('eight_hundred', '/moduledir', [])
+      expect(m.name).to eq 'eight_hundred'
+      expect(m.owner).to be_nil
+    end
+
+    it "parses forward slash separated titles" do
+      m = described_class.new('branan/eight_hundred', '/moduledir', [])
+      expect(m.name).to eq 'eight_hundred'
+      expect(m.owner).to eq 'branan'
+    end
+
+    it "parses hyphen separated titles" do
+      m = described_class.new('branan-eight_hundred', '/moduledir', [])
+      expect(m.name).to eq 'eight_hundred'
+      expect(m.owner).to eq 'branan'
+    end
+
+    it "raises an error when the title is not correctly formatted" do
+      expect {
+        described_class.new('branan!eight_hundred', '/moduledir', [])
+      }.to raise_error(ArgumentError, "Module name (branan!eight_hundred) must match either 'modulename' or 'owner/modulename'")
+    end
+  end
+
+  describe "path variables" do
+    it "uses the module name as the name" do
+      m = described_class.new('eight_hundred', '/moduledir', [])
+      expect(m.dirname).to eq '/moduledir'
+      expect(m.path).to eq(Pathname.new('/moduledir/eight_hundred'))
+    end
+
+    it "does not include the owner in the path" do
+      m = described_class.new('branan/eight_hundred', '/moduledir', [])
+      expect(m.dirname).to eq '/moduledir'
+      expect(m.path).to eq(Pathname.new('/moduledir/eight_hundred'))
+    end
+  end
+
+  describe "with alternate variable names" do
+    subject do
+      described_class.new('branan/eight_hundred', '/moduledir', [])
+    end
+
+    it "aliases full_name to title" do
+      expect(subject.full_name).to eq 'branan-eight_hundred'
+    end
+
+    it "aliases author to owner" do
+      expect(subject.author).to eq 'branan'
+    end
+
+    it "aliases basedir to dirname" do
+      expect(subject.basedir).to eq '/moduledir'
+    end
+  end
+
+  describe "accepting a visitor" do
+    subject { described_class.new('branan-eight_hundred', '/moduledir', []) }
+
+    it "passes itself to the visitor" do
+      visitor = spy('visitor')
+      expect(visitor).to receive(:visit).with(:module, subject)
+      subject.accept(visitor)
+    end
+  end
+end

data/spec/unit/module/forge_spec.rb

@@ -0,0 +1,207 @@
+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 "implementing the Puppetfile spec" do
+    it "should implement 'branan/eight_hundred', '8.0.0'" do
+      expect(described_class).to be_implement('branan/eight_hundred', '8.0.0')
+    end
+
+    it "should implement 'branan-eight_hundred', '8.0.0'" do
+      expect(described_class).to be_implement('branan-eight_hundred', '8.0.0')
+    end
+
+    it "should fail with an invalid title" do
+      expect(described_class).to_not be_implement('branan!eight_hundred', '8.0.0')
+    end
+  end
+
+  describe "setting attributes" do
+    subject { described_class.new('branan/eight_hundred', '/moduledir', '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 "properties" do
+    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)
+    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, :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)
+
+      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)
+
+      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, '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, :latest)
+      expect(subject.v3_module).to receive_message_chain(:current_release, :version).and_return('8.8.8')
+      expect(subject.expected_version).to eq '8.8.8'
+    end
+  end
+
+  describe "determining the status" do
+
+    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
+      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, '8.0.0') }
+
+    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
+      subject.sync
+    end
+
+    it 'reinstalls the module when it is mismatched' do
+      allow(subject).to receive(:status).and_return :mismatched
+      expect(subject).to receive(:reinstall)
+      subject.sync
+    end
+
+    it 'upgrades the module when it is outdated' do
+      allow(subject).to receive(:status).and_return :outdated
+      expect(subject).to receive(:upgrade)
+      subject.sync
+    end
+
+    it 'installs the module when it is absent' do
+      allow(subject).to receive(:status).and_return :absent
+      expect(subject).to receive(:install)
+      subject.sync
+    end
+  end
+
+  describe '#install' do
+    it 'installs the module from the forge' do
+      subject = described_class.new('branan/eight_hundred', fixture_modulepath, '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, '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, '8.0.0')
+      expect(subject).to receive(:uninstall)
+      expect(subject).to receive(:install)
+      subject.reinstall
+    end
+  end
+end