3scale_client 2.0.1

data/.gitignore

@@ -0,0 +1 @@
+pkg

data/3scale_client.gemspec

@@ -0,0 +1,55 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{3scale_client}
+  s.version = "2.0.1"
+
+  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.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}
+  s.extra_rdoc_files = [
+    "README.rdoc"
+  ]
+  s.files = [
+    ".gitignore",
+     "3scale_client.gemspec",
+     "LICENCE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "lib/three_scale/authorize_response.rb",
+     "lib/three_scale/client.rb",
+     "lib/three_scale/response.rb",
+     "test/client_test.rb",
+     "test/remote_test.rb"
+  ]
+  s.homepage = %q{http://www.3scale.net}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{Client for 3scale Web Service Management System API}
+  s.test_files = [
+    "test/remote_test.rb",
+     "test/client_test.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<nokogiri>, [">= 0"])
+    else
+      s.add_dependency(%q<nokogiri>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<nokogiri>, [">= 0"])
+  end
+end
+

data/LICENCE

@@ -0,0 +1,22 @@
+The MIT License
+
+Copyright (c) 2010 3scale networks S.L.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+

data/README.rdoc

@@ -0,0 +1,131 @@
+= Client for 3scale web service management system API
+
+This library provides client for the 3scale web service management API.
+
+== 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:
+
+  gem install 3scale_client
+
+Or alternatively, download the source code from github: 
+http://github.com/3scale/3scale_ws_api_for_ruby
+
+If you are using Rails, put this into your config/environment.rb
+
+  config.gem "3scale_client"
+
+Otherwise, require the gem in whatever way is natural to your framework of choice.
+
+== Usage
+
+First, create an instance of the client, giving it your provider API key:
+
+  client = ThreeScale::Client.new(:provider_key => "your provider key")
+
+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:
+
+  response = client.authorize(:user_key => "the user key")
+
+Then call the +success?+ method on the returned object to see if the authorization was
+successful.
+
+  if response.success?
+    # All fine, proceeed.
+  else
+    # Something's wrong with this user.
+  end
+
+If the authorization succeeded, the response object contains additional information about 
+the status of the user:
+
+  # Returns the name of the plan the user 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:
+
+  # The usages array contains one element per each usage limit defined on the plan.
+  usage = response.usages[0]
+
+  # The metric
+  usage.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"
+
+  # The current value the user already consumed in the period
+  usage.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]
+
+  # Error code
+  error.code    # "user.exceeded_limits"
+
+  # Human readable error message
+  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}})
+
+The :user_key and :usage parameters are required. Additionaly, you can specify a timestamp
+of transaction:
+
+  response = client.report({:user_key => "user's key", :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:
+
+  "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.
+
+Then call the +success?+ method on the returned response object to see if the report was
+successful.
+
+  if response.success?
+    # All OK.
+  else
+    # There were some errors
+  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):
+
+  error = response.errors[0]
+  error.index   # 2
+  error.code    # "user.invalid_key"
+  error.message # "User key is invalid"
+
+== Legal
+
+Copyright (c) 2010 3scale networks S.L., released under the MIT license.
+

data/Rakefile

@@ -0,0 +1,43 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Run unit tests.'
+Rake::TestTask.new(:test) do |t|
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+  t.ruby_opts << '-rubygems'
+end
+
+desc 'Generate documentation.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = '3scale API Management Client'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+begin
+  require 'jeweler'
+
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name     = '3scale_client'
+    gemspec.summary  = 'Client for 3scale Web Service Management System API'
+    gemspec.description = <<END
+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.
+END
+    gemspec.email    = 'adam@3scale.net'
+    gemspec.homepage = 'http://www.3scale.net'
+    gemspec.authors  = ['Adam Cigánek']
+
+    gemspec.add_dependency 'nokogiri'
+  end
+
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler not available. Install it with: gem install jeweler"
+end

data/VERSION

@@ -0,0 +1 @@
+2.0.1

data/lib/three_scale/authorize_response.rb

@@ -0,0 +1,39 @@
+require 'time'
+
+module ThreeScale
+  class AuthorizeResponse < Response
+    def initialize(options = {})
+      super({:success => true}.merge(options))
+      @usages = options[:usages] || []
+    end
+
+    attr_accessor :plan
+
+    class Usage
+      attr_reader :metric
+      attr_reader :period
+      attr_reader :current_value
+      attr_reader :max_value
+
+      def initialize(options = {})
+        options.each do |name, value|
+          instance_variable_set("@#{name}", value)
+        end
+      end
+
+      def period_start
+        @parsed_period_start ||= @period_start && Time.parse(@period_start)
+      end
+
+      def period_end
+        @parsed_period_end ||= @period_end && Time.parse(@period_end)
+      end
+    end      
+
+    attr_reader :usages
+
+    def add_usage(options)
+      @usages << Usage.new(options)
+    end
+  end
+end

data/lib/three_scale/client.rb

@@ -0,0 +1,213 @@
+require 'cgi'
+require 'uri'
+require 'net/http'
+require 'nokogiri'
+
+require 'three_scale/response'
+require 'three_scale/authorize_response'
+
+module ThreeScale
+  Error = Class.new(RuntimeError)
+    
+  class ServerError < Error
+    def initialize(response)
+      super('server error')
+      @response = response
+    end
+
+    attr_reader :response
+  end
+
+  # Wrapper for 3scale Web Service Management API.
+  #
+  # == Example
+  #
+  #   client = ThreeScale::Client.new(:provider_key => "your provider key")
+  #
+  #   response = client.authorize(:user_key => "yout user's key")
+  #
+  #   if response.success?
+  #     response = client.report(:user_key => "your user's key", :usage => {"hits" => 1})
+  #
+  #     if response.success?
+  #       # all fine.
+  #     else
+  #       # something's wrong.
+  #     end
+  #   end
+  #
+  class Client
+    DEFAULT_HOST = 'server.3scale.net'
+
+    def initialize(options)
+      if options[:provider_key].nil? || options[:provider_key] =~ /^\s*$/
+        raise ArgumentError, 'missing :provider_key'
+      end
+
+      @provider_key = options[:provider_key]
+      @host = options[:host] || DEFAULT_HOST
+    end
+
+    attr_reader :provider_key
+    attr_reader :host
+
+    # Report transaction(s).
+    #
+    # == Parameters
+    #
+    # 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
+    #               required.
+    #   usage::     Hash of usage values. The keys are metric names and values are
+    #               correspoding numeric values. Example: {'hits' => 1, 'transfer' => 1024}. 
+    #               This parameter is required.
+    #   timestamp:: Timestamp of the transaction. This can be either a object of the
+    #               ruby's Time class, or a string in the "YYYY-MM-DD HH:MM:SS" format
+    #               (if the time is in the UTC), or a string in 
+    #               the "YYYY-MM-DD HH:MM:SS ZZZZZ" format, where the ZZZZZ is the time offset
+    #               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.
+    #
+    # == Return
+    #
+    # A Response object with method +success?+ that returns true if the report was successful,
+    # or false if there was an error. See ThreeScale::Response class for more information.
+    #
+    # In case of unexpected internal server error, this method raises a ThreeScale::ServerError
+    # exception.
+    #
+    # == Examples
+    #
+    #   # Report two transactions of two users.
+    #   client.report({:user_key => 'foo', :usage => {'hits' => 1}},
+    #                 {:user_key => 'bar', :usage => {'hits' => 1}})
+    #
+    #   # Report one transaction with timestamp.
+    #   client.report({:user_key  => 'foo',
+    #                  :timestamp => Time.local(2010, 4, 27, 15, 14),
+    #                  :usage     => {'hits' => 1})
+    #
+    def report(*transactions)
+      raise ArgumentError, 'no transactions to report' if transactions.empty?
+
+      payload = encode_transactions(transactions)
+      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)
+      end
+    end
+
+    # Authorize a user.
+    #
+    # == Parameters
+    # 
+    # Hash with options:
+    #
+    #   user_key:: API key of the user to authorize. This is required.
+    #
+    # == 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.
+    #
+    # In case of unexpected internal server error, this method raises a ThreeScale::ServerError
+    # exception.
+    #
+    # == Examples
+    #
+    #   response = client.authorize(:user_key => 'foo')
+    #
+    #   if response.success?
+    #     # All good. Proceed...
+    #   end
+    #
+    def authorize(options)
+      path = "/transactions/authorize.xml" +
+        "?provider_key=#{CGI.escape(provider_key)}" +
+        "&user_key=#{CGI.escape(options[:user_key].to_s)}"
+
+      uri = URI.parse("http://#{host}#{path}")
+
+      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)
+      when Net::HTTPClientError
+        build_error_response(http_response.body)
+      else
+        raise ServerError.new(http_response)
+      end
+    end
+
+    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, [:timestamp], transaction[:timestamp])
+        append_encoded_value(result, index, [:client_ip], transaction[:client_ip])
+
+        transaction[:usage].each do |name, value|
+          append_encoded_value(result, index, [:usage, name], value)
+        end
+      end
+
+      result
+    end
+
+    def append_encoded_value(result, index, names, value)
+      result["transactions[#{index}][#{names.join('][')}]"] = CGI.escape(value.to_s) if value
+    end
+
+    def build_authorize_response(body)
+      response = AuthorizeResponse.new
+      doc = Nokogiri::XML(body)
+
+      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)
+      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
+
+      response
+    end
+  end
+end

