chef 11.0.0 → 11.2.0.rc.1

data/lib/chef/version.rb

@@ -17,7 +17,7 @@
 
 class Chef
   CHEF_ROOT = File.dirname(File.expand_path(File.dirname(__FILE__)))
-  VERSION = '11.0.0'
+  VERSION = '11.2.0.rc.1'
 end
 
 # NOTE: the Chef::Version class is defined in version_class.rb

data/spec/unit/knife/configure_spec.rb

@@ -41,7 +41,7 @@ describe Chef::Knife::Configure do
     @knife.config[:initial] = true
     Etc.stub!(:getlogin).and_return("a-new-user")
     @knife.ask_user_for_config
-    @out.string.should match(Regexp.escape("Please enter a clientname for the new client: [a-new-user]"))
+    @out.string.should match(Regexp.escape("Please enter a name for the new user: [a-new-user]"))
     @knife.new_client_name.should == Etc.getlogin
   end
 
@@ -50,7 +50,7 @@ describe Chef::Knife::Configure do
     @knife.config[:node_name] = 'testnode'
     Etc.stub!(:getlogin).and_return("a-new-user")
     @knife.ask_user_for_config
-    @out.string.should_not match(Regexp.escape("Please enter a clientname for the new client"))
+    @out.string.should_not match(Regexp.escape("Please enter a name for the new user"))
     @knife.new_client_name.should == 'testnode'
   end
 
@@ -64,32 +64,32 @@ describe Chef::Knife::Configure do
   it "asks the user for the existing admin client's name if -i is specified" do
     @knife.config[:initial] = true
     @knife.ask_user_for_config
-    @out.string.should match(Regexp.escape("Please enter the existing admin clientname: [chef-webui]"))
-    @knife.admin_client_name.should == 'chef-webui'
+    @out.string.should match(Regexp.escape("Please enter the existing admin name: [admin]"))
+    @knife.admin_client_name.should == 'admin'
   end
 
   it "should not ask the user for the existing admin client's name if -i and --admin-client_name are specified" do
     @knife.config[:initial] = true
     @knife.config[:admin_client_name] = 'my-webui'
     @knife.ask_user_for_config
-    @out.string.should_not match(Regexp.escape("Please enter the existing admin clientname:"))
+    @out.string.should_not match(Regexp.escape("Please enter the existing admin:"))
     @knife.admin_client_name.should == 'my-webui'
   end
 
   it "should not ask the user for the existing admin client's name if -i is not specified" do
     @knife.ask_user_for_config
-    @out.string.should_not match(Regexp.escape("Please enter the existing admin clientname: [chef-webui]"))
-    @knife.admin_client_name.should_not == 'chef-webui'
+    @out.string.should_not match(Regexp.escape("Please enter the existing admin: [admin]"))
+    @knife.admin_client_name.should_not == 'admin'
   end
 
   it "asks the user for the location of the existing admin key if -i is specified" do
     @knife.config[:initial] = true
     @knife.ask_user_for_config
-    @out.string.should match(Regexp.escape("Please enter the location of the existing admin client's private key: [/etc/chef/webui.pem]"))
+    @out.string.should match(Regexp.escape("Please enter the location of the existing admin's private key: [/etc/chef/admin.pem]"))
     if windows?
-      @knife.admin_client_key.should == 'C:/etc/chef/webui.pem'
+      @knife.admin_client_key.should == 'C:/etc/chef/admin.pem'
     else
-      @knife.admin_client_key.should == '/etc/chef/webui.pem'
+      @knife.admin_client_key.should == '/etc/chef/admin.pem'
     end
   end
 
@@ -111,7 +111,7 @@ describe Chef::Knife::Configure do
     if windows?
       @knife.admin_client_key.should_not == 'C:/etc//chef/webui.pem'
     else
-      @knife.admin_client_key.should_not == '/etc/chef/webui.pem' 
+      @knife.admin_client_key.should_not == '/etc/chef/webui.pem'
     end
   end
 
@@ -140,7 +140,7 @@ describe Chef::Knife::Configure do
     if windows?
       @knife.validation_key.should == 'C:/etc/chef/validation.pem'
     else
