peakium 0.1.0 → 0.1.1

data/lib/peakium.rb

@@ -0,0 +1,265 @@
+# Peakium Ruby bindings
+# API spec at https://github.com/peakium/peakium-api
+require 'cgi'
+require 'set'
+require 'openssl'
+require 'rest_client'
+require 'json'
+
+# Version
+require 'peakium/version'
+
+# API operations
+require 'peakium/api_operations/create'
+require 'peakium/api_operations/update'
+require 'peakium/api_operations/delete'
+require 'peakium/api_operations/list'
+
+# Resources
+require 'peakium/util'
+require 'peakium/peakium_object'
+require 'peakium/api_resource'
+require 'peakium/list_object'
+
+# Resources
+require 'peakium/api_resources/customer'
+require 'peakium/api_resources/event'
+require 'peakium/api_resources/event_webhook'
+require 'peakium/api_resources/gateway'
+require 'peakium/api_resources/invoice'
+require 'peakium/api_resources/payment_session'
+require 'peakium/api_resources/subscription'
+require 'peakium/api_resources/submission_form'
+require 'peakium/api_resources/webhook'
+
+# Errors
+require 'peakium/errors/peakium_error'
+require 'peakium/errors/api_error'
+require 'peakium/errors/api_connection_error'
+require 'peakium/errors/invalid_request_error'
+require 'peakium/errors/authentication_error'
+
+module Peakium
+  @api_base = 'https://secure.peakium.com/api'
+
+  @ssl_bundle_path  = File.dirname(__FILE__) + '/data/ca-certificates.crt'
+  @verify_ssl_certs = true
+
+  class << self
+    attr_accessor :api_key, :api_base, :verify_ssl_certs, :api_version
+  end
+
+  def self.api_url(endpoint_url='')
+    @api_base + endpoint_url
+  end
+
+  def self.request(method, endpoint_url, api_key, params={}, headers={})
+    unless api_key ||= @api_key
+      raise AuthenticationError.new('No API key provided. ' +
+        'Set your API key using "Peakium.api_key = <API-KEY>". ' +
+        'You can generate API keys from the Peakium web interface. ' +
+        'Go to https://manage.peakium.com/.')
+    end
+
+    if api_key =~ /\s/
+      raise AuthenticationError.new('Your API key is invalid, as it contains ' +
+        'whitespace. (HINT: You can double-check your API key from the ' +
+        'Peakium web interface. Go to https://manage.peakium.com/.)')
+    end
+
+    request_opts = { :verify_ssl => false }
+
+    if ssl_preflight_passed?
+      request_opts.update(:verify_ssl => OpenSSL::SSL::VERIFY_PEER,
+                          :ssl_ca_file => @ssl_bundle_path)
+    end
+
+    params = Util.objects_to_ids(params)
+    url = api_url(endpoint_url)
+
+    case method.to_s.downcase.to_sym
+    when :get, :head, :delete
+      # Make params into GET parameters
+      url += "#{URI.parse(url).query ? '&' : '?'}#{uri_encode(params)}" if params && params.any?
+      payload = nil
+    else
+      if params.instance_of? String
+        payload = params
+      else
+        payload = uri_encode(params)
+      end
+    end
+
+    request_opts.update(:headers => request_headers(api_key).update(headers),
+                        :method => method, :open_timeout => 30,
+                        :payload => payload, :url => url, :timeout => 80)
+
+    begin
+      response = execute_request(request_opts)
+    rescue SocketError => e
+      handle_restclient_error(e)
+    rescue NoMethodError => e
+      # Work around RestClient bug
+      if e.message =~ /\WRequestFailed\W/
+        e = APIConnectionError.new('Unexpected HTTP response code')
+        handle_restclient_error(e)
+      else
+        raise
+      end
+    rescue RestClient::ExceptionWithResponse => e
+      if rcode = e.http_code and rbody = e.http_body
+        handle_api_error(rcode, rbody)
+      else
+        handle_restclient_error(e)
+      end
+    rescue RestClient::Exception, Errno::ECONNREFUSED => e
+      handle_restclient_error(e)
+    end
+
+    [parse(response), api_key]
+  end
+
+  private
+
+  def self.ssl_preflight_passed?
+    if !verify_ssl_certs && !@no_verify
+      $stderr.puts "WARNING: Running without SSL cert verification. " +
+        "Execute 'Peakium.verify_ssl_certs = true' to enable verification."
+
+      @no_verify = true
+
+    elsif !Util.file_readable(@ssl_bundle_path) && !@no_bundle
+      $stderr.puts "WARNING: Running without SSL cert verification " +
+        "because #{@ssl_bundle_path} isn't readable"
+
+      @no_bundle = true
+    end
+
+    !(@no_verify || @no_bundle)
+  end
+
+  def self.user_agent
+    @uname ||= get_uname
+    lang_version = "#{RUBY_VERSION} p#{RUBY_PATCHLEVEL} (#{RUBY_RELEASE_DATE})"
+
+    {
+      :bindings_version => Peakium::VERSION,
+      :lang => 'ruby',
+      :lang_version => lang_version,
+      :platform => RUBY_PLATFORM,
+      :publisher => 'peakium',
+      :uname => @uname
+    }
+
+  end
+
+  def self.get_uname
+    `uname -a 2>/dev/null`.strip if RUBY_PLATFORM =~ /linux|darwin/i
+  rescue Errno::ENOMEM => ex # couldn't create subprocess
+    "uname lookup failed"
+  end
+
+  def self.uri_encode(params)
+    Util.flatten_params(params).
+      map { |k,v| "#{k}=#{Util.url_encode(v)}" }.join('&')
+  end
+
+  def self.request_headers(api_key)
+    headers = {
+      :user_agent => "Peakium/v1 RubyBindings/#{Peakium::VERSION}",
+      :authorization => "Bearer #{api_key}",
+      :content_type => 'application/x-www-form-urlencoded'
+    }
+
+    headers[:peakium_version] = api_version if api_version
+
+    begin
+      headers.update(:x_peakium_client_user_agent => JSON.generate(user_agent))
+    rescue => e
+      headers.update(:x_peakium_client_raw_user_agent => user_agent.inspect,
+                     :error => "#{e} (#{e.class})")
+    end
+  end
+
+  def self.execute_request(opts)
+    RestClient::Request.execute(opts)
+  end
+
+  def self.parse(response)
+    begin
+      # Would use :symbolize_names => true, but apparently there is
+      # some library out there that makes symbolize_names not work.
+      response = JSON.parse(response.body)
+    rescue JSON::ParserError
+      raise general_api_error(response.code, response.body)
+    end
+
+    Util.symbolize_names(response)
+  end
+
+  def self.general_api_error(rcode, rbody)
+    APIError.new("Invalid response object from API: #{rbody.inspect} " +
+                 "(HTTP response code was #{rcode})", rcode, rbody)
+  end
+
+  def self.handle_api_error(rcode, rbody)
+    begin
+      error_obj = JSON.parse(rbody)
+      error_obj = Util.symbolize_names(error_obj)
+      error = error_obj[:error] or raise PeakiumError.new # escape from parsing
+
+    rescue JSON::ParserError, PeakiumError
+      raise general_api_error(rcode, rbody)
+    end
+
+    case rcode
+    when 400, 404
+      raise invalid_request_error error, rcode, rbody, error_obj
+    when 401
+      raise authentication_error error, rcode, rbody, error_obj
+    else
+      raise api_error error, rcode, rbody, error_obj
+    end
+
+  end
+
+  def self.invalid_request_error(error, rcode, rbody, error_obj)
+    InvalidRequestError.new(error[:message], error[:param], rcode,
+                            rbody, error_obj)
+  end
+
+  def self.authentication_error(error, rcode, rbody, error_obj)
+    AuthenticationError.new(error[:message], rcode, rbody, error_obj)
+  end
+
+  def self.api_error(error, rcode, rbody, error_obj)
+    APIError.new(error[:message], rcode, rbody, error_obj)
+  end
+
+  def self.handle_restclient_error(e)
+    case e
+    when RestClient::ServerBrokeConnection, RestClient::RequestTimeout
+      message = "Could not connect to Peakium (#{@api_base}). " +
+        "Please check your internet connection and try again. " +
+        "If this problem persists, let us know at contact@peakium.com."
+
+    when RestClient::SSLCertificateNotVerified
+      message = "Could not verify Peakium's SSL certificate. " +
+        "Please make sure that your network is not intercepting certificates. " +
+        "(Try going to https://secure.peakium.com/v1 in your browser.) " +
+        "If this problem persists, let us know at contact@peakium.com."
+
+    when SocketError
+      message = "Unexpected error communicating when trying to connect to Peakium. " +
+        "You may be seeing this message because your DNS is not working. " +
+        "To check, try running 'host secure.peakium.com' from the command line."
+
+    else
+      message = "Unexpected error communicating with Peakium. " +
+        "If this problem persists, let us know at contact@peakium.com."
+
+    end
+
+    raise APIConnectionError.new(message + "\n\n(Network error: #{e.message})")
+  end
+end

