fog-softlayer 0.0.4 → 0.0.5

data/tests/helpers/formats_helper_tests.rb

@@ -0,0 +1,111 @@
+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,111 @@
+# 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',
+    :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',
+    :libvirt_uri                      => 'qemu://libvirt/system',
+    :rackspace_api_key                => 'rackspace_api_key',
+    :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,35 @@
+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
+    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,13 @@
+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

data/tests/helpers/succeeds_helper.rb

@@ -0,0 +1,11 @@
+module Shindo
+  class Tests
+
+    def succeeds
+      test('succeeds') do
+        !!instance_eval(&Proc.new)
+      end
+    end
+
+  end
+end

data/tests/lorem.txt

@@ -0,0 +1 @@
+Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.

data/tests/softlayer/compute/helper.rb

@@ -0,0 +1,7 @@
+#
+# Author:: Matt Eldridge (<matt.eldridge@us.ibm.com>)
+# © Copyright IBM Corporation 2014.
+#
+# LICENSE: MIT (http://opensource.org/licenses/MIT)
+#
+require File.expand_path("schema", File.dirname(__FILE__))

data/tests/softlayer/compute/schema.rb

@@ -0,0 +1,133 @@
+#
+# Author:: Matt Eldridge (<matt.eldridge@us.ibm.com>)
+# © Copyright IBM Corporation 2014.
+#
+# LICENSE: MIT (http://opensource.org/licenses/MIT)
+#
+module Fog
+  module Softlayer
+    module Nullable
+      module Account; end
+      module BareMetal; end
+      module Collected; end
+      module Collection; end
+      module VirtualGuest; end
+      module Image; end
+      module IPV4; end
+      module LoadBalancer; end
+    end
+  end
+end
+
+Hash.send :include, Fog::Softlayer::Nullable::Account
+NilClass.send :include, Fog::Softlayer::Nullable::Account
+
+Hash.send :include, Fog::Softlayer::Nullable::BareMetal
+NilClass.send :include, Fog::Softlayer::Nullable::BareMetal
+
+Hash.send :include, Fog::Softlayer::Nullable::Collected
+NilClass.send :include, Fog::Softlayer::Nullable::Collected
+
+Hash.send :include, Fog::Softlayer::Nullable::Collection
+NilClass.send :include, Fog::Softlayer::Nullable::Collection
+
+Hash.send :include, Fog::Softlayer::Nullable::VirtualGuest
+NilClass.send :include, Fog::Softlayer::Nullable::VirtualGuest
+
+Hash.send :include, Fog::Softlayer::Nullable::Image
+NilClass.send :include, Fog::Softlayer::Nullable::Image
+
+Hash.send :include, Fog::Softlayer::Nullable::IPV4
+NilClass.send :include, Fog::Softlayer::Nullable::IPV4
+
+Hash.send :include, Fog::Softlayer::Nullable::LoadBalancer
+NilClass.send :include, Fog::Softlayer::Nullable::LoadBalancer
+
+
+class Softlayer
+  module Compute
+    module Formats
+      module Struct
+        ## nothing here yet
+      end
+
+      module BareMetal
+        SERVER = {
+            "accountId" =>  String,
+            "createDate" => String,
+            "dedicatedAccountHostOnlyFlag" => Fog::Nullable::Boolean,
+            "domain" => Fog::Nullable::String,
+            "fullyQualifiedDomainName" => Fog::Nullable::String,
+            "hostname" => Fog::Nullable::String,
+            "id" => String,
+            "lastPowerStateId" => Fog::Nullable::String,
+            "lastVerifiedDate" => Fog::Nullable::String,
+            "maxCpu" => Fog::Nullable::String,
+            "maxCpuUnits" => String,
+            "maxMemory" => Fog::Nullable::String,
+            "metricPollDate" => Fog::Nullable::String,
+            "modifyDate" => Fog::Nullable::String,
+            "startCpus" => Fog::Nullable::String,
+            "statusId" => Integer,
+            "globalIdentifier" => String
+        }
+
+      end
+
+      module VirtualGuest
+        SERVER = {
+            "accountId" =>  String,
+            "createDate" => String,
+            "dedicatedAccountHostOnlyFlag" => Fog::Nullable::Boolean,
+            "domain" => String,
+            "fullyQualifiedDomainName" => Fog::Nullable::String,
+            "hostname" => String,
+            "id" => String,
+            "lastPowerStateId" => Fog::Nullable::String,
+            "lastVerifiedDate" => Fog::Nullable::String,
+            "maxCpu" => Fog::Nullable::String,
+            "maxCpuUnits" => String,
+            "maxMemory" => Integer,
+            "metricPollDate" => Fog::Nullable::String,
+            "modifyDate" => Fog::Nullable::String,
+            "startCpus" => Integer,
+            "statusId" => Integer,
+            "globalIdentifier" => String
+        }
+
+      end
+
+      module Collected
+        SERVER = {
+            :id => Fog::Nullable::Integer,
+            :hostname => Fog::Nullable::String,
+            :domain => Fog::Nullable::String,
+            :fqdn => Fog::Nullable::String,
+            :cpu => Fog::Nullable::String,
+            :ram => Fog::Nullable,
+            :disk => Fog::Nullable::Array,
+            :private_ip => Fog::Nullable::String,
+            :public_ip => Fog::Nullable::String,
+            :flavor_id => Fog::Nullable::String,
+            :bare_metal => Fog::Nullable::Boolean,
+            :os_code => Fog::Nullable::String,
+            :image_id => Hash,
+            :ephemeral_storage => Fog::Nullable::Boolean,
+            :created_at => Fog::Nullable::Time,
+            :last_verified_date => Fog::Nullable::Time,
+            :metric_poll_date => Fog::Nullable::Time,
+            :modify_date => Fog::Nullable::Time,
+            :account_id => Fog::Nullable::Integer,
+            :datacenter => Fog::Nullable::String,
+            :single_tenant => Fog::Nullable::Boolean,
+            :global_identifier => Fog::Nullable::String,
+            :hourly_billing_flag => Fog::Nullable::Boolean,
+        }
+      end
+
+      module Collection
+        SERVERS = [Softlayer::Compute::Formats::Collected::SERVER]
+      end
+    end
+  end
+end