freemium 0.0.1

data/spec/models/manual_billing_spec.rb

@@ -0,0 +1,174 @@
+require 'spec_helper'
+
+describe Subscription do
+  fixtures :users, :subscriptions, :subscription_plans, :credit_cards
+
+
+  before(:each) do
+    Freemium.gateway = Freemium::Gateways::Test.new
+  end
+
+  it "should find billable" do
+    # making a one-off fixture set, basically
+    create_billable_subscription # this subscription should be billable
+    create_billable_subscription(:paid_through => Date.today) # this subscription should be billable
+    create_billable_subscription(:coupon => Coupon.create!(:description => "Complimentary", :discount_percentage => 100)) # should NOT be billable because it's free
+    create_billable_subscription(:subscription_plan => subscription_plans(:free)) # should NOT be billable because it's free
+    create_billable_subscription(:paid_through => Date.today + 1) # should NOT be billable because it's paid far enough out
+    s = create_billable_subscription # should be billable because it's past due
+    s.update_attribute :expire_on, Date.today + 1
+
+    expirable = Subscription.send(:find_billable)
+    expirable.all? { |subscription| subscription.paid?                      }.should be_true, "free subscriptions aren't billable"
+    expirable.all? { |subscription| !subscription.in_trial?                 }.should be_true, "subscriptions that have been paid are no longer in the trial period"
+    expirable.all? { |subscription| subscription.paid_through <= Date.today }.should be_true, "subscriptions paid through tomorrow aren't billable yet"
+    expirable.size.should eql(3)
+
+    Freemium.gateway.stub!(:charge).and_return(
+      AccountTransaction.new(
+        :billing_key => s.billing_key,
+        :amount => s.rate,
+        :success => false
+      )
+    )
+
+    Subscription.run_billing.size.should eql(expirable.size)
+  end
+
+  it "should not change expire_on on failure overdue payment" do
+    subscription = create_billable_subscription # should NOT be billable because it's already expiring
+    expire_on = Date.today + 2
+    paid_through = subscription.paid_through
+    subscription.update_attribute :expire_on, expire_on
+    subscription.reload
+    subscription.expire_on.should eql(expire_on)
+    expirable = Subscription.send(:find_billable)
+    expirable.size.should eql(1), "Subscriptions in their grace period should be retried"
+
+    Freemium.gateway.stub!(:charge).and_return(
+      AccountTransaction.new(
+        :billing_key => subscription.billing_key,
+        :amount => subscription.rate,
+        :success => false
+      )
+    )
+
+    lambda do
+      transaction = subscription.charge!
+      subscription.expire_on.should eql(expire_on), "Billing failed on existing overdue account but the expire_on date was changed"
+    end.should_not raise_error
+  end
+
+  it "should change expire_on on success overdue payment" do
+    subscription = create_billable_subscription # should NOT be billable because it's already expiring
+    expire_on = Date.today + 2
+    paid_through = subscription.paid_through
+    subscription.update_attribute :expire_on, expire_on
+
+    expirable = Subscription.send(:find_billable)
+    expirable.size.should eql(1), "Subscriptions in their grace period should be retried"
+
+    Freemium.gateway.stub!(:charge).and_return(
+      AccountTransaction.new(
+        :billing_key => subscription.billing_key,
+        :amount => subscription.rate,
+        :success => true
+      )
+    )
+
+    assert_nothing_raised do
+      transaction = subscription.charge!
+      transaction.subscription.paid_through.to_s.should eql((paid_through >> 1).to_s), "extended by a month"
+      subscription.expire_on.should be_nil, "Billing succeeded on existing overdue account but the expire_on date was not reset"
+    end
+  end
+
+  it "should charge a subscription" do
+    subscription = Subscription.first
+    subscription.coupon = Coupon.create!(:description => "Complimentary", :discount_percentage => 30)
+    subscription.save!
+
+    paid_through = subscription.paid_through
+
+    Freemium.gateway.stub!(:charge).and_return(
+      AccountTransaction.new(
+        :billing_key => subscription.billing_key,
+        :amount => subscription.rate,
+        :success => true
+      )
+    )
+
+    lambda do
+      transaction = subscription.charge!
+      transaction.subscription.paid_through.to_s.should eql((paid_through >> 1).to_s)#, "extended by a month"
+    end.should_not raise_error
+
+    subscription = subscription.reload
+    subscription.transactions.empty?.should be_false
+    subscription.transactions.last.should be_true
+    subscription.transactions.last.success?.should be_true
+    subscription.transactions.last.message?.should_not be_nil
+    ((Time.now - 1.minute) < subscription.last_transaction_at).should be_true
+    AccountTransaction.since(Date.today).empty?.should be_false
+    subscription.transactions.last.amount.should eql(subscription.rate)
+    subscription.reload.paid_through.to_s.should eql((paid_through >> 1).to_s), "extended by a month"
+  end
+
+
+  it "should charge an aborted subscription" do
+    subscription = Subscription.first
+    subscription.coupon = Coupon.create!(:description => "Complimentary", :discount_percentage => 30)
+    subscription.save!
+
+    paid_through = subscription.paid_through
+    subscription.transactions.empty?.should be_true
+
+    Freemium.gateway.stub!(:charge).and_return(
+      AccountTransaction.new(
+        :billing_key => subscription.billing_key,
+        :amount => subscription.rate,
+        :success => true
+      )
+    )
+
+    subscription.should_receive(:receive_payment).and_raise(RuntimeError)
+    subscription.charge!
+    subscription.reload.transactions.empty?.should be_false
+  end
+
+  it "should not charge a subscription" do
+    subscription = Subscription.first
+    paid_through = subscription.paid_through
+    Freemium.gateway.stub!(:charge).and_return(
+      AccountTransaction.new(
+        :billing_key => subscription.billing_key,
+        :amount => subscription.rate,
+        :success => false
+      )
+    )
+
+    subscription.expire_on.should be_nil
+    lambda { subscription.charge! }.should_not raise_error
+    subscription.reload.paid_through.should eql(paid_through), "not extended"
+    subscription.expire_on.should_not be_nil
+    subscription.transactions.last.success?.should be_false
+  end
+
+  it "should receive charge! on billable when we run billing" do
+    subscription = Subscription.first
+    Subscription.stub!(:find_billable => [subscription])
+    subscription.should_receive(:charge!).once
+    Subscription.send :run_billing
+  end
+
+  protected
+
+  def create_billable_subscription(options = {})
+    Subscription.create!({
+      :subscription_plan => subscription_plans(:premium),
+      :subscribable => User.new(:name => 'a'),
+      :paid_through => Date.today - 1,
+      :credit_card => CreditCard.sample
+    }.merge(options))
+  end
+end

