radiant-shop-extension 0.11.6 → 0.90.0

data/spec/lib/shop/tags/package_spec.rb

@@ -1,342 +0,0 @@
-require 'spec/spec_helper'
-
-describe Shop::Tags::Package do
-  
-  dataset :pages, :shop_packages
-  
-  it 'should describe these tags' do
-    Shop::Tags::Package.tags.sort.should == [
-      'shop:packages',
-      'shop:packages:if_packages',
-      'shop:packages:unless_packages',
-      'shop:packages:each',
-      'shop:package',
-      'shop:package:id',
-      'shop:package:name',
-      'shop:package:sku',
-      'shop:package:description',
-      'shop:package:price',
-      'shop:package:value',
-      'shop:package:if_products',
-      'shop:package:unless_products',
-      'shop:package:products',
-      'shop:package:products:each',
-      'shop:package:product:quantity'].sort
-  end
-  
-  before :all do
-    @page = pages(:home)
-  end
-  
-  before :each do
-    @package = shop_packages(:all_bread)
-  end
-  
-  context 'outside a package' do
-    describe '<r:shop:packages>' do
-      context 'packages' do
-        it 'should render' do
-          tag = %{<r:shop:packages>success</r:shop:packages>}
-          exp = %{success}
-
-          @page.should render(tag).as(exp)
-        end
-      end
-      context 'no packages' do
-        it 'should render' do
-          tag = %{<r:shop:packages>success</r:shop:packages>}
-          exp = %{success}
-
-          @page.should render(tag).as(exp)
-        end
-      end
-    end
-    
-    describe '<r:shop:packages:if_packages>' do
-      context 'success' do
-        it 'should render' do
-          tag = %{<r:shop:packages:if_packages>success</r:shop:packages:if_packages>}
-          exp = %{success}
-          
-          @page.should render(tag).as(exp)
-        end
-      end
-      context 'failure' do
-        it 'should render' do
-          mock(Shop::Tags::Helpers).current_packages(anything) { [] }
-          tag = %{<r:shop:packages:if_packages>failure</r:shop:packages:if_packages>}
-          exp = %{}
-          
-          @page.should render(tag).as(exp)
-        end
-      end
-    end
-    
-    describe '<r:shop:packages:unless_packages>' do
-      context 'success' do
-        it 'should not render' do
-          mock(Shop::Tags::Helpers).current_packages(anything) { [] }
-          
-          tag = %{<r:shop:packages:unless_packages>success</r:shop:packages:unless_packages>}
-          exp = %{success}
-          
-          @page.should render(tag).as(exp)
-        end
-      end
-      context 'failure' do
-        it 'should render' do
-          mock(Shop::Tags::Helpers).current_packages(anything) { ShopPackage.all }
-        
-          tag = %{<r:shop:packages:unless_packages>failure</r:shop:packages:unless_packages>}
-          exp = %{}
-          
-          @page.should render(tag).as(exp)
-        end
-      end
-    end
-    
-    describe '<r:shop:packages:each>' do
-      context 'success' do
-        it 'should render' do
-          mock(Shop::Tags::Helpers).current_packages(anything) { ShopPackage.all }
-          
-          tag = %{<r:shop:packages:each>.a.</r:shop:packages:each>}
-          exp = ShopPackage.all.map{ '.a.' }.join('')
-          
-          @page.should render(tag).as(exp)
-        end
-      end
-      
-      context 'failure' do
-        it 'should not render' do
-          mock(Shop::Tags::Helpers).current_packages(anything) { [] }
-          
-          tag = %{<r:shop:packages:each>failure</r:shop:packages:each>}
-          exp = %{}
-          
-          @page.should render(tag).as(exp)
-        end
-      end
-    end
-    
-    describe '<r:shop:package>' do
-      context 'success' do
-        it 'should render' do
-          mock(Shop::Tags::Helpers).current_package(anything) { @package }
-          
-          tag = %{<r:shop:package>success</r:shop:package>}
-          exp = %{success}
-          
-          @page.should render(tag).as(exp)
-        end
-      end
-      
-      context 'failure' do
-        it 'should not render' do
-          mock(Shop::Tags::Helpers).current_package(anything) { nil }
-          
-          tag = %{<r:shop:package>failure</r:shop:package>}
-          exp = %{}
-          
-          @page.should render(tag).as(exp)
-        end
-      end
-    end
-    
-  end
-  
-  context 'within a package' do
-    
-    before :each do
-      mock(Shop::Tags::Helpers).current_package(anything) { @package }
-    end
-    
-    context 'simple attributes' do
-      describe '<r:shop:package:id />' do
-        it 'should render the id' do
-          tag = %{<r:shop:package:id />}
-          exp = @package.id.to_s
-          
-          @page.should render(tag).as(exp)
-        end
-      end
-      
-      describe '<r:shop:package:name />' do
-        it 'should render the name' do
-          tag = %{<r:shop:package:name />}
-          exp = @package.name.to_s
-          
-          @page.should render(tag).as(exp)
-        end
-      end
-      
-      describe '<r:shop:package:sku />' do
-        it 'should render the sku' do
-          tag = %{<r:shop:package:sku />}
-          exp = @package.sku.to_s
-          
-          @page.should render(tag).as(exp)
-        end
-      end
-    end
-    
-    describe '<r:package:description />' do
-      it 'should render a textile filtered result' do
-        @package.description = '*bold*'
-        
-        tag = %{<r:shop:package:description />}
-        exp = %{<p><strong>bold</strong></p>}
-        
-        @page.should render(tag).as(exp)
-      end
-    end
-    
-    context 'currency attributes' do
-      describe '<r:shop:package:price />' do
-        before :each do
-          @package.price = 1234.34567890
-        end
-        
-        it 'should render a standard price' do
-          tag = %{<r:shop:package:price />}
-          exp = %{$1,234.35}
-          @page.should render(tag).as(exp)
-        end
-        
-        it 'should render a high precision price' do
-          tag = %{<r:shop:package:price precision="8"/>}
-          exp = %{$1,234.34567890}
-          
-          @page.should render(tag).as(exp)
-        end
-        
-        it 'should render a custom format' do
-          tag = %{<r:shop:package:price unit="%" separator="-" delimiter="+" />}
-          exp = %{%1+234-35}
-          
-          @page.should render(tag).as(exp)
-        end
-      end
-      
-      describe '<r:shop:package:name />' do
-        before :each do
-          stub(@package).value { 1234.34567890 }
-        end
-        
-        it 'should render a standard price' do
-          tag = %{<r:shop:package:value />}
-          exp = %{$1,234.35}
-          
-          @page.should render(tag).as(exp)
-        end
-        
-        it 'should render a high precision price' do
-          tag = %{<r:shop:package:value precision="8"/>}
-          exp = %{$1,234.34567890}
-          
-          @page.should render(tag).as(exp)
-        end
-        
-        it 'should render a custom format' do
-          tag = %{<r:shop:package:value unit="%" separator="-" delimiter="+" />}
-          exp = %{%1+234-35}
-          
-          @page.should render(tag).as(exp)
-        end
-      end
-    end
-    
-  end
-    
-  context 'products in a package' do
-    
-    before :each do
-      mock(Shop::Tags::Helpers).current_package(anything) { @package }
-    end
-          
-    describe '<r:shop:package:if_products>' do  
-      context 'success' do
-        it 'should render' do
-          tag = %{<r:shop:package:if_products>success</r:shop:package:if_products>}
-          exp = %{success}
-          
-          @page.should render(tag).as(exp)
-        end
-      end
-      
-      context 'failure' do
-        it 'should not render' do
-          stub(@package).products { [] }
-          
-          tag = %{<r:shop:package:if_products>failure</r:shop:package:if_products>}
-          exp = %{}
-          
-          @page.should render(tag).as(exp)
-        end
-      end
-    end
-    
-    describe '<r:shop:package:unless_products>' do  
-      context 'success' do
-        it 'should render' do
-          stub(@package).products { [] }
-          tag = %{<r:shop:package:unless_products>success</r:shop:package:unless_products>}
-          exp = %{success}
-          
-          @page.should render(tag).as(exp)
-        end
-      end
-      
-      context 'failure' do
-        it 'should not render' do
-          tag = %{<r:shop:package:unless_products>failure</r:shop:package:unless_products>}
-          exp = %{}
-          
-          @page.should render(tag).as(exp)
-        end
-      end
-    end
-    
-    describe '<r:shop:package:products>' do
-      it 'should render' do
-        tag = %{<r:shop:package:products>success</r:shop:package:products>}
-        exp = %{success}
-        
-        @page.should render(tag).as(exp)
-      end
-    end
-    
-    describe '<r:shop:package:products:each>' do
-      context 'success' do
-        it 'should render' do
-          tag = %{<r:shop:package:products:each>.a.</r:shop:package:products:each>}
-          exp = @package.products.map{'.a.'}.join('')
-          
-          @page.should render(tag).as(exp)
-        end
-      end
-      
-      context 'failure' do
-        it 'should not render' do
-          stub(@package).packings { [] }
-          
-          tag = %{<r:shop:package:products:each>failure</r:shop:package:products:each>}
-          exp = %{}
-          
-          @page.should render(tag).as(exp)
-        end
-      end
-    end
-    
-    describe '<r:shop:package:product:quantity>' do
-      it 'should render the quantity of the current packing' do
-        tag = %{<r:shop:package:products:each:product:quantity />}
-        exp = @package.packings.map{|p| p.quantity}.join('')
-        
-        @page.should render(tag).as(exp)
-      end
-    end
-    
-  end
-
-end

