datashift 0.15.0 → 0.16.0

data/spec/excel_spec.rb

@@ -76,7 +76,7 @@ describe 'Excel Proxy' do
     @excel.create_worksheet( :name => "autechre")
     @excel.create_worksheet( :name => "swarms")
         
-    @excel.worksheets.should have_exactly(4).items
+    expect(@excel.worksheets.size).to eq 4
   end
   
   it "can access a worksheet by index" do
@@ -175,9 +175,12 @@ describe 'Excel Proxy' do
   end
   
   
-  it "can support bools" do
-    pending("reading back value sometimes returns "" when cell was set to false")
-  end
+  #it "can support bools" do
+  #  pending "reading back value sometimes returns "" when cell was set to false"
+    
+   # sheet = @excel.create_worksheet
+    
+  #end
 
   it "can write an Excel file" do
     @excel = Excel.new
@@ -193,7 +196,7 @@ describe 'Excel Proxy' do
     
     @excel.write( expected )
     
-    File.exists?(expected).should be_true
+    expect(File.exists?(expected)).to eq true
     
   end
 end

data/spec/loader_base_spec.rb

@@ -11,18 +11,16 @@ require 'erb'
 
 describe 'LoaderBase' do
 
-  include_context "ActiveRecordTestModelsConnected"
-  
-  include_context "ClearAndPopulateProject"
-  
   before(:each) do    
     @loader = DataShift::LoaderBase.new(Project)
   end
+
+  let(:loader) {DataShift::LoaderBase.new(Project)  }
   
   it "should be able to create a new loader and load object" do
     @loader.load_object.should_not be_nil
     @loader.load_object.should be_is_a(Project)
-    @loader.load_object.new_record?.should be_true
+    expect(@loader.load_object.new_record?).to eq true
   end
 
 
@@ -33,7 +31,7 @@ describe 'LoaderBase' do
 
     @loader.find_and_process(column, row)
 
-    @loader.load_object.errors.should have_exactly(0).items
+    expect(@loader.load_object.errors.size).to eq 0
   end
   
   it "should process a string field against an assigment method detail" do
@@ -114,7 +112,7 @@ describe 'LoaderBase' do
   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
+    expect(@loader.load_object.new_record?).to eq true
      
     @loader.load_object.save!
      
@@ -122,5 +120,47 @@ describe 'LoaderBase' do
     
     @loader.failed_count.should == failed_count + 1
   end
+
+
+  it "should be able to set a plain default value" do
+
+    loader.configure_from( ifixture_file('ProjectsDefaults.yml') )
+
+    loader.process_defaults
+
+    expect(loader.load_object.value_as_string).to eq "Default Project Value"
+
+  end
+
+  it "should be able to set an association default value" do
+
+    skip "pending more work on Populator to make this advanced lookup style work"
+
+    loader.configure_from( ifixture_file('ProjectsDefaults.yml') )
+
+    loader.process_defaults
+
+    expect(loader.load_object.categories.first.reference).to eq "category_002"
+
+  end
+
+
+  it "should be able to set a eval default value" do
+
+    loader.configure_from( ifixture_file('ProjectsDefaults.yml') )
+
+    puts loader.load_object.inspect
+    puts loader.load_object.value_as_datetime.inspect
+
+    loader.process_defaults
+
+    puts loader.load_object.inspect
+    puts loader.load_object.value_as_datetime.inspect
+
+    expect(loader.load_object.value_as_datetime).to be
+    expect(loader.load_object.value_as_datetime).to be <= Time.now.to_s(:db)
+  end
+
+
   
 end

data/spec/mapping_spec.rb

