nurego 1.0.1

data/lib/nurego/nurego_object.rb

@@ -0,0 +1,167 @@
+module Nurego
+  class NuregoObject
+    include Enumerable
+
+    attr_accessor :api_key
+    @@permanent_attributes = Set.new([:api_key, :id])
+
+    # The default :id method is deprecated and isn't useful to us
+    if method_defined?(:id)
+      undef :id
+    end
+
+    def initialize(id=nil, api_key=nil)
+      # parameter overloading!
+      if id.kind_of?(Hash)
+        @retrieve_options = id.dup
+        @retrieve_options.delete(:id)
+        id = id[:id]
+      else
+        @retrieve_options = {}
+      end
+
+      @api_key = api_key
+      @values = {}
+      # This really belongs in APIResource, but not putting it there allows us
+      # to have a unified inspect method
+      @unsaved_values = Set.new
+      @transient_values = Set.new
+      @values[:id] = id if id
+    end
+
+    def self.construct_from(values, api_key=nil)
+      obj = self.new(values[:id], api_key)
+      obj.refresh_from(values, api_key)
+      obj
+    end
+
+    def to_s(*args)
+      Nurego::JSON.dump(@values, :pretty => true)
+    end
+
+    def inspect
+      id_string = (self.respond_to?(:id) && !self.id.nil?) ? " id=#{self.id}" : ""
+      "#<#{self.class}:0x#{self.object_id.to_s(16)}#{id_string}> JSON: " + Nurego::JSON.dump(@values, :pretty => true)
+    end
+
+    def refresh_from(values, api_key, partial=false)
+      @api_key = api_key
+
+      removed = partial ? Set.new : Set.new(@values.keys - values.keys)
+      added = Set.new(values.keys - @values.keys)
+      # Wipe old state before setting new.  This is useful for e.g. updating a
+      # customer, where there is no persistent card parameter.  Mark those values
+      # which don't persist as transient
+
+      instance_eval do
+        remove_accessors(removed)
+        add_accessors(added)
+      end
+      removed.each do |k|
+        @values.delete(k)
+        @transient_values.add(k)
+        @unsaved_values.delete(k)
+      end
+      values.each do |k, v|
+        @values[k] = Util.convert_to_nurego_object(v, api_key)
+        @transient_values.delete(k)
+        @unsaved_values.delete(k)
+      end
+    end
+
+    def [](k)
+      @values[k.to_sym]
+    end
+
+    def []=(k, v)
+      send(:"#{k}=", v)
+    end
+
+    def keys
+      @values.keys
+    end
+
+    def values
+      @values.values
+    end
+
+    def to_json(*a)
+      Nurego::JSON.dump(@values)
+    end
+
+    def as_json(*a)
+      @values.as_json(*a)
+    end
+
+    def to_hash
+      @values
+    end
+
+    def each(&blk)
+      @values.each(&blk)
+    end
+
+    protected
+
+    def metaclass
+      class << self; self; end
+    end
+
+    def remove_accessors(keys)
+      metaclass.instance_eval do
+        keys.each do |k|
+          next if @@permanent_attributes.include?(k)
+          k_eq = :"#{k}="
+          remove_method(k) if method_defined?(k)
+          remove_method(k_eq) if method_defined?(k_eq)
+        end
+      end
+    end
+
+    def add_accessors(keys)
+      metaclass.instance_eval do
+        keys.each do |k|
+          next if @@permanent_attributes.include?(k)
+          k_eq = :"#{k}="
+          define_method(k) { @values[k] }
+          define_method(k_eq) do |v|
+            if v == ""
+              raise ArgumentError.new(
+                "You cannot set #{k} to an empty string." +
+                "We interpret empty strings as nil in requests." +
+                "You may set #{self}.#{k} = nil to delete the property.")
+            end
+            @values[k] = v
+            @unsaved_values.add(k)
+          end
+        end
+      end
+    end
+
+    def method_missing(name, *args)
+      # TODO: only allow setting in updateable classes.
+      if name.to_s.end_with?('=')
+        attr = name.to_s[0...-1].to_sym
+        add_accessors([attr])
+        begin
+          mth = method(name)
+        rescue NameError
+          raise NoMethodError.new("Cannot set #{attr} on this object. HINT: you can't set: #{@@permanent_attributes.to_a.join(', ')}")
+        end
+        return mth.call(args[0])
+      else
+        return @values[name] if @values.has_key?(name)
+      end
+
+      begin
+        super
+      rescue NoMethodError => e
+        if @transient_values.include?(name)
+          raise NoMethodError.new(e.message + ".  HINT: The '#{name}' attribute was set in the past, however.  It was then wiped when refreshing the object with the result returned by Nurego's API, probably as a result of a save().  The attributes currently available on this object are: #{@values.keys.join(', ')}")
+        else
+          raise
+        end
+      end
+    end
+  end
+end

