rexport 0.4.0

data/test/test_helper.rb

@@ -0,0 +1,168 @@
+require 'minitest/autorun'
+require 'rubygems'
+require 'active_record'
+require 'active_support/test_case'
+require 'logger'
+require 'factory_girl'
+require File.dirname(__FILE__) + '/factories'
+require File.dirname(__FILE__) + '/../lib/rexport/data_fields'
+require File.dirname(__FILE__) + '/../lib/rexport/export_methods'
+require File.dirname(__FILE__) + '/../lib/rexport/export_item_methods'
+require File.dirname(__FILE__) + '/../lib/rexport/export_filter_methods'
+require File.dirname(__FILE__) + '/../lib/rexport/tree_node'
+
+ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:")
+
+RAILS_DEFAULT_LOGGER = Logger.new(File.dirname(__FILE__) + '/log/test.log')
+RAILS_DEFAULT_LOGGER.level = Logger::DEBUG
+ActiveRecord::Base.logger = RAILS_DEFAULT_LOGGER
+
+class ActiveSupport::TestCase
+  include Rexport::Factories
+
+  def setup
+    setup_db
+    Enrollment.instance_variable_set('@rexport_fields', nil)
+    Student.instance_variable_set('@rexport_fields', nil)
+  end
+
+  def teardown
+    teardown_db
+  end
+
+  # Placeholder so test/unit ignores test cases without any tests.
+  def default_test
+  end
+
+  private
+
+  def setup_db
+    old_stdout = $stdout
+    $stdout = StringIO.new
+
+    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_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
+
+    $stdout = old_stdout
+  end
+
+  def teardown_db
+    ActiveRecord::Base.connection.tables.each do |table|
+      ActiveRecord::Base.connection.drop_table(table)
+    end
+  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 Enrollment.initialize_local_rexport_fields
+    add_rexport_field(:foo_method, :method => :foo)
+    add_rexport_field(:bad_method, :method => 'bad_method')
+    add_association_methods(:associations => %w(status ilp_status))
+  end
+end
+
+class Student < ActiveRecord::Base
+  include Rexport::DataFields
+  belongs_to :family
+  has_many :enrollments
+end
+
+class Family < ActiveRecord::Base
+  include Rexport::DataFields
+  has_many :students
+
+  def foo
+    'bar'
+  end
+
+  private
+
+  def Family.initialize_local_rexport_fields
+    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
+  belongs_to :enrollment
+
+  def SelfReferentialCheck.rexport_fields
+    'trick get_rexport_models into believing we are exportable'
+  end
+end

data/test/unit/data_field_test.rb

@@ -0,0 +1,25 @@
+require 'test_helper'
+
+class DataFieldTest < ActiveSupport::TestCase
+  def test_should_stringify_name
+    assert_equal('foo', Rexport::DataField.new(:foo).name)
+  end
+
+  def test_should_use_name_for_method
+    assert_equal('foo', Rexport::DataField.new(:foo).method)
+  end
+
+  def test_should_save_method
+    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)
+  end
+
+  def test_should_sort_data_fields
+    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

