ccls-ccls_engine 3.11.0

data/test/unit/ccls/operational_event_type_test.rb

@@ -0,0 +1,51 @@
+require 'test_helper'
+
+class Ccls::OperationalEventTypeTest < ActiveSupport::TestCase
+
+	assert_should_behave_like_a_hash
+
+	assert_should_create_default_object
+	assert_should_act_as_list
+	assert_should_have_many(:operational_events)
+	assert_should_not_require_attributes( :position )	#, :project_id )
+	assert_should_require_attribute_length( :event_category, :in => 4..250 )
+
+	test "explicit Factory operational_event_type test" do
+		assert_difference('OperationalEventType.count',1) {
+			operational_event_type = Factory(:operational_event_type)
+			assert_match /Key\d*/,  operational_event_type.key
+			assert_match /Desc\d*/, operational_event_type.description
+			assert_match /Cat\d*/,  operational_event_type.event_category
+		}
+	end
+
+#	test "should return event_category as to_s" do
+#		operational_event_type = create_operational_event_type
+#		assert_equal operational_event_type.event_category, "#{operational_event_type}"
+#	end
+
+	test "should return event_category and description as to_s" do
+		operational_event_type = create_operational_event_type
+		assert_equal "#{operational_event_type}",
+			"#{operational_event_type.event_category}:#{operational_event_type.description}"
+	end
+
+	test "categories should return a unique, sorted array of event categories" do
+#["ascertainment", "compensation", "completions", "correspondence", "enrollments", "interviews", "operations", "recruitment", "samples"]
+		categories = OperationalEventType.categories
+		assert categories.is_a?(Array)
+		assert !categories.empty?
+		categories.each do |category|
+			assert category.is_a?(String)
+		end
+	end
+
+#protected
+#
+#	def create_operational_event_type(options={})
+#		operational_event_type = Factory.build(:operational_event_type,options)
+#		operational_event_type.save
+#		operational_event_type
+#	end
+
+end

data/test/unit/ccls/organization_test.rb

@@ -0,0 +1,64 @@
+require 'test_helper'
+
+class Ccls::OrganizationTest < ActiveSupport::TestCase
+
+	assert_should_behave_like_a_hash( :value => :name )
+
+	assert_should_create_default_object
+	assert_should_act_as_list
+	assert_should_not_require_attributes( :position, :person_id )
+	assert_should_belong_to( :person )
+	assert_should_have_many( :patients )
+#	assert_should_have_many( :hospitals )
+	assert_should_have_one(  :hospital )
+
+	assert_should_have_many(:aliquots, 
+		:foreign_key => :owner_id)
+
+	with_options :class_name => 'Transfer' do |o|
+		o.assert_should_have_many(:incoming_transfers, 
+			:foreign_key => :to_organization_id)
+		o.assert_should_have_many(:outgoing_transfers, 
+			:foreign_key => :from_organization_id)
+	end
+
+	test "explicit Factory organization test" do
+		assert_difference('Organization.count',1) {
+			organization = Factory(:organization)
+			assert_match /Key \d*/,  organization.key
+			assert_match /Name \d*/, organization.name
+		}
+	end
+
+	test "new incoming_transfer should have matching organization id" do
+		organization = create_organization
+		transfer = organization.incoming_transfers.build
+		assert_equal organization.id, transfer.to_organization_id
+	end
+
+	test "new outgoing_transfer should have matching organization id" do
+		organization = create_organization
+		transfer = organization.outgoing_transfers.build
+		assert_equal organization.id, transfer.from_organization_id
+	end
+
+#	TODO haven't really implemented organization samples yet
+#	test "should have many samples" do
+#		#	this is unclear in my diagram
+#		pending
+#	end
+
+	test "should return name as to_s" do
+		organization = create_organization
+		assert_equal organization.name, "#{organization}"
+	end
+
+#protected
+#
+#	def create_organization(options={})
+#		organization = Factory.build(:organization,options)
+#		organization.save
+#		organization
+#	end
+
+end

data/test/unit/ccls/patient_test.rb

