pin_up 1.3.4 → 1.4.0

data/spec/plan_spec.rb

@@ -0,0 +1,189 @@
+require 'spec_helper'
+
+describe 'Plan', :vcr, class: Pin::Plan do
+  let(:time) { Time.now.iso8601(4) }
+  let(:plan) {
+    { name: "Plan#{time}",
+      amount: '1000',
+      currency: 'AUD',
+      interval: 30,
+      interval_unit: 'day',
+      setup_amount: 0,
+      trial_amount: 0,
+      trial_interval: 7,
+      trial_interval_unit: 'day' }
+  }
+
+  let(:plan_2) {
+    { name: "Subscription#{time}",
+     amount: '1000',
+     currency: 'AUD',
+     interval: 1,
+     interval_unit: 'day',
+     setup_amount: 27900,
+     trial_amount: 0,
+     trial_interval: '',
+     trial_interval_unit: '' }
+  }
+
+  let(:plan_2_token) {
+    Pin::Plan.create(plan_2)['token']
+  }
+
+  let(:plan_token) {
+    Pin::Plan.create(plan)['token']
+  }
+
+  let(:card_1) {
+    { number: '5520000000000000',
+     expiry_month: '12',
+     expiry_year: '2025',
+     cvc: '123',
+     name: 'Roland Robot',
+     address_line1: '123 Fake Street',
+     address_city: 'Melbourne',
+     address_postcode: '1234',
+     address_state: 'Vic',
+     address_country: 'Australia' }
+  }
+
+  let(:card_2) {
+    { number: '4200000000000000',
+     expiry_month: '12',
+     expiry_year: '2020',
+     cvc: '111',
+     name: 'Roland TestRobot',
+     address_line1: '123 Fake Road',
+     address_line2: '',
+     address_city: 'Melbourne',
+     address_postcode: '1223',
+     address_state: 'Vic',
+     address_country: 'AU' }
+  }
+
+  let(:customer) {
+    Pin::Customer.create('email@example.com', card_1)
+  }
+
+  let(:customer_token) {
+    customer['token']
+  }
+
+  let(:card_2_token) {
+    Pin::Card.create(card_2)['token']
+  }
+
+  let(:link_card_2_to_customer) {
+    Pin::Customer.create_card(customer_token, card_2_token)
+  }
+
+  let(:subscription) {
+    { plan_token: plan_token,
+      customer_token: customer_token,
+      include_setup_fee: false }
+  }
+
+  let(:subscription_token) {
+    Pin::Subscription.create(subscription)['token']
+  }
+
+  let(:subscription_2) {
+    { plan_token: plan_2_token,
+     customer_token: customer_token,
+     include_setup_fee: false }
+  }
+
+  let(:subscription_2_token) {
+    Pin::Subscription.create(subscription_2)['token']
+  }
+
+  before(:each) do
+    Pin::Base.new(ENV['PIN_SECRET'], :test)
+  end
+
+  it 'should create a new plan and return its details' do
+    expect(Pin::Plan.create(plan))
+      .to match a_hash_including("name"=>match(/(Plan)/),
+                                 "token"=>match(/(plan)[_]([\w-]{22})/),
+                                 "amount"=>1000,
+                                 "currency"=>"AUD",
+                                 "setup_amount"=>0,
+                                 "trial_amount"=>0,
+                                 "interval"=>30,
+                                 "interval_unit"=>"day",
+                                 "trial_interval"=>7,
+                                 "trial_interval_unit"=>"day",
+                                 "expiration_interval"=>0,
+                                 "expiration_interval_unit"=>"",
+                                 "active_subscriptions"=>0,
+                                 "trial_subscriptions"=>0)
+  end
+
+  it 'should return a paginated list of all plans' do
+    expect(Pin::Plan.all).to_not eq []
+  end
+
+  it 'should go to a specific page when page paramater is passed' do
+    request = Pin::Plan.all(2, true)
+    expect(request[:pagination]['current']).to eq 2
+  end
+
+  it 'should list customers on a page given a page' do
+    request = Pin::Plan.all(1, true)
+    expect(request[:response]).to_not eq []
+  end
+
+  it 'should return pagination if true is passed for pagination' do
+    request = Pin::Plan.all(1, true)
+    request[:pagination].key?(%W('current previous next per_page pages count))
+  end
+
+  it 'should return the details of a specified plan given a token' do
+    expect(Pin::Plan.find(plan_token)['token']).to eq(plan_token)
+  end
+
+  it 'should update the name of a specified plan given a token' do
+    expect(Pin::Plan.update(plan_token, { name: "Updated" })['name'])
+      .to eq("Updated")
+    Pin::Plan.delete(plan_token) # Cleanup as Plan names must be unique
+  end
+
+  it 'should delete a plan with zero subscriptions given a token' do
+    expect(Pin::Plan.delete(plan_token).code).to eq 204
+  end
+
+  it 'should delete a plan and all de-activated subscriptions' do
+    subscription_2_token # attach a subscription to the plan
+    Pin::Subscription.delete(subscription_2_token) # deactivate subscription
+    expect(Pin::Plan.delete(plan_token).code).to eq 204
+  end
+
+  it 'should create a new subscription to the specified plan' do
+    plan = { object: Pin::Plan.create_subscription(plan_token, customer_token),
+             created_at: Time.now }
+    expect(plan[:object])
+      .to match a_hash_including("state"=>"trial",
+                                 "token"=>match(/(sub)[_]([\w-]{22})/),
+                                 "plan_token"=>"#{plan_token}",
+                                 "customer_token"=>"#{customer_token}",
+                                 "card_token"=> nil)
+  end
+
+  it 'should create new plan & linked subscription using a new credit card (billing card_2)' do
+    link_card_2_to_customer
+    expect(Pin::Plan.create_subscription(plan_2_token, customer_token, card_2_token))
+      .to match a_hash_including("state"=>"active",
+                                 "token"=>match(/(sub)[_]([\w-]{22})/),
+                                 "plan_token"=>"#{plan_2_token}",
+                                 "customer_token"=>"#{customer_token}",
+                                 "card_token"=>"#{card_2_token}")
+    charges = Pin::Customer.charges(customer_token)
+    expect(charges[0]['card']['token']).to eq(card_2_token)
+  end
+
+  it 'should return a paginated list of subscriptions for a plan' do
+    subscription_token # attach a subscription to the plan
+    subscription_list = Pin::Plan.subscriptions(plan_token)
+    expect(subscription_list[0]['token']).to eq(subscription_token)
+  end
+end

data/spec/recipients_spec.rb

@@ -1,13 +1,22 @@
 require 'spec_helper'
 
 describe Pin::Recipient, :vcr do
+  let(:recipient_details) {
+    { email: 'hello@example.com',
+      name: 'Roland Robot',
+      bank_account: {
+        name: 'Roland Robot',
+        bsb: '123456',
+        number: 987654321
+      } }
+  }
+
   before(:each) do
     Pin::Base.new(ENV['PIN_SECRET'], :test)
   end
 
   it 'should create a new recipient' do
-    options = { email: 'hello@example.com', name: 'Roland Robot', bank_account: { name: 'Roland Robot', bsb: '123456', number: 987654321 } }
-    expect(Pin::Recipient.create(options)['token']).to match(/^[a-z]{2}[_]/)
+    expect(Pin::Recipient.create(recipient_details)['token']).to match(/^[a-z]{2}[_]/)
   end
 
   it 'lists out recipients' do
@@ -15,22 +24,18 @@ describe Pin::Recipient, :vcr do
   end
 
   it 'gets a recipient given a token' do
-    options = { email: 'hello@example.com', name: 'Roland Robot', bank_account: { name: 'Roland Robot', bsb: '123456', number: 987654321 } }
-    recipient = Pin::Recipient.create(options)
+    recipient = Pin::Recipient.create(recipient_details)
     expect(Pin::Recipient.find(recipient['token'])['token']).to eq recipient['token']
   end
 
   it 'updates the given details of a recipient and returns its details' do
-    options = { email: 'hello@example.com', name: 'Roland Robot', bank_account: { name: 'Roland Robot', bsb: '123456', number: 987654321 } }
-    recipient = Pin::Recipient.create(options)
+    recipient = Pin::Recipient.create(recipient_details)
     updated_options = { email: 'new_email@example.com' }
     expect(Pin::Recipient.update(recipient['token'], updated_options)['email']).to eq 'new_email@example.com'
   end
 
   it 'returns a list of recipients transfers' do
-    options = { email: 'hello@example.com', name: 'Roland Robot', bank_account: { name: 'Roland Robot', bsb: '123456', number: 987654321 } }
-    recipient = Pin::Recipient.create(options)
-
+    recipient = Pin::Recipient.create(recipient_details)
     transfer = { amount: 400, currency: 'AUD', description: 'Pay day', recipient: recipient['token'] }
     Pin::Transfer.create(transfer)
 

data/spec/refund_spec.rb

@@ -1,27 +1,61 @@
 require 'spec_helper'
 
 describe 'Refund', :vcr, class: Pin::Refund do
+  let(:card_1) {
+    { number: '5520000000000000',
+     expiry_month: '12',
+     expiry_year: '2025',
+     cvc: '123',
+     name: 'Roland Robot',
+     address_line1: '123 Fake Street',
+     address_city: 'Melbourne',
+     address_postcode: '1234',
+     address_state: 'Vic',
+     address_country: 'Australia' }
+  }
+
+  let(:customer_token) {
+    Pin::Customer.create('email@example.com', card_1)['token']
+  }
+
+  let(:charge) {
+    Pin::Charges.create(email: 'email@example.com',
+                        description: 'Charge description',
+                        amount: '500',
+                        currency: 'AUD',
+                        number: '5520000000000000',
+                        ip_address: '203.192.1.172',
+                        customer_token: customer_token)
+  }
+
+  let(:no_refund_charge) {
+    Pin::Charges.create(email: 'email@example.com',
+                        description: 'Charge description',
+                        amount: '500',
+                        currency: 'AUD',
+                        number: '5520000000000000',
+                        ip_address: '203.192.1.172',
+                        customer_token: customer_token)
+  }
+
   before(:each) do
     Pin::Base.new(ENV['PIN_SECRET'], :test)
+    Pin::Refund.create(charge['token'], '400')
   end
 
   it 'should list all refunds made to a charge given a token' do
-    expect(Pin::Refund.find('ch_5q0DiDnHZIggDfVDqcP-jQ')[0]['token']).to match(/^[a-z]{2}[_]/)
+    expect(Pin::Refund.find(charge['token'])[0]['token']).to match(/^[a-z]{2}[_]/)
   end
 
   it 'should return nothing if looking for a charge without a refund' do
-    expect(Pin::Refund.find('ch_Dsd62Ey5Hmd3B1dDHNKYvA')).to eq []
+    expect(Pin::Refund.find(no_refund_charge['token'])).to eq []
   end
 
   it 'should return a page of refunds given a page and token' do
-    expect(Pin::Refund.find('ch_5q0DiDnHZIggDfVDqcP-jQ', 1, true)[:response]).to_not eq []
+    expect(Pin::Refund.find(charge['token'], 1, true)[:response]).to_not eq []
   end
 
   it 'should create a refund for a given amount and charge' do
-    customer = Pin::Customer.create('email@example.com', number: '5520000000000000', expiry_month: '12', expiry_year: Time.now.year+1, cvc: '123', name: 'Roland Robot', address_line1: '123 fake street', address_city: 'Melbourne', address_postcode: '1234', address_state: 'Vic', address_country: 'Australia')
-    options = { email: 'email@example.com', description: 'A new charge from testing Pin gem', amount: '400', currency: 'AUD', ip_address: '127.0.0.1', customer_token: customer['token']}
-    @charge = Pin::Charges.create(options)
-    expect(Pin::Refund.create(@charge['token'], '400')['amount']).to eq 400
+    expect(Pin::Refund.find(charge['token'])[0]['amount']).to eq 400
   end
-
 end

data/spec/spec_helper.rb

@@ -1,7 +1,5 @@
-require 'codeclimate-test-reporter'
 require 'simplecov'
 
-CodeClimate::TestReporter.start
 SimpleCov.start
 
 require 'rubygems'
@@ -25,7 +23,9 @@ RSpec.configure do |config|
           .metadata[:full_description]
           .split(/\s+/, 2).join('/')
           .gsub(/[^\w\/]+/, '_')
-    VCR.use_cassette(name) { example.call }
+    valid_keys = %w[record match_on_requests_on]
+    options = example.metadata.select { |key,_| valid_keys.include? key }
+    VCR.use_cassette(name, record: :all) { example.call }
   end
 end
 
@@ -33,5 +33,4 @@ VCR.configure do |c|
   c.cassette_library_dir = 'spec/vcr'
   c.hook_into :webmock
   c.allow_http_connections_when_no_cassette = true
-  c.filter_sensitive_data('<key>') { ENV['PIN_SECRET'] }
 end

data/spec/subscription_spec.rb

@@ -0,0 +1,201 @@
+require 'spec_helper'
+
+describe 'Subscription', :vcr, class: Pin::Subscription do
+  let(:time) { Time.now.iso8601(4) }
+  let(:plan_1) {
+    { name: "Subscription#{time}",
+      amount: '1000',
+      currency: 'AUD',
+      interval: 30,
+      interval_unit: 'day',
+      setup_amount: 0,
+      trial_amount: 0,
+      trial_interval: 7,
+      trial_interval_unit: 'day' }
+  }
+
+  let(:plan_2) {
+    { name: "Subscription#{time}",
+     amount: '1000',
+     currency: 'AUD',
+     interval: 30,
+     interval_unit: 'day',
+     setup_amount: 27900,
+     trial_amount: 0,
+     trial_interval: '',
+     trial_interval_unit: '' }
+  }
+
+  let(:plan_1_token) {
+    Pin::Plan.create(plan_1)['token']
+  }
+
+  let(:plan_2_token) {
+    Pin::Plan.create(plan_2)['token']
+  }
+
+  let(:card_1) {
+    { number: '5520000000000000',
+     expiry_month: '12',
+     expiry_year: '2025',
+     cvc: '123',
+     name: 'Roland Robot',
+     address_line1: '123 Fake Street',
+     address_city: 'Melbourne',
+     address_postcode: '1234',
+     address_state: 'Vic',
+     address_country: 'Australia' }
+  }
+
+  let(:card_2) {
+    { number: '4200000000000000',
+     expiry_month: '12',
+     expiry_year: '2020',
+     cvc: '111',
+     name: 'Roland TestRobot',
+     address_line1: '123 Fake Road',
+     address_line2: '',
+     address_city: 'Melbourne',
+     address_postcode: '1223',
+     address_state: 'Vic',
+     address_country: 'AU' }
+  }
+
+  let(:customer) {
+    Pin::Customer.create('email@example.com', card_1)
+  }
+
+  let(:customer_token) {
+    customer['token']
+  }
+
+  let(:card_2_token) {
+    Pin::Card.create(card_2)['token']
+  }
+
+  let(:link_card_2_to_customer) {
+    Pin::Customer.create_card(customer_token, card_2_token)
+  }
+
+  let(:subscription_1) {
+    { plan_token: plan_1_token,
+      customer_token: customer_token,
+      include_setup_fee: false }
+  }
+
+  let(:subscription_2) {
+    link_card_2_to_customer
+    { plan_token: plan_2_token,
+      customer_token: customer_token,
+      card_token: card_2_token,
+      include_setup_fee: true }
+  }
+
+  let(:subscription_1_token) {
+    Pin::Subscription.create(subscription_1)['token']
+  }
+
+  let(:subscription_2_token) {
+    Pin::Subscription.create(subscription_2)['token']
+  }
+
+  before(:each) do
+    Pin::Base.new(ENV['PIN_SECRET'], :test)
+  end
+
+  it 'should create a new subscription billing default card and return its details' do
+    expect(Pin::Subscription.create(subscription_1))
+      .to match a_hash_including("state"=>"trial",
+                                 "cancelled_at"=>nil,
+                                 "token"=>match(/(sub)[_]([\w-]{22})/),
+                                 "plan_token"=>"#{plan_1_token}",
+                                 "customer_token"=>"#{customer_token}",
+                                 "card_token"=> nil)
+  end
+
+  it 'should create a new subscription billing card_2' do
+    expect(Pin::Subscription.create(subscription_2))
+      .to match a_hash_including("state"=>"active",
+                                 "token"=>match(/(sub)[_]([\w-]{22})/),
+                                 "plan_token"=>"#{plan_2_token}",
+                                 "customer_token"=>"#{customer_token}",
+                                 "card_token"=>"#{card_2_token}")
+    charges = Pin::Customer.charges(customer_token)
+    expect(charges[0]['card']['token']).to eq(card_2_token)
+  end
+
+  it 'should create a new subscription with setup fee, charge equals amount + setup fee' do
+    Pin::Subscription.create(subscription_2)
+    charges = Pin::Customer.charges(customer_token)
+    expect(charges[0]['amount'].to_i).to eq (plan_2[:setup_amount].to_i + plan_2[:amount].to_i)
+  end
+
+  it 'should list all subscriptions' do
+    expect(Pin::Subscription.all).to_not eq []
+  end
+
+  it 'should go to a specific page when page paramater is passed' do
+    request = Pin::Subscription.all(20, true)
+    expect(request[:pagination]['current']).to eq 20
+  end
+
+  it 'should list subscriptions on a page given a page' do
+    request = Pin::Subscription.all(1, true)
+    expect(request[:response]).to_not eq []
+  end
+
+  it 'should return pagination if true is passed for pagination' do
+    request = Pin::Subscription.all(1, true)
+    request[:pagination].keys.include?(%W('current previous next per_page pages count))
+  end
+
+  it 'should not list subscriptions for a given page if there are no subscriptions' do
+    request = Pin::Subscription.all(25, true)
+    expect(request[:response]).to eq []
+  end
+
+  it 'should show a subscription given a token' do
+    expect(Pin::Subscription.find(subscription_2_token)['token']).to eq(subscription_2_token)
+  end
+
+  it 'should update the subscription charged card given a subscription & card token' do
+    Pin::Customer.create_card(customer_token, card_2_token) # register card to customer
+    sub = Pin::Subscription.update(subscription_1_token, card_2_token)
+    expect(sub['card_token']).to eq card_2_token
+    primary_customer_card_token = customer['card']['token']
+    expect(primary_customer_card_token).to_not eq card_2_token
+  end
+
+  it 'should delete(deactivate) a subscription given a token' do
+    expect(Pin::Subscription.delete(subscription_2_token)['state']).to eq('cancelling')
+  end
+
+  it 'should reactivate the subscription given a token' do
+    deactivated = Pin::Subscription.delete(subscription_2_token)
+    expect(Pin::Subscription.reactivate(deactivated['token'])['state']).to eq('active')
+  end
+
+  it 'should fetch history for a subscription given a token' do
+    expect(Pin::Subscription.history(subscription_2_token)).to_not eq []
+  end
+
+  it 'should go to a specific page when page parameter is passed' do
+    request = Pin::Subscription.history(subscription_2_token, 20, true)
+    expect(request[:pagination]['current']).to eq 20
+  end
+
+  it 'should list subscriptions on a page given a page' do
+    request = Pin::Subscription.history(subscription_2_token, 1, true)
+    expect(request[:response]).to_not eq []
+  end
+
+  it 'should return pagination if true is passed for pagination' do
+    request = Pin::Subscription.history(subscription_2_token, 1, true)
+    request[:pagination].key?(%W('current previous next per_page pages count))
+  end
+
+  it 'should not list subscriptions for a given page if there are no subscriptions' do
+    request = Pin::Subscription.history(subscription_2_token, 25, true)
+    expect(request[:response]).to eq []
+  end
+end