brightbox-cli 0.16.0 → 0.17.0

data/lib/brightbox-cli/vendor/fog/lib/fog/vsphere/compute.rb

@@ -21,6 +21,7 @@ module Fog
       request :vm_reboot
       request :vm_clone
       request :vm_destroy
+      request :datacenters
 
       module Shared
 
@@ -29,36 +30,52 @@ module Fog
         attr_reader :vsphere_server
         attr_reader :vsphere_username
 
+        ATTR_TO_PROP = {
+          :id => 'config.instanceUuid',
+          :name => 'name',
+          :uuid => 'config.uuid',
+          :instance_uuid => 'config.instanceUuid',
+          :hostname => 'summary.guest.hostName',
+          :operatingsystem => 'summary.guest.guestFullName',
+          :ipaddress => 'guest.ipAddress',
+          :power_state => 'runtime.powerState',
+          :connection_state => 'runtime.connectionState',
+          :hypervisor => 'runtime.host',
+          :tools_state => 'guest.toolsStatus',
+          :tools_version => 'guest.toolsVersionStatus',
+          :is_a_template => 'config.template',
+        }
+
         # Utility method to convert a VMware managed object into an attribute hash.
         # This should only really be necessary for the real class.
         # This method is expected to be called by the request methods
         # in order to massage VMware Managed Object References into Attribute Hashes.
         def convert_vm_mob_ref_to_attr_hash(vm_mob_ref)
           return nil unless vm_mob_ref
-          # A cloning VM doesn't have a configuration yet.  Unfortuantely we just get
-          # a RunTime exception.
-          begin
-            is_ready = vm_mob_ref.config ? true : false
-          rescue RuntimeError
-            is_ready = nil
+
+          props = vm_mob_ref.collect! *ATTR_TO_PROP.values.uniq
+          # NOTE: Object.tap is in 1.8.7 and later.
+          # Here we create the hash object that this method returns, but first we need
+          # to add a few more attributes that require additional calls to the vSphere
+          # API. The hypervisor name and mac_addresses attributes may not be available
+          # so we need catch any exceptions thrown during lookup and set them to nil.
+          #
+          # The use of the "tap" method here is a convience, it allows us to update the
+          # hash object without expliclty returning the hash at the end of the method.
+          Hash[ATTR_TO_PROP.map { |k,v| [k.to_s, props[v]] }].tap do |attrs|
+            attrs['id'] ||= vm_mob_ref._ref
+            attrs['mo_ref'] = vm_mob_ref._ref
+            # The name method "magically" appears after a VM is ready and
+            # finished cloning.
+            if attrs['hypervisor'].kind_of?(RbVmomi::VIM::HostSystem) then
+              # If it's not ready, set the hypervisor to nil
+              attrs['hypervisor'] = attrs['hypervisor'].name rescue nil
+            end
+            # This inline rescue catches any standard error.  While a VM is
+            # cloning, a call to the macs method will throw and NoMethodError
+            attrs['mac_addresses'] = vm_mob_ref.macs rescue nil
+            attrs['path'] = get_folder_path(vm_mob_ref.parent)
           end
-          {
-            'id'               => is_ready ? vm_mob_ref.config.instanceUuid : vm_mob_ref._ref,
-            'mo_ref'           => vm_mob_ref._ref,
-            'name'             => vm_mob_ref.name,
-            'uuid'             => is_ready ? vm_mob_ref.config.uuid : nil,
-            'instance_uuid'    => is_ready ? vm_mob_ref.config.instanceUuid : nil,
-            'hostname'         => vm_mob_ref.summary.guest.hostName,
-            'operatingsystem'  => vm_mob_ref.summary.guest.guestFullName,
-            'ipaddress'        => vm_mob_ref.summary.guest.ipAddress,
-            'power_state'      => vm_mob_ref.runtime.powerState,
-            'connection_state' => vm_mob_ref.runtime.connectionState,
-            'hypervisor'       => vm_mob_ref.runtime.host ? vm_mob_ref.runtime.host.name : nil,
-            'tools_state'      => vm_mob_ref.summary.guest.toolsStatus,
-            'tools_version'    => vm_mob_ref.summary.guest.toolsVersionStatus,
-            'mac_addresses'    => is_ready ? vm_mob_ref.macs : nil,
-            'is_a_template'    => is_ready ? vm_mob_ref.config.template : nil
-          }
         end
 
       end
