clc-promote 0.9.8 → 0.10.0

data/spec/unit/promote/environment_file_spec.rb

@@ -0,0 +1,28 @@
+require 'promote'
+
+describe Promote::EnvironmentFile do
+  let(:here) { File.expand_path('../../', __FILE__) }
+  let(:env_dir) { File.join(here, 'stubs', 'environments') }
+  let(:config) { Promote::Config.new(environment_directory: env_dir) }
+
+  subject { Promote::EnvironmentFile.new(environment, config) }
+
+  describe 'overrides' do
+    context 'there are overrides' do
+      let(:environment) { 'env1' }
+
+      it 'should return the override value' do
+        expect(subject.overrides['provisioner']['vault_bag']).to eq 'secrets_qa'
+      end
+    end
+
+    context 'there are no overrides' do
+      let(:environment) { 'env2' }
+
+      it 'should return an empty hash' do
+        expect(subject.overrides).to be_a(Hash)
+        expect(subject.overrides.keys.count).to be 0
+      end
+    end
+  end
+end

data/spec/unit/promote/node_shell/ssh_shell_spec.rb

@@ -0,0 +1,39 @@
+require 'promote'
+
+describe Promote::NodeShell::SshShell do
+  let(:ip) { '1.1.1.1' }
+  let(:node) { double('node', ipaddress: ip) }
+  let(:connection) { double('connection', open_channel: nil, loop: nil) }
+  let(:password) { 'pass' }
+  let(:vault) { double('vault', root_password: password) }
+
+  before do
+    allow(Promote::PasswordVault).to receive(:root_password)
+      .and_return(password)
+  end
+
+  subject { Promote::NodeShell::SshShell.new(node, vault) }
+
+  describe 'converge?' do
+    it 'converges the correct endpoint' do
+      expect(Net::SSH).to receive(:start).with(ip, anything, anything)
+        .and_return(connection)
+      subject.converge?
+    end
+
+    it 'converges as root' do
+      expect(Net::SSH).to receive(:start).with(anything, 'root', anything)
+        .and_return(connection)
+      subject.converge?
+    end
+
+    it 'converges with the correct password' do
+      expect(Net::SSH).to receive(:start).with(
+        anything,
+        anything,
+        password: password
+      ).and_return(connection)
+      subject.converge?
+    end
+  end
+end

data/spec/unit/promote/node_shell/winrm_shell_spec.rb

@@ -0,0 +1,30 @@
+require 'promote'
+
+describe Promote::NodeShell::WinrmShell do
+  let(:ip) { '1.1.1.1' }
+  let(:endpoint) { "http://#{ip}:5985/wsman" }
+  let(:node) { double('node', ipaddress: ip) }
+  let(:connection) { double('connection', run_cmd: { exitcode: 0 }, loop: nil) }
+  let(:password) { 'pass' }
+  let(:vault) { double('vault', admin_password: password) }
+
+  before do
+    allow(Promote::PasswordVault).to receive(:root_password)
+      .and_return(password)
+  end
+
+  subject { Promote::NodeShell::WinrmShell.new(node, vault) }
+
+  describe 'converge?' do
+    it 'converges with the correct authentication properties' do
+      expect(WinRM::WinRMWebService).to receive(:new).with(
+        endpoint,
+        :plaintext,
+        user: 'administrator',
+        pass: password,
+        basic_auth_only: true
+      ).and_return(connection)
+      subject.converge?
+    end
+  end
+end

data/spec/unit/promote/node_shell_spec.rb

