jakewendt-simply_testable 1.6.0

data/lib/simply_testable/action_controller_extension/test_case.rb

@@ -0,0 +1,23 @@
+module SimplyTestable::ActionControllerExtension
+module TestCase
+
+	def turn_https_on
+		@request.env['HTTPS'] = 'on'
+#		@request.env['HTTP_X_FORWARDED_PROTO'] == 'https'
+	end
+
+	def turn_https_off
+		@request.env['HTTPS'] = nil
+	end
+
+	def assert_layout(layout)
+		layout = "layouts/#{layout}" unless layout.match(/^layouts/)
+		assert_equal layout, @response.layout
+	end
+
+end	#	module TestCase
+end	#	module SimplyTestable::ActionControllerExtension
+require 'action_controller'
+require 'action_controller/test_case'
+ActionController::TestCase.send(:include,
+	SimplyTestable::ActionControllerExtension::TestCase)

data/lib/simply_testable/acts_as_list.rb

@@ -0,0 +1,41 @@
+module SimplyTestable::ActsAsList
+
+	def self.included(base)
+		base.extend ClassMethods
+#		base.send(:include,InstanceMethods)
+	end
+
+	module ClassMethods
+
+		def assert_should_act_as_list(*args)
+			options = args.extract_options!
+			scope = options[:scope]
+
+			test "#{brand}should act as list" do
+				model = create_object.class.name
+				model.constantize.destroy_all
+				object = create_object
+				assert_equal 1, object.position
+				attrs = {}
+				Array(scope).each do |attr|
+					attrs[attr.to_sym] = object.send(attr)
+				end if scope
+				object = create_object(attrs)
+				assert_equal 2, object.position
+
+				# gotta be a relative test as there may already
+				# by existing objects (unless I destroy them)
+				assert_difference("#{model}.last.position",1) do
+					create_object(attrs)
+				end
+			end
+
+		end
+
+	end
+
+end	# module SimplyTestable::ActsAsList
+require 'active_support'
+require 'active_support/test_case'
+ActiveSupport::TestCase.send(:include,
+	SimplyTestable::ActsAsList)

data/lib/simply_testable/assertions.rb

@@ -0,0 +1,49 @@
+module SimplyTestable::Assertions
+
+	def self.included(base)
+		base.extend ClassMethods
+		base.send(:include,InstanceMethods)
+	end
+
+	module ClassMethods
+
+	end	# ClassMethods
+
+	module InstanceMethods
+
+		#	basically a copy of assert_difference, but
+		#	without any explicit comparison as it is 
+		#	simply stating that something will change
+		#	(designed for updated_at)
+		def assert_changes(expression, message = nil, &block)
+			b = block.send(:binding)
+			exps = Array.wrap(expression)
+			before = exps.map { |e| eval(e, b) }
+			yield
+			exps.each_with_index do |e, i|
+				error = "#{e.inspect} didn't change"
+				error = "#{message}.\n#{error}" if message
+				assert_not_equal(before[i], eval(e, b), error)
+			end
+		end
+
+		#	Just a negation of assert_changes
+		def deny_changes(expression, message = nil, &block)
+			b = block.send(:binding)
+			exps = Array.wrap(expression)
+			before = exps.map { |e| eval(e, b) }
+			yield
+			exps.each_with_index do |e, i|
+				error = "#{e.inspect} changed"
+				error = "#{message}.\n#{error}" if message
+				assert_equal(before[i], eval(e, b), error)
+			end
+		end
+
+	end	#	InstanceMethods
+
+end	# module SimplyTestable::Assertions
+require 'active_support'
+require 'active_support/test_case'
+ActiveSupport::TestCase.send(:include,
+	SimplyTestable::Assertions)

data/lib/simply_testable/associations.rb

