knife-google 1.1.0 → 1.2.0

data/lib/google/compute/zone.rb

@@ -12,20 +12,22 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+#require 'google/compute/resource'
+#require 'google/compute/region'
+
 module Google
   module Compute
     class Zone < Resource
 
-      attr_reader :maintenance_windows, :available_machine_type, :status
-      attr_reader :quotas, :deprecated
+      attr_reader :status, :maintenance_windows
+      attr_reader :deprecated, :region
 
       def from_hash(zone_data)
         super(zone_data)
         @status = zone_data["status"] 
         @maintenance_windows = zone_data["maintenanceWindows"]
-        @available_machine_type = zone_data["availableMachineType"]
-        @quotas = zone_data["quotas"]
         @deprecated = zone_data["deprecated"]
+        @region = zone_data["region"]
       end
     end
   end

data/lib/google/compute/zone_operation.rb

@@ -20,17 +20,20 @@ module Google
   module Compute
     class ZoneOperation < Resource
 
-      attr_reader :target_link, :target_id, :client_operation_id
-      attr_reader :status, :status_message, :user, :progress
+      attr_reader :zone, :client_operation_id, :operation_type
+      attr_reader :target_link, :target_id, :status
+      attr_reader :status_message, :user, :progress
       attr_reader :insert_time, :start_time, :end_time
-      attr_reader :http_error_status_code, :http_error_message
-      attr_reader :error, :warnings, :operation_type, :zone
+      attr_reader :error, :warnings, :http_error_status_code
+      attr_reader :http_error_message, :region
 
       def from_hash(data)
         super(data)
+        @zone = data["zone"]
+        @client_operation_id =  data["clientOperationId"]
+        @operation_type = data["operationType"]
         @target_link= data["targetLink"]
         @target_id = data["targetId"]
-        @client_operation_id =  data["clientOperationId"]
         @status =  data["status"]
         @status_message = data["statusMessage"]
         @user = data["user"]
@@ -38,12 +41,11 @@ module Google
         @insert_time = Time.parse( data["insertTime"] )
         @start_time = Time.parse( data["startTime"] )
         @end_time = Time.parse( data["endTime"] ) if data.key?("endTime")
-        @http_error_status_code = data["httpErrorMessage"]
-        @http_error_message = data["httpErrorMessage"]
         @error = data["error"]
         @warnings = data["warnings"]
-        @operation_type = data["operationType"]
-        @zone = data["zone"]
+        @http_error_status_code = data["httpErrorMessage"]
+        @http_error_message = data["httpErrorMessage"]
+        @region = data["region"]
       end
 
       def wait_for_completion!(options={})

data/lib/knife-google/version.rb

@@ -14,6 +14,6 @@
 #
 module Knife
   module Google
-    VERSION = "1.1.0"
+    VERSION = "1.2.0"
   end
 end

data/spec/chef/knife/google_base_spec.rb

@@ -20,20 +20,20 @@ describe Chef::Knife::GoogleBase do
 
   it "#client should return a Google::Compute::Client" do
     Google::Compute::Client.should_receive(:from_json).
-      and_return(mock(Google::Compute::Client))
+      and_return(double(Google::Compute::Client))
     knife_plugin.client
   end
 
   it "#selflink2name should return name from a seleflink url" do
     knife_plugin.selflink2name(
-      'https://www.googleapis.com/compute/v1beta15/projects/mock-project/category/resource').
+      'https://www.googleapis.com/compute/v1/projects/mock-project/category/resource').
       should eq('resource')
   end
 
-  it "#msg_pair should invoke ui.info with labe : value string" do
+  it "#msg_pair should invoke ui.info with label : value string" do
     knife_plugin.ui.should_receive(:info).
       with("#{knife_plugin.ui.color("label", :cyan)}: value")
-    knife_plugin.msg_pair("label","value")
+    knife_plugin.msg_pair("label", "value")
   end
 
   it "#private_ips should extract private ip as an array from a GCE server" do

data/spec/chef/knife/google_disk_create_spec.rb

@@ -12,25 +12,26 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
+
 require 'spec_helper'
 
 describe Chef::Knife::GoogleDiskCreate do
