r10k 3.14.1 → 5.0.1

data/spec/unit/initializers_spec.rb

@@ -1,68 +0,0 @@
-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

@@ -1,78 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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

@@ -1,68 +0,0 @@
-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

@@ -1,118 +0,0 @@
-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