fog-brightbox 0.8.0 → 0.9.0

data/tests/helper.rb

@@ -0,0 +1,8 @@
+ENV["FOG_RC"]         = ENV["FOG_RC"] || File.expand_path("../.fog", __FILE__)
+ENV["FOG_CREDENTIAL"] = ENV["FOG_CREDENTIAL"] || "default"
+
+require "fog/brightbox"
+
+Excon.defaults.merge!(:debug_request => true, :debug_response => true)
+
+require File.expand_path(File.join(File.dirname(__FILE__), "helpers", "mock_helper"))

data/tests/helpers/collection_helper.rb

@@ -0,0 +1,91 @@
+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" && 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
+
+      %w(
+        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,28 @@
+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,23 @@
+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,8 @@
+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,106 @@
+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

data/tests/helpers/mock_helper.rb

@@ -0,0 +1,98 @@
+# Use so you can run in mock mode from the command line
+#
+# FOG_MOCK=true fog
+
+if ENV["FOG_MOCK"] == "true"
+  Fog.mock!
+end
+
+# if in mocked mode, fill in some fake credentials for us
+if Fog.mock?
+  Fog.credentials = {
+    :aws_access_key_id                => "aws_access_key_id",
+    :aws_secret_access_key            => "aws_secret_access_key",
+    :ia_access_key_id                 => "aws_access_key_id",
+    :ia_secret_access_key             => "aws_secret_access_key",
+    :bluebox_api_key                  => "bluebox_api_key",
+    :bluebox_customer_id              => "bluebox_customer_id",
+    :brightbox_client_id              => "brightbox_client_id",
+    :brightbox_secret                 => "brightbox_secret",
+    :cloudstack_disk_offering_id      => "",
+    :cloudstack_host                  => "http://cloudstack.example.org",
+    :cloudstack_network_ids           => "",
+    :cloudstack_service_offering_id   => "4437ac6c-9fe3-477a-57ec-60a5a45896a4",
+    :cloudstack_template_id           => "8a31cf9c-f248-0588-256e-9dbf58785216",
+    :cloudstack_zone_id               => "c554c592-e09c-9df5-7688-4a32754a4305",
+    :cloudstack_project_id            => "f1f1f1f1-f1f1-f1f1-f1f1-f1f1f1f1f1f1",
+    :clodo_api_key                    => "clodo_api_key",
+    :clodo_username                   => "clodo_username",
+    :digitalocean_api_key             => "digitalocean_api_key",
+    :digitalocean_client_id           => "digitalocean_client_id",
+    :dnsimple_email                   => "dnsimple_email",
+    :dnsimple_password                => "dnsimple_password",
+    :dnsmadeeasy_api_key              => "dnsmadeeasy_api_key",
+    :dnsmadeeasy_secret_key           => "dnsmadeeasy_secret_key",
+    :glesys_username                  => "glesys_username",
+    :glesys_api_key                   => "glesys_api_key",
+    :go_grid_api_key                  => "go_grid_api_key",
+    :go_grid_shared_secret            => "go_grid_shared_secret",
+    :hp_access_key                    => "hp_access_key",
+    :hp_secret_key                    => "hp_secret_key",
+    :hp_tenant_id                     => "hp_tenant_id",
+    :hp_avl_zone                      => "hp_avl_zone",
+    :hp_auth_uri                      => "http://hp/v2.0/tokens",
+    :os_account_meta_temp_url_key     => "os_account_meta_temp_url_key",
+    :ibm_username                     => "ibm_username",
+    :ibm_password                     => "ibm_password",
+    :joyent_username                  => "joyentuser",
+    :joyent_password                  => "joyentpass",
+    :linode_api_key                   => "linode_api_key",
+    :local_root                       => "~/.fog",
+    :bare_metal_cloud_password        => "bare_metal_cloud_password",
+    :bare_metal_cloud_username        => "bare_metal_cloud_username",
+    :ninefold_compute_key             => "ninefold_compute_key",
+    :ninefold_compute_secret          => "ninefold_compute_secret",
+    :ninefold_storage_secret          => "ninefold_storage_secret",
+    :ninefold_storage_token           => "ninefold_storage_token",
+    #    :public_key_path                  => '~/.ssh/id_rsa.pub',
+    #    :private_key_path                 => '~/.ssh/id_rsa',
+    :opennebula_endpoint              => "http://opennebula:2633/RPC2",
+    :opennebula_username              => "oneadmin",
+    :opennebula_password              => "oneadmin",
+    :openstack_api_key                => "openstack_api_key",
+    :openstack_username               => "openstack_username",
+    :openstack_tenant                 => "openstack_tenant",
+    :openstack_auth_url               => "http://openstack:35357/v2.0/tokens",
+    :ovirt_url                        => "http://ovirt:8080/api",
+    :ovirt_username                   => "admin@internal",
+    :ovirt_password                   => "123123",
+    :profitbricks_username            => "profitbricks_username",
+    :profitbricks_password            => "profitbricks_password",
+    :rackspace_api_key                => "rackspace_api_key",
+    :rackspace_region                 => "dfw",
+    :rackspace_username               => "rackspace_username",
+    :sakuracloud_api_token            => "sakuracloud_api_token",
+    :sakuracloud_api_token_secret     => "sakuracloud_api_token_secret",
+    :vcloud_host                      => "vcloud_host",
+    :vcloud_password                  => "vcloud_password",
+    :vcloud_username                  => "vcloud_username",
+    :vcloud_director_host             => "vcloud-director-host",
+    :vcloud_director_password         => "vcloud_director_password",
+    :vcloud_director_username         => "vcd_user@vcd_org_name",
+    :zerigo_email                     => "zerigo_email",
+    :zerigo_token                     => "zerigo_token",
+    :dynect_customer                  => "dynect_customer",
+    :dynect_username                  => "dynect_username",
+    :dynect_password                  => "dynect_password",
+    :vsphere_server                   => "virtualcenter.lan",
+    :vsphere_username                 => "apiuser",
+    :vsphere_password                 => "apipassword",
+    :vsphere_expected_pubkey_hash     => "abcdef1234567890",
+    :cloudsigma_username              => "csuname",
+    :cloudsigma_password              => "cspass",
+    :docker_username                  => "docker-fan",
+    :docker_password                  => "i<3docker",
+    :docker_email                     => "dockerfan@gmail.com",
+    :docker_url                       => "unix://var/run/docker.sock"
+  }.merge(Fog.credentials)
+end