chef 12.1.2 → 12.2.0.rc.1

data/spec/functional/resource/remote_directory_spec.rb

@@ -22,7 +22,7 @@ describe Chef::Resource::RemoteDirectory do
   include_context Chef::Resource::Directory
 
   let(:directory_base) { "directory_spec" }
-  let(:default_mode) { ((0100777 - File.umask) & 07777).to_s(8) }
+  let(:default_mode) { (0777 & ~File.umask).to_s(8) }
 
   def create_resource
     cookbook_repo = File.expand_path(File.join(CHEF_SPEC_DATA, "cookbooks"))

data/spec/functional/resource/remote_file_spec.rb

@@ -52,7 +52,7 @@ describe Chef::Resource::RemoteFile do
     create_resource
   end
 
-  let(:default_mode) { ((0100666 - File.umask) & 07777).to_s(8) }
+  let(:default_mode) { (0666 & ~File.umask).to_s(8) }
 
   context "when fetching files over HTTP" do
     before(:all) do

data/spec/functional/resource/template_spec.rb

@@ -58,7 +58,7 @@ describe Chef::Resource::Template do
     create_resource
   end
 
-  let(:default_mode) { ((0100666 - File.umask) & 07777).to_s(8) }
+  let(:default_mode) { (0666 & ~File.umask).to_s(8) }
 
   it_behaves_like "a file resource"
 

data/spec/functional/resource/user/dscl_spec.rb

@@ -19,9 +19,8 @@ require 'spec_helper'
 require 'chef/mixin/shell_out'
 
 metadata = {
-  :unix_only => true,
+  :mac_osx_only => true,
   :requires_root => true,
-  :provider => {:user => Chef::Provider::User::Dscl},
   :not_supported_on_mac_osx_106 => true,
 }
 

data/spec/functional/resource/user/useradd_spec.rb

@@ -32,6 +32,7 @@ end
 
 metadata = { :unix_only => true,
   :requires_root => true,
+  :not_supported_on_mac_osx => true,
   :provider => {:user => user_provider_for_platform}
 }
 
@@ -76,9 +77,22 @@ describe Chef::Provider::User::Useradd, metadata do
     end
   end
 
+  def try_cleanup
+    ['/home/cheftestfoo', '/home/cheftestbar'].each do |f|
+      FileUtils.rm_rf(f) if File.exists? f
+    end
+
+    ['cf-test'].each do |u|
+      r = Chef::Resource::User.new("DELETE USER", run_context)
+      r.username('cf-test')
+      r.run_action(:remove)
+    end
+  end
+
   before do
     # Silence shell_out live stream
     Chef::Log.level = :warn
+    try_cleanup
   end
 
   after do
@@ -386,18 +400,18 @@ describe Chef::Provider::User::Useradd, metadata do
       end
 
       context "and home directory is updated" do
-        let(:existing_home) { "/home/foo" }
-        let(:home) { "/home/bar" }
+        let(:existing_home) { "/home/cheftestfoo" }
+        let(:home) { "/home/cheftestbar" }
         it "ensures the home directory is set to the desired value" do
-          expect(pw_entry.home).to eq("/home/bar")
+          expect(pw_entry.home).to eq("/home/cheftestbar")
         end
 
         context "and manage_home is enabled" do
           let(:existing_manage_home) { true }
           let(:manage_home) { true }
           it "moves the home directory to the new location" do
-            expect(File).not_to exist("/home/foo")
-            expect(File).to exist("/home/bar")
+            expect(File).not_to exist("/home/cheftestfoo")
+            expect(File).to exist("/home/cheftestbar")
           end
         end
 
@@ -409,19 +423,19 @@ describe Chef::Provider::User::Useradd, metadata do
             # Inconsistent behavior. See: CHEF-2205
             it "created the home dir b/c of CHEF-2205 so it still exists" do
               # This behavior seems contrary to expectation and non-convergent.
-              expect(File).not_to exist("/home/foo")
-              expect(File).to exist("/home/bar")
+              expect(File).not_to exist("/home/cheftestfoo")
+              expect(File).to exist("/home/cheftestbar")
             end
           elsif ohai[:platform] == "aix"
             it "creates the home dir in the desired location" do
