chef-apply 0.4.6 → 0.4.9

data/spec/unit/target_host/linux_spec.rb

@@ -1,57 +0,0 @@
-require "spec_helper"
-require "chef_apply/target_host"
-require "chef_apply/target_host/linux"
-
-RSpec.describe ChefApply::TargetHost::Linux do
-  let(:user) { "testuser" }
-  let(:host) { "mock://#{user}@example.com" }
-  let(:family) { "linux" }
-  let(:name) { "linux" }
-  let(:path) { "/tmp/blah" }
-
-  subject do
-    ChefApply::TargetHost.mock_instance(host, family: family, name: name)
-  end
-
-  context "#make_temp_dir" do
-    it "creates the directory using a properly formed make_temp_dir" do
-      expect(subject).to receive(:run_command!)
-        .with("bash -c '#{ChefApply::TargetHost::Linux::MKTEMP_COMMAND}'")
-        .and_return(instance_double("result", stdout: "/tmp/blah"))
-      expect(subject.make_temp_dir).to eq "/tmp/blah"
-    end
-  end
-
-  context "#mkdir" do
-    it "uses a properly formed mkdir to create the directory and changes ownership to connected user" do
-      expect(subject).to receive(:run_command!).with("mkdir -p /tmp/dir")
-      subject.mkdir("/tmp/dir")
-    end
-  end
-
-  context "#chown" do
-    it "uses a properly formed chown to change owning user to the provided user" do
-      expect(subject).to receive(:run_command!).with("chown newowner '/tmp/dir'")
-      subject.chown("/tmp/dir", "newowner")
-    end
-  end
-
-  context "#install_package" do
-    context "when it receives an RPM package" do
-      let(:expected_command) { "rpm -Uvh /my/package.rpm" }
-      it "should run the correct rpm command" do
-        expect(subject).to receive(:run_command!).with expected_command
-        subject.install_package("/my/package.rpm")
-
-      end
-
-    end
-    context "when it receives a DEB package" do
-      let(:expected_command) { "dpkg -i /my/package.deb" }
-      it "should run the correct dpkg command" do
-        expect(subject).to receive(:run_command!).with expected_command
-        subject.install_package("/my/package.deb")
-      end
-    end
-  end
-end

data/spec/unit/target_host/windows_spec.rb

@@ -1,43 +0,0 @@
-
-require "spec_helper"
-require "chef_apply/target_host"
-require "chef_apply/target_host/windows"
-
-RSpec.describe ChefApply::TargetHost::Windows do
-  let(:host) { "mock://user@example.com" }
-  let(:family) { "windows" }
-  let(:name) { "windows" }
-  let(:path) { "C:\\temp\\blah" }
-
-  subject do
-    ChefApply::TargetHost.mock_instance(host, family: family, name: name)
-  end
-
-  context "#make_temp_dir" do
-    it "creates the temporary directory using the correct PowerShell command and returns the path" do
-      expect(subject).to receive(:run_command!)
-        .with(ChefApply::TargetHost::Windows::MKTEMP_COMMAND)
-        .and_return(instance_double("result", stdout: path))
-      expect(subject.make_temp_dir).to eq(path)
-    end
-  end
-
-  context "#mkdir" do
-    it "creates the directory using the correct command PowerShell command" do
-      expect(subject).to receive(:run_command!).with("New-Item -ItemType Directory -Force -Path C:\\temp\\dir")
-      subject.mkdir("C:\\temp\\dir")
-    end
-  end
-
-  context "#chown" do
-    xit "does nothing - this is not implemented on Windows until we need it"
-  end
-
-  context "#install_package" do
-    it "runs the correct MSI package install command" do
-      expected_command = "cmd /c msiexec /package C:\\My\\Package.msi /quiet"
-      expect(subject).to receive(:run_command!).with(expected_command)
-      subject.install_package("C:/My/Package.msi")
-    end
-  end
-end

data/spec/unit/target_host_spec.rb

