paid 0.1.0 → 1.0.0

data/test/paid/customer_test.rb

@@ -2,43 +2,203 @@ require File.expand_path('../../test_helper', __FILE__)
 
 module Paid
   class CustomerTest < Test::Unit::TestCase
-    should "customers should be listable" do
-      @mock.expects(:get).once.returns(test_response(test_customer_array))
-      c = Paid::Customer.all.data
-      assert c.kind_of? Array
-      assert c[0].kind_of? Paid::Customer
+    setup do
+      @customer_url = "#{Paid.api_base}/v0/customers"
     end
 
-    should "customers should be deletable" do
-      @mock.expects(:delete).once.returns(test_response(test_customer({:deleted => true})))
-      c = Paid::Customer.new("test_customer")
-      c.delete
-      assert c.deleted
+    context 'Customer class' do
+      should 'be retrieveable' do
+        id = "customer_id"
+        @mock.expects(:get).once.with("#{@customer_url}/#{id}", anything, anything).returns(test_response(test_customer))
+        customer = Paid::Customer.retrieve(id)
+        assert(customer.is_a?(Paid::Customer))
+      end
+
+      should 'be retrieveable by alias' do
+        al = "alias_for_cust"
+        @mock.expects(:get).once.with("#{Paid.api_base}/v0/aliases/#{al}", anything, anything).returns(test_response(test_customer))
+        customer = Paid::Customer.by_alias(al)
+        assert(customer.is_a?(Paid::Customer))
+      end
+
+      should 'be retrieveable by external_id' do
+        external_id = "external_id_for_cust"
+        @mock.expects(:get).once.with("#{@customer_url}/by_external_id/#{external_id}", anything, anything).returns(test_response(test_customer))
+        customer = Paid::Customer.by_external_id(external_id)
+        assert(customer.is_a?(Paid::Customer))
+      end
+
+      should 'be createable' do
+        @mock.expects(:post).once.with(@customer_url, anything, test_customer).returns(test_response(test_customer))
+        customer = Paid::Customer.create(test_customer)
+        assert(customer.is_a?(Paid::Customer))
+        assert_equal(test_customer[:id], customer.id)
+      end
+
+      should 'be listable' do
+        @mock.expects(:get).once.returns(test_response(test_customer_list))
+
+        customers = Paid::Customer.all
+
+        assert(customers.is_a?(Paid::APIList))
+        customers.each do |customer|
+          assert(customer.is_a?(Paid::Customer))
+        end
+      end
     end
 
-    should "customers should be updateable" do
-      @mock.expects(:get).once.returns(test_response(test_customer({:mnemonic => "foo"})))
-      @mock.expects(:post).once.returns(test_response(test_customer({:mnemonic => "bar"})))
-      c = Paid::Customer.new("test_customer").refresh
-      assert_equal "foo", c.mnemonic
-      c.mnemonic = "bar"
-      c.save
-      assert_equal "bar", c.mnemonic
+    context 'Customer instance' do
+      should 'be refreshable' do
+        @mock.expects(:get).once.with("#{@customer_url}/#{test_customer[:id]}", anything, anything).returns(test_response(test_customer))
+        customer = Paid::Customer.new(test_customer[:id])
+        customer.refresh
+        assert_equal(test_customer[:name], customer.name)
+      end
+
+      should 'be updateable' do
+        customer = Paid::Customer.new(test_customer)
+        customer.name = "new name"
+        customer.email = "new_email@domain.com"
+
+        @mock.expects(:put).once.with do |url, headers, params|
+          params == customer.changed_attributes && url == "#{@customer_url}/#{customer.id}"
+        end.returns(test_response(test_customer))
+
+        # This should update this instance with test_customer since it was returned
+        customer.save
+        assert_equal(test_customer[:name], customer.name)
+        assert_equal(test_customer[:email], customer.email)
+      end
+
+      should 'be able to generate an invoice' do
+        customer = Paid::Customer.new(test_customer)
+        @mock.expects(:post).once.with("#{@customer_url}/#{customer.id}/generate_invoice", anything, anything).returns(test_response(test_invoice))
+
+        invoice = customer.generate_invoice
+        assert(invoice.is_a?(Paid::Invoice))
+      end
+
+      should 'be able to list invoices' do
+        customer = Paid::Customer.new(test_customer)
+        @mock.expects(:get).once.with("#{Paid.api_base}#{Paid::Invoice.path}?customer=#{customer.id}", anything, anything).returns(test_response(test_invoice_list))
+
+        invoices = customer.invoices
+        assert(invoices.is_a?(Paid::APIList))
+        invoices.each do |invoice|
+          assert(invoice.is_a?(Paid::Invoice))
+        end
+      end
+
+      should 'be able to list transactions' do
+        customer = Paid::Customer.new(test_customer)
+        @mock.expects(:get).once.with("#{Paid.api_base}#{Paid::Transaction.path}?customer=#{customer.id}", anything, anything).returns(test_response(test_transaction_list))
+
+        transactions = customer.transactions
+        assert(transactions.is_a?(Paid::APIList))
+        transactions.each do |transaction|
+          assert(transaction.is_a?(Paid::Transaction))
+        end
+      end
     end
 
