spree 0.4.1 → 0.5.0

data/spec/models/product_property_spec.rb

@@ -0,0 +1,36 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+module ProductPropertySpecHelper
+  def valid_product_property_attributes
+    {
+      :value => "x"
+    }
+  end
+end
+
+
+describe ProductProperty do
+  include ProductPropertySpecHelper
+
+  before(:each) do
+    @product_property = ProductProperty.new
+  end
+
+  it "should not be valid when empty" do
+    @product_property.should_not be_valid
+  end
+
+  ['value'].each do |field|
+    it "should require #{field}" do
+      @product_property.should_not be_valid
+      @product_property.errors.full_messages.should include("#{field.intern.l(field).humanize} #{:error_message_blank.l}")
+    end
+  end
+
+  it "should be valid when having correct information" do
+    pending "Shouldn't it require a product and a property too?"
+    @product_property.attributes = valid_product_property_attributes
+    @product_property.should be_valid
+  end
+
+end

data/spec/models/product_spec.rb

@@ -1,18 +1,46 @@
-require File.dirname(__FILE__) + '/../spec_helper.rb'
+require File.dirname(__FILE__) + '/../spec_helper'
+
+module ProductSpecHelper
+  def valid_product_attributes
+    {
+      :name => "A Product",
+      :master_price => 10,
+      :description => "Just a test product."
+    }
+  end
+
+  def valid_variant_attributes
+    {
+      :on_hand => 45,
+      :sku => "un"
+    }
+  end
+end
+
 
 describe Product do
+  include ProductSpecHelper
 
   before(:each) do
     @product = Product.new
   end
 
-  ['name', 'master price', 'description'].each do |field|
+  it "should not be valid when empty" do
+    @product.should_not be_valid
+  end
+
+  ['name', 'master_price', 'description'].each do |field|
     it "should require #{field}" do
-      @product.valid?.should be_false
-      @product.errors.full_messages.should include("#{field.capitalize} can't be blank")
+      @product.should_not be_valid
+      @product.errors.full_messages.should include("#{field.intern.l(field).humanize} #{:error_message_blank.l}")
     end
   end
 
+  it "should be valid when having correct information" do
+    @product.attributes = valid_product_attributes
+    @product.should be_valid
+  end
+
   describe "#variants?" do
     it "should be false when variants is empty" do
       @product.variants.should be_empty
@@ -20,17 +48,17 @@ describe Product do
     end
 
     it "should be false when none of the variants have option values" do
-      variant_proxy = mock_model(Variant)
-      variant_proxy.should_receive(:option_values).and_return([])
-      @product.variants << variant_proxy
+      variant = mock_model(Variant)
+      variant.should_receive(:option_values).and_return([])
+      @product.variants << variant
       @product.variants?.should be_false
     end
 
     it "should be true when at least one variant has option values" do
-      ov_proxy = mock_model(OptionValue)
-      variant_proxy = mock_model(Variant)
-      variant_proxy.should_receive(:option_values).and_return([ov_proxy])
-      @product.variants << variant_proxy
+      option_value = mock_model(OptionValue)
+      variant = mock_model(Variant)
+      variant.should_receive(:option_values).and_return([option_value])
+      @product.variants << variant
       @product.variants?.should be_true
     end
   end
@@ -39,20 +67,18 @@ describe Product do
     it "should return the emtpy variant if there are only empty variant" do
       variant = mock_model(Variant)
       variant.stub!(:option_values).and_return([])
-      product = Product.new
-      product.stub!(:variants).and_return([variant])
-      product.variant.should == variant
+      @product.stub!(:variants).and_return([variant])
+      @product.variant.should == variant
     end
 
     it "should return nil if there are any non-empty variants" do
       variant1 = mock_model(Variant)
       variant1.stub!(:option_values).and_return([])
-      ov = mock_model(OptionValue)
+      option_value = mock_model(OptionValue)
       variant2 = mock_model(Variant)
