fog-ecloud 0.0.1

data/tests/compute/models/environment_tests.rb

@@ -0,0 +1,23 @@
+provider, config = :ecloud, compute_providers[:ecloud]
+
+Shindo.tests("Fog::Compute[:#{provider}] | environments", [provider.to_s]) do
+  connection = Fog::Compute[provider]
+  @organization = connection.organizations.first
+
+  tests('#all').succeeds do
+    returns(false) { @organization.environments.all.empty? }
+  end
+
+  tests('#get').succeeds do
+    environment         = @organization.environments.all.first
+    fetched_environment = connection.environments.get(environment.href)
+
+    returns(true) { !fetched_environment.nil? }
+  end
+
+  tests("#organization").succeeds do
+    environment = @organization.environments.all.first
+    returns(false, "returns an organization") { environment.organization.nil? }
+    returns(true, "returns correct organization") { environment.organization.href == @organization.href }
+  end
+end

data/tests/compute/models/internet_service_tests.rb

@@ -0,0 +1,28 @@
+provider, config = :ecloud, compute_providers[:ecloud]
+
+Shindo.tests("Fog::Compute[:#{provider}] | internet_services", [provider.to_s, "queries"]) do
+  connection    = Fog::Compute[provider]
+  organization = connection.organizations.first
+  environment  = organization.environments.find { |e| e.name == config[:ecloud_environment_name] } || organization.environments.first
+  public_ips   = environment.public_ips
+  public_ip    = public_ips.find { |i| i.name == config[:ecloud_public_ip_name] } || public_ips.first
+  @internet_services = public_ip.internet_services
+
+  tests('#all').succeeds do
+    returns(true, "is a collection") { @internet_services.is_a?(Fog::Compute::Ecloud::InternetServices) }
+    if Fog.mocking?
+      returns(false, "has services") { @internet_services.empty? }
+    else
+      true
+    end
+  end
+
+  unless @internet_services.empty?
+    tests('#get').succeeds do
+      service = @internet_services.first
+      fetched_service = connection.internet_services.get(service.href)
+      returns(false, "service is not nil") { fetched_service.nil? }
+      returns(true, "is an InternetService") { fetched_service.is_a?(Fog::Compute::Ecloud::InternetService) }
+    end
+  end
+end

data/tests/compute/models/ip_address_tests.rb

@@ -0,0 +1,19 @@
+provider, config = :ecloud, compute_providers[:ecloud]
+
+Shindo.tests("Fog::Compute[:#{provider}] | ip_addresses", [provider.to_s]) do
+  connection = Fog::Compute[provider]
+  @organization = connection.organizations.first
+  @environment = @organization.environments.first
+  @network = @environment.networks.first
+  @ip_addresses = @network.ips
+
+  tests('#all').succeeds do
+    returns(false) { @ip_addresses.all.empty? }
+  end
+
+  tests('#get').succeeds do
+    address = @ip_addresses.first
+    fetched_network = connection.ip_addresses.get(address.href)
+    returns(false) { fetched_network.nil? }
+  end
+end

data/tests/compute/models/network_tests.rb

@@ -0,0 +1,17 @@
+provider, config = :ecloud, compute_providers[:ecloud]
+
+Shindo.tests("Fog::Compute[:#{provider}] | networks", [provider.to_s]) do
+  connection = Fog::Compute[provider]
+  @organization = connection.organizations.first
+  @environment = @organization.environments.first
+
+  tests('#all').succeeds do
+    returns(false) { @environment.networks.all.empty? }
+  end
+
+  tests('#get').succeeds do
+    network = @environment.networks.all.first
+    fetched_network = connection.networks.get(network.href)
+    returns(true) { !fetched_network.nil? }
+  end
+end

data/tests/compute/models/operating_system_families_tests.rb

