r10k 1.3.5 → 1.4.0

data/spec/unit/action/cri_runner_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+require 'r10k/action/cri_runner'
+
+describe R10K::Action::CriRunner do
+
+  let(:action_class) do
+    Class.new do
+      attr_reader :opts
+      attr_reader :argv
+
+      def initialize(opts, argv)
+        @opts = opts
+        @argv = argv
+      end
+
+      def call
+        @opts[:runok]
+      end
+    end
+  end
+
+  subject(:cri_runner) { described_class.wrap(action_class)  }
+
+  let(:opts) { {:value => :yep} }
+  let(:argv) { %w[value yes] }
+
+  describe "handling options" do
+    it "adapts the :verbose flag to :loglevel" do
+      input = {:value => :yep, :verbose => 'DEBUG'}
+      output = {:value => :yep, :loglevel => 'DEBUG'}
+      expect(cri_runner.handle_opts(input)).to eq(output)
+    end
+
+    it "sets the non-argument form of :verbose to :loglevel => 'INFO'" do
+      input = {:value => :yep, :verbose => true}
+      output = {:value => :yep, :loglevel => 'INFO'}
+      expect(cri_runner.handle_opts(input)).to eq(output)
+    end
+  end
+
+  describe "handling arguments" do
+    it "sets the arguments as-is" do
+      expect(cri_runner.handle_argv(%w[one two])).to eq(%w[one two])
+    end
+  end
+
+  describe "proxying invocations to .new" do
+    it "returns itself" do
+      expect(cri_runner.new(opts, argv, :cri_cmd)).to eql cri_runner
+    end
+
+    it "handles options" do
+      expect(cri_runner).to receive(:handle_opts)
+      cri_runner.new({:value => :yep, :verbose => 'DEBUG'}, argv, :cri_cmd)
+    end
+
+    it "handles arguments" do
+      expect(cri_runner).to receive(:handle_argv)
+      cri_runner.new({:value => :yep, :verbose => 'DEBUG'}, argv, :cri_cmd)
+    end
+  end
+
+  describe "calling" do
+    it "exits with a return value of 0 if the action returned true" do
+      expect {
+        cri_runner.new({:runok => true}, []).call
+      }.to exit_with(0)
+    end
+
+    it "exits with a return value of 1 if the action returned false" do
+      expect {
+        cri_runner.new({:runok => false}, []).call
+      }.to exit_with(1)
+    end
+  end
+end

data/spec/unit/action/puppetfile/cri_action_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+require 'r10k/action/puppetfile/cri_runner'
+
+describe R10K::Action::Puppetfile::CriRunner do
+
+  let(:action_class) do
+    Class.new do
+      attr_reader :opts
+      attr_reader :argv
+
+      def initialize(opts, argv)
+        @opts = opts
+        @argv = argv
+      end
+
+      def call
+        @opts[:runok]
+      end
+    end
+  end
+
+  subject(:cri_runner) { described_class.wrap(action_class)  }
+
+  let(:opts) { {:value => :yep} }
+  let(:argv) { %w[value yes] }
+
+  describe "handling options" do
+    it "sets the root to the current wd" do
+      expect(cri_runner).to receive(:wd).and_return('/some/nonexistent')
+      expect(cri_runner.handle_opts({})).to include(:root => '/some/nonexistent')
+    end
+
+    describe "for the moduledir" do
+      before do
+        allow(cri_runner).to receive(:env).and_return({'PUPPETFILE_DIR' => '/some/nonexistent/modules'})
+      end
+
+      it "sets the option from the environment when the cli option is not given" do
+        opts = {}
+        expect(cri_runner.handle_opts(opts)).to include(:moduledir => '/some/nonexistent/modules')
+      end
+
+      it "doesn't set the option from the environment when the cli option is given" do
+        opts = {:moduledir => '/some/other/nonexistent/modules'}
+        expect(cri_runner.handle_opts(opts)).to include(:moduledir => '/some/other/nonexistent/modules')
+      end
+    end
+
+    describe "for the puppetfile path" do
+      before do
+        allow(cri_runner).to receive(:env).and_return({'PUPPETFILE' => '/some/nonexistent/Puppetfile'})
+      end
+
+      it "sets the option from the environment when the cli option is not given" do
+        opts = {}
+        expect(cri_runner.handle_opts(opts)).to include(:puppetfile => '/some/nonexistent/Puppetfile')
+      end
+
+      it "doesn't set the option from the environment when the cli option is given" do
+        opts = {:puppetfile => '/some/other/nonexistent/modules'}
+        expect(cri_runner.handle_opts(opts)).to include(:puppetfile => '/some/other/nonexistent/modules')
+      end
+    end
+  end
+end

