← Back to branch summary

~bkerensa/ubuntu/raring/puppet/new-upstream-release

« back to all changes in this revision

Viewing changes to spec/unit/network/http/handler_spec.rb

  • Committer: Bazaar Package Importer
  • Author(s): Chuck Short
  • Date: 2011-07-25 01:00:37 UTC
  • mfrom: (1.1.24 upstream) (3.1.25 sid)
  • Revision ID: james.westby@ubuntu.com-20110725010037-875vuxs10eboqgw3
Tags: 2.7.1-1ubuntu1
https://launchpad.net/bugs/641001
* Merge from debian unstable.  Remaining changes:
  - debian/puppetmaster-passenger.postinst: Use cacrl instead of hostcrl to
    set the location of the CRL in apache2 configuration. Fix apache2
    configuration on upgrade as well (LP: #641001)
  - move all puppet dependencies to puppet-common since all the code
    actually located in puppet-common.
  - move libagueas from a recommend to a dependency.

Show diffs side-by-side

added added

removed removed

Lines of Context:
spec/unit/network/http/handler_spec.rb
1
 
#!/usr/bin/env ruby
2
 
 
3
 
require File.dirname(__FILE__) + '/../../../spec_helper'
 
1
#!/usr/bin/env rspec
 
2
require 'spec_helper'
4
3
require 'puppet/network/http/handler'
5
4
require 'puppet/network/rest_authorization'
6
5
 
46
45
      @request.stubs(:[]).returns "foo"
47
46
      @response    = stub('http response')
48
47
      @model_class = stub('indirected model class')
 
48
      @indirection = stub('indirection')
 
49
      @model_class.stubs(:indirection).returns(@indirection)
49
50
 
50
51
      @result = stub 'result', :render => "mytext"
51
52
 
79
80
      @handler.process(@request, @response)
80
81
    end
81
82
 
82
 
    it "should call the 'do' method associated with the indirection method" do
83
 
      request = stub 'request'
84
 
      @handler.expects(:uri2indirection).returns request
85
 
 
86
 
      request.expects(:method).returns "mymethod"
87
 
 
88
 
      @handler.expects(:do_mymethod).with(request, @request, @response)
89
 
 
90
 
      @handler.process(@request, @response)
91
 
    end
92
 
 
93
 
    it "should delegate authorization to the RestAuthorization layer" do
94
 
      request = stub 'request'
95
 
      @handler.expects(:uri2indirection).returns request
96
 
 
97
 
      request.expects(:method).returns "mymethod"
98
 
 
99
 
      @handler.expects(:do_mymethod).with(request, @request, @response)
100
 
 
101
 
      @handler.expects(:check_authorization).with(request)
 
83
    it "should call the 'do' method and delegate authorization to the RestAuthorization layer" do
 
84
      @handler.expects(:uri2indirection).returns(["facts", :mymethod, "key", {:node => "name"}])
 
85
 
 
86
      @handler.expects(:do_mymethod).with("facts", "key", {:node => "name"}, @request, @response)
 
87
 
 
88
      @handler.expects(:check_authorization).with("facts", :mymethod, "key", {:node => "name"})
102
89
 
103
90
      @handler.process(@request, @response)
104
91
    end
105
92
 
106
93
    it "should return 403 if the request is not authorized" do
107
 
      request = stub 'request'
108
 
      @handler.expects(:uri2indirection).returns request
 
94
      @handler.expects(:uri2indirection).returns(["facts", :mymethod, "key", {:node => "name"}])
109
95
 
110
96
      @handler.expects(:do_mymethod).never
111
97
 
112
 
      @handler.expects(:check_authorization).with(request).raises(Puppet::Network::AuthorizationError.new("forbindden"))
 
98
      @handler.expects(:check_authorization).with("facts", :mymethod, "key", {:node => "name"}).raises(Puppet::Network::AuthorizationError.new("forbidden"))
113
99
 
114
100
      @handler.expects(:set_response).with { |response, body, status| status == 403 }
115
101
 
117
103
    end
118
104
 
119
105
    it "should serialize a controller exception when an exception is thrown while finding the model instance" do
120
 
      @handler.expects(:uri2indirection).returns stub("request", :method => :find)
 
106
      @handler.expects(:uri2indirection).returns(["facts", :find, "key", {:node => "name"}])
121
107
 
122
108
      @handler.expects(:do_find).raises(ArgumentError, "The exception")
123
109
      @handler.expects(:set_response).with { |response, body, status| body == "The exception" and status == 400 }
141
127
 
142
128
    describe "when finding a model instance" do
143
129
      before do
144
 
        @irequest = stub 'indirection_request', :method => :find, :indirection_name => "my_handler", :to_hash => {}, :key => "my_result", :model => @model_class
145
 
 
146
 
        @model_class.stubs(:find).returns @result
 
130
        @indirection.stubs(:find).returns @result
 
131
        Puppet::Indirector::Indirection.expects(:instance).with(:my_handler).returns( stub "indirection", :model => @model_class )
147
132
 
148
133
        @format = stub 'format', :suitable? => true, :mime => "text/format", :name => "format"
149
134
        Puppet::Network::FormatHandler.stubs(:format).returns @format
153
138
      end
154
139
 
155
140
      it "should use the indirection request to find the model class" do
156
 
        @irequest.expects(:model).returns @model_class
157
 
 
158
 
        @handler.do_find(@irequest, @request, @response)
 
141
        @handler.do_find("my_handler", "my_result", {}, @request, @response)
159
142
      end
160
143
 
161
144
      it "should use the escaped request key" do
162
 
        @model_class.expects(:find).with do |key, args|
 
145
        @indirection.expects(:find).with do |key, args|
163
146
          key == "my_result"
164
147
        end.returns @result
165
 
        @handler.do_find(@irequest, @request, @response)
 
148
        @handler.do_find("my_handler", "my_result", {}, @request, @response)
166
149
      end
167
150
 
168
151
      it "should use a common method for determining the request parameters" do
169
 
        @irequest.stubs(:to_hash).returns(:foo => :baz, :bar => :xyzzy)
170
 
        @model_class.expects(:find).with do |key, args|
 
152
        @indirection.expects(:find).with do |key, args|
171
153
          args[:foo] == :baz and args[:bar] == :xyzzy
172
154
        end.returns @result
173
 
        @handler.do_find(@irequest, @request, @response)
 
155
        @handler.do_find("my_handler", "my_result", {:foo => :baz, :bar => :xyzzy}, @request, @response)
174
156
      end
175
157
 
176
158
      it "should set the content type to the first format specified in the accept header" do
177
159
        @handler.expects(:accept_header).with(@request).returns "one,two"
178
160
        @handler.expects(:set_content_type).with(@response, @oneformat)
179
 
        @handler.do_find(@irequest, @request, @response)
 
161
        @handler.do_find("my_handler", "my_result", {}, @request, @response)
180
162
      end
181
163
 
182
164
      it "should fail if no accept header is provided" do
183
165
        @handler.expects(:accept_header).with(@request).returns nil
184
 
        lambda { @handler.do_find(@irequest, @request, @response) }.should raise_error(ArgumentError)
 
166
        lambda { @handler.do_find("my_handler", "my_result", {}, @request, @response) }.should raise_error(ArgumentError)
185
167
      end
186
168
 
187
169
      it "should fail if the accept header does not contain a valid format" do
188
170
        @handler.expects(:accept_header).with(@request).returns ""
189
 
        lambda { @handler.do_find(@irequest, @request, @response) }.should raise_error(RuntimeError)
 
171
        lambda { @handler.do_find("my_handler", "my_result", {}, @request, @response) }.should raise_error(RuntimeError)
190
172
      end
191
173
 
192
174
      it "should not use an unsuitable format" do
198
180
 
199
181
        @handler.expects(:set_content_type).with(@response, bar) # the suitable one
200
182
 
201
 
        @handler.do_find(@irequest, @request, @response)
 
183
        @handler.do_find("my_handler", "my_result", {}, @request, @response)
202
184
      end
203
185
 
204
186
      it "should render the result using the first format specified in the accept header" do
206
188
        @handler.expects(:accept_header).with(@request).returns "one,two"
207
189
        @result.expects(:render).with(@oneformat)
208
190
 
209
 
        @handler.do_find(@irequest, @request, @response)
 
191
        @handler.do_find("my_handler", "my_result", {}, @request, @response)
210
192
      end
211
193
 
212
194
      it "should pass the result through without rendering it if the result is a string" do
213
 
        @model_class.stubs(:find).returns "foo"
 
195
        @indirection.stubs(:find).returns "foo"
214
196
        @handler.expects(:set_response).with(@response, "foo")
215
 
        @handler.do_find(@irequest, @request, @response)
 
197
        @handler.do_find("my_handler", "my_result", {}, @request, @response)
216
198
      end
217
199
 
218
200
      it "should use the default status when a model find call succeeds" do
219
201
        @handler.expects(:set_response).with { |response, body, status| status.nil? }
220
 
        @handler.do_find(@irequest, @request, @response)
 
202
        @handler.do_find("my_handler", "my_result", {}, @request, @response)
221
203
      end
222
204
 
223
205
      it "should return a serialized object when a model find call succeeds" do
225
207
        @model_instance.expects(:render).returns "my_rendered_object"
226
208
 
227
209
        @handler.expects(:set_response).with { |response, body, status| body == "my_rendered_object" }
228
 
        @model_class.stubs(:find).returns(@model_instance)
229
 
        @handler.do_find(@irequest, @request, @response)
 
210
        @indirection.stubs(:find).returns(@model_instance)
 
211
        @handler.do_find("my_handler", "my_result", {}, @request, @response)
230
212
      end
231
213
 
232
214
      it "should return a 404 when no model instance can be found" do
233
215
        @model_class.stubs(:name).returns "my name"
234
216
        @handler.expects(:set_response).with { |response, body, status| status == 404 }
235
 
        @model_class.stubs(:find).returns(nil)
236
 
        @handler.do_find(@irequest, @request, @response)
 
217
        @indirection.stubs(:find).returns(nil)
 
218
        @handler.do_find("my_handler", "my_result", {}, @request, @response)
237
219
      end
238
220
 
239
221
      it "should write a log message when no model instance can be found" do
240
222
        @model_class.stubs(:name).returns "my name"
241
 
        @model_class.stubs(:find).returns(nil)
 
223
        @indirection.stubs(:find).returns(nil)
242
224
 
243
225
        Puppet.expects(:info).with("Could not find my_handler for 'my_result'")
244
226
 
245
 
        @handler.do_find(@irequest, @request, @response)
 
227
        @handler.do_find("my_handler", "my_result", {}, @request, @response)
246
228
      end
247
229
 
248
230
 
251
233
 
252
234
        @handler.expects(:format_to_use).returns(@oneformat)
253
235
        @model_instance.expects(:render).with(@oneformat).returns "my_rendered_object"
254
 
        @model_class.stubs(:find).returns(@model_instance)
255
 
        @handler.do_find(@irequest, @request, @response)
 
236
        @indirection.stubs(:find).returns(@model_instance)
 
237
        @handler.do_find("my_handler", "my_result", {}, @request, @response)
256
238
      end
257
239
    end
258
240
 
259
241
    describe "when performing head operation" do
260
242
      before do
261
 
        @irequest = stub 'indirection_request', :method => :head, :indirection_name => "my_handler", :to_hash => {}, :key => "my_result", :model => @model_class
 
243
        @handler.stubs(:model).with("my_handler").returns(stub 'model', :indirection => @model_class)
 
244
        @handler.stubs(:http_method).with(@request).returns("HEAD")
 
245
        @handler.stubs(:path).with(@request).returns("/production/my_handler/my_result")
 
246
        @handler.stubs(:params).with(@request).returns({})
262
247
 
263
248
        @model_class.stubs(:head).returns true
264
249
      end
265
250
 
266
 
      it "should use the indirection request to find the model class" do
267
 
        @irequest.expects(:model).returns @model_class
268
 
 
269
 
        @handler.do_head(@irequest, @request, @response)
270
 
      end
271
 
 
272
251
      it "should use the escaped request key" do
273
252
        @model_class.expects(:head).with do |key, args|
274
253
          key == "my_result"
275
254
        end.returns true
276
 
        @handler.do_head(@irequest, @request, @response)
 
255
        @handler.process(@request, @response)
277
256
      end
278
257
 
279
258
      it "should not generate a response when a model head call succeeds" do
280
259
        @handler.expects(:set_response).never
281
 
        @handler.do_head(@irequest, @request, @response)
 
260
        @handler.process(@request, @response)
282
261
      end
283
262
 
284
263
      it "should return a 404 when the model head call returns false" do
285
 
        @model_class.stubs(:name).returns "my name"
286
264
        @handler.expects(:set_response).with { |response, body, status| status == 404 }
287
265
        @model_class.stubs(:head).returns(false)
288
 
        @handler.do_head(@irequest, @request, @response)
 
266
        @handler.process(@request, @response)
289
267
      end
290
268
    end
291
269
 
292
270
    describe "when searching for model instances" do
293
271
      before do
294
 
        @irequest = stub 'indirection_request', :method => :find, :indirection_name => "my_handler", :to_hash => {}, :key => "key", :model => @model_class
 
272
        Puppet::Indirector::Indirection.expects(:instance).with(:my_handler).returns( stub "indirection", :model => @model_class )
295
273
 
296
274
        @result1 = mock 'result1'
297
275
        @result2 = mock 'results'
298
276
 
299
277
        @result = [@result1, @result2]
300
278
        @model_class.stubs(:render_multiple).returns "my rendered instances"
301
 
        @model_class.stubs(:search).returns(@result)
 
279
        @indirection.stubs(:search).returns(@result)
302
280
 
303
281
        @format = stub 'format', :suitable? => true, :mime => "text/format", :name => "format"
304
282
        Puppet::Network::FormatHandler.stubs(:format).returns @format
308
286
      end
309
287
 
310
288
      it "should use the indirection request to find the model" do
311
 
        @irequest.expects(:model).returns @model_class
312
 
 
313
 
        @handler.do_search(@irequest, @request, @response)
 
289
        @handler.do_search("my_handler", "my_result", {}, @request, @response)
314
290
      end
315
291
 
316
292
      it "should use a common method for determining the request parameters" do
317
 
        @irequest.stubs(:to_hash).returns(:foo => :baz, :bar => :xyzzy)
318
 
        @model_class.expects(:search).with do |key, args|
 
293
        @indirection.expects(:search).with do |key, args|
319
294
          args[:foo] == :baz and args[:bar] == :xyzzy
320
295
        end.returns @result
321
 
        @handler.do_search(@irequest, @request, @response)
 
296
        @handler.do_search("my_handler", "my_result", {:foo => :baz, :bar => :xyzzy}, @request, @response)
322
297
      end
323
298
 
324
299
      it "should use the default status when a model search call succeeds" do
325
 
        @model_class.stubs(:search).returns(@result)
326
 
        @handler.do_search(@irequest, @request, @response)
 
300
        @indirection.stubs(:search).returns(@result)
 
301
        @handler.do_search("my_handler", "my_result", {}, @request, @response)
327
302
      end
328
303
 
329
304
      it "should set the content type to the first format returned by the accept header" do
330
305
        @handler.expects(:accept_header).with(@request).returns "one,two"
331
306
        @handler.expects(:set_content_type).with(@response, @oneformat)
332
307
 
333
 
        @handler.do_search(@irequest, @request, @response)
 
308
        @handler.do_search("my_handler", "my_result", {}, @request, @response)
334
309
      end
335
310
 
336
311
      it "should return a list of serialized objects when a model search call succeeds" do
337
312
        @handler.expects(:accept_header).with(@request).returns "one,two"
338
313
 
339
 
        @model_class.stubs(:search).returns(@result)
 
314
        @indirection.stubs(:search).returns(@result)
340
315
 
341
316
        @model_class.expects(:render_multiple).with(@oneformat, @result).returns "my rendered instances"
342
317
 
343
318
        @handler.expects(:set_response).with { |response, data| data == "my rendered instances" }
344
 
        @handler.do_search(@irequest, @request, @response)
 
319
        @handler.do_search("my_handler", "my_result", {}, @request, @response)
345
320
      end
346
321
 
347
322
      it "should return [] when searching returns an empty array" do
348
323
        @handler.expects(:accept_header).with(@request).returns "one,two"
349
 
        @model_class.stubs(:search).returns([])
 
324
        @indirection.stubs(:search).returns([])
350
325
        @model_class.expects(:render_multiple).with(@oneformat, []).returns "[]"
351
326
 
352
327
 
353
328
        @handler.expects(:set_response).with { |response, data| data == "[]" }
354
 
        @handler.do_search(@irequest, @request, @response)
 
329
        @handler.do_search("my_handler", "my_result", {}, @request, @response)
355
330
      end
356
331
 
357
332
      it "should return a 404 when searching returns nil" do
358
333
        @model_class.stubs(:name).returns "my name"
359
334
        @handler.expects(:set_response).with { |response, body, status| status == 404 }
360
 
        @model_class.stubs(:search).returns(nil)
361
 
        @handler.do_search(@irequest, @request, @response)
 
335
        @indirection.stubs(:search).returns(nil)
 
336
        @handler.do_search("my_handler", "my_result", {}, @request, @response)
362
337
      end
363
338
    end
364
339
 
365
340
    describe "when destroying a model instance" do
366
341
      before do
367
 
        @irequest = stub 'indirection_request', :method => :destroy, :indirection_name => "my_handler", :to_hash => {}, :key => "key", :model => @model_class
 
342
        Puppet::Indirector::Indirection.expects(:instance).with(:my_handler).returns( stub "indirection", :model => @model_class )
368
343
 
369
344
        @result = stub 'result', :render => "the result"
370
 
        @model_class.stubs(:destroy).returns @result
 
345
        @indirection.stubs(:destroy).returns @result
371
346
      end
372
347
 
373
348
      it "should use the indirection request to find the model" do
374
 
        @irequest.expects(:model).returns @model_class
375
 
 
376
 
        @handler.do_destroy(@irequest, @request, @response)
 
349
        @handler.do_destroy("my_handler", "my_result", {}, @request, @response)
377
350
      end
378
351
 
379
352
      it "should use the escaped request key to destroy the instance in the model" do
380
 
        @irequest.expects(:key).returns "foo bar"
381
 
        @model_class.expects(:destroy).with do |key, args|
 
353
        @indirection.expects(:destroy).with do |key, args|
382
354
          key == "foo bar"
383
355
        end
384
 
        @handler.do_destroy(@irequest, @request, @response)
 
356
        @handler.do_destroy("my_handler", "foo bar", {}, @request, @response)
385
357
      end
386
358
 
387
359
      it "should use a common method for determining the request parameters" do
388
 
        @irequest.stubs(:to_hash).returns(:foo => :baz, :bar => :xyzzy)
389
 
        @model_class.expects(:destroy).with do |key, args|
 
360
        @indirection.expects(:destroy).with do |key, args|
390
361
          args[:foo] == :baz and args[:bar] == :xyzzy
391
362
        end
392
 
        @handler.do_destroy(@irequest, @request, @response)
 
363
        @handler.do_destroy("my_handler", "my_result", {:foo => :baz, :bar => :xyzzy}, @request, @response)
393
364
      end
394
365
 
395
366
      it "should use the default status code a model destroy call succeeds" do
396
367
        @handler.expects(:set_response).with { |response, body, status| status.nil? }
397
 
        @handler.do_destroy(@irequest, @request, @response)
 
368
        @handler.do_destroy("my_handler", "my_result", {}, @request, @response)
398
369
      end
399
370
 
400
371
      it "should return a yaml-encoded result when a model destroy call succeeds" do
401
372
        @result = stub 'result', :to_yaml => "the result"
402
 
        @model_class.expects(:destroy).returns(@result)
 
373
        @indirection.expects(:destroy).returns(@result)
403
374
 
404
375
        @handler.expects(:set_response).with { |response, body, status| body == "the result" }
405
376
 
406
 
        @handler.do_destroy(@irequest, @request, @response)
 
377
        @handler.do_destroy("my_handler", "my_result", {}, @request, @response)
407
378
      end
408
379
    end
409
380
 
410
381
    describe "when saving a model instance" do
411
382
      before do
412
 
        @irequest = stub 'indirection_request', :method => :save, :indirection_name => "my_handler", :to_hash => {}, :key => "key", :model => @model_class
 
383
        Puppet::Indirector::Indirection.stubs(:instance).with(:my_handler).returns( stub "indirection", :model => @model_class )
413
384
        @handler.stubs(:body).returns('my stuff')
414
385
        @handler.stubs(:content_type_header).returns("text/yaml")
415
386
 
416
387
        @result = stub 'result', :render => "the result"
417
388
 
418
 
        @model_instance = stub('indirected model instance', :save => true)
 
389
        @model_instance = stub('indirected model instance')
419
390
        @model_class.stubs(:convert_from).returns(@model_instance)
 
391
        @indirection.stubs(:save)
420
392
 
421
393
        @format = stub 'format', :suitable? => true, :name => "format", :mime => "text/format"
422
394
        Puppet::Network::FormatHandler.stubs(:format).returns @format
425
397
      end
426
398
 
427
399
      it "should use the indirection request to find the model" do
428
 
        @irequest.expects(:model).returns @model_class
429
 
 
430
 
        @handler.do_save(@irequest, @request, @response)
 
400
        @handler.do_save("my_handler", "my_result", {}, @request, @response)
431
401
      end
432
402
 
433
403
      it "should use the 'body' hook to retrieve the body of the request" do
434
404
        @handler.expects(:body).returns "my body"
435
405
        @model_class.expects(:convert_from).with { |format, body| body == "my body" }.returns @model_instance
436
406
 
437
 
        @handler.do_save(@irequest, @request, @response)
 
407
        @handler.do_save("my_handler", "my_result", {}, @request, @response)
438
408
      end
439
409
 
440
410
      it "should fail to save model if data is not specified" do
441
411
        @handler.stubs(:body).returns('')
442
412
 
443
 
        lambda { @handler.do_save(@irequest, @request, @response) }.should raise_error(ArgumentError)
 
413
        lambda { @handler.do_save("my_handler", "my_result", {}, @request, @response) }.should raise_error(ArgumentError)
444
414
      end
445
415
 
446
416
      it "should use a common method for determining the request parameters" do
447
 
        @model_instance.expects(:save).with('key').once
448
 
        @handler.do_save(@irequest, @request, @response)
 
417
        @indirection.expects(:save).with(@model_instance, 'key').once
 
418
        @handler.do_save("my_handler", "key", {}, @request, @response)
449
419
      end
450
420
 
451
421
      it "should use the default status when a model save call succeeds" do
452
422
        @handler.expects(:set_response).with { |response, body, status| status.nil? }
453
 
        @handler.do_save(@irequest, @request, @response)
 
423
        @handler.do_save("my_handler", "my_result", {}, @request, @response)
454
424
      end
455
425
 
456
426
      it "should return the yaml-serialized result when a model save call succeeds" do
457
 
        @model_instance.stubs(:save).returns(@model_instance)
 
427
        @indirection.stubs(:save).returns(@model_instance)
458
428
        @model_instance.expects(:to_yaml).returns('foo')
459
 
        @handler.do_save(@irequest, @request, @response)
 
429
        @handler.do_save("my_handler", "my_result", {}, @request, @response)
460
430
      end
461
431
 
462
432
      it "should set the content to yaml" do
463
433
        @handler.expects(:set_content_type).with(@response, @yamlformat)
464
 
        @handler.do_save(@irequest, @request, @response)
 
434
        @handler.do_save("my_handler", "my_result", {}, @request, @response)
465
435
      end
466
436
 
467
437
      it "should use the content-type header to know the body format" do
470
440
 
471
441
        @model_class.expects(:convert_from).with { |format, body| format == "format" }.returns @model_instance
472
442
 
473
 
        @handler.do_save(@irequest, @request, @response)
 
443
        @handler.do_save("my_handler", "my_result", {}, @request, @response)
474
444
      end
475
445
    end
476
446
  end