@@ -0,0 +1,13 @@
+provider, config = :ecloud, compute_providers[:ecloud]
+
+Shindo.tests("Fog::Compute[:#{provider}] | operating_system_families", [provider.to_s]) do
+  connection = Fog::Compute[provider]
+  @organization = connection.organizations.first
+  @environment  = @organization.environments.find{|e| e.name == config[:server_attributes][:environment_name]} || @organization.environments.first
+  @compute_pool = @environment.compute_pools.first
+
+  tests('#all').succeeds do
+    operating_system_families = @compute_pool.operating_system_families
+    returns(false) { operating_system_families.empty? }
+  end
+end

data/tests/compute/models/operating_system_tests.rb

@@ -0,0 +1,22 @@
+provider, config = :ecloud, compute_providers[:ecloud]
+
+Shindo.tests("Fog::Compute[:#{provider}] | operating_system", [provider.to_s]) do
+  connection = Fog::Compute[provider]
+  @organization = connection.organizations.first
+  @environment  = @organization.environments.find{|e| e.name == config[:server_attributes][:environment_name]} || @organization.environments.first
+  @compute_pool = @environment.compute_pools.first
+
+  tests('#all').succeeds do
+    family            = @compute_pool.operating_system_families.first
+    operating_systems = family.operating_systems
+
+    returns(false) { operating_systems.empty? }
+  end
+
+  tests('#get').succeeds do
+    family           = @compute_pool.operating_system_families.first
+    operating_system = family.operating_systems.first
+
+    returns(false) { family.operating_systems.get(operating_system.href).nil? }
+  end
+end

data/tests/compute/models/organization_tests.rb

@@ -0,0 +1,21 @@
+provider, config = :ecloud, compute_providers[:ecloud]
+
+Shindo.tests("Fog::Compute[:#{provider}] | organizations", [provider.to_s]) do
+  connection = Fog::Compute[provider]
+
+  tests('#all').succeeds do
+    returns(false) { connection.organizations.all.empty? }
+  end
+
+  tests('#get').succeeds do
+    organization = connection.organizations.all.first
+    fetched_organization = connection.organizations.get(organization.href)
+    returns(true) { !fetched_organization.nil? }
+  end
+
+  tests("#admin").succeeds do
+    organization = connection.organizations.all.first
+
+    returns(true, "return AdminOrganization") { organization.admin.is_a?(Fog::Compute::Ecloud::AdminOrganization) }
+  end
+end

data/tests/compute/models/public_ip_tests.rb

@@ -0,0 +1,19 @@
+provider, config = :ecloud, compute_providers[:ecloud]
+
+Shindo.tests("Fog::Compute[:#{provider}] | ip_addresses", [provider.to_s]) do
+  connection = Fog::Compute[provider]
+  @organization = connection.organizations.first
+  @environment = @organization.environments.first
+  @public_ips = @environment.public_ips
+
+  tests('#all').succeeds do
+    returns(false, "has ips") { @public_ips.all.empty? }
+  end
+
+  tests('#get').succeeds do
+    address = @public_ips.first
+    fetched_ip = connection.public_ips.get(address.href)
+    returns(false, "ip is not nil") { fetched_ip.nil? }
+    returns(true, "is a PublicIp") { fetched_ip.is_a?(Fog::Compute::Ecloud::PublicIp) }
+  end
+end

data/tests/compute/models/server_tests.rb

@@ -0,0 +1,25 @@
+provider, config = :ecloud, compute_providers[:ecloud]
+
+Shindo.tests("Fog::Compute[:#{provider}] | server", [provider.to_s, "attributes"]) do
+  connection   = Fog::Compute[provider]
+  connection.base_path = '/cloudapi/spec'
+  organization = connection.organizations.first
+  environment  = organization.environments.find{|e| e.name == config[:server_attributes][:environment_name]} || organization.environments.first
+  public_ip    = environment.public_ips.first
+  compute_pool = environment.compute_pools.first
+  image_href   = Fog.credentials[:ecloud_image_href] || compute_pool.templates.first.href
+  ssh_key      = organization.admin.ssh_keys.find { |key| key.name == "root" }
+
+  @network = environment.networks.first
+  options = config[:server_attributes].merge(:network_uri => @network.href, :ssh_key_uri => ssh_key.href)
+  #if Fog.credentials[:ecloud_ssh_key_id]
+  #  options = options.merge(:ssh_key_uri => "/cloudapi/ecloud/admin/sshkeys/#{Fog.credentials[:ecloud_ssh_key_id]}")
+  #end
+
+  @server = compute_pool.servers.first || compute_pool.servers.create(image_href, options).tap{|s| s.wait_for { ready? }}
+
+  tests('#ip_addresses').succeeds do
+    returns(true, "is an array") { @server.ips.is_a?(Array) }
+    returns(true, "contains an VirtualMachineAssignedIp") { @server.ips.all?{|ip| ip.is_a?(Fog::Compute::Ecloud::VirtualMachineAssignedIp) } }
+  end
+end

