r10k 1.2.4 → 1.3.0rc1

data/spec/unit/environment/svn_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+require 'r10k/environment'
+
+describe R10K::Environment::SVN do
+
+  subject do
+    described_class.new(
+      'myenv',
+      '/some/nonexistent/environmentdir',
+      'svn-dirname',
+      {
+        :remote => 'https://svn-server.site/svn-repo/trunk'
+      }
+    )
+  end
+
+  let(:working_dir) { subject.working_dir }
+
+  describe "storing attributes" do
+    it "can return the environment name" do
+      expect(subject.name).to eq 'myenv'
+    end
+
+    it "can return the environment basedir" do
+      expect(subject.basedir).to eq '/some/nonexistent/environmentdir'
+    end
+
+    it "can return the environment dirname" do
+      expect(subject.dirname).to eq 'svn-dirname'
+    end
+
+    it "can return the environment remote" do
+      expect(subject.remote).to eq 'https://svn-server.site/svn-repo/trunk'
+    end
+  end
+
+  describe "synchronizing the environment" do
+    it "updates all modules when creating a new environment" do
+      allow(working_dir).to receive(:is_svn?).and_return(false)
+      expect(working_dir).to receive(:checkout)
+      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(:is_svn?).and_return(true)
+      expect(working_dir).to receive(:update)
+      expect(subject).to_not receive(:sync_modules)
+      subject.sync
+    end
+  end
+
+  describe "generating a puppetfile for the environment" do
+    let(:puppetfile) { subject.puppetfile }
+
+    it "creates a puppetfile at the full path to the environment" do
+      expect(puppetfile.basedir).to eq '/some/nonexistent/environmentdir/svn-dirname'
+    end
+
+    it "sets the moduledir to 'modules' relative to the environment path" do
+      expect(puppetfile.moduledir).to eq '/some/nonexistent/environmentdir/svn-dirname/modules'
+    end
+
+    it "sets the puppetfile path to 'Puppetfile' relative to the environment path" do
+      expect(puppetfile.puppetfile_path).to eq '/some/nonexistent/environmentdir/svn-dirname/Puppetfile'
+    end
+  end
+
+  describe "enumerating modules" do
+    it "loads the Puppetfile and returns modules in that puppetfile" do
+      expect(subject.puppetfile).to receive(:load)
+      expect(subject.puppetfile).to receive(:modules).and_return [:modules]
+      expect(subject.modules).to eq([:modules])
+    end
+  end
+end

data/spec/unit/git/repository_spec.rb

@@ -21,14 +21,4 @@ describe R10K::Git::Repository do
       })
     end
   end
-
-  describe "tags" do
-    let(:tags) { %w[0.1.1 0.1.2 0.1.3 0.1.4 0.2.0 0.3.0 2.0.0] }
-    let(:output) { tags.map {|x| x + "\n"}.join }
-
-    it "returns a list of tags for this repo" do
-      expect(subject).to receive(:git).with(%w[tag -l], anything).and_return(double(:stdout => output))
-      expect(subject.tags).to eq(tags)
-    end
-  end
 end

data/spec/unit/git/working_dir_spec.rb

@@ -2,120 +2,11 @@ require 'spec_helper'
 require 'r10k/git'
 
 describe R10K::Git::WorkingDir do
-  include_context "fail on execution"
 
   describe "initializing" do
     it "generates a new cache for the remote" do
-      wd = described_class.new('master', 'git://github.com/adrienthebo/r10k-fixture-repo', '/some/nonexistent/dir')
+      wd = described_class.new('master', 'git://github.com/adrienthebo/r10k-fixture-repo', '/tmp')
       wd.cache.should be_kind_of R10K::Git::Cache
     end
