1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
|
module RSpec
module Matchers
RSpec.describe "eq" do
it_behaves_like "an RSpec value matcher", :valid_value => 1, :invalid_value => 2 do
let(:matcher) { eq(1) }
end
it "is diffable" do
expect(eq(1)).to be_diffable
end
it "matches when actual == expected" do
expect(1).to eq(1)
end
it "does not match when actual != expected" do
expect(1).not_to eq(2)
end
it "compares by sending == to actual (not expected)" do
called = false
actual = Class.new do
define_method :== do |_other|
called = true
end
end.new
expect(actual).to eq :anything # to trigger the matches? method
expect(called).to be_truthy
end
it "describes itself" do
matcher = eq(1)
matcher.matches?(1)
expect(matcher.description).to eq "eq 1"
end
it "provides message, expected and actual on #failure_message" do
matcher = eq("1")
matcher.matches?(1)
expect(matcher.failure_message).to eq "\nexpected: \"1\"\n got: 1\n\n(compared using ==)\n"
end
it "provides message, expected and actual on #negative_failure_message" do
matcher = eq(1)
matcher.matches?(1)
expect(matcher.failure_message_when_negated).to eq "\nexpected: value != 1\n got: 1\n\n(compared using ==)\n"
end
# Older versions of Ruby such as less than 1.9 do not have String#encoding available, they are an array of bytes
if String.method_defined?(:encoding)
context "with String encoding as UTF-16LE" do
it "provides message, expected and actual on #failure_message when string encoding is the same" do
matcher = eq('abc'.encode('UTF-16LE'))
matcher.matches?('def'.encode('UTF-16LE'))
expect(matcher.failure_message).to eq "\nexpected: \"abc\"\n got: \"def\"\n\n(compared using ==)\n"
end
it "matches when actual is BINARY encoding and expected is UTF-8 encoding with the same chars" do
expect('abc'.encode('BINARY')).to eq 'abc'.encode('UTF-8')
end
it "provides message, expected and actual with encoding details on #failure_message when string encoding is different" do
matcher = eq('abc'.encode('UTF-16LE'))
matcher.matches?('abc'.force_encoding('ASCII-8BIT'))
expect(matcher.failure_message).to eq "\nexpected: #<Encoding:UTF-16LE> \"abc\"\n got: #<Encoding:ASCII-8BIT> \"abc\"\n\n(compared using ==)\n"
end
it "provides message, expected and actual on #negative_failure_message" do
matcher = eq('abc'.encode('UTF-16LE'))
matcher.matches?('abc'.encode('UTF-16LE'))
expect(matcher.failure_message_when_negated).to eq "\nexpected: value != \"abc\"\n got: \"abc\"\n\n(compared using ==)\n"
end
end
end
context "with Time objects" do
RSpec::Matchers.define :a_string_with_differing_output do
match do |string|
time_strings = /expected: (.+)\n.*got: (.+)$/.match(string).captures
time_strings.uniq.count == 2
end
end
let(:time1) { Time.utc(1969, 12, 31, 19, 10, 40, 101) }
let(:time2) { Time.utc(1969, 12, 31, 19, 10, 40, 102) }
it "provides additional precision on #failure_message" do
expect {
expect(time1).to eq(time2)
}.to fail_with(a_string_with_differing_output)
end
it "provides additional precision on #negative_failure_message" do
expect {
expect(time1).to_not eq(time1)
}.to fail_with(a_string_with_differing_output)
end
end
it 'fails properly when the actual is an array of multiline strings' do
expect {
expect(["a\nb", "c\nd"]).to eq([])
}.to fail_including("expected: []")
end
describe '#description' do
# Ruby 1.8.7 produces a less precise output
expected_seconds = Time.method_defined?(:nsec) ? '000000000' : '000000'
[
[nil, 'eq nil'],
[true, 'eq true'],
[false, 'eq false'],
[:symbol, 'eq :symbol'],
[1, 'eq 1'],
[1.2, 'eq 1.2'],
['foo', 'eq "foo"'],
[/regex/, 'eq /regex/'],
[['foo'], 'eq ["foo"]'],
[{ :foo => :bar }, 'eq {:foo=>:bar}'],
[Class, 'eq Class'],
[RSpec, 'eq RSpec'],
[Time.utc(2014, 1, 1), "eq 2014-01-01 00:00:00.#{expected_seconds} +0000"],
].each do |expected, expected_description|
context "with #{expected.inspect}" do
around { |ex| with_env_vars('TZ' => 'UTC', &ex) } if expected.is_a?(Time)
it "is \"#{expected_description}\"" do
expect(eq(expected).description).to eq expected_description
end
end
end
context "with Date.new(2014, 1, 1)" do
it "is eq to Date.new(2014, 1, 1).inspect" do
in_sub_process_if_possible do
require 'date'
date = Date.new(2014, 1, 1)
expect(eq(date).description).to eq "eq #{date.inspect}"
end
end
end
context "with Complex(1, 2)" do
it "is eq to Complex(1, 2).inspect" do
in_sub_process_if_possible do
# complex is available w/o requiring on ruby 1.9+.
# Loading it on 1.9+ issues a warning, so we only load it on 1.8.7.
require 'complex' if RUBY_VERSION == '1.8.7'
complex = Complex(1, 2)
expect(eq(complex).description).to eq "eq #{complex.inspect}"
end
end
end
context 'with object' do
it 'matches with "^eq #<Object:0x[0-9a-f]*>$"' do
expect(eq(Object.new).description).to match(/^eq #<Object:0x[0-9a-f]*>$/)
end
end
end
end
end
end
|