-              expect(File).not_to exist("/home/foo")
-              expect(File).to exist("/home/bar")
+              expect(File).not_to exist("/home/cheftestfoo")
+              expect(File).to exist("/home/cheftestbar")
             end
           else
             it "does not create the home dir in the desired location (XXX)" do
               # This behavior seems contrary to expectation and non-convergent.
-              expect(File).not_to exist("/home/foo")
-              expect(File).not_to exist("/home/bar")
+              expect(File).not_to exist("/home/cheftestfoo")
+              expect(File).not_to exist("/home/cheftestbar")
             end
           end
         end
@@ -432,8 +446,8 @@ describe Chef::Provider::User::Useradd, metadata do
 
           it "leaves the old home directory around (XXX)" do
             # Would it be better to remove the old home?
-            expect(File).to exist("/home/foo")
-            expect(File).not_to exist("/home/bar")
+            expect(File).to exist("/home/cheftestfoo")
+            expect(File).not_to exist("/home/cheftestbar")
           end
         end
       end

data/spec/functional/util/powershell/cmdlet_spec.rb

@@ -19,7 +19,7 @@
 require 'chef/json_compat'
 require File.expand_path('../../../../spec_helper', __FILE__)
 
-describe Chef::Util::Powershell::Cmdlet, :windows_only do
+describe Chef::Util::Powershell::Cmdlet, :windows_powershell_dsc_only  do
   before(:all) do
     ohai = Ohai::System.new
     ohai.load_plugins
@@ -88,7 +88,7 @@ describe Chef::Util::Powershell::Cmdlet, :windows_only do
 
   context "when returning json" do
     let(:cmd_output_format) { :json }
-    it "returns json format data", :windows_powershell_dsc_only do
+    it "returns json format data" do
       result = cmdlet_alias_requires_switch_or_argument.run({},{},'ls')
       expect(result.succeeded?).to eq(true)
       expect(lambda{Chef::JSONCompat.parse(result.return_value)}).not_to raise_error
@@ -97,7 +97,7 @@ describe Chef::Util::Powershell::Cmdlet, :windows_only do
 
   context "when returning Ruby objects" do
     let(:cmd_output_format) { :object }
-    it "returns object format data", :windows_powershell_dsc_only do
+    it "returns object format data" do
       result = simple_cmdlet.run({},{:cwd => etc_directory}, 'hosts')
       expect(result.succeeded?).to eq(true)
       data = result.return_value

data/spec/functional/win32/crypto_spec.rb

@@ -0,0 +1,57 @@
+#
+# Author:: Jay Mundrawala(<jdm@chef.io>)
+# Copyright:: Copyright (c) 2015 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'
+if Chef::Platform.windows?
+  require 'chef/win32/crypto'
+end
+
+describe 'Chef::ReservedNames::Win32::Crypto', :windows_only do
+  describe '#encrypt' do
+    before(:all) do
+      ohai_reader = Ohai::System.new
+      ohai_reader.all_plugins("platform")
+
+      new_node = Chef::Node.new
+      new_node.consume_external_attrs(ohai_reader.data,{})
+
+      events = Chef::EventDispatch::Dispatcher.new
+
+      @run_context = Chef::RunContext.new(new_node, {}, events)
+    end
+
+    let (:plaintext) { 'p@assword' }
+
+    it 'can be decrypted by powershell' do
+      encrypted = Chef::ReservedNames::Win32::Crypto.encrypt(plaintext)
+      resource = Chef::Resource::WindowsScript::PowershellScript.new("Powershell resource functional test", @run_context)
+      resource.code <<-EOF
+$encrypted = '#{encrypted}' | ConvertTo-SecureString
+$BSTR = [System.Runtime.InteropServices.Marshal]::SecureStringToBSTR($encrypted)
+$plaintext = [System.Runtime.InteropServices.Marshal]::PtrToStringAuto($BSTR)
+if ($plaintext -ne '#{plaintext}') {
+  Write-Error 'Got: ' $plaintext
+  exit 1
+}
+exit 0
+      EOF
+      resource.returns(0)
+      resource.run_action(:run)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -110,10 +110,13 @@ RSpec.configure do |config|
   # Tests that randomly fail, but may have value.
   config.filter_run_excluding :volatile => true
   config.filter_run_excluding :volatile_on_solaris => true if solaris?
