fog 1.27.0 → 1.28.0

data/lib/fog/riakcs/requests/provisioning/get_user.rb

@@ -1,41 +0,0 @@
-module Fog
-  module RiakCS
-    class Provisioning
-      class Real
-        include Utils
-        include MultipartUtils
-
-        def get_user(key_id)
-          response = @s3_connection.get_object('riak-cs', "user/#{key_id}", { 'Accept' => 'application/json' })
-          response.body = Fog::JSON.decode(response.body)
-          response
-        end
-      end
-
-      class Mock
-        def get_user(key_id)
-          if user = data[key_id]
-            Excon::Response.new.tap do |response|
-              response.status = 200
-              response.headers['Content-Type'] = 'application/json'
-              response.body = {
-                "email"        => user[:email],
-                "display_name" => user[:name],
-                "name"         => "user123",
-                "key_id"       => "XXXXXXXXXXXXXXXXXXXX",
-                "key_secret"   => user[:key_secret],
-                "id"           => "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
-                "status"       => user[:status]
-              }
-            end
-          else
-            Excon::Response.new.tap do |response|
-              response.status = 404
-              response.headers['Content-Type'] = 'application/json'
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/fog/riakcs/requests/provisioning/list_users.rb

@@ -1,43 +0,0 @@
-module Fog
-  module RiakCS
-    class Provisioning
-      class Real
-        include Utils
-        include MultipartUtils
-
-        def list_users(options = {})
-          response      = @s3_connection.get_object('riak-cs', 'users', { 'Accept' => 'application/json', 'query' => options })
-
-          boundary      = extract_boundary(response.headers['Content-Type'])
-          parts         = parse(response.body, boundary)
-          decoded       = parts.map { |part| Fog::JSON.decode(part[:body]) }
-
-          response.body = decoded.flatten
-
-          response
-        end
-      end
-
-      class Mock
-        def list_users(options = {})
-          filtered_data = options[:status] ? data.select { |key, value| value[:status] == options[:status] } : data
-
-          Excon::Response.new.tap do |response|
-            response.status = 200
-            response.body   = filtered_data.map do |key, value|
-              {
-                "email"        => value[:email],
-                "display_name" => value[:name],
-                "name"         => "user123",
-                "key_id"       => key,
-                "key_secret"   => value[:key_secret],
-                "id"           => "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
-                "status"       => value[:status]
-              }
-            end.compact
-          end
-        end
-      end
-    end
-  end
-end

data/lib/fog/riakcs/requests/provisioning/regrant_secret.rb

@@ -1,23 +0,0 @@
-module Fog
-  module RiakCS
-    class Provisioning
-      class Real
-        include Utils
-        include UserUtils
-        include MultipartUtils
-
-        def regrant_secret(key_id)
-          update_riakcs_user(key_id, { :new_key_secret => true })
-        end
-      end
-
-      class Mock
-        include UserUtils
-
-        def regrant_secret(key_id)
-          update_mock_user(key_id, { :new_key_secret => true })
-        end
-      end
-    end
-  end
-end

data/lib/fog/riakcs/requests/provisioning/update_user.rb

@@ -1,23 +0,0 @@
-module Fog
-  module RiakCS
-    class Provisioning
-      class Real
-        include Utils
-        include UserUtils
-        include MultipartUtils
-
-        def update_user(key_id, user)
-          update_riakcs_user(key_id, user)
-        end
-      end
-
-      class Mock
-        include UserUtils
-
-        def update_user(key_id, user)
-          update_mock_user(key_id, user)
-        end
-      end
-    end
-  end
-end

data/lib/fog/riakcs/requests/usage/get_usage.rb

@@ -1,68 +0,0 @@
-module Fog
-  module RiakCS
-    class Usage
-      module Utils
-        TYPES_TO_STRING = { :access  => 'a', :storage => 'b' }
-        DEFAULT_TYPES   = TYPES_TO_STRING.keys
-        DEFAULT_FORMAT  = :json
-
-        def sanitize_and_convert_time(time)
-          time.utc.iso8601.gsub(/[:-]/, '')
-        end
-
-        def format_and_types_to_path(format, types)
-          format_character = format.to_s.split('').first
-          type_characters  = types.map { |t| TYPES_TO_STRING[t] }.compact
-
-          [type_characters, format_character].flatten.compact.join
-        end
-
-        def request_uri(access_key_id, options)
-          format        = DEFAULT_FORMAT
-          types         = options[:types]       || DEFAULT_TYPES
-          start_time    = options[:start_time]  || Time.now.utc - 86400
-          end_time      = options[:end_time]    || Time.now.utc
-
-          [access_key_id,
-           format_and_types_to_path(format, types),
-           sanitize_and_convert_time(start_time),
-           sanitize_and_convert_time(end_time)].join('.')
-        end
-      end
-
-      class Real
-        include Utils
-
-        def get_usage(access_key_id, options = {})
-          response = @connection.get_object('riak-cs', ["usage", request_uri(access_key_id, options)].join("/"))
-
-          if !response.body.empty?
-            response.body = Fog::JSON.decode(response.body)
-          end
-          response
-        end
-      end
-
-      class Mock
-        include Utils
-
-        def get_usage(access_key, options = {})
-          Excon::Response.new.tap do |response|
-            response.status = 200
-            response.headers['Content-Type'] = 'application/json'
-            response.body = {
-              'Access' => {
-                'Nodes'   => [],
-                'Errors'  => []
-              },
-              'Storage' => {
-                'Samples' => [],
-                'Errors'  => []
-              }
-            }
-          end
-        end
-      end
-    end
-  end
-end

data/lib/fog/riakcs/usage.rb

@@ -1,62 +0,0 @@
-require 'fog/riakcs/core'
-require 'time'
-
-module Fog
-  module RiakCS
-    class Usage < Fog::Service
-      requires :riakcs_access_key_id, :riakcs_secret_access_key
-      recognizes :host, :path, :port, :scheme, :persistent
-
-      request_path 'fog/riakcs/requests/usage'
-      request :get_usage
-
-      class Mock
-        include Utils
-
-        def self.data
-          @data ||= Hash.new do |hash, key|
-            hash[key] = {}
-          end
-        end
-
-        def self.reset
-          @data = nil
-        end
-
-        def initialize(options = {})
-          configure_uri_options(options)
-        end
-
-        def data
-          self.class.data[riakcs_uri]
-        end
-
-        def reset_data
-          self.class.data.delete(riakcs_uri)
-        end
-      end
-
-      class Real
-        include Utils
-
-        def initialize(options = {})
-          configure_uri_options(options)
-          @riakcs_access_key_id     = options[:riakcs_access_key_id]
-          @riakcs_secret_access_key = options[:riakcs_secret_access_key]
-          @connection_options       = options[:connection_options] || {}
-          @persistent               = options[:persistent]         || false
-
-          @connection = Fog::Storage.new(
-            :provider              => 'AWS',
-            :aws_access_key_id     => @riakcs_access_key_id,
-            :aws_secret_access_key => @riakcs_secret_access_key,
-            :host                  => @host,
-            :port                  => @port,
-            :scheme                => @scheme,
-            :connection_options    => @connection_options
-          )
-        end
-      end
-    end
-  end
-end

data/tests/riakcs/requests/provisioning/provisioning_tests.rb