-      variant2.stub!(:option_values).and_return([ov])
-      product = Product.new
-      product.stub!(:variants).and_return([variant1, variant2])
-      product.variant.should be_nil
+      variant2.stub!(:option_values).and_return([option_value])
+      @product.stub!(:variants).and_return([variant1, variant2])
+      @product.variant.should be_nil
     end
   end
 
@@ -74,11 +100,11 @@ describe Product do
 
   describe "availability" do
     before(:each) do
-      @product = create_product(:name => 'test 1', :available_on => (Time.now - 1.day))
-      @old_product = create_product(:available_on => (Time.now + 2.weeks))
+      @product = Product.create(valid_product_attributes.with(:available_on => (Time.now - 1.day)))
+      @not_available_product = Product.create(valid_product_attributes.with(:available_on => (Time.now + 2.weeks)))
     end
 
-    it "should only find availble products using the available class method" do
+    it "should only find available products using the available class method" do
       Product.available.all.size.should eql(1)
     end
 
@@ -91,15 +117,55 @@ describe Product do
   describe 'inventory' do
 
     before(:each) do
-      @variant = mock_model(Variant, :on_hand => 45)
-      @product = create_product
+      @variant = Variant.create(valid_variant_attributes)
+      @product.attributes = valid_product_attributes
     end
 
     describe 'on_hand' do
       it "should return the number of items available for the first variant" do
         @product.stub!(:variant).and_return(@variant)
+        @variant.stub!(:on_hand).and_return(45)
         @product.on_hand.should == 45
       end
+
+      it "should update the inventory unit records of the corresponding variant when added" do
+        @product.save
+        @variant = Variant.create!({"price" => "10", "product" => @product})
+
+        @product.variant.inventory_units.size.should == 0
+        
+        @product.update_attributes!({"on_hand" => "1"})
+        @product.variant.inventory_units.size.should == 1
+      end
+
+      it "should update the inventory unit records of the corresponding variant when removed" do
+        @product.save
+        @variant = Variant.create!({"price" => "10", "product" => @product})
+
+        @product.variant.inventory_units.size.should == 0
+
+        @product.update_attributes!({"on_hand" => "2"})
+        @product.variant.inventory_units.size.should == 2
+        
+        @product.update_attributes!({"on_hand" => "1"})
+        @product.variant.inventory_units.size.should == 1
+        
+        @product.update_attributes!({"on_hand" => "0"})
+        @product.variant.inventory_units.size.should == 0
+      end
+    end
+    
+    describe 'sku' do 
+      it "should return the stock keeping unit for the first variant" do
+        @product.stub!(:variant).and_return(@variant)
+        @product.sku.should == "un"
+      end
+
+      it "should update the stock keeping unit of the corresponding variant when changed" do
+        @product.stub!(:variant).and_return(@variant)
+        @product.sku = "mt"
+        @variant.sku.should == "mt"
+      end
     end
 
     describe 'has_stock?' do
@@ -118,13 +184,24 @@ describe Product do
 
   end
 
-end
+  it "should update the inventory unit records of the corresponding variant with an initial value when created" do
+    @product.save
+    if @product.variants.empty?
+      @product.available_on = Time.now
+      @product.variants << Variant.new(:product => @product)
+    end
 
-def create_product(options={})
-  Product.create({
-    :name => 'test product',
-    :available_on => Time.now,
-    :description => 'A test product',
-    :master_price => 100.00,
-  }.merge(options))
+    @product.update_attributes!(valid_product_attributes.with("on_hand" => "2"))
+    
+    first_size = @product.variant.inventory_units.size
+    first_size.should == 2
+  end
+
+  it "should update the empty variant if the 'master_price' attribute is changed" do
+    @variant = Variant.create(valid_variant_attributes)
+    @product.update_attributes!(valid_product_attributes)
+    @product.variants.stub!(:first).and_return(@variant)
+    @variant.should_receive(:price=).with(20)
+    @product.update_attributes!({"master_price" => "20"})
+  end
 end

