radiant-shop-extension 0.9.3 → 0.10.0

data/spec/datasets/shop_customers.rb

@@ -0,0 +1,30 @@
+class ShopCustomersDataset < Dataset::Base
+  def load
+    create_model :shop_customer, :customer,
+      :name     => 'customer',
+      :email    => 'customer@example.com',
+      :login    => 'customer',
+      :password => 'radiant',
+      :password_confirmation => 'radiant'
+      
+    create_model :shop_customer, :bad_customer,
+      :name     => 'bad customer',
+      :email    => 'bad_customer@example.com',
+      :login    => 'bad customer',
+      :password => 'radiant',
+      :password_confirmation => 'radiant'
+  end
+  
+  helpers do
+    def login_as(user)
+      login_user = user.is_a?(User) ? user : users(user)
+      flunk "Can't login as non-existing user #{user.to_s}." unless login_user
+      UserActionObserver.current_user = login_user
+      login_user
+    end
+
+    def logout
+      UserActionObserver.current_user = nil
+    end
+  end
+end

data/spec/datasets/shop_orders.rb

@@ -1,11 +1,15 @@
 class ShopOrdersDataset < Dataset::Base
   
-  uses :shop_products
+  uses :shop_products, :shop_customers, :shop_addresses
   
   def load
     create_record :shop_order, :empty
-    create_record :shop_order, :one_item
-    create_record :shop_order, :several_items
+    create_record :shop_order, :one_item,
+      :customer => shop_customers(:customer)
+    create_record :shop_order, :several_items,
+      :customer => shop_customers(:customer), 
+      :billing  => shop_addresses(:billing),
+      :shipping => shop_addresses(:shipping)
     
     create_record :shop_line_item, :crusty_bread, :item_id => shop_products(:crusty_bread).id, :item_type => 'ShopProduct'
     create_record :shop_line_item, :soft_bread,   :item_id => shop_products(:soft_bread).id, :item_type => 'ShopProduct'

data/spec/datasets/shop_products.rb

@@ -13,6 +13,7 @@ class ShopProductsDataset < Dataset::Base
         create_record :shop_product, "#{product.to_s}_#{category.to_s}".to_sym,
           :name     => "#{product.to_s} #{category.to_s}",
           :sku      => "#{product.to_s}_#{category.to_s}",
+          :description => "*#{product.to_s}*",
           :price    => i + 1 * 10,
           :position => i + 1,
           :weight   => i + 10 * 3,

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

