clc-promote 0.4.3 → 0.4.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5639da39cb5c09225b1f84de02e315c550483433
-  data.tar.gz: a5c506c785f6495178c4c94100980ff7336fca49
+  metadata.gz: 674a20f898ac27d30598579081401a13f660e374
+  data.tar.gz: 55dd1f8a1927e4ff519e40bc33762abd56d40680
 SHA512:
-  metadata.gz: 90a38c6dcabf0a36451cf90e3c14e1de96de0edd631fc3eb5b7bf861e99fa06abf11eb2ce41191f706449472f03cb53f7841af7a4940a46ece02bb6f2bc50289
-  data.tar.gz: 500302a8fbb0809c1cf21c46c95655f4fdfdf6d5165a7a2a9a6e573b2fc1a1c6a44f8d6d15f6fe051c673ff66dcbf14ef465a4ff9ffb41a5c3076db85a9e369c
+  metadata.gz: dd0d30a5d62a51f14c8f30398971ac4cc4be3252c0152817e4ee71aaa66224bf481d2936fd537bfeadd28cbe0a2e990b181604d6b5aa72011140fd7c32d0c090
+  data.tar.gz: 1d1462b21bddf6cb3ed0bb5bd05929f79732e70b8ef782600b72c018e2d7f9c6cb5bb12dca81bbb8a02b8db4d7edac92aaca47c11ea04fd21ed449136f1766fc

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+*.gem

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:test)
+
+task :default => [:test]

data/clc-promote.gemspec

@@ -0,0 +1,24 @@
+$:.unshift(File.dirname(__FILE__) + '/lib')
+require 'promote/version'
+
+Gem::Specification.new do |s|
+  s.name = 'clc-promote'
+  s.version = Promote::VERSION
+  s.platform = Gem::Platform::RUBY
+  s.extra_rdoc_files = ['README.md']
+  s.summary = 'Provides versioning and promotion logic for chef artifacts.'
+  s.description = s.summary
+  s.authors = ['CenturyLink Cloud']
+  s.email = 'matt.wrock@CenturyLinkCloud.com'
+  s.homepage = 'https://github.com/tier3/DevOps/gems/clc-promote'
+
+  s.require_path = 'lib'
+  s.files         = `git ls-files -z`.split("\x0")
+  s.test_files    = s.files.grep(%r{^(test|spec|features)/})
+
+  s.add_runtime_dependency 'clc-git', '~> 1.2', '>= 1.2.8'
+  s.add_runtime_dependency 'berkshelf', '~> 3.1', '>= 3.1.4'
+
+  s.add_development_dependency 'rspec', '~> 3.0', '>= 3.0.0'
+  s.add_development_dependency 'rake', '~> 10.3', '>= 10.3.2'
+end

data/lib/kitchen/provisioner/environment.rb

@@ -0,0 +1,79 @@
+require 'forwardable'
+require "berkshelf/downloader"
+require "kitchen/provisioner/chef_zero"
+require "promote"
+
+module Kitchen
+
+  module Provisioner
+
+    class Environment < ChefZero
+
+      def create_sandbox
+        super
+        prepare_environment_dependencies
+        create_node
+      end
+
+      private
+
+      def create_node
+        node_file = File.join(instance.busser[:test_base_path], "nodes/#{instance.suite.name}.json")
+        if File.exist?(node_file)
+          node = JSON.parse(File.read(node_file))
+          node[:run_list] = config[:run_list]
+          File.open(node_file, 'w') do |out|
+            out << JSON.pretty_generate(node)
+          end
+        end
+      end
+
+      def prepare_environment_dependencies
+        if !config[:client_rb].has_key?(:environment)
+          info("No environment specified to lock")
+          return
+        end
+
+        environment = config[:client_rb][:environment]
+        repo = File.dirname(config[:environments_path])
+        promote_config = Promote::Config.new(:repo_root => repo)
+        env_file = Promote::EnvironmentFile.new(environment, promote_config)
+
+        info("comparing current cookbook versions to those in #{environment}")
+        Kitchen.mutex.synchronize do
+          berks_path = File.join(config[:kitchen_root], 'Berksfile')
+          ::Berkshelf.set_format :null
+          berks = ::Berkshelf::Berksfile.from_file(berks_path)
+          downloader = ::Berkshelf::Downloader.new(berks)
+          berks.install
+          my_deps = berks.list
+
+          my_deps.each do | dep |
+            next if dep.location.respond_to?(:relative_path)
+            env_version = env_file.cookbook_versions[dep.name]
+
+            if !env_version.nil? && dep.locked_version.to_s != env_version
+              if dep.name == File.basename(config[:kitchen_root])
+                raise "cookbook '#{dep.name}' is outdated. Expected v#{env_version} from #{environment}"
+              end
+
+              info("replacing v#{dep.locked_version} of #{dep.name} with #{env_version}")
+              downloader.download(dep.name, env_version) do |stash|
+                FileUtils.copy_entry(stash, File.join(tmpbooks_dir, dep.name))
+              end
+            end
+          end
+
+          # we do this because the vendoring converts metadayta.rb to json
+          # any subsequent berks command on the vendored cookbook will fail
+          FileUtils.rm_rf Dir.glob("#{tmpbooks_dir}/**/Berksfile*")
+        end
+      end
+
+      def tmpbooks_dir
+        File.join(sandbox_path, "cookbooks")
+      end
+
+    end
+  end
+end

data/lib/promote/version.rb

@@ -0,0 +1,3 @@
+module Promote
+  VERSION = '0.4.4'
+end

data/spec/unit/kitchen/provisioner/environment_spec.rb

