fog-atmos 0.0.1

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

data/tests/helpers/mock_helper.rb

@@ -0,0 +1,117 @@
+# 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',
+    :atmos_storage_token              => 'atmos_token',
+    :atmos_storage_secret             => 'atmos_secret',
+    :atmos_storage_endpoint           => 'http://atmos.is.cool:1000/test1.0',
+    :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',
+    :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',
+    :ecloud_username                  => 'ecloud_username',
+    :ecloud_password                  => 'ecloud_password',
+    :ecloud_versions_uri              => 'http://ecloud.versions.uri',
+    :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',
+    :google_storage_access_key_id     => 'google_storage_access_key_id',
+    :google_storage_secret_access_key => 'google_storage_secret_access_key',
+    :google_project                   => 'google_project_name',
+    :google_client_email              => 'fake@developer.gserviceaccount.com',
+    :google_key_location              => '~/fake.p12',
+    :hp_access_key                    => 'hp_access_key',
+    :hp_secret_key                    => 'hp_secret_key',
+    :hp_tenant_id                     => 'hp_tenant_id',
+    :hp_avl_zone                      => 'hp_avl_zone',
+    :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',
+    :libvirt_uri                      => 'qemu://libvirt/system',
+    :rackspace_api_key                => 'rackspace_api_key',
+    :rackspace_region                 => 'dfw',
+    :rackspace_username               => 'rackspace_username',
+    :riakcs_access_key_id             => 'riakcs_access_key_id',
+    :riakcs_secret_access_key         => 'riakcs_secret_access_key',
+    :sakuracloud_api_token            => 'sakuracloud_api_token',
+    :sakuracloud_api_token_secret     => 'sakuracloud_api_token_secret',
+    :storm_on_demand_username         => 'storm_on_demand_username',
+    :storm_on_demand_password         => 'storm_on_demand_password',
+    :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',
+    :voxel_api_key                    => 'voxel_api_key',
+    :voxel_api_secret                 => 'voxel_api_secret',
+    :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',
+    :libvirt_uri                      => 'qemu:///system',
+    :libvirt_username                 => 'root',
+    :libvirt_password                 => 'password',
+    :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

data/tests/helpers/model_helper.rb

@@ -0,0 +1,31 @@
+def model_tests(collection, params = {}, mocks_implemented = true)
+  tests('success') do
+
+    @instance = collection.new(params)
+
+    tests("#save").succeeds do
+      pending if Fog.mocking? && !mocks_implemented
+      @instance.save
+    end
+
+    if block_given?
+      yield(@instance)
+    end
+
+    tests("#destroy").succeeds do
+      pending if Fog.mocking? && !mocks_implemented
+      @instance.destroy
+    end
+
+  end
+end
+
+# Generates a unique identifier with a random differentiator.
+# Useful when rapidly re-running tests, so we don't have to wait
+# serveral minutes for deleted objects to disappear from the API
+# E.g. 'fog-test-1234'
+def uniq_id(base_name = 'fog-test')
+  # random_differentiator
+  suffix = rand(65536).to_s(16).rjust(4, '0')
+  [base_name, suffix] * '-'
+end

data/tests/helpers/responds_to_helper.rb

@@ -0,0 +1,11 @@
+module Shindo
+  class Tests
+    def responds_to(method_names)
+      for method_name in [*method_names]
+        tests("#respond_to?(:#{method_name})").returns(true) do
+          @instance.respond_to?(method_name)
+        end
+      end
+    end
+  end
+end

data/tests/helpers/schema_validator_tests.rb

@@ -0,0 +1,107 @@
+Shindo.tests('Fog::Schema::DataValidator', 'meta') do
+
+  validator = Fog::Schema::DataValidator.new
+
+  tests('#validate') do
+
+    tests('returns true') do
+
+      returns(true, 'when value matches schema expectation') do
+        validator.validate({"key" => "Value"}, {"key" => String})
+      end
+
+      returns(true, 'when values within an array all match schema expectation') do
+        validator.validate({"key" => [1, 2]}, {"key" => [Integer]})
+      end
+
+      returns(true, 'when nested values match schema expectation') do
+        validator.validate({"key" => {:nested_key => "Value"}}, {"key" => {:nested_key => String}})
+      end
+
+      returns(true, 'when collection of values all match schema expectation') do
+        validator.validate([{"key" => "Value"}, {"key" => "Value"}], [{"key" => String}])
+      end
+
+      returns(true, 'when collection is empty although schema covers optional members') do
+        validator.validate([], [{"key" => String}])
+      end
+
+      returns(true, 'when additional keys are passed and not strict') do
+        validator.validate({"key" => "Value", :extra => "Bonus"}, {"key" => String}, {:allow_extra_keys => true})
+      end
+
+      returns(true, 'when value is nil and schema expects NilClass') do
+        validator.validate({"key" => nil}, {"key" => NilClass})
+      end
+
+      returns(true, 'when value and schema match as hashes') do
+        validator.validate({}, {})
+      end
+
+      returns(true, 'when value and schema match as arrays') do
+        validator.validate([], [])
+      end
+
+      returns(true, 'when value is a Time') do
+        validator.validate({"time" => Time.now}, {"time" => Time})
+      end
+
+      returns(true, 'when key is missing but value should be NilClass (#1477)') do
+        validator.validate({}, {"key" => NilClass}, {:allow_optional_rules => true})
+      end
+
+      returns(true, 'when key is missing but value is nullable (#1477)') do
+        validator.validate({}, {"key" => Fog::Nullable::String}, {:allow_optional_rules => true})
+      end
+
+    end
+
+    tests('returns false') do
+
+      returns(false, 'when value does not match schema expectation') do
+        validator.validate({"key" => nil}, {"key" => String})
+      end
+
+      returns(false, 'when key formats do not match') do
+        validator.validate({"key" => "Value"}, {:key => String})
+      end
+
+      returns(false, 'when additional keys are passed and strict') do
+        validator.validate({"key" => "Missing"}, {})
+      end
+
+      returns(false, 'when some keys do not appear') do
+        validator.validate({}, {"key" => String})
+      end
+
+      returns(false, 'when collection contains a member that does not match schema') do
+        validator.validate([{"key" => "Value"}, {"key" => 5}], [{"key" => String}])
+      end
+
+      returns(false, 'when collection has multiple schema patterns') do
+        validator.validate([{"key" => "Value"}], [{"key" => Integer}, {"key" => String}])
+      end
+
+      returns(false, 'when hash and array are compared') do
+        validator.validate({}, [])
+      end
+
+      returns(false, 'when array and hash are compared') do
+        validator.validate([], {})
+      end
+
+      returns(false, 'when a hash is expected but another data type is found') do
+        validator.validate({"key" => {:nested_key => []}}, {"key" => {:nested_key => {}}})
+      end
+
+      returns(false, 'when key is missing but value should be NilClass (#1477)') do
+        validator.validate({}, {"key" => NilClass}, {:allow_optional_rules => false})
+      end
+
+      returns(false, 'when key is missing but value is nullable (#1477)') do
+        validator.validate({}, {"key" => Fog::Nullable::String}, {:allow_optional_rules => false})
+      end
+
+    end
+  end
+end