microwave 1.0.4 → 11.400.2

data/spec/unit/api_client_spec.rb

@@ -6,9 +6,9 @@
 # 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.
@@ -26,158 +26,211 @@ describe Chef::ApiClient do
     @client = Chef::ApiClient.new
   end
 
-  describe "initialize" do
-    it "should be a Chef::ApiClient" do
-      @client.should be_a_kind_of(Chef::ApiClient)
-    end
+  it "has a name attribute" do
+    @client.name("ops_master")
+    @client.name.should == "ops_master"
+  end
+
+  it "does not allow spaces in the name" do
+    lambda { @client.name "ops master" }.should raise_error(ArgumentError)
+  end
+
+  it "only allows string values for the name" do
+    lambda { @client.name Hash.new }.should raise_error(ArgumentError)
+  end
+
+  it "has an admin flag attribute" do
+    @client.admin(true)
+    @client.admin.should be_true
+  end
+
+  it "defaults to non-admin" do
+    @client.admin.should be_false
+  end
+
+  it "allows only boolean values for the admin flag" do
+    lambda { @client.admin(false) }.should_not raise_error
+    lambda { @client.admin(Hash.new) }.should raise_error(ArgumentError)
   end
 
-  describe "name" do
-    it "should let you set the name to a string" do
-      @client.name("ops_master").should == "ops_master"
-    end
 
-    it "should return the current name" do
-      @client.name "ops_master"
-      @client.name.should == "ops_master"
+  it "has a public key attribute" do
+    @client.public_key("super public")
+    @client.public_key.should == "super public"
+  end
+
+  it "accepts only String values for the public key" do
+    lambda { @client.public_key "" }.should_not raise_error
+    lambda { @client.public_key Hash.new }.should raise_error(ArgumentError)
+  end
+
+
+  it "has a private key attribute" do
+    @client.private_key("super private")
+    @client.private_key.should == "super private"
+  end
+
+  it "accepts only String values for the private key" do
+    lambda { @client.private_key "" }.should_not raise_error
+    lambda { @client.private_key Hash.new }.should raise_error(ArgumentError)
+  end
+
+  describe "when serializing to JSON" do
+    before(:each) do
+      @client.name("black")
+      @client.public_key("crowes")
+      @json = @client.to_json
     end
 
-    it "should not accept spaces" do
-      lambda { @client.name "ops master" }.should raise_error(ArgumentError)
+    it "serializes as a JSON object" do
+      @json.should match(/^\{.+\}$/)
     end
 
-    it "should throw an ArgumentError if you feed it anything but a string" do
-      lambda { @client.name Hash.new }.should raise_error(ArgumentError)
+    it "includes the name value" do
+      @json.should include(%q{"name":"black"})
     end
-  end
 
-  describe "admin" do
-    it "should let you set the admin bit" do
-      @client.admin(true).should == true
+    it "includes the public key value" do
+      @json.should include(%{"public_key":"crowes"})
     end
 
-    it "should return the current admin value" do
-      @client.admin true 
-      @client.admin.should == true 
+    it "includes the 'admin' flag" do
+      @json.should include(%q{"admin":false})
     end
 
-    it "should default to false" do
-      @client.admin.should == false
+    it "includes the private key when present" do
+      @client.private_key("monkeypants")
+      @client.to_json.should include(%q{"private_key":"monkeypants"})
     end
 
-    it "should throw an ArgumentError if you feed it anything but true or false" do
-      lambda { @client.name Hash.new }.should raise_error(ArgumentError)
+    it "does not include the private key if not present" do
+      @json.should_not include("private_key")
     end
   end
 
-  describe "public_key" do
-    it "should let you set the public key" do
-      @client.public_key("super public").should == "super public"
+  describe "when deserializing from JSON" do
+    before(:each) do
+      client = {
+      "name" => "black",
+      "public_key" => "crowes",
+      "private_key" => "monkeypants",
+      "admin" => true,
+      "json_class" => "Chef::ApiClient"
+      }
+      @client = Chef::JSONCompat.from_json(client.to_json)
     end
 