@@ -0,0 +1,71 @@
+require 'spec/spec_helper'
+require 'spec/helpers/nested_tag_helper'
+
+#
+# Test for Shop Line Item Tags
+#
+describe Shop::Tags::Card do
+  
+  dataset :pages
+  
+  before :all do
+    @page = pages(:home)
+  end
+  
+  it 'should describe these tags' do
+    Shop::Tags::Card.tags.sort.should == [
+      'form:card',
+      'form:card:type',
+      'form:card:month',
+      'form:card:year'].sort
+  end
+  
+  describe 'form:card:type' do
+    it 'should output the card types' do
+      tag = %{<r:form:card:type />}
+      exp = %{<select name="card[type]" id="card_type">
+<option value="amex">American Express</option>
+<option value="diners">Diners Club</option>
+<option value="mastercard">Master Card</option>
+<option value="visa">Visa</option>
+</select>}
+
+      @page.should render(tag).as(exp)
+    end
+  end
+  
+  describe 'form:card:month' do
+    it 'should output the card months' do
+      tag = %{<r:form:card:month />}
+      exp = %{<select name="card[month]" id="card_month">
+<option value="01">01 - January</option>
+<option value="02">02 - February</option>
+<option value="03">03 - March</option>
+<option value="04">04 - April</option>
+<option value="05">05 - May</option>
+<option value="06">06 - June</option>
+<option value="07">07 - July</option>
+<option value="08">08 - August</option>
+<option value="09">09 - September</option>
+<option value="10">10 - October</option>
+<option value="11">11 - November</option>
+<option value="12">12 - December</option>
+</select>}
+
+      @page.should render(tag).as(exp)
+    end
+  end
+  
+  describe 'form:card:year' do
+    it 'should output the card years' do
+      tag = %{<r:form:card:year />}
+      exp = %{<select name="card[year]" id="card_year">\n}
+      (Time.new.year ... Time.new.year + 10).each do |year|
+        exp << %{<option value="#{year}">#{year}</option>\n}
+      end
+      exp << %{</select>}
+      @page.should render(tag).as(exp)
+    end
+  end
+  
+end

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

@@ -2,378 +2,365 @@ require 'spec/spec_helper'
 
 describe Shop::Tags::Helpers do
   
-  dataset :pages
+  dataset :pages, :shop_products, :shop_orders, :shop_addresses
   
   before :all do
     @page = pages(:home)
   end
   
   before(:each) do
-    @locals = Object.new
-    stub(@locals).page { @page }
-    
-    @attrs  = {}
-    
-    @tag = Object.new
-    stub(@tag).attr   { @attrs }
-    stub(@tag).locals { @locals }
-    
-    category = Object.new
-    @shop_category    = category
-    @shop_categories  = [ @shop_category, @shop_category, @shop_category ]
-    
-    product = Object.new
-    @shop_product   = product
-    @shop_products  = [ @shop_product, @shop_product, @shop_product ]
-    
-    order = Object.new
-    @shop_order = order
-    
-    item = Object.new
-    @shop_line_item   = item
-    @shop_line_items  = [ @shop_line_item, @shop_line_item, @shop_line_item ]
-    
-    stub(@shop_product).category  { @shop_category }
-    stub(@shop_category).products { @shop_products }
-    stub(@shop_line_item).product { @shop_product }
-    stub(@shop_order).line_items  { @shop_line_items }
+    @tag = OpenStruct.new({
+      :attr   => {},
+      :locals => OpenStruct.new({
+        :page => OpenStruct.new({
+          :params   => {},
+          :request  => OpenStruct.new({
+            :session => {}
+          })
+        })
+      })
+    })
   end
   
-  describe '#current_categories(tag)' do
-    context 'search query' do
-      it 'should return matching categories' do
-        stub(@locals).shop_categories { [] }
-        stub(@page).params { {'query'=>'term'} }
-        
-        mock(ShopCategory).search('term') { @shop_categories }
-        
+  describe '#current_categories' do
+    before :each do
+      @category   = shop_categories(:bread)
+    end
+    
+    context 'categories previously set' do
+      before :each do
+        @tag.locals.shop_categories = [@category]
+      end
+      it 'should return categories' do
         result = Shop::Tags::Helpers.current_categories(@tag)
-        result.should == @shop_categories
+        result.should == [@category]
       end
     end
     
-    context 'key => value' do
+    context 'search query sent to page' do
+      before :each do
+        @tag.locals.page.params = { 'query' => @category.handle }
+      end
       it 'should return matching categories' do
-        stub(@locals).shop_categories { [] }
-        stub(@page).params { {} }
-        @attrs['key'] = 'find'
-        @attrs['value'] = 'me'
-        
-        mock(ShopCategory).all(:conditions => { :find => 'me' }) { @shop_categories }
-        
         result = Shop::Tags::Helpers.current_categories(@tag)
-        result.should == @shop_categories
+        result.should == [@category]
+      end
+    end
+    
+    context 'key and value sent' do
+      before :each do
+        @tag.attr = { 'key' => 'handle', 'value' => @category.handle }
+      end
+      it 'should return the matching categories' do
+        result = Shop::Tags::Helpers.current_categories(@tag)
+        result.should == [@category]
       end
     end
     
-    context 'all results' do
-      it 'should return all categories' do
-        stub(@locals).shop_categories { [] }
-        stub(@page).params { {} }
-        
-        mock(ShopCategory).all { @shop_categories }
-        
+    context 'nothing additional sent' do
+      before :each do
+        mock(ShopCategory).all { [@category] }
+      end
+      it 'should return all categories in the database' do
         result = Shop::Tags::Helpers.current_categories(@tag)
-        result.should == @shop_categories
+        result.should == [@category]
       end
     end
   end
   
-  describe '#current_category(tag)' do
-    context 'parameters' do
-      it 'should be calling an object with those attributes' do
-        object = ShopCategory.new
-        object.attributes.include?('handle').should == true
-        object.attributes.include?('name').should == true
-        object.attributes.include?('position').should == true
-      end
-    end
-    context 'key => value' do
-      it 'should return the matching category' do
-        stub(@locals).shop_category { nil }
-        @attrs['key'] = 'find'
-        @attrs['value'] = 'me'
-        
-        mock(ShopCategory).first(:conditions => { :find => 'me' }) { @shop_category }
-        
+  describe '#current_category' do
+    before :each do
+      @category = shop_categories(:bread)
+      @product  = shop_categories(:bread).products.first
+    end
+    
+    context 'category previously set' do
+      before :each do
+        @tag.locals.shop_category = @category
+      end
+      it 'should return the existing category' do
         result = Shop::Tags::Helpers.current_category(@tag)
-        result.should == @shop_category
+        result.should == @category
       end
     end
-    context 'tag.locals.page.shop_category' do
-      it 'should return the matching category' do
-        stub(@locals).shop_category { @shop_category }
-        
+    
+    context 'product previously set' do
+      before :each do
+        @tag.locals.shop_product = @product
+      end
+      it 'should return the category of the product attached to the page' do
+        result = Shop::Tags::Helpers.current_category(@tag)
+        result.should == @category
+      end
+    end
+
+    context 'key and value sent' do
+      before :each do
+        @tag.attr = { 'key' => 'handle', 'value' => @category.handle }
+      end
+      it 'should return the matching categories' do
         result = Shop::Tags::Helpers.current_category(@tag)
-        result.should == @shop_category
+        result.should == @category
       end
     end
-    context 'tag.locals.page.shop_product' do
-      it 'should return the matching category' do
-        stub(@locals).shop_category { nil }
-        stub(@page).shop_product    { @shop_product }
-        
+    
+    context 'the current page has a product attached to it' do
+      before :each do
+        @tag.locals.page.shop_product = @product
+      end
+      it 'should return the category of the product attached to the page' do
         result = Shop::Tags::Helpers.current_category(@tag)
-        result.should == @shop_category
+        result.should == @category
       end
     end
-    context 'tag.locals.shop_category' do
-      it 'should return the matching category' do
-        stub(@locals).shop_category { @shop_category }
-        
+    
+    context 'the current page slug matches the category handle' do
+      before :each do
+        @tag.locals.page.slug = @category.handle
+      end
+      it 'should return the category with that handle' do
         result = Shop::Tags::Helpers.current_category(@tag)
-        result.should == @shop_category
+        result.should == @category
       end
     end
-    context 'tag.locals.shop_product' do
-      it 'should return the matching category' do
-        stub(@page).shop_category   { nil }
-        stub(@page).shop_product    { nil }
-        stub(@locals).shop_category { nil }
-        stub(@locals).shop_product  { @shop_product }
-        
+    
+    context 'the current page has a category attached to it' do
+      before :each do
+        @tag.locals.page.shop_category = @category
+      end
+      it 'should return the category attached to the page' do
         result = Shop::Tags::Helpers.current_category(@tag)
-        result.should == @shop_category
-      end
-    end
-    context 'Using page slug' do
-      it 'should return the matching category' do
-        stub(@shop_category).handle { 'bob' }
-        stub(@page).shop_category   { nil }
-        stub(@page).shop_product    { nil }
-        stub(@locals).shop_category { nil }
-        stub(@locals).shop_product  { nil }
-        stub(@page).slug            { @shop_category.handle }
-        
-        mock(ShopCategory).find(:first, {:conditions=>{:handle=>@shop_category.handle}}) { @shop_category }
-        
+        result.should == @category
+      end
+    end
+    
+    context 'nothing available to find the category' do
+      it 'should return nil' do
         result = Shop::Tags::Helpers.current_category(@tag)
-        result.should == @shop_category
+        result.should be_nil
       end
     end
+    
   end
-  
-  describe '#current_products(tag)' do
-    context 'tag.locals.shop_products' do
-      it 'should return matching products' do
-        stub(@locals).shop_products { @shop_products }
-        
+    
+  describe '#current_products' do
+    before :each do
+      @product  = shop_products(:soft_bread)
+      @category = shop_categories(:bread)
+    end
+
+    context 'products previously set' do
+      before :each do
+        @tag.locals.shop_products = [ @product ]
+      end
+      it 'should return the existing categories' do
+        result = Shop::Tags::Helpers.current_products(@tag)
+        result.should == [@product]
+      end
+    end
+    
+    context 'category previously set' do
+      before :each do
+        @tag.locals.shop_category = @category
+      end
+      it 'should return the categorys products' do
         result = Shop::Tags::Helpers.current_products(@tag)
-        result.should == @shop_products
+        result.should == @category.products
       end
     end
-    context 'search query' do
+    
+    context 'the current page has a category attached to it' do
+      before :each do
+        @tag.locals.page.shop_category = @category
+      end
+      it 'should return the products of the category attached to the page' do
+        result = Shop::Tags::Helpers.current_products(@tag)
+        result.should == @category.products
+      end
+    end
+    
+    context 'search query sent to page' do
+      before :each do
+        @tag.locals.page.params = { 'query' => @product.sku }
+      end
       it 'should return matching products' do
-        stub(@locals).shop_products { [] }
-        stub(@page).params { {'query'=>'term'} }
-        
-        mock(ShopProduct).search('term') { @shop_products }
-        
         result = Shop::Tags::Helpers.current_products(@tag)
-        result.should == @shop_products
+        result.should == [@product]
       end
     end
-    context 'key => value' do
+    
+    context 'key and value sent' do
+      before :each do
+        @tag.attr = { 'key' => 'sku', 'value' => @product.sku }
+      end
       it 'should return the matching products' do
-        stub(@locals).shop_products { [] }
-        stub(@page).params { {} }
-        @attrs['key'] = 'find'
-        @attrs['value'] = 'me'
-        
-        mock(ShopProduct).all(:conditions => { :find => 'me' }) { @shop_products }
-        
         result = Shop::Tags::Helpers.current_products(@tag)
-        result.should == @shop_products
-      end
-    end
-    context 'no query' do
-      context 'tag.locals.page.shop_category' do
-        it 'should return all products in that category' do
-          stub(@page).params          { { } }
-          stub(@locals).shop_products { [] }
-          stub(@page).shop_category   { @shop_category }
-          
-          result = Shop::Tags::Helpers.current_products(@tag)
-          result.should == @shop_category.products
-        end
-      end
-      
-      context 'tag.locals.shop_category' do
-        it 'should return all products in that category' do
-          stub(@locals).shop_products { [] }
-          stub(@page).params          { { } }
-          stub(@page).shop_category   { nil }
-          stub(@locals).shop_category { @shop_category }
-          
-          result = Shop::Tags::Helpers.current_products(@tag)
-          result.should == @shop_category.products
-        end
-      end
-      
-      context 'all results' do
-        it 'should return all products' do
-          stub(@page).params            { {} }
-          stub(@locals).shop_products   { {} }
-          stub(@page).shop_category     { nil }
-          stub(@locals).shop_category   { nil }
-          mock(ShopProduct).all         { @shop_products }
-          
-          result = Shop::Tags::Helpers.current_products(@tag)
-          result.should == @shop_products
-        end
+        result.should == [@product]
+      end
+    end
+    
+    context 'nothing additional sent' do
+      before :each do
+        mock(ShopProduct).all { [@product] }
+      end
+      it 'should return all products in the database' do
+        result = Shop::Tags::Helpers.current_products(@tag)
+        result.should == [@product]
       end
     end
   end
   
-  describe '#current_product(tag)' do
-    context 'parameters' do
-      it 'should be calling an object with those attributes' do
-        object = ShopProduct.new
-        object.attributes.include?('sku').should == true
-        object.attributes.include?('name').should == true
-        object.attributes.include?('position').should == true
-      end
-    end
-    context 'key => value' do
-      it 'should return the matching product' do
-        stub(@locals).shop_product { nil }
-        @attrs['key'] = 'find'
-        @attrs['value'] = 'me'
-        
-        mock(ShopProduct).first(:conditions => { :find => 'me' }) { @shop_product }
-        
+  describe '#current_product' do
+    before :each do
+      @product = shop_products(:soft_bread)
+    end
+    
+    context 'product previously set' do
+      before :each do
+        @tag.locals.shop_product = @product
+      end
+      it 'should return the product attached to the page' do
         result = Shop::Tags::Helpers.current_product(@tag)
-        result.should == @shop_product
+        result.should == @product
       end
     end
-    context 'tag.locals.page.shop_product' do
-      it 'should return the matching product' do
-        stub(@locals).shop_product  { nil }
-        stub(@page).shop_product    { @shop_product }
-        
+
+    context 'key and value sent' do
+      before :each do
+        @tag.attr = { 'key' => 'sku', 'value' => @product.sku }
+      end
+      it 'should return the matching categories' do
         result = Shop::Tags::Helpers.current_product(@tag)
-        result.should == @shop_product
+        result.should == @product
       end
     end
-    context 'tag.locals.shop_product' do
-      it 'should return the matching product' do
-        stub(@locals).shop_product  { @shop_product }
-        
-        result = Shop::Tags::Helpers.current_product(@tag)
-        result.should == @shop_product
-      end
-    end
-    context 'Using page slug' do
-      it 'should return the matching category' do
-        stub(@shop_product).sku     { 'bob' }
-        
-        stub(@page).shop_product    { nil }
-        stub(@locals).shop_product  { nil }
-        stub(@page).slug            { @shop_product.sku }
-                
-        mock(ShopProduct).find(:first, {:conditions=>{:sku=>@shop_product.sku}}) { @shop_product }
-        
+    
+    context 'the current page has a product attached to it' do
+      before :each do
+        @tag.locals.page.shop_product = @product
+      end
+      it 'should return the product attached to the page' do
         result = Shop::Tags::Helpers.current_product(@tag)
-        result.should == @shop_product
+        result.should == @product
       end
     end
+    
   end
   
-  describe '#current_order(tag)' do
-    context 'existing order' do
+  describe '#current_order' do
+    before :each do
+      @order = shop_orders(:one_item)
+    end
+    
+    context 'order previously set' do
+      before :each do
+        @tag.locals.shop_order = @order
+      end
       it 'should return the order' do
-        stub(@locals).shop_order { @shop_order }
-        
         result = Shop::Tags::Helpers.current_order(@tag)
-        result.should == @shop_order
+        result.should == @order
       end
     end
-    context 'using order id' do
-      it 'should return the order' do
-        stub(@locals).shop_order { nil }
-        stub(@shop_order).id { 1 }
-        mock(ShopOrder).find(@shop_order.id) { @shop_order }
-        
-        @attrs['id'] = @shop_order.id
-        
+    
+    context 'key and value sent' do
+      before :each do
+        @tag.attr = { 'key' => 'id', 'value' => @order.id }
+      end
+      it 'should return the matching order' do
         result = Shop::Tags::Helpers.current_order(@tag)
-        result.should == @shop_order
+        result.should == @order
       end
     end
-    context 'using request object' do
-      it 'should return the order' do
-        stub(@locals).shop_order { nil }
-        stub(@shop_order).id { 1 }
-        stub(@page).request.stub!.session { { :shop_order => @shop_order.id  } }
-        
-        mock(ShopOrder).find(@shop_order.id) { @shop_order }
-        
+    
+    context 'session contains the order id' do
+      before :each do
+        @tag.locals.page.request.session[:shop_order] = @order.id
+      end
+      it 'should return the order with that id' do
         result = Shop::Tags::Helpers.current_order(@tag)
-        result.should == @shop_order
+        result.should == @order
       end
     end
+    
+    context 'nothing available to find the product' do
+      it 'should return nil' do
+        result = Shop::Tags::Helpers.current_order(@tag)
+        result.should be_nil
+      end
+    end
+    
   end
   
-  describe '#current_line_item(tag)' do
+  describe '#current_line_item' do
+    before :each do
+      @item = shop_line_items(:crusty_bread)
+    end
+    
     context 'existing line item' do
-      it 'should return the line item' do
-        stub(@locals).shop_line_item { @shop_line_item }
-        
+      before :each do
+        @tag.locals.shop_line_item = @item
+      end
+      it 'should return that existing line item' do
         result = Shop::Tags::Helpers.current_line_item(@tag)
-        result.should == @shop_line_item
+        result.should == @item
       end
     end
-    context 'existing line item' do
-      it 'using the current item' do
-        stub(@shop_product).id { 1 }
-        
-        stub(@locals).shop_line_item  { nil }
-        stub(@locals).shop_order      { @shop_order }
-        stub(@locals).shop_product    { @shop_product }
-        
-        mock(@shop_line_items).find_by_item_id(@shop_product.id) { @shop_line_item }
-        
+    
+    context 'existing product and category' do
+      before :each do
+        @tag.locals.shop_order = shop_orders(:one_item)
+        @tag.locals.shop_product = shop_products(:crusty_bread)
+      end
+      it 'should return the item linking the two' do
         result = Shop::Tags::Helpers.current_line_item(@tag)
-        result.should == @shop_line_item
+        result.should == @item
       end
     end
   end
   
-  describe '#current_address(tag)' do
+  describe '#current_address' do
     before :each do
-      @attrs['type'] = 'billing'
+      @address  = shop_addresses(:billing)
+      @tag.attr = { 'type' => 'billing' }
     end
-    context 'address exists' do
+    
+    context 'billing address already exists and billing type was requested' do
       before :each do
-        @billing = Object.new
-        stub(@shop_order).billing { @billing }
-        stub(@locals).shop_order { @shop_order }
-      end
-      context 'tag exists' do
-        it 'should return the address' do
-          stub(@locals).address { @billing }
-          
-          result = Shop::Tags::Helpers.current_address(@tag)
-          result.should == @billing
-        end
-      end
-      context 'tag doesnt exist' do
-        it 'should return that billing address' do
-          stub(@locals).address { nil }
-          
-          result = Shop::Tags::Helpers.current_address(@tag)
-          result.should == @billing
-        end
-      end
-    end
-    context 'address does not exist' do
+        @tag.locals.address = @address
+        @tag.locals.address_type = 'billing'
+      end
+      it 'should return the existing address' do
+        result = Shop::Tags::Helpers.current_address(@tag)
+        result.should == @address
+      end
+    end
+    
+    context 'current_order exists and has billing' do
+      before :each do
+        @order = shop_orders(:one_item)
+        @order.update_attribute(:billing_id, @address.id)
+        @tag.locals.shop_order = @order
+      end
+      it 'should return the order billing address' do
+        result = Shop::Tags::Helpers.current_address(@tag)
+        result.should == @address
+      end
+    end
+    
+    context 'current order exists and doesnt have billing' do
+      before :each do
+        @order = shop_orders(:one_item)
+      end
+      it 'should return nil' do
+        result = Shop::Tags::Helpers.current_address(@tag)
+        result.should be_nil
+      end
+    end
+    
+    context 'no order exists' do
       it 'should return nil' do
-        stub(@locals).address { nil }
-        stub(@shop_order).billing { nil }
-        stub(@locals).shop_order { @shop_order }
-        
         result = Shop::Tags::Helpers.current_address(@tag)
-        result.should == nil
+        result.should be_nil
       end
     end
   end