@@ -0,0 +1,104 @@
+require 'kitchen'
+require 'kitchen/configurable'
+require 'kitchen/provisioner/environment'
+
+describe Kitchen::Provisioner::Environment do
+  let(:logged_output)   { StringIO.new }
+  let(:logger)          { Logger.new(logged_output) }
+  let(:config) do
+    { :test_base_path => "/b", :kitchen_root => "/cookbook_4", :log_level => :info, :sudo => true, :client_rb => client_rb_config, :environments_path => '/env/path' }
+  end
+  let(:suite) do
+    double('suite', :name => "fries")
+  end
+  let(:transport) do
+    double('transport', :sudo => config[:sudo], :shell => "bourne")
+  end
+  let(:instance) do
+    double('instance', :name => "coolbeans", :logger => logger, :suite => suite, :transport => transport, :busser => {:test_base_path => 'base_path'})
+  end
+  let(:downloader) { double('downloader') }
+  let(:fake_berks) { double('berksfile', :install => nil, :update => nil, :list => [
+    double('Dependency', :name => 'cookbook_2', :locked_version => Semverse::Version.new('1.1.1'), :location => nil),
+    double('Dependency', :name => 'cookbook_3', :locked_version => Semverse::Version.new('2.2.2'), :location => nil),
+    double('Dependency', :name => 'cookbook_4', :locked_version => Semverse::Version.new('3.3.3'), :location => nil)
+  ]) }
+  let(:client_rb_config) { {:environment => 'environment'} }
+  let (:env_file) { double('env', :cookbook_versions => {
+      'cookbook_2' => '1.1.1',
+      'cookbook_3' => '2.2.2',
+      'cookbook_4' => '3.3.3'
+  })}
+
+  subject { Kitchen::Provisioner::Environment.new(config).finalize_config!(instance) }
+
+  before {
+    allow(FileUtils).to receive(:rm_rf)
+    allow(FileUtils).to receive(:copy_entry)
+    allow(Berkshelf::Berksfile).to receive(:from_file).and_return(fake_berks)
+    allow(Promote::EnvironmentFile).to receive(:new).and_return(env_file)
+    allow(Berkshelf::Downloader).to receive(:new).and_return(downloader)
+  }
+
+  context "when no environment specified" do
+    let(:client_rb_config) { {} }
+
+    it "does not get berks dependencies" do
+      expect(fake_berks).not_to receive(:list)
+      subject.create_sandbox
+    end
+  end
+
+  context "wnem local cookbooks are outdated" do
+    let (:env_file) { double('env', :cookbook_versions => {
+      'cookbook_2' => '2.2.2',
+      'cookbook_3' => '2.2.2',
+      'cookbook_4' => '3.3.3'
+    })}
+
+    it "downloads the outdated cookbooks" do
+      expect(downloader).to receive(:download).with('cookbook_2', '2.2.2')
+      subject.create_sandbox
+    end
+  end
+
+  context "when environment file is missing a dependency" do
+    let (:env_file) { double('env', :cookbook_versions => {
+      'cookbook_2' => '2.2.2',
+      'cookbook_4' => '3.3.3'
+    })}
+
+    it "downloads only the outdated cookbook" do
+      expect(downloader).to receive(:download).with('cookbook_2', '2.2.2')
+      subject.create_sandbox
+    end
+  end
+
+  context "when cookbook under test is outdated" do
+    let (:env_file) { double('env', :cookbook_versions => {
+      'cookbook_2' => '1.1.1',
+      'cookbook_3' => '2.2.2',
+      'cookbook_4' => '4.4.4'
+    })}
+
+    it "downloads only the outdated cookbooks" do
+      expect{subject.create_sandbox}.to raise_error(/4\.4\.4/)
+    end
+  end
+
+  context "when outdated cookbook is from a local source" do
+    let(:fake_berks) { double('berksfile', :install => nil, :update => nil, :list => [
+      double('Dependency', :name => 'cookbook_2', :locked_version => Semverse::Version.new('1.1.1'), :location => nil),
+      double('Dependency', 
+        :name => 'cookbook_3', 
+        :locked_version => Semverse::Version.new('1.1.1'), 
+        :location => double('location', :relative_path => '../cookbook')),
+      double('Dependency', :name => 'cookbook_4', :locked_version => Semverse::Version.new('3.3.3'), :location => nil)
+    ]) }
+
+    it "downloads only the outdated cookbooks" do
+      expect(downloader).not_to receive(:download)
+      subject.create_sandbox
+    end
+  end
+end

data/spec/unit/promote/config_spec.rb

@@ -0,0 +1,92 @@
+require 'promote'
+
+describe Promote::Config do
+	let(:opts) {{ 
+		:repo_root => "root", 
+		:cookbook_directory => "cookbooks", 
+		:environment_directory => "environments", 
+		:data_bag_directory => "data_bags", 
+		:temp_directory => "temp", 
+		:node_name => "user", 
+		:client_key => "key", 
+		:chef_server_url => "url"}}
+	subject { Promote::Config.new(opts) }
+
+	it "assigns options to node_name attribute" do
+		expect(subject.node_name).to eq(opts[:node_name])
+	end
+	it "assigns options to client_key attribute" do
+		expect(subject.client_key).to eq(opts[:client_key])
+	end
+	it "assigns options to chef_server_url attribute" do
+		expect(subject.chef_server_url).to eq(opts[:chef_server_url])
+	end
+	it "assigns options to repo_root attribute" do
+		expect(subject.repo_root).to eq(opts[:repo_root])
+	end
+	it "assigns options to cookbook_directory attribute" do
+		expect(subject.cookbook_directory).to eq(opts[:cookbook_directory])
+	end
+	it "assigns options to data_bag_directory attribute" do
+		expect(subject.data_bag_directory).to eq(opts[:data_bag_directory])
+	end
+	it "assigns options to environment_directory attribute" do
+		expect(subject.environment_directory).to eq(opts[:environment_directory])
+	end
+	it "assigns options to temp_directory attribute" do
+		expect(subject.temp_directory).to eq(opts[:temp_directory])
+	end
+	it "can correctly convert to a hash" do
+		hash = subject.to_hash
+		expect(hash[:repo_root]).to eq(opts[:repo_root])
+	end
+
+	context "directories are not in options" do
+		let(:opts) {{ 
+			:node_name => "user", 
+			:client_key => "key", 
+			:chef_server_url => "url"}}
+		subject { Promote::Config.new(opts) }
+
+		it "assigns repo_root to pwd" do
+			expect(subject.repo_root).to eq(Dir.pwd)
+		end
+		it "assigns cookbook_directory to cookbooks off root" do
+			expect(subject.cookbook_directory).to eq(File.join(subject.repo_root, "cookbooks"))
+		end
+		it "assigns data_bag_directory to data_bags off root" do
+			expect(subject.data_bag_directory).to eq(File.join(subject.repo_root, "data_bags"))
+		end
+		it "assigns environment_directory to environments off root" do
+			expect(subject.environment_directory).to eq(File.join(subject.repo_root, "environments"))
+		end
+		it "assigns temp_directory to tmp" do
+			expect(subject.temp_directory).to eq("/tmp/promote")
+		end
+	end
+
+	context "directories are not in options but repo root is" do
+		let(:opts) {{ 
+			:repo_root => "root",
+			:node_name => "user", 
+			:client_key => "key", 
+			:chef_server_url => "url"}}
+		subject { Promote::Config.new(opts) }
+
+		it "assigns repo_root to pwd" do
+			expect(subject.repo_root).to eq(opts[:repo_root])
+		end
+		it "assigns cookbook_directory to cookbooks off root" do
+			expect(subject.cookbook_directory).to eq(File.join(subject.repo_root, "cookbooks"))
+		end
+		it "assigns data_bag_directory to data_bags off root" do
+			expect(subject.data_bag_directory).to eq(File.join(subject.repo_root, "data_bags"))
+		end
+		it "assigns environment_directory to environments off root" do
+			expect(subject.environment_directory).to eq(File.join(subject.repo_root, "environments"))
+		end
+		it "assigns temp_directory to tmp" do
+			expect(subject.temp_directory).to eq("/tmp/promote")
+		end
+	end
+end

