ar_loader 0.0.6 → 0.0.8

data/spec/method_mapper_spec.rb

@@ -0,0 +1,222 @@
+# Copyright:: (c) Autotelik Media Ltd 2011
+# Author ::   Tom Statter
+# Date ::     Aug 2011
+# License::   MIT
+#
+# Details::   Specs for Excel aspect of Active Record Loader
+#
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe 'Method Mapping' do
+
+  before(:all) do
+    db_connect( 'test_file' )    # , test_memory, test_mysql
+    migrate_up
+    @klazz = Project
+    @assoc_klazz = Milestone
+  end
+  
+  before(:each) do
+    MethodMapper.clear
+    MethodMapper.find_operators( @klazz )
+    MethodMapper.find_operators( @assoc_klazz )
+  end
+  
+  it "should populate method map for a given AR model" do
+
+    MethodMapper.has_many.should_not be_empty
+    MethodMapper.has_many[Project].should include('milestones')
+
+    MethodMapper.assignments.should_not be_empty
+    MethodMapper.assignments[Project].should include('id')
+    MethodMapper.assignments[Project].should include('value_as_string')
+    MethodMapper.assignments[Project].should include('value_as_text')
+
+    MethodMapper.belongs_to.should_not be_empty
+    MethodMapper.belongs_to[Project].should be_empty
+
+
+    MethodMapper.column_types.should be_is_a(Hash)
+    MethodMapper.column_types.should_not be_empty
+    MethodMapper.column_types[Project].size.should == Project.columns.size
+
+
+  end
+
+  it "should populate assigment members without the equivalent association names" do
+
+    # we should remove has-many & belongs_to from basic assignment set as they require a DB lookup
+    # or a Model.create call, not a simple assignment
+
+    MethodMapper.assignments_for(@klazz).should_not include( MethodMapper.belongs_to_for(@klazz) )
+    MethodMapper.assignments_for(@klazz).should_not include( MethodMapper.has_many_for(@klazz) )
+  end
+
+
+  it "should populate assignment operators for method details for different forms of a column name" do
+
+    [:value_as_string, 'value_as_string', "VALUE as_STRING", "value as string"].each do |format|
+
+      method_details = MethodMapper.find_method_detail( @klazz, format )
+
+      method_details.class.should == MethodDetail
+
+      method_details.name.should eq( format.to_s )
+
+      method_details.operator.should == 'value_as_string'
+      method_details.operator_for(:assignment).should == 'value_as_string'
+      
+      method_details.operator?('value_as_string').should be_true
+      method_details.operator?('blah_as_string').should be_false
+
+      method_details.operator_for(:belongs_to).should be_nil
+      method_details.operator_for(:has_many).should be_nil
+    end
+  end
+
+
+  # Note : Not all assignments will currently have a column type, for example
+  # those that are derived from a delegate_belongs_to
+
+  it "should populate column types for assignment operators in method details" do
+
+    [:value_as_string, 'value_as_string', "VALUE as_STRING", "value as string"].each do |format|
+
+      method_details = MethodMapper.find_method_detail( @klazz, format )
+
+      method_details.class.should == MethodDetail
+
+      method_details.col_type.should_not be_nil
+      method_details.col_type.name.should == 'value_as_string'
+      method_details.col_type.default.should == nil
+      method_details.col_type.sql_type.should include 'varchar(255)'   # db specific, sqlite
+      method_details.col_type.type.should == :string
+    end
+  end
+
+  it "should populate required Class for assignment operators based on column type" do
+
+    [:value_as_string, 'value_as_string', "VALUE as_STRING", "value as string"].each do |format|
+
+      method_details = MethodMapper.find_method_detail( Project, format )
+
+      method_details.operator_class_name.should == 'String'
+      method_details.operator_class.should be_is_a(Class)
+      method_details.operator_class.should == String
+    end
+
+  end
+
+  it "should populate belongs_to operator for method details for different forms of a column name" do
+
+    # milestone.project = project.id
+    [:project, 'project', "PROJECT", "prOJECt"].each do |format|
+
+      method_details = MethodMapper.find_method_detail( Milestone, format )
+
+      method_details.should_not be_nil
+
+      method_details.operator.should == 'project'
+      method_details.operator_for(:belongs_to).should == 'project'
+
+      method_details.operator_for(:assignment).should be_nil
+      method_details.operator_for(:has_many).should be_nil
+    end
+
+  end
+
+  it "should populate required Class for belongs_to operator method details" do
+
+    MethodMapper.find_operators( LoaderRelease )
+    MethodMapper.find_operators( LongAndComplexTableLinkedToVersion )
+
+    # release.project = project.id
+    [:project, 'project', "PROJECT", "prOJECt"].each do |format|
+
+      method_details = MethodMapper.find_method_detail( LoaderRelease, format )
+
+      method_details.operator_class_name.should == 'Project'
+      method_details.operator_class.should == Project
+    end
+
+
+    #LongAndComplexTableLinkedToVersion.version = version.id
+
+    [:version, "Version", "verSION"].each do |format|
+      method_details = MethodMapper.find_method_detail( LongAndComplexTableLinkedToVersion, format )
+
+      method_details.operator_type.should == :belongs_to
+
+      method_details.operator_class_name.should == 'Version'
+      method_details.operator_class.should == Version
+    end
+  end
+
+   it "should populate required Class for has_one operator method details" do
+
+    MethodMapper.find_operators( Version )
+
+    # version.long_and_complex_table_linked_to_version = LongAndComplexTableLinkedToVersion.create()
+
+    [:long_and_complex_table_linked_to_version, 'LongAndComplexTableLinkedToVersion', "Long And Complex_Table_Linked To  Version", "Long_And_Complex_Table_Linked_To_Version"].each do |format|
+      method_details = MethodMapper.find_method_detail( Version, format )
+
+      method_details.should_not be_nil
+
+      method_details.operator.should == 'long_and_complex_table_linked_to_version'
+      
+      method_details.operator_type.should == :has_one
+
+      method_details.operator_class_name.should == 'LongAndComplexTableLinkedToVersion'
+      method_details.operator_class.should == LongAndComplexTableLinkedToVersion
+    end
+  end
+
+
+  it "should find has_many operator for method details" do
+
+    [:milestones, "Mile Stones", 'mileSTONES', 'MileStones'].each do |format|
+
+      method_details = MethodMapper.find_method_detail( Project, format )
+
+      method_details.class.should == MethodDetail
+      
+      result = 'milestones'
+      method_details.operator.should == result
+      method_details.operator_for(:has_many).should == result
+
+      method_details.operator_for(:belongs_to).should be_nil
+      method_details.operator_for(:assignments).should be_nil
+    end
+
+  end
+
+ 
+  it "should return nil when non existent column name" do
+    ["On sale", 'on_sale'].each do |format|
+      detail = MethodMapper.find_method_detail( @klazz, format )
+
+      detail.should be_nil
+    end
+  end
+
+
+  it "should find a set of methods based on a list of column names" do
+
+    mapper = MethodMapper.new
+
+    [:value_as_string, 'value_as_string', "VALUE as_STRING", "value as string"].each do |format|
+
+      method_details = MethodMapper.find_method_detail( @klazz, format )
+
+      method_details.class.should == MethodDetail
+
+      method_details.col_type.should_not be_nil
+      method_details.col_type.name.should == 'value_as_string'
+      method_details.col_type.default.should == nil
+      method_details.col_type.sql_type.should include 'varchar(255)'   # db specific, sqlite
+      method_details.col_type.type.should == :string
+    end
+  end
+
+end

