chef 13.6.4 → 13.7.16

data/spec/unit/knife/data_bag_create_spec.rb

@@ -46,8 +46,8 @@ describe Chef::Knife::DataBagCreate do
     allow(knife).to receive(:config).and_return(config)
   end
 
-  context "when data_bag already exist" do
-    it "doesn't creates a data bag" do
+  context "when data_bag already exists" do
+    it "doesn't create a data bag" do
       expect(knife).to receive(:create_object).and_yield(raw_hash)
       expect(rest).to receive(:get).with("data/#{bag_name}")
       expect(rest).to_not receive(:post).with("data", { "name" => bag_name })
@@ -80,6 +80,27 @@ describe Chef::Knife::DataBagCreate do
       end
     end
 
+    context "when part of the name is a reserved name" do
+      before do
+        exception = double("404 error", :code => "404")
+        %w{node role client environment}.each do |name|
+          allow(rest).to receive(:get)
+            .with("data/sudoing_#{name}_admins")
+            .and_raise(Net::HTTPServerException.new("404", exception))
+        end
+      end
+
+      it "will create a data bag containing a reserved word" do
+        %w{node role client environment}.each do |name|
+          knife.name_args = ["sudoing_#{name}_admins"]
+          expect(rest).to receive(:post).with("data", { "name" => knife.name_args[0] })
+          expect(knife.ui).to receive(:info).with("Created data_bag[#{knife.name_args[0]}]")
+
+          knife.run
+        end
+      end
+    end
+
     context "when given one argument" do
       before do
         knife.name_args = [bag_name]
@@ -93,6 +114,23 @@ describe Chef::Knife::DataBagCreate do
       end
     end
 
+    context "when given a data bag name partially matching a reserved name for search" do
+      %w{xnode rolex xenvironmentx xclientx}.each do |name|
+        let(:bag_name) { name }
+
+        before do
+          knife.name_args = [bag_name]
+        end
+
+        it "creates a data bag named '#{name}'" do
+          expect(rest).to receive(:post).with("data", { "name" => bag_name })
+          expect(knife.ui).to receive(:info).with("Created data_bag[#{bag_name}]")
+
+          knife.run
+        end
+      end
+    end
+
     context "no secret is specified for encryption" do
       let(:item) do
         item = Chef::DataBagItem.from_hash(raw_hash)

data/spec/unit/knife/data_bag_show_spec.rb

@@ -91,12 +91,11 @@ qux: http://localhost:4000/data/bag_o_data/qux}
   context "Data bag to show is not encrypted" do
     before do
       allow(knife).to receive(:encrypted?).and_return(false)
-      expect(knife).to receive(:read_secret).exactly(0).times
     end
 
     it "displays the data bag" do
+      expect(knife).to receive(:read_secret).exactly(0).times
       expect(Chef::DataBagItem).to receive(:load).with(bag_name, item_name).and_return(data_bag)
