Test: double example

model.rb

class Model
  # Let's say Elasticsearch needs a JSON representation of the model in order
  # to index it. We delegate to a specialized class to generate that JSON:
  def as_indexed_json
    ModelSerializer.new(self).as_json
  end
end

model_spec.no-comments.rb

describe Model do
  describe '#as_indexed_json' do
    let(:model) { Model.new }
    let(:serialization) { double }
    let(:result) { double }

    before do
      expect(ModelSerializer).to receive(:new)
                             .with(model)
                             .and_return(serialization)
      allow(serialization).to receive(:as_json)
                          .and_return(result)
    end

    it 'delegates and returns the result from a serializer' do
      expect(model.as_indexed_json).to eq result
    end
  end
end

model_spec.rb

# Using RSpec syntax.

describe Model do
  # In Model#as_indexed_json, we rely on a ModelSerializer class, which is an external
  # dependency. For we are solely focused on testing Model, we'd like to avoid
  # leveraging that dependency. We can abstract it away using double objects.
  #
  # The only thing we are interested in is whether the right messages are being
  # sent to and received by the right objects. If we trump an actual object, such
  # as ModelSerializer, with a double (fake-object), then we must take care of
  # letting that double receive and respond to the expected messages.
  #
  # We can do so by actually setting up expectations (tests) that the messages will
  # be sent, received and responded to the right way.
  describe '#as_indexed_json' do
    let(:model) { Model.new }
    
    # Step 1: use a double for each and every object that is an external dependency
    # (eg. serialization) or is provided by one (eg. result).
    let(:serialization) { double }
    let(:result) { double }

    before do
      # Step 2: set your expectations when it comes to messages.
      
      # We expect a ModelSerializer to be created. When that happens, let's return
      # our double instead of the actual instance. We make an assertion out of this
      # expectation, with a precise usage of RSpec's expect method and DSL.
      expect(ModelSerializer).to receive(:new)
                             .with(campaign)
                             .and_return(serialization)
      # We expect the serialization to be casted to JSON. When that happens, let's
      # return another double instead of the actual hash. The expectation is "weak",
      # that is, we simply stub the result and don't make an assertion out of the
      # method being called — but the actual test below will assert the result is
      # computed and returned.
      allow(serialization).to receive(:as_json)
                          .and_return(result)
    end

    it 'delegates and returns the result from a serializer' do
      # Step 3: call the targeted method.
      
      # On top of the built-in assertion about ModelSerializer#new, we make sure of
      # checking the return form the Model#as_indexed_json, which should be our double.
      expect(model.as_indexed_json).to eq result
    end
  end
end

Usually, in the before block, I only use allow to setup my doubles. Then, in the test I use expect to verify that my doubles behave as required. Sometimes I would not even expect anything from the double if I'm using it as a stub (see http://martinfowler.com/articles/mocksArentStubs.html for more explanations).
I would write your example as:

describe Model do
  describe '#as_indexed_json' do
    let(:model) { Model.new }
    let(:serializer) { instance_double(ModelSerializer, as_json: result) }
    let(:result) { double }

    before do
      # It's just a setup, I don't care about the way the ModelSerializer is instantiated
      allow(ModelSerializer).to receive(:new) { serializer }
    end

    it 'delegates and returns the result from a serializer' do
      # Here it's an expectation, I want to make sure that my serializer is called with the proper argument
      expect(ModelSerializer).to receive(:new).with(model)
      expect(model.as_indexed_json).to eq result
    end
  end
end