-
-    it "uses the provided ref as the dirname when no dirname is given" do
-      wd = described_class.new('master', 'git://github.com/adrienthebo/r10k-fixture-repo', '/some/nonexistent/dir')
-      expect(wd.dirname).to eq('master')
-    end
-
-    it "uses an explicit dirname when given" do
-      wd = described_class.new('master', 'git://github.com/adrienthebo/r10k-fixture-repo', '/some/nonexistent/dir', 'mydir')
-      expect(wd.dirname).to eq('mydir')
-    end
-  end
-
-  describe "synchronizing the working directory" do
-    subject { described_class.new('master', 'git://github.com/adrienthebo/r10k-fixture-repo', '/some/nonexistent/dir') }
-    it "clones the repository when the repository doesn't exist" do
-      expect(subject).to receive(:cloned?).and_return false
-      expect(subject).to receive(:clone)
-      subject.sync
-    end
-
-    it "updates the repository when the repository already exists" do
-      expect(subject).to receive(:cloned?).and_return true
-      expect(subject).to receive(:update)
-      subject.sync
-    end
-  end
-
-  describe "when cloning a new repository" do
-    subject { described_class.new('master', 'git://github.com/adrienthebo/r10k-fixture-repo', '/some/nonexistent/dir') }
-
-    before do
-      allow(subject).to receive(:cloned?).and_return false
-    end
-
-    it "updates the cache before cloning" do
-      expect(subject.cache).to receive(:sync)
-      allow(subject).to receive(:git)
-      allow(subject).to receive(:checkout)
-      subject.sync
-    end
-
-    it "clones the repository and uses the cache git dir as an object reference" do
-      allow(subject.cache).to receive(:sync)
-      expect(subject).to receive(:git).with(['clone', '--reference', subject.cache.git_dir,
-                                             'git://github.com/adrienthebo/r10k-fixture-repo',
-                                             '/some/nonexistent/dir/master'])
-      expect(subject).to receive(:git).with(['remote', 'add', 'cache', subject.cache.git_dir],
-                                            an_instance_of(Hash))
-
-      expect(subject).to receive(:git).with(['fetch', 'cache'], an_instance_of(Hash))
-      allow(subject).to receive(:checkout)
-      subject.sync
-    end
-
-    it 'checks out the specific ref after the clone' do
-      allow(subject.cache).to receive(:sync)
-      allow(subject).to receive(:git)
-      expect(subject).to receive(:checkout)
-      subject.sync
-    end
-  end
-
-  describe "updating an existing repository" do
-    subject { described_class.new('master', 'git://github.com/adrienthebo/r10k-fixture-repo', '/some/nonexistent/dir') }
-
-    before do
-      allow(subject).to receive(:cloned?).and_return true
-    end
-
-    it "updates the remotes when they are out of sync" do
-      allow(subject).to receive(:ref_needs_fetch?).and_return false
-      allow(subject).to receive(:needs_checkout?).and_return false
-
-      expect(subject).to receive(:update_remotes?).and_return true
-      expect(subject).to receive(:update_remotes)
-
-      subject.sync
-    end
-
-    it "updates the cache when the ref requires an update" do
-      allow(subject).to receive(:update_remotes?).and_return false
-
-      expect(subject).to receive(:ref_needs_fetch?).and_return true
-      expect(subject).to receive(:fetch_from_cache)
-      expect(subject).to receive(:checkout).with(an_instance_of(R10K::Git::Ref))
-
-      subject.sync
-    end
-
-    it "checks out the ref when the wrong commit is checked out" do
-      allow(subject).to receive(:update_remotes?).and_return false
-      allow(subject).to receive(:ref_needs_fetch?).and_return false
-
-      expect(subject).to receive(:needs_checkout?).and_return true
-      expect(subject).to receive(:checkout).with(an_instance_of(R10K::Git::Ref))
-
-      subject.sync
-    end
-
-    it "doesn't update the repo when everything is in sync" do
-      allow(subject).to receive(:update_remotes?).and_return false
-      allow(subject).to receive(:ref_needs_fetch?).and_return false
-      allow(subject).to receive(:needs_checkout?).and_return false
-
-      expect(subject).to_not receive(:checkout)
-
-      subject.sync
-    end
   end
 end

data/spec/unit/{registry_spec.rb → instance_cache_spec.rb}

@@ -1,10 +1,10 @@
 require 'spec_helper'
 
-require 'r10k/registry'
+require 'r10k/instance_cache'
 
-describe R10K::Registry do
+describe R10K::InstanceCache do
 
-  describe "setting up a new registry" do
+  describe "setting up a new instance cache" do
     let(:klass) do
       dubs = double('test class')
       allow(dubs).to receive(:new) { |*args| args }

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/source/git_spec.rb

