Bryan Helmkamp - Home

Rack::Bug debugging toolbar in four minutes

2009-04-22T18:23:00Z

Here’s a quick screencast demonstrating Rack::Bug, a new Rack middleware for inspecting requests to any Rack-compatible web application.

Download the screencast (12 MB, 4:00)

The source is on GitHub. It ships with nine panels:

Rails Info
Resource Usage
Rack Env
SQL
AR Objects
Memcached
Templates
Log
Memory Usage

./script/plugin install git://github.com/brynary/rack-bug.git

# config/initializers/middleware.rb
require "rack/bug"

ActionController::Dispatcher.middleware.use Rack::Bug,
  :ip_masks   => [IPAddr.new("127.0.0.1")],
  :secret_key => "epT5uCIchlsHCeR9dloOeAPG66PtHd9K8l0q9avitiaA/KUrY7DE52hD4yWY+8z1",
  :password   => "rack-bug-secret"

Webrat slides from GoGaRuCo

2009-04-18T01:22:00Z

I finally got an internet connection (on the plane wifi) to upload my slide from GoGaRuCo 2009 about Webrat. Couldn’t get them up to SlideShare yet, so I’ll add that tomorrow. (Update: Slides are now up on SlideShare and embedded below.)

Thanks again to Josh and Leah for organizing GoGaRuCo. I had a great time in SF meeting a lot of cool people and learning about all sorts of new technologies I want to try out soon.

Webrat: Rails Acceptance Testing Evolved<object height="355" width="425"><param /><param /><param /><embed src="http://static.slidesharecdn.com/swf/ssplayer2.swf?doc=1316406&rel=0&stripped_title=webrat-rails-acceptance-testing-evolved" height="355" width="425"></embed></object>

View more presentations from brynary.

Download the slides as a PDF (1.9 MB)

Note: The talks were recorded, so a full video of my presentation should be online soon.

Switching Webrat to Selenium mode

2009-04-06T18:36:00Z

Ryan Bates did a great job covering Webrat in Railscast #156, and I’d recommend anyone who hasn’t used Webrat check it out. It’s a clear demonstration of how you can start using Webrat in a few minutes today with Rails built-in integration testing framework. Webrat works with RSpec, Cucumber, Shoulda, etc. too, but they aren’t required.

Unfortunately, during the screencast some Webrat bugs prevented running the tests in Selenium mode. Webrat has worked with Selenium for some time, but there have been some lingering rough edges around getting it up and running that I’ve been meaning to resolve. Today I’m happy to report those issues are now fixed, and getting started using Selenium with Webrat should now be drop-dead simple.

Give it a try by checking out the full Episode #156 source code, then make the following changes:

# config/environments/test.rb
config.gem "webrat", :version => ">=0.4.4" # was 0.4.3

# test/test_helper.rb
class ActiveSupport::TestCase
  # ...
  self.use_transactional_fixtures = false # was true

  # ...

  # Add these lines:
  setup do |session|
    session.host! "localhost:3001"
  end
end
  
Webrat.configure do |config|
  config.mode = :selenium # was :rails
end

Running the test again should pop open a Firefox window for the running tests and print output like this:

$ rake test:integration
(in /Users/bhelmkamp/p/railscasts-episodes/episode-156/authenticator)
Loaded suite /Library/Ruby/Gems/1.8/gems/rake-0.8.4/lib/rake/rake_test_loader
Started
==> Waiting for Selenium RC server on port 4444... Ready!
==> Waiting for rails application server on port 3001... Ready!
..
Finished in 11.679288 seconds.

2 tests, 2 assertions, 0 failures, 0 errors

Success!

Note: I just pushed Webrat 0.4.4, so it might not be available on all the gem sever mirrors yet. If not, you can install it with the following commands:

git clone git://github.com/brynary/webrat.git
cd webrat
rake install_gem

Speaking about Webrat at GoGaRuCo

2009-03-31T01:12:00Z

Thanks to all those kind attendees who voted for my talk proposal, I’ve been invited to speak at GoGaRuCo in San Francisco on April 17-18th. My talk is titled Webrat: Rails Acceptance Testing Evolved, and I’m especially excited for two reasons:

The conference looks like it will be excellent. There are lots of talks I’m looking forward to seeing, Josh and Leah are doing a great job as organizers (harder than it looks!), and it’s in a cool city I haven’t visited before.
This is the first time I’ll be giving a talk about Webrat specifically, rather than covering Webrat as part of a broader topic. The project is almost a year and a half old now, and there’s plenty of interesting bits to talk about these days.