-
   let(:knife_plugin) do
     Chef::Knife::GoogleDiskCreate.new(
-      [stored_disk.name, "-Z"+stored_zone.name, "-s14"])
+      [stored_disk.name, "-Z"+stored_zone.name])
   end
 
   it "#run should invoke compute api to create a disk" do
-    zones = mock(Google::Compute::ListableResourceCollection)
+    zones = double(Google::Compute::ListableResourceCollection)
     zones.should_receive(:get).
       with(stored_zone.name).and_return(stored_zone)
-    disks = mock(Google::Compute::CreatableResourceCollection)
+    disks = double(Google::Compute::CreatableResourceCollection)
     disks.should_receive(:create).
-      with(:zone=>stored_zone.name, :name=>stored_disk.name, :sizeGb=>"14").
+      with(:name => stored_disk.name, :sizeGb => 10, :zone => stored_zone.name).
       and_return(stored_zone_operation)
-    client = mock(Google::Compute::Client, :zones=>zones, :disks=>disks)
-    Google::Compute::Client.stub!(:from_json).and_return(client)
+    client = double(Google::Compute::Client, :zones => zones, :disks => disks)
+    Google::Compute::Client.stub(:from_json).and_return(client)
+    knife_plugin.config[:disk_size] = 10
     knife_plugin.run
   end
 end

data/spec/chef/knife/google_disk_delete_spec.rb

@@ -15,51 +15,50 @@
 require 'spec_helper'
 
 describe Chef::Knife::GoogleDiskDelete do
-
   let(:knife_plugin) do
     Chef::Knife::GoogleDiskDelete.new([stored_disk.name, "-Z"+stored_zone.name])
   end
 
   it "should print out error message if the disk is not found" do
-    zones = mock(Google::Compute::ListableResourceCollection)
+    zones = double(Google::Compute::ListableResourceCollection)
     zones.should_receive(:get).with(stored_zone.name).
       and_return(stored_zone)
-    disks = mock(Google::Compute::DeletableResourceCollection)
+    disks = double(Google::Compute::DeletableResourceCollection)
     disks.should_receive(:get).
-      with(:zone=>stored_zone.name, :disk=>stored_disk.name).
+      with(:zone => stored_zone.name, :disk => stored_disk.name).
       and_raise(Google::Compute::ResourceNotFound)
     disks.should_not_receive(:delete)
-    client = mock(Google::Compute::Client,
-      :disks=>disks, :zones=>zones)
-    Google::Compute::Client.stub!(:from_json).and_return(client)
+    client = double(Google::Compute::Client,
+      :disks => disks, :zones => zones)
+    Google::Compute::Client.stub(:from_json).and_return(client)
 
     knife_plugin.config[:yes] = true
     knife_plugin.ui.should_receive(:error).
       with("Disk '#{stored_zone.name}:#{stored_disk.name}' not found")
-    knife_plugin.stub!(:msg_pair)
+    knife_plugin.stub(:msg_pair)
     expect {
       knife_plugin.run
     }.to raise_error(SystemExit)
   end
 
   it "should invoke api delete method when run is called" do
-    zones = mock(Google::Compute::ListableResourceCollection)
+    zones = double(Google::Compute::ListableResourceCollection)
     zones.should_receive(:get).with(stored_zone.name).
       and_return(stored_zone)
-    disks = mock(Google::Compute::DeletableResourceCollection)
+    disks = double(Google::Compute::DeletableResourceCollection)
     disks.should_receive(:get).
-      with(:zone=>stored_zone.name, :disk=>stored_disk.name).
+      with(:zone => stored_zone.name, :disk => stored_disk.name).
       and_return(stored_disk)
     disks.should_receive(:delete).
-      with(:zone=>stored_zone.name, :disk=>stored_disk.name)
-    client = mock(Google::Compute::Client,
-      :zones=>zones,:disks=>disks)
-    Google::Compute::Client.stub!(:from_json).
+      with(:zone => stored_zone.name, :disk => stored_disk.name)
+    client = double(Google::Compute::Client,
+      :zones => zones, :disks => disks)
+    Google::Compute::Client.stub(:from_json).
       and_return(client)
     knife_plugin.config[:yes] = true
     knife_plugin.ui.should_receive(:warn).
       with("Disk '#{stored_zone.name}:#{stored_disk.name}' deleted")
-    knife_plugin.stub!(:msg_pair)
+    knife_plugin.stub(:msg_pair)
     knife_plugin.run
   end
 end