data/lib/nurego/offering.rb

@@ -0,0 +1,17 @@
+module Nurego
+  class Offering < APIResource
+
+    def self.retrieve(id, api_key=nil)
+      raise NotImplementedError.new("Offering cannot be retrieved with ID. Retrieve an offering using Offering.current")
+    end
+
+    def self.current(params = {}, api_key = nil)
+      response, api_key = Nurego.request(:get, self.url, api_key, params)
+      Util.convert_to_nurego_object(response, api_key)
+    end
+
+    def plans
+      Plan.all({:offering => id }, @api_key)
+    end
+  end
+end

data/lib/nurego/organization.rb

@@ -0,0 +1,23 @@
+module Nurego
+  class Organization < APIResource
+    include Nurego::APIOperations::List
+    include Nurego::APIOperations::Update
+
+    def instances
+      Instance.all({:organization => id }, @api_key)
+    end
+
+    def paymentmethod
+      PaymentMethod.all({:organization => id}, @api_key)
+    end
+
+    def bills
+      Bill.all({ :organization => id }, @api_key)[:bills]
+    end
+
+    def entitlements(feature_id = nil)
+      Entitlement.all({:organization => id, :feature_id => feature_id}, @api_key)
+    end
+
+  end
+end

data/lib/nurego/password_reset.rb

@@ -0,0 +1,14 @@
+module Nurego
+  class PasswordReset < APIResource
+    include Nurego::APIOperations::Create
+    include Nurego::APIOperations::Delete
+    include Nurego::APIOperations::List
+
+    include Nurego::Auth
+
+    def complete(params)
+      Nurego::Auth.change_password(self.customer_id, params[:password], params[:current_password])
+      self
+    end
+  end
+end

data/lib/nurego/payment_method.rb

@@ -0,0 +1,16 @@
+module Nurego
+  class PaymentMethod < APIResource
+    include Nurego::APIOperations::Create
+    include Nurego::APIOperations::Update
+    include Nurego::APIOperations::List
+
+    def url
+      PaymentMethod.url
+    end
+
+    def self.retrieve(id, api_key = nil)
+      raise NotImplementedError.new("Payment Method cannot be retrieved without a organization ID. Retrieve a paymentmethod using organization.paymentmethod")
+    end
+
+  end
+end

data/lib/nurego/plan.rb

@@ -0,0 +1,9 @@
+module Nurego
+  class Plan < APIResource
+    include Nurego::APIOperations::List
+
+    def features
+      Features.all({:plan => id }, @api_key)
+    end
+  end
+end

data/lib/nurego/registration.rb

@@ -0,0 +1,18 @@
+module Nurego
+  class Registration < APIResource
+    include Nurego::APIOperations::Create
+    include Nurego::APIOperations::List
+
+    def complete(params)
+      response, api_key = Nurego.request(:post, complete_url, @api_key, params)
+      refresh_from({customer: response}, api_key, true)
+      customer
+    end
+
+    private
+
+    def complete_url
+      url + '/complete'
+    end
+  end
+end

data/lib/nurego/util.rb

