fog 1.9.0 → 1.10.0

data/tests/aws/requests/rds/instance_tests.rb

@@ -1,4 +1,7 @@
 Shindo.tests('AWS::RDS | instance requests', ['aws', 'rds']) do
+  # Disabled due to https://github.com/fog/fog/1546
+  pending
+
   # random_differentiator
   # Useful when rapidly re-running tests, so we don't have to wait
   # serveral minutes for deleted servers to disappear
@@ -42,8 +45,8 @@ Shindo.tests('AWS::RDS | instance requests', ['aws', 'rds']) do
       body
     end
 
-    server.reload.wait_for { state == 'modifying' }
-    server.reload.wait_for { state == 'available' }
+    server.wait_for { state == 'modifying' }
+    server.wait_for { state == 'available' }
 
     tests 'new storage' do
       returns(new_storage){ server.allocated_storage}
@@ -55,8 +58,8 @@ Shindo.tests('AWS::RDS | instance requests', ['aws', 'rds']) do
       end
     end
 
-    server.reload.wait_for { state == 'rebooting' }
-    server.reload.wait_for { state == 'available'}
+    server.wait_for { state == 'rebooting' }
+    server.wait_for { state == 'available'}
 
     tests("#create_db_snapshot").formats(AWS::RDS::Formats::CREATE_DB_SNAPSHOT) do
       body = Fog::AWS[:rds].create_db_snapshot(@db_instance_id, @db_snapshot_id).body
@@ -68,7 +71,7 @@ Shindo.tests('AWS::RDS | instance requests', ['aws', 'rds']) do
       body = Fog::AWS[:rds].describe_db_snapshots.body
     end
 
-    server.reload.wait_for { state == 'available' }
+    server.wait_for { state == 'available' }
 
     tests( "#create read replica").formats(AWS::RDS::Formats::CREATE_READ_REPLICA) do
       Fog::AWS[:rds].create_db_instance_read_replica(@db_replica_id, @db_instance_id).body

data/tests/bluebox/requests/blb/helper.rb

@@ -0,0 +1,64 @@
+class Bluebox
+  module BLB
+    module Formats
+      LB_APPLICATION = {
+        'id' => String,
+        'ip_v4' => String,
+        'ip_v6' => String,
+        'name'  => String,
+        'lb_services' => Array,
+        'source_ip_v4' => Fog::Nullable::String,
+      }
+
+      LB_APPLICATIONS = [LB_APPLICATION]
+
+      LB_SERVICE = {
+        'name' => String,
+        'port' => Integer,
+        'private' => Fog::Boolean,
+        'status_username' => String,
+        'status_password' => String,
+        'status_url' => String,
+        'service_type' => String,
+        'created' => String,
+        'lb_backends' => Array,
+        'pem_file_uploaded?' => Fog::Nullable::Boolean,
+      }
+
+      LB_SERVICES = [LB_SERVICE]
+
+      LB_BACKEND = {
+        'id' => String,
+        'backend_name' => String,
+        'lb_machines' => Array,
+        'acl_name' => String,
+        'acl_name' => String,
+        'monitoring_url_hostname' => String,
+        'monitoring_url' => String,
+        'monitoring_url_hostname' => String,
+        'check_interval' => Integer,
+        'rise' => Fog::Nullable::Integer,
+        'order' => Fog::Nullable::Integer,
+        'fall' => Fog::Nullable::Integer,
+      }
+
+      LB_BACKENDS = [LB_BACKEND]
+
+      LB_MACHINE = {
+        'port' => Integer,
+        'id' => String,
+        'ip' => String,
+        'maxconn' => Integer,
+        'hostname' => String,
+        'created' => String,
+      }
+
+      ADD_MACHINE_TO_LB = [
+        { 'text' => String },
+        { 'status' => String },
+      ]
+
+      REMOVE_MACHINE_FROM_BACKEND = 'Record Removed.'
+    end
+  end
+end

data/tests/bluebox/requests/blb/lb_tests.rb

@@ -0,0 +1,75 @@
+require 'securerandom'
+
+Shindo.tests('Bluebox::BLB | lb_tests', ['bluebox']) do
+  pending if Fog.mocking?
+  
+  tests('success') do
+    @flavor_id    = compute_providers[:bluebox][:server_attributes][:flavor_id]
+    @image_id     = compute_providers[:bluebox][:server_attributes][:image_id]
+    @location_id  = compute_providers[:bluebox][:server_attributes][:location_id]
+    @password     = SecureRandom.base64(18)
+
+    tests("get_lb_applications").formats(Bluebox::BLB::Formats::LB_APPLICATIONS) do
+      @lb_applications = Fog::Bluebox[:blb].get_lb_applications.body
+    end
+
+    tests("get_lb_application").formats(Bluebox::BLB::Formats::LB_APPLICATION) do
+      Fog::Bluebox[:blb].get_lb_application(@lb_applications.first['id']).body
+    end
+
+    tests("get_lb_services").formats(Bluebox::BLB::Formats::LB_SERVICES) do
+      @lb_services = Fog::Bluebox[:blb].get_lb_services(@lb_applications.first['id']).body
+    end
+
+    tests("get_lb_service").formats(Bluebox::BLB::Formats::LB_SERVICE) do
+      Fog::Bluebox[:blb].get_lb_service(@lb_applications.first['id'], @lb_services.first['id']).body
+    end
+
+    tests("get_lb_backends").formats(Bluebox::BLB::Formats::LB_BACKENDS) do
+      @lb_backends = Fog::Bluebox[:blb].get_lb_backends(@lb_services.first['id']).body
+    end
+
+    tests("get_lb_backend").formats(Bluebox::BLB::Formats::LB_BACKEND) do
+      Fog::Bluebox[:blb].get_lb_backend(@lb_services.first['id'], @lb_backends.first['id']).body
+    end
+
+    # create block
+    data = Fog::Compute[:bluebox].create_block(@flavor_id, @image_id, @location_id, {'password' => @password}).body
+    @block_id = data['id']
+    Fog::Compute[:bluebox].servers.get(@block_id).wait_for { ready? }
+
+    tests("add_machine_to_lb_application").formats(Bluebox::BLB::Formats::ADD_MACHINE_TO_LB) do
+      Fog::Bluebox[:blb].add_machine_to_lb_application(@lb_applications.first['id'], @block_id).body
+    end
+
+    @default_backend = @lb_backends.select { |x| x['backend_name'] == 'default' }.first
+    @id_in_backend = @default_backend['lb_machines'].last['id']
+    @machine_opts = { 'port' => 4361, 'backup' => true };
+    tests("update_lb_backend_machine(#{@lb_backends.first['id']}, #{@id_in_backend}, #{@machine_opts})").formats(Bluebox::BLB::Formats::LB_MACHINE) do
+      Fog::Bluebox[:blb].update_lb_backend_machine(@lb_backends.first['id'], @id_in_backend, @machine_opts).body
+    end
+
+    tests("remove_machine_from_lb_backend(#{@default_backend['id']}, #{@id_in_backend})").formats(Bluebox::BLB::Formats::REMOVE_MACHINE_FROM_BACKEND) do
+      Fog::Bluebox[:blb].remove_machine_from_lb_backend(@default_backend['id'], @id_in_backend).body
+    end
+
+    tests("add_machine_to_lb_backend(#{@default_backend['id']}, #{@block_id})").formats(Bluebox::BLB::Formats::ADD_MACHINE_TO_LB) do
+      Fog::Bluebox[:blb].add_machine_to_lb_backend(@default_backend['id'], @block_id).body
+    end
+
+    Fog::Compute[:bluebox].destroy_block(@block_id).body
+
+  end
+
+  tests('failure') do
+    tests('get_lb_application').raises(Fog::Compute::Bluebox::NotFound) do
+      Fog::Bluebox[:blb].get_lb_application('00000000-0000-0000-0000-000000000000')
+    end
+    tests('get_lb_service').raises(Fog::Compute::Bluebox::NotFound) do
+      Fog::Bluebox[:blb].get_lb_service('00000000-0000-0000-0000-000000000000','00000000-0000-0000-0000-000000000000')
+    end
+    tests('get_lb_backend').raises(Fog::Compute::Bluebox::NotFound) do
+      Fog::Bluebox[:blb].get_lb_backend('00000000-0000-0000-0000-000000000000','00000000-0000-0000-0000-000000000000')
+    end
+  end
+end

