fog 1.23.0 → 1.24.0

data/lib/fog/sakuracloud/requests/volume/list_plans.rb

@@ -1,40 +0,0 @@
-# coding: utf-8
-
-module Fog
-  module Volume
-    class SakuraCloud
-      class Real
-        def list_plans(options = {})
-          request(
-            :headers => {
-              'Authorization' => "Basic #{@auth_encord}"
-            },
-            :method => 'GET',
-            :path => "#{Fog::SakuraCloud::SAKURACLOUD_API_ENDPOINT}/product/disk"
-          )
-        end
-      end
-
-      class Mock
-        def list_plans(options = {})
-          response = Excon::Response.new
-          response.status = 200
-          response.body = {
-          "DiskPlans" =>
-            [
-            {"Index"=>0,
-              "ID"=>4,
-              "Name"=>"SSDプラン",
-              "Availability"=>"available"},
-            {"Index"=>1,
-              "ID"=>2,
-              "Name"=>"標準プラン",
-              "Availability"=>"available"}
-            ]
-          }
-          response
-        end
-      end
-    end
-  end
-end

data/lib/fog/sakuracloud/volume.rb

@@ -1,88 +0,0 @@
-require 'fog/sakuracloud'
-require 'fog/volume'
-
-module Fog
-  module Volume
-    class SakuraCloud < Fog::Service
-      requires     :sakuracloud_api_token
-      requires     :sakuracloud_api_token_secret
-
-      recognizes   :sakuracloud_api_url
-
-      model_path 'fog/sakuracloud/models/volume'
-      model      :archive
-      collection :archives
-      model      :plan
-      collection :plans
-      model      :disk
-      collection :disks
-
-      request_path 'fog/sakuracloud/requests/volume'
-      request      :list_disks
-      request      :list_plans
-      request      :create_disk
-      request      :configure_disk
-      request      :attach_disk
-      request      :delete_disk
-      request      :list_archives
-
-      class Real
-        def initialize(options = {})
-          @auth_encord = Base64.strict_encode64([
-            options[:sakuracloud_api_token],
-            options[:sakuracloud_api_token_secret]
-          ].join(':'))
-          Fog.credentials[:sakuracloud_api_token]        = options[:sakuracloud_api_token]
-          Fog.credentials[:sakuracloud_api_token_secret] = options[:sakuracloud_api_token_secret]
-
-          @sakuracloud_api_url = options[:sakuracloud_api_url] || 'https://secure.sakura.ad.jp'
-
-          @connection = Fog::Core::Connection.new(@sakuracloud_api_url)
-        end
-
-        def request(params)
-          response = parse @connection.request(params)
-          response
-        end
-
-        private
-        def parse(response)
-          return response if response.body.empty?
-          response.body = Fog::JSON.decode(response.body)
-          response
-        end
-      end
-
-      class Mock
-        def self.data
-          @data ||= Hash.new do |hash, key|
-            hash[key] = {
-              :disks => [],
-              :plans => [],
-              :archives => []
-            }
-          end
-        end
-
-        def self.reset
-          @data = nil
-        end
-
-        def initialize(options={})
-          @sakuracloud_api_token        = options[:sakuracloud_api_token]
-          @sakuracloud_api_token_secret = options[:sakuracloud_api_token_secret]
-        end
-
-        def data
-          self.class.data[@sakuracloud_api_token]
-          self.class.data[@sakuracloud_api_token_secret]
-        end
-
-        def reset_data
-          self.class.data.delete(@sakuracloud_api_token)
-          self.class.data.delete(@sakuracloud_api_token_secret)
-        end
-      end
-    end #SakuraCloud
-  end #Volume
-end

data/lib/fog/schema/data_validator.rb

