Module: Awetestlib::Regression::DragAndDrop

Defined in:
lib/awetestlib/regression/drag_and_drop.rb,
lib/awetestlib/regression/awetest_dsl.rb

Overview

Note:

Still experimental. Works with IE but not fully tested with Firefox or Chrome in Windows using Watir-webdriver. Not compatible with Mac Rdoc is work in progress

Methods for moving and resizing elements, manipulating the mouse, and checking for relative positioning of elements, including overlap, overlay, etc.

Instance Method Summary collapse

Instance Method Details

#adjust_dimensions_by_percent(w, h, p, returnnew = nil) ⇒ Object 



283
284
285
286
287
288
289
290
291
292
293
294
 
# File 'lib/awetestlib/regression/drag_and_drop.rb', line 283

def adjust_dimensions_by_percent(w, h, p, returnnew=nil)
  p      += 100
  nw     = (w * (p/100.0)).to_i
  nh     = (h * (p/100.0)).to_i
  deltaw = nw - w
  deltah = nh - h
  if returnnew
    [deltaw, deltah, nw, nh]
  else
    [deltaw, deltah]
  end
end

#drag_and_drop(x1, y1, dx, dy, speed = nil) ⇒ Object 



324
325
326
327
328
329
330
331
332
333
334
335
336
 
# File 'lib/awetestlib/regression/drag_and_drop.rb', line 324

def drag_and_drop(x1, y1, dx, dy, speed=nil)
  speed = 10 if not speed
  x2 = x1 + dx
  y2 = y1 + dy
  debug_to_log("drag_and_drop: start: [#{x1}, #{y1}] end: [#{x2}, #{y2}]")

  @ai.MouseMove(x1, y1, speed)
  @ai.MouseClick("primary", x1, y1)
  sleep_for(0.5)
  @ai.MouseClick("primary", x1, y1)
  sleep_for(0.5)
  @ai.MouseClickDrag("primary", x1, y1, x2, y2, speed)
end

#drag_and_drop_div(browser, how, what, delta_x, delta_y, desc = '') ⇒ Object 



311
312
313
314
315
316
317
318
319
320
321
322
 
# File 'lib/awetestlib/regression/drag_and_drop.rb', line 311

def drag_and_drop_div(browser, how, what, delta_x, delta_y, desc = '')
  #TODO: webdriver
  #TODO: assumes element is div
  msg = "Drag and drop element :#{how}=>#{what} by x=>#{delta_x} y=>#{delta_y}."
  msg << " #{desc}" if desc.length > 0
  drag_me = browser.div(how, what)
  drag_me.drag_and_drop_by(delta_x, delta_y)
  passed_to_log(msg)
  true
rescue
  failed_to_log(unable_to)
end

#drag_and_drop_element(browser, element, dx, dy, speed = nil) ⇒ Object 



338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
 
# File 'lib/awetestlib/regression/drag_and_drop.rb', line 338

def drag_and_drop_element(browser, element, dx, dy, speed = nil)
  speed = 10 if not speed
  w1, h1, x1, y1, xc1, yc1, xlr1, ylr1 = get_element_coordinates(browser, element, true)
  msg                                  = "Move #{element} by [#{dx}, #{dy}] from center[#{xc1}, #{yc1}] "
  newxc                                = xc1 + dx
  newyc                                = yc1 + dy
  msg << "to center[[#{newxc}, #{newyc}]"
  sleep_for(0.5)

  drag_and_drop(xc1, yc1, dx, dy)

  sleep_for(1)
  w2, h2, x2, y2, xc2, yc2, xlr2, ylr2 = get_element_coordinates(browser, element, true)

  # TODO This adjustment is adhoc and empirical. Needs to be derived more rigorously
  xcerr                                = xc2 - xc1
  ycerr                                = yc2 - yc1

  debug_to_log("\n" +
                   "\t\t   xc1: #{xc1}\n" +
                   "\t\t   yc1: #{yc1}\n" +
                   "\t\t   xc2: #{xc2}\n" +
                   "\t\t   yc2: #{yc2}\n" +
                   "\t\t xcerr: #{xlrerr}\n" +
                   "\t\t ycerr: #{ylrerr}\n" +
                   "\t\t x tol: #{@x_tolerance}\n" +
                   "\t\t y tol: #{@y_tolerance}\n"
  )

  #TODO Add check that window _was_ resized.
  x_ok, x_msg = validate_drag_drop(xcerr, @x_tolerance, newxc, xc2)
  y_ok, y_msg = validate_drag_drop(ycerr, @y_tolerance, newyc, yc2)
  msg         = msg + "x: #{x_msg}, y: #{y_msg}"

  if x_ok and y_ok
    passed_to_log(msg)
  else
    failed_to_log(msg)
  end
  sleep_for(1)
rescue
  failed_to_log("Unable to validate drag and drop. #{$!} (#{__LINE__})")
  sleep_for(1)
end

#get_browser_coord(browser = nil, dbg = nil) ⇒ Object

TODO: needs work: should succeed if browser is other container or element



3697
3698
3699
3700
3701
3702
3703
3704
3705
3706
3707
 
# File 'lib/awetestlib/regression/awetest_dsl.rb', line 3697

def get_browser_coord(browser, dbg=nil)
  title = browser.title
  x, y  = browser.position
  w, h  = browser.size
  if dbg
    debug_to_log("\n\t\tBrowser #{browser.inspect}\n"+
                     "\t\tdimensions:   x: #{w} y: #{h}"+
                     "\t\tscreen offset x: #{x} y: #{y}")
  end
  [x, y, w, h]
end

#get_element_coordinates(browser, element, dbg = nil) ⇒ Object

