ccls-ccls_engine 3.11.0

data/test/unit/ccls/context_data_source_test.rb

@@ -0,0 +1,26 @@
+require 'test_helper'
+
+class Ccls::ContextDataSourceTest < ActiveSupport::TestCase
+
+	assert_should_create_default_object
+	assert_should_initially_belong_to( :context, :data_source )
+
+	test "explicit Factory context_data_source test" do
+		assert_difference('DataSource.count',1) {
+		assert_difference('Context.count',1) {
+		assert_difference('ContextDataSource.count',1) {
+			context_data_source = Factory(:context_data_source)
+			assert_not_nil context_data_source.context
+			assert_not_nil context_data_source.data_source
+		} } }
+	end
+
+protected
+
+#	def create_context_data_source(options={})
+#		context_data_source = Factory.build(:context_data_source,options)
+#		context_data_source.save
+#		context_data_source
+#	end
+
+end

data/test/unit/ccls/context_test.rb

@@ -0,0 +1,40 @@
+require 'test_helper'
+
+class Ccls::ContextTest < ActiveSupport::TestCase
+
+	assert_should_behave_like_a_hash
+
+	assert_should_create_default_object
+	assert_should_not_require_attributes( :position, :notes )
+	assert_should_require_attribute_length( :notes, :maximum => 65000 )
+	assert_should_act_as_list
+	assert_should_have_many(:units)
+
+	test "explicit Factory context test" do
+		assert_difference('Context.count',1) {
+			context = Factory(:context)
+			assert_match /Key\d*/, context.key
+			assert_match /Desc\d*/, context.description
+		}
+	end
+
+	test "should return description as to_s" do
+		context = create_context
+		assert_equal context.description,
+			"#{context}"
+	end
+
+	test "should have many context_data_sources" do
+		context = Context[:addresses]
+		assert !context.context_data_sources.empty?
+		assert_difference('ContextDataSource.count',1) {
+			context.data_sources << Factory(:data_source)
+		}
+	end
+
+	test "should have many data_sources through context_data_sources" do
+		context = Context[:addresses]
+		assert !context.data_sources.empty?
+	end
+
+end

data/test/unit/ccls/core_extension_test.rb

@@ -0,0 +1,17 @@
+require 'test_helper'
+
+class Ccls::CoreExtensionTest < ActiveSupport::TestCase
+
+	test "this class exists" do
+		assert class_exists?('Ccls::CoreExtensionTest')
+	end
+
+	test "non class exists but is not a class" do
+		assert !class_exists?('Ccls::UcbCclsEngineHelper')
+	end
+
+	test "bogus class does not exist" do
+		assert !class_exists?('SomeBogusClass')
+	end
+
+end

data/test/unit/ccls/county_test.rb

@@ -0,0 +1,34 @@
+require 'test_helper'
+
+class Ccls::CountyTest < ActiveSupport::TestCase
+
+	assert_should_create_default_object
+	assert_should_have_many(:zip_codes)
+	assert_should_require( :name, :state_abbrev )
+	assert_should_not_require( :fips_code )
+	assert_should_require_length( :name, :maximum => 250 )
+	assert_should_require_length( :state_abbrev, :maximum => 2 )
+	assert_should_require_length( :fips_code, :maximum => 5 )
+
+	test "explicit Factory county test" do
+		assert_difference('County.count',1) {
+			county = Factory(:county)
+			assert_match /Name \d*/, county.name
+			assert_equal 'XX', county.state_abbrev
+		}
+	end
+
+	test "should return name and state as to_s" do
+		county = create_county
+		assert_equal "#{county.name}, #{county.state_abbrev}", "#{county}"
+	end
+
+#protected
+#
+#	def create_county(options={})
+#		county = Factory.build(:county,options)
+#		county.save
+#		county
+#	end
+
+end

data/test/unit/ccls/data_source_test.rb