@@ -68,6 +85,7 @@ module Fog
         include Shared
 
         def initialize(options={})
+          require 'rbvmomi'
           @vsphere_username = options[:vsphere_username]
           @vsphere_password = 'REDACTED'
           @vsphere_server   = options[:vsphere_server]

data/lib/brightbox-cli/vendor/fog/lib/fog/vsphere/models/compute/server.rb

@@ -33,6 +33,7 @@ module Fog
         attribute :is_a_template
         attribute :connection_state
         attribute :mo_ref
+        attribute :path
 
         def start(options = {})
           requires :instance_uuid
@@ -56,6 +57,24 @@ module Fog
           connection.vm_destroy('instance_uuid' => instance_uuid)
         end
 
+        def clone(options = {})
+          requires :name, :path
+          # Convert symbols to strings
+          req_options = options.inject({}) { |hsh, (k,v)| hsh[k.to_s] = v; hsh }
+          # Give our path to the request
+          req_options['path'] ="#{path}/#{name}"
+          # Perform the actual clone
+          clone_results = connection.vm_clone(req_options)
+          # Create the new VM model.
+          new_vm = self.class.new(clone_results['vm_attributes'])
+          # We need to assign the collection and the connection otherwise we
+          # cannot reload the model.
+          new_vm.collection = self.collection
+          new_vm.connection = self.connection
+          # Return the new VM model.
+          new_vm
+        end
+
       end
 
     end

data/lib/brightbox-cli/vendor/fog/lib/fog/vsphere/models/compute/servers.rb

@@ -9,8 +9,14 @@ module Fog
 
         model Fog::Compute::Vsphere::Server
 
-        def all
-          response = connection.list_virtual_machines
+        # 'path' => '/Datacenters/vm/Jeff/Templates' will be MUCH faster.
+        # than simply listing everything.
+        def all(filters = {})
+          # REVISIT: I'm not sure if this is the best way to implement search
+          # filters on a collection but it does work.  I need to study the AWS
+          # code more to make sure this matches up.
+          filters['folder'] ||= attributes['folder']
+          response = connection.list_virtual_machines(filters)
           load(response['virtual_machines'])
         end
 

data/lib/brightbox-cli/vendor/fog/lib/fog/vsphere/requests/compute/datacenters.rb

@@ -0,0 +1,34 @@
+module Fog
+  module Compute
+    class Vsphere
+      class Real
+        def datacenters
+          @datacenters ||= datacenters_reload
+          # Hide the values which are the RbVmomi instances
+          @datacenters.keys
+        end
+
+        private
+
+        def datacenters_reload
+          @rootfolder  ||= @connection.rootFolder
+          inventory = @rootfolder.inventory(:Datacenter => [ 'name' ])[@rootfolder]
+          # Convert the inventory into a Hash of the form: We remove the
+          # property selectors.  { "<dc_name>" => #<RbVmomi::VIM::Datacenter> }
+          # The Datacenter instance itself is at index 0 and the properties we
+          # collected are at index 1.
+          inventory.inject({}) do |memo, (name,dc_ary)|
+            memo[name] = dc_ary[0]
+            memo
+          end
+        end
+      end
+
+      class Mock
+        def datacenters
+          [ "Solutions", "Solutions2", "Solutions3" ]
+        end
+      end
+    end
+  end
+end

data/lib/brightbox-cli/vendor/fog/lib/fog/vsphere/requests/compute/list_virtual_machines.rb

@@ -1,13 +1,15 @@
 module Fog
   module Compute
     class Vsphere
-
       class Real
-
         def list_virtual_machines(options = {})
-          # First, determine if there's a search filter
+          # Listing all VM's can be quite slow and expensive.  Try and optimize
+          # based on the available options we have.  These conditions are in
+          # ascending order of  time to complete for large deployments.
           if options['instance_uuid'] then
             list_all_virtual_machines_by_instance_uuid(options)
