paid 0.1.0 → 1.0.0

data/test/paid/status_codes_test.rb

@@ -0,0 +1,63 @@
+# -*- coding: utf-8 -*-
+require File.expand_path('../../test_helper', __FILE__)
+
+module Paid
+  class StatusCodesTest < Test::Unit::TestCase
+
+    context 'InvalidRequestError' do
+      should 'be raised when HTTP status code is 400' do
+        response = test_response(test_missing_id_error, 400)
+        @mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 404))
+        begin
+          MockResource.retrieve('bad_id')
+        rescue Paid::InvalidRequestError => e
+          assert_equal(400, e.http_status)
+          assert(!!e.http_body)
+          assert(e.json_body.is_a?(Hash))
+        end
+      end
+
+      should 'be raised when HTTP status code is 404' do
+        response = test_response(test_missing_id_error, 404)
+        @mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 404))
+        assert_raises
+        begin
+          MockResource.retrieve('foo')
+        rescue Paid::InvalidRequestError => e
+          rescued = true
+          assert_equal(404, e.http_status)
+          assert_equal(true, !!e.http_body)
+          assert_equal(true, e.json_body.is_a?(Hash))
+        end
+        assert(rescued)
+      end
+    end
+
+    context 'APIError' do
+      should 'be raised when HTTP status code is 5XX' do
+        response = test_response(test_api_error, 500)
+        @mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 500))
+
+        begin
+          MockResource.new('fake_id').refresh
+        rescue Paid::APIError => e
+          rescued = true
+          assert(e.is_a?(Paid::APIError))
+        end
+        assert(rescued)
+      end
+    end
+
+    context 'AuthenticationError' do
+      should 'be raised when HTTP status code is 401 (invalid credentials)' do
+        Paid.api_key = 'invalid'
+        response = test_response(test_invalid_api_key_error, 401)
+        assert_raises(Paid::AuthenticationError) do
+          @mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 401))
+          MockResource.retrieve('failing')
+        end
+      end
+    end
+
+  end
+end

data/test/paid/subscription_test.rb

@@ -1,31 +1,111 @@
 require File.expand_path('../../test_helper', __FILE__)
 
 module Paid
-  # SubscriptionTest
   class SubscriptionTest < Test::Unit::TestCase
-    should 'retrieve should retrieve subscriptions' do
-      @mock.expects(:get).once.returns(test_response(test_subscription))
-      i = Paid::Subscription.retrieve('in_test_subscription')
-      assert_equal 'sub_test_subscription', i.id
+    setup do
+      @subscription_url = "#{Paid.api_base}/v0/subscriptions"
     end
 
-    should 'create should create a new subscription' do
-      @mock.expects(:post).once.returns(test_response(test_subscription))
-      i = Paid::Subscription.create
-      assert_equal 'sub_test_subscription', i.id
+    context 'Subscription class' do
+      should 'be retrieveable' do
+        id = "subscription_id"
+        @mock.expects(:get).once.with("#{@subscription_url}/#{id}", anything, anything).returns(test_response(test_subscription))
+        subscription = Paid::Subscription.retrieve(id)
+        assert(subscription.is_a?(Paid::Subscription))
+      end
+
+      should 'be createable' do
+        @mock.expects(:post).once.with(@subscription_url, anything, test_subscription).returns(test_response(test_subscription))
+        subscription = Paid::Subscription.create(test_subscription)
+        assert(subscription.is_a?(Paid::Subscription))
+        assert_equal(test_subscription[:id], subscription.id)
+      end
+
+      should 'be listable' do
+        @mock.expects(:get).once.returns(test_response(test_subscription_list))
+
+        subscriptions = Paid::Subscription.all
+
+        assert(subscriptions.is_a?(Paid::APIList))
+        subscriptions.each do |subscription|
+          assert(subscription.is_a?(Paid::Subscription))
+        end
+      end
     end
 