-    it "should return the current public key" do
-      @client.public_key("super public")
-      @client.public_key.should == "super public"
+    it "should deserialize to a Chef::ApiClient object" do
+      @client.should be_a_kind_of(Chef::ApiClient)
     end
 
-    it "should throw an ArgumentError if you feed it something lame" do
-      lambda { @client.public_key Hash.new }.should raise_error(ArgumentError)
-    end 
-  end
+    it "preserves the name" do
+      @client.name.should == "black"
+    end
+
+    it "preserves the public key" do
+      @client.public_key.should == "crowes"
+    end
 
-  describe "private_key" do
-    it "should let you set the private key" do
-      @client.private_key("super private").should == "super private"
+    it "preserves the admin status" do
+      @client.admin.should be_true
     end
 
-    it "should return the private key" do
-      @client.private_key("super private")
-      @client.private_key.should == "super private"
+    it "includes the private key if present" do
+      @client.private_key.should == "monkeypants"
     end
 
-    it "should throw an ArgumentError if you feed it something lame" do
-      lambda { @client.private_key Hash.new }.should raise_error(ArgumentError)
-    end 
   end
 
-  describe "create_keys" do
-    before(:each) do
-      Chef::Certificate.stub!(:gen_keypair).and_return(["cert", "key"])
+  describe "with correctly configured API credentials" do
+    before do
+      Chef::Config[:node_name] = "silent-bob"
+      Chef::Config[:client_key] = File.expand_path('ssl/private_key.pem', CHEF_SPEC_DATA)
     end
 
-    it "should create a certificate based on the client name" do
-      Chef::Certificate.should_receive(:gen_keypair).with(@client.name)
-      @client.create_keys
+    after do
+      Chef::Config[:node_name] = nil
+      Chef::Config[:client_key] = nil
     end
 
-    it "should set the private key" do
-      @client.create_keys
-      @client.private_key.should == "key"
+    let :private_key_data do
+      File.open(Chef::Config[:client_key], "r") {|f| f.read.chomp }
     end
 
-    it "should set the public key" do
-      @client.create_keys
-      @client.public_key.should == "cert"
+    it "has an HTTP client configured with default credentials" do
+      @client.http_api.should be_a_kind_of(Chef::REST)
+      @client.http_api.client_name.should == "silent-bob"
+      @client.http_api.signing_key.to_s.should == private_key_data
     end
   end
 
-  describe "serialize" do
-    before(:each) do
-      @client.name("black")
-      @client.public_key("crowes")
-      @client.private_key("monkeypants")
-      @serial = @client.to_json
-    end
 
-    it "should serialize to a json hash" do
-      @client.to_json.should match(/^\{.+\}$/)
+  describe "when requesting a new key" do
+    before do
+      @http_client = mock("Chef::REST mock")
+      Chef::REST.stub!(:new).and_return(@http_client)
     end
 
-    %w{
-      name
-      public_key
-    }.each do |t| 
-      it "should include '#{t}'" do
-        @serial.should =~ /"#{t}":"#{@client.send(t.to_sym)}"/
+    context "and the client does not exist on the server" do
+      before do
+        @a_404_response = Net::HTTPNotFound.new("404 not found and such", nil, nil)
+        @a_404_exception = Net::HTTPServerException.new("404 not found exception", @a_404_response)
+
+        @http_client.should_receive(:get).with("clients/lost-my-key").and_raise(@a_404_exception)
       end
-    end
 
-    it "should include 'admin'" do
-      @serial.should =~ /"admin":false/
+      it "raises a 404 error" do
+        lambda { Chef::ApiClient.reregister("lost-my-key") }.should raise_error(Net::HTTPServerException)
+      end
     end
 