@@ -0,0 +1,117 @@
+# Copyright:: (c) Autotelik Media Ltd 2015
+# Author ::   Tom Statter
+# Date ::     Aug 2015
+# License::   MIT
+#
+# Details::   Specs for Mapping aspects
+#             Provides automatic mapping between different system's column headings
+#
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+require 'mapping_generator'
+
+describe 'Mapping Services' do
+
+  before(:all) do
+    DataShift::MethodDictionary.clear
+    DataShift::MethodDictionary.find_operators( Project )
+  end
+
+  before(:each) do
+    load File.join( rspec_datashift_root,'lib/thor/mapping.thor')
+  end
+
+
+  it "should generate an empty mapping doc" do
+
+    f = result_file("mapper.yaml")
+
+    mapper = DataShift::MappingGenerator.new(f)
+
+    mapper.generate(nil, {:file => f} )
+
+    expect(File.exists?(f)).to be true
+  end
+
+
+  it "should generate a mapping doc with pre supplied title" do
+
+    f = result_file("mapper.yaml")
+
+    mapper = DataShift::MappingGenerator.new(f)
+
+    mapper.generate(nil,  {:file => f} )
+
+    expect(File.exists?(f)).to be true
+  end
+
+  it "should generate a populated mapping doc for a class" do
+
+    f = result_file("mapper_project.yaml")
+
+    mapper = DataShift::MappingGenerator.new(f)
+
+    mapper.generate( Project,  {:file => f} )
+
+    expect(File.exists?(f)).to be true
+  end
+
+  it "should be able to create a mapping service for a class" do
+    mapping_services = DataShift::MappingService.new(Project)
+
+    expect(mapping_services).to be
+  end
+
+  it "should be able to read a mapping" do
+
+    f = result_file("mapping_service_project.yaml")
+
+    mapper = DataShift::MappingGenerator.new(f)
+
+    mapper.generate(Project, {:file => f} )
+
+    expect(File.exists?(f)).to be true
+
+    mapping_service = DataShift::MappingService.new(Project)
+
+    mapping_service.read(f)
+
+    expect(mapping_service.map_file_name).to eq f
+
+    expect(mapping_service.raw_data).to_not be_empty
+    expect(mapping_service.yaml_data).to_not be_empty
+
+    expect(mapping_service.mapping_entry).to be_a OpenStruct
+
+    # puts mapping_service.mapping_entry.inspect
+    expect(mapping_service.mapping_entry.mappings).to be_a Hash
+    expect(mapping_service.mapping_entry['mappings']).to be_a Hash
+
+  end
+
+  it "should be able to generate a mapping from_excel" do
+
+    f = result_file("mapping_service_excel.yaml")
+
+    mapper = DataShift::MappingGenerator.new(f)
+
+    mapper.generate_from_excel(ifixture_file('SimpleProjects.xls'), :file => f )
+
+  end
+
+  it "should provide tasks to generate a mapping doc" do
+
+    opts  = {:model =>  "Project", :result => "#{results_path}"}
+
+    run_in(rails_sandbox()) do
+      output = capture(:stdout) { Datashift::Mapping.new.invoke(:template, [], opts) }
+
+      puts output
+
+      expect(output).to include("Output generated")
+    end
+  end
+
+
+
+end

data/spec/method_dictionary_spec.rb

@@ -12,8 +12,6 @@ require File.join(File.dirname(__FILE__), 'spec_helper')
 require 'method_dictionary'
 
 describe 'Method Dictionary' do
-
-  include_context "ActiveRecordTestModelsConnected"
   
   before(:each) do
     DataShift::MethodDictionary.clear
@@ -42,7 +40,7 @@ describe 'Method Dictionary' do
     DataShift::MethodDictionary.assignments[Project].should include('value_as_text')
 
     DataShift::MethodDictionary.belongs_to.should_not be_empty
-    DataShift::MethodDictionary.belongs_to[Project].should be_empty
+    expect(DataShift::MethodDictionary.belongs_to[Project]).to include 'user'
 
 
     DataShift::MethodDictionary.column_types.should be_is_a(Hash)
@@ -80,11 +78,11 @@ describe 'Method Dictionary' do
       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
+      expect(method_details.operator?('value_as_string')).to eq true
+      expect(method_details.operator?('blah_as_string')).to eq false
 
-      method_details.operator_for(:belongs_to).should be_nil
-      method_details.operator_for(:has_many).should be_nil
+      expect(method_details.operator_for(:belongs_to)).to eq nil
+      expect(method_details.operator_for(:has_many)).to eq nil
     end
   end
 
@@ -128,6 +126,25 @@ describe 'Method Dictionary' do
     end
 
   end
+  
+  
+  it "should populate method_details on Class for belongs_to" do
+
+    DataShift::MethodDictionary.find_operators( Owner )
+    
+    DataShift::MethodDictionary.build_method_details( Owner )
+        
+    [:project, 'PROJECT'].each do |format|
+
+      method_details = DataShift::MethodDictionary.find_method_detail( Owner, format )
+
+      expect(method_details.operator_class_name).to eq 'Project'
+      expect(method_details.operator_class).to be_a(Class)
+      expect(method_details.operator_class).to eq Project
+    end
+
+  end
+  
 
   it "should populate belongs_to operator for method details for different forms of a column name" do
 