:category: GUI



246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
 
# File 'lib/awetestlib/regression/drag_and_drop.rb', line 246

def get_element_coordinates(browser, element, dbg=nil)
  bx, by, bw, bh = get_browser_coord(browser, dbg)
  if @browserAbbrev == 'IE'
    x_hack = @horizontal_hack_ie
    y_hack = @vertical_hack_ie
  elsif @browserAbbrev == 'FF'
    x_hack = @horizontal_hack_ff
    y_hack = @vertical_hack_ff
  end
  sleep_for(1)
  w, h   = element.dimensions.to_a
  xc, yc = element.client_offset.to_a
  #    xcc, ycc = element.client_center.to_a
  xcc    = xc + w/2
  ycc    = yc + h/2
  # screen offset:
  xs     = bx + x_hack + xc - 1
  ys     = by + y_hack + yc - 1
  # screen center:
  xsc    = xs + w/2
  ysc    = ys + h/2
  xslr   = xs + w
  yslr   = ys + h
  if dbg
    debug_to_log(
        "\n\t\tElement: #{element.inspect}"+
            "\n\t\tbrowser screen offset: x: #{bx} y: #{by}"+
            "\n\t\t           dimensions: x: #{w} y: #{h}"+
            "\n\t\t         client offset x: #{xc} y: #{yc}"+
            "\n\t\t         screen offset x: #{xs} y: #{ys}"+
            "\n\t\t         client center x: #{xcc} y: #{ycc}"+
            "\n\t\t         screen center x: #{xsc} y: #{ysc}"+
            "\n\t\t    screen lower right x: #{xslr} y: #{yslr}")
  end
  [w, h, xs, ys, xsc, ysc, xslr, yslr]
end

#get_element_dimensions(container, element, desc = '', refs = '') ⇒ Object 



4043
4044
4045
4046
4047
4048
4049
4050
4051
4052
4053
4054
4055
4056
4057
4058
4059
4060
4061
4062
4063
4064
4065
4066
 
# File 'lib/awetestlib/regression/awetest_dsl.rb', line 4043

def get_element_dimensions(container, element, desc = '', refs = '')
  hash                = Hash.new
  #hash[:text]         = element.text
  #hash[:unit]         = element
  hash[:clientLeft]   = element.attribute_value('clientLeft').to_i
  hash[:clientTop]    = element.attribute_value('clientTop').to_i
  hash[:clientWidth]  = element.attribute_value('clientWidth').to_i
  hash[:clientHeight] = element.attribute_value('clientHeight').to_i
  #hash[:offsetParent] = element.attribute_value('offsetParent')
  hash[:offsetLeft]   = element.attribute_value('offsetLeft').to_i
  hash[:offsetTop]    = element.attribute_value('offsetTop').to_i
  hash[:offsetWidth]  = element.attribute_value('offsetWidth').to_i
  hash[:offsetHeight] = element.attribute_value('offsetHeight').to_i
  hash[:scrollLeft]   = element.attribute_value('scrollLeft').to_i
  hash[:scrollTop]    = element.attribute_value('scrollTop').to_i
  hash[:scrollWidth]  = element.attribute_value('scrollWidth').to_i
  hash[:scrollHeight] = element.attribute_value('scrollHeight').to_i
  if desc.length > 0
    debug_to_log("#{desc} #{refs}\n#{hash.to_yaml}")
  end
  hash
rescue
  failed_to_log(unable_to)
end

#get_element_dimensions1(container, element, desc = '', refs = '') ⇒ Object 



4068
4069
4070
4071
4072
4073
4074
4075
4076
4077
4078
4079
4080
4081
4082
4083
4084
4085
4086
4087
4088
4089
4090
4091
 
# File 'lib/awetestlib/regression/awetest_dsl.rb', line 4068

def get_element_dimensions1(container, element, desc = '', refs = '')
  hash                = Hash.new
  #hash[:text]         = element.text
  #hash[:unit]         = element
  hash[:clientLeft]   = container.execute_script("return arguments[0].clientLeft", element)
  hash[:clientTop]    = container.execute_script("return arguments[0].clientTop", element)
  hash[:clientWidth]  = container.execute_script("return arguments[0].clientWidth", element)
  hash[:clientHeight] = container.execute_script("return arguments[0].clientHeight", element)
  #hash[:offsetParent] = container.execute_script("return arguments[0].offsetParent", element)
  hash[:offsetLeft]   = container.execute_script("return arguments[0].offsetLeft", element)
  hash[:offsetTop]    = container.execute_script("return arguments[0].offsetTop", element)
  hash[:offsetWidth]  = container.execute_script("return arguments[0].offsetWidth", element)
  hash[:offsetHeight] = container.execute_script("return arguments[0].offsetHeight", element)
  hash[:scrollLeft]   = container.execute_script("return arguments[0].scrollLeft", element)
  hash[:scrollTop]    = container.execute_script("return arguments[0].scrollTop", element)
  hash[:scrollWidth]  = container.execute_script("return arguments[0].scrollWidth", element)
  hash[:scrollHeight] = container.execute_script("return arguments[0].scrollHeight", element)
  if desc.length > 0
    debug_to_log("#{desc} #{refs}\n#{hash.to_yaml}")
  end
  hash
rescue
  failed_to_log(unable_to)
end

#get_element_screen_coordinates(browser, element, dbg = nil) ⇒ Object 



3709
3710
3711
3712
3713
3714
3715
3716
3717
3718
3719
3720
3721
3722
3723
3724
3725
3726
3727
3728
3729
3730
3731
3732
3733
3734
3735
3736
3737
3738
3739
3740
3741
3742
3743
3744
3745
3746
3747
3748
 
