rexport 0.5.4 → 1.2.0

data/test/unit/data_field_test.rb

@@ -1,25 +1,25 @@
 require 'test_helper'
 
 class DataFieldTest < ActiveSupport::TestCase
-  def test_should_stringify_name
-    assert_equal('foo', Rexport::DataField.new(:foo).name)
+  test 'should stringify name' do
+    assert_equal 'foo', Rexport::DataField.new(:foo).name
   end
 
-  def test_should_use_name_for_method
-    assert_equal('foo', Rexport::DataField.new(:foo).method)
+  test 'should use name for method' do
+    assert_equal 'foo', Rexport::DataField.new(:foo).method
   end
 
-  def test_should_save_method
-    assert_equal('bar', Rexport::DataField.new(:foo, :method => :bar).method)
+  test 'should save method' do
+    assert_equal 'bar', Rexport::DataField.new(:foo, method: :bar).method
   end
 
-  def test_should_save_type
-    assert_equal(:type_test, Rexport::DataField.new(:test, :type => :type_test).type)
+  test 'should save type' do
+    assert_equal :type_test, Rexport::DataField.new(:test, type: :type_test).type
   end
 
-  def test_should_sort_data_fields
+  test 'should_sort_data_fields' do
     a = Rexport::DataField.new(:a)
     b = Rexport::DataField.new(:b)
-    assert_equal([a,b], [b,a].sort)
+    assert_equal [a,b], [b,a].sort
   end
-end
+end

data/test/unit/data_fields_test.rb

@@ -3,115 +3,73 @@ require 'test_helper'
 class DataFieldsTest < ActiveSupport::TestCase
 
   class RexportClassMethodsTest < DataFieldsTest
-    def test_should_initialize_local_rexport_fields
-      assert_kind_of(Hash, Enrollment.rexport_fields)
-      assert_equal(%w(active bad_method created_at foo_method grade ilp_status_name status_name updated_at), Enrollment.rexport_fields.keys.sort)
-      assert_equal('grade', Enrollment.rexport_fields[:grade].method)
-      assert_equal('foo', Enrollment.rexport_fields[:foo_method].method)
-      assert_equal(:boolean, Enrollment.rexport_fields[:active].type)
-      assert_equal(:integer, Enrollment.rexport_fields[:grade].type)
+    test 'should get klass from assocations' do
+      assert_equal Family, Enrollment.get_klass_from_associations('student', 'family')
     end
-    
-    def test_should_return_sorted_data_fields_array
-      assert_equal(%w(active bad_method created_at foo_method grade ilp_status_name status_name updated_at),
-        Enrollment.rexport_fields_array.map {|df| df.name})
-    end
-    
-    def test_should_add_single_association_method_to_rexport_fields
-      assert_difference('Enrollment.rexport_fields.length') do
-        Enrollment.add_association_methods(:associations => 'test_association')
-      end
-      assert_equal('test_association_name', Enrollment.rexport_fields[:test_association_name].name)
-      assert_equal('test_association.name', Enrollment.rexport_fields[:test_association_name].method)
-    end
-    
-    def test_should_add_name_methods_for_multiple_associations
-      assert_difference('Enrollment.rexport_fields.length', 3) do
-        Enrollment.add_association_methods(:associations => %w(a b c))
-      end
-    end
-    
-    def test_should_add_multiple_methods_for_multiple_associations
-      assert_difference('Enrollment.rexport_fields.length', 9) do
-        Enrollment.add_association_methods(:associations => %w(a1 a2 a3), :methods => %w(m1 m2 m3))
+
+    test 'should raise no method error for missing associations' do
+      assert_raise NoMethodError do
+        Enrollment.get_klass_from_associations('not_an_association')
       end
     end
-    
-    def test_should_get_rexport_methods
-      assert_equal(%w(grade), Enrollment.get_rexport_methods(:grade))
-      assert_equal(%w(status.name), Enrollment.get_rexport_methods(:status_name))
-      assert_equal(%w(undefined_rexport_field), Enrollment.get_rexport_methods('bad_association.test'))
-      assert_equal(%w(undefined_rexport_field), Enrollment.get_rexport_methods('student.bad_method'))
-      assert_equal(%w(student.name), Enrollment.get_rexport_methods('student.name'))
-      assert_equal(%w(student.family.foo), Enrollment.get_rexport_methods('student.family.foo_method'))
-      assert_equal(['student.family.foo', 'student.name', 'undefined_rexport_field', 'undefined_rexport_field', 'status.name', 'grade'],
-        Enrollment.get_rexport_methods('student.family.foo_method', 'student.name', 'student.bad_method', 'bad_association.test', 'status_name', 'grade'))
+  end
+
+  class RexportInstanceMethodsTest < DataFieldsTest
+    test 'should exoport value of data attribute' do
+      assert_equal %w(1), build(:enrollment).export('grade')
     end
