ccls-common_lib 1.4.0

data/lib/common_lib/active_support_extension.rb

@@ -0,0 +1,12 @@
+module CommonLib::ActiveSupportExtension; end
+if defined?(Rails) and Rails.env == 'test'
+require 'common_lib/active_support_extension/test_case'
+require 'common_lib/active_support_extension/associations'
+require 'common_lib/active_support_extension/assertions'
+require 'common_lib/active_support_extension/attributes'
+
+#	due to the complications of rake and autotest using
+#	differing versions of Test::Unit and MiniTest
+#	I have modified and am reincluding pending
+require 'common_lib/active_support_extension/pending'
+end

data/lib/common_lib/active_support_extension/assertions.rb

@@ -0,0 +1,108 @@
+module CommonLib::ActiveSupportExtension::Assertions
+
+	def self.included(base)
+		base.extend(ClassMethods)
+	end
+
+	def assert_blank obj, msg = nil
+		msg ||= "Expected '#{obj}' to be blank"
+		assert obj.blank?, msg
+	end
+
+	module ClassMethods
+
+		def assert_should_create_default_object(*args)
+			options = {}
+			options.update(args.extract_options!)
+			model = options[:model] || model_name_without_test
+
+			test "should create default #{model.underscore}" do
+				assert_difference( "#{model}.count", 1 ) do
+					object = create_object
+					assert !object.new_record?, 
+						"#{object.errors.full_messages.to_sentence}"
+				end
+			end
+		end
+
+		def assert_should_behave_like_a_hash(*args)
+			options = {
+				:key => :key,
+				:value => :description
+			}
+			options.update(args.extract_options!)
+			model = options[:model] || model_name_without_test
+
+			assert_should_require_attribute( options[:key], options[:value] )
+			assert_should_require_unique_attribute( options[:key], options[:value] )
+			assert_should_require_attribute_length( options[:key], options[:value],
+				:maximum => 250 )
+
+			test "should find by key with ['string']" do
+				object = create_object
+				assert object.is_a?(model.constantize)
+				found = (model.constantize)[object.key.to_s]
+				assert found.is_a?(model.constantize)
+				assert_equal object, found
+			end
+
+			test "should find by key with [:symbol]" do
+				object = create_object
+				assert object.is_a?(model.constantize)
+				found = (model.constantize)[object.key.to_sym]
+				assert found.is_a?(model.constantize)
+				assert_equal object, found
+			end
+
+		end	#	def assert_should_behave_like_a_hash(*args)
+
+		def assert_should_accept_only_good_values(*attributes)
+			options = {
+				:good_values => [],
+				:bad_values  => []
+			}
+			options.update(attributes.extract_options!)
+			model = options[:model] || model_name_without_test
+
+			attributes.flatten.each do |field|
+
+				[options[:bad_values]].flatten.each do |value|
+
+#	could be a naming problem if both nil and blank are passed
+
+					test "should NOT allow #{value||'nil'} for #{field}" do
+#						object = model.constantize.new(field => value)
+#	what if field is protected?
+						object = model.constantize.new
+						object.send("#{field}=", value)
+						assert_equal object.send(field), value
+						object.valid?
+						assert object.errors.matching?(field,'is not included in the list')
+					end
+
+				end
+
+				[options[:good_values]].flatten.each do |value|
+		
+#	could be a naming problem if both nil and blank are passed
+
+					test "should allow #{value||'nil'} for #{field}" do
+#						object = model.constantize.new(field => value)
+#	what if field is protected?
+						object = model.constantize.new
+						object.send("#{field}=", value)
+						assert_equal object.send(field), value
+						object.valid?
+						assert !object.errors.include?(field)
+					end
+
+				end
+		
+			end	#	attributes.flatten.each do |field|
+
+		end	#	def assert_should_accept_only_good_values(*attributes)
+
+	end	#	module ClassMethods
+
+end	#	module ActiveSupportExtension::Assertions
+ActiveSupport::TestCase.send(:include,CommonLib::ActiveSupportExtension::Assertions)

data/lib/common_lib/active_support_extension/associations.rb

@@ -0,0 +1,154 @@
+module CommonLib::ActiveSupportExtension::Associations
+
+	def self.included(base)
+		base.extend ClassMethods
+		base.class_eval do 
+			class << self
+				alias_methods = {
+					:should_have_many                  => :should_have_many_,
+					:should_have_many_associations     => :should_have_many_
+				}
+				alias_methods.each do |alias_name,method_name|
+					alias_method( "assert_#{alias_name}",
+						"assert_#{method_name}" ) unless
+							self.method_defined?("assert_#{alias_name}")
+				end # alias_methods.each
+			end # class << self
+		end # base.class_eval
+	end # def self.included
+
+	module ClassMethods
+
+		def assert_should_initially_belong_to(*associations)
+			options = associations.extract_options!
+			model = options[:model] || model_name_without_test
+			associations.each do |assoc|
+				class_name = ( assoc = assoc.to_s ).camelize
+				title = "#{brand}should initially belong to #{assoc}"
+				if !options[:class_name].blank?
+					title << " ( #{options[:class_name]} )"
+					class_name = options[:class_name].to_s
+				end
+				test title do
+					object = create_object
+					assert_not_nil object.send(assoc)
+					if object.send(assoc).respond_to?(
+						"#{model.underscore.pluralize}_count")
+						assert_equal 1, object.reload.send(assoc).send(
+							"#{model.underscore.pluralize}_count")
+					end
+					if !options[:class_name].blank?
+						assert object.send(assoc).is_a?(class_name.constantize)
+					end
+				end
+			end
+		end
+
+		def assert_should_belong_to(*associations)
+			options = associations.extract_options!
+			model = options[:model] || model_name_without_test
+			associations.each do |assoc|
+				class_name = ( assoc = assoc.to_s ).camelize
+				title = "#{brand}should belong to #{assoc}" 
+				if !options[:class_name].blank?
+					title << " ( #{options[:class_name]} )"
+					class_name = options[:class_name].to_s
+				end
+				test title do
+					object = create_object
+					assert_nil object.send(assoc)
+					object.send("#{assoc}=",send("create_#{class_name.underscore}"))
+					assert_not_nil object.send(assoc)
+					assert object.send(assoc).is_a?(class_name.constantize
+						) unless options[:polymorphic]
+#	Paperclip attachments don't get deleted on rollback.
+#	So we much destroy the object, and therefore the attachment, by hand.
+#	Only seems to matter with ...
+#		BirthDatumTest#assert_should_belong_to( :birth_datum_update )
+#		but does't seem to cause a problem elsewhere.
+object.send(assoc).destroy
+object.destroy
+				end
+			end
+		end
+
+		def assert_should_have_one(*associations)
+			options = associations.extract_options!
+			model = options[:model] || model_name_without_test
+			associations.each do |assoc|
+				assoc = assoc.to_s
+				test "#{brand}should have one #{assoc}" do
+					object = create_object
+					assert_nil object.reload.send(assoc)
+					send("create_#{assoc}", model.underscore => object )
+					assert_not_nil object.reload.send(assoc)
+					object.send(assoc).destroy
+					assert_nil object.reload.send(assoc)
+				end
+			end
+		end
+
+		def assert_should_have_many_(*associations)
+			options = associations.extract_options!
+			model = options[:model] || model_name_without_test
+			associations.each do |assoc|
+				class_name = ( assoc = assoc.to_s ).camelize
+				title = "#{brand}should have many #{assoc}"
+				if !options[:class_name].blank?
+					title << " ( #{options[:class_name]} )"
+					class_name = options[:class_name].to_s
+				end
+				if !options[:as].blank?
+					title << " ( as #{options[:as]} )"
+				end
+				test title do
+					object = create_object
+					assert_equal 0, object.send(assoc).length
+					command = ["create_#{class_name.singularize.underscore}"]
+					if !options[:foreign_key].blank?
+						command.push( options[:foreign_key].to_sym => object.id )
+					elsif !options[:as].blank?
+						command.push( options[:as].to_sym => object )
+					else
+						command.push( model.underscore => object )
+					end
+					send *command
+					assert_equal 1, object.reload.send(assoc).length
+					if object.respond_to?("#{assoc}_count")
+						assert_equal 1, object.reload.send("#{assoc}_count")
+					end
+					send *command
+					assert_equal 2, object.reload.send(assoc).length
+					if object.respond_to?("#{assoc}_count")
+						assert_equal 2, object.reload.send("#{assoc}_count")
+					end
+				end
+			end
+		end
+
+		def assert_should_habtm(*associations)
+			options = associations.extract_options!
+			model = options[:model] || model_name_without_test
+			associations.each do |assoc|
+				assoc = assoc.to_s
+				test "#{brand}should habtm #{assoc}" do
+					object = create_object
+					assert_equal 0, object.send(assoc).length
+					object.send(assoc) << send("create_#{assoc.singularize}")
+					assert_equal 1, object.reload.send(assoc).length
+					if object.respond_to?("#{assoc}_count")
+						assert_equal 1, object.reload.send("#{assoc}_count")
+					end
+					object.send(assoc) << send("create_#{assoc.singularize}")
+					assert_equal 2, object.reload.send(assoc).length
+					if object.respond_to?("#{assoc}_count")
+						assert_equal 2, object.reload.send("#{assoc}_count")
+					end
+				end
+			end
+		end
+
+	end	# ClassMethods
+
+end	# module ActiveSupportExtension::Associations
+ActiveSupport::TestCase.send(:include, CommonLib::ActiveSupportExtension::Associations)

data/lib/common_lib/active_support_extension/attributes.rb

@@ -0,0 +1,296 @@
+module CommonLib::ActiveSupportExtension::Attributes
+
+	def self.included(base)
+		base.extend ClassMethods
+		base.class_eval do 
+			class << self
+				alias_methods = {
+					:not_require_unique_attributes => :not_require_unique_attribute,
+					:not_require_unique            => :not_require_unique_attribute,
+					:require_unique_attributes  => :require_unique_attribute,
+					:require_unique             => :require_unique_attribute,
+					:require_attributes_not_nil => :require_attribute_not_nil,
+					:require_not_nil            => :require_attribute_not_nil,
+					:require_attributes         => :require_attribute,
+					:require                    => :require_attribute,
+					:not_require_attributes     => :not_require_attribute,
+					:not_require                => :not_require_attribute,
+					:require_attributes_length  => :require_attribute_length,
+					:require_length             => :require_attribute_length,
+					:protect_attributes         => :protect_attribute,
+					:protect                    => :protect_attribute,
+					:not_protect_attributes     => :not_protect_attribute,
+					:not_protect                => :not_protect_attribute
+				}
+				alias_methods.each do |alias_name,method_name|
+					alias_method( "assert_should_#{alias_name}", 
+						"assert_should_#{method_name}" ) unless
+							self.method_defined?("assert_should_#{alias_name}")
+				end	#	alias_methods.each
+			end	#	class << self
+		end	#	base.class_eval
+	end	# def self.included
+
+	module ClassMethods
+
+		def assert_should_not_require_unique_attribute(*attributes)
+			options = attributes.extract_options!
+			
+			attributes.flatten.each do |attr|
+				attr = attr.to_s
+				title = "#{brand}should not require unique #{attr}"
+				scope = options[:scope]
+				unless scope.blank?
+					title << " scope "
+					title << (( scope.is_a?(Array) ) ? scope.join(',') : scope.to_s )
+				end
+				test title do
+					o = create_object
+					attrs = { attr.to_sym => o.send(attr) }
+					if( scope.is_a?(String) || scope.is_a?(Symbol) )
+						attrs[scope.to_sym] = o.send(scope.to_sym)
+					elsif scope.is_a?(Array)
+						scope.each do |s|
+							attrs[s.to_sym] = o.send(s.to_sym)
+						end
+					end 
+					object = create_object(attrs)
+					assert !object.errors.matching?(attr,'has already been taken'),
+						object.errors.full_messages.to_sentence
+				end
+			end
+		end
+
+		def assert_should_require_unique_attribute(*attributes)
+			options = attributes.extract_options!
+			model = options[:model] || model_name_without_test
+			
+			attributes.flatten.each do |attr|
+				attr = attr.to_s
+				title = "#{brand}should require unique #{attr}"
+				scope = options[:scope]
+				unless scope.blank?
+					title << " scope "
+					title << (( scope.is_a?(Array) ) ? scope.join(',') : scope.to_s)
+				end
+				test title do
+					o = create_object
+					assert_no_difference "#{model}.count" do
+						attrs = { attr.to_sym => o.send(attr) }
+						if( scope.is_a?(String) || scope.is_a?(Symbol) )
+							attrs[scope.to_sym] = o.send(scope.to_sym)
+						elsif scope.is_a?(Array)
+							scope.each do |s|
+								attrs[s.to_sym] = o.send(s.to_sym)
+							end
+						end 
+						object = create_object(attrs)
+						assert object.errors.matching?(attr,'has already been taken'),
+							object.errors.full_messages.to_sentence
+					end
+				end
+			end
+		end
+
+		def assert_should_require_attribute_not_nil(*attributes)
+			options = attributes.extract_options!
+			model = options[:model] || model_name_without_test
+			
+			attributes.flatten.each do |attr|
+				attr = attr.to_s
+				test "#{brand}should require #{attr} not nil" do
+					object = model.constantize.new
+					object.send("#{attr}=", nil)
+					assert !object.valid?
+					#		message could be a number of things ...
+					# "is not included in the list","can't be blank"
+					assert object.errors.include?(attr.to_sym),
+						object.errors.full_messages.to_sentence
+				end
+			end
+		end
+
+		def assert_should_require_attribute(*attributes)
+			options = attributes.extract_options!
+			model = options[:model] || model_name_without_test
+			
+			attributes.flatten.each do |attr|
+				attr = attr.to_s
+				test "#{brand}should require #{attr}" do
+					object = model.constantize.new
+					object.send("#{attr}=", nil)
+					assert !object.valid?
+					assert object.errors.include?(attr.to_sym),
+						object.errors.full_messages.to_sentence
+					assert object.errors.matching?(attr,"can't be blank") ||
+						object.errors.matching?(attr,'is too short'),
+						object.errors.full_messages.to_sentence
+				end
+			end
+		end
+
+		def assert_should_not_require_attribute(*attributes)
+			options = attributes.extract_options!
+			model = options[:model] || model_name_without_test
+			
+			attributes.flatten.each do |attr|
+				attr = attr.to_s
+				test "#{brand}should not require #{attr}" do
+					object = model.constantize.new
+					object.send("#{attr}=", nil)
+					#	don't know if it will be true or false, but must be called
+					object.valid?	
+					assert !object.errors.include?(attr.to_sym),
+						object.errors.full_messages.to_sentence
+					if attr =~ /^(.*)_id$/
+						assert !object.errors.include?($1.to_sym),
+							object.errors.full_messages.to_sentence
+					end
+				end
+			end
+		end
+
+		def assert_should_require_attribute_length(*attributes)
+			options = attributes.extract_options!
+			model = options[:model] || model_name_without_test
+
+			if( ( options.keys & [:in,:within] ).length >= 1 )
+				range = options[:in]||options[:within]
+				options[:minimum] = range.min
+				options[:maximum] = range.max
+			end
+			
+			attributes.flatten.each do |attr|
+				attr = attr.to_s
+				if options.keys.include?(:is)
+					length = options[:is]
+					test "#{brand}should require exact length of #{length} for #{attr}" do
+						value = 'x'*(length-1)
+						object = model.constantize.new
+						object.send("#{attr}=", value)
+						assert !object.valid?
+						assert_equal length-1, object.send(attr.to_sym).length
+						assert_equal object.send(attr.to_sym), value
+						assert object.errors.include?(attr.to_sym),
+							object.errors.full_messages.to_sentence
+						assert object.errors.matching?(attr,'is the wrong length'),
+							object.errors.full_messages.to_sentence
+
+						value = 'x'*(length+1)
+						object = model.constantize.new
+						object.send("#{attr}=", value)
+						assert !object.valid?
+						assert_equal length+1, object.send(attr.to_sym).length
+						assert_equal object.send(attr.to_sym), value
+						assert object.errors.include?(attr.to_sym),
+							object.errors.full_messages.to_sentence
+						assert object.errors.matching?(attr,'is the wrong length'),
+							object.errors.full_messages.to_sentence
+					end
+				end
+
+				if options.keys.include?(:minimum)
+					min = options[:minimum]
+					test "#{brand}should require min length of #{min} for #{attr}" do
+						value = 'x'*(min)
+						object = model.constantize.new
+						object.send("#{attr}=", value)
+						#	don't know if really valid
+						object.valid?
+						assert_equal min, object.send(attr.to_sym).length
+						assert_equal object.send(attr.to_sym), value
+						assert !object.errors.matching?(attr,'is too short'),
+							object.errors.full_messages.to_sentence
+
+						value = 'x'*(min-1)
+						object = model.constantize.new
+						object.send("#{attr}=", value)
+						assert !object.valid?
+						assert_equal min-1, object.send(attr.to_sym).length
+						assert_equal object.send(attr.to_sym), value
+						assert object.errors.include?(attr.to_sym),
+							object.errors.full_messages.to_sentence
+						assert object.errors.matching?(attr,'is too short'),
+							object.errors.full_messages.to_sentence
+					end
+				end
+
+				if options.keys.include?(:maximum)
+					max = options[:maximum]
+					test "#{brand}should require max length of #{max} for #{attr}" do
+						value = 'x'*(max)
+						object = model.constantize.new
+						object.send("#{attr}=", value)
+						#	don't know if really valid
+						object.valid?
+						assert_equal max, object.send(attr.to_sym).length
+						assert_equal object.send(attr.to_sym), value
+						assert !object.errors.matching?(attr,'is too long'),
+							object.errors.full_messages.to_sentence
+
+						value = 'x'*(max+1)
+						object = model.constantize.new
+						object.send("#{attr}=", value)
+						assert !object.valid?
+						assert_equal max+1, object.send(attr.to_sym).length
+						assert_equal object.send(attr.to_sym), value
+						assert object.errors.include?(attr.to_sym),
+							object.errors.full_messages.to_sentence
+						assert object.errors.matching?(attr,'is too long'),
+							object.errors.full_messages.to_sentence
+					end
+				end
+
+			end
+		end
+
+		def assert_should_protect_attribute(*attributes)
+			options = attributes.extract_options!
+			model = options[:model] || model_name_without_test
+			
+			attributes.flatten.each do |attr|
+				attr = attr.to_s
+				test "#{brand}should protect attribute #{attr}" do
+					assert model.constantize.accessible_attributes||model.constantize.protected_attributes,
+						"Both accessible and protected attributes are empty"
+					assert !(model.constantize.accessible_attributes||[]).include?(attr),
+						"#{attr} is included in accessible attributes"
+					if !model.constantize.protected_attributes.nil?
+						assert model.constantize.protected_attributes.include?(attr),
+							"#{attr} is not included in protected attributes"
+					end
+				end
+			end
+		end
+
+#	>> Abstract.accessible_attributes
+#	=> #<ActiveModel::MassAssignmentSecurity::WhiteList: {}>
+
+#	>> Abstract.protected_attributes
+#	=> #<ActiveModel::MassAssignmentSecurity::BlackList: {"study_subject", "entry_2_by_uid", "entry_1_by_uid", "id", "type", "study_subject_id", "merged_by_uid"}>
+
+		def assert_should_not_protect_attribute(*attributes)
+			options = attributes.extract_options!
+			model = options[:model] || model_name_without_test
+			
+			attributes.flatten.each do |attr|
+				attr = attr.to_s
+				test "#{brand}should not protect attribute #{attr}" do
+					assert !model.constantize.protected_attributes.include?(attr),
+						"#{attr} is included in protected attributes"
+
+#	Rails 3 change
+#	apparently no longer always true
+#					if !model.accessible_attributes.nil?
+#						assert model.accessible_attributes.include?(attr),
+#							"#{attr} is not included in accessible attributes"
+#					end
+
+				end
+			end
+		end
+
+	end
+
+end	# module ActiveSupportExtension::Attributes
+ActiveSupport::TestCase.send(:include, CommonLib::ActiveSupportExtension::Attributes)