# File 'lib/awetestlib/regression/awetest_dsl.rb', line 3709

def get_element_screen_coordinates(browser, element, dbg = nil)
  hash                            = Hash.new
  bx, by                          = browser.position
  ox, oy                          = window_viewport_offsets(browser)
  rect                            = element.bounding_client_rectangle
  w                               = rect['width']
  h                               = rect['height']
  hash['width']                   = w
  hash['height']                  = h
  xc                              = rect['left']
  yc                              = rect['top']
  xcc                             = xc + w/2
  ycc                             = yc + h/2
  # screen offset:
  xs                              = bx + ox + xc - 1
  ys                              = by + oy + yc - 1
  hash['left']                    = xs
  hash['top']                     = ys
  # screen center:
  xsc                             = xs + w/2
  ysc                             = ys + h/2
  hash['screen_center_left']      = xsc
  hash['screen_center_top']       = ysc
  xslr                            = xs + w
  yslr                            = ys + h
  hash['screen_lower_right_left'] = xslr
  hash['screen_lower_right_top']  = xs
  if dbg
    debug_to_log(
        "\n\t\tElement: #{element.inspect}"+
            "\n\t\tbrowser screen offset: x: #{bx} y: #{by}"+
            "\n\t\t           dimensions: x: #{w} y: #{h}"+
            "\n\t\t         client offset x: #{xc} y: #{yc}"+
            "\n\t\t         screen offset x: #{xs} y: #{ys}"+
            "\n\t\t         client center x: #{xcc} y: #{ycc}"+
            "\n\t\t         screen center x: #{xsc} y: #{ysc}"+
            "\n\t\t    screen lower right x: #{xslr} y: #{yslr}")
  end
  hash
end

#get_outside_location(element, desc = '', refs = '', offset = 10, vertical = 'top', horizontal = 'right') ⇒ Object 



4093
4094
4095
4096
4097
4098
4099
4100
4101
4102
4103
4104
4105
4106
4107
4108
4109
4110
 
# File 'lib/awetestlib/regression/awetest_dsl.rb', line 4093

def get_outside_location(element, desc = '', refs = '', offset = 10, vertical = 'top', horizontal = 'right')
  dimensions = get_element_dimensions(element.browser, element, with_caller(desc), refs)

  if vertical =~ /top/i
    y = dimensions[:offsetTop].to_i
  else
    y = dimensions[:offsetTop].to_i + dimensions[:offsetHeight].to_i
  end
  if horizontal =~ /right/i
    x = dimensions[:offsetLeft].to_i + dimensions[:offsetWidth].to_i + offset
  else
    x = dimensions[:offsetLeft].to_i - offset
  end

  [x, y]
rescue
  failed_to_log(unable_to)
end

#get_resize_handle_by_class(element, strg, dbg = nil) ⇒ Object

:category: GUI



238
239
240
241
242
243
 
# File 'lib/awetestlib/regression/drag_and_drop.rb', line 238

def get_resize_handle_by_class(element, strg, dbg=nil)
  handle = get_div_by_class(element, strg, dbg)
  sleep_for(0.5)
  handle.flash(5)
  return handle
end

#get_resize_handle_by_id(element, id, dbg = nil) ⇒ Object

:category: GUI



230
231
232
233
234
235
 
# File 'lib/awetestlib/regression/drag_and_drop.rb', line 230

def get_resize_handle_by_id(element, id, dbg=nil)
  handle = get_div_by_id(element, id, dbg)
  sleep_for(1)
  handle.flash(5)
  return handle
end

#get_viewport_to_win_diff(browser) ⇒ Object

Deprecated. 


4007
4008
4009
 
# File 'lib/awetestlib/regression/awetest_dsl.rb', line 4007

def get_viewport_to_win_diff(browser)
  window_viewport_offsets(browser)[0]
end

#hover(browser, element, wait = 2) ⇒ Object 



109
110
111
112
113
 
# File 'lib/awetestlib/regression/drag_and_drop.rb', line 109

def hover(browser, element, wait = 2)
  w1, h1, x1, y1, xc1, yc1, xlr1, ylr1 = get_element_coordinates(browser, element, true)
  @ai.MoveMouse(xc1, yc1)
  sleep_for(1)
end

#insert_viewport_div(browser) ⇒ Object 



3790
3791
3792
3793
3794
3795
3796
3797
3798
3799
3800
3801
3802
 
# File 'lib/awetestlib/regression/awetest_dsl.rb', line 3790

def insert_viewport_div(browser)
  browser.execute_script(
      'var test = document.createElement( "div" );' +
          'test.style.cssText = "position: fixed;top: 0;left: 0;bottom: 0;right: 0;"; ' +
          'test.id = "awetest-temp-viewport"; ' +
          'document.documentElement.insertBefore( test, document.documentElement.firstChild ); '
  )
  viewport = browser.div(:id, 'awetest-temp-viewport')
  x        = browser.execute_script("return arguments[0].offsetWidth", viewport)
  y        = browser.execute_script("return arguments[0].offsetHeight", viewport)
  browser.execute_script("document.documentElement.removeChild( arguments[0] )", viewport)
  [x, y]
end

#left_click(element) ⇒ Object 



389
390
391
392
393
 
# File 'lib/awetestlib/regression/drag_and_drop.rb', line 389

def left_click(element)
  x = element.left_edge_absolute + 2
  y = element.top_edge_absolute + 2
  @ai.MouseClick("primary", x, y)
end

#mouse_to_browser_edge(container, offset_x = -3,, offset_y = -3)) ⇒ Object 



