clc-promote 0.4.5 → 0.7.8

data/spec/unit/promote/promoter_spec.rb

@@ -1,12 +1,15 @@
 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(:config) { Promote::Config.new({ 
+    :node_name => 'user', 
+    :cookbook_directory => '/cookbooks',
+    :client_key => 'key', 
+    :chef_server_url => 'https://some.chef.server'}) }
+
+  subject { Promote::Promoter.new(config) }
+
+  context "promote_to" do
     let(:fake_file){double('file')}
     let(:env1) do
       <<-EOS
@@ -43,8 +46,6 @@ describe Promote::Promoter do
       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)
@@ -56,4 +57,46 @@ describe Promote::Promoter do
       subject.promote_to("env1", "env2")
     end
   end
+
+  context "monitor_promotion" do
+    let(:finder_good){ double('node_finder', :search => [good_node]) }
+    let(:finder_bad){ double('node_finder', :search => [bad_node]) }
+    let (:good_node) {
+      node = Chef::Node.new
+      node.default["ohai_time"] = Time.now.to_i + 3600
+      node
+    }
+    let (:bad_node) {
+      node = Chef::Node.new
+      node.default["ohai_time"] = Time.now.to_i - 3600
+      node
+    }
+
+    before {
+      allow(Promote::NodeFinder).to receive(:new).and_return(finder_good)
+    }
+
+    context "all environments succeed" do
+      it "promotes all nodes" do
+        expect(subject).to receive(:promote_to).with("env1", "env2", nil)
+        expect(subject).to receive(:promote_to).with("env1", "env3", nil)
+        expect(subject).to receive(:promote_to).with("env1", "env4", nil)
+        subject.monitor_promotion("env1", ["env2", "env3", "env4"], 1)
+      end
+    end
+
+    context "stops promotion when promotion fails" do
+      before {
+        allow(Promote::NodeFinder).to receive(:new).with("chef_environment:env3", config).and_return(finder_bad)
+      }
+
+      it "stops on failure" do
+
+        expect(subject).to receive(:promote_to).with("env1", "env2", nil)
+        expect(subject).not_to receive(:promote_to).with("env1", "env3", nil)
+        expect(subject).not_to receive(:promote_to).with("env1", "env4", nil)
+        subject.monitor_promotion("env1", ["env2", "env3", "env4"], 1)
+      end
+    end
+  end
 end

data/spec/unit/promote/uploader_spec.rb

@@ -4,15 +4,19 @@ 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', 
+	let(:config) { Promote::Config.new({
+		:node_name => 'user',
 		:cookbook_directory => '/cookbooks',
-		:client_key => 'key', 
+		:client_key => 'key',
 		:temp_directory => temp_dir,
 		:chef_server_url => 'https://some.chef.server'}) }
 
 	subject { Promote::Uploader.new(config) }
 
+	before {
+		allow(Chef::ChefFS::FileSystem).to receive(:copy_to)
+	}
+
 	context "upload cookbooks" do
 		let(:env_name) { "QA1" }
 		let(:metadata) { PromoteSpecs::DummyMetadata.new({'version' => "1.1.1"}) }
@@ -50,6 +54,7 @@ describe Promote::Uploader do
 			}}
 		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('')
@@ -59,6 +64,7 @@ describe Promote::Uploader do
 			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(:glob).with(File.join(config.temp_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)
@@ -117,7 +123,7 @@ describe Promote::Uploader do
 		context "temp directory already exists" do
 			before {allow(Dir).to receive(:exist?).and_return(true)}
 
-			it "deletes temp directory" do		
+			it "deletes temp directory" do
 				expect(FileUtils).to receive(:rm_rf).with(config.temp_directory)
 				subject.upload_cookbooks(env_name)
 			end
@@ -126,7 +132,7 @@ describe Promote::Uploader do
 		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		
+			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)
@@ -137,7 +143,7 @@ describe Promote::Uploader do
 			let(:berks_cookbooks) {[]}
 			let(:internal_cookbooks) {[]}
 
-			it "does not call knife" do		
+			it "does not call knife" do
 				expect(Chef::Knife::CookbookUpload).not_to receive(:new)
 
 				subject.upload_cookbooks(env_name)
@@ -145,31 +151,31 @@ describe Promote::Uploader do
 		end
 
 		context "config missing node_name" do
