akerl-r10k 3.14.2.1

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,118 @@
+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 'deleting the spec dir' 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' }
+
+    before(:each) do
+      logger = double("logger")
+      allow_any_instance_of(described_class).to receive(:logger).and_return(logger)
+      allow(logger).to receive(:debug2).with(any_args)
+      allow(logger).to receive(:info).with(any_args)
+    end
+
+    it 'does not remove the spec directory by default' do
+      FileUtils.mkdir_p(spec_path)
+      m = described_class.new(title, dirname, {})
+      m.maybe_delete_spec_dir
+      expect(Dir.exist?(spec_path)).to eq true
+    end
+
+    it 'detects a symlink and deletes the target' do
+      Dir.mkdir(dirname + module_name)
+      target_dir = Dir.mktmpdir
+      FileUtils.ln_s(target_dir, spec_path)
+      m = described_class.new(title, dirname, {exclude_spec: true})
+      m.maybe_delete_spec_dir
+      expect(Dir.exist?(target_dir)).to eq false
+    end
+
+    it 'removes the spec directory if exclude_spec is set' do
+      FileUtils.mkdir_p(spec_path)
+      m = described_class.new(title, dirname, {exclude_spec: true})
+      m.maybe_delete_spec_dir
+      expect(Dir.exist?(spec_path)).to eq false
+    end
+
+    it 'does not remove the spec directory if spec_deletable is false' do
+      FileUtils.mkdir_p(spec_path)
+      m = described_class.new(title, dirname, {})
+      m.spec_deletable = false
+      m.maybe_delete_spec_dir
+      expect(Dir.exist?(spec_path)).to eq true
+    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