@@ -251,10 +268,6 @@ describe 'Method Dictionary' do
   end
 
 
-  it "should find a set of methods based on a list of column names" do
-    pending("key API - map column headers to set of methods")
-  end
-
   it "should not by default map setter methods" do
     DataShift::MethodDictionary.find_operators( Milestone )
     

data/spec/method_mapper_spec.rb

@@ -12,8 +12,6 @@ require File.join(File.dirname(__FILE__), 'spec_helper')
 require 'method_mapper'
 
 describe 'Method Mapper' do
-
-  include_context "ActiveRecordTestModelsConnected"
    
   before(:each) do
     DataShift::MethodDictionary.clear   
@@ -27,7 +25,7 @@ describe 'Method Mapper' do
     
     method_details = @method_mapper.map_inbound_headers_to_methods( Project, headers )
     
-    method_details.should have_exactly(4).items
+    expect(method_details.size).to eq 4
   end
 
   it "should leave nil in set of methods when no such operator" do
@@ -36,7 +34,7 @@ describe 'Method Mapper' do
     
     method_details = @method_mapper.map_inbound_headers_to_methods( Project, headers )
     
-    method_details.should have_exactly(6).items
+    expect(method_details.size).to eq 6
     
     method_details[2].should be_nil
     method_details[5].should be_nil
@@ -53,7 +51,7 @@ describe 'Method Mapper' do
     
     method_details = @method_mapper.map_inbound_headers_to_methods( Project, headers )
     
-    method_details.should have_exactly(4).items
+    expect(method_details.size).to eq 4
     
     method_details[2].should be_nil
    
@@ -67,7 +65,7 @@ describe 'Method Mapper' do
     
     method_details = @method_mapper.map_inbound_headers_to_methods( Project, headers )
     
-    method_details.should have_exactly(4).items
+    expect(method_details.size).to eq 4
     
     method_details[0].should be_a DataShift::MethodDetail
     
@@ -85,7 +83,7 @@ describe 'Method Mapper' do
     
     method_details = @method_mapper.map_inbound_headers_to_methods( Project, headers )
     
-    method_details.should have_exactly(4).items
+    expect(method_details.size).to eq 4
     
     method_details.should_not include nil
     

data/spec/model_mapper_spec.rb

@@ -0,0 +1,41 @@
+# Copyright:: (c) Autotelik Media Ltd 2015
+# Author ::   Tom Statter
+# Date ::     Aug 2015
+# License::   MIT
+#
+# Details::   Specs for Mapping aspects
+#             Provides automatic mapping between different system's column headings
+#
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+require 'mapping_generator'
+
+describe 'ModelMapper' do
+
+  before(:all) do
+  end
+
+  before(:each) do
+  end
+
+  it "should identify the class from a string" do
+    # Similar to const_get_from_string except this version
+    # returns nil if no such class found
+    # Support modules e.g "Spree::Property"
+    #
+    expect(DataShift::ModelMapper.class_from_string( Project)).to be_a Class
+
+  end
+
+  it "should identify the class from a string contianing modules" do
+    # Similar to const_get_from_string except this version
+    # returns nil if no such class found
+    # Support modules e.g "Spree::Property"
+    #
+    expect(DataShift::ModelMapper.class_from_string( DataShift::AClassInAModule )).to be_a Class
+
+  end
+
+
+
+end

data/spec/paperclip_loader_spec.rb

@@ -13,9 +13,6 @@ Paperclip.options[:command_path] = "/usr/local/bin/"
 
 describe 'PaperClip Bulk Loader' do
 
-  include_context "ActiveRecordTestModelsConnected"
-  
-  include_context "ClearAndPopulateProject"
   
   include DataShift::Logging
   
@@ -38,7 +35,7 @@ describe 'PaperClip Bulk Loader' do
   end
   
   it "should create a new paperclip loader and define attachment class" do 
-    loader = DataShift::Paperclip::AttachmentLoader.new(@attachment_klass, true, nil, @common_options)
+    loader = DataShift::Paperclip::AttachmentLoader.new(@attachment_klass, nil, @common_options)
     
     loader.load_object_class.should == Digital
     loader.load_object.should be_a Digital
@@ -50,7 +47,7 @@ describe 'PaperClip Bulk Loader' do
              
     opts = { :attach_to_klass => Owner }.merge(@common_options)
     