@@ -1,174 +0,0 @@
-Shindo.tests('RiakCS::Provisioning | provisioning requests', ['riakcs']) do
-
-  current_timestamp = Time.now.to_i
-
-  user_format = {
-    'email'        => String,
-    'display_name' => String,
-    'name'         => String,
-    'key_id'       => String,
-    'key_secret'   => String,
-    'id'           => String,
-    'status'       => String,
-  }
-
-  tests('User creation') do
-
-    tests('is successful').returns(String) do
-
-      # Create a user.
-      #
-      email, name = "successful_user_creation_test_#{current_timestamp}@example.com", "Fog User"
-      key_id      = Fog::RiakCS[:provisioning].create_user(email, name).body['key_id']
-      key_id.class
-
-    end
-
-    tests('is successful anonymously').returns(String) do
-
-      # Create a user.
-      #
-      email, name = "successful_anonymous_user_creation_test_#{current_timestamp}@example.com", "Fog User"
-      key_id      = Fog::RiakCS[:provisioning].create_user(email, name, :anonymous => true).body['key_id']
-      key_id.class
-
-    end
-
-    tests('fails if duplicate').raises(Fog::RiakCS::Provisioning::UserAlreadyExists) do
-      2.times do
-        email, name = "failed_duplicate_user_creation_test_#{current_timestamp}@example.com", "Fog User"
-        key_id      = Fog::RiakCS[:provisioning].create_user(email, name).body['key_id']
-      end
-    end
-
-    tests('fails if invalid email').raises(Fog::RiakCS::Provisioning::ServiceUnavailable) do
-      email, name = "failed_duplicate_user_creation_test_#{current_timestamp}", "Fog User"
-      key_id      = Fog::RiakCS[:provisioning].create_user(email, name).body['key_id']
-    end
-
-  end
-
-  tests('User disable') do
-
-    tests('is successful').returns(200) do
-
-      # Create a user.
-      #
-      email, name = "successful_user_disable_test_#{current_timestamp}@example.com", "Fog User"
-      key_id      = Fog::RiakCS[:provisioning].create_user(email, name).body['key_id']
-
-      Fog::RiakCS[:provisioning].disable_user(key_id).status
-
-    end
-
-  end
-
-  tests('User enable') do
-
-    tests('is successful').returns(200) do
-
-      # Create a user.
-      #
-      email, name = "successful_user_disable_enable_test_#{current_timestamp}@example.com", "Fog User"
-      key_id      = Fog::RiakCS[:provisioning].create_user(email, name).body['key_id']
-
-      Fog::RiakCS[:provisioning].disable_user(key_id).status
-      Fog::RiakCS[:provisioning].enable_user(key_id).status
-
-    end
-
-  end
-
-  tests('User granted new key secret') do
-
-    tests('is successful').returns(true) do
-
-      # Create a user.
-      #
-      email, name        = "successful_user_regrant_test_#{current_timestamp}@example.com", "Fog User"
-      user               = Fog::RiakCS[:provisioning].create_user(email, name).body
-      key_id, key_secret = user['key_id'], user['key_secret']
-
-      Fog::RiakCS[:provisioning].regrant_secret(key_id).status
-
-      # Verify new secret.
-      #
-      new_key_secret = Fog::RiakCS[:provisioning].get_user(key_id).body['key_secret']
-      new_key_secret != key_secret
-
-    end
-
-  end
-
-  tests('User retrieval') do
-
-    tests('is successful').formats(user_format) do
-
-      # Create a user.
-      #
-      email, name = "user_retrieval_test_#{current_timestamp}@example.com", "Fog User"
-      key_id      = Fog::RiakCS[:provisioning].create_user(email, name).body['key_id']
-
-      # Get user details.
-      #
-      Fog::RiakCS[:provisioning].get_user(key_id).body
-
-    end
-
-  end
-
-  tests('User listing') do
-
-    tests('sucessfully lists users').formats(user_format) do
-
-      # Create a user.
-      #
-      email, name = "user_listing_test_#{current_timestamp}@example.com", "Fog User"
-      key_id      = Fog::RiakCS[:provisioning].create_user(email, name).body['key_id']
-
-      # Ensure the list users response contains the user that we just
-      # created.
-      #
-      Fog::RiakCS[:provisioning].list_users.body.select { |x| x['email'] == email }.first
-
-    end
-
-    tests('successfully lists users containing no disabled users').returns(nil) do
-
-      # Create a user.
-      #
-      email, name = "user_listing_without_disabled_users_test_#{current_timestamp}@example.com", "Fog User"
-      key_id      = Fog::RiakCS[:provisioning].create_user(email, name).body['key_id']
-
-      # Disable that user.
-      #
-      Fog::RiakCS[:provisioning].disable_user(key_id)
-
-      # Ensure the list users response does not contain the user that we
-      # just created and disabled.
-      #
-      Fog::RiakCS[:provisioning].list_users(:status => :enabled).body.select { |x| x['Email'] == email }.first
-
-    end
-
-    tests('successfully lists users containing disabled users').formats(user_format) do
-
-      # Create a user.
-      #
-      email, name = "user_listing_with_disabled_users_test_#{current_timestamp}@example.com", "Fog User"
-      key_id      = Fog::RiakCS[:provisioning].create_user(email, name).body['key_id']
-
-      # Disable that user.
-      #
-      Fog::RiakCS[:provisioning].disable_user(key_id)
-
-      # Ensure the list users response contains the user that we just
-      # created and disabled.
-      #
-      Fog::RiakCS[:provisioning].list_users.body.select { |x| x['email'] == email }.first
-
-    end
-
-  end
-
-end

data/tests/riakcs/requests/usage/usage_tests.rb

@@ -1,29 +0,0 @@
-Shindo.tests('RiakCS::Usage | usage requests', ['riakcs']) do
-
-  @blank_usage_format = {
-    'Access' => {
-      'Nodes'   => [],
-      'Errors'  => []
-    },
-    'Storage' => {
-      'Samples' => [],
-      'Errors'  => []
-    }
-  }
-
-  tests('Statistics retrieval with no data returned') do
-
-    start_time = Time.now.utc + 86400
-    end_time   = start_time   + 86400
-
-    tests('via JSON').returns(@blank_usage_format) do
-
-      Fog::RiakCS[:usage].get_usage(Fog.credentials[:riakcs_access_key_id],
-                                    :types      => [:access, :storage],
-                                    :start_time => start_time,
-                                    :end_time   => end_time).body
-
-    end
-  end
-
-end