chef 10.12.0 → 10.14.0.beta.1

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

@@ -0,0 +1,160 @@
+#
+# Author:: Adam Jacob (<adam@opscode.com>)
+# Author:: Tim Hinderliter (<tim@opscode.com>)
+# Author:: Daniel DeLeo (<dan@opscode.com>)
+# Copyright:: Copyright (c) 2008, 2011 Opscode, 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'
+
+describe Chef::Knife::UI do
+  before do
+    @out, @err, @in = StringIO.new, StringIO.new, StringIO.new
+    @config = {}
+    @ui = Chef::Knife::UI.new(@out, @err, @in, @config)
+  end
+
+  describe "format_list_for_display" do
+    it "should print the full hash if --with-uri is true" do
+      @ui.config[:with_uri] = true
+      @ui.format_list_for_display({ :marcy => :playground }).should == { :marcy => :playground }
+    end
+
+    it "should print only the keys if --with-uri is false" do
+      @ui.config[:with_uri] = false
+      @ui.format_list_for_display({ :marcy => :playground }).should == [ :marcy ]
+    end
+  end
+
+  describe "format_for_display" do
+    it "should return the raw data" do
+      input = { :gi => :go }
+      @ui.format_for_display(input).should == input
+    end
+
+    describe "with --attribute passed" do
+      it "should return the deeply nested attribute" do
+        input = { "gi" => { "go" => "ge" } }
+        @ui.config[:attribute] = "gi.go"
+        @ui.format_for_display(input).should == { "gi.go" => "ge" }
+      end
+    end
+
+    describe "with --run-list passed" do
+      it "should return the run list" do
+        input = Chef::Node.new
+        input.run_list("role[monkey]", "role[churchmouse]")
+        @ui.config[:run_list] = true
+        response = @ui.format_for_display(input)
+        response["run_list"][0].should == "role[monkey]"
+        response["run_list"][1].should == "role[churchmouse]"
+      end
+    end
+  end
+
+  describe "format_cookbook_list_for_display" do
+    before(:each) do
+      @item = {
+        "cookbook_name" => {
+          "url" => "http://url/cookbooks/cookbook",
+          "versions" => [
+            { "version" => "3.0.0", "url" => "http://url/cookbooks/3.0.0" },
+            { "version" => "2.0.0", "url" => "http://url/cookbooks/2.0.0" },
+            { "version" => "1.0.0", "url" => "http://url/cookbooks/1.0.0" }
+          ]
+        }
+      }
+    end
+
+    it "should return an array of the cookbooks with versions" do
+      expected_response = [ "cookbook_name   3.0.0  2.0.0  1.0.0" ]
+      response = @ui.format_cookbook_list_for_display(@item)
+      response.should == expected_response
+    end
+
+    describe "with --with-uri" do
+      it "should return the URIs" do
+        response = {
+          "cookbook_name"=>{
+            "1.0.0" => "http://url/cookbooks/1.0.0", 
+            "2.0.0" => "http://url/cookbooks/2.0.0", 
+            "3.0.0" => "http://url/cookbooks/3.0.0"}
+        }
+        @ui.config[:with_uri] = true
+        @ui.format_cookbook_list_for_display(@item).should == response
+      end
+    end
+  end
+
+  describe "confirm" do
+    before(:each) do
+      @question = "monkeys rule"
+      @stdout = StringIO.new
+      @ui.stub(:stdout).and_return(@stdout)
+      @ui.stdin.stub!(:readline).and_return("y")
+    end
+
+    it "should return true if you answer Y" do
+      @ui.stdin.stub!(:readline).and_return("Y")
+      @ui.confirm(@question).should == true
+    end
+
+    it "should return true if you answer y" do
+      @ui.stdin.stub!(:readline).and_return("y")
+      @ui.confirm(@question).should == true
+    end
+
+    it "should exit 3 if you answer N" do
+      @ui.stdin.stub!(:readline).and_return("N")
+      lambda {
+        @ui.confirm(@question)
+      }.should raise_error(SystemExit) { |e| e.status.should == 3 }
+    end
+
+    it "should exit 3 if you answer n" do
+      @ui.stdin.stub!(:readline).and_return("n")
+      lambda {
+        @ui.confirm(@question)
+      }.should raise_error(SystemExit) { |e| e.status.should == 3 }
+    end
+
+    describe "with --y or --yes passed" do
+      it "should return true" do
+        @ui.config[:yes] = true
+        @ui.confirm(@question).should == true
+      end
+    end
+
+    describe "when asking for free-form user input" do
+      it "asks a question and returns the answer provided by the user" do
+        out = StringIO.new
+        @ui.stub!(:stdout).and_return(out)
+        @ui.stub!(:stdin).and_return(StringIO.new("http://mychefserver.example.com\n"))
+        @ui.ask_question("your chef server URL?").should == "http://mychefserver.example.com"
+        out.string.should == "your chef server URL?"
+      end
+
+      it "suggests a default setting and returns the default when the user's response only contains whitespace" do
+        out = StringIO.new
+        @ui.stub!(:stdout).and_return(out)
+        @ui.stub!(:stdin).and_return(StringIO.new(" \n"))
+        @ui.ask_question("your chef server URL? ", :default => 'http://localhost:4000').should == "http://localhost:4000"
+        out.string.should == "your chef server URL? [http://localhost:4000] "
+      end
+    end
+
+  end
+end

