assert 2.3.1 → 2.3.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -1,154 +1,162 @@
1
1
  module Assert
2
2
  module Assertions
3
3
 
4
- def assert_block(desc=nil)
5
- msg ||= "Expected block to return a true value."
6
- assert(yield, desc, msg)
4
+ def assert_block(desc = nil)
5
+ assert(yield, desc){ "Expected block to return a true value." }
7
6
  end
8
7
 
9
- def assert_not_block(desc=nil)
10
- msg ||= "Expected block to return a false value."
11
- assert(!yield, desc, msg)
8
+ def assert_not_block(desc = nil)
9
+ assert(!yield, desc){ "Expected block to return a false value." }
12
10
  end
13
11
  alias_method :refute_block, :assert_not_block
14
12
 
15
- def assert_empty(collection, desc=nil)
16
- msg = "Expected #{collection.inspect} to be empty."
17
- assert(collection.empty?, desc, msg)
13
+ def assert_empty(collection, desc = nil)
14
+ assert(collection.empty?, desc) do
15
+ "Expected #{collection.inspect} to be empty."
16
+ end
18
17
  end
19
18
 
20
- def assert_not_empty(collection, desc=nil)
21
- msg = "Expected #{collection.inspect} to not be empty."
22
- assert(!collection.empty?, desc, msg)
19
+ def assert_not_empty(collection, desc = nil)
20
+ assert(!collection.empty?, desc) do
21
+ "Expected #{collection.inspect} to not be empty."
22
+ end
23
23
  end
24
24
  alias_method :refute_empty, :assert_not_empty
25
25
 
26
- def assert_equal(expected, actual, desc=nil)
27
- msg = "Expected #{expected.inspect}, not #{actual.inspect}."
28
- assert(actual == expected, desc, msg)
26
+ def assert_equal(expected, actual, desc = nil)
27
+ assert(actual == expected, desc) do
28
+ "Expected #{expected.inspect}, not #{actual.inspect}."
29
+ end
29
30
  end
30
31
 
31
- def assert_not_equal(expected, actual, desc=nil)
32
- msg = "#{actual.inspect} not expected to equal #{expected.inspect}."
33
- assert(actual != expected, desc, msg)
32
+ def assert_not_equal(expected, actual, desc = nil)
33
+ assert(actual != expected, desc) do
34
+ "#{actual.inspect} not expected to equal #{expected.inspect}."
35
+ end
34
36
  end
35
37
  alias_method :refute_equal, :assert_not_equal
36
38
 
37
- def assert_file_exists(file_path, desc=nil)
38
- msg = "Expected #{file_path.inspect} to exist."
39
- assert(File.exists?(File.expand_path(file_path)), desc, msg)
39
+ def assert_file_exists(file_path, desc = nil)
40
+ assert(File.exists?(File.expand_path(file_path)), desc) do
41
+ "Expected #{file_path.inspect} to exist."
42
+ end
40
43
  end
41
44
 
42
- def assert_not_file_exists(file_path, desc=nil)
43
- msg = "Expected #{file_path.inspect} to not exist."
44
- assert(!File.exists?(File.expand_path(file_path)), desc, msg)
45
+ def assert_not_file_exists(file_path, desc = nil)
46
+ assert(!File.exists?(File.expand_path(file_path)), desc) do
47
+ "Expected #{file_path.inspect} to not exist."
48
+ end
45
49
  end
46
50
  alias_method :refute_file_exists, :assert_not_file_exists
47
51
 
48
- def assert_includes(object, collection, desc=nil)
49
- msg = "Expected #{collection.inspect} to include #{object.inspect}."
50
- assert(collection.include?(object), desc, msg)
52
+ def assert_includes(object, collection, desc = nil)
53
+ assert(collection.include?(object), desc) do
54
+ "Expected #{collection.inspect} to include #{object.inspect}."
55
+ end
51
56
  end
52
57
  alias_method :assert_included, :assert_includes
53
58
 
54
- def assert_not_includes(object, collection, desc=nil)
55
- msg = "Expected #{collection.inspect} to not include #{object.inspect}."
56
- assert(!collection.include?(object), desc, msg)
59
+ def assert_not_includes(object, collection, desc = nil)
60
+ assert(!collection.include?(object), desc) do
61
+ "Expected #{collection.inspect} to not include #{object.inspect}."
62
+ end
57
63
  end
58
64
  alias_method :assert_not_included, :assert_not_includes
59
65
  alias_method :refute_includes, :assert_not_includes
