chef 12.0.0.alpha.0-x86-mingw32 → 12.0.0.alpha.1-x86-mingw32

data/spec/unit/knife/cookbook_site_download_spec.rb

@@ -26,7 +26,7 @@ describe Chef::Knife::CookbookSiteDownload do
       @knife.name_args  = ['apache2']
       @noauth_rest      = double('no auth rest')
       @stderr           = StringIO.new
-      @cookbook_api_url = 'http://cookbooks.opscode.com/api/v1/cookbooks'
+      @cookbook_api_url = 'https://supermarket.getchef.com/api/v1/cookbooks'
       @version          = '1.0.2'
       @version_us       = @version.gsub '.', '_'
       @current_data     = { 'deprecated'       => false,

data/spec/unit/knife/cookbook_site_share_spec.rb

@@ -108,11 +108,11 @@ describe Chef::Knife::CookbookSiteShare do
       File.stub(:open).and_return(true)
     end
 
-    it 'should post the cookbook to "http://cookbooks.opscode.com"' do
-      response_text = {:uri => 'http://cookbooks.opscode.com/cookbooks/cookbook_name'}.to_json
+    it 'should post the cookbook to "https://supermarket.getchef.com"' do
+      response_text = {:uri => 'https://supermarket.getchef.com/cookbooks/cookbook_name'}.to_json
       @upload_response.stub(:body).and_return(response_text)
       @upload_response.stub(:code).and_return(201)
-      Chef::CookbookSiteStreamingUploader.should_receive(:post).with(/cookbooks\.opscode\.com/, anything(), anything(), anything())
+      Chef::CookbookSiteStreamingUploader.should_receive(:post).with(/supermarket\.getchef\.com/, anything(), anything(), anything())
       @knife.run
     end
 

data/spec/unit/knife/data_bag_from_file_spec.rb

@@ -21,7 +21,6 @@ require 'spec_helper'
 require 'chef/data_bag_item'
 require 'chef/encrypted_data_bag_item'
 require 'tempfile'
-require 'json'
 
 Chef::Knife::DataBagFromFile.load_deps
 
@@ -86,7 +85,6 @@ describe Chef::Knife::DataBagFromFile do
   end
 
   it "loads all from a folder and saves" do
-    dir = File.dirname(@db_file.path)
     @knife.name_args = [ 'bag_name', @db_folder ]
     @knife.loader.should_receive(:load_from).with("data_bags", 'bag_name', @db_file.path).and_return(@plain_data)
     @knife.loader.should_receive(:load_from).with("data_bags", 'bag_name', @db_file2.path).and_return(@plain_data)

data/spec/unit/knife/data_bag_show_spec.rb

@@ -30,9 +30,9 @@ describe Chef::Knife::DataBagShow do
     @knife = Chef::Knife::DataBagShow.new
     @knife.config[:format] = 'json'
     @rest = double("Chef::REST")
-    @knife.stub(:rest).and_return(@rest)
+    allow(@knife).to receive(:rest).and_return(@rest)
     @stdout = StringIO.new
-    @knife.ui.stub(:stdout).and_return(@stdout)
+    allow(@knife.ui).to receive(:stdout).and_return(@stdout)
   end
 
 
@@ -40,24 +40,33 @@ describe Chef::Knife::DataBagShow do
     @knife.instance_variable_set(:@name_args, ['bag_o_data'])
     data_bag_contents = { "baz"=>"http://localhost:4000/data/bag_o_data/baz",
       "qux"=>"http://localhost:4000/data/bag_o_data/qux"}
-    Chef::DataBag.should_receive(:load).and_return(data_bag_contents)
+    expect(Chef::DataBag).to receive(:load).and_return(data_bag_contents)
     expected = %q|[
   "baz",
   "qux"
 ]|
     @knife.run
-    @stdout.string.strip.should == expected
+    expect(@stdout.string.strip).to eq(expected)
   end
 
   it "prints the contents of the data bag item when given a bag and item name" do
     @knife.instance_variable_set(:@name_args, ['bag_o_data', 'an_item'])
     data_item = Chef::DataBagItem.new.tap {|item| item.raw_data = {"id" => "an_item", "zsh" => "victory_through_tabbing"}}
 
-    Chef::DataBagItem.should_receive(:load).with('bag_o_data', 'an_item').and_return(data_item)
+    expect(Chef::DataBagItem).to receive(:load).with('bag_o_data', 'an_item').and_return(data_item)
 
     @knife.run
-    Chef::JSONCompat.from_json(@stdout.string).should == data_item.raw_data
+    expect(Chef::JSONCompat.from_json(@stdout.string)).to eq(data_item.raw_data)
+  end
+
+  it "should pretty print the data bag contents" do
+    @knife.instance_variable_set(:@name_args, ['bag_o_data', 'an_item'])
+    data_item = Chef::DataBagItem.new.tap {|item| item.raw_data = {"id" => "an_item", "zsh" => "victory_through_tabbing"}}
+
+    expect(Chef::DataBagItem).to receive(:load).with('bag_o_data', 'an_item').and_return(data_item)
 
+    @knife.run
+    expect(@stdout.string).to eql("{\n  \"id\": \"an_item\",\n  \"zsh\": \"victory_through_tabbing\"\n}\n")
   end
 
   describe "encrypted data bag items" do
@@ -83,29 +92,29 @@ describe Chef::Knife::DataBagShow do
     end
 
     it "prints the decrypted contents of an item when given --secret" do
-      @knife.stub(:config).and_return({:secret => @secret})
-      Chef::EncryptedDataBagItem.should_receive(:load).
+      allow(@knife).to receive(:config).and_return({:secret => @secret})
+      expect(Chef::EncryptedDataBagItem).to receive(:load).
         with('bag_name', 'item_name', @secret).
         and_return(Chef::EncryptedDataBagItem.new(@enc_data, @secret))
       @knife.run
-      Chef::JSONCompat.from_json(@stdout.string).should == @plain_data
+      expect(Chef::JSONCompat.from_json(@stdout.string)).to eq(@plain_data)
     end
 
     it "prints the decrypted contents of an item when given --secret_file" do
-      @knife.stub(:config).and_return({:secret_file => @secret_file.path})
-      Chef::EncryptedDataBagItem.should_receive(:load).
+      allow(@knife).to receive(:config).and_return({:secret_file => @secret_file.path})
+      expect(Chef::EncryptedDataBagItem).to receive(:load).
         with('bag_name', 'item_name', @secret).
         and_return(Chef::EncryptedDataBagItem.new(@enc_data, @secret))
       @knife.run
-      Chef::JSONCompat.from_json(@stdout.string).should == @plain_data
+      expect(Chef::JSONCompat.from_json(@stdout.string)).to eq(@plain_data)
     end
   end
 
   describe "command line parsing" do
     it "prints help if given no arguments" do
       @knife.instance_variable_set(:@name_args, [])
-      lambda { @knife.run }.should raise_error(SystemExit)
-      @stdout.string.should match(/^knife data bag show BAG \[ITEM\] \(options\)/)
+      expect { @knife.run }.to raise_error(SystemExit)
+      expect(@stdout.string).to match(/^knife data bag show BAG \[ITEM\] \(options\)/)
     end
   end
 

data/spec/unit/knife/node_show_spec.rb

@@ -19,30 +19,47 @@
 require 'spec_helper'
 
 describe Chef::Knife::NodeShow do
+
+  let(:node) do
+    node = Chef::Node.new()
+    node.name("adam")
+    node.run_list = ['role[base]']
+    node
+  end
+
+  let(:knife) do
+    knife = Chef::Knife::NodeShow.new
+    knife.name_args = [ "adam" ]
+    knife
+  end
+
   before(:each) do
     Chef::Config[:node_name]  = "webmonkey.example.com"
-    @knife = Chef::Knife::NodeShow.new
-    @knife.config = {
-      :attribute => nil,
-      :run_list => nil,
-      :environment => nil
-    }
-    @knife.name_args = [ "adam" ]
-    @knife.stub(:output).and_return(true)
-    @node = Chef::Node.new()
-    Chef::Node.stub(:load).and_return(@node)
   end
 
   describe "run" do
     it "should load the node" do
-      Chef::Node.should_receive(:load).with("adam").and_return(@node)
-      @knife.run
+      expect(Chef::Node).to receive(:load).with("adam").and_return(node)
+      allow(knife).to receive(:output).and_return(true)
+      knife.run
     end
 
     it "should pretty print the node, formatted for display" do
-      @knife.should_receive(:format_for_display).with(@node).and_return("poop")
-      @knife.should_receive(:output).with("poop")
-      @knife.run
+      knife.config[:format] = nil
+      stdout = StringIO.new
+      allow(knife.ui).to receive(:stdout).and_return(stdout)
+      allow(Chef::Node).to receive(:load).and_return(node)
+      knife.run
+      expect(stdout.string).to eql("Node Name:   adam\nEnvironment: _default\nFQDN:        \nIP:          \nRun List:    \nRoles:       \nRecipes:     \nPlatform:     \nTags:        \n")
+    end
+
+    it "should pretty print json" do
+      knife.config[:format] = 'json'
+      stdout = StringIO.new
+      allow(knife.ui).to receive(:stdout).and_return(stdout)
+      expect(Chef::Node).to receive(:load).with('adam').and_return(node)
+      knife.run
+      expect(stdout.string).to eql("{\n  \"name\": \"adam\",\n  \"chef_environment\": \"_default\",\n  \"run_list\": [\n\n]\n,\n  \"normal\": {\n\n  }\n}\n")
     end
   end
 end

data/spec/unit/knife/role_show_spec.rb

@@ -0,0 +1,59 @@
+#
+# Author:: Lamont Granquist (<lamont@getchef.com>)
+# Copyright:: Copyright (c) 2014 Lamont Granquist
+# 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'
+
+describe Chef::Knife::RoleShow do
+  let(:role) { 'base' }
+
+  let(:knife) do
+    knife = Chef::Knife::RoleShow.new
+    knife.name_args = [ role ]
+    knife
+  end
+
+  let(:role_mock) { double('role_mock') }
+
+  describe 'run' do
+    it 'should list the role' do
+      expect(Chef::Role).to receive(:load).with('base').and_return(role_mock)
+      expect(knife).to receive(:format_for_display).with(role_mock)
+      knife.run
+    end
+
+    it 'should pretty print json' do
+      knife.config[:format] = 'json'
+      stdout = StringIO.new
+      allow(knife.ui).to receive(:stdout).and_return(stdout)
+      fake_role_contents = {"foo"=>"bar", "baz"=>"qux"}
+      expect(Chef::Role).to receive(:load).with('base').and_return(fake_role_contents)
+      knife.run
+      expect(stdout.string).to eql("{\n  \"foo\": \"bar\",\n  \"baz\": \"qux\"\n}\n")
+    end
+
+    context "without a role name" do
+      let(:role) { }
+
+      it 'should print usage and exit when a role name is not provided' do
+        expect(knife).to receive(:show_usage)
+        expect(knife.ui).to receive(:fatal)
+        expect { knife.run }.to raise_error(SystemExit)
+      end
+    end
+  end
+end

data/spec/unit/platform_spec.rb

@@ -254,6 +254,16 @@ describe Chef::Platform do
 
     end
 
+    it "does not overwrite the platform map when using :default platform" do
+      Chef::Platform.set(
+        :resource => :file,
+        :platform => :default,
+        :provider => "new school"
+      )
+      Chef::Platform.platforms[:default][:file].should eql("new school")
+      Chef::Platform.platforms[:default][:cat].should eql("nice")
+    end
+
   end
 
   context "while testing the configured platform data" do

data/spec/unit/provider/deploy_spec.rb

@@ -192,6 +192,7 @@ describe Chef::Provider::Deploy do
       FileUtils.should_receive(:rm_rf).with("/my/deploy/dir/releases/5")
       @provider.run_action(:rollback)
       @provider.release_path.should eql("/my/deploy/dir/releases/3")
+      @provider.shared_path.should eql("/my/deploy/dir/shared")
     end
 
     it "sets the release path to the specified release, symlinks, and rm's any newer releases on rollback" do
@@ -203,6 +204,7 @@ describe Chef::Provider::Deploy do
       FileUtils.should_receive(:rm_rf).with("/my/deploy/dir/releases/20040815162342")
       @provider.run_action(:rollback)
       @provider.release_path.should eql("/my/deploy/dir/releases/20040700000000")
+      @provider.shared_path.should eql("/my/deploy/dir/shared")
     end
 
     it "sets the release path to the penultimate release, symlinks, and rm's the last release on rollback" do
@@ -216,6 +218,7 @@ describe Chef::Provider::Deploy do
       FileUtils.should_receive(:rm_rf).with("/my/deploy/dir/releases/20040815162342")
       @provider.run_action(:rollback)
       @provider.release_path.should eql("/my/deploy/dir/releases/20040700000000")
+      @provider.shared_path.should eql("/my/deploy/dir/shared")
     end
 
     describe "if there are no releases to fallback to" do
@@ -255,6 +258,7 @@ describe Chef::Provider::Deploy do
       FileUtils.should_receive(:rm_rf).with("/my/deploy/dir/releases/20040815162342")
       @provider.run_action(:rollback)
       @provider.release_path.should eql("/my/deploy/dir/releases/20040700000000")
+      @provider.shared_path.should eql("/my/deploy/dir/shared")
     end
   end
 

data/spec/unit/provider/env_spec.rb

@@ -229,4 +229,23 @@ describe Chef::Provider::Env do
       @provider.compare_value.should be_true
     end
   end
+
+  describe "modify_env" do
+    before(:each) do
+      @provider.stub(:create_env).and_return(true)
+      @new_resource.delim ";"
+
+      @current_resource = Chef::Resource::Env.new("FOO")
+      @current_resource.value "C:/foo/bin"
+      @provider.current_resource = @current_resource
+    end
+
+    it "should not modify the variable passed to the resource" do
+      new_value = "C:/bar/bin"
+      passed_value = new_value.dup
+      @new_resource.value(passed_value)
+      @provider.modify_env
+      passed_value.should == new_value
+    end
+  end
 end

data/spec/unit/provider/git_spec.rb

@@ -195,6 +195,26 @@ SHAS
         @provider.clone
       end
     end
+    context "with a specific home" do
+      let (:override_home) do
+        {"HOME" => "/home/masterNinja"}
+      end
+      let(:overrided_options) do
+        {
+          :user => deploy_user,
+          :environment => { "GIT_SSH" => wrapper, "HOME" => "/home/masterNinja" },
+          :log_tag => "git[web2.0 app]"
+        }
+      end
+      before do
+        @resource.environment(override_home)
+      end
+      before { @resource.environment(override_home) }
+      it "clones a repo with amended git options with specific home" do
+        @provider.should_receive(:shell_out!).with(expected_cmd, overrided_options)
+        @provider.clone
+      end
+    end
   end
 
   it "runs a clone command with escaped destination" do
@@ -224,8 +244,8 @@ SHAS
     @provider.clone
   end
 
-  it "runs a checkout command with default options" do
-    expected_cmd = 'git checkout -b deploy d35af14d41ae22b19da05d7d03a0bafc321b244c'
+  it "runs a checkout command with default options and uses -B to reset branches if necessary" do
+    expected_cmd = 'git checkout -B deploy d35af14d41ae22b19da05d7d03a0bafc321b244c'
     @provider.should_receive(:shell_out!).with(expected_cmd, :cwd => "/my/deploy/dir",
                                                              :log_tag => "git[web2.0 app]")
     @provider.checkout

data/spec/unit/provider/group/dscl_spec.rb

@@ -240,6 +240,7 @@ describe Chef::Provider::Group::Dscl do
       @provider.load_current_resource
       @provider.define_resource_requirements
     end
+
     it "raises an error if the required binary /usr/bin/dscl doesn't exist" do
       File.should_receive(:exists?).with("/usr/bin/dscl").and_return(false)
 
@@ -251,7 +252,7 @@ describe Chef::Provider::Group::Dscl do
       lambda { @provider.process_resource_requirements }.should_not raise_error
     end
   end
-
+ 
   describe "when creating the group" do
     it "creates the group, password field, gid, and sets group membership" do
       @provider.should_receive(:set_gid).and_return(true)
@@ -294,3 +295,39 @@ describe Chef::Provider::Group::Dscl do
     end
   end
 end
+
+describe 'Test DSCL loading' do
+  before do
+    @node = Chef::Node.new
+    @events = Chef::EventDispatch::Dispatcher.new
+    @run_context = Chef::RunContext.new(@node, {}, @events)
+    @new_resource = Chef::Resource::Group.new("aj")
+    @provider = Chef::Provider::Group::Dscl.new(@new_resource, @run_context)
+    @output = <<-EOF
+AppleMetaNodeLocation: /Local/Default
+Comment:
+ Test Group
+GeneratedUID: AAAAAAAA-AAAA-AAAA-AAAA-AAAAAAAAAAAA
+NestedGroups: AAAAAAAA-AAAA-AAAA-AAAA-AAAAAAAAAAAB
+Password: *
+PrimaryGroupID: 999
+RealName:
+ TestGroup
+RecordName: com.apple.aj
+RecordType: dsRecTypeStandard:Groups
+GroupMembership: waka bar
+EOF
+    @provider.stub(:safe_dscl).with("read /Groups/aj").and_return(@output)
+    @current_resource = @provider.load_current_resource
+
+  end
+
+  it 'should parse gid properly' do
+    File.stub(:exists?).and_return(true)
+    @current_resource.gid.should eq("999")
+  end
+  it 'should parse members properly' do
+    File.stub(:exists?).and_return(true)
+    @current_resource.members.should eq(['waka', 'bar'])
+  end
+end

data/spec/unit/provider/group/pw_spec.rb

@@ -49,7 +49,7 @@ describe Chef::Provider::Group::Pw do
   describe "when creating a group" do
     it "should run pw groupadd with the return of set_options and set_members_option" do
       @new_resource.gid(23)
-      @provider.should_receive(:run_command).with({ :command => "pw groupadd wheel -g '23'" }).and_return(true)
+      @provider.should_receive(:run_command).with({ :command => "pw groupadd wheel -g '23' -M root,aj" }).and_return(true)
       @provider.create_group
     end
   end
@@ -113,7 +113,7 @@ describe Chef::Provider::Group::Pw do
         @provider.set_members_options
       end
 
-      it "should set the -M option with the members joined by ','" do
+      it "should set the -m option with the members joined by ','" do
         @provider.set_members_options.should eql([ " -m all,your,base" ])
       end
     end

data/spec/unit/provider/http_request_spec.rb

@@ -53,13 +53,13 @@ describe Chef::Provider::HttpRequest do
 
       it "should inflate a message block at runtime" do
         @new_resource.message { "return" }
-        @http.should_receive(:get).with("http://www.opscode.com/?message=return", {})
+        @http.should_receive(:get).with("http://www.opscode.com/", {})
         @provider.run_action(:get)
         @new_resource.should be_updated
       end
 
       it "should run a GET request" do
-        @http.should_receive(:get).with("http://www.opscode.com/?message=is cool", {})
+        @http.should_receive(:get).with("http://www.opscode.com/", {})
         @provider.run_action(:get)
         @new_resource.should be_updated
       end
@@ -112,25 +112,25 @@ describe Chef::Provider::HttpRequest do
 
       it "should inflate a message block at runtime" do
         @new_resource.message { "return" }
-        @http.should_receive(:head).with("http://www.opscode.com/?message=return", {}).and_return(nil)
+        @http.should_receive(:head).with("http://www.opscode.com/", {}).and_return(nil)
         @provider.run_action(:head)
         @new_resource.should be_updated
       end
 
       it "should run a HEAD request" do
-        @http.should_receive(:head).with("http://www.opscode.com/?message=is cool", {}).and_return(nil)
+        @http.should_receive(:head).with("http://www.opscode.com/", {}).and_return(nil)
         @provider.run_action(:head)
         @new_resource.should be_updated
       end
 
       it "should update a HEAD request with empty string response body (CHEF-4762)" do
-        @http.should_receive(:head).with("http://www.opscode.com/?message=is cool", {}).and_return("")
+        @http.should_receive(:head).with("http://www.opscode.com/", {}).and_return("")
         @provider.run_action(:head)
         @new_resource.should be_updated
       end
 
       it "should update a HEAD request with nil response body (CHEF-4762)" do
-        @http.should_receive(:head).with("http://www.opscode.com/?message=is cool", {}).and_return(nil)
+        @http.should_receive(:head).with("http://www.opscode.com/", {}).and_return(nil)
         @provider.run_action(:head)
         @new_resource.should be_updated
       end
@@ -138,14 +138,14 @@ describe Chef::Provider::HttpRequest do
       it "should not update a HEAD request if a not modified response (CHEF-4762)" do
         if_modified_since = File.mtime(__FILE__).httpdate
         @new_resource.headers "If-Modified-Since" => if_modified_since
-        @http.should_receive(:head).with("http://www.opscode.com/?message=is cool", {"If-Modified-Since" => if_modified_since}).and_return(false)
+        @http.should_receive(:head).with("http://www.opscode.com/", {"If-Modified-Since" => if_modified_since}).and_return(false)
         @provider.run_action(:head)
         @new_resource.should_not be_updated
       end
 
       it "should run a HEAD request with If-Modified-Since header" do
         @new_resource.headers "If-Modified-Since" => File.mtime(__FILE__).httpdate
-        @http.should_receive(:head).with("http://www.opscode.com/?message=is cool", @new_resource.headers)
+        @http.should_receive(:head).with("http://www.opscode.com/", @new_resource.headers)
         @provider.run_action(:head)
       end