data/spec/lib/shop/tags/product_variant_spec.rb

@@ -1,175 +0,0 @@
-require 'spec/spec_helper'
-
-describe Shop::Tags::ProductVariant do
-  
-  dataset :pages, :shop_product_variants, :shop_products
-  
-  it 'should describe these tags' do
-    Shop::Tags::ProductVariant.tags.sort.should == [
-      'shop:product:variants',
-      'shop:product:variants:each',
-      'shop:product:variants:if_variants',
-      'shop:product:variants:unless_variants',
-      'shop:product:variant',
-      'shop:product:variant:id',
-      'shop:product:variant:name',
-      'shop:product:variant:sku',
-      'shop:product:variant:price'].sort
-  end
-  
-  before :all do
-    @page = pages(:home)
-  end
-  
-  context 'tags' do
-    
-    before :each do
-      @product = shop_products(:crusty_bread)
-      @variant = shop_product_variants(:mouldy_crusty_bread)
-      
-      stub(Shop::Tags::Helpers).current_product(anything) { @product }
-    end
-    
-    describe '<r:shop:product:variants>' do
-      context 'variants exist' do
-        it 'should render' do
-          tag = %{<r:shop:product:variants>success</r:shop:product:variants>}
-          exp = %{success}
-
-          @page.should render(tag).as(exp)
-        end
-      end
-      
-      context 'variants do not exist' do
-        it 'should render' do
-          @product.variants = []
-          
-          tag = %{<r:shop:product:variants>success</r:shop:product:variants>}
-          exp = %{success}
-
-          @page.should render(tag).as(exp)
-        end
-      end
-    end
-    
-    describe '<r:shop:product:variants:if_variants>' do
-      context 'success' do
-        it 'should render' do
-          tag = %{<r:shop:product:variants:if_variants>success</r:shop:product:variants:if_variants>}
-          exp = %{success}
-          @page.should render(tag).as(exp)
-        end
-      end
-
-      context 'failure' do
-        it 'should not render' do
-          mock(Shop::Tags::Helpers).current_product_variants(anything) { [] }
-            
-          tag = %{<r:shop:product:variants:if_variants>failure</r:shop:product:variants:if_variants>}
-          exp = %{}
-          @page.should render(tag).as(exp)
-        end
-      end
-    end
-    
-    describe '<r:shop:product:variants:unless_variants>' do
-      context 'success' do
-        it 'should render' do
-          mock(Shop::Tags::Helpers).current_product_variants(anything) { [] }
-          
-          tag = %{<r:shop:product:variants:unless_variants>success</r:shop:product:variants:unless_variants>}
-          exp = %{success}
-          @page.should render(tag).as(exp)
-        end
-      end
-
-      context 'failure' do
-        it 'should not render' do
-          tag = %{<r:shop:product:variants:unless_variants>failure</r:shop:product:variants:unless_variants>}
-          exp = %{}
-          @page.should render(tag).as(exp)
-        end
-      end
-    end
-    
-    describe '<r:shop:product:variants:each>' do
-      context 'success' do
-        it 'should not render' do
-          tag = %{<r:shop:product:variants:each><r:product:id /></r:shop:product:variants:each>}
-          exp = @product.variants.map{ |p| p.product.id }.join('')
-          @page.should render(tag).as(exp)
-        end      
-      end
-
-      context 'failure' do
-        it 'should not render' do
-          mock(Shop::Tags::Helpers).current_product_variants(anything) { [] }
-          
-          tag = %{<r:shop:product:variants:each>failure</r:shop:product:variants:each>}
-          exp = %{}
-          @page.should render(tag).as(exp)
-        end
-      end
-    end
-    
-    describe '<r:shop:product:variant>' do
-      context 'variant exists in the context' do
-        it 'should render' do
-          mock(Shop::Tags::Helpers).current_product_variant(anything) { @variant }
-          
-          tag = %{<r:shop:product:variant>success</r:shop:product:variant>}
-          exp = %{success}
-          @page.should render(tag).as(exp)
-        end
-      end
-
-      context 'product does not exist in the context' do
-        it 'should not render' do
-          mock(Shop::Tags::Helpers).current_product_variant(anything) { nil }
-          
-          tag = %{<r:shop:product:variant>failure</r:shop:product:variant>}
-          exp = %{}
-          @page.should render(tag).as(exp)
-        end
-      end
-    end
-    
-    context '#attributes' do
-      before :each do
-        mock(Shop::Tags::Helpers).current_product_variant(anything) { @variant }
-      end
-      
-      describe '<r:id />' do
-        it 'should render the product id' do
-          tag = %{<r:shop:product:variant:id />}
-          exp = @variant.id.to_s
-          @page.should render(tag).as(exp)
-        end
-      end
-      describe '<r:name />' do
-        it 'should render the product name' do
-          tag = %{<r:shop:product:variant:name />}
-          exp = @variant.name
-          @page.should render(tag).as(exp)
-        end
-      end
-      describe '<r:sku />' do
-        it 'should render the product sku' do
-          tag = %{<r:shop:product:variant:sku />}
-          exp = @variant.sku
-          @page.should render(tag).as(exp)
-        end
-      end
-      describe '<r:price />' do
-        it 'should render a standard price' do
-          tag = %{<r:shop:product:variant:price />}
-          exp = Shop::Tags::Helpers.currency(@variant.price,{})
-        
-          @page.should render(tag).as(exp)
-        end
-      end
-    end
-    
-  end
-  
-end