-    should "create should return a new customer" do
-      @mock.expects(:post).once.returns(test_response(test_customer))
-      c = Paid::Customer.create
-      assert_equal "cus_test_customer", c.id
+
+    context 'Retrieved Paid::Customer instance' do
+      setup do
+        @mock.expects(:get).once.returns(test_response(test_customer))
+        @customer = Paid::Customer.retrieve('customer_id')
+      end
+
+      should 'have the id attribute' do
+        assert_equal(test_customer[:id], @customer.id)
+      end
+
+      should 'have the object attribute' do
+        assert_equal(test_customer[:object], @customer.object)
+      end
+
+      should 'have the name attribute' do
+        assert_equal(test_customer[:name], @customer.name)
+      end
+
+      should 'have the email attribute' do
+        assert_equal(test_customer[:email], @customer.email)
+      end
+
+      should 'have the description attribute' do
+        assert_equal(test_customer[:description], @customer.description)
+      end
+
+      should 'have the phone attribute' do
+        assert_equal(test_customer[:phone], @customer.phone)
+      end
+
+      should 'have the address_line1 attribute' do
+        assert_equal(test_customer[:address_line1], @customer.address_line1)
+      end
+
+      should 'have the address_line2 attribute' do
+        assert_equal(test_customer[:address_line2], @customer.address_line2)
+      end
+
+      should 'have the address_city attribute' do
+        assert_equal(test_customer[:address_city], @customer.address_city)
+      end
+
+      should 'have the address_state attribute' do
+        assert_equal(test_customer[:address_state], @customer.address_state)
+      end
+
+      should 'have the address_zip attribute' do
+        assert_equal(test_customer[:address_zip], @customer.address_zip)
+      end
+
+      should 'have the allow_ach attribute' do
+        assert_equal(test_customer[:allow_ach], @customer.allow_ach)
+      end
+
+      should 'have the allow_wire attribute' do
+        assert_equal(test_customer[:allow_wire], @customer.allow_wire)
+      end
+
+      should 'have the allow_check attribute' do
+        assert_equal(test_customer[:allow_check], @customer.allow_check)
+      end
+
+      should 'have the allow_credit_card attribute' do
+        assert_equal(test_customer[:allow_credit_card], @customer.allow_credit_card)
+      end
+
+      should 'have the terms attribute' do
+        assert_equal(test_customer[:terms], @customer.terms)
+      end
+
+      should 'have the billing_type attribute' do
+        assert_equal(test_customer[:billing_type], @customer.billing_type)
+      end
+
+      should 'have the billing_cycle attribute' do
+        assert_equal(test_customer[:billing_cycle], @customer.billing_cycle)
+      end
+
+      should 'have the stripe_customer_id attribute' do
+        assert_equal(test_customer[:stripe_customer_id], @customer.stripe_customer_id)
+      end
+
+      should 'have the external_id attribute' do
+        assert_equal(test_customer[:external_id], @customer.external_id)
+      end
+
+      should 'have & convert the aliases attribute' do
+        assert(@customer.aliases.is_a?(Paid::APIList))
+        assert_equal(test_customer[:aliases][:data], @customer.aliases.data)
+      end
+
     end
 
