ccls-ccls_engine 3.11.0

data/test/unit/ccls/address_test.rb

@@ -0,0 +1,155 @@
+require 'test_helper'
+
+class Ccls::AddressTest < ActiveSupport::TestCase
+
+
+#	TODO	this should really be unique, only used during importing
+#	validates_uniqueness_of :external_address_id, :allow_blank => true
+
+	#	external_address_id isn't required so don't use class level test
+	test "should require unique external_address_id" do
+		Factory(:address,:external_address_id => 123456789)
+		assert_difference('Address.count',0){
+			address = Factory.build(:address,:external_address_id => 123456789)
+			address.save
+			assert address.errors.on_attr_and_type?(:external_address_id,:taken)
+		}
+	end
+
+
+
+	assert_should_create_default_object
+	assert_should_require_attributes( 
+		:line_1, 
+		:city, 
+		:state, 
+		:zip )
+	assert_should_not_require_attributes( 
+		:country, 
+		:county, 
+		:line_2, 
+		:unit,
+		:external_address_id )
+	assert_should_require_attribute_length( 
+		:zip, 
+			:maximum => 10 )
+	assert_should_require_attribute_length( 
+		:line_1, 
+		:line_2, 
+		:unit,
+		:city, 
+		:state,
+			:maximum => 250 )
+
+	assert_should_have_one(:addressing)
+	assert_should_have_many(:interviews)
+	assert_should_initially_belong_to(:address_type)
+
+	test "explicit Factory address test" do
+		assert_difference('AddressType.count',1) {
+		assert_difference('Address.count',1) {
+			address = Factory(:address)
+			assert_not_nil address.address_type
+			assert_match /Box \d*/, address.line_1
+			assert_equal "Berkeley", address.city
+			assert_equal "CA", address.state
+			assert_equal "12345", address.zip
+		} }
+	end
+
+	test "explicit Factory mailing_address test" do
+		assert_difference('AddressType.count',0) {
+		assert_difference('Address.count',1) {
+			address = Factory(:mailing_address)
+			assert_equal address.address_type, AddressType['mailing']
+		} }
+	end
+
+	test "explicit Factory residence_address test" do
+		assert_difference('AddressType.count',0) {
+		assert_difference('Address.count',1) {
+			address = Factory(:residence_address)
+			assert_equal address.address_type, AddressType['residence']
+		} }
+	end
+
+	test "should require address_type" do
+		assert_difference( "Address.count", 0 ) do
+			address = create_address( :address_type => nil)
+			assert !address.errors.on(:address_type)
+			assert  address.errors.on_attr_and_type?(:address_type_id,:blank)
+		end
+	end
+
+	test "should require valid address_type" do
+		assert_difference( "Address.count", 0 ) do
+			address = create_address( :address_type_id => 0)
+			assert !address.errors.on(:address_type_id)
+			assert  address.errors.on_attr_and_type?(:address_type,:blank)
+		end
+	end
+
+	test "should require 5 or 9 digit zip" do
+		%w( asdf 1234 123456 1234Q ).each do |bad_zip|
+			assert_difference( "Address.count", 0 ) do
+				address = create_address( :zip => bad_zip )
+				assert address.errors.on(:zip)
+			end
+		end
+		%w( 12345 12345-6789 123456789 ).each do |good_zip|
+			assert_difference( "Address.count", 1 ) do
+				address = create_address( :zip => good_zip )
+				assert !address.errors.on(:zip)
+				assert address.zip =~ /\A\d{5}(-)?(\d{4})?\z/
+			end
+		end
+	end
+
+	test "should format 9 digit zip" do
+		assert_difference( "Address.count", 1 ) do
+			address = create_address( :zip => '123456789' )
+			assert !address.errors.on(:zip)
+			assert address.zip =~ /\A\d{5}(-)?(\d{4})?\z/
+			assert_equal '12345-6789', address.zip
+		end
+	end
+
+	test "should order address chronologically reversed" do
+		a1 = Factory(:address, :created_at => Date.jd(2440000) ).id
+		a2 = Factory(:address, :created_at => Date.jd(2450000) ).id
+		a3 = Factory(:address, :created_at => Date.jd(2445000) ).id
+		address_ids = Address.all.collect(&:id)
+		assert_equal address_ids, [a2,a3,a1]
+	end
+
+	test "should return city state and zip with csz" do
+		address = Factory(:address,
+			:city  => 'City',
+			:state => 'CA',
+			:zip   => '12345')
+		assert_equal "City, CA 12345", address.csz
+	end
+
+	#	Note that there are probably legitimate address line 1's 
+	#	that will match the p.*o.*box regex.
+	test "should require non-residence address type with pobox in line" do
+		["P.O. Box 123","PO Box 123","P O Box 123","Post Office Box 123"].each do |pobox|
+			assert_difference( "Address.count", 0 ) do
+				address = create_address( 
+					:line_1 => pobox,
+					:address_type => AddressType['residence']
+				)
+				assert address.errors.on(:address_type_id)
+			end
+		end
+	end
+
+#protected
+#
+#	def create_address(options={})
+#		address = Factory.build(:address,options)
+#		address.save
+#		address
+#	end
+
+end

data/test/unit/ccls/address_type_test.rb

@@ -0,0 +1,25 @@
+require 'test_helper'
+
+class Ccls::AddressTypeTest < ActiveSupport::TestCase
+
+	assert_should_behave_like_a_hash
+
+	assert_should_create_default_object
+	assert_should_not_require_attributes( :position )
+	assert_should_act_as_list
+	assert_should_have_many(:addresses)
+
+	test "explicit Factory address_type test" do
+		assert_difference('AddressType.count',1) {
+			address_type = Factory(:address_type)
+			assert_match /Key\d*/,  address_type.key
+			assert_match /Desc\d*/,  address_type.description
+		}
+	end
+
+	test "should return key as to_s" do
+		address_type = Factory(:address_type)
+		assert_equal address_type.key, "#{address_type}"
+	end
+
+end

data/test/unit/ccls/addressing_test.rb

@@ -0,0 +1,466 @@
+require 'test_helper'
+
+class Ccls::AddressingTest < ActiveSupport::TestCase
+
+	assert_should_create_default_object
+	assert_should_protect(:study_subject_id, :study_subject)
+	assert_should_not_require_attributes( 
+		:address_id,
+		:current_address,
+		:address_at_diagnosis,
+		:is_valid,
+		:why_invalid,
+		:is_verified,
+		:how_verified,
+		:valid_from,
+		:valid_to,
+		:verified_on,
+		:verified_by_uid )
+#		:data_source_id )
+	assert_should_initially_belong_to( 
+		:study_subject, 
+		:address )
+	assert_should_require_attribute_length( 
+		:why_invalid, 
+		:how_verified, 
+			:maximum => 250 )
+	assert_requires_complete_date( 
+		:valid_from, 
+		:valid_to )
+
+	test "explicit Factory addressing test" do
+		assert_difference('StudySubject.count',1) {
+		assert_difference('Address.count',1) {
+		assert_difference('Addressing.count',1) {
+			addressing = Factory(:addressing)
+			assert_not_nil addressing.address
+			assert_not_nil addressing.study_subject
+			assert_equal 1, addressing.is_valid
+#			assert_equal 2, addressing.is_verified
+			assert         !addressing.is_verified	#	noticed that this is NOT int for YNDK, but boolean
+		} } }
+	end
+
+	test "explicity Factory mailing_addressing test" do
+		assert_difference('StudySubject.count',1) {
+		assert_difference('Address.count',1) {
+		assert_difference('Addressing.count',1) {
+			addressing = Factory(:mailing_addressing)
+			assert_equal addressing.address.address_type,
+				AddressType['mailing']
+			assert_equal addressing.current_address, YNDK[:no]
+		} } }
+	end
+
+	test "explicity Factory current_mailing_addressing test" do
+		assert_difference('StudySubject.count',1) {
+		assert_difference('Address.count',1) {
+		assert_difference('Addressing.count',1) {
+			addressing = Factory(:current_mailing_addressing)
+			assert_equal addressing.address.address_type,
+				AddressType['mailing']
+			assert_equal addressing.current_address, YNDK[:yes]
+		} } }
+	end
+
+	test "explicity Factory residence_addressing test" do
+		assert_difference('StudySubject.count',1) {
+		assert_difference('Address.count',1) {
+		assert_difference('Addressing.count',1) {
+			addressing = Factory(:residence_addressing)
+			assert_equal addressing.address.address_type,
+				AddressType['residence']
+			assert_equal addressing.current_address, YNDK[:no]
+		} } }
+	end
+
+	test "explicity Factory current_residence_addressing test" do
+		assert_difference('StudySubject.count',1) {
+		assert_difference('Address.count',1) {
+		assert_difference('Addressing.count',1) {
+			addressing = Factory(:current_residence_addressing)
+			assert_equal addressing.address.address_type,
+				AddressType['residence']
+			assert_equal addressing.current_address, YNDK[:yes]
+		} } }
+	end
+
+	test "current_address should default to 1" do
+		addressing = Addressing.new
+		assert_equal 1, addressing.current_address
+	end
+
+	#
+	# addressing uses accepts_attributes_for :address
+	# so the addressing can't require address_id on create
+	# or this test fails.
+	#
+#	test "should require address on update" do
+#		assert_difference("Addressing.count", 1 ) do
+#			addressing = create_addressing(:address_id => nil)
+#			addressing.reload.update_attributes(
+#				:created_at => Date.yesterday )
+#			assert addressing.errors.on(:address)
+#		end
+#	end
+
+
+	test "should require data_source_other if data_source is other" do
+		assert_difference( "Addressing.count", 0 ) {
+#		assert_difference( "Address.count", 0 ) {
+			#	The factory will create the associations regardless
+			#	so an Address and StudySubject gets created regardless
+			addressing = create_addressing( :data_source => DataSource['Other'] )
+			assert addressing.errors.on_attr_and_type?(:data_source_other,:blank)
+		} # }
+	end
+
+	test "should NOT require data_source_other if data_source is not other" do
+		assert_difference( "Address.count", 1 ) {
+		assert_difference( "Addressing.count", 1 ) {
+			addressing = create_addressing( :data_source => DataSource['raf'])
+			assert !addressing.errors.on_attr_and_type?(:data_source_other,:blank)
+		} }
+	end
+
+	test "should require a valid address with address_attributes" do
+		assert_difference("Address.count", 0 ) {
+		assert_difference("Addressing.count", 0 ) {
+			addressing = create_addressing(:address_id => nil,
+				:address_attributes => {} )
+		} }
+	end
+
+	[:yes,:nil].each do |yndk|
+		test "should NOT require why_invalid if is_valid is #{yndk}" do
+			assert_difference("Addressing.count", 1 ) do
+				addressing = create_addressing(:is_valid => YNDK[yndk])
+			end
+		end
+	end
+	[:no,:dk].each do |yndk|
+		test "should require why_invalid if is_valid is #{yndk}" do
+			assert_difference("Addressing.count", 0 ) do
+				addressing = create_addressing(:is_valid => YNDK[yndk])
+				assert addressing.errors.on(:why_invalid)
+			end
+		end
+	end
+
+	test "should NOT require how_verified if is_verified is false" do
+		assert_difference("Addressing.count", 1 ) do
+			addressing = create_addressing(:is_verified => false)
+		end
+	end
+	test "should require how_verified if is_verified is true" do
+		assert_difference("Addressing.count", 0 ) do
+			addressing = create_addressing(:is_verified => true)
+			assert addressing.errors.on(:how_verified)
+		end
+	end
+
+
+	test "should NOT set verified_on if is_verified NOT changed to true" do
+		addressing = create_addressing(:is_verified => false)
+		assert_nil addressing.verified_on
+	end
+
+
+	test "should set verified_on if is_verified changed to true" do
+		addressing = create_addressing(:is_verified => true,
+			:how_verified => "not a clue")
+		assert_not_nil addressing.verified_on
+	end
+
+	test "should set verified_on to NIL if is_verified changed to false" do
+		addressing = create_addressing(:is_verified => true,
+			:how_verified => "not a clue")
+		assert_not_nil addressing.verified_on
+		addressing.update_attributes(:is_verified => false)
+		assert_nil addressing.verified_on
+	end
+
+	test "should NOT set verified_by_uid if is_verified NOT changed to true" do
+		addressing = create_addressing(:is_verified => false)
+		assert_nil addressing.verified_by_uid
+	end
+
+	test "should set verified_by_uid to 0 if is_verified changed to true" do
+		addressing = create_addressing(:is_verified => true,
+			:how_verified => "not a clue")
+		assert_not_nil addressing.verified_by_uid
+		assert_equal addressing.verified_by_uid, ''
+	end
+
+	test "should set verified_by_uid to current_user.id if is_verified " <<
+		"changed to true if current_user passed" do
+		cu = admin_user
+		addressing = create_addressing(:is_verified => true,
+			:current_user => cu,
+			:how_verified => "not a clue")
+		assert_not_nil addressing.verified_by_uid
+		assert_equal addressing.verified_by_uid, cu.uid
+	end
+
+	test "should set verified_by_uid to NIL if is_verified changed to false" do
+		addressing = create_addressing(:is_verified => true,
+			:how_verified => "not a clue")
+		assert_not_nil addressing.verified_by_uid
+		addressing.update_attributes(:is_verified => false)
+		assert_nil addressing.verified_by_uid
+	end
+
+
+	test "should only return current addressings" do
+		create_addressing(:current_address => YNDK[:yes])
+		create_addressing(:current_address => YNDK[:no])
+		create_addressing(:current_address => YNDK[:dk])
+		addressing = Addressing.current
+		assert_equal 2, addressing.length
+		addressing.each do |addressing|
+			assert [1,999].include?(addressing.current_address)
+		end
+	end
+
+	test "should only return historic addressings" do
+		create_addressing(:current_address => YNDK[:yes])
+		create_addressing(:current_address => YNDK[:no])
+		create_addressing(:current_address => YNDK[:dk])
+		addressing = Addressing.historic
+		assert_equal 1, addressing.length
+		addressing.each do |addressing|
+			assert ![1,999].include?(addressing.current_address)
+		end
+	end
+
+	test "should make study_subject ineligible "<<
+			"on create if state NOT 'CA' and address is ONLY residence" do
+		study_subject = create_eligible_hx_study_subject
+		assert_difference('OperationalEvent.count',1) {
+		assert_difference('Addressing.count',1) {
+		assert_difference('Address.count',1) {
+			create_az_addressing(study_subject)
+		} } }
+		assert_study_subject_is_not_eligible(study_subject)
+		hxe = study_subject.enrollments.find_by_project_id(Project['HomeExposures'].id)
+		assert_equal   hxe.ineligible_reason,
+			IneligibleReason['newnonCA']
+	end
+
+	test "should make study_subject ineligible "<<
+			"on create if state NOT 'CA' and address is ANOTHER residence" do
+		study_subject = create_eligible_hx_study_subject
+		assert_difference('OperationalEvent.count',1) {
+		assert_difference('Address.count',2) {
+		assert_difference("Addressing.count", 2 ) {
+			create_ca_addressing(study_subject)
+			create_az_addressing(study_subject)
+		} } }
+		assert_study_subject_is_not_eligible(study_subject)
+		hxe = study_subject.enrollments.find_by_project_id(Project['HomeExposures'].id)
+		assert_equal   hxe.ineligible_reason,
+			IneligibleReason['moved']
+	end
+
+	test "should NOT make study_subject ineligible "<<
+			"on create if OET is missing" do
+		OperationalEventType['ineligible'].destroy
+		study_subject = create_eligible_hx_study_subject
+		assert_difference('OperationalEvent.count',0) {
+		assert_difference('Address.count',1) {
+		assert_difference("Addressing.count", 1 ) {
+			create_ca_addressing(study_subject)
+			assert_raise(ActiveRecord::RecordNotSaved){
+				create_az_addressing(study_subject)
+		} } } }
+		assert_study_subject_is_eligible(study_subject)
+	end
+
+	test "should NOT make study_subject ineligible "<<
+			"on create if state NOT 'CA' and address is NOT residence" do
+		study_subject = create_eligible_hx_study_subject
+		assert_difference('OperationalEvent.count',0) {
+		assert_difference('Address.count',1) {
+		assert_difference("Addressing.count", 1 ) {
+			create_az_addressing(study_subject,
+				:address => { :address_type => AddressType['mailing'] })
+		} } }
+		assert_study_subject_is_eligible(study_subject)
+	end
+
+	test "should NOT make study_subject ineligible "<<
+			"on create if state 'CA' and address is residence" do
+		study_subject = create_eligible_hx_study_subject
+		assert_difference('OperationalEvent.count',0) {
+		assert_difference('Address.count',1) {
+		assert_difference("Addressing.count", 1 ) {
+			create_ca_addressing(study_subject)
+		} } }
+		assert_study_subject_is_eligible(study_subject)
+	end
+
+	%w( address_type address_type_id
+			line_1 line_2 unit city state zip csz county ).each do |method_name|
+		test "should respond to #{method_name}" do
+			addressing = create_addressing
+			assert addressing.respond_to?(method_name)
+		end
+	end
+
+
+#	'1' and '0' are the default values for a checkbox.
+#	I probably should add a condition to this event that
+#	the address_type be 'Residence', but I've left that to the view.
+#			addressing = Factory(:current_residence_addressing)
+
+	test "should NOT add 'subject_moved' event to subject if subject_moved is '1'" <<
+			" if not residence address" do
+		addressing = Factory(:current_mailing_addressing)
+		assert_difference('OperationalEvent.count',0) {
+			addressing.update_attributes(
+				:current_address => '2',
+				:subject_moved => '1')
+		}
+	end
+
+	test "should NOT add 'subject_moved' event to subject if subject_moved is '1'" <<
+			" if was not current address" do
+		addressing = Factory(:residence_addressing)
+		assert_difference('OperationalEvent.count',0) {
+			addressing.update_attributes(
+				:current_address => '2',
+				:subject_moved => '1')
+		}
+	end
+
+	test "should add 'subject_moved' event to subject if subject_moved is '1'" do
+		addressing = Factory(:current_residence_addressing)
+		assert_difference('OperationalEvent.count',1) {
+			addressing.update_attributes(
+				:current_address => '2',
+				:subject_moved => '1')
+		}
+	end
+
+	test "should not add 'subject_moved' event to subject if subject_moved is '0'" do
+		addressing = Factory(:current_residence_addressing)
+		assert_difference('OperationalEvent.count',0) {
+			addressing.update_attributes(
+				:current_address => '2',
+				:subject_moved => '0')
+		}
+	end
+
+	test "should add 'subject_moved' event to subject if subject_moved is 'true'" do
+		addressing = Factory(:current_residence_addressing)
+		assert_difference('OperationalEvent.count',1) {
+			addressing.update_attributes(
+				:current_address => '2',
+				:subject_moved => 'true')
+		}
+	end
+
+	test "should not add 'subject_moved' event to subject if subject_moved is 'false'" do
+		addressing = Factory(:current_residence_addressing)
+		assert_difference('OperationalEvent.count',0) {
+			addressing.update_attributes(
+				:current_address => '2',
+				:subject_moved => 'false')
+		}
+	end
+
+	test "should not add 'subject_moved' event to subject if subject_moved is nil" do
+		addressing = Factory(:current_residence_addressing)
+		assert_difference('OperationalEvent.count',0) {
+			addressing.update_attributes(
+				:current_address => '2',
+				:subject_moved => nil)
+		}
+	end
+
+	#	current_address has a database default of 1
+	[ :current_address ].each do |field|
+
+		#	Making assumption that 12345 will NEVER be a valid value.
+		test "should NOT allow 12345 for #{field}" do
+			addressing = Addressing.new(field => 12345)
+			addressing.valid?
+			assert addressing.errors.on_attr_and_type?(field,:inclusion)
+		end
+
+#		test "should allow nil for #{field}" do
+#			addressing = Addressing.new(field => nil)
+#			assert_nil addressing.send(field)
+#			addressing.valid?
+#			assert !addressing.errors.on(field)
+#		end
+
+		test "should allow all valid YNDK values for #{field}" do
+			addressing = Addressing.new
+			YNDK.valid_values.each do |value|
+				addressing.send("#{field}=", value)
+				addressing.valid?
+				assert !addressing.errors.on(field)
+			end
+		end
+
+	end
+
+	[ :is_valid, :address_at_diagnosis ].each do |field|
+
+		#	Making assumption that 12345 will NEVER be a valid value.
+		test "should NOT allow 12345 for #{field}" do
+			addressing = Addressing.new(field => 12345)
+			addressing.valid?
+			assert addressing.errors.on_attr_and_type?(field,:inclusion)
+		end
+
+		test "should allow nil for #{field}" do
+			addressing = Addressing.new(field => nil)
+			assert_nil addressing.send(field)
+			addressing.valid?
+			assert !addressing.errors.on(field)
+		end
+
+		test "should allow all valid YNDK values for #{field}" do
+			addressing = Addressing.new
+			YNDK.valid_values.each do |value|
+				addressing.send("#{field}=", value)
+				addressing.valid?
+				assert !addressing.errors.on(field)
+			end
+		end
+
+	end
+
+protected
+
+#	def create_addressing(options={})
+#		addressing = Factory.build(:addressing,options)
+#		addressing.save
+#		addressing
+#	end
+
+	def create_addressing_with_address(study_subject,options={})
+		create_addressing({
+			:study_subject => study_subject,
+#	doesn't work in rcov for some reason
+#			:address => nil,	#	block address_attributes
+			:address_id => nil,	#	block address_attributes
+			:address_attributes => Factory.attributes_for(:address,{
+				:address_type => AddressType['residence']
+			}.merge(options[:address]||{}))
+		}.merge(options[:addressing]||{}))
+	end
+
+	def create_ca_addressing(study_subject,options={})
+		create_addressing_with_address(study_subject,{
+			:address => {:state => 'CA'}}.merge(options))
+	end
+
+	def create_az_addressing(study_subject,options={})
+		create_addressing_with_address(study_subject,{
+			:address => {:state => 'AZ'}}.merge(options))
+	end
+
+end