60
66
  alias_method :refute_included, :assert_not_includes
61
67
 
62
- def assert_instance_of(klass, instance, desc=nil)
63
- msg = "Expected #{instance.inspect} (#{instance.class}) to"\
64
- " be an instance of #{klass}."
65
- assert(instance.instance_of?(klass), desc, msg)
68
+ def assert_instance_of(klass, instance, desc = nil)
69
+ assert(instance.instance_of?(klass), desc) do
70
+ "Expected #{instance.inspect} (#{instance.class}) to be an instance of #{klass}."
71
+ end
66
72
  end
67
73
 
68
- def assert_not_instance_of(klass, instance, desc=nil)
69
- msg = "#{instance.inspect} not expected to be an instance of #{klass}."
70
- assert(!instance.instance_of?(klass), desc, msg)
74
+ def assert_not_instance_of(klass, instance, desc = nil)
75
+ assert(!instance.instance_of?(klass), desc) do
76
+ "#{instance.inspect} (#{instance.class}) not expected to be an instance of #{klass}."
77
+ end
71
78
  end
72
79
  alias_method :refute_instance_of, :assert_not_instance_of
73
80
 
74
81
  def assert_kind_of(klass, instance, desc=nil)
75
- msg = "Expected #{instance.inspect} (#{instance.class}) to"\
76
- " be a kind of #{klass}."
77
- assert(instance.kind_of?(klass), desc, msg)
82
+ assert(instance.kind_of?(klass), desc) do
83
+ "Expected #{instance.inspect} (#{instance.class}) to be a kind of #{klass}."
84
+ end
78
85
  end
79
86
 
80
87
  def assert_not_kind_of(klass, instance, desc=nil)
81
- msg = "#{instance.inspect} not expected to be a kind of #{klass}."
82
- assert(!instance.kind_of?(klass), desc, msg)
88
+ assert(!instance.kind_of?(klass), desc) do
89
+ "#{instance.inspect} not expected to be a kind of #{klass}."
90
+ end
83
91
  end
84
92
  alias_method :refute_kind_of, :assert_not_kind_of
85
93
 
86
94
  def assert_match(expected, actual, desc=nil)
87
- msg = "Expected #{actual.inspect} to match #{expected.inspect}."
88
- expected = /#{Regexp.escape(expected)}/ if String === expected && String === actual
89
- assert(actual =~ expected, desc, msg)
95
+ exp = String === expected && String === actual ? /#{Regexp.escape(expected)}/ : expected
96
+ assert(actual =~ exp, desc) do
97
+ "Expected #{actual.inspect} to match #{expected.inspect}."
98
+ end
90
99
  end
91
100
 
92
101
  def assert_not_match(expected, actual, desc=nil)
93
- msg = "#{actual.inspect} not expected to match #{expected.inspect}."
94
- expected = /#{Regexp.escape(expected)}/ if String === expected && String === actual
95
- assert(actual !~ expected, desc, msg)
102
+ exp = String === expected && String === actual ? /#{Regexp.escape(expected)}/ : expected
103
+ assert(actual !~ exp, desc) do
104
+ "#{actual.inspect} not expected to match #{expected.inspect}."
105
+ end
96
106
  end
97
107
  alias_method :refute_match, :assert_not_match
98
108
  alias_method :assert_no_match, :assert_not_match
99
109
 
100
110
  def assert_nil(object, desc=nil)
101
- msg = "Expected nil, not #{object.inspect}."
102
- assert(object.nil?, desc, msg)
111
+ assert(object.nil?, desc){ "Expected nil, not #{object.inspect}." }
103
112
  end
104
113
 
105
114
  def assert_not_nil(object, desc=nil)
106
- msg = "Expected #{object.inspect} to not be nil."
107
- assert(!object.nil?, desc, msg)
115
+ assert(!object.nil?, desc){ "Expected #{object.inspect} to not be nil." }
108
116
  end
109
117
  alias_method :refute_nil, :assert_not_nil
110
118
 
111
119
  def assert_raises(*exceptions, &block)
112
120
  desc = exceptions.last.kind_of?(String) ? exceptions.pop : nil
113
121
  err = RaisedException.new(exceptions, &block)
114
- assert(err.raised?, desc, err.msg)
122
+ assert(err.raised?, desc){ err.msg }
115
123
  end
116
124
  alias_method :assert_raise, :assert_raises
117
125
 
118
126
  def assert_nothing_raised(*exceptions, &block)
119
127
  desc = exceptions.last.kind_of?(String) ? exceptions.pop : nil
