shop_bunny 0.8.5 → 0.8.6

data/spec/models/cart_spec.rb

@@ -0,0 +1,344 @@
+require 'spec_helper'
+
+describe Cart do
+  include ShopBunny
+  it { should have_many :cart_items}
+  
+  context "A Cart" do
+    before(:each) do
+      @article1 = Item.make(:price => 10.0)
+      @article2 = Item.make(:price => 20.0)
+      @cart = Cart.make
+    end    
+    
+    it "should be able to add articles" do
+      proc {@cart.add_item(@article1, :quantity => 1)}.should change(@cart, :item_count).by(1)
+      @cart.items.size.should be(1)
+      @cart.item_sum.should be_within(0.01).of(10)
+      proc {@cart.add_item(@article2, :quantity => 1)}.should change(@cart, :item_count).by(1)
+      @cart.items.size.should be(2)
+      @cart.item_sum.should be_within(0.01).of(30)
+      proc {@cart.add_item(@article1, :quantity => 3)}.should change(@cart, :item_count).by(3)
+      @cart.items.size.should be(2)
+      @cart.item_sum.should be_within(0.01).of(60)
+    end    
+    
+    it "should be able to set a default quantity with 1" do
+      proc {@cart.add_item(@article1)}.should change(@cart, :item_count).by(1)      
+    end
+       
+    it "passes shipping_cost requests to the shipping costs calculator" do
+      calculator = mock()
+      calculator.expects(:costs_for).with(@cart, anything).once
+      
+      @cart.stubs(:shipping_cost_calculator).returns(calculator)
+      @cart.shipping_costs
+      
+      calculator = mock()
+      calculator.expects(:costs_for).with(@cart, :net_costs => true).once
+      
+      @cart.stubs(:shipping_cost_calculator).returns(calculator)
+      
+      @cart.shipping_costs(:net_costs => true)
+    end
+
+    describe "#items_with_coupons" do
+      it "might return a negative value" do
+        @cart.stubs(:item_sum).returns(100.0)
+        @cart.coupons << Coupon.make(:discount_credit => 110)
+        @cart.items_with_coupons.should == -10.0
+      end
+    end
+
+    describe "adding coupons using #coupons<<" do
+      it "adds a coupon though CouponUse" do
+        coupon = Coupon.make
+        add_a_coupon = lambda {
+          @cart.coupons << coupon
+        }
+        add_a_coupon.should change { @cart.coupons.count }.by(1)
+        add_a_coupon.should change { CouponUse.count }.by(1)
+      end
+
+      it "adds a Coupon only once" do
+        coupon = Coupon.make
+        lambda {
+          @cart.coupons << coupon
+          @cart.coupons << coupon
+        }.should change { @cart.coupons.count }.by(1)
+      end
+    end
+
+    context "#empty" do
+      it "knows that it is empty when empty" do
+        @cart.cart_items.should be_empty
+        @cart.should be_empty
+      end
+
+      it "is not empty when havin a bonus article" do
+        @item = Item.make
+        @coupon = Coupon.make(:bonus_article => @item)
+        @cart.coupon_code = @coupon.code
+        @cart.save
+        @cart.should_not be_empty
+      end
+    end
+       
+    context "with an article" do
+      before(:each) do
+        @cart.add_item(@article1, :quantity => 10)
+      end
+      
+      it "should destroy empty cart_items" do
+        @cart.cart_items.first.update_attribute :quantity, 0        
+        @cart.cart_items.should be_empty
+      end
+
+      it "should be able to remove all occurences of an article in the cart" do
+        # FIXME DRY?
+        article1_count = @cart.cart_items.select {|ci| ci.item == @article1}.first.quantity
+        @cart.item_count.should be(article1_count)
+        proc {@cart.remove_item(@article1)}.should change(@cart, :item_count).by(-1 * article1_count)
+        
+        @cart.item_count.should be(0)
+        
+        @cart.add_item(@article1, :quantity => 10)
+        proc {@cart.remove_item(@article1, :quantity => 100)}.should change(@cart, :item_count).to(0)
+        @cart.cart_items.should be_empty
+      end
+
+      it "should be able to set the quantity of an article directly" do
+        proc {@cart.update_item(@article1, :quantity => 5)}.should change(@cart, :item_count).to(5)
+      end  
+      
+      it "JSON representation should include cart_items" do
+        decoded = ActiveSupport::JSON.decode(@cart.to_json)
+        decoded['cart']['cart_items'].should_not be_empty 
+        # FIXME Test existence of other values like, total, coupons etc.
+      end
+    end
+    
+    context "adding coupons with #coupon_code=" do
+      it "should show an error when adding an incorrect coupon code" do
+        @cart.coupon_code = "incorrectcode"
+        @cart.should_not be_valid        
+        @cart.errors[:coupon_code].should_not be_nil
+      end
+
+      it "should add a coupon after save via coupon_code=" do
+        coupon = Coupon.make(:percent20off)
+        @cart.coupon_code = coupon.code
+        @cart.coupons.should be_empty
+        @cart.save
+        @cart.coupons.should include coupon
+      end
+
+      it "with max_uses=1 via coupon_code= should not invalidate the cart" do
+        coupon = Coupon.make(:max_uses => 1)
+        @cart.coupon_code = coupon.code
+        @cart.save!
+        @cart.should be_valid
+      end
+
+      it "should create coupon_uses" do
+        coupon = Coupon.make
+        @cart.coupon_code = coupon.code
+        lambda {
+          @cart.save!
+        }.should change { coupon.coupon_uses.count }.by(1)
+      end
+
+      it "should only add one coupon of a kind" do
+        coupon = Coupon.make(:percent20off)
+        
+        @cart.coupon_code = coupon.code
+        @cart.coupons.should be_empty
+        @cart.save
+        @cart.reload
+        
+        @cart.coupons.should include coupon
+        @cart.coupons.size.should == 1
+        
+        @cart.coupon_code = ""
+        @cart.save
+        @cart.reload
+        
+        @cart.coupons.size.should == 1
+        @cart.coupon_code = coupon.code
+        @cart.save
+        @cart.reload
+
+        @cart.coupons.size.should == 1
+      end
+
+      it "should not add a coupon if they are all used up" do
+        coupon = Coupon.make(:percent20off)
+        coupon.max_uses = -1
+        coupon.save
+        @cart.coupon_code = coupon.code
+        @cart.coupons.should be_empty
+        @cart.save
+        @cart.reload
+        @cart.coupons.size.should == 0
+      end
+    end
+    context "with bonusarticle" do
+      before do
+        @item = Item.make
+        @coupon = Coupon.make(:bonus_article => @item)
+        @coupon2 = Coupon.make()
+        @cart.coupon_code = @coupon.code
+        @cart.save
+        @cart.coupon_code = @coupon2.code
+        @cart.save
+      end
+
+      it "should contain the bonus item" do
+        @cart.bonus_items.should include @item
+      end
+
+      it "should not contain nil articles in bonus articles" do
+        @cart.coupons.size.should == 2
+        @cart.bonus_items.size.should == 1
+      end
+    end
+
+    context "with mutiple articles" do
+      before(:each) do
+        @article3 = Item.make(:price => 30.3)
+        @cart.add_item(@article1, :quantity => 10)
+        @cart.add_item(@article2, :quantity => 2)
+        @cart.add_item(@article3, :quantity => 4)
+      end
+
+      it "should be able to calculate the sum" do
+        @cart.item_sum.should be_within(0.01).of(10*10.0+2*20.0+4*30.3)
+      end
+      
+      it "can clear all items and coupons from the cart" do
+        @cart.cart_items.size.should be > 0
+        a_cart_item = @cart.cart_items.last
+        
+        coupon = Coupon.make()
+        @cart.coupons << coupon
+        @cart.save!
+        @cart.reload
+        @cart.coupons.size.should be > 0
+        a_coupon_use = @cart.coupon_uses.last
+        
+        @cart.clear!
+        @cart.cart_items.size.should be 0
+        @cart.coupons.size.should be 0
+
+        CartItem.find_by_id(a_cart_item.id).should be_nil
+        CouponUse.find_by_id(a_coupon_use.id).should be_nil
+      end
+      
+      
+      context "and coupons" do
+        it "should calculate the sum with a 20% off coupon" do
+          @cart.coupons << Coupon.make(:percent20off)
+          @cart.total.should be_within(0.01).of(@cart.item_sum*0.8 + @cart.shipping_costs)
+        end
+        
+        it "should reduce items sum by 10" do
+          @cart.coupons << Coupon.make(:euro10)
+          @cart.total.should be_within(0.01).of(@cart.item_sum - 10 + @cart.shipping_costs)
+        end
+        
+        it "should be no shipping costs with a coupon" do
+          @cart.shipping_costs.should be_within(0.01).of(8.90)
+          @cart.coupons << Coupon.make(:shipping)
+          @cart.shipping_costs.should be_within(0.01).of(0)
+        end
+        
+        it "can not have a negative total" do
+          @cart.total.should >(0)
+
+          @cart.coupons << Coupon.make(:euro10, :discount_credit => @cart.total + 10)
+
+          @cart.total.should be_within(0.01).of(0)
+        end
+        
+      end
+    end
+    
+    context "automatic coupons" do
+      it "adds coupons automatically which are valid (datewise) and are set to be enabled automatically at a certain total price of a cart" do
+        expensive_product = Item.make(:price => 50.01)
+        intermediate_mock = mock
+        Coupon.stubs(:valid).returns(intermediate_mock)
+        bonus_coupon = Coupon.make
+        intermediate_mock.expects(:automatically_added_over).with(expensive_product.price).returns([bonus_coupon])
+        @cart.add_item(expensive_product)
+        @cart.coupons.should == [bonus_coupon]
+      end
+      
+      it "never adds an automatic coupon twice" do
+        coupon = Coupon.make(:value_of_automatic_add => 10)
+        item = Item.make(:price => 10)
+        @cart.clear!
+        @cart.add_item(item)
+        @cart.add_item(item)
+        @cart.coupons.should include coupon
+        @cart.coupons.count.should be
+      end
+      
+      it "it removes automatically added coupons that are not longer applicable from the cart whenever an item is removed" do
+        coupon1 = Coupon.make(:value_of_automatic_add => 10)
+        coupon2 = Coupon.make(:value_of_automatic_add => 15)
+        
+        item1 = Item.make(:price => 12)
+        item2 = Item.make(:price =>  3)
+        
+        @cart.clear!
+        @cart.add_item(item1)
+        @cart.add_item(item2)
+        @cart.coupons.size.should be 2
+        @cart.coupons.should include(coupon1)
+        @cart.coupons.should include(coupon2)
+        
+        @cart.remove_item(item2)
+        @cart.coupons.size.should be 1
+        @cart.coupons.should include(coupon1)
+        
+        @cart.remove_item(item1)
+        @cart.coupons.size.should be 0
+      end
+      
+      it "coupons reappear when the cart had enough items, the user then removed some so that the coupon wasn't automatically applicable anymore and then adds more items to the cart" do
+        coupon = Coupon.make(:value_of_automatic_add => 10)
+        
+        item1 = Item.make(:price => 5)
+        item2 = Item.make(:price => 6)
+        item3 = Item.make(:price => 7)
+        
+        @cart.clear!
+        @cart.add_item(item1)
+        @cart.add_item(item2)
+        @cart.remove_item(item2)
+        @cart.add_item(item3)
+        
+        @cart.coupons.size.should be 1
+        @cart.coupons.should include(coupon)
+      end
+      
+      it "adds or removes the coupon when updating a cart item" do
+        coupon = Coupon.make(:value_of_automatic_add => 10)
+        item = Item.make(:price => 5)
+        
+        @cart.clear!
+        @cart.add_item(item)
+        @cart.coupons.size.should be 0
+        
+        @cart.update_item(item, :quantity => 2)
+        @cart.coupons.size.should be 1
+        @cart.coupons.should include(coupon)
+        
+        @cart.update_item(item, :quantity => 1)
+        @cart.coupons.size.should be 0
+      end
+    end
+    
+  end
+end