-    should 'subscriptions should be cancellable' do
-      @mock.expects(:get).never
-      @mock.expects(:post).once.returns(
-        test_response(
-          id: 'sub_test_subscription',
-          cancelled_at: 123_456_789
-        )
-      )
-      s = Paid::Subscription.new('test_subscription')
-      s.cancel
-      assert !s.cancelled_at.nil?
+    context 'Subscription instance' do
+      setup do
+        @subscription = Paid::Subscription.new(test_subscription[:id])
+      end
+
+      should 'be refreshable' do
+        @mock.expects(:get).once.with("#{@subscription_url}/#{@subscription.id}", anything, anything).returns(test_response(test_subscription))
+        @subscription.refresh
+        assert_equal(test_subscription[:customer], @subscription.customer)
+      end
+
+      should 'be cancellable' do
+        response = test_response(test_subscription.merge(:cancelled_at => 1425494198))
+        @mock.expects(:post).once.with("#{@subscription_url}/#{@subscription.id}/cancel", anything, anything).returns(response)
+
+        @subscription.cancel
+        assert_equal(1425494198, @subscription.cancelled_at)
+      end
     end
+
+    context 'Retrieved Paid::Subscription instance' do
+      setup do
+        @mock.expects(:get).once.returns(test_response(test_subscription))
+        @subscription = Paid::Subscription.retrieve('subscription_id')
+      end
+
+      should 'have the id attribute' do
+        assert_equal(test_subscription[:id], @subscription.id)
+      end
+
+      should 'have the object attribute' do
+        assert_equal(test_subscription[:object], @subscription.object)
+      end
+
+      should 'have the created_at attribute' do
+        assert_equal(test_subscription[:created_at], @subscription.created_at)
+      end
+
+      should 'have the starts_on attribute' do
+        assert_equal(test_subscription[:starts_on], @subscription.starts_on)
+      end
+
+      should 'have the next_transaction_on attribute' do
+        assert_equal(test_subscription[:next_transaction_on], @subscription.next_transaction_on)
+      end
+
+      should 'have & convert the plan attribute' do
+        assert_equal(test_subscription[:plan][:id], @subscription.plan.id)
+        assert(@subscription.plan.is_a?(Paid::Plan))
+      end
+
+      should 'have the customer attribute' do
+        assert_equal(test_subscription[:customer], @subscription.customer)
+      end
+
+      should 'have the started_at attribute' do
+        assert_equal(test_subscription[:started_at], @subscription.started_at)
+      end
+
+      should 'have the ended_at attribute' do
+        assert_equal(test_subscription[:ended_at], @subscription.ended_at)
+      end
+
+      should 'have the cancelled_at attribute' do
+        assert_equal(test_subscription[:cancelled_at], @subscription.cancelled_at)
+      end
+
+    end
+
+    should 'be registered' do
+      assert(APIClass.subclasses.include?(Paid::Subscription))
+      assert_equal(Paid::Subscription, APIClass.subclass_fetch("subscription"))
+    end
+
   end
 end

data/test/paid/transaction_test.rb

@@ -2,54 +2,127 @@ require File.expand_path('../../test_helper', __FILE__)
 
 module Paid
   class TransactionTest < Test::Unit::TestCase
-    should 'transactions should be listable' do
-      @mock.expects(:get).once.returns(test_response(test_transaction_array))
-      c = Paid::Transaction.all
-      assert c.data.is_a? Array
-      c.each do |transaction|
-        assert transaction.is_a?(Paid::Transaction)
-      end
+    setup do
+      @transaction_url = "#{Paid.api_base}/v0/transactions"
     end
 
-    should 'transactions should not be deletable' do
-      assert_raises NoMethodError do
-        @mock.expects(:get).once.returns(test_response(test_transaction))
-        c = Paid::Transaction.retrieve('test_transaction')
-        c.delete
+    context 'Transaction class' do
+      should 'be retrieveable' do
+        id = "transaction_id"
+        @mock.expects(:get).once.with("#{@transaction_url}/#{id}", anything, anything).returns(test_response(test_transaction))
+        transaction = Paid::Transaction.retrieve(id)
+        assert(transaction.is_a?(Paid::Transaction))
+      end
+
+      should 'be createable' do
+        @mock.expects(:post).once.with(@transaction_url, anything, test_transaction).returns(test_response(test_transaction))
+        transaction = Paid::Transaction.create(test_transaction)
+        assert(transaction.is_a?(Paid::Transaction))
+        assert_equal(test_transaction[:id], transaction.id)
+      end
+
+      should 'be listable' do
+        @mock.expects(:get).once.returns(test_response(test_transaction_list))
+
+        transactions = Paid::Transaction.all
+
+        assert(transactions.is_a?(Paid::APIList))
+        transactions.each do |transaction|
+          assert(transaction.is_a?(Paid::Transaction))
+        end
       end
     end
 
-    should 'transactions should be updateable' do
-      @mock.expects(:get).once.returns(test_response(test_transaction))
-      @mock.expects(:post).once.returns(test_response(test_transaction))
-      c = Paid::Transaction.new('test_transaction')
-      c.refresh
-      c.mnemonic = 'New transaction description'
-      c.save
+    context 'Transaction instance' do
+      setup do
+        @transaction = Paid::Transaction.new(test_transaction[:id])
+      end
+
+      should 'be refreshable' do
+        @mock.expects(:get).once.with("#{@transaction_url}/#{@transaction.id}", anything, anything).returns(test_response(test_transaction))
+        @transaction.refresh
+        assert_equal(test_transaction[:description], @transaction.description)
+      end
+
+      should 'be updateable' do
+        transaction = Paid::Transaction.new(test_transaction)
+        transaction.description = "new description"
+
+        @mock.expects(:put).once.with do |url, headers, params|
+          params == transaction.changed_attributes && url == "#{@transaction_url}/#{transaction.id}"
+        end.returns(test_response(test_transaction))
+
+        # This should update this instance with test_transaction since it was returned
+        transaction.save
+        assert_equal(test_transaction[:description], transaction.description)
+      end
+
+      should 'be able to mark as paid' do
+        paid_on = "2015-01-01"
+        response = test_response(test_invoice.merge(:paid => true, :paid_on => paid_on))
+        @mock.expects(:post).once.with("#{@transaction_url}/#{@transaction.id}/mark_as_paid", anything, { :paid_on => paid_on }).returns(response)
+
+        assert(!@transaction.paid)
+        @transaction.mark_as_paid(:paid_on => paid_on)
+        assert_equal(paid_on, @transaction.paid_on)
+        assert(@transaction.paid)
+      end
     end
 
-    should 'execute should return a new, fully executed transaction when passed correct parameters' do
-      @mock.expects(:post).with do |url, api_key, params|
-        url == "#{Paid.api_base}/v0/transactions" && api_key.nil? && CGI.parse(params) == {
-          'amount' => ['100'],
-          'description' => ['a description'],
-          'customer' => ['cus_test_customer']
-        }
-      end.once.returns(test_response(test_transaction))
 
-      c = Paid::Transaction.create(amount: 100,
-                                   description: 'a description',
-                                   customer: 'cus_test_customer')
+    context 'Retrieved Paid::Transaction instance' do
+      setup do
+        @mock.expects(:get).once.returns(test_response(test_transaction))
+        @transaction = Paid::Transaction.retrieve('transaction_id')
+      end
+
+      should 'have the id attribute' do
+        assert_equal(test_transaction[:id], @transaction.id)
+      end
+
+      should 'have the object attribute' do
+        assert_equal(test_transaction[:object], @transaction.object)
+      end
+
+      should 'have the amount attribute' do
+        assert_equal(test_transaction[:amount], @transaction.amount)
+      end
+
+      should 'have the description attribute' do
+        assert_equal(test_transaction[:description], @transaction.description)
+      end
+
+      should 'have the customer attribute' do
+        assert_equal(test_transaction[:customer], @transaction.customer)
+      end
+
+      should 'have the alias attribute' do
+        assert_equal(test_transaction[:alias], @transaction.alias)
+      end
+
+      should 'have the paid attribute' do
+        assert_equal(test_transaction[:paid], @transaction.paid)
+      end
+
+      should 'have the paid_on attribute' do
+        assert_equal(test_transaction[:paid_on], @transaction.paid_on)
+      end
+
+      should 'have the properties attribute' do
+        assert_equal(test_transaction[:properties], @transaction.properties)
+      end
+
+      should 'have the invoice attribute' do
+        assert_equal(test_transaction[:invoice], @transaction.invoice)
+      end
 
