datashift 0.13.0 → 0.14.0

data/spec/excel_exporter_spec.rb

@@ -25,7 +25,6 @@ describe 'Excel Exporter' do
     # handle migration changes or reset of test DB
     migrate_up
 
-    db_clear()    # todo read up about proper transactional fixtures
     results_clear()
 
     @klazz = Project
@@ -36,6 +35,13 @@ describe 'Excel Exporter' do
     MethodDictionary.clear
     MethodDictionary.find_operators( @klazz )
     MethodDictionary.find_operators( @assoc_klazz )
+    
+    db_clear()    # todo read up about proper transactional fixtures
+        
+    Project.create( :value_as_string	=> 'Value as String', :value_as_boolean => true,	:value_as_double => 75.672)
+    Project.create( :value_as_string	=> 'Another Value as String', :value_as_boolean => false,	:value_as_double => 12)
+     
+    
   end
   
   it "should be able to create a new excel exporter" do
@@ -44,7 +50,33 @@ describe 'Excel Exporter' do
     generator.should_not be_nil
   end
   
-  it "should export a model to .xls file" do
+  it "should handle bad params to export" do
+
+    expect = result_file('project_first_export_spec.csv')
+
+    exporter = DataShift::ExcelExporter.new( expect )
+    
+    expect{ exporter.export(nil) }.not_to raise_error
+
+    expect{ exporter.export([]) }.not_to raise_error
+   
+    puts "Can manually check file @ #{expect}"
+  end
+  
+  it "should export model object to .xls file" do
+
+    expect = result_file('project_first_export_spec.xls')
+
+    gen = ExcelExporter.new( expect )
+    
+    gen.export(Project.all.first)
+ 
+    File.exists?(expect).should be_true
+      
+    puts "Can manually check file @ #{expect}"
+  end
+
+  it "should export collection of model objects to .xls file" do
 
     expect = result_file('project_export_spec.xls')
 
@@ -56,7 +88,7 @@ describe 'Excel Exporter' do
       
     puts "Can manually check file @ #{expect}"
   end
-
+  
   it "should export a  model and associations to .xls file" do
 
     Project.create( :value_as_string	=> 'Value as Text', :value_as_boolean => true,	:value_as_double => 75.672)

data/spec/excel_loader_spec.rb

@@ -28,7 +28,7 @@ describe 'Excel Loader' do
   before(:each) do
 
     %w{category_001 category_002 category_003 category_004 category_005}.each do |cat|
-      Category.find_or_create_by_reference(cat)
+      Category.find_or_create_by(reference: cat)
     end
 
     
@@ -136,13 +136,15 @@ describe 'Excel Loader' do
   it "should provide facility to set default values", :focus => true do
     loader = ExcelLoader.new(Project)
       
-    loader.set_default_value('value_as_string', 'some default text' )
-    loader.set_default_value('value_as_double', 45.467 )
-    loader.set_default_value('value_as_boolean', true )
+    populator = loader.populator
+    
+    populator.set_default_value('value_as_string', 'some default text' )
+    populator.set_default_value('value_as_double', 45.467 )
+    populator.set_default_value('value_as_boolean', true )
       
     texpected = Time.now.to_s(:db)
       
-    loader.set_default_value('value_as_datetime', texpected )
+    populator.set_default_value('value_as_datetime', texpected )
       
     #value_as_string	Value as Text	value as datetime	value_as_boolean	value_as_double	category
 
@@ -171,8 +173,8 @@ describe 'Excel Loader' do
   it "should provide facility to set pre and post fix values" do
     loader = ExcelLoader.new(Project)
       
-    loader.set_prefix('value_as_string', 'myprefix' )
-    loader.set_postfix('value_as_string', 'my post fix' )
+    loader.populator.set_prefix('value_as_string', 'myprefix' )
+    loader.populator.set_postfix('value_as_string', 'my post fix' )
       
     #value_as_string	Value as Text	value as datetime	value_as_boolean	value_as_double	category
 

data/spec/excel_spec.rb

@@ -39,13 +39,34 @@ describe 'Excel Proxy' do
     sheet2 = @excel.create_worksheet( :name => "underworld")
     sheet2.name.should == "underworld"
   end
+
+  it "can sanitize worksheet names as per Excel spec" do
+    
+    include ExcelBase
+    extend ExcelBase
+    
+    #    name.gsub(/[\[\]:\*\/\\\?]/, '
+    
+    sanitize_sheet_name("aute?chre").should == "autechre"
+    sanitize_sheet_name("?autechre").should == "autechre"
+    sanitize_sheet_name("aute?chre?").should == "autechre"
+    
+    sanitize_sheet_name("daft: ?punk").should == "daft punk"
+    sanitize_sheet_name("guy call[]ed *Gerald").should == "guy called Gerald"
+
+    sanitize_sheet_name("guy called */Gerald").should == "guy called Gerald"
+  end
   
