chef-apply 0.2.8 → 0.2.13

data/spec/unit/action/install_chef_spec.rb

@@ -19,8 +19,8 @@ require "spec_helper"
 require "chef_apply/action/install_chef"
 
 RSpec.describe ChefApply::Action::InstallChef do
-  let(:mock_os_name) { "mock" }
-  let(:mock_os_family) { "mock" }
+  let(:mock_os_name) { "linux" }
+  let(:mock_os_family) { "linux" }
   let(:mock_os_release ) { "unknown" }
   let(:mock_opts) do
     {
@@ -31,38 +31,133 @@ RSpec.describe ChefApply::Action::InstallChef do
     }
   end
   let(:target_host) do
-    ChefApply::TargetHost.new("mock://user1:password1@localhost")
+    ChefApply::TargetHost.mock_instance("mock://user1:password1@localhost", mock_opts)
   end
 
-  subject(:installer) do
-    ChefApply::Action::InstallChef
+  let(:reporter) do
+    ChefApply::MockReporter.new
   end
 
-  before do
-    target_host.connect!
-    target_host.backend.mock_os(mock_opts)
+  subject(:install) do
+    ChefApply::Action::InstallChef.new(target_host: target_host,
+                                       reporter: reporter,
+                                       check_only: false)
   end
 
-  context ".instance_for_target" do
-    context "windows target" do
-      let(:mock_os_name) { "Windows_Server" }
-      let(:mock_os_family) { "windows" }
-      let(:mock_os_release) { "10.0.0" }
+  context "#perform_action" do
+    context "when chef is already installed on target" do
+      it "notifies of success and takes no further action" do
+        expect(ChefApply::MinimumChefVersion).to receive(:check!).with(install.target_host, false)
+                       .and_return(:minimum_version_met)
+        expect(install).not_to receive(:perform_local_install)
+        install.perform_action
+      end
+    end
+
+    context "when chef is not already installed on target" do
+      it "should invoke perform_local_install" do
+        expect(ChefApply::MinimumChefVersion).to receive(:check!).with(install.target_host, false)
+                       .and_return(:client_not_installed)
+        expect(install).to receive(:perform_local_install)
+        install.perform_action
+      end
+    end
+  end
+
+  context "#perform_local_install" do
+    let(:artifact) { double("artifact") }
+    let(:package_url) { "https://chef.io/download/package/here" }
+    before do
+      allow(artifact).to receive(:url).and_return package_url
+    end
+
+    it "performs the steps necessary to perform an installation" do
+      expect(install).to receive(:lookup_artifact).and_return artifact
+      expect(install).to receive(:download_to_workstation).with(package_url) .and_return "/local/path"
+      expect(install).to receive(:upload_to_target).with("/local/path").and_return("/remote/path")
+      expect(target_host).to receive(:install_package).with("/remote/path")
+
+      install.perform_local_install
+    end
+  end
+
+  context "#train_to_mixlib" do
+    let(:platform) { double }
+    before do
+      allow(platform).to receive(:release).and_return "1234"
+      allow(platform).to receive(:name).and_return "beos"
+      allow(platform).to receive(:arch).and_return "ppc"
+    end
+
+    context "when any flavor of windows" do
+      before do
+        allow(platform).to receive(:name).and_return "windows_10_pro_n"
+      end
+
+      it "sets platform name to 'windows'" do
+        mixlib_info = install.train_to_mixlib(platform)
+        expect(mixlib_info[:platform]).to eq "windows"
+      end
+    end
+
+    context "when redhat" do
+      before do
+        allow(platform).to receive(:name).and_return "redhat"
+      end
+
+      it "sets platform name to 'el'" do
+        mixlib_info = install.train_to_mixlib(platform)
+        expect(mixlib_info[:platform]).to eq "el"
+      end
+    end
+
+    context "when centos" do
+      before do
+        allow(platform).to receive(:name).and_return "centos"
+      end
 
-      it "should return a InstallChef::Windows instance" do
-        inst = installer.instance_for_target(target_host)
-        expect(inst).to be_a installer::Windows
+      it "sets platform name to 'el'" do
+        mixlib_info = install.train_to_mixlib(platform)
+        expect(mixlib_info[:platform]).to eq "el"
       end
     end
 
