We can build this relationship using self-referential associations, and a model as a join table. We’ll call the joining model Follow.

class CreateFollows < ActiveRecord::Migration
  def self.up
    create_table :follows do |t|
      t.integer :follower_id
      t.integer :followed_id
      ...

Next, we can add the follower and followed associations to the our new Follow model.

class Follow < ActiveRecord::Base
  belongs_to :follower, :class_name => "User"
  belongs_to :followed, :class_name => "User"
end

Lastly, we can set up the self-referential associations in the User model.

class User < ActiveRecord::Base
  has_many :follows, :foreign_key => "follower_id", :class_name => "Follow", :dependent => :destroy
  has_many :users_followed, :through => :follows, :source => :followed
 
  has_many :followings, :foreign_key => "followed_id", :class_name => "Follow", :dependent => :destroy
  has_many :users_following, :through => :followings, :source => :follower
end

This allows the User to be both followed and a follower. See this blog post for a good explanation of self-referential associations.

Your controller can look basically like this:

class FollowsController < ApplicationController
 
  def create
    @follow = current_user.follows.build(:followed_id => params[:followed_id])
    if @follow.save
      flash[:notice] = "You are now following #{@follow.followed.name}"
      redirect_to user_path(@follow.followed)
    else
      flash[:error] = "Unable to follow."
      redirect_to user_path(@follow.followed)
    end
  end
 
  def destroy
    @follow = current_user.follows.find_by_followed_id(params[:followed_id])
    @follow.destroy
    flash[:notice] = "Removed follow."
    redirect_to user_path(params[:followed_id])
  end
 
end

This post assumes you already have Cucumber, Authlogic and Machinist setup and bootstrapped. If not, see these links first: Cucumber, Authlogic, Machinist.

When writing your Cucumber stories you will inevitably come across scenarios like the following:

Scenario: User fills in profile
   Given I am a logged in user
   And I am on the My Profile page
   ...

How do you setup a logged in user? First, you need create a Machinist blueprint for your user.

User.blueprint do
  username 'test_user'
  email 'test@user.com'
  password 'spacemonkey'
  password_confirmation 'spacemonkey'
end

Next you will need to create step definitions for your login stories. Here are a few handy functions that can make the step of creating a logged in user easier and more module:

1
2
3
4
5
6
7
8
9
10
11

def user
   @user ||= User.make
end
 
def login
  user
  visit '/login'
  fill_in("Email", :with => user.email)
  fill_in("Password", :with => user.password)
  click_button("Login")
end

Next we can create the login step:

12
13
14

Given /^I am a logged in user$/ do
   login
end

Now the Given I am a logged in user step should pass.

In your other Cucumber step definitions it will come in handy to be able to use Authlogic’s built in current_user method in your Cucumber steps. Since the current_user method apply to users, you can add it to your user_steps.rb file within a module:

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

module UserHelpers
  def current_user_session
    return @current_user_session if defined?(@current_user_session)
    @current_user_session = UserSession.find
  end
 
  def current_user
    return @current_user if defined?(@current_user)
    @current_user = current_user_session && current_user_session.user
  end
end
World(UserHelpers)

Now you should be able to easily run tests involving the logged in session. For example, to make the And I am on the My Profile page step pass you will have to add the path to your path.rb file. In the path reference we can now make use of Authlogic’s current_user method:

1
2
3
4
5
6
7
8
9
10

module NavigationHelpers
 
  def path_to(page_name)
    case page_name
 
    when /the My Profile page/
      user_path(current_user)
    end
end
World(NavigationHelpers)

Another useful step to add to your user steps is one which creates multiple users. The following step can be used to make a specific amount of users:

15
16
17
18
19
20

Given /^there exists at least (\d+) other user$/ do |number|
   @users = []
   number.scan(/\d/).join.to_i.times do |i|
      @users[i] = User.make
   end
end

In the end your user_steps.rb file should look like: