datashift_spree 0.1.0

data/spec/spree_method_mapping_spec.rb

@@ -0,0 +1,222 @@
+# Copyright:: (c) Autotelik Media Ltd 2011
+# Author ::   Tom Statter
+# Date ::     Summer 2011
+#
+# License::   MIT - Free, OpenSource
+#
+# Details::   Specification for Spree aspect of datashift gem.
+#
+#             Tests the method mapping aspect, such as that we correctly identify 
+#             Spree Product attributes and associations
+#             
+require File.join(File.expand_path(File.dirname(__FILE__) ), "spec_helper")
+
+  
+describe 'SpreeMethodMapping' do
+
+
+
+    
+  before(:all) do
+    before_all_spree
+  end
+
+  before(:each) 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.has_many.should_not be_empty
+    DataShift::MethodDictionary.belongs_to.should_not be_empty
+    DataShift::MethodDictionary.assignments.should_not be_empty
+
+    assign = DataShift::MethodDictionary.assignments_for(@Product_klass)
+
+    assign.should include('available_on')   # Example of a simple column
+
+    DataShift::MethodDictionary.assignments[@Product_klass].should include('available_on')
+
+    has_many_ops = DataShift::MethodDictionary.has_many_for(@Product_klass)
+
+    has_many_ops.should include('properties')   # Product can have many properties
+
+    DataShift::MethodDictionary.has_many[@Product_klass].should include('properties')
+
+    btf = DataShift::MethodDictionary.belongs_to_for(@Product_klass)
+
+    btf.should include('tax_category')    # Example of a belongs_to assignment
+
+    DataShift::MethodDictionary.belongs_to[@Product_klass].should include('tax_category')
+
+    DataShift::MethodDictionary.column_types[@Product_klass].size.should == @Product_klass.columns.size
+  end
+
+
+  it "should find method details correctly for different forms of a column name" do
+
+    DataShift::MethodDictionary.build_method_details( @Product_klass )
+        
+    ["available On", 'available_on', "Available On", "AVAILABLE_ON"].each do |format|
+
+      method_details = DataShift::MethodDictionary.find_method_detail( @Product_klass, format )
+
+      method_details.operator.should == 'available_on'
+      method_details.operator_for(:assignment).should == 'available_on'
+
+      method_details.operator_for(:belongs_to).should be_nil
+      method_details.operator_for(:has_many).should be_nil
+
+      method_details.col_type.should_not be_nil
+      method_details.col_type.name.should == 'available_on'
+      method_details.col_type.default.should == nil
+      method_details.col_type.sql_type.should include 'datetime'   # works on mysql and sqlite
+      method_details.col_type.type.should == :datetime
+    end
+  end
+
+  it "should populate method details correctly for has_many forms of association name" do
+
+    DataShift::MethodDictionary.has_many[@Product_klass].should include('product_option_types')
+
+    DataShift::MethodDictionary.build_method_details( @Product_klass )
+        
+    ["product_option_types", "product option types", 'product Option_types', "ProductOptionTypes", "Product_Option_Types"].each do |format|
+      method_detail = DataShift::MethodDictionary.find_method_detail( @Product_klass, format )
+
+      method_detail.should_not be_nil
+
+      method_detail.operator_for(:has_many).should eq('product_option_types')
+      method_detail.operator_for(:belongs_to).should be_nil
+      method_detail.operator_for(:assignment).should be_nil
+    end
+  end
+
+
+  it "should populate method details correctly for assignment operators (none columns on #{@Product_klass})" do
+
+    DataShift::MethodDictionary.find_operators( @Product_klass, :reload => true, :instance_methods => true )
+
+    DataShift::MethodDictionary.build_method_details( @Product_klass )
+        
+    # Example of delegates i.e. cost_price column on Variant, delegated to Variant by Product
+
+    DataShift::MethodDictionary.assignments[@Product_klass].should include('cost_price')
+    DataShift::MethodDictionary.assignments[@Product_klass].should include('sku')
+
+
+    count_on_hand = DataShift::MethodDictionary.find_method_detail( @Product_klass, 'count on hand' )
+    count_on_hand.should_not be_nil
+    count_on_hand.operator.should == 'count_on_hand'
+
+    method = DataShift::MethodDictionary.find_method_detail( @Product_klass, 'sku' )
+    method.should_not be_nil
+    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 )
+
+    DataShift::MethodDictionary.build_method_details( @Product_klass )
+        
+    klazz_object = @Product_klass.new
+
+    klazz_object.should be_new_record
+
+    # we can use method details to populate a new AR object, essentailly same as
+    # klazz_object.send( count_on_hand.operator, 2)
+    count_on_hand = DataShift::MethodDictionary.find_method_detail( @Product_klass, 'count on hand' )
+
+    count_on_hand.assign( klazz_object, 2 )
+    klazz_object.count_on_hand.should == 2
+
+    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
+
+    method.operator.should == 'sku'
+
+    method.assign( klazz_object, 'TEST_SK 001')
+    klazz_object.sku.should == 'TEST_SK 001'
+
+  end
+
+  it "should enable assignment to has_many association on new object" do
+ 
+    DataShift::MethodDictionary.build_method_details( @Product_klass )
+        
+    method_detail = DataShift::MethodDictionary.find_method_detail( @Product_klass, 'taxons' )
+
+    method_detail.operator.should == 'taxons'
+
+    upload_object = @Product_klass.new
+
+    upload_object.taxons.size.should == 0
+
+    # NEW ASSOCIATION ASSIGNMENT
+
+    # assign via the send operator directly on load object
+    upload_object.send( method_detail.operator ) << @Taxon_klass.new
+
+    upload_object.taxons.size.should == 1
+
+    upload_object.send( method_detail.operator ) << [@Taxon_klass.new, @Taxon_klass.new]
+    upload_object.taxons.size.should == 3
+
+    # Use generic assignment on method detail - expect has_many to use << not =
+    method_detail.assign( upload_object, @Taxon_klass.new )
+    upload_object.taxons.size.should == 4
+
+    method_detail.assign( upload_object, [@Taxon_klass.new, @Taxon_klass.new])
+    upload_object.taxons.size.should == 6
+  end
+
+  it "should enable assignment to has_many association using existing objects" do
+
+    DataShift::MethodDictionary.find_operators( @Product_klass )
+
+    DataShift::MethodDictionary.build_method_details( @Product_klass )
+        
+    method_detail = DataShift::MethodDictionary.find_method_detail( @Product_klass, 'product_properties' )
+
+    method_detail.operator.should == 'product_properties'
+
+    klazz_object = @Product_klass.new
+
+    pp = @ProductProperty_klass.new
+    
+    pp.property = @prop1
+
+    # NEW ASSOCIATION ASSIGNMENT
+    klazz_object.send( method_detail.operator ) << @ProductProperty_klass.new
+
+    klazz_object.product_properties.size.should == 1
+
+    klazz_object.send( method_detail.operator ) << [@ProductProperty_klass.new, @ProductProperty_klass.new]
+    klazz_object.product_properties.size.should == 3
+
+    # Use generic assignment on method detail - expect has_many to use << not =
+    pp2 = @ProductProperty_klass.new
+    pp2.property = @prop1
+    method_detail.assign( klazz_object,  pp2)
+    klazz_object.product_properties.size.should == 4
+
+    pp3, pp4 = @ProductProperty_klass.new, @ProductProperty_klass.new
+    pp3.property = @prop2
+    pp4.property = @prop3
+    method_detail.assign( klazz_object, [pp3, pp4])
+    klazz_object.product_properties.size.should == 6
+
+  end
+
+  
+end

