output.txt

$bundle exec rake

Run options: --seed 62924

# Running:

................autoprefixer: /home/rof/src/bitbucket.org/sharecoffee/share/app/assets/stylesheets/application.scss:6859:5: Gradient has outdated direction syntax. New syntax is like "to left" instead of "right".
autoprefixer: /home/rof/src/bitbucket.org/sharecoffee/share/app/assets/stylesheets/application.scss:6868:5: Gradient has outdated direction syntax. New syntax is like "to left" instead of "right".
........................................autoprefixer: /home/rof/src/bitbucket.org/sharecoffee/share/app/assets/stylesheets/coming_soon.scss:6859:5: Gradient has outdated direction syntax. New syntax is like "to left" instead of "right".
autoprefixer: /home/rof/src/bitbucket.org/sharecoffee/share/app/assets/stylesheets/coming_soon.scss:6868:5: Gradient has outdated direction syntax. New syntax is like "to left" instead of "right".
.............E.............................E........E..E...E.....................

Finished in 69.394763s, 1.9742 runs/s, 9.6405 assertions/s.

1) Error:
GiftsTest#test_recipient_sets_address:
ActionController::RoutingError: No route matches [GET] "/system/subcategories/images/original/000/000/018.jpg"



2) Error:
SubscriptionTest#test_reup_subscription_schedule:
RuntimeError: can't modify frozen object
test/models/subscription_test.rb:841:in `block in <class:SubscriptionTest>'


3) Error:
SubscriptionTest#test_switch_plan_tier:
RuntimeError: can't modify frozen object
test/models/subscription_test.rb:673:in `block in <class:SubscriptionTest>'