data/spec/unit/promote/cookbook_spec.rb

@@ -0,0 +1,250 @@
+require 'promote'
+
+describe Promote::Cookbook do 
+  let(:cookbook_dir) {'/tmp/promote_test_cookbooks/stubs'}
+  let(:config) { Promote::Config.new({ 
+    :cookbook_directory => cookbook_dir}) 
+  }
+  let(:fake_berks) { double('berksfile', :list => nil, :install => nil, :update => nil) }
+
+  before(:all) {
+    cb_dir = '/tmp/promote_test_cookbooks'
+    FileUtils.rm_rf(cb_dir) if Dir.exist?(cb_dir)
+    Dir.mkdir(cb_dir)
+    FileUtils.cp_r(File.join(File.dirname(File.dirname(__FILE__)), 'stubs'), cb_dir)
+  }
+
+  subject { Promote::Cookbook.new('cookbook_1', config) }
+
+  describe "dependencies" do
+    before {
+      allow(Berkshelf::Berksfile).to receive(:from_file).and_return(fake_berks)
+      allow(fake_berks).to receive(:list).and_return([
+        double('Dependency', :name => 'cookbook_2', :locked_version => Semverse::Version.new('1.1.1')),
+        double('Dependency', :name => 'cookbook_3', :locked_version => Semverse::Version.new('2.2.2')),
+        double('Dependency', :name => 'cookbook_4', :locked_version => Semverse::Version.new('3.3.3'))
+        ])
+    }
+
+    it "returns dependencies from lockfile" do
+      expect(subject.dependencies.keys.count).to be 3
+      expect(subject.dependencies['cookbook_2'].to_s).to eq '1.1.1'
+      expect(subject.dependencies['cookbook_3'].to_s).to eq '2.2.2'
+      expect(subject.dependencies['cookbook_4'].to_s).to eq '3.3.3'
+    end
+  end
+
+  describe "metadata_dependencies" do
+
+    it "returns dependencies from metadata.rb" do
+      expect(subject.metadata_dependencies.keys.count).to be 1
+      expect(subject.metadata_dependencies['cookbook_2'].to_s).to eq '= 1.1.1'
+    end
+  end
+
+  describe "path" do
+
+    it "returns the correct path of the cookbook" do
+      expect(subject.path).to eq(File.join(cookbook_dir, 'cookbook_1'))
+    end
+  end
+
+  describe "version" do
+
+    it "reads the current version" do
+      expect(subject.version.to_s).to eq('1.0.0')
+    end
+
+    it "writes changed version to metadata.rb" do
+      subject.version = Semverse::Version.new('2.2.2')
+      expect(Promote::Cookbook.new('cookbook_1', config).version.to_s).to eq '2.2.2'
+    end
+
+    it "returns the new version after a version has changed" do
+      subject.version = Semverse::Version.new('2.2.2')
+      expect(subject.version.to_s).to eq('2.2.2')
+    end
+  end
+
+  describe "stamp_commit" do
+    it "writes the sha1 to the end of the metadata file" do
+      subject.stamp_commit('commit_1')
+      expect(subject.raw_metadata).to end_with "\n#sha1 'commit_1'"
+    end
+
+    it "does not write the sha1 m ore than once" do
+      subject.stamp_commit('commit_1')
+      subject.stamp_commit('commit_2')
+      expect(subject.raw_metadata).not_to include "commit_1"
+    end
+  end
+
+  describe "sync_berksfile" do
+    before {
+      allow(File).to receive(:exist?).with(/Berksfile$/).and_return(true)
+      allow(File).to receive(:exist?).with(/Berksfile.lock/).and_return(true)
+    }
+
+    it "Installs berks dependencies" do
+      dummy = double('berksfile')
+      expect(Berkshelf::Berksfile).to receive(:from_file).with(
+        File.join(subject.path, "Berksfile")).and_return(dummy)
+      expect(dummy).to receive(:install)
+
+      subject.sync_berksfile
+    end
+
+    it "Updates berks dependencies when asked to update" do
+      dummy = double('berksfile')
+      expect(Berkshelf::Berksfile).to receive(:from_file).with(
+        File.join(subject.path, "Berksfile")).and_return(dummy)
+      expect(dummy).to receive(:update)
+
+      subject.sync_berksfile(true)
+    end
+
+    context "update berksfile with no lock file" do
+      before {
+        allow(File).to receive(:exist?).with(/Berksfile.lock/).and_return(false)
+      }
+
+      it "Installs berks dependencies instead of update" do
+        dummy = double('berksfile')
+        expect(Berkshelf::Berksfile).to receive(:from_file).with(
+          File.join(subject.path, "Berksfile")).and_return(dummy)
+        expect(dummy).to receive(:install)
+
+        subject.sync_berksfile(true)
+      end
+    end
+  end
+
+  describe "dependencies_changed_after_update?" do
+    before {
+      allow(File).to receive(:exist?).and_return(true)
+      allow(Berkshelf::Berksfile).to receive(:from_file).and_return(fake_berks)
+      allow(fake_berks).to receive(:list).and_return([
+        double('Dependency', :name => 'cookbook_2', :locked_version => Semverse::Version.new('1.1.1')),
+        double('Dependency', :name => 'cookbook_3', :locked_version => Semverse::Version.new('2.2.2')),
+        double('Dependency', :name => 'cookbook_4', :locked_version => Semverse::Version.new('3.3.3'))
+        ])
+    }
+
+    it "performs a berks update" do
+      expect(fake_berks).to receive(:update)
+      subject.dependencies_changed_after_update?
+    end
+
+    context "there is no change" do
+
+      before {
+        allow(fake_berks).to receive(:list).and_return(
+          [
+            double('Dependency', :name => 'cookbook_2', :locked_version => Semverse::Version.new('1.1.1')),
+            double('Dependency', :name => 'cookbook_3', :locked_version => Semverse::Version.new('2.2.2')),
+            double('Dependency', :name => 'cookbook_4', :locked_version => Semverse::Version.new('3.3.3'))
+          ],
+          [
+            double('Dependency', :name => 'cookbook_2', :locked_version => Semverse::Version.new('1.1.1')),
+            double('Dependency', :name => 'cookbook_3', :locked_version => Semverse::Version.new('2.2.2')),
+            double('Dependency', :name => 'cookbook_4', :locked_version => Semverse::Version.new('3.3.3'))
+          ]
+        )
+      }
+
+      it "returns false" do
+        expect(subject.dependencies_changed_after_update?).to be false
+      end
+    end
+
+    context "there is a version change" do
+
+      before {
+        allow(Berkshelf::Berksfile).to receive(:from_file).and_return(fake_berks)
+        allow(fake_berks).to receive(:list).and_return(
+          [
+            double('Dependency', :name => 'cookbook_2', :locked_version => Semverse::Version.new('1.1.1')),
+            double('Dependency', :name => 'cookbook_3', :locked_version => Semverse::Version.new('2.2.2')),
+            double('Dependency', :name => 'cookbook_4', :locked_version => Semverse::Version.new('3.3.3'))
+          ],
+          [
+            double('Dependency', :name => 'cookbook_2', :locked_version => Semverse::Version.new('1.1.1')),
+            double('Dependency', :name => 'cookbook_3', :locked_version => Semverse::Version.new('2.2.3')),
+            double('Dependency', :name => 'cookbook_4', :locked_version => Semverse::Version.new('3.3.3'))
+          ]
+        )
+      }
+
+      it "returns true" do
+        expect(subject.dependencies_changed_after_update?).to be true
+      end
+    end
+
+    context "a dependency is removed" do
+
+      before {
+        allow(Berkshelf::Berksfile).to receive(:from_file).and_return(fake_berks)
+        allow(fake_berks).to receive(:list).and_return(
+          [
+            double('Dependency', :name => 'cookbook_2', :locked_version => Semverse::Version.new('1.1.1')),
+            double('Dependency', :name => 'cookbook_3', :locked_version => Semverse::Version.new('2.2.2')),
+            double('Dependency', :name => 'cookbook_4', :locked_version => Semverse::Version.new('3.3.3'))
+          ],
+          [
+            double('Dependency', :name => 'cookbook_2', :locked_version => Semverse::Version.new('1.1.1')),
+            double('Dependency', :name => 'cookbook_4', :locked_version => Semverse::Version.new('3.3.3'))
+          ]
+        )
+      }
+
+      it "returns true" do
+        expect(subject.dependencies_changed_after_update?).to be true
+      end
+    end
+
+    context "a dependency is added" do
+
+      before {
+        allow(Berkshelf::Berksfile).to receive(:from_file).and_return(fake_berks)
+        allow(fake_berks).to receive(:list).and_return(
+          [
+            double('Dependency', :name => 'cookbook_2', :locked_version => Semverse::Version.new('1.1.1')),
+            double('Dependency', :name => 'cookbook_3', :locked_version => Semverse::Version.new('2.2.2')),
+            double('Dependency', :name => 'cookbook_4', :locked_version => Semverse::Version.new('3.3.3'))
+          ],
+          [
+            double('Dependency', :name => 'cookbook_2', :locked_version => Semverse::Version.new('1.1.1')),
+            double('Dependency', :name => 'cookbook_3', :locked_version => Semverse::Version.new('2.2.2')),
+            double('Dependency', :name => 'cookbook_4', :locked_version => Semverse::Version.new('3.3.3')),
+            double('Dependency', :name => 'cookbook_5', :locked_version => Semverse::Version.new('3.3.3'))
+          ]
+        )
+      }
+
+      it "returns true" do
+        expect(subject.dependencies_changed_after_update?).to be true
+      end
+    end
+
+    context "the cookbook under test has changed" do
+
+      before {
+        allow(Berkshelf::Berksfile).to receive(:from_file).and_return(fake_berks)
+        allow(fake_berks).to receive(:list).and_return(
+          [
+            double('Dependency', :name => 'cookbook_1', :locked_version => Semverse::Version.new('1.1.1')),
+            double('Dependency', :name => 'cookbook_3', :locked_version => Semverse::Version.new('2.2.2')),
+          ],
+          [
+            double('Dependency', :name => 'cookbook_1', :locked_version => Semverse::Version.new('1.1.2')),
+            double('Dependency', :name => 'cookbook_3', :locked_version => Semverse::Version.new('2.2.2')),
+          ]
+        )
+      }
+
+      it "returns false" do
+        expect(subject.dependencies_changed_after_update?).to be false
+      end
+    end
+  end
+end

