wake-up-neo.net

Wie überprüfe ich mit RSpec, ob eine JSON-Antwort vorliegt?

Ich habe den folgenden Code in meinem Controller:

format.json { render :json => { 
        :flashcard  => @flashcard,
        :lesson     => @lesson,
        :success    => true
} 

In meinem RSpec-Controller-Test möchte ich sicherstellen, dass ein bestimmtes Szenario eine erfolgreiche JSON-Antwort erhält, sodass ich die folgende Zeile hatte:

controller.should_receive(:render).with(hash_including(:success => true))

Obwohl ich beim Ausführen meiner Tests die folgende Fehlermeldung erhalte:

Failure/Error: controller.should_receive(:render).with(hash_including(:success => false))
 (#<AnnoController:0x00000002de0560>).render(hash_including(:success=>false))
     expected: 1 time
     received: 0 times

Überprüfe ich die Antwort falsch?

139
Fizz

Sie können das Antwortobjekt untersuchen und sicherstellen, dass es den erwarteten Wert enthält:

@expected = { 
        :flashcard  => @flashcard,
        :lesson     => @lesson,
        :success    => true
}.to_json
get :action # replace with action name / params as necessary
response.body.should == @expected

EDIT

Wenn Sie dies in post ändern, wird es etwas schwieriger. Hier ist eine Möglichkeit, damit umzugehen:

 it "responds with JSON" do
    my_model = stub_model(MyModel,:save=>true)
    MyModel.stub(:new).with({'these' => 'params'}) { my_model }
    post :create, :my_model => {'these' => 'params'}, :format => :json
    response.body.should == my_model.to_json
  end

Beachten Sie, dass mock_model antwortet nicht auf to_json, also entweder stub_model oder eine echte Modellinstanz wird benötigt.

161
zetetic

Sie können den Antworttext folgendermaßen analysieren:

parsed_body = JSON.parse(response.body)

Dann können Sie Ihre Aussagen gegen diesen analysierten Inhalt machen.

parsed_body["foo"].should == "bar"
155
brentmc79

Aufbauend auf Kevin Trowbridges Antwort

response.header['Content-Type'].should include 'application/json'
45
lightyrs

Es gibt auch das Juwel json_spec , das einen Blick wert ist

https://github.com/collectiveidea/json_spec

34
acw

Einfach und leicht zu tun.

# set some variable on success like :success => true in your controller
controller.rb
render :json => {:success => true, :data => data} # on success

spec_controller.rb
parse_json = JSON(response.body)
parse_json["success"].should == true
11

Sie könnten in den 'Content-Type' - Header schauen, um zu sehen, ob er korrekt ist?

response.header['Content-Type'].should include 'text/javascript'
7

Sie können auch eine Hilfsfunktion in spec/support/ Definieren.

module ApiHelpers
  def json_body
    JSON.parse(response.body)
  end
end

RSpec.configure do |config| 
  config.include ApiHelpers, type: :request
end

und verwenden Sie json_body, wenn Sie auf die JSON-Antwort zugreifen müssen.

In Ihrer Anforderungsspezifikation können Sie sie beispielsweise direkt verwenden

context 'when the request contains an authentication header' do
  it 'should return the user info' do
    user  = create(:user)
    get URL, headers: authenticated_header(user)

    expect(response).to have_http_status(:ok)
    expect(response.content_type).to eq('application/vnd.api+json')
    expect(json_body["data"]["attributes"]["email"]).to eq(user.email)
    expect(json_body["data"]["attributes"]["name"]).to eq(user.name)
  end
end
7

Ein anderer Ansatz, um nur auf eine JSON-Antwort zu testen (nicht, dass der Inhalt einen erwarteten Wert enthält), besteht darin, die Antwort mit ActiveSupport zu analysieren:

ActiveSupport::JSON.decode(response.body).should_not be_nil

Wenn die Antwort nicht syntaktisch analysiert werden kann, wird eine Ausnahme ausgelöst und der Test schlägt fehl.

7
Clinton

Bei Verwendung von Rails 5 (derzeit noch in der Beta) gibt es eine neue Methode, parsed_body in der Testantwort, die die Antwort zurückgibt, die als das analysiert wurde, in dem die letzte Anforderung codiert wurde.

Das Festschreiben auf GitHub: https://github.com/Rails/rails/commit/eee3534b

4
Koen.

Wenn Sie den von Rspec bereitgestellten Hash-Diff nutzen möchten, ist es besser, den Body zu analysieren und mit einem Hash zu vergleichen. Der einfachste Weg, den ich gefunden habe:

it 'asserts json body' do
  expected_body = {
    my: 'json',
    hash: 'ok'
  }.stringify_keys

  expect(JSON.parse(response.body)).to eql(expected_body)
end
1
Damien Roche

Ich habe hier einen Kunden-Matcher gefunden: https://raw.github.com/Gist/917903/92d7101f643e07896659f84609c117c4c279dfad/have_content_type.rb

Legen Sie es in spec/support/matchers/have_content_type.rb ab und stellen Sie sicher, dass Sie in spec/spec_helper.rb so etwas von support laden

Dir[Rails.root.join('spec/support/**/*.rb')].each {|f| require f}

Hier ist der Code selbst, für den Fall, dass er aus dem angegebenen Link verschwunden ist.

RSpec::Matchers.define :have_content_type do |content_type|
  CONTENT_HEADER_MATCHER = /^(.*?)(?:; charset=(.*))?$/

  chain :with_charset do |charset|
    @charset = charset
  end

  match do |response|
    _, content, charset = *content_type_header.match(CONTENT_HEADER_MATCHER).to_a

    if @charset
      @charset == charset && content == content_type
    else
      content == content_type
    end
  end

  failure_message_for_should do |response|
    if @charset
      "Content type #{content_type_header.inspect} should match #{content_type.inspect} with charset #{@charset}"
    else
      "Content type #{content_type_header.inspect} should match #{content_type.inspect}"
    end
  end

  failure_message_for_should_not do |model|
    if @charset
      "Content type #{content_type_header.inspect} should not match #{content_type.inspect} with charset #{@charset}"
    else
      "Content type #{content_type_header.inspect} should not match #{content_type.inspect}"
    end
  end

  def content_type_header
    response.headers['Content-Type']
  end
end
0
Zeke Fast