← Back to branch summary

~ubuntu-branches/debian/sid/ruby-poltergeist/sid

« back to all changes in this revision

Viewing changes to lib/capybara/poltergeist/browser.rb

  • Committer: Package Import Robot
  • Author(s): Pirate Praveen
  • Date: 2016-09-15 22:01:34 UTC
  • Revision ID: package-import@ubuntu.com-20160915220134-vd142d9tvojjvcyo
Tags: upstream-1.10.0
Import upstream version 1.10.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/capybara/poltergeist/browser.rb
 
1
require "capybara/poltergeist/errors"
 
2
require "capybara/poltergeist/command"
 
3
require 'json'
 
4
require 'time'
 
5
 
 
6
module Capybara::Poltergeist
 
7
  class Browser
 
8
    ERROR_MAPPINGS = {
 
9
      'Poltergeist.JavascriptError' => JavascriptError,
 
10
      'Poltergeist.FrameNotFound'   => FrameNotFound,
 
11
      'Poltergeist.InvalidSelector' => InvalidSelector,
 
12
      'Poltergeist.StatusFailError' => StatusFailError,
 
13
      'Poltergeist.NoSuchWindowError' => NoSuchWindowError,
 
14
      'Poltergeist.UnsupportedFeature' => UnsupportedFeature
 
15
    }
 
16
 
 
17
    attr_reader :server, :client, :logger
 
18
 
 
19
    def initialize(server, client, logger = nil)
 
20
      @server = server
 
21
      @client = client
 
22
      @logger = logger
 
23
    end
 
24
 
 
25
    def restart
 
26
      server.restart
 
27
      client.restart
 
28
 
 
29
      self.debug = @debug if defined?(@debug)
 
30
      self.js_errors = @js_errors if defined?(@js_errors)
 
31
      self.extensions = @extensions if @extensions
 
32
    end
 
33
 
 
34
    def visit(url)
 
35
      command 'visit', url
 
36
    end
 
37
 
 
38
    def current_url
 
39
      command 'current_url'
 
40
    end
 
41
 
 
42
    def status_code
 
43
      command 'status_code'
 
44
    end
 
45
 
 
46
    def body
 
47
      command 'body'
 
48
    end
 
49
 
 
50
    def source
 
51
      command 'source'
 
52
    end
 
53
 
 
54
    def title
 
55
      command 'title'
 
56
    end
 
57
 
 
58
    def parents(page_id, id)
 
59
      command 'parents', page_id, id
 
60
    end
 
61
 
 
62
    def find(method, selector)
 
63
      result = command('find', method, selector)
 
64
      result['ids'].map { |id| [result['page_id'], id] }
 
65
    end
 
66
 
 
67
    def find_within(page_id, id, method, selector)
 
68
      command 'find_within', page_id, id, method, selector
 
69
    end
 
70
 
 
71
    def all_text(page_id, id)
 
72
      command 'all_text', page_id, id
 
73
    end
 
74
 
 
75
    def visible_text(page_id, id)
 
76
      command 'visible_text', page_id, id
 
77
    end
 
78
 
 
79
    def delete_text(page_id, id)
 
80
      command 'delete_text', page_id, id
 
81
    end
 
82
 
 
83
    def property(page_id, id, name)
 
84
      command 'property', page_id, id, name.to_s
 
85
    end
 
86
 
 
87
    def attributes(page_id, id)
 
88
      command 'attributes', page_id, id
 
89
    end
 
90
 
 
91
    def attribute(page_id, id, name)
 
92
      command 'attribute', page_id, id, name.to_s
 
93
    end
 
94
 
 
95
    def value(page_id, id)
 
96
      command 'value', page_id, id
 
97
    end
 
98
 
 
99
    def set(page_id, id, value)
 
100
      command 'set', page_id, id, value
 
101
    end
 
102
 
 
103
    def select_file(page_id, id, value)
 
104
      command 'select_file', page_id, id, value
 
105
    end
 
106
 
 
107
    def tag_name(page_id, id)
 
108
      command('tag_name', page_id, id).downcase
 
109
    end
 
110
 
 
111
    def visible?(page_id, id)
 
112
      command 'visible', page_id, id
 
113
    end
 
114
 
 
115
    def disabled?(page_id, id)
 
116
      command 'disabled', page_id, id
 
117
    end
 
118
 
 
119
    def click_coordinates(x, y)
 
120
      command 'click_coordinates', x, y
 
121
    end
 
122
 
 
123
    def evaluate(script)
 
124
      command 'evaluate', script
 
125
    end
 
126
 
 
127
    def execute(script)
 
128
      command 'execute', script
 
129
    end
 
130
 
 
131
    def within_frame(handle, &block)
 
132
      if handle.is_a?(Capybara::Node::Base)
 
