jackpot 0.0.3

data/spec/helpers/jackpot/customers_helper_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Jackpot::CustomersHelper do
+  describe "#subscription_name_when_available" do
+    it "returns '-' when there is no subscription available" do
+      customer = FactoryGirl.build(:customer)
+      helper.subscription_name_when_available(customer).should == "-"
+    end 
+
+    it "returns the subscription name when it is available" do
+      customer = FactoryGirl.build(:customer_with_subscription)
+      helper.subscription_name_when_available(customer).should == "Gold"
+    end 
+
+  end 
+end

data/spec/helpers/jackpot/subscriptions_helper_spec.rb

@@ -0,0 +1,4 @@
+require 'spec_helper'
+
+describe Jackpot::SubscriptionsHelper do
+end

data/spec/lib/cron_spec.rb

@@ -0,0 +1,39 @@
+require './lib/jackpot/cron'
+require './lib/jackpot/errors'
+require 'rspec'
+
+describe Jackpot::Cron do
+  let(:logger) { stub(:info => true) } 
+
+  it "finds every overdue customer and bills their cards" do
+    customers = [ mock_customer(true), mock_customer(true) ]
+    customer_storage = stub(:overdue => customers) 
+    cron = Jackpot::Cron.new(customer_storage, logger)
+    cron.run
+  end 
+
+
+  context "when something has failed" do
+
+    it "logs the execption" do
+      customers = [ mock_customer(true), failed_customer ]
+      customer_storage = stub(:overdue => customers) 
+      logger.should_receive(:error)
+      cron = Jackpot::Cron.new(customer_storage, logger)
+      cron.run
+    end 
+  end 
+
+end 
+
+def mock_customer(return_value)
+  customer = stub(:pay_subscription => return_value)
+  customer.should_receive(:pay_subscription).and_return(return_value)
+  customer
+end 
+
+def failed_customer
+  customer = Object.new
+  customer.stub(:pay_subscription).and_raise(Jackpot::Error.new)
+  customer
+end 

data/spec/lib/factory_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe Jackpot::Factory do
+
+  it "creates jackpot gateways" do
+    factory = Jackpot::Factory.new("type"=> :braintree) 
+    factory.build.should be_a(Jackpot::Gateway)
+  end 
+
+  it "raises an error upon unsupported gateways" do
+    factory = Jackpot::Factory.new("type"=> :notexistinggatway) 
+    expect { factory.build }.to raise_error(Jackpot::Errors::InvalidGateway)
+  end 
+
+  context "supported gateways" do
+    before do
+      ActiveMerchant::Billing::BraintreeGateway
+                                          .stub(:new).with(:login    => 'login',
+                                               :password => 'password',
+                                               :mode     => 'test').and_return('braintree')
+
+      ActiveMerchant::Billing::BogusGateway.stub(:new).and_return('bogus')
+    
+    end 
+   let(:opts) { { :type => :braintree, :login => 'login', :password => 'password', :mode => 'test' } }
+
+    it "supports braintree" do
+      factory = Jackpot::Factory.new(opts)
+      Jackpot::Gateway.should_receive(:new).with('braintree')
+      factory.build
+    end 
+
+    it "supports bogus for testing" do
+      factory = Jackpot::Factory.new(:type => :bogus)
+      Jackpot::Gateway.should_receive(:new).with('bogus')
+      factory.build
+    end 
+  end 
+
+end 

data/spec/models/jackpot/card_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Jackpot::Card do
+
+  describe "#new" do
+    subject { Jackpot::Card.new(credit_card_hash) }  
+
+    it { subject.masquerade_number.should   == 'XXXX-XXXX-XXXX-4242' } 
+    it { subject.number.should              == '4242424242424242'    } 
+    it { subject.month.should               == 1                     } 
+    it { subject.year.should                == next_year             } 
+    it { subject.first_name.should          == "John"                } 
+    it { subject.last_name.should           == "Doe"                 } 
+    it { subject.verification_value.should  == 123                   } 
+  end 
+
+
+  describe ".valid?" do
+    it { Jackpot::Card.new(credit_card_hash('987', :year => '2000')).should_not be_valid }
+    it { Jackpot::Card.new(credit_card_hash).should be_valid }
+  end 
+
+end 

