caruby-core 1.5.5 → 2.1.1

data/test/lib/caruby/domain/reference_visitor_test.rb

@@ -1,130 +0,0 @@
-$:.unshift 'lib'
-$:.unshift 'examples/clinical_trials/lib'
-
-require 'test/unit'
-
-require 'caruby/util/log' and
-CaRuby::Log.instance.open('test/results/log/clinical_trials.log', :shift_age => 10, :shift_size => 1048576, :debug => true)
-
-require 'clinical_trials'
-require 'caruby/domain/reference_visitor'
-
-# CaRuby::ReferenceVisitor test cases.
-class ReferenceVisitorTest < Test::Unit::TestCase
-  def setup
-    super
-    coordinator = ClinicalTrials::User.new(:login => 'study.coordinator@test.org')
-    address = ClinicalTrials::Address.new(:street => '555 Elm St', :city => 'Burlington', :state => 'VT', :zip_code => '55555')
-    @pnt = ClinicalTrials::Participant.new(:name => 'Test Participant', :address => address)
-    @study = ClinicalTrials::Study.new(:name => 'Test Study', :coordinator => coordinator, :enrollment => [@pnt])
-    @event = ClinicalTrials::StudyEvent.new(:study => @study, :calendar_event_point => 1.0)
-  end
-
-  def test_path_references
-    visitor = CaRuby::ReferencePathVisitorFactory.create(ClinicalTrials::Study, [:enrollment, :address])
-    assert_equal([@study, @pnt, @pnt.address], visitor.to_enum(@study).to_a, "Path references incorrect")
-  end
-
-  def test_cycles
-    # visit all references
-    visitor = CaRuby::ReferenceVisitor.new { |ref| ref.class.domain_attributes }
-    visitor.visit(@study)
-    assert_equal([[@study, @event, @study]], visitor.cycles, "Cycles incorrect")
-  end
-
-  def test_path_attributes
-    visitor = CaRuby::ReferencePathVisitorFactory.create(ClinicalTrials::Study, [:enrollment, :address])
-    assert_equal([nil, :enrollment, :address], visitor.to_enum(@study).map { visitor.attribute }, "Path attributes incorrect")
-  end
-
-  def test_to_enum
-    visitor = CaRuby::ReferencePathVisitorFactory.create(ClinicalTrials::Study, [:enrollment, :address])
-    assert_equal([@study, @pnt, @pnt.address], visitor.to_enum(@study).to_a, "Enumeration incorrect")
-  end
-
-  def test_id_match
-    # set the source ids
-    @study.identifier = 1
-    @event.identifier = 2
-    # make a match target
-    target = CaRuby::CopyVisitor.new { |ref| ref.class.dependent_attributes }.visit(@study)
-    # match the source to the target
-    matcher = CaRuby::MatchVisitor.new { |ref| ref.class.dependent_attributes }
-    matcher.visit(@study, target)
-    expected = {@study => target, @event => target.events.first}
-    # validate the match
-    assert_equal(expected, matcher.matches, "Match incorrect")
-  end
-
-  def test_copy
-    visitor = CaRuby::CopyVisitor.new { |ref| ref.class.dependent_attributes }
-    copy = visitor.visit(@study)
-    assert_not_nil(copy, "Study not copied")
-    assert_not_nil(visitor.visited[@study], "#{@study.qp} copy #{copy.qp} not captured in visited #{visitor.visited.qp}")
-    assert_same(copy, visitor.visited[@study], "#{@study.qp} visited value incorrect")
-    assert_not_same(copy, @study, "#{@study.qp} not copied into #{copy.qp} as new object")
-    assert_equal(@study.name, copy.name, "#{@study.qp} attribute not copied")
-    assert_nil(copy.coordinator, "#{@study.qp} coordinator incorrectly copied into #{copy.qp} as a dependent")
-    assert(!@study.events.empty?, "#{@study.qp} events cleared by copy")
-    assert(!copy.events.empty?, "#{@study.qp} events #{@study.events.qp} not copied into #{copy.qp}")
-    assert_equal(1, copy.events.size, "#{@study.qp} events copy #{copy.qp} size incorrect")
-    assert_not_same(copy.events.first, @study.events.first, "#{@study.qp} event #{@study.events.first} not copied into #{copy.qp} as new object")
-    assert_same(copy, copy.events.first.study, "Dependent owner attribute not set to copied owner #{copy.qp}")
-  end
-
-  def test_merge
-    # make a merge target
-    target = CaRuby::CopyVisitor.new { |ref| ref.class.dependent_attributes }.visit(@study)
-    # set the source ids
-    @study.identifier = 1
-    @event.identifier = 2
-    
-    # merge into the copy
-    merger = CaRuby::MergeVisitor.new { |ref| ref.class.dependent_attributes }
-    merger.visit(@study, target)
-    
-    # validate that the ids are copied
-    assert_equal(@study.identifier, target.identifier, "Merge didn't copy the study identifier")
-    assert_not_nil(target.events.first, "Merge didn't copy #{@study.qp} event #{@event.qp} to #{target.qp}")
-    assert_equal(target.events.first.identifier, @event.identifier, "Merge didn't copy #{@study.qp} event #{@event.qp} event identifier to  #{target.qp}")
-  end
-
-  def test_copy_id_match
-    # set the study id
-    @study.identifier = 1
-    # mutate the references a la caCORE to form reference path @study -> @event -> s2,
-    # where @study.identifier == s2.identifier
-    s2 = @study.copy(:identifier)
-    @event.study = s2
-    s2.events.clear
-    @study.events << @event
-    
-    # copy the mutated source
-    copier = CaRuby::CopyVisitor.new { |ref| ref.class.dependent_attributes }
-    copy = copier.visit(@study)
-    
-    # validate the copy
-    assert_not_nil(copy.events.first, "Merge didn't copy event")
-    assert_same(copy, copy.events.first.study, "Merge didn't match on study id")
-  end
-
-  def test_copy_with_visit_block
-    visitor = CaRuby::CopyVisitor.new { |ref| ref.class.domain_attributes }
-    id = visitor.visit(@study) { |src, tgt| src.identifier }
-    assert_equal(@study.identifier, id, "Visit didn't return block result")
-  end
-
-  def test_copy_revisit_same_object
-    # make a new event in the study, resulting in two paths to the study
-    ClinicalTrials::StudyEvent.new(:study => @study, :calendar_event_point => 2.0)
-    # eliminate extraneous references
-    @study.coordinator = nil
-    @study.enrollment.clear
-    # visit all references, starting at an event, with traversal event -> study -> other event -> study
-    visitor = CaRuby::CopyVisitor.new { |ref| ref.class.domain_attributes }
-    visited = visitor.visit(@event)
-    studies = visitor.visited.select { |ref, copy| ClinicalTrials::Study === ref }
-    assert(!studies.empty?, "No study copied")
-    assert_equal(1, studies.size, "More than one study copied")
-  end
-end

