Class: ApiMiniTester::TestStep

Inherits:
Object
  • Object
show all
Includes:
HTTParty
Defined in:
lib/api_mini_tester/test_step.rb

Constant Summary collapse

SUPPORTED_METHODS = 
i[ get post put delete ].freeze
SUPPORTED_RANDOM_DISTRIBUTION = 
%w[ static norm uniform ].freeze

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(base_uri, step, context = nil, data = nil, defaults = nil, debug = false) ⇒ TestStep

Returns a new instance of TestStep.



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
 
# File 'lib/api_mini_tester/test_step.rb', line 20

def initialize(base_uri, step, context = nil, data = nil, defaults = nil, debug = false)
  @debug = debug
  if debug
    @debug_output = File.open(ApiMiniTester::TestSuite::DEBUG_FILE, 'a')
  end
  step = step.deep_merge!(defaults) do |key, this_val, other_val|
    if this_val.nil?
      other_val
    elsif this_val.is_a?(Array)
      (this_val + other_val)
    else
      this_val
    end
  end if defaults

  Liquid::Template.register_filter(::TestFakerFilter)
  @context = context
  uri_template = Liquid::Template.parse([base_uri, step['uri']].join("/"), error_mode: :strict)
  @name = step['name']
  @sleeps = step['sleep']

  @uri = uri_template.render(
    {'context' => context, 'data' => data},
    { strict_variables: true })
  @method = step['method'].downcase.to_sym

  input_template = Liquid::Template.parse(step['input'].to_yaml.to_s, error_mode: :strict)
  @input = YAML.load(
    input_template.render({'context' => context, 'data' => data}, { strict_variables: true }))

  output_template = Liquid::Template.parse(step['output'].to_yaml.to_s, error_mode: :strict)
  @output = YAML.load(
    output_template.render({'context' => context, 'data' => data}, { strict_variables: true }))

  @results = { name: step['name'], desc: step['desc'], status: [], headers: [], body: [], url: [], method: [], timing: [] }
end

Instance Attribute Details

#debug ⇒ Object (readonly)

Returns the value of attribute debug.



18
19
20
 
# File 'lib/api_mini_tester/test_step.rb', line 18

def debug
  @debug
end

#input ⇒ Object

Returns the value of attribute input.



17
18
19
 
# File 'lib/api_mini_tester/test_step.rb', line 17

def input
  @input
end

#method ⇒ Object (readonly)

Returns the value of attribute method.



18
19
20
 
# File 'lib/api_mini_tester/test_step.rb', line 18

def method
  @method
end

#name ⇒ Object

Returns the value of attribute name.



17
18
19
 
# File 'lib/api_mini_tester/test_step.rb', line 17

def name
  @name
end

#output ⇒ Object

Returns the value of attribute output.



17
18
19
 
# File 'lib/api_mini_tester/test_step.rb', line 17

def output
  @output
end

#results ⇒ Object (readonly)

Returns the value of attribute results.



18
19
20
 
# File 'lib/api_mini_tester/test_step.rb', line 18

def results
  @results
end

#sleeps ⇒ Object (readonly)

Returns the value of attribute sleeps.



18
19
20
 
# File 'lib/api_mini_tester/test_step.rb', line 18

def sleeps
  @sleeps
end

#timing ⇒ Object

Returns the value of attribute timing.



17
18
19
 
# File 'lib/api_mini_tester/test_step.rb', line 17

def timing
  @timing
end

#uri ⇒ Object (readonly)

Returns the value of attribute uri.



18
19
20
 
# File 'lib/api_mini_tester/test_step.rb', line 18

def uri
  @uri
end

Instance Method Details

#add_result(section, result) ⇒ Object 



181
182
183
 
# File 'lib/api_mini_tester/test_step.rb', line 181

def add_result(section, result)
  @results[section] << result
end

#array_diff(a, b, path = nil, section = :body) ⇒ Object 



235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
 
# File 'lib/api_mini_tester/test_step.rb', line 235