data/peakium.gemspec

@@ -0,0 +1,27 @@
+$:.unshift(File.join(File.dirname(__FILE__), 'lib'))
+
+require 'peakium/version'
+
+spec = Gem::Specification.new do |s|
+  s.name = 'peakium'
+  s.version = Peakium::VERSION
+  s.summary = 'Ruby bindings for the Peakium API'
+  s.description = 'Peakium allows global, flexible recurring payments.  See https://peakium.com for details.'
+  s.authors = ['Dan Schultzer']
+  s.email = ['dan@dreamconception.com']
+  s.homepage = 'https://github.com/peakium/peakium-api'
+  s.license = 'MIT'
+
+  s.add_dependency('rest-client', '~> 1.4')
+  s.add_dependency('json', '~> 1.8.1')
+
+  s.add_development_dependency('mocha', '~> 0.13.2')
+  s.add_development_dependency('shoulda', '~> 3.4.0')
+  s.add_development_dependency('test-unit')
+  s.add_development_dependency('rake')
+
+  s.files = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- test/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ['lib']
+end

data/test/peakium/api_resource_test.rb

@@ -0,0 +1,315 @@
+# -*- coding: utf-8 -*-
+require File.expand_path('../../test_helper', __FILE__)
+
+module Peakium
+  class ApiResourceTest < Test::Unit::TestCase
+    should "creating a new APIResource should not fetch over the network" do
+      @mock.expects(:get).never
+      g = Peakium::Gateway.new("someid")
+    end
+
+    should "creating a new APIResource from a hash should not fetch over the network" do
+      @mock.expects(:get).never
+      g = Peakium::Gateway.construct_from({
+        :id => "somegateway",
+        :object => "gateway"
+      })
+    end
+
+    should "setting an attribute should not cause a network request" do
+      @mock.expects(:get).never
+      @mock.expects(:post).never
+      g = Peakium::Gateway.new("gw_test_gateway");
+      g.name = "Gateway Test";
+    end
+
+    should "accessing id should not issue a fetch over the network" do
+      @mock.expects(:get).never
+      g = Peakium::Gateway.new("gw_test_gateway");
+      g.id
+    end
+
+    should "not specifying api credentials should raise an exception" do
+      Peakium.api_key = nil
+      assert_raises Peakium::AuthenticationError do
+        Peakium::Gateway.new("gw_test_gateway").refresh
+      end
+    end
+
+    should "specifying api credentials containing whitespace should raise an exception" do
+      Peakium.api_key = "key "
+      assert_raises Peakium::AuthenticationError do
+        Peakium::Gateway.new("gw_test_gateway").refresh
+      end
+    end
+
+    should "specifying invalid api credentials should raise an exception" do
+      Peakium.api_key = "invalid"
+      response = test_response(test_invalid_api_key_error, 401)
+      assert_raises Peakium::AuthenticationError do
+        @mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 401))
+        Peakium::Gateway.retrieve("gw_failing_gateway")
+      end
+    end
+
+    should "AuthenticationErrors should have an http status, http body, and JSON body" do
+      Peakium.api_key = "invalid"
+      response = test_response(test_invalid_api_key_error, 401)
+      begin
+        @mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 401))
+        Peakium::Gateway.retrieve("gw_failing_gateway")
+      rescue Peakium::AuthenticationError => e
+        assert_equal(401, e.http_status)
+        assert_equal(true, !!e.http_body)
+        assert_equal(true, !!e.json_body[:error][:message])
+        assert_equal(test_invalid_api_key_error['error']['message'], e.json_body[:error][:message])
+      end
+    end
+
+    context "when specifying per-object credentials" do
+      context "with no global API key set" do
+        should "use the per-object credential when creating" do
+          Peakium.expects(:execute_request).with do |opts|
+            opts[:headers][:authorization] == 'Bearer sk_test_local'
+          end.returns(test_response(test_gateway))
+
+          Peakium::Gateway.create({:name => "test", :module => "test", :settings => []},
+            'sk_test_local')
+        end
+      end
+
+      context "with a global API key set" do
+        setup do
+          Peakium.api_key = "global"
+        end
+
+        teardown do
+          Peakium.api_key = nil
+        end
+
+        should "use the per-object credential when creating" do
+          Peakium.expects(:execute_request).with do |opts|
+            opts[:headers][:authorization] == 'Bearer local'
+          end.returns(test_response(test_gateway))
+
+          Peakium::Gateway.create({:name => "test", :module => "test", :settings => []},
+            'local')
+        end
+
+        should "use the per-object credential when retrieving and making other calls" do
+          Peakium.expects(:execute_request).with do |opts|
+            opts[:url] == "#{Peakium.api_base}/v1/gateways/gw_test_gateway" &&
+              opts[:headers][:authorization] == 'Bearer local'
+          end.returns(test_response(test_gateway))
+          Peakium.expects(:execute_request).with do |opts|
+            opts[:url] == "#{Peakium.api_base}/v1/gateways/gw_test_gateway/default" &&
+              opts[:headers][:authorization] == 'Bearer local'
+          end.returns(test_response(test_gateway))
+
+          gw = Peakium::Gateway.retrieve('gw_test_gateway', 'local')
+          gw.set_default
+        end
+      end
+    end
+
+    context "with valid credentials" do
+
+      should "urlencode values in GET params" do
+        response = test_response(test_payment_session_array)
+        @mock.expects(:get).with("#{Peakium.api_base}/v1/payment_sessions?customer=test%20customer", nil, nil).returns(response)
+        payment_sessions = Peakium::PaymentSession.all(:customer => 'test customer').data
+        assert payment_sessions.kind_of? Array
+      end
+
+      should "construct URL properly with base query parameters" do
+        response = test_response(test_invoice_customer_array)
+        @mock.expects(:get).with("#{Peakium.api_base}/v1/invoices?customer=test_customer", nil, nil).returns(response)
+        invoices = Peakium::Invoice.all(:customer => 'test_customer')
+
+        @mock.expects(:get).with("#{Peakium.api_base}/v1/invoices?customer=test_customer&paid=true", nil, nil).returns(response)
+        invoices.all(:paid => true)
+      end
+
+      should "a 400 should give an InvalidRequestError with http status, body, and JSON body" do
+        response = test_response(test_missing_id_error, 400)
+        @mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 404))
+        begin
+          Peakium::Gateway.retrieve("foo")
+        rescue Peakium::InvalidRequestError => e
+          assert_equal(400, e.http_status)
+          assert_equal(true, !!e.http_body)
+          assert_equal(true, e.json_body.kind_of?(Hash))
+        end
+      end
+
+      should "a 401 should give an AuthenticationError with http status, body, and JSON body" do
+        response = test_response(test_missing_id_error, 401)
+        @mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 404))
+        begin
+          Peakium::Gateway.retrieve("foo")
+        rescue Peakium::AuthenticationError => e
+          assert_equal(401, e.http_status)
+          assert_equal(true, !!e.http_body)
+          assert_equal(true, e.json_body.kind_of?(Hash))
+        end
+      end
+
+      should "a 404 should give an InvalidRequestError with http status, body, and JSON body" do
+        response = test_response(test_missing_id_error, 404)
+        @mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 404))
+        begin
+          Peakium::Gateway.retrieve("foo")
+        rescue Peakium::InvalidRequestError => e
+          assert_equal(404, e.http_status)
+          assert_equal(true, !!e.http_body)
+          assert_equal(true, e.json_body.kind_of?(Hash))
+        end
+      end
+
+      should "setting a nil value for a param should exclude that param from the request" do
+        @mock.expects(:get).with do |url, api_key, params|
+          uri = URI(url)
+          query = CGI.parse(uri.query)
+          (url =~ %r{^#{Peakium.api_base}/v1/gateways?} &&
+           query.keys.sort == ['offset', 'sad'])
+        end.returns(test_response({ :count => 1, :data => [test_gateway] }))
+        g = Peakium::Gateway.all(:count => nil, :offset => 5, :sad => false)
+
+        @mock.expects(:post).with do |url, api_key, params|
+          url == "#{Peakium.api_base}/v1/gateways" && 
+            api_key.nil? && 
+            CGI.parse(params) == { 'name' => ['test'], 'module' => ['test'] }
+        end.returns(test_response({ :count => 1, :data => [test_gateway] }))
+        g = Peakium::Gateway.create(:name => "test", :module => "test", :settings => [])
+      end
+
+      should "requesting with a unicode ID should result in a request" do
+        response = test_response(test_missing_id_error, 404)
+        @mock.expects(:get).once.with("#{Peakium.api_base}/v1/gateways/%E2%98%83", nil, nil).raises(RestClient::ExceptionWithResponse.new(response, 404))
+        g = Peakium::Gateway.new("☃")
+        assert_raises(Peakium::InvalidRequestError) { g.refresh }
+      end
+
+      should "requesting with no ID should result in an InvalidRequestError with no request" do
+        g = Peakium::Gateway.new
+        assert_raises(Peakium::InvalidRequestError) { g.refresh }
+      end
+
+      should "making a GET request with parameters should have a query string and no body" do
+        params = { :limit => 1 }
+        @mock.expects(:get).once.with("#{Peakium.api_base}/v1/gateways?limit=1", nil, nil).returns(test_response([test_gateway]))
+        g = Peakium::Gateway.all(params)
+      end
+
+      should "making a POST request with parameters should have a body and no query string" do
+        params = { :name => 'Test gateway', :module => 'test' }
+        @mock.expects(:post).once.with do |url, get, post|
+          get.nil? && CGI.parse(post) == {'name' => ['Test gateway'], 'module' => ['test']}
+        end.returns(test_response(test_gateway))
+        g = Peakium::Gateway.create(params)
+      end
+
+      should "loading an object should issue a GET request" do
+        @mock.expects(:get).once.returns(test_response(test_gateway))
+        g = Peakium::Gateway.new("gw_test_gateway")
+        g.refresh
+      end
+
+      should "using array accessors should be the same as the method interface" do
+        @mock.expects(:get).once.returns(test_response(test_gateway))
+        g = Peakium::Gateway.new("gw_test_gateway")
+        g.refresh
+        assert_equal g.created, g[:created]
+        assert_equal g.created, g['created']
+        g['created'] = 12345
+        assert_equal g.created, 12345
+      end
+
+      should "accessing a property other than id or parent on an unfetched object should fetch it" do
+        @mock.expects(:get).once.returns(test_response(test_customer))
+        g = Peakium::Customer.new("test_cusotmer")
+        g.subscriptions
+      end
+
+      should "updating an object should issue a POST request with only the changed properties" do
+        @mock.expects(:post).with do |url, api_key, params|
+          url == "#{Peakium.api_base}/v1/gateways/gw_test_gateway" && api_key.nil? && CGI.parse(params) == {'name' => ['another name']}
+        end.once.returns(test_response(test_gateway))
+        g = Peakium::Gateway.construct_from(test_gateway)
+        g.name = "another name"
+        g.save
+      end
+
+      should "updating should merge in returned properties" do
+        @mock.expects(:post).once.returns(test_response(test_gateway))
+        g = Peakium::Gateway.new("gw_test_gateway")
+        g.name = "another name"
+        g.save
+        assert_equal false, g.livemode
+      end
+
+      should "deleting should send no props and result in an object that has no props other deleted" do
+        @mock.expects(:get).never
+        @mock.expects(:post).never
+        @mock.expects(:delete).with("#{Peakium.api_base}/v1/webhooks/#{CGI.escape("http://example.com/webhook_endpoint/")}", nil, nil).once.returns(test_response({ "url" => "http\:\/\/example.com\/webhook_endpoint\/", "deleted" => true }))
+
+        g = Peakium::Webhook.construct_from(test_webhook)
+        g.delete
+        assert_equal true, g.deleted
+
+        assert_raises NoMethodError do
+          g.livemode
+        end
+      end
+
+      should "loading an object with properties that have specific types should instantiate those classes" do
+        @mock.expects(:get).once.returns(test_response(test_gateway))
+        g = Peakium::Gateway.retrieve("gw_test_gateway")
+        assert g.module.kind_of?(Peakium::PeakiumObject) && g.module.object == 'gateway_module'
+      end
+
+      should "loading all of an APIResource should return an array of recursively instantiated objects" do
+        @mock.expects(:get).once.returns(test_response(test_gateway_array))
+        g = Peakium::Gateway.all.data
+        assert g.kind_of? Array
+        assert g[0].kind_of? Peakium::Gateway
+        assert g[0].module.kind_of?(Peakium::PeakiumObject) && g[0].module.object == 'gateway_module'
+      end
+
+      context "error checking" do
+
+        should "404s should raise an InvalidRequestError" do
+          response = test_response(test_missing_id_error, 404)
+          @mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 404))
+
+          begin
+            Peakium::Gateway.new("gw_test_gateway").refresh
+            assert false #shouldn't get here either
+          rescue Peakium::InvalidRequestError => e # we don't use assert_raises because we want to examine e
+            assert e.kind_of? Peakium::InvalidRequestError
+            assert_equal "id", e.param
+            assert_equal "Missing id", e.message
+            return
+          end
+
+          assert false #shouldn't get here
+        end
+
+        should "5XXs should raise an APIError" do
+          response = test_response(test_api_error, 500)
+          @mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 500))
+
+          begin
+            Peakium::Gateway.new("gw_test_gateway").refresh
+            assert false #shouldn't get here either
+          rescue Peakium::APIError => e # we don't use assert_raises because we want to examine e
+            assert e.kind_of? Peakium::APIError
+            return
+          end
+
+          assert false #shouldn't get here
+        end
+      end
+    end
+  end
+end