3970
3971
3972
3973
3974
3975
 
# File 'lib/awetestlib/regression/awetest_dsl.rb', line 3970

def mouse_to_browser_edge(container, offset_x = -3, offset_y = -3)
  x, y = window_dimensions(container)[4, 2]
  container.driver.mouse.move_to(container.driver[:tag_name => 'body'], x - offset_x, y - offset_y)
  container.driver.mouse.down
  container.driver.mouse.up
end

#move_element_with_handle(browser, element, handle_id, dx, dy) ⇒ Object 



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
 
# File 'lib/awetestlib/regression/drag_and_drop.rb', line 115

def move_element_with_handle(browser, element, handle_id, dx, dy)
  #    msg = "Move element "
  #    w1, h1, x1, y1, xc1, yc1, xlr1, ylr1 = get_element_coordinates(browser, element, true)
  #    newx   = w1 + dx
  #    newy   = h1 + dy
  #    msg << " by [#{dx}, #{dy}] to expected [[#{newx}, #{newy}] "
  #    handle = get_resize_handle(element, handle_id)
  #    hw, hh, hx, hy, hxc, hyc, hxlr, hylr  = get_element_coordinates(browser, handle, true)

  #    drag_and_drop(hxc, hyc, dx, dy)

  #    w2, h2, x2, y2, xc2, yc2, xlr2, ylr2 = get_element_coordinates(browser, element, true)

  #    xerr = x2 - newx
  #    yerr = y2 - newy
  #    xdsp = (x1 - x2).abs
  #    ydsp = (y1 - y2).abs

  #    if x2 == newx and y2 == newy
  #      msg << "succeeded."
  #      passed_to_log(msg)
  #    else
  #      msg << "failed. "
  #      failed_to_log(msg)
  #      debug_to_log("x: actual #{x2}, error #{xerr}, displace #{xdsp}. y: actual #{y2}, error #{yerr}, displace #{ydsp}.")
  #    end

end

#overlay?(inner, outer, side = :bottom) ⇒ Boolean

Returns:

  • (Boolean) 


4011
4012
4013
4014
4015
4016
4017
4018
4019
4020
4021
4022
4023
4024
4025
4026
4027
4028
4029
4030
4031
4032
4033
4034
4035
4036
4037
4038
4039
4040
4041
 
# File 'lib/awetestlib/regression/awetest_dsl.rb', line 4011

def overlay?(inner, outer, side = :bottom)
  i_dims = inner.bounding_client_rectangle
  o_dims = outer.bounding_client_rectangle
  case side
    when :bottom
      overlay = i_dims['bottom'] > o_dims['top']
    when :top
      overlay = i_dims['top'] > o_dims['top']
    when :left
      overlay = i_dims['left'] > o_dims['right']
    when :right
      overlay = i_dims['right'] > o_dims['right']
    when :inside
      overlay =
          !(i_dims['top'] > o_dims['top'] and
              i_dims['right'] < o_dims['right'] and
              i_dims['left'] > o_dims['left'] and
              i_dims['bottom'] < o_dims['bottom']
          )
    else
      overlay =
          (i_dims['top'] > o_dims['bottom'] or
              i_dims['right'] < o_dims['left'] or
              i_dims['left'] > o_dims['right'] or
              i_dims['bottom'] < o_dims['top']
          )
  end
  overlay
rescue
  failed_to_log("Unable to determine overlay. '#{$!}'")
end

#remove_focus(container, element, desc = '', refs = '', tab_twice = false) ⇒ Object 



3599
3600
3601
3602
3603
3604
3605
3606
3607
3608
3609
3610
3611
3612
3613
3614
3615
3616
3617
3618
3619
3620
3621
3622
3623
3624
3625
3626
3627
3628
3629
3630
3631
3632
3633
3634
3635
3636
3637
3638
3639
3640
3641
3642
3643
3644
3645
3646
 
# File 'lib/awetestlib/regression/awetest_dsl.rb', line 3599

def remove_focus(container, element, desc = '', refs = '', tab_twice = false)
  msg = build_message(desc, refs)
  ok  = true
  if element.focused?
    debug_to_log('element has focus')
    element.fire_event('onblur')
    debug_to_log("Fired 'onblur' event")
    which = :blur
    if element.focused?
      container.send_keys(:tab)
      debug_to_log("Sent tab")
      which = :tab
      if tab_twice
        container.send_keys(:tab)
        debug_to_log("Sent second tab")
        which = :tab
      end
      if element.focused?
        container.send_keys(:enter)
        debug_to_log("Sent enter")
        which = :enter
      end
    end
    if element.focused?
      failed_to_log(unable_to(msg))
      which = :fail
      ok    = false
    else
      passed_to_log(with_caller("#{element.tag_name}", msg))
    end
  else
    debug_to_log('Element does not have focus to remove.')
    which = :already
  end
  begin
    if @focus_moves
      @focus_moves[:remove][which] += 1
      if which == :tab and tab_twice
        @focus_moves[:remove][which] += 1
      end
    end
  rescue
    debug_to_log(with_caller("'#{$!}'", msg))
  end
  ok
rescue
  failed_to_log(unable_to(msg))
end

#resize_element_with_handle(browser, element, target, dx, dy = nil) ⇒ Object 



144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
 
# File 'lib/awetestlib/regression/drag_and_drop.rb', line 144