-      expect(knife.ui).to receive(:warn).with("Unencrypted data bag detected, ignoring any provided secret options.")
 
       expected = %q{baz: http://localhost:4000/data/bag_o_data/baz
 id:  id
@@ -104,6 +103,21 @@ qux: http://localhost:4000/data/bag_o_data/qux}
       knife.run
       expect(stdout.string.strip).to eq(expected)
     end
+
+    context "when a secret is given" do
+      it "displays the data bag" do
+        expect(knife).to receive(:encryption_secret_provided_ignore_encrypt_flag?).and_return(true)
+        expect(knife).to receive(:read_secret).and_return(secret)
+        expect(Chef::DataBagItem).to receive(:load).with(bag_name, item_name).and_return(data_bag)
+        expect(knife.ui).to receive(:warn).with("Unencrypted data bag detected, ignoring any provided secret options.")
+
+        expected = %q{baz: http://localhost:4000/data/bag_o_data/baz
+id:  id
+qux: http://localhost:4000/data/bag_o_data/qux}
+        knife.run
+        expect(stdout.string.strip).to eq(expected)
+      end
+    end
   end
 
   it "displays the list of items in the data bag when only one @name_arg is provided" do

data/spec/unit/knife/ssh_spec.rb

@@ -49,28 +49,36 @@ describe Chef::Knife::Ssh do
 
       def self.should_return_specified_attributes
         it "returns an array of the attributes specified on the command line OR config file, if only one is set" do
-          @node_bar["config"] = "10.0.0.2"
-          @node_foo["config"] = "10.0.0.1"
-          @knife.config[:attribute] = "ipaddress"
+          @node_bar["target"] = "10.0.0.2"
+          @node_foo["target"] = "10.0.0.1"
+          @node_bar["prefix"] = "bar"
+          @node_foo["prefix"] = "foo"
+          @knife.config[:ssh_attribute] = "ipaddress"
+          @knife.config[:prefix_attribute] = "name"
           Chef::Config[:knife][:ssh_attribute] = "ipaddress" # this value will be in the config file
-          expect(@knife).to receive(:session_from_list).with([["10.0.0.1", nil], ["10.0.0.2", nil]])
+          Chef::Config[:knife][:prefix_attribute] = "name" # this value will be in the config file
+          expect(@knife).to receive(:session_from_list).with([["10.0.0.1", nil, "foo"], ["10.0.0.2", nil, "bar"]])
           @knife.configure_session
         end
 
         it "returns an array of the attributes specified on the command line even when a config value is set" do
-          @node_bar["config"] = "10.0.0.2"
-          @node_foo["config"] = "10.0.0.1"
+          @node_bar["target"] = "10.0.0.2"
+          @node_foo["target"] = "10.0.0.1"
+          @node_bar["prefix"] = "bar"
+          @node_foo["prefix"] = "foo"
           Chef::Config[:knife][:ssh_attribute] = "config_file" # this value will be in the config file
-          @knife.config[:attribute] = "ipaddress" # this is the value of the command line via #configure_attribute
-          expect(@knife).to receive(:session_from_list).with([["10.0.0.1", nil], ["10.0.0.2", nil]])
+          Chef::Config[:knife][:prefix_attribute] = "config_file" # this value will be in the config file
+          @knife.config[:ssh_attribute] = "ipaddress" # this is the value of the command line via #configure_attribute
+          @knife.config[:prefix_attribute] = "name" # this is the value of the command line via #configure_attribute
+          expect(@knife).to receive(:session_from_list).with([["10.0.0.1", nil, "foo"], ["10.0.0.2", nil, "bar"]])
           @knife.configure_session
         end
       end
 
-      it "searchs for and returns an array of fqdns" do
+      it "searches for and returns an array of fqdns" do
         expect(@knife).to receive(:session_from_list).with([
-          ["foo.example.org", nil],
-          ["bar.example.org", nil],
+          ["foo.example.org", nil, nil],
+          ["bar.example.org", nil, nil],
         ])
         @knife.configure_session
       end
@@ -84,8 +92,8 @@ describe Chef::Knife::Ssh do
         end
         it "returns an array of cloud public hostnames" do
           expect(@knife).to receive(:session_from_list).with([
-            ["ec2-10-0-0-1.compute-1.amazonaws.com", nil],
-            ["ec2-10-0-0-2.compute-1.amazonaws.com", nil],
+            ["ec2-10-0-0-1.compute-1.amazonaws.com", nil, nil],
+            ["ec2-10-0-0-2.compute-1.amazonaws.com", nil, nil],
           ])
           @knife.configure_session
         end
@@ -101,8 +109,8 @@ describe Chef::Knife::Ssh do
 
         it "returns an array of fqdns" do
           expect(@knife).to receive(:session_from_list).with([
-            ["foo.example.org", nil],
-            ["bar.example.org", nil],
+            ["foo.example.org", nil, nil],
+            ["bar.example.org", nil, nil],
           ])
           @knife.configure_session
         end
@@ -144,15 +152,35 @@ describe Chef::Knife::Ssh do
     end
   end
 
+  describe "#get_prefix_attribute" do
+    # Order of precedence for prefix
+    # 1) config value (cli or knife config)
+    # 2) nil
+    before do
+      Chef::Config[:knife][:prefix_attribute] = nil
+      @knife.config[:prefix_attribute] = nil
+      @node_foo["cloud"]["public_hostname"] = "ec2-10-0-0-1.compute-1.amazonaws.com"
+      @node_bar["cloud"]["public_hostname"] = ""
+    end
+
+    it "should return nil by default" do
+      expect(@knife.get_prefix_attribute({})).to eq(nil)
+    end
+
+    it "should favor config over nil" do
+      @node_foo["prefix"] = "config"
+      expect( @knife.get_prefix_attribute(@node_foo)).to eq("config")
+    end
+  end
+
   describe "#get_ssh_attribute" do
     # Order of precedence for ssh target
-    # 1) command line attribute
-    # 2) configuration file
-    # 3) cloud attribute
-    # 4) fqdn
+    # 1) config value (cli or knife config)
+    # 2) cloud attribute
+    # 3) fqdn
     before do
       Chef::Config[:knife][:ssh_attribute] = nil
-      @knife.config[:attribute] = nil
+      @knife.config[:ssh_attribute] = nil
       @node_foo["cloud"]["public_hostname"] = "ec2-10-0-0-1.compute-1.amazonaws.com"
       @node_bar["cloud"]["public_hostname"] = ""
     end
@@ -165,18 +193,9 @@ describe Chef::Knife::Ssh do
       expect(@knife.get_ssh_attribute(@node_foo)).to eq("ec2-10-0-0-1.compute-1.amazonaws.com")
     end
 
-    it "should favor to attribute_from_cli over config file and cloud" do
-      @knife.config[:attribute] = "command_line"
-      Chef::Config[:knife][:ssh_attribute] = "config_file"
-      @node_foo["config"] = "command_line"
-      @node_foo["knife_config"] = "config_file"
-      expect( @knife.get_ssh_attribute(@node_foo)).to eq("command_line")
-    end
-
-    it "should favor config file over cloud and default" do
-      Chef::Config[:knife][:ssh_attribute] = "config_file"
-      @node_foo["knife_config"] = "config_file"
-      expect( @knife.get_ssh_attribute(@node_foo)).to eq("config_file")
+    it "should favor config over cloud and default" do
+      @node_foo["target"] = "config"
+      expect( @knife.get_ssh_attribute(@node_foo)).to eq("config")
     end
 
     it "should return fqdn if cloud.hostname is empty" do
@@ -192,40 +211,50 @@ describe Chef::Knife::Ssh do
     end
 
     it "uses the port from an ssh config file" do
-      @knife.session_from_list([["the.b.org", nil]])
+      @knife.session_from_list([["the.b.org", nil, nil]])
       expect(@knife.session.servers[0].port).to eq(23)
     end
 
     it "uses the port from a cloud attr" do
-      @knife.session_from_list([["the.b.org", 123]])
+      @knife.session_from_list([["the.b.org", 123, nil]])
       expect(@knife.session.servers[0].port).to eq(123)
     end
 
+    it "uses the prefix from list" do
+      @knife.session_from_list([["the.b.org", nil, "b-team"]])
+      expect(@knife.session.servers[0][:prefix]).to eq("b-team")
+    end
+
+    it "defaults to a prefix of host" do
+      @knife.session_from_list([["the.b.org", nil, nil]])
+      expect(@knife.session.servers[0][:prefix]).to eq("the.b.org")
+    end
+
     it "defaults to a timeout of 120 seconds" do
-      @knife.session_from_list([["the.b.org", nil]])
+      @knife.session_from_list([["the.b.org", nil, nil]])
       expect(@knife.session.servers[0].options[:timeout]).to eq(120)
     end
 
     it "uses the timeout from Chef Config" do
       Chef::Config[:knife][:ssh_timeout] = 5
       @knife.config[:ssh_timeout] = nil
-      @knife.session_from_list([["the.b.org", nil]])
+      @knife.session_from_list([["the.b.org", nil, nil]])
       expect(@knife.session.servers[0].options[:timeout]).to eq(5)
     end
 
     it "uses the timeout from knife config" do
       @knife.config[:ssh_timeout] = 6
-      @knife.session_from_list([["the.b.org", nil]])
+      @knife.session_from_list([["the.b.org", nil, nil]])
       expect(@knife.session.servers[0].options[:timeout]).to eq(6)
     end
 
     it "uses the user from an ssh config file" do
-      @knife.session_from_list([["the.b.org", 123]])
+      @knife.session_from_list([["the.b.org", 123, nil]])
       expect(@knife.session.servers[0].user).to eq("locutus")
     end
 
     it "uses keepalive settings from an ssh config file" do
-      @knife.session_from_list([["the.b.org", 123]])
+      @knife.session_from_list([["the.b.org", 123, nil]])
       expect(@knife.session.servers[0].options[:keepalive]).to be true
       expect(@knife.session.servers[0].options[:keepalive_interval]).to eq 60
     end
@@ -295,6 +324,23 @@ describe Chef::Knife::Ssh do
     end
   end
 
+  describe "#tmux" do
+    before do
+      ssh_config = { :timeout => 50, :user => "locutus", :port => 23, :keepalive => true, :keepalive_interval => 60 }
+      allow(Net::SSH).to receive(:configuration_for).with("foo.example.org", true).and_return(ssh_config)
+      @query = Chef::Search::Query.new
+      expect(@query).to receive(:search).and_yield(@node_foo)
+      allow(Chef::Search::Query).to receive(:new).and_return(@query)
+      allow(@knife).to receive(:exec).and_return(0)
+    end
+
+    it "filters out invalid characters from tmux session name" do
+      @knife.name_args = ["name:foo.example.org", "tmux"]
+      expect(@knife).to receive(:shell_out!).with("tmux new-session -d -s 'knife ssh name=foo-example-org' -n 'foo.example.org' 'ssh locutus@foo.example.org' ")
+      @knife.run
+    end
+  end
+
   describe "#run" do
     before do
       @query = Chef::Search::Query.new

data/spec/unit/knife_spec.rb

@@ -47,6 +47,7 @@ describe Chef::Knife do
 
     allow(Chef::WorkstationConfigLoader).to receive(:new).and_return(config_loader)
     allow(config_loader).to receive(:explicit_config_file=)
+    allow(config_loader).to receive(:profile=)
 
     # Prevent gratuitous code reloading:
     allow(Chef::Knife).to receive(:load_commands)
@@ -331,6 +332,7 @@ describe Chef::Knife do
           knife.config[:config_file] = fake_config
           config_loader = double("Chef::WorkstationConfigLoader", :load => true, :no_config_found? => false, :chef_config_dir => "/etc/chef", :config_location => fake_config)
           allow(config_loader).to receive(:explicit_config_file=).with(fake_config).and_return(fake_config)
+          allow(config_loader).to receive(:profile=)
           allow(Chef::WorkstationConfigLoader).to receive(:new).and_return(config_loader)
         end
 

data/spec/unit/lwrp_spec.rb

@@ -571,14 +571,16 @@ describe "LWRP" do
 
   context "resource class created" do
     let(:test_lwrp_class) { @test_lwrp_class }
-    before(:context) do
-      @tmpdir = Dir.mktmpdir("lwrp_test")
+    before(:each) do
+      @tmpparent = Dir.mktmpdir("lwrp_test")
+      @tmpdir = File.join(@tmpparent, "lwrp")
+      Dir.mkdir(@tmpdir)
       resource_path = File.join(@tmpdir, "once.rb")
       IO.write(resource_path, "default_action :create")
       @test_lwrp_class = Chef::Resource::LWRPBase.build_from_file("lwrp", resource_path, nil)
     end
 
-    after(:context) do
+    after(:each) do
       FileUtils.remove_entry @tmpdir
     end
 

data/spec/unit/mixin/powershell_type_coercions_spec.rb

@@ -1,6 +1,6 @@
 #
 # Author:: Jay Mundrawala (<jdm@chef.io>)
-# Copyright:: Copyright 2015-2016, Chef Software, Inc.
+# Copyright:: Copyright 2015-2017, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -64,14 +64,15 @@ describe Chef::Mixin::PowershellTypeCoercions do
     end
 
     it "translates a Chef::Node::ImmutableMash like a hash" do
-      test_mash = Chef::Node::ImmutableMash.new({ "a" => 1, "b" => 1.2,
-                                                  "c" => false, "d" => true })
-      expect(test_class.translate_type(test_mash)).to eq("@{a=1;b=1.2;c=$false;d=$true}")
+      node = Chef::Node.new
+      node.default[:test] = { "a" => 1, "b" => 1.2, "c" => false, "d" => true }
+      expect(test_class.translate_type(node[:test])).to eq("@{a=1;b=1.2;c=$false;d=$true}")
     end
 
     it "translates a Chef::Node::ImmutableArray like an array" do
-      test_array = Chef::Node::ImmutableArray.new([true, false])
-      expect(test_class.translate_type(test_array)).to eq("@($true,$false)")
+      node = Chef::Node.new
+      node.default[:test] = [ true, false ]
+      expect(test_class.translate_type(node[:test])).to eq("@($true,$false)")
     end
 
     it "falls back :to_psobject if we have not defined at explicit rule" do

data/spec/unit/node/attribute_spec.rb

@@ -171,6 +171,7 @@ describe Chef::Node::Attribute do
     }
     @automatic_hash = { "week" => "friday" }
     @attributes = Chef::Node::Attribute.new(@attribute_hash, @default_hash, @override_hash, @automatic_hash, node)
+    allow(node).to receive(:attributes).and_return(@attributes)
   end
 
   describe "initialize" do
@@ -179,13 +180,14 @@ describe Chef::Node::Attribute do
     end
 
     it "should take an Automatioc, Normal, Default and Override hash" do
-      expect { Chef::Node::Attribute.new({}, {}, {}, {}) }.not_to raise_error
+      expect { Chef::Node::Attribute.new({}, {}, {}, {}, node) }.not_to raise_error
     end
 
     [ :normal, :default, :override, :automatic ].each do |accessor|
       it "should set #{accessor}" do
-        na = Chef::Node::Attribute.new({ :normal => true }, { :default => true }, { :override => true }, { :automatic => true })
-        expect(na.send(accessor)).to eq({ accessor.to_s => true })
+        @attributes = Chef::Node::Attribute.new({ :normal => true }, { :default => true }, { :override => true }, { :automatic => true }, node)
+        allow(node).to receive(:attributes).and_return(@attributes)
+        expect(@attributes.send(accessor)).to eq({ accessor.to_s => true })
       end
     end
 
@@ -330,7 +332,8 @@ describe Chef::Node::Attribute do
     end
 
     it "merges nested hashes between precedence levels" do
-      @attributes = Chef::Node::Attribute.new({}, {}, {}, {})
+      @attributes = Chef::Node::Attribute.new({}, {}, {}, {}, node)
+      allow(node).to receive(:attributes).and_return(@attributes)
       @attributes.env_default = { "a" => { "b" => { "default" => "default" } } }
       @attributes.normal = { "a" => { "b" => { "normal" => "normal" } } }
       @attributes.override = { "a" => { "override" => "role" } }
@@ -584,8 +587,10 @@ describe Chef::Node::Attribute do
           "one" => { "six" => "seven" },
           "snack" => "cookies",
         },