data/spec/lib/shop/tags/responses_spec.rb

@@ -1,129 +0,0 @@
-require 'spec/spec_helper'
-
-describe Shop::Tags::Responses do
-  
-  dataset :forms, :pages
-  
-  it 'should describe these tags' do
-    Shop::Tags::Responses.tags.sort.should == [
-      'response:checkout',
-      'response:checkout:payment',
-      'response:checkout:payment:if_success',
-      'response:checkout:payment:unless_success'
-    ].sort
-  end
-  
-  context 'responses' do
-    
-    before :each do
-      login_as :customer
-      @order = shop_orders(:several_items)
-      
-      mock_page_with_request_and_data
-      mock_response
-      
-      mock.instance_of(ActiveMerchant::Billing::CreditCard).valid? { true }
-      mock_valid_form_checkout_request
-      @checkout = FormCheckout.new(@form, @page)
-    end
-    
-    describe '<r:response:checkout>' do
-      context 'checkout exists' do
-        before :each do
-          @response.result[:results][:checkout] = @checkout.create
-        end
-        it 'should expand' do
-          tag = %{<r:response:checkout>success</r:response:checkout>}
-          exp = %{success}
-          
-          pages(:home).should render(tag).as(exp)
-        end
-      end
-      context 'checkout does not exist' do
-        it 'should not expand' do
-          tag = %{<r:response:checkout>failure</r:response:checkout>}
-          exp = %{}
-        
-          pages(:home).should render(tag).as(exp)
-        end
-      end
-    end
-    
-    describe '<r:response:payment>' do
-      before :each do
-        @response.result[:results][:checkout] = @checkout.create
-      end
-      context 'payment success' do
-        it 'should expand' do
-          tag = %{<r:response:checkout:payment>success</r:response:checkout:payment>}
-          exp = %{success}
-        
-          pages(:home).should render(tag).as(exp)
-        end
-      end
-      context 'payment failure' do
-        before :each do
-          @response.result[:results][:checkout][:payment] = false
-        end
-        it 'should expand' do
-          tag = %{<r:response:checkout:payment>success</r:response:checkout:payment>}
-          exp = %{success}
-          
-          pages(:home).should render(tag).as(exp)
-        end
-      end
-    end
-    
-    describe '<r:response:payment:if_success>' do
-      before :each do
-        @response.result[:results][:checkout] = @checkout.create
-      end
-      context 'payment success' do
-        it 'should expand' do
-          tag = %{<r:response:checkout:payment:if_success>success</r:response:checkout:payment:if_success>}
-          exp = %{success}
-          
-          pages(:home).should render(tag).as(exp)
-        end
-      end
-      context 'payment failure' do
-        before :each do
-          @response.result[:results][:checkout][:payment] = false
-        end
-        it 'should not expand' do
-          tag = %{<r:response:checkout:payment:if_success>failure</r:response:checkout:payment:if_success>}
-          exp = %{}
-          
-          pages(:home).should render(tag).as(exp)
-        end
-      end
-    end
-    
-    describe '<r:response:payment:unless_success>' do
-      before :each do
-        @response.result[:results][:checkout] = @checkout.create
-      end
-      context 'payment failure' do
-        before :each do
-          @response.result[:results][:checkout][:payment] = false
-        end
-        it 'should expand' do
-          tag = %{<r:response:checkout:payment:unless_success>success</r:response:checkout:payment:unless_success>}
-          exp = %{success}
-          
-          pages(:home).should render(tag).as(exp)
-        end
-      end
-      context 'payment success' do
-        it 'should not expand' do
-          tag = %{<r:response:checkout:payment:unless_success>failure</r:response:checkout:payment:unless_success>}
-          exp = %{}
-          
-          pages(:home).should render(tag).as(exp)
-        end
-      end
-    end
-    
-  end
-
-end

