Wie man den rspec Put-Controller-Test von Scaffold abschließt

Ok, so das ist, wie ich tun, ich behaupte nicht, strikt befolgen Sie die best practices, sondern konzentriere mich auf Präzision meiner tests, die Klarheit der meinen code, und die schnelle Ausführung meiner suite.

So nehmen Beispiel einer UserController

1- ich nicht verwenden, FactoryGirl Attribute definieren, um post zu meinem controller, da ich gerne für mich behalten die Kontrolle über diese Attribute. FactoryGirl ist nützlich, um aufzuzeichnen, aber Sie sollte immer manuell die Daten, die an der operation beteiligt, die Sie testen, es ist besser für die Lesbarkeit und Konsistenz.

In diesem Zusammenhang werden wir manuell definieren gepostet Attribute

let(:valid_update_attributes) { {first_name: 'updated_first_name', last_name: 'updated_last_name'} }

2- ich Dann definieren Sie die Attribute erwarte ich für den aktualisierten Datensatz, es kann eine exakte Kopie der gesendeten Attribute, aber es kann sein, dass der controller einige zusätzliche Arbeit, und wir wollen auch testen. Also sagen wir mal für unser Beispiel, dass einmal unsere Benutzer aktualisiert seine persönlichen Informationen unserer Steuerung automatisch hinzufügen need_admin_validation Flagge

let(:expected_update_attributes) { valid_update_attributes.merge(need_admin_validation: true) }

Das ist auch, wo Sie hinzufügen können, die Behauptung für die attribute, die unverändert bleiben müssen. Beispiel mit dem Feld ageaber es kann alles sein

let(:expected_update_attributes) { valid_update_attributes.merge(age: 25, need_admin_validation: true) }

3- ich die Aktion definieren, die in einem let block. Zusammen mit den vorangegangenen 2 let ich finde es macht meine Angaben sehr gut lesbar ist. Und es auch einfach zu schreiben shared_examples

let(:action) { patch :update, format: :js, id: record.id, user: valid_update_attributes }

4- (ab diesem Punkt ist alles in gemeinsame Beispiel und benutzerdefinierte rspec-Matcher in meinen Projekten) Zeit, um den ursprünglichen Datensatz, für die, die wir verwenden können, FactoryGirl

let!(:record) { FactoryGirl.create :user, :with_our_custom_traits, age: 25 }

Wie Sie sehen können wir manuell setzen Sie den Wert für age wie wollen wir überprüfen, ob es nicht ändern, während der update Aktion. Auch wenn das Werk bereits im Alter von 25 habe ich immer überschreiben also mein test wird nicht brechen, wenn ich die Fabrik.

Zweite Sache zu beachten: wir verwenden hier let! mit einem Knall. Das ist, weil manchmal möchten Sie vielleicht zu test-controller fail Aktion, und der beste Weg das zu tun ist, um auszudrücken valid? aus und gibt false zurück. Sobald Sie stub valid? Sie können nicht erstellen Sie Datensätze für die gleiche Klasse mehr, dafür let! mit einem Knall schaffen würde, den Rekord vor der stub valid?

5- Die Behauptungen selbst (und schließlich die Antwort auf Ihre Frage)

before { action }
it {
  assert_record_values record.reload, expected_update_attributes
  is_expected.to redirect_to(record)
  expect(controller.notice).to eq('User was successfully updated.')
}

Zusammenfassen Also addition aller oben, dies ist, wie die Skillung aussieht

describe 'PATCH update' do
  let(:valid_update_attributes) { {first_name: 'updated_first_name', last_name: 'updated_last_name'} }
  let(:expected_update_attributes) { valid_update_attributes.merge(age: 25, need_admin_validation: true) }
  let(:action) { patch :update, format: :js, id: record.id, user: valid_update_attributes }
  let(:record) { FactoryGirl.create :user, :with_our_custom_traits, age: 25 }
  before { action }
  it {
    assert_record_values record.reload, expected_update_attributes
    is_expected.to redirect_to(record)
    expect(controller.notice).to eq('User was successfully updated.')
  }
end

assert_record_values ist der Helfer, um Ihren rspec einfacher.

def assert_record_values(record, values)
  values.each do |field, value|
    record_value = record.send field
    record_value = record_value.to_s if (record_value.is_a? BigDecimal and value.is_a? String) or (record_value.is_a? Date and value.is_a? String)

    expect(record_value).to eq(value)
  end