data/test/lib/caruby/import/java_test.rb

@@ -1,80 +0,0 @@
-$:.unshift 'lib'
-$:.unshift '../caruby/lib'
-
-require "test/unit"
-require 'caruby'
-
-class JavaTest < Test::Unit::TestCase
-  def test_ruby_to_java_date_conversion
-    rdt = DateTime.now
-    jdt = Java::JavaUtil::Date.from_ruby_date(rdt)
-    assert(CaRuby::Resource.value_equal?(rdt, jdt.to_ruby_date), 'Ruby->Java->Ruby date conversion not idempotent')
-  end
-
-  def test_java_to_ruby_date_conversion
-    cal = Java::JavaUtil::Calendar.instance
-    verify_java_to_ruby_date_conversion(cal.time)
-    # roll back to a a different DST setting
-    if cal.timeZone.useDaylightTime then
-      verify_java_to_ruby_date_conversion(flip_DST(cal))
-    end
-  end
-  
-  def test_zero_date
-    jdt = Java::JavaUtil::Date.new(0)
-    verify_java_to_ruby_date_conversion(jdt)
-  end
-  
-  def flip_DST(cal)
-    isdt = cal.timeZone.inDaylightTime(cal.time)
-    11.times do
-      cal.roll(Java::JavaUtil::Calendar::MONTH, false)
-      return cal.time if cal.timeZone.inDaylightTime(cal.time) != isdt
-    end
-  end
-
-  def test_to_ruby
-    assert_same(Java::JavaUtil::BitSet, Class.to_ruby(java.util.BitSet.java_class), "Java => Ruby class incorrect")
-  end
-
-  def test_list_delete_if
-    list = Java::JavaUtil::ArrayList.new << 1 << 2
-    assert_same(list, list.delete_if { |n| n == 2 })
-    assert_equal([1], list.to_a, "Java ArrayList delete_if incorrect")
-  end
-
-  def test_set_delete_if
-    list = Java::JavaUtil::HashSet.new << 1 << 2
-    assert_same(list, list.delete_if { |n| n == 2 })
-    assert_equal([1], list.to_a, "Java HashSet delete_if incorrect")
-  end
-
-  def test_list_clear
-    list = Java::JavaUtil::ArrayList.new
-    assert(list.empty?, "Cleared ArrayList not empty")
-    assert_same(list, list.clear, "ArrayList clear result incorrect")
-  end
-
-  def test_set_clear
-    set = Java::JavaUtil::HashSet.new
-    assert(set.empty?, "Cleared HashSet not empty")
-    assert_same(set, set.clear, "HashSet clear result incorrect")
-  end
-
-  def test_set_merge
-    set = Java::JavaUtil::HashSet.new << 1
-    other = Java::JavaUtil::HashSet.new << 2
-    assert_same(set, set.merge(other), "HashSet merge result incorrect")
-    assert(set.include?(2), "HashSet merge not updated")
-    assert_same(set, set.clear, "HashSet clear result incorrect")
-  end
-  
-  private 
-  
-  def verify_java_to_ruby_date_conversion(jdate)
-    rdt = jdate.to_ruby_date
-    actual = Java::JavaUtil::Date.from_ruby_date(rdt)
-    assert_equal(jdate.to_s, actual.to_s, 'Java->Ruby->Java date conversion not idempotent')
-    assert_equal(jdate.to_ruby_date, rdt, 'Java->Ruby date reconversion not equal')
-  end
-end

