rexport 1.2.1 → 1.4.0

data/test/unit/data_fields_test.rb

@@ -1,75 +0,0 @@
-require 'test_helper'
-
-class DataFieldsTest < ActiveSupport::TestCase
-
-  class RexportClassMethodsTest < DataFieldsTest
-    test 'should get klass from assocations' do
-      assert_equal Family, Enrollment.get_klass_from_associations('student', 'family')
-    end
-
-    test 'should raise no method error for missing associations' do
-      assert_raise NoMethodError do
-        Enrollment.get_klass_from_associations('not_an_association')
-      end
-    end
-  end
-
-  class RexportInstanceMethodsTest < DataFieldsTest
-    test 'should exoport value of data attribute' do
-      assert_equal %w(1), build(:enrollment).export('grade')
-    end
-
-    test 'should export value returned from method' do
-      assert_equal %w(bar), build(:enrollment).export('foo')
-    end
-
-    test 'should return empty string for undefined method' do
-      assert_equal [''], build(:enrollment).export('bad_method')
-    end
-
-    test 'should format date for export' do
-      assert_equal [Time.now.strftime("%m/%d/%y")], build(:enrollment).export('updated_at')
-    end
-
-    test 'should export Y for true' do
-      assert_equal %w(Y), Enrollment.new(active: true).export('active')
-    end
-
-    test 'should export N for false' do
-      assert_equal %w(N), Enrollment.new(active: false).export('active')
-    end
-
-    test 'should handle missing associations' do
-      assert_equal [''], Enrollment.new.export('status.name')
-    end
-
-    test 'should handle undefined export field' do
-      assert_equal ['UNDEFINED EXPORT FIELD'], Enrollment.new.export('undefined_rexport_field')
-    end
-
-    test 'should export value of associated data attribute' do
-      assert_equal ['The Sample Family'], build(:enrollment).export('student.family.name')
-    end
-
-    test 'should export value returned from associated method' do
-      assert_equal %w(bar), build(:enrollment).export('student.family.foo')
-    end
-
-    test 'should export field from non rexported model' do
-      assert_equal %w(active), build(:enrollment).export('status.name')
-    end
-
-    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

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