data/spec/chef/knife/google_disk_list_spec.rb

@@ -12,24 +12,24 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
+
 require 'spec_helper'
 
 describe Chef::Knife::GoogleDiskList do
-
   let(:knife_plugin) do
     Chef::Knife::GoogleDiskList.new(["-Z"+stored_zone.name])
   end
 
   it "should enlist all the GCE disks when run invoked" do
-    zones = mock(Google::Compute::ListableResourceCollection)
+    zones = double(Google::Compute::ListableResourceCollection)
     zones.should_receive(:get).with(stored_zone.name).
       and_return(stored_zone)
-    disks = mock(Google::Compute::ListableResourceCollection)
-    disks.should_receive(:list).with(:zone=>stored_zone.name).
+    disks = double(Google::Compute::ListableResourceCollection)
+    disks.should_receive(:list).with(:zone => stored_zone.name).
       and_return([stored_disk])
 
-    client = mock(Google::Compute::Client, :disks=>disks, :zones=>zones)
-    Google::Compute::Client.stub!(:from_json).and_return(client)
+    client = double(Google::Compute::Client, :disks => disks, :zones => zones)
+    Google::Compute::Client.stub(:from_json).and_return(client)
     $stdout.should_receive(:write).with(kind_of(String))
     knife_plugin.run
   end

data/spec/chef/knife/google_region_list_spec.rb

@@ -0,0 +1,32 @@
+# Copyright 2013 Google Inc. All Rights Reserved.
+#
+# 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::GoogleRegionList do
+  let(:knife_plugin) do
+    Chef::Knife::GoogleRegionList.new([])
+  end
+
+  it "should enlist all the GCE regions when run invoked" do
+    client = double(Google::Compute::Client)
+    Google::Compute::Client.stub(:from_json).
+      and_return(client)
+    client.should_receive(:regions).
+      and_return(double("region-collection", :list => [stored_region]))
+    $stdout.should_receive(:write).with(kind_of(String))
+    knife_plugin.run
+  end
+end

data/spec/chef/knife/google_server_create_spec.rb

@@ -12,91 +12,125 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
+
 require 'spec_helper'
 
 describe Chef::Knife::GoogleServerCreate do
-
   before(:each) do
-    zones = mock(Google::Compute::ListableResourceCollection)
+
+    zones = double(Google::Compute::ListableResourceCollection)
     zones.should_receive(:get).with(stored_zone.name).
       and_return(stored_zone)
 
-    machine_types = mock(Google::Compute::ListableResourceCollection)
+    machine_types = double(Google::Compute::ListableResourceCollection)
     machine_types.should_receive(:get).
-      with({:name=>stored_machine_type.name, :zone=>stored_zone.name}).
+      with({:name => stored_machine_type.name, :zone => stored_zone.name}).
       and_return(stored_machine_type)
 
-    images = mock(Google::Compute::ListableResourceCollection)
+    images = double(Google::Compute::ListableResourceCollection)
     images.should_receive(:get).
-      with({:project=>"debian-cloud", :name=>stored_image.name}).
+      with({:project => "mock-project", :name => stored_image.name}).
       and_return(stored_image)
 
-    networks = mock(Google::Compute::ListableResourceCollection)
+    sizeGb = 10
+    disks = double(Google::Compute::ListableResourceCollection)
+    disks.should_receive(:insert).
+      with({:sourceImage => stored_image.self_link, :zone => stored_zone.name,
+            :name => stored_instance.name, :sizeGb => sizeGb}).
+      and_return(stored_disk)
+
+    networks = double(Google::Compute::ListableResourceCollection)
     networks.should_receive(:get).with(stored_network.name).
       and_return(stored_network)
 