@@ -0,0 +1,109 @@
+module Nurego
+  module Util
+    def self.objects_to_ids(h)
+      case h
+      when APIResource
+        h.id
+      when Hash
+        res = {}
+        h.each { |k, v| res[k] = objects_to_ids(v) unless v.nil? }
+        res
+      when Array
+        h.map { |v| objects_to_ids(v) }
+      else
+        h
+      end
+    end
+
+    def self.object_classes
+      @object_classes ||= {
+        'customer' => Customer,
+        'registration' => Registration,
+        'organization' => Organization,
+        'instance' => Instance,
+        'connector' => Connector,
+        'passwordreset' => PasswordReset,
+        'offering' => Offering,
+        'plan' => Plan,
+        'feature' => Feature,
+        'paymentmethod' => PaymentMethod,
+        'bill' => Bill,
+        'list' => ListObject
+      }
+    end
+
+    def self.convert_to_nurego_object(resp, api_key)
+      case resp
+      when Array
+        resp.map { |i| convert_to_nurego_object(i, api_key) }
+      when Hash
+        # Try converting to a known object class.  If none available, fall back to generic NuregoObject
+        object_classes.fetch(resp[:object], NuregoObject).construct_from(resp, api_key)
+      else
+        resp
+      end
+    end
+
+    def self.file_readable(file)
+      # This is nominally equivalent to File.readable?, but that can
+      # report incorrect results on some more oddball filesystems
+      # (such as AFS)
+      begin
+        File.open(file) { |f| }
+      rescue
+        false
+      else
+        true
+      end
+    end
+
+    def self.symbolize_names(object)
+      case object
+      when Hash
+        new = {}
+        object.each do |key, value|
+          key = (key.to_sym rescue key) || key
+          new[key] = symbolize_names(value)
+        end
+        new
+      when Array
+        object.map { |value| symbolize_names(value) }
+      else
+        object
+      end
+    end
+
+    def self.url_encode(key)
+      URI.escape(key.to_s, Regexp.new("[^#{URI::PATTERN::UNRESERVED}]"))
+    end
+
+    def self.flatten_params(params, parent_key=nil)
+      result = []
+      params.each do |key, value|
+        calculated_key = parent_key ? "#{parent_key}[#{url_encode(key)}]" : url_encode(key)
+        if value.is_a?(Hash)
+          result += flatten_params(value, calculated_key)
+        elsif value.is_a?(Array)
+          result += flatten_params_array(value, calculated_key)
+        else
+          result << [calculated_key, value]
+        end
+      end
+      result
+    end
+
+    def self.flatten_params_array(value, calculated_key)
+      result = []
+      value.each do |elem|
+        if elem.is_a?(Hash)
+          result += flatten_params(elem, calculated_key)
+        elsif elem.is_a?(Array)
+          result += flatten_params_array(elem, calculated_key)
+        else
+          result << ["#{calculated_key}[]", elem]
+        end
+      end
+      result
+    end
+  end
+end

data/lib/nurego/version.rb

@@ -0,0 +1,3 @@
+module Nurego
+  VERSION = '1.0.1'
+end

data/nurego.gemspec

@@ -0,0 +1,31 @@
+$:.unshift(File.join(File.dirname(__FILE__), 'lib'))
+
+require 'nurego/version'
+
+spec = Gem::Specification.new do |s|
+  s.name = 'nurego'
+  s.version = Nurego::VERSION
+  s.summary = 'Ruby bindings for the Nurego API'
+  s.description = 'Business Operations for Subscription Services.  See http://www.nurego.com for details.'
+  s.authors = ['Ilia Gilderman']
+  s.email = ['ilia@nurego.com']
+  s.homepage = 'http://www.nurego.com/api'
+  s.license = 'MIT'
+
+  s.add_dependency('rest-client', '~> 1.4')
+  s.add_dependency('mime-types', '~> 1.25')
+  s.add_dependency('multi_json', '>= 1.0.4', '< 2')
+  s.add_dependency('cf-uaa-lib', '= 1.3.10')
+
+  s.add_development_dependency('rake')
+  s.add_development_dependency('uuidtools')
+  s.add_development_dependency('rspec')
+  s.add_development_dependency('simplecov')
+  s.add_development_dependency('simplecov-rcov')
+  s.add_development_dependency('rack-test')
+  s.add_development_dependency('ci_reporter')
+
+  s.files = Dir.glob("{lib,examples}/**/*") + %w(Gemfile Gemfile.lock nurego.gemspec Rakefile VERSION LICENSE README.md)
+  s.test_files    = `git ls-files -- spec/unit*`.split("\n")
+  s.require_paths = ['lib']
+end

data/spec/unit/nurego/api_resource_spec.rb