def resize_element_with_handle(browser, element, target, dx, dy=nil)
  #TODO enhance to accept differing percentages in each direction
  msg                                  = "Resize element "
  w1, h1, x1, y1, xc1, yc1, xlr1, ylr1 = get_element_coordinates(browser, element, true)
  if dy
    deltax = dx
    deltay = dy
    neww   = w1 + dx
    newh   = h1 + dy
    msg << " by [#{dx}, #{dy}] " #"" to expected dimension [#{neww}, #{newh}] "
  else
    deltax, deltay, neww, newh = adjust_dimensions_by_percent(w1, h1, dx, true)
    msg << "by #{dx} percent " #"" to expected dimension [#{neww}, #{newh}] "
  end
  handle = get_resize_handle_by_class(element, target) #, true)
  sleep_for(0.5)
  hw, hh, hx, hy, hxc, hyc, hxlr, hylr = get_element_coordinates(browser, handle, true)
  hxlr_diff                            = 0
  hylr_diff                            = 0

  # TODO These adjustments are adhoc and empirical. Need to be derived more rigorously
  if @browserAbbrev == 'IE'
    hxlr_diff = (xlr1 - hxlr)
    hylr_diff = (ylr1 - hylr)
    x_start   = hxlr - 2
    y_start   = hylr - 2
  else
    hxlr_diff = (xlr1 - hxlr) / 2 unless (xlr1 - hxlr) == 0
    hylr_diff = (ylr1 - hylr) / 2 unless (ylr1 - hylr) == 0
    x_start = hxlr
    y_start = hylr
  end

  newxlr = xlr1 + deltax
  newylr = ylr1 + deltay
  #    msg << ", lower right [#{newxlr}, #{newylr}] - "
  sleep_for(0.5)

  drag_and_drop(x_start, y_start, deltax, deltay)

  sleep_for(1.5)
  w2, h2, x2, y2, xc2, yc2, xlr2, ylr2 = get_element_coordinates(browser, element, true)

  werr   = w2 - neww
  herr   = h2 - newh

  # TODO This adjustment is adhoc and empirical. Needs to be derived more rigorously
  xlrerr = xlr2 - newxlr + hxlr_diff
  ylrerr = ylr2 - newylr + hylr_diff

  xlrdsp = (xlr1 - xlr2).abs
  ylrdsp = (ylr1 - ylr2).abs

  debug_to_log("\n" +
                   "\t\t  hxlr_diff: #{hxlr_diff}\n" +
                   "\t\t  hylr_diff: #{hylr_diff}\n" +
                   "\t\t       werr: #{werr}\n" +
                   "\t\t       herr: #{herr}\n" +
                   "\t\t     xlrerr: #{xlrerr}\n" +
                   "\t\t     ylrerr: #{ylrerr}\n" +
                   "\t\t     xlrdsp: #{xlrdsp}\n" +
                   "\t\t     ylrdsp: #{ylrdsp}\n" +
                   "\t\t @min_width: #{@min_width}\n" +
                   "\t\t@min_height: #{@min_height}\n" +
                   "\t\t      x tol: #{@x_tolerance}\n" +
                   "\t\t      y tol: #{@y_tolerance}\n"
  )

  #TODO Add check that window _was_ resized.
  x_ok, x_msg = validate_move(w2, xlrerr, @x_tolerance, @min_width, xlr2)
  y_ok, y_msg = validate_move(h2, ylrerr, @y_tolerance, @min_height, ylr2)
  msg         = msg + "x: #{x_msg}, y: #{y_msg}"

  if x_ok and y_ok
    passed_to_log(msg)
  else
    failed_to_log(msg)
    debug_to_log("x - actual #{xlr2}, error #{xlrerr}, displace #{xlrdsp}, y - actual #{ylr2}, error #{ylrerr}, displace #{ylrdsp}.")
  end
  sleep_for(1)
rescue
  failed_to_log("Unable to validate resize. #{$!} (#{__LINE__})")
  sleep_for(1)
end

#return_focus(container, element, desc = '', refs = '') ⇒ Object 



3648
3649
3650
3651
3652
3653
3654
3655
3656
3657
3658
3659
3660
3661
3662
3663
3664
3665
3666
3667
3668
3669
3670
3671
3672
3673
3674
3675
3676
3677
3678
3679
3680
3681
3682
3683
3684
3685
3686
3687
3688
3689
3690
3691
3692
3693
3694
 
# File 'lib/awetestlib/regression/awetest_dsl.rb', line 3648

def return_focus(container, element, desc = '', refs = '')
  msg = build_message(desc, refs)
  ok  = true
  if element.focused?
    debug_to_log('Element already has focus.')
    which = :already
  else
    element.fire_event('onclick')
    debug_to_log("Fired 'onclick' event")
    which = :onclick
    unless element.focused?
      element.fire_event('onfocus')
      debug_to_log("Fired 'onfocus' event")
      which = :onfocus
      unless element.focused?
        element.focus
        debug_to_log("Called focus method")
        which = :focus
        unless element.focused?
          element.click
          debug_to_log("Called click method")
          which = :click
          unless element.focused?
            container.send_keys([:shift, :tab])
            debug_to_log("Sent shift tab")
            which = :shift_tab
          end
        end
      end
    end
    if element.focused?
      passed_to_log(with_caller("#{element.tag_name}", msg))
    else
      failed_to_log(unable_to(msg))
      which = :fail
      ok    = false
    end
  end
  begin
    @focus_moves[:remove][which] += 1 if @focus_moves
  rescue
    debug_to_log(with_caller("'#{$!}'", msg))
  end
  ok
rescue
  failed_to_log(unable_to(msg))
end

#right_click(element) ⇒ Object 



383
384
385
386
387
 
# File 'lib/awetestlib/regression/drag_and_drop.rb', line 383

def right_click(element)
  x = element.left_edge_absolute + 2
  y = element.top_edge_absolute + 2
  @ai.MouseClick("secondary", x, y)