-    instances = mock(Google::Compute::ListableResourceCollection)
-    instances.should_receive(:create).with(
-      {:name=>stored_instance.name, :image=>stored_image.self_link,
-      :machineType=>stored_machine_type.self_link, :disks=>[],
-      :metadata=>{"items"=>[]}, :zone=>stored_zone.name,
-      :networkInterfaces=>[
-        {"network"=>stored_network.self_link,
-        "accessConfigs"=>[
-          {"name"=>"External NAT", "type"=>"ONE_TO_ONE_NAT"}]}],
-      :tags=>nil}).and_return(stored_zone_operation)
+    instances = double(Google::Compute::ListableResourceCollection)
+    instances.should_receive(:create).with({
+      :name => stored_instance.name,
+      :zone => stored_zone.name,
+      :machineType => stored_machine_type.self_link,
+      #:image => stored_image.self_link,
+      :disks => [{
+        "boot" => true,
+        "type" => "PERSISTENT",
+        "mode" => "READ_WRITE",
+        "deviceName" => "",
+        "source" => nil}],
+      :networkInterfaces => [{
+        "network" => stored_network.self_link,
+        "accessConfigs" => [{
+          "name" => "External NAT",
+          "type" => "ONE_TO_ONE_NAT"}]}],
+      :serviceAccounts => [{
+        "kind" => "compute#serviceAccount",
+        "email" => "123845678986@project.gserviceaccount.com",
+        "scopes" => [
+          "https://www.googleapis.com/auth/userinfo.email",
+          "https://www.googleapis.com/auth/compute",
+          "https://www.googleapis.com/auth/devstorage.full_control"]}],
+      :scheduling=>{
+        "automaticRestart" => "false",
+        "onHostMaintenance" => "TERMINATE"},
+      :metadata => {"items" => []},
+      :tags => {"items" => []}}).and_return(stored_zone_operation)
 
     instances.should_receive(:get).
-      with(:zone=>stored_zone.name, :name=>stored_instance.name).
+      with(:zone => stored_zone.name, :name => stored_instance.name).
       and_return(stored_instance)
 
-    client = mock(Google::Compute::Client, :instances=>instances,
-      :images=>images, :zones=>zones,:machine_types=>machine_types,
-      :networks=>networks)
-    Google::Compute::Client.stub!(:from_json).and_return(client)
+    client = double(Google::Compute::Client, :instances => instances,
+      :images => images, :zones => zones,:machine_types => machine_types,
+      :networks => networks, :disks => disks)
+    Google::Compute::Client.stub(:from_json).and_return(client)
   end
 
-  it "#run should invoke compute api to create an server" do
-    knife_plugin = Chef::Knife::GoogleServerCreate.new(["-m"+stored_machine_type.name,
-      "-I"+stored_image.name, "-J"+"debian-cloud",
+  it "#run should invoke compute api to create an server with a service account" do
+    knife_plugin = Chef::Knife::GoogleServerCreate.new([
+      "-m"+stored_machine_type.name,
+      "-I"+stored_image.name,
       "-n"+stored_network.name,
-      "-Z"+stored_zone.name, stored_instance.name])
-    knife_plugin.config[:disks]=[]
+      "-Z"+stored_zone.name, 
+      stored_instance.name])
+    knife_plugin.config[:service_account_scopes]=["https://www.googleapis.com/auth/userinfo.email","https://www.googleapis.com/auth/compute","https://www.googleapis.com/auth/devstorage.full_control"]
+    knife_plugin.config[:service_account_name]='123845678986@project.gserviceaccount.com'
+    knife_plugin.config[:boot_disk_size]='10'
     knife_plugin.config[:metadata]=[]
+    knife_plugin.config[:tags]=[]
     knife_plugin.config[:public_ip]='EPHEMERAL'
-    knife_plugin.ui.stub!(:info)
-
-    knife_plugin.stub!(:wait_for_sshd)
+    knife_plugin.ui.stub(:info)
+    knife_plugin.stub(:wait_for_disk)
+    knife_plugin.stub(:wait_for_sshd)
     knife_plugin.should_receive(:bootstrap_for_node).
       with(stored_instance,'10.100.0.10').
-      and_return(mock("Chef::Knife::Bootstrap",:run=>true))
-
+      and_return(double("Chef::Knife::Bootstrap",:run => true))
     knife_plugin.run
   end
 
   it "should read zone value from knife config file." do