-  it "ensures name of worksheet sanitized" do
-    sheet = @excel.create_worksheet( :name => "daft: ?punk")
-    sheet.name.should == "daft punk"
+  # Pending - inject create_worksheet method into Spreadsheet gem
+  if(DataShift::Guards.jruby?)  
+    it "ensures name of worksheet sanitized" do
     
-    sheet = @excel.create_worksheet( :name => "under[]world")
-    sheet.name.should == "underworld"
+      sheet = @excel.create_worksheet( :name => "daft: ?punk")
+      sheet.name.should == "daft punk"
+    
+      sheet = @excel.create_worksheet( :name => "under[]world")
+      sheet.name.should == "underworld"
+    end
   end
   
   it "can create multiple named worksheets" do

data/spec/{loader_spec.rb → loader_base_spec.rb}

@@ -9,7 +9,7 @@ require File.dirname(__FILE__) + '/spec_helper'
 
 require 'erb'
 
-describe 'Basic Loader' do
+describe 'LoaderBase' do
 
   include_context "ActiveRecordTestModelsConnected"
   
@@ -111,4 +111,16 @@ describe 'Basic Loader' do
 
   end
 
+  it "should be able to mark a load attempt as a failure" do
+    
+    failed_count = @loader.failed_count
+    @loader.load_object.new_record?.should be_true
+     
+    @loader.load_object.save!
+     
+    @loader.failure 
+    
+    @loader.failed_count.should == failed_count + 1
+  end
+  
 end

data/spec/method_dictionary_spec.rb

@@ -13,72 +13,69 @@ require 'method_dictionary'
 
 describe 'Method Dictionary' do
 
-
   include_context "ActiveRecordTestModelsConnected"
   
-  include DataShift
-  
   before(:each) do
-    MethodDictionary.clear
+    DataShift::MethodDictionary.clear
   end
   
   it "should store dictionary for multiple AR models" do
     
-    MethodDictionary.find_operators( Project )
-    MethodDictionary.find_operators( Milestone )
+    DataShift::MethodDictionary.find_operators( Project )
+    DataShift::MethodDictionary.find_operators( Milestone )
     
-    MethodDictionary.assignments.size.should == 2 
-    MethodDictionary.has_many.size.should == 2
+    DataShift::MethodDictionary.assignments.size.should == 2 
+    DataShift::MethodDictionary.has_many.size.should == 2
   end
   
   it "should populate method dictionary for a given AR model" do
 
-    MethodDictionary.find_operators( Project )
-    MethodDictionary.find_operators( Milestone )
+    DataShift::MethodDictionary.find_operators( Project )
+    DataShift::MethodDictionary.find_operators( Milestone )
     
-    MethodDictionary.has_many.should_not be_empty
-    MethodDictionary.has_many[Project].should include('milestones')
+    DataShift::MethodDictionary.has_many.should_not be_empty
+    DataShift::MethodDictionary.has_many[Project].should include('milestones')
 
-    MethodDictionary.assignments.should_not be_empty
-    MethodDictionary.assignments[Project].should include('id')
-    MethodDictionary.assignments[Project].should include('value_as_string')
-    MethodDictionary.assignments[Project].should include('value_as_text')
+    DataShift::MethodDictionary.assignments.should_not be_empty
+    DataShift::MethodDictionary.assignments[Project].should include('id')
+    DataShift::MethodDictionary.assignments[Project].should include('value_as_string')
+    DataShift::MethodDictionary.assignments[Project].should include('value_as_text')
 
-    MethodDictionary.belongs_to.should_not be_empty
-    MethodDictionary.belongs_to[Project].should be_empty
+    DataShift::MethodDictionary.belongs_to.should_not be_empty
+    DataShift::MethodDictionary.belongs_to[Project].should be_empty
 
 
-    MethodDictionary.column_types.should be_is_a(Hash)
-    MethodDictionary.column_types.should_not be_empty
-    MethodDictionary.column_types[Project].size.should == Project.columns.size
+    DataShift::MethodDictionary.column_types.should be_is_a(Hash)
+    DataShift::MethodDictionary.column_types.should_not be_empty
+    DataShift::MethodDictionary.column_types[Project].size.should == Project.columns.size
 
 
   end
 
   it "should populate assigment members without the equivalent association names" do
 
-    MethodDictionary.find_operators( Project )
+    DataShift::MethodDictionary.find_operators( Project )
     
     # 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
 
