chef-apply 0.1.17 → 0.1.18

data/spec/unit/target_host_spec.rb

@@ -0,0 +1,231 @@
+#
+# Copyright:: Copyright (c) 2018 Chef Software Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require "spec_helper"
+require "ostruct"
+require "chef_apply/target_host"
+
+RSpec.describe ChefApply::TargetHost do
+  let(:host) { "mock://user@example.com" }
+  let(:sudo) { true }
+  let(:logger) { nil }
+  let(:family) { "windows" }
+  let(:is_linux) { false }
+  let(:platform_mock) { double("platform", linux?: is_linux, family: family, name: "an os") }
+  subject do
+    s = ChefApply::TargetHost.new(host, sudo: sudo, logger: logger)
+    allow(s).to receive(:platform).and_return(platform_mock)
+    s
+  end
+
+  context "#base_os" do
+    context "for a windows os" do
+      it "reports :windows" do
+        expect(subject.base_os).to eq :windows
+      end
+    end
+
+    context "for a linux os" do
+      let(:family) { "debian" }
+      let(:is_linux) { true }
+      it "reports :linux" do
+        expect(subject.base_os).to eq :linux
+      end
+    end
+
+    context "for an unsupported OS" do
+      let(:family) { "other" }
+      let(:is_linux) { false }
+      it "raises UnsupportedTargetOS" do
+        expect { subject.base_os }.to raise_error(ChefApply::TargetHost::UnsupportedTargetOS)
+      end
+    end
+  end
+
+  context "#installed_chef_version" do
+    let(:manifest) { :not_found }
+    before do
+      allow(subject).to receive(:get_chef_version_manifest).and_return manifest
+    end
+
+    context "when no version manifest is present" do
+      it "raises ChefNotInstalled" do
+        expect { subject.installed_chef_version }.to raise_error(ChefApply::TargetHost::ChefNotInstalled)
+      end
+    end
+
+    context "when version manifest is present" do
+      let(:manifest) { { "build_version" => "14.0.1" } }
+      it "reports version based on the build_version field" do
+        expect(subject.installed_chef_version).to eq Gem::Version.new("14.0.1")
+      end
+    end
+  end
+
+  context "connect!" do
+    let(:train_connection_mock) { double("train connection") }
+    before do
+      allow(subject).to receive(:train_connection).and_return(train_connection_mock)
+    end
+    context "when an Train::UserError occurs" do
+      it "raises a ConnectionFailure" do
+        allow(train_connection_mock).to receive(:connection).and_raise Train::UserError
+        expect { subject.connect! }.to raise_error(ChefApply::TargetHost::ConnectionFailure)
+      end
+    end
+    context "when a Train::Error occurs" do
+      it "raises a ConnectionFailure" do
+        allow(train_connection_mock).to receive(:connection).and_raise Train::Error
+        expect { subject.connect! }.to raise_error(ChefApply::TargetHost::ConnectionFailure)
+      end
+    end
+  end
+
+  context "#user" do
+    before do
+      allow(subject).to receive(:config).and_return(user: user)
+    end
+    context "when a user has been configured" do
+      let(:user) { "testuser" }
+      it "returns that user" do
+        expect(subject.user).to eq user
+      end
+    end
+    context "when no user has been configured" do
+      let(:user) { nil }
+      it "returns the correct default from train" do
+        expect(subject.user).to eq Train::Transports::SSH.default_options[:user][:default]
+      end
+    end
+  end
+
+  context "#run_command!" do
+    let(:backend) { double("backend") }
+    let(:exit_status) { 0 }
+    let(:result) { RemoteExecResult.new(exit_status, "", "an error occurred") }
+    let(:command) { "cmd" }
+
+    before do
+      allow(subject).to receive(:backend).and_return(backend)
+      allow(backend).to receive(:run_command).with(command).and_return(result)
+    end
+
+    context "when no error occurs" do
+      let(:exit_status) { 0 }
+      it "returns the result" do
+        expect(subject.run_command!(command)).to eq result
+      end
+
+      context "when sudo_as_user is true" do
+        let(:family) { "debian" }
+        let(:is_linux) { true }
+        it "returns the result" do
+          expect(backend).to receive(:run_command).with("-u user #{command}").and_return(result)
+          expect(subject.run_command!(command, true)).to eq result
+        end
+      end
+    end
+
+    context "when an error occurs" do
+      let(:exit_status) { 1 }
+      it "raises a RemoteExecutionFailed error" do
+        expected_error = ChefApply::TargetHost::RemoteExecutionFailed
+        expect { subject.run_command!(command) }.to raise_error(expected_error)
+      end
+    end
+  end
+
+  context "#get_chef_version_manifest" do
+    let(:manifest_content) { '{"build_version" : "1.2.3"}' }
+    let(:expected_manifest_path) do
+      {
+        windows: "c:\\opscode\\chef\\version-manifest.json",
+        linux: "/opt/chef/version-manifest.json"
+      }
+    end
+    let(:base_os) { :unknown }
+    before do
+      remote_file_mock = double("remote_file", file?: manifest_exists, content: manifest_content)
+      backend_mock = double("backend")
+      expect(backend_mock).to receive(:file).
+        with(expected_manifest_path[base_os]).
+        and_return(remote_file_mock)
+      allow(subject).to receive(:backend).and_return backend_mock
+      allow(subject).to receive(:base_os).and_return base_os
+    end
+
+    context "when manifest is missing" do
+      let(:manifest_exists) { false }
+      context "on windows" do
+        let(:base_os) { :windows }
+        it "returns :not_found" do
+          expect(subject.get_chef_version_manifest).to eq :not_found
+        end
+
+      end
+      context "on linux" do
+        let(:base_os) { :linux }
+        it "returns :not_found" do
+          expect(subject.get_chef_version_manifest).to eq :not_found
+        end
+      end
+    end
+
+    context "when manifest is present" do
+      let(:manifest_exists) { true }
+      context "on windows" do
+        let(:base_os) { :windows }
+        it "should return the parsed manifest" do
+          expect(subject.get_chef_version_manifest).to eq({ "build_version" => "1.2.3" })
+        end
+      end
+
+      context "on linux" do
+        let(:base_os) { :linux }
+        it "should return the parsed manifest" do
+          expect(subject.get_chef_version_manifest).to eq({ "build_version" => "1.2.3" })
+        end
+      end
+    end
+  end
+
+  context "#apply_ssh_config" do
+    let(:ssh_host_config) { { user: "testuser", port: 1000, proxy: double("Net:SSH::Proxy::Command") } }
+    let(:connection_config) { { user: "user1", port: 8022, proxy: nil } }
+    before do
+      allow(subject).to receive(:ssh_config_for_host).and_return ssh_host_config
+    end
+
+    ChefApply::TargetHost::SSH_CONFIG_OVERRIDE_KEYS.each do |key|
+      context "when a value is not explicitly provided in options" do
+        it "replaces config config[:#{key}] with the ssh config value" do
+          subject.apply_ssh_config(connection_config, key => nil)
+          expect(connection_config[key]).to eq(ssh_host_config[key])
+        end
+      end
+
+      context "when a value is explicitly provided in options" do
+        it "the connection configuration isnot updated with a value from ssh config" do
+          original_config = connection_config.clone
+          subject.apply_ssh_config(connection_config, { key => "testvalue" } )
+          expect(connection_config[key]).to eq original_config[key]
+        end
+      end
+    end
+  end
+
+end