data/test/lib/caruby/import/mixed_case_test.rb

@@ -1,14 +0,0 @@
-# Add the Java jar file to the Java path.
-require 'test/fixtures/caruby/import/ext/bin/mixed_case.jar'
-
-require 'java'
-require "test/unit"
-
-# Verifies whether JRuby supports a mixed-case package. This can occur in caBIG applications, e.g.
-# the +caTissue+ PSBIN custom dynamic extensions. Work-around is to 
-class MixedCaseTest < Test::Unit::TestCase
-  def test_import
-    assert_raises(NameError, "Mixed-case package not resolved") { Java::mixed.Case.Example }
-    assert_nothing_raised("Mixed-case JRuby module not resolved") { Java::MixedCase::Example }
-  end
-end

data/test/lib/caruby/migration/test_case.rb

@@ -1,102 +0,0 @@
-LOG_FILE = 'test/results/log/migration.log'
-
-require File.join(File.dirname(__FILE__), '..', 'test_case')
-require 'caruby/domain/uniquify'
-require 'caruby/migration/migrator'
-
-module CaRuby
-  module MigrationTestCase
-    include CaRuby::TestCase
-
-    #@param [String] fixtures the fixtures directory
-    def setup(fixtures, database=nil)
-      super(database)
-      @fixtures = fixtures
-      # Clear the uniquifier for this migration.
-      CaRuby::ResourceUniquifier.instance.clear
-    end
-
-    ## MIGRATION TEST UTILITY METHODS ##
-
-    private
-
-    # Runs a migrator on the given input fixture and options.
-    #
-    # @param (see #create_migrator)
-    # @option (see #create_migrator)
-    def migrate_to_database(fixture, opts={}, &verifier)
-      mgtr = create_migrator(fixture, opts)
-      logger.debug { "Migration test migrating #{fixture} fixture..." }
-      mgtr.migrate_to_database(&verifier)
-      logger.debug { "Migration test migrated #{fixture} fixture." }
-    end
-
-    # Creates a new Migrator for the given fixture with the given options.
-    # If a factory block is provided, then that factory is called to make a new
-    # Migrator instance. Otherwise, {CaTissue::Migrator#initialize} makes the instance.
-    #
-    # If there is no :input option, then the migration input is set to the
-    # _fixture_.+csv+ file in the {#initialize} fixtures directory.
-    #
-    # @param [Symbol] fixture the migration test fixture
-    # @param [{Symbol => Object}] opts (see CaTissue::Migrator#initialize)
-    # @option (see CaTissue::Migrator#initialize)
-    # @return [CaTissue::Migrator]
-    # @yield [opts] the optional Migrator factory
-    def create_migrator(fixture, opts={}, &factory)
-      opts[:input] ||= File.join(@fixtures, fixture.to_s + '.csv')
-      block_given? ? yield(opts) : CaRuby::Migrator.new(opts)
-    end
-
-    # Verifies that the given test fixture is successfully migrated.
-    # Each migrated target object is validated using {CaTissue::TestCase#verify_saved}.
-    # In addition, if a verifier block is given to this method, then that block is
-    # called on the target migration object, or nil if no target was migrated.
-    # Supported options are described in {CaTissue::Migrator#migrate}.
-    #
-    # @param (see #verify_target)
-    # @option (see #verify_target)
-    # @yield (see #verify_target)
-    # @yieldparam (see #verify_target)
-    def verify_save(fixture, opts={})
-      logger.debug { "Migrating the #{fixture} test fixture..." }
-      opts[:unique] = true unless opts.has_key?(:unique)
-      migrate_to_database(fixture, opts) do |tgt|
-        verify_saved(tgt)
-        yield tgt if block_given?
-      end
-    end
-
-    # Verifies the given fixture migration.
-    # Each migrated target object is validated using {#validate_target}.
-    # The target is migrated but not stored.
-    #
-    # @param [Symbol] fixture the test fixture to verify
-    # @param [<Symbol>] opts the migration options
-    # @option (see CaTissue::Migrator#migrate)
-    # @yield [target] verifies the given target
-    # @yieldparam [Resource] target the domain object to verify
-    def verify_target(fixture, opts={}, &verifier)
-      opts[:unique] ||= false
-      create_migrator(fixture, opts).migrate { |tgt| validate_target(tgt, &verifier) }
-    end
-
-    # Validates that the given target was successfully migrated.
-    # If a target was migrated, then this method calls {CaTissue::TestCase#verify_defaults}
-    # to confirm that the target can be stored.
-    # In addition, if a block is given to this method then the block is called on the
-    # (possibly nil) migration target.
-    #
-    # @param [Resource] target the domain object to verify
-    # @yield (see #verify_target)
-    # @yieldparam (see #verify_target)
-    def validate_target(target)
-      assert_not_nil(target, "Missing target")
-      logger.debug { "Validating migration target #{target}..." }
-      verify_defaults(target) if target
-      yield target if block_given?
-      logger.debug { "Validated migration target #{target}." }
-      target
-    end
-  end
-end

