recurly 0.4.16 → 2.0.0

data/spec/integration/invoice_spec.rb

@@ -1,86 +0,0 @@
-require 'spec_helper'
-
-module Recurly
-  describe Invoice do
-    # version accounts based on this current files modification dates
-    timestamp = File.mtime(__FILE__).to_i
-
-    def create_sample_charges(account)
-      Factory.create_charge(account.account_code, :amount => 10.00)
-      Factory.create_charge(account.account_code, :amount => 15.00)
-    end
-
-    describe "creating an invoice" do
-      context "with charges" do
-        use_vcr_cassette "invoice/create/#{timestamp}"
-
-        let(:account) { Factory.create_account_with_billing_info("invoice-create-#{timestamp}") }
-        before(:each) do
-          create_sample_charges(account)
-          @invoice = Invoice.create(:account_code => account.account_code)
-        end
-
-        it "should save successfully" do
-          @invoice.total_in_cents.should == 2500
-          @invoice.line_items.length.should == 2
-        end
-      end
-
-      context "without charges" do
-        use_vcr_cassette "invoice/create-no-charges/#{timestamp}"
-
-        let(:account) { Factory.create_account_with_billing_info("invoice-create-no-charges-#{timestamp}") }
-
-        it "should not be created since no charges were posted" do
-          @invoice = Invoice.create(:account_code => account.account_code)
-          @invoice.should_not be_valid
-        end
-      end
-    end
-
-    describe "listing invoices" do
-      use_vcr_cassette "invoice/list/#{timestamp}"
-
-      let(:account) { Factory.create_account_with_billing_info("invoice-list-#{timestamp}") }
-      before(:each) do
-        Factory.create_charge(account.account_code, :amount => 1.00)
-        invoice = Invoice.create(:account_code => account.account_code)
-
-        Factory.create_charge(account.account_code, :amount => 3.00)
-        invoice = Invoice.create(:account_code => account.account_code)
-
-        @invoices = Invoice.list(account.account_code)
-      end
-
-      it "should return the list of invoices" do
-        @invoices.length.should == 2
-      end
-
-      it "should also be available via Account#invoices" do
-        account.invoices.should == @invoices
-      end
-
-    end
-
-    describe "looking up an invoice" do
-      use_vcr_cassette "invoice/lookup/#{timestamp}"
-
-      let(:account) { Factory.create_account_with_billing_info("invoice-lookup-#{timestamp}") }
-      before(:each) do
-        Factory.create_charge(account.account_code, :amount => 15.00)
-        invoice = Invoice.create(:account_code => account.account_code)
-        @invoice = Invoice.lookup(account.account_code, invoice.id)
-      end
-
-      it "should return the invoice" do
-        @invoice.total_in_cents.should == 1500
-        @invoice.line_items.length.should == 1
-      end
-
-      it "should also be available via Account#lookup_invoice" do
-        account.lookup_invoice(@invoice.id).should == @invoice
-      end
-
-    end
-  end
-end

data/spec/integration/plan_spec.rb

@@ -1,87 +0,0 @@
-require 'spec_helper'
-
-module Recurly
-  describe Plan do
-    # version accounts based on this current files modification dates
-    timestamp = File.mtime(__FILE__).to_i
-
-    describe "list all plans" do
-      use_vcr_cassette "plan/all"
-
-      before(:each) do
-        @paid = Factory.paid_plan
-        @trial = Factory.trial_plan
-        @plans = Plan.all
-      end
-
-      it "should return a list result" do
-        @plans.should be_an_instance_of(Array)
-      end
-
-      it "should return the paid plan" do
-        @plans.should include(@paid)
-      end
-
-      it "should return the trial plan" do
-        @plans.should include(@trial)
-      end
-
-    end
-
-    describe "find plan" do
-      use_vcr_cassette 'plan/find'
-      before(:each) do
-        @paid = Factory.paid_plan
-        @trial = Factory.trial_plan
-      end
-
-      it "should return the paid plan" do
-        plan = Plan.find(@paid.plan_code)
-        plan.should_not be_nil
-        plan.should == @paid
-      end
-
-      it "should return the trial plan" do
-        plan = Plan.find(@trial.plan_code)
-        plan.should_not be_nil
-        plan.should == @trial
-      end
-    end
-
-    describe "update a plan" do
-      use_vcr_cassette 'plan/update'
-
-      # grabs a fresh test_plan
-      def test_plan
-        Plan.find("test")
-      end
-
-      # setup test plan
-      before(:each) do
-        begin
-          @test_plan = test_plan
-        rescue ActiveResource::ResourceNotFound => e
-          Plan.new({
-            :plan_code => "test",
-            :name => "Test Plan",
-            :unit_amount_in_cents => 100,
-            :plan_interval_length => 1,
-            :plan_interval_unit => "months",
-            :trial_interval_length => 0,
-            :trial_interval_unit => "months"
-          }).save!
-          @test_plan = test_plan
-        end
-      end
-
-      it "should update the plan" do
-        @test_plan.unit_amount_in_cents = 200
-        @test_plan.save!
-
-        @test_plan = test_plan
-        @test_plan.unit_amount_in_cents.should == 200
-      end
-    end
-
-  end
-end