@@ -1,297 +0,0 @@
-#
-# Copyright:: Copyright (c) 2018-2019 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(:family) { "debian" }
-  let(:name) { "ubuntu" }
-
-  subject do
-    ChefApply::TargetHost.mock_instance(host, family: family, name: name)
-  end
-
-  context "#base_os" do
-    context "for a windows os" do
-      let(:family) { "windows" }
-      let(:name) { "windows" }
-      it "reports :windows" do
-        expect(subject.base_os).to eq :windows
-      end
-    end
-
-    context "for a linux os" do
-      let(:family) { "debian" }
-      let(:name) { "ubuntu" }
-      it "reports :linux" do
-        expect(subject.base_os).to eq :linux
-      end
-    end
-
-    context "for an unsupported OS" do
-      let(:family) { "unknown" }
-      let(:name) { "unknown" }
-      it "reports :other" do
-        expect(subject.base_os).to eq :other
-      end
-    end
-  end
-
-  context "#installed_chef_version" do
-    context "when no version manifest is present" do
-      it "raises ChefNotInstalled" do
-        expect(subject).to receive(:read_chef_version_manifest).and_raise(ChefApply::TargetHost::ChefNotInstalled.new)
-        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).to receive(:read_chef_version_manifest).and_return manifest
-        expect(subject.installed_chef_version).to eq Gem::Version.new("14.0.1")
-      end
-    end
-  end
-
-  context "connect!" do
-    # For all other tets, target_host is a mocked instance that is already connected
-    # In this case, we want to build a new one that is not yet connected to test connect! itself.
-    let(:target_host) { ChefApply::TargetHost.new(host, sudo: false) }
-    let(:train_connection_mock) { double("train connection") }
-    before do
-      allow(target_host).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 { target_host.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 { target_host.connect! }.to raise_error(ChefApply::TargetHost::ConnectionFailure)
-      end
-    end
-  end
-
-  context "#mix_in_target_platform!" do
-    let(:base_os) { :none }
-    before do
-      allow(subject).to receive(:base_os).and_return base_os
-    end
-
-    context "when base_os is linux" do
-      let(:base_os) { :linux }
-      it "mixes in Linux support" do
-        expect(subject.class).to receive(:include).with(ChefApply::TargetHost::Linux)
-        subject.mix_in_target_platform!
-      end
-    end
-
-    context "when base_os is windows" do
-      let(:base_os) { :windows }
-      it "mixes in Windows support" do
-        expect(subject.class).to receive(:include).with(ChefApply::TargetHost::Windows)
-        subject.mix_in_target_platform!
-      end
-    end
-
-    context "when base_os is other" do
-      let(:base_os) { :other }
-      it "raises UnsupportedTargetOS" do
-        expect { subject.mix_in_target_platform! }.to raise_error(ChefApply::TargetHost::UnsupportedTargetOS)
-      end
-
-    end
-    context "after it connects" do
-      context "to a Windows host" do
-        it "includes the Windows TargetHost mixin" do
-        end
-
-      end
-
-      context "and the platform is linux" do
-        it "includes the Windows TargetHost mixin" do
-        end
-      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
-    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 "#read_chef_version_manifest" do
-    let(:manifest_content) { '{"build_version" : "1.2.3"}' }
-    before do
-      allow(subject).to receive(:fetch_file_contents).and_return(manifest_content)
-      allow(subject).to receive(:omnibus_manifest_path).and_return("/path/to/manifest.json")
-    end
-
-    context "when manifest is missing" do
-      let(:manifest_content) { nil }
-      it "raises ChefNotInstalled" do
-        expect { subject.read_chef_version_manifest }.to raise_error(ChefApply::TargetHost::ChefNotInstalled)
-      end
-    end
-
-    context "when manifest is present" do
-      let(:manifest_content) { '{"build_version" : "1.2.3"}' }
-      it "should return the parsed manifest" do
-        expect(subject.read_chef_version_manifest).to eq({ "build_version" => "1.2.3" })
-      end
-    end
-  end
-
-  # What we test:
-  #   - file contents can be retrieved, and invalid conditions results in no content
-  # What we mock:
-  #   - the train `backend`
-  #   - the backend `file` method
-  #   Why?
-  #     - in this unit test, we're not testing round-trip behavior of the train API, only
-  #       that we are invoking the API and interpreting its results correctly.
-  context "#fetch_file_contents" do
-    let(:path) { "/path/to/file" }
-    let(:sample_content) { "content" }
-    let(:backend_mock) { double("backend") }
-    let(:path_exists) { true }
-    let(:path_is_file) { true }
-    let(:remote_file_mock) do
-      double("remote_file", exist?: path_exists,
-                                    file?: path_is_file, content: sample_content)
-    end
-    before do
-      expect(subject).to receive(:backend).and_return backend_mock
-      expect(backend_mock).to receive(:file).with(path).and_return remote_file_mock
-    end
-
-    context "when path exists" do
-      let(:path_exists) { true }
-      before do
-      end
-
-      context "but is not a file" do
-        let(:path_is_file) { false }
-        it "returns nil" do
-          expect(subject.fetch_file_contents(path)).to be_nil
-        end
-      end
-      context "and is a file" do
-        it "returns the expected file contents" do
-          expect(subject.fetch_file_contents(path)).to eq sample_content
-        end
-      end
-    end
-    context "when path does not exist" do
-      let(:path_exists) { false }
-      it "returns nil" do
-        expect(subject.fetch_file_contents(path)).to be_nil
-      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
-
-  context "#temp_dir" do
-    it "creates the temp directory and changes ownership" do
-      expect(subject).to receive(:make_temp_dir).and_return("/tmp/dir")
-      expect(subject).to receive(:chown).with("/tmp/dir", subject.user)
-      subject.temp_dir
-    end
-  end
-
-  context "#make_directory" do
-    it "creates the directory and sets ownership to connecting user" do
-      expect(subject).to receive(:mkdir).with("/tmp/mkdir")
-      expect(subject).to receive(:chown).with("/tmp/mkdir", subject.user)
-      subject.make_directory("/tmp/mkdir")
-    end
-  end
-
-end

data/spec/unit/target_resolver_spec.rb

@@ -1,380 +0,0 @@
-#
-# 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