-    should "be able to generate invoice" do
-      @mock.expects(:get).never
-      @mock.expects(:post).once.returns(test_response(test_customer))
-      c = Paid::Customer.create
-      @mock.expects(:post).once.returns(test_response(test_invoice))
-      i = c.generate_invoice
-      assert i.kind_of?(Paid::Invoice)
+    should 'be registered' do
+      assert(APIClass.subclasses.include?(Paid::Customer))
+      assert_equal(Paid::Customer, APIClass.subclass_fetch("customer"))
     end
+
   end
 end

data/test/paid/event_test.rb

@@ -0,0 +1,74 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+module Paid
+  class EventTest < Test::Unit::TestCase
+    setup do
+      @event_url = "#{Paid.api_base}/v0/events"
+    end
+
+    context 'Event class' do
+      should 'be retrieveable' do
+        id = "event_id"
+        @mock.expects(:get).once.with("#{@event_url}/#{id}", anything, anything).returns(test_response(test_event))
+        event = Paid::Event.retrieve(id)
+        assert(event.is_a?(Paid::Event))
+      end
+
+      should 'be listable' do
+        @mock.expects(:get).once.returns(test_response(test_event_list))
+
+        events = Paid::Event.all
+
+        assert(events.is_a?(Paid::APIList))
+        events.each do |event|
+          assert(event.is_a?(Paid::Event))
+        end
+      end
+    end
+
+    context 'Event instance' do
+      should 'be refreshable' do
+        @mock.expects(:get).once.with("#{@event_url}/#{test_event[:id]}", anything, anything).returns(test_response(test_event))
+        event = Paid::Event.new(test_event[:id])
+        event.refresh
+        assert_equal(test_event[:type], event.type)
+      end
+    end
+
+    context 'Retrieved Paid::Event instance' do
+      setup do
+        @mock.expects(:get).once.returns(test_response(test_event))
+        @event = Paid::Event.retrieve('event_id')
+      end
+
+      should 'have the id attribute' do
+        assert_equal(test_event[:id], @event.id)
+      end
+
+      should 'have the object attribute' do
+        assert_equal(test_event[:object], @event.object)
+      end
+
+      should 'have the created_at attribute' do
+        assert_equal(test_event[:created_at], @event.created_at)
+      end
+
+      should 'have the type attribute' do
+        assert_equal(test_event[:type], @event.type)
+      end
+
+      should 'have & convert the data attribute' do
+        assert(@event.data.is_a?(Paid::APIClass))
+        event2 = Paid::Event.new(test_event(test_invoice))
+        assert(event2.data.is_a?(Paid::Invoice))
+      end
+
+    end
+
+    should 'be registered' do
+      assert(APIClass.subclasses.include?(Paid::Event))
+      assert_equal(Paid::Event, APIClass.subclass_fetch("event"))
+    end
+
+  end
+end

data/test/paid/invoice_test.rb

@@ -2,32 +2,113 @@ require File.expand_path('../../test_helper', __FILE__)
 
 module Paid
   class InvoiceTest < Test::Unit::TestCase
-    should "retrieve should retrieve invoices" do
-      @mock.expects(:get).once.returns(test_response(test_invoice))
-      i = Paid::Invoice.retrieve('in_test_invoice')
-      assert_equal 'inv_test_invoice', i.id
+    setup do
+      @invoice_url = "#{Paid.api_base}/v0/invoices"
     end
 
