datashift 0.16.0 → 0.40.0

data/spec/datashift/failure_data_spec.rb

@@ -0,0 +1,27 @@
+# Copyright:: (c) Autotelik Media Ltd 2016
+# Author ::   Tom Statter
+# License::   MIT
+#
+require File.join(File.dirname(__FILE__), '/../spec_helper')
+
+module DataShift
+
+  describe FailureData do
+
+    include_context 'ClearThenManageProject'
+
+    let(:load_object)     { create(:project, title: 'my title') }
+
+    let(:model_method)    { project_collection.search('value_as_string') }
+
+    let(:method_binding)  { MethodBinding.new('value_as_string', 1, model_method) }
+
+    let(:node_context) { DataShift::NodeContext.new(self, method_binding, 1, "1,2,3") }
+
+    it 'should store details of load object and inbound context' do
+      failed = FailureData.new(load_object, node_context)
+      expect(failed).to be
+    end
+
+  end
+end

data/spec/{file_definitions.rb → datashift/file_definitions.rb}

@@ -1,8 +1,8 @@
 # To change this template, choose Tools | Templates
 # and open the template in the editor.
 
-$:.unshift File.join(File.dirname(__FILE__),'..','lib')
-$:.unshift File.join(File.dirname(__FILE__),'..','lib', 'engine')
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+$LOAD_PATH.unshift File.join(File.dirname(__FILE__), '..', 'lib', 'engine')
 
 require 'test/unit'
 require 'file_definitions'
@@ -27,12 +27,11 @@ class File_definitions < Test::Unit::TestCase
 
   end
 
-
   def test_fields_symbols
     klass = Object.const_set('SymClass', Class.new)
     klass.module_eval do
       include FileDefinitions
-      create_field_definition  [:a_symbol, :b_symbol]
+      create_field_definition [:a_symbol, :b_symbol]
 
       create_field_attr_accessors
     end
@@ -45,16 +44,16 @@ class File_definitions < Test::Unit::TestCase
     klass = Object.const_set('A', Class.new)
     klass.module_eval do
       include FileDefinitions
-      create_field_definition %w{abc def  ghi jkl}
+      create_field_definition %w(abc def  ghi jkl)
 
       create_field_attr_accessors
     end
 
     x = A.new
 
-    assert_equal ["abc", "def", "ghi", "jkl"], A.field_definition.sort
+    assert_equal %w(abc def ghi jkl), A.field_definition.sort
 
-    A::add_field( "xyz" )
+    A.add_field( 'xyz' )
 
     line = '1,2,3,4, 5'
     x = A.new(line)
@@ -101,9 +100,9 @@ class File_definitions < Test::Unit::TestCase
     assert_equal 3,  AFixed.field_definition.size
     assert_equal 3,  AFixed.fixed_definition.keys.size
 
-    assert_equal  ["ccy", "date", "value"], AFixed.field_definition.sort
+    assert_equal %w(ccy date value), AFixed.field_definition.sort
 
-    assert_equal AFixed.field_definition.sort,  AFixed.fixed_definition.keys.sort
+    assert_equal AFixed.field_definition.sort, AFixed.fixed_definition.keys.sort
 
     assert_instance_of Range, AFixed.fixed_definition.values[0]
 
@@ -133,7 +132,7 @@ class File_definitions < Test::Unit::TestCase
 
         create_field_attr_accessors
       end
-      flunk    # We should never get here
+      flunk # We should never get here
     rescue => e
       assert e
     end

data/spec/datashift/headers_spec.rb

@@ -0,0 +1,56 @@
+# 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'
+
+describe 'Headers' do
+  before(:each) do
+  end
+
+  context 'No Initial Headers' do
+    it 'should be able to populate empty' do
+      expect(DataShift::Headers.new( :csv, 0 )).to be
+    end
+
+    it 'should be able to identify the source and index' do
+      h = DataShift::Headers.new( :csv, 2 )
+      expect(h.source).to eq :csv
+      expect(h.idx).to eq 2
+    end
+
+    it 'should act like an Array' do
+      h = DataShift::Headers.new( :csv, 0 )
+
+      expect(h.respond_to?(:each)).to eq true
+    end
+
+    it 'should be able to add headers as if using an Array' do
+      h = DataShift::Headers.new( :csv, 0 )
+
+      expect(h.size).to eq 0
+      expect(h.empty?).to eq true
+
+      h << 'sku'
+
+      expect(h.size).to eq 1
+      expect(h.empty?).to eq false
+    end
+
+    it 'should be able to read headers as if using an Array' do
+      h = DataShift::Headers.new( :csv, 0 )
+
+      expect(h.size).to eq 0
+      expect(h.empty?).to eq true
+
+      h << 'sku'
+
+      expect(h.size).to eq 1
+      expect(h.empty?).to eq false
+    end
+
+  end
+end