-    Chef::Config[:knife][:google_compute_zone] = stored_zone.name
-    knife_plugin = Chef::Knife::GoogleServerCreate.new(["-m"+stored_machine_type.name,
-      "-I"+stored_image.name, "-J"+"debian-cloud",
+    Chef::Config[:knife][:gce_zone] = stored_zone.name
+    knife_plugin = Chef::Knife::GoogleServerCreate.new([
+      "-m"+stored_machine_type.name,
+      "-I"+stored_image.name,
       "-n"+stored_network.name,
-       stored_instance.name])
-    knife_plugin.config[:disks]=[]
+      stored_instance.name])
+    knife_plugin.config[:service_account_scopes]=["https://www.googleapis.com/auth/userinfo.email","https://www.googleapis.com/auth/compute","https://www.googleapis.com/auth/devstorage.full_control"]
+    knife_plugin.config[:service_account_name]='123845678986@project.gserviceaccount.com'
+    knife_plugin.config[:boot_disk_size]='10'
     knife_plugin.config[:metadata]=[]
+    knife_plugin.config[:tags]=[]
     knife_plugin.config[:public_ip]='EPHEMERAL'
-    knife_plugin.ui.stub!(:info)
-
-    knife_plugin.stub!(:wait_for_sshd)
+    knife_plugin.ui.stub(:info)
+    knife_plugin.stub(:wait_for_disk)
+    knife_plugin.stub(:wait_for_sshd)
     knife_plugin.should_receive(:bootstrap_for_node).
-      with(stored_instance,'10.100.0.10').
-      and_return(mock("Chef::Knife::Bootstrap",:run=>true))
+      with(stored_instance, '10.100.0.10').
+      and_return(double("Chef::Knife::Bootstrap", :run => true))
     knife_plugin.run
   end
-
 end
 
 describe "without appropriate command line options" do
   it "should throw exception when required params are not passed" do
-    $stdout.stub!(:write) # lets not print those error messages
+    $stdout.stub(:write) # lets not print those error messages
     expect {
       Chef::Knife::GoogleServerCreate.new([ "NAME"])
     }.to raise_error(SystemExit)

data/spec/chef/knife/google_server_delete_spec.rb

@@ -17,84 +17,84 @@
 require 'spec_helper'
 
 describe Chef::Knife::GoogleServerDelete do
-
   let(:knife_plugin) do
     Chef::Knife::GoogleServerDelete.new(
       [stored_instance.name, "-Z"+stored_zone.name])
   end
 
   it "should print out error message if the server is not found" do
-    zones = mock(Google::Compute::ListableResourceCollection)
+    zones = double(Google::Compute::ListableResourceCollection)
     zones.should_receive(:get).with(stored_zone.name).
       and_return(stored_zone)
 
-    instances = mock(Google::Compute::DeletableResourceCollection)
+    instances = double(Google::Compute::DeletableResourceCollection)
     instances.should_receive(:get).
-      with(:name=>stored_instance.name, :zone=>stored_zone.name).
+      with(:name => stored_instance.name, :zone => stored_zone.name).
       and_raise(Google::Compute::ResourceNotFound)
     instances.should_not_receive(:delete)
 
-    client = mock(Google::Compute::Client,
-      :instances=>instances, :zones=>zones)
-    Google::Compute::Client.stub!(:from_json).and_return(client)
+    client = double(Google::Compute::Client,
+      :instances => instances, :zones => zones)
+    Google::Compute::Client.stub(:from_json).and_return(client)
 
     knife_plugin.config[:yes] = true
     knife_plugin.ui.should_receive(:error).
       with("Could not locate server '#{stored_zone.name}:#{stored_instance.name}'.")
-    knife_plugin.stub!(:msg_pair)
+    knife_plugin.stub(:msg_pair)
     knife_plugin.run
   end
 
   describe "without purge" do
 
     it "should invoke api delete method when run is called" do
-      zones = mock(Google::Compute::ListableResourceCollection)
+      zones = double(Google::Compute::ListableResourceCollection)
       zones.should_receive(:get).with(stored_zone.name).
         and_return(stored_zone)
 
-      instances = mock(Google::Compute::DeletableResourceCollection)
+      instances = double(Google::Compute::DeletableResourceCollection)
       instances.should_receive(:get).
-        with(:name=>stored_instance.name, :zone=>stored_zone.name).
+        with(:name => stored_instance.name, :zone => stored_zone.name).
         and_return(stored_instance)
       instances.should_receive(:delete).
-        with(:instance=>stored_instance.name, :zone=>stored_zone.name)
+        with(:instance => stored_instance.name, :zone => stored_zone.name)
 
-      client = mock(Google::Compute::Client,
-        :zones=>zones, :instances=>instances)
-      Google::Compute::Client.stub!(:from_json).and_return(client)
+      client = double(Google::Compute::Client,
+        :zones => zones, :instances => instances)
+      Google::Compute::Client.stub(:from_json).and_return(client)
+      knife_plugin.ui.should_receive(:warn)
       knife_plugin.config[:yes] = true
       knife_plugin.ui.should_receive(:warn).twice
-      knife_plugin.stub!(:msg_pair)
+      knife_plugin.stub(:msg_pair)
       knife_plugin.run
     end
   end
 
   describe "with purge" do
     it "should invoke api delete method as well as chef objects destroy when run is called" do
-      chef_client = mock(Chef::ApiClient)
+      chef_client = double(Chef::ApiClient)
       chef_client.should_receive(:destroy)
-      chef_node = mock(Chef::Node)
+      chef_node = double(Chef::Node)
       chef_node.should_receive(:destroy)
 
-      zones = mock(Google::Compute::ListableResourceCollection)
+      zones = double(Google::Compute::ListableResourceCollection)
       zones.should_receive(:get).with(stored_zone.name).
         and_return(stored_zone)
 
-      instances = mock(Google::Compute::DeletableResourceCollection)
+      instances = double(Google::Compute::DeletableResourceCollection)
       instances.should_receive(:get).
-        with(:name=>stored_instance.name, :zone=>stored_zone.name).
+        with(:name => stored_instance.name, :zone => stored_zone.name).
         and_return(stored_instance)
       instances.should_receive(:delete).
-        with(:instance=>stored_instance.name, :zone=>stored_zone.name)
+        with(:instance => stored_instance.name, :zone => stored_zone.name)
 
-      client = mock(Google::Compute::Client,
-        :zones=>zones, :instances=>instances)
-      Google::Compute::Client.stub!(:from_json).and_return(client)
+      client = double(Google::Compute::Client,
+        :zones => zones, :instances => instances)
+      Google::Compute::Client.stub(:from_json).and_return(client)
 
       knife_plugin.config[:yes] = true
       knife_plugin.config[:purge] = true
-      knife_plugin.ui.stub!(:warn)
-      knife_plugin.stub!(:msg_pair)
+      knife_plugin.ui.stub(:warn)
+      knife_plugin.stub(:msg_pair)
       Chef::Node.should_receive(:load).with(stored_instance.name).
         and_return(chef_node)
       Chef::ApiClient.should_receive(:load).with(stored_instance.name).
@@ -106,22 +106,22 @@ end
 
 describe Chef::Knife::GoogleServerDelete do
   it "should read zone value from knife config file." do
-    Chef::Config[:knife][:google_compute_zone] = stored_zone.name
+    Chef::Config[:knife][:gce_zone] = stored_zone.name
     knife_plugin = Chef::Knife::GoogleServerDelete.new([stored_instance.name])
-    zones = mock(Google::Compute::ListableResourceCollection)
+    zones = double(Google::Compute::ListableResourceCollection)
     zones.should_receive(:get).with(stored_zone.name).and_return(stored_zone)
 
-    instances = mock(Google::Compute::DeletableResourceCollection)
-    instances.should_receive(:get).with(:name=>stored_instance.name, :zone=>stored_zone.name).
+    instances = double(Google::Compute::DeletableResourceCollection)
+    instances.should_receive(:get).with(:name => stored_instance.name, :zone => stored_zone.name).
         and_return(stored_instance)
-    instances.should_receive(:delete).with(:instance=>stored_instance.name, :zone=>stored_zone.name)
+    instances.should_receive(:delete).with(:instance => stored_instance.name, :zone => stored_zone.name)
 
-    client = mock(Google::Compute::Client, :zones=>zones, :instances=>instances)
-    Google::Compute::Client.stub!(:from_json).and_return(client)
+    client = double(Google::Compute::Client, :zones => zones, :instances => instances)
+    Google::Compute::Client.stub(:from_json).and_return(client)
+    knife_plugin.ui.should_receive(:warn)
     knife_plugin.config[:yes] = true
     knife_plugin.ui.should_receive(:warn).twice
-    knife_plugin.stub!(:msg_pair)
+    knife_plugin.stub(:msg_pair)
     knife_plugin.run
-    
   end
-end
+end