datashift 0.16.0 → 0.40.0

data/spec/loader_base_spec.rb

@@ -1,166 +0,0 @@
-# Copyright:: (c) Autotelik Media Ltd 2011
-# Author ::   Tom Statter
-# Date ::     Aug 2011
-# License::   MIT
-#
-# Details::   Specs for base class Loader
-#
-require File.dirname(__FILE__) + '/spec_helper'
-
-require 'erb'
-
-describe 'LoaderBase' do
-
-  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)
-    expect(@loader.load_object.new_record?).to eq true
-  end
-
-
-  it "should process a string field against an assigment method detail" do
-
-    column = 'Value As String'
-    row = 'Another Lazy fox '
-
-    @loader.find_and_process(column, row)
-
-    expect(@loader.load_object.errors.size).to eq 0
-  end
-  
-  it "should process a string field against an assigment method detail" do
-
-    column = 'Value As String'
-    row = 'Another Lazy fox '
-
-    @loader.find_and_process(column, row)
-
-    @loader.load_object.value_as_string.should == row
-  end
-
-  it "should process a text field against an assigment method detail" do
-
-    column = :value_as_text
-    row = "Another Lazy fox\nJumped over something and bumped,\nHis head"
-
-    @loader.find_and_process(column, row)
-
-    @loader.load_object.value_as_text.should == row
-
-  end
-
-  it "should process a boolean field against an assigment method detail" do
-
-    column = :value_as_boolean
-    row = true
-
-    @loader.find_and_process(column, row)
-
-    @loader.load_object.value_as_boolean.should == row
-
-    row = 'false'
-
-    @loader.find_and_process(column, row)
-
-    @loader.load_object.value_as_boolean.should == false
-
-
-  end
-
-  it "should process a double field against an assigment operator" do
-  end
-
-  it "should process various date formats against a date assigment operator" do
-    column = :value_as_datetime
-
-    @loader.find_and_process(column, Time.now)
-    @loader.load_object.value_as_datetime.should_not be_nil
-
-    @loader.find_and_process(column, "2011-07-23")
-    @loader.load_object.value_as_datetime.should_not be_nil
-
-    @loader.find_and_process(column, "Sat Jul 23 09:01:56 +0100 2011")
-    @loader.load_object.value_as_datetime.should_not be_nil
-
-    @loader.find_and_process(column,  Time.now.to_s(:db))
-    @loader.load_object.value_as_datetime.should_not be_nil
-
-    @loader.find_and_process(column,  "Jul 23 2011 23:02:59")
-    @loader.load_object.value_as_datetime.should_not be_nil
-
-    if(DataShift::Guards.jruby?)
-      @loader.find_and_process(column,  "07/23/2011")    # dd/mm/YYYY
-      @loader.load_object.value_as_datetime.should_not be_nil
-    end
-    
-    # bad casts - TODO - is this really an error needs raising ?
-    @loader.find_and_process(column, "2011 07 23")
-    @loader.load_object.value_as_datetime.should be_nil
-
-
-    @loader.find_and_process(column,  "2011-23-07")
-    @loader.load_object.value_as_datetime.should be_nil
-
-  end
-
-  it "should be able to mark a load attempt as a failure" do
-    
-    failed_count = @loader.failed_count
-    expect(@loader.load_object.new_record?).to eq true
-     
-    @loader.load_object.save!
-     
-    @loader.failure 
-    
-    @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

@@ -1,117 +0,0 @@
-# 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