def array_diff(a, b, path = nil, section = :body)
  a.each do |a_item|
    if b.nil?
      add_result section, { result: false,
        name: "Response boby value: #{[path].join(".")}",
        desc: "Assert #{[path].join(".")} is empty" }
    elsif a_item.instance_of?(Hash)
      found = false
      b.each do |b_item|
        matching = true
        a_item.each_key do |k, v|
          matching = (b_item[k] == a_item[k]) if matching
        end
        found = true if matching
      end
      add_result section, { result: found,
                            name: "Response body value: #{[path].join(".")}",
                            desc: "Assert #{[path].join(".")} #{found ? 'contains' : 'does not contains'} #{a_item}" }
    elsif a_item.instance_of?(Array)
      # TODO: Add support for array of array it isn't so needed to compate so deep structures
    else
      add_result section, { result: b.include?(a_item),
                            name: "Response boby value: #{[path].join(".")}",
                            desc: "Assert #{[path].join(".")} #{b.include?(a_item) ? 'contains' : 'does not contains'} #{a_item}" }
    end
  end
end

#assert_body(response, output) ⇒ Object 



227
228
229
230
231
232
233
 
# File 'lib/api_mini_tester/test_step.rb', line 227

def assert_body(response, output)
  if output.instance_of?(Hash)
    hash_diff(output, response)
  elsif output.instance_of?(Array)
    array_diff(output, response)
  end
end

#assert_headers(response, output) ⇒ Object 



216
217
218
219
220
221
222
223
224
225
 
# File 'lib/api_mini_tester/test_step.rb', line 216

def assert_headers(response, output)
  return if output.nil?

  output.each do |k, v|
    add_result :headers, { result: (v == response[k]),
                           name: "Header value: #{k} == #{v}",
                           desc: "Header #{k} expected: #{v}, got #{response[k]}",
                           exp: v, real: response[k] }
  end
end

#assert_status(response, output) ⇒ Object 



209
210
211
212
213
214
 
# File 'lib/api_mini_tester/test_step.rb', line 209

def assert_status(response, output)
  add_result :status, { result: (response == output),
                        name: "Response code == #{output}",
                        desc: "Expected response #{output}, got response #{response}",
                        exp: output, real: response }
end

#assert_timing(runtime, limit = nil) ⇒ Object 



201
202
203
204
205
206
207
 
# File 'lib/api_mini_tester/test_step.rb', line 201

def assert_timing(runtime, limit = nil)
  limit ||= Float::INFINITY
  add_result :timing, { result: (runtime < limit),
                        name: "Request time < #{limit}",
                        desc: "Expected request time #{limit}, real time #{runtime}",
                        exp: limit, real: runtime }
end

#body ⇒ Object 



77
78
79
80
81
82
83
84
85
86
 
# File 'lib/api_mini_tester/test_step.rb', line 77

def body
  case content_type
  when 'application/x-www-form-urlencoded'
    body_to_urlencoded
  when 'multipart/form-data'
    body_to_form_data
  else
    @input["body"].to_json
  end
end

#body_to_form_data ⇒ Object 



92
93
94
95
96
97
98
99
 
# File 'lib/api_mini_tester/test_step.rb', line 92

def body_to_form_data
  body = {}
  @input["body"].each do |item|
    body[item['name']] = item['value'] if item['type'] == 'input'
    body[item['name']] = File.open(item['value'], 'r') if item['type'] == 'file'
  end
  body
end

#body_to_urlencoded ⇒ Object 



101
102
103
104
105
106
107
 
# File 'lib/api_mini_tester/test_step.rb', line 101

def body_to_urlencoded
  body = []
  @input["body"].each do |key, value|
    body << [key, value]
  end
  URI.encode_www_form(body)
end

#content_type ⇒ Object 



67
68
69
 
# File 'lib/api_mini_tester/test_step.rb', line 67

def content_type
  @input['content_type'] || 'application/json'
end

#hash_diff(a, b, path = nil, section = :body) ⇒ Object 



263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
 
# File 'lib/api_mini_tester/test_step.rb', line 263

def hash_diff(a, b, path = nil, section = :body)
  return nil if a.nil? || b.nil?

  a.each_key do |k, v|
    current_path = [path, k].join('.')
    if b[k].nil?
      add_result section, { result: false,
                            name: "Reponse value: #{[path, k].join(".")}",
                            desc: "Missing #{current_path}" }
    elsif v.instance_of?(Hash)
      hash_diff(a[k], b[k], current_path, section)
    elsif v.instance_of?(Array)
      array_diff(a[k], b[k], current_path, section)
    else
      add_result section, { result: (a[k] == b[k]),
                            name: "Reponse body value: #{[path, k].join(".")}",
                            desc: "Assert #{[path, k].join(".")}: #{a[k]} #{a[k] == b[k] ? '==' : '!='} #{b[k]}" }
    end
  end