-        {}
+        {},
+        node
       )
+      allow(node).to receive(:attributes).and_return(@attributes)
     end
 
     it "should yield each top level key" do
@@ -632,8 +637,10 @@ describe Chef::Node::Attribute do
           "one" => "six",
           "snack" => "cookies",
         },
-        {}
+        {},
+        node
       )
+      allow(node).to receive(:attributes).and_return(@attributes)
     end
 
     it "should yield each top level key and value, post merge rules" do
@@ -670,8 +677,10 @@ describe Chef::Node::Attribute do
           "one" => "six",
           "snack" => "cookies",
         },
-        {}
+        {},
+        node
       )
+      allow(node).to receive(:attributes).and_return(@attributes)
     end
 
     it "should respond to each_key" do
@@ -706,8 +715,10 @@ describe Chef::Node::Attribute do
           "one" => "six",
           "snack" => "cookies",
         },
-        {}
+        {},
+        node
       )
+      allow(node).to receive(:attributes).and_return(@attributes)
     end
 
     it "should respond to each_pair" do
@@ -742,8 +753,10 @@ describe Chef::Node::Attribute do
           "one" => "six",
           "snack" => "cookies",
         },
-        {}
+        {},
+        node
       )
+      allow(node).to receive(:attributes).and_return(@attributes)
     end
 
     it "should respond to each_value" do