data/spec/models/shop_bunny/cart_item_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+  
+describe ShopBunny::CartItem do
+  include ShopBunny
+
+  before(:each) do
+    @cart_item = CartItem.make
+    @cart_item.item = Item.new
+  end
+
+  it {should belong_to :cart}
+  it {should_not belong_to :item}
+  it {should validate_presence_of :cart_id }
+  it {should validate_numericality_of(:quantity)}
+  
+  it "knows it's total price" do
+    @cart_item.item.price = 10
+
+    @cart_item.total_price.should be_within(0.001).of(10)
+    
+    @cart_item.quantity = 5
+    
+    @cart_item.total_price.should be_within(0.001).of(50)
+  end
+  
+  describe "item marshalling" do
+    it "marshalls it's item and reloads it on request" do
+      item = Item.make
+      @cart_item.item = item
+      @cart_item.raw_item.should == item.shop_bunny_json_attributes.to_json
+      @cart_item.item.should == item
+    end
+    
+    it "is possible to create an item with an item with create or new" do
+      item = Item.make
+      cart_item = CartItem.new(:item => item)
+      cart_item.item.should == item
+    end
+    
+    it "uses the shop_bunny_json_attributes method method to marshal if present" do
+      item = Object.new
+      item.expects(:respond_to?).with(:shop_bunny_json_attributes).returns(true)
+      item.expects(:shop_bunny_json_attributes).returns({})
+      
+      cart_item = CartItem.new(:item => item)
+    end
+    
+    it "uses the attributes method to marshal if the item has no shop_bunny_json_attributes method" do
+      item = Object.new
+      item.expects(:respond_to?).with(:shop_bunny_json_attributes).returns(false)
+      item.expects(:attributes).returns({})
+      
+      cart_item = CartItem.new(:item => item)
+    end
+  end
+end