120
128
  err = NoRaisedException.new(exceptions, &block)
121
- assert(!err.raised?, desc, err.msg)
129
+ assert(!err.raised?, desc){ err.msg }
122
130
  end
123
131
  alias_method :assert_not_raises, :assert_nothing_raised
124
132
  alias_method :assert_not_raise, :assert_nothing_raised
125
133
 
126
134
  def assert_respond_to(method, object, desc=nil)
127
- msg = "Expected #{object.inspect} (#{object.class}) to"\
128
- " respond to `#{method}`."
129
- assert(object.respond_to?(method), desc, msg)
135
+ assert(object.respond_to?(method), desc) do
136
+ "Expected #{object.inspect} (#{object.class}) to respond to `#{method}`."
137
+ end
130
138
  end
131
139
  alias_method :assert_responds_to, :assert_respond_to
132
140
 
133
141
  def assert_not_respond_to(method, object, desc=nil)
134
- msg = "#{object.inspect} (#{object.class}) not expected to"\
135
- " respond to `#{method}`."
136
- assert(!object.respond_to?(method), desc, msg)
142
+ assert(!object.respond_to?(method), desc) do
143
+ "#{object.inspect} (#{object.class}) not expected to respond to `#{method}`."
144
+ end
137
145
  end
138
146
  alias_method :assert_not_responds_to, :assert_not_respond_to
139
147
  alias_method :refute_respond_to, :assert_not_respond_to
140
148
  alias_method :refute_responds_to, :assert_not_respond_to
141
149
 
142
150
  def assert_same(expected, actual, desc=nil)
143
- msg = "Expected #{actual} (#{actual.object_id}) to"\
144
- " be the same as #{expected} (#{expected.object_id})."
145
- assert(actual.equal?(expected), desc, msg)
151
+ assert(actual.equal?(expected), desc) do
152
+ "Expected #{actual} (#{actual.object_id}) to be the same as #{expected} (#{expected.object_id})."
153
+ end
146
154
  end
147
155
 
148
156
  def assert_not_same(expected, actual, desc=nil)
149
- msg = "#{actual} (#{actual.object_id}) not expected to"\
150
- " be the same as #{expected} (#{expected.object_id})."
151
- assert(!actual.equal?(expected), desc, msg)
157
+ assert(!actual.equal?(expected), desc) do
158
+ "#{actual} (#{actual.object_id}) not expected to be the same as #{expected} (#{expected.object_id})."
159
+ end
152
160
  end
153
161
  alias_method :refute_same, :assert_not_same
154
162
 
@@ -174,17 +174,19 @@ module Assert
174
174
  # check if the assertion is a truthy value, if so create a new pass result, otherwise
175
175
  # create a new fail result with the desc and what failed msg.
176
176
  # all other assertion helpers use this one in the end
177
- def assert(assertion, fail_desc=nil, what_failed_msg=nil)
178
- what_failed_msg ||= "Failed assert: assertion was <#{assertion.inspect}>."
179
- msg = fail_message(fail_desc) { what_failed_msg }
180
- assertion ? pass : fail(msg)
177
+ def assert(assertion, fail_desc = nil)
178
+ if assertion
179
+ pass
180
+ else
181
+ what_failed_msg = block_given? ? yield : "Failed assert: assertion was <#{assertion.inspect}>."
182
+ fail(fail_message(fail_desc, what_failed_msg))
183
+ end
181
184
  end
182
185
 
183
186
  # the opposite of assert, check if the assertion is a false value, if so create a new pass
184
187
  # result, otherwise create a new fail result with the desc and it's what failed msg
185
- def assert_not(assertion, fail_desc=nil)
186
- what_failed_msg = "Failed assert_not: assertion was <#{assertion.inspect}>."
187
- assert(!assertion, fail_desc, what_failed_msg)
188
+ def assert_not(assertion, fail_desc = nil)
189
+ assert(!assertion, fail_desc){ "Failed assert_not: assertion was <#{assertion.inspect}>." }
188
190
  end
189
191
  alias_method :refute, :assert_not
190
192
 
@@ -206,13 +208,12 @@ module Assert
206
208
 
207
209
  # adds a Fail result to the end of the test's results
208
210
  # break test execution if Assert.config.halt_on_fail
209
- def fail(fail_msg=nil)
210
- message = (fail_message(fail_msg) { }).call
211
+ def fail(message = nil)
211
212
  if Assert.config.halt_on_fail
212
- raise Result::TestFailure, message
213
+ raise Result::TestFailure, message || ''
213
214
  else
