paid 0.1.0 → 1.0.0

data/paid.gemspec

@@ -1,18 +1,16 @@
 $:.unshift(File.join(File.dirname(__FILE__), 'lib'))
 
-# Maintain your gem's version:
-require "paid/version"
+require 'paid/version'
 
-# Describe your gem and declare its dependencies:
-Gem::Specification.new do |s|
-  s.name        = 'paid'
-  s.version     = Paid::VERSION
-  s.authors     = ['Ryan Jackson']
-  s.email       = ['ryan@paidapi.com']
-  s.homepage    = 'http://docs.paidapi.com'
-  s.summary     = 'Ruby bindings for Paid API'
+spec = Gem::Specification.new do |s|
+  s.name = 'paid'
+  s.summary = 'Ruby bindings for Paid API'
   s.description = 'Paid is the programmatic way to manage payments.  See https://paidapi.com for details.'
-  s.license     = 'MIT'
+  s.homepage = 'http://docs.paidapi.com'
+  s.authors = ['Jon Calhoun', 'Ryan Jackson']
+  s.email = ['joncalhoun@gmail.com', 'ryan@paidapi.com']
+  s.version = Paid::VERSION
+  s.license = 'MIT'
 
   s.add_dependency('rest-client', '~> 1.4')
   s.add_dependency('mime-types', '>= 1.25', '< 3.0')
@@ -28,3 +26,4 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ['lib']
 end
+

data/tasks/api_test.rb