@@ -0,0 +1,117 @@
+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)
+    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))
+      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
+    
+    def test_should_remove_single_rexport_field
+      assert(Enrollment.rexport_fields[:grade])
+      assert(Enrollment.remove_rexport_fields(:grade))
+      assert_nil(Enrollment.rexport_fields[:grade])
+    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])}
+    end
+    
+    def test_should_get_klass_from_assocations
+      assert_equal(Family, Enrollment.get_klass_from_associations('student', 'family'))
+    end
+    
+    def test_should_rasie_no_method_error_for_missing_associations
+      assert_raise(NoMethodError) { Enrollment.get_klass_from_associations('not_an_association') }
+    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'))
+    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'))
+    end
+  
+    def test_should_handle_missing_associations
+      enrollment = Enrollment.new
+      assert_equal([''], enrollment.export('status.name'))
+      assert_equal([''], enrollment.export('student.name'))
+    end
+  
+    def test_should_handle_undefined_export
+      enrollment = FactoryGirl.create(:enrollment)
+      assert_equal(['UNDEFINED EXPORT FIELD'], enrollment.export('undefined_rexport_field'))
+    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'))
+    end
+  
+    def test_should_export_field_from_non_rexported_model
+      enrollment = FactoryGirl.create(:enrollment)
+      assert_equal(['active'], 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'))
+    end
+  end
+end

data/test/unit/export_methods_test.rb

@@ -0,0 +1,97 @@
+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)
+  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))
+  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))
+  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)
+  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)
+  end
+
+  def test_sample_records
+    export = FactoryGirl.create(:export)
+    export.expects(:get_records).with(Rexport::SAMPLE_SIZE).returns(true)
+    assert(export.sample_records)
+  end
+
+  def test_to_s_with_no_records
+    export = FactoryGirl.create(:export)
+    assert_equal("Family Name|Grade|Status|Bogus Item\n", export.to_s)
+  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)
+  end
+
+  def test_to_csv_with_no_records
+    export = FactoryGirl.create(:export)
+    assert_equal("Family Name,Grade,Status,Bogus Item\n", export.to_csv)
+  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)
+  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)]))
+  end
+
+  def test_build_conditions
+    export = FactoryGirl.create(:filtered_export)
+    assert_equal({'statuses.name' => 'active', 'enrollments.grade' => '1'}, export.send(:build_conditions))
+  end
+
+  def test_build_include
+    export = FactoryGirl.create(:export)
+    assert_equal([{:student=>[:family]}, :status], export.send(:build_include))
+  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)
+  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
+  end
+
+  def test_should_copy_export_with_export_items
+    assert_equal FactoryGirl.create(:export).export_items.count, FactoryGirl.create(:export).copy.export_items.count
+  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
+  end
+end

data/test/unit/rexport_model_test.rb

@@ -0,0 +1,35 @@
+require 'test_helper'
+
+class RexportModel < ActiveSupport::TestCase
+  def test_return_correct_foreign_key
+    rexport_model = Rexport::RexportModel.new(Enrollment)
+
+    data_field = Enrollment.rexport_fields['status_name']
+    assert_equal('status_id', rexport_model.filter_column(data_field))
+
+    data_field = Enrollment.rexport_fields['ilp_status_name']
+    assert_equal('ilp_status_id', rexport_model.filter_column(data_field))
+  end
+
+  def test_should_call_rexport_fields_array
+    rexport_model = Rexport::RexportModel.new(Enrollment)
+    Enrollment.expects(:rexport_fields_array).returns(true)
+    assert(rexport_model.rexport_fields_array)
+  end
+
+  def test_field_path
+    rexport_model = Rexport::RexportModel.new(Enrollment, 'foo')
+    assert_equal('foo.bar', rexport_model.field_path('bar'))
+  end
+
+  def test_collection_from_association
+    rexport_model = Rexport::RexportModel.new(Enrollment)
+    Status.expects(:all).returns(true)
+    assert(rexport_model.collection_from_association('status'))
+  end
+
+  def test_should_return_class_name
+    rexport_model = Rexport::RexportModel.new(Enrollment)
+    assert_equal('Enrollment', rexport_model.name)
+  end
+end

data/test/unit/tree_node_test.rb

@@ -0,0 +1,43 @@
+require 'test_helper'
+
+class TreeNodeTest < ActiveSupport::TestCase
+  def test_should_initialize_with_name
+    t = Rexport::TreeNode.new('test')
+    assert_equal('test', t.name)
+    assert_equal([], t.children)
+  end
+
+  def test_should_initialize_with_name_and_children
+    t = Rexport::TreeNode.new('test', %w(one two three))
+    assert_equal('test', t.name)
+    assert_equal(["test", [["one", [["two", [["three", []]]]]]]], t.to_a)
+  end
+
+  def test_should_add_children
+    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
+
+  def test_should_return_empty_include
+    root = Rexport::TreeNode.new('root')
+    assert_equal([], root.to_include)
+  end
+
+  def test_should_return_single_level_array_include
+    root = Rexport::TreeNode.new('root')
+    %w(a b c).each {|l| root.add_child(l)}
+    assert_equal([:a, :b, :c], root.to_include)
+  end
+
+  def test_should_return_nested_hash_include
+    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