-    loader = DataShift::Paperclip::AttachmentLoader.new(@attachment_klass, true, nil, opts)
+    loader = DataShift::Paperclip::AttachmentLoader.new(@attachment_klass, nil, opts)
     
     loader.attach_to_klass.should == Owner
   end
@@ -89,7 +86,7 @@ describe 'PaperClip Bulk Loader' do
  
     loader.process_from_filesystem(@attachment_path, opts)
     
-    Dir.glob("MissingAttachmentRecords/*.jpeg", File::FNM_CASEFOLD).should have_exactly(names.size).items
+    expect(Dir.glob("MissingAttachmentRecords/*.jpeg", File::FNM_CASEFOLD).size).to eq names.size
   end
   
 end

data/spec/populator_spec.rb

@@ -11,9 +11,6 @@ require 'erb'
 
 describe 'Populator' do
 
-  include_context "ActiveRecordTestModelsConnected"
-  
-  include_context "ClearAndPopulateProject"
   
   before(:each) do    
     @loader = DataShift::LoaderBase.new(Project)
@@ -35,7 +32,7 @@ describe 'Populator' do
     
     options = {:populator => 'AnotherPopulator' }
     
-    local_loader = DataShift::LoaderBase.new(Project, true, nil, options)
+    local_loader = DataShift::LoaderBase.new(Project, nil, options)
     
     local_loader.populator.should_not be_nil
     local_loader.populator.should be_a AnotherPopulator
@@ -48,7 +45,7 @@ describe 'Populator' do
     
     options = {:populator => AnotherPopulator }
     
-    local_loader = DataShift::LoaderBase.new(Project, true, nil, options)
+    local_loader = DataShift::LoaderBase.new(Project, nil, options)
     
     local_loader.populator.should_not be_nil
     local_loader.populator.should be_a AnotherPopulator
@@ -61,19 +58,54 @@ describe 'Populator' do
 
     method_detail = DataShift::MethodDictionary.find_method_detail( Project, column_heading )
     
-    method_detail.should_not be_nil
+    expect(method_detail).to be_a  DataShift::MethodDetail
     
-    x, attributes = @populator.prepare_data(method_detail, value)
+    pop_value, attributes = @populator.prepare_data(method_detail, value)
     
-    x.should == value
+    pop_value.should == value
     attributes.should be_a Hash
     attributes.should be_empty
     
+    # check for white space preservation
+    value = 'Another Lazy fox'
+
+    pop_value, attributes = @populator.prepare_data(method_detail, value)
+    
+    pop_value.should == value
+    
   end
 
-  it "should process a string value against an assigment instance method" do
+  it "should process a DSL string into a real hash" do
+
+    str1  = "{:name => 'the_fox' }"
+    
+    x = DataShift::Populator::string_to_hash( str1 )
+     
+    expect(x).to  be_a Hash
+    expect(x.size).to eq 1
+    
+    str2 =  "{:name => 'the_fox', 'occupation' => 'fantastic', :food => 'duck soup' }"
+    
+    x = DataShift::Populator::string_to_hash( str2 )
+     
+    expect(x.size).to eq 3
+    expect(x.keys).to include 'food'
+    expect(x['food']).to eq 'duck soup'
+    
+    str3 =  "{:cost_price => '13.45', :price => 23,  :sale_price => 4.23 }"
+    
+    x = DataShift::Populator::string_to_hash( str3 )
 
-    value = 'Get up Lazy fox '
+    expect(x.keys).to include 'price'
+    expect(x['cost_price']).to eq '13.45'
+    expect(x['price']).to eq 23
+    expect(x['sale_price']).to eq 4.23
+    
+  end
+  
+  it "should process a string value against an assigment instance method" do
+   
+    value = 'Get up Lazy fox {:name => \'the_fox\' }'
 
     DataShift::MethodDictionary.find_operators( Milestone, :instance_methods => true  )
     
@@ -83,11 +115,13 @@ describe 'Populator' do
     
     method_detail.should_not be_nil
     
-    x, attributes = @populator.prepare_data(method_detail, value)
+    pop_value, attrs = @populator.prepare_data(method_detail, value)
     
-    x.should == value
-    attributes.should be_a Hash
-    attributes.should be_empty
+    expect(pop_value).to eq 'Get up Lazy fox '
+    expect(attrs).to  be_a Hash
+    expect(attrs.size).to eq 1
+    expect(attrs.keys).to include 'name'
+    expect(attrs['name']).to eq 'the_fox'
     
   end