data/spec/unit/promote/promoter_spec.rb

@@ -0,0 +1,59 @@
+require 'promote'
+
+describe Promote::Promoter do
+  context "Promote one environment to another" do
+    let(:config) { Promote::Config.new({ 
+      :node_name => 'user', 
+      :cookbook_directory => '/cookbooks',
+      :client_key => 'key', 
+      :chef_server_url => 'https://some.chef.server'}) }
+    let(:fake_file){double('file')}
+    let(:env1) do
+      <<-EOS
+        {
+          "name": "QA1",
+          "chef_type": "environment",
+          "json_class": "Chef::Environment",
+          "cookbook_versions": {
+            "build-essential": "2.0.0",
+            "newrelic": "2.0.0",
+            "platform_haproxy": "2.0.0"
+          }
+        }
+      EOS
+    end
+
+    let(:env2) do
+      <<-EOS
+        {
+          "name": "QA1",
+          "chef_type": "environment",
+          "json_class": "Chef::Environment",
+          "cookbook_versions": {
+            "build-essential": "1.0.0",
+            "platform_haproxy": "1.0.0"
+          }          
+        }
+      EOS
+    end
+
+    before {
+      allow(File).to receive(:read).with(/env1\.json$/).and_return(env1)
+      allow(File).to receive(:read).with(/env2\.json$/).and_return(env2)
+      allow(File).to receive(:open).with(/env2\.json$/, "w").and_yield(fake_file)
+    }
+
+    subject { Promote::Promoter.new(config) }
+
+    it "copies the cookbook constraints" do
+      expect(fake_file).to receive(:<<).with(an_instance_of(String)) do |arg|
+        parsed = JSON.parse(arg)
+        expect(parsed['cookbook_versions'].length).to eq(3)
+        expect(parsed['cookbook_versions']['build-essential']).to eq('2.0.0')
+        expect(parsed['cookbook_versions']['newrelic']).to eq('2.0.0')
+        expect(parsed['cookbook_versions']['platform_haproxy']).to eq('2.0.0')
+      end
+      subject.promote_to("env1", "env2")
+    end
+  end
+end