data/spec/models/recurring_billing_spec.rb

@@ -0,0 +1,92 @@
+require 'spec_helper'
+
+
+describe Subscription do
+  fixtures :users, :subscriptions, :subscription_plans, :credit_cards
+
+
+  before(:each) do
+    class Subscription
+      include Freemium::RecurringBilling
+    end
+    Freemium.gateway = Freemium::Gateways::Test.new
+  end
+
+  it "should run billing" do
+    Subscription.should_receive(:process_transactions).once
+    Subscription.should_receive(:find_expirable).once.and_return([])
+    Subscription.should_receive(:expire).once
+    Subscription.run_billing
+  end
+
+  it "should send reports" do
+    Subscription.stub!(:process_transactions)
+    Freemium.stub!(:admin_report_recipients).and_return("test@example.com")
+
+    Freemium.mailer.should_receive(:deliver_admin_report)
+    Subscription.run_billing
+  end
+
+  it "should find expireable subscriptions" do
+    # making a one-off fixture set, basically
+    create_billable_subscription # this subscription qualifies
+    create_billable_subscription(:subscription_plan => subscription_plans(:free)) # this subscription would qualify, except it's for the free plan
+    create_billable_subscription(:paid_through => Date.today) # this subscription would qualify, except it's already paid
+    create_billable_subscription(:coupon => Coupon.create!(:description => "Complimentary", :discount_percentage => 100)) # should NOT be billable because it's free
+    s = create_billable_subscription # this subscription would qualify, except it's already been set to expire
+    s.update_attribute :expire_on, Date.today + 1
+
+    expirable = Subscription.send(:find_expirable)
+    expirable.all? { |subscription| subscription.paid?                              }.should be_true, "free subscriptions don't expire"
+    expirable.all? { |subscription| !subscription.in_trial?                         }.should be_true, "subscriptions that have been paid are no longer in the trial period"
+    expirable.all? { |subscription| subscription.paid_through < Date.today          }.should be_true, "paid subscriptions don't expire"
+    expirable.all? { |subscription|
+      !subscription.expire_on or subscription.expire_on < subscription.paid_through }.should be_true, "subscriptions already expiring aren't included"
+
+    expirable.size.should eql(1)
+  end
+
+  it "should process new transactions" do
+    subscription = subscriptions(:bobs_subscription)
+    subscription.coupon = Coupon.create!(:description => "Complimentary", :discount_percentage => 30)
+    subscription.save!
+
+    paid_through = subscription.paid_through
+    t = AccountTransaction.new(:billing_key => subscription.billing_key, :amount => subscription.rate, :success => true)
+    Subscription.stub!(:new_transactions => [t])
+
+    # the actual test
+    Subscription.send :process_transactions
+    subscription.reload.paid_through.to_s.should eql((paid_through + 1.month).to_s), "extended by two months"
+  end
+
+  it "should process a failed transaction" do
+    subscription = subscriptions(:bobs_subscription)
+    paid_through = subscription.paid_through
+    t = AccountTransaction.new(:billing_key => subscription.billing_key, :amount => subscription.rate, :success => false)
+    Subscription.stub!(:new_transactions => [t])
+
+    # the actual test
+    subscription.expire_on.should be_nil
+    Subscription.send :process_transactions
+    subscription.reload.paid_through.should eql(paid_through), "not extended"
+    subscription.expire_on.should_not be_nil
+  end
+
+  it "should find new transactions" do
+    last_transaction_at = Subscription.maximum(:last_transaction_at)
+    method_args = Subscription.send(:new_transactions)
+    method_args[:after].should eql(last_transaction_at)
+  end
+
+  protected
+
+  def create_billable_subscription(options = {})
+    Subscription.create!({
+      :subscription_plan => subscription_plans(:premium),
+      :subscribable => User.new(:name => 'a'),
+      :paid_through => Date.today - 1,
+      :credit_card => CreditCard.sample
+    }.merge(options))
+  end
+end