+          elsif options['folder'] then
+            list_all_virtual_machines_in_folder(options)
           else
             list_all_virtual_machines
           end
@@ -15,6 +17,48 @@ module Fog
 
         private
 
+        def list_all_virtual_machines_in_folder(options = {})
+          # Tap gets rid of the leading empty string and "Datacenters" element
+          # and returns the array.
+          path_elements = options['folder'].split('/').tap { |ary| ary.shift 2 }
+          # The DC name itself.
+          dc_name = path_elements.shift
+          # If the first path element contains "vm" this denotes the vmFolder
+          # and needs to be shifted out since each DC contains only one
+          # vmFolder
+          path_elements.shift if path_elements[0] = 'vm'
+          # Make sure @datacenters is populated (the keys are DataCenter instances)
+          self.datacenters.include? dc_name or raise ArgumentError, "Could not find a Datacenter named #{dc_name}"
+          # Get the datacenter managed object
+          dc = @datacenters[dc_name]
+
+          # Get the VM Folder (Group) efficiently
+          vm_folder = dc.vmFolder
+
+          # Walk the tree resetting the folder pointer as we go
+          folder = path_elements.inject(vm_folder) do |current_folder, sub_folder_name|
+            # JJM VIM::Folder#find appears to be quite efficient as it uses the
+            # searchIndex It certainly appears to be faster than
+            # VIM::Folder#inventory since that returns _all_ managed objects of
+            # a certain type _and_ their properties.
+            sub_folder = current_folder.find(sub_folder_name, RbVmomi::VIM::Folder)
+            raise ArgumentError, "Could not descend into #{sub_folder_name}.  Please check your path." unless sub_folder
+            sub_folder
+          end
+
+          # This should be efficient since we're not obtaining properties
+          virtual_machines = folder.children.inject([]) do |ary, child|
+            if child.is_a? RbVmomi::VIM::VirtualMachine then
+              ary << convert_vm_mob_ref_to_attr_hash(child)
+            end
+            ary
+          end
+
+          # Return the managed objects themselves as an array.  These may be converted
+          # to an attribute has using convert_vm_mob_ref_to_attr_hash
+          { 'virtual_machines' => virtual_machines }
+        end
+
         def list_all_virtual_machines_by_instance_uuid(options = {})
           uuid = options['instance_uuid']
           search_filter = { :uuid => uuid, 'vmSearch' => true, 'instanceUuid' => true }
@@ -34,6 +78,7 @@ module Fog
           { 'virtual_machines' => virtual_machines }
         end
 
+
         # NOTE: This is a private instance method required by the vm_clone
         # request.  It's very hard to get the Managed Object Reference
         # of a Template because we can't search for it by instance_uuid
@@ -45,19 +90,50 @@ module Fog
           datacenters = @connection.rootFolder.children.find_all do |child|
             child.kind_of? RbVmomi::VIM::Datacenter
           end
-          # Next, look in the "vmFolder" of each data center:
+          # Next, search the "vmFolder" inventory of each data center:
           datacenters.each do |dc|
-            dc.vmFolder.children.each do |vm|
-              virtual_machines << vm
+            inventory = dc.vmFolder.inventory( 'VirtualMachine' => :all )
+            virtual_machines << find_all_in_inventory(inventory, :type => RbVmomi::VIM::VirtualMachine, :property => 'name' )
+          end
+
+          virtual_machines.flatten
+        end
+
+        def find_all_in_inventory(inventory, properties = { :type => RbVmomi::VIM::VirtualMachine, :property => nil } )
+          results = Array.new
+
+          inventory.each do |k,v|
+
+            # If we have a VMware folder we need to traverse the directory
+            # to ensure we pick VMs inside folders. So we do a bit of recursion
+            # here.
+            results << find_all_in_inventory(v) if k.is_a? RbVmomi::VIM::Folder
+
+            if v[0].is_a? properties[:type]
+              if properties[:property].nil?
+                results << v[0]
+              else
+                results << v[1][properties[:property]]
+              end
             end
           end
