The BitMacro Blog » Category » Rails

vendors/rails/

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

require '../test_helper'

class AdminLoginTest < ActionController::IntegrationTest
  context 'An employee' do
    setup do
      @employee = Factory(:employee)
    end

    should 'be able to login with a valid username and password' do
      visit '/admin'
      assert https?
      assert_equal '/admin/sessions/new', path
      fills_in 'Email', :with => @employee.user.email
      fills_in 'Password', :with => @employee.user.password
      clicks_button 'Log In'
      assert_equal @employee.user.id, session[:user_id]
    end

    should 'be denied access with an invalid username or password' do
      visit '/admin'
      assert https?
      assert_equal '/admin/sessions/new', path
      fills_in 'Email', :with => @employee.user.email
      fills_in 'Password', :with => 'wrongpassord'
      clicks_button 'Log In'
      assert_nil session[:user_id]
    end
  end
end

1
2
3
4
5
6
7
8
9
10
11
12

# Sequences

Factory.sequence :name do |n|
  'name' + n.to_s
end

# Manufacturers

Factory.define :manufacturer do |m|
  m.name Factory.next(:name)
  m.active true
end

1
2
3
4
5

class Manufacturer < ActiveRecord::Base

  validates_uniqueness_of :name

end

1
2
3
4
5
6
7
8
9

require File.dirname(__FILE__) + '/../test_helper'

class ProductTest < ActiveSupport::TestCase

  setup do
    2.times { Factory(:manufactuer) }
  end

end

m.name { Factory.next(:name) }
1
2
3

class Supplier < ActiveRecord::Base
  validates_uniqueness_of :name   
end

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

def validates_each(*attrs)
  options = attrs.last.is_a?(Hash) ? attrs.pop.symbolize_keys : {}
  attrs   = attrs.flatten

  # Declare the validation.
  send(validation_method(options[:on] || :save)) do |record|
    # Don't validate when there is an :if condition and that condition is false
    unless options[:if] && !evaluate_condition(options[:if], record)
      attrs.each do |attr|
        value = record.send(attr)
        next if value.nil? && options[:allow_nil]
        yield record, attr, value
      end
    end
  end
end

send(validation_method(options[:on] || :save)) do |record|
1
2
3
4
5
6
7

def validation_method(on)
  case on
    when :save   then :validate
    when :create then :validate_on_create
    when :update then :validate_on_update
  end
end
1
2
3

class Supplier &gt; ActiveRecord::Base
  validates_uniqueness_of :name, :on => :create   
end
1
2
3
4

def validate(*methods, &block)
  methods << block if block_given?
  write_inheritable_set(:validate, methods)
end
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

def valid?
  errors.clear

  run_validations(:validate)
  validate

  if new_record?
    run_validations(:validate_on_create)
    validate_on_create
  else
    run_validations(:validate_on_update)
    validate_on_update
  end

  errors.empty?
end
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

def run_validations(validation_method)
  validations = self.class.read_inheritable_attribute(validation_method.to_sym)
  if validations.nil? then return end
  validations.each do |validation|
    if validation.is_a?(Symbol)
      self.send(validation)
    elsif validation.is_a?(String)
      eval(validation, binding)
    elsif validation_block?(validation)
      validation.call(self)
    elsif validation_class?(validation, validation_method)
      validation.send(validation_method, self)
    else
      raise(
        ActiveRecordError,
        "Validations need to be either a symbol, string (to be eval'ed), proc/method, or " +
         "class implementing a static validation method"
      )
    end
  end
end
1
2
3
4
5
6
7

def save_with_validation(perform_validation = true)
  if perform_validation && valid? || !perform_validation
    save_without_validation
  else
    false
  end
end
1
2
3
4
5
6
7
8

def alias_method_chain(target, feature)
  # Strip out punctuation on predicates or bang methods since
  # e.g. target?_without_feature is not a valid method name.
  aliased_target, punctuation = target.to_s.sub(/([?!=])$/, ''), $1
  yield(aliased_target, punctuation) if block_given?
  alias_method "#{aliased_target}_without_#{feature}#{punctuation}", target
  alias_method target, "#{aliased_target}_with_#{feature}#{punctuation}"
end
1
2

alias_method :foo_without_feature, :foo
alias_method :foo, :foo_with_feature
1
2
3
4
5
6
7
8
9
10
11
12
13

