fog 1.6.0 → 1.7.0

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

@@ -0,0 +1,78 @@
+Shindo.tests('AWS::RDS | tagging requests', ['aws', 'rds']) do
+  @rds = Fog::AWS[:rds]
+  @db_instance_id = "fog-test-#{rand(65536).to_s(16)}"
+  Formatador.display_line "Creating RDS instance #{@db_instance_id}"
+  @rds.create_db_instance(@db_instance_id, 'AllocatedStorage' => 5,
+        'DBInstanceClass' => 'db.t1.micro', 'Engine' => 'mysql',
+        'MasterUsername' => 'foguser', 'MasterUserPassword' => 'fogpassword')
+  Formatador.display_line "Waiting for instance #{@db_instance_id} to be ready"
+  @db = @rds.servers.get(@db_instance_id)
+  @db.wait_for { ready? }
+
+  tests('success') do
+
+    single_tag  = {'key1' => 'value1'}
+    two_tags    = {'key2' => 'value2', 'key3' => 'value3'}
+
+    tests("#add_tags_to_resource with a single tag").
+    formats(AWS::RDS::Formats::BASIC) do
+      result = @rds.add_tags_to_resource(@db_instance_id, single_tag).body
+      returns(single_tag) do
+        @rds.list_tags_for_resource(@db_instance_id).
+          body['ListTagsForResourceResult']['TagList']
+      end
+      result
+    end
+
+    tests("#add_tags_to_resource with a multiple tags").
+    formats(AWS::RDS::Formats::BASIC) do
+      result = @rds.add_tags_to_resource(@db_instance_id, two_tags).body
+      returns(single_tag.merge(two_tags)) do
+        @rds.list_tags_for_resource(@db_instance_id).
+          body['ListTagsForResourceResult']['TagList']
+      end
+      result
+    end
+
+    tests("#remove_tags_from_resource").formats(AWS::RDS::Formats::BASIC) do
+      result = @rds.remove_tags_from_resource(
+                @db_instance_id, single_tag.keys).body
+      returns(two_tags) do
+        @rds.list_tags_for_resource(@db_instance_id).
+          body['ListTagsForResourceResult']['TagList']
+      end
+      result
+    end
+
+    tests("#list_tags_for_resource").
+    formats(AWS::RDS::Formats::LIST_TAGS_FOR_RESOURCE) do
+      result = @rds.list_tags_for_resource(@db_instance_id).body
+      returns(two_tags) do
+        result['ListTagsForResourceResult']['TagList']
+      end
+      result
+    end
+
+  end
+
+  tests('failure') do
+    tests "tagging a nonexisting instance" do
+      raises(Fog::AWS::RDS::NotFound) do
+        @rds.add_tags_to_resource('doesnexist', {'key1' => 'value1'})
+      end
+    end
+    tests "listing tags for a nonexisting instance" do
+      raises(Fog::AWS::RDS::NotFound) do
+        @rds.list_tags_for_resource('doesnexist')
+      end
+    end
+    tests "removing tags for a nonexisting instance" do
+      raises(Fog::AWS::RDS::NotFound) do
+        @rds.remove_tags_from_resource('doesnexist', ['key1'])
+      end
+    end
+  end
+
+  Formatador.display_line "Destroying DB instance #{@db_instance_id}"
+  @db.destroy
+end

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

@@ -2,17 +2,37 @@ Shindo.tests('Fog::Compute[:brightbox] | account requests', ['brightbox']) do
 
   tests('success') do
 
-    tests("#get_account") do
+    tests("#list_accounts") do
       pending if Fog.mocking?
