datashift_spree 0.2.1 → 0.3.0

data/spec/spree_images_loader_spec.rb

@@ -33,9 +33,7 @@ describe 'SpreeImageLoading' do
     @product_loader.perform_load( ifixture_file('SpreeProductsWithImages.csv'), options )
    
     @Image_klass.count.should == 3
-    
-    #@Image_klass.all.each_with_index {|i, x| puts "SPEC CHECK IMAGE #{x}", i.inspect }
-        
+   
     p = @Product_klass.find_by_name("Demo Product for AR Loader")
     
     p.name.should == "Demo Product for AR Loader"
@@ -61,11 +59,10 @@ describe 'SpreeImageLoading' do
     @Product_klass.all.each {|p| p.images.should have_exactly(1).items }
      
     @Image_klass.count.should == 3
-
   end
   
   
-  it "should assign Images to preloaded Products by SKU via Excel", :fail => true  do
+  it "should assign Images to preloaded Products by SKU via Excel"  do
     
     DataShift::MethodDictionary.find_operators( @Image_klass )
     
@@ -76,8 +73,8 @@ describe 'SpreeImageLoading' do
     @Image_klass.count.should == 0
          
     @Product_klass.find_by_name("Demo third row in future").images.should have_exactly(0).items
-     
-    loader = DataShift::SpreeHelper::ImageLoader.new
+      
+    loader = DataShift::SpreeHelper::ImageLoader.new(nil, {})
     
     loader.perform_load( ifixture_file('SpreeImagesBySku.xls'), {} )
    
@@ -92,7 +89,7 @@ describe 'SpreeImageLoading' do
     # fixtures/images/DEMO_003_ror_mug.jpeg
   end
   
-  it "should assign Images to preloaded Products by Name via Excel "  do
+  it "should assign Images to preloaded Products by Name via Excel" do
     
     @Product_klass.count.should == 0
     
@@ -104,7 +101,7 @@ describe 'SpreeImageLoading' do
      
     p.images.should have_exactly(0).items
      
-    loader = DataShift::SpreeHelper::ImageLoader.new
+    loader = DataShift::SpreeHelper::ImageLoader.new(nil, {})
     
     loader.perform_load( ifixture_file('SpreeImagesByName.xls'), {} )
    
@@ -119,34 +116,76 @@ describe 'SpreeImageLoading' do
     # fixtures/images/DEMO_003_ror_mug.jpeg
   end
   
-  it "should be able to set alternative text" do
+  it "should be able to set alternative text within images column" do
    
     options = {:mandatory => ['sku', 'name', 'price']}
     
     @product_loader.perform_load( ifixture_file('SpreeProductsWithMultipleImages.xls'), options )
-         
+       
+    @Product_klass.count.should == 2
     @Image_klass.count.should == 5
-    
-    product = @Product_klass.where(:name => "Demo Product for AR Loader").first
-    
-    p = DataShift::SpreeHelper::get_image_owner(product)
+     
+    p = DataShift::SpreeHelper::get_image_owner( @Product_klass.find_by_name("Demo Product 001") )
     
     p.sku.should == 'MULTI_001'
     p.images.should have_exactly(3).items
     
-    # attr_accessible :alt, :attachment, :position, :viewable_type, :viewable_id
-    p.images[1].alt.should == 'more random alt text'
+    p.images[0].alt.should == ''
+    p.images[1].alt.should == 'alt text for multi 001'
          
-    product = @Product_klass.where(:name => "Demo Excel Load via Jruby").first
-    
-    p = DataShift::SpreeHelper::get_image_owner(product)
+    p = DataShift::SpreeHelper::get_image_owner( @Product_klass.find_by_name("Demo Product 002") )
     
     p.sku.should == 'MULTI_002'
     p.images.should have_exactly(2).items
-    
-    # attr_accessible :alt, :attachment, :position, :viewable_type, :viewable_id
-    p.images[1].alt.should == 'some random alt text'
+
+    p.images[0].alt.should == 'some random alt text for 002'
+    p.images[1].alt.should == '323X428 ror bag'
 
   end
   