data/spec/unit/knife/data_bag_create_spec.rb

@@ -0,0 +1,96 @@
+#
+# Author:: Daniel DeLeo (<dan@opscode.com>)
+# Author:: Seth Falcon (<seth@opscode.com>)
+# Copyright:: Copyright (c) 2009-2010 Opscode, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'spec_helper'
+require 'tempfile'
+
+module ChefSpecs
+  class ChefRest
+    attr_reader :args_received
+    def initialize
+      @args_received = []
+    end
+
+    def post_rest(*args)
+      @args_received << args
+    end
+  end
+end
+
+
+describe Chef::Knife::DataBagCreate do
+  before do
+    Chef::Config[:node_name]  = "webmonkey.example.com"
+    @knife = Chef::Knife::DataBagCreate.new
+    @rest = ChefSpecs::ChefRest.new
+    @knife.stub!(:rest).and_return(@rest)
+    @stdout = StringIO.new
+    @knife.ui.stub!(:stdout).and_return(@stdout)
+  end
+
+
+  it "creates a data bag when given one argument" do
+    @knife.name_args = ['sudoing_admins']
+    @rest.should_receive(:post_rest).with("data", {"name" => "sudoing_admins"})
+    @knife.ui.should_receive(:info).with("Created data_bag[sudoing_admins]")
+
+    @knife.run
+  end
+
+  it "creates a data bag item when given two arguments" do
+    @knife.name_args = ['sudoing_admins', 'ME']
+    user_supplied_hash = {"login_name" => "alphaomega", "id" => "ME"}
+    data_bag_item = Chef::DataBagItem.from_hash(user_supplied_hash)
+    data_bag_item.data_bag("sudoing_admins")
+    @knife.should_receive(:create_object).and_yield(user_supplied_hash)
+    @rest.should_receive(:post_rest).with("data", {'name' => 'sudoing_admins'}).ordered
+    @rest.should_receive(:post_rest).with("data/sudoing_admins", data_bag_item).ordered
+
+    @knife.run
+  end
+
+  describe "encrypted data bag items" do
+    before(:each) do
+      @secret = "abc123SECRET"
+      @plain_data = {"login_name" => "alphaomega", "id" => "ME"}
+      @enc_data = Chef::EncryptedDataBagItem.encrypt_data_bag_item(@plain_data,
+                                                                   @secret)
+      @knife.name_args = ['sudoing_admins', 'ME']
+      @knife.should_receive(:create_object).and_yield(@plain_data)
+      data_bag_item = Chef::DataBagItem.from_hash(@enc_data)
+      data_bag_item.data_bag("sudoing_admins")
+      @rest.should_receive(:post_rest).with("data", {'name' => 'sudoing_admins'}).ordered
+      @rest.should_receive(:post_rest).with("data/sudoing_admins", data_bag_item).ordered
+    end
+
+    it "creates an encrypted data bag item via --secret" do
+      @knife.stub!(:config).and_return({:secret => @secret})
+      @knife.run
+    end
+
+    it "creates an encrypted data bag item via --secret_file" do
+      secret_file = Tempfile.new("encrypted_data_bag_secret_file_test")
+      secret_file.puts(@secret)
+      secret_file.flush
+      @knife.stub!(:config).and_return({:secret_file => secret_file.path})
+      @knife.run
+    end
+  end
+
+end

data/spec/unit/knife/data_bag_edit_spec.rb

