-
-
Notifications
You must be signed in to change notification settings - Fork 763
/
reporter_spec.rb
155 lines (124 loc) · 4.84 KB
/
reporter_spec.rb
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
require "spec_helper"
module RSpec::Core
RSpec.describe Reporter do
let(:config) { Configuration.new }
let(:reporter) { Reporter.new config }
describe "finish" do
let(:formatter) { double("formatter") }
let(:example) { double("example") }
%w[start_dump dump_pending dump_failures dump_summary close].map(&:to_sym).each do |message|
it "sends #{message} to the formatter(s) that respond to message" do
reporter.register_listener formatter, message
expect(formatter.as_null_object).to receive(message)
reporter.finish
end
it "doesnt notify formatters about messages they dont implement" do
expect { reporter.finish }.to_not raise_error
end
end
end
context "given one formatter" do
it "passes messages to that formatter" do
formatter = double("formatter", :example_started => nil)
example = double("example")
reporter.register_listener formatter, :example_started
expect(formatter).to receive(:example_started) do |notification|
expect(notification.example).to eq example
end
reporter.example_started(example)
end
it "passes example_group_started and example_group_finished messages to that formatter in that order" do
order = []
formatter = double("formatter")
allow(formatter).to receive(:example_group_started) { |n| order << "Started: #{n.group.description}" }
allow(formatter).to receive(:example_group_finished) { |n| order << "Finished: #{n.group.description}" }
reporter.register_listener formatter, :example_group_started, :example_group_finished
group = ExampleGroup.describe("root")
group.describe("context 1") do
example("ignore") {}
end
group.describe("context 2") do
example("ignore") {}
end
group.run(reporter)
expect(order).to eq([
"Started: root",
"Started: context 1",
"Finished: context 1",
"Started: context 2",
"Finished: context 2",
"Finished: root"
])
end
end
context "given an example group with no examples" do
it "does not pass example_group_started or example_group_finished to formatter" do
formatter = double("formatter")
expect(formatter).not_to receive(:example_group_started)
expect(formatter).not_to receive(:example_group_finished)
reporter.register_listener formatter, :example_group_started, :example_group_finished
group = ExampleGroup.describe("root")
group.run(reporter)
end
end
context "given multiple formatters" do
it "passes messages to all formatters" do
formatters = (1..2).map { double("formatter", :example_started => nil) }
example = double("example")
formatters.each do |formatter|
expect(formatter).to receive(:example_started) do |notification|
expect(notification.example).to eq example
end
reporter.register_listener formatter, :example_started
end
reporter.example_started(example)
end
end
describe "#report" do
it "supports one arg (count)" do
reporter.report(1) {}
end
it "yields itself" do
yielded = nil
reporter.report(3) { |r| yielded = r }
expect(yielded).to eq(reporter)
end
end
describe "#register_listener" do
let(:listener) { double("listener", :start => nil) }
before { reporter.register_listener listener, :start }
it 'will register the listener to specified notifications' do
expect(reporter.registered_listeners :start).to eq [listener]
end
it 'will match string notification names' do
reporter.register_listener listener, "stop"
expect(reporter.registered_listeners :stop).to eq [listener]
end
it 'will send notifications when a subscribed event is triggered' do
expect(listener).to receive(:start) do |notification|
expect(notification.count).to eq 42
end
reporter.start 42
end
it 'will ignore duplicated listeners' do
reporter.register_listener listener, :start
expect(listener).to receive(:start).once
reporter.start 42
end
end
describe "timing" do
it "uses RSpec::Core::Time as to not be affected by changes to time in examples" do
formatter = double(:formatter)
reporter.register_listener formatter, :dump_summary
reporter.start 1
allow(Time).to receive_messages(:now => ::Time.utc(2012, 10, 1))
duration = nil
allow(formatter).to receive(:dump_summary) do |notification|
duration = notification.duration
end
reporter.finish
expect(duration).to be < 0.2
end
end
end
end