ccls-ccls_engine 3.11.0

data/test/unit/ccls/sample_type_test.rb

@@ -0,0 +1,58 @@
+require 'test_helper'
+
+class Ccls::SampleTypeTest < ActiveSupport::TestCase
+
+	assert_should_behave_like_a_hash
+
+	assert_should_create_default_object
+	assert_should_act_as_list( :scope => :parent_id )
+	assert_should_have_many( :samples )
+	assert_should_belong_to( :parent, 
+		:class_name => 'SampleType' )
+	assert_should_have_many( :children,
+		:class_name => 'SampleType',
+		:foreign_key => 'parent_id' )
+	assert_should_not_require_attributes( :position, :parent_id )
+
+	test "should return description as to_s" do
+		object = create_object(:description => "Description")
+		assert_equal object.description,
+			"#{object}"
+	end
+
+	test "explicit Factory sample_type test" do
+		#	creates sample_type and a parent sample_type
+		assert_difference('SampleType.count',2) {	
+			sample_type = Factory(:sample_type)
+			assert_not_nil sample_type.parent
+			assert_match /Key\d*/, sample_type.key
+			assert_match /Desc\d*/, sample_type.description
+			assert sample_type.is_child?
+		}
+	end
+
+	test "explicit Factory sample_type parent test" do
+		assert_difference('SampleType.count',1) {
+			sample_type = Factory(:sample_type_parent)
+			assert_nil sample_type.parent
+			assert_match /Key\d*/, sample_type.key
+			assert_match /Desc\d*/, sample_type.description
+			assert sample_type.is_root?
+		}
+	end
+
+protected
+
+#	The common assertions use create_object, so leave this alone.
+
+	def create_object(options = {})
+#		record = Factory.build(:sample_type,options)
+#	The normal sample_type factory creates a parent 
+#	which seems to cause some testing issues unless
+#	this was expected so ....
+		record = Factory.build(:sample_type_parent,options)
+		record.save
+		record
+	end
+
+end

data/test/unit/ccls/section_test.rb

@@ -0,0 +1,34 @@
+require 'test_helper'
+
+class Ccls::SectionTest < ActiveSupport::TestCase
+
+	assert_should_behave_like_a_hash
+
+	assert_should_create_default_object
+	assert_should_act_as_list
+	assert_should_have_many(:follow_ups)
+	assert_should_not_require_attributes( :position )
+#	assert_should_require_attribute_length( :event_category, :in => 4..250 )
+
+	test "explicit Factory section test" do
+		assert_difference('Section.count',1) {
+			section = Factory(:section)
+			assert_match /Key\d*/, section.key
+			assert_match /Desc\d*/, section.description
+		}
+	end
+
+	test "should return description as to_s" do
+		section = create_section
+		assert_equal section.description, "#{section}"
+	end
+
+#protected
+#
+#	def create_section(options={})
+#		section = Factory.build(:section,options)
+#		section.save
+#		section
+#	end
+
+end

data/test/unit/ccls/state_test.rb

@@ -0,0 +1,31 @@
+require 'test_helper'
+
+class Ccls::StateTest < ActiveSupport::TestCase
+
+	assert_should_create_default_object
+	assert_should_act_as_list
+	assert_should_require_attributes( :code, :name, :fips_state_code, :fips_country_code )
+	assert_should_require_unique_attributes( :code, :name, :fips_state_code )
+	assert_should_not_require_attributes( :position )
+	assert_should_require_attribute_length( :code, :name, 
+		:fips_state_code, :fips_country_code, 
+			:maximum => 250 )
+
+	test "explicit Factory state test" do
+		assert_difference('State.count',1) {
+			state = Factory(:state)
+			assert_match /Code\d*/, state.code
+			assert_match /Name\d*/, state.name
+			assert_not_nil state.fips_state_code
+			assert_equal 'US', state.fips_country_code
+		}
+	end
+
+	test "should return an array of state abbreviations" do
+		abbreviations = State.abbreviations
+		assert_not_nil abbreviations
+		assert abbreviations.is_a?(Array)
+		assert abbreviations.length > 50
+	end
+
+end

data/test/unit/ccls/study_subject_abstracts_test.rb