133
        command 'push_frame', [handle.native.page_id, handle.native.id]
 
134
      else
 
135
        command 'push_frame', handle
 
136
      end
 
137
 
 
138
      yield
 
139
    ensure
 
140
      command 'pop_frame'
 
141
    end
 
142
 
 
143
    def window_handle
 
144
      command 'window_handle'
 
145
    end
 
146
 
 
147
    def window_handles
 
148
      command 'window_handles'
 
149
    end
 
150
 
 
151
    def switch_to_window(handle)
 
152
      command 'switch_to_window', handle
 
153
    end
 
154
 
 
155
    def open_new_window
 
156
      command 'open_new_window'
 
157
    end
 
158
 
 
159
    def close_window(handle)
 
160
      command 'close_window', handle
 
161
    end
 
162
 
 
163
    def find_window_handle(locator)
 
164
      return locator if window_handles.include? locator
 
165
 
 
166
      handle = command 'window_handle', locator
 
167
      raise NoSuchWindowError unless handle
 
168
      return handle
 
169
    end
 
170
 
 
171
    def within_window(locator, &block)
 
172
      original = window_handle
 
173
      handle = find_window_handle(locator)
 
174
      switch_to_window(handle)
 
175
      yield
 
176
    ensure
 
177
      switch_to_window(original)
 
178
    end
 
179
 
 
180
    def click(page_id, id)
 
181
      command 'click', page_id, id
 
182
    end
 
183
 
 
184
    def right_click(page_id, id)
 
185
      command 'right_click', page_id, id
 
186
    end
 
187
 
 
188
    def double_click(page_id, id)
 
189
      command 'double_click', page_id, id
 
190
    end
 
191
 
 
192
    def hover(page_id, id)
 
193
      command 'hover', page_id, id
 
194
    end
 
195
 
 
196
    def drag(page_id, id, other_id)
 
197
      command 'drag', page_id, id, other_id
 
198
    end
 
199
 
 
200
    def drag_by(page_id, id, x, y)
 
201
      command 'drag_by', page_id, id, x, y
 
202
    end
 
203
 
 
204
    def select(page_id, id, value)
 
205
      command 'select', page_id, id, value
 
206
    end
 
207
 
 
208
    def trigger(page_id, id, event)
 
209
      command 'trigger', page_id, id, event.to_s
 
210
    end
 
211
 
 
212
    def reset
 
213
      command 'reset'
 
214
    end
 
215
 
 
216
    def scroll_to(left, top)
 
217
      command 'scroll_to', left, top
 
218
    end
 
219
 
 
220
    def render(path, options = {})
 
221
      check_render_options!(options)
 
222
      options[:full] = !!options[:full]
 
223
      command 'render', path.to_s, options
 
224
    end
 
225
 
 
226
    def render_base64(format, options = {})
 
227
      check_render_options!(options)
 
228
      options[:full] = !!options[:full]
 
229
      command 'render_base64', format.to_s, options
 
230
    end
 
231
 
 
232
    def set_zoom_factor(zoom_factor)
 
233
      command 'set_zoom_factor', zoom_factor
 
234
    end
 
235
 
 
236
    def set_paper_size(size)
 
237
      command 'set_paper_size', size
 
238
    end
 
239
 
 
240
    def resize(width, height)
 
241
      command 'resize', width, height
 
242
    end
 
243
 
 
244
    def send_keys(page_id, id, keys)
 
245
      command 'send_keys', page_id, id, normalize_keys(keys)
 
246
    end
 
247
 
 
248
    def path(page_id, id)
 
249
      command 'path', page_id, id
 
250
    end
 
251
 
 
252
    def network_traffic
 
253
      command('network_traffic').values.map do |event|
 
254
        NetworkTraffic::Request.new(
 
255
          event['request'],
 
256
          event['responseParts'].map { |response| NetworkTraffic::Response.new(response) },
 
257
          event['error'] ? NetworkTraffic::Error.new(event['error']) : nil
 
258
        )
 
259
      end
 
260
    end
 
261
 
 
262
    def clear_network_traffic
 
263
      command('clear_network_traffic')
 
264
    end
 
265
 
 
266
    def set_proxy(ip, port, type, user, password)
 
267
      args = [ip, port, type]
 
268
      args << user if user
 
269
      args << password if password
 
270
      command('set_proxy', *args)
 
271
    end
 
272
 
 
273
    def equals(page_id, id, other_id)
 
274
      command('equals', page_id, id, other_id)
 
275
    end
 
276
 
 
277
    def get_headers
 
278
      command 'get_headers'
 
279
    end
 
280
 
 
281
    def set_headers(headers)
 
282
      command 'set_headers', headers
 
283
    end
 
284
 
 
285
    def add_headers(headers)
 
286
      command 'add_headers', headers
 
287
    end
 