@@ -0,0 +1,187 @@
+require 'paid'
+
+class APITest
+  def initialize(api_key)
+    Paid.api_key = api_key
+  end
+
+  def run
+    account = run_account_test
+    customer = run_customer_tests
+    plan = run_plan_tests
+    subscription = run_subscription_tests(customer, plan)
+    transaction = run_transaction_tests(customer)
+    invoice = run_invoice_tests(customer)
+    event = run_events_tests
+    run_advanced_tests(transaction, invoice, subscription)
+  end
+
+  def run_advanced_tests(transaction, invoice, subscription)
+    puts "Marking the transaction as paid..."
+    transaction.mark_as_paid
+    puts "Marked transaction=#{transaction.id} as paid."
+
+    puts "Issuing the invoice..."
+    invoice.issue
+    puts "Invoice=#{invoice.id} issued."
+
+    puts "Marking the invoice as paid..."
+    invoice.mark_as_paid(:via => :ach)
+    puts "Marked invoice=#{invoice.id} as paid."
+
+    puts "Cancelling subscription=#{subscription.id}..."
+    subscription.cancel
+    puts "Subscription cancelled."
+  end
+
+  def run_events_tests
+    puts "Looking up all events..."
+    events = Paid::Event.all
+    puts "Found #{events.length} events."
+
+    puts "Retrieving the first event..."
+    event = Paid::Event.retrieve(events.first.id)
+    puts "Retrieved the event with the id=#{event.id}"
+
+    event
+  end
+
+  def run_invoice_tests(customer)
+    puts "Creating an invoice with customer=#{customer.id}"
+    invoice = customer.generate_invoice
+    puts "Created: #{invoice.inspect}"
+
+    puts "Looking up all invoices..."
+    invoices = Paid::Invoice.all
+    puts "Found #{invoices.length} invoices."
+
+    puts "Retrieving the generated invoice..."
+    invoice = Paid::Invoice.retrieve(invoice.id)
+    puts "Retrieved the invoice with the id=#{invoice.id}"
+
+    puts "Retrieving the customer=#{customer.id}'s invoices..."
+    invoices = customer.invoices
+    puts "Retrieved: #{invoices.inspect}"
+
+    invoice
+  end
+
+  def run_transaction_tests(customer)
+    puts "Creating 2 transactions with customer=#{customer.id}"
+    transaction = Paid::Transaction.create({
+      :amount => 100,
+      :description => 'a description',
+      :customer => customer.id,
+      :paid => false
+    })
+    transaction_b = Paid::Transaction.create({
+      :amount => 1000,
+      :description => 'another description',
+      :customer => customer.id,
+      :paid => false
+    })
+    puts "Created: #{transaction.inspect} + 1 other"
+
+    puts "Looking up all transactions..."
+    transactions = Paid::Transaction.all
+    puts "Found #{transactions.length} transactions."
+
+    puts "Retrieving the created transaction..."
+    transaction = Paid::Transaction.retrieve(transaction.id)
+    puts "Retrieved the transaction with the id=#{transaction.id}"
+
+    puts "Updating the transaction's name..."
+    transaction.description = "an updated description..."
+    transaction.save
+    puts "Updated the transaction with id=#{transaction.id} with the new description #{transaction.description.inspect}"
+
+    puts "Looking up customer=#{customer.id}'s transactions..."
+    transactions = customer.transactions
+    puts "Retrieved: #{transactions.inspect}"
+
+    transaction
+  end
+
+  def run_subscription_tests(customer, plan)
+    puts "Creating a subscription for customer=#{customer.id} and plan=#{plan.id}..."
+    subscription = Paid::Subscription.create({
+      :starts_on => (Time.now + 1 * 60 * 60 * 24).strftime("%Y-%m-%d"),
+      :plan => plan.id,
+      :customer => customer.id
+    })
+    puts "Created: #{subscription.inspect}"
+
+    puts "Looking up all subscriptions..."
+    subscriptions = Paid::Subscription.all
+    puts "Found #{subscriptions.length} subscriptions."
+
+    puts "Retrieving the created subscription..."
+    subscription = Paid::Subscription.retrieve(subscription.id)
+    puts "Retrieved the subscription with the id=#{subscription.id}"
+
+    subscription
+  end
+
+  def run_plan_tests
+    puts "Creating a plan..."
+    plan = Paid::Plan.create({
+      :description => "Plan for testing stuff",
+      :name => "Test Plan #{Time.now.to_i}-#{rand(2000)}",
+      :interval => "month",
+      :interval_count => 1,
+      :amount => 5000
+    })
+    puts "Created: #{plan.inspect}"
+
+    puts "Looking up all plans..."
+    plans = Paid::Plan.all
+    puts "Found #{plans.length} plans."
+
+    puts "Retrieving the created plan..."
+    plan = Paid::Plan.retrieve(plan.id)
+    puts "Retrieved the plan with the id=#{plan.id}"
+
+    plan
+  end
+
+  def run_customer_tests
+    puts "Creating a customer..."
+    customer = Paid::Customer.create({
+      :name => "Paid",
+      :email => "hello@paidapi.com",
+      :description => "Obviously this is just a description.",
+      :phone => "4155069330",
+      :address_line1 => "2261 Market Street",
+      :address_line2 => "#567",
+      :address_city => "San Francisco",
+      :address_state => "CA",
+      :address_zip => "94114"
+    })
+    puts "Created: #{customer.inspect}"
+
+    puts "Looking up all customers..."
+    customers = Paid::Customer.all
+    puts "Found #{customers.length} customers"
+
+    puts "Retrieving the created customer..."
+    customer = Paid::Customer.retrieve(customer.id)
+    puts "Retrieved the customer with id=#{customer.id}"
+
+    # TODO(joncalhoun): Add by_external_id lookup test
+
+    puts "Updating the customer's name..."
+    customer.name = "Paid Inc"
+    customer.save
+    puts "Updated the customer with id=#{customer.id} with the new name #{customer.name.inspect}"
+
+    customer
+  end
+
+  def run_account_test
+    puts "Looking up the account..."
+    account = Paid::Account.retrieve
+    puts "Retrieved the account with id=#{account.id}"
+    account
+  end
+
+end

data/test/mock_resource.rb