data/spec/models/subscription_plan_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe SubscriptionPlan do
+  fixtures :users, :subscriptions, :subscription_plans, :credit_cards
+
+  it "should have associations" do
+    [subscriptions(:bobs_subscription)].should == (subscription_plans(:basic).subscriptions)
+  end
+
+  it "should have rate intervals" do
+    plan = SubscriptionPlan.new(:rate_cents => 3041)
+    plan.daily_rate.should eql(Money.new(99))
+    plan.monthly_rate.should eql(Money.new(3041))
+    plan.yearly_rate.should eql(Money.new(36492))
+  end
+
+  it "should create plan" do
+    plan = create_plan
+    plan.new_record?.should be_false
+  end
+
+  it "should have errors" do
+    [:name, :rate_cents].each do |field|
+      plan = create_plan(field => nil)
+      plan.new_record?.should be_true
+      plan.should have(1).errors_on(field)
+    end
+  end
+
+  it "should have ads" do
+    subscription_plans(:free).features.ads?.should_not be_nil
+  end
+
+  protected
+
+  def create_plan(options = {})
+    SubscriptionPlan.create({
+      :name => 'super-duper-ultra-premium',
+      :redemption_key => 'super-duper-ultra-premium',
+      :rate_cents => 99995,
+      :feature_set_id => :premium
+    }.merge(options))
+  end
+end