-          virtual_machines
+          results.flatten
         end
 
+        def get_folder_path(folder, root = nil)
+          if ( not folder.methods.include?('parent') ) or ( folder == root )
+            return
+          end
+          "#{get_folder_path(folder.parent)}/#{folder.name}"
+        end
       end
 
       class Mock
 
+        def get_folder_path(folder, root = nil)
+          nil
+        end
+
         def list_virtual_machines(options = {})
           case options['instance_uuid']
           when nil
@@ -154,10 +230,7 @@ module Fog
             { 'virtual_machines' => [] }
           end
         end
-
       end
-
     end
   end
 end
-

data/lib/brightbox-cli/vendor/fog/lib/fog/vsphere/requests/compute/vm_clone.rb

@@ -6,14 +6,19 @@ module Fog
         private
         def vm_clone_check_options(options)
           options = { 'force' => false }.merge(options)
-          required_options = %w{ instance_uuid name }
+          required_options = %w{ path name }
           required_options.each do |param|
             raise ArgumentError, "#{required_options.join(', ')} are required" unless options.has_key? param
           end
-          # First, figure out if there's already a VM of the same name.
-          all_virtual_machines = list_virtual_machines['virtual_machines']
-          if not options['force'] and all_virtual_machines.detect { |vm| vm['name'] == options['name'] } then
-            raise Fog::Vsphere::Errors::ServiceError, "A VM already exists with name #{options['name']}"
+          # The tap removes the leading empty string
+          path_elements = options['path'].split('/').tap { |o| o.shift }
+          first_folder = path_elements.shift
+          if first_folder != 'Datacenters' then
+            raise ArgumentError, "vm_clone path option must start with /Datacenters.  Got: #{options['path']}"
+          end
+          dc_name = path_elements.shift
+          if not self.datacenters.include? dc_name then
+            raise ArgumentError, "Datacenter #{dc_name} does not exist, only datacenters #{self.dacenters.join(",")} are accessible."
           end
           options
         end
@@ -25,23 +30,47 @@ module Fog
           # Option handling
           options = vm_clone_check_options(options)
 
-          notfound = lambda { raise Fog::Compute::Vsphere::NotFound, "Cloud not find VM template" }
+          notfound = lambda { raise Fog::Compute::Vsphere::NotFound, "Could not find VM template" }
 
-          # REVISIT: This will have horrible performance for large sites.
-          # Find the Managed Object reference of the template VM (Wish I could do this with the API)
-          vm_mob_ref = list_all_virtual_machine_mobs.find(notfound) do |vm|
-            convert_vm_mob_ref_to_attr_hash(vm)['instance_uuid'] == options['instance_uuid']
+          # Find the template in the folder.  This is more efficient than
+          # searching ALL VM's looking for the template.
+          # Tap gets rid of the leading empty string and "Datacenters" element
+          # and returns the array.
+          path_elements = options['path'].split('/').tap { |ary| ary.shift 2 }
+          # The DC name itself.
+          template_dc = path_elements.shift
+          # If the first path element contains "vm" this denotes the vmFolder
+          # and needs to be shifted out
+          path_elements.shift if path_elements[0] = 'vm'
+          # The template name.  The remaining elements are the folders in the
+          # datacenter.
+          template_name = path_elements.pop
+          # Make sure @datacenters is populated.  We need the instances from the Hash keys.
+          self.datacenters
+          # Get the datacenter managed object from the hash
+          dc = @datacenters[template_dc]
+          # Get the VM Folder (Group) efficiently
+          vm_folder = dc.vmFolder
+          # Walk the tree resetting the folder pointer as we go
+          folder = path_elements.inject(vm_folder) do |current_folder, sub_folder_name|
+            # JJM VIM::Folder#find appears to be quite efficient as it uses the
+            # searchIndex It certainly appears to be faster than
+            # VIM::Folder#inventory since that returns _all_ managed objects of
+            # a certain type _and_ their properties.
+            sub_folder = current_folder.find(sub_folder_name, RbVmomi::VIM::Folder)
+            raise ArgumentError, "Could not descend into #{sub_folder_name}.  Please check your path." unless sub_folder
+            sub_folder
           end
 