data/spec/models/property_spec.rb

@@ -0,0 +1,38 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+module PropertySpecHelper
+  def valid_property_attributes
+    {
+      :name => "a_property",
+      :presentation => "A Property"
+    }
+  end
+end
+
+
+describe Property do
+  include PropertySpecHelper
+
+  before(:each) do
+    @property = Property.new
+  end
+
+  it "should not be valid when empty" do
+    @property.should_not be_valid
+  end
+
+  ['name', 'presentation'].each do |field|
+    it "should require #{field}" do
+      @property.should_not be_valid
+      @property.errors.full_messages.should include("#{field.intern.l(field).humanize} #{:error_message_blank.l}")
+    end
+  end
+
+  it "should be valid when having correct information" do
+    @property.attributes = valid_property_attributes
+    @property.should be_valid
+  end
+
+  it "should find all by prototype"
+  
+end

data/spec/models/prototype_spec.rb

@@ -0,0 +1,35 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+module PrototypeSpecHelper
+  def valid_prototype_attributes
+    {
+      :name => "A Prototype"
+    }
+  end
+end
+
+
+describe Prototype do
+  include PrototypeSpecHelper
+
+  before(:each) do
+    @prototype = Prototype.new
+  end
+
+  it "should not be valid when empty" do
+    @prototype.should_not be_valid
+  end
+
+  ['name'].each do |field|
+    it "should require #{field}" do
+      @prototype.should_not be_valid
+      @prototype.errors.full_messages.should include("#{field.intern.l(field).humanize} #{:error_message_blank.l}")
+    end
+  end
+
+  it "should be valid when having correct information" do
+    @prototype.attributes = valid_prototype_attributes
+    @prototype.should be_valid
+  end
+
+end

data/spec/models/state_spec.rb

@@ -0,0 +1,28 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe State do
+
+  before(:each) do
+    @state = State.new
+  end
+
+  it "should not be valid when empty" do
+    @state.should_not be_valid
+  end
+
+  ['country', 'name'].each do |field|
+    it "should require #{field}" do
+      @state.should_not be_valid
+      @state.errors.full_messages.should include("#{field.intern.l(field).humanize} #{:error_message_blank.l}")
+    end
+  end
+  
+  it "should be valid when having correct information" do
+    @state.name = "A State"
+    @state.abbr = "ST"
+    @state.country = Country.new
+
+    @state.should be_valid
+  end
+
+end

data/spec/models/taxon_spec.rb

@@ -0,0 +1,38 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+module TaxonHelper
+  def valid_taxon_attributes
+    {
+      :name => "A Taxon",
+      :position => 1
+    }
+  end
+end
+
+describe Taxon do
+  include TaxonHelper
+
+  before(:each) do
+    @taxon = Taxon.new
+  end
+
+  it "should not be valid when empty" do
+    pending "Can it really be valid when empty?"
+    @taxon.should_not be_valid
+  end
+
+  ['name'].each do |field|
+    it "should require #{field}" do
+      pending "Is this field mandatory?"
+      @taxon.should_not be_valid
+      @taxon.errors.full_messages.should include("#{field.intern.l(field).humanize} #{:error_message_blank.l}")
+    end
+  end
+  
+  it "should be valid when having correct information" do
+    @taxon.attributes = valid_taxon_attributes
+
+    @taxon.should be_valid
+  end
+  
+end

data/spec/models/taxonomy_spec.rb