@@ -1,153 +0,0 @@
-module Fog
-  module Schema
-    # This validates a data object against a Ruby based schema to see
-    # if they match.
-    #
-    # * An object matches the schema if +==+ or +===+ returns +true+
-    # * Hashes match if all the key's values match the classes given
-    #   in the schema as well. This can be configured in the options
-    # * Arrays match when every element in the data matches the case
-    #   given in the schema.
-    #
-    # The schema and validation are very simple and probably not
-    # suitable for some cases.
-    #
-    # The following classes can be used to check for special behaviour
-    #
-    # * Fog::Boolean - value may be +true+ or +false+
-    # * Fog::Nullable::Boolean - value may be +true+, +false+ or +nil+
-    # * Fog::Nullable::Integer - value may be an Integer or +nil+
-    # * Fog::Nullable::String
-    # * Fog::Nullable::Time
-    # * Fog::Nullable::Float
-    # * Fog::Nullable::Hash
-    # * Fog::Nullable::Array
-    #
-    # All the "nullable" objects will pass if the value is of the class
-    # or if it is +nil+. This allows you to match APIs that may include
-    # keys when the value is not available in some cases but will
-    # always be a String. Such as an password that is only displayed
-    # on the reset action.
-    #
-    # The keys for "nullable" resources should always be present but
-    # original matcher had a bug that allowed these to also appear to
-    # work as optional keys/values.
-    #
-    # If you need the original behaviour, data with a missing key is
-    # still valid, then you may pass the +:allow_optional_rules+
-    # option to the #validate method.
-    #
-    # That is not recommended because you are describing a schema
-    # with optional keys in a format that does not support it.
-    #
-    # Setting +:allow_extra_keys+ as +true+ allows the data to
-    # contain keys not declared by the schema and still pass. This
-    # is useful if new attributes appear in the API in a backwards
-    # compatible manner and can be ignored.
-    #
-    # This is the behaviour you would have seen with +strict+ being
-    # +false+ in the original test helper.
-    #
-    # @example Schema example
-    #     {
-    #       "id" => String,
-    #       "ram" => Integer,
-    #       "disks" => [
-    #         "size" => Float
-    #       ],
-    #       "dns_name" => Fog::Nullable::String,
-    #       "active" => Fog::Boolean,
-    #       "created" => DateTime
-    #     }
-    #
-    class DataValidator
-      def initialize
-        @message = nil
-      end
-
-      # Checks if the data structure matches the schema passed in and
-      # returns +true+ if it fits.
-      #
-      # @param [Object] data Hash or Array to check
-      # @param [Object] schema Schema pattern to check against
-      # @param [Boolean] options
-      # @option options [Boolean] :allow_extra_keys
-      #     If +true+ does not fail if extra keys are in the data
-      #     that are not in the schema.
-      # @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!
-      #
-      # @return [Boolean] Did the data fit the schema?
-      def validate(data, schema, options = {})
-        valid = validate_value(schema, data, options)
-
-        unless valid
-          @message = "#{data.inspect} does not match #{schema.inspect}"
-        end
-        valid
-      end
-
-      # This returns the last message set by the validator
-      #
-      # @return [String]
-      def message
-        @message
-      end
-
-      private
-
-      # This contains a slightly modified version of the Hashidator gem
-      # but unfortunately the gem does not cope with Array schemas.
-      #
-      # @see https://github.com/vangberg/hashidator/blob/master/lib/hashidator.rb
-      #
-      def validate_value(validator, value, options)
-        Fog::Logger.write :debug, "[yellow][DEBUG] #{value.inspect} against #{validator.inspect}[/]\n"
-
-        case validator
-        when Array
-          return false if value.is_a?(Hash)
-          value.respond_to?(:all?) && value.all? {|x| validate_value(validator[0], x, options)}
-        when Symbol
-          value.respond_to? validator
-        when Hash
-          return false if value.is_a?(Array)
-
-          # When being strict values not specified in the schema are fails
-          unless options[:allow_extra_keys]
-            if value.respond_to?(:empty?)
-              # Validator is empty but values are not
-              return false if !value.empty? && validator.empty?
-            end
-          end
-
-          unless options[:allow_optional_rules]
-            if value.respond_to?(:empty?)
-              # Validator has rules left but no more values
-              return false if value.empty? && !validator.empty?
-            end
-          end
-
-          validator.all? do |key, sub_validator|
-            Fog::Logger.write :debug, "[blue][DEBUG] #{key.inspect} against #{sub_validator.inspect}[/]\n"
-            validate_value(sub_validator, value[key], options)
-          end
-        else
-          result = validator == value
-          result = validator === value unless result
-          # Repeat unless we have a Boolean already
-          unless (result.is_a?(TrueClass) || result.is_a?(FalseClass))
-            result = validate_value(result, value, options)
-          end
-          if result
-            Fog::Logger.write :debug, "[green][DEBUG] Validation passed: #{value.inspect} against #{validator.inspect}[/]\n"
-          else
-            Fog::Logger.write :debug, "[red][DEBUG] Validation failed: #{value.inspect} against #{validator.inspect}[/]\n"
-          end
-          result
-        end
-      end
-    end
-  end
-end

data/tests/sakuracloud/helper.rb

@@ -1,7 +0,0 @@
-def volume_service
-  Fog::Volume[:sakuracloud]
-end
-
-def compute_service
-  Fog::Compute[:sakuracloud]
-end

data/tests/sakuracloud/requests/compute/plans_tests.rb