end

#screen_available_size(browser) ⇒ Object 



3781
3782
3783
3784
3785
3786
3787
3788
 
# File 'lib/awetestlib/regression/awetest_dsl.rb', line 3781

def screen_available_size(browser)
  [browser.execute_script('return screen.availWidth'),
   browser.execute_script('return screen.availHeight')]
rescue => e
  unless rescue_me(e, __method__, "#{__method__}(browser)")
    raise e
  end
end

#screen_center(element, browser = nil) ⇒ Object 



402
403
404
405
406
407
408
 
# File 'lib/awetestlib/regression/drag_and_drop.rb', line 402

def screen_center(element, browser=nil)
  bx, by, bw, bh = get_browser_coord(browser)
  w, h           = element.dimensions.to_a
  cx             = bx + w/2
  cy             = by + h/2
  [cx, cy]
end

#screen_lower_right(element, browser = nil) ⇒ Object 



410
411
412
413
414
 
# File 'lib/awetestlib/regression/drag_and_drop.rb', line 410

def screen_lower_right(element, browser=nil)
  bx, by, bw, bh = get_browser_coord(browser)
  w, h           = element.dimensions.to_a
  [bx + w, by + h]
end

#screen_offset(element, browser = nil) ⇒ Object 



395
396
397
398
399
400
 
# File 'lib/awetestlib/regression/drag_and_drop.rb', line 395

def screen_offset(element, browser=nil)
  bx, by, bw, bh = get_browser_coord(browser)
  ex             = element.left_edge
  ey             = element.top_edge
  [bx + ex, by + ey]
end

#screen_size(browser) ⇒ Object 



3772
3773
3774
3775
3776
3777
3778
3779
 
# File 'lib/awetestlib/regression/awetest_dsl.rb', line 3772

def screen_size(browser)
  [browser.execute_script('return screen.width'),
   browser.execute_script('return screen.height')]
rescue => e
  unless rescue_me(e, __method__, "#{__method__}(browser)")
    raise e
  end
end

#scroll_element_into_view(element, desc = '', refs = '') ⇒ Object 



3818
3819
3820
3821
3822
3823
3824
3825
3826
3827
3828
3829
 
# File 'lib/awetestlib/regression/awetest_dsl.rb', line 3818

def scroll_element_into_view(element, desc = '', refs = '')
  msg   = build_message(desc, "#{__method__.to_s.humanize}", refs)
  point = element.wd.location_once_scrolled_into_view
  if point
    passed_to_log(msg)
    [point.x, point.y]
  else
    failed_to_log(msg)
  end
rescue
  failed_to_log(unable_to(desc))
end

#scroll_in_element(element, direction, amount) ⇒ Object 



3872
3873
3874
3875
3876
3877
3878
3879
3880
3881
3882
3883
3884
3885
3886
3887
3888
3889
3890
3891
3892
3893
3894
3895
3896
3897
3898
3899
3900
3901
3902
3903
3904
3905
3906
3907
3908
3909
3910
3911
3912
3913
3914
3915
3916
3917
3918
3919
3920
3921
 
# File 'lib/awetestlib/regression/awetest_dsl.rb', line 3872

def scroll_in_element(element, direction, amount)
  js     = 'return arguments[0].scroll@@@ = arguments[1];",EEEEE, PPPPP'
  ortho  = ''
  pixels = amount
  case direction
    when :up
      ortho = 'Top'
    when :down
      ortho  = 'Top'
      pixels = -amount
    when :left
      ortho = 'Left'
    when :right
      ortho  = 'Left'
      pixels = -amount
    else
      failed_to_log(with_caller("Invalid direction '#{direction}'"))
  end
  element.browser.execute_script("return arguments[0].scroll#{ortho} = arguments[1];\"", element, pixels)

    # Scroll inside web element vertically (e.g. 100 pixel)
    # js.executeScript("arguments[0].scrollTop = arguments[1];",driver.findElement(By.id("<div-id>")), 100);

    # eula = dr.find_element_by_id('eulaFrame')
    # dr.execute_script('arguments[0].scrollTop = arguments[0].scrollHeight', eula)

    # JavascriptExecutor jse = (JavascriptExecutor) localDriver;
    # //locate web element you need for scroll and its height
    #                               WebElement element = localDriver.findElement(By.id("DIV_element"));
    #                               String blockHeight = "return arguments[0].offsetHeight";
    #
    #                               String myscript = "arguments[0].scrollTop"+jse.executeScript(blockHeight,element);
    #
    #                               element.click();
    #                               pause(100);
    #                               jse.executeScript(myscript, element);

    # If you want to scroll inner div element, not window you can try this below code:
    #                                                                                //Get div element having scroll bar you want to do
    #   WebElement scrollArea = driver.findElement(By.xpath("//"));
    #   // Initialize Javascript executor
    #   JavascriptExecutor js = (JavascriptExecutor) driver;
    #   // Scroll inside web element vertically (e.g. 1000 pixel)
    #   js.executeScript("arguments[0].scrollTop = arguments[1];",scrollArea, 1000);
    #   Thread.sleep(1000);
    #   // do something (ex. choose an item in list ...)
    #   Good luck! hihi
rescue
  failed_to_log(unable_to(ortho, pixels))
end

#scroll_into_view(container, element, how, what, desc = '', refs = '', options = {}) ⇒ Object 



3804
3805
3806
3807
3808
3809
3810
3811
3812
3813
3814
3815
3816
 
# File 'lib/awetestlib/regression/awetest_dsl.rb', line 3804