@@ -0,0 +1,83 @@
+#
+# Author:: Seth Falcon (<seth@opscode.com>)
+# Copyright:: Copyright 2010 Opscode, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'spec_helper'
+require 'tempfile'
+
+describe Chef::Knife::DataBagEdit do
+  before do
+    @plain_data = {"login_name" => "alphaomega", "id" => "item_name"}
+    @edited_data = {
+      "login_name" => "rho", "id" => "item_name",
+      "new_key" => "new_value" }
+
+    Chef::Config[:node_name]  = "webmonkey.example.com"
+
+    @knife = Chef::Knife::DataBagEdit.new
+    @rest = mock('chef-rest-mock')
+    @knife.stub!(:rest).and_return(@rest)
+
+    @stdout = StringIO.new
+    @knife.stub!(:stdout).and_return(@stdout)
+    @log = Chef::Log
+    @knife.name_args = ['bag_name', 'item_name']
+  end
+
+  it "requires data bag and item arguments" do
+    @knife.name_args = []
+    lambda { @knife.run }.should raise_error(SystemExit)
+    @stdout.string.should match(/^You must supply the data bag and an item to edit/)
+  end
+
+  it "saves edits on a data bag item" do
+    Chef::DataBagItem.stub!(:load).with('bag_name', 'item_name').and_return(@plain_data)
+    @knife.should_receive(:edit_data).with(@plain_data).and_return(@edited_data)
+    @rest.should_receive(:put_rest).with("data/bag_name/item_name", @edited_data).ordered
+    @knife.run
+  end
+
+  describe "encrypted data bag items" do
+    before(:each) do
+      @secret = "abc123SECRET"
+      @enc_data = Chef::EncryptedDataBagItem.encrypt_data_bag_item(@plain_data,
+                                                                   @secret)
+      @enc_edited_data = Chef::EncryptedDataBagItem.encrypt_data_bag_item(@edited_data,
+                                                                          @secret)
+      Chef::DataBagItem.stub!(:load).with('bag_name', 'item_name').and_return(@enc_data)
+    end
+
+    it "decrypts and encrypts via --secret" do
+      @knife.stub!(:config).and_return({:secret => @secret})
+      @knife.should_receive(:edit_data).with(@plain_data).and_return(@edited_data)
+      @rest.should_receive(:put_rest).with("data/bag_name/item_name", @enc_edited_data).ordered
+
+      @knife.run
+    end
+
+    it "decrypts and encrypts via --secret_file" do
+      secret_file = Tempfile.new("encrypted_data_bag_secret_file_test")
+      secret_file.puts(@secret)
+      secret_file.flush
+      @knife.stub!(:config).and_return({:secret_file => secret_file.path})
+      @knife.should_receive(:edit_data).with(@plain_data).and_return(@edited_data)
+      @rest.should_receive(:put_rest).with("data/bag_name/item_name", @enc_edited_data).ordered
+
+      @knife.run
+    end
+  end
+end

data/spec/unit/knife/data_bag_from_file_spec.rb