@@ -0,0 +1,40 @@
+require 'promote'
+
+describe Promote::NodeShell do
+  let(:config) do
+    Promote::Config.new(
+      node_name: 'user',
+      cookbook_directory: '/cookbooks',
+      client_key: 'key',
+      chef_server_url: 'https://some.chef.server'
+    )
+  end
+
+  subject { Promote::NodeShell }
+
+  describe 'for_node' do
+    let(:node) { double('node', platform_family: 'family') }
+
+    it 'adds the correct vault to the shell' do
+      expect(subject.for_node(node, config).vault.node).to be node
+    end
+
+    context 'linux node' do
+      let(:node) { double('node', platform_family: 'ubuntu') }
+
+      it 'returns a SshShell' do
+        expect(subject.for_node(node, config)).to(
+          be_instance_of Promote::NodeShell::SshShell)
+      end
+    end
+
+    context 'windows node' do
+      let(:node) { double('node', platform_family: 'windows') }
+
+      it 'returns a SshShell' do
+        expect(subject.for_node(node, config)).to(
+          be_instance_of Promote::NodeShell::WinrmShell)
+      end
+    end
+  end
+end

data/spec/unit/promote/password_vault_spec.rb

@@ -0,0 +1,39 @@
+require 'promote'
+
+describe Promote::PasswordVault do
+  let(:node) do
+    node = Chef::Node.new
+    node.name 'node'
+    node.override['provisioner']['vault_bag'] = bag
+    node.override['clc_library']['win_fqdn'] = domain_item
+    node
+  end
+  let(:bag) { 'secrets_qa' }
+  let(:domain_item) { 't3n' }
+  let(:config) { Promote::Config.new }
+  let(:vault) do
+    {
+      'local_admin_password' => 'Pass@word1',
+      'local_root_password' => 'Password1'
+    }
+  end
+
+  before do
+    allow(ChefVault::Item).to receive(:load)
+      .with(bag, "#{domain_item}_domain").and_return(vault)
+  end
+  
+  subject { Promote::PasswordVault.new(node, config) }
+
+  describe 'root_password' do
+    it 'should return the correct password' do
+      expect(subject.root_password).to eq 'Password1'
+    end
+  end
+
+  describe 'admin_password' do
+    it 'should return the correct password' do
+      expect(subject.admin_password).to eq 'Pass@word1'
+    end
+  end
+end

data/spec/unit/promote/promoter_spec.rb

@@ -72,21 +72,27 @@ describe Promote::Promoter do
     let(:good_node) do
       node = Chef::Node.new
       node.name 'good_node'
-      node.default['ohai_time'] = Time.now.to_i + 3600
+      node.default['ohai_time'] = Time.now.to_i - 1
       node
     end
     let(:bad_node) do
       node = Chef::Node.new
       node.name 'bad_node'
-      node.default['ohai_time'] = Time.now.to_i - 3600
+      node.default['ohai_time'] = Time.now.to_i - 1
       node
     end
+    let(:good_shell) { double('shell', converge?: true) }
+    let(:bad_shell) { double('shell', converge?: false) }
     let(:uploader) { double('uploader') }
     let(:ui) { nil }
 
     before do
       allow(Promote::NodeFinder).to receive(:new).and_return(finder_good)
       allow(Promote::Uploader).to receive(:new).and_return(uploader)
+      allow(Promote::NodeShell).to receive(:for_node).with(good_node, config)
+        .and_return(good_shell)
+      allow(Promote::NodeShell).to receive(:for_node).with(bad_node, config)
+        .and_return(bad_shell)
     end
 
     context 'all environments succeed' do
@@ -98,9 +104,68 @@ describe Promote::Promoter do
         subject.monitor_promotion(
           'env1',
           %w(env2 env3 env4),
+          3,
+          0.25,
+          false,
+          ui
+        )
+      end
+    end
+
+    context 'converge windows first' do
+      let(:finder_ubu) { double('ubu_finder', search: [bad_node]) }
+      let(:finder_win) { double('win_finder', search: [good_node]) }
+
+      before do
+        allow(Promote::NodeFinder).to(
+          receive(:new).with(
+            'chef_environment:env1 AND platform:ubuntu',
+            config
+          ).and_return(finder_ubu)
+        )
+        allow(Promote::NodeFinder).to(
+          receive(:new).with(
+            'chef_environment:env1 AND platform:windows',
+            config
+          ).and_return(finder_win)
+        )
+      end
+
+      it 'promotes windows before ubuntu fails' do
+        expect(good_shell).to receive(:converge?)
+        expect do
+          subject.monitor_promotion(
+            'env1',
+            %w(env2 env3 env4),
+            0.25,
+            3,
+            false,
+            ui
+          )
+        end.to raise_error(/env1/)
+      end
+    end
+
+    context 'dont converge if already converged' do
+      let(:good_node) do
+        node = Chef::Node.new
+        node.name 'converged'
+        node.default['ohai_time'] = Time.now.to_i + 3600
+        node
+      end
+
+      it 'does not converge' do
+        %w(env2 env3 env4).each do |env|
+          expect(subject).to receive(:promote_to).with('env1', env, ui)
+          expect(uploader).to receive(:upload_environment).with(env, ui)
+        end
+        expect(good_shell).not_to receive(:converge?)
+        subject.monitor_promotion(
+          'env1',
+          %w(env2 env3 env4),
+          3,
           0.25,
           false,
-          1,
           ui
         )
       end