def scroll_into_view(container, element, how, what, desc = '', refs = '', options = {})
  msg   = build_message(desc, "#{__method__.to_s.humanize} :#{element.to_s.upcase} :#{how}='#{what}'", refs)
  code  = build_webdriver_fetch(element, how, what, options)
  point = eval("#{code}.when_present.wd.location_once_scrolled_into_view")
  if point
    passed_to_log(msg)
    [point.x, point.y]
  else
    failed_to_log(msg)
  end
rescue
  failed_to_log(unable_to(msg))
end

#scroll_to(browser, param, desc = '', refs = '') ⇒ Object 



3831
3832
3833
3834
3835
3836
3837
3838
3839
3840
3841
3842
3843
3844
3845
3846
3847
3848
3849
3850
3851
3852
3853
3854
3855
3856
3857
3858
3859
3860
3861
3862
3863
3864
3865
3866
3867
3868
3869
3870
 
# File 'lib/awetestlib/regression/awetest_dsl.rb', line 3831

def scroll_to(browser, param, desc = '', refs = '')
  ok = true
  case param
    when Array
      what = nice_array(param)
    when param.respond_to?(:tag_name)
      what = translate_tag_name(param)
    else
      what = "#{param}"
  end

  #Thanks to Alex Rodionov (p0deje)
  args = case param
           when :top, :start
             'window.scrollTo(0, 0);'
           when :center
             'window.scrollTo(document.body.scrollWidth / 2, document.body.scrollHeight / 2);'
           when :bottom, :end
             'window.scrollTo(0, document.body.scrollHeight);'
           when Watir::Element, Watir::WhenPresentDecorator
             ['arguments[0].scrollIntoView();', param]
           when Array
             ['window.scrollTo(arguments[0], arguments[1]);', Integer(param[0]), Integer(param[1])]
           else
             if param.respond_to?(:tag_name)
               target = param.element
               ['arguments[0].scrollIntoView();', target]
             else
               failed_to_log(build_message(with_caller(desc, what), refs, "Don't know how to scroll to: #{param.to_s}!"))
               ok = false
             end
         end

  if ok
    browser.execute_script(*args)
  end
  ok
rescue
  failed_to_log(unable_to(build_message(desc, what, refs)))
end

#set_viewport_size(browser, width, height, diff = nil, move_to_origin = true, use_body = false, desc = '', refs = '') ⇒ Object 



3977
3978
3979
3980
3981
3982
3983
3984
3985
3986
3987
3988
3989
3990
3991
3992
3993
3994
3995
3996
3997
3998
3999
4000
4001
4002
4003
4004
 
# File 'lib/awetestlib/regression/awetest_dsl.rb', line 3977

def set_viewport_size(browser, width, height, diff = nil, move_to_origin = true, use_body = false, desc = '', refs = '')
  if $mobile
    debug_to_log(with_caller("Not supported for mobile browsers"))
  else
    diff = window_viewport_offsets(browser.browser) unless diff
    resize_browser_window(browser.browser, width + diff[0], height + diff[1], move_to_origin)
    sleep(0.5)
    msg          = build_message(desc, "viewport (#{width}, #{height})",
                                 "(offsets (#{diff[0]}, #{diff[1]}))")
    act_x, act_y = viewport_size(browser.browser, use_body)
    if width == act_x.to_i and height == act_y.to_i
      if @targetBrowser.abbrev == 'FF'
        debug_to_log(with_caller(msg, refs))
      else
        passed_to_log(with_caller(msg, refs))
      end
      true
    else
      if @targetBrowser.abbrev == 'FF'
        debug_to_report(with_caller(msg, "Found (#{act_x}, #{act_y})", refs))
      else
        failed_to_log(with_caller(msg, "Found (#{act_x}, #{act_y})", refs))
      end
    end
  end
rescue
  failed_to_log(unable_to)
end

#validate_drag_drop(err, tol, exp, act) ⇒ Object 



432
433
434
435
436
437
438
439
440
 
# File 'lib/awetestlib/regression/drag_and_drop.rb', line 432

def validate_drag_drop(err, tol, exp, act)
  ary = [false, "failed, expected: #{exp}, actual: #{act}, err: #{err}"]
  if err == 0
    ary = [true, 'succeeded ']
  elsif err.abs <= tol
    ary = [true, "within tolerance (+-#{tol}px) "]
  end
  ary
end

#verify_element_inside(inner_element, outer_element, desc = '') ⇒ Object

Verify that specified inner_element is fully enclosed by outer_element.

Parameters:

  • inner_element (Watir::Element) —

    A reference to a DOM element

  • outer_element (Watir::Element) —

    A reference to a DOM element

  • desc (String) (defaults to: '') —

    Contains a message or description intended to appear in the log and/or report output



38
39
40
41
42
43
44
45
46
47
48
49
50
 
# File 'lib/awetestlib/regression/drag_and_drop.rb', line 38

def verify_element_inside(inner_element, outer_element, desc = '')
  mark_testlevel("#{__method__.to_s.titleize}", 3)
  msg = build_message("#{inner_element.class.to_s} (:id=#{inner_element.id}) is fully enclosed by "+
                      "#{outer_element.class.to_s} (:id=#{outer_element.id}).", desc)
  if overlay?(inner_element, outer_element, :inside)
    failed_to_log(msg)
  else
    passed_to_log(msg)
    true
  end
rescue
  failed_to_log("Unable to verify that #{msg} '#{$!}'")
end

#verify_no_element_overlap(browser, above_element, above_how, above_what, below_element, below_how, below_what, side, desc = '') ⇒ Object

Verify that two elements, identified by specified attribute and value, do not overlap on a given side.