data/spec/unit/action/runner_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+require 'r10k/action/runner'
+
+
+describe R10K::Action::Runner do
+
+  let(:action_class) do
+    Class.new do
+      attr_reader :opts
+      attr_reader :argv
+
+      def initialize(opts, argv)
+        @opts = opts
+        @argv = argv
+      end
+
+      def call
+        @argv.map(&:upcase)
+      end
+    end
+  end
+
+  subject(:runner) { described_class.new({:opts => :yep}, %w[args yes], action_class) }
+
+  describe "instantiating the wrapped class" do
+    it "creates an instance of the class" do
+      expect(runner.instance).to be_a_kind_of action_class
+    end
+
+    it "passes the opts and argv to the instance" do
+      expect(runner.instance.opts).to eq(:opts => :yep)
+      expect(runner.instance.argv).to eq(%w[args yes])
+    end
+
+    it "strips out options that the runner handles" do
+      runner = described_class.new({:opts => :yep, :loglevel => 'FATAL'}, %w[args yes], action_class)
+      expect(runner.instance.opts).to eq(:opts => :yep)
+    end
+  end
+
+  describe "calling" do
+    it "configures logging" do
+      expect(runner).to receive(:setup_logging)
+      runner.call
+    end
+
+    it "returns the result of the wrapped class #call method" do
+      expect(runner.call).to eq %w[ARGS YES]
+    end
+  end
+
+  describe "configuring logging" do
+    it "sets the log level if :loglevel is provided" do
+      runner = described_class.new({:opts => :yep, :loglevel => 'FATAL'}, %w[args yes], action_class)
+      expect(R10K::Logging).to receive(:level=).with('FATAL')
+      runner.call
+    end
+
+    it "does not modify the loglevel if :loglevel is not provided" do
+      expect(R10K::Logging).to_not receive(:level=)
+      runner.call
+    end
+  end
+end

data/spec/unit/action/visitor_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+require 'r10k/action/visitor'
+require 'r10k/logging'
+
+describe R10K::Action::Visitor do
+  let(:visitor_class) do
+    Class.new do
+      include R10K::Action::Visitor
+      include R10K::Logging
+      attr_accessor :trace
+
+      def visit_error(other)
+        raise ArgumentError, "no soup for you"
+      end
+    end
+  end
+
+  subject { visitor_class.new }
+
+  it "dispatches visit invocations to the type specific method" do
+    expect(subject).to receive(:visit_sym).with(:hi)
+    subject.visit(:sym, :hi)
+  end
+
+  describe "when a visit_ method raises an error" do
+
+    [true, false].each do |trace|
+      msg = trace ? "a" : "no"
+      it "logs the error with #{msg} backtrace when trace is #{trace}" do
+        subject.trace = trace
+        expect(R10K::Errors::Formatting).to(
+          receive(:format_exception).with(instance_of(ArgumentError), trace)
+        ).and_return("errmsg")
+        expect(subject.logger).to receive(:error).with('errmsg')
+        subject.visit(:error, :hi)
+      end
+    end
+  end
+end

data/spec/unit/deployment_spec.rb