data/spec/datashift/inbound_data_spec.rb

@@ -0,0 +1,47 @@
+# Copyright:: (c) Autotelik Media Ltd 2015
+# Author ::   Tom Statter
+# License::   MIT
+#
+require File.join(File.dirname(__FILE__), '/../spec_helper')
+
+module DataShift
+
+  module InboundData
+
+    describe 'Inbound Data' do
+      it 'should store details of inbound lookup' do
+        ls = LookupSupport.new( Project, :title, 'my title')
+        expect(ls).to be
+      end
+
+      it 'should store details of inbound column' do
+        c = Column.new( 'Value As A String')
+        expect(c).to be
+      end
+
+      it 'should store details of inbound column with its column number' do
+        c = Column.new( 'Value As A String', 0)
+        expect(c).to be
+      end
+
+      context 'lookups' do
+        let(:create_project) { create(:project, title: 'my title') }
+
+        let(:lookup) { LookupSupport.new( Project, :title, 'my title') }
+
+        it 'should enable lookup of a domain object' do
+          create_project
+          result = lookup.klass.where( lookup.field => lookup.where_value ).first
+          expect(result).to be_a Project
+        end
+
+        it 'should provide shortcut to return active record relation', fail: true do
+          id = create_project.id
+          result = lookup.find
+          expect(result).to be_a ActiveRecord::Relation
+          expect(result.first.id).to eq id
+        end
+      end
+    end
+  end
+end

data/spec/datashift/mapper_utils_spec.rb

@@ -0,0 +1,38 @@
+# 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')
+
+describe 'MapperUtils' do
+
+  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::MapperUtils.class_from_string( Project)).to be_a Class
+  end
+
+  it 'should identify the class from a string containing 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::MapperUtils.class_from_string( DataShift::AClassInAModule )).to be_a Class
+  end
+
+  it 'should ensure a valid class is returned whether a class or string passed in' do
+    expect(DataShift::MapperUtils.ensure_class("Project")).to be_a Class
+    expect(DataShift::MapperUtils.ensure_class(Project)).to be_a Class
+  end
+
+  it 'should throw when invalid class supplied' do
+    expect { DataShift::MapperUtils.ensure_class("Proj") }.to raise_error
+  end
+
+end

data/spec/datashift/method_binding_spec.rb

@@ -0,0 +1,60 @@
+# Copyright:: (c) Autotelik Media Ltd 2015
+# Author ::   Tom Statter
+# Date ::     Jan 2015
+# License::   MIT
+#
+# Details::   Specs for MethodBinding aspect of Active Record Loader
+#             MethodBinding holds details of a method call on an AR object
+#             linked to the incoming column header/index
+#
+require File.join(File.dirname(__FILE__), '/../spec_helper')
+
+module DataShift
+
+  describe 'Method Binding' do
+    include_context 'ClearThenManageProject'
+
+    let( :model_method) { project_collection.search('value_as_string') }
+
+    it 'should bind details of inbound header to domain model' do
+      binding = MethodBinding.new('value_as_string', 1, model_method)
+      expect(binding).to be
+    end
+
+    context ('Bound to Header') do
+      let(:binding) { MethodBinding.new('value_as_string', 1, model_method) }
+
+      let(:valid_column_on_project) { 'value_as_string' }
+
+      it 'should provide access to inbound column (header)' do
+        expect(binding.inbound_column).to be_a InboundData::Column
+      end
+
+      it 'should provide access to domain model method' do
+        expect(binding.model_method).to eq model_method
+      end
+
+      it 'should enable an index to be set for index style processors' do
+        binding = MethodBinding.new(valid_column_on_project, 2, model_method)
+        expect(binding.inbound_column.index).to eq 2
+
+        binding = MethodBinding.new(valid_column_on_project, 99999, model_method)
+        expect(binding.inbound_column.index).to eq 99999
+      end
+
+      it 'should be valid when both name and model method provided' do
+        binding = MethodBinding.new(valid_column_on_project, 2, model_method)
+        expect(binding.valid?).to eq true
+      end
+
+      it 'should be invalid when either name or model method nil' do
+        binding = MethodBinding.new(nil, 3, model_method)
+        expect(binding.valid?).to eq false
+
+        binding = MethodBinding.new(valid_column_on_project, 3, nil)
+        expect(binding.valid?).to eq false
+      end
+    end
+  end
+
+end