-      assert !c.paid
     end
 
-    should 'transactions should be able to be marked as paid' do
-      @mock.expects(:get).never
-      @mock.expects(:post).once.returns(test_response(id: 'tr_test_transaction', paid: true))
-      t = Paid::Invoice.new('test_transaction')
-      t.mark_as_paid
-      assert t.paid
+    should 'be registered' do
+      assert(APIClass.subclasses.include?(Paid::Transaction))
+      assert_equal(Paid::Transaction, APIClass.subclass_fetch("transaction"))
     end
+
+
   end
 end

data/test/paid/util_test.rb

@@ -2,7 +2,7 @@ require File.expand_path('../../test_helper', __FILE__)
 
 module Paid
   class UtilTest < Test::Unit::TestCase
-    should "symbolize_names should convert names to symbols" do
+    should "symbolize_keys should convert keys to symbols" do
       start = {
         'foo' => 'bar',
         'array' => [{ 'foo' => 'bar' }],
@@ -22,38 +22,29 @@ module Paid
         }
       }
 
-      symbolized = Paid::Util.symbolize_names(start)
+      symbolized = Paid::Util.symbolize_keys(start)
       assert_equal(finish, symbolized)
     end
 
-    should "parse a nil opts argument" do
-      api_key, headers = Paid::Util.parse_opts(nil)
-      assert_equal({}, headers)
-      assert_equal(nil, api_key)
-    end
+    should 'query_array should convert { :a => "value" } to []' do
+      start = { :a => "value" }
+      finish = ["a=value"]
 
-    should "parse a string opts argument" do
-      api_key, headers = Paid::Util.parse_opts('foo')
-      assert_equal({}, headers)
-      assert_equal('foo', api_key)
+      assert_equal(finish, Paid::Util.query_array(start))
     end
 
-    should "parse a hash opts argument with just api_key" do
-      api_key, headers = Paid::Util.parse_opts({:api_key => 'foo'})
-      assert_equal({}, headers)
-      assert_equal('foo', api_key)
-    end
+    should 'query_array should convert { :a => { :b => { :c => "cvalue" } } } to ["a[b][c]=cvalue"]' do
+      start = { :a => { :b => { :c => "cvalue" } } }
+      finish = ["a[b][c]=cvalue"]
 
-    should "parse a hash opts argument with just idempotency_key" do
-      api_key, headers = Paid::Util.parse_opts({:idempotency_key => 'foo'})
-      assert_equal({:idempotency_key => 'foo'}, headers)
-      assert_equal(nil, api_key)
+      assert_equal(finish, Paid::Util.query_array(start))
     end
 
-    should "parse a hash opts argument both idempotency_key and api_key" do
-      api_key, headers = Paid::Util.parse_opts({:api_key => 'bar', :idempotency_key => 'foo'})
-      assert_equal({:idempotency_key => 'foo'}, headers)
-      assert_equal('bar', api_key)
+    should 'query_array should convert { :a => [1, 2] } to ["a[]=1", "a[]=2"]' do
+      start = { :a => [1, 2] }
+      finish = ["a[]=1", "a[]=2"]
+
+      assert_equal(finish, Paid::Util.query_array(start))
     end
   end
 end

data/test/test_data.rb

@@ -1,5 +1,6 @@
 module Paid
   module TestData
+
     def test_response(body, code=200)
       # When an exception is raised, restclient clobbers method_missing.  Hence we
       # can't just use the stubs interface.