-          # We need to locate the datacenter object to find the
-          # default resource pool.
-          container = vm_mob_ref.parent
-          until container.kind_of? RbVmomi::VIM::Datacenter
-            container = container.parent
-          end
-          dc = container
-          # With the Datacenter Object we can obtain the resource pool
-          resource_pool = dc.hostFolder.children.first.resourcePool
+          # Now find the template itself using the efficient find method
+          vm_mob_ref = folder.find(template_name, RbVmomi::VIM::VirtualMachine)
+
+          # Now find _a_ resource pool of the template's host (REVISIT: We need
+          # to support cloning into a specific RP)
+          esx_host = vm_mob_ref.collect!('runtime.host')['runtime.host']
+          # The parent of the ESX host itself is a ComputeResource which has a resourcePool
+          resource_pool = esx_host.parent.resourcePool
+
           # Next, create a Relocation Spec instance
           relocation_spec = RbVmomi::VIM.VirtualMachineRelocateSpec(:pool => resource_pool,
                                                                     :transform => options['transform'] || 'sparse')
@@ -50,27 +79,37 @@ module Fog
                                                             :powerOn  => options['power_on'] || true,
                                                             :template => false)
           task = vm_mob_ref.CloneVM_Task(:folder => vm_mob_ref.parent, :name => options['name'], :spec => clone_spec)
-          # REVISIT: The task object contains a reference to the template but does
-          # not appear to contain a reference to the newly created VM.
-          # This is a really naive way to find the managed object reference
-          # of the newly created VM.
-          tries = 0
-          new_vm = begin
-            list_virtual_machines['virtual_machines'].detect(lambda { raise Fog::Vsphere::Errors::NotFound }) do |vm|
-              vm['name'] == options['name']
-            end
-          rescue Fog::Vsphere::Errors::NotFound
-            tries += 1
-            if tries <= 10 then
-              sleep 1
-              retry
+
+          # Waiting for the VM to complete allows us to get the VirtulMachine
+          # object of the new machine when it's done.  It is HIGHLY recommended
+          # to set 'wait' => true if your app wants to wait.  Otherwise, you're
+          # going to have to reload the server model over and over which
+          # generates a lot of time consuming API calls to vmware.
+          if options['wait'] then
+            # REVISIT: It would be awesome to call a block passed to this
+            # request to notify the application how far along in the process we
+            # are.  I'm thinking of updating a progress bar, etc...
+            new_vm = task.wait_for_completion
+          else
+            tries = 0
+            new_vm = begin
+              # Try and find the new VM (folder.find is quite efficient)
+              folder.find(options['name'], RbVmomi::VIM::VirtualMachine) or raise Fog::Vsphere::Errors::NotFound
+            rescue Fog::Vsphere::Errors::NotFound
+              tries += 1
+              if tries <= 10 then
+                sleep 15
+                retry
+              end
+              nil
             end
-            nil
           end
+
           # Return hash
           {
-            'vm_ref'   => new_vm ? new_vm['mo_ref'] : nil,
-            'task_ref' => task._ref
+            'vm_ref'        => new_vm ? new_vm._ref : nil,
+            'vm_attributes' => new_vm ? convert_vm_mob_ref_to_attr_hash(new_vm) : {},
+            'task_ref'      => task._ref
           }
         end
 
@@ -83,7 +122,7 @@ module Fog
           options = vm_clone_check_options(options)
           notfound = lambda { raise Fog::Compute::Vsphere::NotFound, "Cloud not find VM template" }
           vm_mob_ref = list_virtual_machines['virtual_machines'].find(notfound) do |vm|
