3scale_client 2.10.0 → 2.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a0c46a8b42107a91987d9861498f796287909fb5
-  data.tar.gz: 5d43b1ee44766fe2057fec8eea21f5a30a8ac83f
+  metadata.gz: 2d32c601eff7116122dfc1e2054d2a25a7d8717d
+  data.tar.gz: b1cf03f30513e43ef8662724a7c869a50d061e68
 SHA512:
-  metadata.gz: 1c3b09b26c8ec29367f68fc231b52c3d7af036d8360179b968d50d231a2a1332ba5b0c11139539e4af6a711cb2716fe47972eaa34e66fb4ba8addc29c876e33b
-  data.tar.gz: 3d3136b451d4694fc00291d013e07dd1fd562f4c605caf1bc32a7c4f1e5ca6c6bb9808eed46f54909d7e551fea5f7260363d6ef5c75aca9ef4f00b85f9d6c717
+  metadata.gz: 032857a37711005b6790446648c4794c133fd98edd7508f53e89d0d1f95c6e9d6ffde13030567538d089004108f9a9c9ba7445e95c2bb8919e38f8474e9f83eb
+  data.tar.gz: f853e1abaceb96ee439cbafbaa1a420e004cf29888db70bcef5e1acd9f3df97f22117571bb772e86d2b928746f0e5d2dc777bac4098d65f91adfc51e3fdb5344

data/CHANGELOG.md

@@ -1,6 +1,19 @@
 # Change Log
 All notable changes to this project will be documented in this file.
 
+## [2.11.0] - 2017-01-20
+### Added
+- Added support for (Service Tokens)[https://support.3scale.net/docs/accounts/tokens]
+  Just instantiate the client with `ThreeScale::Client.new(service_tokens: true)`
+  and specify in each call the `service_token` and `service_id` parameters.
+- Deprecated usage of `provider_key` when instantiating the client.
+- Deprecated usage of the provided Rack Auth middleware. You should write your own.
+- Added optional parameter `warn_deprecated` defaulting to `true` to be able to
+  opt out of deprecation warnings. It is encouraged to not turn this off unless
+  you are sure you understand all deprecation warnings you get, and even so good
+  practice suggests you should turn it back on each time you upgrade this client
+  to check for new warnings.
+
 ## [2.10.0] - 2016-11-25
 ### Added
 - Added support for 3scale extensions (experimental or non-standard

data/README.md

@@ -6,9 +6,9 @@
 3scale is an API Infrastructure service which handles API Keys, Rate Limiting, Analytics, Billing Payments and Developer Management. Includes a configurable API dashboard and developer portal CMS. More product stuff at http://www.3scale.net/, support information at http://support.3scale.net/.
 
 ### Tutorials
-Plugin Setup: https://support.3scale.net/howtos/api-configuration/plugin-setup
-Rate Limiting: https://support.3scale.net/howtos/basics/provision-rate-limits
-Analytics Setup: https://support.3scale.net/quickstarts/3scale-api-analytics
+* Plugin Setup: https://support.3scale.net/howtos/api-configuration/plugin-setup
+* Rate Limiting: https://support.3scale.net/howtos/basics/provision-rate-limits
+* Analytics Setup: https://support.3scale.net/quickstarts/3scale-api-analytics
 
 ## Installation
 
@@ -36,28 +36,53 @@ Otherwise, require the gem in whatever way is natural to your framework of choic
 
 ## Usage
 
-First, create an instance of the client, giving it your provider API key:
+First, create an instance of the client:
 
 ```ruby
-client = ThreeScale::Client.new(:provider_key => "your provider key")
+ThreeScale::Client.new(service_tokens: true)
 ```
+
+> NOTE: unless you specify `service_tokens: true` you will be expected to specify
+a `provider_key` parameter, which is deprecated in favor of Service Tokens:
+```ruby
+client = ThreeScale::Client.new(provider_key: 'your_provider_key')
+```
+
 Because the object is stateless, you can create just one and store it globally.
 
+Then you can perform calls in the client:
+
+```ruby
+client.authorize(service_token: 'token', service_id: '123', usage: usage)
+client.report(service_token: 'token', service_id: '123', usage: usage)
+```
+
+If you had configured a (deprecated) provider key, you would instead use:
+
+```ruby
+client.authrep(service_id: '123', usage: usage)
+```
+
+> NOTE: `service_id` is mandatory since November 2016, both when using service
+tokens and when using provider keys
+
+> NOTE: You might use the option `warn_deprecated: false` to avoid deprecation
+warnings. This is enabled by default.
 
 ### SSL and Persistence
 
-Starting with version 2.4.0 you can use two more options: `:secure` and `:persistent` like:
+Starting with version 2.4.0 you can use two more options: `secure` and `persistent` like:
 
 ```ruby
-client = ThreeScale::Client.new(:provider_key => '...', :secure => true, :persistent => true)
+client = ThreeScale::Client.new(provider_key: '...', secure: true, persistent: true)
 ```
 
-#### :secure
+#### `secure`
 
 Enabling secure will force all traffic going through HTTPS.
-Because estabilishing SSL/TLS for every call is expensive, there is `:persistent`.
+Because estabilishing SSL/TLS for every call is expensive, there is `persistent`.
 
-#### :persistent
+#### `persistent`
 
 Enabling persistent will use HTTP Keep-Alive to keep open connection to our servers.
 This option requires installing gem `net-http-persistent`.
@@ -67,14 +92,13 @@ This option requires installing gem `net-http-persistent`.
 Authrep is a 'one-shot' operation to authorize an application and report the associated transaction at the same time.
 The main difference between this call and the regular authorize call is that usage will be reported if the authorization is successful. Read more about authrep at the [active docs page on the 3scale's support site](https://support.3scale.net/reference/activedocs#operation/66)
 
-You can make request to this backend operation like this:
+You can make request to this backend operation using `service_token` and `service_id`, and an authentication pattern like `user_key`, or `app_id` with an optional key, like this:
 
 ```ruby
-response = client.authrep(:app_id => "the app id", :app_key => "the app key")
+response = client.authrep(service_token: 'token', service_id: 'service_id', app_id: 'app_id', app_key: 'app_key')
 ```
 
-Then call the +success?+ method on the returned object to see if the authorization was
-successful.
+Then call the `success?` method on the returned object to see if the authorization was successful.
 
 ```ruby
 if response.success?
@@ -84,7 +108,7 @@ else
 end
 ```
 
-The example is using the app_id authentication pattern, but you can also use other patterns.
+The example is using the `app_id` authentication pattern, but you can also use other patterns such as `user_key`.
 
 #### A rails example
 
@@ -95,19 +119,25 @@ class ApplicationController < ActionController
   before_filter :authenticate
 
   # You only need to instantiate a new Client once and store it as a global variable
-  # You should store your provider key in the environment because this key is secret!
+  # If you used a provider key it is advisable to fetch it from the environment, as
+  # it is secret.
   def create_client
-    @@threescale_client ||= ThreeScale::Client.new(:provider_key => ENV['PROVIDER_KEY'])
+    @@threescale_client ||= ThreeScale::Client.new(service_tokens: true)
   end
 
   # To record usage, create a new metric in your application plan. You will use the
   # "system name" that you specifed on the metric/method to pass in as the key to the usage hash.
   # The key needs to be a symbol.
   # A way to pass the metric is to add a parameter that will pass the name of the metric/method along
+  #
+  # Note that you don't always want to retrieve the service token and service id from
+  # the parameters - this will depend on your application.
   def authenticate
-    response = create_client.authrep(:app_id => params["app_id"],
-                                     :app_key => params["app_key"],
-                                     :usage => { params[:metric].to_sym => 1 })
+    response = create_client.authrep(service_token: params['service_token']
+                                     service_id: params['service_id'],
+                                     app_id: params['app_id'],
+                                     app_key: params['app_key'],
+                                     usage: { params['metric'].to_sym => 1 })
     if response.success?
       return true
       # All fine, the usage will be reported automatically. Proceeed.
@@ -122,15 +152,13 @@ end
 
 ### Authorize
 
-To authorize an application, call the +authorize+ method passing it the application's id and
-optionally a key:
+To authorize an application, call the `authorize` method passing it the `service_token` and `service_id`, as well as a supported pattern for application authentication:
 
 ```ruby
-response = client.authorize(:app_id => "the app id", :app_key => "the app key")
+response = client.authorize(service_token: 'token', service_id: 'service_id', user_key: 'user_key')
 ```
 
-Then call the +success?+ method on the returned object to see if the authorization was
-successful.
+Then call the `success?` method on the returned object to see if the authorization was successful.
 
 ```ruby
 if response.success?
@@ -140,16 +168,14 @@ else
 end
 ```
 
-If both provider key and app id are valid, the response object contains additional
-information about the status of the application:
+If the service (provided with the token and its id, or otherwise the id if the provider key was specified at instantiation time) and the application are valid, the response object contains additional information about the application's status:
 
 ```ruby
 # Returns the name of the plan the application is signed up to.
 response.plan
 ```
 
-If the plan has defined usage limits, the response contains details about the usage broken
-down by the metrics and usage limit periods.
+If the plan has defined usage limits, the response contains details about the usage broken down by the metrics and usage limit periods.
 
 ```ruby
 # The usage_reports array contains one element per each usage limit defined on the plan.
@@ -173,8 +199,7 @@ usage_report.max_value     # 10000
 usage_report.exceeded?     # false
 ```
 
-If the authorization failed, the +error_code+ returns system error code and +error_message+
-human readable error description:
+If the authorization failed, the `error_code` returns system error code and `error_message` human readable error description:
 
 ```ruby
 response.error_code    # "usage_limits_exceeded"
@@ -183,13 +208,13 @@ response.error_message # "Usage limits are exceeded"
 
 ### OAuth Authorize
 
-To authorize an application with OAuth, call the +oauth_authorize+ method passing it the application's id.
+To authorize an application with OAuth, call the `oauth_authorize` method passing it the `service_token` with `service_id` and the `app_id`.
 
 ```ruby
-response = client.oauth_authorize(:app_id => "the app id")
+response = client.oauth_authorize(service_token: 'token', service_id: 'service_id', app_id: 'app_id')
 ```
 
-If the authorization is successful, the response will contain the +app_key+ and +redirect_url+ defined for this application:
+If the authorization is successful, the response will contain the `app_key` and `redirect_url` defined for this application:
 
 ```ruby
 response.app_key
@@ -198,45 +223,34 @@ response.redirect_url
 
 ### Report
 
-To report usage, use the +report+ method. You can report multiple transactions at the same time:
+To report usage, use the `report` method. You can report multiple transactions at the same time:
 
 ```ruby
 response = client.report(
-  :transactions => [{:app_id => "first app id",  :usage => {'hits' => 1}},
-                    {:app_id => "second app id", :usage => {'hits' => 1}}])
+  service_token: 'token',
+  service_id: 'service_id',
+  transactions: [{app_id: '1st app_id', usage: { 'hits' => 1 }},
+                 {app_id: '2nd app_id', usage: { 'hits' => 1 }}])
 ```
 
-To specify a service other than the default one:
-```ruby
-response = client.report(
-  :transactions => [{:app_id => "first app id",  :usage => {'hits' => 1}},
-                    {:app_id => "second app id", :usage => {'hits' => 1}}],
-  :service_id => 'service_123')
-```
-
-The :app_id and :usage parameters are required. Additionaly, you can specify a timestamp
-of a transaction:
+The `app_id` and `usage` parameters are required. Additionally, you can specify a timestamp of a transaction:
 
 ```ruby
 response = client.report(
-  :transactions => [{:app_id => "app id",
-                     :usage => {'hits' => 1},
-                     :timestamp => Time.local(2010, 4, 28, 12, 36)}])
+  :transactions => [{app_id: 'app_id',
+                     usage: { 'hits' => 1 },
+                     timestamp: Time.local(2010, 4, 28, 12, 36)}])
 ```
 
-The timestamp can be either a Time object (from ruby's standard library) or something that
-"quacks" like it (for example, the ActiveSupport::TimeWithZone from Rails) or a string. The
-string has to be in a format parseable by the Time.parse method. For example:
+The timestamp can be either a `Time` object (from ruby's standard library) or something that _quacks_ like it (for example, the `ActiveSupport::TimeWithZone` from Rails) or a string. Such string has to be in a format parseable by the `Time.parse` method. For example:
 
 ```ruby
 "2010-04-28 12:38:33 +0200"
 ```
 
-If the timestamp is not in UTC, you have to specify a time offset. That's the "+0200"
-(two hours ahead of the Universal Coordinate Time) in the example abowe.
+If the timestamp is not in UTC, you have to specify a time offset. That's the "+0200" (two hours ahead of the Universal Coordinate Time) in the example abowe.
 
-Then call the +success?+ method on the returned response object to see if the report was
-successful.
+Then call the `success?` method on the returned response object to see if the report was successful.
 
 ```ruby
   if response.success?
@@ -246,19 +260,20 @@ successful.
   end
 ```
 
-In case of error, the +error_code+ returns system error code and +error_message+
-human readable error description:
+In case of error, the `error_code` returns system error code and `error_message` human readable error description:
 
 ```ruby
 response.error_code    # "provider_key_invalid"
 response.error_message # "provider key \"foo\" is invalid"
 ```
 
-
 ## Rack Middleware
 
 You can use our Rack middleware to automatically authenticate your Rack applications.
 
+> NOTE: this is deprecated. Please observe that there is no support for multiple
+services nor for service tokens.
+
 ```ruby
 require '3scale/middleware'
 use ThreeScale::Middleware, provider_key, :user_key # or :app_id

data/lib/3scale/client.rb

@@ -7,7 +7,7 @@ require '3scale/client/version'
 
 require '3scale/response'
 require '3scale/authorize_response'
-require '3scale/rack_query'
+require '3scale/client/rack_query'
 
 module ThreeScale
   Error = Class.new(RuntimeError)
@@ -25,9 +25,9 @@ module ThreeScale
   #
   # == Example
   #
-  #   client = ThreeScale::Client.new(:provider_key => "your provider key")
+  #   client = ThreeScale::Client.new(service_tokens: true)
   #
-  #   response = client.authorize(:app_id => "an app id", :app_key => "a secret key")
+  #   response = client.authorize(service_token: 'token', service_id: '123', app_id: 'an app id', app_key: 'a secret key')
   #
   #   if response.success?
   #     response = client.report(:app_id => "some app id", :usage => {"hits" => 1})
@@ -39,9 +39,15 @@ module ThreeScale
   #     end
   #   end
   #
+  #   Note: Provider Keys are deprecated in favor of Service Tokens with Service IDs
+  #         The next major release of this client will default to use Service Tokens.
+  #
   class Client
     DEFAULT_HOST = 'su1.3scale.net'
 
+    DEPRECATION_MSG_PROVIDER_KEY = 'provider keys are deprecated - ' \
+      'please switch at your earliest convenience to use service tokens'.freeze
+    private_constant :DEPRECATION_MSG_PROVIDER_KEY
     DEPRECATION_MSG_OLD_REPORT = 'warning: def report(*transactions) is '\
       'deprecated. In next versions, the signature of the report method is '\
       'going to be: '\
@@ -52,24 +58,24 @@ module ThreeScale
     private_constant :EXTENSIONS_HEADER
 
     def initialize(options)
-      if options[:provider_key].nil? || options[:provider_key] =~ /^\s*$/
-        raise ArgumentError, 'missing :provider_key'
-      end
-
       @provider_key = options[:provider_key]
+      @service_tokens = options[:service_tokens]
+      @warn_deprecated = options.fetch(:warn_deprecated, true)
+
+      generate_creds_params
 
       @host = options[:host] ||= DEFAULT_HOST
 
       @http = ThreeScale::Client::HTTPClient.new(options)
     end
 
-    attr_reader :provider_key, :host, :http
+    attr_reader :provider_key, :service_tokens, :host, :http
 
     # Authorize and report an application.
     # TODO (in the mean time read authorize comments or head over to https://support.3scale.net/reference/activedocs#operation/66 for details
     #
     def authrep(options)
-      path = "/transactions/authrep.xml?provider_key=#{CGI.escape(provider_key)}"
+      path = "/transactions/authrep.xml?#{creds_params(options)}"
 
       options_usage = options.delete :usage
       options_log   = options.delete :log
@@ -108,9 +114,9 @@ module ThreeScale
     #
     # == Parameters
     #
-    # Hash with two fields:
+    # Hash with up to three fields:
     #
-    #   transactions:: It is required. It is an enumerable. Each element is a hash with the fields:
+    #   transactions::   Required. Enumerable. Each element is a hash with the fields:
     #         app_id:    ID of the application to report the transaction for. This parameter is
     #                    required.
     #         usage:     Hash of usage values. The keys are metric names and values are
@@ -123,8 +129,9 @@ module ThreeScale
     #                    from the UTC. For example, "US Pacific Time" has offset -0800, "Tokyo"
     #                    has offset +0900. This parameter is optional, and if not provided, equals
     #                    to the current time.
-    #   service_id::   ID of the service. It is optional. When not specified, the transactions
-    #                  are reported to the default service.
+    #   service_id::     ID of the service. It is optional. When not specified, the transactions
+    #                    are reported to the default service.
+    #   service_token::  Token granting access to the specified service ID.
     #
     # == Return
     #
@@ -154,7 +161,7 @@ module ThreeScale
     # The signature of this method is a bit complicated because we decided to
     # keep backwards compatibility with a previous version of the method:
     # def report(*transactions)
-    def report(*reports, transactions: [], service_id: nil, extensions: nil, **rest)
+    def report(*reports, transactions: [], service_id: nil, extensions: nil, service_token: nil, **rest)
       if (!transactions || transactions.empty?) && rest.empty?
         raise ArgumentError, 'no transactions to report'
       end
@@ -162,12 +169,17 @@ module ThreeScale
       transactions = transactions.concat(reports)
 
       unless rest.empty?
-        warn(DEPRECATION_MSG_OLD_REPORT)
+        warn DEPRECATION_MSG_OLD_REPORT if @warn_deprecated
         transactions.concat([rest])
       end
 
       payload = encode_transactions(transactions)
-      payload['provider_key'] = CGI.escape(provider_key)
+      if @service_tokens
+        raise ArgumentError, "service_token or service_id not specified" unless service_token && service_id
+        payload['service_token'] = CGI.escape(service_token)
+      else
+        payload['provider_key'] = CGI.escape(@provider_key)
+      end
       payload['service_id'] = CGI.escape(service_id.to_s) if service_id
 
       headers = extensions_to_header extensions if extensions
@@ -189,14 +201,15 @@ module ThreeScale
     #
     # Hash with options:
     #
-    #   app_id::     id of the application to authorize. This is required.
-    #   app_key::    secret key assigned to the application. Required only if application has
-    #                a key defined.
-    #   service_id:: id of the service (required if you have more than one service)
-    #   usage::      predicted usage. It is optional. It is a hash where the keys are metrics
-    #                and the values their predicted usage.
-    #                Example: {'hits' => 1, 'my_metric' => 100}
-    #   extensions:: Optional. Hash of extension keys and values.
+    #   service_token:: token granting access to the specified service_id.
+    #   app_id::        id of the application to authorize. This is required.
+    #   app_key::       secret key assigned to the application. Required only if application has
+    #                   a key defined.
+    #   service_id::    id of the service (required if you have more than one service)
+    #   usage::         predicted usage. It is optional. It is a hash where the keys are metrics
+    #                   and the values their predicted usage.
+    #                   Example: {'hits' => 1, 'my_metric' => 100}
+    #   extensions::    Optional. Hash of extension keys and values.
     #
     # == Return
     #
@@ -219,7 +232,8 @@ module ThreeScale
     #
     def authorize(options)
       extensions = options.delete :extensions
-      path = "/transactions/authorize.xml" + options_to_params(options, ALL_PARAMS)
+      creds = creds_params(options)
+      path = "/transactions/authorize.xml" + options_to_params(options, ALL_PARAMS) + '&' + creds
 
       headers = extensions_to_header extensions if extensions
       http_response = @http.get(path, headers: headers)
@@ -240,11 +254,12 @@ module ThreeScale
     #
     # Hash with options:
     #
-    #   app_id::  id of the application to authorize. This is required.
-    #   service_id:: id of the service (required if you have more than one service)
-    #   usage::      predicted usage. It is optional. It is a hash where the keys are metrics
-    #                and the values their predicted usage.
-    #                Example: {'hits' => 1, 'my_metric' => 100}
+    #   service_token:: token granting access to the specified service_id.
+    #   app_id::        id of the application to authorize. This is required.
+    #   service_id::    id of the service (required if you have more than one service)
+    #   usage::         predicted usage. It is optional. It is a hash where the keys are metrics
+    #                   and the values their predicted usage.
+    #                   Example: {'hits' => 1, 'my_metric' => 100}
     #
     # == Return
     #
@@ -270,7 +285,8 @@ module ThreeScale
     #
     def oauth_authorize(options)
       extensions = options.delete :extensions
-      path = "/transactions/oauth_authorize.xml" + options_to_params(options, OAUTH_PARAMS)
+      creds = creds_params(options)
+      path = "/transactions/oauth_authorize.xml" + options_to_params(options, OAUTH_PARAMS) + '&' + creds
 
       headers = extensions_to_header extensions if extensions
       http_response = @http.get(path, headers: headers)
@@ -292,7 +308,7 @@ module ThreeScale
     REPORT_PARAMS = [:user_key, :app_id, :service_id, :timestamp]
 
     def options_to_params(options, allowed_keys)
-      params = { :provider_key  => provider_key }
+      params = {}
 
       (allowed_keys - [:usage]).each do |key|
         params[key] = options[key] if options.has_key?(key)
@@ -397,5 +413,25 @@ module ThreeScale
     def extensions_to_header(extensions)
       { EXTENSIONS_HEADER => RackQuery.encode(extensions) }
     end
+
+    # helper to generate the creds_params method
+    def generate_creds_params
+      define_singleton_method :creds_params,
+        if @service_tokens
+          lambda do |options|
+            token = options.delete(:service_token)
+            service_id = options[:service_id]
+            raise ArgumentError, "need to specify a service_token and a service_id" unless token && service_id
+            'service_token='.freeze + CGI.escape(token)
+          end
+        elsif @provider_key
+          warn DEPRECATION_MSG_PROVIDER_KEY if @warn_deprecated
+          lambda do |_|
+            "provider_key=#{CGI.escape @provider_key}".freeze
+          end
+        else
+          raise ArgumentError, 'missing credentials - either use "service_tokens: true" or specify a provider_key value'
+        end
+    end
   end
 end

data/lib/3scale/client/rack_query.rb

@@ -0,0 +1,41 @@
+# A simple module to encode hashes of param keys and values as expected by
+# Rack in its nested queries parsing.
+#
+module ThreeScale
+  class Client
+    module RackQuery
+      class << self
+        def encode(hash)
+          hash.flat_map do |hk, hv|
+            encode_value(CGI.escape(hk.to_s), hv)
+          end.join('&'.freeze)
+        end
+
+        private
+
+        def encode_value(rack_param, val)
+          if val.is_a? Array
+            encode_array(rack_param, val)
+          elsif val.is_a? Hash
+            encode_hash(rack_param, val)
+          else
+            "#{rack_param}=#{CGI.escape(val.to_s)}"
+          end
+        end
+
+        def encode_array(rack_param, val)
+          rack_param = rack_param + '[]'
+          val.flat_map do |v|
+            encode_value(rack_param, v)
+          end
+        end
+
+        def encode_hash(rack_param, val)
+          val.flat_map do |k, v|
+            encode_value(rack_param + "[#{CGI.escape(k.to_s)}]", v)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/3scale/client/version.rb

@@ -1,5 +1,5 @@
 module ThreeScale
   class Client
-    VERSION = '2.10.0'
+    VERSION = '2.11.0'
   end
 end

data/test/benchmark.rb

@@ -2,12 +2,21 @@ require 'benchmark'
 
 require '3scale/client'
 
-provider_key = ENV['TEST_3SCALE_PROVIDER_KEY']
+provider_key = ENV['TEST_3SCALE_PROVIDER_KEY'] or raise 'No provider key set'
+warn_deprecated = ENV['WARN_DEPRECATED'] == '1'
 
-client = ThreeScale::Client.new(:provider_key => provider_key)
-persistent_client = ThreeScale::Client.new(:provider_key => provider_key, :persistent => true)
-persistent_ssl_client = ThreeScale::Client.new(:provider_key => provider_key, :secure => true, :persistent => true)
-ssl_client = ThreeScale::Client.new(:provider_key => provider_key, :secure => true)
+client = ThreeScale::Client.new(provider_key: provider_key,
+                                warn_deprecated: warn_deprecated)
+persistent_client = ThreeScale::Client.new(provider_key: provider_key,
+                                           warn_deprecated: warn_deprecated,
+                                           persistent: true)
+persistent_ssl_client = ThreeScale::Client.new(provider_key: provider_key,
+					       warn_deprecated: warn_deprecated,
+                                               secure: true,
+                                               persistent: true)
+ssl_client = ThreeScale::Client.new(provider_key: provider_key,
+                                    warn_deprecated: warn_deprecated,
+                                    secure: true)
 
 auth = { :app_id => ENV['TEST_3SCALE_APP_IDS'], :app_key => ENV['TEST_3SCALE_APP_KEYS'] }
 

data/test/client_test.rb

@@ -7,8 +7,11 @@ require '3scale/client'
 
 class ThreeScale::ClientTest < MiniTest::Test
 
+  WARN_DEPRECATED = ENV['WARN_DEPRECATED'] == '1'
+
   def client(options = {})
-    ThreeScale::Client.new({:provider_key => '1234abcd'}.merge(options))
+    ThreeScale::Client.new({ provider_key: '1234abcd',
+                             warn_deprecated: WARN_DEPRECATED }.merge(options))
   end
 
   def setup
@@ -19,36 +22,53 @@ class ThreeScale::ClientTest < MiniTest::Test
     @host   = ThreeScale::Client::DEFAULT_HOST
   end
 
-  def test_raises_exception_if_provider_key_is_missing
+  def test_raises_exception_if_no_credentials_are_specified
     assert_raises ArgumentError do
       ThreeScale::Client.new({})
     end
+    assert_raises ArgumentError do
+      ThreeScale::Client.new(service_tokens: false)
+    end
+  end
+
+  def test_does_not_raise_if_some_credentials_are_specified
+    assert ThreeScale::Client.new(provider_key: 'some_key',
+                                  warn_deprecated: WARN_DEPRECATED)
+    assert ThreeScale::Client.new(service_tokens: true)
   end
 
   def test_default_host
-    client = ThreeScale::Client.new(:provider_key => '1234abcd')
+    client = ThreeScale::Client.new(provider_key: '1234abcd',
+                                    warn_deprecated: WARN_DEPRECATED)
 
     assert_equal 'su1.3scale.net', client.host
   end
 
   def test_custom_host
-    client = ThreeScale::Client.new(:provider_key => '1234abcd', :host => "example.com")
+    client = ThreeScale::Client.new(provider_key: '1234abcd',
+                                    warn_deprecated: WARN_DEPRECATED,
+                                    host: "example.com")
 
     assert_equal 'example.com', client.host
   end
 
   def test_default_protocol
-    client = ThreeScale::Client.new(:provider_key => 'test')
+    client = ThreeScale::Client.new(provider_key: 'test',
+                                    warn_deprecated: WARN_DEPRECATED)
     assert_equal false, client.http.use_ssl?
   end
 
   def test_insecure_protocol
-    client = ThreeScale::Client.new(:provider_key => 'test', :secure => false)
+    client = ThreeScale::Client.new(provider_key: 'test',
+                                    warn_deprecated: WARN_DEPRECATED,
+                                    secure: false)
     assert_equal false, client.http.use_ssl?
   end
 
   def test_secure_protocol
-    client = ThreeScale::Client.new(:provider_key => 'test', :secure => true)
+    client = ThreeScale::Client.new(provider_key: 'test',
+                                    warn_deprecated: WARN_DEPRECATED,
+                                    secure: true)
     assert_equal true, client.http.use_ssl?
   end
 
@@ -631,7 +651,8 @@ class ThreeScale::ClientTest < MiniTest::Test
                          :status => ['403', 'Forbidden'],
                          :body   => error_body)
 
-    client   = ThreeScale::Client.new(:provider_key => 'foo')
+    client   = ThreeScale::Client.new(provider_key: 'foo',
+                                      warn_deprecated: WARN_DEPRECATED)
     transactions = [{ :app_id => 'abc', :usage => { 'hits' => 1 } }]
     response = client.report(transactions: transactions)
 
@@ -659,7 +680,8 @@ class ThreeScale::ClientTest < MiniTest::Test
                          :status => ['200', 'OK'],
                          :body   => success_body)
 
-    client = ThreeScale::Client.new(:provider_key => 'foo')
+    client = ThreeScale::Client.new(provider_key: 'foo',
+                                    warn_deprecated: WARN_DEPRECATED)
     response = client.authorize(:app_id => 'foo')
 
     assert response.success?
@@ -676,7 +698,8 @@ class ThreeScale::ClientTest < MiniTest::Test
     FakeWeb.register_uri(:post, "http://#{@host}/transactions.xml",
                          :status => ['200', 'OK'],
                          :body   => success_body)
-    client = ThreeScale::Client.new(:provider_key => 'foo')
+    client = ThreeScale::Client.new(provider_key: 'foo',
+                                    warn_deprecated: WARN_DEPRECATED)
     transactions = [{ :app_id => 'abc', :usage => { 'hits' => 1 } }]
     client.report(transactions: transactions)
 
@@ -692,7 +715,8 @@ class ThreeScale::ClientTest < MiniTest::Test
                          :status => ['200', 'OK'],
                          :body   => success_body)
 
-    client = ThreeScale::Client.new(:provider_key => 'foo')
+    client = ThreeScale::Client.new(provider_key: 'foo',
+                                    warn_deprecated: WARN_DEPRECATED)
     response = client.authrep(:app_id => 'abc')
 
     assert response.success?
@@ -761,6 +785,56 @@ class ThreeScale::ClientTest < MiniTest::Test
     assert_equal EXTENSIONS_STR, request['3scale-options']
   end
 
+  def test_client_initialized_with_sevice_tokens_uses_percall_specified_token
+    body = '<status>
+              <authorized>true</authorized>
+              <plan>Ultimate</plan>
+            </status>'
+    transactions = [{ app_id:    'foo',
+                      timestamp: Time.local(2010, 4, 27, 15, 00),
+                      usage:     {'hits' => 1 } }]
+    usage = { 'metric1' => 1, 'metric2' => 2}
+
+    FakeWeb.register_uri(:get, "http://#{@host}/transactions/authorize.xml?user_key=foo&service_id=1&service_token=newtoken", status: ['200', 'OK'], body: body)
+    FakeWeb.register_uri(:get, "http://#{@host}/transactions/authrep.xml?service_token=newtoken&user_key=foo&service_id=1&%5Busage%5D%5Bhits%5D=1", status: ['200', 'OK'], body: body)
+    FakeWeb.register_uri(:post, "http://#{@host}/transactions.xml", parameters: {service_token: 'newtoken', service_id: '1', transactions: transactions}, status: ['200', 'OK'])
+    FakeWeb.register_uri(:get, "http://#{@host}/transactions/oauth_authorize.xml?service_id=1&%5Busage%5D%5Bmetric1%5D=1&%5Busage%5D%5Bmetric2%5D=2&service_token=newtoken",
+                         status: ['200', 'OK'], body: body)
+
+    client = ThreeScale::Client.new(service_tokens: true)
+
+    response = client.authorize(user_key: 'foo', service_token: 'newtoken', service_id: 1)
+    assert response.success?
+    response = client.authrep(user_key: 'foo', service_token: 'newtoken', service_id: 1)
+    assert response.success?
+    response = client.report(transactions: transactions, service_token: 'newtoken', service_id: 1)
+    assert response.success?
+    response = client.oauth_authorize(access_token: 'oauth', usage: usage, service_token: 'newtoken', service_id: 1)
+    assert response.success?
+  end
+
+  def test_client_initialized_with_service_tokens_raises_if_unspecified_percall
+    transactions = [{ app_id:    'foo',
+                      timestamp: Time.local(2010, 4, 27, 15, 00),
+                      usage:     {'hits' => 1 } }]
+    usage = { 'metric1' => 1, 'metric2' => 2}
+
+    client = ThreeScale::Client.new(service_tokens: true)
+
+    assert_raises ArgumentError do
+      client.authorize(user_key: 'foo', service_id: 1)
+    end
+    assert_raises ArgumentError do
+      client.authrep(user_key: 'foo', service_id: 1)
+    end
+    assert_raises ArgumentError do
+      client.report(transactions: transactions, service_id: 1)
+    end
+    assert_raises ArgumentError do
+      client.oauth_authorize(user_key: 'foo', usage: usage, service_id: 1)
+    end
+  end
+
   private
 
   #OPTIMIZE this tricky test helper relies on fakeweb catching the urls requested by the client
@@ -789,7 +863,10 @@ end
 class ThreeScale::NetHttpPersistentClientTest < ThreeScale::ClientTest
   def client(options = {})
     ThreeScale::Client::HTTPClient.persistent_backend = ThreeScale::Client::HTTPClient::NetHttpPersistent
-    ThreeScale::Client.new({:provider_key => '1234abcd', :persistent => true}.merge(options))
+    ThreeScale::Client.new({ provider_key: '1234abcd',
+                             warn_deprecated: WARN_DEPRECATED,
+                             persistent: true,
+                           }.merge(options))
   end
 end
 

data/test/middleware_test.rb

@@ -39,7 +39,7 @@ class ThreeScale::MiddlewareTest < MiniTest::Test
   def test_nil_authenticator
     authenticator = ThreeScale::Middleware::NilAuthenticator.new(mock)
     assert authenticator.provided?
-    assert_equal(nil, authenticator.credentials)
+    assert_nil authenticator.credentials
     assert authenticator.to_proc.call(nil, nil)
   end
 end

data/test/persistence_test.rb

@@ -5,6 +5,8 @@ require 'mocha/setup'
 
 if ENV['TEST_3SCALE_PROVIDER_KEY'] && ENV['TEST_3SCALE_APP_IDS'] && ENV['TEST_3SCALE_APP_KEYS']
   class ThreeScale::NetHttpPersistenceTest < MiniTest::Test
+    WARN_DEPRECATED = ENV['WARN_DEPRECATED'] == '1'
+
     def setup
       ThreeScale::Client::HTTPClient.persistent_backend = ThreeScale::Client::HTTPClient::NetHttpPersistent
 
@@ -13,7 +15,9 @@ if ENV['TEST_3SCALE_PROVIDER_KEY'] && ENV['TEST_3SCALE_APP_IDS'] && ENV['TEST_3S
       @app_id = ENV['TEST_3SCALE_APP_IDS']
       @app_key = ENV['TEST_3SCALE_APP_KEYS']
 
-      @client = ThreeScale::Client.new(provider_key: provider_key, persistence: true)
+      @client = ThreeScale::Client.new(provider_key: provider_key,
+				       warn_deprecated: WARN_DEPRECATED,
+                                       persistence: true)
 
       if defined?(FakeWeb)
         FakeWeb.allow_net_connect = true

data/test/remote_test.rb

@@ -5,6 +5,8 @@ if ENV['TEST_3SCALE_PROVIDER_KEY'] &&
    ENV['TEST_3SCALE_APP_IDS']      &&
    ENV['TEST_3SCALE_APP_KEYS']
   class ThreeScale::RemoteTest < MiniTest::Test
+    WARN_DEPRECATED = ENV['WARN_DEPRECATED'] == '1'
+
     def setup
       @provider_key = ENV['TEST_3SCALE_PROVIDER_KEY']
 
@@ -13,7 +15,8 @@ if ENV['TEST_3SCALE_PROVIDER_KEY'] &&
       @app_ids  = ENV['TEST_3SCALE_APP_IDS'].split(',').map(&stripper)
       @app_keys = ENV['TEST_3SCALE_APP_KEYS'].split(',').map(&stripper)
 
-      @client = ThreeScale::Client.new(:provider_key => @provider_key)
+      @client = ThreeScale::Client.new(provider_key: @provider_key,
+                                       warn_deprecated: WARN_DEPRECATED)
 
       if defined?(FakeWeb)
         FakeWeb.clean_registry
@@ -39,7 +42,9 @@ if ENV['TEST_3SCALE_PROVIDER_KEY'] &&
     end
 
     def test_successful_secure_authrep
-      @client = ThreeScale::Client.new(:provider_key => @provider_key, :secure => true)
+      @client = ThreeScale::Client.new(provider_key: @provider_key,
+                                       warn_deprecated: WARN_DEPRECATED,
+                                       secure: true)
       test_successful_authrep
     end
 
@@ -96,7 +101,8 @@ if ENV['TEST_3SCALE_PROVIDER_KEY'] &&
         {:app_id => app_id, :usage => {'hits' => 1}}
       end
 
-      client   = ThreeScale::Client.new(:provider_key => 'invalid-key')
+      client   = ThreeScale::Client.new(provider_key: 'invalid-key',
+                                        warn_deprecated: WARN_DEPRECATED)
       response = client.report(transactions: transactions)
       assert !response.success?
       assert_equal 'provider_key_invalid',                  response.error_code

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: 3scale_client
 version: !ruby/object:Gem::Version
-  version: 2.10.0
+  version: 2.11.0
 platform: ruby
 authors:
 - Michal Cichra
@@ -12,7 +12,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-11-25 00:00:00.000000000 Z
+date: 2017-01-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -176,9 +176,9 @@ files:
 - lib/3scale/authorize_response.rb
 - lib/3scale/client.rb
 - lib/3scale/client/http_client.rb
+- lib/3scale/client/rack_query.rb
 - lib/3scale/client/version.rb
 - lib/3scale/middleware.rb
-- lib/3scale/rack_query.rb
 - lib/3scale/response.rb
 - lib/3scale_client.rb
 - test/benchmark.rb
@@ -206,7 +206,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.4
+rubygems_version: 2.6.8
 signing_key: 
 specification_version: 4
 summary: Client for 3scale Web Service Management System API

data/lib/3scale/rack_query.rb

@@ -1,37 +0,0 @@
-# A simple module to encode hashes of param keys and values as expected by
-# Rack in its nested queries parsing.
-#
-module RackQuery
-  class << self
-    def encode(hash)
-      hash.flat_map do |hk, hv|
-        encode_value(CGI.escape(hk.to_s), hv)
-      end.join('&'.freeze)
-    end
-
-    private
-
-    def encode_value(rack_param, val)
-      if val.is_a? Array
-        encode_array(rack_param, val)
-      elsif val.is_a? Hash
-        encode_hash(rack_param, val)
-      else
-        "#{rack_param}=#{CGI.escape(val.to_s)}"
-      end
-    end
-
-    def encode_array(rack_param, val)
-      rack_param = rack_param + '[]'
-      val.flat_map do |v|
-        encode_value(rack_param, v)
-      end
-    end
-
-    def encode_hash(rack_param, val)
-      val.flat_map do |k, v|
-        encode_value(rack_param + "[#{CGI.escape(k.to_s)}]", v)
-      end
-    end
-  end
-end