@@ -0,0 +1,326 @@
+# -*- coding: utf-8 -*-
+require File.expand_path('../../test_helper', __FILE__)
+
+describe "Nurego::ApiResource" do
+  before(:each) do
+    @mock = double
+    Nurego.mock_rest_client = @mock
+    Nurego.api_key="foo"
+  end
+
+  it "creating a new APIResource should not fetch over the network" do
+    @mock.should_not_receive(:get)
+    Nurego::Customer.new("someid")
+  end
+
+  it "creating a new APIResource from a hash should not fetch over the network" do
+    @mock.should_not_receive(:get)
+    Nurego::Customer.construct_from({
+                                        :id => "somecustomer",
+                                        :card => {:id => "somecard", :object => "card"},
+                                        :object => "customer"
+                                    })
+  end
+
+  it "setting an attribute should not cause a network request" do
+    @mock.should_not_receive(:get)
+    @mock.should_not_receive(:post)
+    c = Nurego::Customer.new("test_customer");
+    c.card = {:id => "somecard", :object => "card"}
+  end
+
+  it "accessing id should not issue a fetch" do
+    @mock.should_not_receive(:get)
+    c = Nurego::Customer.new("test_customer");
+    c.id
+  end
+
+  it "not specifying api credentials should raise an exception" do
+    Nurego.api_key = nil
+    expect { Nurego::Customer.new("test_customer").refresh }.to raise_error(Nurego::AuthenticationError)
+  end
+
+  it "specifying api credentials containing whitespace should raise an exception" do
+    Nurego.api_key = "key "
+    expect { Nurego::Customer.new("test_customer").refresh }.to raise_error(Nurego::AuthenticationError)
+  end
+
+  it "specifying invalid api credentials should raise an exception" do
+    Nurego.api_key = "invalid"
+    response = test_response(test_invalid_api_key_error, 401)
+    expect do
+      @mock.should_receive(:get).and_raise(RestClient::ExceptionWithResponse.new(response, 401))
+      Nurego::Customer.retrieve("failing_customer")
+    end.to raise_error(Nurego::AuthenticationError)
+  end
+
+  it "AuthenticationErrors should have an http status, http body, and JSON body" do
+    Nurego.api_key = "invalid"
+    response = test_response(test_invalid_api_key_error, 401)
+    begin
+      @mock.should_receive(:get).and_raise(RestClient::ExceptionWithResponse.new(response, 401))
+      Nurego::Customer.retrieve("failing_customer")
+    rescue Nurego::AuthenticationError => e
+      e.http_status.should eq(401)
+      !!e.http_body.should(be_true)
+      !!e.json_body[:error][:message].should(be_true)
+      test_invalid_api_key_error['error']['message'].should eq(e.json_body[:error][:message])
+    end
+  end
+
+  context "when specifying per-object credentials" do
+    context "with no global API key set" do
+      xit "use the per-object credential when creating" do
+        Nurego.should_receive(:execute_request).with do |opts|
+          opts[:headers][:authorization] == 'Bearer sk_test_local'
+        end.and_return(test_response(test_charge))
+
+        Nurego::Charge.create({:card => {:number => '4242424242424242'}},
+                              'sk_test_local')
+      end
+    end
+
+    context "with a global API key set" do
+      before(:each) do
+        Nurego.api_key = "global"
+      end
+
+      xit "use the per-object credential when creating" do
+        Nurego.should_receive(:execute_request).with do |opts|
+          opts[:headers][:authorization] == 'Bearer local'
+        end.and_return(test_response(test_charge))
+
+        Nurego::Charge.create({:card => {:number => '4242424242424242'}},
+                              'local')
+      end
+
+      xit "use the per-object credential when retrieving and making other calls" do
+        Nurego.should_receive(:execute_request).with do |opts|
+          opts[:url] == "#{Nurego.api_base}/v1/charges/ch_test_charge" &&
+              opts[:headers][:authorization] == 'Bearer local'
+        end.and_return(test_response(test_charge))
+        Nurego.should_receive(:execute_request).with do |opts|
+          opts[:url] == "#{Nurego.api_base}/v1/charges/ch_test_charge/refund" &&
+              opts[:headers][:authorization] == 'Bearer local'
+        end.and_return(test_response(test_charge))
+
+        ch = Nurego::Charge.retrieve('ch_test_charge', 'local')
+        ch.refund
+      end
+    end
+  end
+
+  context "with valid credentials" do
+    xit "urlencode values in GET params" do
+      response = test_response(test_charge_array)
+      @mock.should_receive(:get).with("#{Nurego.api_base}/v1/charges?customer=test%20customer", nil, nil).and_return(response)
+      charges = Nurego::Charge.all(:customer => 'test customer').data
+      assert charges.kind_of? Array
+    end
+
+    xit "construct URL properly with base query parameters" do
+      response = test_response(test_invoice_customer_array)
+      @mock.should_receive(:get).with("#{Nurego.api_base}/v1/invoices?customer=test_customer", nil, nil).and_return(response)
+      invoices = Nurego::Invoice.all(:customer => 'test_customer')
+
+      @mock.should_receive(:get).with("#{Nurego.api_base}/v1/invoices?customer=test_customer&paid=true", nil, nil).and_return(response)
+      invoices.all(:paid => true)
+    end
+
+    it "a 400 should give an InvalidRequestError with http status, body, and JSON body" do
+      response = test_response(test_missing_id_error, 400)
+      @mock.should_receive(:get).and_raise(RestClient::ExceptionWithResponse.new(response, 404))
+      begin
+        Nurego::Customer.retrieve("foo")
+      rescue Nurego::InvalidRequestError => e
+        e.http_status.should eq(400)
+        !!e.http_body.should(be_true)
+        e.json_body.kind_of?(Hash).should be_true
+      end
+    end
+
+    it "a 401 should give an AuthenticationError with http status, body, and JSON body" do
+      response = test_response(test_missing_id_error, 401)
+      @mock.should_receive(:get).and_raise(RestClient::ExceptionWithResponse.new(response, 404))
+      begin
+        Nurego::Customer.retrieve("foo")
+      rescue Nurego::AuthenticationError => e
+        e.http_status.should eq(401)
+        !!e.http_body.should(be_true)
+        e.json_body.kind_of?(Hash).should be_true
+      end
+    end
+
+    it "a 402 should give a CardError with http status, body, and JSON body" do
+      response = test_response(test_missing_id_error, 402)
+      @mock.should_receive(:get).and_raise(RestClient::ExceptionWithResponse.new(response, 404))
+      begin
+        Nurego::Customer.retrieve("foo")
+      rescue Nurego::CardError => e
+        e.http_status.should eq(402)
+        !!e.http_body.should(be_true)
+        e.json_body.kind_of?(Hash).should be_true
+      end
+    end
+
+    it "a 404 should give an InvalidRequestError with http status, body, and JSON body" do
+      response = test_response(test_missing_id_error, 404)
+      @mock.should_receive(:get).and_raise(RestClient::ExceptionWithResponse.new(response, 404))
+      begin
+        Nurego::Customer.retrieve("foo")
+      rescue Nurego::InvalidRequestError => e
+        e.http_status.should eq(404)
+        !!e.http_body.should(be_true)
+        e.json_body.kind_of?(Hash).should be_true
+      end
+    end
+
+    xit "setting a nil value for a param should exclude that param from the request" do
+      @mock.should_receive(:get).with do |url, api_key, params|
+        uri = URI(url)
+        query = CGI.parse(uri.query)
+        (url =~ %r{^#{Nurego.api_base}/v1/charges?} &&
+            query.keys.sort == ['offset', 'sad'])
+      end.and_return(test_response({ :count => 1, :data => [test_charge] }))
+      Nurego::Charge.all(:count => nil, :offset => 5, :sad => false)
+
+      @mock.should_receive(:post).with do |url, api_key, params|
+        url == "#{Nurego.api_base}/v1/charges" &&
+            api_key.nil? &&
+            CGI.parse(params) == { 'amount' => ['50'], 'currency' => ['usd'] }
+      end.and_return(test_response({ :count => 1, :data => [test_charge] }))
+      Nurego::Charge.create(:amount => 50, :currency => 'usd', :card => { :number => nil })
+    end
+
+    it "requesting with a unicode ID should result in a request" do
+      response = test_response(test_missing_id_error, 404)
+      @mock.should_receive(:get).with("#{Nurego.api_base}/v1/customers/%E2%98%83", nil, nil).and_raise(RestClient::ExceptionWithResponse.new(response, 404))
+      c = Nurego::Customer.new("☃")
+      expect { c.refresh }.to raise_error(Nurego::InvalidRequestError)
+    end
+
+    it "requesting with no ID should result in an InvalidRequestError with no request" do
+      c = Nurego::Customer.new
+      expect { c.refresh }.to raise_error(Nurego::InvalidRequestError)
+    end
+
+    xit "making a GET request with parameters should have a query string and no body" do
+      params = { :limit => 1 }
+      @mock.should_receive(:get).with("#{Nurego.api_base}/v1/charges?limit=1", nil, nil).and_return(test_response([test_charge]))
+      Nurego::Charge.all(params)
+    end
+
+    xit "making a POST request with parameters should have a body and no query string" do
+      params = { :amount => 100, :currency => 'usd', :card => 'sc_token' }
+      @mock.should_receive(:post).once.with do |url, get, post|
+        get.nil? && CGI.parse(post) == {'amount' => ['100'], 'currency' => ['usd'], 'card' => ['sc_token']}
+      end.and_return(test_response(test_charge))
+      Nurego::Charge.create(params)
+    end
+
+    it "loading an object should issue a GET request" do
+      @mock.should_receive(:get).once.and_return(test_response(test_customer))
+      c = Nurego::Customer.new("test_customer")
+      c.refresh
+    end
+
+    xit "using array accessors should be the same as the method interface" do
+      @mock.should_receive(:get).once.and_return(test_response(test_customer))
+      c = Nurego::Customer.new("test_customer")
+      c.refresh
+      c.created.should eq(c[:created])
+      c.created.should eq(c['created'])
+      c['created'] = 12345
+      c.created.should eq(12345)
+    end
+
+    xit "accessing a property other than id or parent on an unfetched object should fetch it" do
+      @mock.should_receive(:get).once.and_return(test_response(test_customer))
+      c = Nurego::Customer.new("test_customer")
+      c.charges
+    end
+
+    xit "updating an object should issue a POST request with only the changed properties" do
+      @mock.should_receive(:post).with do |url, api_key, params|
+        url == "#{Nurego.api_base}/v1/customers/c_test_customer" && api_key.nil? && CGI.parse(params) == {'description' => ['another_mn']}
+      end.once.returns(test_response(test_customer))
+      c = Nurego::Customer.construct_from(test_customer)
+      c.description = "another_mn"
+      c.save
+    end
+
+    xit "updating should merge in returned properties" do
+      @mock.should_receive(:post).once.and_return(test_response(test_customer))
+      c = Nurego::Customer.new("c_test_customer")
+      c.description = "another_mn"
+      c.save
+      assert_equal false, c.livemode
+    end
+
+    xit "deleting should send no props and result in an object that has no props other deleted" do
+      @mock.should_not_receive(:get)
+      @mock.should_not_receive(:post)
+      @mock.should_receive(:delete).with("#{Nurego.api_base}/v1/customers/c_test_customer", nil, nil).once.and_return(test_response({ "id" => "test_customer", "deleted" => true }))
+
+      c = Nurego::Customer.construct_from(test_customer)
+      c.delete
+      c.deleted.should be_true
+
+      assert_raises NoMethodError do
+        c.livemode
+      end
+    end
+
+    xit "loading an object with properties that have specific types should instantiate those classes" do
+      @mock.should_receive(:get).once.and_return(test_response(test_charge))
+      c = Nurego::Charge.retrieve("test_charge")
+      (c.card.kind_of?(Nurego::NuregoObject) && c.card.object == 'card').should be_true
+    end
+
+    xit "loading all of an APIResource should return an array of recursively instantiated objects" do
+      @mock.should_receive(:get).once.and_return(test_response(test_charge_array))
+      c = Nurego::Charge.all.data
+      c.kind_of?(Array).should be_true
+      c[0].kind_of?(Nurego::Charge).should be_true
+      (c[0].card.kind_of?(Nurego::NuregoObject) && c[0].card.object == 'card').should be_true
+    end
+
+    context "error checking" do
+
+      it "404s should raise an InvalidRequestError" do
+        response = test_response(test_missing_id_error, 404)
+        @mock.should_receive(:get).and_raise(RestClient::ExceptionWithResponse.new(response, 404))
+
+        rescued = false
+        begin
+          Nurego::Customer.new("test_customer").refresh
+          assert false #shouldn't get here either
+        rescue Nurego::InvalidRequestError => e # we don't use assert_raises because we want to examine e
+          rescued = true
+          e.kind_of?(Nurego::InvalidRequestError).should be_true
+          e.param.should eq("id")
+          e.message.should eq("Missing id")
+        end
+
+        rescued.should be_true
+      end
+
+      it "5XXs should raise an APIError" do
+        response = test_response(test_api_error, 500)
+        @mock.should_receive(:get).once.and_raise(RestClient::ExceptionWithResponse.new(response, 500))
+
+        rescued = false
+        begin
+          Nurego::Customer.new("test_customer").refresh
+          fail
+        rescue Nurego::APIError => e # we don't use assert_raises because we want to examine e
+          rescued = true
+          e.kind_of?(Nurego::APIError).should be_true
+        end
+
+        rescued.should be_true
+      end
+
+    end
+  end
+end