r10k 1.3.5 → 1.4.0

data/spec/unit/module_spec.rb

@@ -5,19 +5,19 @@ describe R10K::Module do
   describe 'delegating to R10K::Module::Git' do
     it "accepts args {:git => 'git url}" do
       obj = R10K::Module.new('foo', '/modulepath', :git => 'git url')
-      obj.should be_a_kind_of R10K::Module::Git
+      expect(obj).to be_a_kind_of(R10K::Module::Git)
     end
   end
 
   describe 'delegating to R10K::Module::Git' do
     it "accepts name matching 'username/modulename' and no args" do
       obj = R10K::Module.new('bar/quux', '/modulepath', [])
-      obj.should be_a_kind_of R10K::Module::Forge
+      expect(obj).to be_a_kind_of(R10K::Module::Forge)
     end
 
     it "accepts name matching 'username/modulename' and a semver argument" do
       obj = R10K::Module.new('bar/quux', '/modulepath', '10.0.0')
-      obj.should be_a_kind_of R10K::Module::Forge
+      expect(obj).to be_a_kind_of(R10K::Module::Forge)
     end
   end
 

data/spec/unit/puppetfile_spec.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+require 'r10k/puppetfile'
+
+describe R10K::Puppetfile do
+
+  subject do
+    described_class.new(
+      '/some/nonexistent/basedir'
+    )
+  end
+
+  describe "the default moduledir" do
+    it "is the basedir joined with '/modules' path" do
+      expect(subject.moduledir).to eq '/some/nonexistent/basedir/modules'
+    end
+  end
+
+  describe "setting moduledir" do
+    it "changes to given moduledir if it is an absolute path" do
+      subject.set_moduledir('/absolute/path/moduledir')
+      expect(subject.moduledir).to eq '/absolute/path/moduledir'
+    end
+
+    it "joins the basedir with the given moduledir if it is a relative path" do
+      subject.set_moduledir('relative/moduledir')
+      expect(subject.moduledir).to eq '/some/nonexistent/basedir/relative/moduledir'
+    end
+  end
+
+  describe "evaluating a Puppetfile" do
+    def expect_wrapped_error(orig, pf_path, wrapped_error)
+      expect(orig).to be_a_kind_of(R10K::Error)
+      expect(orig.message).to eq("Failed to evaluate #{pf_path}")
+      expect(orig.original).to be_a_kind_of(wrapped_error)
+    end
+
+    it "wraps and re-raises syntax errors" do
+      path = File.join(PROJECT_ROOT, 'spec', 'fixtures', 'unit', 'puppetfile', 'invalid-syntax')
+      pf_path = File.join(path, 'Puppetfile')
+      subject = described_class.new(path)
+      expect {
+        subject.load!
+      }.to raise_error do |e|
+        expect_wrapped_error(e, pf_path, SyntaxError)
+      end
+    end
+
+    it "wraps and re-raises load errors" do
+      path = File.join(PROJECT_ROOT, 'spec', 'fixtures', 'unit', 'puppetfile', 'load-error')
+      pf_path = File.join(path, 'Puppetfile')
+      subject = described_class.new(path)
+      expect {
+        subject.load!
+      }.to raise_error do |e|
+        expect_wrapped_error(e, pf_path, LoadError)
+      end
+    end
+  end
+
+  describe "accepting a visitor" do
+    it "passes itself to the visitor" do
+      visitor = spy('visitor')
+      expect(visitor).to receive(:visit).with(:puppetfile, subject)
+      subject.accept(visitor)
+    end
+
+    it "passes the visitor to each module if the visitor yields" do
+      visitor = spy('visitor')
+      expect(visitor).to receive(:visit) do |type, other, &block|
+        expect(type).to eq :puppetfile
+        expect(other).to eq subject
+        block.call
+      end
+
+      mod1 = spy('module')
+      expect(mod1).to receive(:accept).with(visitor)
+      mod2 = spy('module')
+      expect(mod2).to receive(:accept).with(visitor)
+
+      expect(subject).to receive(:modules).and_return([mod1, mod2])
+      subject.accept(visitor)
+    end
+  end
+end