data/spec/models.rb

@@ -0,0 +1,55 @@
+
+class Project < ActiveRecord::Base
+
+  has_one  :owner
+
+  has_many :milestones
+
+  has_many :loader_releases
+  has_many :versions, :through => :loader_releases
+
+
+  #has_many :release_versions, :through => :loader_releases, :source => :versions
+
+  has_and_belongs_to_many :categories
+
+end
+
+class Owner < ActiveRecord::Base
+  belongs_to :project
+end
+
+class Milestone < ActiveRecord::Base
+  belongs_to :project
+  #validate the name, cost
+end
+
+# had_and_belongs to join table
+class Category < ActiveRecord::Base
+  has_and_belongs_to_many :projects
+end
+
+
+class Version < ActiveRecord::Base
+  has_many :releases
+
+  has_one :long_and_complex_table_linked_to_version
+end
+
+# Join Table with additional columns
+class LoaderRelease < ActiveRecord::Base
+  
+  belongs_to :project
+  belongs_to :version
+
+  #validate the name
+end
+
+class Empty < ActiveRecord::Base
+end
+
+# Join Table with additional columns
+class LongAndComplexTableLinkedToVersion < ActiveRecord::Base
+
+  belongs_to :version
+end

data/spec/spec_helper.rb

@@ -1,19 +1,86 @@
-
-
-RSpec::Runner.configure do |config|
-  # config.use_transactional_fixtures = true
-  # config.use_instantiated_fixtures  = false
-  # config.fixture_path = RAILS_ROOT + '/spec/fixtures'
-
-  # You can declare fixtures for each behaviour like this:
-  #   describe "...." do
-  #     fixtures :table_a, :table_b
-  #
-  # Alternatively, if you prefer to declare them only once, you can
-  # do so here, like so ...
-  #
-  #   config.global_fixtures = :table_a, :table_b
-  #
-  # If you declare global fixtures, be aware that they will be declared
-  # for all of your examples, even those that don't use them.
+#require 'active_support'
+require 'active_record'
+require 'erb'
+
+require File.dirname(__FILE__) + '/../lib/ar_loader'
+
+
+#.# Copyright:: (c) Autotelik Media Ltd 2011
+# Author ::   Tom Statter
+# Date ::     Aug 2011
+# License::   MIT
+#
+# Details::   Spec Helper for Active Record Loader
+#
+#
+# We are not setup as a Rails project so need to mimic an active record database setup so
+# we have some  AR models top test against. Create an in memory database from scratch.
+#
+
+def db_connect( env = 'test_file')
+
+  require 'active_record'
+
+  # Some active record stuff seems to rely on the RAILS_ENV being set ?
+
+  ENV['RAILS_ENV'] = env
+  
+  configuration = {}
+
+  configuration[:database_configuration] = YAML::load(ERB.new(IO.read( File.dirname(__FILE__) + '/database.yml')).result)
+  db = configuration[:database_configuration][ env ]
+
+  puts "Setting DB Config - #{db.inspect}"
+  ActiveRecord::Base.configurations = db
+
+  #ActiveRecord::Base.logger = Logger.new(STDOUT)
+
+  puts "Connecting to DB"
+  ActiveRecord::Base.establish_connection( db )
+
+  require 'logger'
+  logdir = File.dirname(__FILE__) + '/logs'
+  FileUtils.mkdir_p(logdir) unless File.exists?(logdir)
+  ActiveRecord::Base.logger = Logger.new(logdir + '/test.log')
+
+  #puts "Connected to DB - #{ActiveRecord::Base.connection.inspect}"
+
+  require File.dirname(__FILE__) + '/models'   # load our test model definitions
+
+  # handle migration changes or reset of test DB
+  migrate_up
+
+end
+
+def db_clear
+  [Project, Milestone, Category, Version, LoaderRelease].each {|x| x.delete_all}
+end
+
+def load_in_memory
+  load "#{Rails.root}/db/schema.rb"
+end
+
+def migrate_up
+  ActiveRecord::Migrator.up(  File.dirname(__FILE__) + '/db/migrate')
+end
+
+
+$fixture_path = File.join(File.dirname(__FILE__), 'fixtures')
+
+RSpec.configure do |config|
+  # config.use_transactional_fixtures = true
+  # config.use_instantiated_fixtures  = false
+  # config.fixture_path = RAILS_ROOT + '/spec/fixtures'
+
+  # You can declare fixtures for each behaviour like this:
+  #   describe "...." do
+  #     fixtures :table_a, :table_b
+  #
+  # Alternatively, if you prefer to declare them only once, you can
+  # do so here, like so ...
+  #
+  #   config.global_fixtures = :table_a, :table_b
+  #
+  # If you declare global fixtures, be aware that they will be declared
+  # for all of your examples, even those that don't use them.
 end

data/spec/spree_loader_spec.rb

@@ -1,158 +1,224 @@
-unless defined? SPREE_ROOT
-  ENV["RAILS_ENV"] = "test"
-  case
-  when ENV["SPREE_ENV_FILE"]
-    require ENV["SPREE_ENV_FILE"]
-  when File.dirname(__FILE__) =~ %r{vendor/SPREE/vendor/extensions}
-    require "#{File.expand_path(File.dirname(__FILE__) + "/../../../../../../")}/config/environment"
-  else
-    require "#{File.expand_path(File.dirname(__FILE__) + "/../../../../")}/config/environment"
-  end
-end
-require "#{SPREE_ROOT}/spec/spec_helper"
-
-if File.directory?(File.dirname(__FILE__) + "/scenarios")
-  Scenario.load_paths.unshift File.dirname(__FILE__) + "/scenarios"
-end
-if File.directory?(File.dirname(__FILE__) + "/matchers")
-  Dir[File.dirname(__FILE__) + "/matchers/*.rb"].each {|file| require file }
-end
-
-require File.dirname(__FILE__) + '/spec_helper'
-
-describe 'ExcelLoader' do
-
-  before do
-    @klazz = Product
-    MethodMapper.clear
-  end
-  
-  it "should populate operators for a given AR model" do
-    MethodMapper.find_operators( @klazz )
-
-    MethodMapper.has_many.should_not be_empty
-    MethodMapper.assignments.should_not be_empty
-
-    hmf = MethodMapper.has_many_for(@klazz)
-    arf = MethodMapper.assignments_for(@klazz)
-
-    (hmf & arf).should_not be_empty       # Associations provide << or =
-
-    hmf.should include('properties')
-    arf.should include('count_on_hand')   # example of a column
-    arf.should include('cost_price')      # example of delegated assignment (available through Variant)
-
-    MethodMapper.column_types.should be_is_a(Hash)
-    MethodMapper.column_types.should_not be_empty
-
-    MethodMapper.column_type_for(@klazz, 'count_on_hand').should_not be_nil
-  end
-
-  it "should populate operators respecting unique option" do
-    MethodMapper.find_operators( @klazz, :unique => true )
-
-    hmf = MethodMapper.has_many_for(@klazz)
-    arf = MethodMapper.assignments_for(@klazz)
-
-    (hmf & arf).should be_empty
-  end
-
-  it "should populate assignment method and col type for different forms of a column name" do
-
-    MethodMapper.find_operators( @klazz )
-
-    ["Count On hand", 'count_on_hand', "Count OnHand", "COUNT ONHand"].each do |format|
-      mmap = MethodMapper.determine_calls( @klazz, format )
-
-      mmap.class.should == MethodDetail
-
-      mmap.assignment.should == 'count_on_hand='
-      mmap.has_many.should be_nil
-
-      mmap.col_type.should_not be_nil
-      mmap.col_type.name.should == 'count_on_hand'
-      mmap.col_type.default.should == 0
-      mmap.col_type.sql_type.should == 'int(10)'
-      mmap.col_type.type.should == :integer
-    end
-  end
-
-  it "should populate both methods for different forms of an association name" do
-
-    MethodMapper.find_operators( @klazz )
-    ["product_option_types", "product option types", 'product Option_types', "ProductOptionTypes", "Product_Option_Types"].each do |format|
-      mmap = MethodMapper.determine_calls( @klazz, format )
-
-      mmap.assignment.should == 'product_option_types='
-      mmap.has_many.should   == 'product_option_types'
-
-      mmap.col_type.should be_nil
-    end
-  end
-
-
-  it "should not populate anything when  non existent column name" do
-    ["On sale", 'on_sale'].each do |format|
-      mmap = MethodMapper.determine_calls( @klazz, format )
-
-      mmap.class.should == MethodDetail
-      mmap.assignment.should be_nil
-      mmap.has_many.should be_nil
-      mmap.col_type.should be_nil
-    end
-  end
-
-  it "should enable correct assignment and sending of a value to AR model" do
-
-    MethodMapper.find_operators( @klazz )
-    
-    mmap = MethodMapper.determine_calls( @klazz, 'count on hand' )
-    mmap.assignment.should == 'count_on_hand='
-
-    x = @klazz.new
-
-    x.should be_new_record
-
-    x.send( mmap.assignment, 2 )
-    x.count_on_hand.should == 2
-    x.on_hand.should == 2     # helper method I know looks at same thing
-
-    mmap = MethodMapper.determine_calls( @klazz, 'SKU' )
-    mmap.assignment.should == 'sku='
-    x.send( mmap.assignment, 'TEST_SK 001' )
-    x.sku.should == 'TEST_SK 001'
-  end
-
-  it "should enable correct assignment and sending of association to AR model" do
-
-    MethodMapper.find_operators( @klazz )
-
-    mmap = MethodMapper.determine_calls( @klazz, 'taxons' )
-    mmap.has_many.should == 'taxons'
-
-    x = @klazz.new
-
-    # NEW ASSOCIATION ASSIGNMENT  v.,mn
-    x.send( mmap.has_many ) << Taxon.new
-    x.taxons.size.should == 1
-
-    x.send( mmap.has_many ) << [Taxon.new, Taxon.new]
-    x.taxons.size.should == 3
-
-    # EXISTING ASSOCIATIONS
-    x = Product.find :first
-
-    t = Taxonomy.find_or_create_by_name( 'BlahSpecTest' )
-
-    if x
-      sz = x.taxons.size
-      x.send(mmap.has_many) << t.root
-      x.taxons.size.should == sz + 1
-    else
-      puts "WARNING : Test not run could not find any Test Products"
-    end
-
-  end
-
-
+require File.dirname(__FILE__) + '/spec_helper'
+
+require 'spree_helper'
+
+include ARLoader
+  
+describe 'SpreeLoader' do
+
+  before(:all) do
+    db_connect( 'test_file' )    # , test_memory, test_mysql
+    Spree.load
+    Spree.migrate_up
+
+    @klazz = Product
+
+    # TODO create proper suite of fixtures for Spree testing
+    @prop1 = Property.find_or_create_by_name( 'RSpecTestProperty')
+    @prop2 = Property.find_or_create_by_name( 'AN Other RSpecTestProperty')
+    @prop3 = Property.find_or_create_by_name( 'AN Other RSpecTestProperty')
+
+  end
+
+  before do
+
+    MethodMapper.clear
+    MethodMapper.find_operators( @klazz )
+
+    # TOFIX - weird error
+    # NameError:
+    #   undefined local variable or method `check_price' for #<Variant:0x1031f6658>
+    # but that method defined on Variant class in variant.rb
+
+    #@product = Product.new( :sku => "TRspec001", :name => 'Test RSPEC Product', :price => 99.99 )
+    #@product.save
+  end
+  
+  it "should populate operators for a Spree Product" do
+  
+    MethodMapper.has_many.should_not be_empty
+    MethodMapper.belongs_to.should_not be_empty
+    MethodMapper.assignments.should_not be_empty
+
+
+    assign = MethodMapper.assignments_for(@klazz)
+
+    assign.should include('count_on_hand')   # Example of a simple column
+    assign.should include('cost_price')      # Example of delegated assignment (available through Variant)
+
+    MethodMapper.assignments[@klazz].should include('cost_price')
+
+    has_many_ops = MethodMapper.has_many_for(@klazz)
+
+    has_many_ops.should include('properties')   # Product can have many properties
+
+    MethodMapper.has_many[@klazz].should include('properties')
+
+    btf = MethodMapper.belongs_to_for(@klazz)
+
+    btf.should include('tax_category')    # Example of a belongs_to assignment
+
+    MethodMapper.belongs_to[@klazz].should include('tax_category')
+
+    MethodMapper.column_types[@klazz].size.should == @klazz.columns.size
+  end
+
+
+  it "should find method details correctly for different forms of a column name" do
+
+    ["Count On hand", 'count_on_hand', "Count OnHand", "COUNT ONHand"].each do |format|
+
+      method_details = MethodMapper.find_method_detail( @klazz, format )
+
+      method_details.operator.should == 'count_on_hand'
+      method_details.operator_for(:assignment).should == 'count_on_hand'
+
+      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 == 'count_on_hand'
+      method_details.col_type.default.should == 0
+      method_details.col_type.sql_type.should include 'int'   # works on mysql and sqlite
+      method_details.col_type.type.should == :integer
+    end
+  end
+
+  it "should populate method details correctly for has_many forms of association name" do
+
+    MethodMapper.has_many[@klazz].should include('product_option_types')
+
+    ["product_option_types", "product option types", 'product Option_types', "ProductOptionTypes", "Product_Option_Types"].each do |format|
+      method_detail = MethodMapper.find_method_detail( @klazz, 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 enable correct assignment to a column on Product" do
+
+    method_detail = MethodMapper.find_method_detail( @klazz, 'count on hand' )
+    method_detail.operator.should == 'count_on_hand'
+
+    klazz_object = @klazz.new
+
+    klazz_object.should be_new_record
+
+    method_detail.assign( klazz_object, 2 )
+    klazz_object.count_on_hand.should == 2
+
+    method_detail.assign( klazz_object, 5 )
+    klazz_object.count_on_hand.should == 5
+
+    method = MethodMapper.find_method_detail( @klazz, 'SKU' )
+    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
+ 
+    method_detail = MethodMapper.find_method_detail( @klazz, 'taxons' )
+
+    method_detail.operator.should == 'taxons'
+
+    klazz_object = @klazz.new
+
+    klazz_object.taxons.size.should == 0
+
+    # NEW ASSOCIATION ASSIGNMENT
+
+    # assign via the send operator directly on load object
+    klazz_object.send( method_detail.operator ) << Taxon.new
+
+    klazz_object.taxons.size.should == 1
+
+    klazz_object.send( method_detail.operator ) << [Taxon.new, Taxon.new]
+    klazz_object.taxons.size.should == 3
+
+    # Use generic assignment on method detail - expect has_many to use << not =
+    method_detail.assign( klazz_object, Taxon.new )
+    klazz_object.taxons.size.should == 4
+
+    method_detail.assign( klazz_object, [Taxon.new, Taxon.new])
+    klazz_object.taxons.size.should == 6
+  end
+
+  it "should enable assignment to has_many association using existing objects" do
+
+    MethodMapper.find_operators( @klazz )
+
+    method_detail = MethodMapper.find_method_detail( @klazz, 'product_properties' )
+
+    method_detail.operator.should == 'product_properties'
+
+    klazz_object = @klazz.new
+
+    ProductProperty.new(:property => @prop1)
+
+    # NEW ASSOCIATION ASSIGNMENT
+    klazz_object.send( method_detail.operator ) << ProductProperty.new
+
+    klazz_object.product_properties.size.should == 1
+
+    klazz_object.send( method_detail.operator ) << [ProductProperty.new, ProductProperty.new]
+    klazz_object.product_properties.size.should == 3
+
+    # Use generic assignment on method detail - expect has_many to use << not =
+    method_detail.assign( klazz_object, ProductProperty.new(:property => @prop1) )
+    klazz_object.product_properties.size.should == 4
+
+    method_detail.assign( klazz_object, [ProductProperty.new(:property => @prop2), ProductProperty.new(:property => @prop3)])
+    klazz_object.product_properties.size.should == 6
+
+  end
+
+  it "should process a simple .xls spreadsheet" do
+
+    Zone.delete_all
+
+    loader = ExcelLoader.new(Zone)
+
+    count = Zone.count
+    loader.load( $fixture_path + '/SpreeZoneExample.xls')
+
+    loader.loaded_count.should == (Zone.count - count)
+  end
+
+  it "should process a simple csv file", :focus => false do
+
+    Zone.delete_all
+
+    loader = CsvLoader.new(Zone)
+
+    count = Zone.count
+    loader.load( $fixture_path + '/SpreeZoneExample.csv')
+
+    loader.loaded_count.should == (Zone.count - count)
+  end
+
+  it "should load Products via specific Spree loader", :focus => true do
+
+    require 'product_loader'
+
+    Product.delete_all; Variant.delete_all; Taxon.delete_all
+    
+    count = Product.count
+
+    loader = ARLoader::ProductLoader.new
+
+    # REQUIRED 'set' methods on Product i.e will not validate/save without these
+
+    loader.load($fixture_path + '/SpreeProducts.xls', :mandatory => ['sku', 'name', 'price'] )
+
+    loader.loaded_count.should == (Product.count - count)
+  end
+
 end