+  config.filter_run_excluding :volatile_from_verify => false
 
   # Add jruby filters here
   config.filter_run_excluding :windows_only => true unless windows?
   config.filter_run_excluding :not_supported_on_mac_osx_106 => true if mac_osx_106?
+  config.filter_run_excluding :not_supported_on_mac_osx=> true if mac_osx?
+  config.filter_run_excluding :mac_osx_only=> true if !mac_osx?
   config.filter_run_excluding :not_supported_on_win2k3 => true if windows_win2k3?
   config.filter_run_excluding :not_supported_on_solaris => true if solaris?
   config.filter_run_excluding :win2k3_only => true unless windows_win2k3?

data/spec/support/platform_helpers.rb

@@ -88,6 +88,20 @@ def mac_osx_106?
   false
 end
 
+def mac_osx?
+  if File.exists? "/usr/bin/sw_vers"
+    result = ShellHelpers.shell_out("/usr/bin/sw_vers")
+    result.stdout.each_line do |line|
+      if line =~ /^ProductName:\sMac OS X.*$/
+        return true
+      end
+    end
+  end
+
+  false
+end
+
+
 # detects if the hardware is 64-bit (evaluates to true in "WOW64" mode in a 32-bit app on a 64-bit system)
 def windows64?
   windows? && ( ENV['PROCESSOR_ARCHITECTURE'] == 'AMD64' || ENV['PROCESSOR_ARCHITEW6432'] == 'AMD64' )

data/spec/support/shared/functional/securable_resource_with_reporting.rb

@@ -35,7 +35,7 @@ shared_examples_for "a securable resource with reporting" do
   # Default mode varies based on implementation. Providers that use a tempfile
   # will default to 0600. Providers that use File.open will default to 0666 -
   # umask
-  # let(:default_mode) { ((0100666 - File.umask) & 07777).to_s(8) }
+  # let(:default_mode) { (0666 & ~File.umask).to_s(8) }
 
   describe "reading file security metadata for reporting on unix", :unix_only => true do
     # According to POSIX standard created files get either the
@@ -185,7 +185,7 @@ shared_examples_for "a securable resource with reporting" do
           # TODO: most stable way to specify?
           expect(current_resource.owner).to eq(Etc.getpwuid(Process.uid).name)
           expect(current_resource.group).to eq(@expected_group_name)
-          expect(current_resource.mode).to eq("0#{((0100666 - File.umask) & 07777).to_s(8)}")
+          expect(current_resource.mode).to eq("0#{(0666 & ~File.umask).to_s(8)}")
         end
       end
 
@@ -239,8 +239,8 @@ shared_examples_for "a securable resource with reporting" do
       end
 
       context "and mode is specified as a String" do
-        let(:default_create_mode) { (0100666 - File.umask) }
-        let(:expected_mode) { "0#{(default_create_mode & 07777).to_s(8)}" }
+        let(:default_create_mode) { 0666 & ~File.umask }
+        let(:expected_mode) { "0#{default_create_mode.to_s(8)}" }
 
         before do
           resource.mode(expected_mode)
@@ -252,7 +252,7 @@ shared_examples_for "a securable resource with reporting" do
       end
 
       context "and mode is specified as an Integer" do
-        let(:set_mode) { (0100666 - File.umask) & 07777 }
+        let(:set_mode) { 0666 & ~File.umask }
         let(:expected_mode) { "0#{set_mode.to_s(8)}" }
 
         before do

data/spec/unit/application/client_spec.rb

@@ -305,7 +305,7 @@ describe Chef::Application::Client, "run_application", :unix_only do
         allow(Chef::Daemon).to receive(:daemonize).and_return(true)
       end
 
-      it "should exit hard with exitstatus 3" do
+      it "should exit hard with exitstatus 3", :volatile do
         pid = fork do
           @app.run_application
         end
@@ -320,9 +320,9 @@ describe Chef::Application::Client, "run_application", :unix_only do
         end
         expect(@pipe[0].gets).to eq("started\n")
         Process.kill("TERM", pid)