data/spec/unit/promote/uploader_spec.rb

@@ -0,0 +1,208 @@
+require 'promote'
+require_relative '../support/dummy_metadata'
+
+describe Promote::Uploader do
+	let(:knife_config) {{ :cookbook_path => "path"}}
+	let(:temp_dir) { "/tmp/berks" }
+	let(:config) { Promote::Config.new({ 
+		:node_name => 'user', 
+		:cookbook_directory => '/cookbooks',
+		:client_key => 'key', 
+		:temp_directory => temp_dir,
+		:chef_server_url => 'https://some.chef.server'}) }
+
+	subject { Promote::Uploader.new(config) }
+
+	context "upload cookbooks" do
+		let(:env_name) { "QA1" }
+		let(:metadata) { PromoteSpecs::DummyMetadata.new({'version' => "1.1.1"}) }
+		let(:environment) do
+			<<-EOS
+				{
+				  "name": "#{env_name}",
+				  "chef_type": "environment",
+				  "json_class": "Chef::Environment",
+				  "cookbook_versions": {
+				    "int_cookbook1": "1.1.1",
+				    "int_cookbook3": "1.1.1",
+				    "cookbook3": "3.3.3"
+				  }
+				}
+			EOS
+		end
+		let(:berks_cookbooks) {[
+				"/berks/cookbook1-1.1.1",
+				"/berks/cookbook1-1.1.2",
+				"/berks/cookbook2-2.2.2",
+				"/berks/cookbook3-3.3.3",
+				"/berks/cookbook4-3.3.3",
+				]}
+		let(:internal_cookbooks) {[
+				"/cookbooks/int_cookbook1",
+				"/cookbooks/int_cookbook2",
+				"/cookbooks/int_cookbook3",
+				]}
+		let(:server_cookbooks){{
+			"cookbook1" => {"versions" => [{"version" => "1.1.1"}]},
+			"cookbook2" => {"versions" => [{"version" => "1.1.1"}]},
+			"int_cookbook1" => {"versions" => [{"version" => "1.1.1"}]},
+			"int_cookbook2" => {"versions" => [{"version" => "2.2.2"}]}
+			}}
+		let(:rest){double('rest')}
+		let(:knife) { instance_double('CookbookUpload', :run => nil) }
+		before {
+			allow(File).to receive(:read).with(File.join(config.environment_directory, "#{env_name}.json")).and_return(environment)
+			allow(File).to receive(:read).with(/metadata\.json$/).and_return('')
+			allow(Chef::REST).to receive(:new).and_return(rest)
+			allow(rest).to receive(:get_rest).and_return(server_cookbooks)
+			allow(Chef::Cookbook::Metadata).to receive(:new).and_return(metadata)
+			allow(Chef::Knife::CookbookUpload).to receive(:new).and_return(knife)
+			allow(Dir).to receive(:glob).with(File.expand_path("~/.berkshelf/cookbooks/*")).and_return(berks_cookbooks)
+			allow(Dir).to receive(:glob).with(File.join(config.cookbook_directory, "*")).and_return(internal_cookbooks)
+			allow(Dir).to receive(:mkdir)
+			allow(Dir).to receive(:exist?).and_return(false)
+			allow(knife).to receive(:config).and_return(knife_config)
+			allow(FileUtils).to receive(:copy_entry)
+			allow(File).to receive(:exist?).with(/metadata\.rb$/).and_return(true)
+		}
+
+		it "copies updated cookbooks to temp directory" do
+			expect(FileUtils).not_to receive(:copy_entry).with("/berks/cookbook1-1.1.1", File.join(config.temp_directory, "cookbook1"))
+			expect(FileUtils).not_to receive(:copy_entry).with("/berks/cookbook1-1.1.2", File.join(config.temp_directory, "cookbook1"))
+			expect(FileUtils).not_to receive(:copy_entry).with("/berks/cookbook4-3.3.3", File.join(config.temp_directory, "cookbook4"))
+			expect(FileUtils).not_to receive(:copy_entry).with("/berks/cookbook2-2.2.2", File.join(config.temp_directory, "cookbook2"))
+			expect(FileUtils).to receive(:copy_entry).with("/berks/cookbook3-3.3.3", File.join(config.temp_directory, "cookbook3"))
+			expect(FileUtils).not_to receive(:copy_entry).with("/cookbooks/int_cookbook2", File.join(config.temp_directory, "int_cookbook2"))
+			expect(FileUtils).not_to receive(:copy_entry).with("/cookbooks/int_cookbook1", File.join(config.temp_directory, "int_cookbook1"))
+			expect(FileUtils).to receive(:copy_entry).with("/cookbooks/int_cookbook3", File.join(config.temp_directory, "int_cookbook3"))
+			subject.upload_cookbooks(env_name)
+		end
+		it "uploads cookbooks to chef server" do
+			expect(knife).to receive(:run)
+
+			subject.upload_cookbooks(env_name)
+		end
+		it "Creates temp directory" do
+			expect(Dir).to receive(:mkdir).with(config.temp_directory)
+
+			subject.upload_cookbooks(env_name)
+		end
+		it "uploads cookbooks from config temp path" do
+			subject.upload_cookbooks(env_name)
+			expect(knife.config[:cookbook_path]).to eq(config.temp_directory)
+		end
+		it "uploads all cookbooks" do
+			subject.upload_cookbooks(env_name)
+			expect(knife.config[:all]).to eq(true)
+		end
+		it "freezes all cookbooks" do
+			subject.upload_cookbooks(env_name)
+			expect(knife.config[:freeze]).to eq(true)
+		end
+
+		context "no environment is given" do
+			it "copies updated cookbooks and does not filter by environment" do
+				expect(FileUtils).not_to receive(:copy_entry).with("/berks/cookbook1-1.1.1", File.join(config.temp_directory, "cookbook1"))
+				expect(FileUtils).to receive(:copy_entry).with("/berks/cookbook1-1.1.2", File.join(config.temp_directory, "cookbook1"))
+				expect(FileUtils).to receive(:copy_entry).with("/berks/cookbook4-3.3.3", File.join(config.temp_directory, "cookbook4"))
+				expect(FileUtils).to receive(:copy_entry).with("/berks/cookbook2-2.2.2", File.join(config.temp_directory, "cookbook2"))
+				expect(FileUtils).to receive(:copy_entry).with("/berks/cookbook3-3.3.3", File.join(config.temp_directory, "cookbook3"))
+				expect(FileUtils).to receive(:copy_entry).with("/cookbooks/int_cookbook2", File.join(config.temp_directory, "int_cookbook2"))
+				expect(FileUtils).not_to receive(:copy_entry).with("/cookbooks/int_cookbook1", File.join(config.temp_directory, "int_cookbook1"))
+				expect(FileUtils).to receive(:copy_entry).with("/cookbooks/int_cookbook3", File.join(config.temp_directory, "int_cookbook3"))
+				subject.upload_cookbooks
+			end
+		end
+
+		context "temp directory already exists" do
+			before {allow(Dir).to receive(:exist?).and_return(true)}
+
+			it "deletes temp directory" do		
+				expect(FileUtils).to receive(:rm_rf).with(config.temp_directory)
+				subject.upload_cookbooks(env_name)
+			end
+		end
+
+		context "no metadata.rb file exists for cookbook" do
+			before {allow(File).to receive(:exist?).with(/rb$/).and_return(false)}
+
+			it "loads json instead of ruby file" do		
+				expect(metadata).to receive(:from_json).at_least(1).times
+				expect(metadata).not_to receive(:from_file)
+				subject.upload_cookbooks(env_name)
+			end
+		end
+
+		context "nothing to upload" do
+			let(:berks_cookbooks) {[]}
+			let(:internal_cookbooks) {[]}
+
+			it "does not call knife" do		
+				expect(Chef::Knife::CookbookUpload).not_to receive(:new)
+
+				subject.upload_cookbooks(env_name)
+			end
+		end
+
+		context "config missing node_name" do
+			let(:config) { Promote::Config.new({ 
+				:client_key => 'key', 
+				:chef_server_url => 'https://some.chef.server'}) }
+
+			it "raises error that node_name is missing" do		
+				expect{subject.upload_cookbooks(env_name)}.to raise_error(/node_name/)
+			end
+		end
+
+		context "config missing client_key" do
+			let(:config) { Promote::Config.new({ 
+				:node_name => 'user', 
+				:chef_server_url => 'https://some.chef.server'}) }
+
+			it "raises error that client_key is missing" do		
+				expect{subject.upload_cookbooks(env_name)}.to raise_error(/client_key/)
+			end
+		end
+
+		context "config missing chef_server_url" do
+			let(:config) { Promote::Config.new({ 
+				:node_name => 'user', 
+				:client_key => 'key'}) }
+
+			it "raises error that chef_server_url is missing" do		
+				expect{subject.upload_cookbooks(env_name)}.to raise_error(/chef_server_url/)
+			end
+		end
+	end
+
+	context "upload json artifacts" do
+		context "upload an environment" do
+			let(:env_name) { "my_test" }
+			
+			it "uploads the environment" do
+				expect(Chef::ChefFS::FileSystem).to receive(:copy_to).with(an_instance_of(Chef::ChefFS::FilePattern), anything(), anything(), anything(), anything()) do |arg|
+					expect(arg.pattern).to eq(File.join("/environments", "#{env_name}.json"))
+				end
+				subject.upload_environment(env_name)
+			end
+		end
+
+		context "upload all environments" do
+			it "uploads the environment" do
+				expect(Chef::ChefFS::FileSystem).to receive(:copy_to).with(an_instance_of(Chef::ChefFS::FilePattern), anything(), anything(), anything(), anything()) do |arg|
+					expect(arg.pattern).to eq(File.join("/environments/*.json"))
+				end
+				subject.upload_environments
+			end
+		end
+
+		context "upload data_bags" do
+			it "uploads the data_bags" do
+				expect(Chef::ChefFS::FileSystem).to receive(:copy_to).with(an_instance_of(Chef::ChefFS::FilePattern), anything(), anything(), anything(), anything()) do |arg|
+					expect(arg.pattern).to eq("/data_bags/**/*.json")
+				end
+				subject.upload_data_bags
+			end
+		end
+	end
+end