214
215
  capture_result do |test, backtrace|
215
- Assert::Result::Fail.new(test, message, backtrace)
216
+ Assert::Result::Fail.new(test, message || '', backtrace)
216
217
  end
217
218
  end
218
219
  end
@@ -220,7 +221,7 @@ module Assert
220
221
 
221
222
  # adds a Skip result to the end of the test's results and breaks test execution
222
223
  def skip(skip_msg=nil)
223
- raise(Result::TestSkipped, skip_msg || "")
224
+ raise(Result::TestSkipped, skip_msg || '')
224
225
  end
225
226
 
226
227
  # alter the backtraces of fail results generated in the given block
@@ -250,10 +251,8 @@ module Assert
250
251
  protected
251
252
 
252
253
  # Returns a Proc that will output a custom message along with the default fail message.
253
- def fail_message(fail_desc=nil, &what_failed)
254
- fail_desc.kind_of?(::Proc) ? fail_desc : Proc.new do
255
- [ fail_desc, what_failed.call ].compact.join("\n")
256
- end
254
+ def fail_message(fail_desc = nil, what_failed_msg = nil)
255
+ [ fail_desc, what_failed_msg ].compact.join("\n")
257
256
  end
258
257
 
259
258
  private
data/lib/assert/suite.rb CHANGED
@@ -77,7 +77,7 @@ module Assert
77
77
  if block_given?
78
78
  self.setups << block
79
79
  else
80
- self.setups.each{|setup| setup.call}
80
+ self.setups.each{ |setup| setup.call }
81
81
  end
82
82
  end
83
83
  alias_method :startup, :setup
@@ -86,7 +86,7 @@ module Assert
86
86
  if block_given?
87
87
  self.teardowns << block
88
88
  else
89
- self.teardowns.reverse.each{|teardown| teardown.call}
89
+ self.teardowns.reverse.each{ |teardown| teardown.call }
90
90
  end
91
91
  end
92
92
  alias_method :shutdown, :teardown
data/lib/assert/test.rb CHANGED
@@ -35,11 +35,19 @@ module Assert
35
35
  @results << Result::Fail.new(self, err)
36
36
  rescue Result::TestSkipped => err
37
37
  @results << Result::Skip.new(self, err)
38
+ rescue SignalException => err
39
+ raise(err)
38
40
  rescue Exception => err
39
41
  @results << Result::Error.new(self, err)
40
42
  ensure
41
43
  begin
42
44
  run_test_teardown(run_scope)
45
+ rescue Result::TestFailure => err
46
+ @results << Result::Fail.new(self, err)
47
+ rescue Result::TestSkipped => err
48
+ @results << Result::Skip.new(self, err)
49
+ rescue SignalException => err
50
+ raise(err)
43
51
  rescue Exception => teardown_err
44
52
  @results << Result::Error.new(self, teardown_err)
45
53
  end
@@ -1,3 +1,3 @@
1
1
  module Assert
2
- VERSION = "2.3.1"
2
+ VERSION = "2.3.2"
3
3
  end
@@ -50,7 +50,7 @@ module Assert::Assertions
50
50
  end
51
51
 
52
52
  should "have a fail message with custom and generic explanations" do
53
- exp = "#{@args[2]}\n#{@args[1].inspect} not expected to"\
53
+ exp = "#{@args[2]}\n#{@args[1].inspect} (#{@args[1].class}) not expected to"\
54
54
  " be an instance of #{@args[0]}."
55
55
  assert_equal exp, subject.fail_results.first.message
56
56
  end
@@ -108,12 +108,6 @@ class Assert::Context
108
108
  assert_equal fail_msg, result.message
109
109
  end
110
110
 
111
- should "set any given result message evaluated from a proc" do
112
- fail_msg = ::Proc.new{ "Still didn't work" }
113
- result = @context.fail(fail_msg)
114
- assert_equal fail_msg.call, result.message
115
- end
116
-
117
111
  end
118
112
 
119
113
  class HaltOnFailTests < FailTests
@@ -151,13 +145,13 @@ class Assert::Context
151
145
  end
152
146
 
153
147
  should "return a pass result given a `true` assertion" do
154
- result = subject.assert(true, @fail_desc, @what_failed)
148
+ result = subject.assert(true, @fail_desc){ @what_failed }
155
149
  assert_kind_of Assert::Result::Pass, result
156
150
  assert_nil result.message
157
151
  end
158
152
 
159
153
  should "return a fail result given a `false` assertion" do