@@ -1,32 +0,0 @@
-# coding: utf-8
-Shindo.tests('Fog::Compute[:sakuracloud] | list_plans request', ['sakuracloud', 'compute']) do
-
-  @plan_format = {
-    'Index'        => Integer,
-    'ID'           => Integer,
-    'Name'         => String,
-    'CPU'          => Integer,
-    'MemoryMB'     => Integer,
-    'Availability' => String
-  }
-
-  tests('success') do
-
-    tests('#list_plans') do
-      serverplans = compute_service.list_plans
-      test 'returns a Hash' do
-        serverplans.body.is_a? Hash
-      end
-      if Fog.mock?
-        tests('ServerPlans').formats(@plan_format, false) do
-          serverplans.body['ServerPlans'].first
-        end
-      else
-        returns(200) { serverplans.status }
-        returns(false) { serverplans.body.empty? }
-      end
-    end
-
-  end
-
-end

data/tests/sakuracloud/requests/compute/servers_tests.rb

@@ -1,46 +0,0 @@
-# coding: utf-8
-Shindo.tests('Fog::Compute[:sakuracloud] | list_servers request', ['sakuracloud', 'compute']) do
-
-  @servers_format = {
-    'Index'        => Integer,
-    'ID'           => Integer,
-    'Name'         => String,
-    'ServerPlan'   => Hash,
-    'Instance'     => Hash,
-    'Disks'        => Array
-  }
-
-  tests('success') do
-
-    tests('#list_servers') do
-      servers = compute_service.list_servers
-      test 'returns a Hash' do
-        servers.body.is_a? Hash
-      end
-      if Fog.mock?
-        tests('Servers').formats(@servers_format, false) do
-          servers.body['Servers'].first
-        end
-      else
-        returns(200) { servers.status }
-        returns(true) { servers.body.is_a? Hash }
-      end
-    end
-  end
-end
-
-Shindo.tests('Fog::Compute[:sakuracloud] | create_servers request', ['sakuracloud', 'compute']) do
-  tests('success') do
-    tests('#create_servers') do
-      servers = compute_service.create_server('foobar', 2001)
-      test 'returns a Hash' do
-        servers.body.is_a? Hash
-      end
-
-      unless Fog.mock?
-        returns(201) { servers.status }
-        returns(true) { servers.body.is_a? Hash }
-      end
-    end
-  end
-end

data/tests/sakuracloud/requests/compute/ssh_keys_tests.rb

@@ -1,30 +0,0 @@
-# coding: utf-8
-Shindo.tests('Fog::Compute[:sakuracloud] | list_ssh_keys request', ['sakuracloud', 'compute']) do
-
-  @sshkey_format = {
-    'Index'        => Integer,
-    'ID'           => String,
-    'Name'           => String,
-    'PublicKey'    => String
-  }
-
-  tests('success') do
-
-    tests('#list_ssh_keys') do
-      sshkeys = compute_service.list_ssh_keys
-      test 'returns a Hash' do
-        sshkeys.body.is_a? Hash
-      end
-      if Fog.mock?
-        tests('SSHKeys').formats(@sshkey_format, false) do
-          sshkeys.body['SSHKeys'].first
-        end
-      else
-        returns(200) { sshkeys.status }
-        returns(false) { sshkeys.body.empty? }
-      end
-    end
-
-  end
-
-end

data/tests/sakuracloud/requests/compute/zones_tests.rb

@@ -1,30 +0,0 @@
-# coding: utf-8
-Shindo.tests('Fog::Compute[:sakuracloud] | list_zones request', ['sakuracloud', 'compute']) do
-
-  @zone_format = {
-    'Index'        => Integer,
-    'ID'           => Integer,
-    'Name'         => String,
-    'Description'  => String
-  }
-
-  tests('success') do
-
-    tests('#list_zones') do
-      zones = compute_service.list_zones
-      test 'returns a Hash' do
-        zones.body.is_a? Hash
-      end
-      if Fog.mock?
-        tests('Zones').formats(@zone_format, false) do
-          zones.body['Zones'].first
-        end
-      else
-        returns(200) { zones.status }
-        returns(false) { zones.body.empty? }
-      end
-    end
-
-  end
-
-end

data/tests/sakuracloud/requests/volume/archives_tests.rb

@@ -1,31 +0,0 @@
-# coding: utf-8
-Shindo.tests('Fog::Volume[:sakuracloud] | list_archives request', ['sakuracloud', 'volume']) do
-
-  @archive_format = {
-    'Index'        => Integer,
-    'ID'           => Integer,
-    'Name'         => String,
-    'SizeMB'       => Integer,
-    'Plan'         => Hash
-  }
-
-  tests('success') do
-
-    tests('#list_archives') do
-      archives = volume_service.list_archives
-      test 'returns a Hash' do
-        archives.body.is_a? Hash
-      end
-      if Fog.mock?
-        tests('Archives').formats(@archive_format, false) do
-          archives.body['Archives'].first
-        end
-      else
-        returns(200) { archives.status }
-        returns(false) { archives.body.empty? }
-      end
-    end
-
-  end
-
-end