data/tests/compute/models/ssh_key_tests.rb

@@ -0,0 +1,19 @@
+provider, config = :ecloud, compute_providers[:ecloud]
+
+Shindo.tests("Fog::Compute[:#{provider}] | ssh_keys", [provider.to_s]) do
+  connection = Fog::Compute[provider]
+  @organization = connection.organizations.first
+  @admin_organization = @organization.admin
+  @admin_organization.reload
+  @ssh_keys = @admin_organization.ssh_keys
+
+  tests('#all').succeeds do
+    returns(false) { @ssh_keys.empty? }
+  end
+
+  tests('#get').succeeds do
+    ssh_key = @ssh_keys.first
+
+    returns(false) { @ssh_keys.get(ssh_key.href).nil? }
+  end
+end

data/tests/compute/models/template_tests.rb

@@ -0,0 +1,20 @@
+provider, config = :ecloud, compute_providers[:ecloud]
+
+Shindo.tests("Fog::Compute[:#{provider}] | templates", [provider.to_s]) do
+  connection = Fog::Compute[provider]
+  @organization = connection.organizations.first
+  @environment  = @organization.environments.find{|e| e.name == config[:server_attributes][:environment_name]} || @organization.environments.first
+  @compute_pool = @environment.compute_pools.first
+
+  tests('#all').succeeds do
+    templates = @compute_pool.templates
+    returns(false) { templates.empty? }
+  end
+
+  tests('#get').succeeds do
+    templates = @compute_pool.templates
+    template = templates.first
+
+    returns(false) { @compute_pool.templates.get(template.href).nil? }
+  end
+end

data/tests/helper.rb

@@ -0,0 +1,24 @@
+if ENV['COVERAGE']
+  require 'coveralls'
+  require 'simplecov'
+
+  SimpleCov.start do
+    add_filter '/spec/'
+    add_filter '/test/'
+  end
+end
+
+require 'fog/ecloud'
+
+Excon.defaults.merge!(:debug_request => true, :debug_response => true)
+
+require File.expand_path(File.join(File.dirname(__FILE__), 'helpers', 'mock_helper'))
+
+# This overrides the default 600 seconds timeout during live test runs
+if Fog.mocking?
+  FOG_TESTING_TIMEOUT = ENV['FOG_TEST_TIMEOUT'] || 2000
+  Fog.timeout = 2000
+  Fog::Logger.warning "Setting default fog timeout to #{Fog.timeout} seconds"
+else
+  FOG_TESTING_TIMEOUT = Fog.timeout
+end

data/tests/helpers/collection_helper.rb