160
- result = subject.assert(false, @fail_desc, @what_failed)
154
+ result = subject.assert(false, @fail_desc){ @what_failed }
161
155
  assert_kind_of Assert::Result::Fail, result
162
156
  assert_equal [@fail_desc, @what_failed].join("\n"), result.message
163
157
  end
@@ -7,7 +7,7 @@ class Assert::Test
7
7
  desc "a test obj"
8
8
  setup do
9
9
  @test_code = lambda{ assert(true) }
10
- @context_class = Factory.context_class { desc "context class" }
10
+ @context_class = Factory.context_class{ desc "context class" }
11
11
  @context_info = Factory.context_info(@context_class)
12
12
  @test = Factory.test("should do something amazing", @context_info, @test_code)
13
13
  end
@@ -51,9 +51,16 @@ class Assert::Test
51
51
  ignore("something")
52
52
  assert(true)
53
53
  assert(false)
54
- ignore("something else")
55
- assert(34)
56
- assert(nil)
54
+ end
55
+ @test.context_class.setup do
56
+ ignore("something")
57
+ assert(true)
58
+ assert(false)
59
+ end
60
+ @test.context_class.teardown do
61
+ ignore("something")
62
+ assert(true)
63
+ assert(false)
57
64
  end
58
65
  @test.run
59
66
  end
@@ -61,7 +68,7 @@ class Assert::Test
61
68
 
62
69
  should "know its pass results" do
63
70
  assert_kind_of Array, subject.pass_results
64
- assert_equal 2, subject.pass_results.size
71
+ assert_equal 3, subject.pass_results.size
65
72
  subject.pass_results.each do |result|
66
73
  assert_kind_of Assert::Result::Pass, result
67
74
  end
@@ -70,7 +77,7 @@ class Assert::Test
70
77
 
71
78
  should "know its fail results" do
72
79
  assert_kind_of Array, subject.fail_results
73
- assert_equal 2, subject.fail_results.size
80
+ assert_equal 3, subject.fail_results.size
74
81
  subject.fail_results.each do |result|
75
82
  assert_kind_of Assert::Result::Fail, result
76
83
  end
@@ -79,7 +86,7 @@ class Assert::Test
79
86
 
80
87
  should "know its ignore results" do
81
88
  assert_kind_of Array, subject.ignore_results
82
- assert_equal 2, subject.ignore_results.size
89
+ assert_equal 3, subject.ignore_results.size
83
90
  subject.ignore_results.each do |result|
84
91
  assert_kind_of Assert::Result::Ignore, result
85
92
  end
@@ -87,25 +94,48 @@ class Assert::Test
87
94
  end
88
95
 
89
96
  should "know the total number of results" do
90
- assert_equal(6, subject.result_count)
97
+ assert_equal(9, subject.result_count)
91
98
  end
92
99
 
93
100
  end
94
101
 
95
102
  class SkipHandlingTests < BasicTests
96
103
  setup do
97
- @test = Factory.test("skip test", @context_info) { skip }
104
+ @test = Factory.test("skip test", @context_info){ skip }
98
105
  @test.run
99
106
  end
100
107
  subject{ @test }
101
108
 
102
- should "know its skip results" do
103
- assert_kind_of Array, subject.skip_results
104
- assert_equal 1, subject.skip_results.size
105
- subject.skip_results.each do |result|
106
- assert_kind_of Assert::Result::Skip, result
109
+ should "capture skip results" do
110
+ assert_skipped(subject)
111
+ end
112
+
113
+ should "capture skips in the context setup" do
114
+ test = Factory.test("setup skip test", @context_info){ }
115
+ test.context_class.setup{ skip }
116
+ test.run
117
+
118
+ assert_skipped(test)
119
+ end
120
+
121
+ should "capture skips in the context teardown" do
122
+ test = Factory.test("teardown skip test", @context_info){ }
123
+ test.context_class.teardown{ skip }
124
+ test.run
125
+
126
+ assert_skipped(test)
127
+ end
128
+
129
+ private
130
+
131
+ def assert_skipped(test)
132
+ with_backtrace(caller) do
133
+ assert_equal 1, test.skip_results.size, 'too many/few skip results'
134
+ test.skip_results.each do |result|
135
+ assert_kind_of Assert::Result::Skip, result, 'result is not a skip result'
136
+ end
137
+ assert_equal test.skip_results.size, test.result_count(:skip), 'skip result not counted'
107
138
  end
108
- assert_equal subject.skip_results.size, subject.result_count(:skip)
109
139
  end