@@ -0,0 +1,274 @@
+require 'spec_helper'
+require 'r10k/source'
+
+describe R10K::Source::Git do
+
+  subject do
+    described_class.new('mysource', '/some/nonexistent/dir',
+                        {:remote => 'https://git-server/repo.git'})
+  end
+
+  it "stores the name" do
+    expect(subject.name).to eq 'mysource'
+  end
+
+  it "stores the basedir" do
+    expect(subject.basedir).to eq '/some/nonexistent/dir'
+  end
+
+  describe "preloading" do
+    it "fetches the git cache" do
+      expect(subject.cache).to receive(:sync)
+      subject.preload!
+    end
+  end
+
+  describe "lazily generating environments" do
+    it "returns an empty list of environments when the cache has not been created" do
+      allow(subject.cache).to receive(:cached?).and_return false
+      expect(subject.environments).to be_empty
+    end
+
+    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
+    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
+    end
+  end
+
+  describe "eagerly generating environments" do
+    before do
+      allow(subject.cache).to receive(:branches).and_return %w[master]
+    end
+
+    let(:master_env) { subject.generate_environments.first }
+
+    it "creates an environment for each branch" do
+      expect(subject.generate_environments).to have(1).items
+    end
+
+    it "copies the source remote to the environment" do
+      expect(master_env.remote).to eq subject.remote
+    end
+
+    it "uses the branch name as the directory by default" do
+      expect(master_env.dirname).to eq 'master'
+    end
+  end
+end
+
+describe R10K::Source::Git, "handling invalid branch names" do
+  %w[correct_and_warn correct].each do |setting|
+    describe "when invalid is #{setting}" do
+      subject do
+        described_class.new('/some/nonexistent/dir', 'mysource', {
+          :remote           => 'https://git-server/repo.git',
+          :invalid_branches => setting
+        })
+      end
+
+      before do
+        allow(subject.cache).to receive(:branches).and_return ['master', 'invalid-branch']
+      end
+
+      it "creates an environment for each branch" do
+        expect(subject.generate_environments).to have(2).items
+      end
+
+      it "removes invalid characters from branch names" do
+        invalid_env = subject.generate_environments.last
+        expect(invalid_env.dirname).to eq 'invalid_branch'
+      end
+    end
+  end
+
+  describe "when invalid is 'error'" do
+    subject do
+      described_class.new('/some/nonexistent/dir', 'mysource', {
+        :remote   => 'https://git-server/repo.git',
+        :invalid_branches => 'error',
+      })
+    end
+
+    before do
+      allow(subject.cache).to receive(:branches).and_return ['master', 'invalid-branch']
+    end
+
+    it "only creates an environment for valid branches" do
+      expect(subject.generate_environments).to have(1).items
+    end
+  end
+end
+
+# Since prefixing is an immutable property of a source, it's easier to create
+# a new context and duplicate stubs in a single location rather than packing a
+# single test with all the stubs that entirely recreate the source.
+describe R10K::Source::Git, 'when prefixing is enabled' do
+  subject do
+    described_class.new(
+      'prefixed',
+      '/some/nonexistent/dir',
+      {
+        :prefix => true,
+        :remote => 'https://git-server/repo.git',
+      })
+  end
+
+  describe "generating prefixed environments" do
+    before do
+      allow(subject.cache).to receive(:cached?).and_return true
+      allow(subject.cache).to receive(:branches).and_return %w[master other]
+    end
+
+    let(:environments) { subject.environments }
+
+    it "creates an environment for each branch" do
+      expect(subject.environments).to have(2).items
+    end
+
+    it "prefixes the source name to environments when prefixing is enabled" do
+      expect(environments[0].dirname).to eq 'prefixed_master'
+      expect(environments[1].dirname).to eq 'prefixed_other'
+    end
+  end
+end
+
+describe R10K::Source::Git, 'registering as a source' do
+  it "registers with the :git key" do
+    expect(R10K::Source.retrieve(:git)).to eq described_class
+  end
+
+  it "registers with the nil key" do
+    expect(R10K::Source.retrieve(nil)).to eq described_class
+  end
+end
+
+describe R10K::Source::Git::BranchName do
+  describe "prefixing" do
+    it "uses the branch name as the dirname when prefixing is off" do
+      bn = described_class.new('mybranch', {:prefix => false, :sourcename => 'foo'})
+      expect(bn.dirname).to eq 'mybranch'
+    end
+
+    it "prepends the source name when prefixing is on" do
+      bn = described_class.new('mybranch', {:prefix => true, :sourcename => 'foo'})
+      expect(bn.dirname).to eq 'foo_mybranch'
+    end
+  end
+
+  describe "determining the validate behavior with :invalid" do
+    [
+      ['correct_and_warn', {:validate => true, :correct => true}],
+      ['correct',          {:validate => false, :correct => true}],
+      ['error',            {:validate => true, :correct => false}],
+    ].each do |(setting, outcome)|
+      it "treats #{setting} as #{outcome.inspect}" do
+        bn = described_class.new('mybranch', {:invalid => setting})
+        expect(bn.validate?).to eq outcome[:validate]
+        expect(bn.correct?).to eq outcome[:correct]
+      end
+    end
+  end
+
+  describe "determining if a branch is a valid environment name" do
+    invalid_cases = [
+      'hyphenated-branch',
+      'dotted.branch',
+      'slashed/branch',
+      'at@branch',
+      'http://branch'
+    ]
+
+    valid_cases = [
+      'my_branchname',
+      'my_issue_346',
+    ]
+
+    describe "and validate is false" do
+      invalid_cases.each do |branch|
+        it "is valid if the branch is #{branch}" do
+          bn = described_class.new(branch, {:validate => false})
+          expect(bn).to be_valid
+        end
+      end
+
+      valid_cases.each do |branch|
+        it "is valid if the branch is #{branch}" do
+          bn = described_class.new(branch, {:validate => false})
+          expect(bn).to be_valid
+        end
+      end
+    end
+
+    describe "and validate is true" do
+      invalid_cases.each do |branch|
+        it "is invalid if the branch is #{branch}" do
+          bn = described_class.new(branch, {:validate => true})
+          expect(bn).to_not be_valid
+        end
+      end
+
+      valid_cases.each do |branch|
+        it "is valid if the branch is #{branch}" do
+          bn = described_class.new(branch, {:validate => true})
+          expect(bn).to be_valid
+        end
+      end
+
+    end
+  end
+
+  describe "correcting branch names" do
+    invalid_cases = [
+      'hyphenated-branch',
+      'dotted.branch',
+      'slashed/branch',
+      'at@branch',
+      'http://branch'
+    ]
+
+    valid_cases = [
+      'my_branchname',
+      'my_issue_346',
+    ]
+
+    describe "and correct is false" do
+      invalid_cases.each do |branch|
+        it "doesn't modify #{branch}" do
+          bn = described_class.new(branch.dup, {:correct => false})
+          expect(bn.dirname).to eq branch
+        end
+      end
+
+      valid_cases.each do |branch|
+        it "doesn't modify #{branch}" do
+          bn = described_class.new(branch.dup, {:correct => false})
+          expect(bn.dirname).to eq branch
+        end
+      end
+    end
+
+    describe "and correct is true" do
+      invalid_cases.each do |branch|
+        it "replaces invalid characters in #{branch} with underscores" do
+          bn = described_class.new(branch.dup, {:correct => true})
+          expect(bn.dirname).to eq branch.gsub(/\W/, '_')
+        end
+      end
+
+      valid_cases.each do |branch|
+        it "doesn't modify #{branch}" do
+          bn = described_class.new(branch.dup, {:correct => true})
+          expect(bn.dirname).to eq branch
+        end
+      end
+    end
+  end
+end