data/spec/models/shop_bunny/coupon_spec.rb

@@ -0,0 +1,177 @@
+require 'spec_helper'
+
+describe ShopBunny::Coupon do
+  include ShopBunny
+  subject { Coupon.make }  
+  it {should validate_presence_of :title }
+  it {should validate_presence_of :code }
+  it {should validate_uniqueness_of :code }
+  
+  it "should not be expired by default" do
+    Coupon.make.should_not be_expired
+  end
+  
+  it "should be valid within the given range" do
+    coupon = Coupon.make(:daterange)
+    Time.stubs(:now).returns(Time.local(2010,9,14).to_time)
+    coupon.should_not have_expired
+    coupon.should_not be_not_yet_valid
+    coupon.should be_redeemable
+    Time.stubs(:now).returns(Time.local(2010,2,2).to_time)
+    coupon.reload.should_not have_expired
+    coupon.should be_not_yet_valid
+    coupon.should_not be_redeemable
+    Time.stubs(:now).returns(Time.local(2010,9,22).to_time)
+    coupon.should have_expired
+    coupon.should_not be_redeemable
+    coupon.should_not be_not_yet_valid
+  end
+
+  describe "#state" do
+    it "is inactive by default" do
+      Coupon.new.state.should == 'inactive'
+    end
+
+    it "can be overwritten" do
+      Coupon.new(:state => 'active').state.should == 'active'
+      Coupon.make(:state => 'redeemed').state.should == 'redeemed'
+      Coupon.make(:state => 'inactive').state.should == 'inactive'
+    end
+  end
+
+  describe "#activate!" do
+    it "changes the state from inactive to active" do
+      coupon = Coupon.make(:state => 'inactive')
+      coupon.activate!
+      coupon.state.should == 'active'
+    end
+
+    it "fails for all other states" do
+      %w(active redeemed).each do |state|
+        lambda { Coupon.make(:state => state).activate! }.should raise_error(Coupon::InvalidEvent)
+      end
+    end
+
+    it "saves the record" do
+      coupon = Coupon.make_unsaved(:state => 'inactive')
+      coupon.activate!
+      coupon.should be_persisted
+    end
+  end
+
+  describe "#redeem!" do
+    it "changes the state from active to redeemed" do
+      coupon = Coupon.make(:state => 'active')
+      coupon.redeem!
+      coupon.state.should == 'redeemed'
+    end
+
+    it "fails for all other states" do
+      %w(inactive redeemed).each do |state|
+        lambda { Coupon.make(:state => state).redeem! }.should raise_error(Coupon::InvalidEvent)
+      end
+    end
+
+    it "fails if redeemable? returns false" do
+      lambda {
+        coupon = Coupon.make(:state => 'active')
+        coupon.stubs(:redeemable?).returns(false)
+        coupon.redeem!
+      }.should raise_error
+    end
+
+    it "saves the record" do
+      coupon = Coupon.make_unsaved
+      coupon.redeem!
+      coupon.should be_persisted
+    end
+  end
+
+  describe "#redeemable?" do
+    it "is false by default" do
+      Coupon.new.redeemable?.should be_false
+    end
+
+    it "is only true if state is active" do
+      %w(inactive active redeemed).each do |state|
+        Coupon.make(:state => state).redeemable?.should == (state == 'active')
+      end
+    end
+
+    it "is false if it is used_up" do
+      coupon = Coupon.make
+      coupon.stubs(:used_up?).returns(true)
+      coupon.should_not be_redeemable
+    end
+  end
+
+  describe "#used_up?" do
+    it "becomes true if used one time" do
+      coupon = Coupon.make(:max_uses => 1)
+      coupon.should_not be_used_up
+      Cart.make(:coupon_code => coupon.code)
+      coupon.reload.should be_used_up
+    end
+
+    it "becomes true if max_uses is reached" do
+      coupon = Coupon.make(:max_uses => 2)
+      coupon.should_not be_used_up
+      2.times { Cart.make(:coupon_code => coupon.code) }
+      coupon.should be_used_up
+    end
+
+    it "is true if max_uses is zero" do
+      coupon = Coupon.make(:max_uses => 0)
+      coupon.should be_used_up
+    end
+
+    it "never becomes true if max_uses is blank (unlimited)" do
+      coupon = Coupon.make(:max_uses => nil)
+      coupon.should_not be_used_up
+      2.times { Cart.make(:coupon_code => coupon.code) }
+      coupon.should_not be_used_up
+    end
+  end
+
+  context "scopes" do
+    it "can find the valid coupons" do
+      Coupon.destroy_all # rspec bug?
+      Time.stubs(:now).returns(Time.local(2010,9,22,14,31).to_time)
+      
+      valid_coupon = Coupon.make
+      valid_coupon.valid_from = Time.local(2010,9,22,14,30).to_datetime
+      valid_coupon.valid_until = Time.local(2010,9,25,17,30).to_datetime
+      valid_coupon.save!
+      
+      invalid_coupon1 = Coupon.make
+      invalid_coupon1.valid_from = Time.local(2010,9,21,10,30).to_datetime
+      invalid_coupon1.valid_until = Time.local(2010,9,22,14,29).to_datetime
+      invalid_coupon1.save!
+      
+      invalid_coupon2 = Coupon.make
+      invalid_coupon2.valid_from = Time.local(2010,9,25,17,31).to_datetime
+      invalid_coupon2.valid_until = Time.local(2010,9,26,15,00).to_datetime
+      invalid_coupon2.save!
+
+      inactive_coupon = Coupon.make(:state => 'inactive')
+      
+      coupon_without_dates = Coupon.make(:valid_from => nil, :valid_until => nil)
+      
+      Coupon.valid.size.should be 2
+      Coupon.valid.should include valid_coupon
+      Coupon.valid.should include coupon_without_dates
+
+      (Coupon.all - Coupon.valid).should include inactive_coupon
+    end
+    
+    it "can find coupons with an automatic add value less than the given value" do
+      [10.50, 50, 2].each do |value|
+        lambda {
+          coupon = Coupon.make(:value_of_automatic_add => value)
+          Coupon.make(:value_of_automatic_add => nil)
+          Coupon.automatically_added_over(value).should include(coupon)
+        }.should change { Coupon.automatically_added_over(value).count }.by(1)
+      end
+    end
+  end
+end