The conference is sold out, but if you’re going you should say hello. I’m always up for chatting about Ruby, scaling or testing, and grabbing a beer. Should be easy to find, and you can message me as @brynary on Twitter.

Rack::Test released: Simply test any Rack-compatible app

2009-03-05T04:14:00Z

Today I’m happy to announce the first release of a new library I’ve been cooking up: Rack::Test. It’s a simple API for issuing fake requests to any Rack app (e.g. Rails, Sinatra, Merb, etc.) similar to what you might be familiar with in Rails’ integration tests or Merb’s request specs. Basically, I extracted Merb’s request helper code into a small, reusable, framework agnostic library. Here’s an example:

require "rack/test"

class HomepageTest < Test::Unit::TestCase
  include Rack::Test::Methods
  
  def app
    MyApp.new
  end
  
  def test_redirect_logged_in_users_to_dashboard
    authorize "bryan", "secret"
    get "/"
    follow_redirect!
    
    assert_equal "http://example.org/redirected", last_request.url
    assert last_response.ok?
  end
end

While developing Webrat, I started to realize all of the Ruby web frameworks were reinventing boilerplate code to create a test environment for issuing fake requests. They all have to:

Convert params hashes into encoded strings (something the browser handles for normal requests)
Maintain a simulated cooke jar to enable sessions
Generate multipart requests (to support test file uploads)

Through discussions with Josh Knowles and Yehuda Katz, it became apparent that an abstracted layer for these concerns would be valuable.

With Rack::Test, we hope to make it easy for frameworks to encourage their users to write tests by making it trivial to provide a testing environment. We’d like to foster compatibility between Ruby web app testing environments (especially important as ideas like multi-framework apps become more prominent). The philosophy is the library should stay small and extendable so frameworks can layer on additional functionality they want to offer without modifying Rack::Test’s core behavior or resorting to monkeypatching.

The Rack::Test API

The full RDoc is available on gitrdoc, but I’ve reproduced some of it below. It should feel familiar if you’re used to Rails integration testing or Merb request specs:

Rack::Test.initialize(app) — Initialize a new session for the given Rack app

#get(uri, params = {}, env = {}) — Issue a GET request for the given URI with the given params and Rack environment. Stores the issues request object in #last_request and the app’s response in #last_response. Yield #last_response to a block if given.

#post, #put, #delete, and #head — Behave like #get but specifying a different HTTP method

#request(uri, env = {}) — Issue a request to the Rack app for the given URI and optional Rack environment. Stores the issues request object in #last_request and the app’s response in #last_response. Yield #last_response to a block if given.

#follow_redirect! — Rack::Test does not follow any redirects automatically. This method will follow the redirect returned in the last response. If the last response was not a redirect, an error will be raised.

#header(name, value) — Set a header to be included on all subsequent requests through the session. Use a value of nil to remove a previously configured header.

#authorize(username, password)— Set the username and password for HTTP Basic authorization, to be included in subsequent requests in the HTTP_AUTHORIZATION header.

#last_request — Return the last request issued in the session. Raises an error if no requests have been sent yet.

#last_response — Return the last response received in the session. Raises an error if no requests have been sent yet.</macro:code>

Note: Thanks to the people who helped get Rack::Test off the ground: The Merb Team for their request helper code; Yehuda Katz and Josh Knowles for guidance, encouragement and support; Simon Rozet and Pat Nakajima for early code contributions.

Cucumber step definition tip: Stubbing time

2009-02-03T04:09:00Z

When writing Cucumber scenarios, you'll occasionally need to describe a behavior that is dependent on time passing. For example, at weplay we want to ensure that a password reset link expires after one week.

In a RSpec code example, you might be used to stubbing time in this situation:

123	now = Time.nowTime.stub!(:now).and_return(now + 8.days)

This doesn't work out-of-the-box in a Cucumber step definition. By default, Cucumber doesn't include any of RSpec's mocking or stubbing support. This makes sense because Cucumber is a tool for acceptance testing (full stack), where stubbing and especially mocking should be discouraged and only used for very specific purposes (like stubbing time!).

If you find yourself in this situation, you can enable RSpec's stubbing support in your Cucumber step definitions by adding the following code to env.rb:


require "spec/mocks"