@@ -11,155 +12,205 @@ module Paid
       m
     end
 
-    def test_alias(params={})
-      id = params[:id] || 'al_test_alias'
+    def test_mock_resource
       {
-        :object => "alias",
-        :id => id,
-        :name => 'test-alias',
-        :customer => 'cus_test_customer'
-      }.merge(params)
+        :id => 'test_mock_resource_id',
+        :object => 'mock_resource',
+        :name => 'test mr name',
+        :nested => {
+          :id => 'test_nested_id',
+          :object => 'nested_resource',
+          :price => 500
+        },
+        :thash => { :some_key => "some value" },
+        :tarray => ["abc", "xyz"]
+      }
     end
 
-    def test_alias_array(params={})
+    def test_mock_resource_list
       {
-        :data => [test_alias, test_alias, test_alias],
         :object => 'list',
-        :url => '/v0/aliases'
+        :data => [test_mock_resource, test_mock_resource, test_mock_resource],
+      }
+    end
+
+    def test_account
+      {
+        :id => 'account_id',
+        :object => 'account',
+        :business_name => 'some co inc',
+        :business_url => 'http://www.somecoinc.com/',
+        :business_logo => 'http://www.somecoinc.com/logo.png'
       }
     end
 
-    def test_customer(params={})
-      id = params[:id] || 'cus_test_customer'
+    def test_customer
       {
-        :transactions => [],
+        :id => "cus_DLjf9aDKE9fkdncz",
         :object => "customer",
-        :id => id,
-        :created => 1304114758
-      }.merge(params)
+        :name => "Paid",
+        :email => "hello@paidapi.com",
+        :description => "Obviously this is just a description.",
+        :address_line1 => "2261 Market Street",
+        :address_line2 => "#567",
+        :address_city => "San Francisco",
+        :address_state => "CA",
+        :address_zip => "94114",
+        :phone => "4155069330",
+        :allow_ach => true,
+        :allow_check => true,
+        :allow_credit_card => true,
+        :allow_wire => true,
+        :terms => 30,
+        :billing_type => "invoice",
+        :billing_cycle => "manual",
+        :stripe_customer_id => nil,
+        :external_id => "customer_external_id",
+        :aliases => {
+          :object => "list",
+          :data => ["12345"]
+        }
+      }
     end
 
-    def test_customer_array
+    def test_customer_list
       {
         :data => [test_customer, test_customer, test_customer],
-        :object => 'list',
-        :url => '/v0/customers'
+        :object => 'list'
       }
     end
 
-    def test_transaction(params={})
-      id = params[:id] || 'tr_test_transaction'
+    def test_invoice
       {
+        :object => "invoice",
+        :id => "inv_8KAu1BU4PiYnPE49XtN0A",
+        :summary => nil,
+        :chase_schedule => ["-7", "-1", "0", "1", "5", "10", "15", "20", "25", "30", "~1"],
+        :next_chase_on => nil,
+        :terms => 30,
+        :customer => "cus_XJuvZeQXQgKMrpUAzPbGA",
+        :issued_at => nil,
         :paid => false,
-        :amount => 100,
-        :id => id,
+        :url => "https://payments.paid.com/invoices/inv_8KAu1BU4PiYnPE49XtN0A"
+      }
+    end
+
+    def test_invoice_list
+      {
+        :data => [test_invoice, test_invoice, test_invoice],
+        :object => 'list'
+      }
+    end
+
+    def test_transaction
+      {
+        :id => 'tr_a09sd8a8s9df7asdf98',
         :object => "transaction",
+        :amount => 100,
         :description => 'a description',
-        :created => 1304114826,
-        :customer => 'cus_test_customer'
-      }.merge(params)
+        :customer => 'cus_test_customer',
+        :paid => false,
+        :paid_on => nil,
+        :properties => {},
+        :invoice => 'inv_8KAu1BU4PiYnPE49XtN0A'
+      }
     end
 