data/spec/unit/promote/versioner_spec.rb

@@ -0,0 +1,291 @@
+require 'promote'
+require_relative '../support/dummy_log'
+
+describe Promote::Versioner do
+  before(:all) {
+    cb_dir = '/tmp/promote_test_cookbooks'
+    FileUtils.rm_rf(cb_dir) if Dir.exist?(cb_dir)
+    Dir.mkdir(cb_dir)
+    FileUtils.cp_r(File.join(File.dirname(File.dirname(__FILE__)), 'stubs'), cb_dir)
+  }
+
+  let(:cookbook_dir) {'/tmp/promote_test_cookbooks/stubs'}
+  let(:test_cookbook) {'cookbook_1'}
+  let(:config) {Promote::Config.new(:cookbook_directory => cookbook_dir)}
+	let(:fake_file) { double('file') }
+
+	let(:artifact_file) { "" }
+	let(:fake_berks) { double('berksfile', :install => nil) }
+	before {
+		allow(Berkshelf::Berksfile).to receive(:from_file).and_return(fake_berks)
+		allow_any_instance_of(Promote::GitRepo).to receive(:git).and_return(Git::Base.new)
+		allow_any_instance_of(Git::Base).to receive(:tags).and_return([
+			double("tag", :name => '1.0', :sha => 'abc'),
+			double("tag", :name => '1.1', :sha => 'def'),
+			double("tag", :name => '1.2', :sha => 'ghi')
+		])
+		allow_any_instance_of(Git::Base).to receive(:log).with(10000).and_return(
+			PromoteSpecs::DummyLog.new([
+				{:msg => 'blah', :sha => 'aaa'},
+				{:msg => 'CI:bumping', :sha => 'bbb'},
+				{:msg => 'blah', :sha => 'ccc'}
+			]))
+		config = Promote::Config.new
+	}
+
+  subject { Promote::Versioner.new(config) }
+
+	context 'version_cookbook' do
+		context 'when versioning a new cookbook version' do
+			it "writes the new version and sha to the file" do
+				subject.version_cookbook(test_cookbook)
+				expect(Promote::Cookbook.new(test_cookbook, config).version.to_s).to eq('1.2.2')
+			end
+
+			it "adds the new version and sha to the cookbook" do
+				subject.version_cookbook(test_cookbook)
+				expect(Promote::Cookbook.new(test_cookbook, config).raw_metadata).to end_with("#sha1 'aaa'")
+			end
+		end
+
+		context 'when versioning a cookbook with no changes' do
+			it "does not write to metadata rb" do
+				expect(subject.version_cookbook(test_cookbook)).to be nil
+			end
+		end
+	end
+
+	context 'version_cookbooks' do
+		let(:cookbooks) {[
+			File.join(subject.config.cookbook_directory, "cookbook1"), 
+			File.join(subject.config.cookbook_directory, "cookbook2"), 
+			File.join(subject.config.cookbook_directory, "cookbook3")
+		]}
+		before {
+			allow(subject).to receive(:version_cookbook)
+			allow(Dir).to receive(:glob).with(
+				File.join(subject.config.cookbook_directory, "*")).and_return(cookbooks)
+		}
+
+		it "versions each cookbook" do
+			cookbooks.each do |cookbook|
+				expect(subject).to receive(:version_cookbook).with(File.basename(cookbook))
+			end
+			subject.version_cookbooks
+		end
+	end
+
+	context 'version_environment' do
+		before {
+			regex = File.join(config.environment_directory,'test.json')
+			allow(File).to receive(:read).with(regex).and_return(artifact_file)
+			allow(File).to receive(:open).with(regex, "w").and_yield(fake_file)
+		}
+
+		context 'when versioning a new environment with no version' do
+			let(:artifact_file) do
+				<<-EOS
+					{
+					  "name": "QA1",
+					  "chef_type": "environment",
+					  "json_class": "Chef::Environment",
+					  "override_attributes": {
+					    "environment_parent": "QA"
+					  }
+					}
+				EOS
+			end
+
+			it "writes the new version and sha to the file" do
+				parsed = JSON.parse(artifact_file)
+				parsed['override_attributes']['version'] = '1.2.2'
+				parsed['override_attributes']['sha1'] = 'aaa'
+				expect(fake_file).to receive(:<<).with(JSON.pretty_generate(parsed))
+				subject.version_environment('test')
+			end
+		end
+
+		context 'when versioning a new environment with old version' do
+
+			let(:artifact_file) do
+				<<-EOS
+					{
+					  "name": "QA1",
+					  "chef_type": "environment",
+					  "json_class": "Chef::Environment",
+					  "override_attributes": {
+					    "environment_parent": "QA",
+	    				"version": "1.0.0",
+	    				"sha1": "ccc"
+					  }
+					}
+				EOS
+			end
+
+			it "writes the new version and sha to the file" do
+				parsed = JSON.parse(artifact_file)
+				parsed['override_attributes']['version'] = '1.2.2'
+				parsed['override_attributes']['sha1'] = 'aaa'
+				expect(fake_file).to receive(:<<).with(JSON.pretty_generate(parsed))
+				subject.version_environment('test')
+			end
+		end
+
+		context 'when commiting an environment with no changes' do
+			let(:artifact_file) do
+				<<-EOS
+					{
+					  "name": "QA1",
+					  "chef_type": "environment",
+					  "json_class": "Chef::Environment",
+					  "override_attributes": {
+					    "environment_parent": "QA",
+	    				"version": "1.2.2",
+	    				"sha1": "aaa"
+					  }
+					}
+				EOS
+			end
+
+			it "does not write to the file" do
+				expect(fake_file).not_to receive(:<<)
+				subject.version_environment('test')
+			end
+		end
+	end
+
+	context 'version_environments' do
+		let(:environments) {%w{dir/environment1.json dir/environment2.json dir/environment3.json}}
+		before {
+			allow(subject).to receive(:version_environment)
+			allow(Dir).to receive(:glob).with(
+				File.join(subject.config.environment_directory, "*.json")).and_return(environments)
+		}
+
+		it "versions each environment" do
+			environments.each do |environment|
+				expect(subject).to receive(:version_environment).with(
+					File.basename(environment ,File.extname(environment)))
+			end
+			subject.version_environments
+		end
+	end
+
+	context 'constrain_environment' do
+		before {
+			regex = File.join(config.environment_directory,'test.json')
+			allow(File).to receive(:read).with(regex).and_return(artifact_file)
+			allow(File).to receive(:open).with(regex, "w").and_yield(fake_file)
+		}
+
+		let(:artifact_file) do
+			<<-EOS
+				{
+				  "name": "QA1",
+				  "chef_type": "environment",
+				  "json_class": "Chef::Environment"
+				}
+			EOS
+		end
+		before {
+			allow(File).to receive(:exist?).with(/Berksfile$/).and_return(true)
+			allow(fake_berks).to receive(:list).and_return([
+				double('Dependency', :name => 'cookbook1', :locked_version => Semverse::Version.new('1.1.1')),
+				double('Dependency', :name => 'cookbook2', :locked_version => Semverse::Version.new('2.2.2')),
+				double('Dependency', :name => 'cookbook3', :locked_version => Semverse::Version.new('3.3.3'))
+				])
+		}
+		it "writes the cookbook constraints to the file" do
+			expect(fake_file).to receive(:<<).with(an_instance_of(String)) do |arg|
+				parsed = JSON.parse(arg)
+				expect(parsed['cookbook_versions']['cookbook1']).to eq('1.1.1')
+				expect(parsed['cookbook_versions']['cookbook2']).to eq('2.2.2')
+				expect(parsed['cookbook_versions']['cookbook3']).to eq('3.3.3')
+			end
+			subject.constrain_environment('test', 'test_cookbook')
+		end
+	end
+
+	context 'is_dirty' do
+		before {
+			regex = File.join(config.environment_directory,'test.json')
+			allow(File).to receive(:read).with(regex).and_return(artifact_file)
+			allow(File).to receive(:open).with(regex, "w").and_yield(fake_file)
+			allow(File).to receive(:read).with(/new.json/).and_return(
+					<<-EOS
+						{
+						  "name": "test",
+						  "chef_type": "environment",
+						  "json_class": "Chef::Environment",
+						  "cookbook_versions": {
+						    "cookbook1": "1.1.1",
+						    "cookbook2": "2.2.2",
+						    "cookbook3": "3.3.3"
+						  }
+						}
+					EOS
+				)
+		}
+
+		context "cookbook is dirty" do
+
+			let(:artifact_file) do
+				<<-EOS
+					{
+					  "name": "QA1",
+					  "chef_type": "environment",
+					  "json_class": "Chef::Environment",
+					  "cookbook_versions": {
+					    "cookbook1": "1.1.1",
+					    "cookbook2": "1.1.1",
+					    "cookbook3": "3.3.3"
+					  }
+					}
+				EOS
+			end
+
+			it "returns dirty" do
+				expect(subject.is_dirty('new', 'test', 'cookbook2')).to be(true)
+			end
+		end
+		context "cookbook is not dirty" do
+			let(:artifact_file) do
+				<<-EOS
+					{
+					  "name": "QA1",
+					  "chef_type": "environment",
+					  "json_class": "Chef::Environment",
+					  "cookbook_versions": {
+					    "cookbook1": "1.1.1",
+					    "cookbook2": "2.2.2",
+					    "cookbook3": "3.3.3"
+					  }
+					}
+				EOS
+			end
+
+			it "returns clean" do
+				expect(subject.is_dirty('new', 'test', 'cookbook2')).to be(false)
+			end
+		end
+		context "cookbook is new to environment" do
+			let(:artifact_file) do
+				<<-EOS
+					{
+					  "name": "QA1",
+					  "chef_type": "environment",
+					  "json_class": "Chef::Environment",
+					  "cookbook_versions": {
+					    "cookbook1": "1.1.1",
+					    "cookbook3": "3.3.3"
+					  }
+					}
+				EOS
+			end
+
+			it "returns dirty" do
+				expect(subject.is_dirty('new', 'test', 'cookbook2')).to be(true)
+			end
+		end
+	end
+end