110
140
 
111
141
  end
@@ -119,13 +149,64 @@ class Assert::Test
119
149
  end
120
150
  subject{ @test }
121
151
 
122
- should "know its error results" do
123
- assert_kind_of Array, subject.error_results
124
- assert_equal 1, subject.error_results.size
125
- subject.error_results.each do |result|
126
- assert_kind_of Assert::Result::Error, result
152
+ should "capture error results" do
153
+ assert_errored(subject)
154
+ end
155
+
156
+ should "capture errors in the context setup" do
157
+ test = Factory.test("setup error test", @context_info){ }
158
+ test.context_class.setup{ raise 'an error' }
159
+ test.run
160
+
161
+ assert_errored(test)
162
+ end
163
+
164
+ should "capture errors in the context teardown" do
165
+ test = Factory.test("teardown error test", @context_info){ }
166
+ test.context_class.teardown{ raise 'an error' }
167
+ test.run
168
+
169
+ assert_errored(test)
170
+ end
171
+
172
+ private
173
+
174
+ def assert_errored(test)
175
+ with_backtrace(caller) do
176
+ assert_equal 1, subject.error_results.size, 'too many/few error results'
177
+ test.error_results.each do |result|
178
+ assert_kind_of Assert::Result::Error, result, 'result is not an error result'
179
+ end
180
+ assert_equal test.error_results.size, test.result_count(:error), 'error result not counted'
127
181
  end
128
- assert_equal subject.error_results.size, subject.result_count(:error)
182
+ end
183
+
184
+ end
185
+
186
+ class SignalExceptionHandlingTests < BasicTests
187
+ setup do
188
+ @test = Factory.test("signal test", @context_info) do
189
+ raise SignalException, "USR1"
190
+ end
191
+ end
192
+ subject{ @test }
193
+
194
+ should "raise any signal exceptions and not capture as an error" do
195
+ assert_raises(SignalException){ subject.run }
196
+ end
197
+
198
+ should "raises signal exceptions in the context setup" do
199
+ test = Factory.test("setup signal test", @context_info){ }
200
+ test.context_class.setup{ raise SignalException, 'INT' }
201
+
202
+ assert_raises(SignalException){ test.run }
203
+ end
204
+
205
+ should "raises signal exceptions in the context teardown" do
206
+ test = Factory.test("teardown signal test", @context_info){ }
207
+ test.context_class.teardown{ raise SignalException, "TERM" }
208
+
209
+ assert_raises(SignalException){ test.run }
129
210
  end
130
211
 
131
212
  end
@@ -157,10 +238,10 @@ class Assert::Test
157
238
  class CaptureOutTests < BasicTests
158
239
  desc "when capturing std out"
159
240
  setup do
160
- @test = Factory.test("stdout") {
241
+ @test = Factory.test("stdout") do
161
242
  puts "std out from the test"
162
243
  assert true
163
- }
244
+ end
164
245
  @orig_capture = Assert.config.capture_output
165
246
  Assert.config.capture_output true
166
247
  end
@@ -182,8 +263,8 @@ class Assert::Test
182
263
  puts "std out from the test"
183
264
  assert a_method_an_assert_calls
184
265
  end
185
- @test.context_class.setup { puts "std out from the setup" }
186
- @test.context_class.teardown { puts "std out from the teardown" }
266
+ @test.context_class.setup{ puts "std out from the setup" }
267
+ @test.context_class.teardown{ puts "std out from the teardown" }
187
268
  @test.context_class.send(:define_method, "a_method_an_assert_calls") do
188
269
  puts "std out from a method an assert called"
189
270
  end
metadata CHANGED
@@ -1,13 +1,13 @@
1
1
  --- !ruby/object:Gem::Specification
2
2
  name: assert
3
3
  version: !ruby/object:Gem::Version
4
- hash: 1
4
+ hash: 7
5
5
  prerelease:
6
6
  segments:
7
7
  - 2
8
8
  - 3
9
- - 1
10
- version: 2.3.1
9
+ - 2
10
+ version: 2.3.2
11
11
  platform: ruby
12
12
  authors:
13
13
  - Kelly Redding
@@ -16,7 +16,7 @@ autorequire:
16
16
  bindir: bin
17
17
  cert_chain: []
18
18
 
19
- date: 2013-10-03 00:00:00 Z
19
+ date: 2013-10-29 00:00:00 Z
20
20
  dependencies:
21
21
  - !ruby/object:Gem::Dependency
22
22
  name: ansi