+  
+  it "should assign Images to preloaded Products from filesystem on SKU", :fail => true  do
+    
+    # first load some products with SKUs that match the image names
+    @Product_klass.count.should == 0
+    
+    @product_loader.perform_load( ifixture_file('SpreeProducts.xls'))
+    
+    @Product_klass.count.should == 3
+    @Image_klass.all.size.should == 0
+    
+    # now the test - find files, chew up name, find product, create image, attach 
+                     
+    image_klass = DataShift::SpreeHelper::get_spree_class('Image' )
+   
+    raise "Cannot find Attachment Class" unless image_klass
+        
+    loader_options = { :verbose => true }
+
+    owner_klass = DataShift::SpreeHelper::product_attachment_klazz
+    
+    if(DataShift::SpreeHelper::version.to_f > 1.0 )
+      owner_klass.should == Spree::Variant
+    else
+      owner_klass.should == Spree::Product
+    end
+    
+    loader_options[:attach_to_klass] = owner_klass    # Pass in real Ruby class not string class name
+    
+    # TOFIX - name wont currently work for Variant and sku won't work for Product
+    # so need  way to build a where clause or add scopes to Variant/Product 
+    loader_options[:attach_to_find_by_field] = (owner_klass == Spree::Variant) ? :sku : :name
+    
+    loader_options[:attach_to_field] = 'images'
+         
+    loader = DataShift::Paperclip::AttachmentLoader.new(image_klass, true, nil, loader_options)
+
+    loader.attach_to_klass.should == owner_klass
+    
+    attachment_options = { :split_file_name_on => '_' }
+    
+    loader.process_from_filesystem( File.join(fixtures_path, 'images'), attachment_options)
+     
+    @Image_klass.count.should == 3
+  end
 end

data/spec/spree_loader_spec.rb

@@ -27,7 +27,7 @@ describe 'SpreeLoader' do
 
     @Zone_klass.delete_all
 
-    loader = DataShift::ExcelLoader.new(@Zone_klass)
+    loader = DataShift::ExcelLoader.new(@Zone_klass, true)
     
     loader.perform_load( ifixture_file('SpreeZoneExample.xls') )
 

data/spec/spree_method_mapping_spec.rb

@@ -14,8 +14,6 @@ require File.join(File.expand_path(File.dirname(__FILE__) ), "spec_helper")
   
 describe 'SpreeMethodMapping' do
 
-
-
     
   before(:all) do
     before_all_spree
@@ -26,13 +24,13 @@ describe 'SpreeMethodMapping' do
     before_each_spree
       
     DataShift::MethodDictionary.clear
-    DataShift::MethodDictionary.find_operators( @Product_klass )
-    #MethodDictionary.build_method_details( @Product_klass )
   end
 
   
   it "should populate operators for a Spree Product" do
   
+    DataShift::MethodDictionary.find_operators( @Product_klass )
+     
     DataShift::MethodDictionary.has_many.should_not be_empty
     DataShift::MethodDictionary.belongs_to.should_not be_empty
     DataShift::MethodDictionary.assignments.should_not be_empty
@@ -61,6 +59,8 @@ describe 'SpreeMethodMapping' do
 
   it "should find method details correctly for different forms of a column name" do
 
+    DataShift::MethodDictionary.find_operators( @Product_klass )
+     
     DataShift::MethodDictionary.build_method_details( @Product_klass )
         
     ["available On", 'available_on', "Available On", "AVAILABLE_ON"].each do |format|
@@ -83,6 +83,8 @@ describe 'SpreeMethodMapping' do
 
   it "should populate method details correctly for has_many forms of association name" do
 
+    DataShift::MethodDictionary.find_operators( @Product_klass )
+    
     DataShift::MethodDictionary.has_many[@Product_klass].should include('product_option_types')
 
     DataShift::MethodDictionary.build_method_details( @Product_klass )
@@ -120,6 +122,7 @@ describe 'SpreeMethodMapping' do
     method.operator.should == 'sku'
   end
 
+
   it "should enable assignment via operators for none columns on #{@Product_klass}" do
 
     DataShift::MethodDictionary.find_operators( @Product_klass, :reload => true, :instance_methods => true )
@@ -140,18 +143,22 @@ describe 'SpreeMethodMapping' do
     count_on_hand.assign( klazz_object, 5 )
     klazz_object.count_on_hand.should == 5
 
-    method = DataShift::MethodDictionary.find_method_detail( @Product_klass, 'sku' )
-    method.should_not be_nil
+    ["sku", "SKU", 'Sku'].each do |f|
+      method = DataShift::MethodDictionary.find_method_detail( @Product_klass, f )
+      method.should_not be_nil
 