@@ -0,0 +1,41 @@
+require 'test_helper'
+
+class Ccls::DataSourceTest < ActiveSupport::TestCase
+
+	assert_should_behave_like_a_hash
+
+	assert_should_create_default_object
+	assert_should_act_as_list
+	assert_should_not_require_attributes( 
+		:position, 
+		:organization_id, 
+		:other_organization, 
+		:person_id, 
+		:other_person, 
+		:data_origin )
+	assert_should_require_attribute_length( 
+		:other_organization, 
+		:other_person, 
+		:data_origin, 
+			:maximum => 250 )
+
+	test "explicit Factory data_source test" do
+		assert_difference('DataSource.count',1) {
+			data_source = Factory(:data_source)
+			assert_match /Key\d*/, data_source.key
+			assert_match /Desc\d*/, data_source.description
+		}
+	end
+
+	test "should return description as to_s" do
+		data_source = create_data_source
+		assert_equal data_source.description,
+			"#{data_source}"
+	end
+
+	test "should return true for is_other if is other" do
+		data_source = DataSource['Other']
+		assert data_source.is_other?
+	end
+
+end

data/test/unit/ccls/diagnosis_test.rb

@@ -0,0 +1,51 @@
+require 'test_helper'
+
+class Ccls::DiagnosisTest < ActiveSupport::TestCase
+
+	assert_should_behave_like_a_hash
+
+	assert_should_create_default_object
+	assert_should_require_attributes( :code )
+	assert_should_require_unique_attributes( :code )
+	assert_should_not_require_attributes(:position)
+	assert_should_act_as_list
+	#	NOTE	code is an integer for diagnosis (so key is used)
+
+	test "explicit Factory diagnosis test" do
+		assert_difference('Diagnosis.count',1) {
+			diagnosis = Factory(:diagnosis)
+			assert_match /key\d*/,  diagnosis.key
+			assert_match /\d*/,     diagnosis.code.to_s
+			assert_match /Desc\d*/, diagnosis.description
+		}
+	end
+
+	test "should return description as to_s" do
+		diagnosis = create_diagnosis
+		assert_equal diagnosis.description, "#{diagnosis}"
+	end
+
+	test "Diagnosis['other'] should return true for is_other?" do
+		diagnosis = Diagnosis['other']
+		assert diagnosis.is_other?
+	end
+
+	test "Diagnosis['ALL'] should return false for is_other?" do
+		diagnosis = Diagnosis['ALL']
+		assert !diagnosis.is_other?
+	end
+
+	test "Diagnosis['AML'] should return false for is_other?" do
+		diagnosis = Diagnosis['AML']
+		assert !diagnosis.is_other?
+	end
+
+#protected
+#
+#	def create_diagnosis(options={})
+#		diagnosis = Factory.build(:diagnosis,options)
+#		diagnosis.save
+#		diagnosis
+#	end
+
+end

data/test/unit/ccls/document_type_test.rb

@@ -0,0 +1,35 @@
+require 'test_helper'
+
+class Ccls::DocumentTypeTest < ActiveSupport::TestCase
+
+	assert_should_create_default_object
+	assert_should_act_as_list
+	assert_should_have_many(:document_versions)
+	assert_should_require_attributes( :title )
+	assert_should_not_require_attributes( :position, :description )
+	assert_should_require_attribute_length( 
+		:title, 
+		:description, 
+			:maximum => 250 )
+
+	test "explicit Factory document_type test" do
+		assert_difference('DocumentType.count',1) {
+			document_type = Factory(:document_type)
+			assert_match /Title\d*/,  document_type.title
+		}
+	end
+
+	test "should return title as to_s" do
+		document_type = create_document_type
+		assert_equal document_type.title, "#{document_type}"
+	end
+
+#protected
+#
+#	def create_document_type(options={})
+#		document_type = Factory.build(:document_type,options)
+#		document_type.save
+#		document_type
+#	end
+
+end

data/test/unit/ccls/document_version_test.rb