@@ -0,0 +1,97 @@
+def collection_tests(collection, params = {}, mocks_implemented = true)
+  tests('success') do
+
+    tests("#new(#{params.inspect})").succeeds do
+      pending if Fog.mocking? && !mocks_implemented
+      collection.new(params)
+    end
+
+    tests("#create(#{params.inspect})").succeeds do
+      pending if Fog.mocking? && !mocks_implemented
+      @instance = collection.create(params)
+    end
+    # FIXME: work around for timing issue on AWS describe_instances mocks
+
+    if Fog.mocking? && @instance.respond_to?(:ready?)
+      @instance.wait_for { ready? }
+    end
+
+    tests("#all").succeeds do
+      pending if Fog.mocking? && !mocks_implemented
+      collection.all
+    end
+
+    if !Fog.mocking? || mocks_implemented
+      @identity = @instance.identity
+    end
+
+    tests("#get(#{@identity})").succeeds do
+      pending if Fog.mocking? && !mocks_implemented
+      collection.get(@identity)
+    end
+
+    tests('Enumerable') do
+      pending if Fog.mocking? && !mocks_implemented
+
+      methods = [
+        'all?', 'any?', 'find',  'detect', 'collect', 'map',
+        'find_index', 'flat_map', 'collect_concat', 'group_by',
+        'none?', 'one?'
+      ]
+
+      # JRuby 1.7.5+ issue causes a SystemStackError: stack level too deep
+      # https://github.com/jruby/jruby/issues/1265
+      if RUBY_PLATFORM == "java" and JRUBY_VERSION =~ /1\.7\.[5-8]/
+        methods.delete('all?')
+      end
+
+      methods.each do |enum_method|
+        if collection.respond_to?(enum_method)
+          tests("##{enum_method}").succeeds do
+            block_called = false
+            collection.send(enum_method) {|x| block_called = true }
+            block_called
+          end
+        end
+      end
+
+      [
+        'max_by','min_by'
+      ].each do |enum_method|
+        if collection.respond_to?(enum_method)
+          tests("##{enum_method}").succeeds do
+            block_called = false
+            collection.send(enum_method) {|x| block_called = true; 0 }
+            block_called
+          end
+        end
+
+      end
+
+    end
+
+    if block_given?
+      yield(@instance)
+    end
+
+    if !Fog.mocking? || mocks_implemented
+      @instance.destroy
+    end
+  end
+
+  tests('failure') do
+
+    if !Fog.mocking? || mocks_implemented
+      @identity = @identity.to_s
+      @identity = @identity.gsub(/[a-zA-Z]/) { Fog::Mock.random_letters(1) }
+      @identity = @identity.gsub(/\d/)       { Fog::Mock.random_numbers(1) }
+      @identity
+    end
+
+    tests("#get('#{@identity}')").returns(nil) do
+      pending if Fog.mocking? && !mocks_implemented
+      collection.get(@identity)
+    end
+
+  end
+end

data/tests/helpers/compute/flavors_helper.rb

@@ -0,0 +1,32 @@
+def flavors_tests(connection, params = {}, mocks_implemented = true)
+  tests('success') do
+
+    tests("#all").succeeds do
+      pending if Fog.mocking? && !mocks_implemented
+      connection.flavors.all
+    end
+
+    if !Fog.mocking? || mocks_implemented
+      @identity = connection.flavors.first.identity
+    end
+
+    tests("#get('#{@identity}')").succeeds do
+      pending if Fog.mocking? && !mocks_implemented
+      connection.flavors.get(@identity)
+    end
+
+  end
+
+  tests('failure') do
+
+    if !Fog.mocking? || mocks_implemented
+      invalid_flavor_identity = connection.flavors.first.identity.to_s.gsub(/\w/, '0')
+    end
+
+    tests("#get('#{invalid_flavor_identity}')").returns(nil) do
+      pending if Fog.mocking? && !mocks_implemented
+      connection.flavors.get(invalid_flavor_identity)
+    end
+
+  end
+end

data/tests/helpers/compute/server_helper.rb

@@ -0,0 +1,25 @@
+def server_tests(connection, params = {}, mocks_implemented = true)
+  model_tests(connection.servers, params, mocks_implemented) do
+
+    tests('#reload').returns(true) do
+      pending if Fog.mocking? && !mocks_implemented
+      @instance.wait_for { ready? }
+      identity = @instance.identity
+      !identity.nil? && identity == @instance.reload.identity
+    end
+
+    responds_to([:ready?, :state])
+    yield if block_given?
+
+    tests('#reboot').succeeds do
+      pending if Fog.mocking? && !mocks_implemented
+      @instance.wait_for { ready? }
+      @instance.reboot
+    end
+
+    if !Fog.mocking? || mocks_implemented
+      @instance.wait_for { ready? }
+    end
+
+  end
+end