data/spec/integration/subscription_spec.rb

@@ -1,221 +0,0 @@
-require 'spec_helper'
-
-require 'test/unit'
-require 'active_support/testing/deprecation'
-
-module Recurly
-  describe Subscription do
-    # version accounts based on this current files modification dates
-    timestamp = File.mtime(__FILE__).to_i
-
-    describe "look up a subscription" do
-      use_vcr_cassette "subscription/find/#{timestamp}"
-
-      let(:account){ Factory.create_account("subscription-find-#{timestamp}") }
-
-      before(:each) do
-        Factory.create_subscription(account, :paid)
-      end
-
-      it "should return the subscription" do
-        subscription = Subscription.find(account.account_code)
-        subscription.state.should == "active"
-        subscription.plan.plan_code.should == "paid"
-        subscription.plan_code.should == "paid"
-      end
-    end
-
-    describe "create a new subscription" do
-      use_vcr_cassette "subscription/create/#{timestamp}"
-
-      let(:account){ Factory.create_account("subscription-create-#{timestamp}") }
-
-      before(:each) do
-        @subscription = Factory.create_subscription(account, :paid)
-      end
-
-      it "should create the subscription successfully" do
-        @subscription.should_not be_nil
-      end
-
-      it "should not be canceled" do
-        @subscription.canceled_at.should be_nil
-      end
-
-      it "should be active" do
-        @subscription.state.should == "active"
-      end
-
-      it "should be started" do
-        @subscription.current_period_started_at.should_not be_nil
-      end
-
-    end
-
-    describe "updates and downgrades" do
-
-      context "normal case" do
-        use_vcr_cassette "subscription/change1/#{timestamp}"
-
-        let(:account){ Factory.create_account("subscription-change1-#{timestamp}") }
-
-        before(:each) do
-          Factory.create_subscription(account, :paid)
-          @subscription = Subscription.find(account.account_code)
-
-          @subscription.change('now', :quantity => 2)
-        end
-
-        it "should update the subscription quantity" do
-          Subscription.find(account.account_code).quantity.should == 2
-        end
-      end
-
-      context "when account code is an integer (issue GH-4)" do
-        use_vcr_cassette "subscription/change2/#{timestamp}"
-
-        let(:account){ Factory.create_account(timestamp) }
-
-        before(:each) do
-          Factory.create_subscription(account, :paid)
-          @subscription = Subscription.find(account.account_code)
-
-          @subscription.id = account.account_code.to_i
-          @subscription.change('now', :quantity => 2)
-        end
-
-        it "should update the subscription quantity" do
-          Subscription.find(account.account_code).quantity.should == 2
-        end
-      end
-    end
-
-    describe "reactivate a subscription" do
-      use_vcr_cassette "subscription/reactivate/#{timestamp}"
-
-      let(:account){ Factory.create_account("subscription-reactivate-#{timestamp}") }
-      before(:each) do
-        Factory.create_subscription(account, :paid)
-        @subscription = Subscription.find(account.account_code)
-        @subscription.cancel
-
-        Subscription.reactivate(account.account_code)
-      end
-
-      it "should mark the subscription as active" do
-        subscription = Subscription.find(account.account_code)
-        subscription.state.should == "active"
-      end
-
-    end
-
-    describe "cancel a subscription" do
-      context "without account_code" do
-
-        use_vcr_cassette "subscription/cancel/#{timestamp}"
-
-        let(:account){ Factory.create_account("subscription-cancel-#{timestamp}") }
-        before(:each) do
-          Factory.create_subscription(account, :paid)
-          @subscription = Subscription.find(account.account_code)
-
-          # cancel subscription
-          @subscription.cancel
-        end
-
-        it "should mark the subscription state as canceled" do
-          Subscription.find(account.account_code).state.should == "canceled"
-        end
-
-        it "should mark the subscription canceled_at" do
-          Subscription.find(account.account_code).canceled_at.should_not be_nil
-        end
-
-      end
-
-      context "with account_code (backward compat)" do
-        use_vcr_cassette "subscription/cancel-with-code/#{timestamp}"
-
-        include ActiveSupport::Testing::Deprecation
-
-        # ghetto workaround for rspec2 (till i figure out how to use test/unit helpers within rspec)
-        def assert(value, msg = nil)
-          raise "#{value} should have been true" unless value
-        end
-
-        let(:account){ Factory.create_account("subscription-cancel-with-code-#{timestamp}") }
-        before(:each) do
-          Factory.create_subscription(account, :paid)
-          @subscription = Subscription.find(account.account_code)
-
-          assert_deprecated("Calling Recurly::Subscription#cancel with an account_code has been deprecated. Use the static method Recurly::Subscription.cancel(account_code) instead") do
-            # cancel subscription
-            @subscription.cancel(account.account_code)
-          end
-        end
-
-        it "should mark the subscription state as canceled" do
-          Subscription.find(account.account_code).state.should == "canceled"
-          Subscription.find(account.account_code).canceled_at.should_not be_nil
-        end
-      end
-    end
-
-    describe "refund a subscription" do
-      context "full refund" do
-        use_vcr_cassette "subscription/refund-full/#{timestamp}"
-
-        let(:account){ Factory.create_account("subscription-refund-full-#{timestamp}") }
-
-        before(:each) do
-          Factory.create_subscription(account, :paid)
-          @subscription = Subscription.find(account.account_code)
-        end
-
-        it "should remove the subscription entry and post a full refund" do
-          @subscription.refund(:full)
-          expect {
-            Subscription.find(account.account_code)
-          }.to raise_error(ActiveResource::ResourceNotFound)
-        end
-      end
-
-      context "partial refund" do
-        use_vcr_cassette "subscription/refund-partial/#{timestamp}"
-
-        let(:account){ Factory.create_account("subscription-refund-partial-#{timestamp}") }
-
-        before(:each) do
-          Factory.create_subscription(account, :paid)
-          @subscription = Subscription.find(account.account_code)
-        end
-
-        it "should remove the subscription entry and post a partial refund" do
-          @subscription.refund(:partial)
-          expect {
-            Subscription.find(account.account_code)
-          }.to raise_error(ActiveResource::ResourceNotFound)
-        end
-      end
-
-      context "no refund" do
-        use_vcr_cassette "subscription/refund-none/#{timestamp}"
-
-        let(:account){ Factory.create_account("subscription-refund-none-#{timestamp}") }
-
-        before(:each) do
-          Factory.create_subscription(account, :paid)
-          @subscription = Subscription.find(account.account_code)
-        end
-
-        it "should remove the subscription entry and not post a refund" do
-          @subscription.refund(:none)
-          expect {
-            Subscription.find(account.account_code)
-          }.to raise_error(ActiveResource::ResourceNotFound)
-        end
-      end
-
-    end
-  end
-end