@@ -0,0 +1,538 @@
+require 'test_helper'
+
+class Ccls::PatientTest < ActiveSupport::TestCase
+
+	[ :was_under_15_at_dx, :was_previously_treated,
+		:was_ca_resident_at_diagnosis ].each do |field|
+
+		#	Making assumption that 12345 will NEVER be a valid value.
+		test "should NOT allow 12345 for #{field}" do
+			patient = Patient.new(field => 12345)
+			patient.valid?
+			assert patient.errors.on_attr_and_type?(field,:inclusion)
+		end
+
+		test "should allow nil for #{field}" do
+			patient = Patient.new(field => nil)
+			assert_nil patient.send(field)
+			patient.valid?
+			assert !patient.errors.on(field)
+		end
+
+		test "should allow all valid YNDK values for #{field}" do
+			patient = Patient.new
+			YNDK.valid_values.each do |value|
+				patient.send("#{field}=", value)
+				patient.valid?
+				assert !patient.errors.on(field)
+			end
+		end
+
+	end
+
+	assert_should_create_default_object
+	assert_should_initially_belong_to :study_subject
+	assert_should_initially_belong_to :organization
+	assert_should_initially_belong_to :diagnosis
+	assert_should_protect( :study_subject_id, :study_subject )
+
+	assert_should_require_attributes(
+		:diagnosis_id,
+		:hospital_no, :organization_id, :admit_date )
+
+	assert_should_not_require_attributes(
+		:other_diagnosis,
+		:diagnosis_date,
+		:raf_zip,
+		:raf_county )
+
+	assert_should_require_attribute_length :hospital_no, :maximum => 25
+	assert_should_require_unique(:hospital_no, :scope => :organization_id)
+	assert_should_require_attribute_length( :raf_zip, :maximum => 10 )
+	assert_requires_complete_date :admit_date
+	assert_requires_complete_date :diagnosis_date
+	assert_requires_complete_date :treatment_began_on
+	assert_requires_past_date :admit_date
+	assert_requires_past_date :diagnosis_date
+	assert_requires_past_date :treatment_began_on
+
+	test "explicit Factory subjectless patient test" do
+		assert_difference('StudySubject.count',0) {
+		assert_difference('Patient.count',1) {
+			patient = Factory(:subjectless_patient)
+			assert_nil patient.study_subject
+			assert_not_nil patient.admit_date
+			assert_not_nil patient.hospital_no
+			assert_not_nil patient.organization_id
+			assert_not_nil patient.diagnosis_id
+		} }
+	end
+
+	test "explicit Factory patient hospital sequence test" do
+		patient = Factory(:patient)		#	'first' hospital
+		(Hospital.count - 1).times {	#	loop over the rest of the hospitals
+			new_patient = Factory(:patient)
+			assert patient.organization_id != new_patient.organization_id
+		}
+		new_patient = Factory(:patient)	#	back to the 'first' hospital
+		assert patient.organization_id == new_patient.organization_id
+	end
+
+	test "explicit Factory patient test" do
+		assert_difference('StudySubject.count',1) {
+		assert_difference('Patient.count',1) {
+			patient = Factory(:patient)
+			assert_not_nil patient.study_subject
+			assert_equal patient.study_subject.subject_type, SubjectType['Case']
+		} }
+	end
+
+	test "explicit Factory waivered patient hospital sequence test" do
+		patient = Factory(:waivered_patient)		#	'first' hospital
+		(Hospital.waivered.count - 1).times {	#	loop over the rest of the hospitals
+			new_patient = Factory(:waivered_patient)
+			assert patient.organization_id != new_patient.organization_id
+		}
+		new_patient = Factory(:waivered_patient)	#	back to the 'first' hospital
+		assert patient.organization_id == new_patient.organization_id
+	end
+
+	test "explicit Factory waivered_patient test" do
+		assert_difference('StudySubject.count',1) {
+		assert_difference('Patient.count',1) {
+			patient = Factory(:waivered_patient)
+			assert_not_nil patient.study_subject
+			assert_equal patient.study_subject.subject_type, SubjectType['Case']
+			assert patient.organization.hospital.has_irb_waiver
+		} }
+	end
+
+	test "explicit Factory nonwaivered patient hospital sequence test" do
+		patient = Factory(:nonwaivered_patient)		#	'first' hospital
+		(Hospital.nonwaivered.count - 1).times {	#	loop over the rest of the hospitals
+			new_patient = Factory(:nonwaivered_patient)
+			assert patient.organization_id != new_patient.organization_id
+		}
+		new_patient = Factory(:nonwaivered_patient)	#	back to the 'first' hospital
+		assert patient.organization_id == new_patient.organization_id
+	end
+
+	test "explicit Factory nonwaivered_patient test" do
+		assert_difference('StudySubject.count',1) {
+		assert_difference('Patient.count',1) {
+			patient = Factory(:nonwaivered_patient)
+			assert_not_nil patient.study_subject
+			assert_equal patient.study_subject.subject_type, SubjectType['Case']
+			assert !patient.organization.hospital.has_irb_waiver
+		} }
+	end
+
+	test "should default was_ca_resident_at_diagnosis to null" do
+		assert_difference( "Patient.count", 1 ) {
+			patient = create_patient
+			assert_nil patient.reload.was_ca_resident_at_diagnosis
+		}
+	end
+
+	test "should default was_previously_treated to null" do
+		assert_difference( "Patient.count", 1 ) {
+			patient = create_patient
+			assert_nil patient.reload.was_previously_treated
+		}
+	end
+
+#	This would have been because there was no dob because
+#	there was no pii.  Not true anymore
+#	test "should default was_under_15_at_dx to null" do
+#		assert_difference( "Patient.count", 1 ) {
+#			patient = create_patient
+#			assert_nil patient.reload.was_under_15_at_dx
+#		}
+#	end
+
+	test "should require Case study_subject" do
+		assert_difference( "StudySubject.count", 1 ) {
+		assert_difference( "Patient.count", 0 ) {
+			patient = create_patient(:study_subject => Factory(:study_subject))
+			assert patient.errors.on(:study_subject)
+		} }
+	end
+
+	test "should require case study_subject when using nested attributes" do
+		assert_difference( "StudySubject.count", 0 ) {
+		assert_difference( "Patient.count", 0 ) {
+			study_subject = create_study_subject(
+				:patient_attributes => Factory.attributes_for(:patient))
+			#	raised from study_subject model, NOT patient
+			assert study_subject.errors.on(:patient)
+		} }
+	end
+
+	test "should allow admit_date be on DOB" do
+		assert_difference( "Patient.count", 1 ) {
+			study_subject = Factory(:case_study_subject)
+			patient = create_patient(
+				:study_subject => study_subject,
+				:admit_date => study_subject.dob )
+			assert !patient.errors.on(:admit_date)
+			assert_equal study_subject.dob, patient.admit_date
+		}
+	end
+
+	test "should require admit_date be after DOB" do
+		assert_difference( "Patient.count", 0 ) {
+			study_subject = Factory(:case_study_subject)
+			assert Date.jd(2430000) < study_subject.dob
+			patient = create_patient(
+				:study_subject => study_subject,
+				:admit_date => Date.jd(2430000) ) 
+				# BEFORE my factory set dob to raise error (Date.jd(2440000+rand(15000))
+			assert patient.errors.on(:admit_date)
+			assert_match(/before.*dob/,
+				patient.errors.on(:admit_date))
+		}
+	end
+
+	test "should NOT require admit_date 1/1/1900 be after DOB" do
+		assert_difference( "Patient.count", 1 ) {
+			study_subject = Factory(:case_study_subject)
+			patient = create_patient(
+				:study_subject => study_subject,
+				:admit_date => Date.parse('1/1/1900') )
+			assert !patient.errors.on(:admit_date)
+		}
+	end
+
+	test "should require admit_date be after DOB when using nested attributes" do
+		assert_difference( "StudySubject.count", 0 ) {
+		assert_difference( "Patient.count", 0 ) {
+			study_subject = create_case_study_subject(
+				:patient_attributes => Factory.attributes_for(:patient,{
+					# BEFORE my factory set dob to raise error (Date.jd(2440000+rand(15000))
+					:admit_date => Date.jd(2430000)
+				}))
+			assert study_subject.errors.on('patient:admit_date')
+			assert_match(/before.*dob/,
+				study_subject.errors.on('patient:admit_date'))
+		} }
+	end
+
+	test "should NOT require admit_date 1/1/1900 be after DOB" <<
+			" when using nested attributes" do
+		assert_difference( "StudySubject.count", 1 ) {
+		assert_difference( "Patient.count", 1 ) {
+			study_subject = create_case_study_subject(
+				:patient_attributes => Factory.attributes_for(:patient,{
+					:admit_date => Date.parse('1/1/1900')
+				}))
+			assert !study_subject.errors.on('patient:admit_date')
+		} }
+	end
+
+
+	test "should allow diagnosis_date be on DOB" do
+		assert_difference( "Patient.count", 1 ) do
+			study_subject = Factory(:case_study_subject)
+			patient = create_patient(
+				:study_subject => study_subject,
+				:diagnosis_date => study_subject.dob )
+			assert !patient.errors.on(:diagnosis_date)
+			assert_equal patient.diagnosis_date, study_subject.dob
+		end
+	end
+
+	test "should require diagnosis_date be after DOB" do
+		assert_difference( "Patient.count", 0 ) do
+			study_subject = Factory(:case_study_subject)
+			assert Date.jd(2430000) < study_subject.dob
+			patient = create_patient(
+				:study_subject => study_subject,
+				:diagnosis_date => Date.jd(2430000) ) 
+				# BEFORE my factory set dob to raise error (Date.jd(2440000+rand(15000))
+			assert patient.errors.on(:diagnosis_date)
+			assert_match(/before.*dob/,
+				patient.errors.on(:diagnosis_date))
+		end
+	end
+
+	test "should require diagnosis_date be after DOB when using nested attributes" do
+		assert_difference( "StudySubject.count", 0 ) {
+		assert_difference( "Patient.count", 0 ) {
+			study_subject = create_case_study_subject(
+				:patient_attributes => Factory.attributes_for(:patient,{
+					# BEFORE my factory set dob to raise error
+					:diagnosis_date => Date.jd(2430000),
+				}))
+			assert study_subject.errors.on('patient:diagnosis_date')
+		} }
+	end
+
+
+	test "should require treatment_began_on be after diagnosis_date" do
+		assert_difference( "Patient.count", 0 ) do
+			study_subject = Factory(:case_study_subject,
+				:dob => Date.jd(2420000) )
+			patient = create_patient(
+				:study_subject => study_subject,
+				:diagnosis_date => Date.jd(2440000),
+				:treatment_began_on => Date.jd(2430000) ) 
+			assert patient.errors.on(:treatment_began_on)
+			assert_match(/Date treatment began must be on or after the diagnosis date/,
+				patient.errors.on(:treatment_began_on))
+		end
+	end
+
+	test "should require treatment_began_on be after diagnosis_date" <<
+			" when using nested attributes" do
+		assert_difference( "StudySubject.count", 0 ) {
+		assert_difference( "Patient.count", 0 ) {
+			study_subject = create_case_study_subject(
+				:dob => Date.jd(2420000),
+				:patient_attributes => Factory.attributes_for(:patient,{
+					:diagnosis_date => Date.jd(2440000),
+					:treatment_began_on => Date.jd(2430000),
+				}))
+			assert study_subject.patient.errors.on(:treatment_began_on)
+			assert study_subject.errors.on('patient.treatment_began_on')
+			assert_match(/Date treatment began must be on or after the diagnosis date/,
+				study_subject.patient.errors.on(:treatment_began_on))
+		} }
+	end
+
+
+	test "should NOT set was_under_15_at_dx with admit_date 1/1/1900" <<
+			" using nested attributes" do
+		assert_difference( "StudySubject.count", 1 ) {
+		assert_difference( "Patient.count", 1 ) {
+			dob        = 10.years.ago.to_date
+			admit_date = Date.parse('1/1/1900')
+			study_subject = create_case_study_subject(
+				:dob => dob,
+				:patient_attributes => Factory.attributes_for(:patient,{
+					:admit_date => admit_date
+				})
+			).reload
+			assert_equal dob,        study_subject.dob
+			assert_equal admit_date, study_subject.patient.admit_date
+			assert_nil study_subject.patient.was_under_15_at_dx
+		} }
+	end
+
+	test "should NOT set was_under_15_at_dx with admit_date 1/1/1900" <<
+			" not using nested attributes" do
+		assert_difference( "StudySubject.count", 1 ) {
+		assert_difference( "Patient.count", 1 ) {
+			dob        = 10.years.ago.to_date
+			admit_date = Date.parse('1/1/1900')
+			study_subject = create_case_study_subject( :dob => dob )
+			patient = Factory(:patient,{
+				:study_subject => study_subject,
+				:admit_date => admit_date
+			})
+			study_subject.reload
+			assert_equal dob,        study_subject.dob
+			assert_equal admit_date, study_subject.patient.admit_date
+			assert_nil study_subject.patient.was_under_15_at_dx
+		} }
+	end
+
+
+	test "should NOT set was_under_15_at_dx with dob 1/1/1900 using nested attributes" do
+		assert_difference( "StudySubject.count", 1 ) {
+		assert_difference( "Patient.count", 1 ) {
+			dob        = Date.parse('1/1/1900')
+			admit_date = 1.year.ago.to_date
+			study_subject = create_case_study_subject(
+				:dob => dob,
+				:patient_attributes => Factory.attributes_for(:patient,{
+					:admit_date => admit_date
+				})
+			).reload
+			assert_equal dob,        study_subject.dob
+			assert_equal admit_date, study_subject.patient.admit_date
+			assert_nil study_subject.patient.was_under_15_at_dx
+		} }
+	end
+
+	test "should NOT set was_under_15_at_dx with dob 1/1/1900 not using nested attributes" do
+		assert_difference( "StudySubject.count", 1 ) {
+		assert_difference( "Patient.count", 1 ) {
+			dob        = Date.parse('1/1/1900')
+			admit_date = 1.year.ago.to_date
+			study_subject = create_case_study_subject( :dob => dob )
+			patient = Factory(:patient,{
+				:study_subject => study_subject,
+				:admit_date => admit_date
+			})
+			study_subject.reload
+			assert_equal dob,        study_subject.dob
+			assert_equal admit_date, study_subject.patient.admit_date
+			assert_nil study_subject.patient.was_under_15_at_dx
+		} }
+	end
+
+
+	test "should set was_under_15_at_dx to YNDK[:yes] using nested attributes" do
+		assert_difference( "StudySubject.count", 1 ) {
+		assert_difference( "Patient.count", 1 ) {
+			dob        = 14.years.ago.to_date
+			admit_date = 1.year.ago.to_date
+			study_subject = create_case_study_subject(
+				:dob => dob,
+				:patient_attributes => Factory.attributes_for(:patient,{
+					:admit_date => admit_date
+				})
+			).reload
+			assert_equal dob,        study_subject.dob
+			assert_equal admit_date, study_subject.patient.admit_date
+			assert_equal YNDK[:yes], study_subject.patient.was_under_15_at_dx
+		} }
+	end
+
+	test "should set was_under_15_at_dx to YNDK[:yes] not using nested attributes" do
+		assert_difference( "StudySubject.count", 1 ) {
+		assert_difference( "Patient.count", 1 ) {
+			dob        = 14.years.ago.to_date
+			admit_date = 1.year.ago.to_date
+			study_subject = create_case_study_subject( :dob => dob )
+			patient = Factory(:patient,{
+				:study_subject => study_subject,
+				:admit_date => admit_date
+			})
+			study_subject.reload
+			assert_equal dob,        study_subject.dob
+			assert_equal admit_date, study_subject.patient.admit_date
+			assert_equal YNDK[:yes], study_subject.patient.was_under_15_at_dx
+		} }
+	end
+
+
+	test "should set was_under_15_at_dx to YNDK[:no] using nested attributes" do
+		assert_difference( "StudySubject.count", 1 ) {
+		assert_difference( "Patient.count", 1 ) {
+			dob        = 20.years.ago.to_date
+			admit_date = 1.year.ago.to_date
+			study_subject = create_case_study_subject(
+				:dob => dob,
+				:patient_attributes => Factory.attributes_for(:patient,{
+					:admit_date => admit_date
+				})
+			).reload
+			assert_equal dob,        study_subject.dob
+			assert_equal admit_date, study_subject.patient.admit_date
+			assert_equal YNDK[:no], study_subject.patient.was_under_15_at_dx
+		} }
+	end
+
+	test "should set was_under_15_at_dx to YNDK[:no] not using nested attributes" do
+		assert_difference( "StudySubject.count", 1 ) {
+		assert_difference( "Patient.count", 1 ) {
+			dob        = 20.years.ago.to_date
+			admit_date = 1.year.ago.to_date
+			study_subject = create_case_study_subject( :dob => dob )
+			#	patient creation MUST come AFTER pii creation
+			patient = Factory(:patient,{
+				:study_subject    => study_subject,
+				:admit_date => admit_date
+			})
+			study_subject.reload
+			assert_equal dob,        study_subject.dob
+			assert_equal admit_date, study_subject.patient.admit_date
+			assert_equal YNDK[:no], study_subject.patient.was_under_15_at_dx
+		} }
+	end
+
+	test "should set was_under_15_at_dx on dob change" do
+		study_subject = create_case_study_subject(
+			:dob => 20.years.ago.to_date,
+			:patient_attributes => Factory.attributes_for(:patient,{
+				:admit_date => 1.year.ago.to_date
+			})
+		).reload
+		assert_equal YNDK[:no], study_subject.patient.was_under_15_at_dx
+		study_subject.update_attributes(:dob => 10.years.ago.to_date)
+		assert_equal YNDK[:yes], study_subject.patient.reload.was_under_15_at_dx
+	end
+
+	test "should set was_under_15_at_dx on admit_date change" do
+		study_subject = create_case_study_subject(
+			:dob => 20.years.ago.to_date,
+			:patient_attributes => Factory.attributes_for(:patient,{
+				:admit_date => 1.year.ago.to_date
+			})
+		).reload
+		assert_equal YNDK[:no], study_subject.patient.was_under_15_at_dx
+		study_subject.patient.update_attributes(:admit_date => 10.years.ago.to_date)
+		assert_equal YNDK[:yes], study_subject.patient.reload.was_under_15_at_dx
+	end
+
+	test "should require 5 or 9 digit raf_zip" do
+		%w( asdf 1234 123456 1234Q ).each do |bad_zip|
+			assert_difference( "Patient.count", 0 ) do
+				patient = create_patient( :raf_zip => bad_zip )
+				assert patient.errors.on(:raf_zip)
+			end
+		end
+		%w( 12345 12345-6789 123456789 ).each do |good_zip|
+			assert_difference( "Patient.count", 1 ) do
+				patient = create_patient( :raf_zip => good_zip )
+				assert !patient.errors.on(:raf_zip)
+				assert patient.raf_zip =~ /\A\d{5}(-)?(\d{4})?\z/
+			end
+		end
+	end
+
+	test "should format 9 digit zip" do
+		assert_difference( "Patient.count", 1 ) do
+			patient = create_patient( :raf_zip => '123456789' )
+			assert !patient.errors.on(:raf_zip)
+			assert patient.raf_zip =~ /\A\d{5}(-)?(\d{4})?\z/
+			assert_equal '12345-6789', patient.raf_zip
+		end
+	end
+
+	test "should require other_diagnosis if diagnosis == other" do
+		assert_difference( "Patient.count", 0 ) do
+			patient = create_patient(:diagnosis => Diagnosis['other'])
+			assert patient.errors.on_attr_and_type?(:other_diagnosis,:blank)
+		end
+	end
+
+	test "should not require other_diagnosis if diagnosis != other" do
+		assert_difference( "Patient.count", 1 ) do
+			patient = create_patient(:diagnosis => Diagnosis['ALL'])
+			assert !patient.errors.on_attr_and_type?(:other_diagnosis,:blank)
+		end
+	end
+
+	test "should require hospital_no with custom message" do
+		assert_difference( "Patient.count", 0 ) do
+			patient = create_patient( :hospital_no => nil )
+			assert patient.errors.on_attr_and_type?(:hospital_no,:blank)
+			assert_match /Hospital record number can't be blank/, 
+				patient.errors.full_messages.to_sentence
+			assert_no_match /Hospital no/i, 
+				patient.errors.full_messages.to_sentence
+		end
+	end
+
+	test "should require organization_id with custom message" do
+		assert_difference( "Patient.count", 0 ) do
+			patient = create_patient( :organization_id => nil )
+			assert patient.errors.on_attr_and_type?(:organization_id,:blank)
+			assert_match /Treating institution can't be blank/, 
+				patient.errors.full_messages.to_sentence
+			assert_no_match /Organization/i, 
+				patient.errors.full_messages.to_sentence
+		end
+	end
+
+#protected
+#
+#	def create_patient(options={})
+#		patient = Factory.build(:patient,options)
+#		patient.save
+#		patient
+#	end
+
+end