data/tests/helpers/compute/servers_helper.rb

@@ -0,0 +1,10 @@
+def servers_tests(connection, params = {}, mocks_implemented = true)
+  collection_tests(connection.servers, params, mocks_implemented) do
+
+    if !Fog.mocking? || mocks_implemented
+      @instance.wait_for { ready? }
+      yield if block_given?
+    end
+
+  end
+end

data/tests/helpers/formats_helper.rb

@@ -0,0 +1,98 @@
+require "fog/schema/data_validator"
+
+# format related hackery
+# allows both true.is_a?(Fog::Boolean) and false.is_a?(Fog::Boolean)
+# allows both nil.is_a?(Fog::Nullable::String) and ''.is_a?(Fog::Nullable::String)
+module Fog
+  module Boolean; end
+  module Nullable
+    module Boolean; end
+    module Integer; end
+    module String; end
+    module Time; end
+    module Float; end
+    module Hash; end
+    module Array; end
+  end
+end
+[FalseClass, TrueClass].each {|klass| klass.send(:include, Fog::Boolean)}
+[FalseClass, TrueClass, NilClass, Fog::Boolean].each {|klass| klass.send(:include, Fog::Nullable::Boolean)}
+[NilClass, String].each {|klass| klass.send(:include, Fog::Nullable::String)}
+[NilClass, Time].each {|klass| klass.send(:include, Fog::Nullable::Time)}
+[Integer, NilClass].each {|klass| klass.send(:include, Fog::Nullable::Integer)}
+[Float, NilClass].each {|klass| klass.send(:include, Fog::Nullable::Float)}
+[Hash, NilClass].each {|klass| klass.send(:include, Fog::Nullable::Hash)}
+[Array, NilClass].each {|klass| klass.send(:include, Fog::Nullable::Array)}
+
+module Shindo
+  class Tests
+    # Generates a Shindo test that compares a hash schema to the result
+    # of the passed in block returning true if they match.
+    #
+    # The schema that is passed in is a Hash or Array of hashes that
+    # have Classes in place of values. When checking the schema the
+    # value should match the Class.
+    #
+    # Strict mode will fail if the data has additional keys. Setting
+    # +strict+ to +false+ will allow additional keys to appear.
+    #
+    # @param [Hash] schema A Hash schema
+    # @param [Hash] options Options to change validation rules
+    # @option options [Boolean] :allow_extra_keys
+    #     If +true+ does not fail when keys are in the data that are
+    #     not specified in the schema. This allows new values to
+    #     appear in API output without breaking the check.
+    # @option options [Boolean] :allow_optional_rules
+    #     If +true+ does not fail if extra keys are in the schema
+    #     that do not match the data. Not recommended!
+    # @yield Data to check with schema
+    #
+    # @example Using in a test
+    #     Shindo.tests("comparing welcome data against schema") do
+    #       data = {:welcome => "Hello" }
+    #       data_matches_schema(:welcome => String) { data }
+    #     end
+    #
+    #     comparing welcome data against schema
+    #     + data matches schema
+    #
+    # @example Example schema
+    #     {
+    #       "id" => String,
+    #       "ram" => Integer,
+    #       "disks" => [
+    #         {
+    #           "size" => Float
+    #         }
+    #       ],
+    #       "dns_name" => Fog::Nullable::String,
+    #       "active" => Fog::Boolean,
+    #       "created" => DateTime
+    #     }
+    #
+    # @return [Boolean]
+    def data_matches_schema(schema, options = {})
+      test('data matches schema') do
+        validator = Fog::Schema::DataValidator.new
+        valid = validator.validate(yield, schema, options)
+        @message = validator.message unless valid
+        valid
+      end
+    end
+
+    # @deprecated #formats is deprecated. Use #data_matches_schema instead
+    def formats(format, strict = true)
+      test('has proper format') do
+        if strict
+          options = {:allow_extra_keys => false, :allow_optional_rules => true}
+        else
+          options = {:allow_extra_keys => true, :allow_optional_rules => true}
+        end
+        validator = Fog::Schema::DataValidator.new
+        valid = validator.validate(yield, format, options)
+        @message = validator.message unless valid
+        valid
+      end
+    end
+  end
+end