@@ -110,77 +175,119 @@ describe Promote::Promoter do
       let(:self_node) do
         node = Chef::Node.new
         node.name config.node_name
-        node.default['ohai_time'] = Time.now.to_i - 3600
+        node.default['ohai_time'] = Time.now.to_i - 1
         node
       end
-      let(:finder_good) { double('node_finder', search: [self_node, good_node]) }
-      
+      let(:finder_good) { double('finder', search: [self_node, good_node]) }
+      let(:self_shell) { double('shell') }
+
+      before do
+        allow(Promote::NodeShell).to receive(:for_node).with(self_node, config)
+          .and_return(self_shell)
+      end
+
       it 'promotes all nodes' do
         %w(env2 env3 env4).each do |env|
           expect(subject).to receive(:promote_to).with('env1', env, ui)
           expect(uploader).to receive(:upload_environment).with(env, ui)
         end
+        expect(self_shell).not_to receive(:converge?)
+        expect(good_shell).to receive(:converge?)
         subject.monitor_promotion(
           'env1',
           %w(env2 env3 env4),
+          3,
           0.25,
           false,
-          1,
           ui
         )
       end
     end
 
-    context 'source environment does not fully converge' do
-      before do
-        allow(Promote::NodeFinder).to(
-          receive(:new).with('chef_environment:env1', config)
-            .and_return(finder_bad)
-        )
+    context 'ignore provisioner' do
+      let(:prov) do
+        node = Chef::Node.new
+        node.name 'BA1PROVISIONER01'
+        node.default['ohai_time'] = Time.now.to_i - 1
+        node
       end
+      let(:finder_good) { double('finder', search: [prov, good_node]) }
+      let(:prov_shell) { double('shell') }
 
-      it 'promotes no nodes' do
-        expect(subject).not_to receive(:promote_to)
-        expect(uploader).not_to receive(:upload_environment)
+      before do
+        allow(Promote::NodeShell).to receive(:for_node).with(prov, config)
+          .and_return(prov_shell)
+      end
 
-        expect do
-          subject.monitor_promotion(
-            'env1',
-            %w(env2 env3 env4),
-            0.25,
-            false,
-            1,
-            ui
-          )
-        end.to raise_error(/env1$/)
+      it 'promotes all nodes' do
+        %w(env2 env3 env4).each do |env|
+          expect(subject).to receive(:promote_to).with('env1', env, ui)
+          expect(uploader).to receive(:upload_environment).with(env, ui)
+        end
+        expect(prov_shell).not_to receive(:converge?)
+        expect(good_shell).to receive(:converge?)
+        subject.monitor_promotion(
+          'env1',
+          %w(env2 env3 env4),
+          3,
+          0.25,
+          false,
+          ui
+        )
       end
     end
 
-    context 'stops promotion when promotion fails' do
+    context 'converge fails' do
       before do
         allow(Promote::NodeFinder).to(
-          receive(:new).with('chef_environment:env3', config)
-            .and_return(finder_bad)
+          receive(:new).with(
+            "chef_environment:#{env} AND platform:ubuntu",
+            config
+          ).and_return(finder_bad)
         )
       end
 