@@ -0,0 +1,69 @@
+# Setup a fake resource for testing the APIResource
+
+class NestedResource < Paid::APIResource
+  attribute :price
+
+  def self.path
+    "/nested_resources"
+  end
+end
+
+class MockResource < Paid::APIResource
+  attribute :name
+  attribute :tarray
+  attribute :thash
+  attribute :nested, NestedResource
+
+  api_class_method :retrieve, :get, ":path/:id", :arguments => [:id]
+  api_class_method :all, :get, :constructor => Paid::APIList.constructor(MockResource)
+  api_class_method :create, :post
+  api_class_method :many_args_get, :get, ":path/:b/many", :arguments => [:a, :b, :c]
+  api_class_method :many_args_post, :post, ":path/:b/many", :arguments => [:a, :b, :c]
+  api_class_method :crazy_path, :get, ":crazy"
+
+  api_class_method :with_con_self, :get, :constructor => :self
+  api_class_method :with_con_class, :get, :constructor => MockResource
+  api_class_method :with_con_lambda, :get, :constructor => lambda{ |json| "lamdba result" }
+  api_class_method :with_con_default, :get
+
+  def self.default_lambda
+    lambda do |this|
+      self.default_values
+    end
+  end
+  api_class_method :with_lambda, :post, :default_params => self.default_lambda
+  api_class_method :with_symbol, :post, :default_params => :default_values
+  api_class_method :with_symbol_and_args, :post, :default_params => :default_values, :arguments => [:name]
+
+  api_instance_method :refresh, :get, :constructor => :self
+  api_instance_method :save, :put, :default_params => changed_lambda, :constructor => :self
+  api_instance_method :delete, :delete
+  api_instance_method :custom_path, :get, ":path", :arguments => [:path]
+  api_instance_method :name_path, :get, ":name"
+  api_instance_method :crazy_path, :get, ":crazy"
+
+  api_instance_method :with_con_self, :get, :constructor => :self
+  api_instance_method :with_con_class, :get, :constructor => MockResource
+  api_instance_method :with_con_lambda, :get, :constructor => lambda{ |json| "lamdba result" }
+  api_instance_method :with_con_default, :get
+
+  api_instance_method :with_lambda, :put, :default_params => changed_lambda
+  api_instance_method :with_symbol, :put, :default_params => :changed_attributes
+  api_instance_method :with_symbol_and_args, :put, :default_params => :changed_attributes, :arguments => [:name]
+
+  def self.path
+    "/mocks"
+  end
+
+  def self.crazy
+    "/crazy_path"
+  end
+
+  def self.default_values
+    {
+      :name => "default name",
+      :tarray => [1,2,3]
+    }
+  end
+
+end

data/test/paid/account_test.rb

@@ -2,11 +2,48 @@ require File.expand_path('../../test_helper', __FILE__)
 
 module Paid
   class AccountTest < Test::Unit::TestCase
-    should "account should be retrievable" do
-      resp = {:email => "test+bindings@paidapi.com"}
-      @mock.expects(:get).once.returns(test_response(resp))
+    setup do
+      @account_url = "#{Paid.api_base}/v0/account"
+    end
+
+    should 'be retrievable' do
+      @mock.expects(:get).once.with(@account_url, anything, anything).returns(test_response(test_account))
       a = Paid::Account.retrieve
-      assert_equal "test+bindings@paidapi.com", a.email
+      assert(a.is_a?(Paid::Account))
+      assert_equal(test_account[:id], a.id)
+    end
+
+    context 'Retrieved Paid::Account instance' do
+      setup do
+        @mock.expects(:get).once.returns(test_response(test_account))
+        @account = Paid::Account.retrieve
+      end
+
+      should 'have the id attribute' do
+        assert_equal(test_account[:id], @account.id)
+      end
+
+      should 'have the object attribute' do
+        assert_equal(test_account[:object], @account.object)
+      end
+
+      should 'have the business_name attribute' do
+        assert_equal(test_account[:business_name], @account.business_name)
+      end
+
+      should 'have the business_url attribute' do
+        assert_equal(test_account[:business_url], @account.business_url)
+      end
+
+      should 'have the business_logo attribute' do
+        assert_equal(test_account[:business_logo], @account.business_logo)
+      end
     end
+
+    should 'be registered' do
+      assert(APIClass.subclasses.include?(Paid::Account))
+      assert_equal(Paid::Account, APIClass.subclass_fetch("account"))
+    end
+
   end
 end

data/test/paid/api_class_test.rb