data/spec/models/subscription_spec.rb

@@ -0,0 +1,386 @@
+require 'spec_helper'
+
+describe Subscription do
+  fixtures :users, :subscriptions, :subscription_plans, :credit_cards
+
+  def build_subscription(options = {})
+    Subscription.new({
+      :subscription_plan => subscription_plans(:free),
+      :subscribable => users(:sue)
+    }.merge(options))
+  end
+
+  def create_transaction_for(amount, subscription)
+    AccountTransaction.create :amount => amount, :subscription => subscription, :success => true, :billing_key => 12345
+  end
+
+  def assert_changed(subscribable, reason, original_plan, new_plan)
+    changes = SubscriptionChange.where(["subscribable_id = ? AND subscribable_type = ?", subscribable.id, subscribable.class.to_s]).last
+    changes.should_not be_nil
+    changes.reason.should eql(reason.to_s)
+    changes.original_subscription_plan.should eql(original_plan)
+    changes.new_subscription_plan.should eq(new_plan)
+    changes.original_rate_cents.should eql(original_plan ? original_plan.rate.cents : 0)
+    changes.new_rate_cents.should eql(new_plan ? new_plan.rate.cents : 0)
+  end
+
+  it "should create free subscription" do
+    subscription = build_subscription(:subscription_plan => subscription_plans(:free))
+    subscription.save!
+
+    subscription.should_not be_new_record
+    subscription.reload.started_on.should eql(Date.today)
+    subscription.in_trial?.should be_false
+    subscription.paid_through.should be_nil
+    subscription.paid?.should be_false
+
+    #TODO understand what is that
+    assert_changed(subscription.subscribable, :new, nil, subscription_plans(:free))
+  end
+
+  it "should create paid subscription" do
+    Freemium.days_free_trial = 30
+
+    subscription = build_subscription(:subscription_plan => subscription_plans(:basic), :credit_card => CreditCard.sample)
+    subscription.save!
+
+    subscription.should_not be_new_record
+    subscription.reload.started_on.should eql(Date.today)
+    subscription.in_trial?.should be_true
+    subscription.paid_through.should_not be_nil
+    subscription.paid_through.should eql(Date.today + Freemium.days_free_trial)
+    subscription.paid?.should be_true
+    subscription.billing_key.should_not be_nil
+
+    assert_changed(subscription.subscribable, :new, nil, subscription_plans(:basic))
+  end
+
+  it "should be upgraded from free" do
+    subscription = build_subscription(:subscription_plan => subscription_plans(:free))
+    subscription.save!
+
+    new_date = Date.today + 10.days
+    Date.stub!(:today => new_date)
+
+    subscription.in_trial?.should be_false
+    subscription.subscription_plan = subscription_plans(:basic)
+    subscription.credit_card = CreditCard.sample
+    subscription.save!
+
+    subscription.reload.started_on.should eql(new_date)
+    subscription.paid_through.should_not be_nil
+    subscription.in_trial?.should be_false
+    subscription.paid_through.should eql(new_date)
+    subscription.paid?.should be_true
+    subscription.billing_key.should_not be_nil
+
+    assert_changed(subscription.subscribable, :upgrade, subscription_plans(:free), subscription_plans(:basic))
+  end
+
+  it "should be downgraded" do
+    subscription = build_subscription(:subscription_plan => subscription_plans(:basic), :credit_card => CreditCard.sample)
+    subscription.save!
+
+    new_date = Date.today + 10.days
+    Date.stub!(:today => new_date)
+
+    subscription.subscription_plan = subscription_plans(:free)
+    subscription.save!
+
+    subscription.reload.started_on.should eql(new_date)
+    subscription.paid_through.should be_nil
+    subscription.paid?.should be_false
+    subscription.billing_key.should be_nil
+    subscription.credit_card.should be_nil
+
+    assert_changed(subscription.subscribable, :downgrade, subscription_plans(:basic), subscription_plans(:free))
+  end
+
+  it "should have associations" do
+    assert_equal users(:bob), subscriptions(:bobs_subscription).subscribable
+    assert_equal subscription_plans(:basic), subscriptions(:bobs_subscription).subscription_plan
+  end
+
+  it "should have remaining_days" do
+    assert_equal 20, subscriptions(:bobs_subscription).remaining_days
+  end
+
+  it "should have remaining_value" do
+    assert_equal Money.new(840), subscriptions(:bobs_subscription).remaining_value
+  end
+
+  ##
+  ## Upgrade / Downgrade service credits
+  ##
+
+  it "should upgrade credit" do
+    subscription = subscriptions(:bobs_subscription)
+    new_plan = subscription_plans(:premium)
+
+    subscription.remaining_value.cents.should > 0
+    expected_paid_through = Date.today + (subscription.remaining_value.cents / new_plan.daily_rate.cents)
+    subscription.subscription_plan = subscription_plans(:premium)
+    subscription.save!
+
+    subscription.paid_through.should eql(expected_paid_through)
+  end
+
+  it "should upgrade no credit for free trial" do
+    subscription = build_subscription(:subscription_plan => subscription_plans(:premium), :credit_card => CreditCard.sample)
+    subscription.save!
+
+    subscription.paid_through.should eql(Date.today + Freemium.days_free_trial)
+    subscription.in_trial?.should be_true
+
+    subscription.subscription_plan = subscription_plans(:basic)
+    subscription.save!
+
+    subscription.paid_through.should eql(Date.today)
+    subscription.in_trial?.should be_false
+  end
+
+  ##
+  ## Validations
+  ##
+
+  it "should test missing fields" do
+    [:subscription_plan, :subscribable].each do |field|
+      subscription = build_subscription(field => nil)
+      subscription.save
+
+      subscription.should be_new_record
+      subscription.should have(1).errors_on(field)
+    end
+  end
+
+  ##
+  ## Receiving payment
+  ##
+
+  it "should receive monthly payment" do
+    subscription = subscriptions(:bobs_subscription)
+    paid_through = subscription.paid_through
+    subscription.credit(subscription_plans(:basic).rate)
+    subscription.save!
+
+    subscription.paid_through.to_s.should eql((paid_through >> 1).to_s) #extended by one month
+    subscription.transactions.should_not be_nil
+  end
+
+  its "should receive quarterly payment" do
+    subscription = subscriptions(:bobs_subscription)
+    paid_through = subscription.paid_through
+    subscription.credit(subscription_plans(:basic).rate * 3)
+    subscription.save!
+    subscription.paid_through.to_s.should eql((paid_through >> 3).to_s) #extended by three months
+  end
+
+  it "should receive partial payment" do
+    subscription = subscriptions(:bobs_subscription)
+    paid_through = subscription.paid_through
+    subscription.credit(subscription_plans(:basic).rate * 0.5)
+    subscription.save!
+    subscription.paid_through.to_s.should eql((paid_through + 15).to_s) #extended by 15 days
+  end
+
+  it "should send invoice when receiving payment" do
+    subscription = subscriptions(:bobs_subscription)
+    ActionMailer::Base.deliveries = []
+    transaction = create_transaction_for(subscription_plans(:basic).rate, subscription)
+    subscription.receive_payment!(transaction)
+    ActionMailer::Base.deliveries.size.should eql(1)
+  end
+
+  it "should save transaction message when receiving payment" do
+    subscription = subscriptions(:bobs_subscription)
+    transaction = create_transaction_for(subscription_plans(:basic).rate, subscription)
+    subscription.receive_payment!(transaction)
+    transaction.reload.message.should match(/^now paid through/)
+  end
+
+  it "should receive payment though invoice has delivered with error" do
+    subscription = subscriptions(:bobs_subscription)
+    paid_through = subscription.paid_through
+    transaction = create_transaction_for(subscription_plans(:basic).rate, subscription)
+    Freemium.mailer.should_receive(:invoice).and_raise(RuntimeError)
+    subscription.receive_payment!(transaction)
+    subscription = subscription.reload
+    subscription.paid_through.to_s.should eql((paid_through >> 1).to_s) #extended by one month
+  end
+
+  ##
+  ## Requiring Credit Cards ...
+  ##
+
+  it "should require credit card for pay plan" do
+    subscription = build_subscription(:subscription_plan => subscription_plans(:premium))
+    subscription.stub!(:credit_card => nil)
+    subscription.should have(1).errors_on(:credit_card)
+  end
+
+  it "should not require credit card for free_plan" do
+    subscription = build_subscription
+    subscription.should have(0).errors_on(:credit_card)
+  end
+
+  ##
+  ## Expiration
+  ##
+
+  it "should expire instance" do
+    Freemium.expired_plan_key = :free
+    Freemium.gateway.should_receive(:cancel).once.and_return(nil)
+    ActionMailer::Base.deliveries = []
+    subscriptions(:bobs_subscription).expire!
+
+    ActionMailer::Base.deliveries.size.should eql(1) #notice is sent to user
+    subscriptions(:bobs_subscription).reload.subscription_plan.should eql(subscription_plans(:free)) #subscription is downgraded to free
+    subscriptions(:bobs_subscription).billing_key.should be_nil #billing key is thrown away
+    subscriptions(:bobs_subscription).reload.billing_key.should be_nil #billing key is thrown away
+
+    assert_changed(subscriptions(:bobs_subscription).subscribable, :expiration, subscription_plans(:basic), subscription_plans(:free))
+  end
+
+  it "should expire instance with expired_plan_key = nil" do
+    Freemium.expired_plan_key = nil
+    Freemium.gateway.should_receive(:cancel).once.and_return(nil)
+    ActionMailer::Base.deliveries = []
+    subscriptions(:bobs_subscription).expire!
+
+    ActionMailer::Base.deliveries.size.should eql(1) #notice is sent to user
+    subscriptions(:bobs_subscription).subscription_plan.should eql(subscription_plans(:basic)) #subscription was not changed
+    subscriptions(:bobs_subscription).billing_key.should be_nil #billing key is thrown away
+    subscriptions(:bobs_subscription).reload.billing_key.should be_nil #billing key is thrown away
+  end
+
+  it "should expire class" do
+    Freemium.expired_plan_key = :free
+    Freemium.expired_plan_key.should eql(:free)
+    Freemium.expired_plan.should_not be_nil
+    subscriptions(:bobs_subscription).update_attributes(:paid_through => Date.today - 4, :expire_on => Date.today)
+    ActionMailer::Base.deliveries = []
+
+    subscriptions(:bobs_subscription).subscription_plan.should eql(subscription_plans(:basic))
+
+    Freemium.expired_plan.should eql(subscription_plans(:free))
+    Subscription.expire
+
+    subscriptions(:bobs_subscription).expire!
+    subscriptions(:bobs_subscription).reload.subscription_plan.should eql(subscription_plans(:free))
+    subscriptions(:bobs_subscription).reload.started_on.should eql(Date.today)
+    ActionMailer::Base.deliveries.size.should > 0
+
+    assert_changed(subscriptions(:bobs_subscription).subscribable, :expiration, subscription_plans(:basic), subscription_plans(:free))
+  end
+
+  it "should expire after grace " do
+    subscriptions(:bobs_subscription).expire_on.should be_nil
+    subscriptions(:bobs_subscription).paid_through = Date.today - 2
+    ActionMailer::Base.deliveries = []
+
+    subscriptions(:bobs_subscription).expire_after_grace!
+
+    ActionMailer::Base.deliveries.size.should eql(1)
+    subscriptions(:bobs_subscription).reload.expire_on.should eql(Date.today + Freemium.days_grace)
+  end
+
+  it "should expire after grace with remaining period" do
+    subscriptions(:bobs_subscription).paid_through = Date.today + 1
+    subscriptions(:bobs_subscription).expire_after_grace!
+
+    subscriptions(:bobs_subscription).reload.expire_on.should eql(Date.today + 1 + Freemium.days_grace)
+  end
+
+  it "should test grace and expiration" do
+    Freemium.days_grace.should eql(3)
+
+    subscription = Subscription.new(:paid_through => Date.today + 5)
+    subscription.in_grace?.should be_false
+    subscription.expired?.should be_false
+
+    # a subscription that's pastdue but hasn't been flagged to expire yet.
+    # this could happen if a billing process skips, in which case the subscriber
+    # should still get a full grace period beginning from the failed attempt at billing.
+    # even so, the subscription is "in grace", even if the grace period hasn't officially started.
+    subscription = Subscription.new(:paid_through => Date.today - 5)
+    subscription.in_grace?.should be_true
+    subscription.expired?.should be_false
+
+    # expires tomorrow
+    subscription = Subscription.new(:paid_through => Date.today - 5, :expire_on => Date.today + 1)
+    subscription.remaining_days_of_grace.should eql(0)
+    subscription.in_grace?.should be_true
+    subscription.expired?.should be_false
+
+    # expires today
+    subscription = Subscription.new(:paid_through => Date.today - 5, :expire_on => Date.today)
+    subscription.remaining_days_of_grace.should eql(-1)
+    subscription.in_grace?.should be_false
+    subscription.expired?.should be_true
+  end
+
+  ##
+  ## Deleting (possibly from a cascading delete, such as User.find(5).delete)
+  ##
+
+  it "should delete canceles in gateway" do
+    Freemium.gateway.should_receive(:cancel).once.and_return(nil)
+    subscriptions(:bobs_subscription).destroy
+
+    assert_changed(subscriptions(:bobs_subscription).subscribable, :cancellation, subscription_plans(:basic), nil)
+  end
+
+  ##
+  ## The Subscription#credit_card= shortcut
+  ##
+  it "should add credit card" do
+    subscription = build_subscription(:subscription_plan => subscription_plans(:premium))
+    cc = CreditCard.sample
+    response = Freemium::Response.new(true)
+    response.billing_key = "alphabravo"
+    Freemium.gateway.should_receive(:store).with(cc, cc.address).and_return(response)
+
+    subscription.credit_card = cc
+    lambda { subscription.save! }.should_not raise_error
+    subscription.billing_key.should eql("alphabravo")
+  end
+
+  it "should update a credit card" do
+    subscription = Subscription.where("billing_key IS NOT NULL").first
+    cc = CreditCard.sample
+    response = Freemium::Response.new(true)
+    response.billing_key = "new code"
+    Freemium.gateway.should_receive(:update).with(subscription.billing_key, cc, cc.address).and_return(response)
+
+    subscription.credit_card = cc
+    lambda { subscription.save! }.should_not raise_error
+    subscription.billing_key.should eql("new code") #catches any change to the billing key
+  end
+
+  it "should update an expired credit card" do
+    subscription = Subscription.where("billing_key IS NOT NULL").first
+    cc = CreditCard.sample
+    response = Freemium::Response.new(true)
+    Freemium.gateway.should_receive(:update).with(subscription.billing_key, cc, cc.address).and_return(response)
+
+    subscription.expire_on = Time.now
+    subscription.save.should be_true
+    subscription.reload.expire_on.should_not be_nil
+
+    subscription.credit_card = cc
+    lambda { subscription.save! }.should_not raise_error
+    #subscription.expire_on.should be_nil
+    #subscription.reload.expire_on.should be_nil
+  end
+
+  it "should fail to add credit card" do
+    subscription = build_subscription(:subscription_plan => subscription_plans(:premium))
+    cc = CreditCard.sample
+    response = Freemium::Response.new(false)
+    Freemium.gateway.should_receive(:store).and_return(response)
+
+    subscription.credit_card = cc
+    lambda { subscription.save! }.should raise_error(Freemium::CreditCardStorageError)
+  end
+
+end