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
|
if ENV['COVERAGE']
require 'simplecov'
SimpleCov.start do
add_filter '/test/'
add_group 'sinatra-contrib', 'sinatra-contrib'
add_group 'rack-protection', 'rack-protection'
end
end
ENV['APP_ENV'] = 'test'
require 'rack'
testdir = __dir__
$LOAD_PATH.unshift testdir unless $LOAD_PATH.include?(testdir)
libdir = File.dirname(__dir__) + '/lib'
$LOAD_PATH.unshift libdir unless $LOAD_PATH.include?(libdir)
require 'minitest'
require 'contest'
require 'rack/test'
# Some of ActiveSupport's core extensions to Hash get loaded during internal
# testing (e.g. by RABL and our RABL test) that we have no control over, but we
# need them to load *before* Sinatra::IndifferentHash (which is itself loaded
# by Sinatra::Base) whenever the full test suite is executed, so we'll do it
# preemptively here.
#
# Newer Rubies have these methods built-in, so the extensions are no-ops.
require 'active_support/core_ext/hash/conversions'
require 'active_support/core_ext/hash/slice'
require 'active_support/core_ext/hash/keys'
require 'sinatra/base'
require 'i18n'
I18n.config.available_locales = :en
class Sinatra::Base
include Minitest::Assertions
# Allow assertions in request context
def assertions
@assertions ||= 0
end
attr_writer :assertions
end
class Rack::Builder
def include?(middleware)
@ins.any? { |m| middleware === m }
end
end
Sinatra::Base.set :environment, :test
class Minitest::Test
include Rack::Test::Methods
class << self
alias_method :it, :test
alias_method :section, :context
end
def self.example(desc = nil, &block)
@example_count = 0 unless instance_variable_defined? :@example_count
@example_count += 1
it(desc || "Example #{@example_count}", &block)
end
alias_method :response, :last_response
setup do
Sinatra::Base.set :environment, :test
end
# Sets up a Sinatra::Base subclass defined with the block
# given. Used in setup or individual spec methods to establish
# the application.
def mock_app(base=Sinatra::Base, &block)
@app = Sinatra.new(base, &block)
end
def app
Rack::Lint.new(@app)
end
def body
response.body.to_s
end
def assert_body(value)
if value.respond_to? :to_str
assert_equal value.lstrip.gsub(/\s*\n\s*/, ""), body.lstrip.gsub(/\s*\n\s*/, "")
else
assert_match value, body
end
end
def assert_status(expected)
assert_equal Integer(expected), Integer(status)
end
def assert_like(a,b)
pattern = /id=['"][^"']*["']|\s+/
assert_equal a.strip.gsub(pattern, ""), b.strip.gsub(pattern, "")
end
def assert_include(str, substr)
assert str.include?(substr), "expected #{str.inspect} to include #{substr.inspect}"
end
def options(uri, params = {}, env = {}, &block)
request(uri, env.merge(:method => "OPTIONS", :params => params), &block)
end
def patch(uri, params = {}, env = {}, &block)
request(uri, env.merge(:method => "PATCH", :params => params), &block)
end
def link(uri, params = {}, env = {}, &block)
request(uri, env.merge(:method => "LINK", :params => params), &block)
end
def unlink(uri, params = {}, env = {}, &block)
request(uri, env.merge(:method => "UNLINK", :params => params), &block)
end
# Delegate other missing methods to response.
def method_missing(name, *args, &block)
if response && response.respond_to?(name)
response.send(name, *args, &block)
else
super
end
rescue Rack::Test::Error
super
end
# Do not output warnings for the duration of the block.
def silence_warnings
$VERBOSE, v = nil, $VERBOSE
yield
ensure
$VERBOSE = v
end
end
|