-      @knife.validation_key.should == '/etc/chef/validation.pem' 
+      @knife.validation_key.should == '/etc/chef/validation.pem'
     end
   end
 
@@ -208,28 +208,25 @@ describe Chef::Knife::Configure do
     File.should_receive(:expand_path).with("/home/you/.chef/knife.rb").and_return("/home/you/.chef/knife.rb")
     File.should_receive(:expand_path).with("/home/you/.chef/a-new-user.pem").and_return("/home/you/.chef/a-new-user.pem")
     File.should_receive(:expand_path).with("/etc/chef/validation.pem").and_return("/etc/chef/validation.pem")
-    File.should_receive(:expand_path).with("/etc/chef/webui.pem").and_return("/etc/chef/webui.pem")
+    File.should_receive(:expand_path).with("/etc/chef/admin.pem").and_return("/etc/chef/admin.pem")
     Chef::Config[:node_name]  = "webmonkey.example.com"
 
-
-    client_command_config = {}
-
-    client_command = mock("knife client create command", :config => client_command_config)
-    client_command.should_receive(:name_args=).with(["a-new-user"])
-    client_command.stub!(:name_args).and_return(["a-new-user"])
-    client_command.should_receive(:run)
+    user_command = Chef::Knife::UserCreate.new
+    user_command.should_receive(:run)
 
     Etc.stub!(:getlogin).and_return("a-new-user")
 
-    Chef::Knife::ClientCreate.stub!(:new).and_return(client_command)
+    Chef::Knife::UserCreate.stub!(:new).and_return(user_command)
     FileUtils.should_receive(:mkdir_p).with("/home/you/.chef")
     ::File.should_receive(:open).with("/home/you/.chef/knife.rb", "w")
     @knife.config[:initial] = true
+    @knife.config[:user_password] = "blah"
     @knife.run
-    client_command.name_args.should == Array("a-new-user")
-    client_command.config[:admin].should be_true
-    client_command.config[:file].should == "/home/you/.chef/a-new-user.pem"
-    client_command.config[:yes].should be_true
-    client_command.config[:disable_editing].should be_true
+    user_command.name_args.should == Array("a-new-user")
+    user_command.config[:user_password].should == "blah"
+    user_command.config[:admin].should be_true
+    user_command.config[:file].should == "/home/you/.chef/a-new-user.pem"
+    user_command.config[:yes].should be_true
+    user_command.config[:disable_editing].should be_true
   end
 end

data/spec/unit/knife/user_create_spec.rb

@@ -0,0 +1,86 @@
+#
+# Author:: Steven Danna (<steve@opscode.com>)
+# Copyright:: Copyright (c) 2012 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'
+
+Chef::Knife::UserCreate.load_deps
+
+describe Chef::Knife::UserCreate do
+  before(:each) do
+    @knife = Chef::Knife::UserCreate.new
+    @knife.name_args = [ 'a_user' ]
+    @knife.config[:user_password] = "foobar"
+    @user = Chef::User.new
+    @user.name "a_user"
+    @user_with_private_key = Chef::User.new
+    @user_with_private_key.name "a_user"
+    @user_with_private_key.private_key 'private_key'
+    @user.stub!(:create).and_return(@user_with_private_key)
+    Chef::User.stub!(:new).and_return(@user)
+    Chef::User.stub!(:from_hash).and_return(@user)
+    @knife.stub!(:edit_data).and_return(@user.to_hash)
+    @stdout = StringIO.new
+    @stderr = StringIO.new
+    @knife.ui.stub!(:stdout).and_return(@stdout)
+    @knife.ui.stub!(:stderr).and_return(@stderr)
+  end
+
+  it "creates a new user" do
+    Chef::User.should_receive(:new).and_return(@user)
+    @user.should_receive(:create)
+    @knife.run
+    @stdout.string.should match /created user.+a_user/i
+  end
+
+  it "sets the password" do
+    @knife.config[:user_password] = "a_password"
+    @user.should_receive(:password).with("a_password")
+    @knife.run
+  end
+
+  it "exits with an error if password is blank" do
+    @knife.config[:user_password] = ''
+    lambda { @knife.run }.should raise_error SystemExit
+    @stderr.string.should match /You must specify a non-blank password/
+  end
+
+  it "sets the user name" do
+    @user.should_receive(:name).with("a_user")
+    @knife.run
+  end
+
+  it "sets the public key if given" do
+    @knife.config[:user_key] = "/a/filename"
+    File.stub(:read).with("/a/filename").and_return("a_key")
+    @user.should_receive(:public_key).with("a_key")
+    @knife.run
+  end
+
+  it "allows you to edit the data" do
+    @knife.should_receive(:edit_data).with(@user)
+    @knife.run
+  end
+
+  it "writes the private key to a file when --file is specified" do
+    @knife.config[:file] = "/tmp/a_file"
+    filehandle = mock("filehandle")
+    filehandle.should_receive(:print).with('private_key')
+    File.should_receive(:open).with("/tmp/a_file", "w").and_yield(filehandle)
+    @knife.run
+  end
+end