@@ -0,0 +1,68 @@
+require 'test_helper'
+
+class Ccls::DocumentVersionTest < ActiveSupport::TestCase
+
+	assert_should_create_default_object
+	assert_should_act_as_list
+	assert_should_initially_belong_to(:document_type)
+	assert_should_belong_to( :language )
+	assert_should_not_require_attributes( :position, :title, :description, :indicator,
+		:language_id, :began_use_on, :ended_use_on )
+	assert_should_require_attribute_length( :title, :description, :indicator,
+		:maximum => 250 )
+	assert_requires_complete_date( :began_use_on, :ended_use_on )
+
+	test "explicit Factory document_version test" do
+		assert_difference('DocumentType.count',1) {
+		assert_difference('DocumentVersion.count',1) {
+			document_version = Factory(:document_version)
+			assert_match /Title\d*/,  document_version.title
+			assert_not_nil document_version.document_type
+		} }
+	end
+
+	test "should require document_type" do
+		assert_difference( "DocumentVersion.count", 0 ) do
+			document_version = create_document_version( :document_type => nil)
+			assert !document_version.errors.on(:document_type)
+			assert  document_version.errors.on_attr_and_type?(:document_type_id, :blank)
+		end
+	end
+
+	test "should require valid document_type" do
+		assert_difference( "DocumentVersion.count", 0 ) do
+			document_version = create_document_version( :document_type_id => 0)
+			assert !document_version.errors.on(:document_type_id)
+			assert  document_version.errors.on_attr_and_type?(:document_type,:blank)
+		end
+	end
+
+	test "should only return document type id == 1 for type1" do
+		objects = DocumentVersion.type1
+		assert_not_nil objects
+		objects.each do |o|
+			assert_equal 1, o.document_type_id
+		end
+	end
+
+	test "should return title as to_s" do
+		document_version = create_document_version
+		assert_equal document_version.title, "#{document_version}"
+	end
+
+	test "should have many consented enrollments" do
+		document_version = create_document_version
+		assert_equal 0, document_version.enrollments.length
+		document_version.enrollments << Factory(:consented_enrollment)
+		assert_equal 1, document_version.reload.enrollments.length
+	end
+
+#protected
+#
+#	def create_document_version(options={})
+#		document_version = Factory.build(:document_version,options)
+#		document_version.save
+#		document_version
+#	end
+
+end

data/test/unit/ccls/enrollment_test.rb