@@ -0,0 +1,115 @@
+require 'test_helper'
+
+#	This is just a collection of abstract related tests 
+#	for StudySubject separated only for clarity due
+#	to the size of the StudySubjectTest class.
+class Ccls::StudySubjectAbstractsTest < ActiveSupport::TestCase
+
+	assert_should_have_many( :abstracts, :model => 'StudySubject')
+
+	test "should NOT destroy abstracts with study_subject" do
+		assert_difference('StudySubject.count',1) {
+		assert_difference('Abstract.count',1) {
+			@study_subject = Factory(:study_subject)
+			Factory(:abstract, :study_subject => @study_subject)
+		} }
+		assert_difference('StudySubject.count',-1) {
+		assert_difference('Abstract.count',0) {
+			@study_subject.destroy
+		} }
+	end
+
+	test "should raise StudySubject::NotTwoAbstracts with 0 abstracts" <<
+			" on abstracts_the_same?" do
+		study_subject = Factory(:study_subject)
+		assert_equal 0, study_subject.abstracts.length
+		assert_raise(StudySubject::NotTwoAbstracts) {
+			study_subject.abstracts_the_same?
+		}
+	end
+
+	test "should raise StudySubject::NotTwoAbstracts with 1 abstracts" <<
+			" on abstracts_the_same?" do
+		study_subject = Factory(:study_subject)
+		Factory(:abstract, :study_subject => study_subject)
+		study_subject.reload
+		assert_equal 1, study_subject.abstracts.length
+		assert_raise(StudySubject::NotTwoAbstracts) {
+			study_subject.abstracts_the_same?
+		}
+	end
+
+	test "should return true if abstracts are the same on abstracts_the_same?" do
+		study_subject = Factory(:study_subject)
+		Factory(:abstract, :study_subject => study_subject)
+		Factory(:abstract, :study_subject => study_subject)
+		study_subject.reload
+		assert_equal 2, study_subject.abstracts.length
+		assert study_subject.abstracts_the_same?
+	end
+
+	test "should raise StudySubject::NotTwoAbstracts with 3 abstracts" <<
+			" on abstracts_the_same?" do
+		study_subject = Factory(:study_subject)
+		Factory(:abstract, :study_subject => study_subject)
+		Factory(:abstract, :study_subject => study_subject)
+		Factory(:abstract, :study_subject => study_subject)
+		study_subject.reload
+		assert_equal 3, study_subject.abstracts.length
+		assert_raise(StudySubject::NotTwoAbstracts) {
+			study_subject.abstracts_the_same?
+		}
+	end
+
+	test "should raise StudySubject::NotTwoAbstracts with 0 abstracts" <<
+			" on abstract_diffs" do
+		study_subject = Factory(:study_subject)
+		assert_equal 0, study_subject.abstracts.length
+		assert_raise(StudySubject::NotTwoAbstracts) {
+			study_subject.abstract_diffs
+		}
+	end
+
+	test "should raise StudySubject::NotTwoAbstracts with 1 abstracts" <<
+			" on abstract_diffs" do
+		study_subject = Factory(:study_subject)
+		Factory(:abstract, :study_subject => study_subject)
+		study_subject.reload
+		assert_equal 1, study_subject.abstracts.length
+		assert_raise(StudySubject::NotTwoAbstracts) {
+			study_subject.abstract_diffs
+		}
+	end
+
+	test "should return true if abstracts are the same on abstract_diffs" do
+		study_subject = Factory(:study_subject)
+		Factory(:abstract, :study_subject => study_subject)
+		Factory(:abstract, :study_subject => study_subject)
+		study_subject.reload
+		assert_equal 2, study_subject.abstracts.length
+		assert_equal Hash.new, study_subject.abstract_diffs
+		assert       study_subject.abstract_diffs.empty?
+	end
+
+	test "should raise StudySubject::NotTwoAbstracts with 3 abstracts" <<
+			" on abstract_diffs" do
+		study_subject = Factory(:study_subject)
+		Factory(:abstract, :study_subject => study_subject)
+		Factory(:abstract, :study_subject => study_subject)
+		Factory(:abstract, :study_subject => study_subject)
+		study_subject.reload
+		assert_equal 3, study_subject.abstracts.length
+		assert_raise(StudySubject::NotTwoAbstracts) {
+			study_subject.abstract_diffs
+		}
+	end
+
+protected
+
+	def create_object
+		study_subject = Factory.build(:study_subject)
+		study_subject.save
+		study_subject
+	end
+
+end