data/spec/integration/transaction_spec.rb

@@ -1,154 +0,0 @@
-require 'spec_helper'
-
-module Recurly
-  describe Transaction do
-    # version accounts based on this current files modification dates
-    timestamp = File.mtime(__FILE__).to_i
-
-    describe "create new transaction" do
-      context "on an new account" do
-        use_vcr_cassette "transaction/create-no-account/#{timestamp}"
-        let(:account_code) { "transaction-create-with-accout-#{timestamp}" }
-
-        before(:each) do
-          @transaction = Factory.create_full_transaction account_code,
-                                                          :amount_in_cents => 700,
-                                                          :description => "setup fee of 7 dollarz"
-        end
-
-        it "should save successfully" do
-          @transaction.status.should == "success"
-          @transaction.errors.should be_empty
-        end
-      end
-
-      context "with an existing account" do
-        use_vcr_cassette "transaction/create-with-account/#{timestamp}"
-        let(:account) { Factory.create_account_with_billing_info("transaction-create-with-account-#{timestamp}") }
-
-        before(:each) do
-          @transaction = Factory.create_transaction account.account_code,
-                                                     :amount_in_cents => 700,
-                                                     :description => "test transaction for $7"
-        end
-
-        it "should save successfully" do
-          @transaction.status.should == "success"
-          @transaction.errors.should be_empty
-        end
-      end
-    end
-
-    describe "find all transactions" do
-      use_vcr_cassette "transaction/all/#{timestamp}"
-
-      before(:each) do
-        @transactions = Transaction.all
-      end
-
-      it "should be successful" do
-        @transactions.should be_an_instance_of(Array)
-      end
-    end
-
-    describe "list account transactions" do
-      context "initial void transaction" do
-        use_vcr_cassette "transaction/list-initial/#{timestamp}"
-        let(:account) { Factory.create_account_with_billing_info("transaction-list-initial-#{timestamp}") }
-
-        before(:each) do
-          @transactions = Transaction.list_for_account(account.account_code)
-        end
-
-        it "should create one transaction after registering" do
-          @transactions.count.should eql(1)
-        end
-
-        it "should be in void state" do
-          @transactions.first.amount_in_cents.should == 0
-          @transactions.first.status.should == 'success'
-        end
-      end
-
-      context "with transactions" do
-        use_vcr_cassette "transaction/list-filled/#{timestamp}"
-        let(:account) { Factory.create_account_with_billing_info("transaction-list-filled-#{timestamp}") }
-
-        before(:each) do
-          Factory.create_transaction account.account_code, :amount_in_cents => 100, :description => "one"
-          Factory.create_transaction account.account_code, :amount_in_cents => 200, :description => "two"
-          Factory.create_transaction account.account_code, :amount_in_cents => 300, :description => "three"
-
-          @successful_transactions = Transaction.list_for_account(account.account_code, :success)
-          @total_transactions = Transaction.list_for_account(account.account_code)
-        end
-
-        it "should return a list of transactions made on the account" do
-          # one authorization and three transactions
-          @successful_transactions.length.should == 4
-          @total_transactions.length.should == 4
-        end
-
-        it "should also be available via Account#transactions" do
-          account.transactions(:success).should == @successful_transactions
-        end
-
-      end
-    end
-
-    describe "lookup account transaction" do
-      use_vcr_cassette "transaction/lookup/#{timestamp}"
-      let(:account) { Factory.create_account_with_billing_info("transaction-lookup-#{timestamp}") }
-
-      before(:each) do
-        t1 = Factory.create_transaction account.account_code, :amount_in_cents => 100, :description => "one"
-        t2 = Factory.create_transaction account.account_code, :amount_in_cents => 200, :description => "two"
-        t3 = Factory.create_transaction account.account_code, :amount_in_cents => 300, :description => "three"
-
-        @transaction1 = Transaction.lookup(account.account_code, t1.id)
-        @transaction2 = Transaction.lookup(account.account_code, t2.id)
-        @transaction3 = Transaction.lookup(account.account_code, t3.id)
-      end
-
-      it "should the transaction details" do
-        @transaction2.amount_in_cents.should == 200
-      end
-
-      it "should also be available via Account#lookup_transaction" do
-        account.lookup_transaction(@transaction3.id).should == @transaction3
-      end
-    end
-
-    describe "void a transaction" do
-      use_vcr_cassette "transaction/void/#{timestamp}"
-      let(:account) { Factory.create_account_with_billing_info("transaction-void-#{timestamp}") }
-
-      before(:each) do
-        @transaction = Factory.create_transaction account.account_code, :amount_in_cents => 100, :description => "one"
-      end
-
-      it "should void a transaction" do
-        @transaction.void
-        Transaction.list(:voided).should include(@transaction)
-      end
-    end
-
-    describe "refund a transaction" do
-      use_vcr_cassette "transaction/refund/#{timestamp}"
-      let(:account) { Factory.create_account_with_billing_info("transaction-refund-#{timestamp}") }
-
-      before(:each) do
-        @transaction = Factory.create_transaction account.account_code, :amount_in_cents => 1000, :description => "one"
-      end
-
-      it "should refund the transaction" do
-        @transaction.refund(1000)
-
-        pending "not showing up in the refunds list for some reason..."
-        Transaction.list(:refunds).map(&:id).should include(@transaction.id)
-      end
-    end
-
-
-  end
-end