-    
-    def test_should_remove_single_rexport_field
-      assert(Enrollment.rexport_fields[:grade])
-      assert(Enrollment.remove_rexport_fields(:grade))
-      assert_nil(Enrollment.rexport_fields[:grade])
+
+    test 'should export value returned from method' do
+      assert_equal %w(bar), build(:enrollment).export('foo')
     end
-    
-    def test_should_remove_multiple_rexport_fields
-      fields = %w(grade status_name foo_method)
-      fields.each {|field| assert(Enrollment.rexport_fields[field])}
-      assert(Enrollment.remove_rexport_fields(fields))
-      fields.each {|field| assert_nil(Enrollment.rexport_fields[field])}
+
+    test 'should return empty string for undefined method' do
+      assert_equal [''], build(:enrollment).export('bad_method')
     end
-    
-    def test_should_get_klass_from_assocations
-      assert_equal(Family, Enrollment.get_klass_from_associations('student', 'family'))
+
+    test 'should format date for export' do
+      assert_equal [Time.now.strftime("%m/%d/%y")], build(:enrollment).export('updated_at')
     end
-    
-    def test_should_rasie_no_method_error_for_missing_associations
-      assert_raise(NoMethodError) { Enrollment.get_klass_from_associations('not_an_association') }
+
+    test 'should export Y for true' do
+      assert_equal %w(Y), Enrollment.new(active: true).export('active')
     end
-    
-    def test_reset_column_information_with_rexport_reset
-      assert(Enrollment.rexport_fields)
-      assert(Enrollment.instance_variable_get('@rexport_fields'))
-      Enrollment.reset_column_information
-      assert_nil(Enrollment.instance_variable_get('@rexport_fields'))
+
+    test 'should export N for false' do
+      assert_equal %w(N), Enrollment.new(active: false).export('active')
     end
-  end
-  
-  class RexportInstanceMethodsTest < DataFieldsTest
-    def test_should_export_fields_for_record
-      enrollment = FactoryGirl.create(:enrollment)
-      assert_equal(%w(1), enrollment.export('grade'))
-      assert_equal(%w(bar), enrollment.export('foo'))
-      assert_equal([''], enrollment.export('bad_method'))
-      assert_equal(%w(1 bar) << Date.today.strftime("%m/%d/%y"), enrollment.export('grade', 'foo', 'updated_at'))
+
+    test 'should handle missing associations' do
+      assert_equal [''], Enrollment.new.export('status.name')
     end
-  
-    def test_should_handle_missing_associations
-      enrollment = Enrollment.new
-      assert_equal([''], enrollment.export('status.name'))
-      assert_equal([''], enrollment.export('student.name'))
+
+    test 'should handle undefined export field' do
+      assert_equal ['UNDEFINED EXPORT FIELD'], Enrollment.new.export('undefined_rexport_field')
     end
-  
-    def test_should_handle_undefined_export
-      enrollment = FactoryGirl.create(:enrollment)
-      assert_equal(['UNDEFINED EXPORT FIELD'], enrollment.export('undefined_rexport_field'))
+
+    test 'should export value of associated data attribute' do
+      assert_equal ['The Sample Family'], build(:enrollment).export('student.family.name')
     end
-  
-    def test_should_export_associated_fields
-      enrollment = FactoryGirl.create(:enrollment)
-      assert_equal(['Sammy Sample'], enrollment.export('student.name'))
-      assert_equal(['The Sample Family'], enrollment.export('student.family.name'))
-      assert_equal(%w(bar), enrollment.export('student.family.foo'))
+
+    test 'should export value returned from associated method' do
+      assert_equal %w(bar), build(:enrollment).export('student.family.foo')
     end
-  
-    def test_should_export_field_from_non_rexported_model
-      enrollment = FactoryGirl.create(:enrollment)
-      assert_equal(['active'], enrollment.export('status.name'))
+
+    test 'should export field from non rexported model' do
+      assert_equal %w(active), build(:enrollment).export('status.name')
     end
-  
-    def test_should_export_local_associated_and_non_rexported_fields
-      enrollment = FactoryGirl.create(:enrollment)
-      assert_equal(['The Sample Family', 'Sammy Sample', '1', 'bar', 'active'], enrollment.export('student.family.name', 'student.name', 'grade', 'student.family.foo', 'status.name'))
+
+    test 'should export local, associated, and non rexported fields in order' do
+      assert_equal(
+        ['The Sample Family', 'Sammy Sample', '1', 'bar', 'active'],
+        build(:enrollment).export(
+          'student.family.name',
+          'student.name',
+          'grade',
+          'student.family.foo',
+          'status.name'
+        )
+      )
     end
   end
 end