-    it "should not include the private key" do
-      @serial.should_not =~ /"private_key":/
-    end
-  end
+    context "and the client exists" do
+      before do
+        @api_client_without_key = Chef::ApiClient.new
+        @api_client_without_key.name("lost-my-key")
+        @http_client.should_receive(:get).with("clients/lost-my-key").and_return(@api_client_without_key)
+      end
 
-  describe "deserialize" do
-    before(:each) do
-      @client.name("black")
-      @client.public_key("crowes")
-      @client.private_key("monkeypants")
-      @client.admin(true)
-      @deserial = Chef::JSONCompat.from_json(@client.to_json)
-    end
 
-    it "should deserialize to a Chef::ApiClient object" do
-      @deserial.should be_a_kind_of(Chef::ApiClient)
-    end
+      context "and the client exists on a Chef 11-like server" do
+        before do
+          @api_client_with_key = Chef::ApiClient.new
+          @api_client_with_key.name("lost-my-key")
+          @api_client_with_key.private_key("the new private key")
+          @http_client.should_receive(:put).
+            with("clients/lost-my-key", :name => "lost-my-key", :admin => false, :private_key => true).
+            and_return(@api_client_with_key)
+        end
+
+        it "returns an ApiClient with a private key" do
+          response = Chef::ApiClient.reregister("lost-my-key")
+          # no sane == method for ApiClient :'(
+          response.should == @api_client_without_key
+          response.private_key.should == "the new private key"
+          response.name.should == "lost-my-key"
+          response.admin.should be_false
+        end
+      end
 
-    %w{
-      name
-      public_key
-      admin
-    }.each do |t| 
-      it "should match '#{t}'" do
-        @deserial.send(t.to_sym).should == @client.send(t.to_sym)
+      context "and the client exists on a Chef 10-like server" do
+        before do
+          @api_client_with_key = {"name" => "lost-my-key", "private_key" => "the new private key"}
+          @http_client.should_receive(:put).
+            with("clients/lost-my-key", :name => "lost-my-key", :admin => false, :private_key => true).
+            and_return(@api_client_with_key)
+        end
+
+        it "returns an ApiClient with a private key" do
+          response = Chef::ApiClient.reregister("lost-my-key")
+          # no sane == method for ApiClient :'(
+          response.should == @api_client_without_key
+          response.private_key.should == "the new private key"
+          response.name.should == "lost-my-key"
+          response.admin.should be_false
+        end
       end
-    end
 
-    it "should not include the private key" do
-      @deserial.private_key.should == nil
     end
-
   end
 end
 

data/spec/unit/application/apply.rb

@@ -0,0 +1,84 @@
+#
+# Author:: Bryan W. Berry (<bryan.berry@gmail.com>)
+# Copyright:: Copyright (c) 2012 Bryan W. Berry
+# 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::Application::Apply do
+
+  before do
+    @original_config = Chef::Config.configuration
+    @app = Chef::Application::Recipe.new
+    @app.stub!(:configure_logging).and_return(true)
+    @recipe_text = "package 'nyancat'"
+    Chef::Config[:solo] = true
+  end
+
+  after do
+    Chef::Config[:solo] = nil
+    Chef::Config.configuration.replace(@original_config)
+    Chef::Config[:solo] = false
+  end
+
+
+  describe "configuring the application" do
+    it "should set solo mode to true" do
+      @app.reconfigure
+      Chef::Config[:solo].should be_true
+    end
+  end
+  describe "read_recipe_file" do
+    before do
+      @recipe_file_name = "foo.rb"
+      @recipe_path = File.expand_path("foo.rb")
+      @recipe_file = mock("Tempfile (mock)", :read => @recipe_text)
+      @app.stub!(:open).with(@recipe_path).and_return(@recipe_file)
+      File.stub!(:exist?).with("foo.rb").and_return(true)
+      Chef::Application.stub!(:fatal!).and_return(true)
+    end
+    it "should read text properly" do
+      @app.read_recipe_file(@recipe_file_name)[0].should == @recipe_text
+    end
+    it "should return a file_handle" do
+      @app.read_recipe_file(@recipe_file_name)[1].should be_instance_of(RSpec::Mocks::Mock)
+    end
+    describe "when recipe doesn't exist" do
+      before do
+        File.stub!(:exist?).with(@recipe_file_name).and_return(false)
+      end
+      it "should raise a fatal" do
+        Chef::Application.should_receive(:fatal!)
+        @app.read_recipe_file(@recipe_file_name)
+      end
+    end
+  end
+  describe "temp_recipe_file" do
+    before do
+      @app.instance_variable_set(:@recipe_text, @recipe_text)
+      @app.temp_recipe_file      
+      @recipe_fh = @app.instance_variable_get(:@recipe_fh)
+    end
+    it "should open a tempfile" do
+      @recipe_fh.path.should match(/.*recipe-temporary-file.*/)
+    end
+    it "should write recipe text to the tempfile" do
+      @recipe_fh.read.should == @recipe_text
+    end
+    it "should save the filename for later use" do
+      @recipe_fh.path.should == @app.instance_variable_get(:@recipe_filename)
+    end
+  end
+end