-            vm['instance_uuid'] == options['instance_uuid']
+            vm['name'] == options['path'].split("/")[-1]
           end
           {
             'vm_ref'   => 'vm-123',

data/lib/brightbox-cli/vendor/fog/lib/fog.rb

@@ -3,7 +3,7 @@ require File.join(File.dirname(__FILE__), 'fog', 'core')
 module Fog
 
   unless const_defined?(:VERSION)
-    VERSION = '1.0.0'
+    VERSION = '1.1.1'
   end
 
 end

data/lib/brightbox-cli/vendor/fog/tests/aws/models/cloud_watch/alarm_data_tests.rb

@@ -1,22 +1,24 @@
 Shindo.tests("AWS::CloudWatch | alarm_data", ['aws', 'cloudwatch']) do
 
+  pending if Fog.mocking?
+
   tests('success') do
     tests("#all").succeeds do
       Fog::AWS[:cloud_watch].alarm_data.all
     end
-    
+
     alarm_name_prefix = {'AlarmNamePrefix'=>'tmp'}
-	tests("#all_by_prefix").succeeds do
+    tests("#all_by_prefix").succeeds do
       Fog::AWS[:cloud_watch].alarm_data.all(alarm_name_prefix)
     end
-    
+
     namespace = 'AWS/EC2'
     metric_name = 'CPUUtilization'
 
     tests("#get").succeeds do
       Fog::AWS[:cloud_watch].alarm_data.get(namespace, metric_name).to_json
     end
-    
+
     new_attributes = {
       :alarm_name => 'tmp-alarm',
       :comparison_operator => 'GreaterThanOrEqualToThreshold',
@@ -30,11 +32,11 @@ Shindo.tests("AWS::CloudWatch | alarm_data", ['aws', 'cloudwatch']) do
     tests('#new').returns(new_attributes) do
       Fog::AWS[:cloud_watch].alarm_data.new(new_attributes).attributes
     end
-    
+
     tests('#create').returns(new_attributes) do
       Fog::AWS[:cloud_watch].alarm_data.create(new_attributes).attributes
     end
-    
+
   end
 
 end

data/lib/brightbox-cli/vendor/fog/tests/aws/models/cloud_watch/alarm_history_tests.rb

@@ -1,10 +1,12 @@
 Shindo.tests("AWS::CloudWatch | alarm_histories", ['aws', 'cloudwatch']) do
 
+  pending if Fog.mocking?
+
   tests('success') do
     tests("#all").succeeds do
       Fog::AWS[:cloud_watch].alarm_histories.all
     end
-    
+
   new_attributes = {
       :alarm_name => 'tmp-alarm',
       :end_date => '',

data/lib/brightbox-cli/vendor/fog/tests/aws/models/compute/security_group_tests.rb

@@ -2,17 +2,10 @@ Shindo.tests("Fog::Compute[:aws] | security_group", ['aws']) do
 
   model_tests(Fog::Compute[:aws].security_groups, {:description => 'foggroupdescription', :name => 'foggroupname'}, true)
 
-  tests("a group with trailing whitespace") do
-    @group = Fog::Compute[:aws].security_groups.create(:name => "foggroup with spaces   ", :description => "   fog group desc   ")
-    test("name is correct") do
-      @group.name ==  "foggroup with spaces   "
-    end
-
-    test("description is correct") do
-      @group.description == "   fog group desc   "
-    end
+  tests("authorize and revoke helpers") do
+    @group = Fog::Compute[:aws].security_groups.create(:name => "foggroup", :description => "fog group desc")
 
-    @other_group = Fog::Compute[:aws].security_groups.create(:name => 'other group', :description => 'another group')
+    @other_group = Fog::Compute[:aws].security_groups.create(:name => 'fog other group', :description => 'another fog group')
 
     test("authorize access by another security group") do
       @group.authorize_group_and_owner(@other_group.name)
@@ -26,6 +19,18 @@ Shindo.tests("Fog::Compute[:aws] | security_group", ['aws']) do
       @group.ip_permissions.empty?
     end
 
+    test("authorize access to a port range") do
+      @group.authorize_port_range(5000..6000)
+      @group.reload
+      @group.ip_permissions.size == 1
+    end
+
+    test("revoke access to a port range") do
+      @group.revoke_port_range(5000..6000)
+      @group.reload
+      @group.ip_permissions.empty?
+    end
+
     @other_group.destroy
     @group.destroy
   end

data/lib/brightbox-cli/vendor/fog/tests/aws/models/elb/model_tests.rb

@@ -33,7 +33,7 @@ Shindo.tests('AWS::ELB | models', ['aws', 'elb']) do
 
     tests('create') do
       tests('without availability zones') do
-        elb = Fog::AWS[:elb].load_balancers.create(:id => elb_id)
+        elb = Fog::AWS[:elb].load_balancers.create(:id => elb_id, :availability_zones => @availability_zones)
         tests("availability zones are correct").returns(@availability_zones.sort) { elb.availability_zones.sort }
         tests("dns names is set").returns(true) { elb.dns_name.is_a?(String) }
         tests("created_at is set").returns(true) { Time === elb.created_at }
@@ -54,7 +54,7 @@ Shindo.tests('AWS::ELB | models', ['aws', 'elb']) do
       # Need to sleep here for IAM changes to propgate
       tests('with ListenerDescriptions') do
         @certificate = Fog::AWS[:iam].upload_server_certificate(AWS::IAM::SERVER_CERT_PUBLIC_KEY, AWS::IAM::SERVER_CERT_PRIVATE_KEY, @key_name).body['Certificate']
-        sleep(8) unless Fog.mocking?
+        sleep(10) unless Fog.mocking?
         listeners = [{
             'Listener' => {
               'LoadBalancerPort' => 2030, 'InstancePort' => 2030, 'Protocol' => 'HTTP'
@@ -67,7 +67,7 @@ Shindo.tests('AWS::ELB | models', ['aws', 'elb']) do
             },
             'PolicyNames' => []
           }]
-        elb3 = Fog::AWS[:elb].load_balancers.create(:id => "#{elb_id}-3", 'ListenerDescriptions' => listeners)
+        elb3 = Fog::AWS[:elb].load_balancers.create(:id => "#{elb_id}-3", 'ListenerDescriptions' => listeners, :availability_zones => @availability_zones)
         tests('there are 2 listeners').returns(2) { elb3.listeners.count }
         tests('instance_port is 2030').returns(2030) { elb3.listeners.first.instance_port }
         tests('lb_port is 2030').returns(2030) { elb3.listeners.first.lb_port }
@@ -81,7 +81,7 @@ Shindo.tests('AWS::ELB | models', ['aws', 'elb']) do
           'Listener' => {
           'LoadBalancerPort' => 443, 'InstancePort' => 80, 'Protocol' => 'HTTPS', "SSLCertificateId" => "fakecert"}
         }]
-        Fog::AWS[:elb].load_balancers.create(:id => "#{elb_id}-4", "ListenerDescriptions" => listeners)
+        Fog::AWS[:elb].load_balancers.create(:id => "#{elb_id}-4", "ListenerDescriptions" => listeners, :availability_zones => @availability_zones)
       end
     end
 

data/lib/brightbox-cli/vendor/fog/tests/aws/requests/cloud_formation/stack_tests.rb

@@ -18,6 +18,11 @@ Shindo.tests('AWS::CloudFormation | stack requests', ['aws', 'cloudformation'])
     'StackId'   => String
   }
 
+  @update_stack_format = {
+    'RequestId' => String,
+    'StackId'   => String
+  }
+
   @get_template_format = {
     'RequestId'     => String,
     'TemplateBody'  => String
@@ -103,6 +108,15 @@ Shindo.tests('AWS::CloudFormation | stack requests', ['aws', 'cloudformation'])
       ).body
     end
 
+    tests("update_stack('#{@stack_name}', 'TemplateURL' => '#{@template_url}', Parameters => {'KeyName' => 'cloudformation'})").formats(@update_stack_format) do
+      pending if Fog.mocking?
+      Fog::AWS[:cloud_formation].update_stack(
+        @stack_name,
+        'TemplateURL' => @template_url,
+        'Parameters'  => {'KeyName' => 'cloudformation'}
+      ).body
+    end
+
     tests("get_template('#{@stack_name})").formats(@get_template_format) do
       pending if Fog.mocking?
       Fog::AWS[:cloud_formation].get_template(@stack_name).body