data/test/unit/export_filter_methods_test.rb

@@ -0,0 +1,37 @@
+require 'test_helper'
+
+class ExportFilterMethodsTest < ActiveSupport::TestCase
+  test 'should return associated object name' do
+    assert_equal '1', FactoryBot.create(:grade_filter).display_value
+  end
+
+  test 'should return chained associated object value' do
+    assert_equal 'active', FactoryBot.create(:status_filter).display_value
+  end
+
+  test 'should return chained associated object' do
+    family = FactoryBot.create(:family)
+    assert_equal(
+      family.name,
+      export_filter('student.family_id', value: family.id).display_value
+    )
+  end
+
+  test 'should return undefined association' do
+    assert_equal('UNDEFINED ASSOCIATION', export_filter('bogus_id').display_value)
+  end
+
+  test 'should return associated object not found' do
+    assert_equal 'ASSOCIATED OBJECT NOT FOUND', export_filter('status_id').display_value
+  end
+
+  private
+
+  def export_filter(filter_field, value: 1)
+    ExportFilter.new(
+      export:       FactoryBot.create(:export),
+      filter_field: filter_field,
+      value:        value
+    )
+  end
+end

data/test/unit/export_item_methods_test.rb

@@ -0,0 +1,21 @@
+require 'test_helper'
+
+class ExportItemMethodsTest < ActiveSupport::TestCase
+  test 'should resort export items' do
+    export = FactoryBot.create(:export)
+    ExportItem.resort(export.export_items.ordered.reverse.map(&:id).map(&:to_s))
+    assert_equal 'Bogus Item', export.export_items.ordered.first.name
+  end
+
+  test 'should return attributes_for_copy' do
+    assert FactoryBot.create(:family_name_export_item).attributes_for_copy
+  end
+
+  test 'should set name when blank' do
+    assert_equal 'Grade', FactoryBot.create(:grade_export_item).name
+  end
+
+  test 'should set name for chained field to last two items' do
+    assert_equal 'Name - Test', ExportItem.create(rexport_field: 'this.is.a.name.test').name
+  end
+end

data/test/unit/export_methods_test.rb

@@ -1,97 +1,219 @@
 require 'test_helper'
 
 class ExportMethodsTest < ActiveSupport::TestCase
-  def test_should_return_header
-    export = FactoryGirl.create(:export)
-    assert_equal(['Family Name', 'Grade', 'Status', 'Bogus Item'], export.header)
+  test 'should return models' do
+    assert Export.models
   end
 
-  def test_should_return_rexport_fields
-    export = FactoryGirl.create(:export)
-    assert_equal(%w(student.family.name grade status_name bogus_field), export.send(:rexport_fields))
+  test 'should return full name' do
+    assert_equal 'Enrollments - Enrollment Export', build(:export).full_name
   end
 
-  def test_should_return_rexport_methods
-    export = FactoryGirl.create(:export)
-    assert_equal(%w(student.family.name grade status.name undefined_rexport_field), export.send(:rexport_methods))
+  test 'should return header' do
+    assert_equal ['Family Name', 'Grade', 'Status', 'Bogus Item'], create(:export).header
   end
 
-  def test_records
-    export = FactoryGirl.create(:export)
-    enrollment = FactoryGirl.create(:enrollment)
-    assert_equal(['The Sample Family', '1', 'active', 'UNDEFINED EXPORT FIELD'], export.records.first)
+  test 'should return rexport_fields' do
+    assert_equal(
+      %w(student.family.name grade status_name bogus_field),
+      build(:export).send(:rexport_fields)
+    )
   end
 
-  def test_records_with_filters
-    export = FactoryGirl.create(:export)
-    filtered_export = FactoryGirl.create(:export)
-    enrollment = FactoryGirl.create(:enrollment)
-    FactoryGirl.create(:second_grade_enrollment)
-    assert_equal(2, Enrollment.count)
-    assert_equal(2, export.records.length)
-    assert_equal(['The Sample Family', '1', 'active', 'UNDEFINED EXPORT FIELD'], filtered_export.records.first)
+  test 'should return rexport_methods' do
+    assert_equal(
+      %w(student.family.name grade status.name undefined_rexport_field),
+      create(:export).send(:rexport_methods)
+    )
   end
 