-    should "create should create a new invoice" do
-      @mock.expects(:post).once.returns(test_response(test_invoice))
-      i = Paid::Invoice.create
-      assert_equal "inv_test_invoice", i.id
+    context 'Invoice class' do
+      should 'be retrieveable' do
+        id = "invoice_id"
+        @mock.expects(:get).once.with("#{@invoice_url}/#{id}", anything, anything).returns(test_response(test_invoice))
+        invoice = Paid::Invoice.retrieve(id)
+        assert(invoice.is_a?(Paid::Invoice))
+      end
+
+      should 'be createable' do
+        @mock.expects(:post).once.with(@invoice_url, anything, test_invoice).returns(test_response(test_invoice))
+        invoice = Paid::Invoice.create(test_invoice)
+        assert(invoice.is_a?(Paid::Invoice))
+        assert_equal(test_invoice[:id], invoice.id)
+      end
+
+      should 'be listable' do
+        @mock.expects(:get).once.returns(test_response(test_invoice_list))
+
+        invoices = Paid::Invoice.all
+
+        assert(invoices.is_a?(Paid::APIList))
+        invoices.each do |invoice|
+          assert(invoice.is_a?(Paid::Invoice))
+        end
+      end
     end
 
-    should "invoices should be issuable" do
-      @mock.expects(:get).never
-      @mock.expects(:post).once.returns(test_response({:id => "inv_test_invoice", :issued_at => 123467890}))
-      i = Paid::Invoice.new("test_invoice")
-      i.issue
-      assert !i.issued_at.nil?
+    context 'Invoice instance' do
+      setup do
+        @invoice = Paid::Invoice.new(test_invoice[:id])
+      end
+
+      should 'be refreshable' do
+        @mock.expects(:get).once.with("#{@invoice_url}/#{@invoice.id}", anything, anything).returns(test_response(test_invoice))
+        @invoice.refresh
+        assert_equal(test_invoice[:summary], @invoice.summary)
+      end
+
+      should 'be able to mark as paid' do
+        via = :ach
+        @mock.expects(:post).once.with("#{@invoice_url}/#{@invoice.id}/mark_as_paid", anything, { :via => via }).returns(test_response(test_invoice))
+
+        @invoice.mark_as_paid(:via => via)
+        assert_equal(test_invoice[:summary], @invoice.summary)
+      end
+
+      should 'be issuable' do
+        @mock.expects(:post).once.with("#{@invoice_url}/#{@invoice.id}/issue", anything, anything).returns(test_response(test_invoice))
+
+        @invoice.issue
+        assert_equal(test_invoice[:summary], @invoice.summary)
+      end
     end
 
-    should "invoices should be able to be marked as paid" do
-      @mock.expects(:get).never
-      @mock.expects(:post).once.returns(test_response({:id => "inv_test_invoice", :paid => true}))
-      i = Paid::Invoice.new("test_invoice")
-      i.mark_as_paid
-      assert i.paid
+
+    context 'Retrieved Paid::Invoice instance' do
+      setup do
+        @mock.expects(:get).once.returns(test_response(test_invoice))
+        @invoice = Paid::Invoice.retrieve('invoice_id')
+      end
+
+      should 'have the id attribute' do
+        assert_equal(test_invoice[:id], @invoice.id)
+      end
+
+      should 'have the object attribute' do
+        assert_equal(test_invoice[:object], @invoice.object)
+      end
+
+      should 'have the summary attribute' do
+        assert_equal(test_invoice[:summary], @invoice.summary)
+      end
+
+      should 'have the chase_schedule attribute' do
+        assert_equal(test_invoice[:chase_schedule], @invoice.chase_schedule)
+      end
+
+      should 'have the next_chase_on attribute' do
+        assert_equal(test_invoice[:next_chase_on], @invoice.next_chase_on)
+      end
+
+      should 'have the customer attribute' do
+        assert_equal(test_invoice[:customer], @invoice.customer)
+      end
+
+      should 'have the issued_at attribute' do
+        assert_equal(test_invoice[:issued_at], @invoice.issued_at)
+      end
+
+      should 'have the terms attribute' do
+        assert_equal(test_invoice[:terms], @invoice.terms)
+      end
+
+      should 'have the url attribute' do
+        assert_equal(test_invoice[:url], @invoice.url)
+      end
+
     end