data/spec/spree_taxons_loader_spec.rb

@@ -0,0 +1,282 @@
+# Copyright:: (c) Autotelik Media Ltd 2011
+# Author ::   Tom Statter
+# Date ::     Summer 2011
+#
+# License::   MIT - Free, OpenSource
+#
+# Details::   Specification for Spree aspect of datashift gem.
+#
+#             Provides Loaders and rake tasks specifically tailored for uploading or exporting
+#             Spree Products, associations and Images
+#
+require File.join(File.expand_path(File.dirname(__FILE__) ), "spec_helper")
+
+require 'product_loader'
+
+describe 'SpreeLoader' do
+        
+  before(:all) do
+    before_all_spree
+  end
+
+  before(:each) do
+
+    begin
+        
+      before_each_spree
+    
+      @Product_klass.count.should == 0
+      @Taxon_klass.count.should == 0
+      
+      DataShift::MethodDictionary.clear
+      
+      # For Spree important to get instance methods too as Product delegates
+      # many important attributes to Variant (master)
+      DataShift::MethodDictionary.find_operators( @Product_klass, :instance_methods => true )
+    
+      @product_loader = DataShift::SpreeHelper::ProductLoader.new
+    rescue => e
+      puts e.inspect
+      puts e.backtrace
+    end
+  end
+
+
+  # Operation and results should be identical when loading multiple associations
+  # if using either single column embedded syntax, or one column per entry.
+
+  it "should load Products and multiple Taxons from single column", :taxons => true, :fail => true do
+    test_taxon_creation( 'SpreeProducts.xls' )
+  end
+
+  it "should load Products and multiple Taxons from multiple columns .xls", :taxons => true do
+    test_taxon_creation( 'SpreeProductsMultiColumn.xls' )
+  end
+
+  it "should load Products and multiple Taxons from multiple columns CSV", :taxons => true do
+    test_taxon_creation( 'SpreeProductsMultiColumn.csv' )
+  end
+  
+  def test_taxon_creation( source )
+
+    # we want to test both find and find_or_create so should already have an object
+    # for find
+    # want to test both lookup and dynamic creation - this Taxonomy should be found, rest created
+    root = @Taxonomy_klass.create( :name => 'Paintings' )
+    
+    x = root.taxons.create( :name => 'Landscape')
+    root.root.children << x
+    
+  
+    @Taxonomy_klass.count.should == 1
+    @Taxon_klass.count.should == 2
+    
+    root.root.children.should have_exactly(1).items
+    root.root.children[0].name.should == 'Landscape'
+    
+    @product_loader.perform_load( ifixture_file(source), :mandatory => ['sku', 'name', 'price'] )
+    
+    expected_multi_column_taxons
+  end
+  
+  def expected_multi_column_taxons
+      
+
+    # Paintings already existed and had 1 child Taxon (Landscape)
+    # 2 nested Taxon (Paintings>Nature>Seascape) created under it so expect Taxonomy :
+    
+    # WaterColour	
+    # Oils	
+    # Paintings >Nature>Seascape + Paintings>Landscape	
+    # Drawings
+    
+    @Taxonomy_klass.all.collect(&:name).sort.should == ["Drawings", "Oils", "Paintings", "WaterColour"]
+       
+
+    @Taxonomy_klass.count.should == 4
+    @Taxon_klass.count.should == 7
+
+    @Product_klass.count.should == 3
+    
+    p = @Variant_klass.find_by_sku("DEMO_001").product
+
+    p.taxons.should have_exactly(2).items
+    p.taxons.collect(&:name).sort.should == ['Paintings','WaterColour']
+     
+    p2 = @Variant_klass.find_by_sku("DEMO_002").product
+
+    p2.taxons.should have_exactly(4).items    
+    p2.taxons.collect(&:name).sort.should == ['Nature','Oils','Paintings','Seascape']
+     
+    paint_parent = @Taxonomy_klass.find_by_name('Paintings')
+     
+    paint_parent.taxons.should have_exactly(4).items # 3 children + all Taxonomies have a root Taxon
+    
+    paint_parent.taxons.collect(&:name).sort.should == ['Landscape','Nature','Paintings','Seascape']
+    
+    tn = @Taxon_klass.find_by_name('Nature')    # child with children 
+    ts = @Taxon_klass.find_by_name('Seascape')  # last child
+
+    ts.should_not be_nil
+    tn.should_not be_nil
+    
+    p2.taxons.collect( &:id ).should include(ts.id)
+    p2.taxons.collect( &:id ).should include(tn.id)
+
+     
+    tn.parent.id.should == paint_parent.root.id
+    ts.parent.id.should == tn.id
+    
+    tn.children.should have_exactly(1).items
+    ts.children.should have_exactly(0).items
+ 
+  end
+  
+  it "should load nested Taxons correctly even when same names from csv", :taxons => true do
+    
+    @Taxonomy_klass.delete_all
+    @Taxon_klass.delete_all    
+    
+    @Taxonomy_klass.count.should == 0
+    @Taxon_klass.count.should == 0 
+    
+    @product_loader.perform_load( ifixture_file('SpreeProductsComplexTaxons.xls') )
+    
+    expected_nested_multi_column_taxons
+  end
+
+  it "should load nested Taxons correctly even when same names from xls", :taxons => true do
+    
+    @Taxonomy_klass.delete_all
+    @Taxon_klass.delete_all    
+    
+    @Taxonomy_klass.count.should == 0
+    @Taxon_klass.count.should == 0 
+    
+    @product_loader.perform_load( ifixture_file('SpreeProductsComplexTaxons.csv') )
+    
+    expected_nested_multi_column_taxons
+    
+  end
+  
+  def expected_nested_multi_column_taxons
+    # Expected :
+    # 2  Paintings>Landscape
+    # 1  WaterColour
+    # 1  Paintings
+    # 1  Oils
+    # 2  Drawings>Landscape            - test same name for child (Paintings)
+    # 1  Paintings>Nature>Landscape    - test same name for child of a child
+    # 1  Landscape	
+    # 0  Drawings>Landscape                - test same structure should be reused
+    # 2  Paintings>Nature>Seascape->Cliffs - test only the leaf node is created, rest re-used
+    # 1  Drawings>Landscape>Bristol        - test a new leaf node created when parent name is same over different taxons
+      
+    #puts @Taxonomy_klass.all.collect(&:name).sort.inspect
+    @Taxonomy_klass.count.should == 5 
+    
+    @Taxonomy_klass.all.collect(&:name).sort.should == ['Drawings', 'Landscape', 'Oils', 'Paintings','WaterColour']
+    
+    @Taxonomy_klass.all.collect(&:root).collect(&:name).sort.should == ['Drawings', 'Landscape', 'Oils', 'Paintings','WaterColour']
+   
+    taxons = @Taxon_klass.all.collect(&:name).sort
+    
+    #puts "#{taxons.inspect} (#{taxons.size})"
+    
+    @Taxon_klass.count.should == 12
+   
+    taxons.should == ['Bristol', 'Cliffs', 'Drawings', 'Landscape', 'Landscape', 'Landscape', 'Landscape', 'Nature', 'Oils', 'Paintings', 'Seascape','WaterColour']
+
+    # drill down acts_as_nested_set ensure structures correct
+    
+    # Paintings - Landscape
+    #           - Nature
+    #                 - Landscape
+    #                 - Seascape
+    #                     - Cliffs
+    painting_onomy = @Taxonomy_klass.find_by_name('Paintings')
+
+    painting_onomy.taxons.should have_exactly(6).items
+    painting_onomy.root.child?.should be false
+     
+    painting = painting_onomy.root
+    
+    painting.children.should have_exactly(2).items
+    painting.children.collect(&:name).sort.should == ["Landscape", "Nature"]
+    
+    painting.descendants.should have_exactly(5).items
+    
+    lscape = {}
+    nature = nil
+    
+    @Taxon_klass.each_with_level(painting.self_and_descendants) do |t, i|
+    
+      
+      if(t.name == 'Nature')
+        nature = t
+        i.should == 1
+        t.children.should have_exactly(2).items
+        t.children.collect(&:name).should == ["Landscape", "Seascape"]
+
+        t.descendants.should have_exactly(3).items
+        t.descendants.collect(&:name).sort.should == ["Cliffs", "Landscape", "Seascape"]
+    
+      elsif(t.name == 'Landscape')
+        lscape[i] = t
+      end
+    end
+
+    nature.should_not be_nil
+    
+    lscape.size.should be 2
+    lscape[1].name.should == 'Landscape'
+    lscape[1].parent.id.should == painting.id
+
+    lscape[2].name.should == 'Landscape'
+    lscape[2].parent.id.should == nature.id
+    
+ 
+    seascape = @Taxon_klass.find_by_name('Seascape') 
+    seascape.children.should have_exactly(1).items
+    seascape.leaf?.should be false
+    
+
+    cliffs = @Taxon_klass.find_by_name('Cliffs') 
+    cliffs.children.should have_exactly(0).items
+    cliffs.leaf?.should be true
+
+    @Taxon_klass.find_by_name('Seascape').ancestors.collect(&:name).sort.should == ["Nature", "Paintings"]
+    
+    # Landscape appears multiple times, under different parents
+    @Taxon_klass.find_all_by_name('Landscape').should have_exactly(4).items
+
+    # Check the correct Landscape used, Drawings>Landscape>Bristol
+    
+    drawings = @Taxonomy_klass.find_by_name('Drawings')
+    
+    drawings.taxons.should have_exactly(3).items
+    
+    dl = drawings.taxons.find_by_name('Landscape').children
+    
+    
+    dl.should have_exactly(1).items
+  
+    b = dl.find_by_name('Bristol')
+    
+    b.children.should have_exactly(0).items
+    b.ancestors.collect(&:name).sort.should == ["Drawings", "Landscape"]
+
+    # empty top level taxons
+    ['Oils', 'Landscape'].each do |t|
+      tx = @Taxonomy_klass.find_by_name(t)
+      tx.taxons.should have_exactly(1).items
+      tx.root.name.should == t
+      tx.root.children.should have_exactly(0).items
+      tx.root.leaf?.should be true
+    end
+    
+
+  end
+  
+  
+end