Het schrijven van tests voor applicatiecode is iets waar alle programmeurs vertrouwd mee zouden moeten zijn, ongeacht de taal of het framework van hun keuze. RSpec is een ongelooflijke testsuite en DSL (Domain-Specific Language) die is gebouwd in Ruby, waarmee je gemakkelijk unit tests kunt schrijven met behulp van een set vooraf gedefinieerde methoden. Mijn kennismaking met het schrijven van code in Ruby was nauw verweven met de ervaring van het religieus draaien van RSpec om te testen wat ik had geschreven; en dus toen ik begon met het leren van Rails, zorgde het blijven gebruiken van RSpec voor een meer natuurlijke en naadloze overgang. Rails gebruikt standaard het MiniTest test framework. We zullen bespreken hoe je een nieuw Rails-project op te zetten om RSpec te gebruiken, en dan te verkennen met behulp van Capybara om onze views te testen.
Eerst zullen we een nieuw Rails-project door het uitvoeren van rails new NAME -T -B, waar NAME is het pad naar de map voor het project dat moet worden gemaakt. De vlag -T geeft aan dat Rails geen test framework mag opzetten voor ons nieuwe project, wat precies is wat we willen. De vlag -B instrueert Rails om het uitvoeren van bundle install op dit punt over te slaan. Vervolgens moeten we onze Gemfile bewerken om het volgende op te nemen:
group :development, :test do
gem 'rspec-rails'
gem 'capybara'
end
Dit voegt zowel RSpec als Capybara toe aan onze ontwikkel- en testomgevingen. Op dit punt, draai bundle om gems en alle afhankelijkheden te installeren die het project nodig heeft. Ik vind het leuk om op dit punt rails console te draaien om te controleren of alles werkt, en zo niet – dan ga ik terug naar mijn Gemfile en los eventuele problemen op.
Nu we ons project skelet op zijn plaats hebben, is de volgende stap het opzetten van onze test suite. Start gewoon rails generate rspec:install op dit punt om de spec directory en de benodigde bestandsstructuur aan te maken. De laatste stap is om onze tests te vertellen dat ze Capybara moeten gebruiken. In spec/rails_helper.rb, voeg het volgende toe:
require 'capybara/rspec'
Dat is het voor de setup! Voordat we verder gaan, laten we de wijzigingen die we in ons project hebben aangebracht, vastleggen: git add . && git commit -m "initial commit". Laten we beginnen met het maken van een controller en wat testen!
Voor onze testdoeleinden maken we een eenvoudig formulier met wat inputs, en dan vertellen we Capybara om wat voorbeeldgegevens in te vullen en het formulier te verzenden. We zullen ons geen zorgen maken over het maken van complexe modellen of het persisteren van informatie naar een database. Laten we Rails vertellen om een users controller te maken en wat routing voor ons in te stellen:
rails generate controller Users new --no-helper --no-assets --no-view-specs
Door --no-helper --no-assets te specificeren vertellen we Rails om geen assets of een helper voor onze controller te maken. De --no-view-specs optie instrueert de generator om geen tests te maken voor de views – we zullen later zien hoe we de tests kunnen maken die we willen. Rails heeft een new route voor ons gemaakt, die we kunnen zien in config/routes.rb:
Rails.application.routes.draw do
get 'users/new'
end
En in app/controllers/users_controller.rb:
class UsersController < ApplicationController
def new
end
end
Tot slot, Rails heeft een view voor ons gemaakt in app/views/users/new.html.erb. Laten we deze view bewerken om een eenvoudig formulier te maken:
<h1>User Login</h1>
<%= form_tag users_path do %>
<%= label_tag :name %>
<%= text_field_tag :name %>
<%= submit_tag "submit" %>
<% end %>
We moeten nog een paar dingen doen om dit af te ronden. In routes.rb voegen we het volgende toe:
post 'users' => 'users#welcome'
We moeten ook een welcome actie toevoegen aan users_controller.rb:
def welcome
@user = params
render :welcome
end
De laatste stap hier is het maken van views/users/welcome.html.erb en het toevoegen van wat HTML en ERB om de naam van de gebruiker weer te geven:
<h1><%= "Welcome, #{@user}!" %></h1>
Phew! Als we rails server uitvoeren en naar localhost:3000/users/new gaan in onze browser, zouden we begroet moeten worden met een formulier dat ons vraagt onze naam in te voeren. Als we onze naam invoeren en op de submit-knop drukken, zouden we moeten worden omgeleid naar een pagina die ons met een warm welkom begroet. Dit is allemaal goed en wel, maar om onze code op deze manier te moeten testen om er zeker van te zijn dat het werkt elke keer als we een nieuw formulier toevoegen of een nieuwe functie implementeren wordt al snel vermoeiend. Gelukkig is er een tool gemaakt om dit proces voor ons te automatiseren!
Dit is waar Capybara om de hoek komt kijken. Capybara is een raamwerk dat ons in staat stelt de code in onze views te testen door formulier gegevens in te vullen, pagina inhoud te inspecteren en HTTP requests naar de browser te sturen. Laten we een spec opzetten om ons nieuw aangemaakte formulier te testen:
rails generate rspec:feature form
Dit zal het bestand spec/features/form_spec.rb genereren. Standaard verwacht Capybara specs te vinden in een directory genaamd features. Laten we dit bestand bewerken om een nieuwe test toe te voegen, die het name tekst veld zal invullen en op submit drukken:
require 'rails_helper'RSpec.feature "Forms", type: :feature do
it 'can enter a name and receive a greeting' do
visit 'users/new'
fill_in :name, with: "Capybara"
click_on 'submit'
expect(page).to have_content "Welcome, Capybara!"
end
end
Dat is het! We hebben met succes onze eerste test in Rails gemaakt met behulp van RSpec en Capybara. Als we rspec --format documentation uitvoeren, zouden we moeten zien dat de test slaagt. Voel je vrij om te experimenteren – wat zijn manieren om de test te laten falen? Zijn er andere tests die we zouden kunnen maken voor dit voorbeeld? Hopelijk zet dit je aan het denken over hoe je het proces van het testen van je code kunt vereenvoudigen en automatiseren met behulp van deze tools, en hoe je er een gewoonte van kunt maken om je code vaak te testen.
Vis hier voor de code die in deze post wordt gepresenteerd.