data/lib/three_scale/response.rb

@@ -0,0 +1,21 @@
+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
+

data/test/client_test.rb

@@ -0,0 +1,169 @@
+require 'test/unit'
+require 'fakeweb'
+require 'mocha'
+
+require 'three_scale/client'
+
+class ThreeScale::ClientTest < Test::Unit::TestCase
+  def setup
+    FakeWeb.clean_registry
+    FakeWeb.allow_net_connect = false
+
+    @client = ThreeScale::Client.new(:provider_key => '1234abcd')
+  end
+
+  def test_raises_exception_if_provider_key_is_missing
+    assert_raise ArgumentError do
+      ThreeScale::Client.new({})
+    end
+  end
+
+  def test_default_host
+    client = ThreeScale::Client.new(:provider_key => '1234abcd')
+
+    assert_equal 'server.3scale.net', client.host
+  end
+
+  def test_successful_authorize
+    body = '<status>
+              <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>
+            </status>'
+
+    FakeWeb.register_uri(:get, 'http://server.3scale.net/transactions/authorize.xml?provider_key=1234abcd&user_key=foo', :status => ['200', 'OK'], :body => body)
+
+    response = @client.authorize(:user_key => 'foo')
+
+    assert response.success?
+    assert_equal 'Ultimate', response.plan
+    assert_equal 2, response.usages.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
+  end
+
+  def test_failed_authorize
+    error_body = '<error code="user.exceeded_limits">
+                    usage limits are exceeded
+                  </error>'
+    
+    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(:user_key => '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
+  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!')
+
+    assert_raise ThreeScale::ServerError do
+      @client.authorize(:user_key => 'foo')
+    end
+  end
+
+  def test_report_raises_an_exception_if_no_transactions_given
+    assert_raise ArgumentError do
+      @client.report
+    end
+  end
+
+  def test_successful_report
+    FakeWeb.register_uri(:post, 'http://server.3scale.net/transactions.xml',
+                         :status => ['200', 'OK'])
+
+    response = @client.report({:user_key  => 'foo',
+                               :timestamp => Time.local(2010, 4, 27, 15, 00),
+                               :usage     => {'hits' => 1}})
+
+    assert response.success?
+  end
+
+  def test_report_encodes_transactions
+    http_response = stub
+    Net::HTTPSuccess.stubs(:===).with(http_response).returns(true)
+
+    Net::HTTP.expects(:post_form).
+      with(anything,
+           'provider_key'                 => '1234abcd',
+           'transactions[0][user_key]'    => '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][usage][hits]' => '1',
+           'transactions[1][timestamp]'   => CGI.escape('2010-04-27 15:55:12 0200')).
+      returns(http_response)
+
+    @client.report({:user_key  => 'foo',
+                    :usage     => {'hits' => 1},
+                    :timestamp => '2010-04-27 15:42:17 0200'},
+
+                   {:user_key  => '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',
+                         :status => ['403', 'Forbidden'],
+                         :body   => error_body)
+   
+    response = @client.report({:user_key => 'bogus', :usage => {'hits' => 1}},
+                              {:user_key => 'bar',   :usage => {'monkeys' => 1000000000}})
+
+    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
+  end
+
+  def test_report_with_server_error
+    FakeWeb.register_uri(:post, 'http://server.3scale.net/transactions.xml',
+                         :status => ['500', 'Internal Server Error'],
+                         :body   => 'OMG! WTF!')
+
+    assert_raise ThreeScale::ServerError do
+      @client.report({:user_key => 'foo', :usage => {'hits' => 1}})
+    end
+  end
+end

data/test/remote_test.rb

@@ -0,0 +1,41 @@
+require 'test/unit'
+require 'three_scale/client'
+
+if ENV['TEST_3SCALE_PROVIDER_KEY'] && ENV['TEST_3SCALE_USER_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 }
+
+      @client = ThreeScale::Client.new(:provider_key => @provider_key)
+
+      if defined?(FakeWeb)
+        FakeWeb.clean_registry
+        FakeWeb.allow_net_connect = true
+      end
+    end
+
+    def test_successful_authorize
+      response = @client.authorize(:user_key => @user_keys[0])
+      assert response.success?
+    end
+
+    def test_failed_authorize
+      response = @client.authorize(:user_key => 'invalid-user-key')
+      assert !response.success?
+      assert_equal 'user.invalid_key', response.errors[0].code
+    end
+
+    def test_successful_report
+      transactions = @user_keys.map do |user_key|
+        {:user_key => user_key, :usage => {'hits' => 1}}
+      end
+
+      response = @client.report(*transactions)
+      assert response.success?
+    end
+  end
+
+else
+  puts "You need to set enviroment variables TEST_3SCALE_PROVIDER_KEY and TEST_3SCALE_USER_KEYS to run this remote test."
+end

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification 
+name: 3scale_client
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 2
+  - 0
+  - 1
+  version: 2.0.1
+platform: ruby
+authors: 
+- "Adam Cig\xC3\xA1nek"
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-04-28 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: nokogiri
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+description: |
+  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.
+
+email: adam@3scale.net
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- .gitignore
+- 3scale_client.gemspec
+- LICENCE
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/three_scale/authorize_response.rb
+- lib/three_scale/client.rb
+- lib/three_scale/response.rb
+- test/client_test.rb
+- test/remote_test.rb
+has_rdoc: true
+homepage: http://www.3scale.net
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Client for 3scale Web Service Management System API
+test_files: 
+- test/remote_test.rb
+- test/client_test.rb