-  def test_sample_records
-    export = FactoryGirl.create(:export)
+  test 'should return records' do
+    create(:enrollment)
+    assert_equal(
+      ['The Sample Family', '1', 'active', 'UNDEFINED EXPORT FIELD'],
+      create(:export).records.first
+    )
+  end
+
+  test 'should return records that match filters' do
+    create(:enrollment)
+    create(:second_grade_enrollment)
+    assert_equal 2, Enrollment.count
+    assert_equal [['1', 'active']], create(:filtered_export).records
+  end
+
+  test 'should call get_records' do
+    export = build(:export)
     export.expects(:get_records).with(Rexport::SAMPLE_SIZE).returns(true)
-    assert(export.sample_records)
+    assert export.sample_records
+  end
+
+  test 'should return to_s with no records' do
+    assert_equal "Family Name|Grade|Status|Bogus Item\n", create(:export).to_s
+  end
+
+  test 'should return to_s with record' do
+    create(:enrollment)
+    assert_equal(
+      "Family Name|Grade|Status|Bogus Item\nThe Sample Family|1|active|UNDEFINED EXPORT FIELD\n",
+      create(:export).to_s
+    )
+  end
+
+  test 'should return to_csv with no records' do
+    assert_equal "Family Name,Grade,Status,Bogus Item\n", create(:export).to_csv
   end
 
-  def test_to_s_with_no_records
-    export = FactoryGirl.create(:export)
-    assert_equal("Family Name|Grade|Status|Bogus Item\n", export.to_s)
+  test 'should return to_csv with record' do
+    FactoryBot.create(:enrollment)
+    assert_equal(
+      "Family Name,Grade,Status,Bogus Item\nThe Sample Family,1,active,UNDEFINED EXPORT FIELD\n",
+      create(:export).to_csv
+    )
   end
 
-  def test_to_s_with_record
-    export = FactoryGirl.create(:export)
-    enrollment = FactoryGirl.create(:enrollment)
-    assert_equal("Family Name|Grade|Status|Bogus Item\nThe Sample Family|1|active|UNDEFINED EXPORT FIELD\n", export.to_s)
+  test 'should return to_csv with passed objects' do
+    assert_equal(
+      "Family Name,Grade,Status,Bogus Item\n\"\",99,\"\",UNDEFINED EXPORT FIELD\n",
+      create(:export).to_csv([Enrollment.new(grade: 99)])
+    )
   end
 
-  def test_to_csv_with_no_records
-    export = FactoryGirl.create(:export)
-    assert_equal("Family Name,Grade,Status,Bogus Item\n", export.to_csv)
+  test 'should return build_conditions' do
+    assert_equal(
+      {'statuses.name' => 'active', 'enrollments.grade' => '1'},
+      create(:filtered_export).send(:build_conditions)
+    )
   end
 
-  def test_to_csv_with_record
-    export = FactoryGirl.create(:export)
-    enrollment = FactoryGirl.create(:enrollment)
-    assert_equal("Family Name,Grade,Status,Bogus Item\nThe Sample Family,1,active,UNDEFINED EXPORT FIELD\n", export.to_csv)
+  test 'should return build_include' do
+    assert_equal [{student: [:family]}, :status], create(:export).send(:build_include)
   end
 
-  def test_to_csv_with_passed_objects
-    export = FactoryGirl.create(:export)
-    assert_equal("Family Name,Grade,Status,Bogus Item\n\"\",99,\"\",UNDEFINED EXPORT FIELD\n", export.to_csv([Enrollment.new(:grade => 99)]))
+  test 'should return rexport_models' do
+    export = create(:export)
+    assert_equal(
+      %w(Enrollment Family SelfReferentialCheck Student),
+      export.rexport_models.map(&:name).sort
+    )
+    assert_equal(
+      ['', 'self_referential_check', 'student', 'student.family'],
+      export.rexport_models.map(&:path).map(&:to_s).sort
+    )
   end
 
-  def test_build_conditions
-    export = FactoryGirl.create(:filtered_export)
-    assert_equal({'statuses.name' => 'active', 'enrollments.grade' => '1'}, export.send(:build_conditions))
+  test 'should return true for has_rexport_field?' do
+    assert build(:export).has_rexport_field?('student.family.name')
   end
 
-  def test_build_include
-    export = FactoryGirl.create(:export)
-    assert_equal([{:student=>[:family]}, :status], export.send(:build_include))
+  test 'should return false for has_rexport_field?' do
+    refute build(:export).has_rexport_field?('student.family.number')
   end
 