-      it 'stops on failure' do
-        %w(env2 env3).each do |env|
-          expect(subject).to receive(:promote_to).with('env1', env, ui)
-          expect(uploader).to receive(:upload_environment).with(env, ui)
+      context 'source environment does not fully converge' do
+        let(:env) { 'env1' }
+
+        it 'promotes no nodes' do
+          expect(subject).not_to receive(:promote_to)
+          expect(uploader).not_to receive(:upload_environment)
+
+          expect do
+            subject.monitor_promotion(
+              'env1',
+              %w(env2 env3 env4),
+              3,
+              0.25,
+              false,
+              ui
+            )
+          end.to raise_error(/env1/)
+        end
+      end
+
+      context 'stops promotion when promotion fails' do
+        let(:env) { 'env3' }
+
+        it 'stops on failure' do
+          %w(env2 env3).each do |env|
+            expect(subject).to receive(:promote_to).with('env1', env, ui)
+            expect(uploader).to receive(:upload_environment).with(env, ui)
+          end
+          expect(subject).not_to receive(:promote_to).with('env1', 'env4', ui)
+          expect(uploader).not_to receive(:upload_environment).with('env4')
+          expect do
+            subject.monitor_promotion(
+              'env1',
+              %w(env2 env3 env4),
+              3,
+              0.25,
+              false,
+              ui
+            )
+          end.to raise_error(/env3/)
         end
-        expect(subject).not_to receive(:promote_to).with('env1', 'env4', ui)
-        expect(uploader).not_to receive(:upload_environment).with('env4')
-        expect do
-          subject.monitor_promotion(
-            'env1',
-            %w(env2 env3 env4),
-            0.25,
-            false,
-            1,
-            ui
-          )
-        end.to raise_error(/env3$/)
       end
     end
   end

data/spec/unit/promote/uploader_spec.rb

@@ -187,8 +187,18 @@ describe Promote::Uploader 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(), anything(), anything()) do |arg|
-          expect(arg.pattern).to eq(File.join('/environments', "#{env_name}.json"))
+        expect(Chef::ChefFS::FileSystem).to receive(:copy_to).with(
+          an_instance_of(Chef::ChefFS::FilePattern),
+          anything,
+          anything,
+          anything,
+          anything,
+          anything,
+          anything
+        ) do |arg|
+          expect(arg.pattern).to eq(
+            File.join('/environments', "#{env_name}.json")
+          )
         end
         subject.upload_environment(env_name)
       end
@@ -196,19 +206,20 @@ describe Promote::Uploader do
 
     context 'upload all environments' do
       it 'uploads the environment' do
-        local_environments = Chef::ChefFS::Config.new.local_fs.child_paths['environments']
+        local = 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(),
-          anything(),
-          anything()          
+          an_instance_of(
+            Chef::ChefFS::FileSystem::ChefRepositoryFileSystemRootDir),
+          anything,
+          anything,
+          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)
+          expect(source.child_paths['environments']).to eq(local)
         end
         subject.upload_environments
       end
@@ -219,13 +230,14 @@ describe Promote::Uploader 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(),
-        anything(),
-        anything()
+          an_instance_of(Chef::ChefFS::FilePattern),
+          an_instance_of(
+            Chef::ChefFS::FileSystem::ChefRepositoryFileSystemRootDir),
+          anything,
+          anything,
+          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)
@@ -238,24 +250,27 @@ describe Promote::Uploader 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'}) }
+      let(:config) do
+        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'
+        )
+      end
 
-      before {
+      before do
         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))
-      }
+      end
 
-      after {
+      after do
         FileUtils.rm_rf(config.temp_directory)
         FileUtils.rm_rf(config.repo_root)
-      }
+      end
 
       it 'copies the data_bags to a temp folder' do
         subject.upload_data_bags
@@ -272,12 +287,13 @@ describe Promote::Uploader do
       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(),
-          anything(),
-          anything()
+          an_instance_of(
+            Chef::ChefFS::FileSystem::ChefRepositoryFileSystemRootDir),
+          anything,
+          anything,
+          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])