pro seu software. Por exemplo, poderíamos re-escrever o teste:
33
3.5. Os matchers de equidade
Casa do Código
it "is possible to put words on it" do
bag = BagOfWords.new
bag.put("hello", "world")
expect(bag).to have(2).words
end
para:
it "is possible to put words on it" do
bag = BagOfWords.new
bag.put("hello", "world")
expected = (bag.words.size == 2)
expect(expected).to be_true
end
Mas usar os be matchers para tudo, como usamos acima, prejudicaria a semân-
tica dos nossos testes e é por isso que temos outros matchers.
3.5
Os matchers de equidade
Os equality matchers servem para verificar se um objeto é igual a outro objeto.
Existe mais de um matcher para esse tipo de verificação porque no Ruby existe mais
de um modo de checar a equidade entre dois objetos, que são os seguintes:
a.equal?(b) # object identity - a e b se referem ao mesmo objeto
a.eql?(b)
# object equivalence - a e b tem o mesmo valor
a == b
# object equivalence - a e b tem o mesmo valor com conversão
# de tipo
Os matchers que o RSpec tem para verificar equidade são:
expect(a).to equal(b) # passa se a.equal?(b)
expect(a).to be(b)
# passa se a.equal?(b)
expect(a).to eql(b)
# passa se a.eql?(b)
expect(a).to eq(b)
# passa se a == b
34
Casa do Código
Capítulo 3. Introdução ao básico do RSpec
3.6
Matchers relacionados a arrays
O RSpec nos oferece alguns matchers específicos para verificação de arrays. O pri-
meiro é o MatchArray. Esse matcher é usado para verificar se um array é igual
a outro, independente da ordem dos elementos do array. Segue um exemplo de uso
desse matcher:
array = [1, 2, 3, 4]
expect(array).to match_array([1, 2, 3, 4])
expect(array).to match_array([4, 3, 2, 1])
expect(array).not_to match_array([1, 2, 3])
expect(array).not_to
match_array([1, 2, 3, 4, 5])
Outro matcher relacionado a verificação de arrays é o Include Matcher.
Você pode usá-lo para verificar a relação de pertinência entre um ou mais elementos
e um determinado array. Segue um exemplo de uso desse matcher:
array = [1, 2, 3, 4]
expect(array).to include(1)
expect(array).to include(1, 2, 3)
expect(array).to include(1, 2, 3, 4)
expect(array).not_to include(0)
expect(array).not_to include(5)
expect(array).not_to include(5, 6, 7, 8)
expect(array).not_to include([1, 2, 3, 4])
Por fim, existem também os matchers start_with e end_with que servem
para verificar se um array começa ou termina com uma sequência de elementos.
Segue um exemplo de uso desses matchers:
array = [1, 2, 3, 4]
expect(array).to start_with(1)
expect(array).to start_with(1, 2)
expect(array).not_to start_with(2)
expect(array).to end_with(4)
35
3.6. Matchers relacionados a arrays
Casa do Código
expect(array).to end_with(3, 4)
expect(array).not_to end_with(3)
Matchers relacionados a hashes
Para verificar Hashes, o RSpec nos oferece o Include Matcher, o mesmo
matcher que vimos na verificação de arrays. Segue um exemplo de uso desse matcher
com hashes:
hash = { a: 7, b: 5 }
# você pode usar para verificar se um hash tem uma ou mais chaves
expect(hash).to include(:a)
expect(hash).to include(:a, :b)
# você pode usar para verificar se um hash tem um ou mais pares de
# chave - valor
expect(hash).to include(a: 7)
expect(hash).to include(b: 5, a: 7)
expect(hash).not_to include(:c)
expect(hash).not_to include(a: 11)
expect(hash).not_to include(a: 13, c: 11)
expect(hash).not_to include(:c, :d)
Matchers relacionados a strings
O RSpec oferece alguns matchers relacionados a strings, sendo que alguns de-
les são os mesmos usados para verificar arrays. Vamos começar olhando o Match
Matcher, que serve para verificar o valor de uma string de acordo com uma expres-
são regular:
string = "hugo barauna"
expect(string).to match(/hugo/)
expect(string).to match(/araun/)
expect(string).not_to match(/barao/)
expect(string).not_to match(/hugs/)
Agora seguem exemplos dos matchers usados por strings e arrays, começando
pelo include:
36
Casa do Código
Capítulo 3. Introdução ao básico do RSpec
string = "hugo barauna"
expect(string).to include("h")
expect(string).to include("hugo")
expect(string).to include("hugo", "bara")
expect(string).not_to include("barao")
expect(string).not_to include("hugs")
Por fim, você também pode usar os matchers start_with e end_with com
strings:
string = "hugo barauna"
expect(string).to start_with("hugo")
expect(string).not_to start_with("barauna")
expect(string).to end_with("barauna")
expect(string).not_to end_with("hugo")
Predicate matchers
Um dos tipos de matchers mais famosos do RSpec são os Predicate Matchers.
Para entender esses matchers vamos começar estudando o seguinte exemplo.
Imagine que você está desenvolvendo uma aplicação de e-commerce e tem uma
classe chamada Cart. Essa classe tem um método de instância chamado empty?.
Para especificar esse método, você poderia fazer o seguinte teste:
describe Cart do
describe "#empty?" do
it "returns true when the cart has no products" do
cart = Cart.new