-			let(:config) { Promote::Config.new({ 
-				:client_key => 'key', 
+			let(:config) { Promote::Config.new({
+				:client_key => 'key',
 				:chef_server_url => 'https://some.chef.server'}) }
 
-			it "raises error that node_name is missing" do		
+			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', 
+			let(:config) { Promote::Config.new({
+				:node_name => 'user',
 				:chef_server_url => 'https://some.chef.server'}) }
 
-			it "raises error that client_key is missing" do		
+			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', 
+			let(:config) { Promote::Config.new({
+				:node_name => 'user',
 				:client_key => 'key'}) }
 
-			it "raises error that chef_server_url is missing" do		
+			it "raises error that chef_server_url is missing" do
 				expect{subject.upload_cookbooks(env_name)}.to raise_error(/chef_server_url/)
 			end
 		end
@@ -178,7 +184,7 @@ describe Promote::Uploader do
 	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"))
@@ -189,18 +195,87 @@ describe Promote::Uploader do
 
 		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"))
+				local_environments = Chef::ChefFS::Config.new.local_fs.child_paths["environments"]
+
+				expect(Chef::ChefFS::FileSystem).to receive(:copy_to).with(
+					an_instance_of(Chef::ChefFS::FilePattern),
+					an_instance_of(Chef::ChefFS::FileSystem::ChefRepositoryFileSystemRootDir),
+					anything(),
+					anything(),
+					anything()
+				) do |file_pattern, source|
+					expect(file_pattern.pattern).to eq(File.join("/environments/*.json"))
+					expect(source.child_paths["environments"]).to eq(local_environments)
 				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")
+		context "upload all roles" do
+			it "uploads the role" do
+				local_roles = Chef::ChefFS::Config.new.local_fs.child_paths["roles"]
+
+				expect(Chef::ChefFS::FileSystem).to receive(:copy_to).with(
+				an_instance_of(Chef::ChefFS::FilePattern),
+				an_instance_of(Chef::ChefFS::FileSystem::ChefRepositoryFileSystemRootDir),
+				anything(),
+				anything(),
+				anything()
+				) do |file_pattern, source|
+					expect(file_pattern.pattern).to eq(File.join("/roles/*.json"))
+					expect(source.child_paths["roles"]).to eq(local_roles)
+				end
+				subject.upload_roles
+			end
+		end
+
+		context "upload_data_bags" do
+			let(:temp_data_bags) { File.join(config.temp_directory, "data_bags") }
+			let(:fake_bag_file) { File.join("bags", "bag.json") }
+			let(:secret_key_file) { File.join("bags", "bag_secrets_keys.json") }
+			let(:config) { Promote::Config.new({
+				:temp_directory => "/tmp/promote_tests",
+				:repo_root => "/tmp/promote_repo",
+				:node_name => 'user',
+				:client_key => 'key',
+				:chef_server_url => 'https://some.chef.server'}) }
+
+			before {
+				fake_bag_path = File.join(config.data_bag_directory, fake_bag_file)
+				FileUtils.mkdir_p(File.dirname(fake_bag_path))
+				FileUtils.touch(fake_bag_path)
+				FileUtils.touch(File.join(config.data_bag_directory, secret_key_file))
+			}
+
+			after {
+				FileUtils.rm_rf(config.temp_directory)
+				FileUtils.rm_rf(config.repo_root)
+			}
+
+			it "copies the data_bags to a temp folder" do
+				subject.upload_data_bags
+
+				expect(File).to exist(File.join(temp_data_bags, fake_bag_file))
+			end
+
+			it "does not copy key files" do
+				subject.upload_data_bags
+
+				expect(File).not_to exist(File.join(temp_data_bags, secret_key_file))
+			end
+
+			it "uploads the data_bags to chef" do
+				expect(Chef::ChefFS::FileSystem).to receive(:copy_to).with(
+					an_instance_of(Chef::ChefFS::FilePattern),
+					an_instance_of(Chef::ChefFS::FileSystem::ChefRepositoryFileSystemRootDir),
+					anything(),
+					anything(),
+					anything()
+				) do |file_pattern, source|
+					expect(file_pattern.pattern).to eq("/data_bags/**/*.json")
+					expect(source.child_paths["data_bags"]).to eq([temp_data_bags])
 				end
+
 				subject.upload_data_bags
 			end
 		end

data/spec/unit/promote/versioner_spec.rb

@@ -57,8 +57,8 @@ describe Promote::Versioner do
 
 	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, "cookbook1"),
+			File.join(subject.config.cookbook_directory, "cookbook2"),
 			File.join(subject.config.cookbook_directory, "cookbook3")
 		]}
 		before {
@@ -171,6 +171,120 @@ describe Promote::Versioner do
 		end
 	end
 
+  context 'version_role' do
+    before {
+      regex = File.join(config.role_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 role with no version' do
+      let(:artifact_file) do
+        <<-EOS
+        {
+          "name": "QA1",
+          "chef_type": "role",
+          "json_class": "Chef::Role",
+          "override_attributes": {
+            "foo": "bar"
+          }
+        }
+        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_role('test')
+      end
+    end
+
+    context 'when versioning a role with no override_attributes' do
+      let(:artifact_file) do
+        <<-EOS
+        {
+          "name": "QA1",
+          "chef_type": "role",
+          "json_class": "Chef::Role"
+        }
+        EOS
+      end
+      it "adds an override_attributes key to the role" do
+        parsed = JSON.parse(artifact_file)
+        override_hash = { "override_attributes" => {} }
+        parsed.merge!(override_hash)
+        expect(fake_file).to receive(:<<).with(JSON.pretty_generate(parsed))
+        subject.version_role('test')
+      end
+    end
+
+    context 'when versioning a new role with old version' do
+
+      let(:artifact_file) do
+        <<-EOS
+        {
+          "name": "QA1",
+          "chef_type": "role",
+          "json_class": "Chef::Role",
+          "override_attributes": {
+            "foo": "bar",
+            "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_role('test')
+      end
+    end
+
+    context 'when committing a role with no changes' do
+      let(:artifact_file) do
+        <<-EOS
+        {
+          "name": "QA1",
+          "chef_type": "role",
+          "json_class": "Chef::Role",
+          "override_attributes": {
+            "foo": "bar",
+            "version": "1.2.2",
+            "sha1": "aaa"
+          }
+        }
+        EOS
+      end
+
+      it "does not write to the file" do
+        expect(fake_file).not_to receive(:<<)
+        subject.version_role('test')
+      end
+    end
+  end
+
+  context 'version_roles' do
+    let(:roles) {%w{dir/role1.json dir/role2.json dir/role3.json}}
+    before {
+      allow(subject).to receive(:version_role)
+      allow(Dir).to receive(:glob).with(
+      File.join(subject.config.role_directory, "*.json")).and_return(roles)
+    }
+
+    it "versions each role" do
+      roles.each do |role|
+        expect(subject).to receive(:version_role).with(
+        File.basename(role ,File.extname(role)))
+      end
+      subject.version_roles
+    end
+  end
+
 	context 'constrain_environment' do
 		before {
 			regex = File.join(config.environment_directory,'test.json')
@@ -232,59 +346,80 @@ describe Promote::Versioner do
 			let(:artifact_file) do
 				<<-EOS
 					{
-					  "name": "QA1",
+					  "name": "LKG",
+					  "chef_type": "environment",
+					  "json_class": "Chef::Environment",
+					  "cookbook_versions": {
+					    "cookbook1": "1.1.1.hash",
+					    "cookbook2": "1.1.1.hash",
+					    "cookbook3": "3.3.3.hash"
+					  }
+					}
+				EOS
+			end
+
+			it "returns dirty" do
+				expect(subject.is_dirty('new', 'test', 'cookbook2', 'hash')).to be(true)
+			end
+		end
+		context "cookbook has same version but different hash" do
+
+			let(:artifact_file) do
+				<<-EOS
+					{
+					  "name": "LKG",
 					  "chef_type": "environment",
 					  "json_class": "Chef::Environment",
 					  "cookbook_versions": {
-					    "cookbook1": "1.1.1",
-					    "cookbook2": "1.1.1",
-					    "cookbook3": "3.3.3"
+					    "cookbook1": "1.1.1.hash",
+					    "cookbook2": "2.2.2.diff_hash",
+					    "cookbook3": "3.3.3.hash"
 					  }
 					}
 				EOS
 			end
 
 			it "returns dirty" do
-				expect(subject.is_dirty('new', 'test', 'cookbook2')).to be(true)
+				expect(subject.is_dirty('new', 'test', 'cookbook2', 'hash')).to be(true)
 			end
 		end
 		context "cookbook is not dirty" do
 			let(:artifact_file) do
 				<<-EOS
 					{
-					  "name": "QA1",
+					  "name": "LKG",
 					  "chef_type": "environment",
 					  "json_class": "Chef::Environment",
 					  "cookbook_versions": {
-					    "cookbook1": "1.1.1",
-					    "cookbook2": "2.2.2",
-					    "cookbook3": "3.3.3"
+					    "cookbook1": "1.1.1.hash",
+					    "cookbook2": "2.2.2.hash",
+					    "cookbook3": "3.3.3.hash"
 					  }
 					}
 				EOS
 			end
 
 			it "returns clean" do
-				expect(subject.is_dirty('new', 'test', 'cookbook2')).to be(false)
+				expect(subject.is_dirty('new', 'test', 'cookbook2', 'hash')).to be(false)
 			end
 		end
 		context "cookbook is new to environment" do
 			let(:artifact_file) do
 				<<-EOS
 					{
-					  "name": "QA1",
+					  "name": "LKG",
 					  "chef_type": "environment",
 					  "json_class": "Chef::Environment",
 					  "cookbook_versions": {
-					    "cookbook1": "1.1.1",
-					    "cookbook3": "3.3.3"
+					    "cookbook1": "1.1.1.hash",
+					    "cookbook3": "3.3.3.hash"
 					  }
 					}
 				EOS
 			end
 
 			it "returns dirty" do
-				expect(subject.is_dirty('new', 'test', 'cookbook2')).to be(true)
+				expect(subject.is_dirty('new', 'test', 'cookbook2', 'hash')).to be(true)
 			end
 		end
 	end