data/spec/unit/knife/user_delete_spec.rb

@@ -0,0 +1,39 @@
+#
+# Author:: Steven Danna (<steve@opscode.com>)
+# Copyright:: Copyright (c) 2012 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::UserDelete do
+  before(:each) do
+    Chef::Knife::UserDelete.load_deps
+    @knife = Chef::Knife::UserDelete.new
+    @knife.name_args = [ 'my_user' ]
+  end
+
+  it 'deletes the user' do
+    @knife.should_receive(:delete_object).with(Chef::User, 'my_user')
+    @knife.run
+  end
+
+  it 'prints usage and exits when a user name is not provided' do
+    @knife.name_args = []
+    @knife.should_receive(:show_usage)
+    @knife.ui.should_receive(:fatal)
+    lambda { @knife.run }.should raise_error(SystemExit)
+  end
+end

data/spec/unit/knife/user_edit_spec.rb

@@ -0,0 +1,42 @@
+#
+# Author:: Steven Danna (<steve@opscode.com>)
+# Copyright:: Copyright (c) 2012 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::UserEdit do
+  before(:each) do
+    Chef::Knife::UserEdit.load_deps
+    @knife = Chef::Knife::UserEdit.new
+    @knife.name_args = [ 'my_user' ]
+    @knife.config[:disable_editing] = true
+  end
+
+  it 'loads and edits the user' do
+    data = { :name => "my_user" }
+    Chef::User.stub(:load).with("my_user").and_return(data)
+    @knife.should_receive(:edit_data).with(data).and_return(data)
+    @knife.run
+  end
+
+  it 'prints usage and exits when a user name is not provided' do
+    @knife.name_args = []
+    @knife.should_receive(:show_usage)
+    @knife.ui.should_receive(:fatal)
+    lambda { @knife.run }.should raise_error(SystemExit)
+  end
+end

data/spec/unit/knife/user_list_spec.rb

@@ -0,0 +1,32 @@
+#
+# Author:: Steven Danna
+# Copyright:: Copyright (c) 2012 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::UserList do
+  before(:each) do
+    Chef::Knife::UserList.load_deps
+    @knife = Chef::Knife::UserList.new
+  end
+
+  it 'lists the users' do
+    Chef::User.should_receive(:list)
+    @knife.should_receive(:format_list_for_display)
+    @knife.run
+  end
+end

data/spec/unit/knife/user_reregister_spec.rb

@@ -0,0 +1,53 @@
+#
+# Author:: Steven Danna (<steve@opscode.com>)
+# Copyright:: Copyright (c) 2012 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::UserReregister do
+  before(:each) do
+    Chef::Knife::UserReregister.load_deps
+    @knife = Chef::Knife::UserReregister.new
+    @knife.name_args = [ 'a_user' ]
+    @user_mock = mock('user_mock', :private_key => "private_key")
+    Chef::User.stub!(:load).and_return(@user_mock)
+    @stdout = StringIO.new
+    @knife.ui.stub!(:stdout).and_return(@stdout)
+  end
+
+  it 'prints usage and exits when a user name is not provided' do
+    @knife.name_args = []
+    @knife.should_receive(:show_usage)
+    @knife.ui.should_receive(:fatal)
+    lambda { @knife.run }.should raise_error(SystemExit)
+  end
+
+  it 'reregisters the user and prints the key' do
+    @user_mock.should_receive(:reregister).and_return(@user_mock)
+    @knife.run
+    @stdout.string.should match( /private_key/ )
+  end
+
+  it 'writes the private key to a file when --file is specified' do
+    @user_mock.should_receive(:reregister).and_return(@user_mock)
+    @knife.config[:file] = '/tmp/a_file'
+    filehandle = StringIO.new
+    File.should_receive(:open).with('/tmp/a_file', 'w').and_yield(filehandle)
+    @knife.run
+    filehandle.string.should == "private_key"
+  end
+end