Before do
  $rspec_mocks ||= Spec::Mocks::Space.new
end

After do
  begin
    $rspec_mocks.verify_all
  ensure
    $rspec_mocks.reset_all
  end
end

Now you can go ahead and create a time_steps.rb like this:


When /^(\d+) minutes pass$/ do |minutes|
  now = Time.now
  Time.stub!(:now).and_return(now + minutes.to_i.minutes)
end

When /^(\d+) hours pass$/ do |hours|
  now = Time.now
  Time.stub!(:now).and_return(now + hours.to_i.hours)
end

When /^(\d+) days pass$/ do |days|
  now = Time.now
  Time.stub!(:now).and_return(now + days.to_i.days)
end

RSpec will clear your time stub at the end of each scenario.

The RSpec Book is now in Beta

2009-01-30T04:36:00Z

I’m very happy to report that The RSpec Book, which I’ve been collaborating on, is now available for sale as a Beta Book from the Pragmatic Bookshelf. David Chelimsky posted an announcement to the rspec-users mailing list which sums it up quite well. To quote:

On behalf of all the authors, I’d like to extend a special thank you to all of you who have contributed to the software and the conversation around RSpec, Cucumber, and BDD in general. RSpec would be nothing without the community that has evolved around it, so thank you, thank you, thank you.

Enjoy! And if you do pick it up, please let us know what you think. We’re eager to improve it based on the feedback we get.

features2cards released: Convert Cucumber feature files to PDF task cards

2009-01-20T19:10:00Z

Today I’d like to announce the first real release of features2cards 0.1.1. The code has been sitting in my GitHub repository for awhile now, but I thought it was time to give it a formal release announcement.

features2cards is a simple tool to generate a printable PDF of scenario cards from Cucumber feature files. At weplay, we use this at the start of each sprint to get out Scrum task board up-to-date. Interally, features2cards uses the Cucumber feature parser and Prawn for PDF generation (in native Ruby!).

I’ve uploaded the gem and you should be able to install it off RubyForge very soon:

sudo gem install features2cards

Here’s how you use it:

features2cards features/scale_rails.feature

This will generate a file called cards.pdf in the current directory. Open that up, print it, and you’ve got cards ready to be chopped up and stuck to your Agile task board.

That’s all there is to it for now. Fork away. It’s only 150 lines including whitespace. I’d be happy to add additional formats, color support and other enhancements.

Special thanks to Luke Melia. His pdf-storycards project inspired this.

Setting the git commit author to pair programmers' names

2008-09-01T00:48:00Z

Are you using git? Are you writing all your code that needs to be maintained in pairs? Great. Your commits probably look something like this:

commit a5ab4d39be608280fbea6ba9710aea4593f20bc6
Author: Bryan Helmkamp <bryan@brynary.com>
Date:   Fri Aug 29 18:47:29 2008 -0400

    Some important refactoring LM/BH

Subversion has limited support for tracking authors, so we used to manually add the initials of the programmers working on a changeset for future reference. With git, however, we can specify arbitrary author names for each commit. Now our commits look like this:

commit a5ab4d39be608280fbea6ba9710aea4593f20bc6
Author: Luke Melia and Bryan Helmkamp <developers@weplay.com>
Date:   Fri Aug 29 18:47:29 2008 -0400

    Some important refactoring

To simplify updating the git author configuration as we switch pairs, I whipped up a quick Ruby shell script called pair. Called with a list of developers' initials, it configures the git author name and email fields. Called with no arguments, it unsets the per-project git author configuration so your global settings take effect.

#!/usr/bin/env ruby

# Configures the git author to a list of developers when pair programming
# 
# Usage: pair lm bh (Sets the author to 'Luke Melia and Bryan Helmkamp')
#        pair       (Unsets the author so the git global config takes effect)
# 
# Author: Bryan Helmkamp (http://brynary.com)

#######################################################################
## Configuration

PAIR_EMAIL = "developers@weplay.com"

AUTHORS = {
  "bh" => "Bryan Helmkamp",
  "lm" => "Luke Melia"
  # ...
}

## End of configuration
#######################################################################

unless File.exists?(".git")
  puts "This doesn't look like a git repository."
  exit 1
end

authors = ARGV.map do |initials|
  if AUTHORS[initials.downcase]
    AUTHORS[initials.downcase]
  else
    puts "Couldn't find author name for initials: #{initials}"
    exit 1
  end
end