data/spec/unit/application/knife_spec.rb

@@ -23,6 +23,11 @@ describe Chef::Application::Knife do
 
   before(:all) do
     class NoopKnifeCommand < Chef::Knife
+      option :opt_with_default,
+        :short => "-D VALUE",
+        :long => "-optwithdefault VALUE",
+        :default => "default-value"
+
       def run
       end
     end

data/spec/unit/application_spec.rb

@@ -20,12 +20,17 @@ require 'spec_helper'
 
 describe Chef::Application do
   before do
+    @original_conf = Chef::Config.configuration
     Chef::Log.logger = Logger.new(StringIO.new)
     @app = Chef::Application.new
     Dir.stub!(:chdir).and_return(0)
     @app.stub!(:reconfigure)
   end
 
+  after do
+    Chef::Config.configuration.replace(@original_conf)
+  end
+
   describe "reconfigure" do
     before do
       @app = Chef::Application.new
@@ -170,14 +175,14 @@ describe Chef::Application do
     end
   end
 
-  describe "configure_logging" do
+  describe "when configuring the logger" do
     before do
       @app = Chef::Application.new
       Chef::Log.stub!(:init)
-      Chef::Log.stub!(:level=)
     end
 
     it "should initialise the chef logger" do
+      Chef::Log.stub!(:level=)
       Chef::Log.should_receive(:init).with(Chef::Config[:log_location]).and_return(true)
       @app.configure_logging
     end
@@ -187,6 +192,56 @@ describe Chef::Application do
       @app.configure_logging
     end
 
+    context "and log_level is :auto" do
+      before do
+        Chef::Config[:log_level] = :auto
+      end
+
+      context "and STDOUT is to a tty" do
+        before do
+          STDOUT.stub!(:tty?).and_return(true)
+        end
+
+        it "configures the log level to :warn" do
+          @app.configure_logging
+          Chef::Log.level.should == :warn
+        end
+
+        context "and force_logger is configured" do
+          before do
+            Chef::Config[:force_logger] = true
+          end
+
+          it "configures the log level to info" do
+            @app.configure_logging
+            Chef::Log.level.should == :info
+          end
+        end
+      end
+
+      context "and STDOUT is not to a tty" do
+        before do
+          STDOUT.stub!(:tty?).and_return(false)
+        end
+
+        it "configures the log level to :info" do
+          @app.configure_logging
+          Chef::Log.level.should == :info
+        end
+
+        context "and force_formatter is configured" do
+          before do
+            Chef::Config[:force_formatter] = true
+          end
+          it "sets the log level to :warn" do
+            @app.configure_logging
+            Chef::Log.level.should == :warn
+          end
+        end
+      end
+
+
+    end
   end
 
   describe "class method: fatal!" do