data/spec/unit/settings/container_spec.rb

@@ -12,7 +12,7 @@ describe R10K::Settings::Container do
 
     it 'can check if a key is valid' do
       subject.add_valid_key(:v)
-      expect(subject.valid_key?(:v)).to be_true
+      expect(subject.valid_key?(:v)).to be_truthy
     end
 
     it 'can list all valid keys' do

data/spec/unit/source/base_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+require 'r10k/source'
+
+describe R10K::Source::Base do
+  subject { described_class.new('base', '/some/nonexistent/path') }
+
+  describe "accepting a visitor" do
+    it "passes itself to the visitor" do
+      visitor = spy('visitor')
+      expect(visitor).to receive(:visit).with(:source, subject)
+      subject.accept(visitor)
+    end
+
+    it "passes the visitor to each environment if the visitor yields" do
+      visitor = spy('visitor')
+      expect(visitor).to receive(:visit) do |type, other, &block|
+        expect(type).to eq :source
+        expect(other).to eq subject
+        block.call
+      end
+
+      env1 = spy('environment')
+      expect(env1).to receive(:accept).with(visitor)
+      env2 = spy('environment')
+      expect(env2).to receive(:accept).with(visitor)
+
+      expect(subject).to receive(:environments).and_return([env1, env2])
+      subject.accept(visitor)
+    end
+  end
+end

data/spec/unit/source/git_spec.rb

@@ -32,14 +32,14 @@ describe R10K::Source::Git do
     it "generates environments when the cache is present and environments have not been loaded" do
       allow(subject.cache).to receive(:cached?).and_return true
       allow(subject).to receive(:generate_environments).and_return %w[hi]
-      expect(subject.environments).to have(1).items
+      expect(subject.environments.size).to eq(1)
     end
 
     it "doesn't recreate environments if they have already been loaded" do
       allow(subject.cache).to receive(:cached?).and_return true
       allow(subject).to receive(:generate_environments).once.and_return %w[hi]
-      expect(subject.environments).to have(1).items
-      expect(subject.environments).to have(1).items
+      expect(subject.environments.size).to eq(1)
+      expect(subject.environments.size).to eq(1)
     end
   end
 
@@ -51,7 +51,7 @@ describe R10K::Source::Git do
     let(:master_env) { subject.generate_environments.first }
 
     it "creates an environment for each branch" do
-      expect(subject.generate_environments).to have(1).items
+      expect(subject.generate_environments.size).to eq(1)
     end
 
     it "copies the source remote to the environment" do
@@ -79,7 +79,7 @@ describe R10K::Source::Git, "handling invalid branch names" do
       end
 
       it "creates an environment for each branch" do
-        expect(subject.generate_environments).to have(2).items
+        expect(subject.generate_environments.size).to eq(2)
       end
 
       it "removes invalid characters from branch names" do
@@ -102,7 +102,7 @@ describe R10K::Source::Git, "handling invalid branch names" do
     end
 
     it "only creates an environment for valid branches" do
-      expect(subject.generate_environments).to have(1).items
+      expect(subject.generate_environments.size).to eq(1)
     end
   end
 end
@@ -130,7 +130,7 @@ describe R10K::Source::Git, 'when prefixing is enabled' do
     let(:environments) { subject.environments }
 
     it "creates an environment for each branch" do
-      expect(subject.environments).to have(2).items
+      expect(subject.environments.size).to eq(2)
     end
 
     it "prefixes the source name to environments when prefixing is enabled" do

data/spec/unit/source/svn_spec.rb

@@ -83,7 +83,7 @@ describe R10K::Source::SVN, 'when prefixing is enabled' do
     let(:environments) { subject.generate_environments }
 
     it "creates an environment for each branch and the trunk" do