@@ -0,0 +1,222 @@
+module SimplyTestable::Associations
+
+	def self.included(base)
+		base.extend ClassMethods
+#		base.send(:include,InstanceMethods)
+	end
+
+	module ClassMethods
+
+		def assert_should_initially_belong_to(*associations)
+			options = associations.extract_options!
+			model = options[:model] || st_model_name
+			
+			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] || st_model_name
+			
+			associations.each do |assoc|
+				class_name = ( assoc = assoc.to_s ).camelize
+				title = "#{brand}should belong to #{assoc}" 
+#				if !options[:as].blank?
+#					title << " as #{options[:as]}"
+#					as = options[:as]
+#				end
+				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]
+				end
+
+			end
+
+		end
+
+		def assert_should_have_one(*associations)
+			options = associations.extract_options!
+			model = options[:model] || st_model_name
+			
+#			foreign_key = if !options[:foreign_key].blank?
+#				options[:foreign_key].to_sym
+#			else
+#				"#{model.underscore}_id".to_sym
+#			end
+
+			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}", foreign_key => object.id)
+					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] || st_model_name
+
+#			foreign_key = if !options[:foreign_key].blank?
+#				options[:foreign_key].to_sym
+#			else
+#				"#{model.underscore}_id".to_sym
+#			end
+
+			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
+				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 )
+					else
+						command.push( model.underscore => object )
+					end
+#					send("create_#{class_name.singularize.underscore}", foreign_key => object.id)
+#					send("create_#{class_name.singularize.underscore}", model.underscore => object )
+					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("create_#{class_name.singularize.underscore}", foreign_key => object.id)
+#					send("create_#{class_name.singularize.underscore}", model.underscore => object )
+					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
+		alias_method :assert_should_have_many, 
+			:assert_should_have_many_
+		alias_method :assert_should_have_many_associations, 
+			:assert_should_have_many_
+
+		def assert_should_habtm(*associations)
+			options = associations.extract_options!
+			model = options[:model] || st_model_name
+			
+			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
+
+		def assert_requires_valid_associations(*associations)
+#				options = associations.extract_options!
+#				model = options[:model] || st_model_name
+#	
+#				associations.each do |assoc|
+#					as = assoc = assoc.to_s
+#					as = options[:as] if !options[:as].blank?
+#	
+#					test "#{brand}should require foreign key #{as}_id" do
+#						assert_difference("#{model}.count",0) do
+#							object = create_object("#{as}_id".to_sym => nil)
+#							assert object.errors.on("#{as}_id".to_sym)
+#						end
+#					end
+#	
+#	#				test "#{brand}should require valid foreign key #{as}_id" do
+#	#					assert_difference("#{model}.count",0) do
+#	#						object = create_object("#{as}_id".to_sym => 0)
+#	#						assert object.errors.on("#{as}_id".to_sym)
+#	#					end
+#	#				end
+#	
+#					title = "#{brand}should require valid association #{assoc}"
+#					title << " as #{options[:as]}" if !options[:as].blank?
+#					test title do
+#						assert_difference("#{model}.count",0) { 
+#							object = create_object(
+#								assoc.to_sym => Factory.build(assoc.to_sym))
+#	#							as.to_sym => Factory.build(assoc.to_sym))
+#							assert object.errors.on("#{as}_id".to_sym)
+#						}    
+#					end 
+#	
+#				end
+
+		end
+		alias_method :assert_should_require_valid_associations,
+			:assert_requires_valid_associations
+		alias_method :assert_should_require_valid_association,
+			:assert_requires_valid_associations
+		alias_method :assert_requires_valid_association,
+			:assert_requires_valid_associations
+		alias_method :assert_requires_valid,
+			:assert_requires_valid_associations
+
+	end	# ClassMethods
+
+end	# module SimplyTestable::Associations
+require 'active_support'
+require 'active_support/test_case'
+ActiveSupport::TestCase.send(:include,
+	SimplyTestable::Associations)

data/lib/simply_testable/attributes.rb

@@ -0,0 +1,240 @@
+module SimplyTestable::Attributes
+
+	def self.included(base)
+		base.extend ClassMethods
+#		base.send(:include,InstanceMethods)
+	end
+
+	module ClassMethods
+
+		def assert_should_require_unique_attribute(*attributes)
+			options = attributes.extract_options!
+			model = options[:model] || st_model_name
+			
+			attributes.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.on_attr_and_type(attr.to_sym, :taken)
+					end
+				end
+			end
+		end
+		alias_method :assert_should_require_unique_attributes, 
+			:assert_should_require_unique_attribute
+		alias_method :assert_should_require_unique, 
+			:assert_should_require_unique_attribute
+
+		def assert_should_require_attribute_not_nil(*attributes)
+			options = attributes.extract_options!
+			model = options[:model] || st_model_name
+			
+			attributes.each do |attr|
+				attr = attr.to_s
+				test "#{brand}should require #{attr} not nil" do
+					assert_no_difference "#{model}.count" do
+						object = create_object(attr.to_sym => nil)
+						assert object.errors.on(attr.to_sym)
+					end
+				end
+			end
+		end
+		alias_method :assert_should_require_attributes_not_nil,
+			:assert_should_require_attribute_not_nil
+		alias_method :assert_should_require_not_nil,
+			:assert_should_require_attribute_not_nil
+
+		def assert_should_require_attribute(*attributes)
+			options = attributes.extract_options!
+			model = options[:model] || st_model_name
+			
+			attributes.each do |attr|
+				attr = attr.to_s
+				test "#{brand}should require #{attr}" do
+					assert_no_difference "#{model}.count" do
+						object = create_object(attr.to_sym => nil)
+						assert object.errors.on_attr_and_type(attr.to_sym, :blank) ||
+							object.errors.on_attr_and_type(attr.to_sym, :too_short)
+					end
+				end
+			end
+		end
+		alias_method :assert_should_require_attributes, 
+			:assert_should_require_attribute
+		alias_method :assert_should_require, 
+			:assert_should_require_attribute
+
+		def assert_should_not_require_attribute(*attributes)
+			options = attributes.extract_options!
+			model = options[:model] || st_model_name
+			
+			attributes.each do |attr|
+				attr = attr.to_s
+				test "#{brand}should not require #{attr}" do
+					assert_difference( "#{model}.count", 1 ) do
+						object = create_object(attr.to_sym => nil)
+						assert !object.errors.on(attr.to_sym)
+						if attr =~ /^(.*)_id$/
+							assert !object.errors.on($1.to_sym)
+						end
+					end
+				end
+			end
+		end
+		alias_method :assert_should_not_require_attributes, 
+			:assert_should_not_require_attribute
+		alias_method :assert_should_not_require, 
+			:assert_should_not_require_attribute
+
+		def assert_should_require_attribute_length(*attributes)
+			options = attributes.extract_options!
+			model = options[:model] || st_model_name
+
+			if( ( options.keys & [:in,:within] ).length >= 1 )
+				range = options[:in]||options[:within]
+				options[:minimum] = range.min
+				options[:maximum] = range.max
+			end
+			
+			attributes.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
+						assert_no_difference "#{model}.count" do
+							value = 'x'*(length-1)
+							object = create_object(attr.to_sym => value)
+							assert_equal length-1, object.send(attr.to_sym).length
+							assert_equal object.send(attr.to_sym), value
+							assert object.errors.on_attr_and_type(attr.to_sym, :wrong_length)
+						end
+						assert_no_difference "#{model}.count" do
+							value = 'x'*(length+1)
+							object = create_object(attr.to_sym => value)
+							assert_equal length+1, object.send(attr.to_sym).length
+							assert_equal object.send(attr.to_sym), value
+							assert object.errors.on_attr_and_type(attr.to_sym, :wrong_length)
+						end
+					end
+				end
+
+				if options.keys.include?(:minimum)
+					min = options[:minimum]
+					test "#{brand}should require min length of #{min} for #{attr}" do
+#	because the model may have other requirements
+#	just check to ensure that we don't get a :too_short error
+#						assert_difference "#{model}.count" do
+							value = 'x'*(min)
+							object = create_object(attr.to_sym => value)
+							assert_equal min, object.send(attr.to_sym).length
+							assert_equal object.send(attr.to_sym), value
+							assert !object.errors.on_attr_and_type(attr.to_sym, :too_short)
+#						end
+						assert_no_difference "#{model}.count" do
+							value = 'x'*(min-1)
+							object = create_object(attr.to_sym => value)
+							assert_equal min-1, object.send(attr.to_sym).length
+							assert_equal object.send(attr.to_sym), value
+							assert object.errors.on_attr_and_type(attr.to_sym, :too_short)
+						end
+					end
+				end
+
+				if options.keys.include?(:maximum)
+					max = options[:maximum]
+					test "#{brand}should require max length of #{max} for #{attr}" do
+#	because the model may have other requirements
+#	just check to ensure that we don't get a :too_long error
+#						assert_difference "#{model}.count" do
+							value = 'x'*(max)
+							object = create_object(attr.to_sym => value)
+							assert_equal max, object.send(attr.to_sym).length
+							assert_equal object.send(attr.to_sym), value
+							assert !object.errors.on_attr_and_type(attr.to_sym, :too_long)
+#						end
+						assert_no_difference "#{model}.count" do
+							value = 'x'*(max+1)
+							object = create_object(attr.to_sym => value)
+							assert_equal max+1, object.send(attr.to_sym).length
+							assert_equal object.send(attr.to_sym), value
+							assert object.errors.on_attr_and_type(attr.to_sym, :too_long)
+						end
+					end
+				end
+
+			end
+		end
+		alias_method :assert_should_require_attributes_length,
+			:assert_should_require_attribute_length
+		alias_method :assert_should_require_length,
+			:assert_should_require_attribute_length
+
+		def assert_should_protect_attribute(*attributes)
+			options = attributes.extract_options!
+			model_name = options[:model] || st_model_name
+			model = model_name.constantize
+			
+			attributes.each do |attr|
+				attr = attr.to_s
+				test "#{brand}should protect attribute #{attr}" do
+					assert model.accessible_attributes||model.protected_attributes,
+						"Both accessible and protected attributes are empty"
+					assert !(model.accessible_attributes||[]).include?(attr),
+						"#{attr} is included in accessible attributes"
+					if !model.protected_attributes.nil?
+						assert model.protected_attributes.include?(attr),
+							"#{attr} is not included in protected attributes"
+					end
+				end
+			end
+		end
+		alias_method :assert_should_protect_attributes, 
+			:assert_should_protect_attribute
+		alias_method :assert_should_protect, 
+			:assert_should_protect_attribute
+
+		def assert_should_not_protect_attribute(*attributes)
+			options = attributes.extract_options!
+			model_name = options[:model] || st_model_name
+			model = model_name.constantize
+			
+			attributes.each do |attr|
+				attr = attr.to_s
+				test "#{brand}should not protect attribute #{attr}" do
+					assert !(model.protected_attributes||[]).include?(attr),
+						"#{attr} is included in protected attributes"
+					if !model.accessible_attributes.nil?
+						assert model.accessible_attributes.include?(attr),
+							"#{attr} is not included in accessible attributes"
+					end
+				end
+			end
+		end
+		alias_method :assert_should_not_protect_attributes, 
+			:assert_should_not_protect_attribute
+		alias_method :assert_should_not_protect, 
+			:assert_should_not_protect_attribute
+
+	end
+
+end	# module SimplyTestable::Attributes
+require 'active_support'
+require 'active_support/test_case'
+ActiveSupport::TestCase.send(:include,
+	SimplyTestable::Attributes)