-      result = Fog::Compute[:brightbox].get_account
+      result = Fog::Compute[:brightbox].list_accounts
+      formats(Brightbox::Compute::Formats::Collection::ACCOUNTS, false) { result }
+    end
+
+    tests("#get_scoped_account") do
+      pending if Fog.mocking?
+      result = Fog::Compute[:brightbox].get_scoped_account
+      @scoped_account_identifier = result["id"]
+      formats(Brightbox::Compute::Formats::Full::ACCOUNT, false) { result }
+      test("ftp password is blanked") { result["library_ftp_password"].nil?  }
+    end
+
+    tests("#get_account(#{@scoped_account_identifier}") do
+      pending if Fog.mocking?
+      result = Fog::Compute[:brightbox].get_account(@scoped_account_identifier)
       formats(Brightbox::Compute::Formats::Full::ACCOUNT, false) { result }
       test("ftp password is blanked") { result["library_ftp_password"].nil?  }
     end
 
     update_options = {:name => "Fog@#{Time.now.iso8601}"}
-    tests("#update_account(#{update_options.inspect})") do
+    tests("#update_scoped_account(#{update_options.inspect})") do
+      pending if Fog.mocking?
+      result = Fog::Compute[:brightbox].update_scoped_account(update_options)
+      formats(Brightbox::Compute::Formats::Full::ACCOUNT, false) { result }
+    end
+
+    tests("#update_account(#{@scoped_account_identifier}, #{update_options.inspect})") do
       pending if Fog.mocking?
-      result = Fog::Compute[:brightbox].update_account(update_options)
+      result = Fog::Compute[:brightbox].update_account(@scoped_account_identifier, update_options)
       formats(Brightbox::Compute::Formats::Full::ACCOUNT, false) { result }
     end
 

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

@@ -0,0 +1,63 @@
+Shindo.tests('Fog::Compute[:brightbox] | api client requests', ['brightbox']) do
+
+  tests('success') do
+
+    create_options = {
+      :name => "Fog@#{Time.now.iso8601}"
+    }
+
+    tests("#create_application(#{create_options.inspect})") do
+      pending if Fog.mocking?
+      result = Fog::Compute[:brightbox].create_application(create_options)
+      @application_id = result["id"]
+      formats(Brightbox::Compute::Formats::Full::APPLICATION, false) { result }
+    end
+
+    tests("#list_applications") do
+      pending if Fog.mocking?
+      result = Fog::Compute[:brightbox].list_applications
+      formats(Brightbox::Compute::Formats::Collection::APPLICATION, false) { result }
+    end
+
+    tests("#get_application('#{@application_id}')") do
+      pending if Fog.mocking?
+      result = Fog::Compute[:brightbox].get_application(@application_id)
+      formats(Brightbox::Compute::Formats::Full::APPLICATION, false) { result }
+    end
+
+    update_options = {:name => "Fog@#{Time.now.iso8601}"}
+    tests("#update_application('#{@application_id}', #{update_options.inspect})") do
+      pending if Fog.mocking?
+      result = Fog::Compute[:brightbox].update_application(@application_id, update_options)
+      formats(Brightbox::Compute::Formats::Full::APPLICATION, false) { result }
+    end
+
+    tests("#reset_secret_application('#{@application_id}')") do
+      pending if Fog.mocking?
+      result = Fog::Compute[:brightbox].reset_secret_application(@application_id)
+      formats(Brightbox::Compute::Formats::Full::APPLICATION, false) { result }
+      test("new secret is visible") { ! result["secret"].nil?  }
+    end
+
+    tests("#destroy_application('#{@application_id}')") do
+      pending if Fog.mocking?
+      result = Fog::Compute[:brightbox].destroy_application(@application_id)
+      formats(Brightbox::Compute::Formats::Full::APPLICATION, false) { result }
+    end
+
+  end
+
+  tests('failure') do
+
+    tests("#get_api_client('app-00000')").raises(Excon::Errors::NotFound) do
+      pending if Fog.mocking?
+      Fog::Compute[:brightbox].get_application('app-00000')
+    end
+
+    tests("#get_api_client").raises(ArgumentError) do
+      pending if Fog.mocking?
+      Fog::Compute[:brightbox].get_application
+    end
+  end
+
+end

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

@@ -73,7 +73,7 @@ class Brightbox
       def self.select_testing_image_from_api
         images = Fog::Compute[:brightbox].list_images
         raise "No available images!" if images.empty?