-    context "linux target" do
-      let(:mock_os_name) { "ubuntu" }
-      let(:mock_os_family) { "debian" }
-      let(:mock_os_release) { "16.04" }
+    context "when suse" do
+      before do
+        allow(platform).to receive(:name).and_return "suse"
+      end
+
+      it "sets platform name to 'sles'" do
+        mixlib_info = install.train_to_mixlib(platform)
+        expect(mixlib_info[:platform]).to eq "sles"
+      end
+    end
+    context "when amazon" do
+      before do
+        allow(platform).to receive(:name).and_return "amazon"
+      end
+
+      context "when amazon linux 1.x" do
+        before do
+          allow(platform).to receive(:release).and_return "2017.09"
+        end
+
+        it "sets platform name to 'amazon' and plaform_version to '6'" do
+          mixlib_info = install.train_to_mixlib(platform)
+          expect(mixlib_info[:platform]).to eq "el"
+          expect(mixlib_info[:platform_version]).to eq "6"
+        end
+      end
+      context "when amazon linux 2.x" do
+        before do
+          allow(platform).to receive(:release).and_return "2"
+        end
 
-      it "should return a InstallChef::Linux instance" do
-        inst = installer.instance_for_target(target_host)
-        expect(inst).to be_a installer::Linux
+        it "sets platform name to 'amazon' and plaform_version to '7'" do
+          mixlib_info = install.train_to_mixlib(platform)
+          expect(mixlib_info[:platform]).to eq "el"
+          expect(mixlib_info[:platform_version]).to eq "7"
+        end
       end
     end
   end

data/spec/unit/cli_spec.rb

@@ -146,6 +146,7 @@ RSpec.describe ChefApply::CLI do
       context "and they are valid" do
         it "creates the cookbook locally and converges it" do
           expect(subject).to receive(:parse_options)
+          expect(subject).to receive(:check_license_acceptance)
           expect(subject).to receive(:validate_params)
           expect(subject).to receive(:resolve_targets).and_return target_hosts
           expect(subject).to receive(:render_cookbook_setup)
@@ -156,6 +157,33 @@ RSpec.describe ChefApply::CLI do
     end
   end
 
+  describe "#check_license_acceptance" do
+    let(:acceptance_value) { "accept-no-persist" }
+    let(:acceptor) { instance_double(LicenseAcceptance::Acceptor) }
+
+    before do
+      ChefApply::Config.reset
+      expect(LicenseAcceptance::Acceptor).to receive(:new).with(provided: ChefApply::Config.chef.chef_license).and_return(acceptor)
+    end
+
+    it "sets the config value to the acceptance value" do
+      expect(ChefApply::Config.chef.chef_license).to eq(nil)
+      expect(acceptor).to receive(:check_and_persist).with("infra-client", "latest")
+      expect(acceptor).to receive(:acceptance_value).and_return(acceptance_value)
+      subject.check_license_acceptance
+      expect(ChefApply::Config.chef.chef_license).to eq(acceptance_value)
+    end
+
+    describe "when the user does not accept the license" do
+      it "raises a LicenseCheckFailed error" do
+        expect(ChefApply::Config.chef.chef_license).to eq(nil)
+        expect(acceptor).to receive(:check_and_persist).with("infra-client", "latest").and_raise(LicenseAcceptance::LicenseNotAcceptedError.new(nil, []))
+        expect { subject.check_license_acceptance }.to raise_error(ChefApply::LicenseCheckFailed)
+        expect(ChefApply::Config.chef.chef_license).to eq(nil)
+      end
+    end
+  end
+
   describe "#connect_target" do
     let(:host) { double("TargetHost", config: {}, user: "root" ) }
     let(:reporter) { double("reporter", update: :ok, success: :ok) }
@@ -354,12 +382,12 @@ RSpec.describe ChefApply::CLI do
                           upgrading?: upgrading,
                           version_to_install: "14.0") end
 
-    it "updates status, gets an InstallChef via instance_for_target and executes it" do
+    it "updates status, creates an InstallChef action and executes it" do
       expect(reporter)
         .to receive(:update)
         .with(ChefApply::CLI::TS.install_chef.verifying)
-      expect(ChefApply::Action::InstallChef).to receive(:instance_for_target)
-        .with(target_host, check_only: false)
+      expect(ChefApply::Action::InstallChef).to receive(:new)
+        .with(target_host: target_host, check_only: false)
         .and_return action
       expect(action).to receive(:run)
       subject.install(target_host, reporter)
@@ -371,7 +399,7 @@ RSpec.describe ChefApply::CLI do
 
       before do
         allow(ChefApply::Action::InstallChef)
-          .to receive(:instance_for_target).and_return action
+          .to receive(:new).and_return action
         allow(action)
           .to receive(:run) { |&block| block.call(event, event_args) }
         allow(reporter)

