Discovery (Animal Planet)

describe "#by_category_id" do
      let(:given_category) do 
        Factory.create(:given_category)
      end
 

      let(:product_in_given_category) do
        Factory.create(
          :product,
          :categories => [category]
        )
      end

      let(:product_not_in_given_category) do
        Factory.create(
          :product,
          :categories => [Factory.create(:category)]
        )
      end

      # This might be tricky to redefine subject as the finder result
      # but in this way we can delegate the matcher to subject and 
      # avoid writing test descriptions.
      subject { Product.by_category_id(given_category.id) }

      it { should discover(product_in_given_category) }
      it { should_not discover(product_not_in_given_category) }

    end

def let!(name, &block)
  let(name, &block)
  before { __send__(name) } 
end

Testing sort order

describe "#most_commented named scope" do
  let(:uncommented_post) { Factory.create(:post)}
  let!(:less_commented_post) { Factory.create(:post, :comments => [Factory.build(:comment)])}
  let!(:more_commented_post) { 
    Factory.create(:post, :comments => [Factory.build(:comment), Factory.build(:comment)])}
  }

  subject { described_class.most_commented }
 it {should discover(more_commented_post, less_commented_post).with_exact_order }
 it {should_not discover(uncommented_post) }
end

Summary

Existing solutions

it { should validate_numericality_of(:age, :greater_than => 18, :only_integer => true) }

Easy DSL and Implementation

describe User do
  it { should accept_values_for(:email, “john@example.com”, “lambda@gusiev.com”) }
  it { should_not accept_values_for(:email, “invalid”, nil, “a@b”, “john@.com”) }
end

validates_uniqueness_of

describe User do
  context "if user with email 'aa@bb.com' exists" do
    before do
      User.create!(@valid_attributes.merge(:email => 'aa@bb.com')
    end
    it { should_not accept_values_for(:email, “aa@bb.com”) }
  end
end

Summary

How the flat controller architecture goes to hell

class UsersController < ApplicationController
#
# Filters
#
skip_before_filter :check_user_is_valid, :only => [:edit, :update]
before_filter :require_user, :only => [
:update, :edit, :settings, :disconnect_twitter, :connect_facebook_account, :google_contacts
]

before_filter :load_user, :except => [
:index, :new, :create, :remote_validate_email, :autocomplete_for_user_full_name,
:remote_validate_facebook_uid, :google_contacts
]

before_filter :check_permissions, :only => [ :edit, :update, :settings, :update_photo, :connect_facebook_account ]

before_filter :load_invitation, :only => [:new, :create]
before_filter :ensure_authenticated_to_facebook, :only => :connect_facebook_account
before_filter :initialize_form, :only => [:edit]

#
# And 20 almost independent actions goes here
# And the twice longer tests file for this controller
#

end

Namespaces and nesting

map.resources :categories do |c|
  c.namespace :categories do |categories|
    categories.resouces :projects
  end
end
map.resources :users do |u|
  c.namespace :users do |users|
    users.resouces :projects
  end
end

class Categories::ProjectsController

  def index
    @projects = ....
  end
end

class Users::ProjectsController

  def index
    @projects = ....
  end
end

class Users::TwitterConnectionController < ApplicationController

  def create
  end

  def destroy
  end
end

Out of scope

class ArticlesController 

  def {new, create, update, edit, destroy}
  end

  def publish
    @article.publish!
    redirect_to articles_path
  end

end

Some sugar from generators

$ ./script/generate rspec_controller users/categories
      create  app/controllers/users
      create  app/helpers/users
      create  app/views/users/categories
      create  spec/controllers/users
      create  spec/helpers/users
      create  spec/views/users/categories
      create  spec/controllers/users/categories_controller_spec.rb
      create  spec/helpers/users/categories_helper_spec.rb
      create  app/controllers/users/categories_controller.rb
      create  app/helpers/users/categories_helper.rb

Drawbacks

class Users::ProjectController

 include UserNestedResource

end

Summary

<a> Delete</a>
<a> Edit</a>

• By order(first, second) will cause problems if designer would like to change the order.
• By id will fail if you would have a list of elements where each has these links
• By label is just a fuck up and won’t work for multi language application

<a class="js-new-comment big-blue-button"> New Comment </a>

<input type='button' class="js-follow-button follow-button"> Follow this person </input>

class A
  private
  def implementation
    puts 'private A'
  end
end

class B < A
  def api
    implementation
  end
end

B.new.api

class A
  def api
    self.implementation #exception here
  end
  private
  def implementation
    puts 'private A'
  end
end

A.new.api

class A
  def api(another) #suppose to receive an instance of a
    implementation == another.implementation
  end
  protected
  def implementation
    puts 'private A'
  end
end
A.new.api(A.new)

named_scope :network_of, lambda {|user|
{
:select => "u.*"
:from => "users u, followings f1, followings f2",
:conditions => "f1.follower_id = #{user.id} AND " + 
"f1.followed_id = f2.follower_id AND " +
"f2.followed_id = u.id"
}

:select => "users.*"
:from => "followings f1, followings f2, users",
:conditions => "f1.follower_id = #{user.id} AND " + 
"f1.followed_id = f2.follower_id AND " +
"f2.followed_id = users.id"

module LoggedModel
  def after_save
    super
    handle_logging
  end
end

describe LoggableModel
  it "should be loggable" do
    LoggableModel.should ...
  end
end

class MyModel
  include LoggableModel
  def after_save
    do_some_other_thing
  end
end

shared_examples_for "logged model" do
  it "should be loggable" do
    subject.should...
  end
end

describe MyModel do
  it_should_behave_like 'loggable model'
end

• Object hierarchy
• Normalized database model

• Do it as fast as possible
• Customer wants!