-    MethodDictionary.assignments_for(Project).should_not include( MethodDictionary.belongs_to_for(Project) )
-    MethodDictionary.assignments_for(Project).should_not include( MethodDictionary.has_many_for(Project) )
+    DataShift::MethodDictionary.assignments_for(Project).should_not include( DataShift::MethodDictionary.belongs_to_for(Project) )
+    DataShift::MethodDictionary.assignments_for(Project).should_not include( DataShift::MethodDictionary.has_many_for(Project) )
   end
 
 
   it "should populate assignment operators for method details for different forms of a column name" do
 
-    MethodDictionary.find_operators( Project )
-    MethodDictionary.find_operators( Milestone )
+    DataShift::MethodDictionary.find_operators( Project )
+    DataShift::MethodDictionary.find_operators( Milestone )
     
-    MethodDictionary.build_method_details( Project )
+    DataShift::MethodDictionary.build_method_details( Project )
     
     [:value_as_string, 'value_as_string', "VALUE as_STRING", "value as string"].each do |format|
 
-      method_details = MethodDictionary.find_method_detail( Project, format )
+      method_details = DataShift::MethodDictionary.find_method_detail( Project, format )
 
-      method_details.class.should == MethodDetail
+      method_details.class.should == DataShift::MethodDetail
 
       method_details.operator.should == 'value_as_string'
       method_details.operator_for(:assignment).should == 'value_as_string'
@@ -97,15 +94,15 @@ describe 'Method Dictionary' do
 
   it "should populate column types for assignment operators in method details" do
 
-    MethodDictionary.find_operators( Project )
+    DataShift::MethodDictionary.find_operators( Project )
     
-    MethodDictionary.build_method_details( Project )
+    DataShift::MethodDictionary.build_method_details( Project )
         
     [:value_as_string, 'value_as_string', "VALUE as_STRING", "value as string"].each do |format|
 
-      method_details = MethodDictionary.find_method_detail( Project, format )
+      method_details = DataShift::MethodDictionary.find_method_detail( Project, format )
 
-      method_details.class.should == MethodDetail
+      method_details.class.should == DataShift::MethodDetail
 
       method_details.col_type.should_not be_nil
       method_details.col_type.name.should == 'value_as_string'
@@ -117,13 +114,13 @@ describe 'Method Dictionary' do
 
   it "should populate required Class for assignment operators based on column type" do
 
-    MethodDictionary.find_operators( Project )
+    DataShift::MethodDictionary.find_operators( Project )
     
-    MethodDictionary.build_method_details( Project )
+    DataShift::MethodDictionary.build_method_details( Project )
         
     [:value_as_string, 'value_as_string', "VALUE as_STRING", "value as string"].each do |format|
 
-      method_details = MethodDictionary.find_method_detail( Project, format )
+      method_details = DataShift::MethodDictionary.find_method_detail( Project, format )
 
       method_details.operator_class_name.should == 'String'
       method_details.operator_class.should be_is_a(Class)
@@ -134,16 +131,16 @@ describe 'Method Dictionary' do
 
   it "should populate belongs_to operator for method details for different forms of a column name" do
 
-    MethodDictionary.find_operators( Project )
-    MethodDictionary.find_operators( Milestone )
+    DataShift::MethodDictionary.find_operators( Project )
+    DataShift::MethodDictionary.find_operators( Milestone )
     
-    MethodDictionary.build_method_details( Project )
-    MethodDictionary.build_method_details( Milestone )
+    DataShift::MethodDictionary.build_method_details( Project )
+    DataShift::MethodDictionary.build_method_details( Milestone )
             
     # milestone.project = project.id
     [:project, 'project', "PROJECT", "prOJECt"].each do |format|
 
-      method_details = MethodDictionary.find_method_detail( Milestone, format )
+      method_details = DataShift::MethodDictionary.find_method_detail( Milestone, format )
 
       method_details.should_not be_nil
 
@@ -158,17 +155,17 @@ describe 'Method Dictionary' do
 
   it "should populate required Class for belongs_to operator method details" do
 
-    MethodDictionary.find_operators( LoaderRelease )
-    MethodDictionary.find_operators( LongAndComplexTableLinkedToVersion )
+    DataShift::MethodDictionary.find_operators( LoaderRelease )
+    DataShift::MethodDictionary.find_operators( LongAndComplexTableLinkedToVersion )
 
-    MethodDictionary.build_method_details( LoaderRelease )
-    MethodDictionary.build_method_details( LongAndComplexTableLinkedToVersion )
+    DataShift::MethodDictionary.build_method_details( LoaderRelease )
+    DataShift::MethodDictionary.build_method_details( LongAndComplexTableLinkedToVersion )
           
     
     # release.project = project.id
     [:project, 'project', "PROJECT", "prOJECt"].each do |format|
 
-      method_details = MethodDictionary.find_method_detail( LoaderRelease, format )
+      method_details = DataShift::MethodDictionary.find_method_detail( LoaderRelease, format )
 
       method_details.operator_class_name.should == 'Project'
       method_details.operator_class.should == Project