@@ -0,0 +1,142 @@
+require 'spec_helper'
+require 'r10k/deployment'
+require 'tmpdir'
+
+describe R10K::Deployment do
+
+  let(:confdir) { Dir.mktmpdir }
+
+  let(:config) do
+    R10K::Deployment::MockConfig.new(
+      :sources => {
+        :control => {
+          :type => :mock,
+          :basedir => File.join(confdir, 'environments'),
+          :environments => %w[first second third],
+        },
+        :hiera => {
+          :type => :mock,
+          :basedir => File.join(confdir, 'hiera'),
+          :environments => %w[fourth fifth sixth],
+        }
+      }
+    )
+  end
+
+  subject(:deployment) { described_class.new(config) }
+
+  let(:control) { deployment.sources.find { |source| source.name == :control } }
+  let(:hiera)   { deployment.sources.find { |source| source.name == :hiera } }
+
+  describe "loading" do
+    describe "sources" do
+      it "creates a source for each key in the ':sources' config entry" do
+        expect(control.basedir).to eq(File.join(confdir, 'environments'))
+        expect(hiera.basedir).to eq(File.join(confdir, 'hiera'))
+      end
+    end
+
+    describe "loading environments" do
+      it "loads environments from each source" do
+        %w[first second third fourth fifth sixth].each do |env|
+          expect(deployment.environments.map(&:name)).to include(env)
+        end
+      end
+    end
+  end
+
+  describe "preloading" do
+    it "invokes #preload! on each source" do
+      deployment.sources.each do |source|
+        expect(source).to receive(:preload!)
+      end
+      deployment.preload!
+    end
+  end
+
+  describe "paths" do
+    it "retrieves the path for each source" do
+      expect(deployment.paths).to include(File.join(confdir, 'environments'))
+      expect(deployment.paths).to include(File.join(confdir, 'hiera'))
+    end
+  end
+
+  describe "paths and sources" do
+    it "retrieves the path for each source" do
+      p_a_s = deployment.paths_and_sources
+
+      expect(p_a_s[File.join(confdir, 'environments')]).to eq([control])
+      expect(p_a_s[File.join(confdir, 'hiera')]).to eq([hiera])
+    end
+  end
+
+  describe "purging" do
+    it "purges each managed directory" do
+      env_basedir = double("basedir environments")
+      hiera_basedir = double("basedir hiera")
+
+      expect(env_basedir).to receive(:purge!)
+      expect(hiera_basedir).to receive(:purge!)
+
+      expect(R10K::Util::Basedir).to receive(:new).with(File.join(confdir, 'environments'), [control]).and_return(env_basedir)
+      expect(R10K::Util::Basedir).to receive(:new).with(File.join(confdir, 'hiera'), [hiera]).and_return(hiera_basedir)
+
+      deployment.purge!
+    end
+  end
+
+  describe "accepting a visitor" do
+    it "passes itself to the visitor" do
+      visitor = spy('visitor')
+      expect(visitor).to receive(:visit).with(:deployment, 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 :deployment
+        expect(other).to eq subject
+        block.call
+      end
+
+      source1 = spy('source')
+      expect(source1).to receive(:accept).with(visitor)
+      source2 = spy('source')
+      expect(source2).to receive(:accept).with(visitor)
+
+      expect(subject).to receive(:sources).and_return([source1, source2])
+      subject.accept(visitor)
+    end
+  end
+end
+
+describe R10K::Deployment, "with environment collisions" do
+
+  let(:confdir) { Dir.mktmpdir }
+
+  let(:config) do
+    R10K::Deployment::MockConfig.new(
+      :sources => {
+        :s1 => {
+          :type => :mock,
+          :basedir => File.join(confdir, 'environments'),
+          :environments => %w[first second third],
+        },
+        :s2 => {
+          :type => :mock,
+          :basedir => File.join(confdir, 'environments'),
+          :environments => %w[third fourth fifth],
+        }
+      }
+    )
+  end
+
+  subject(:deployment) { described_class.new(config) }
+
+  it "raises an error when validating" do
+    expect {
+      deployment.validate!
+    }.to raise_error(R10K::R10KError, /Environment collision at .* between s\d:third and s\d:third/)
+  end
+end

data/spec/unit/environment/base_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+require 'r10k/environment'
+
+describe R10K::Environment::Base do
+
+  subject(:environment) { described_class.new('envname', '/some/imaginary/path', 'env_name', {}) }
+
+  it "can return the fully qualified path" do
+    expect(environment.path).to eq(Pathname.new('/some/imaginary/path/env_name'))
+  end
+
+  it "raises an exception when #sync is called" do
+    expect { environment.sync }.to raise_error(NotImplementedError)
+  end
+
+  describe "accepting a visitor" do
+    it "passes itself to the visitor" do
+      visitor = spy('visitor')
+      expect(visitor).to receive(:visit).with(:environment, subject)
+      subject.accept(visitor)
+    end
+
+    it "passes the visitor to the puppetfile if the visitor yields" do
+      visitor = spy('visitor')
+      expect(visitor).to receive(:visit) do |type, other, &block|
+        expect(type).to eq :environment
+        expect(other).to eq subject
+        block.call
+      end
+
+      pf = spy('puppetfile')
+      expect(pf).to receive(:accept).with(visitor)
+
+      expect(subject).to receive(:puppetfile).and_return(pf)
+      subject.accept(visitor)
+    end
+  end
+end

data/spec/unit/environment/git_spec.rb

@@ -40,17 +40,8 @@ describe R10K::Environment::Git do
   end
 
   describe "synchronizing the environment" do
-    it "updates all modules when creating a new environment" do
-      allow(working_dir).to receive(:cloned?).and_return(false)
+    it "syncs the working directory" do
       expect(working_dir).to receive(:sync)
-      expect(subject).to receive(:sync_modules)
-      subject.sync
-    end
-
-    it "does not update all modules when updating an existing environment" do
-      allow(working_dir).to receive(:cloned?).and_return(true)
-      expect(working_dir).to receive(:sync)
-      expect(subject).to_not receive(:sync_modules)
       subject.sync
     end
   end
@@ -78,4 +69,43 @@ describe R10K::Environment::Git do
       expect(subject.modules).to eq([:modules])
     end
   end
+
+  describe "determining the status" do
+    it "is absent when the working directory is absent" do
+      expect(working_dir).to receive(:exist?).and_return false
+      expect(subject.status).to eq :absent
+    end
+
+    it "is mismatched when the working directory is not git" do
+      expect(working_dir).to receive(:exist?).and_return true
+      expect(working_dir).to receive(:git?).and_return false
+      expect(subject.status).to eq :mismatched
+    end
+
+    it "is mismatched when the working directory remote doesn't match the desired remote" do
+      expect(working_dir).to receive(:exist?).and_return true
+      expect(working_dir).to receive(:git?).and_return true
+      expect(working_dir).to receive(:remote).and_return 'git://git-server.site/my-other-repo.git'
+      expect(subject.status).to eq :mismatched
+    end
+
+    it "is is outdated when the working directory has not been synced" do
+      expect(working_dir).to receive(:exist?).and_return true
+      expect(working_dir).to receive(:git?).and_return true
+      expect(working_dir).to receive(:remote).and_return 'git://git-server.site/my-repo.git'
+      expect(subject.status).to eq :outdated
+    end
+
+    it "is is insync when the working directory has been synced" do
+      expect(working_dir).to receive(:exist?).and_return true
+      expect(working_dir).to receive(:git?).and_return true
+      expect(working_dir).to receive(:remote).and_return 'git://git-server.site/my-repo.git'
+
+      expect(working_dir).to receive(:sync)
+
+      subject.sync
+
+      expect(subject.status).to eq :insync
+    end
+  end
 end