justinko

def stub_model(model_name)
  stub_class model_name, ActiveRecord::Base
end

def stub_class(class_name, super_class = Object)
  stub_module class_name, Class.new(super_class)
end

def stub_module(module_name, object = Module.new)
  module_name = module_name.to_s.camelize

justinko

a = lambda {}
b = a.dup
m = Module.new
a.extend m
b.extend m

puts a == b # true for 1.9, false for 1.8 :(

justinko

require 'delegate'

A = Struct.new(:a)
class B < DelegateClass(A)
  attr_accessor :foo
end
b = B.new(A.new(5))
puts b.inspect
puts b.respond_to?(:foo)

justinko

class NullLogger < Logger
  def initialize(*args); end
  def write(*input); true; end
end

Rails.application.assets.logger = NullLogger.new

class TemporaryLoggerLevel
  LEVEL = Logger::ERROR

justinko

require 'spec_helper'

describe TCPSocket do
  describe '#write_nonblock' do
    let(:payload) { 'JUNK IN THE TUBES' }

    it "writes if the operation won't block" do
      setup_tcp do |client, peer|
        client.write_nonblock(payload).should eq payload.length
        peer.read(payload.length).should eq payload

justinko

require 'spec_helper'

shared_examples_for 'employee signin' do
  it { should have_selector('title',     text: employee.emp_full_name) }
  it { should have_link('Sign out',      href: signout_path) }
  it { should_not have_link('Sign in',   href: signin_path) }
end

 describe "Authentication" do

justinko

Let's say I have a file that needs to be parsed and validated. Instead of jumping to tests, I want to first think about the objects involved and their messages.

I would then write out the above code.

After I'm satisfied with the objects and their interactions, I would then write a spec for FileObject or FileValidator#validate.

I consider this approach a technique above TDD. Before, when I used to jump straight into the specs, it would often result in working code, but bad design. TDD encourages you to think about design, but only in your head (which is obviously not as efficient as writing it out, not to mention the visual feedback).

NOTE: The very first thing I do is create a functional/high-level spec, so this approach only applies on the implementation level (units).

justinko

class PostsController < ActiveRecord::Base
  helper_method :posts, :post

  def index; end

  def create
    if post.save
    end
  end

justinko

# lib/tasks/app.rake

namespace :app do
  desc 'Seed the current env db with "dummy" data'
  task seed: :environment do
    require './lib/seed'
    Seed.start
  end
end

justinko

module MyApp
  class Application < Rails::Application
    config.to_prepare do
      User.devise :database_authenticatable, :recoverable, :rememberable,
                  :trackable, :validatable

      Admin.devise :database_authenticatable, :recoverable, :rememberable,
                   :trackable, :validatable
    end
  end