data/spec/models/jackpot/customer_spec.rb

@@ -0,0 +1,140 @@
+require 'spec_helper'
+require 'timecop'
+
+describe Jackpot::Customer do
+  it { should     belong_to                :subscription             } 
+  it { should     have_many(:payments).through(:subscription)        }
+
+  it { should_not allow_mass_assignment_of :credit_card_number       } 
+  it { should_not allow_mass_assignment_of :credit_card_expiry_year  } 
+  it { should_not allow_mass_assignment_of :credit_card_expiry_month } 
+  it { should_not allow_mass_assignment_of :credit_card_token        } 
+
+  let(:customer)      { Jackpot::Customer.new } 
+  let(:card)          { Jackpot::Card.new credit_card_hash } 
+  let(:invalid_card)  { Jackpot::Card.new credit_card_hash('9', :year => '2000') } 
+
+  describe ".expiration_date" , :vcr => { :cassette_name => "jackpot/customer_expiration_date" } do
+    it "should return this card expiration date" do
+      customer.update_credit_card(card)
+      customer.expiration_date.should == "1/#{next_year}"
+    end 
+  end 
+
+
+  describe ".overdue" do
+    before do
+      Timecop.freeze(Date.today) do
+        @today       = Factory(:customer, :good_until => Date.today)
+        @tomorrow    = Factory(:customer, :good_until => Date.tomorrow)
+        @yesterday   = Factory(:customer, :good_until => Date.yesterday)
+      end 
+    end 
+    
+    subject { Jackpot::Customer.overdue} 
+
+    it { subject.should     include @yesterday } 
+    it { subject.should_not include @tomorrow  } 
+    it { subject.should_not include @today     } 
+    
+  end 
+
+  describe ".due_in" do
+    before do
+      Timecop.freeze(Date.today) do
+        @next_week    = Factory(:customer, :good_until => 1.week.from_now)
+        @thirty_days  = Factory(:customer, :good_until => 30.days.from_now)
+        @two_days     = Factory(:customer, :good_until => 2.days.from_now)
+        @tomorrow     = Factory(:customer, :good_until => Date.tomorrow)
+      end 
+    end 
+
+    context "two days" do 
+      subject { Jackpot::Customer.due_in 2} 
+
+      it { subject.should     include @tomorrow    } 
+      it { subject.should     include @two_days    } 
+      it { subject.should_not include @thirty_days } 
+      it { subject.should_not include @next_week   } 
+    end 
+      
+  end 
+
+
+  describe ".pay_subscription" do 
+    let(:customer)                    { Factory(:customer_with_subscription, 
+                                                :credit_card_token => '42') }
+
+    let(:customer_with_no_card_saved) { Factory(:customer_with_subscription) } 
+
+    it "fetches charges this customer subscription using his/hers credit card token" do
+      customer.subscription.should_receive(:charge).with(customer).and_return(true)
+      customer.pay_subscription
+    end
+
+    it "sets this customer as not due until the next billing period" do
+      customer.subscription.stub(:charge).with(customer).and_return(true)
+      customer.pay_subscription
+
+      retrieved_customer = Jackpot::Customer.find(customer)
+      retrieved_customer.good_until.should == Date.today + 1.month
+    end 
+    it { expect { customer_with_no_card_saved.pay_subscription }.to raise_error(Jackpot::Errors::CustomerHasNoCardSaved) }
+  end 
+
+  describe ".update_credit_card_number" do
+
+    context "when card is invalid" do
+      it "raises invalid card exception" do
+        expect { customer.update_credit_card(invalid_card)}.to raise_error(Jackpot::Errors::CardIsInvalid)
+      end 
+
+      it "shouldn't be persisted" do
+        expect { customer.reload }.to raise_error(ActiveRecord::RecordNotFound)
+      end 
+
+    end 
+
+    context "when card is valid", :vcr => { :cassette_name => "jackpot/customer/updatecard" } do
+      before(:each) do 
+        customer.update_credit_card(card)
+      end 
+
+      it "should masquerade the card number" do
+        customer.credit_card_number.should                == 'XXXX-XXXX-XXXX-4242'
+      end 
+
+      it { customer.credit_card_expiry_month.should       == 1          } 
+      it { customer.credit_card_expiry_year.should        == next_year  } 
+
+      context "when persisting" do
+
+        let(:retrieved_customer) { Jackpot::Customer.find customer } 
+
+        it "should store this card at the gateway" do
+          # Check corresponding VCR for this magical number 
+          retrieved_customer.credit_card_token.should == '1979016654'
+        end 
+
+        it "should persist the card information" do 
+          retrieved_customer.credit_card_number.should == 'XXXX-XXXX-XXXX-4242'
+        end 
+
+        it "should persist in the database the ONLY last four digits" do
+          retrieved_customer.credit_card_number.should == 'XXXX-XXXX-XXXX-4242'
+        end 
+
+        it "should NEVER persist in the database the actual card number" do
+          retrieved_customer.credit_card_number.should_not  == credit_card_hash[:number]
+        end 
+
+        it "should NEVER persist in the database the verification value" do 
+          retrieved_customer.credit_card_verification_value.should_not == 123       
+          retrieved_customer.credit_card_verification_value.should be_nil
+        end
+
+      end 
+    end
+  end 
+
+end 