-    method.operator.should == 'sku'
+      method.operator.should == 'sku'
 
-    method.assign( klazz_object, 'TEST_SK 001')
-    klazz_object.sku.should == 'TEST_SK 001'
+      method.assign( klazz_object, 'TEST_SK 001')
+      klazz_object.sku.should == 'TEST_SK 001'
+    end
 
   end
 
   it "should enable assignment to has_many association on new object" do
  
+    DataShift::MethodDictionary.find_operators( @Product_klass )
+ 
     DataShift::MethodDictionary.build_method_details( @Product_klass )
         
     method_detail = DataShift::MethodDictionary.find_method_detail( @Product_klass, 'taxons' )
@@ -218,5 +225,99 @@ describe 'SpreeMethodMapping' do
 
   end
 
+  it "should leave nil entries when no method_detail found for inbound headers" do
+    
+    DataShift::MethodDictionary.find_operators( @Product_klass, :instance_methods => true )
+ 
+    DataShift::MethodDictionary.build_method_details(@Product_klass)
+    
+    headers = ['BLAH', 'Weight', :rubbish,  :variants]
+    
+    method_mapper = DataShift::MethodMapper.new
+     
+    method_details = method_mapper.map_inbound_headers_to_methods( @Product_klass, headers )
+    
+    method_details.compact.should have_exactly(2).items
+    
+    method_details.should have_exactly(4).items
+    
+    method_details[0].should be_nil
+    method_details[2].should be_nil
+    
+  end
+  
+  it "should add 'null' type method details for :force_inclusion items when no method_detail found" do
+    
+    DataShift::MethodDictionary.find_operators( @Product_klass, :instance_methods => true )
+ 
+    DataShift::MethodDictionary.build_method_details(@Product_klass)
+    
+    headers = ['BLAH', 'Weight', :rubbish,  :variants]
+    
+    method_mapper = DataShift::MethodMapper.new
+    
+    options = { :force_inclusion => ['blah', :rubbish] }
+   
+    method_details = method_mapper.map_inbound_headers_to_methods( @Product_klass, headers, options )
+    
+    method_details[0].name.should == 'BLAH'
+    method_details[0].operator.should == 'BLAH'
+    method_details[0].col_type.should be_nil
+      
+    method_details.compact.should have_exactly(4).items
+    
+    method_details.should have_exactly(4).items
+  end
+    
+  it "should ignore :force_inclusion items if they are genuine columns" do
+    
+    DataShift::MethodDictionary.find_operators( @Product_klass, :instance_methods => true )
+ 
+    DataShift::MethodDictionary.build_method_details(@Product_klass)
+    
+    headers = ['VARIANTS', 'BLAH_SHOULD_BE_NULL_MD', 'Weight', :rubbish_should_be_nil]
+    
+    method_mapper = DataShift::MethodMapper.new
+     
+    options = { :force_inclusion => ['blah_SHOULD_be_null_MD', 'weight', :variants] }
+   
+    method_details = method_mapper.map_inbound_headers_to_methods( @Product_klass, headers, options )
+    
+    method_details.compact.should have_exactly(3).items
+    
+    method_details.should have_exactly(4).items
+    
+    method_details[0].name.should == 'VARIANTS' 
+    method_details[0].operator.should == 'variants'
+    method_details[0].operator_type.should == :has_many
+    
+    method_details[1].name.should == 'BLAH_SHOULD_BE_NULL_MD' 
+    method_details[1].operator_type.should == :assignment
+    method_details[1].col_type.should be_nil
+    
+  end
+  
+  
+  it "should find all method_details for instance methods based on inbound headers" do
+    
+    DataShift::MethodDictionary.find_operators( @Product_klass, :instance_methods => true )
+ 
+    DataShift::MethodDictionary.build_method_details(@Product_klass)
+    
+    headers = ['SKU', 'Sku', :cost_price, 'PRICE', :junk, 'Weight']
+    expected = ['sku', 'sku', 'cost_price', 'price', 'weight']
+        
+    method_mapper = DataShift::MethodMapper.new
+     
+    method_details = method_mapper.map_inbound_headers_to_methods( @Product_klass, headers )
+    
+    method_details.should have_exactly(6).items
+    
+    method_details.compact.should have_exactly(5).items
+    
+    method_details.compact.collect(&:operator).should == expected
+    
+  end
+  
   
 end