if authors.any?
  if authors.size == 1
    authors = authors.first
  elsif authors.size == 2
    authors = authors.join(" and ")
  else
    authors = authors[0..-2].join(", ") + " and " + authors.last
  end
  
  `git config user.name '#{authors}'`
  `git config user.email '#{PAIR_EMAIL}'`
  
  puts "user.name = #{authors}"
  puts "user.email = #{PAIR_EMAIL}"
else
  `git config --unset user.name`
  `git config --unset user.email`
  
  puts "Unset user.name and user.email"
end

Note: If you're using GitHub, it's important to choose a PAIR_EMAIL value that does not correspond to a GitHub account. Otherwise, GitHub will resolve the email address to a GitHub user and display their username instead of the value of the author.name. We just made one up.

Our Git deployment workflow

2008-08-03T20:49:00Z

At weplay, we recently switched to pure git version control from git-svn. Now that we've had a couple weeks for the dust to settle, I'd like to share our workflow for managing deployments to our staging and production clusters.

We started by outlining the goals of our system:

All code that's pushed to our staging and production environments must be in GitHub. Nothing goes straight from a local repository to our servers.
Any developer can deploy our most recent work to staging.
Any developer can deploy the code on staging into production. We (try to) avoid deploying anything to production that hasn't been pushed to staging first.
Any developer can see a diff between "What is deployed" and "What I'm about to deploy."
Any developer can branch from the production codebase for time sensitive tweaks and fixes. These need to be staged before they're deployed to production too.
That functionality is available in an automated, safe, easy to use form. (Hint: rake)

We ruled out having "production" and "staging" tags because updating tags across a tree of remotes doesn't seem to work smoothly. We also ruled out doing git merges from master into our staging branch. Our staging server/codebase jumps around from the latest changes to the production code (up to a week old) based on what we need to test, so we really just want to replace it.

We settled on using remote git branches for production and staging on origin and hard resetting them to other branches to simulate a copy. We treat these branches more like tags and never commit to them directly. This has worked great so far.

Here's what our rake tasks look like:

class GitCommands

  def diff_staging
    `git fetch`
    puts `git diff origin/production origin/staging`
  end
  
  def tag_staging(branch_name)
    verify_working_directory_clean
    
    `git fetch`
    `git branch -f staging origin/staging`
    `git checkout staging`
    `git reset --hard origin/#{branch_name}`
    `git push -f origin staging`
    `git checkout master`
    `git branch -D staging`
  end
  
  def tag_production
    verify_working_directory_clean
    
    `git fetch`
    `git branch -f production origin/production`
    `git checkout production`
    `git reset --hard origin/staging`
    `git push -f origin production`
    `git checkout master`
    `git branch -D production`
  end

  def branch_production(branch_name)
    verify_working_directory_clean
    
    `git fetch`
    `git branch -f production origin/production`
    `git checkout production`
    `git branch #{branch_name}`
    `git checkout #{branch_name}`
    `git push origin #{branch_name}`
  end
  
protected

  def verify_working_directory_clean
    return if `git status` =~ /working directory clean/
    raise "Must have clean working directory"
  end
end


namespace :tag do
  desc <<-DESC
    Update the staging branch to prepare for a staging deploy.
    Defaults to master. Optionally specify a BRANCH=name
  DESC
  
  task :staging do
    branch_name = ENV['BRANCH'] || "master"
    GitCommands.new.tag_staging(branch_name)
  end

  desc "Update the remove production branch to prepare for a release"
  task :production => ['diff:staging'] do
    GitCommands.new.tag_production
  end
end

namespace :diff do
  desc "Show the differences between the staging branch and the production branch"
  task :staging do
    GitCommands.new.diff_staging
  end
end

namespace :branch do
  desc "Branch from production for tweaks or bug fixs. Specify BRANCH=name"
  task :production do
    branch_name = ENV['BRANCH']
    raise "You must specify a branch name using BRANCH=name" unless branch_name
    GitCommands.new.branch_production
  end
end

namespace :deploy do
  desc "Tag and deploy staging"
  task :staging => "tag:staging" do
    `cap staging deploy:long`
  end
end

The last one (rake deploy:staging) simply wraps up the common task of tagging our latest code to be pushed to staging and initiating a staging deploy.

Note: To use most of these commands, your local working directory must be clean. If we have outstanding changes in our tree when we need to run them, we use git-stash to temporarily move them out of the way.

