3scale_client 2.0.1 → 2.2.4

data/3scale_client.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{3scale_client}
-  s.version = "2.0.1"
+  s.version = "2.2.4"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Adam Cig\303\241nek"]
-  s.date = %q{2010-04-28}
+  s.authors = ["Adam Cigánek"]
+  s.date = %q{2010-09-15}
   s.description = %q{This gem allows to easily connect an application that provides a Web Service with the 3scale API Management System to authorize it's users and report the usage.
 }
   s.email = %q{adam@3scale.net}
@@ -23,9 +23,9 @@ Gem::Specification.new do |s|
      "README.rdoc",
      "Rakefile",
      "VERSION",
-     "lib/three_scale/authorize_response.rb",
-     "lib/three_scale/client.rb",
-     "lib/three_scale/response.rb",
+     "lib/3scale/authorize_response.rb",
+     "lib/3scale/client.rb",
+     "lib/3scale/response.rb",
      "test/client_test.rb",
      "test/remote_test.rb"
   ]

data/README.rdoc

@@ -1,15 +1,10 @@
 = Client for 3scale web service management system API
 
-This library provides client for the 3scale web service management API.
-
+Please note: This version of the library targets the new API, which is currently in beta phase. Please contact 3scale support as support@3scale.net before you use it. You can also use older version (2.0.1) targeting the old API: http://github.com/3scale/3scale_ws_api_for_ruby/tree/v2.0.1.
+ 
 == Installation
 
-This library is distributed as a gem. First, add gemcutter to your gem source list,
-unless it's already there:
-
-  gem source --add http://gemcutter.org
-
-Then install the gem:
+This library is distributed as a gem:
 
   gem install 3scale_client
 
@@ -32,10 +27,10 @@ Because the object is stateless, you can create just one and store it globally.
 
 === Authorize
 
-To authorize a particular user, call the +authorize+ method passing it the user key
-identifiing the user:
+To authorize an application, call the +authorize+ method passing it the application's id and
+optionally a key:
 
-  response = client.authorize(:user_key => "the user key")
+  response = client.authorize(:app_id => "the app id", :app_id => "the app key")
 
 Then call the +success?+ method on the returned object to see if the authorization was
 successful.
@@ -43,57 +38,55 @@ successful.
   if response.success?
     # All fine, proceeed.
   else
-    # Something's wrong with this user.
+    # Something's wrong with this application.
   end
 
-If the authorization succeeded, the response object contains additional information about 
-the status of the user:
+If both provider key and app id are valid, the response object contains additional
+information about the status of the application:
 
-  # Returns the name of the plan the user is signed up to.
+  # 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 how close the user
-is to meet these limits:
+If the plan has defined usage limits, the response contains details about the usage broken
+down by the metrics and usage limit periods.
 
-  # The usages array contains one element per each usage limit defined on the plan.
-  usage = response.usages[0]
+  # The usage_reports array contains one element per each usage limit defined on the plan.
+  usage_report = response.usage_reports[0]
 
   # The metric
-  usage.metric # "hits"
+  usage_report.metric # "hits"
 
   # The period the limit applies to
-  usage.period       # :day
-  usage.period_start # "Wed Apr 28 00:00:00 +0200 2010"
-  usage.period_end   # "Wed Apr 28 23:59:59 +0200 2010"
+  usage_report.period        # :day
+  usage_report.period_start  # "Wed Apr 28 00:00:00 +0200 2010"
+  usage_report.period_end    # "Wed Apr 28 23:59:59 +0200 2010"
 
-  # The current value the user already consumed in the period
-  usage.current_value # 8032
+  # The current value the application already consumed in the period
+  usage_report.current_value # 8032
 
   # The maximal value allowed by the limit in the period
-  usage.max_value     # 10000
-
-If the authorization failed, the +errors+ method contains one or more errors with more
-detailed information:
-
-  error = response.errors[0]
+  usage_report.max_value     # 10000
 
