rexport 1.2.1 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8cf8cb2fe8850f491ab8eb8a92d0034d1447babd6a4a79457acea80fcbec94fc
-  data.tar.gz: 2e646631a4c3673359f31bd222c43c32ed6fcb20813f7f6ac34d633005899628
+  metadata.gz: 91b93bfa7c3dea7a0a9df8dce1e59681aa8de412825556ad9c8b1c743d08c29b
+  data.tar.gz: ac601552d8d3b65b106bab210dc142eda8d88fc489742021100364f1dfc0707b
 SHA512:
-  metadata.gz: '08d2fd739cf9775d22295a57ba4ffd934da63079339f0b697ff923ecba958b2bf5c007987a5ade00756b56a758672d37b23482dc9151dbb610157be181761521'
-  data.tar.gz: '0359913d6d17b4303518284a54a5da8428a1c0b3ce871766fa117a37c063f5d739aa812a08e495689867502ca63be23e719405211eb2ea35b2c046dae006c6e7'
+  metadata.gz: 85cb6d95f199755c44ade632a1cedbe3c6c8834a9d9da9ea1938d1749ee3a4f7045b4fa5ccc091245c0c6471cf24a0d435964621fc93f4f7ab431e4eb8bf2a01
+  data.tar.gz: e69b135131c1484152e10cfc4e0b580888b308084c06b050962dd690dc6917e730be489dedb88265e218ea11ca75635e6d375f89b5c77de84f7800985f901c49

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2011 Aaron Baldwin, WWIDEA INC.
+Copyright 2011-2023 Aaron Baldwin
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -0,0 +1,13 @@
+# Rexport
+Ruby on Rails gem to manage exports
+
+## Installation
+1. install gem
+2. copy migration into application db/migrate folder and run
+3. create models and mix in corresponding module
+    - **export** - export_methods
+    - **export_item** - export_item_methods
+    - **export_filter** - export_filter_methods
+
+## License
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -1,10 +1,3 @@
-require "bundler/gem_tasks"
-require "rake/testtask"
-
-Rake::TestTask.new(:test) do |t|
-  t.libs << "test"
-  t.libs << "lib"
-  t.test_files = FileList["test/**/*_test.rb"]
-end
+require "bundler/setup"
 
-task default: :test
+require "bundler/gem_tasks"

data/lib/rexport/version.rb

@@ -1,3 +1,3 @@
 module Rexport
-  VERSION = '1.2.1'
+  VERSION = '1.3.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rexport
 version: !ruby/object:Gem::Version
-  version: 1.2.1
+  version: 1.3.0
 platform: ruby
 authors:
 - Aaron Baldwin
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-09-02 00:00:00.000000000 Z
+date: 2023-01-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -25,58 +25,16 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 6.0.3
-- !ruby/object:Gem::Dependency
-  name: factory_bot
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '6.2'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '6.2'
-- !ruby/object:Gem::Dependency
-  name: sqlite3
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.4'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.4'
-- !ruby/object:Gem::Dependency
-  name: mocha
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.13'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.13'
 description: Rexport integrates into a Rails application making model data available
   for export into CSV files.
 email:
-- developers@brightwayslearning.org
+- baldwina@brightwayslearning.org
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
 - MIT-LICENSE
-- README.rdoc
+- README.md
 - Rakefile
 - app/helpers/exports_helper.rb
 - app/views/export_filters/_export_filter.html.erb
@@ -107,19 +65,13 @@ files:
 - lib/rexport/rexport_model.rb
 - lib/rexport/tree_node.rb
 - lib/rexport/version.rb
-- test/factories.rb
-- test/test_helper.rb
-- test/unit/data_field_test.rb
-- test/unit/data_fields_test.rb
-- test/unit/export_filter_methods_test.rb
-- test/unit/export_item_methods_test.rb
-- test/unit/export_methods_test.rb
-- test/unit/rexport_model_test.rb
-- test/unit/tree_node_test.rb
 homepage: https://github.com/wwidea/rexport
 licenses:
 - MIT