data/test/unit/ccls/study_subject_addresses_test.rb

@@ -0,0 +1,93 @@
+require 'test_helper'
+
+class Ccls::StudySubjectAddressesTest < ActiveSupport::TestCase
+
+	assert_should_have_many(:addressings, :model => 'StudySubject')
+
+	test "should create study_subject and accept_nested_attributes_for addressings" do
+		assert_difference( 'Address.count', 1) {
+		assert_difference( 'Addressing.count', 1) {
+		assert_difference( "StudySubject.count", 1 ) {
+			study_subject = create_study_subject(
+				:addressings_attributes => [Factory.attributes_for(:addressing,
+					:address_attributes => Factory.attributes_for(:address,
+					:address_type => AddressType['residence'] ) )])
+			assert !study_subject.new_record?, 
+				"#{study_subject.errors.full_messages.to_sentence}"
+		} } }
+	end
+
+	test "should create study_subject and ignore blank address" do
+		assert_difference( 'Address.count', 0) {
+		assert_difference( 'Addressing.count', 0) {
+		assert_difference( "StudySubject.count", 1 ) {
+			study_subject = create_study_subject(
+				:addressings_attributes => [Factory.attributes_for(:addressing,
+					:address_attributes => { :address_type => AddressType['residence'] } )])
+			assert !study_subject.new_record?, 
+				"#{study_subject.errors.full_messages.to_sentence}"
+		} } }
+	end
+
+	test "should create study_subject and require address with flag" do
+		assert_difference( 'Address.count', 0) {
+		assert_difference( 'Addressing.count', 0) {
+		assert_difference( "StudySubject.count", 0 ) {
+			study_subject = create_study_subject(
+				:addressings_attributes => [Factory.attributes_for(:addressing,
+					:address_required   => true,
+					:address_attributes => { :address_type => AddressType['residence'] } )])
+			assert study_subject.errors.on_attr_and_type?('addressings.address.line_1',:blank)
+			assert study_subject.errors.on_attr_and_type?('addressings.address.city',:blank)
+			assert study_subject.errors.on_attr_and_type?('addressings.address.state',:blank)
+			assert study_subject.errors.on_attr_and_type?('addressings.address.zip',:blank)
+		} } }
+	end
+
+	test "should respond to residence_addresses_count" do
+		study_subject = create_study_subject
+		assert study_subject.respond_to?(:residence_addresses_count)
+		assert_equal 0, study_subject.residence_addresses_count
+		study_subject.update_attributes(
+				:addressings_attributes => [Factory.attributes_for(:addressing,
+					:address_attributes => Factory.attributes_for(:address,
+					{ :address_type => AddressType['residence'] } ))])
+		assert_equal 1, study_subject.reload.residence_addresses_count
+		study_subject.update_attributes(
+				:addressings_attributes => [Factory.attributes_for(:addressing,
+					:address_attributes => Factory.attributes_for(:address,
+					{ :address_type => AddressType['residence'] } ))])
+		assert_equal 2, study_subject.reload.residence_addresses_count
+	end
+
+	test "should NOT destroy addressings with study_subject" do
+		assert_difference('StudySubject.count',1) {
+		assert_difference('Addressing.count',1) {
+			@study_subject = Factory(:addressing).study_subject
+		} }
+		assert_difference('StudySubject.count',-1) {
+		assert_difference('Addressing.count',0) {
+			@study_subject.destroy
+		} }
+	end
+
+	test "should NOT destroy addresses with study_subject" do
+		assert_difference('StudySubject.count',1) {
+		assert_difference('Address.count',1) {
+			@study_subject = Factory(:addressing).study_subject
+		} }
+		assert_difference('StudySubject.count',-1) {
+		assert_difference('Address.count',0) {
+			@study_subject.destroy
+		} }
+	end
+
+protected
+
+	def create_object
+		study_subject = Factory.build(:study_subject)
+		study_subject.save
+		study_subject
+	end
+
+end

data/test/unit/ccls/study_subject_duplicates_test.rb