288
 
 
289
    def add_header(header, permanent)
 
290
      command 'add_header', header, permanent
 
291
    end
 
292
 
 
293
    def response_headers
 
294
      command 'response_headers'
 
295
    end
 
296
 
 
297
    def cookies
 
298
      Hash[command('cookies').map { |cookie| [cookie['name'], Cookie.new(cookie)] }]
 
299
    end
 
300
 
 
301
    def set_cookie(cookie)
 
302
      if cookie[:expires]
 
303
        cookie[:expires] = cookie[:expires].to_i * 1000
 
304
      end
 
305
 
 
306
      command 'set_cookie', cookie
 
307
    end
 
308
 
 
309
    def remove_cookie(name)
 
310
      command 'remove_cookie', name
 
311
    end
 
312
 
 
313
    def clear_cookies
 
314
      command 'clear_cookies'
 
315
    end
 
316
 
 
317
    def cookies_enabled=(flag)
 
318
      command 'cookies_enabled', !!flag
 
319
    end
 
320
 
 
321
    def set_http_auth(user, password)
 
322
      command 'set_http_auth', user, password
 
323
    end
 
324
 
 
325
    def js_errors=(val)
 
326
      @js_errors = val
 
327
      command 'set_js_errors', !!val
 
328
    end
 
329
 
 
330
    def extensions=(names)
 
331
      @extensions = names
 
332
      Array(names).each do |name|
 
333
        command 'add_extension', name
 
334
      end
 
335
    end
 
336
 
 
337
    def url_whitelist=(whitelist)
 
338
      command 'set_url_whitelist', *whitelist
 
339
    end
 
340
 
 
341
    def url_blacklist=(blacklist)
 
342
      command 'set_url_blacklist', *blacklist
 
343
    end
 
344
 
 
345
    def debug=(val)
 
346
      @debug = val
 
347
      command 'set_debug', !!val
 
348
    end
 
349
 
 
350
    def clear_memory_cache
 
351
      command 'clear_memory_cache'
 
352
    end
 
353
 
 
354
    def command(name, *args)
 
355
      cmd = Command.new(name, *args)
 
356
      log cmd.message
 
357
 
 
358
      response = server.send(cmd)
 
359
      log response
 
360
 
 
361
      json = JSON.load(response)
 
362
 
 
363
      if json['error']
 
364
        klass = ERROR_MAPPINGS[json['error']['name']] || BrowserError
 
365
        raise klass.new(json['error'])
 
366
      else
 
367
        json['response']
 
368
      end
 
369
    rescue DeadClient
 
370
      restart
 
371
      raise
 
372
    end
 
373
 
 
374
    def go_back
 
375
      command 'go_back'
 
376
    end
 
377
 
 
378
    def go_forward
 
379
      command 'go_forward'
 
380
    end
 
381
 
 
382
    def accept_confirm
 
383
      command 'set_confirm_process', true
 
384
    end
 
385
 
 
386
    def dismiss_confirm
 
387
      command 'set_confirm_process', false
 
388
    end
 
389
 
 
390
    #
 
391
    # press "OK" with text (response) or default value
 
392
    #
 
393
    def accept_prompt(response)
 
394
      command 'set_prompt_response', response || false
 
395
    end
 
396
 
 
397
    #
 
398
    # press "Cancel"
 
399
    #
 
400
    def dismiss_prompt
 
401
      command 'set_prompt_response', nil
 
402
    end
 
403
 
 
404
    def modal_message
 
405
      command 'modal_message'
 
406
    end
 
407
 
 
408
    private
 
409
 
 
410
    def log(message)
 
411
      logger.puts message if logger
 
412
    end
 
413
 
 
414
    def check_render_options!(options)
 
415
      if !!options[:full] && options.has_key?(:selector)
 
416
        warn "Ignoring :selector in #render since :full => true was given at #{caller.first}"
 
417
        options.delete(:selector)
 
418
      end
 
419
    end
 
420
 
 
421
    def normalize_keys(keys)
 
422
      keys.map do |key|
 
423
        case key
 
424
        when Array
 
425
          # [:Shift, "s"] => { modifier: "shift", key: "S" }
 
426
          # [:Ctrl, :Left] => { modifier: "ctrl", key: :Left }
 
427
          # [:Ctrl, :Shift, :Left] => { modifier: "ctrl,shift", key: :Left }
 
428
          letter = key.last
 
429
          symbol = key[0...-1].map { |k| k.to_s.downcase }.join(',')
 
430
 
 
431
          { modifier: symbol.to_s.downcase, key: letter.capitalize }
 
432
        when Symbol
 
433
          { key: key.capitalize } # Return a known sequence for PhantomJS
 
434
        when String
 
435
          key # Plain string, nothing to do
 
436
        end
 
437
      end
 
438
    end
 
439
  end
 
440
end