# * No record exists: Creates a new record with values 
#   matching those of the object attributes.
# * A record does exist: Updates the record with 
#   values matching those of the object attributes.
def save
  create_or_update
end

# Attempts to save the record, but instead of just returning false if it couldn't happen, 
# it raises a RecordNotSaved exception
def save!
  create_or_update || raise(RecordNotSaved)
end
1
2
3
4
5

def create_or_update
  raise ReadOnlyRecord if readonly?
  result = new_record? ? create : update
  result != false
end
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

# Updates the associated record with values matching those of the instance attributes.
# Returns the number of affected rows.
def update
  connection.update(
    "UPDATE #{self.class.table_name} " +
    "SET #{quoted_comma_pair_list(connection, attributes_with_quotes(false))} " +
    "WHERE #{connection.quote_column_name(self.class.primary_key)} = #{quote_value(id)}",
    "#{self.class.name} Update"
  )
end

# Creates a record with values matching those of the instance attributes
# and returns its id.
def create
  if self.id.nil? && connection.prefetch_primary_key?(self.class.table_name)
    self.id = connection.next_sequence_value(self.class.sequence_name)
  end

  self.id = connection.insert(
    "INSERT INTO #{self.class.table_name} " +
    "(#{quoted_column_names.join(', ')}) " +
    "VALUES(#{attributes_with_quotes.values.join(', ')})",
    "#{self.class.name} Create",
    self.class.primary_key, self.id, self.class.sequence_name
  )

  @new_record = false
  id
end
1
2
3
4
5
6
7
8

def self.included(base) # :nodoc:
  base.extend ClassMethods
  base.class_eval do
    alias_method_chain :save, :validation
    alias_method_chain :save!, :validation
    alias_method_chain :update_attribute, :validation_skipping
  end
end
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

# The validation process on save can be skipped by passing false. The regular Base#save method
# is replaced with this when the validations module is mixed in, which it is by default.
def save_with_validation(perform_validation = true)
  if perform_validation && valid? || !perform_validation
    save_without_validation
  else
    false
  end
end

# Attempts to save the record just like Base#save but will raise a RecordInvalid exception 
# instead of returning false if the record is not valid.
def save_with_validation!
  if valid?
    save_without_validation!
  else
    raise RecordInvalid.new(self)
  end
end
1
2
3
4
5
6

class Post < ActiveRecord::Base

  validates_presence_of :title
  validates_length_of :title, :minimum => 2

end
1
2
3
4
5
6
7
8
9
10
11
12
13

# Taken from 
# http://wincent.com/knowledge-base/Fixtures_considered_harmful%3F
class Hash
  # for excluding keys
  def except(*exclusions)
    self.reject { |key, value| exclusions.include? key.to_sym }
  end

  # for overriding keys
  def with(overrides = {})
    self.merge overrides
  end
end
1
2
3
4
5
6
7
8
9
10

require File.dirname(__FILE__) + '/../spec_helper'
module PostSpecHelper
  def valid_post_attributes
    {
      :title => "rSpec is Great"
      :body => "rSpec is a fun way to write documentation 
        and test your application at the same time"
    }
  end
end
1
2
3
4
5
6
7
8
9
10

describe Post do
  include PostSpecHelper
  before(:each) do
    @post = Post.new
    @post.attributes = valid_post_attributes
  end
  it do
    @post.should be_valid
  end
end
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

describe Post, "with a title that is 1 character long" do
  include PostSpecHelper
  before(:each) do
    @post = Post.new
    @post.attributes = valid_post_attributes.with(:title => "r")
  end

  it do
    @post.should_not be_valid
  end

  it "should have an error on title" do
    @post.should have(1).error_on(:title)
  end
end
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

describe Post, "with a blank title" do
  include PostSpecHelper
  before(:each) do
    @post = Post.new
    @post.attributes = valid_post_attributes.except(:title)
  end

  it do
    @post.should_not be_valid
  end

  it "should have an error on title" do
    @post.should have(1).error_on(:title)
  end
end

Shoulda + Factory_Girl + Webrat for Rails Integration Tests

Factory_Girl Sequences as Lazy Attributes

Dissecting Rails Validations - Part II

The loading of the built-in validators

Can't find that Rails Method? (alias_method_chain)

Dissecting Rails Validations - Part I

The road from save to validation.

Lose the fixtures with rSpec

RailsConf 2007

Categories

Months

Recently

Search

Blogs I Read

License

Promotion