data/spec/datashift/model_method_spec.rb

@@ -0,0 +1,109 @@
+# Copyright:: (c) Autotelik Media Ltd 2015
+# Author ::   Tom Statter
+# Date ::     Jan 2015
+# License::   MIT
+#
+# Details::   Specs for ModelMethod aspect of
+#
+require File.join(File.dirname(__FILE__), '/../spec_helper')
+
+
+module DataShift
+
+  describe 'Model Method' do
+    include_context 'ClearAllCatalogues'
+
+    it 'should hold details of assignment method on a class' do
+      model_method = DataShift::ModelMethod.new(Project, :value_as_string, :assignment )
+
+      expect(model_method).to be
+    end
+
+    it 'should hold details of belongs_to method on a class' do
+      model_method = DataShift::ModelMethod.new(Project, 'user', :belongs_to )
+
+      expect(model_method).to be
+    end
+
+    it 'should hold details of has_one method on a class' do
+      model_method = DataShift::ModelMethod.new(Project, 'owner', :has_one )
+
+      expect(model_method).to be
+    end
+
+    it 'should hold details of has_many method on a class' do
+      model_method = DataShift::ModelMethod.new(Project, 'milestones', :has_many )
+
+      expect(model_method).to be
+    end
+
+    it 'should hold details of a callable method on a class' do
+      model_method = DataShift::ModelMethod.new(Project, 'my_funky_method', :method )
+
+      expect(model_method).to be
+
+      expect(model_method.operator).to eq 'my_funky_method'
+      expect(model_method.operator_type).to eq :method
+    end
+
+    it 'should hold details of operator type as a symbol' do
+      model_method = DataShift::ModelMethod.new(Project, 'my_funky_method', 'method' )
+      expect(model_method.operator_type).to eq :method
+
+      model_method = DataShift::ModelMethod.new(Owner, 'milestones', 'has_many' )
+      expect(model_method.operator_type).to eq :has_many
+    end
+
+    it 'should raise when unknown type' do
+      expect { DataShift::ModelMethod.new(Project, 'milestones', :junk ) }.to raise_error BadOperatorType
+    end
+
+    it 'should be comparable based on class' do
+
+      a = DataShift::ModelMethod.new(Owner, 'owner', :has_one)
+      b = DataShift::ModelMethod.new(Project, 'owner', :has_one)
+
+      expect(a == b).to eq false
+
+      expect(a).to be < b
+      expect(b).to be > a
+    end
+
+    it 'should be comparable based on operator_type and operator' do
+
+      a = DataShift::ModelMethod.new(Project, 'value_as_text', :assignment )
+      b = DataShift::ModelMethod.new(Project, 'title', :assignment )
+      a_again = DataShift::ModelMethod.new(Project, 'value_as_text', :assignment )
+      a_diff_type = DataShift::ModelMethod.new(Project, 'value_as_text', :has_one )
+
+      c = DataShift::ModelMethod.new(Project, 'owner', :has_one )
+
+      d = DataShift::ModelMethod.new(Project, 'owner', :has_many )
+      d_again = DataShift::ModelMethod.new(Project, 'owner', :has_many )
+
+      expect(a == b).to eq false
+      expect(a == a).to eq true
+      expect(a == a_again).to eq true
+      expect(a == a_diff_type).to eq false
+      expect(c == d).to eq false
+      expect(d == d_again).to eq true
+
+      expect(a).to be > b
+
+      # i.e assignment comes before has_one
+      expect(a).to be < a_diff_type
+
+      expect(c).to be < a_diff_type
+      expect(c).to be < d
+      expect(d).to be > c
+      expect(d).to be >= d_again
+
+      clist = [a, d_again, b, d, c]
+
+      clist.sort!
+
+      expect(clist).to eq [b, a,c ,d, d_again]
+    end
+  end
+
+end