@@ -0,0 +1,575 @@
+require 'test_helper'
+
+class Ccls::EnrollmentTest < ActiveSupport::TestCase
+
+	[ :use_smp_future_rsrch,
+		:use_smp_future_cancer_rsrch, :use_smp_future_other_rsrch,
+		:share_smp_with_others, :contact_for_related_study,
+		:provide_saliva_smp, :receive_study_findings ].each do |field|
+
+		#	Making assumption that 12345 will NEVER be a valid value.
+		test "should NOT allow 12345 for #{field}" do
+			enrollment = Enrollment.new(field => 12345)
+			enrollment.valid?
+			assert enrollment.errors.on_attr_and_type?(field,:inclusion)
+		end
+
+		test "should allow nil for #{field}" do
+			enrollment = Enrollment.new(field => nil)
+			assert_nil enrollment.send(field)
+			enrollment.valid?
+			assert !enrollment.errors.on(field)
+		end
+
+		test "should allow all valid ADNA values for #{field}" do
+			enrollment = Enrollment.new
+			ADNA.valid_values.each do |value|
+				enrollment.send("#{field}=", value)
+				enrollment.valid?
+				assert !enrollment.errors.on(field)
+			end
+		end
+
+	end
+
+	[ :consented, :is_eligible,
+		:is_chosen, :is_complete, :terminated_participation,
+		:is_candidate ].each do |field|
+
+		#	Making assumption that 12345 will NEVER be a valid value.
+		test "should NOT allow 12345 for #{field}" do
+			enrollment = Enrollment.new(field => 12345)
+			enrollment.valid?
+			assert enrollment.errors.on_attr_and_type?(field,:inclusion)
+		end
+
+		test "should allow nil for #{field}" do
+			enrollment = Enrollment.new(field => nil)
+			assert_nil enrollment.send(field)
+			enrollment.valid?
+			assert !enrollment.errors.on(field)
+		end
+
+		test "should allow all valid YNDK values for #{field}" do
+			enrollment = Enrollment.new
+			YNDK.valid_values.each do |value|
+				enrollment.send("#{field}=", value)
+				enrollment.valid?
+				assert !enrollment.errors.on(field)
+			end
+		end
+
+	end
+
+
+
+	assert_should_create_default_object
+	assert_should_protect(:study_subject_id, :study_subject)
+	assert_should_not_require_attributes( 
+		:refused_by_physician,
+		:refused_by_family,
+		:use_smp_future_rsrch,
+		:use_smp_future_cancer_rsrch,
+		:use_smp_future_other_rsrch,
+		:share_smp_with_others,
+		:contact_for_related_study,
+		:provide_saliva_smp,
+		:receive_study_findings,
+		:position,
+		:recruitment_priority,
+#		:able_to_locate,
+		:is_candidate,
+		:is_eligible,
+		:ineligible_reason_id,
+		:ineligible_reason_specify,
+		:refusal_reason_id,
+		:other_refusal_reason,
+		:is_chosen,
+		:reason_not_chosen,
+		:terminated_participation,
+		:terminated_reason,
+		:is_complete,
+		:completed_on,
+		:is_closed,
+		:reason_closed,
+		:notes,
+		:document_version_id )
+	assert_should_require_attribute_length( 
+		:recruitment_priority,
+		:ineligible_reason_specify,
+		:other_refusal_reason,
+		:reason_not_chosen,
+		:terminated_reason,
+		:reason_closed, 
+			:maximum => 250 )
+
+	assert_should_have_many(:follow_ups)
+	assert_should_have_many(:operational_events)
+	assert_should_belong_to( 
+		:tracing_status,
+		:project_outcome,
+		:ineligible_reason,
+		:refusal_reason,
+		:document_version )
+	assert_should_require_attribute_length( :notes, :maximum => 65000 )
+
+#	using subjectless_enrollment so, this isn't true
+#	assert_should_initially_belong_to(:study_subject, :project)
+	assert_should_belong_to(:study_subject)
+
+	assert_should_initially_belong_to(:project)
+	assert_requires_complete_date(:completed_on, :consented_on)
+	assert_requires_past_date(    :completed_on, :consented_on)
+
+	test "explicit Factory enrollment test" do
+		assert_difference('Project.count',1) {
+		assert_difference('StudySubject.count',1) {
+		assert_difference('Enrollment.count',2) {	#	this enrollment AND the subject's ccls enrollment
+			enrollment = Factory(:enrollment)
+			assert !enrollment.consented
+			assert_not_nil enrollment.project
+			assert_not_nil enrollment.study_subject
+		} } }
+	end
+
+	test "explicit Factory subjectless_enrollment test" do
+		assert_difference('Project.count',1) {
+		assert_difference('StudySubject.count',0) {
+		assert_difference('Enrollment.count',1) {
+			enrollment = Factory(:subjectless_enrollment)
+			assert !enrollment.consented
+			assert_not_nil enrollment.project
+			assert_nil     enrollment.study_subject
+		} } }
+	end
+
+	test "explicit Factory consented_enrollment test" do
+		assert_difference('Project.count',1) {
+		assert_difference('StudySubject.count',1) {
+		assert_difference('Enrollment.count',2) {	#	this enrollment AND the subject's ccls enrollment
+			enrollment = Factory(:consented_enrollment)
+			assert enrollment.consented
+			assert_equal enrollment.consented, YNDK[:yes]
+			assert_not_nil enrollment.project
+			assert_not_nil enrollment.study_subject
+		} } }
+	end
+
+	test "explicit Factory declined_enrollment test" do
+		assert_difference('Project.count',1) {
+		assert_difference('StudySubject.count',1) {
+		assert_difference('Enrollment.count',2) {	#	this enrollment AND the subject's ccls enrollment
+			enrollment = Factory(:declined_enrollment)
+			assert enrollment.consented
+			assert_equal enrollment.consented, YNDK[:no]
+			assert_not_nil enrollment.project
+			assert_not_nil enrollment.study_subject
+		} } }
+	end
+
+	test "should require project" do
+		assert_difference( "Enrollment.count", 0 ) do
+			enrollment = create_subjectless_enrollment( :project => nil)
+			assert !enrollment.errors.on(:project)
+			assert  enrollment.errors.on_attr_and_type?(:project_id,:blank)
+		end
+	end
+
+	test "should require valid project" do
+		assert_difference( "Enrollment.count", 0 ) do
+			enrollment = create_subjectless_enrollment( :project_id => 0)
+			assert !enrollment.errors.on(:project_id)
+			assert  enrollment.errors.on_attr_and_type?(:project,:blank)
+		end
+	end
+
+	test "should require unique project_id scope study_subject_id" do
+		o = create_enrollment
+		assert_no_difference "Enrollment.count" do
+			enrollment = create_enrollment(:project => o.project,
+				:study_subject => o.study_subject)
+			assert enrollment.errors.on_attr_and_type?(:project_id, :taken)
+		end
+	end
+
+#	test "should require completed_on be in the past" do
+#		assert_difference( "Enrollment.count", 0 ) do
+#			enrollment = create_enrollment(
+#				:is_complete  => YNDK[:yes],
+#				:completed_on => Date.tomorrow )
+#			#	sometimes this fails during test:coverage?
+#			assert enrollment.errors.on(:completed_on)
+#			assert_match(/future/,
+#				enrollment.errors.on(:completed_on))
+#		end
+#	end
+
+	test "should require ineligible_reason if is_eligible == :no" do
+		assert_difference( "Enrollment.count", 0 ) do
+			enrollment = create_subjectless_enrollment(:is_eligible => YNDK[:no])
+			assert !enrollment.errors.on(:ineligible_reason)
+			assert  enrollment.errors.on_attr_and_type?(:ineligible_reason_id,:blank)
+		end
+	end
+	test "should require valid ineligible_reason if is_eligible == :no" do
+		assert_difference( "Enrollment.count", 0 ) do
+			enrollment = create_subjectless_enrollment(:is_eligible => YNDK[:no],
+				:ineligible_reason_id => 0)
+			assert !enrollment.errors.on(:ineligible_reason_id)
+			assert  enrollment.errors.on_attr_and_type?(:ineligible_reason,:blank)
+		end
+	end
+	[:yes,:dk,:nil].each do |yndk|
+		test "should NOT ALLOW ineligible_reason if is_eligible == #{yndk}" do
+			assert_difference( "Enrollment.count", 0 ) do
+				enrollment = create_subjectless_enrollment(:is_eligible => YNDK[yndk],
+					:ineligible_reason => Factory(:ineligible_reason) )
+				assert !enrollment.errors.on(:ineligible_reason)
+				assert  enrollment.errors.on_attr_and_type?(:ineligible_reason_id,:present)
+			end
+		end
+	end
+
+	test "should require ineligible_reason_specify if " <<
+			"ineligible_reason == other" do
+		assert_difference( "Enrollment.count", 0 ) do
+			enrollment = create_subjectless_enrollment(
+				:is_eligible => YNDK[:no],
+				:ineligible_reason => IneligibleReason['other'] )
+			assert enrollment.errors.on(:ineligible_reason_specify)
+			assert enrollment.errors.on_attr_and_type?(:ineligible_reason_specify,:blank)
+		end
+	end
+	test "should ALLOW ineligible_reason_specify if " <<
+			"ineligible_reason != other" do
+		assert_difference( "Enrollment.count", 1 ) do
+			enrollment = create_subjectless_enrollment(
+				:is_eligible => YNDK[:no],
+				:ineligible_reason => Factory(:ineligible_reason),
+				:ineligible_reason_specify => 'blah blah blah' )
+			assert !enrollment.errors.on(:ineligible_reason_specify)
+		end
+	end
+	[:yes,:dk,:nil].each do |yndk|
+		test "should NOT ALLOW ineligible_reason_specify if " <<
+				"is_eligible == #{yndk}" do
+			assert_difference( "Enrollment.count", 0 ) do
+				enrollment = create_subjectless_enrollment(
+					:is_eligible => YNDK[yndk],
+					:ineligible_reason => Factory(:ineligible_reason),
+					:ineligible_reason_specify => 'blah blah blah' )
+				assert enrollment.errors.on(:ineligible_reason_specify)
+				assert enrollment.errors.on_attr_and_type?(:ineligible_reason_specify,:present)
+			end
+		end
+	end
+
+
+	test "should require reason_not_chosen if is_chosen == :no" do
+		assert_difference( "Enrollment.count", 0 ) do
+			enrollment = create_subjectless_enrollment(:is_chosen => YNDK[:no])
+			assert enrollment.errors.on(:reason_not_chosen)
+			assert enrollment.errors.on_attr_and_type?(:reason_not_chosen,:blank)
+		end
+	end
+	[:yes,:dk,:nil].each do |yndk|
+		test "should NOT ALLOW reason_not_chosen if is_chosen == #{yndk}" do
+			assert_difference( "Enrollment.count", 0 ) do
+				enrollment = create_subjectless_enrollment(:is_chosen => YNDK[yndk],
+					:reason_not_chosen => "blah blah blah")
+				assert enrollment.errors.on(:reason_not_chosen)
+				assert enrollment.errors.on_attr_and_type?(:reason_not_chosen,:present)
+			end
+		end
+	end
+
+
+	test "should require refusal_reason if consented == :no" do
+		assert_difference( "Enrollment.count", 0 ) do
+			enrollment = create_subjectless_enrollment(:consented => YNDK[:no])
+			assert !enrollment.errors.on(:refusal_reason)
+			assert  enrollment.errors.on_attr_and_type?(:refusal_reason_id,:blank)
+		end
+	end
+	test "should require valid refusal_reason if consented == :no" do
+		assert_difference( "Enrollment.count", 0 ) do
+			enrollment = create_subjectless_enrollment(:consented => YNDK[:no],
+				:refusal_reason_id => 0)
+			assert !enrollment.errors.on(:refusal_reason_id)
+			assert  enrollment.errors.on_attr_and_type?(:refusal_reason,:blank)
+		end
+	end
+	[:yes,:dk,:nil].each do |yndk|
+		test "should NOT ALLOW refusal_reason if consented == #{yndk}" do
+			assert_difference( "Enrollment.count", 0 ) do
+				enrollment = create_subjectless_enrollment(:consented => YNDK[yndk],
+					:refusal_reason => Factory(:refusal_reason))
+				assert !enrollment.errors.on(:refusal_reason)
+				assert  enrollment.errors.on_attr_and_type?(:refusal_reason_id,:present)
+			end
+		end
+	end
+
+	test "should require other_refusal_reason if " <<
+			"refusal_reason == other" do
+		assert_difference( "Enrollment.count", 0 ) do
+			enrollment = create_subjectless_enrollment(:consented => YNDK[:no],
+				:refusal_reason => RefusalReason['other'] )
+			assert enrollment.errors.on(:other_refusal_reason)
+			assert enrollment.errors.on_attr_and_type?(:other_refusal_reason,:blank)
+		end
+	end
+	test "should ALLOW other_refusal_reason if " <<
+			"refusal_reason != other" do
+		assert_difference( "Enrollment.count", 1 ) do
+			enrollment = create_subjectless_enrollment(:consented => YNDK[:no],
+				:consented_on => Date.today,
+				:refusal_reason => Factory(:refusal_reason),
+				:other_refusal_reason => 'asdfasdf' )
+			assert !enrollment.errors.on(:other_refusal_reason)
+		end
+	end
+	[:yes,:dk,:nil].each do |yndk|
+		test "should NOT ALLOW other_refusal_reason if "<<
+				"consented == #{yndk}" do
+			assert_difference( "Enrollment.count", 0 ) do
+				enrollment = create_subjectless_enrollment(:consented => YNDK[yndk],
+					:refusal_reason => Factory(:refusal_reason),
+					:other_refusal_reason => 'asdfasdf' )
+				assert enrollment.errors.on(:other_refusal_reason)
+				assert enrollment.errors.on_attr_and_type?(:other_refusal_reason,:present)
+			end
+		end
+	end
+
+
+	[:yes,:no].each do |yndk|
+		test "should require consented_on if consented == #{yndk}" do
+			assert_difference( "Enrollment.count", 0 ) do
+				enrollment = create_subjectless_enrollment(:consented => YNDK[yndk],
+					:consented_on => nil)
+				assert enrollment.errors.on_attr_and_type?(:consented_on,:blank)
+			end
+		end
+	end
+	[:dk,:nil].each do |yndk|
+		test "should NOT ALLOW consented_on if consented == #{yndk}" do
+			assert_difference( "Enrollment.count", 0 ) do
+				enrollment = create_subjectless_enrollment(:consented => YNDK[yndk],
+					:consented_on => Date.today)
+				assert enrollment.errors.on(:consented_on)
+				assert enrollment.errors.on_attr_and_type?(:consented_on,:present)
+			end
+		end
+	end
+
+
+	test "should require terminated_reason if " <<
+			"terminated_participation == :yes" do
+		assert_difference( "Enrollment.count", 0 ) do
+			enrollment = create_subjectless_enrollment(:terminated_participation => YNDK[:yes])
+			assert enrollment.errors.on(:terminated_reason)
+			assert enrollment.errors.on_attr_and_type?(:terminated_reason,:blank)
+		end
+	end
+	[:no,:dk,:nil].each do |yndk|
+		test "should NOT ALLOW terminated_reason if " <<
+				"terminated_participation == #{yndk}" do
+			assert_difference( "Enrollment.count", 0 ) do
+				enrollment = create_subjectless_enrollment(
+					:terminated_participation => YNDK[yndk],
+					:terminated_reason => 'some bogus reason')
+				assert enrollment.errors.on(:terminated_reason)
+				assert enrollment.errors.on_attr_and_type?(:terminated_reason,:present)
+			end
+		end
+	end
+
+
+	test "should require completed_on if is_complete == :yes" do
+		assert_difference( "Enrollment.count", 0 ) do
+			enrollment = create_subjectless_enrollment(:is_complete => YNDK[:yes])
+			assert enrollment.errors.on(:completed_on)
+			assert enrollment.errors.on_attr_and_type?(:completed_on,:blank)
+		end
+	end
+	[:no,:dk,:nil].each do |yndk|
+		test "should NOT ALLOW completed_on if is_complete == #{yndk}" do
+			assert_difference( "Enrollment.count", 0 ) do
+				enrollment = create_subjectless_enrollment(:is_complete => YNDK[yndk],
+					:completed_on => Date.today)
+				assert enrollment.errors.on(:completed_on)
+				assert enrollment.errors.on_attr_and_type?(:completed_on,:present)
+			end
+		end
+	end
+
+
+	[:dk,:nil].each do |yndk|
+		test "should NOT ALLOW document_version_id if consented == #{yndk}" do
+			assert_difference( "Enrollment.count", 0 ) do
+				enrollment = create_subjectless_enrollment(:consented => YNDK[yndk],
+					:document_version => Factory(:document_version) )
+				assert !enrollment.errors.on(:document_version)
+				assert  enrollment.errors.on_attr_and_type?(:document_version_id,:present)
+			end
+		end
+	end
+	test "should allow document_version_id if consented == :yes" do
+		assert_difference( "Enrollment.count", 1 ) do
+			enrollment = create_subjectless_enrollment(:consented => YNDK[:yes],
+				:consented_on     => Date.today,
+				:document_version => Factory(:document_version) )
+		end
+	end
+	test "should allow document_version_id if consented == :no" do
+		assert_difference( "Enrollment.count", 1 ) do
+			enrollment = create_subjectless_enrollment(:consented => YNDK[:no],
+				:consented_on     => Date.today,
+				:refusal_reason   => Factory(:refusal_reason),
+				:document_version => Factory(:document_version) )
+		end
+	end
+	test "should require valid document_version if given" do
+		assert_difference( "Enrollment.count", 0 ) do
+			enrollment = create_subjectless_enrollment(:consented => YNDK[:yes],
+				:consented_on     => Date.today,
+				:document_version_id => 0 )
+			assert !enrollment.errors.on(:document_version_id)
+			assert  enrollment.errors.on_attr_and_type?(:document_version,:blank)
+		end
+	end
+
+
+	test "should create operational event when enrollment complete" do
+		enrollment = create_subjectless_enrollment(
+			:completed_on => nil,
+			:is_complete => YNDK[:no])
+		#	arbitrary past date
+		past_date = Date.parse('Jan 15 2003')
+		assert_difference('OperationalEvent.count',1) do
+			enrollment.update_attributes(
+				:completed_on => past_date,
+				:is_complete => YNDK[:yes])
+		end
+		oe = enrollment.operational_events.find(:last,:order => 'id ASC')
+		assert_equal 'complete', oe.operational_event_type.key
+		assert_equal past_date,  oe.occurred_on
+		assert_equal enrollment.study_subject_id, oe.enrollment.study_subject_id
+	end
+
+	test "should create operational event when enrollment complete UNSET" do
+		#	arbitrary past date
+		past_date = Date.parse('Jan 15 2003')
+		enrollment = nil
+		assert_difference('OperationalEvent.count',1) do
+			enrollment = create_subjectless_enrollment(
+				:completed_on => past_date,
+				:is_complete => YNDK[:yes])
+		end
+		oe = enrollment.operational_events.find(:last,:order => 'id ASC')
+		assert_equal 'complete', oe.operational_event_type.key
+		assert_difference('OperationalEvent.count',1) do
+			enrollment.update_attributes(
+				:is_complete => YNDK[:no],
+				:completed_on => nil)
+		end
+		oe = enrollment.operational_events.find(:last,:order => 'id ASC')
+		assert_equal 'reopened', oe.operational_event_type.key
+		assert_equal Date.today, oe.occurred_on
+		assert_equal enrollment.study_subject_id, oe.enrollment.study_subject_id
+	end
+
+	test "should create subjectConsents operational event if consent changes to yes" do
+		enrollment = Factory(:subjectless_enrollment)
+		assert_nil enrollment.consented
+		assert_difference("Enrollment.find(#{enrollment.id}).operational_events.count",1){
+			enrollment.update_attributes(:consented => YNDK[:yes],
+				:consented_on => Date.today )
+		}
+		enrollment.reload
+		assert_equal enrollment.consented, YNDK[:yes]
+		assert_equal enrollment.consented_on, Date.today
+		consented_event = enrollment.operational_events.find(:first,:conditions => {
+			:operational_event_type_id => OperationalEventType['subjectConsents'].id })
+		assert_not_nil consented_event
+	end
+
+	test "should not create subjectConsents operational event if consent doesn't change" do
+		enrollment = Factory(:consented_enrollment)
+		assert_not_nil enrollment.consented
+		assert_difference("Enrollment.find(#{enrollment.id}).operational_events.count",0){
+			enrollment.update_attributes(:consented => YNDK[:yes],
+				:consented_on => Date.today )
+		}
+		enrollment.reload
+		assert_equal enrollment.consented, YNDK[:yes]
+		assert_equal enrollment.consented_on, Date.today
+		consented_event = enrollment.operational_events.find(:first,:conditions => {
+			:operational_event_type_id => OperationalEventType['subjectConsents'].id })
+		assert_not_nil consented_event
+	end
+
+	test "should create subjectDeclines operational event if consent changes to no" do
+		enrollment = Factory(:subjectless_enrollment)
+		assert_nil enrollment.consented
+		assert_difference("Enrollment.find(#{enrollment.id}).operational_events.count",1){
+			enrollment.update_attributes(:consented => YNDK[:no],
+				:refusal_reason => Factory(:refusal_reason),
+				:consented_on   => Date.today )
+		}
+		enrollment.reload
+		assert_equal enrollment.consented, YNDK[:no]
+		assert_equal enrollment.consented_on, Date.today
+		declined_event = enrollment.operational_events.find(:first,:conditions => {
+			:operational_event_type_id => OperationalEventType['subjectDeclines'].id })
+		assert_not_nil declined_event
+	end
+
+	test "should not create subjectDeclines operational event if consent doesn't change" do
+		enrollment = Factory(:declined_enrollment)
+		assert_not_nil enrollment.consented
+		assert_difference("Enrollment.find(#{enrollment.id}).operational_events.count",0){
+			enrollment.update_attributes(:consented => YNDK[:no],
+				:consented_on => Date.today )
+		}
+		enrollment.reload
+		assert_equal enrollment.consented, YNDK[:no]
+		assert_equal enrollment.consented_on, Date.today
+		declined_event = enrollment.operational_events.find(:first,:conditions => {
+			:operational_event_type_id => OperationalEventType['subjectDeclines'].id })
+		assert_not_nil declined_event
+	end
+
+	test "should have consented named_scope" do
+		assert_equal [], Enrollment.consented
+		Factory(:enrollment)
+		assert_equal [], Enrollment.consented
+		enrollment = Factory(:consented_enrollment)
+		assert_equal [enrollment], Enrollment.consented
+		Factory(:enrollment)
+		assert_equal [enrollment], Enrollment.consented
+	end
+
+protected
+
+	#	MUST define this method so can use the alias_method below.
+	#	Or could just define create_object.  Either way.
+	def create_subjectless_enrollment(options={})
+		enrollment = Factory.build(:subjectless_enrollment,options)
+		enrollment.save
+		enrollment
+	end
+
+#	create_object is used in the basic assertions,
+#	but it creates a subject which creates an enrollment and operational_event
+#	so if I create a subjectless enrollment, they work
+	alias_method :create_object, :create_subjectless_enrollment
+
+#	def create_enrollment(options={})
+#		enrollment = Factory.build(:enrollment,options)
+#		enrollment.save
+#		enrollment
+#	end
+
+end