end

Wie Sie sehen können, mit diesem einfachen Helfer, wenn wir erwarten, dass für eine BigDecimal können wir nur Folgendes schreiben, und der Helfer den rest machen

let(:expected_update_attributes) { {latitude: '0.8137713195'} }

Also am Ende, und zum Abschluss, wenn Sie geschrieben haben, Ihre shared_examples, Helfer und benutzerdefinierten Matcher, können Sie Ihre Spezifikationen super TROCKEN. Sobald Sie beginnen, wiederholen die gleiche Sache, die in Ihrem Controller-Spezifikationen, finden, wie können Sie diese umgestalten. Es kann einige Zeit dauern, aber wenn Ihre getan, können Sie schreiben die tests für einen ganzen controller in wenigen Minuten

Und ein letztes Wort (ich kann nicht aufhören, ich Liebe Rspec) hier ist, wie voll meine Helfer Aussehen. Es ist verwendbar für alles, was in der Tat, nicht nur Modelle.

def assert_records_values(records, values)
  expect(records.length).to eq(values.count), "Expected <#{values.count}> number of records, got <#{records.count}>\n\nRecords:\n#{records.to_a}"
  records.each_with_index do |record, index|
    assert_record_values record, values[index], index: index
  end
end

def assert_record_values(record, values, index: nil)
  values.each do |field, value|
    record_value = [field].flatten.inject(record) { |object, method| object.try :send, method }
    record_value = record_value.to_s if (record_value.is_a? BigDecimal and value.is_a? String) or (record_value.is_a? Date and value.is_a? String)

    expect_string_or_regexp record_value, value,
                            "#{"(index #{index}) " if index}<#{field}> value expected to be <#{value.inspect}>. Got <#{record_value.inspect}>"
  end
end

def expect_string_or_regexp(value, expected, message = nil)
  if expected.is_a? String
    expect(value).to eq(expected), message
  else
    expect(value).to match(expected), message
  end
end

InformationsquelleAutor der Antwort Benj

Gut, ich habe etwas einfacher, ich bin mit der Verarbeiter, aber ich bin mir ziemlich sicher, dass es das gleiche mit FactoryGirl:

  let(:new_attributes) ( { "phone" => 87276251 } )

  it "updates the requested patient" do
    patient = Fabricate :patient
    put :update, id: patient.to_param, patient: new_attributes
    patient.reload
    # skip("Add assertions for updated state")
    expect(patient.attributes).to include( { "phone" => 87276251 } )
  end

Auch, ich bin mir nicht sicher, warum Sie den Bau einer neuen Fabrik, SETZEN verb soll, fügen Sie neue Material, richtig?. Und was Sie testen, wenn das, was Sie Hinzugefügt haben, in den ersten Platz (new_attributes), existiert nach dem put im gleichen Modell.

InformationsquelleAutor der Antwort Pablo Olmos de Aguilera C.

Hier ist meine Art der Prüfung GESTELLT. Das ist ein Ausschnitt aus meinem notes_controller_spec ist der Grundgedanke sollte klar sein (sagen Sie mir, wenn nicht):

RSpec.describe NotesController, :type => :controller do
  let(:note) { FactoryGirl.create(:note) }
  let(:valid_note_params) { FactoryGirl.attributes_for(:note) }
  let(:request_params) { {} }

  ...

  describe "PUT 'update'" do
    subject { put 'update', request_params }

    before(:each) { request_params[:id] = note.id }

    context 'with valid note params' do
      before(:each) { request_params[:note] = valid_note_params }

      it 'updates the note in database' do
        expect{ subject }.to change{ Note.where(valid_note_params).count }.by(1)
      end
    end
  end
end

Statt FactoryGirl.build(:company).attributes.symbolize_keyswürde ich schreiben FactoryGirl.attributes_for(:company). Es ist kürzer und enthält nur die Parameter, die Sie angegeben haben in Ihrer Fabrik.

Leider das ist alles was ich sagen kann, über Ihre Fragen.

P. S. Obwohl, wenn Sie legen BigDecimal Gleichheit prüfen auf Datenbank-Ebene durch das schreiben in der Art wie

expect{ subject }.to change{ Note.where(valid_note_params).count }.by(1)

kann dies für Sie arbeiten.

InformationsquelleAutor der Antwort nsave