@@ -0,0 +1,182 @@
+#
+# Author:: Seth Falcon (<seth@opscode.com>)
+# Copyright:: Copyright (c) 2010 Opscode, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'spec_helper'
+
+require 'chef/data_bag_item'
+require 'chef/encrypted_data_bag_item'
+require 'tempfile'
+require 'json'
+
+Chef::Knife::DataBagFromFile.load_deps
+
+describe Chef::Knife::DataBagFromFile do
+  before :each do
+    Chef::Config[:node_name]  = "webmonkey.example.com"
+    @knife = Chef::Knife::DataBagFromFile.new
+    @rest = mock("Chef::REST")
+    @knife.stub!(:rest).and_return(@rest)
+    @stdout = StringIO.new
+    @knife.ui.stub!(:stdout).and_return(@stdout)
+    @db_folder = File.join(Dir.tmpdir, 'data_bags', 'bag_name')
+    FileUtils.mkdir_p(@db_folder)
+    @db_file = Tempfile.new(["data_bag_from_file_test", ".json"], @db_folder)
+    @db_file2 = Tempfile.new(["data_bag_from_file_test2", ".json"], @db_folder)
+    @db_folder2 = File.join(Dir.tmpdir, 'data_bags', 'bag_name2')
+    FileUtils.mkdir_p(@db_folder2)
+    @db_file3 = Tempfile.new(["data_bag_from_file_test3", ".json"], @db_folder2)
+    @plain_data = {
+        "id" => "item_name",
+        "greeting" => "hello",
+        "nested" => { "a1" => [1, 2, 3], "a2" => { "b1" => true }}
+    }
+    @db_file.write(@plain_data.to_json)
+    @db_file.flush
+    @knife.instance_variable_set(:@name_args, ['bag_name', @db_file.path])
+  end
+
+  # We have to explicitly clean up Tempfile on Windows because it said so.
+  after :each do
+    @db_file.close
+    @db_file2.close
+    @db_file3.close
+    FileUtils.rm_rf(@db_folder)
+    FileUtils.rm_rf(@db_folder2)
+  end
+
+  it "loads from a file and saves" do
+    @knife.loader.should_receive(:load_from).with("data_bags", 'bag_name', @db_file.path).and_return(@plain_data)
+    dbag = Chef::DataBagItem.new
+    Chef::DataBagItem.stub!(:new).and_return(dbag)
+    dbag.should_receive(:save)
+    @knife.run
+
+    dbag.data_bag.should == 'bag_name'
+    dbag.raw_data.should == @plain_data
+  end
+
+  it "loads all from a mutiple files and saves" do
+    @knife.name_args = [ 'bag_name', @db_file.path, @db_file2.path ]
+    @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)
+    dbag = Chef::DataBagItem.new
+    Chef::DataBagItem.stub!(:new).and_return(dbag)
+    dbag.should_receive(:save).twice
+    @knife.run
+
+    dbag.data_bag.should == 'bag_name'
+    dbag.raw_data.should == @plain_data
+  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)
+    dbag = Chef::DataBagItem.new
+    Chef::DataBagItem.stub!(:new).and_return(dbag)
+    dbag.should_receive(:save).twice
+    @knife.run
+  end
+
+  describe "loading all data bags" do
+
+    before do
+      @pwd = Dir.pwd
+      Dir.chdir(Dir.tmpdir)
+    end
+
+    after do
+      Dir.chdir(@pwd)
+    end
+
+    it "loads all data bags when -a or --all options is provided" do
+      @knife.name_args = []
+      @knife.stub!(:config).and_return({:all => true})
+      @knife.loader.should_receive(:load_from).with("data_bags", "bag_name", File.basename(@db_file.path)).
+        and_return(@plain_data)
+      @knife.loader.should_receive(:load_from).with("data_bags", "bag_name", File.basename(@db_file2.path)).
+        and_return(@plain_data)
+      @knife.loader.should_receive(:load_from).with("data_bags", "bag_name2", File.basename(@db_file3.path)).
+        and_return(@plain_data)
+      dbag = Chef::DataBagItem.new
+      Chef::DataBagItem.stub!(:new).and_return(dbag)
+      dbag.should_receive(:save).exactly(3).times
+      @knife.run
+    end
+
+    it "loads all data bags items when -a or --all options is provided" do
+      @knife.name_args = ["bag_name2"]
+      @knife.stub!(:config).and_return({:all => true})
+      @knife.loader.should_receive(:load_from).with("data_bags", "bag_name2", File.basename(@db_file3.path)).
+        and_return(@plain_data)
+      dbag = Chef::DataBagItem.new
+      Chef::DataBagItem.stub!(:new).and_return(dbag)
+      dbag.should_receive(:save)
+      @knife.run
+      dbag.data_bag.should == 'bag_name2'
+      dbag.raw_data.should == @plain_data
+    end
+
+  end
+
+  describe "encrypted data bag items" do
+    before(:each) do
+      @secret = "abc123SECRET"
+      @enc_data = Chef::EncryptedDataBagItem.encrypt_data_bag_item(@plain_data,
+                                                                   @secret)
+    end
+
+    it "encrypts values when given --secret" do
+      @knife.stub!(:config).and_return({:secret => @secret})
+
+      @knife.loader.should_receive(:load_from).with("data_bags", "bag_name", @db_file.path).and_return(@plain_data)
+      dbag = Chef::DataBagItem.new
+      Chef::DataBagItem.stub!(:new).and_return(dbag)
+      dbag.should_receive(:save)
+      @knife.run
+      dbag.data_bag.should == 'bag_name'
+      dbag.raw_data.should == @enc_data
+    end
+
+    it "encrypts values when given --secret_file" do
+      secret_file = Tempfile.new("encrypted_data_bag_secret_file_test")
+      secret_file.puts(@secret)
+      secret_file.flush
+      @knife.stub!(:config).and_return({:secret_file => secret_file.path})
+
+      @knife.loader.stub!(:load_from).with("data_bags", 'bag_name', @db_file.path).and_return(@plain_data)
+      dbag = Chef::DataBagItem.new
+      Chef::DataBagItem.stub!(:new).and_return(dbag)
+      dbag.should_receive(:save)
+      @knife.run
+      dbag.data_bag.should == 'bag_name'
+      dbag.raw_data.should == @enc_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 from file BAG FILE|FOLDER [FILE|FOLDER..] \(options\)/)
+    end
+  end
+
+end