-        Process.wait
-        sleep 1 # Make sure we give the converging child process enough time to finish
-        expect(IO.select([@pipe[0]], nil, nil, 0)).not_to be_nil
+        Process.wait(pid)
+        # The timeout value needs to be large enough for the child process to finish
+        expect(IO.select([@pipe[0]], nil, nil, 15)).not_to be_nil
         expect(@pipe[0].gets).to eq("finished\n")
       end
     end

data/spec/unit/audit/audit_reporter_spec.rb

@@ -203,7 +203,7 @@ describe Chef::Audit::AuditReporter do
       it "doesn't send reports" do
         expect(reporter).to receive(:auditing_enabled?).and_return(true)
         expect(reporter).to receive(:run_status).and_return(nil)
-        expect(Chef::Log).to receive(:debug).with("Run failed before audits were initialized, not sending audit report to server")
+        expect(Chef::Log).to receive(:debug).with("Run failed before audit mode was initialized, not sending audit report to server")
         reporter.run_completed(node)
       end
 

data/spec/unit/audit/runner_spec.rb

@@ -36,6 +36,15 @@ describe Chef::Audit::Runner do
     RSpec::Core::Sandbox.sandboxed { ex.run }
   end
 
+  context "when we run in audit mode" do
+    let(:paths) { [ "/opt/chef/lib/chef/", 'C:\windows/here/lib/chef/' , "/opt/chef/extra/folders/lib/chef/"] }
+    it "excludes the current path from backtrace" do
+      paths.each do |path|
+        expect(runner.exclusion_pattern).to match(path)
+      end
+    end
+  end
+
   describe "#initialize" do
     it "correctly sets the run_context during initialization" do
       expect(runner.instance_variable_get(:@run_context)).to eq(run_context)
@@ -72,6 +81,7 @@ describe Chef::Audit::Runner do
 
           expect(RSpec.configuration.color).to eq(color)
           expect(RSpec.configuration.expose_dsl_globally?).to eq(false)
+          expect(RSpec.configuration.backtrace_exclusion_patterns).to include(runner.exclusion_pattern)
 
           expect(Specinfra.configuration.backend).to eq(:exec)
         end

data/spec/unit/config_spec.rb

@@ -360,18 +360,12 @@ describe Chef::Config do
       describe "Chef::Config[:user_home]" do
         it "should set when HOME is provided" do
           expected = to_platform("/home/kitten")
-          allow(Chef::Config).to receive(:env).and_return({ 'HOME' => expected })
-          expect(Chef::Config[:user_home]).to eq(expected)
-        end
-
-        it "should be set when only USERPROFILE is provided" do
-          expected = to_platform("/users/kitten")
-          allow(Chef::Config).to receive(:env).and_return({ 'USERPROFILE' => expected })
+          allow(Chef::Util::PathHelper).to receive(:home).and_return(expected)
           expect(Chef::Config[:user_home]).to eq(expected)
         end
 
         it "falls back to the current working directory when HOME and USERPROFILE is not set" do
-          allow(Chef::Config).to receive(:env).and_return({})
+          allow(Chef::Util::PathHelper).to receive(:home).and_return(nil)
           expect(Chef::Config[:user_home]).to eq(Dir.pwd)
         end
       end

data/spec/unit/knife/bootstrap_spec.rb

@@ -115,7 +115,7 @@ describe Chef::Knife::Bootstrap do
       end
 
       def configure_env_home
-        ENV['HOME'] = "/env/home"
+        allow(Chef::Util::PathHelper).to receive(:home).with(".chef", "bootstrap", "example.erb").and_yield(env_home_template_path)
       end
 
       def configure_gem_files
@@ -123,15 +123,9 @@ describe Chef::Knife::Bootstrap do
       end
 
       before(:each) do
-        @original_home = ENV['HOME']
-        ENV['HOME'] = nil
         expect(File).to receive(:exists?).with(bootstrap_template).and_return(false)
       end
 
-      after(:each) do
-        ENV['HOME'] = @original_home
-      end
-
       context "when file is available everywhere" do
         before do
           configure_chef_config_dir
@@ -161,7 +155,7 @@ describe Chef::Knife::Bootstrap do
         end
       end
 
-      context "when file is available in ENV['HOME']" do
+      context "when file is available in home directory" do
         before do
           configure_chef_config_dir
           configure_env_home