-  def test_should_return_rexport_models
-    export = FactoryGirl.create(:export)
-    assert_equal(%w(Enrollment Family SelfReferentialCheck Student), export.rexport_models.map {|m| m.klass.to_s}.sort)
-    assert_equal(['', 'self_referential_check', 'student', 'student.family'], export.rexport_models.map {|m| m.path.to_s}.sort)
+  test 'should save export_items from a hash' do
+    assert_equal %w(a b c), rexport_fields_for(create_export(fields: {a: 1, b: 1, c: 1}))
   end
 
-  def test_should_create_copy_with_unique_name
-    assert_equal 'Enrollment Export Copy', FactoryGirl.create(:export).copy.name
-    assert_equal 'Enrollment Export Copy [1]', FactoryGirl.create(:export).copy.name
-    assert_equal 'Enrollment Export Copy [2]', FactoryGirl.create(:export).copy.name
+  test 'should save export_items from an array' do
+    assert_equal %w(a b c), rexport_fields_for(create_export(fields: %w(a b c)))
   end
 
-  def test_should_copy_export_with_export_items
-    assert_equal FactoryGirl.create(:export).export_items.count, FactoryGirl.create(:export).copy.export_items.count
+  test 'should add export_item to exising export on update' do
+    export = create_export(fields: %w(a c))
+    assert_difference 'ExportItem.count' do
+      export.update_attribute(:rexport_fields, %w(a b c))
+    end
+    assert_equal %w(a b c), rexport_fields_for(export)
+  end
+
+  test 'should delete export_item that is not in rexport_fields on update' do
+    export = create_export(fields: %w(a b c))
+    assert_difference 'ExportItem.count', -1 do
+      export.update_attribute(:rexport_fields, %w(a c))
+    end
+    assert_equal %w(a c), rexport_fields_for(export)
+  end
+
+  test 'should re-order export_items when passed an array of export_fields on update' do
+    export = create_export(fields: %w(a b c))
+    export.update_attribute(:rexport_fields, %w(c b a))
+    assert_equal %w(c b a), rexport_fields_for(export)
+  end
+
+  test 'should not re-order export_items when passed a hash of export_fields on update' do
+    export = create_export(fields: %w(a b c))
+    export.update_attribute(:rexport_fields, {c: 1, b: 1, a: 1})
+    assert_equal %w(a b c), rexport_fields_for(export)
+  end
+
+  test 'should not modify export_items on update when no export_fields are passed' do
+    export = create_export(fields: %w(a b c))
+    assert_no_difference 'ExportItem.count' do
+      export.update_attribute(:name, 'New Name')
+    end
+    assert_equal %w(a b c), rexport_fields_for(export)
+  end
+
+  test 'should create export with an export_filter' do
+    assert_difference 'ExportFilter.count' do
+      create_export(filters: {status_id: 1})
+    end
+  end
+
+  test 'should add an export_filter to an existing export' do
+    export = create_export
+    assert_difference 'ExportFilter.count' do
+      export.update_attribute(:export_filter_attributes, {status_id: 1})
+    end
+  end
+
+  test 'should delete an export_filter from an export' do
+    export = create_export(filters: {status_id: 1})
+    assert_difference 'ExportFilter.count', -1 do
+      export.update_attribute(:export_filter_attributes, {status_id: ''})
+    end
+  end
+
+  test 'should return filter_value for filter_field' do
+    assert_equal 'active', create(:filtered_export).filter_value('status.name')
+  end
+
+  test 'should return nil for filter_value when no matching export_filters' do
+    assert_nil create(:filtered_export).filter_value('does_not_exist')
+  end
+
+  test 'should create copy with unique name' do
+    assert_equal 'Enrollment Export Copy',      create(:export).copy.name
+    assert_equal 'Enrollment Export Copy [1]',  create(:export).copy.name
+    assert_equal 'Enrollment Export Copy [2]',  create(:export).copy.name
+  end
+
+  test 'should copy export with export_items' do
+    export = create(:export)
+    assert_difference 'ExportItem.count', export.export_items.count do
+      export.copy.export_items.count
+    end
+  end
+
+  test 'should copy export with export_filters' do
+    export = create(:filtered_export)
+    assert_difference 'ExportFilter.count', export.export_filters.count do
+      export.copy
+    end
+  end
+
+  private
+
+  def create_export(fields: {}, filters: {})
+    Export.create(
+      name:                     'Test',
+      model_class_name:         'Enrollment',
+      rexport_fields:           fields,
+      export_filter_attributes: filters
+    )
   end
 
-  def test_should_copy_export_with_export_filters
-    assert_equal FactoryGirl.create(:filtered_export).export_filters.count, FactoryGirl.create(:filtered_export).copy.export_filters.count
+  def rexport_fields_for(export)
+    export.export_items.ordered.map(&:rexport_field)
   end
 end