data/tests/brightbox/requests/compute/firewall_policy_tests.rb

@@ -25,6 +25,13 @@ Shindo.tests('Fog::Compute[:brightbox] | firewall policy requests', ['brightbox'
       end
     end
 
+    update_options = {:name => "Fog test policy B"}
+    tests("#update_firewall_policy('#{@firewall_policy_id}', #{update_options.inspect})") do
+      result = Fog::Compute[:brightbox].update_firewall_policy(@firewall_policy_id, update_options)
+      formats(Brightbox::Compute::Formats::Full::FIREWALL_POLICY, false) { result }
+      returns("Fog test policy B") { result["name"] }
+    end
+
     tests("#destroy_firewall_policy('#{@firewall_policy_id}')") do
       result = Fog::Compute[:brightbox].destroy_firewall_policy(@firewall_policy_id)
       formats(Brightbox::Compute::Formats::Full::FIREWALL_POLICY, false) { result }

data/tests/brightbox/requests/compute/helper.rb

@@ -372,7 +372,8 @@ class Brightbox
           "snapshots"       => [Brightbox::Compute::Formats::Nested::IMAGE],
           "interfaces"      => [Brightbox::Compute::Formats::Nested::INTERFACE],
           "zone"            => Fog::Brightbox::Nullable::Zone,
-          "username"        => Fog::Nullable::String
+          "username"        => Fog::Nullable::String,
+          "compatibility_mode" => Fog::Boolean
         }
 
         SERVER_GROUP = {
@@ -612,7 +613,8 @@ class Brightbox
           "interfaces"      => [Brightbox::Compute::Formats::Nested::INTERFACE],
           "zone"            => Fog::Brightbox::Nullable::Zone,
           "licence_name"    => Fog::Nullable::String,
-          "username"        => Fog::Nullable::String
+          "username"        => Fog::Nullable::String,
+          "compatibility_mode" => Fog::Boolean
         }
 
         SERVER_GROUP = {

data/tests/compute/helper.rb

@@ -91,6 +91,14 @@ def compute_providers
     :joyent => {
       :mocked => false
     },
+    :hp       => {
+      :server_attributes => {
+        :flavor_id => 100,
+        :image_id => 1242,
+        :name     => "fog_#{Time.now.to_i}"
+      },
+      :mocked => true
+    },
     :ninefold   => {
       :mocked => false
     },

data/tests/core/user_agent_tests.rb

@@ -0,0 +1,6 @@
+Shindo.tests('Fog::Connection', 'core') do
+  tests('user_agent').returns("fog/#{Fog::VERSION}") do
+    conn = Fog::Connection.new("http://www.testserviceurl.com", false, {})
+    conn.instance_variable_get(:@excon).data[:headers]['User-Agent']
+  end
+end

data/tests/dreamhost/README.md

@@ -0,0 +1,56 @@
+# Testing the Dreamhost DNS API
+
+Dreamhost API sandbox only permits read-only commands, so you'll need a Dreamhost
+PS account for the testing and a dedicated domain.
+
+See http://wiki.dreamhost.com/Application_programming_interface#Test_Account
+
+## Create an API key
+
+You'll need a Dreamhost (PS I think) account and a dedicated domain for testing.
+
+1. Go to the Dreamhost web panel and create an API key to manage DNS records
+
+   https://panel.dreamhost.com/index.cgi?tree=home.api
+
+   Select 'All dns functions' for the new API key to be able to add/remove/list
+records.
+
+2. Create a .fog file in the tests/ directory with the following contents:
+
+   ```yaml
+   :default:
+     :dreamhost_api_key: SDFASDFWQWASDFASDFAS
+   ```
+   Where dreamhost_api_key is the key you created in the previous step.
+
+3. Update the test_domain helper in tests/dreamhost/helper.rb to use your own 
+   domain for testing. You will also need at least a record created via
+   the Dreamhost Webpanel (you'll get a **no_such_zone** error otherwise).
+
+   I usually create a do-not-delete.my-domain.com record. The tests skip that
+   record when cleaning up (see the do_not_delete_record helper).
+
+4. Run the tests
+
+   ```
+   shindo tests/dreamhost
+   ```
+   
+## Notes
+
+The API is rate limited, so do not smash the DH servers too often. Two
+consecutive test runs will trigger the rate limit.
+You'll see a **slow_down_bucko** error if the frequency is too high.
+
+http://wiki.dreamhost.com/Application_programming_interface#Rate_Limit
+
+## Resources
+
+Dreamhost API:
+
+http://wiki.dreamhost.com/Application_programming_interface
+
+Dreamhost DNS API:
+
+http://wiki.dreamhost.com/API/Dns_commands

data/tests/dreamhost/dns_tests.rb

@@ -0,0 +1,20 @@
+Shindo.tests('Fog::DNS[:dreamhost]', ['dreamhost', 'dns']) do
+
+  service = Fog::DNS[:dreamhost]
+
+  tests("collections") do
+    %w{ records zones }.each do |collection|
+      test("it should respond to #{collection}") { service.respond_to? collection }
+      test("it should respond to #{collection}.all") { eval("service.#{collection}").respond_to? 'all' }
+      test("it should respond to #{collection}.get") { eval("service.#{collection}").respond_to? 'get' }
+    end
+  end
+  
+  tests("requests") do
+    %w{ list_records create_record delete_record }.each do |request|
+      test("it should respond to #{request}") { service.respond_to? request }
+    end
+  end
+
+end
+

data/tests/dreamhost/helper.rb

@@ -0,0 +1,19 @@
+def test_domain
+  'fog-dream.com'
+end
+
+def do_not_delete_record 
+  "do-not-delete.#{test_domain}"
+end
+
+## Cleanup
+# We need to have at least one record defined for the Dreamhost DNS api to work
+# or you will get a no_such_zone runtime error
+# The first record needs to be created using the Dreamhost Web panel AFAIK
+#
+def cleanup_records
+  Fog::DNS[:dreamhost].records.each do |r|
+    # Do not delete the 'do-not-delete' record, we need it for the tests
+    r.destroy if r.name =~ /#{test_domain}/ and r.name != do_not_delete_record
+  end
+end

data/tests/dreamhost/models/dns/record_tests.rb

@@ -0,0 +1,73 @@
+Shindo.tests("Fog::DNS[:dreamhost] | record", ['dreamhost', 'dns']) do
+
+  service = Fog::DNS[:dreamhost]
+  record  = service.records.first
+
+  tests('#attributes') do
+    tests('should have') do
+      model_attribute_hash = record.attributes
+      attributes = [ 
+        :name,
+        :value,
+        :zone,
+        :type,
+        :editable,
+        :account_id,
+        :comment,
+      ]
+      attributes.each do |attribute|
+        test("#{attribute} method") { record.respond_to? attribute }
+      end
+      attributes.each do |attribute|
+        test("#{attribute} key") { model_attribute_hash.has_key? attribute }
+      end
+    end
+
+    test('be a kind of Fog::DNS::Dreamhost::Record') do
+      record.kind_of? Fog::DNS::Dreamhost::Record
+    end
+
+    tests('Write operations') do
+      name = "test.#{test_domain}"
+      r = service.records.create :name  => name,
+                                 :type  => 'A',
+                                 :value => "8.8.8.8"
+      sleep 10
+      tests('#save') do 
+        test('returns Fog::DNS::Dreamhost::Record') do
+          r.is_a? Fog::DNS::Dreamhost::Record 
+        end
+        test('value is 8.8.8.8') do
+          r.value == '8.8.8.8'
+        end
+        test("name is #{name}") do
+          r.name == name
+        end
+        test("listed") do
+          !(service.records.find { |r| r.name == name }).nil?
+        end
+      end
+      tests('#destroy') do
+        test('returns true') { r.destroy == true }
+        test('destroyed record not listed') do
+          (service.records.find { |r| r.name == name }).nil?
+        end
+      end
+      tests('#save from zone') do
+        name = "zone-create.#{test_domain}"
+        r = service.zones.first.records.create :name  => name,
+                                               :type  => 'A',
+                                               :value => "8.8.8.8"
+        sleep 10
+        test("listed") do
+          !(service.records.find { |r| r.name == name }).nil?
+        end
+      end
+    end
+  end
+
+  # cleanup
+  cleanup_records
+
+end
+

data/tests/dreamhost/models/dns/records_tests.rb

@@ -0,0 +1,29 @@
+Shindo.tests("Fog::DNS[:dreamhost] | records", ['dreamhost', 'dns']) do
+
+  service = Fog::DNS[:dreamhost]
+  
+  tests('#all') do
+    records = service.records
+
+    test('should be an array') { records.is_a? Array }
+
+    test('should not be empty') { !records.empty? }
+    
+    tests('should list Fog::DNS::Dreamhost::Record') do
+      records.each do |r|
+        test("as records") { r.is_a?(Fog::DNS::Dreamhost::Record) }
+      end
+    end
+  end
+
+  tests('#get') do
+    tests('should fetch a record') do
+      record = service.records.get do_not_delete_record
+      test('should be a Fog::DNS::Dreamhost::Record') do
+        record.is_a? Fog::DNS::Dreamhost::Record
+      end
+    end
+  end
+
+end
+

data/tests/dreamhost/models/dns/zone_tests.rb

@@ -0,0 +1,62 @@
+Shindo.tests("Fog::DNS[:dreamhost] | zone", ['dreamhost', 'dns']) do
+
+  service = Fog::DNS[:dreamhost]
+  zone = service.zones.first
+
+  tests('#attributes') do
+    tests('should have') do
+      model_attribute_hash = zone.attributes
+      attributes = [ 
+        :domain,
+        :id,
+      ]
+      attributes.each do |attribute|
+        test("#{attribute} method") { zone.respond_to? attribute }
+      end
+      attributes.each do |attribute|
+        test("#{attribute} key") { model_attribute_hash.has_key? attribute }
+      end
+    end
+
+    test('be a kind of Fog::DNS::Dreamhost::Zone') do
+      zone.kind_of? Fog::DNS::Dreamhost::Zone
+    end
+
+    tests('Write operations') do
+      name = "#{test_domain}"
+      tests('#save') do 
+        # Does not capture the exception for some reason
+        #raises(NotImplementedError, 'raises NotImplementedError') do
+        #  service.zones.create :domain => name
+        #end
+        test 'raises NotImplementedError' do
+          begin
+            service.zones.create :domain => name
+            false
+          rescue NotImplementedError => e
+            true
+          end
+        end
+      end
+      tests('#destroy') do
+        test 'raises NotImplementedError' do
+          begin
+            zone.destroy
+            false
+          rescue NotImplementedError => e
+            true
+          end
+        end
+      end
+
+      tests('#records') do
+        zone.records.each do |r|
+          test('list records') { r.is_a? Fog::DNS::Dreamhost::Record }
+          test('zone matches') { r.zone == test_domain }
+        end
+      end
+    end
+  end
+
+end
+