-  # Error code
-  error.code    # "user.exceeded_limits"
+  # If the limit is exceeded, this will be true, otherwise false:
+  usage_report.exceeded?     # false
 
-  # Human readable error message
-  error.message # "Usage limits are exceeded"
+If the authorization failed, the +error_code+ returns system error code and +error_message+ 
+human readable error description:
+ 
+  response.error_code    # "usage_limits_exceeded"
+  response.error_message # "Usage limits are exceeded"
 
 === Report
 
 To report usage, use the +report+ method. You can report multiple transaction at the same time:
 
-  response = client.report({:user_key => "first user's key",  :usage => {'hits' => 1}},
-                           {:user_key => "second user's key", :usage => {'hits' => 1}})
+  response = client.report({:app_id => "first app id",  :usage => {'hits' => 1}},
+                           {:app_id => "second app id", :usage => {'hits' => 1}})
 
-The :user_key and :usage parameters are required. Additionaly, you can specify a timestamp
+The :app_id and :usage parameters are required. Additionaly, you can specify a timestamp
 of transaction:
 
-  response = client.report({:user_key => "user's key", :usage => {'hits' => 1},
+  response = client.report({: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
@@ -111,19 +104,14 @@ successful.
   if response.success?
     # All OK.
   else
-    # There were some errors
+    # There was an error.
   end
 
-If the report was successful, you are done. Otherwise, the +errors+ method will return array
-of errors with more detailed information. Each of these errors has the +index+ attribute that
-returns numeric index of the transaction this error corresponds to. For example, if you report
-three transactions, first two are ok and the last one has invalid user key, there will be
-an error in the +errors+ array with the +index+ equal to 2 (the indices start at 0):
+In case of error, the +error_code+ returns system error code and +error_message+
+human readable error description:
 
-  error = response.errors[0]
-  error.index   # 2
-  error.code    # "user.invalid_key"
-  error.message # "User key is invalid"
+  response.error_code    # "provider_key_invalid"
+  response.error_message # "provider key \"foo\" is invalid"
 
 == Legal
 

data/Rakefile

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require 'rake'
 require 'rake/testtask'
 require 'rake/rdoctask'

data/VERSION

@@ -1 +1 @@
-2.0.1
+2.2.4

data/lib/{three_scale → 3scale}/authorize_response.rb

@@ -2,14 +2,14 @@ require 'time'
 
 module ThreeScale
   class AuthorizeResponse < Response
-    def initialize(options = {})
-      super({:success => true}.merge(options))
-      @usages = options[:usages] || []
+    def initialize
+      super
+      @usage_reports = []
     end
 
     attr_accessor :plan
 
-    class Usage
+    class UsageReport
       attr_reader :metric
       attr_reader :period
       attr_reader :current_value
@@ -28,12 +28,16 @@ module ThreeScale
       def period_end
         @parsed_period_end ||= @period_end && Time.parse(@period_end)
       end
+
+      def exceeded?
+        current_value > max_value
+      end
     end      
 
-    attr_reader :usages
+    attr_reader :usage_reports
 
-    def add_usage(options)
-      @usages << Usage.new(options)
+    def add_usage_report(options)
+      @usage_reports << UsageReport.new(options)
     end
   end
 end

data/lib/{three_scale → 3scale}/client.rb

@@ -3,8 +3,8 @@ require 'uri'
 require 'net/http'
 require 'nokogiri'
 
-require 'three_scale/response'
-require 'three_scale/authorize_response'
+require '3scale/response'
+require '3scale/authorize_response'
 
 module ThreeScale
   Error = Class.new(RuntimeError)
@@ -24,10 +24,10 @@ module ThreeScale
   #
   #   client = ThreeScale::Client.new(:provider_key => "your provider key")
   #
-  #   response = client.authorize(:user_key => "yout user's key")
+  #   response = client.authorize(:app_id => "an app id", :app_key => "a secret key")
   #
   #   if response.success?
-  #     response = client.report(:user_key => "your user's key", :usage => {"hits" => 1})
+  #     response = client.report(:app_id => "some app id", :usage => {"hits" => 1})
   #
   #     if response.success?
   #       # all fine.
@@ -37,7 +37,7 @@ module ThreeScale
   #   end
   #
   class Client
-    DEFAULT_HOST = 'server.3scale.net'
+    DEFAULT_HOST = 'su1.3scale.net'
 
     def initialize(options)
       if options[:provider_key].nil? || options[:provider_key] =~ /^\s*$/
@@ -58,7 +58,7 @@ module ThreeScale
     # The parameters the transactions to report. Each transaction is a hash with
     # these elements:
     #
-    #   user_key::  API key of the user to report the transaction for. This parameter is
+    #   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
     #               correspoding numeric values. Example: {'hits' => 1, 'transfer' => 1024}. 
@@ -81,12 +81,12 @@ module ThreeScale
     #
     # == Examples
     #
-    #   # Report two transactions of two users.
-    #   client.report({:user_key => 'foo', :usage => {'hits' => 1}},
-    #                 {:user_key => 'bar', :usage => {'hits' => 1}})
+    #   # Report two transactions of two applications.
+    #   client.report({:app_id => 'foo', :usage => {'hits' => 1}},
+    #                 {:app_id => 'bar', :usage => {'hits' => 1}})
     #
     #   # Report one transaction with timestamp.
-    #   client.report({:user_key  => 'foo',
+    #   client.report({:app_id    => 'foo',
     #                  :timestamp => Time.local(2010, 4, 27, 15, 14),
     #                  :usage     => {'hits' => 1})
     #
@@ -97,34 +97,42 @@ module ThreeScale
       payload['provider_key'] = CGI.escape(provider_key)
 
       uri = URI.parse("http://#{host}/transactions.xml")
-
-      process_response(Net::HTTP.post_form(uri, payload)) do |http_response|
-        Response.new(:success => true)
+      http_response = Net::HTTP.post_form(uri, payload)
+      
+      case http_response
+      when Net::HTTPSuccess
+        build_report_response
+      when Net::HTTPClientError
+        build_error_response(http_response.body)
+      else
+        raise ServerError.new(http_response)
       end
     end
 
-    # Authorize a user.
+    # Authorize an application.
     #
     # == Parameters
     # 
     # Hash with options:
     #
-    #   user_key:: API key of the user to authorize. This is required.
+    #   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.
     #
     # == Return
     #
     # An ThreeScale::AuthorizeResponse object. It's +success?+ method returns true if
-    # the authorization is successful. In that case, it contains additional information
-    # about the status of the use. See the ThreeScale::AuthorizeResponse for more information.
-    # In case of error, the +success?+ method returns false and the +errors+ contains list
-    # of errors with more details.
+    # the authorization is successful, false otherwise. It contains additional information
+    # about the status of the usage. See the ThreeScale::AuthorizeResponse for more information.
+    # In case of error, the +error_code+ returns code of the error and +error_message+
+    # human readable error description.
     #
     # In case of unexpected internal server error, this method raises a ThreeScale::ServerError
     # exception.
     #
     # == Examples
     #
-    #   response = client.authorize(:user_key => 'foo')
+    #   response = client.authorize(:app_id => '1234')
     #
     #   if response.success?
     #     # All good. Proceed...
@@ -133,21 +141,15 @@ module ThreeScale
     def authorize(options)
       path = "/transactions/authorize.xml" +
         "?provider_key=#{CGI.escape(provider_key)}" +
-        "&user_key=#{CGI.escape(options[:user_key].to_s)}"
+        "&app_id=#{CGI.escape(options[:app_id].to_s)}"
+      path += "&app_key=#{CGI.escape(options[:app_key])}" if options[:app_key]
 
       uri = URI.parse("http://#{host}#{path}")
+      http_response = Net::HTTP.get_response(uri)
 
-      process_response(Net::HTTP.get_response(uri)) do |http_response|
-        build_authorize_response(http_response.body)
-      end
-    end
-
-    private
-
-    def process_response(http_response)
       case http_response
       when Net::HTTPSuccess
-        yield(http_response)
+        build_authorize_response(http_response.body)
       when Net::HTTPClientError
         build_error_response(http_response.body)
       else
@@ -155,11 +157,13 @@ module ThreeScale
       end
     end
 
+    private
+
     def encode_transactions(transactions)
       result = {}
       
       transactions.each_with_index do |transaction, index|
-        append_encoded_value(result, index, [:user_key],  transaction[:user_key])
+        append_encoded_value(result, index, [:app_id],    transaction[:app_id])
         append_encoded_value(result, index, [:timestamp], transaction[:timestamp])
         append_encoded_value(result, index, [:client_ip], transaction[:client_ip])
 
@@ -175,38 +179,42 @@ module ThreeScale
       result["transactions[#{index}][#{names.join('][')}]"] = CGI.escape(value.to_s) if value
     end
 
+    def build_report_response
+      response = Response.new
+      response.success!
+      response
+    end
+
     def build_authorize_response(body)
       response = AuthorizeResponse.new
       doc = Nokogiri::XML(body)
 
+      if doc.at_css('authorized').content == 'true'
+        response.success!
+      else
+        response.error!(doc.at_css('reason').content)
+      end
+
       response.plan = doc.at_css('plan').content.to_s.strip
 
-      doc.css('usage').each do |node|
-        response.add_usage(:metric        => node['metric'].to_s.strip,
-                           :period        => node['period'].to_s.strip.to_sym,
-                           :period_start  => node.at('period_start').content,
-                           :period_end    => node.at('period_end').content,
-                           :current_value => node.at('current_value').content.to_i,
-                           :max_value     => node.at('max_value').content.to_i)
+      doc.css('usage_reports usage_report').each do |node|
+        response.add_usage_report(:metric        => node['metric'].to_s.strip,
+                                  :period        => node['period'].to_s.strip.to_sym,
+                                  :period_start  => node.at('period_start').content,
+                                  :period_end    => node.at('period_end').content,
+                                  :current_value => node.at('current_value').content.to_i,
+                                  :max_value     => node.at('max_value').content.to_i)
       end
 
       response
     end
 
     def build_error_response(body)
-      response = Response.new(:success => false)
       doc = Nokogiri::XML(body)
-
-      doc.css('error').each do |node|
-        response.add_error(node['index'].to_i, 
-                           
-                           # Backwards compatibility: error code is sometimes in
-                           # the "id" attribute.
-                           node['code'] || node['id'],
-
-                           node.content.to_s.strip)
-      end
-
+      node = doc.at_css('error')
+      
+      response = Response.new
+      response.error!(node.content.to_s.strip, node['code'].to_s.strip)
       response
     end
   end

data/lib/3scale/response.rb

@@ -0,0 +1,24 @@
+module ThreeScale
+  class Response
+    def success!
+      @error_code = nil
+      @error_message = nil
+    end
+
+    def error!(message, code = nil)
+      @error_code = code
+      @error_message = message
+    end
+
+    def success?
+      @error_code.nil? && @error_message.nil?
+    end
+ 
+    # System error code.
+    attr_reader :error_code
+
+    # Human readable error message.
+    attr_reader :error_message  
+  end
+end
+

data/test/client_test.rb

@@ -2,7 +2,7 @@ require 'test/unit'
 require 'fakeweb'
 require 'mocha'
 
-require 'three_scale/client'
+require '3scale/client'
 
 class ThreeScale::ClientTest < Test::Unit::TestCase
   def setup
@@ -10,6 +10,7 @@ class ThreeScale::ClientTest < Test::Unit::TestCase
     FakeWeb.allow_net_connect = false
 
     @client = ThreeScale::Client.new(:provider_key => '1234abcd')
+    @host   = ThreeScale::Client::DEFAULT_HOST
   end
 
   def test_raises_exception_if_provider_key_is_missing
@@ -21,69 +22,114 @@ class ThreeScale::ClientTest < Test::Unit::TestCase
   def test_default_host
     client = ThreeScale::Client.new(:provider_key => '1234abcd')
 
-    assert_equal 'server.3scale.net', client.host
+    assert_equal 'su1.3scale.net', client.host
   end
 
   def test_successful_authorize
     body = '<status>
+              <authorized>true</authorized>
               <plan>Ultimate</plan>
-              
-              <usage metric="hits" period="day">
-                <period_start>2010-04-26 00:00:00</period_start>
-                <period_end>2010-04-26 23:59:59</period_end>
-                <current_value>10023</current_value>
-                <max_value>50000</max_value>
-              </usage>
-
-              <usage metric="hits" period="month">
-                <period_start>2010-04-01 00:00:00</period_start>
-                <period_end>2010-04-30 23:59:59</period_end>
-                <current_value>999872</current_value>
-                <max_value>150000</max_value>
-              </usage>
+             
+              <usage_reports>
+                <usage_report metric="hits" period="day">
+                  <period_start>2010-04-26 00:00:00 +0000</period_start>
+                  <period_end>2010-04-27 00:00:00 +0000</period_end>
+                  <current_value>10023</current_value>
+                  <max_value>50000</max_value>
+                </usage_report>
+
+                <usage_report metric="hits" period="month">
+                  <period_start>2010-04-01 00:00:00 +0000</period_start>
+                  <period_end>2010-05-01 00:00:00 +0000</period_end>
+                  <current_value>999872</current_value>
+                  <max_value>150000</max_value>
+                </usage_report>
+              </usage_reports>
             </status>'
 
-    FakeWeb.register_uri(:get, 'http://server.3scale.net/transactions/authorize.xml?provider_key=1234abcd&user_key=foo', :status => ['200', 'OK'], :body => body)
+    FakeWeb.register_uri(:get, "http://#{@host}/transactions/authorize.xml?provider_key=1234abcd&app_id=foo", :status => ['200', 'OK'], :body => body)
 
-    response = @client.authorize(:user_key => 'foo')
+    response = @client.authorize(:app_id => 'foo')
 
     assert response.success?
     assert_equal 'Ultimate', response.plan
-    assert_equal 2, response.usages.size
+    assert_equal 2, response.usage_reports.size
     
-    assert_equal :day, response.usages[0].period
-    assert_equal Time.local(2010, 4, 26), response.usages[0].period_start
-    assert_equal Time.local(2010, 4, 26, 23, 59, 59), response.usages[0].period_end
-    assert_equal 10023, response.usages[0].current_value
-    assert_equal 50000, response.usages[0].max_value
-
-    assert_equal :month, response.usages[1].period
-    assert_equal Time.local(2010, 4, 1), response.usages[1].period_start
-    assert_equal Time.local(2010, 4, 30, 23, 59, 59), response.usages[1].period_end
-    assert_equal 999872, response.usages[1].current_value
-    assert_equal 150000, response.usages[1].max_value
+    assert_equal :day, response.usage_reports[0].period
+    assert_equal Time.utc(2010, 4, 26), response.usage_reports[0].period_start
+    assert_equal Time.utc(2010, 4, 27), response.usage_reports[0].period_end
+    assert_equal 10023, response.usage_reports[0].current_value
+    assert_equal 50000, response.usage_reports[0].max_value
+
+    assert_equal :month, response.usage_reports[1].period
+    assert_equal Time.utc(2010, 4, 1), response.usage_reports[1].period_start
+    assert_equal Time.utc(2010, 5, 1), response.usage_reports[1].period_end
+    assert_equal 999872, response.usage_reports[1].current_value
+    assert_equal 150000, response.usage_reports[1].max_value
   end
+  
+  def test_successful_authorize_with_app_keys
+    body = '<status>
+              <authorized>true</authorized>
+              <plan>Ultimate</plan>
+            </status>'
+
+    FakeWeb.register_uri(:get, "http://#{@host}/transactions/authorize.xml?provider_key=1234abcd&app_id=foo&app_key=toosecret", :status => ['200', 'OK'], :body => body)
 
-  def test_failed_authorize
-    error_body = '<error code="user.exceeded_limits">
-                    usage limits are exceeded
-                  </error>'
+    response = @client.authorize(:app_id => 'foo', :app_key => 'toosecret')
+    assert response.success?
+  end
+
+  def test_authorize_with_exceeded_usage_limits
+    body = '<status>
+              <authorized>false</authorized>
+              <reason>usage limits are exceeded</reason>
+
+              <plan>Ultimate</plan>
+             
+              <usage_reports>
+                <usage_report metric="hits" period="day" exceeded="true">
+                  <period_start>2010-04-26 00:00:00 +0000</period_start>
+                  <period_end>2010-04-27 00:00:00 +0000</period_end>
+                  <current_value>50002</current_value>
+                  <max_value>50000</max_value>
+                </usage_report>
+
+                <usage_report metric="hits" period="month">
+                  <period_start>2010-04-01 00:00:00 +0000</period_start>
+                  <period_end>2010-05-01 00:00:00 +0000</period_end>
+                  <current_value>999872</current_value>
+                  <max_value>150000</max_value>
+                </usage_report>
+              </usage_reports>
+            </status>'
+    
+    FakeWeb.register_uri(:get, "http://#{@host}/transactions/authorize.xml?provider_key=1234abcd&app_id=foo", :status => ['200', 'OK'], :body => body)
     
-    FakeWeb.register_uri(:get, 'http://server.3scale.net/transactions/authorize.xml?provider_key=1234abcd&user_key=foo', :status => ['403', 'Forbidden'], :body => error_body)
+    response = @client.authorize(:app_id => 'foo')
+
+    assert !response.success?
+    assert_equal 'usage limits are exceeded', response.error_message
+    assert response.usage_reports[0].exceeded?
+  end
+
+  def test_authorize_with_invalid_app_id
+    body = '<error code="application_not_found">application with id="foo" was not found</error>'
     
-    response = @client.authorize(:user_key => 'foo')
+    FakeWeb.register_uri(:get, "http://#{@host}/transactions/authorize.xml?provider_key=1234abcd&app_id=foo", :status => ['403', 'Forbidden'], :body => body)
+
+    response = @client.authorize(:app_id => 'foo')
 
     assert !response.success?
-    assert_equal 1, response.errors.size
-    assert_equal 'user.exceeded_limits',      response.errors[0].code
-    assert_equal 'usage limits are exceeded', response.errors[0].message
+    assert_equal 'application_not_found',                   response.error_code
+    assert_equal 'application with id="foo" was not found', response.error_message
   end
   
   def test_authorize_with_server_error
-    FakeWeb.register_uri(:get, 'http://server.3scale.net/transactions/authorize.xml?provider_key=1234abcd&user_key=foo', :status => ['500', 'Internal Server Error'], :body => 'OMG! WTF!')
+    FakeWeb.register_uri(:get, "http://#{@host}/transactions/authorize.xml?provider_key=1234abcd&app_id=foo", :status => ['500', 'Internal Server Error'], :body => 'OMG! WTF!')
 
     assert_raise ThreeScale::ServerError do
-      @client.authorize(:user_key => 'foo')
+      @client.authorize(:app_id => 'foo')
     end
   end
 
@@ -94,10 +140,10 @@ class ThreeScale::ClientTest < Test::Unit::TestCase
   end
 
   def test_successful_report
-    FakeWeb.register_uri(:post, 'http://server.3scale.net/transactions.xml',
+    FakeWeb.register_uri(:post, "http://#{@host}/transactions.xml",
                          :status => ['200', 'OK'])
 
-    response = @client.report({:user_key  => 'foo',
+    response = @client.report({:app_id    => 'foo',
                                :timestamp => Time.local(2010, 4, 27, 15, 00),
                                :usage     => {'hits' => 1}})
 
@@ -111,59 +157,45 @@ class ThreeScale::ClientTest < Test::Unit::TestCase
     Net::HTTP.expects(:post_form).
       with(anything,
            'provider_key'                 => '1234abcd',
-           'transactions[0][user_key]'    => 'foo',
+           'transactions[0][app_id]'      => 'foo',
            'transactions[0][usage][hits]' => '1',
            'transactions[0][timestamp]'   => CGI.escape('2010-04-27 15:42:17 0200'),
-           'transactions[1][user_key]'    => 'bar',
+           'transactions[1][app_id]'      => 'bar',
            'transactions[1][usage][hits]' => '1',
            'transactions[1][timestamp]'   => CGI.escape('2010-04-27 15:55:12 0200')).
       returns(http_response)
 
-    @client.report({:user_key  => 'foo',
+    @client.report({:app_id    => 'foo',
                     :usage     => {'hits' => 1},
                     :timestamp => '2010-04-27 15:42:17 0200'},
 
-                   {:user_key  => 'bar',
+                   {:app_id    => 'bar',
                     :usage     => {'hits' => 1},
                     :timestamp => '2010-04-27 15:55:12 0200'})
   end
 
   def test_failed_report
-    error_body = '<errors>
-                    <error code="user.invalid_key" index="0">
-                      user key is invalid
-                    </error>
-                    <error code="provider.invalid_metric" index="1">
-                      metric does not exist
-                    </error>
-                  </errors>'
-
-    FakeWeb.register_uri(:post, 'http://server.3scale.net/transactions.xml',
+    error_body = '<error code="provider_key_invalid">provider key "foo" is invalid</error>'
+
+    FakeWeb.register_uri(:post, "http://#{@host}/transactions.xml",
                          :status => ['403', 'Forbidden'],
                          :body   => error_body)
    
-    response = @client.report({:user_key => 'bogus', :usage => {'hits' => 1}},
-                              {:user_key => 'bar',   :usage => {'monkeys' => 1000000000}})
+    client   = ThreeScale::Client.new(:provider_key => 'foo')                         
+    response = client.report({:app_id => 'abc', :usage => {'hits' => 1}})
 
     assert !response.success?
-    assert_equal 2, response.errors.size
-
-    assert_equal 0,                         response.errors[0].index
-    assert_equal 'user.invalid_key',        response.errors[0].code
-    assert_equal 'user key is invalid',     response.errors[0].message
-    
-    assert_equal 1,                         response.errors[1].index
-    assert_equal 'provider.invalid_metric', response.errors[1].code
-    assert_equal 'metric does not exist',   response.errors[1].message
+    assert_equal 'provider_key_invalid',          response.error_code
+    assert_equal 'provider key "foo" is invalid', response.error_message
   end
 
   def test_report_with_server_error
-    FakeWeb.register_uri(:post, 'http://server.3scale.net/transactions.xml',
+    FakeWeb.register_uri(:post, "http://#{@host}/transactions.xml",
                          :status => ['500', 'Internal Server Error'],
                          :body   => 'OMG! WTF!')
 
     assert_raise ThreeScale::ServerError do
-      @client.report({:user_key => 'foo', :usage => {'hits' => 1}})
+      @client.report({:app_id => 'foo', :usage => {'hits' => 1}})
     end
   end
 end

data/test/remote_test.rb

@@ -1,11 +1,17 @@
 require 'test/unit'
-require 'three_scale/client'
+require '3scale/client'
 
-if ENV['TEST_3SCALE_PROVIDER_KEY'] && ENV['TEST_3SCALE_USER_KEYS']
+if ENV['TEST_3SCALE_PROVIDER_KEY'] && 
+   ENV['TEST_3SCALE_APP_IDS']      &&
+   ENV['TEST_3SCALE_APP_KEYS']
   class ThreeScale::RemoteTest < Test::Unit::TestCase
     def setup
       @provider_key = ENV['TEST_3SCALE_PROVIDER_KEY']
-      @user_keys    = ENV['TEST_3SCALE_USER_KEYS'].split(',').map { |key| key.strip }
+
+      stripper = lambda { |string| string.strip }
+
+      @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)
 
@@ -16,26 +22,44 @@ if ENV['TEST_3SCALE_PROVIDER_KEY'] && ENV['TEST_3SCALE_USER_KEYS']
     end
 
     def test_successful_authorize
-      response = @client.authorize(:user_key => @user_keys[0])
-      assert response.success?
+      @app_keys.each do |app_key|
+        response = @client.authorize(:app_id => @app_ids[0], :app_key => app_key)
+        assert response.success?, "Authorize should succeed for app_id=#{@app_ids[0]} and app_key=#{app_key}, but it didn't"
+      end
     end
 
     def test_failed_authorize
-      response = @client.authorize(:user_key => 'invalid-user-key')
+      response = @client.authorize(:app_id => 'invalid-id')
       assert !response.success?
-      assert_equal 'user.invalid_key', response.errors[0].code
+      assert_equal 'application_not_found',                          response.error_code
+      assert_equal 'application with id="invalid-id" was not found', response.error_message
     end
 
     def test_successful_report
-      transactions = @user_keys.map do |user_key|
-        {:user_key => user_key, :usage => {'hits' => 1}}
+      transactions = @app_ids.map do |app_id|
+        {:app_id => app_id, :usage => {'hits' => 1}}
       end
 
       response = @client.report(*transactions)
       assert response.success?
     end
+
+    def test_failed_report
+      transactions = @app_ids.map do |app_id|
+        {:app_id => app_id, :usage => {'hits' => 1}}
+      end
+
+      client   = ThreeScale::Client.new(:provider_key => 'invalid-key')
+      response = client.report(*transactions)
+      assert !response.success?
+      assert_equal 'provider_key_invalid',                  response.error_code
+      assert_equal 'provider key "invalid-key" is invalid', response.error_message
+    end
   end
 
 else
-  puts "You need to set enviroment variables TEST_3SCALE_PROVIDER_KEY and TEST_3SCALE_USER_KEYS to run this remote test."
+  puts "This test executes real requests against 3scale backend server. It needs to know provider key, application ids and application keys to use in the requests. You have to set these environment variables:"
+  puts " * TEST_3SCALE_PROVIDER_KEY - a provider key."
+  puts " * TEST_3SCALE_APP_IDS      - list of application ids, separated by commas."
+  puts " * TEST_3SCALE_APP_KEYS     - list of application keys corresponding to the FIRST id in the TEST_3SCALE_APP_IDS list. Also separated by commas."
 end

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 2
-  - 0
-  - 1
-  version: 2.0.1
+  - 2
+  - 4
+  version: 2.2.4
 platform: ruby
 authors: 
 - "Adam Cig\xC3\xA1nek"
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-04-28 00:00:00 +02:00
+date: 2010-09-15 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -46,9 +46,9 @@ files:
 - README.rdoc
 - Rakefile
 - VERSION
-- lib/three_scale/authorize_response.rb
-- lib/three_scale/client.rb
-- lib/three_scale/response.rb
+- lib/3scale/authorize_response.rb
+- lib/3scale/client.rb
+- lib/3scale/response.rb
 - test/client_test.rb
 - test/remote_test.rb
 has_rdoc: true

data/lib/three_scale/response.rb

@@ -1,21 +0,0 @@
-module ThreeScale
-  class Response
-    def initialize(options)
-      @success = options[:success]
-      @errors  = options[:errors] || []
-    end
-
-    def success?
-      @success
-    end
-  
-    Error = Struct.new(:index, :code, :message)
-    
-    attr_reader :errors
-
-    def add_error(*args)
-      @errors << Error.new(*args)
-    end
-  end
-end
-