data/spec/datashift/model_methods_catalogue.rb

@@ -0,0 +1,111 @@
+# Copyright:: (c) Autotelik Media Ltd 2011
+# Author ::   Tom Statter
+# Date ::     Mar 2015
+# License::   MIT
+#
+require File.join(File.dirname(__FILE__), '/../spec_helper')
+
+module DataShift
+
+  module ModelMethods
+
+    describe 'Model Methods' do
+      include_context 'ClearAllCatalogues'
+
+      context 'Catalogue a Class' do
+        it 'should enable checking a model catalogued' do
+          expect(Catalogue.catalogued?(Milestone) ).to eq false
+        end
+
+        it 'should report how many classes catalogued' do
+          expect(Catalogue.size ).to eq 0
+        end
+
+        it 'should catalogue model methods on a domain model' do
+          Catalogue.populate( Milestone )
+
+          expect(Catalogue.size ).to eq 1
+          expect(Catalogue.catalogued?(Milestone) ).to eq true
+        end
+
+        it 'should catalogue model methods on a domain model once' do
+          Catalogue.populate( Milestone )
+          Catalogue.populate( Milestone )
+
+          expect(Catalogue.size ).to eq 1
+          expect(Catalogue.catalogued?(Milestone) ).to eq true
+        end
+
+        it 'should catalogue multiple domain models' do
+          Catalogue.populate( Milestone )
+          Catalogue.populate( Project )
+          expect(Catalogue.size ).to eq 2
+
+          expect(Catalogue.catalogued?(Project)).to eq true
+          expect(Catalogue.catalogued?(Owner)).to eq false
+        end
+      end
+
+      context 'interrogate a Class' do
+        before(:each) do
+          Catalogue.populate( Project )
+          Catalogue.populate( Milestone )
+        end
+
+        it 'should interrogate a domain model to build has_many associations' do
+          expect(Catalogue.has_many).to_not be_empty
+
+          expect(Catalogue.has_many[Project]).to include('milestones')
+        end
+
+        it 'should interrogate a domain model to build set of model methods' do
+          expect(Catalogue.assignments).to_not be_empty
+          expect(Catalogue.assignments[Project]).to include('id')
+          expect( Catalogue.assignments[Project]).to include('value_as_string')
+          expect(Catalogue.assignments[Project]).to include('value_as_text')
+
+          expect( Catalogue.belongs_to).to_not be_empty
+          expect(Catalogue.belongs_to[Project]).to include 'user'
+
+          expect(Catalogue.column_types).to be_is_a(Hash)
+          expect(Catalogue.column_types).to_not be_empty
+          expect(Catalogue.column_types[Project].size).to eq Project.columns.size
+        end
+
+        it 'should return a list of assignment members' do
+          expect(Catalogue.assignments_for(Project)).to be_a Array
+        end
+
+        it 'should populate assignment 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
+          expect(Catalogue.assignments_for(Project)).to_not include Catalogue.belongs_to_for(Project)
+          expect(Catalogue.assignments_for(Project)).to_not include Catalogue.has_many_for(Project)
+        end
+
+        it 'has the operator names in the array' do
+          name = Catalogue.assignments_for(Project).first
+
+          expect(name).to be_a String
+          expect(name.size).to be > 0
+        end
+
+        it 'can include instance methods' do
+          Catalogue.populate( Owner, instance_methods: true )
+
+          expect( Catalogue.assignments_for(Owner)).to include 'after_add_for_digitals'
+        end
+
+        it 'can force a reload' do
+          Catalogue.populate( Owner )
+
+          count = Catalogue.assignments_for(Owner).size
+
+          Catalogue.populate( Owner, reload: true, instance_methods: true )
+
+          expect(Catalogue.assignments_for(Owner).size).to be > count
+        end
+      end
+    end
+  end
+end