data/spec/models/jackpot/gateway_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe Jackpot::Gateway do 
+
+  let(:gateway_component) { ActiveMerchant::Billing::BogusGateway.new } 
+  subject                 { Jackpot::Gateway.new(gateway_component) } 
+
+  it "checks if the gateway component has a method" do
+    gateway_component.should_receive(:respond_to?).with('purchase')
+    subject.respond_to? 'purchase'
+  end 
+
+  it "should not recognize methods this component doesn't respond to" do
+    expect { subject.foo }.to raise_error(NoMethodError)
+  end 
+
+  it "forwards every call the component knows to gateway component" do
+    gateway_component.should_receive(:purchase).with(1000, 'args')
+    subject.purchase(1000, 'args')
+  end 
+
+end 

data/spec/models/jackpot/payment_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+
+module Jackpot 
+  describe Payment , :vcr do
+    it { should belong_to :customer } 
+    it { should belong_to :subscription } 
+
+    let(:fail_response)     { stub("success?" => false) } 
+
+    let(:subscription)      { Factory(:subscription, :price => 4200) } 
+    let(:customer)          { Factory(:customer_with_valid_card, :email => 'john@doe.com') } 
+
+    let(:invalid_customer)  { Factory(:customer, :email => 'john@doe.com',
+                                      :credit_card_token => '1') } 
+
+    let(:payment)         { Payment.create(:description => "foo", 
+                           :customer     => customer, 
+                           :subscription => subscription) }
+
+    let(:invalid_payment) { Payment.create(:description => "foo", 
+                             :customer     => invalid_customer, 
+                             :subscription => subscription) }
+
+
+    describe ".customer_name"  do
+      it "returns its customer email" do
+        payment.customer_email.should == "john@doe.com"
+      end 
+    end 
+
+    describe "#create" do
+      context "with valid token information"  do 
+        let(:retrieved_payment) { Payment.find(payment.id) } 
+
+        it "creates a new payment" do
+          expect { payment }.to change(Payment, :count).by(1)
+        end 
+
+        it "records the payment transaction id for future reference" do
+          retrieved_payment.payment_transaction_token.should == "1561142493"
+        end 
+
+        it "records this payment information" do
+          retrieved_payment.amount.should          == 4200
+          retrieved_payment.description.should_not be_nil 
+          retrieved_payment.subscription.should_not be_nil 
+        end 
+
+        it "does not persist credit card token information" do
+          retrieved_payment.credit_card_token.should be_nil
+        end 
+      end 
+      context "with invalid token information"  do
+        before do
+          Jackpot::Gateway.any_instance.stub(:authorize)
+                                  .with(4200, '1')
+                                  .and_return(fail_response)
+        end 
+
+        it "raises an unauthorized token information" do
+          expect { invalid_payment }.to raise_error Jackpot::Errors::UnauthorizedPayment
+        end
+
+        it "must not save an additional payment" do
+          begin
+            invalid_payment
+          rescue Jackpot::Errors::UnauthorizedPayment
+            Payment.count.should == 0
+          end 
+        end 
+      end 
+    end 
+  end
+end 