data/test/lib/caruby/test_case.rb

@@ -1,230 +0,0 @@
-$:.unshift  '../caruby/lib'
-
-# open the logger
-LOG_FILE = 'test/results/log/catissue.log' unless defined?(LOG_FILE)
-require 'caruby/util/log' and
-  CaRuby::Log.instance.open(LOG_FILE, :shift_age => 10, :shift_size => 1048576, :debug => true)
-
-require 'caruby'
-
-module CaRuby
-  module TestCase
-    attr_reader :database
-
-    def setup(database=nil)
-      super()
-      logger.info("Testing #{name}...")
-      @database = database
-    end
-
-    def teardown
-      super
-      @database.close if @database
-      logger.info("Test #{name} completed.")
-    end
-    
-    def defaults
-      @defaults ||= CaTissueTest.defaults.uniquify
-    end
-    
-    # Tests the domain object +add_defaults_local+ method.
-    # Subclasses are responsible for setting every attribute that is a pre-condition for default value initialization.
-    def verify_defaults(subject)
-      subject.add_defaults
-      msg = "#{subject.qp} with default attributes fails validation"
-      assert_nothing_raised(ValidationError, msg) { subject.validate }
-    end
-
-    # Tests saving the subject. Calls {Database::Writer#save} on the subject and verifies that subject and its
-    # references were persisted.
-    #
-    # @param [Resource] subject the object to save
-    def verify_save(subject)
-      logger.debug{ "Verifying #{subject.qp} save with content:\n#{dump(subject)}" }
-      # capture the save operation time
-      @database.clear
-      st = Stopwatch.measure { @database.open { |db| db.save(subject) } }.elapsed
-      # the database execution time
-      dt = @database.execution_time
-      logger.debug { "#{subject.qp} save took #{'%.2f' % st} seconds, of which #{'%.2f' % dt} were database operations." }
-      verify_saved(subject)
-    end
-
-    # Verifies that the given subject and its references were persisted.
-    #
-    # @param [Resource] subject the saved object to verify
-    def verify_saved(subject)
-      logger.debug { "Verifying saved content of #{subject}..." }
-      subject.dependent? ? verify_saved_dependent(subject) : verify_saved_independent(subject)
-      logger.debug { "Verified saved content of #{subject}." }
-    end
-    
-    # Tests a query on the given template.
-    # The block given to this method is called on the query result.
-    def verify_query(template, *path) # :yields: result
-      yield database.query(template, *path)
-    end
-
-    # Returns the Ruby date as determined by setting a Java Date property.
-    def date(year, month, day)
-      jdate = java.util.Calendar.instance
-      jdate.clear
-      jdate.set(year, month - 1, day)
-      jdate.time.to_ruby_date
-    end
-
-    private
-    
-    def dump(obj)
-      @database.lazy_loader.suspend { obj.dump }
-    end
-  
-    # @param (see #mock_storable_template)
-    # @return (see #mock_storable_template)
-    def mock_create_template(obj)
-      mock_storable_template(obj) { |ref| ref.class.creatable_domain_attributes }
-    end
-  
-    # @param (see #mock_storable_template)
-    # @return (see #mock_storable_template)
-    def mock_update_template(obj)
-      mock_storable_template(obj) { |ref| ref.class.updatable_domain_attributes }
-    end
-    
-    # @param [Resource] obj the domain object to "save"
-    # @return [Resource] the template to use in the save operation
-    # @yield [ref] the storable attributes
-    # @yieldparam [Resource] ref the domain object to "save"
-    def mock_storable_template(obj, &selector)
-      # add fake identifiers to prerequisite references
-      obj.class.storable_prerequisite_attributes.each do |attr|
-        obj.send(attr).enumerate { |ref| ref.identifier = 1 }
-      end
-      # the template builder
-      bldr = CaRuby::StoreTemplateBuilder.new(@database, &selector)
-      # the save template
-      bldr.build_template(obj)
-    end
-
-    def verify_saved_dependent(dependent)
-      verify_dependency(dependent)
-      verify_saved_content(dependent)
-    end
-    
-    def verify_dependency(dependent)
-      return if dependent.class.owner_attribute.nil?
-      ownr = dependent.owner
-      assert_not_nil(ownr, "Owner missing for dependent: #{dependent}")
-      attribute = ownr.class.dependent_attribute(dependent.class)
-      assert_not_nil(attribute, "Dependent attribute missing for #{dependent} owner #{ownr}")
-      # a dependent collection reference must be refetched
-      if ownr.class.collection_attribute?(attribute) then
-        verify_saved_dependent_collection_member(dependent, ownr, attribute)
-      else
-        assert_not_nil(dependent.identifier, "Stored dependent #{dependent} identifier is not set")
-      end
-    end
-
-    # Verifies that the given dependent has an identifier and that the given owner dependent attribute value
-    # contains the dependent.
-    #
-    # JRuby Set include? incorrectly returns false in the OHSU PSR samples_test test_save_grade
-    # call to this method. Work around by using Set detect rather than include?.
-    def verify_saved_dependent_collection_member(dependent, owner, attribute)
-      deps = owner.send(attribute)
-      assert(deps.detect { |dep| dep == dependent }, "Owner #{owner.qp} #{attribute} value #{deps.pp_s} does not contain #{dependent}")
-      assert_not_nil(dependent.identifier, "Identifier not set for stored owner #{owner.qp} #{attribute} dependent collection member #{dependent}")
-    end
-
-    # Verifies the subject stored content.
-    def verify_saved_independent(subject)
-      subject_id = subject.identifier
-      assert_not_nil(subject_id, "#{subject.class.qp} identifier not set")
-      verify_saved_content(subject)
-    end
-
-    # Verifies that the given subject matches the database content. Does not verify subject unless it has
-    # a secondary key.
-    def verify_saved_content(subject)
-      attrs = subject.class.secondary_key_attributes
-      return if attrs.empty?
-      rqd = attrs & subject.class.mandatory_attributes
-      missing = rqd.reject { |attr| subject.send(attr) }
-      assert(missing.empty?, "#{subject} is missing values for secondary key attributes #{missing.to_series}")
-      # make a secondary key search template
-      vh = attrs.to_compact_hash do |attr|
-         v = subject.send(attr)
-         Resource === v ? v.copy : v
-      end
-      tmpl = subject.class.new(vh)
-      # find the template in the database
-      logger.debug  { "Verifying #{subject.qp} by finding and comparing template #{tmpl.pp_s}..." }
-      assert_not_nil(tmpl.find, "#{subject} not found in database")
-      # compare the subject to the fetched template
-      verify_that_saved_matches_fetched(subject, tmpl)
-    end
-
-    # Verifies that the given expected domain object has the same content as actual,
-    # and that the dependents match.
-    #
-    # @quirk caTissue caTissue mutilates an unspecified specimen type available quantity, e.g.
-    #   changing a Specimen with specimen type 'Not Specified' from available quantity 1, initial
-    #   quantity 1 to available quantity 0, initial quantity 3 results in available quantity 2
-    #   in database. The update is necessary when creating the Specimen with available quantity 0,
-    #   initial quantity 3 to work around a different caTissue bug. Thus, the bug work-around
-    #   is broken by a different caTissue bug.
-    #
-    # @param [Resource] expected the saved value
-    # @param [Resource] actual the fetched value
-    def verify_that_saved_matches_fetched(expected, actual)
-      expected.class.saved_nondomain_attributes.each do |attr|
-        # TODO - available_quantity broken for spc type Not Specified
-        # compare attributes that are fetched and set on create
-        attr_md = expected.class.attribute_metadata(attr)
-        if verify_saved_attribute?(attr_md) then
-          eval = expected.database.lazy_loader.suspend { expected.send(attr) }
-          next if eval.nil_or_empty?
-          aval = actual.send(attr)
-          if eval.nil? then
-            assert_nil(aval, "#{expected.qp} was saved without a #{attr} value, but was stored in the database with value #{actual.qp}")
-          else
-            assert_not_nil(aval, "#{expected.qp} was saved with #{attr} value #{eval.qp}, but this value was not found in the database.")
-            if attr == :available_quantity and expected.specimen_type == 'Not Specified' and eval != aval then
-              logger.warn("Skipped broken caTissue unspecified specimen type available comparison.")
-            else
-              assert(CaRuby::Resource.value_equal?(eval, aval), "#{expected.qp} was saved with #{attr} value #{eval.qp} that does not match the database value #{aval.qp}")
-            end
-          end
-        end
-      end
-      verify_dependents_match(expected, actual)
-    end
-    
-    # @param [Attribute] attr_md the saved attribute to check
-    # @return whether the attribute is fetched, creatable and not volatile
-    def verify_saved_attribute?(attr_md)
-      attr_md.fetched? and attr_md.creatable? and not attr_md.volatile?
-    end
-
-    # Verifies that each expected dependent matches an actual dependent and has the same content.
-    def verify_dependents_match(expected, actual)
-      expected.class.dependent_attributes.each do |attr|
-        edeps = expected.database.lazy_loader.suspend { expected.send(attr) }
-        next if edeps.nil_or_empty?
-        adeps = actual.send(attr)
-        logger.debug { "Verifying #{expected.qp} dependent #{attr} #{edeps.qp} against #{actual.qp} #{adeps.qp}..." } unless edeps.nil_or_empty?
-        if edeps.collection? then
-          edeps.each do |edep|
-            adep = edep.match_in_owner_scope(adeps)
-            assert_not_nil(adep, "#{expected} #{attr} dependent #{edep} not found in fetched #{adeps.pp_s}")
-            verify_that_saved_matches_fetched(edep, adep)
-          end
-        else
-          edep = edeps; adep = adeps;
-          assert_not_nil(adep, "#{expected} #{attr} dependent #{edep} not found in database")
-          verify_that_saved_matches_fetched(edep, adep)
-        end
-      end
-    end
-  end
-end