-      expect(environments).to have(4).items
+      expect(environments.size).to eq(4)
     end
 
     it "prefixes the source name to environments" do

data/spec/unit/svn/working_dir_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+require 'r10k/svn/working_dir'
+
+describe R10K::SVN::WorkingDir, "initializing" do
+  let(:pathname) { Pathname.new("/some/imaginary/path") }
+  it "stores the provided path" do
+    subject = described_class.new(pathname)
+    expect(subject.path).to eq Pathname.new("/some/imaginary/path")
+  end
+
+  describe "when auth is provided" do
+    it "raises an error when only the username is provided" do
+      expect {
+        described_class.new(pathname, :username => "root")
+      }.to raise_error(ArgumentError, "Both username and password must be specified")
+    end
+
+    it "raises an error when only the password is provided" do
+      expect {
+        described_class.new(pathname, :password => "hunter2")
+      }.to raise_error(ArgumentError, "Both username and password must be specified")
+    end
+
+    it "does not raise an error when both username and password are provided" do
+      o = described_class.new(pathname, :username => "root", :password => "hunter2")
+      expect(o.username).to eq("root")
+      expect(o.password).to eq("hunter2")
+    end
+  end
+end
+
+describe R10K::SVN::WorkingDir, "when authentication credentials are given" do
+  let(:pathname) { Pathname.new("/some/imaginary/path") }
+  subject { described_class.new(pathname, :username => "root", :password => "hunter2") }
+
+  def check_args(args)
+    expect(args).to include("--username")
+    expect(args).to include("root")
+    expect(args).to include("--password")
+    expect(args).to include("hunter2")
+  end
+
+  it "invokes 'svn checkout' with the given credentials" do
+    expect(subject).to receive(:svn) do |args, _|
+      check_args(args)
+    end
+    subject.checkout('https://some.svn.url/trunk')
+  end
+
+  it "invokes 'svn update' with the given credentials" do
+    expect(subject).to receive(:svn) do |args, _|
+      check_args(args)
+    end
+    subject.update
+  end
+end

data/spec/unit/util/attempt_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+require 'r10k/util/attempt'
+
+describe R10K::Util::Attempt do
+
+  describe "with a single truthy value" do
+    subject(:attempt) { described_class.new("hello") }
+
+    it "invokes the next action with the value" do
+      value = nil
+      attempt.try { |inner| value = inner }
+      attempt.run
+      expect(attempt).to be_ok
+      expect(value).to eq "hello"
+    end
+
+    it "returns the resulting value from the block" do
+      attempt.try { |inner| inner + " world" }
+      result = attempt.run
+      expect(attempt).to be_ok
+      expect(result).to eq "hello world"
+    end
+  end
+
+  describe "with a false value" do
+    subject(:attempt) { described_class.new(nil) }
+
+    it "does not evaluate the block" do
+      value = "outside of block"
+      attempt.try { |inner| value = "ran block" }
+      attempt.run
+      expect(attempt).to be_ok
+      expect(value).to eq "outside of block"
+    end
+
+    it "does not continue execution" do
+      attempt.try { |_| "something" }.try { raise }
+      expect(attempt.run).to be_nil
+    end
+  end
+
+  describe "with an array" do
+    subject(:attempt) { described_class.new([1, 2, 3, 4, 5]) }
+
+    it "runs the block for each element in the array" do
+      sum = 0
+      attempt.try { |inner| sum += inner }
+      attempt.run
+      expect(attempt).to be_ok
+      expect(sum).to eq 15
+    end
+
+    it "returns the result of the operation on each array member" do
+      sum = 0
+      attempt.try { |inner| sum += inner }
+      result = attempt.run
+      expect(result).to eq([1, 3, 6, 10, 15])
+    end
+  end
+
+  describe "when an exception is raised" do
+    subject(:attempt) { described_class.new("initial") }
+
+    it "returns the exception" do
+      attempt.try { |_| raise RuntimeError }
+      result = attempt.run
+      expect(attempt).to_not be_ok
+      expect(result).to be_a_kind_of RuntimeError
+    end
+
+    it "does not continue execution" do
+      attempt.try { |_| raise RuntimeError }.try { |_| "This should not be run" }
+      result = attempt.run
+      expect(result).to be_a_kind_of RuntimeError
+    end
+
+    it "only rescues descendants of StandardError" do
+      attempt.try { |_| raise Exception }
+      expect { attempt.run }.to raise_error
+    end
+  end
+end