Thanks to Scott Chacon for helping us work this out. Be sure to check out his GitCasts and Git Internals PDF.

How I got started programming

2008-06-30T05:02:00Z

Mr. Paul C. Dix tagged me to answer these...

How old were you when you started programming?

I started to understand the concept of programming around age nine or ten. I remember how amazing I thought it was that making the computer do new things didn't require rooms full of special equipment.

How did you get started programming?

A lot of my experiences around this time are blurred together.

My parents got me into a beginner programming course for kids at the local community college. The instructor taught the basics of variables and control structures while the students swapped QBasic games they downloaded at home.

The first program I distinctly remember working on calculated golf handicaps from a series of scores. I wrote it with an elementary school friend in his basement using a copy of Borland C++ he found. We fumbled around with functions like getch and cout without any idea that they stood for.

What was your first language?

Beginners All-purpose Symbolic Instructional Code.

What was the first real program you wrote?

When I joined the website development team at my high school half way though the ninth grade, I took on the task of creating a system to post football scores and statistics to our website. After a frustrating first attempt in Perl, I discovered PHP and rewrote it.

The program allowed our statistician to enter the numbers into a form, saving the web team from having to manually enter all the data from paper print outs. It calculated simple averages and YTD totals.

What languages have you used since you started programming?

In no particular order: QBasic, Visual Basic, Bash, Java, JavaScript, C, C++, Ruby, Perl, PHP, Python, and SQL.

So far, Ruby is my favorite hands down. I'm fortunate enough to say I've never written a line of real production code in either Java or .NET.

What was your first professional programming gig?

The summer before my senior year of high school, I interned in a local government IT applications department. The other developers were doing mostly ASP work, but I built their first PHP application which I deployed on their first Linux server.

Unsatisfied with the maintainability of PHP apps I had built in the past, I developed a Struts-like framework in the process. At this point I was feeling pain with the PHP language and the lack of a suitable web development framework. After a brief exploration into Python, I would soon find relief in Ruby and Rails.

If there is one thing you learned along the way that you would tell new developers, what would it be?

Engage in the community, both locally and online, as much as possible. Attend user group meetings, contribute to mailing lists, blog, go to conferences that look interesting. Surround yourself with other programmers, especially those you admire. You won't regret it.

What's the most fun you've ever had programming?

Solving interesting problems with great developers while building applications with an impact. 'Nuff said.

Up Next

It's entirely optional, of course.

Jack Baty
Lee Bankewitz
Wilson Bilkovich
âˆš David Chelimsky
Luke Melia
âˆš Noah Davis (Edit: Added Noah after he started a blog)

Story Driven Development slides posted

2008-04-26T18:09:00Z

Just wrapped up my Story Driven Development talk at GoRuCo 2008. There were some great questions at the end, and I'm looking forward to more hallway track conversations about SDD.

Download the slides as a PDF (1.6 MB)

Note: Confreaks is recording the talks today, so a full video of my presentation should be online soon.

weplay launches

2008-03-26T06:49:00Z

The online community for youth sports I’ve been working on for the last month or so, weplay, is now in public beta. It’s been a roller coaster, but entirely worth it.

As part of this launch, we’re set to appear on the front page of the New York Times business section in tomorrow’s paper. The online version of the article is already available, and we’ve been busy all night responding to our first production load…. ever.

Check it out, don’t mind a few bumps and bruises as we settle in, and expect more to come soon. Oh, and be sure to checkout my weplay profile.

Presenting at GoRuCo in NYC

2008-02-09T22:12:00Z

I just received word that my proposal to speak at NYC’s very own second annual GoRuCo has been accepted. The conference is set for Saturday, April 26th at Pace University downtown. My topic will be the same as my Scotland on Rails presentation.

I’m really excited to have the opportunity to present at home, in front of many of my friends and colleagues. Now I just need to make sure I don’t suck. Better get back to working on my slide deck…

Presenting at Scotland on Rails

2008-01-31T17:44:00Z

I’m going to be presenting on Story Driven Development at the first Scottish Ruby on Rails conference, Scotland on Rails. I’ll be exploring the concept of Story-first development from both an agile process and implementation standpoint.

Topics will include:

Collaborating with the product owner on stories
What makes good stories and scenarios?
Driving stories with a browser simulator like Webrat
Potential pitfalls and ways to avoid them

If you’re going to be in Edinburgh for the conference, let me know.