-metadata: {}
+metadata:
+  homepage_uri: https://github.com/wwidea/rexport
+  source_code_uri: https://github.com/wwidea/rexport
+  rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -128,24 +80,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.9
+rubygems_version: 3.4.5
 signing_key:
 specification_version: 4
 summary: Ruby on Rails gem to manage exports.
-test_files:
-- test/factories.rb
-- test/test_helper.rb
-- test/unit/data_field_test.rb
-- test/unit/data_fields_test.rb
-- test/unit/export_filter_methods_test.rb
-- test/unit/export_item_methods_test.rb
-- test/unit/export_methods_test.rb
-- test/unit/rexport_model_test.rb
-- test/unit/tree_node_test.rb
+test_files: []

data/README.rdoc

@@ -1,17 +0,0 @@
-=Rexport
-
-Ruby on Rails gem to manage exports
-
-
-==Installation
-1. install gem
-2. copy migration into application db/migrate folder and run
-3. create models and mix in corresponding module
-* export => export_methods
-* export_item => export_item_methods
-* export_filter => export_filter_methods
-
-
-==License
-
-Copyright (c) 2008-2018 Brightways Learning, released under the MIT license

data/test/factories.rb

@@ -1,111 +0,0 @@
-module Rexport
-  module Factories
-
-    FactoryBot.define do
-
-      factory :status do
-        name { 'active' }
-      end
-
-      factory :family do
-        name { 'The Sample Family' }
-      end
-
-      factory :student do
-        family        { |family| family.association(:family) }
-        name          { 'Sammy Sample' }
-        date_of_birth { Date.parse('2008-12-08') }
-      end
-
-      factory :enrollment do
-        status      { |status|  status.association(:status) }
-        student     { |student| student.association(:student) }
-        grade       { 1 }
-        updated_at  { Time.now }
-      end
-
-      factory :second_grade_enrollment, class: 'Enrollment' do
-        status  { |status| status.association(:status) }
-        grade   { 2 }
-      end
-
-      factory :export do
-        name              { 'Enrollment Export' }
-        model_class_name  { 'Enrollment' }
-        export_items do |items|
-          %w(family_name_export_item grade_export_item status_name_export_item bogus_export_item).map do |item|
-            items.association(item)
-          end
-        end
-      end
-
-      factory :filtered_export, class: 'Export' do
-        name              { 'Filtered Enrollment Export' }
-        model_class_name  { 'Enrollment' }
-        export_items do |items|
-          %w(grade_export_item status_name_export_item).map do |item|
-            items.association(item)
-          end
-        end
-        export_filters do |filters|
-          %w(grade_filter status_filter).map do |filter|
-            filters.association(filter)
-          end
-        end
-      end
-
-      factory :invalid_filtered_export, class: 'Export' do
-        name              { 'Invalid Filtered Enrollment Export' }
-        model_class_name  { 'Enrollment' }
-        export_items do |items|
-          %w(grade_export_item status_name_export_item).map do |item|
-            items.association(item)
-          end
-        end
-        export_filters do |filters|
-          %w(invalid_filter).map do |filter|
-            filters.association(filter)
-          end
-        end
-      end
-
-      factory :family_name_export_item, class: 'ExportItem' do
-        position       { 1 }
-        name           { 'Family Name' }
-        rexport_field  { 'student.family.name' }
-      end
-
-      factory :grade_export_item, class: 'ExportItem' do
-        position       { 2 }
-        rexport_field  { 'grade' }
-      end
-
-      factory :status_name_export_item, class: 'ExportItem' do
-        position       { 3 }
-        name           { 'Status' }
-        rexport_field  { 'status_name' }
-      end
-
-      factory :bogus_export_item, class: 'ExportItem' do
-        position       { 4 }
-        name           { 'Bogus Item' }
-        rexport_field  { 'bogus_field' }
-      end
-
-      factory :grade_filter, class: 'ExportFilter' do
-        filter_field   { 'grade' }
-        value          { '1' }
-      end
-
-      factory :status_filter, class: 'ExportFilter' do
-        filter_field   { 'status.name' }
-        value          { 'active' }
-      end
-
-      factory :invalid_filter, class: 'ExportFilter' do
-        filter_field   { 'invalid' }
-        value          { '1' }
-      end
-    end
-  end
-end

data/test/test_helper.rb