@@ -1,300 +0,0 @@
-# Copyright:: (c) Autotelik Media Ltd 2011
-# Author ::   Tom Statter
-# Date ::     Aug 2011
-# License::   MIT
-#
-# Details::   Specs for MethodMapper aspect of Active Record Loader
-#             MethodMapper provides the bridge between 'strings' e.g column headings
-#             and a classes different types of assignment operators
-#
-require File.join(File.dirname(__FILE__), 'spec_helper')
-  
-require 'method_dictionary'
-
-describe 'Method Dictionary' do
-  
-  before(:each) do
-    DataShift::MethodDictionary.clear
-  end
-  
-  it "should store dictionary for multiple AR models" do
-    
-    DataShift::MethodDictionary.find_operators( Project )
-    DataShift::MethodDictionary.find_operators( Milestone )
-    
-    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
-
-    DataShift::MethodDictionary.find_operators( Project )
-    DataShift::MethodDictionary.find_operators( Milestone )
-    
-    DataShift::MethodDictionary.has_many.should_not be_empty
-    DataShift::MethodDictionary.has_many[Project].should include('milestones')
-
-    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')
-
-    DataShift::MethodDictionary.belongs_to.should_not be_empty
-    expect(DataShift::MethodDictionary.belongs_to[Project]).to include 'user'
-
-
-    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
-
-    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
-
-    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
-
-    DataShift::MethodDictionary.find_operators( Project )
-    DataShift::MethodDictionary.find_operators( Milestone )
-    
-    DataShift::MethodDictionary.build_method_details( Project )
-    
-    [:value_as_string, 'value_as_string', "VALUE as_STRING", "value as string"].each do |format|
-
-      method_details = DataShift::MethodDictionary.find_method_detail( Project, format )
-
-      method_details.class.should == DataShift::MethodDetail
-
-      method_details.operator.should == 'value_as_string'
-      method_details.operator_for(:assignment).should == 'value_as_string'
-      
-      expect(method_details.operator?('value_as_string')).to eq true
-      expect(method_details.operator?('blah_as_string')).to eq false
-
-      expect(method_details.operator_for(:belongs_to)).to eq nil
-      expect(method_details.operator_for(:has_many)).to eq 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
-
-    DataShift::MethodDictionary.find_operators( Project )
-    
-    DataShift::MethodDictionary.build_method_details( Project )
-        
-    [:value_as_string, 'value_as_string', "VALUE as_STRING", "value as string"].each do |format|
-
-      method_details = DataShift::MethodDictionary.find_method_detail( Project, format )
-
-      method_details.class.should == DataShift::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
-
-    DataShift::MethodDictionary.find_operators( Project )
-    
-    DataShift::MethodDictionary.build_method_details( Project )
-        
-    [:value_as_string, 'value_as_string', "VALUE as_STRING", "value as string"].each do |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)
-      method_details.operator_class.should == String
-    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
-
-    DataShift::MethodDictionary.find_operators( Project )
-    DataShift::MethodDictionary.find_operators( 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 = DataShift::MethodDictionary.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
-
-    DataShift::MethodDictionary.find_operators( LoaderRelease )
-    DataShift::MethodDictionary.find_operators( 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 = DataShift::MethodDictionary.find_method_detail( LoaderRelease, format )
-
-      method_details.operator_class_name.should == 'Project'
-      method_details.operator_class.should == Project
-    end
-
-
-    [:version, "Version", "verSION"].each do |format|
-      method_details = DataShift::MethodDictionary.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
-
-    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 = DataShift::MethodDictionary.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 return false on for?(klass) if find_operators hasn't been called for klass" do
-    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
-    DataShift::MethodDictionary.clear
-    DataShift::MethodDictionary::for?(Project).should == false
-  end
-  
-  it "should find has_many operator for method details" do
-    
-    DataShift::MethodDictionary.find_operators( Project )
-    
-    DataShift::MethodDictionary.build_method_details( Project )
-     
-    [:milestones, "Mile Stones", 'mileSTONES', 'MileStones'].each do |format|
-
-      method_details = DataShift::MethodDictionary.find_method_detail( Project, format )
-
-      method_details.class.should == DataShift::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
-    
-    DataShift::MethodDictionary.find_operators( Project )
-    
-    ["On sale", 'on_sale'].each do |format|
-      detail = DataShift::MethodDictionary.find_method_detail( Project, format )
-
-      detail.should be_nil
-    end
-  end
-
-
-  it "should not by default map setter methods" do
-    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
-    
-    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
-
-    DataShift::MethodDictionary.find_operators( Project )
-    DataShift::MethodDictionary.find_operators( Milestone )
-    
-    DataShift::MethodDictionary.assignments[Milestone].should_not include('title')
-    
-    DataShift::MethodDictionary.find_operators( Milestone, :reload => true, :instance_methods => true )
-     
-    # Milestone delegates :title to Project
-    DataShift::MethodDictionary.assignments[Milestone].should include('title')
-    DataShift::MethodDictionary.assignments[Milestone].should include('milestone_setter')
-  end
-
-end