-        images.select {|img| img.size == 0 }.first || images.first
+        images.select { |img| img["official"] && img["virtual_size"] != 0 }.sort_by { |img| img["disk_size"] }.first || images.first
       end
 
     end
@@ -239,6 +239,37 @@ class Brightbox
       end
 
       module Collected
+        ACCOUNT = {
+          "id"              => String,
+          "resource_type"   => String,
+          "url"             => String,
+          "name"            => String,
+          "status"          => String,
+          "vat_registration_number" => Fog::Nullable::String,
+          "telephone_number" => Fog::Nullable::String,
+          "telephone_verified" => Fog::Nullable::Boolean,
+          "ram_limit"       => Integer,
+          "ram_used"        => Integer,
+          "cloud_ips_limit" => Integer,
+          "cloud_ips_used"  => Integer,
+          "load_balancers_limit" => Integer,
+          "load_balancers_used" => Integer,
+          "library_ftp_password" => Fog::Nullable::String,
+          "verified_telephone" => Fog::Nullable::String,
+          "verified_at"     => Fog::Nullable::String,
+          "verified_ip"     => Fog::Nullable::String,
+          "owner"           => Brightbox::Compute::Formats::Nested::USER,
+          "users"           => [Brightbox::Compute::Formats::Nested::USER],
+          "clients"         => [Brightbox::Compute::Formats::Nested::API_CLIENT],
+          "servers"         => [Brightbox::Compute::Formats::Nested::SERVER],
+          "load_balancers"  => [Brightbox::Compute::Formats::Nested::LOAD_BALANCER],
+          "cloud_ips"       => [Brightbox::Compute::Formats::Nested::CLOUD_IP],
+          "server_groups"   => [Brightbox::Compute::Formats::Nested::SERVER_GROUP],
+          "firewall_policies" => [Brightbox::Compute::Formats::Nested::FIREWALL_POLICY],
+          "images"          => [Brightbox::Compute::Formats::Nested::IMAGE],
+          "zones"           => [Brightbox::Compute::Formats::Nested::ZONE]
+        }
+
         API_CLIENT = {
           "id"              => String,
           "resource_type"   => String,
@@ -249,6 +280,13 @@ class Brightbox
           "account"         => Brightbox::Compute::Formats::Nested::ACCOUNT
         }
 
+        APPLICATION = {
+          "id"              => String,
+          "resource_type"   => String,
+          "url"             => String,
+          "name"            => Fog::Nullable::String
+        }
+
         CLOUD_IP = {
           "id"              => String,
           "resource_type"   => String,
@@ -448,6 +486,14 @@ class Brightbox
           "account"         => Brightbox::Compute::Formats::Nested::ACCOUNT
         }
 