+
+    should 'be registered' do
+      assert(APIClass.subclasses.include?(Paid::Invoice))
+      assert_equal(Paid::Invoice, APIClass.subclass_fetch("invoice"))
+    end
+
   end
 end

data/test/paid/plan_test.rb

@@ -2,16 +2,92 @@ require File.expand_path('../../test_helper', __FILE__)
 
 module Paid
   class PlanTest < Test::Unit::TestCase
-    should "retrieve should retrieve plans" do
-      @mock.expects(:get).once.returns(test_response(test_plan))
-      i = Paid::Plan.retrieve('in_test_plan')
-      assert_equal 'pl_test_plan', i.id
+    setup do
+      @plan_url = "#{Paid.api_base}/v0/plans"
     end
 
-    should "create should create a new plan" do
-      @mock.expects(:post).once.returns(test_response(test_plan))
-      i = Paid::Plan.create
-      assert_equal "pl_test_plan", i.id
+    context 'Plan class' do
+      should 'be retrieveable' do
+        id = "plan_id"
+        @mock.expects(:get).once.with("#{@plan_url}/#{id}", anything, anything).returns(test_response(test_plan))
+        plan = Paid::Plan.retrieve(id)
+        assert(plan.is_a?(Paid::Plan))
+      end
+
+      should 'be createable' do
+        @mock.expects(:post).once.with(@plan_url, anything, test_plan).returns(test_response(test_plan))
+        plan = Paid::Plan.create(test_plan)
+        assert(plan.is_a?(Paid::Plan))
+        assert_equal(test_plan[:id], plan.id)
+      end
+
+      should 'be listable' do
+        @mock.expects(:get).once.returns(test_response(test_plan_list))
+
+        plans = Paid::Plan.all
+
+        assert(plans.is_a?(Paid::APIList))
+        plans.each do |plan|
+          assert(plan.is_a?(Paid::Plan))
+        end
+      end
+    end
+
+    context 'Plan instance' do
+      should 'be refreshable' do
+        @mock.expects(:get).once.with("#{@plan_url}/#{test_plan[:id]}", anything, anything).returns(test_response(test_plan))
+        plan = Paid::Plan.new(test_plan[:id])
+        plan.refresh
+        assert_equal(test_plan[:name], plan.name)
+      end
+    end
+
+
+    context 'Retrieved Paid::Plan instance' do
+      setup do
+        @mock.expects(:get).once.returns(test_response(test_plan))
+        @plan = Paid::Plan.retrieve('plan_id')
+      end
+
+      should 'have the id attribute' do
+        assert_equal(test_plan[:id], @plan.id)
+      end
+
+      should 'have the object attribute' do
+        assert_equal(test_plan[:object], @plan.object)
+      end
+
+      should 'have the created_at attribute' do
+        assert_equal(test_plan[:created_at], @plan.created_at)
+      end
+
+      should 'have the description attribute' do
+        assert_equal(test_plan[:description], @plan.description)
+      end
+
+      should 'have the name attribute' do
+        assert_equal(test_plan[:name], @plan.name)
+      end
+
+      should 'have the interval attribute' do
+        assert_equal(test_plan[:interval], @plan.interval)
+      end
+
+      should 'have the interval_count attribute' do
+        assert_equal(test_plan[:interval_count], @plan.interval_count)
+      end
+
+      should 'have the amount attribute' do
+        assert_equal(test_plan[:amount], @plan.amount)
+      end
+
+    end
+
+    should 'be registered' do
+      assert(APIClass.subclasses.include?(Paid::Plan))
+      assert_equal(Paid::Plan, APIClass.subclass_fetch("plan"))
     end
+
+
   end
 end