data/spec/unit/target_resolver_spec.rb

@@ -0,0 +1,380 @@
+#
+# Copyright:: Copyright (c) 2018 Chef Software Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require "spec_helper"
+require "chef_apply/target_resolver"
+
+RSpec.describe ChefApply::TargetResolver do
+  let(:target_string) { "" }
+  let(:default_protocol) { "ssh" }
+  let(:connection_options) { {} }
+  subject { ChefApply::TargetResolver.new(target_string, default_protocol, connection_options) }
+
+  context "#targets" do
+    context "when no target is provided" do
+      let(:target_string) { "" }
+      it "returns an empty array" do
+        expect(subject.targets).to eq []
+      end
+    end
+
+    context "when a single target is provided" do
+      let(:target_string) { "ssh://localhost" }
+      it "returns any array with one target" do
+        actual_targets = subject.targets
+        expect(actual_targets[0].config[:host]).to eq "localhost"
+      end
+    end
+
+    context "when a comma-separated list of targets is provided" do
+      let(:target_string) { "ssh://node1.example.com,winrm://node2.example.com" }
+      it "returns an array with correct TargetHost instances" do
+        actual_targets = subject.targets
+        expect(actual_targets[0].config[:host]).to eq "node1.example.com"
+        expect(actual_targets[1].config[:host]).to eq "node2.example.com"
+      end
+    end
+    context "when a comma-separated list of targets that include ranges is provided" do
+      let(:target_string) { "ssh://node[0:1],ssh://machine[0:1]" }
+      it "returns an array with correct TargetHost instances" do
+        actual_targets = subject.targets
+
+        expect(actual_targets[0].config[:host]).to eq "node0"
+        expect(actual_targets[1].config[:host]).to eq "node1"
+        expect(actual_targets[2].config[:host]).to eq "machine0"
+        expect(actual_targets[3].config[:host]).to eq "machine1"
+      end
+    end
+
+    context "when a mixed list of targets containing user prefix and not are included" do
+
+      let(:target_string) { "test_user1@node1,node2,test_user2:password@node3" }
+
+      context "and the :user option is provided" do
+
+        let(:connection_options) { { user: "defaultuser" } }
+        it "should default to the given :user only for the host that does not include name" do
+          actual_targets = subject.targets
+          tc = actual_targets[0].config
+          expect(tc[:host]).to eq "node1"
+          expect(tc[:user]).to eq "test_user1"
+
+          tc = actual_targets[1].config
+          expect(tc[:host]).to eq "node2"
+          expect(tc[:user]).to eq "defaultuser"
+
+          tc = actual_targets[2].config
+          expect(tc[:host]).to eq "node3"
+          expect(tc[:user]).to eq "test_user2"
+        end
+      end
+      context "and the :user option is not provided" do
+        let(:opts) { {} }
+        it "should default to no user when user is not included with host" do
+          actual_targets = subject.targets
+          tc = actual_targets[0].config
+          expect(tc[:host]).to eq "node1"
+          expect(tc[:user]).to eq "test_user1"
+
+          tc = actual_targets[1].config
+          expect(tc[:host]).to eq "node2"
+          expect(tc[:user]).to eq nil
+
+          tc = actual_targets[2].config
+          expect(tc[:host]).to eq "node3"
+          expect(tc[:user]).to eq "test_user2"
+        end
+      end
+
+    end
+  end
+
+  context "#expand_targets" do
+    it "returns a single item when no expansion is required" do
+      expect(subject.expand_targets("one")).to eq ["one"]
+    end
+
+    it "expands single alphabetic range" do
+      expect(subject.expand_targets("host[a:h]")).to eq %w{
+        hosta hostb hostc hostd hoste hostf hostg hosth
+      }
+    end
+    it "expands single alphabetic range even if reverse ordering is given" do
+      expect(subject.expand_targets("host[h:a]")).to eq %w{
+        hosta hostb hostc hostd hoste hostf hostg hosth
+      }
+    end
+
+    it "expands a range when the target name is qualified with credentials" do
+      expect(subject.expand_targets("ssh://user:password@host[a:b]")).to eq %w{
+        ssh://user:password@hosta
+        ssh://user:password@hostb
+      }
+    end
+
+    it "expands a numeric range correctly when start/stop string values ASCII-sort in reverse" do
+      # eg: ["4", "10"].sort => ["10", "4"]
+      expect(subject.expand_targets("[4:10]")).to eq %w{ 4 5 6 7 8 9 10 }
+    end
+
+    it "expands a numeric range correctly when stop is higher than start" do
+      expect(subject.expand_targets("[10:8]")).to eq %w{ 8 9 10 }
+    end
+
+    it "expands a string range correctly when stop is higher than start" do
+      expect(subject.expand_targets("[z:y]")).to eq %w{ y z }
+    end
+
+    it "expands single numeric range" do
+      expect(subject.expand_targets("host[10:20]")).to eq %w{
+        host10 host11 host12 host13 host14 host15 host16
+        host17 host18 host19 host20
+      }
+    end
+
+    it "expands two included ranges" do
+      expect(subject.expand_targets("host[1:4].domain[a:c]").sort).to eq [
+        "host1.domaina", "host1.domainb", "host1.domainc",
+        "host2.domaina", "host2.domainb", "host2.domainc",
+        "host3.domaina", "host3.domainb", "host3.domainc",
+        "host4.domaina", "host4.domainb", "host4.domainc"
+      ].sort
+    end
+
+    it "raises InvalidRange if a range mixes alpha and numeric" do
+      expect { subject.expand_targets("host[a:9]") }.to raise_error(ChefApply::TargetResolver::InvalidRange)
+    end
+
+    it "raises TooManyRanges if more than two ranges are included" do
+      expect { subject.expand_targets("[0:1][5:10][10:11]") }.to raise_error(ChefApply::TargetResolver::TooManyRanges)
+    end
+
+    context "when the target resolves to more than #{ChefApply::TargetResolver::MAX_EXPANDED_TARGETS} names" do
+      it "raises TooManyTargets" do
+        expect { subject.expand_targets("[0:99999]") }.to raise_error(ChefApply::TargetResolver::TooManyTargets)
+      end
+    end
+  end
+
+  context "#make_credentials" do
+    let(:default_user) { nil }
+    let(:default_password) { nil }
+
+    let(:inline_user) { nil }
+    let(:inline_password) { nil }
+
+    subject do
+      opts = {}
+      opts[:user] = default_user unless default_user.nil?
+      opts[:password] = default_password unless default_password.nil?
+      resolver = ChefApply::TargetResolver.new("", default_protocol, opts)
+      Proc.new { resolver.make_credentials(inline_user, inline_password) }
+    end
+
+    context "when no default user or password is given" do
+      let(:default_user) { nil }
+      let(:default_password) { nil }
+
+      context "and only an inline user is provided" do
+        let(:inline_user) { "aninlineuser" }
+        let(:inline_password) { nil }
+        it "returns the decorated inline user with nil password" do
+          expect(subject.call).to eq [inline_user, nil]
+        end
+      end
+
+      context "and only an inline password is provided" do
+        let(:inline_user) { nil }
+        let(:inline_password) { "inlinepassword4u" }
+        it "returns the decorated inline password" do
+          expect(subject.call).to eq [nil, inline_password]
+        end
+      end
+
+      context "and neither inline user nor inline password is given" do
+        let(:inline_user) { nil }
+        let(:inline_password) { nil }
+        it "returns an empty string" do
+          expect(subject.call).to eq [nil, nil]
+        end
+      end
+
+      context "and both inline user and inline password are given" do
+        let(:inline_user) { "adefaultuser" }
+        let(:inline_password) { "inlinepassword4u" }
+        it "returns the decorated inline_user and inline password" do
+          expect(subject.call).to eq [inline_user, inline_password]
+        end
+      end
+    end
+
+    context "when only a default user is given" do
+      let(:default_user) { "defaultusername" }
+      let(:default_password) { nil }
+
+      context "and only an inline user is provided" do
+        let(:inline_user) { "aninlineuser" }
+        let(:inline_password) { nil }
+        it "returns the inline user with no password" do
+          expect(subject.call).to eq [inline_user, nil]
+        end
+      end
+
+      context "and only an inline password is provided" do
+        let(:inline_user) { nil }
+        let(:inline_password) { "inlinepassword4u" }
+        it "returns the default user and inline password" do
+          expect(subject.call).to eq [default_user, inline_password]
+        end
+      end
+
+      context "and neither inline user nor inline password is given" do
+        let(:inline_user) { nil }
+        let(:inline_password) { nil }
+        it "returns the default user" do
+          expect(subject.call).to eq [default_user, nil]
+        end
+      end
+
+      context "and both inline user and inline password are given" do
+        let(:inline_user) { "adefaultuser" }
+        let(:inline_password) { "inlinepassword4u" }
+        it "returns the decorated inline_user and inline password" do
+          expect(subject.call).to eq [inline_user, inline_password]
+        end
+      end
+    end
+
+    context "when only a default password is given" do
+      let(:default_user) { nil }
+      let(:default_password) { "ihasdefaultpassword" }
+
+      context "and only an inline user is provided" do
+        let(:inline_user) { "aninlineuser" }
+        let(:inline_password) { nil }
+        it "returns the decorated inline user and default password" do
+          expect(subject.call).to eq [inline_user, default_password]
+        end
+      end
+
+      context "and only an inline password is provided" do
+        let(:inline_user) { nil }
+        let(:inline_password) { "inlinepassword4u" }
+        it "returns nil user and inline password" do
+          expect(subject.call).to eq [nil, inline_password]
+        end
+      end
+
+      context "and neither inline user nor inline password is given" do
+        let(:inline_user) { nil }
+        let(:inline_password) { nil }
+        it "returns the nil user and default password" do
+          expect(subject.call).to eq [nil, default_password]
+        end
+      end
+
+      context "and both inline user and inline password are given" do
+        let(:inline_user) { "adefaultuser" }
+        let(:inline_password) { "inlinepassword4u" }
+        it "returns the inline_user and inline password" do
+          expect(subject.call).to eq [inline_user, inline_password]
+        end
+      end
+    end
+
+    context "when defaults for both user and password are given" do
+      let(:default_user) { "adefaultuser" }
+      let(:default_password) { "ihasdefaultpassword" }
+
+      context "and only an inline user is provided" do
+        let(:inline_user) { "aninlineuser" }
+        let(:inline_password) { nil }
+        it "returns the decorated inline user and default password" do
+          expect(subject.call).to eq [inline_user, default_password]
+        end
+      end
+
+      context "and only an inline password is provided" do
+        let(:inline_user) { nil }
+        let(:inline_password) { "inlinepassword4u" }
+        it "returns the decorated default user and inline password" do
+          expect(subject.call).to eq [default_user, inline_password]
+        end
+      end
+
+      context "and neither inline user nor inline password is given" do
+        let(:inline_user) { nil }
+        let(:inline_password) { nil }
+        it "returns the decorated default user and default password" do
+          expect(subject.call).to eq [default_user, default_password]
+        end
+      end
+
+      context "and both inline user and inline password are given" do
+        let(:inline_user) { "adefaultuser" }
+        let(:inline_password) { "inlinepassword4u" }
+        it "returns the decorated inline_user and inline password" do
+          expect(subject.call).to eq [inline_user, inline_password]
+        end
+      end
+    end
+  end
+
+  context "#config_for_target" do
+    { "example.com" => { password: nil, url: "ssh://example.com", user: nil },
+      "ssh://example.com" =>  { password: nil, url: "ssh://example.com", user: nil },
+      "ssh://user@example.com" => { password: nil, url: "ssh://example.com", user: "user" },
+      "ssh://user:password@example.com" => { password: "password", user: "user", url: "ssh://example.com" },
+      "ssh://user:pas:sw:ord@example.com" => { password: "pas:sw:ord", user: "user", url: "ssh://example.com" },
+      "ssh://user:!@#$%^&*()|\'\";:/?><.,{}[]+=`~@example.com" => { password: "!@#$%^&*()|\'\";:/?><.,{}[]+=`~", user: "user", url: "ssh://example.com" }
+    }.each do |values|
+      it "resolves #{values[0]} to #{values[1]}" do
+        expect(subject.config_for_target(values[0])).to eq values[1]
+      end
+    end
+
+    it "preserves range specifiers in the host portion while encoding in the password portion" do
+      input = "user:pas[1:2]!^@ho[a:b]s[t:z].com"
+      output = { password: "pas[1:2]!^", url: "ssh://ho[a:b]s[t:z].com", user: "user" }
+      expect(subject.config_for_target(input)).to eq output
+    end
+  end
+
+  context "#prefix_from_target" do
+    context "when no protocol is provided" do
+      let(:default_protocol) { "badproto" }
+      it "uses the default from configuration" do
+        expect(subject.prefix_from_target("host.com")).to eq %w{badproto:// host.com}
+      end
+    end
+
+    context "when protocol is provided" do
+      context "and it is valid" do
+        it "keeps the protocol" do
+          expect(subject.prefix_from_target("ssh://host.com")).to eq %w{ssh:// host.com}
+        end
+      end
+      context "and it is not valid" do
+        it "raises an error" do
+          expect { subject.prefix_from_target("bad://host.com") }.
+            to raise_error(ChefApply::TargetResolver::UnsupportedProtocol)
+        end
+      end
+    end
+  end
+
+end