+        APPLICATION = {
+          "id"              => String,
+          "resource_type"   => String,
+          "url"             => String,
+          "name"            => Fog::Nullable::String,
+          "secret"          => Fog::Nullable::String
+        }
+
         CLOUD_IP = {
           "id"              => String,
           "resource_type"   => String,
@@ -614,7 +660,9 @@ class Brightbox
       end
 
       module Collection
+        ACCOUNTS = [Brightbox::Compute::Formats::Collected::ACCOUNT]
         API_CLIENTS = [Brightbox::Compute::Formats::Collected::API_CLIENT]
+        APPLICATION = [Brightbox::Compute::Formats::Collected::APPLICATION]
         CLOUD_IPS = [Brightbox::Compute::Formats::Collected::CLOUD_IP]
         IMAGES = [Brightbox::Compute::Formats::Collected::IMAGE]
         FIREWALL_POLICIES = [Brightbox::Compute::Formats::Collected::FIREWALL_POLICY]

data/tests/helper.rb

@@ -1,3 +1,6 @@
+ENV['FOG_RC']         = ENV['FOG_RC'] || File.expand_path('../.fog', __FILE__)
+ENV['FOG_CREDENTIAL'] = ENV['FOG_CREDENTIAL'] || 'default'
+
 require 'fog'
 require 'fog/bin' # for available_providers and registered_providers
 
@@ -22,7 +25,7 @@ available_providers = Fog.available_providers.map {|provider| provider.downcase}
 unavailable_providers = all_providers - available_providers
 
 for provider in unavailable_providers
-  Formatador.display_line("[yellow]Skipping tests for [bold]#{provider}[/] [yellow]due to lacking credentials (add some to '~/.fog' to run them)[/]")
+  Formatador.display_line("[yellow]Skipping tests for [bold]#{provider}[/] [yellow]due to lacking credentials (add some to '#{Fog.credentials_path}' to run them)[/]")
   Thread.current[:tags] << ('-' << provider)
 end
 

data/tests/local/models/directory_tests.rb

@@ -0,0 +1,16 @@
+Shindo.tests('Storage[:local] | directory', ["local"]) do
+
+  pending if Fog.mocking?
+
+  before do
+    @options = { :local_root => '~/.fog' }
+  end
+
+  tests('save') do
+    returns(true) do
+      connection = Fog::Storage::Local.new(@options)
+      connection.directories.create(:key => 'directory')
+      connection.directories.create(:key => 'directory')
+    end
+  end
+end

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

@@ -312,6 +312,59 @@ class Ninefold
         }
         FORWARDING_RULES = [FORWARDING_RULE]
       end
+      module LoadBalancers
+        CREATE_LOAD_BALANCER_RULE_RESPONSE = {
+          "id"=>Integer,
+          "account"=>String,
+          "algorithm"=>String,
+          "cidrlist"=>String,
+          "domain"=>String,
+          "domainid"=>Integer,
+          "name"=>String,
+          "privateport"=>String,
+          "publicip"=>String,
+          "publicipid"=>Integer,
+          "publicport"=>String,
+          "state"=>String,
+          "zoneid"=>Integer
+        }
+        ASSIGN_LOAD_BALANCER_RULE_RESPONSE = {
+          "success"=>Fog::Boolean
+        }
+        LIST_LOAD_BALANCER_RULES_RESPONSE = {
+          "id"=>Integer,
+          "name"=>String,
+          "publicipid"=>Integer,
+          "publicip"=>String,
+          "publicport"=>String,
+          "privateport"=>String,
+          "algorithm"=>String,
+          "cidrlist"=>String,
+          "account"=>String,
+          "domainid"=>Integer,
+          "domain"=>String,
+          "state"=>String,
+          "zoneid"=>Integer
+        }
+        UPDATE_LOAD_BALANCER_RULE_RESPONSE = {
+          "id"=>Integer,
+          "name"=>String,
+          "publicipid"=>Integer,
+          "publicip"=>String,
+          "publicport"=>String,
+          "privateport"=>String,
+          "algorithm"=>String,
+          "cidrlist"=>String,
+          "account"=>String,
+          "domainid"=>Integer,
+          "domain"=>String,
+          "state"=>String,
+          "zoneid"=>Integer
+        }
+        REMOVE_FROM_LOAD_BALANCER_RULE_RESPONSE = {
+          "success"=>Fog::Boolean
+        }
+      end
     end
   end
 end

data/tests/ninefold/requests/compute/load_balancer_tests.rb