@@ -178,9 +172,27 @@ describe Chef::Knife::Bootstrap do
       end
 
       context "when file is available in Gem files" do
+        before do
+          configure_chef_config_dir
+          configure_env_home
+          configure_gem_files
+
+          expect(File).to receive(:exists?).with(builtin_template_path).and_return(false)
+          expect(File).to receive(:exists?).with(chef_config_dir_template_path).and_return(false)
+          expect(File).to receive(:exists?).with(env_home_template_path).and_return(false)
+          expect(File).to receive(:exists?).with(gem_files_template_path).and_return(true)
+        end
+
+        it "should load the template from Gem files" do
+          expect(knife.find_template).to eq(gem_files_template_path)
+        end
+      end
+
+      context "when file is available in Gem files and home dir doesn't exist" do
         before do
           configure_chef_config_dir
           configure_gem_files
+          allow(Chef::Util::PathHelper).to receive(:home).with(".chef", "bootstrap", "example.erb").and_return(nil)
 
           expect(File).to receive(:exists?).with(builtin_template_path).and_return(false)
           expect(File).to receive(:exists?).with(chef_config_dir_template_path).and_return(false)

data/spec/unit/knife/core/subcommand_loader_spec.rb

@@ -19,23 +19,29 @@
 require 'spec_helper'
 
 describe Chef::Knife::SubcommandLoader do
+  let(:loader) { Chef::Knife::SubcommandLoader.new(File.join(CHEF_SPEC_DATA, 'knife-site-subcommands')) }
+  let(:home) { File.join(CHEF_SPEC_DATA, 'knife-home') }
+  let(:plugin_dir) { File.join(home, '.chef', 'plugins', 'knife') }
+  
   before do
     allow(Chef::Platform).to receive(:windows?) { false }
-    @home = File.join(CHEF_SPEC_DATA, 'knife-home')
-    @env = {'HOME' => @home}
-    @loader = Chef::Knife::SubcommandLoader.new(File.join(CHEF_SPEC_DATA, 'knife-site-subcommands'), @env)
+    Chef::Util::PathHelper.class_variable_set(:@@home_dir, home) 
+  end
+
+  after do
+    Chef::Util::PathHelper.class_variable_set(:@@home_dir, nil) 
   end
 
   it "builds a list of the core subcommand file require paths" do
-    expect(@loader.subcommand_files).not_to be_empty
-    @loader.subcommand_files.each do |require_path|
+    expect(loader.subcommand_files).not_to be_empty
+    loader.subcommand_files.each do |require_path|
       expect(require_path).to match(/chef\/knife\/.*|plugins\/knife\/.*/)
     end
   end
 
   it "finds files installed via rubygems" do
-    expect(@loader.find_subcommands_via_rubygems).to include('chef/knife/node_create')
-    @loader.find_subcommands_via_rubygems.each {|rel_path, abs_path| expect(abs_path).to match(%r[chef/knife/.+])}
+    expect(loader.find_subcommands_via_rubygems).to include('chef/knife/node_create')
+    loader.find_subcommands_via_rubygems.each {|rel_path, abs_path| expect(abs_path).to match(%r[chef/knife/.+])}
   end
 
   it "finds files from latest version of installed gems" do
@@ -54,23 +60,23 @@ describe Chef::Knife::SubcommandLoader do
       expect(gems[0]).to receive(:full_gem_path).and_return('/usr/lib/ruby/gems/knife-ec2-0.5.12')
       expect(Dir).to receive(:[]).with('/usr/lib/ruby/gems/knife-ec2-0.5.12/lib/chef/knife/*.rb').and_return(gem_files)
     end
-    expect(@loader).to receive(:find_subcommands_via_dirglob).and_return({})
-    expect(@loader.find_subcommands_via_rubygems.values.select { |file| file =~ /knife-ec2/ }.sort).to eq(gem_files)
+    expect(loader).to receive(:find_subcommands_via_dirglob).and_return({})
+    expect(loader.find_subcommands_via_rubygems.values.select { |file| file =~ /knife-ec2/ }.sort).to eq(gem_files)
   end
 
   it "finds files using a dirglob when rubygems is not available" do