data/spec/unit/knife/user_show_spec.rb

@@ -0,0 +1,41 @@
+#
+# Author:: Steven Danna (<steve@opscode.com>)
+# Copyright:: Copyright (c) 2012 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::UserShow do
+  before(:each) do
+    Chef::Knife::UserShow.load_deps
+    @knife = Chef::Knife::UserShow.new
+    @knife.name_args = [ 'my_user' ]
+    @user_mock = mock('user_mock')
+  end
+
+  it 'loads and displays the user' do
+    Chef::User.should_receive(:load).with('my_user').and_return(@user_mock)
+    @knife.should_receive(:format_for_display).with(@user_mock)
+    @knife.run
+  end
+
+  it 'prints usage and exits when a user name is not provided' do
+    @knife.name_args = []
+    @knife.should_receive(:show_usage)
+    @knife.ui.should_receive(:fatal)
+    lambda { @knife.run }.should raise_error(SystemExit)
+  end
+end

data/spec/unit/user_spec.rb

@@ -0,0 +1,255 @@
+#
+# Author:: Steven Danna (steve@opscode.com)
+# Copyright:: Copyright (c) 2012 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/user'
+require 'tempfile'
+
+describe Chef::User do
+  before(:each) do
+    @user = Chef::User.new
+  end
+
+  describe "initialize" do
+    it "should be a Chef::User" do
+      @user.should be_a_kind_of(Chef::User)
+    end
+  end
+
+  describe "name" do
+    it "should let you set the name to a string" do
+      @user.name("ops_master").should == "ops_master"
+    end
+
+    it "should return the current name" do
+      @user.name "ops_master"
+      @user.name.should == "ops_master"
+    end
+
+    # It is not feasible to check all invalid characters.  Here are a few
+    # that we probably care about.
+    it "should not accept invalid characters" do
+      # capital letters
+      lambda { @user.name "Bar" }.should raise_error(ArgumentError)
+      # slashes
+      lambda { @user.name "foo/bar" }.should raise_error(ArgumentError)
+      # ?
+      lambda { @user.name "foo?" }.should raise_error(ArgumentError)
+      # &
+      lambda { @user.name "foo&" }.should raise_error(ArgumentError)
+    end
+
+
+    it "should not accept spaces" do
+      lambda { @user.name "ops master" }.should raise_error(ArgumentError)
+    end
+
+    it "should throw an ArgumentError if you feed it anything but a string" do
+      lambda { @user.name Hash.new }.should raise_error(ArgumentError)
+    end
+  end
+
+  describe "admin" do
+    it "should let you set the admin bit" do
+      @user.admin(true).should == true
+    end
+
+    it "should return the current admin value" do
+      @user.admin true
+      @user.admin.should == true
+    end
+
+    it "should default to false" do
+      @user.admin.should == false
+    end
+
+    it "should throw an ArgumentError if you feed it anything but true or false" do
+      lambda { @user.name Hash.new }.should raise_error(ArgumentError)
+    end
+  end
+
+  describe "public_key" do
+    it "should let you set the public key" do
+      @user.public_key("super public").should == "super public"
+    end
+
+    it "should return the current public key" do
+      @user.public_key("super public")
+      @user.public_key.should == "super public"
+    end
+
+    it "should throw an ArgumentError if you feed it something lame" do
+      lambda { @user.public_key Hash.new }.should raise_error(ArgumentError)
+    end
+  end
+
+  describe "private_key" do
+    it "should let you set the private key" do
+      @user.private_key("super private").should == "super private"
+    end
+
+    it "should return the private key" do
+      @user.private_key("super private")
+      @user.private_key.should == "super private"
+    end
+
+    it "should throw an ArgumentError if you feed it something lame" do
+      lambda { @user.private_key Hash.new }.should raise_error(ArgumentError)
+    end
+  end
+
+  describe "when serializing to JSON" do
+    before(:each) do
+      @user.name("black")
+      @user.public_key("crowes")
+      @json = @user.to_json
+    end
+
+    it "serializes as a JSON object" do
+      @json.should match(/^\{.+\}$/)
+    end
+
+    it "includes the name value" do
+      @json.should include(%q{"name":"black"})
+    end
+
+    it "includes the public key value" do
+      @json.should include(%{"public_key":"crowes"})
+    end
+
+    it "includes the 'admin' flag" do
+      @json.should include(%q{"admin":false})
+    end
+
+    it "includes the private key when present" do
+      @user.private_key("monkeypants")
+      @user.to_json.should include(%q{"private_key":"monkeypants"})
+    end
+
+    it "does not include the private key if not present" do
+      @json.should_not include("private_key")
+    end
+
+    it "includes the password if present" do
+      @user.password "password"
+      @user.to_json.should include(%q{"password":"password"})
+    end
+
+    it "does not include the password if not present" do
+      @json.should_not include("password")
+    end
+  end
+
+  describe "when deserializing from JSON" do
+    before(:each) do
+      user = { "name" => "mr_spinks",
+        "public_key" => "turtles",
+        "private_key" => "pandas",
+        "password" => "password",
+        "admin" => true }
+      @user = Chef::User.from_json(user.to_json)
+    end
+
+    it "should deserialize to a Chef::User object" do
+      @user.should be_a_kind_of(Chef::User)
+    end
+
+    it "preserves the name" do
+      @user.name.should == "mr_spinks"
+    end
+
+    it "preserves the public key" do
+      @user.public_key.should == "turtles"
+    end
+
+    it "preserves the admin status" do
+      @user.admin.should be_true
+    end
+
+    it "includes the private key if present" do
+      @user.private_key.should == "pandas"
+    end
+
+    it "includes the password if present" do
+      @user.password.should == "password"
+    end
+
+  end
+
+  describe "API Interactions" do
+    before (:each) do
+      @user = Chef::User.new
+      @user.name "foobar"
+      @http_client = mock("Chef::REST mock")
+      Chef::REST.stub!(:new).and_return(@http_client)
+    end
+
+    describe "list" do
+      before(:each) do
+        Chef::Config[:chef_server_url] = "http://www.example.com"
+        @osc_response = { "admin" => "http://www.example.com/users/admin"}
+        @ohc_response = [ { "user" => { "username" => "admin" }} ]
+      end
+
+      it "lists all clients on an OSC server" do
+        @http_client.stub!(:get_rest).with("users").and_return(@osc_response)
+        Chef::User.list.should == @osc_response
+      end
+
+      it "lists all clients on an OHC/OPC server" do
+        @http_client.stub!(:get_rest).with("users").and_return(@ohc_response)
+        # We expect that Chef::User.list will give a consistent response
+        # so OHC API responses should be transformed to OSC-style output.
+        Chef::User.list.should == @osc_response
+      end
+    end
+
+    describe "create" do
+      it "creates a new user via the API" do
+        @user.password "password"
+        @http_client.should_receive(:post_rest).with("users", {:name => "foobar", :admin => false, :password => "password"}).and_return({})
+        @user.create
+      end
+    end
+
+    describe "read" do
+      it "loads a named user from the API" do
+        @http_client.should_receive(:get_rest).with("users/foobar").and_return({"name" => "foobar", "admin" => true, "public_key" => "pubkey"})
+        user = Chef::User.load("foobar")
+        user.name.should == "foobar"
+        user.admin.should == true
+        user.public_key.should == "pubkey"
+      end
+    end
+
+    describe "update" do
+      it "updates an existing user on via the API" do
+        @http_client.should_receive(:put_rest).with("users/foobar", {:name => "foobar", :admin => false}).and_return({})
+        @user.update
+      end
+    end
+
+    describe "destroy" do
+      it "deletes the specified user via the API" do
+        @http_client.should_receive(:delete_rest).with("users/foobar")
+        @user.destroy
+      end
+    end
+  end
+end