4) Error:
SubscriptionTest#test_switch_plan_size:
RuntimeError: can't modify frozen object
test/models/subscription_test.rb:647:in `block in <class:SubscriptionTest>'


5) Error:
SetReferralTest#test_the_truth:
ActionController::RoutingError: No route matches [GET] "/system/subcategories/images/original/000/000/066.jpg"


137 runs, 669 assertions, 0 failures, 5 errors, 0 skips

subscription_test.rb

require 'test_helper'

class SubscriptionTest < ActiveSupport::TestCase
  
  test "activity" do
    @subscription = FactoryGirl.create(:subscription)
    run_timely_jobs
    
    assert_difference "@subscription.reload.activity.length" do
      @subscription.pause!
    end
    assert_difference "@subscription.reload.activity.length" do
      @subscription.activate!
    end
    assert_difference "@subscription.reload.activity.length" do
      @subscription.update_attributes({:away_count => 1, :away_action => 'pause'})
    end
    assert_difference "@subscription.reload.activity.length" do
      @subscription.update_attribute(:away_count, 0)
    end
  end
  
  test "activate from away" do
    @address = FactoryGirl.create(:address)
    @subscription = FactoryGirl.create(:subscription, :away_address_id => @address.id, :away_action => 'share', :away_count => 3)
    assert @subscription.temporarily_sharing?
    @subscription.pause!
    assert @subscription.paused?
    @subscription.activate!
    assert [email protected]_away?
    assert @subscription.active?
  end
  
  test "add orders remaining" do
    @subscription = FactoryGirl.create(:subscription)
    assert_difference "@subscription.orders_remaining" do
      assert_no_difference "Stripe::Invoice::STORE.length" do
        assert_no_difference "Stripe::InvoiceItem::STORE.length" do
          assert_no_difference "Invoice.count" do
            assert_no_difference "InvoiceItem.count" do
              @subscription.add_orders_remaining(1)
            end
          end
        end
      end
    end
    
    assert_difference "@subscription.orders_remaining", -1 do
      @subscription.add_orders_remaining(-1)
    end
  end
  
  test "away" do
    @subscription = FactoryGirl.create(:subscription, :tier => 2)
    run_timely_jobs
    @date = Date.today
    
    
    # ======================
    # = Temporarily Paused =
    # ======================
    @subscription.update_attributes({
      :away_action => "pause",
      :away_count => 1
    })
    
    assert_difference "@subscription.reload.away_count.to_i", -1 do
      assert_no_difference "@subscription.reload.orders_remaining" do
        @subscription.create_order!(@date)
        run_timely_jobs
      end
    end
    
    assert_equal "0", @subscription.away_count
    
    assert_no_difference "@subscription.reload.away_count.to_i" do
      assert_difference "@subscription.reload.orders_remaining", -1 do
        @subscription.create_order!(@date)
      end
    end
    
    # =======================
    # = Temporarily Sharing =
    # =======================
    @subscription.update_attributes!({
      :away_action => 'share',
      :away_count => 1,
      :away_address_id => FactoryGirl.create(:address, :user => @subscription.user).id
    })
    
    assert_not_equal @subscription.away_address_id, @subscription.address_id
    
    assert_difference "@subscription.reload.away_count.to_i", -1 do
      assert_difference "@subscription.reload.orders_remaining", -1 do
        @order = @subscription.create_order!(@date + 1.week)
      end
    end
    
    assert_equal @subscription.away_address_id, @order.address.id
    
    assert_difference "@subscription.reload.away_count.to_i", 0 do
      assert_difference "@subscription.reload.orders_remaining", -1 do
        @order = @subscription.create_order!(@date + 2.weeks)
      end
    end
    
    assert_equal @subscription.address_id, @order.address.id.to_i
    
  end
  
  test "delinquent" do
    @subscription = FactoryGirl.create(:subscription, :status => 'delinquent')
    @user = @subscription.user
    run_timely_jobs
    @subscription.reload.delinquent!
    assert_equal 'delinquent', @subscription.reload.status
    
    @card = @user.add_card!({:number => 123, :exp_month => '01', :exp_year => 1.year.from_now.year})
    
    assert_change "@subscription.reload.status", "active" do
      @user.update_attribute(:default_source, @card.id)
      @subscription.reload
    end
  end
  
  test "downgrade plan" do
    @subscription = FactoryGirl.create(:subscription, :tier => '1', :size => 'medium')
    run_timely_jobs
    @user = @subscription.user
    diff = Subscription::PRICING['1']['medium'] - Subscription::PRICING['1']['small']
    assert_difference "@user.reload.account_balance.to_i", -diff do
      @subscription.process_switch_plan!({:tier => '1', :size => 'small', :great_coffee_ids => @subscription.great_coffee_ids.slice(0,1)})
      run_timely_jobs
    end
  end
  
  # TODO: assert that first time discount is not applied twice for same credit card
  test "first time discount limitter" do
    @subscription = FactoryGirl.create(:subscription, :tier => '1', :size => 'small')
    assert_difference "DiscountFlag.count" do
      run_timely_jobs
    end
    assert_equal 0, @subscription.invoices.first.total.to_i
    
    @s2 = FactoryGirl.create(:subscription, :tier => '1', :size => 'small')
    @s2.user.card.stubs({:fingerprint => 'foobar'})
    run_timely_jobs
    assert_equal 0, @s2.invoices.first.total.to_i
    
    Stripe::Card.any_instance.stubs({:fingerprint => @subscription.card.fingerprint})
    @s3 = FactoryGirl.create(:subscription, :tier => '1', :size => 'small')
    run_timely_jobs
    
    # => assert starter discount of 20% off
    assert_equal 1300*0.8, @s3.invoices.first.total.to_i
  end
  
  test "processing status" do
    @subscription = FactoryGirl.create(:subscription)
    assert_equal 'processing-invoice', @subscription.reload.status
    assert_change "@subscription.reload.status", 'active' do
      run_timely_jobs
    end
    
    assert_change "@subscription.reload.status", 'processing-invoice' do
      @subscription.create_invoice!
    end
    
    assert_change "@subscription.reload.status", "active" do
      run_timely_jobs
    end
  end
  
  test "first order free" do
    assert_difference "Invoice.count" do
      assert_difference "Stripe::Invoice::STORE.select{|k,v| v.paid and (v.amount == 0)}.length" do
        assert_difference "Stripe::Invoice::STORE.length" do
          assert_difference "Stripe::InvoiceItem::STORE.length", 2 do
            assert_difference "Stripe::InvoiceItem::STORE.select{|k,v| v.amount == -Subscription.first_time_discount}.length" do
              @subscription = FactoryGirl.create(:subscription, :tier => '1', :size => 'small')
              run_timely_jobs
            end
          end
        end
      end
    end
    
    assert_no_difference "Stripe::InvoiceItem::STORE.select{|k,v| v.amount == -Subscription.first_time_discount}.length" do
      FactoryGirl.create(:subscription, :user => @subscription.user, :tier => '1', :size => 'small')
      run_timely_jobs
    end
    
    options = {:tier => '2', :size => 'medium'}
    diff = Subscription::PRICING[options.tier][options[:size]] - Subscription.first_time_discount
    assert_difference "Stripe::Invoice::STORE.length" do
      assert_difference "Stripe::Invoice::STORE.select{|k,v| v.amount == diff}.length" do
        assert_difference "Stripe::InvoiceItem::STORE.select{|k,v| v.amount == -Subscription.first_time_discount}.length" do
          @s3 = FactoryGirl.create(:subscription, options)
          @s3.user.card.stubs({:fingerprint => 'foobar'})
          run_timely_jobs
        end
      end
    end
    
  end
  
  test "idempotency of process_switch_plan!" do
    @subscription = FactoryGirl.create(:subscription, {:tier => '1'})
    run_timely_jobs
    
    Stripe::Invoice.stubs(:create).raises(RuntimeError.new('test error'))
    
    assert_difference "Stripe::Invoice::STORE.length" do

      assert_enqueued_with({:job => ChangePlanInvoice::CreateJob}) do
        @subscription.process_switch_plan!({:tier => '2', :size => @subscription.size})
      end
      
      assert_no_difference "Invoice.count" do
        assert_no_difference "InvoiceItem.count" do
          assert_no_difference "Stripe::InvoiceItem::STORE.length" do
            assert_no_difference "Stripe::Invoice::STORE.length" do
              run_timely_jobs(:silence_errors => true)
            end
          end
        end
      end
    
      Stripe::Invoice.unstub(:create)
      
      assert_no_enqueued_jobs do
        assert_equal false, @subscription.process_switch_plan!({:tier => '2', :size => @subscription.size})
        assert [email protected]?, 'errors expected'
      end
      
      assert_change "@subscription.reload.status", 'active' do
        assert_performed_with({:job => ChangePlanInvoice::PayJob}) do
          run_jobs
        end
      end
      
    end
    
  end
  
  test "idempotency of failed call to save!" do
    @subscription = FactoryGirl.create(:subscription, {:tier => '1'})
    run_timely_jobs; @subscription.reload
    Subscription.any_instance.stubs(:save!).raises(RuntimeError.new('test error foobar'))
    
    assert_no_difference "Stripe::Invoice::STORE.select{|k,v| !v.paid }.length" do
      assert_difference "Stripe::InvoiceItem::STORE.length", 2 do
        
        assert_enqueued_with({:job => ChangePlanInvoice::PayJob}) do
          assert_enqueued_with({:job => ChangePlanInvoice::CreateJob}) do
            assert_equal 'active', @subscription.status
            @subscription.process_switch_plan!({:tier => '2', :size => @subscription.size})
            assert @subscription.errors.empty?, @subscription.errors.full_messages.to_sentence
          end
          
          assert_difference "Stripe::Invoice::STORE.select{|k,v| !v.paid}.length" do
            assert_difference "Invoice.count" do
              assert_difference "Stripe::Invoice::STORE.length" do
                run_timely_jobs(:silence_errors => true )
              end
            end
          end
          
        end

        Subscription.any_instance.unstub(:save!)
        
        assert_no_enqueued_jobs do
          @subscription.process_switch_plan!({:tier => '2', :size => @subscription.size})
        end
        
        assert_equal 1, enqueued_jobs.length

        enqueued_jobs.first.reject!{ |k,v| k.to_s == 'at' }
        
        assert_no_difference "Invoice.count" do
          assert_no_difference "InvoiceItem.count" do
            assert_no_difference "Stripe::Invoice::STORE.length" do
              assert_no_difference "Stripe::InvoiceItem::STORE.length" do
                assert_difference "Stripe::Invoice::STORE.select{|k,v| v.paid}.length" do
                  assert_change "@subscription.reload.status", 'active' do
                    run_timely_jobs
                  end
                end
              end
            end
          end
        end
        
      end
    end
  end
  
  test "idempotency of failed call to pay" do
    @subscription = FactoryGirl.create(:subscription, {:tier => '1'})
    run_timely_jobs; @subscription.reload
    Stripe::Invoice.any_instance.stubs(:pay).raises(RuntimeError.new('test error'))
    
    assert_enqueued_with({:job => ChangePlanInvoice::CreateJob}) do
      @subscription.process_switch_plan!({:tier => '2', :size => @subscription.size})
    end
    
    assert_difference "Stripe::Invoice::STORE.select{|k,v| v.closed }.length" do
      assert_difference "Stripe::Invoice::STORE.length" do
        assert_difference "Stripe::InvoiceItem::STORE.length", 2 do
      
          assert_difference ("Stripe::Invoice::STORE.length") do
            assert_difference "Stripe::InvoiceItem::STORE.length", 2 do
              assert_difference "Invoice.count" do
                assert_difference "InvoiceItem.count", 2 do
                  assert_enqueued_jobs 0 do
                    run_timely_jobs(:silence_errors => true)
                    run_jobs(:silence_errors => true)
                  end
                end
              end
            end
          end

          Stripe::Invoice.any_instance.unstub(:pay)
          assert_no_enqueued_jobs do
            assert_equal false, @subscription.process_switch_plan!({:tier => '2', :size => @subscription.size})
          end
          
          assert_difference "Stripe::Invoice::STORE.select{|k,v|v.paid}.length" do
            assert_no_difference "Stripe::Invoice::STORE.length" do
              run_jobs
            end
          end
          
        end
      end
    end
  end
  
  test "create subscription when there are unpaid invoice items" do
    
    @user = FactoryGirl.create(:user)
    Stripe::InvoiceItem.create(:amount => 100, :customer => @user.stripe_customer.id)
    
    assert_difference "Invoice.count" do
      assert_difference "Subscription.count" do

        # => 1 item for the charge and 1 for first time discount totaling 2 minus unpaid invoice
        assert_difference "Stripe::InvoiceItem::STORE.length" do
          assert_difference "InvoiceItem.count", 2 do
            assert_difference "Stripe::Invoice::STORE.length" do
              FactoryGirl.create(:subscription, :user => @user, :size => 'small', :tier => '1')
              run_timely_jobs
            end
          end
        end
      end
    end
    
  end

  test "reup subscription when there are unpaid invoice items" do
    
    @subscription = FactoryGirl.create(:subscription)
    run_timely_jobs; @subscription.reload
    @user = @subscription.user
    
    @subscription.update_attribute(:orders_remaining, 0)
    2.times{Stripe::InvoiceItem.create(:amount => 100, :customer => @user.store.id)}
    
    assert_difference "Invoice.count" do
      
      # => 1 for price and 1 for starter discount
      assert_difference "InvoiceItem.count", 2 do
        
        # => clear 2 orphaned and create invoice item and starter discount itme totalling zero change.
        assert_no_difference "Stripe::InvoiceItem::STORE.length" do
          assert_difference "Stripe::Invoice::STORE.length" do
            @subscription.reup!
            run_timely_jobs
          end
        end
      end
    end
    
  end
  
  test "change plan when there are unpaid invoice items" do
    
    @subscription = FactoryGirl.create(:subscription, :tier => '1')
    run_timely_jobs; @subscription.reload
    @user = @subscription.user
    
    @subscription.update_attribute(:orders_remaining, 0)
    Stripe::InvoiceItem.create(:amount => 100, :customer => @user.store.id)
    
    # => delete orphan and create cost.  No refund because orders_remaining == 0
    assert_no_difference "Stripe::InvoiceItem::STORE.length" do
      assert_difference "Stripe::Invoice::STORE.length" do
        assert_difference "Invoice.count" do
          assert_difference "InvoiceItem.count" do
            @subscription.process_switch_plan!({:tier => '2', :size => 'small'})
            run_timely_jobs
          end
        end
      end
    end
    
  end
  
  test "delay create subscription if customer is flagged as processing-invoice" do
    
    @user = FactoryGirl.create(:user)
    @user.flag_as_processing_invoice!
    
    assert_no_difference "Stripe::Invoice::STORE.length" do
      assert_no_difference "InvoiceItem.count" do
        assert_raises Errors::UserAlreadyProcessingInvoice do
          FactoryGirl.create(:subscription, :user => @user, :size => 'small', :tier => '1')
          run_timely_jobs(:raise_errors => true)
        end
      end
    end

    @user.invoice_processing_done!
    assert_difference "Invoice.count" do
      assert_difference "Subscription.count" do
        FactoryGirl.create(:subscription, :user => @user, :size => 'small', :tier => '1')
        run_timely_jobs
      end
    end
    
  end

  test "delay reup if customer is flagged as processing-invoice" do
    @subscription = FactoryGirl.create(:subscription, :size => 'small', :tier => '1')
    run_timely_jobs; @subscription.reload
    assert @subscription.valid?, @subscription.errors.full_messages.to_sentence
    
    @subscription.update_attribute(:orders_remaining, 0)
    
    @subscription.user.flag_as_processing_invoice!
    assert_difference "Invoice.count" do
      assert_no_difference "InvoiceItem.count" do
        assert_no_difference "Stripe::InvoiceItem::STORE.length" do
          assert_no_difference "Stripe::Invoice::STORE.length" do
            assert_raises Errors::UserAlreadyProcessingInvoice do
              @subscription.reup!
              run_timely_jobs(:raise_errors => true)
            end
          end
        end
      end
    end

    @subscription.user.invoice_processing_done!
    assert_no_difference "Invoice.count" do
      @subscription.reup!
      run_timely_jobs
    end
    
  end
  
  test "delay change subscription if customer is flagged as processing-invoice" do
    @subscription = FactoryGirl.create(:subscription, :size => 'small', :tier => '1')
    run_timely_jobs
    assert @subscription.valid?, @subscription.errors.full_messages.to_sentence

    assert_difference "Invoice.count" do
      assert_enqueued_with({:job => ChangePlanInvoice::CreateJob}) do
        @subscription.process_switch_plan!({:tier => '2', :size => 'small'})
        assert @subscription.errors.empty?, @subscription.errors.full_messages.to_sentence
      end
      run_timely_jobs
      assert_equal Subscription::TIERS[@subscription.reload.tier], @subscription.reload.orders_remaining
    end
    
    @subscription.user.flag_as_processing_invoice!
    assert_no_difference "Invoice.count" do
      assert_no_enqueued_jobs do
        @subscription.process_switch_plan!({:tier => '3', :size => 'small'})
      end
    end
  end
  
  test "switch plan with bad card" do
    @subscription = FactoryGirl.create(:subscription, :tier => '2', :size => 'medium')
    run_timely_jobs; @subscription.reload
    Stripe::Invoice.any_instance.stubs(:pay).raises(Stripe::CardError.new('Your card was declined.', 'test2','test3'))

    assert_enqueued_with(job: ChangePlanInvoice::PayJob) do
      assert_enqueued_with({:job => ChangePlanInvoice::CreateJob}) do
        @subscription.process_switch_plan!({:tier => '3', :size => 'large', :great_coffee_ids => (1..3).map{ FactoryGirl.create(:great_coffee).id }})
      end
    
      assert_no_change "@subscription.reload.attributes.slice('tier', 'size', 'orders_remaining')" do
        assert_no_change "@subscription.subscribed_coffees.pluck(:great_coffee_id).sort" do
          # assert_difference "Alerter.deliveries.length", 2 do
            assert_no_difference "Invoice.find_paid.count" do
              assert_difference "Invoice.count" do
                assert_no_difference "Stripe::Invoice::STORE.select{|k,v|v.paid}.length" do
                  assert_difference "Stripe::Invoice::STORE.length" do
                    run_timely_jobs(:silence_errors => true)
                    run_jobs(:silence_errors => true)
                  end
                end
              end
            # end
          end
        end
      end
    end
    
    Stripe::Invoice.any_instance.unstub(:pay)
    
    assert_equal 1, enqueued_jobs.length
    
    assert_change "@subscription.reload.attributes.slice('tier', 'size', 'orders_remaining')" do
      assert_change "@subscription.subscribed_coffees.pluck(:great_coffee_id).sort" do
        assert_difference "Stripe::Invoice::STORE.select{|k,v| v.paid}.length" do
          assert_difference "Invoice.find_paid.count" do
            assert_no_difference "Invoice.count" do
              assert_no_difference "Stripe::Invoice::STORE.length" do
                assert_enqueued_jobs -1 do
                  run_jobs
                  assert_equal 0, enqueued_jobs.length
                end
              end
            end
          end
        end
      end
    end
    
  end
  
  test "create invoice" do
    assert_difference "Invoice.count" do
      assert_difference %Q{Invoice.where("invoices.store -> 'paid' = 'true'").count} do
        @subscription = FactoryGirl.create(:subscription, :tier => 1, :size => 'small')
        run_timely_jobs
      end
    end
  end
  
  test "create" do
    
    @subscription = FactoryGirl.create(:subscription, :tier => 1, :size => 'small')
    run_timely_jobs; @subscription.reload
    assert_equal 1, @subscription.orders_remaining
    assert_equal 1, @subscription.subscribed_coffees.count

    @subscription = FactoryGirl.create(:subscription, :tier => 1, :size => 'medium')
    run_timely_jobs; @subscription.reload
    assert_equal 1, @subscription.orders_remaining
    assert_equal 2, @subscription.subscribed_coffees.count

    @subscription = FactoryGirl.create(:subscription, :tier => 1, :size => 'large')
    run_timely_jobs; @subscription.reload
    assert_equal 1, @subscription.orders_remaining
    assert_equal 3, @subscription.subscribed_coffees.count

    @subscription = FactoryGirl.create(:subscription, :tier => 2, :size => 'small')
    run_timely_jobs; @subscription.reload
    assert_equal 4, @subscription.orders_remaining
    assert_equal 1, @subscription.subscribed_coffees.count

    @subscription = FactoryGirl.create(:subscription, :tier => 2, :size => 'medium')
    run_timely_jobs; @subscription.reload
    assert_equal 4, @subscription.orders_remaining
    assert_equal 2, @subscription.subscribed_coffees.count

    @subscription = FactoryGirl.create(:subscription, :tier => 2, :size => 'large')
    run_timely_jobs; @subscription.reload
    assert_equal 4, @subscription.orders_remaining
    assert_equal 3, @subscription.subscribed_coffees.count

    @subscription = FactoryGirl.create(:subscription, :tier => 3, :size => 'small')
    run_timely_jobs; @subscription.reload
    assert_equal 26, @subscription.orders_remaining
    assert_equal 1, @subscription.subscribed_coffees.count

    @subscription = FactoryGirl.create(:subscription, :tier => 3, :size => 'medium')
    run_timely_jobs; @subscription.reload
    assert_equal 26, @subscription.orders_remaining
    assert_equal 2, @subscription.subscribed_coffees.count

    @subscription = FactoryGirl.create(:subscription, :tier => 3, :size => 'large')
    run_timely_jobs; @subscription.reload
    assert_equal 26, @subscription.orders_remaining
    assert_equal 3, @subscription.subscribed_coffees.count
    #
    # @subscription = FactoryGirl.create(:subscription, :tier => 5, :size => 'small')
    # run_timely_jobs; @subscription.reload
    # assert_equal 52, @subscription.orders_remaining
    # assert_equal 1, @subscription.subscribed_coffees.count
    #
    # @subscription = FactoryGirl.create(:subscription, :tier => 5, :size => 'medium')
    # run_timely_jobs; @subscription.reload
    # assert_equal 52, @subscription.orders_remaining
    # assert_equal 2, @subscription.subscribed_coffees.count
    #
    # @subscription = FactoryGirl.create(:subscription, :tier => 5, :size => 'large')
    # run_timely_jobs; @subscription.reload
    # assert_equal 52, @subscription.orders_remaining
    # assert_equal 3, @subscription.subscribed_coffees.count

  end
  
  test "validations" do
    @subscription = FactoryGirl.build(:subscription)
    assert @subscription.valid?
    
    @subscription.day = nil
    assert [email protected]?
    assert @subscription.errors[:day]
    @subscription.day = Day.first
    assert @subscription.valid?
    
    @subscription.day.update_attribute(:active, false)
    assert [email protected]?
    assert @subscription.errors[:active]
    @subscription.day.update_attribute(:active, true)
    assert @subscription.valid?
    
    @subscription.great_coffees = []
    @subscription.subscribed_coffees = []
    assert [email protected]?
    assert @subscription.errors[:subscribed_coffees]
    @subscription.great_coffees << GreatCoffee.first
    assert @subscription.valid?
    
    @subscription.address = nil
    assert [email protected]?
    assert @subscription.errors[:address]
    @subscription.address = @subscription.user.addresses.first
    assert @subscription.valid?
  end
  
  # TODO: test switch plan invalid
  
  test "switch plan size" do
    @subscription = FactoryGirl.create(:subscription, :tier => '1', :size => 'small')
    run_timely_jobs; @subscription.reload
    @day = @subscription.day
    travel_to(@day.payment_time_for_next_cutoff - 1.second) do
      diff = Subscription::PRICING['1']['medium'] - Subscription::PRICING['1']['small']
      assert_difference(%Q{Invoice.where("invoices.store -> 'amount' = ?", diff.to_s).count}) do
        assert_difference "Invoice.find_paid.count" do
          assert_difference "Invoice.count" do
            
            # 1 refund InvoiceItem and 1 charge InvoiceItem
            assert_difference "@subscription.user.invoice_items.count", 2 do
              assert_no_difference "@subscription.reload.orders_remaining" do
                @subscription.process_switch_plan!({:tier => @subscription.tier, :size => 'medium', :great_coffee_ids => GreatCoffee.limit(1).pluck(:id)*2})
                run_timely_jobs
              end
            end
          end
        end
      end
    end
    
  end
  
  test "switch plan tier" do
    
    @subscription = FactoryGirl.create(:subscription, :tier => '1', :size => 'small')
    run_timely_jobs
    @day = @subscription.day
    
    travel_to(@day.payment_time_for_next_cutoff - 1.second) do
      orders_remaining = @subscription.reload.orders_remaining
      diff = Subscription::PRICING['2']['small'] - (Subscription::PRICING['1']['small']/Subscription::TIERS['1']) * @subscription.orders_remaining
      assert_difference "@subscription.reload.orders_remaining", Subscription::TIERS['2'] - orders_remaining do
        assert_difference(%Q{Invoice.where("invoices.store -> 'amount' = ?", diff.to_s).count}) do
          assert_difference "Invoice.find_paid.count" do
            assert_difference "Invoice.count" do
              @subscription.process_switch_plan!({:tier => '2', :size => @subscription.size})
              run_timely_jobs
            end
          end
        end
      end
    end
    
  end
  
  test "auto switch to weekly" do
    @subscription = FactoryGirl.create(:subscription, :on_end => 'switch-to-base', :tier => 3, :size => 'medium')
    run_timely_jobs; @subscription.reload
    assert_equal '3', @subscription.reload.tier
    assert_equal 26, @subscription.orders_remaining

    @subscription.update_attribute(:orders_remaining, 1)
    
    assert_no_difference "Invoice.find_paid.count" do
      assert_no_difference "InvoiceItem.count" do
        assert_no_difference "Invoice.count" do
          assert_change "@subscription.tier", "1" do
            assert_no_change "@subscription.size" do
              @subscription.decrement_orders_remaining!
              run_timely_jobs
            end
          end
        end
      end
    end
    assert_equal '1', @subscription.reload.tier
    assert_equal 'medium', @subscription.size
    assert_equal 'active', @subscription.status
    assert_equal 0, @subscription.orders_remaining
  end
  
  test "cancel subscription" do
    @subscription = FactoryGirl.create(:subscription)
    run_timely_jobs
    
    assert_change "@subscription.reload.status", 'paused' do
      @subscription.pause!
    end
    
    assert_no_difference "Invoice.count" do
      assert_no_difference "@subscription.reload.orders_remaining" do
        assert_no_difference "Order.count" do
          @subscription.create_order!
        end
      end
    end
    
    assert_no_difference "Invoice.count" do
      assert_no_difference "@subscription.reload.orders_remaining" do
        assert_difference "Alerter::MESSAGES.length" do
          @subscription.reup!
        end
      end
    end
  end
  
  test "put plan on hold" do
    @subscription = FactoryGirl.create(:subscription, :tier => '1')
    run_timely_jobs; @subscription.reload
    @subscription.update_attribute(:orders_remaining, 0)
    
    assert_difference "@subscription.reload.orders_remaining" do
      @subscription.reup!; run_timely_jobs
    end
    
    @subscription.update_attribute(:orders_remaining, 0)
    @subscription.pause!
    
    assert_no_difference "@subscription.reload.orders_remaining" do
      assert_no_difference "Invoice.count" do
        @subscription.reup!; run_timely_jobs
      end
    end
    
  end
  
  # TODO: test pricing on dup plans
  
  test "complimentary order" do
    @subscription = FactoryGirl.create(:subscription, :size => 'medium', :tier => '3')
    run_timely_jobs
    @user = @subscription.user
    
    assert_equal 26, @user.reload.points
    
    Stripe::Invoice.any_instance.stubs(:pay).raises(Stripe::CardError.new('Your card was declined.', 'test2','test3'))
    @subscription.reload.update_attribute(:orders_remaining, 0)
    
    assert @subscription.reload.reup_ready?, "not reup ready"
    assert @subscription.user.reload.deserves_complimentary_order?
    
    assert_difference "@subscription.reload.orders_remaining" do
      assert_mail_difference({:to => @subscription.email, :subject => Mailer.failed_reup(@subscription, true).subject}) do
        @subscription.reup!
        run_timely_jobs
      end
    end
    
  end
  
  test "create subscription adds points" do
    @user = FactoryGirl.create(:user)
    @address = FactoryGirl.create(:address, :user => @user)
    tier = '2'

    assert_difference "@user.reload.points", 1 do
      FactoryGirl.create(:subscription, :user => @user, :tier => '1')
      run_timely_jobs
    end

    assert_difference "@user.reload.points", 4 do
      FactoryGirl.create(:subscription, :user => @user, :tier => '2')
      run_timely_jobs
    end

    assert_difference "@user.reload.points", 26 do
      @subscription = FactoryGirl.create(:subscription, :user => @user, :tier => '3')
      run_timely_jobs
    end

    # assert_difference "@user.reload.points", 26 do
    #   FactoryGirl.create(:subscription, :user => @user, :tier => '4')
    #   run_timely_jobs
    # end
    #
    # assert_difference "@user.reload.points", 52 do
    #   @subscription = FactoryGirl.create(:subscription, :user => @user, :tier => '5')
    #   run_timely_jobs
    # end
    
    assert_no_difference "@user.reload.points" do
      assert_difference "@subscription.orders.count" do
        assert_difference "@subscription.reload.orders_remaining", -1 do
          @subscription.create_order!
        end
      end
    end

  end
  
  test "reup subscription schedule" do
    @subscription = FactoryGirl.create(:subscription, {:tier => '2', :size => 'small'})
    assert_equal 'switch-to-base', @subscription.reload.on_end
    run_timely_jobs and @subscription.reload
    @day = @subscription.day

    @subscription.update_attribute(:orders_remaining, 1)
    
    assert_difference '@subscription.reload.orders_remaining', -1 do
      assert_difference '@subscription.orders.count' do
        @subscription.create_order!
      end
    end
    
    ChargeSubscriptionsJob.set(:wait_until => @day.next_charge_cutoff).perform_later(@day.id)

    travel_to @day.next_charge_cutoff - 1.second do
      assert_no_difference "@subscription.orders_remaining" do
        assert_no_difference "Invoice.count" do
          run_timely_jobs
        end
      end
    end
    
    travel_to @day.next_charge_cutoff + 1.second do
      assert_equal 'switch-to-base', @subscription.reload.on_end
      
      assert_difference "@subscription.reload.orders_remaining", 1 do
        assert_difference "Invoice.find_paid.count" do
          assert_difference "Invoice.count" do
            run_timely_jobs
          end
        end
      end
    end
    
  end
  
end