@@ -1,21 +0,0 @@
-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,226 +0,0 @@
-require 'test_helper'
-
-class ExportMethodsTest < ActiveSupport::TestCase
-  test 'should return models' do
-    assert Export.models
-  end
-
-  test 'should return full name' do
-    assert_equal 'Enrollments - Enrollment Export', build(:export).full_name
-  end
-
-  test 'should return header' do
-    assert_equal ['Family Name', 'Grade', 'Status', 'Bogus Item'], create(:export).header
-  end
-
-  test 'should return rexport_fields' do
-    assert_equal(
-      %w(student.family.name grade status_name bogus_field),
-      build(:export).send(:rexport_fields)
-    )
-  end
-
-  test 'should return rexport_methods' do
-    assert_equal(
-      %w(student.family.name grade status.name undefined_rexport_field),
-      create(:export).send(:rexport_methods)
-    )
-  end
-
-  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 return error message for records when export has an invalid filter' do
-    assert_equal(
-      [["SQLite3::SQLException: no such column: enrollments.invalid"]],
-      create(:invalid_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
-  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
-
-  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
-
-  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
-
-  test 'should return build_conditions' do
-    assert_equal(
-      {'statuses.name' => 'active', 'enrollments.grade' => '1'},
-      create(:filtered_export).send(:build_conditions)
-    )
-  end
-
-  test 'should return build_include' do
-    assert_equal [{student: [:family]}, :status], create(:export).send(:build_include)
-  end
-
-  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
-
-  test 'should return true for has_rexport_field?' do
-    assert build(:export).has_rexport_field?('student.family.name')
-  end
-
-  test 'should return false for has_rexport_field?' do
-    refute build(:export).has_rexport_field?('student.family.number')
-  end
-
-  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
-
-  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
-
-  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 rexport_fields_for(export)
-    export.export_items.ordered.map(&:rexport_field)
-  end
-end

data/test/unit/rexport_model_test.rb

@@ -1,137 +0,0 @@
-require 'test_helper'
-
-class RexportModel < ActiveSupport::TestCase
-  test 'should initialize rexport_fields' do
-    assert_equal(
-      %w(active bad_method created_at foo_method grade ilp_status_name status_name updated_at),
-      rexport_model.rexport_fields.keys.sort
-    )
-  end
-
-  test 'should initialize data atributes' do
-    assert_equal 'grade',   rexport_model.rexport_fields[:grade].method
-    assert_equal :integer,  rexport_model.rexport_fields[:grade].type
-  end
-
-  test 'should initialize method' do
-    assert_equal 'foo', rexport_model.rexport_fields[:foo_method].method
-    assert_nil rexport_model.rexport_fields[:foo_method].type
-  end
-
-  test 'should add single association method to rexport_fields' do
-    assert_fields_length do |rexport|
-      rexport.add_association_methods(associations: 'test_association')
-      assert_equal 'test_association_name', rexport.rexport_fields[:test_association_name].name
-      assert_equal 'test_association.name', rexport.rexport_fields[:test_association_name].method
-    end
-  end
-
-  test 'should add name methods for multiple associations' do
-    assert_fields_length(change: 3) do |rexport|
-      rexport.add_association_methods(associations: %w(a b c))
-    end
-  end
-
-  test 'should add multiple methods for multiple associations' do
-    assert_fields_length(change: 9) do |rexport|
-      rexport.add_association_methods(associations: %w(a1 a2 a3), methods: %w(m1 m2 m3))
-    end
-  end
-
-  test 'should remove single rexport field' do
-    rexport_model.tap do |rexport|
-      assert      rexport.rexport_fields[:grade]
-      assert      rexport.remove_rexport_fields(:grade)
-      assert_nil  rexport.rexport_fields[:grade]
-    end
-  end
-
-  test 'should remove multiple rexport fields' do
-    fields = %w(grade status_name foo_method)
-
-    rexport_model.tap do |rexport|
-      fields.each { |field| assert(rexport.rexport_fields[field]) }
-      assert rexport.remove_rexport_fields(fields)
-      fields.each { |field| assert_nil(rexport.rexport_fields[field]) }
-    end
-  end
-
-  test 'should get rexport methods' do
-    assert_equal(
-      [
-        'student.family.foo',
-        'student.name',
-        'undefined_rexport_field',
-        'undefined_rexport_field',
-        'status.name',
-        'grade'
-      ],
-      rexport_model.get_rexport_methods(
-        'student.family.foo_method',
-        'student.name',
-        'student.bad_method',
-        'bad_association.test',
-        'status_name',
-        'grade'
-      )
-    )
-  end
-
-  test 'should use cached rexport_model when getting multiple fields from one model' do
-    rexport_model.tap do |rexport|
-      assert_equal ['student.name'], rexport.get_rexport_methods('student.name')
-      Student.expects(:get_klass_from_associations).times(0)
-      assert_equal ['student.date_of_birth'], rexport.get_rexport_methods('student.date_of_birth')
-    end
-  end
-
-  test 'should return default foreign_key' do
-    assert_equal 'status_id', rexport_model.filter_column(data_field('status_name'))
-  end
-
-  test 'should return custom foreign_key' do
-    assert_equal 'ilp_status_id', rexport_model.filter_column(data_field('ilp_status_name'))
-  end
-
-  test 'should call rexport_fields_array' do
-    assert_equal(
-      %w(active bad_method created_at foo_method grade ilp_status_name status_name updated_at),
-      rexport_model.rexport_fields_array.map(&:name)
-    )
-  end
-
-  test 'should return field_path' do
-    assert_equal 'foo.bar', rexport_model(path: 'foo').field_path('bar')
-  end
-
-  test 'should return collection_from_association' do
-    Status.expects(:all).returns(true)
-    assert rexport_model.collection_from_association('status')
-  end
-
-  test 'should return custom find method for collection_from_association' do
-    Student.expects(:find_family_for_rexport).returns(true)
-    assert rexport_model(model: Student).collection_from_association('family')
-  end
-
-
-  test 'should return class name' do
-    assert_equal 'Enrollment', rexport_model.name
-  end
-
-  private
-
-  def rexport_model(model: Enrollment, path: nil)
-    Rexport::RexportModel.new(model, path: path)
-  end
-
-  def data_field(name)
-    rexport_model.rexport_fields[name]
-  end
-
-  def assert_fields_length(rexport: rexport_model, change: 1, &block)
-    assert_difference('rexport.rexport_fields.length', change) do
-      block.call(rexport)
-    end
-  end
-end

data/test/unit/tree_node_test.rb

@@ -1,43 +0,0 @@
-require 'test_helper'
-
-class TreeNodeTest < ActiveSupport::TestCase
-  test 'should initialize with name' do
-    t = Rexport::TreeNode.new('test')
-    assert_equal 'test', t.name
-    assert_equal [], t.children
-  end
-
-  test 'should initialize with name and children' do
-    t = Rexport::TreeNode.new('test', %w(one two three))
-    assert_equal 'test', t.name
-    assert_equal ["test", [["one", [["two", [["three", []]]]]]]], t.to_a
-  end
-
-  test 'should add children' do
-    root = Rexport::TreeNode.new('root')
-    root.add_child('a')
-    assert_equal ['root', [['a', []]]], root.to_a
-    root.add_child('a')
-    assert_equal ['root', [['a', []]]], root.to_a
-    root.add_child('a', [1 , 2])
-    assert_equal ['root', [['a', [[1, [[2, []]]]]]]], root.to_a
-  end
-
-  test 'should return empty include' do
-    root = Rexport::TreeNode.new('root')
-    assert_equal [], root.to_include
-  end
-
-  test 'should return single level array include' do
-    root = Rexport::TreeNode.new('root')
-    %w(a b c).each { |l| root.add_child(l) }
-    assert_equal [:a, :b, :c], root.to_include
-  end
-
-  test 'should return nested hash include' do
-    root = Rexport::TreeNode.new('root', %w(a b c))
-    assert_equal [{a: [{b: [:c]}]}], root.to_include
-    root.add_child 'b', 'one', 'two'
-    assert_equal [{a: [{b: [:c]}]}, {b: [{one:[:two]}]}], root.to_include
-  end
-end