• let(:foo) for anything to be referenced in an it or before that can be lazily created. If you see yourself using instance variables, think about using let instead.
  
• The let! version is useful for things like controller and route tests so you don't have to reference foo just to create it before requesting your action. If you see yourself doing foo; get(:action), look at let!.
  
• before blocks are for performing some setup repeatedly before a group of its. If the examples you are testing have no side effects, look at using before(:all) so the setup only runs once for every example; otherwise you will need to use :each (the default) to set your state before every example.
  
• after blocks only really become useful in situations where you use before(:all) (and should then be after(:all)) for some form of teardown (although usually transactions take care of this).
  

describe Ticket do
  subject { create(:ticket, state: state) }

  context 'when the ticket is new' do
    let(:state) { 'new' }

    it 'cannot transition to resolved' do
      expect { subject.resolve! }.to raise_error(TransitionError)
    end
  end
  context 'when the ticket is acknowledged' do
    let(:state) { 'acknowledged' }

    it 'can transition to resolved' do
      expect { subject.resolved! }.not_to raise_error(TransitionError)
    end
  end
  context 'when the ticket is resolved' do
    let(:state) { 'resolved' }

    it { should be_frozen }
  end
end

• Add a main_link_to helper (or some such name) that always passes subdomain: false as an option
  
• Setup a new link_to using alias_method_chain and default the subdomain option to false (but still allow it to be specified at call time)
  

postcard.thumbnail_front_url = newcard['thumbnails'].first['medium']
postcard.thumbnail_back_url = newcard['thumbnails'].last['medium']

necrotic fucked around with this message at 18:14 on Apr 21, 2015