@@ -176,7 +173,7 @@ describe 'Method Dictionary' do
 
 
     [:version, "Version", "verSION"].each do |format|
-      method_details = MethodDictionary.find_method_detail( LongAndComplexTableLinkedToVersion, format )
+      method_details = DataShift::MethodDictionary.find_method_detail( LongAndComplexTableLinkedToVersion, format )
 
       method_details.operator_type.should == :belongs_to
 
@@ -187,13 +184,13 @@ describe 'Method Dictionary' do
 
   it "should populate required Class for has_one operator method details" do
 
-    MethodDictionary.find_operators( Version )
-    MethodDictionary.build_method_details( Version )
+    DataShift::MethodDictionary.find_operators( Version )
+    DataShift::MethodDictionary.build_method_details( 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 = MethodDictionary.find_method_detail( Version, format )
+      method_details = DataShift::MethodDictionary.find_method_detail( Version, format )
 
       method_details.should_not be_nil
 
@@ -207,29 +204,29 @@ describe 'Method Dictionary' do
   end
   
   it "should return false on for?(klass) if find_operators hasn't been called for klass" do
-    MethodDictionary.clear
-    MethodDictionary::for?(Project).should == false
-    MethodDictionary::find_operators(Project)
-    MethodDictionary::for?(Project).should == true
+    DataShift::MethodDictionary.clear
+    DataShift::MethodDictionary::for?(Project).should == false
+    DataShift::MethodDictionary::find_operators(Project)
+    DataShift::MethodDictionary::for?(Project).should == true
      
   end
 
   it "should return false on for?(klass) if find_operators hasn't been called for klass" do
-    MethodDictionary.clear
-    MethodDictionary::for?(Project).should == false
+    DataShift::MethodDictionary.clear
+    DataShift::MethodDictionary::for?(Project).should == false
   end
   
   it "should find has_many operator for method details" do
     
-    MethodDictionary.find_operators( Project )
+    DataShift::MethodDictionary.find_operators( Project )
     
-    MethodDictionary.build_method_details( Project )
+    DataShift::MethodDictionary.build_method_details( Project )
      
     [:milestones, "Mile Stones", 'mileSTONES', 'MileStones'].each do |format|
 
-      method_details = MethodDictionary.find_method_detail( Project, format )
+      method_details = DataShift::MethodDictionary.find_method_detail( Project, format )
 
-      method_details.class.should == MethodDetail
+      method_details.class.should == DataShift::MethodDetail
       
       result = 'milestones'
       method_details.operator.should == result
@@ -244,10 +241,10 @@ describe 'Method Dictionary' do
  
   it "should return nil when non existent column name" do
     
-    MethodDictionary.find_operators( Project )
+    DataShift::MethodDictionary.find_operators( Project )
     
     ["On sale", 'on_sale'].each do |format|
-      detail = MethodDictionary.find_method_detail( Project, format )
+      detail = DataShift::MethodDictionary.find_method_detail( Project, format )
 
       detail.should be_nil
     end
@@ -259,22 +256,32 @@ describe 'Method Dictionary' do
   end
 
   it "should not by default map setter methods" do
-    MethodDictionary.find_operators( Milestone )
+    DataShift::MethodDictionary.find_operators( Milestone )
+    
+    DataShift::MethodDictionary.assignments[Milestone].should_not include('title')
+  end
+  
+  it "should support inclusion of setter methods" do
+       
+    Milestone.new.respond_to?('title=').should == true
+    Milestone.new.respond_to?('milestone_setter=').should == true
     
-    MethodDictionary.assignments[Milestone].should_not include('title')
+    DataShift::MethodDictionary.setters( Milestone ).should include('title=')               # delegate
+    DataShift::MethodDictionary.setters( Milestone ).should include('milestone_setter=')    # normal method
   end
   
   it "should support reload and  inclusion of setter methods" do
 
-    MethodDictionary.find_operators( Project )
-    MethodDictionary.find_operators( Milestone )
+    DataShift::MethodDictionary.find_operators( Project )
+    DataShift::MethodDictionary.find_operators( Milestone )
     
-    MethodDictionary.assignments[Milestone].should_not include('title')
-        
-    MethodDictionary.find_operators( Milestone, :reload => true, :instance_methods => true )
+    DataShift::MethodDictionary.assignments[Milestone].should_not include('title')
+    
+    DataShift::MethodDictionary.find_operators( Milestone, :reload => true, :instance_methods => true )
      
     # Milestone delegates :title to Project
-    MethodDictionary.assignments[Milestone].should include('title')
+    DataShift::MethodDictionary.assignments[Milestone].should include('title')
+    DataShift::MethodDictionary.assignments[Milestone].should include('milestone_setter')
   end
 
 end