@@ -0,0 +1,37 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+module TaxonomyHelper
+  def valid_taxonomy_attributes
+    {
+      :name => "A Taxonomy"
+    }
+  end
+end
+
+describe Taxonomy do
+  include TaxonomyHelper
+
+  before(:each) do
+    @taxonomy = Taxonomy.new
+  end
+
+  it "should not be valid when empty" do
+    pending "Can it really be valid when empty?"
+    @taxonomy.should_not be_valid
+  end
+
+  ['name', 'root'].each do |field|
+    it "should require #{field}" do
+      pending "Is this field mandatory?"
+      @taxonomy.should_not be_valid
+      @taxonomy.errors.full_messages.should include("#{field.intern.l(field).humanize} #{:error_message_blank.l}")
+    end
+  end
+  
+  it "should be valid when having correct information" do
+    @taxonomy.attributes = valid_taxonomy_attributes
+
+    @taxonomy.should be_valid
+  end
+  
+end

data/spec/models/variant_spec.rb

@@ -1,14 +1,35 @@
-require File.dirname(__FILE__) + '/../spec_helper.rb'
+require File.dirname(__FILE__) + '/../spec_helper'
+
+module VariantSpecHelper
+  def valid_variant_attributes
+    {
+      :sku => "mt",
+      :price => 10,
+      :weight => 1,
+      :height => 1,
+      :width => 1,
+      :depth => 1
+    }
+  end
+end
+
 
 describe Variant do
-  
-  before do
+  include VariantSpecHelper
+
+  before(:each) do
     @variant = Variant.new
   end
 
-  it "should require a Product" do
-    @variant.valid?.should be_false
-    @variant.errors.full_messages.should include("Product can't be blank")
+  it "should not be valid when empty" do
+    @variant.should_not be_valid
+  end
+
+  ['product'].each do |field|
+    it "should require #{field}" do
+      @variant.should_not be_valid
+      @variant.errors.full_messages.should include("#{field.intern.l(field).humanize} #{:error_message_blank.l}")
+    end
   end
 
   describe "with a valid product" do
@@ -18,20 +39,60 @@ describe Variant do
       @variant.stub!(:product).and_return p
     end
 
-    it "should be valid with a price" do
-      @variant.price = "12.50"
-      @variant.valid?.should be_true
+    it "should be valid when having correct information" do
+      @variant.attributes = valid_variant_attributes
+      @variant.should be_valid
     end
-
-    it "should use the product.master_price if there is no price" do
+  
+    it "should set the price with the same value as its product master_price if not set" do
       @variant.product.should_receive(:master_price).exactly(2).and_return "11.33"
       @variant.valid?.should be_true
       @variant.price.should == BigDecimal.new("11.33")
     end
 
-    it "should be invalid without a price or a product.master_price" do
+    it "should not be valid if the price and its product master_price is not set" do
       @variant.valid?.should be_false
       @variant.errors.full_messages.should include("Must supply price for variant or master_price for product.")
     end
+
+    describe 'on_hand' do
+      before do
+        @variant.update_attributes!(valid_variant_attributes)
+      end
+
+      it "should update the inventory unit records when added" do
+        @variant.inventory_units.size.should == 0
+
+        @variant.update_attributes!({"on_hand" => "1"})
+        @variant.inventory_units.size.should == 1
+      end
+
+      it "should update the inventory unit records when removed" do
+        @variant.update_attributes!({"on_hand" => "2"})
+        @variant.inventory_units.size.should == 2
+
+        @variant.update_attributes!({"on_hand" => "1"})
+        @variant.inventory_units.size.should == 1
+        
+        @variant.update_attributes!({"on_hand" => "0"})
+        @variant.inventory_units.size.should == 0
+      end
+    end
+
+    it "should return how many units are available when requested" do
+        @variant.update_attributes!(valid_variant_attributes)
+        @variant.on_hand.should == 0
+        
+        @variant.update_attributes!({"on_hand" => 3.to_s})
+        @variant.on_hand.should == 3
+    end
+  
+    it "should respond if it is in stock" do
+        @variant.update_attributes!(valid_variant_attributes)
+        @variant.in_stock.should == false
+        
+        @variant.update_attributes!({"on_hand" => 3.to_s})
+        @variant.in_stock.should == true
+    end
   end
 end