data/tests/helpers/formats_helper_tests.rb

@@ -0,0 +1,110 @@
+Shindo.tests('test_helper', 'meta') do
+
+  tests('comparing welcome data against schema') do
+    data = {:welcome => "Hello" }
+    data_matches_schema(:welcome => String) { data }
+  end
+
+  tests('#data_matches_schema') do
+    tests('when value matches schema expectation') do
+      data_matches_schema({"key" => String}) { {"key" => "Value"} }
+    end
+
+    tests('when values within an array all match schema expectation') do
+      data_matches_schema({"key" => [Integer]}) { {"key" => [1, 2]} }
+    end
+
+    tests('when nested values match schema expectation') do
+      data_matches_schema({"key" => {:nested_key => String}}) { {"key" => {:nested_key => "Value"}} }
+    end
+
+    tests('when collection of values all match schema expectation') do
+      data_matches_schema([{"key" => String}]) { [{"key" => "Value"}, {"key" => "Value"}] }
+    end
+
+    tests('when collection is empty although schema covers optional members') do
+      data_matches_schema([{"key" => String}], {:allow_optional_rules => true}) { [] }
+    end
+
+    tests('when additional keys are passed and not strict') do
+      data_matches_schema({"key" => String}, {:allow_extra_keys => true}) { {"key" => "Value", :extra => "Bonus"} }
+    end
+
+    tests('when value is nil and schema expects NilClass') do
+      data_matches_schema({"key" => NilClass}) { {"key" => nil} }
+    end
+
+    tests('when value and schema match as hashes') do
+      data_matches_schema({}) { {} }
+    end
+
+    tests('when value and schema match as arrays') do
+      data_matches_schema([]) { [] }
+    end
+
+    tests('when value is a Time') do
+      data_matches_schema({"time" => Time}) { {"time" => Time.now} }
+    end
+
+    tests('when key is missing but value should be NilClass (#1477)') do
+      data_matches_schema({"key" => NilClass}, {:allow_optional_rules => true}) { {} }
+    end
+
+    tests('when key is missing but value is nullable (#1477)') do
+      data_matches_schema({"key" => Fog::Nullable::String}, {:allow_optional_rules => true}) { {} }
+    end
+  end
+
+  tests('#formats backwards compatible changes') do
+
+    tests('when value matches schema expectation') do
+      formats({"key" => String}) { {"key" => "Value"} }
+    end
+
+    tests('when values within an array all match schema expectation') do
+      formats({"key" => [Integer]}) { {"key" => [1, 2]} }
+    end
+
+    tests('when nested values match schema expectation') do
+      formats({"key" => {:nested_key => String}}) { {"key" => {:nested_key => "Value"}} }
+    end
+
+    tests('when collection of values all match schema expectation') do
+      formats([{"key" => String}]) { [{"key" => "Value"}, {"key" => "Value"}] }
+    end
+
+    tests('when collection is empty although schema covers optional members') do
+      formats([{"key" => String}]) { [] }
+    end
+
+    tests('when additional keys are passed and not strict') do
+      formats({"key" => String}, false) { {"key" => "Value", :extra => "Bonus"} }
+    end
+
+    tests('when value is nil and schema expects NilClass') do
+      formats({"key" => NilClass}) { {"key" => nil} }
+    end
+
+    tests('when value and schema match as hashes') do
+      formats({}) { {} }
+    end
+
+    tests('when value and schema match as arrays') do
+      formats([]) { [] }
+    end
+
+    tests('when value is a Time') do
+      formats({"time" => Time}) { {"time" => Time.now} }
+    end
+
+    tests('when key is missing but value should be NilClass (#1477)') do
+      formats({"key" => NilClass}) { {} }
+    end
+
+    tests('when key is missing but value is nullable (#1477)') do
+      formats({"key" => Fog::Nullable::String}) { {} }
+    end
+
+  end
+
+end