-    def test_transaction_array
+    def test_transaction_list
       {
         :data => [test_transaction, test_transaction, test_transaction],
-        :object => 'list',
-        :url => '/v0/transactions'
+        :object => 'list'
       }
     end
 
-    def test_invoice
+    def test_plan
       {
-        object: "invoice",
-        id: "inv_test_invoice",
-        summary: nil,
-        chase_schedule: [
-        "-7",
-        "-1",
-        "0",
-        "1",
-        "5",
-        "10",
-        "15",
-        "20",
-        "25",
-        "30",
-        "~1"
-        ],
-        next_chase_on: nil,
-        terms: 30,
-        due_date: nil,
-        customer: "cus_test_customer",
-        issued_at: nil
+        :object => "plan",
+        :id => "pl_F0h9MWFeZyXKVPHZ0bIcfQ",
+        :created_at => 1425494198,
+        :description => "Plan for testing stuff",
+        :name => "Test Plan",
+        :interval => "year",
+        :interval_count => 1,
+        :amount => 50000
       }
     end
 
-    def test_invalid_api_key_error
+    def test_plan_list
       {
-        :error => {
-          :type => "invalid_request_error",
-          :message => "Invalid API Key provided: invalid"
-        }
+        :data => [test_plan, test_plan, test_plan],
+        :object => 'list'
       }
     end
 
-    def test_missing_id_error
+    def test_event(data=test_invoice, type="invoice.generated")
       {
-        :error => {
-          :param => "id",
-          :type => "invalid_request_error",
-          :message => "Missing id"
-        }
+        :id => "evt_b8DZtUtZs8sxs0EsCcMg",
+        :object => "event",
+        :created_at => 1421719697,
+        :type => type,
+        :data => data
       }
     end
 
-    def test_api_error
+    def test_event_list
       {
-        :error => {
-          :type => "api_error"
-        }
+        :data => [test_event, test_event(test_customer, "customer.created"), test_event(test_plan, "plan.created")],
+        :object => 'list'
       }
     end
 
-    def test_plan(params={})
+    def test_subscription
       {
-        :amount => 100,
-        :id => 'pl_test_plan',
-        :object => 'plan',
-        :name => 'test-name',
-        :description => 'a description',
-        :interval => 'month',
-        :interval_count => 3
-      }.merge(params)
+        :id => "sub_IQSGpEv9mKr6NBkKTr4qfA",
+        :object => "subscription",
+        :created_at => 1425494242,
+        :starts_on => "2015-03-04",
+        :next_transaction_on => "2016-03-04",
+        :plan => test_plan,
+        :customer => "cus_VygTkKwTBgfjV3xo60wRRA",
+        :started_at => 1425494242,
+        :ended_at => 0,
+        :cancelled_at => 0
+      }
     end
 
-    def test_plans_array(params={})
+    def test_subscription_list
       {
-        :data => [test_plan, test_plan, test_plan],
-        :object => 'list',
-        :url => '/v0/plans'
+        :data => [test_subscription, test_subscription, test_subscription],
+        :object => 'list'
       }
     end
 
-    def test_subscription(params={})
+
+
+    # Errors
+    def test_api_error
       {
-        :amount => 100,
-        :id => 'sub_test_subscription',
-        :customer => 'cus_test_customer',
-        :cancelled_at => nil,
-        :ended_at => nil,
-        :started_at => 123_456_789,
-        :start_on => nil,
-        :plan => 'pl_test_plan'
-      }.merge(params)
+        :error => {
+          :type => "api_error"
+        }
+      }
     end
 
-    def test_subscriptions_array(params={})
+    def test_invalid_api_key_error
       {
-        :data => [test_subscription, test_subscription, test_subscription],
-        :object => 'list',
-        :url => '/v0/subscriptions'
+        :error => {
+          :type => "invalid_request_error",
+          :message => "Invalid API Key provided: invalid"
+        }
+      }
+    end
+
+    def test_missing_id_error
+      {
+        :error => {
+          :param => "id",
+          :type => "invalid_request_error",
+          :message => "Missing id"
+        }
       }
     end
+
   end
 end