data/test/peakium/customer_test.rb

@@ -0,0 +1,21 @@
+# -*- coding: utf-8 -*-
+require File.expand_path('../../test_helper', __FILE__)
+
+module Peakium
+  class CustomerTest < Test::Unit::TestCase
+    should "customers should be listable" do
+      @mock.expects(:get).once.returns(test_response(test_customer_array))
+      c = Peakium::Customer.all.data
+      assert c.kind_of? Array
+      assert c[0].kind_of? Peakium::Customer
+    end
+
+    should "be able to cancel a customer's subscription" do
+      @mock.expects(:get).once.returns(test_response(test_customer))
+      c = Peakium::Customer.retrieve("test_customer")
+
+      @mock.expects(:delete).once.with("#{Peakium.api_base}/v1/customers/test_customer/subscriptions/test_subscription", nil, nil).returns(test_response(test_subscription()))
+      s = c.cancel_subscription('test_subscription');
+    end
+  end
+end

data/test/peakium/event_test.rb

@@ -0,0 +1,30 @@
+# -*- coding: utf-8 -*-
+require File.expand_path('../../test_helper', __FILE__)
+
+module Peakium
+  class EventTest < Test::Unit::TestCase
+    should "events should be listable" do
+      @mock.expects(:get).once.returns(test_response(test_event_array))
+      e = Peakium::Event.all.data
+      assert e.kind_of? Array
+      assert e[0].kind_of? Peakium::Event
+    end
+
+    should "be able to validate an event" do
+      @mock.expects(:get).once.returns(test_response(test_event))
+      e = Peakium::Event.retrieve("ev_test_event")
+
+      @mock.expects(:post).once.with("#{Peakium.api_base}/v1/events/ev_test_event/validate", nil, e.to_json).returns(test_response(test_event()))
+      e = e.validate(e.to_json);
+    end
+
+
+    should "be able to send/resend an event" do
+      @mock.expects(:get).once.returns(test_response(test_event))
+      e = Peakium::Event.retrieve("ev_test_event")
+
+      @mock.expects(:post).once.with("#{Peakium.api_base}/v1/events/ev_test_event/send", nil, 'force=true').returns(test_response(test_event()))
+      e = e.send({:force => true});
+    end
+  end
+end

data/test/peakium/event_webhook_test.rb

@@ -0,0 +1,13 @@
+# -*- coding: utf-8 -*-
+require File.expand_path('../../test_helper', __FILE__)
+
+module Peakium
+  class EventWebhookTest < Test::Unit::TestCase
+    should "event webhooks should be listable" do
+      @mock.expects(:get).once.returns(test_response(test_event_webhook_array))
+      ew = Peakium::EventWebhook.all.data
+      assert ew.kind_of? Array
+      assert ew[0].kind_of? Peakium::EventWebhook
+    end
+  end
+end