@@ -786,9 +799,10 @@ describe Chef::Node::Attribute do
           "one" => "six",
           "snack" => "cookies",
         },
-        {}
+        {},
+        node
       )
-      @empty = Chef::Node::Attribute.new({}, {}, {}, {})
+      allow(node).to receive(:attributes).and_return(@attributes)
     end
 
     it "should respond to empty?" do
@@ -796,7 +810,9 @@ describe Chef::Node::Attribute do
     end
 
     it "should return true when there are no keys" do
-      expect(@empty.empty?).to eq(true)
+      @attributes = Chef::Node::Attribute.new({}, {}, {}, {}, node)
+      allow(node).to receive(:attributes).and_return(@attributes)
+      expect(@attributes.empty?).to eq(true)
     end
 
     it "should return false when there are keys" do
@@ -820,8 +836,10 @@ describe Chef::Node::Attribute do
           "one" => "six",
           "snack" => "cookies",
         },
-        {}
+        {},
+        node
       )
+      allow(node).to receive(:attributes).and_return(@attributes)
     end
 
     it "should respond to fetch" do
@@ -877,8 +895,10 @@ describe Chef::Node::Attribute do
           "one" => "six",
           "snack" => "cookies",
         },
-        {}
+        {},
+        node
       )
+      allow(node).to receive(:attributes).and_return(@attributes)
     end
 
     it "should respond to has_value?" do