data/spec/models/jackpot/subscription_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe Jackpot::Subscription do
+  it { should have_many(:customers)       } 
+  it { should validate_presence_of :name  }
+  it { should have_many(:payments)        }
+
+
+  describe ".charge" do
+    let(:customer_to_be_charged) { Factory(:customer_with_subscription)  } 
+    subject { customer_to_be_charged.subscription  } 
+
+    it "creates a payment for the given customer" , 
+      :vcr => { :cassette_name => "jackpot/subscription_charge" } do
+      expect { subject.charge(customer_to_be_charged)}.to change(subject.payments, :count).by(1)
+    end 
+  end   
+
+end

data/spec/requests/jackpot/jackpot_assign_subscription_to_customer_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+
+feature "Assign Subscription to customer", %q{
+  To bill my plan's subscribers  
+  As a user
+  I want to record their plan and subscription  
+} do
+  
+  let(:user)         {  Factory(:user) }
+
+  before do
+    sign_in user
+
+    @subscription = Factory :subscription, :name => "Gold"
+  end
+
+  scenario "creating a customer and assigning a new subscription" do
+    visit customers_path
+    click_link "New Customer"
+
+    fill_in "customer[email]", with: "john@doe.net"
+    select  'Gold', :from => 'Subscription'
+
+    click_button "Create Customer"
+
+    # Customer created successfully 
+    page.should have_css(".alert.alert-success") 
+    # Subscription is listed at Customer details 
+    page.should have_content("Gold")
+    
+    visit subscription_path(@subscription)
+    within("#subscribers") do
+      page.should have_content("john@doe.net")
+    end 
+
+  end 
+ 
+end 

data/spec/requests/jackpot/jackpot_create_customer_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+
+feature "Create Customers", %q{ 
+  To bill monthly my customers 
+  As a user
+  I want to record their billing information
+} do
+
+
+  let(:user) { Factory(:user) } 
+
+  before do
+    sign_in user
+  end 
+
+
+  scenario "customer creation" do
+    visit customers_path 
+    click_link "New Customer"
+
+    page.should have_no_css("#credit-card-information")
+
+    within('form') do
+      fill_in "customer[email]"       , :with => "foo@bar.com" 
+      fill_in "customer[description]" , :with => "random description" 
+      
+      click_button("Create Customer")
+    end 
+
+    # Customer should have been created successfully 
+    page.should have_css    (".alert.alert-success") 
+    page.should have_content("foo@bar.com"           )
+  end 
+
+  it "assigning credit card information to customer", :vcr  do
+    ActiveMerchant::Billing::Base.mode = :test
+    Jackpot::Payment.gateway = Jackpot::Gateway.new(ActiveMerchant::Billing::BraintreeGateway.new :login => "demo" , :password => 'password')
+
+    @customer = FactoryGirl.create("customer", :email => "baz@bar.com")
+
+
+    visit customers_path 
+    within("#customer-#{@customer.id}") { click_link "Edit" } 
+
+
+    page.should have_css      ("#credit-card-information" )
+    # fill credit card's information
+    within("#credit-card-form") do
+      fill_in "credit_card[number]"              , :with => "5105105105105100"
+      fill_in "credit_card[month]"               , :with => "5"
+      fill_in "credit_card[year]"                , :with => next_year 
+      fill_in "credit_card[first_name]"          , :with => 'John' 
+      fill_in "credit_card[last_name]"           , :with => 'Doe' 
+      fill_in "credit_card[verification_value]"  , :with => 123 
+
+      # submit data
+
+      click_button 'Confirm'
+    end 
+    page.should have_css         (".alert.alert-success" ) 
+
+    within("#customer") do
+      # Not quite what would be expected but this is due Bogus Gateway usage
+      page.should have_content     ("XXXX-XXXX-XXXX-5100")   
+      page.should have_content     ( next_year           )
+      page.should have_content     ( "5"  )
+      page.should have_no_content  ( "123")
+    end 
+
+  end 
+
+end