data/spec/unit/stubs/cookbook_1/Berksfile

@@ -0,0 +1,3 @@
+source "https://api.berkshelf.com"
+
+metadata

data/spec/unit/stubs/cookbook_1/metadata.rb

@@ -0,0 +1,9 @@
+name             'cookbook_1'
+maintainer       'CenturyLink Cloud'
+maintainer_email 'your.mama@clc.io'
+license          'all_rights'
+description      'Transfers files via scp'
+long_description 'Transfers files via scp'
+version          '1.0.0'
+
+depends "cookbook_2", '1.1.1'

data/spec/unit/support/dummy_log.rb

@@ -0,0 +1,47 @@
+require 'git'
+
+module PromoteSpecs
+  
+  class DummyLog < Git::Log
+    include Enumerable
+    
+    def initialize(commits)
+      @commits = commits
+      @author = nil
+      @grep = nil
+      @object = nil
+      @path = nil
+      @since = nil
+      @skip = nil
+      @until = nil
+      @between = nil
+    end
+ 
+    def size
+      run_log.size rescue nil
+    end
+        
+    def first
+      run_log.first rescue nil
+    end
+
+    private 
+    
+      def run_log
+        filtered = @commits.select { |c| @grep.nil? ? true : c[:msg] == @grep }
+        filtered.map { |c| DummyCommit.new(c[:sha]) }
+      ensure
+        @grep = nil
+      end
+      
+  end
+
+  class DummyCommit
+    def initialize(sha)
+      @sha=sha
+    end
+
+    attr_accessor :sha
+  end
+  
+end