@@ -0,0 +1,407 @@
+require 'test_helper'
+
+#	This is just a collection of duplicate related tests 
+#	for StudySubject separated only for clarity due
+#	to the size of the StudySubjectTest class.
+class Ccls::StudySubjectDuplicatesTest < ActiveSupport::TestCase
+
+	test "should respond to duplicates" do
+		@duplicates = StudySubject.duplicates
+		assert_no_duplicates_found
+	end
+
+	test "create_case_study_subject_for_duplicate_search test" do
+		subject = create_case_study_subject_for_duplicate_search
+		assert_equal subject.sex, 'M'
+		assert_equal subject.subject_type, SubjectType['Case']
+		assert_not_nil subject.dob
+		assert_not_nil subject.patient
+		assert_not_nil subject.admit_date
+		assert_equal 'matchthis', subject.hospital_no
+		assert_nil subject.mother_maiden_name
+	end
+
+	test "should return no subjects as duplicates with no params" do
+		create_case_study_subject_for_duplicate_search
+		@duplicates = StudySubject.duplicates
+		assert_no_duplicates_found
+	end
+
+	test "should return no subjects as duplicates with minimal params" do
+		create_case_study_subject_for_duplicate_search
+		@duplicates = Factory.build(:study_subject).duplicates
+		assert_no_duplicates_found
+	end
+
+#	All subjects:  Have the same birth date (piis.dob) and sex (subject.sex) as the new subject and 
+#			(same mother’s maiden name or existing mother’s maiden name is null)
+
+	test "should return subject as duplicate if has matching " <<
+			"dob and sex and blank mother_maiden_names" do
+		study_subject = create_case_study_subject_for_duplicate_search
+		new_study_subject = new_case_study_subject_for_duplicate_search(
+			:sex => 'M',
+			:dob => study_subject.dob )
+		@duplicates = new_study_subject.duplicates
+		assert_duplicates_found
+	end
+
+	test "should return subject as duplicate if has matching " <<
+			"dob and sex and mother_maiden_name" do
+		study_subject = create_case_study_subject_for_duplicate_search(
+			:mother_maiden_name => 'Smith' )
+		new_study_subject = new_case_study_subject_for_duplicate_search(
+			:sex => 'M', :dob => study_subject.dob, :mother_maiden_name => 'Smith' )
+		@duplicates = new_study_subject.duplicates
+		assert_duplicates_found
+	end
+
+	test "should return subject as duplicate if has matching " <<
+			"dob and sex and existing mother_maiden_name is nil" do
+		study_subject = create_case_study_subject_for_duplicate_search
+		new_study_subject = new_case_study_subject_for_duplicate_search(
+			:sex => 'M', :dob => study_subject.dob, :mother_maiden_name => 'Smith' )
+		@duplicates = new_study_subject.duplicates
+		assert_duplicates_found
+	end
+
+	test "should return subject as duplicate if has matching " <<
+			"dob and sex and existing mother_maiden_name is blank" do
+		study_subject = create_case_study_subject_for_duplicate_search(
+			:mother_maiden_name => '' )
+		new_study_subject = new_case_study_subject_for_duplicate_search(
+			:sex => 'M', :dob => study_subject.dob, :mother_maiden_name => 'Smith' )
+		@duplicates = new_study_subject.duplicates
+		assert_duplicates_found
+	end
+
+	test "should NOT return subject as duplicate if has matching " <<
+			"dob and sex and explicitly excluded" do
+		study_subject = create_case_study_subject_for_duplicate_search
+		new_study_subject = new_case_study_subject_for_duplicate_search(
+			:sex => 'M', :dob => study_subject.dob )
+		@duplicates = new_study_subject.duplicates(:exclude_id => study_subject.id)
+		assert_no_duplicates_found
+	end
+
+	test "should NOT return subject as duplicate if has matching " <<
+			"dob and sex and differing mother_maiden_name" do
+		study_subject = create_case_study_subject_for_duplicate_search(
+			:mother_maiden_name => 'Smith' )
+		new_study_subject = new_case_study_subject_for_duplicate_search(
+			:sex => 'M', :dob => study_subject.dob, :mother_maiden_name => 'Jones' )
+		@duplicates = new_study_subject.duplicates
+		assert_no_duplicates_found
+	end
+
+	test "should NOT return subject as duplicate if just has matching dob" do
+		study_subject = create_case_study_subject_for_duplicate_search
+		new_study_subject = new_case_study_subject_for_duplicate_search(
+			:dob => study_subject.dob )
+		@duplicates = new_study_subject.duplicates
+		assert_no_duplicates_found
+	end
+
+	test "should NOT return subject as duplicate if has matching dob and blank sex" do
+		study_subject = create_case_study_subject_for_duplicate_search
+		new_study_subject = new_case_study_subject_for_duplicate_search(
+			:sex => ' ', :dob => study_subject.dob )
+		@duplicates = new_study_subject.duplicates
+		assert_no_duplicates_found
+	end
+
+	test "should NOT return subject as duplicate if just has matching sex" do
+		study_subject = create_case_study_subject_for_duplicate_search
+		new_study_subject = new_case_study_subject_for_duplicate_search(
+			:sex => study_subject.sex )
+		@duplicates = new_study_subject.duplicates
+		assert_no_duplicates_found
+	end
+
+	test "should NOT return subject as duplicate if just matching sex and blank dob" do
+		study_subject = create_case_study_subject_for_duplicate_search
+		new_study_subject = new_case_study_subject_for_duplicate_search(
+			:sex => study_subject.sex, :dob => ' ' )
+		@duplicates = new_study_subject.duplicates
+		assert_no_duplicates_found
+	end
+
+#	Case subjects: Have the same hospital_no (patient.hospital_no) as the new subject
+#	Only cases have a patient record, so not explicit check for Case is done.
+
+	test "should return subject as duplicate if has matching hospital_no" do
+		study_subject = create_case_study_subject_for_duplicate_search
+		new_study_subject = new_case_study_subject_for_duplicate_search(
+			:patient_attributes => { :hospital_no => study_subject.hospital_no })
+		@duplicates = new_study_subject.duplicates
+		assert_duplicates_found
+	end
+
+	test "should NOT return subject as duplicate if has matching " <<
+			"hospital_no and explicitly excluded" do
+		study_subject = create_case_study_subject_for_duplicate_search
+		new_study_subject = new_case_study_subject_for_duplicate_search(
+			:patient_attributes => { :hospital_no => study_subject.hospital_no })
+		@duplicates = new_study_subject.duplicates(:exclude_id => study_subject.id)
+		assert_no_duplicates_found
+	end
+
+#	Case subjects:  Are admitted the same admit date (patients.admit_date) at the same institution (patients.organization_id)
+#	Only cases have a patient record, so not explicit check for Case is done.
+
+	test "should return subject as duplicate if has matching " <<
+			"admit_date and organization" do
+		study_subject = create_case_study_subject_for_duplicate_search
+		new_study_subject = new_case_study_subject_for_duplicate_search(
+			:patient_attributes => { 
+				:admit_date => study_subject.admit_date,
+				:organization_id => study_subject.organization_id })
+		@duplicates = new_study_subject.duplicates
+		assert_duplicates_found
+	end
+
+	test "should NOT return subject as duplicate if has matching " <<
+			"admit_date and organization and explicitly excluded" do
+		study_subject = create_case_study_subject_for_duplicate_search
+		new_study_subject = new_case_study_subject_for_duplicate_search(
+			:patient_attributes => { 
+				:admit_date => study_subject.admit_date,
+				:organization_id => study_subject.organization_id })
+		@duplicates = new_study_subject.duplicates(:exclude_id => study_subject.id)
+		assert_no_duplicates_found
+	end
+
+	test "should NOT return subject as duplicate if just has matching admit_date" do
+		study_subject = create_case_study_subject_for_duplicate_search
+		new_study_subject = new_case_study_subject_for_duplicate_search(
+			:patient_attributes => { 
+				:admit_date => study_subject.admit_date,
+				:organization_id => '0' })
+		@duplicates = new_study_subject.duplicates
+		assert_no_duplicates_found
+	end
+
+	test "should NOT return subject as duplicate if has matching " <<
+			"admit_date and blank organization_id" do
+		study_subject = create_case_study_subject_for_duplicate_search
+		new_study_subject = new_case_study_subject_for_duplicate_search(
+			:patient_attributes => { 
+				:admit_date => study_subject.admit_date,
+				:organization_id => ' ' })
+		@duplicates = new_study_subject.duplicates
+		assert_no_duplicates_found
+	end
+
+	test "should NOT return subject as duplicate if just has matching organization" do
+		study_subject = create_case_study_subject_for_duplicate_search
+		new_study_subject = new_case_study_subject_for_duplicate_search(
+			:patient_attributes => { 
+				:organization_id => study_subject.organization_id })
+		@duplicates = new_study_subject.duplicates
+		assert_no_duplicates_found
+	end
+
+	test "should NOT return subject as duplicate if has matching " <<
+			"organization and blank admit_date" do
+		study_subject = create_case_study_subject_for_duplicate_search
+		new_study_subject = new_case_study_subject_for_duplicate_search(
+			:patient_attributes => { 
+				:admit_date => ' ',
+				:organization_id => study_subject.organization_id })
+		@duplicates = new_study_subject.duplicates
+		assert_no_duplicates_found
+	end
+
+	test "should create operational event for raf duplicate" do
+		study_subject = create_case_study_subject_for_duplicate_search
+		new_study_subject = new_case_study_subject_for_duplicate_search(
+			:patient_attributes => { :hospital_no => study_subject.hospital_no })
+		@duplicates = new_study_subject.duplicates
+		assert_duplicates_found
+		assert_difference('OperationalEvent.count',1) {
+			study_subject.raf_duplicate_creation_attempted(new_study_subject)
+		}
+	end
+
+#	class level duplicates search tests (used in candidate_control)
+
+	test "class should return subject as duplicate if has matching " <<
+			"admit_date and organization_id" do
+		study_subject = create_case_study_subject_for_duplicate_search
+		@duplicates = StudySubject.duplicates(
+			:admit_date => study_subject.admit_date,
+			:organization_id => study_subject.organization_id)
+		assert_duplicates_found
+	end
+
+	test "class should NOT return subject as duplicate if has matching " <<
+			"admit_date and organization_id if excluded" do
+		study_subject = create_case_study_subject_for_duplicate_search
+		@duplicates = StudySubject.duplicates(
+			:exclude_id => study_subject.id,
+			:admit_date => study_subject.admit_date,
+			:organization_id => study_subject.organization_id)
+		assert_no_duplicates_found
+	end
+
+	test "class should return subject as duplicate if has matching hospital_no" do
+		study_subject = create_case_study_subject_for_duplicate_search
+		@duplicates = StudySubject.duplicates(
+			:hospital_no => study_subject.hospital_no )
+		assert_duplicates_found
+	end
+
+	test "class should NOT return subject as duplicate if has matching " <<
+			"hospital_no if excluded" do
+		study_subject = create_case_study_subject_for_duplicate_search
+		@duplicates = StudySubject.duplicates(
+			:exclude_id => study_subject.id,
+			:hospital_no => study_subject.hospital_no )
+		assert_no_duplicates_found
+	end
+
+	test "class should return subject as duplicate if has matching " <<
+			"sex, dob and mother_maiden_name" do
+		study_subject = create_case_study_subject_for_duplicate_search
+		@duplicates = StudySubject.duplicates(
+			:sex => 'M',
+			:dob => study_subject.dob,
+			:mother_maiden_name => study_subject.mother_maiden_name )
+		assert_duplicates_found
+	end
+
+	test "class should NOT return subject as duplicate if has matching " <<
+			"sex, dob and mother_maiden_name if excluded" do
+		study_subject = create_case_study_subject_for_duplicate_search
+		@duplicates = StudySubject.duplicates(
+			:exclude_id => study_subject.id,
+			:sex => 'M',
+			:dob => study_subject.dob,
+			:mother_maiden_name => study_subject.mother_maiden_name )
+		assert_no_duplicates_found
+	end
+
+	test "class should return subject as duplicate when all of these params " <<
+			"are passed and all match" do
+		study_subject = create_case_study_subject_for_duplicate_search
+		@duplicates = StudySubject.duplicates(
+			:mother_maiden_name => study_subject.mother_maiden_name,
+			:hospital_no => study_subject.hospital_no,
+			:sex => 'M',
+			:dob => study_subject.dob,
+			:admit_date => study_subject.admit_date,
+			:organization_id => study_subject.organization_id)
+		assert_duplicates_found
+	end
+
+	test "class should NOT return subject as duplicate when all of these params " <<
+			"are passed and all match if excluded" do
+		study_subject = create_case_study_subject_for_duplicate_search
+		@duplicates = StudySubject.duplicates(
+			:exclude_id => study_subject.id,
+			:mother_maiden_name => study_subject.mother_maiden_name,
+			:hospital_no => study_subject.hospital_no,
+			:sex => 'M',
+			:dob => study_subject.dob,
+			:admit_date => study_subject.admit_date,
+			:organization_id => study_subject.organization_id)
+		assert_no_duplicates_found
+	end
+
+	test "class should NOT return subject as duplicate when all of these params " <<
+			"are passed and none match" do
+		study_subject = create_case_study_subject_for_duplicate_search
+		@duplicates = StudySubject.duplicates(
+			:mother_maiden_name => 'somethingdifferent',
+			:hospital_no => 'somethingdifferent',
+			:sex => 'F',
+			:dob => Date.today,
+			:admit_date => Date.today,
+			:organization_id => 0 )
+		assert_no_duplicates_found
+	end
+
+	test "class should NOT return subject as duplicate when all of these params " <<
+			"are passed only sex matches" do
+		study_subject = create_case_study_subject_for_duplicate_search
+		@duplicates = StudySubject.duplicates(
+			:mother_maiden_name => 'somethingdifferent',
+			:hospital_no => 'somethingdifferent',
+			:sex => 'M',
+			:dob => Date.today,
+			:admit_date => Date.today,
+			:organization_id => 0 )
+		assert_no_duplicates_found
+	end
+
+	test "class should NOT return subject as duplicate when all of these params " <<
+			"are passed only dob matches" do
+		study_subject = create_case_study_subject_for_duplicate_search
+		@duplicates = StudySubject.duplicates(
+			:mother_maiden_name => 'somethingdifferent',
+			:hospital_no => 'somethingdifferent',
+			:sex => 'F',
+			:dob => study_subject.dob,
+			:admit_date => Date.today,
+			:organization_id => 0 )
+		assert_no_duplicates_found
+	end
+
+	test "class should NOT return subject as duplicate when all of these params " <<
+			"are passed only admit_date matches" do
+		study_subject = create_case_study_subject_for_duplicate_search
+		@duplicates = StudySubject.duplicates(
+			:mother_maiden_name => 'somethingdifferent',
+			:hospital_no => 'somethingdifferent',
+			:sex => 'F',
+			:dob => Date.today,
+			:admit_date => study_subject.admit_date,
+			:organization_id => 0 )
+		assert_no_duplicates_found
+	end
+
+	test "class should NOT return subject as duplicate when all of these params " <<
+			"are passed only organization matches" do
+		study_subject = create_case_study_subject_for_duplicate_search
+		@duplicates = StudySubject.duplicates(
+			:mother_maiden_name => 'somethingdifferent',
+			:hospital_no => 'somethingdifferent',
+			:sex => 'F',
+			:dob => Date.today,
+			:admit_date => Date.today,
+			:organization_id => study_subject.organization_id )
+		assert_no_duplicates_found
+	end
+
+protected
+
+	def assert_no_duplicates_found
+		assert_not_nil @duplicates
+		assert @duplicates.is_a?(Array)
+		assert @duplicates.empty?
+	end
+
+	def assert_duplicates_found
+		assert_not_nil @duplicates
+		assert @duplicates.is_a?(Array)
+		assert !@duplicates.empty?
+	end
+
+	def create_case_study_subject_for_duplicate_search(options={})
+		Factory(:case_study_subject, { :sex => 'M',
+			:dob => Date.yesterday,
+			:patient_attributes => Factory.attributes_for(:patient,
+				:hospital_no => 'matchthis',
+				:admit_date => Date.yesterday ) }.deep_merge(options) )
+	end
+
+	def new_case_study_subject_for_duplicate_search(options={})
+		Factory.build(:case_study_subject, { :sex => 'F',
+			:dob => Date.today,
+			:patient_attributes => Factory.attributes_for(:patient,
+				:hospital_no => 'somethingdifferent',
+#				:organization_id => 0,	#	Why 0? was for just matching admit_date
+				:admit_date => Date.today ) }.deep_merge(options) )
+	end
+
+end