@@ -922,8 +942,10 @@ describe Chef::Node::Attribute do
           "one" => "six",
           "snack" => "cookies",
         },
-        {}
+        {},
+        node
       )
+      allow(node).to receive(:attributes).and_return(@attributes)
     end
 
     it "should respond to index" do
@@ -963,8 +985,10 @@ describe Chef::Node::Attribute do
           "one" => "six",
           "snack" => "cookies",
         },
-        {}
+        {},
+        node
       )
+      allow(node).to receive(:attributes).and_return(@attributes)
     end
 
     it "should respond to values" do
@@ -999,8 +1023,10 @@ describe Chef::Node::Attribute do
           "one" => "six",
           "snack" => "cookies",
         },
-        {}
+        {},
+        node
       )
+      allow(node).to receive(:attributes).and_return(@attributes)
     end
 
     it "should respond to select" do
@@ -1049,10 +1075,11 @@ describe Chef::Node::Attribute do
           "one" => "six",
           "snack" => "cookies",
         },
-        {}
+        {},
+        node
       )
+      allow(node).to receive(:attributes).and_return(@attributes)
 
-      @empty = Chef::Node::Attribute.new({}, {}, {}, {})
     end
 
     it "should respond to size" do
@@ -1064,7 +1091,9 @@ describe Chef::Node::Attribute do
     end
 
     it "should return 0 for an empty attribute" do