@@ -0,0 +1,412 @@
+# -*- coding: utf-8 -*-
+require File.expand_path('../../test_helper', __FILE__)
+
+module Paid
+  class ApiClassTest < Test::Unit::TestCase
+
+    context 'Non-network actions' do
+      setup do
+        @mock.expects(:get).never
+        @mock.expects(:post).never
+        @mock.expects(:put).never
+        @mock.expects(:delete).never
+      end
+
+      should 'not fetch over the network when creating a new APIClass' do
+        MockResource.new('fake_id')
+      end
+
+      should 'not fetch over the network when creating a new APIClass from a hash' do
+        MockResource.construct(test_mock_resource)
+      end
+
+      should 'not fetch over the network when setting an attribute' do
+        c = MockResource.new('fake_id')
+        c.name = 'Another Name'
+      end
+
+      should 'not fetch over the network when accessing an attribute' do
+        c = MockResource.new('fake_id')
+        c.id
+      end
+    end
+
+    # These GET, POST, etc should really be in a dif test, but this is easier.
+    context 'Making a GET request' do
+      should 'urlencode values in params and have no payload' do
+        response = test_response(test_mock_resource_list)
+
+        # The test is to basically make sure this expectation passes.
+        @mock.expects(:get).with do |url, headers, params|
+          (url == "#{Paid.api_base}#{MockResource.path}?page=1&filter=test%20filter" ||
+            url == "#{Paid.api_base}#{MockResource.path}?filter=test%20filter&page=1") &&
+          params == nil
+        end.returns(response)
+
+        list = MockResource.all({
+          :page => 1,
+          :filter => 'test filter',
+        })
+      end
+    end
+
+    context 'Making a DELETE request' do
+      should 'urlencode values in params and have no payload' do
+        @mock.expects(:get).once.returns(test_response(test_mock_resource))
+        mock_resource = MockResource.retrieve("fake_id")
+
+        @mock.expects(:delete).once.with do |url, headers, payload|
+          url == "#{Paid.api_base}#{mock_resource.path}?reason=delinquent%20payments" && payload.nil?
+        end.returns(test_response({}))
+        mock_resource.delete(:reason => "delinquent payments")
+      end
+    end
+
+    context 'Making a PUT request' do
+      should 'have a payload with no query string' do
+        @mock.expects(:get).once.returns(test_response(test_mock_resource))
+        mock_resource = MockResource.retrieve("fake_id")
+        mock_resource.name = "new name"
+
+        @mock.expects(:put).once.with do |url, header, payload|
+          payload == { :name => "new name" }
+        end.returns(test_response(test_mock_resource))
+        mock_resource.save
+      end
+    end
+
+    context 'Making a POST request' do
+      should 'have a payload with no query string' do
+        params = { :name => "some name" }
+        @mock.expects(:post).once.with("#{Paid.api_base}#{MockResource.path}", anything, params).returns(test_response(test_mock_resource))
+
+        MockResource.create(params)
+      end
+    end
+
+    context 'APIClass :default_params' do
+      context 'api_instance_method' do
+        setup do
+          @response = test_response(test_mock_resource_list)
+          @mr = MockResource.new(test_mock_resource)
+        end
+
+        should 'call any provided lambdas and set the result as params' do
+          @mock.expects(:put).once.with(anything, anything, { :name => "new name" }).returns(@response)
+
+          @mr.name = "new name"
+          @mr.with_lambda
+        end
+
+        should 'call any method defined by a symbol and set the results as params' do
+          @mock.expects(:put).once.with(anything, anything, { :name => "new name" }).returns(@response)
+
+          @mr.name = "new name"
+          @mr.with_symbol
+        end
+
+        context 'order priority' do
+          # Intended order of priority:
+          # 1. Params. eg in mock_resource.save(params, opts), params should take
+          #    priority with duplicate keys.
+          # 2. Arguments. These should take priority over default values from :params
+          #    method.
+          # 3. Results from method defined by :default_params. This can be a symbol that is
+          #    the name of a method to call, or a lambda (though a hash is preferred).
+          should 'prioritize params argument over args and default_params method' do
+            params = {
+              :name => "not arg name",
+              :tarray => ["not method tarray"],
+              :thash => { :val => "custom hash" }
+            }
+            @mock.expects(:put).once.with(anything, anything, params).returns(@response)
+
+            @mr.tarray = ["method array"]
+            @mr.with_symbol_and_args("arg name", params)
+          end
+
+          should 'prioritize arguments over :default_params' do
+            @mock.expects(:put).once.with(anything, anything, { :name => "arg name" }).returns(@response)
+
+            @mr.name = "changed name"
+            @mr.with_symbol_and_args("arg name")
+          end
+
+          should 'use :default_params method as even when args and params are present' do
+            @mock.expects(:put).once.with(anything, anything, {
+              :thash => { :val => "params hash" },
+              :name => "arg name",
+              :tarray => ["change array"],
+            }).returns(@response)
+
+            @mr.tarray = ["change array"]
+            @mr.with_symbol_and_args("arg name", { :thash => { :val => "params hash" } })
+          end
+        end
+      end
+
+      context 'api_class_method' do
+        setup do
+          @response = test_response(test_mock_resource_list)
+        end
+
+        should 'call any provided lambdas and set the result as params' do
+          @mock.expects(:post).once.with(anything, anything, MockResource.default_values).returns(@response)
+          MockResource.with_lambda
+        end
+
+        should 'call any method defined by a symbol and set the results as params' do
+          @mock.expects(:post).once.with(anything, anything, MockResource.default_values).returns(@response)
+          MockResource.with_symbol
+        end
+
+        context 'order priority' do
+          # Intended order of priority:
+          # 1. Params. eg in mock_resource.save(params, opts), params should take
+          #    priority with duplicate keys.
+          # 2. Arguments. These should take priority over default values from :params
+          #    method.
+          # 3. Results from method defined by :default_params. This can be a symbol that is
+          #    the name of a method to call, or a lambda (though a hash is preferred).
+          should 'prioritize params argument over args and default_params method' do
+            params = {
+              :name => "not arg name",
+              :tarray => ["not method tarray"],
+              :thash => { :val => "custom hash" }
+            }
+            @mock.expects(:post).once.with(anything, anything, params).returns(@response)
+            MockResource.with_symbol_and_args("name arg", params)
+          end
+
+          should 'prioritize arguments over :default_params' do
+            params = Util.sorta_deep_clone(MockResource.default_values)
+            params[:name] = "name arg"
+            @mock.expects(:post).once.with(anything, anything, params).returns(@response)
+            MockResource.with_symbol_and_args("name arg", params)
+          end
+
+          should 'use :default_params method as even when args and params are present' do
+            params = {
+              :name => "name arg",
+              :tarray => MockResource.default_values[:tarray].dup,
+              :thash => { :val => "custom hash" }
+            }
+            @mock.expects(:post).once.with(anything, anything, params).returns(@response)
+            MockResource.with_symbol_and_args("name arg", { :thash => { :val => "custom hash" }})
+          end
+        end
+      end
+    end
+
+
+    context 'APIClass#attribute' do
+      should 'create a getter method' do
+        assert(MockResource.method_defined?(:name))
+      end
+
+      should 'create a setter method' do
+        assert(MockResource.method_defined?(:name=))
+      end
+
+      should 'have no changed attributes after init' do
+        mr = MockResource.new(test_mock_resource)
+        assert(mr.changed_attributes.empty?)
+      end
+
+      should 'keep track of changed attributes' do
+        mr = MockResource.new(test_mock_resource)
+        assert(mr.changed_attributes.empty?)
+        mr.name = "new name"
+        assert_equal({:name => "new name"}, mr.changed_attributes)
+      end
+
+      should 'keep track of changed arrays' do
+        mr = MockResource.new(test_mock_resource)
+        assert(mr.changed_attributes.empty?)
+        mr.tarray << "new"
+        assert_equal({:tarray => test_mock_resource[:tarray] + ["new"]}, mr.changed_attributes)
+      end
+
+      should 'keep track of changed hashes' do
+        mr = MockResource.new(test_mock_resource)
+        assert(mr.changed_attributes.empty?)
+        mr.thash[:some_key] = "new value"
+        assert_equal({:thash => { :some_key => "new value" }}, mr.changed_attributes)
+      end
+
+      context 'constructors' do
+        should 'instantiate on #new' do
+          mr = MockResource.new(test_mock_resource)
+          assert(mr.nested.is_a?(NestedResource))
+        end
+
+        should 'instantiate on #construct' do
+          mr = MockResource.construct(test_mock_resource)
+          assert(mr.nested.is_a?(NestedResource))
+        end
+
+        should 'instantiate on #refresh_from' do
+          mr = MockResource.new('fake_id')
+          assert(mr.nested.nil?)
+
+          mr.refresh_from(test_mock_resource)
+          assert(mr.nested.is_a?(NestedResource))
+        end
+      end
+    end
+
+    context 'APIClass :constructor' do
+      context 'for api_class_method' do
+        setup do
+          @mock.expects(:get).once.returns(test_response(test_mock_resource))
+        end
+
+        should 'create a new MockResource with :constructor => :self' do
+          mr = MockResource.with_con_self
+          assert(mr.is_a?(MockResource))
+        end
+
+        should 'create a new MockResource with :constructor => MockResource' do
+          mr = MockResource.with_con_class
+          assert(mr.is_a?(MockResource))
+        end
+
+        should 'use the lambda with :constructor => lambda{...}' do
+          mr = MockResource.with_con_lambda
+          assert_equal("lamdba result", mr)
+        end
+
+        should 'create a new MockResource with no constructor defined' do
+          mr = MockResource.with_con_default
+          assert(mr.is_a?(MockResource))
+        end
+      end
+
+      context 'for api_instance_method' do
+        setup do
+          @mock.expects(:get).once.returns(test_response(test_mock_resource))
+          @mr = MockResource.new('fake_id')
+        end
+
+        should 'update this instance with :constructor => :self' do
+          @mr.with_con_self
+          assert(@mr.is_a?(MockResource))
+          assert_equal(test_mock_resource[:id], @mr.id)
+        end
+
+        should 'create a new instance with :constructor => MockResource' do
+          res = @mr.with_con_class
+          assert(res.is_a?(MockResource))
+          assert_not_equal(@mr.id, res.id)
+        end
+
+        should 'use the lambda with :constructor => lambda{...}' do
+          res = @mr.with_con_lambda
+          assert_equal("lamdba result", res)
+        end
+
+        should 'update this instance with no constructor defined' do
+          @mr.with_con_default
+          assert(@mr.is_a?(MockResource))
+          assert_equal(test_mock_resource[:id], @mr.id)
+        end
+      end
+    end
+
+    context 'APIClass api_*_method arguments' do
+      should 'throw an ArgumentError if too few arguments are provided' do
+        assert_raises(ArgumentError) { MockResource.retrieve }
+      end
+
+      should 'throw an ArgumentError with the name of missing arguments' do
+        begin
+          MockResource.retrieve
+          assert(false, "ArgumentError was expected.")
+        rescue ArgumentError => e
+          assert(e.message =~ /id/)
+        end
+      end
+
+      should 'throw an ArgumentError if too many arguments are provided' do
+        assert_raises(ArgumentError) { MockResource.retrieve(1, 2, {}, {}) }
+      end
+
+      should 'throw an ArgumentError if the param argument is invalid' do
+        assert_raises(ArgumentError) { MockResource.retrieve(1, 2) }
+      end
+
+      should 'throw an ArgumentError if the opts argument is invalid' do
+        assert_raises(ArgumentError) { MockResource.retrieve(1, {}, "abc") }
+      end
+
+      should 'not throw an ArgumentError if the opts or params are nil' do
+        @mock.expects(:get).times(2).returns(test_response(test_mock_resource))
+        MockResource.retrieve(1, nil, {})
+        MockResource.retrieve(1, {}, nil)
+      end
+
+      should 'urlencode unused arguments via GET' do
+        response = test_response(test_mock_resource)
+        @mock.expects(:get).with do |url, headers, params|
+          (url == "#{Paid.api_base}#{MockResource.path}/bval/many?a=aval&c=cval" ||
+            url == "#{Paid.api_base}#{MockResource.path}/bval/many?c=cval&a=aval") &&
+          params.nil?
+        end.returns(response)
+
+        MockResource.many_args_get("aval", "bval", "cval")
+      end
+
+      should 'assign unused arguments to the params payload via POST' do
+        response = test_response(test_mock_resource)
+        @mock.expects(:post).with("#{Paid.api_base}#{MockResource.path}/bval/many", anything, { :a => "aval", :c => "cval" }).returns(response)
+
+        MockResource.many_args_post("aval", "bval", "cval")
+      end
+    end
+
+    context 'APIClass api_instance_method paths' do
+      should 'use the provided argument if it is present' do
+        response = test_response(test_mock_resource)
+        @mock.expects(:get).with("#{Paid.api_base}/custom_path", anything, anything).returns(response)
+
+        mr = MockResource.new(test_mock_resource)
+        mr.custom_path("/custom_path")
+      end
+
+      should 'use the instance method for path values' do
+        response = test_response(test_mock_resource)
+        name = "/mock_resource_name"
+        @mock.expects(:get).with("#{Paid.api_base}#{name}", anything, anything).returns(response)
+
+        mr = MockResource.new(test_mock_resource)
+        mr.name = name
+        mr.name_path
+      end
+
+      should 'use the class method for path values' do
+        response = test_response(test_mock_resource)
+        @mock.expects(:get).with("#{Paid.api_base}#{MockResource.crazy}", anything, anything).returns(response)
+
+        mr = MockResource.new(test_mock_resource)
+        mr.crazy_path
+      end
+    end
+
+    context 'APIClass api_class_method paths' do
+      should 'use the provided argument if it is present' do
+        response = test_response(test_mock_resource)
+        @mock.expects(:get).with("#{Paid.api_base}#{MockResource.path}/fake_id", anything, anything).returns(response)
+
+        mr = MockResource.retrieve('fake_id')
+      end
+
+      should 'use the class method for path values' do
+        response = test_response(test_mock_resource)
+        @mock.expects(:get).with("#{Paid.api_base}#{MockResource.crazy}", anything, anything).returns(response)
+
+        MockResource.crazy_path
+      end
+    end
+
+  end
+end