ccls-ccls_engine 3.11.0

data/test/unit/ccls/subject_language_test.rb

@@ -0,0 +1,43 @@
+require 'test_helper'
+
+class Ccls::SubjectLanguageTest < ActiveSupport::TestCase
+
+	assert_should_create_default_object
+	assert_should_initially_belong_to( :study_subject, :language )
+	assert_should_protect( :study_subject_id, :study_subject )
+
+	test "explicit Factory subject_language test" do
+		assert_difference('Language.count',1) {
+		assert_difference('StudySubject.count',1) {
+		assert_difference('SubjectLanguage.count',1) {
+			subject_language = Factory(:subject_language)
+			assert_not_nil subject_language.study_subject
+			assert_not_nil subject_language.language
+		} } }
+	end
+
+	test "should require other if language == other" do
+		assert_difference( "SubjectLanguage.count", 0 ) do
+			subject_language = create_subject_language(
+				:language_id => Language['other'].id )
+			assert subject_language.errors.on_attr_and_type?(:other,:blank)
+		end
+	end
+
+	test "should not require other if language != other" do
+		assert_difference( "SubjectLanguage.count", 1 ) do
+			subject_language = create_subject_language(
+				:language_id => Language['ENglish'].id )
+			assert !subject_language.errors.on_attr_and_type?(:other,:blank)
+		end
+	end
+
+#protected
+#
+#	def create_subject_language(options={})
+#		subject_language = Factory.build(:subject_language,options)
+#		subject_language.save
+#		subject_language
+#	end
+
+end

data/test/unit/ccls/subject_race_test.rb

@@ -0,0 +1,35 @@
+require 'test_helper'
+
+class Ccls::SubjectRaceTest < ActiveSupport::TestCase
+
+	assert_should_create_default_object
+	assert_should_initially_belong_to( :study_subject, :race )
+	assert_should_protect( :study_subject_id, :study_subject )
+
+	test "explicit Factory subject_race test" do
+		assert_difference('Race.count',1) {
+		assert_difference('StudySubject.count',1) {
+		assert_difference('SubjectRace.count',1) {
+			subject_race = Factory(:subject_race)
+			assert_not_nil subject_race.study_subject
+			assert_not_nil subject_race.race
+		} } }
+	end
+
+	test "should require other if race == other" do
+		assert_difference( "SubjectRace.count", 0 ) do
+			subject_race = create_subject_race(
+				:race_id => Race['other'].id )
+			assert subject_race.errors.on_attr_and_type?(:other,:blank)
+		end
+	end
+
+	test "should not require other if race != other" do
+		assert_difference( "SubjectRace.count", 1 ) do
+			subject_race = create_subject_race(
+				:race_id => Race['white'].id )
+			assert !subject_race.errors.on_attr_and_type?(:other,:blank)
+		end
+	end
+
+end

data/test/unit/ccls/subject_relationship_test.rb

@@ -0,0 +1,43 @@
+require 'test_helper'
+
+class Ccls::SubjectRelationshipTest < ActiveSupport::TestCase
+
+	assert_should_behave_like_a_hash
+
+	assert_should_create_default_object
+	assert_should_act_as_list
+	assert_should_not_require_attributes( :position )
+
+	test "explicit Factory subject_relationship test" do
+		assert_difference('SubjectRelationship.count',1) {
+			subject_relationship = Factory(:subject_relationship)
+			assert_match /Key\d*/, subject_relationship.key
+			assert_match /Desc\d*/, subject_relationship.description
+		}
+	end
+
+	test "should return description as to_s" do
+		subject_relationship = create_subject_relationship
+		assert_equal subject_relationship.description, "#{subject_relationship}"
+	end
+
+	test "should find random" do
+		subject_relationship = SubjectRelationship.random()
+		assert subject_relationship.is_a?(SubjectRelationship)
+	end
+
+	test "should return nil on random when no records" do
+		SubjectRelationship.stubs(:count).returns(0)
+		subject_relationship = SubjectRelationship.random()
+		assert_nil subject_relationship
+	end
+
+#protected
+#
+#	def create_subject_relationship(options={})
+#		subject_relationship = Factory.build(:subject_relationship,options)
+#		subject_relationship.save
+#		subject_relationship
+#	end
+
+end

data/test/unit/ccls/subject_type_test.rb

@@ -0,0 +1,40 @@
+require 'test_helper'
+
+class Ccls::SubjectTypeTest < 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_not_require_attributes( :position, :related_case_control_type )
+
+	test "explicit Factory subject_type test" do
+		assert_difference('SubjectType.count',1) {
+			subject_type = Factory(:subject_type)
+			assert_match /Key\d*/, subject_type.key
+			assert_match /Desc\d*/, subject_type.description
+		}
+	end
+
+	test "should return description as name" do
+		subject_type = create_subject_type
+		assert_equal subject_type.description,
+			subject_type.name
+	end
+
+	test "should return description as to_s" do
+		subject_type = create_subject_type
+		assert_equal subject_type.description,
+			"#{subject_type}"
+	end
+
+#protected
+#
+#	def create_subject_type(options={})
+#		subject_type = Factory.build(:subject_type,options)
+#		subject_type.save
+#		subject_type
+#	end
+
+end

data/test/unit/ccls/tracing_status_test.rb

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

data/test/unit/ccls/transfer_test.rb

@@ -0,0 +1,81 @@
+require 'test_helper'
+
+class Ccls::TransferTest < ActiveSupport::TestCase
+
+	assert_should_create_default_object
+	assert_should_initially_belong_to( :aliquot )
+	assert_should_initially_belong_to( :to_organization, :from_organization, 
+		:class_name => 'Organization' )
+#	assert_should_require_attributes( :aliquot_id, 
+#		:from_organization_id, :to_organization_id )
+	assert_should_not_require_attributes( :position, :amount, :reason, :is_permanent )
+	assert_should_require_attribute_length( :reason, :maximum => 250 )
+
+	test "explicit Factory transfer test" do
+		assert_difference('Organization.count',3) {	#	aliquot also creates an Organization
+		assert_difference('Aliquot.count',1) {
+		assert_difference('Transfer.count',1) {
+			transfer = Factory(:transfer)
+			assert_not_nil transfer.aliquot
+			assert_not_nil transfer.from_organization
+			assert_not_nil transfer.to_organization
+		} } }
+	end
+
+	test "should require aliquot" do
+		assert_difference( "Transfer.count", 0 ) do
+			transfer = create_transfer( :aliquot => nil)
+			assert !transfer.errors.on(:aliquot)
+			assert  transfer.errors.on_attr_and_type?(:aliquot_id,:blank)
+		end
+	end
+
+	test "should require valid aliquot" do
+		assert_difference( "Transfer.count", 0 ) do
+			transfer = create_transfer( :aliquot_id => 0)
+			assert !transfer.errors.on(:aliquot_id)
+			assert  transfer.errors.on_attr_and_type?(:aliquot,:blank)
+		end
+	end
+
+	test "should require from_organization" do
+		assert_difference( "Transfer.count", 0 ) do
+			transfer = create_transfer( :from_organization => nil)
+			assert !transfer.errors.on(:from_organization)
+			assert  transfer.errors.on_attr_and_type?(:from_organization_id,:blank)
+		end
+	end
+
+	test "should require valid from_organization" do
+		assert_difference( "Transfer.count", 0 ) do
+			transfer = create_transfer( :from_organization_id => 0)
+			assert !transfer.errors.on(:from_organization_id)
+			assert  transfer.errors.on_attr_and_type?(:from_organization,:blank)
+		end
+	end
+
+	test "should require to_organization" do
+		assert_difference( "Transfer.count", 0 ) do
+			transfer = create_transfer( :to_organization => nil)
+			assert !transfer.errors.on(:to_organization)
+			assert  transfer.errors.on_attr_and_type?(:to_organization_id,:blank)
+		end
+	end
+
+	test "should require valid to_organization" do
+		assert_difference( "Transfer.count", 0 ) do
+			transfer = create_transfer( :to_organization_id => 0)
+			assert !transfer.errors.on(:to_organization_id)
+			assert  transfer.errors.on_attr_and_type?(:to_organization,:blank)
+		end
+	end
+
+#protected
+#
+#	def create_transfer(options={})
+#		transfer = Factory.build(:transfer,options)
+#		transfer.save
+#		transfer
+#	end
+
+end

data/test/unit/ccls/translation_table_test.rb

@@ -0,0 +1,40 @@
+require 'test_helper'
+
+class Ccls::TranslationTableTest < ActiveSupport::TestCase
+
+	test "YNDK valid values" do
+		assert_equal YNDK.valid_values, [1,2,999]
+	end
+
+	test "YNDK selector options" do
+		assert_equal YNDK.selector_options, [['Yes',1],['No',2],["Don't Know",999]]
+	end
+
+	test "YNODK valid values" do
+		assert_equal YNODK.valid_values, [1,2,3,999]
+	end
+
+	test "YNODK selector options" do
+		assert_equal YNODK.selector_options, 
+			[['Yes',1],['No',2],['Other',3],["Don't Know",999]]
+	end
+
+	test "YNRDK valid values" do
+		assert_equal YNRDK.valid_values, [1,2,999,888]
+	end
+
+	test "YNRDK selector options" do
+		assert_equal YNRDK.selector_options, 
+			[['Yes',1],['No',2],["Don't Know",999],['Refused',888]]
+	end
+
+	test "ADNA valid values" do
+		assert_equal ADNA.valid_values, [1,2,555,999]
+	end
+
+	test "ADNA selector options" do
+		assert_equal ADNA.selector_options, 
+			[['Agree',1],['Do Not Agree',2],['N/A',555],["Don't Know",999]]
+	end
+
+end

data/test/unit/ccls/unit_test.rb

@@ -0,0 +1,21 @@
+require 'test_helper'
+
+class Ccls::UnitTest < ActiveSupport::TestCase
+
+	assert_should_behave_like_a_hash
+
+	assert_should_create_default_object
+	assert_should_act_as_list
+	assert_should_have_many( :aliquots, :samples )
+	assert_should_belong_to( :context )
+	assert_should_not_require_attributes( :position, :context_id )
+
+	test "explicit Factory unit test" do
+		assert_difference('Unit.count',1) {
+			unit = Factory(:unit)
+			assert_match /Key\d*/, unit.key
+			assert_match /Desc\d*/, unit.description
+		}
+	end
+
+end

data/test/unit/ccls/user_test.rb

@@ -0,0 +1,156 @@
+require 'test_helper'
+
+class Ccls::UserTest < ActiveSupport::TestCase
+
+	assert_should_require(:uid)
+	assert_should_require_unique(:uid)
+	assert_should_habtm(:roles)
+
+	test "should create user" do
+		assert_difference 'User.count' do
+			user = create_user
+			assert !user.new_record?, "#{user.errors.full_messages.to_sentence}"
+			assert !user.may_administrate?
+		end
+	end
+
+	test "should create reader" do
+		assert_difference 'User.count' do
+			user = create_user
+			user.roles << Role.find_by_name('reader')
+			assert  user.is_reader?
+			assert  user.may_read?
+			assert !user.is_administrator?
+			assert !user.may_administrate?
+			assert !user.new_record?, "#{user.errors.full_messages.to_sentence}"
+		end
+	end
+
+	test "should create interviewer" do
+		assert_difference 'User.count' do
+			user = create_user
+			user.roles << Role.find_by_name('interviewer')
+			assert  user.is_interviewer?
+			assert  user.may_interview?
+			assert  user.may_read?
+			assert !user.is_administrator?
+			assert !user.may_administrate?
+			assert !user.new_record?, "#{user.errors.full_messages.to_sentence}"
+		end
+	end
+
+	test "should create editor" do
+		assert_difference 'User.count' do
+			user = create_user
+			user.roles << Role.find_by_name('editor')
+			assert  user.is_editor?
+			assert  user.may_edit?
+			assert  user.may_interview?
+			assert  user.may_read?
+			assert !user.is_administrator?
+			assert !user.may_administrate?
+			assert !user.new_record?, "#{user.errors.full_messages.to_sentence}"
+		end
+	end
+
+	test "should create administrator" do
+		assert_difference 'User.count' do
+			user = create_user
+			user.roles << Role.find_by_name('administrator')
+			assert  user.is_administrator?
+			assert  user.may_edit?
+			assert  user.may_interview?
+			assert  user.may_read?
+			assert  user.may_administrate?
+
+			assert user.may_view_permissions?
+			assert user.may_create_user_invitations?
+			assert user.may_view_users?
+			assert user.may_assign_roles?
+#			assert user.may_edit_subjects?
+#			assert user.may_moderate?
+#			assert user.moderator?
+#			assert user.editor?
+			assert user.may_maintain_pages?
+#			assert user.may_view_home_page_pics?
+#			assert user.may_view_calendar?
+#			assert user.may_view_packages?
+#			assert user.may_view_subjects?
+#			assert user.may_view_dust_kits?
+#			assert user.may_view_home_exposures?
+#			assert user.may_edit_addresses?
+#			assert user.may_edit_enrollments?
+#			assert user.employee?
+#			assert user.may_view_responses?
+#			assert user.may_take_surveys?
+#			assert user.may_view_study_events?
+#			assert user.may_create_survey_invitations?
+			assert user.may_view_user?
+			assert user.is_user?(user)
+			assert user.may_be_user?(user)
+			assert user.may_share_document?('document')
+			assert user.may_view_document?('document')
+
+			assert !user.new_record?, "#{user.errors.full_messages.to_sentence}"
+		end
+	end
+
+	test "should create superuser" do
+		assert_difference 'User.count' do
+			user = create_user
+			user.roles << Role.find_by_name('superuser')
+			assert  user.is_superuser?
+			assert  user.is_super_user?
+			assert  user.may_administrate?
+			assert  user.may_edit?
+			assert  user.may_interview?
+			assert  user.may_read?
+			assert  user.may_administrate?
+			assert !user.new_record?, "#{user.errors.full_messages.to_sentence}"
+		end
+	end
+
+	test "should deputize to create administrator" do
+		u = create_user
+		assert !u.role_names.include?('administrator')
+		u.deputize
+		assert  u.role_names.include?('administrator')
+	end
+
+	test "should return non-nil mail" do
+		user = create_user
+		assert_not_nil user.mail
+	end
+	test "should respond to roles" do
+		user = create_user
+		assert user.respond_to?(:roles)
+	end
+
+	test "should have many roles" do
+		u = create_user
+		assert_equal 0, u.roles.length
+		roles = Role.all
+		assert roles.length > 0
+		roles.each do |role|
+			assert_difference("User.find(#{u.id}).role_names.length") {
+			assert_difference("User.find(#{u.id}).roles.length") {
+				u.roles << role
+			} }
+		end
+	end
+
+	test "should return displayname as to_s" do
+		user = create_user(:displayname => "Mr Test")
+		assert_equal user.displayname, "Mr Test"
+		assert_equal user.displayname, "#{user}"
+	end
+
+#protected
+#
+#	def create_user(options = {})
+#		user = Factory.build(:user,options)
+#		user.save
+#		user
+#	end
+	
+end