end

#headers ⇒ Object 



71
72
73
74
75
 
# File 'lib/api_mini_tester/test_step.rb', line 71

def headers
  @input['header'] = {} unless @input['header']
  @input['header']['Content-Type'] ||= content_type
  @input['header']
end

#log_debug(request, response, expectations) ⇒ Object 



170
171
172
173
 
# File 'lib/api_mini_tester/test_step.rb', line 170

def log_debug(request, response, expectations)
  log = { uri: uri, method: method, request: request, response: response, expectations: expectations }
  @debug_output.puts log.to_json
end

#print_results ⇒ Object 



175
176
177
178
179
 
# File 'lib/api_mini_tester/test_step.rb', line 175

def print_results
  @results.each do |line|
    puts line
  end
end

#raw_body ⇒ Object 



88
89
90
 
# File 'lib/api_mini_tester/test_step.rb', line 88

def raw_body
  @input["body"].to_hash
end

#run_asserts(response) ⇒ Object 



163
164
165
166
167
168
 
# File 'lib/api_mini_tester/test_step.rb', line 163

def run_asserts(response)
  assert_status(response.code, test_status)
  assert_headers(response.headers, test_headers)
  assert_body(response.parsed_response, test_body)
  assert_timing(timing, test_timing)
end

#run_step ⇒ Object 



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
 
# File 'lib/api_mini_tester/test_step.rb', line 125

def run_step
  if sleeps
    step_sleep(sleeps['before']) if sleeps['before']
  end

  @timing = Time.now
  case method
  when :get
    response = HTTParty.get(uri, headers: headers)
  when :post
    response = HTTParty.post(uri, headers: headers, body: body)
  when :put
    response = HTTParty.put(uri, headers: headers, body: body)
  when :delete
    response = HTTParty.delete(uri, headers: headers)
  when :patch
    response = HTTParty.patch(uri, headers: headers, body: body)
  else
    raise "Unknown HTTP method: #{method}"
  end
  @timing = Time.now - @timing

  if sleeps
    step_sleep(sleeps['after']) if sleeps['after']
  end

  add_result :url, { result: true, desc: "Url: #{uri}" }
  add_result :method, { result: true, desc: "Method: #{method}" }

  log_debug({ headers: headers, body: raw_body },
            { headers: response.headers, body: response.parsed_response, code: response.code },
            output) if debug

  run_asserts(response)

  [ results, response ]
end

#step_sleep(params) ⇒ Object 



185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
 
# File 'lib/api_mini_tester/test_step.rb', line 185

def step_sleep(params)
  params['distribution'] = 'static' unless SUPPORTED_RANDOM_DISTRIBUTION.include?(params['distribution'])

  t = begin
    case params['distribution']
    when 'static'
      params['value']
    when 'norm'
      Distribution::Normal.rng(params['mean'], params['sigma'], srand).call
    when 'uniform'
      Random.new.rand(params['max'] - params['min']) + params['min']
    end
  end
  sleep(t.to_f.abs) if t
end

#test_body ⇒ Object 



113
114
115
 
# File 'lib/api_mini_tester/test_step.rb', line 113

def test_body
  @output['body']
end

#test_headers ⇒ Object 



109
110
111
 
# File 'lib/api_mini_tester/test_step.rb', line 109

def test_headers
  @output['header']
end

#test_status ⇒ Object 



117
118
119
 
# File 'lib/api_mini_tester/test_step.rb', line 117

def test_status
  @output['status']
end

#test_timing ⇒ Object 



121
122
123
 
# File 'lib/api_mini_tester/test_step.rb', line 121

def test_timing
  @output['timing']
end

#valid? ⇒ Boolean

Returns:

  • (Boolean) 


57
58
59
60
61
62
63
64
65
 
# File 'lib/api_mini_tester/test_step.rb', line 57

def valid?
  return false if uri.nil? || uri.empty?

  return false unless URI.parse(uri) rescue false
  return false unless SUPPORTED_METHODS.include? method
  return false if @name.nil? || @name.empty?

  true
end