-    expect(@loader.find_subcommands_via_dirglob).to include('chef/knife/node_create')
-    @loader.find_subcommands_via_dirglob.each {|rel_path, abs_path| expect(abs_path).to match(%r[chef/knife/.+])}
+    expect(loader.find_subcommands_via_dirglob).to include('chef/knife/node_create')
+    loader.find_subcommands_via_dirglob.each {|rel_path, abs_path| expect(abs_path).to match(%r[chef/knife/.+])}
   end
 
   it "finds user-specific subcommands in the user's ~/.chef directory" do
-    expected_command = File.join(@home, '.chef', 'plugins', 'knife', 'example_home_subcommand.rb')
-    expect(@loader.site_subcommands).to include(expected_command)
+    expected_command = File.join(home, '.chef', 'plugins', 'knife', 'example_home_subcommand.rb')
+    expect(loader.site_subcommands).to include(expected_command)
   end
 
   it "finds repo specific subcommands by searching for a .chef directory" do
     expected_command = File.join(CHEF_SPEC_DATA, 'knife-site-subcommands', 'plugins', 'knife', 'example_subcommand.rb')
-    expect(@loader.site_subcommands).to include(expected_command)
+    expect(loader.site_subcommands).to include(expected_command)
   end
 
   # https://github.com/opscode/chef-dk/issues/227
@@ -137,25 +143,19 @@ describe Chef::Knife::SubcommandLoader do
     end
 
     before do
-      expect(@loader).to receive(:find_files_latest_gems).with("chef/knife/*.rb").and_return(all_found_commands)
-      expect(@loader).to receive(:find_subcommands_via_dirglob).and_return({})
+      expect(loader).to receive(:find_files_latest_gems).with("chef/knife/*.rb").and_return(all_found_commands)
+      expect(loader).to receive(:find_subcommands_via_dirglob).and_return({})
     end
 
     it "ignores commands from the non-matching gem install" do
-      expect(@loader.find_subcommands_via_rubygems.values).to eq(expected_valid_commands)
+      expect(loader.find_subcommands_via_rubygems.values).to eq(expected_valid_commands)
     end
 
   end
 
   describe "finding 3rd party plugins" do
-    let(:env_home) { "/home/alice" }
-    let(:manifest_path) { env_home + "/.chef/plugin_manifest.json" }
-
-    before do
-      env_dup = ENV.to_hash
-      allow(ENV).to receive(:[]) { |key| env_dup[key] }
-      allow(ENV).to receive(:[]).with("HOME").and_return(env_home)
-    end
+    let(:home) { "/home/alice" }
+    let(:manifest_path) { home + "/.chef/plugin_manifest.json" }
 
     context "when there is not a ~/.chef/plugin_manifest.json file" do
       before do
@@ -168,14 +168,14 @@ describe Chef::Knife::SubcommandLoader do
         else
           expect(Gem.source_index).to receive(:latest_specs).and_call_original
         end
-        @loader.subcommand_files.each do |require_path|
+        loader.subcommand_files.each do |require_path|
           expect(require_path).to match(/chef\/knife\/.*|plugins\/knife\/.*/)
         end
       end
 
       context "and HOME environment variable is not set" do
         before do
-          allow(ENV).to receive(:[]).with("HOME").and_return(nil)
+          allow(Chef::Util::PathHelper).to receive(:home).and_return(nil)
         end
 
         it "searches rubygems for plugins" do
@@ -184,7 +184,7 @@ describe Chef::Knife::SubcommandLoader do
           else
             expect(Gem.source_index).to receive(:latest_specs).and_call_original
           end
-          @loader.subcommand_files.each do |require_path|
+          loader.subcommand_files.each do |require_path|
             expect(require_path).to match(/chef\/knife\/.*|plugins\/knife\/.*/)
           end
         end
@@ -215,7 +215,7 @@ describe Chef::Knife::SubcommandLoader do
 
       it "uses paths from the manifest instead of searching gems" do
         expect(Gem::Specification).not_to receive(:latest_specs).and_call_original
-        expect(@loader.subcommand_files).to include(ec2_server_create_plugin)
+        expect(loader.subcommand_files).to include(ec2_server_create_plugin)
       end
 
     end