@@ -0,0 +1,66 @@
+Shindo.tests('Fog::Compute[:ninefold] | load balancers', ['ninefold']) do
+
+  # NOTE: all of these tests require you to have a vm built with a public IP address.
+  tests('success') do
+
+    before do
+      @compute = Fog::Compute[:ninefold]
+      unless Fog.mocking?
+        @public_ip_id = @compute.list_public_ip_addresses.first['id']
+        @server_id = @compute.servers.all.first.id
+        @create_load_balancer = @compute.create_load_balancer_rule(:algorithm => 'roundrobin', :name => 'test',
+                                                                  :privateport => 1000, :publicport => 2000,
+                                                                  :publicipid => @public_ip_id)
+      end
+    end
+
+    after do
+      unless Fog.mocking?
+        delete = @compute.delete_load_balancer_ruler(:id => @create_load_balancer['id'])
+        Ninefold::Compute::TestSupport.wait_for_job(delete['jobid'])
+      end
+    end
+
+    tests("#create_load_balancer_rule()").formats(Ninefold::Compute::Formats::LoadBalancers::CREATE_LOAD_BALANCER_RULE_RESPONSE) do
+      pending if Fog.mocking?
+      result = Ninefold::Compute::TestSupport.wait_for_job(@create_load_balancer['jobid'])
+      result['jobresult']['loadbalancer']
+    end
+
+    tests("#assign_to_load_balancer_rule()").formats(Ninefold::Compute::Formats::LoadBalancers::ASSIGN_LOAD_BALANCER_RULE_RESPONSE) do
+      pending if Fog.mocking?
+      assign_load_balancer = @compute.assign_to_load_balancer_rule(:id => @create_load_balancer['id'], :virtualmachineids => @server_id)
+      result = Ninefold::Compute::TestSupport.wait_for_job(assign_load_balancer['jobid'])
+      result['jobresult']
+    end
+
+    tests("#list_to_load_balancer_rules()").formats(Ninefold::Compute::Formats::LoadBalancers::LIST_LOAD_BALANCER_RULES_RESPONSE) do
+      pending if Fog.mocking?
+      list_load_balancer_rules = @compute.list_load_balancer_rules
+      list_load_balancer_rules['loadbalancerrule'].first
+    end
+
+    tests("#update_to_load_balancer_rule()").formats(Ninefold::Compute::Formats::LoadBalancers::UPDATE_LOAD_BALANCER_RULE_RESPONSE) do
+      pending if Fog.mocking?
+      update_load_balancer = @compute.update_load_balancer_rule(:id => @create_load_balancer['id'], :algorithm => 'source')
+      result = Ninefold::Compute::TestSupport.wait_for_job(update_load_balancer['jobid'])
+      result['jobresult']['loadbalancer']
+    end
+
+    tests('with assigned to load balancer rule') do
+      before do
+        unless Fog.mocking?
+          assign_load_balancer = @compute.assign_to_load_balancer_rule(:id => @create_load_balancer['id'], :virtualmachineids => @server_id)
+          result = Ninefold::Compute::TestSupport.wait_for_job(assign_load_balancer['jobid'])
+        end
+      end
+
+      tests("#remove_from_load_balancer_rule()").formats(Ninefold::Compute::Formats::LoadBalancers::REMOVE_FROM_LOAD_BALANCER_RULE_RESPONSE) do
+        pending if Fog.mocking?
+        remove = @compute.remove_from_load_balancer_rule(:id => @create_load_balancer['id'], :virtualmachineids => @server_id)
+        result = Ninefold::Compute::TestSupport.wait_for_job(remove['jobid'])
+        result['jobresult']
+      end
+    end
+  end
+end

data/tests/openstack/models/image/image_tests.rb

@@ -31,5 +31,6 @@ Shindo.tests("Fog::Image[:openstack] | image", ['openstack']) do
     tests('#destroy').succeeds do
       @instance.destroy == true
     end
+
   end
 end

data/tests/openstack/models/network/network_tests.rb

@@ -0,0 +1,24 @@
+Shindo.tests("Fog::Network[:openstack] | network", ['openstack']) do
+
+  tests('success') do
+
+    tests('#create').succeeds do
+      @instance = Fog::Network[:openstack].networks.create(:name => 'net_name',
+                                                           :shared => false,
+                                                           :admin_state_up => true,
+                                                           :tenant_id => 'tenant_id')
+      !@instance.id.nil?
+    end
+
+    tests('#update').succeeds do
+      @instance.name = 'new_net_name'
+      @instance.update
+    end
+
+    tests('#destroy').succeeds do
+      @instance.destroy == true
+    end
+
+  end
+
+end