data/spec/unit/util/setopts_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+require 'r10k/util/setopts'
+
+describe R10K::Util::Setopts do
+  let(:klass) do
+    Class.new do
+      include R10K::Util::Setopts
+
+      attr_reader :valid, :alsovalid, :truthyvalid
+
+      def initialize(opts = {})
+        setopts(opts, {
+          :valid => :self, :alsovalid => :self, :truthyvalid => true,
+          :validalias => :valid,
+          :ignoreme => nil
+        })
+      end
+    end
+  end
+
+  it "can handle an empty hash of options" do
+    o = klass.new()
+    expect(o.valid).to be_nil
+    expect(o.alsovalid).to be_nil
+  end
+
+  it "can handle a single valid option" do
+    o = klass.new(:valid => 'yep')
+    expect(o.valid).to eq 'yep'
+    expect(o.alsovalid).to be_nil
+  end
+
+  it "can handle multiple valid options" do
+    o = klass.new(:valid => 'yep', :alsovalid => 'yarp')
+    expect(o.valid).to eq 'yep'
+    expect(o.alsovalid).to eq 'yarp'
+  end
+
+  it "can handle options marked with TrueClass" do
+    o = klass.new(:truthyvalid => 'so truthy')
+    expect(o.truthyvalid).to eq 'so truthy'
+  end
+
+  it "can handle aliases marked with :self" do
+    o = klass.new(:validalias => 'yuuup')
+    expect(o.valid).to eq 'yuuup'
+  end
+
+
+  it "raises an error when given an unhandled option" do
+    expect {
+      klass.new(:valid => 'yep', :notvalid => 'newp')
+    }.to raise_error(ArgumentError, /cannot handle option 'notvalid'/)
+  end
+
+  it "ignores values that are marked as unhandled" do
+    klass.new(:ignoreme => "IGNORE ME!")
+  end
+end

data/spec/unit/util/subprocess/result_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+require 'r10k/util/subprocess'
+
+describe R10K::Util::Subprocess::Result do
+  describe "formatting" do
+    it "includes the exit code" do
+      result = described_class.new(%w[/usr/bin/gti --zoom], '', '', 42)
+      expect(result.format).to match(%r[Exit code: 42])
+    end
+
+    describe "stdout" do
+      it "is omitted when empty" do
+        result = described_class.new(%w[/usr/bin/gti --zoom], '', '', 42)
+        expect(result.format).to_not match(%r[Stdout])
+      end
+      it "is included when non-empty" do
+        result = described_class.new(%w[/usr/bin/gti --zoom], 'stuff here', '', 42)
+        expect(result.format).to match(%r[Stdout:])
+        expect(result.format).to match(%r[stuff here])
+      end
+    end
+
+    describe "stderr" do
+      it "is omitted when empty" do
+        result = described_class.new(%w[/usr/bin/gti --zoom], '', '', 42)
+        expect(result.format).to_not match(%r[Stderr])
+      end
+
+      it "is included when non-empty" do
+        result = described_class.new(%w[/usr/bin/gti --zoom], '', 'other stuff', 42)
+        expect(result.format).to match(%r[Stderr:])
+        expect(result.format).to match(%r[other stuff])
+      end
+    end
+  end
+end