data/spec/unit/target_host/linux_spec.rb

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

@@ -0,0 +1,43 @@
+
+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,5 +1,5 @@
 #
-# Copyright:: Copyright (c) 2018 Chef Software Inc.
+# Copyright:: Copyright (c) 2018-2019 Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -21,19 +21,17 @@ 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") }
+  let(:family) { "debian" }
+  let(:name) { "ubuntu" }
+
   subject do
-    s = ChefApply::TargetHost.new(host, sudo: sudo, logger: logger)
-    allow(s).to receive(:platform).and_return(platform_mock)
-    s
+    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
@@ -41,29 +39,25 @@ RSpec.describe ChefApply::TargetHost do
 
     context "for a linux os" do
       let(:family) { "debian" }
-      let(:is_linux) { true }
+      let(:name) { "ubuntu" }
       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)
+      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
-    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).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
@@ -71,30 +65,79 @@ RSpec.describe ChefApply::TargetHost do
     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(subject).to receive(:train_connection).and_return(train_connection_mock)
+      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 { subject.connect! }.to raise_error(ChefApply::TargetHost::ConnectionFailure)
+        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 { subject.connect! }.to raise_error(ChefApply::TargetHost::ConnectionFailure)
+        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)
@@ -140,58 +183,73 @@ RSpec.describe ChefApply::TargetHost do
     end
   end
 
-  context "#get_chef_version_manifest" do
+  context "#read_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
+      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_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
+      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_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
+      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 "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" })
+      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
@@ -219,83 +277,20 @@ RSpec.describe ChefApply::TargetHost do
     end
   end
 
-  context "target host operations" do
-    let(:base_os) { :unknown }
-    let(:user) { "testuser" }
-    before do
-      allow(subject).to receive(:base_os).and_return base_os
-      allow(subject).to receive(:user).and_return user
+  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
-    context "#mkdir" do
-      context "when the target is Windows" do
-        let(:base_os) { :windows }
-        it "creates the directory using the correct command PowerShell command" do
-          # TODO - testing command strings always feels a bit like an antipattern. Do we have alternatives?
-          expect(subject).to receive(:run_command!).with("New-Item -ItemType Directory -Force -Path C:\\temp\\dir")
-          subject.mkdir("C:\\temp\\dir")
-        end
-
-      end
-      context "when the target is Linux" do
-        let(:base_os) { :linux }
-        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")
-          expect(subject).to receive(:run_command!).with("chown testuser '/tmp/dir'")
-          subject.mkdir("/tmp/dir")
-
-        end
-      end
-    end
-
-    context "#chown" do
-      context "when the target is Windows" do
-        let(:base_os) { :windows }
-        xit "does nothing - this is not implemented until we need it"
-      end
-
-      context "when the target is Linux" do
-        let(:base_os) { :linux }
-        let(:path) { "/tmp/blah" }
-
-        context "and an owner is provided" do
-          it "uses a properly formed chown to change owning user to the connected user" do
-            expect(subject).to receive(:run_command!).with("chown newowner '/tmp/dir'")
-            subject.chown("/tmp/dir", "newowner")
-          end
-        end
-
-        context "and an owner is not provided" do
-          it "uses a properly formed chown to change owning user to the connected user" do
-            expect(subject).to receive(:run_command!).with("chown #{user} '/tmp/dir'")
-            subject.chown("/tmp/dir")
-          end
-        end
-      end
-    end
-
-    context "#mktemp" do
-      context "when the target is Windows" do
-        let(:base_os) { :windows }
-        let(:path) { "C:\\temp\\blah" }
-        it "creates the temporary directory using the correct PowerShell command and returns the path" do
-          expect(subject).to receive(:run_command!)
-            .with(ChefApply::TargetHost::MKTMP_WIN_CMD)
-            .and_return(instance_double("result", stdout: path))
-          expect(subject.mktemp()).to eq(path)
-        end
-      end
+  end
 
-      context "when the target is Linux" do
-        let(:base_os) { :linux }
-        let(:path) { "/tmp/blah" }
-        it "creates the directory using a properly formed mktemp, changes ownership to connecting user, and returns the path" do
-          expect(subject).to receive(:run_command!)
-            .with("bash -c '#{ChefApply::TargetHost::MKTMP_LINUX_CMD}'")
-            .and_return(instance_double("result", stdout: "/tmp/blah"))
-          expect(subject).to receive(:chown).with(path)
-          expect(subject.mktemp()).to eq path
-        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