@@ -1,167 +0,0 @@
-require 'simplecov'
-SimpleCov.start do
-  add_filter '/test/'
-end
-
-$LOAD_PATH.unshift File.expand_path("../../lib", __FILE__)
-require "rails"
-require 'active_record'
-require "rexport"
-
-require 'minitest/autorun'
-require 'factory_bot'
-require 'mocha/minitest'
-require File.dirname(__FILE__) + '/factories'
-
-ActiveRecord::Base.establish_connection(adapter: "sqlite3", database: ":memory:")
-
-class ActiveSupport::TestCase
-  include FactoryBot::Syntax::Methods
-  include Rexport::Factories
-
-  def setup
-    suppress_output { setup_db }
-    Enrollment.instance_variable_set('@rexport_fields', nil)
-    Student.instance_variable_set('@rexport_fields', nil)
-  end
-
-  def teardown
-    teardown_db
-  end
-
-  private
-
-  def setup_db
-    ActiveRecord::Schema.define(version: 1) do
-      create_table :enrollments do |t|
-        t.integer :student_id, :status_id, :grade
-        t.boolean :active
-        t.timestamps
-      end
-
-      create_table :students do |t|
-        t.integer :family_id
-        t.string :name
-        t.date :date_of_birth
-        t.timestamps
-      end
-
-      create_table :families do |t|
-        t.string :name
-        t.timestamps
-      end
-
-      create_table :statuses do |t|
-        t.string :name
-      end
-
-      create_table :exports do |t|
-        t.string :name
-        t.string :model_class_name
-        t.text :description
-      end
-
-      create_table :export_items do |t|
-        t.integer :export_id
-        t.string :name, :rexport_field
-        t.integer :position
-      end
-
-      create_table :export_filters do |t|
-        t.integer :export_id
-        t.string :filter_field, :value
-      end
-
-      create_table :self_referential_checks do |t|
-      end
-    end
-  end
-
-  def teardown_db
-    ActiveRecord::Base.connection.data_sources.each do |table|
-      ActiveRecord::Base.connection.drop_table(table)
-    end
-  end
-
-  def suppress_output
-    original_stdout = $stdout.clone
-    $stdout.reopen File.new('/dev/null', 'w')
-    yield
-  ensure
-    $stdout.reopen original_stdout
-  end
-end
-
-class ActiveRecord::Base
-  class << self
-    def acts_as_list(options = {})
-    end
-  end
-end
-
-class Enrollment < ActiveRecord::Base
-  include Rexport::DataFields
-  belongs_to :student
-  belongs_to :status
-  belongs_to :ilp_status, class_name: 'Status', foreign_key: 'ilp_status_id'
-  belongs_to :self_referential_check
-
-  def foo
-    'bar'
-  end
-
-  private
-
-  def self.initialize_local_rexport_fields(rexport_model)
-    rexport_model.add_rexport_field(:foo_method, method: :foo)
-    rexport_model.add_rexport_field(:bad_method, method: 'bad_method')
-    rexport_model.add_association_methods(associations: %w(status ilp_status))
-  end
-end
-
-class Student < ActiveRecord::Base
-  include Rexport::DataFields
-  belongs_to :family
-  has_many :enrollments
-
-  def self.find_family_for_rexport
-    Family.order(:name)
-  end
-end
-
-class Family < ActiveRecord::Base
-  include Rexport::DataFields
-  has_many :students
-
-  def foo
-    'bar'
-  end
-
-  private
-
-  def self.initialize_local_rexport_fields(rexport_model)
-    rexport_model.add_rexport_field(:foo_method, method: :foo)
-  end
-end
-
-class Status < ActiveRecord::Base
-  # does not include Rexport
-  has_many :enrollments
-end
-
-class Export < ActiveRecord::Base
-  include Rexport::ExportMethods
-end
-
-class ExportItem < ActiveRecord::Base
-  include Rexport::ExportItemMethods
-end
-
-class ExportFilter < ActiveRecord::Base
-  include Rexport::ExportFilterMethods
-end
-
-class SelfReferentialCheck < ActiveRecord::Base
-  include Rexport::DataFields
-  belongs_to :enrollment
-end

data/test/unit/data_field_test.rb

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

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