data/spec/unit/support/dummy_metadata.rb

@@ -0,0 +1,20 @@
+module PromoteSpecs
+  
+  class DummyMetadata < Chef::Cookbook::Metadata
+    def initialize(hash = nil)
+      @hash = hash
+    end
+
+    def from_file(file_path)
+      @name = File.basename(File.dirname(file_path))
+      idx = @name.rindex('-')
+      if !idx.nil?
+        @version = @name[idx+1,@name.length-idx]
+        @name = @name[0,idx]
+      else
+        from_hash(@hash) unless @hash.nil?
+      end
+    end
+  end
+  
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: clc-promote
 version: !ruby/object:Gem::Version
-  version: 0.4.3
+  version: 0.4.4
 platform: ruby
 authors:
 - CenturyLink Cloud
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-18 00:00:00.000000000 Z
+date: 2014-12-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: clc-git
@@ -97,8 +97,12 @@ extensions: []
 extra_rdoc_files:
 - README.md
 files:
+- ".gitignore"
 - README.md
+- Rakefile
+- clc-promote.gemspec
 - lib/chef/knife/promote.rb
+- lib/kitchen/provisioner/environment.rb
 - lib/promote.rb
 - lib/promote/config.rb
 - lib/promote/cookbook.rb
@@ -108,7 +112,18 @@ files:
 - lib/promote/rake_tasks.rb
 - lib/promote/uploader.rb
 - lib/promote/utils.rb
+- lib/promote/version.rb
 - lib/promote/versioner.rb
+- spec/unit/kitchen/provisioner/environment_spec.rb
+- spec/unit/promote/config_spec.rb
+- spec/unit/promote/cookbook_spec.rb
+- spec/unit/promote/promoter_spec.rb
+- spec/unit/promote/uploader_spec.rb
+- spec/unit/promote/versioner_spec.rb
+- spec/unit/stubs/cookbook_1/Berksfile
+- spec/unit/stubs/cookbook_1/metadata.rb
+- spec/unit/support/dummy_log.rb
+- spec/unit/support/dummy_metadata.rb
 homepage: https://github.com/tier3/DevOps/gems/clc-promote
 licenses: []
 metadata: {}
@@ -132,5 +147,15 @@ rubygems_version: 2.4.1
 signing_key: 
 specification_version: 4
 summary: Provides versioning and promotion logic for chef artifacts.
-test_files: []
+test_files:
+- spec/unit/kitchen/provisioner/environment_spec.rb
+- spec/unit/promote/config_spec.rb
+- spec/unit/promote/cookbook_spec.rb
+- spec/unit/promote/promoter_spec.rb
+- spec/unit/promote/uploader_spec.rb
+- spec/unit/promote/versioner_spec.rb
+- spec/unit/stubs/cookbook_1/Berksfile
+- spec/unit/stubs/cookbook_1/metadata.rb
+- spec/unit/support/dummy_log.rb
+- spec/unit/support/dummy_metadata.rb
 has_rdoc: