jakewendt-rails_extension 2.0.22

data/lib/rails_extension/action_controller_extension/routing.rb

@@ -0,0 +1,23 @@
+module RailsExtension::ActionControllerExtension::Routing
+
+	def self.included(base)
+		base.extend ClassMethods
+	end
+
+	module ClassMethods
+
+#		def assert_route
+#		end
+
+		def assert_no_route(verb,action,args={})
+			test "#{brand}no route to #{verb} #{action} #{args}" do
+				assert_raise(ActionController::RoutingError){
+					send(verb,action,args)
+				}
+			end
+		end
+
+	end	# module ClassMethods
+end	#	module RailsExtension::ActionControllerExtension::Routing
+ActionController::TestCase.send(:include, 
+	RailsExtension::ActionControllerExtension::Routing)

data/lib/rails_extension/action_controller_extension/test_case.rb

@@ -0,0 +1,19 @@
+module RailsExtension::ActionControllerExtension::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 RailsExtension::ActionControllerExtension::TestCase
+ActionController::TestCase.send(:include,
+	RailsExtension::ActionControllerExtension::TestCase)

data/lib/rails_extension/active_record_extension.rb

@@ -0,0 +1,5 @@
+require 'active_record'
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'active_record_extension/base'
+require 'active_record_extension/errors'
+require 'active_record_extension/error'

data/lib/rails_extension/active_record_extension/base.rb

@@ -0,0 +1,82 @@
+module RailsExtension::ActiveRecordExtension::Base
+	def self.included(base)
+		base.extend(ClassMethods)
+	end
+
+	module ClassMethods
+
+		def random
+			count = count()
+			if count > 0
+				first(:offset => rand(count))
+			else
+				nil
+			end
+		end
+
+		def validates_absence_of(*attr_names)
+			configuration = { :on => :save,
+				:message => "is present and must be absent." }
+			configuration.update(attr_names.extract_options!)
+
+			send(validation_method(configuration[:on]), configuration) do |record|
+				attr_names.each do |attr_name|
+					unless record.send(attr_name).blank?
+						record.errors.add(attr_name, 
+							ActiveRecord::Error.new(record,attr_name,:present,
+								{ :message => configuration[:message] }))
+					end
+				end
+			end
+		end
+
+		def validates_past_date_for(*attr_names)
+			configuration = { :on => :save,
+				:message => "is in the future and must be in the past." }
+			configuration.update(attr_names.extract_options!)
+
+			send(validation_method(configuration[:on]), configuration) do |record|
+				attr_names.each do |attr_name|
+					date = record.send(attr_name)
+					if !date.blank? && Time.now < date
+						record.errors.add(attr_name, 
+							ActiveRecord::Error.new(record,attr_name,:not_past_date,
+								{ :message => configuration[:message] }))
+					end
+				end
+			end
+		end
+
+		#	This doesn't work as one would expect if the column
+		#	is a DateTime instead of just a Date.
+		#	For some reason, *_before_type_cast actually
+		#	returns a parsed DateTime?
+		def validates_complete_date_for(*attr_names)
+			configuration = { :on => :save,
+				:message => "is not a complete date." }
+			configuration.update(attr_names.extract_options!)
+
+			send(validation_method(configuration[:on]), configuration) do |record|
+				attr_names.each do |attr_name|
+
+					value = record.send("#{attr_name}_before_type_cast")
+					unless( configuration[:allow_nil] && value.blank? ) ||
+						( !value.is_a?(String) )
+						date_hash = Date._parse(value)
+						unless date_hash.has_key?(:year) &&
+							date_hash.has_key?(:mon) &&
+							date_hash.has_key?(:mday)
+							record.errors.add(attr_name, 
+								ActiveRecord::Error.new(record,attr_name,:not_complete_date,
+									{ :message => configuration[:message] }))
+						end
+					end
+				end
+			end
+		end
+
+	end
+
+end
+ActiveRecord::Base.send(:include,
+	RailsExtension::ActiveRecordExtension::Base)

data/lib/rails_extension/active_record_extension/error.rb

@@ -0,0 +1,18 @@
+module RailsExtension::ActiveRecordExtension::Error
+
+	def self.included(base)
+		base.alias_method_chain( :generate_full_message, :attribute_strip ) unless
+			base.method_defined?(:generate_full_message_without_attribute_strip)
+	end
+
+	def generate_full_message_with_attribute_strip(options = {}, &block)
+		m = generate_full_message_without_attribute_strip(options, &block)
+		unless( ( i = m.index('<|X|') ).nil? )
+			m = m[i+4..-1]
+		end
+		m
+	end
+	
+end
+ActiveRecord::Error.send(:include,
+	RailsExtension::ActiveRecordExtension::Error)

data/lib/rails_extension/active_record_extension/errors.rb

@@ -0,0 +1,20 @@
+module RailsExtension::ActiveRecordExtension::Errors
+	def self.included(base)
+		base.extend(ClassMethods)
+		base.send(:include,InstanceMethods)
+	end
+	module InstanceMethods
+		def on_attr_and_type(attribute,type)
+			attribute = attribute.to_s
+			return nil unless @errors.has_key?(attribute)
+			@errors[attribute].collect(&:type).include?(type)
+		end
+	end
+	module ClassMethods
+		def delete(key)
+			@errors.delete(key.to_s)
+		end
+	end
+end	#	RailsExtension::ActiveRecordExtension::Errors
+ActiveRecord::Errors.send(:include,
+	RailsExtension::ActiveRecordExtension::Errors)

data/lib/rails_extension/active_support_extension.rb

@@ -0,0 +1,29 @@
+require 'active_support'
+require 'active_support/test_case'
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'active_support_extension/test_case'
+require 'active_support_extension/associations'
+require 'active_support_extension/attributes'
+require 'active_support_extension/pending'
+
+
+Rails.backtrace_cleaner.add_silencer {|line|
+#	line =~ /\/test\/.*\.\.\/declarative\.rb:/
+#	Due to my modification, every error is accompanied by 
+#		3 additional and unnecessary lines like ...
+#	/test/functional/../declarative.rb:21:in `_test_should_change_locale_to_es_without_verbosity'
+#/test/functional/../declarative.rb:21:in `send'
+#/test/functional/../declarative.rb:21:in `_test_should_change_locale_to_es_with_verbosity']:
+#
+#	in rvm/jruby the error is passing through
+#	test/declarative.rb:21:in `_test_should_NOT_create_new_user_if_invitation_update_fails_with_verbosity']:
+
+#     /Users/jakewendt/github_repo/jakewendt/ucb_ccls_clic/vendor/plugins/ucb_ccls_engine/rails/../test/helpers/declarative.rb:21:in `_test_AWiHTTP_should_get_show_with_admin_login_with_verbosity'
+
+#	This doesn't seem to work at all in the plugin engine.
+#	line =~ /test.*\/declarative\.rb:/
+#	line =~ /simply_testable\/declarative\.rb:/
+
+#	Return true or false.  Need to collect if adding multiple conditions.
+	line =~ /rails_extension\/active_support_extension\/test_case\.rb:/
+} if defined? Rails 

data/lib/rails_extension/active_support_extension/associations.rb

@@ -0,0 +1,209 @@
+module RailsExtension::ActiveSupportExtension::Associations
+
+	def self.included(base)
+		base.extend ClassMethods
+#		base.send(:include,InstanceMethods)
+		base.class_eval do 
+			class << self
+				alias_methods = {
+					:should_have_many                  => :should_have_many_,
+					:should_have_many_associations     => :should_have_many_,
+					:should_require_valid_associations => :requires_valid_associations,
+					:should_require_valid_association  => :requires_valid_associations,
+					:requires_valid_association        => :requires_valid_associations,
+					:requires_valid                    => :requires_valid_associations
+				}
+				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] || 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
+				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("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
+
+		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
+
+	end	# ClassMethods
+
+end	# module RailsExtension::Associations
+ActiveSupport::TestCase.send(:include,
+	RailsExtension::ActiveSupportExtension::Associations)

data/lib/rails_extension/active_support_extension/attributes.rb

@@ -0,0 +1,235 @@
+module RailsExtension::ActiveSupportExtension::Attributes
+
+	def self.included(base)
+		base.extend ClassMethods
+#		base.send(:include,InstanceMethods)
+		base.class_eval do 
+			class << self
+				alias_methods = {
+					: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_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
+
+		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
+
+		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
+
+		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
+
+		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
+
+		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
+
+		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
+
+	end
+
+end	# module RailsExtension::Attributes
+ActiveSupport::TestCase.send(:include,
+	RailsExtension::ActiveSupportExtension::Attributes)