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
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
|
Feature: Run command in a simpler fashion
To run a command use the `#run_command_and_stop`-method. There are some configuration options
which are relevant here:
- `fail_on_error`:
Given this option is `true`, `aruba` fails if the `command` fails to run - exit code <> 0.
For all other options see [run.feature](run.feature).
Background:
Given I use a fixture named "cli-app"
Scenario: Require executable to succeed (by default value)
Given an executable named "bin/aruba-test-cli" with:
"""bash
#!/bin/bash
exit 1
"""
And a file named "spec/run_spec.rb" with:
"""ruby
require 'spec_helper'
RSpec.describe 'Run command', type: :aruba do
it { expect { run_command_and_stop('aruba-test-cli') }.to raise_error RSpec::Expectations::ExpectationNotMetError }
end
"""
When I run `rspec`
Then the specs should all pass
Scenario: Require executable to succeed (set by option)
Given an executable named "bin/aruba-test-cli" with:
"""bash
#!/bin/bash
exit 1
"""
And a file named "spec/run_spec.rb" with:
"""ruby
require 'spec_helper'
RSpec.describe 'Run command', type: :aruba do
it { expect { run_command_and_stop('aruba-test-cli', fail_on_error: true) }.to raise_error }
end
"""
When I run `rspec`
Then the specs should all pass
Scenario: Ignore failure of executable (set by option)
Given an executable named "bin/aruba-test-cli" with:
"""bash
#!/bin/bash
exit 1
"""
And a file named "spec/run_spec.rb" with:
"""ruby
require 'spec_helper'
RSpec.describe 'Run command', type: :aruba do
it { expect { run_command_and_stop('aruba-test-cli', fail_on_error: false) }.not_to raise_error }
end
"""
When I run `rspec`
Then the specs should all pass
Scenario: Command with long startup phase
If you have got a command with a long startup phase or use `ruby` together
with `bundler`, you should consider using the `startup_wait_time`-option.
Otherwise methods like `#send_signal` don't work since they require the
command to be running and have setup its signal handler.
Given an executable named "bin/aruba-test-cli" with:
"""bash
#!/usr/bin/env bash
function initialize_script {
sleep 0.2
}
function do_some_work {
echo "Hello, Aruba is working"
}
initialize_script
do_some_work
exit 0
"""
And a file named "spec/run_spec.rb" with:
"""ruby
require 'spec_helper'
RSpec.describe 'Run command', type: :aruba, exit_timeout: 0.1, startup_wait_time: 0.5 do
before { run_command_and_stop('aruba-test-cli') }
it 'runs the command with the expected results' do
aggregate_failures do
expect(last_command_started).to be_successfully_executed
expect(last_command_started).to have_output /Hello, Aruba is working/
end
end
end
"""
When I run `rspec`
Then the specs should all pass
Scenario: Long-running command
If you have got a long-running command, you should consider using the
`exit_timeout`-option.
Given an executable named "bin/aruba-test-cli" with:
"""bash
#!/usr/bin/env bash
function do_some_work {
sleep 0.1
echo "Hello, Aruba here"
}
do_some_work
"""
And a file named "spec/run_spec.rb" with:
"""ruby
require 'spec_helper'
RSpec.describe 'Run command', type: :aruba, exit_timeout: 0.5 do
before { run_command_and_stop('aruba-test-cli') }
it 'runs the command with the expected results' do
aggregate_failures do
expect(last_command_started).to be_successfully_executed
expect(last_command_started).to have_output /Hello, Aruba here/
end
end
end
"""
When I run `rspec`
Then the specs should all pass
Scenario: Sending signals to commands started with `#run_command_and_stop()`
Sending signals to a command which is started by
`#run_command_and_stop()` does not make sense. The command is stopped internally when
its exit status is checked.
Given an executable named "bin/aruba-test-cli" with:
"""bash
#!/usr/bin/env bash
function initialize_script {
sleep 0.1
}
function cleanup_script {
sleep 0.1
}
function do_some_work {
echo "Hello, Aruba is working"
}
trap stop_script TERM
initialize_script
do_some_work
cleanup_script
exit 0
"""
And a file named "spec/run_spec.rb" with:
"""ruby
require 'spec_helper'
RSpec.describe 'Run command', type: :aruba, exit_timeout: 0.3, startup_wait_time: 0.3 do
before { run_command_and_stop('aruba-test-cli') }
it 'refuses to send a signal' do
expect { last_command_started.send_signal 'HUP' }.
to raise_error Aruba::CommandAlreadyStoppedError
end
end
"""
When I run `rspec`
Then the specs should all pass
Scenario: Activate announcer channels on failure
Given an executable named "bin/aruba-test-cli" with:
"""bash
#!/bin/bash
echo "Hello, I'm STDOUT"
echo "Hello, I'm STDERR" 1>&2
exit 1
"""
And a file named "spec/run_spec.rb" with:
"""ruby
require 'spec_helper'
Aruba.configure do |config|
config.activate_announcer_on_command_failure = [:stdout, :stderr]
end
RSpec.describe 'Run command', type: :aruba do
it { expect { run_command_and_stop('aruba-test-cli', fail_on_error: true) }.to_not raise_error }
end
"""
When I run `rspec`
Then the specs should not pass
And the output should contain:
"""
<<-STDOUT
Hello, I'm STDOUT
STDOUT
<<-STDERR
Hello, I'm STDERR
STDERR
"""
|
