ccls-ccls_engine 3.11.0

data/test/unit/ccls/person_test.rb

@@ -0,0 +1,55 @@
+require 'test_helper'
+
+class Ccls::PersonTest < ActiveSupport::TestCase
+
+	assert_should_create_default_object
+	assert_should_require_attribute( :last_name )
+	assert_should_not_require_attributes( 
+		:position, 
+		:first_name, 
+		:honorific, 
+		:organization_id, 
+		:person_type_id )
+	assert_should_act_as_list
+	assert_should_have_many( :organizations )
+
+#	TODO assert_should_have_many( :interviews, :foreign_key => :interviewer_id )
+
+	assert_should_require_attribute_length( 
+		:first_name, 
+		:last_name, 
+		:honorific, 
+			:maximum => 250 )
+
+	test "explicit Factory person test" do
+		assert_difference('Person.count',1) {
+			person = Factory(:person)
+			assert_match /LastName\d*/, person.last_name
+		}
+	end
+
+	test "should return full_name as to_s" do
+		person = create_person
+		assert_equal person.full_name, "#{person}"
+	end
+
+	test "should find random" do
+		person = Person.random()
+		assert person.is_a?(Person)
+	end
+
+	test "should return nil on random when no records" do
+		Person.stubs(:count).returns(0)
+		person = Person.random()
+		assert_nil person
+	end
+
+#protected
+#
+#	def create_person(options={})
+#		person = Factory.build(:person,options)
+#		person.save
+#		person
+#	end
+
+end

data/test/unit/ccls/phone_number_test.rb

@@ -0,0 +1,244 @@
+require 'test_helper'
+
+class Ccls::PhoneNumberTest < ActiveSupport::TestCase
+
+	[ :current_phone, :is_valid ].each do |field|
+
+		#	Making assumption that 12345 will NEVER be a valid value.
+		test "should NOT allow 12345 for #{field}" do
+			phone_number = PhoneNumber.new(field => 12345)
+			phone_number.valid?
+			assert phone_number.errors.on_attr_and_type?(field,:inclusion)
+		end
+
+		test "should allow nil for #{field}" do
+			phone_number = PhoneNumber.new(field => nil)
+			assert_nil phone_number.send(field)
+			phone_number.valid?
+			assert !phone_number.errors.on(field)
+		end
+
+		test "should allow all valid YNDK values for #{field}" do
+			phone_number = PhoneNumber.new
+			YNDK.valid_values.each do |value|
+				phone_number.send("#{field}=", value)
+				phone_number.valid?
+				assert !phone_number.errors.on(field)
+			end
+		end
+
+	end
+
+	assert_should_create_default_object
+	assert_should_protect(:study_subject_id, :study_subject)
+	assert_should_act_as_list( :scope => :study_subject_id )
+
+	assert_should_initially_belong_to( :study_subject, :phone_type )
+	assert_should_require_attribute(:phone_number )
+	assert_should_not_require_attributes( :position, :study_subject_id,
+#		:data_source_id, :is_primary, :is_valid,
+		:is_primary, :is_valid,
+		:why_invalid, :is_verified, :how_verified,
+		:verified_on, :verified_by_uid, :current_phone )
+	assert_should_require_attribute_length( :how_verified, :why_invalid, 
+		:maximum => 250 )
+
+	test "explicit Factory phone_number test" do
+		assert_difference('StudySubject.count',1) {
+		assert_difference('PhoneType.count',1) {
+		assert_difference('PhoneNumber.count',1) {
+			phone_number = Factory(:phone_number)
+			assert_not_nil phone_number.study_subject
+			assert_not_nil phone_number.phone_type
+			assert_match /\(\d{3}\) \d{3}-\d{4}/, phone_number.phone_number
+			assert_equal 1, phone_number.is_valid
+			assert         !phone_number.is_verified
+		} } }
+	end
+
+	test "should return phone number as to_s" do
+		phone_number = create_phone_number
+		assert_equal phone_number.phone_number, "#{phone_number}"
+	end
+
+	test "should require data_source_other if data_source is other" do
+		assert_difference( "PhoneNumber.count", 0 ) do
+			phone_number = create_phone_number( :data_source => DataSource['Other'])
+			assert phone_number.errors.on_attr_and_type?(:data_source_other,:blank)
+		end
+	end
+
+	test "should NOT require data_source_other if data_source is not other" do
+		assert_difference( "PhoneNumber.count", 1 ) do
+			phone_number = create_phone_number( :data_source => DataSource['raf'])
+			assert !phone_number.errors.on_attr_and_type?(:data_source_other,:blank)
+		end
+	end
+
+	test "should require phone_type" do
+		assert_difference( "PhoneNumber.count", 0 ) do
+			phone_number = create_phone_number( :phone_type => nil)
+			assert !phone_number.errors.on(:phone_type)
+			assert  phone_number.errors.on_attr_and_type?(:phone_type_id, :blank)
+		end
+	end
+
+	test "should require valid phone_type" do
+		assert_difference( "PhoneNumber.count", 0 ) do
+			phone_number = create_phone_number( :phone_type_id => 0)
+			assert !phone_number.errors.on(:phone_type_id)
+			assert  phone_number.errors.on_attr_and_type?(:phone_type,:blank)
+		end
+	end
+
+	test "current_phone should default to 1" do
+		phone_number = PhoneNumber.new
+		assert_equal 1, phone_number.current_phone
+	end
+
+	test "should only return current phone_numbers" do
+		create_phone_number(:current_phone => YNDK[:yes])
+		create_phone_number(:current_phone => YNDK[:no])
+		create_phone_number(:current_phone => YNDK[:dk])
+		phone_numbers = PhoneNumber.current
+		assert_equal 2, phone_numbers.length
+		phone_numbers.each do |phone_number|
+			assert [1,999].include?(phone_number.current_phone)
+		end
+	end
+
+	test "should only return historic phone_numbers" do
+		create_phone_number(:current_phone => YNDK[:yes])
+		create_phone_number(:current_phone => YNDK[:no])
+		create_phone_number(:current_phone => YNDK[:dk])
+		phone_numbers = PhoneNumber.historic
+		assert_equal 1, phone_numbers.length
+		phone_numbers.each do |phone_number|
+			assert ![1,999].include?(phone_number.current_phone)
+		end
+	end
+
+	test "should not have multiple errors for blank phone number" do
+		assert_difference( "PhoneNumber.count", 0 ) do
+			phone_number = create_phone_number(:phone_number => '')
+			assert !phone_number.errors.on_attr_and_type?(:phone_number,:invalid)
+			assert  phone_number.errors.on_attr_and_type?(:phone_number,:blank)
+		end
+	end
+
+	test "should require properly formated phone number" do
+		[ 'asdf', 'me@some@where.com','12345678','12345678901' 
+		].each do |bad_phone|
+			assert_difference( "PhoneNumber.count", 0 ) do
+				phone_number = create_phone_number(:phone_number => bad_phone)
+				assert phone_number.errors.on_attr_and_type?(:phone_number,:invalid)
+			end
+		end
+		[ "(123)456-7890", "1234567890", 
+			"  1 asdf23,4()5\+67   8 9   0asdf" ].each do |good_phone|
+			assert_difference( "PhoneNumber.count", 1 ) do
+				phone_number = create_phone_number(:phone_number => good_phone)
+				assert !phone_number.errors.on_attr_and_type?(:phone_number,:invalid)
+				assert phone_number.reload.phone_number =~ /\A\(\d{3}\)\s+\d{3}-\d{4}\z/
+				assert_equal '(123) 456-7890', phone_number.phone_number
+			end
+		end
+	end
+
+	test "should format phone number" do
+		assert_difference( "PhoneNumber.count", 1 ) do
+			phone_number = create_phone_number( :phone_number => '1234567890' )
+			assert !phone_number.errors.on(:phone_number)
+			assert phone_number.phone_number =~ /\A\(\d{3}\)\s+\d{3}-\d{4}\z/
+			assert_equal '(123) 456-7890', phone_number.phone_number
+		end
+	end
+
+
+	[:yes,:nil].each do |yndk|
+		test "should NOT require why_invalid if is_valid is #{yndk}" do
+			assert_difference( "PhoneNumber.count", 1 ) do
+				phone_number = create_phone_number(: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( "PhoneNumber.count", 0 ) do
+				phone_number = create_phone_number(:is_valid => YNDK[yndk])
+				assert phone_number.errors.on(:why_invalid)
+			end
+		end
+	end
+
+	test "should NOT require how_verified if is_verified is false" do
+		assert_difference( "PhoneNumber.count", 1 ) do
+			phone_number = create_phone_number(:is_verified => false)
+		end
+	end
+
+	test "should require how_verified if is_verified is true" do
+		assert_difference( "PhoneNumber.count", 0 ) do
+			phone_number = create_phone_number(:is_verified => true)
+			assert phone_number.errors.on(:how_verified)
+		end
+	end
+
+	test "should NOT set verified_on if is_verified NOT changed to true" do
+		phone_number = create_phone_number(:is_verified => false)
+		assert_nil phone_number.verified_on
+	end
+
+	test "should set verified_on if is_verified changed to true" do
+		phone_number = create_phone_number(:is_verified => true,
+			:how_verified => "not a clue")
+		assert_not_nil phone_number.verified_on
+	end
+
+	test "should set verified_on to NIL if is_verified changed to false" do
+		phone_number = create_phone_number(:is_verified => true,
+			:how_verified => "not a clue")
+		assert_not_nil phone_number.verified_on
+		phone_number.update_attributes(:is_verified => false)
+		assert_nil phone_number.verified_on
+	end
+
+	test "should NOT set verified_by_uid if is_verified NOT changed to true" do
+		phone_number = create_phone_number(:is_verified => false)
+		assert_nil phone_number.verified_by_uid
+	end
+
+	test "should set verified_by_uid to 0 if is_verified changed to true" do
+		phone_number = create_phone_number(:is_verified => true,
+			:how_verified => "not a clue")
+		assert_not_nil phone_number.verified_by_uid
+		assert_equal phone_number.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
+		phone_number = create_phone_number(:is_verified => true,
+			:current_user => cu,
+			:how_verified => "not a clue")
+		assert_not_nil phone_number.verified_by_uid
+		assert_equal phone_number.verified_by_uid, cu.uid
+	end
+
+	test "should set verified_by_uid to NIL if is_verified changed to false" do
+		phone_number = create_phone_number(:is_verified => true,
+			:how_verified => "not a clue")
+		assert_not_nil phone_number.verified_by_uid
+		phone_number.update_attributes(:is_verified => false)
+		assert_nil phone_number.verified_by_uid
+	end
+
+#protected
+#
+#	def create_phone_number(options={})
+#		phone_number = Factory.build(:phone_number,options)
+#		phone_number.save
+#		phone_number
+#	end
+
+end

data/test/unit/ccls/phone_type_test.rb

@@ -0,0 +1,32 @@
+require 'test_helper'
+
+class Ccls::PhoneTypeTest < ActiveSupport::TestCase
+
+	assert_should_behave_like_a_hash
+
+	assert_should_create_default_object
+	assert_should_act_as_list
+	assert_should_have_many(:phone_numbers)
+	assert_should_not_require_attributes( :position )
+
+	test "explicit Factory phone_type test" do
+		assert_difference('PhoneType.count',1) {
+			phone_type = Factory(:phone_type)
+			assert_match /Key\d*/, phone_type.key
+		}
+	end
+
+	test "should return key as to_s" do
+		phone_type = create_phone_type
+		assert_equal phone_type.key, "#{phone_type}"
+	end
+
+#protected
+#
+#	def create_phone_type(options={})
+#		phone_type = Factory.build(:phone_type,options)
+#		phone_type.save
+#		phone_type
+#	end
+
+end

data/test/unit/ccls/project_outcome_test.rb

@@ -0,0 +1,34 @@
+require 'test_helper'
+
+class Ccls::ProjectOutcomeTest < ActiveSupport::TestCase
+
+	assert_should_behave_like_a_hash
+
+	assert_should_create_default_object
+	assert_should_act_as_list
+	assert_should_not_require_attributes( :position, :project_id )
+	assert_should_have_many( :enrollments )
+
+	test "explicit Factory project_outcome test" do
+		assert_difference('ProjectOutcome.count',1) {
+			project_outcome = Factory(:project_outcome)
+			assert_match /Key\d*/, project_outcome.key
+			assert_match /Desc\d*/, project_outcome.description
+		}
+	end
+
+	test "should return description as to_s" do
+		project_outcome = create_project_outcome
+		assert_equal project_outcome.description,
+			"#{project_outcome}"
+	end
+
+#protected
+#
+#	def create_project_outcome(options={})
+#		project_outcome = Factory.build(:project_outcome,options)
+#		project_outcome.save
+#		project_outcome
+#	end
+
+end

data/test/unit/ccls/project_test.rb

@@ -0,0 +1,60 @@
+require 'test_helper'
+
+class Ccls::ProjectTest < ActiveSupport::TestCase
+
+	assert_should_behave_like_a_hash
+
+	assert_should_create_default_object
+
+	assert_should_have_many( :instrument_types, :enrollments, :instruments, 
+		:samples, :gift_cards )
+	assert_should_not_require_attributes( :position, :began_on, :ended_on, 
+		:eligibility_criteria )
+	assert_should_require_attribute_length( :eligibility_criteria, :maximum => 65000 )
+	assert_should_act_as_list
+
+	assert_requires_complete_date( :began_on, :ended_on )
+
+	test "explicit Factory project test" do
+		assert_difference('Project.count',1) {
+			project = Factory(:project)
+			assert_match /Key\d*/, project.key
+			assert_match /Desc\d*/, project.description
+		}
+	end
+
+	test "should return description as to_s" do
+		project = create_project
+		assert_equal project.description, "#{project}"
+	end
+
+	test "should have many study_subjects through enrollments" do
+		project = create_project
+		assert_equal 0, project.study_subjects.length
+		Factory(:enrollment, :project_id => project.id)
+		assert_equal 1, project.reload.study_subjects.length
+		Factory(:enrollment, :project_id => project.id)
+		assert_equal 2, project.reload.study_subjects.length
+	end
+
+	#	this method seems like it would be better suited to 
+	#	be in the StudySubject model rather than Project
+	test "should return projects not enrolled by given study_subject" do
+		study_subject = create_study_subject
+		unenrolled = Project.unenrolled_projects(study_subject)
+		assert_not_nil unenrolled
+		assert unenrolled.is_a?(Array)
+		assert_equal 10, Project.count
+		#	due to the auto-enrollment in ccls, there are only 9 now
+		assert_equal 9, unenrolled.length
+	end
+
+#protected
+#
+#	def create_project(options={})
+#		project = Factory.build(:project,options)
+#		project.save
+#		project
+#	end
+
+end

data/test/unit/ccls/race_test.rb

@@ -0,0 +1,37 @@
+require 'test_helper'
+
+class Ccls::RaceTest < ActiveSupport::TestCase
+
+	assert_should_behave_like_a_hash
+
+	assert_should_create_default_object
+	assert_should_act_as_list
+#	assert_should_have_many( :study_subjects )
+	assert_should_require_attributes( :code )
+	assert_should_require_unique_attributes( :code )
+	assert_should_not_require_attributes( :position )
+	assert_should_require_attribute_length( :code, :maximum => 250 )
+
+	test "explicit Factory race test" do
+		assert_difference('Race.count',1) {
+			race = Factory(:race)
+			assert_match /key\d*/,  race.key
+			assert_match /Race\d*/, race.code
+			assert_match /Desc\d*/, race.description
+		}
+	end
+
+	test "should return name as to_s" do
+		race = create_race
+		assert_equal race.name, "#{race}"
+	end
+
+#protected
+#
+#	def create_race(options={})
+#		race = Factory.build(:race,options)
+#		race.save
+#		race
+#	end
+
+end