-      expect(@empty.size).to eq(0)
+      @attributes = Chef::Node::Attribute.new({}, {}, {}, {}, node)
+      allow(node).to receive(:attributes).and_return(@attributes)
+      expect(@attributes.size).to eq(0)
     end
 
     it "should return the number of pairs" do
@@ -1092,8 +1121,9 @@ describe Chef::Node::Attribute do
 
   describe "to_s" do
     it "should output simple attributes" do
-      attributes = Chef::Node::Attribute.new(nil, nil, nil, nil)
-      expect(attributes.to_s).to eq("{}")
+      @attributes = Chef::Node::Attribute.new(nil, nil, nil, nil, node)
+      allow(node).to receive(:attributes).and_return(@attributes)
+      expect(@attributes.to_s).to eq("{}")
     end
 
     it "should output merged attributes" do
@@ -1105,8 +1135,9 @@ describe Chef::Node::Attribute do
           "b" => 3,
           "c" => 4,
       }
-      attributes = Chef::Node::Attribute.new(nil, default_hash, override_hash, nil)
-      expect(attributes.to_s).to eq('{"a"=>1, "b"=>3, "c"=>4}')
+      @attributes = Chef::Node::Attribute.new(nil, default_hash, override_hash, nil, node)
+      allow(node).to receive(:attributes).and_return(@attributes)
+      expect(@attributes.to_s).to eq('{"b"=>3, "c"=>4, "a"=>1}')
     end
   end