data/spec/unit/source/svn_spec.rb

@@ -0,0 +1,102 @@
+require 'spec_helper'
+require 'r10k/source'
+
+describe R10K::Source::SVN do
+
+  subject do
+    described_class.new('mysource', '/some/nonexistent/dir',
+                        {:remote => 'https://svn-server.site/repo'})
+  end
+
+  it "stores the name" do
+    expect(subject.name).to eq 'mysource'
+  end
+
+  it "stores the basedir" do
+    expect(subject.basedir).to eq '/some/nonexistent/dir'
+  end
+
+
+  describe "lazily generating environments" do
+    it "generates environments when they have not been loaded" do
+      expect(subject).to receive(:generate_environments).and_return %w[hi]
+      expect(subject.environments).to eq %w[hi]
+    end
+
+    it "doesn't recreate environments if they have already been loaded" do
+      expect(subject).to receive(:generate_environments).once.and_return %w[hi]
+      subject.environments
+      subject.environments
+    end
+  end
+
+  describe "eagerly generating environments" do
+    before do
+      allow(subject.svn_remote).to receive(:branches).and_return %w[apache dns robobutler]
+    end
+
+    let(:environments) { subject.generate_environments }
+
+    it "creates an environment for each branch and the trunk" do
+      expect(environments[0].name).to eq 'production'
+      expect(environments[1].name).to eq 'apache'
+      expect(environments[2].name).to eq 'dns'
+      expect(environments[3].name).to eq 'robobutler'
+    end
+
+    it "maps trunk to production" do
+      expect(environments[0].remote).to eq 'https://svn-server.site/repo/trunk'
+    end
+
+    it "sets the remote for branch environments to subdirectories of the branches/ directory" do
+      expect(environments[1].remote).to eq 'https://svn-server.site/repo/branches/apache'
+      expect(environments[2].remote).to eq 'https://svn-server.site/repo/branches/dns'
+      expect(environments[3].remote).to eq 'https://svn-server.site/repo/branches/robobutler'
+    end
+
+    it "uses the branch name as the directory by default" do
+      expect(environments[0].dirname).to eq 'production'
+      expect(environments[1].dirname).to eq 'apache'
+      expect(environments[2].dirname).to eq 'dns'
+      expect(environments[3].dirname).to eq 'robobutler'
+    end
+  end
+end
+
+describe R10K::Source::SVN, 'when prefixing is enabled' do
+  subject do
+    described_class.new(
+      'mysource',
+      '/some/nonexistent/dir',
+      {
+        :remote => 'https://svn-server.site/repo',
+        :prefix => true
+      }
+    )
+  end
+
+  describe "generating prefixed environments" do
+    before do
+      allow(subject.svn_remote).to receive(:branches).and_return %w[apache dns robobutler]
+    end
+
+    let(:environments) { subject.generate_environments }
+
+    it "creates an environment for each branch and the trunk" do
+      expect(environments).to have(4).items
+    end
+
+    it "prefixes the source name to environments" do
+      expect(environments[0].dirname).to eq 'mysource_production'
+      expect(environments[1].dirname).to eq 'mysource_apache'
+      expect(environments[2].dirname).to eq 'mysource_dns'
+      expect(environments[3].dirname).to eq 'mysource_robobutler'
+    end
+  end
+end
+
+describe R10K::Source::SVN, 'registering as a source' do
+  it "registers with the :svn key" do
+    expect(R10K::Source.retrieve(:svn)).to eq described_class
+  end
+end

data/spec/unit/source_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+require 'r10k/source'
+
+describe R10K::Source do
+  it "implementds methods for a keyed factory" do
+    expect(described_class).to respond_to :register
+    expect(described_class).to respond_to :retrieve
+    expect(described_class).to respond_to :generate
+  end
+end

data/spec/unit/svn/remote_spec.rb

@@ -0,0 +1,21 @@
+require 'r10k'
+require 'r10k/svn'
+
+describe R10K::SVN::Remote do
+  subject { described_class.new('https://svn-server.site/repo') }
+
+  it "generates the trunk URL by appending '/trunk' to the base URL" do
+    expect(subject.trunk).to eq 'https://svn-server.site/repo/trunk'
+  end
+
+  describe "retrieving branches" do
+    let(:branches) do
+      %[apache/\ndns/\nrobobutler/\nstaging/\n]
+    end
+
+    it "enumerates the /branches directory of the base URL" do
+      allow(subject).to receive(:svn).with(['ls', 'https://svn-server.site/repo/branches']).and_return(branches)
+      expect(subject.branches).to eq(%w[apache dns robobutler staging])
+    end
+  end
+end