data/spec/models/shop_bunny/coupon_use_spec.rb

@@ -0,0 +1,6 @@
+require 'spec_helper'
+
+describe ShopBunny::CouponUse do
+  it { should validate_presence_of :cart_id }
+  it { should validate_presence_of :coupon_id }  
+end

data/spec/requests/shop_bunny/shopping_spec.rb

@@ -0,0 +1,119 @@
+require 'spec_helper'
+
+describe "On the cart page" do
+  def add_coupon_code(code)
+    fill_in 'Coupon code', :with => code
+    click_button 'Add coupon'
+  end
+
+  def add_item(item)
+    within "#item_#{item.id}" do
+      click_link "Add to cart"
+    end
+  end
+
+  def remove_item(item)
+    click_link "Remove item #{item.id}"
+  end
+
+  def assert_no_errors
+    find('#error_messages').should have_no_selector('li')
+  end
+
+  before do
+    @item = Item.make(:price => 10)
+    visit cart_path
+  end
+
+  it "shows the expected price numbers for an empty cart" do
+    find('#price-item-sum').should have_content("$0.0")
+    find('#price-shipping-costs').should have_content("$8.90")
+    find('#price-total').should have_content("$8.90")
+  end
+
+  describe "adding an item to the cart" do
+    it "updates the price" do
+      add_item(@item)
+      find('#price-total').should have_content("$18.90")
+    end
+
+    it "lists the item" do
+      add_item(@item)
+      find('#cart .items').should have_content("Remove item #{@item.id}")
+    end
+  end
+
+  describe "removing an item from the cart" do
+    before { add_item(@item) }
+    it "resets the price" do
+      lambda {
+        remove_item(@item)
+      }.should change { find('#price-total').text }.from("$18.90").to("$8.90")
+    end
+
+    it "removes the item" do
+      find('#cart .items').should have_content("Remove item #{@item.id}")
+      remove_item(@item)
+      find('#cart .items').should have_no_content("Remove item #{@item.id}")
+    end
+  end
+
+  describe "adding coupons" do
+    it "does not show an error if the code is ok" do
+      coupon = ShopBunny::Coupon.make
+      add_coupon_code(coupon.code)
+      assert_no_errors
+    end
+
+    it "does not show an error for one-time coupons" do
+      coupon = ShopBunny::Coupon.make(:max_uses => 1)
+      add_coupon_code(coupon.code)
+      assert_no_errors
+    end
+
+    it "lists the newly added coupon" do
+      coupon = ShopBunny::Coupon.make(:title => "New Coupon")
+      add_coupon_code(coupon.code)
+      find('#your_coupons').should have_content("New Coupon")
+    end
+
+    it "removes the coupon's credit from the total price" do
+      coupon = ShopBunny::Coupon.make(:discount_credit => 5)
+      lambda {
+        add_coupon_code(coupon.code)
+      }.should change { find('#price-total').text }.from("$8.90").to("$3.90")
+    end
+
+    it "does not show a negative total price" do
+      coupon = ShopBunny::Coupon.make(:discount_credit => 10)
+      lambda {
+        add_coupon_code(coupon.code)
+      }.should change { find('#price-total').text }.from("$8.90").to("$0.00")
+    end
+
+    it "shows an error if the code is unknown" do
+      add_coupon_code('unknown')
+      find('#error_messages').should have_content("The provided code is unknown or invalid")
+    end
+
+    it "shows an error if the code is expired" do
+      expired = ShopBunny::Coupon.make(:expired)
+      add_coupon_code(expired.code)
+      find('#error_messages').should have_content("The provided code has expired")
+      page.should have_no_selector('#your_coupons')
+    end
+
+    it "shows an error if the the maximum use count is exceeded" do
+      coupon = ShopBunny::Coupon.make(:max_uses => 1)
+      # use up coupon
+      add_coupon_code(coupon.code)
+      assert_no_errors
+      # try to the same coupon again in a new session
+      reset_session!
+      visit cart_path
+      add_coupon_code(coupon.code)
+      find('#error_messages').should have_content("The number of uses for this code has been exceeded")
+    end
+  end
+end
+