Parameters:

  • above_element (Symbol) —

    The element type for the first element, e.g. :div, :span, etc.

  • above_how (Symbol) —

    The element attribute used to identify the above_element. Valid values depend on the kind of element. Common values: :text, :id, :title, :name, :class, :href (:link only)

  • above_what (String, Regexp) —

    A string or a regular expression to be found in the above_how attribute that uniquely identifies the element.

  • below_element (Symbol) —

    The element type for the second element, e.g. :div, :span, etc.

  • below_how (Symbol) —

    The element attribute used to identify the below_element.

  • below_what (String, Regexp) —

    A string or a regular expression to be found in the below_how attribute that uniquely identifies the element.

  • side (Symbol) —

    :top, :bottom, :left, :right, :inside, or :outside

  • desc (String) (defaults to: '') —

    Contains a message or description intended to appear in the log and/or report output



63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
 
# File 'lib/awetestlib/regression/drag_and_drop.rb', line 63

def verify_no_element_overlap(browser, above_element, above_how, above_what, below_element, below_how, below_what, side, desc = '')
  mark_testlevel("#{__method__.to_s.titleize}", 3)
  msg = build_message("#{above_element.to_s.titleize} #{above_how}=>#{above_what} does not overlap "+
                      "#{below_element.to_s.titleize} #{below_how}=>#{below_what} at the #{side}.", desc)
  above = browser.element(above_how, above_what)
  below = browser.element(below_how, below_what)
  if overlay?(above, below, side)
    failed_to_log(msg)
  else
    passed_to_log(msg)
    true
  end
rescue
  failed_to_log("Unable to verify that #{msg} '#{$!}'")
end

#verify_resize(d, err, tol, min, act) ⇒ Object Also known as: validate_move, validate_resize 



416
417
418
419
420
421
422
423
424
425
426
427
 
# File 'lib/awetestlib/regression/drag_and_drop.rb', line 416

def verify_resize(d, err, tol, min, act)
  ary = [false, "failed, actual #{act} err #{err}"]
  if err == 0
    ary = [true, 'succeeded ']
    #TODO need to find way to calculate this adjustment
  elsif d <= min + 4
    ary = [true, "reached minimum (#{min}) "]
  elsif err.abs <= tol
    ary = [true, "within tolerance (+-#{tol}px) "]
  end
  ary
end

#viewport_size(browser) ⇒ Object 



3750
3751
3752
3753
3754
3755
3756
3757
3758
3759
3760
3761
3762
3763
3764
3765
3766
3767
3768
3769
3770
 
# File 'lib/awetestlib/regression/awetest_dsl.rb', line 3750

def viewport_size(browser, use_body = false)
  browser = browser.browser if browser.respond_to?(:tag_name)
  if @targetBrowser.abbrev == 'IE' and @browserVersion.to_i < 9
    x, y = insert_viewport_div(browser)
  else
    if use_body
      x = browser.body.attribute_value('clientWidth')
      y = browser.body.attribute_value('clientHeight')
    else
      x = browser.execute_script("return window.innerWidth")
      y = browser.execute_script("return window.innerHeight")
    end
  end

  [x, y]

rescue => e
  unless rescue_me(e, __method__, "#{__method__}(browser, #{use_body})")
    raise e
  end
end

#window_dimensions(browser) ⇒ Object 



3943
3944
3945
3946
3947
3948
3949
3950
3951
3952
3953
3954
3955
3956
3957
3958
3959
3960
3961
3962
3963
3964
3965
3966
3967
3968
 
# File 'lib/awetestlib/regression/awetest_dsl.rb', line 3943

def window_dimensions(browser)
  browser = browser.browser if browser.respond_to?(:tag_name)
  wd_dim  = browser.window.size
  wd_pos  = browser.window.position
  vp_dim  = viewport_size(browser)
  off_x   = (wd_dim.width - vp_dim[0])
  off_y   = (wd_dim.height - vp_dim[1])
  off_y   += 1 if @targetBrowser.abbrev == 'FF'

  just_inside_x = wd_pos.x + wd_dim.width - off_x - 3
  just_inside_y = wd_pos.y + off_x + 3

  debug_to_log(with_caller("\nposition: [#{wd_pos.x},#{wd_pos.y}]",
                           "\nsize:     [#{wd_dim.width},#{wd_dim.height}] ",
                           "\nviewport: [#{vp_dim[0]},#{vp_dim[1]}]",
                           "\noffsets:  [#{off_x},#{off_y}]",
                           "\njust_inside: [#{just_inside_x},#{just_inside_y}]"
               ))
  [wd_pos.x, wd_pos.y,
   wd_dim.width, wd_dim.height,
   vp_dim[0], vp_dim[1],
   off_x, off_y,
   just_inside_x, just_inside_y]
rescue
  failed_to_log(unable_to)
end

#window_viewport_offsets(browser) ⇒ Object 



3923
3924
3925
3926
3927
3928
3929
3930
3931
3932
3933
3934
3935
3936
3937
3938
3939
3940
3941
 
# File 'lib/awetestlib/regression/awetest_dsl.rb', line 3923

def window_viewport_offsets(browser)
  x = 0
  y = 0

  if $mobile
    debug_to_log(with_caller("Not supported for mobile browsers"))
  else
    browser = browser.browser if browser.respond_to?(:tag_name)
    wd_dim  = browser.window.size
    vp_dim  = viewport_size(browser)
    x       = (wd_dim.width - vp_dim[0])
    y       = (wd_dim.height - vp_dim[1])
    y       += 1 if @targetBrowser.abbrev == 'FF'
  end

  [x, y]
rescue
  failed_to_log(unable_to)
end