data/spec/models/form_discount_spec.rb

@@ -1,63 +0,0 @@
-require 'spec/spec_helper'
-
-describe FormDiscount do
-  
-  dataset :shop_discounts, :pages, :forms
-  
-  before :each do
-    mock_page_with_request_and_data
-  end
-    
-  describe '#create' do
-    before :each do
-      login_as :customer
-      @order = shop_orders(:several_items)
-    end
-    context 'add' do
-      before :each do
-        mock_valid_form_discount_request
-      end
-      context 'valid discount' do
-        before :each do
-          @discount = FormDiscount.new(@form, @page)
-          @result = @discount.create
-        end
-        it 'should add the discount to the order' do
-          shop_orders(:several_items).discounts.first(:conditions => { :code => '10pcoff' }).should_not be_nil
-        end
-        it 'should return true for result[:add]' do
-          @result[:add].should be_true
-        end
-      end
-      context 'invalid discount' do
-        before :each do
-          @data[:discount][:code] = 'invalid'
-        end
-        it 'should not add the discount to the order' do
-          shop_orders(:several_items).discounts.first(:conditions => { :code => 'invalid' }).should be_nil
-        end
-      end
-    end
-    
-    context 'remove' do
-      before :each do
-        discountable = shop_discounts(:ten_percent).discountables.create(:discounted_id => @order.id, :discounted_type => @order.class.name)
-        
-        mock_valid_form_discount_request
-        @form[:extensions][:discount][:process] = 'remove'
-        @data[:discountable] = { :id => discountable.id }
-        
-        @discount = FormDiscount.new(@form, @page)
-        @result = @discount.create
-      end
-      it 'should remove the discount from the order' do
-        shop_orders(:several_items).discounts.include?(shop_discounts(:ten_percent)).should be_false
-      end  
-      it 'should return true for result[:remove]' do
-        @result[:remove].should be_true
-      end
-    end
-    
-  end
-  
-end