scoutui 2.0.3.31.pre → 2.0.3.32.pre

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 73a3448dde2bef2a6176cd5a8845b08caca7d92c
-  data.tar.gz: 808bda329dce2017ffd5133606337a70512a2379
+  metadata.gz: 94cd87322cf8c91d5ac519bc749a6e96d8984b9c
+  data.tar.gz: 8f0b560c94101065a3785987d4c55e2ca85726a0
 SHA512:
-  metadata.gz: 59ba1d8747567b7a8261afd434f3a86e8c8a6913d6e28a1d7afaee997b0e72041d12c03d72ceb03fb488e116219c393957a8e366891697fa88c3b3d14f53dd37
-  data.tar.gz: 0cca14d03c2acb9a15c87cf6b979f61a0f8a4840f39a47860842c0ed1062b5755697e644d23efb24f8ebe92e4efe50d6883f5a5178524b84a34c0aefa0aca518
+  metadata.gz: 37cdcff948a33c1ca3e754d38dafcf61f1ecd90350f6d6ab5ec917d307383412ece1bae34c9999913afc07cbed0be53901124e4980bf171aafebb2f30295f777
+  data.tar.gz: 69cc7c0745d6fd6d30b12b4c7bfd94c39bd2730c5745e4850dab7090d4cd9568b8a8894ca99cdbc6dd7fa386064446bc6abdb9e94a168a2c4a96c3f0b2a4e8f5

data/lib/scoutui/base/assertions.rb

@@ -15,7 +15,8 @@ module Scoutui::Base
       @assertionTypes=[
           { :cmd => 'isEnabled',   :pattern => '^\s*[!]*isEnabled\((.*)\)\s*$', :parse => lambda { |_a| _parseFrameLoc('isEnabled', _a) } },
           { :cmd => 'isSelected',  :pattern => '^\s*[!]*isSelected\((.*)\)\s*$', :parse => lambda { |_a| _parseFrameLoc('isSelected', _a) } },
-          { :cmd => 'isValue',      :pattern => '^\s*(isValue)\s*\(.*\)\s*\=\s*(.*)\s*$',   :parse => lambda { |_a| _parseWith('isValue', _a) } },
+          { :cmd => 'isText',      :pattern => '^\s*[!]*(isText)\s*\(.*\)\s*\=\s*(.*)\s*$',   :parse => lambda { |_a| _parseWith('isText', _a) } },
+          { :cmd => 'isValue',      :pattern => '^\s*[!]*(isValue)\s*\(.*\)\s*\=\s*(.*)\s*$',   :parse => lambda { |_a| _parseWith('isValue', _a) } },
           { :cmd => 'visible',     :pattern => '^\s*[!]*visible\((.*)\)\s*$', :parse => nil }
       ]
 
@@ -88,6 +89,38 @@ module Scoutui::Base
       rc
     end
 
+
+    # Returns
+    #
+    # if frame exists
+    #  {
+    #     'frame' => <frame>,
+    #     'locator' => 'locator'
+    #  }
+    #
+    # otherwise,
+    #
+    # { 'locator => <locator> '}
+    def _parseFrameLocator(_a)
+      puts __FILE__ + (__LINE__).to_s + " _parseFrameLocator(#{_a})"
+      _pattern='(frame\(.*\)[\.frame\(.*\)]*)\s*,\s*(.*)\s*$'
+      _fMatch = _a.match(/#{_pattern}/)
+      puts __FILE__ + (__LINE__).to_s + " === _fMatch : #{_fMatch}"
+      rc=nil
+      if _fMatch
+        rc = {
+               'frame'    =>  _fMatch[1].strip,
+               'locator'  =>  _fMatch[2].strip }
+      else
+        rc = {
+            'locator' => _a
+        }
+      end
+
+      puts __FILE__ + (__LINE__).to_s + " _parseFrameLocator(#{_a}) => #{rc}"
+      rc
+    end
+
     # _a : frame(xyz).frame(123), <locator>
     def _parseFrameLoc(_cmd, _a)
 
@@ -179,7 +212,7 @@ module Scoutui::Base
         ;
       end
 
-      puts __FILE__ + (__LINE__).to_s + " isVisibleCmd?(#{_a}) : #{rc}"
+      puts __FILE__ + (__LINE__).to_s + " isVisibleFrameCmd?(#{_a}) : #{rc}"
       rc
     end
 
@@ -257,7 +290,7 @@ module Scoutui::Base
     end
 
 
-    def isEnabled?(my_driver, _execute_when)
+    def isEnabled?(my_driver, _execute_when, _enableAsserts=true)
 
       rc=true
       _locator=nil
@@ -278,7 +311,7 @@ module Scoutui::Base
           Scoutui::Commands::Utils.instance.setEnableFrameSearch(_t['frame'])
         end
 
-        _obj = Scoutui::Base::QBrowser.findElement(my_driver, _locator, Scoutui::Commands::Utils.instance.getFrameSearch(),  Scoutui::Commands::Utils.instance.getTimeout)
+        _obj = Scoutui::Base::QBrowser.findElement(my_driver, Scoutui::Base::UserVars.instance.normalize(_locator), Scoutui::Commands::Utils.instance.getFrameSearch(),  Scoutui::Commands::Utils.instance.getTimeout)
       else
         Scoutui::Logger::LogMgr.instance.warn __FILE__ + (__LINE__).to_s + " invalid assertion cmd: #{_execute_when}"
       end
@@ -305,19 +338,58 @@ module Scoutui::Base
         puts __FILE__ + (__LINE__).to_s + " _obj.enabled? => #{_enabled}"
 
         if _execute_when.match(/^\s*!isEnabled/i) && _enabled
-          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " !isEnabled(#{_locator}) : false"
-          rc=false
+
+          if _enableAsserts
+            Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " !isEnabled(#{_locator}) : false"
+            rc=false
+          else
+
+            begin
+              Selenium::WebDriver::Wait.new(timeout: 15).until {
+                _obj = Scoutui::Base::QBrowser.findElement(my_driver, _locator, Scoutui::Commands::Utils.instance.getFrameSearch(),  Scoutui::Commands::Utils.instance.getTimeout)
+                puts __FILE__ + (__LINE__).to_s + " waiting .. => #{_obj.class.to_s} : enabled - #{_obj.enabled?}"
+
+                !_obj.enabled?
+              }
+
+            rescue Selenium::WebDriver::Error::TimeOutError
+              rc=!_obj.enabled?
+
+              Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " TimeOutError waiting for !enabled - #{_locator}  => #{rc}"
+            end
+
+            Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + "  wait #{_locator} to be !enabled => #{rc}"
+          end
+
         elsif _execute_when.match(/^\s*isEnabled/i) && !_enabled
           Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " isEnabled(#{_locator}) : false"
           rc=false
         end
 
+
+
+      elsif _t.has_key?('cmd') && !_t['cmd'].empty? && _t['cmd'].match(/[!]*isText/i)
+        rc=false
+
+        if _obj.is_a?(Selenium::WebDriver::Element)
+          _v = _obj.text.to_s
+          rc=!_v.match(/#{_t['expected_value']}/).nil?
+
+          if _t['cmd'].match(/^!\s*isText/i)
+            rc=!rc
+          end
+        end
+
       elsif _t.has_key?('cmd') && !_t['cmd'].empty? && _t['cmd'].match(/[!]*isValue/i)
         rc=false
 
         if _obj.is_a?(Selenium::WebDriver::Element)
           _v = _obj.attribute('value')
           rc=!_v.match(/#{_t['expected_value']}/).nil?
+
+          if _t['cmd'].match(/^!\s*isValue/i)
+            rc=!rc
+          end
         end
 
         Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " assert #{_t['locator']} expected: #{_t['expected_value']} with actual: #{_v} => #{rc}"
@@ -353,7 +425,7 @@ module Scoutui::Base
     end
 
 
-    def isVisible?(my_driver, _execute_when)
+    def isVisible?(my_driver, _execute_when, _enableAsserts=true)
       rc=true
 
       begin
@@ -361,7 +433,9 @@ module Scoutui::Base
         _t = isVisibleFrameCmd?(_execute_when)
 
         if !_t.nil?
-          _locator = _t['locator']
+      # 5150    _locator = _t['locator']
+          _locator = Scoutui::Base::UserVars.instance.normalize(_locator)
+
           Scoutui::Commands::Utils.instance.setEnableFrameSearch(_t['frame'])
         elsif isVisibleCmd?(_execute_when)
            _locator = _execute_when.match(/^\s*[!]*visible\((.*)\)\s*$/i)[1].to_s
@@ -382,6 +456,42 @@ module Scoutui::Base
         end
 
 
+        if !_enableAsserts
+          _rc=false
+
+          begin
+            if _execute_when.match(/^\s*!visible/)
+
+                Selenium::WebDriver::Wait.new(timeout: 15).until {
+                  _obj = Scoutui::Base::QBrowser.findElement(my_driver, _locator, Scoutui::Commands::Utils.instance.getFrameSearch(),  Scoutui::Commands::Utils.instance.getTimeout)
+                  puts __FILE__ + (__LINE__).to_s + " waiting .. => #{_obj.class.to_s}"
+                  _rc = (_obj.is_a?(Selenium::WebDriver::Element) && !_obj.displayed?) || _obj.nil?
+                }
+
+            elsif _execute_when.match(/^\s*visible/)
+
+                Selenium::WebDriver::Wait.new(timeout: 15).until {
+                  _obj = Scoutui::Base::QBrowser.findElement(my_driver, _locator, Scoutui::Commands::Utils.instance.getFrameSearch(),  Scoutui::Commands::Utils.instance.getTimeout)
+                  puts __FILE__ + (__LINE__).to_s + " waiting .. => #{_obj.class.to_s}"
+
+                  if _obj.is_a?(Selenium::WebDriver::Element)
+                    puts "***** displayed? : #{_obj.displayed?}"
+                  end
+
+                  _rc = !_obj.nil? && _obj.displayed?
+                  _rc
+                }
+            end
+
+          rescue Selenium::WebDriver::Error::TimeOutError
+            ;
+          end
+
+          puts __FILE__ + (__LINE__).to_s + " waitFor : #{_rc}"
+          return _rc
+        end
+
+
         puts __FILE__ + (__LINE__).to_s + " _obj.displayed? => #{_state}"
 
         if _execute_when.match(/^\s*!visible/i) && _state

data/lib/scoutui/base/q_browser.rb

@@ -53,6 +53,18 @@ module Scoutui::Base
       rc
     end
 
+    def self.isFileType?(obj)
+      rc=false
+      begin
+        if obj.is_a?(Selenium::WebDriver::Element)
+          rc=!obj.attribute('type').match(/file/i).nil?
+        end
+      rescue => ex
+        ;
+      end
+
+      rc
+    end
 
     def self.existsAlert?(drv)
       rc=false

data/lib/scoutui/base/requirements.rb

@@ -0,0 +1,33 @@
+
+
+require 'singleton'
+
+
+module Scoutui::Base
+
+  class Requirements
+    include Singleton
+
+    attr_accessor :requirements
+
+    def initialize
+      @requirements={}
+    end
+
+
+    def add(_id, _reqs)
+      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " add(#{_id}, #{_reqs}"
+      @requirements[_id]=_reqs
+    end
+
+    def get(_id)
+      @requirements[_id]
+    end
+
+  end
+
+
+
+
+
+end

data/lib/scoutui/base/visual_test_framework.rb

@@ -318,7 +318,7 @@ module Scoutui::Base
       processConditions(my_driver, e, 'assertions')
     end
 
-    def self.processAsserts(my_driver, _execute_when)
+    def self.processAsserts(my_driver, _execute_when, _enableAsserts=true)
 
       Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " processAsserts#{_execute_when}"
 
@@ -340,11 +340,13 @@ module Scoutui::Base
 
 
             if _assertType[:cmd]=='isEnabled'   # Scoutui::Base::Assertions.instance.isEnabledCmd?(_a)
-              _rc=Scoutui::Base::Assertions.instance.isEnabled?(my_driver, _a)
+              _rc=Scoutui::Base::Assertions.instance.isEnabled?(my_driver, _a, _enableAsserts)
             elsif _assertType[:cmd]=='visible'
-              _rc=Scoutui::Base::Assertions.instance.isVisible?(my_driver, _a)
+              _rc=Scoutui::Base::Assertions.instance.isVisible?(my_driver, _a, _enableAsserts)
             elsif _assertType[:cmd]=='isSelected'
               _rc=Scoutui::Base::Assertions.instance.isEnabled?(my_driver, _a)
+            elsif _assertType[:cmd]=='isText'
+              _rc=Scoutui::Base::Assertions.instance.isEnabled?(my_driver, _a)
             elsif _assertType[:cmd]=='isValue'
               _rc=Scoutui::Base::Assertions.instance.isEnabled?(my_driver, _a)
             end
@@ -359,11 +361,25 @@ module Scoutui::Base
             _rc=Scoutui::Base::Assertions.instance.isValue?(my_driver, _a)
           elsif Scoutui::Base::Assertions.instance.isTitleCmd?(_a)
             _rc=Scoutui::Base::Assertions.instance.isTitle(my_driver, _a)
+          elsif _a.match(/^\s*(req|requirement)\s*\((.*)\)\s*$/i)
+
+            _reqID=_a.match(/^\s*(req|requirement)\s*\((.*)\)\s*$/i)[2].to_s
+
+            puts __FILE__ + (__LINE__).to_s + "  Process REQ ASSERT: #{_reqID}";
+            _reqAsserts=Scoutui::Base::Requirements.instance.get(_reqID)
+            puts __FILE__ + (__LINE__).to_s + " => #{_reqAsserts}"
+
+            _req = Scoutui::Utils::TestUtils.instance.setReq(_reqID)
+            _rc=processAsserts(my_driver, _reqAsserts, _enableAsserts)
+            Scoutui::Utils::TestUtils.instance.setReq(_req)
           end
 
           if !_rc.nil?
-            Scoutui::Logger::LogMgr.instance.asserts.info __FILE__ + (__LINE__).to_s + " Verify #{_a} - #{_rc}"
-            Testmgr::TestReport.instance.getReq(_req).get_child('visible_when').add(_rc, "Verify #{_a}")
+
+            if _enableAsserts
+              Scoutui::Logger::LogMgr.instance.asserts.info __FILE__ + (__LINE__).to_s + " Verify #{_a} - #{_rc}"
+              Testmgr::TestReport.instance.getReq(_req).get_child('visible_when').add(_rc, "Verify #{_a}")
+            end
 
             Scoutui::Commands::Utils.instance.resetFrameSearch()
 
@@ -1081,7 +1097,30 @@ module Scoutui::Base
               end
 
               if !_region.nil?
-                eyeScout.check_window(_name, _region)
+
+                Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " snapit.region: #{_region}"
+                _frames = Scoutui::Base::Assertions.instance._parseFrameLocator(_region)
+
+                Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + "*** frames: #{_frames}"
+
+
+
+                if _frames.has_key?('frame')
+                  my_driver.switch_to.default_content
+                  Scoutui::Commands::Utils.instance.resetFrameSearch
+                  Scoutui::Commands::Utils.instance.setEnableFrameSearch(_frames['frame'])
+
+                  _obj=Scoutui::Base::QBrowser.findElement(my_driver, _frames['locator]'], Scoutui::Commands::Utils.instance.getFrameSearch(),  Scoutui::Commands::Utils.instance.getTimeout)
+                  Scoutui::Base::QBrowser.highlight(my_driver, obj)
+
+                  Scoutui::Base::QBrowser.switch_frame(my_driver, _frames['frame'])
+
+                  eyeScout.check_window(_name, _frames['locator'])
+                else
+                  eyeScout.check_window(_name, Scoutui::Base::UserVars.instance.normalize(_region))
+                end
+
+
               else
                 eyeScout.check_window(_name)
               end
@@ -1107,7 +1146,7 @@ module Scoutui::Base
         processAssertions(my_driver, e)
 
          if !_region.nil?
-          eyeScout.check_window(_name, _region)
+          eyeScout.check_window(_name, Scoutui::Base::UserVars.instance.normalize(_region))
         else
           eyeScout.check_window(_name)
         end

data/lib/scoutui/commands/click_object.rb

@@ -68,10 +68,17 @@ module Scoutui::Commands
 
           # Refactor in qbrowser
 
-          wait = Selenium::WebDriver::Wait.new(:timeout =>  Scoutui::Commands::Utils.instance.getTimeout)
-
           isDisplayed=false
-          isDisplayed = wait.until { obj.displayed? }
+
+          begin
+            wait = Selenium::WebDriver::Wait.new(:timeout =>  Scoutui::Commands::Utils.instance.getTimeout)
+            isDisplayed = wait.until {
+              true if obj.displayed?
+            }
+          rescue Selenium::WebDriver::Error::TimeOutError => ex
+            Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Timeout waiting for display?: #{_xpath}"
+          end
+
 
           if isDisplayed
 

data/lib/scoutui/commands/commands.rb

@@ -50,6 +50,38 @@ module Scoutui::Commands
         _cmd='pause'
         _c = Scoutui::Commands::Pause.new(nil)
         _c.execute(e);
+
+      elsif Scoutui::Commands::Utils.instance.isLoadRequirements?(_action)
+        _cmd='loadrequirements'
+        _c = Scoutui::Commands::LoadRequirements.new(e)
+        _c.run(driver: my_driver, dut: e)
+      elsif Scoutui::Commands::Utils.instance.isAssignments?(_action)
+        _cmd='assignments'
+        if e['page'].has_key?('vars')
+          e['page']['vars'].each do |_a|
+
+            puts __FILE__ + (__LINE__).to_s + "  Process Assignment.var : #{_a}"
+
+            begin
+              _caborted=false
+
+              if !Scoutui::Commands::Utils.instance.isAssignVar?(_a)
+                _m=_a.match(/([\w\_])+\=(.*)/)
+                _a="assign(#{_m[1]},#{_m[2]})"
+              end
+
+              _c = Scoutui::Commands::AssignVar.new(_a)
+              _rc=_c.run(driver: my_driver, dut: e)
+              _c.setResult(_rc)
+            rescue => ex
+              _caborted=true
+            end
+
+            Testmgr::TestReport.instance.getReq(_req).get_child(_cmd.downcase).add(!_caborted, "Verify command assign did not abort")
+          end
+        end
+
+
       elsif Scoutui::Commands::Utils.instance.isAssignVar?(_action)
         _cmd='assignvar'
         _c = Scoutui::Commands::AssignVar.new(_action)
@@ -136,6 +168,12 @@ module Scoutui::Commands
         _c = Scoutui::Commands::UpdateUrl.new(_action)
         _c.run(driver: my_driver)
 
+
+      elsif Scoutui::Commands::Utils.instance.isUploadFiles?(_action)
+        _cmd='UploadFiles'
+        _c = Scoutui::Commands::UploadFiles.new(_action)
+        rc=_c.execute(my_driver, e)
+
       elsif Scoutui::Commands::Utils.instance.isVerifyElt?(_action)
         _cmd='VerifyElement'
         _c = Scoutui::Commands::VerifyElement.new(_action)

data/lib/scoutui/commands/highlight.rb

@@ -44,6 +44,17 @@ module Scoutui::Commands
 
         locators.each do |elt|
 
+
+          q=Scoutui::Base::Assertions.instance._parseFrameLocator(elt)
+
+          if q.has_key?('frame')
+            Scoutui::Commands::Utils.instance.setEnableFrameSearch(q['frame'])
+            elt = q['locator']
+
+       #     puts __FILE__ + (__LINE__).to_s + "  highlight with frame #{q['frame']} with locator #{q['locator']} - PAUSE"
+          end
+
+
           _loc = Scoutui::Base::UserVars.instance.normalize(elt)
 
          # obj = Scoutui::Base::QBrowser.getObject(@drv, loc, Scoutui::Commands::Utils.instance.getTimeout)
@@ -52,8 +63,17 @@ module Scoutui::Commands
                                                     Scoutui::Commands::Utils.instance.getFrameSearch(),
                                                     Scoutui::Commands::Utils.instance.getTimeout)
 
+          if !obj.is_a?(Selenium::WebDriver::Element)
+            Scoutui::Logger::LogMgr.instance.warn __FILE__ + (__LINE__).to_s + " highlight : unable to find #{_loc}"
+          end
+
           _rc = _highlight(obj, e)
 
+          if q.has_key?('frame')
+            @drv.switch_to.default_content
+            Scoutui::Commands::Utils.instance.resetFrameSearch
+          end
+
           rc &&= _rc
 
           Testmgr::TestReport.instance.getReq(_req).testcase('highlight').add(!obj.nil?, "Verify object #{_locator} to highlight exists : #{obj.class.to_s}")

data/lib/scoutui/commands/load_requirements.rb

@@ -0,0 +1,58 @@
+require_relative './commands'
+
+module Scoutui::Commands
+
+  class LoadRequirements < Command
+
+
+    def execute(drv, e=nil)
+      @drv=drv if !drv.nil?
+
+      rc=false
+      obj=nil
+      _locator=nil
+
+      _req = Scoutui::Utils::TestUtils.instance.getReq()
+
+      begin
+
+        Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " LoadRequirements()"
+
+        if e['page'].has_key?('files')
+
+          e['page']['files'].each do |r|
+            y=YAML.load_stream File.read(r)
+
+            puts __FILE__ + (__LINE__).to_s + " *** REQMT => #{y}"
+
+            y.each do |_y|
+              puts __FILE__ + (__LINE__).to_s + " ===> #{_y}"
+              Scoutui::Base::Requirements.instance.add(_y['requirement']['name'], _y['requirement']['assertions'])
+            end
+
+
+          end
+
+
+        end
+
+        rc=true
+
+      rescue => ex
+        Scoutui::Logger::LogMgr.instance.warn "Error during processing: #{ex}"
+        Scoutui::Logger::LogMgr.instance.warn "Backtrace:\n\t#{ex.backtrace.join("\n\t")}"
+      end
+
+      if rc
+        Scoutui::Logger::LogMgr.instance.asserts.info "Verify requirements command passed - #{rc}"
+        Testmgr::TestReport.instance.getReq(_req).testcase('click').add(rc, "Verify requirements command passed")
+      end
+
+      setResult(rc)
+    end
+
+  end
+
+
+
+end

data/lib/scoutui/commands/type.rb

@@ -6,7 +6,6 @@ module Scoutui::Commands
 
 
     KEYBOARD_LIST={
-
         '__DOWN__' => lambda { |obj| obj.send_keys(:arrow_down) },
         '__TAB__'  => lambda { |obj| obj.send_keys(:tab) },
         '__CLEAR__'  => lambda { |obj| obj.clear }
@@ -49,6 +48,7 @@ module Scoutui::Commands
 
     end
 
+
     def execute(drv=nil, _notUsed=nil)
       @drv=drv if !drv.nil?
 
@@ -81,24 +81,31 @@ module Scoutui::Commands
 
           if !obj.nil? &&
                 (obj.tag_name.downcase=='body' ||
-                !obj.attribute('type').downcase.match(/(text|textarea|password|email)/).nil? )
+                !obj.attribute('type').downcase.match(/(file|input|text|textarea|password|email)/).nil? )
 
-            # Refactor in qbrowser
-
-            wait = Selenium::WebDriver::Wait.new(:timeout =>  Scoutui::Commands::Utils.instance.getTimeout)
             isDisplayed=false
-            isDisplayed = wait.until {
-              true if obj.displayed?
-            }
 
-            if @cmd.match(/type\!/i)
+            # FileUpload dialog is not 'displayed'
+            if !Scoutui::Base::QBrowser.isFileType?(obj)
+              begin
+                wait = Selenium::WebDriver::Wait.new(:timeout =>  Scoutui::Commands::Utils.instance.getTimeout)
+                isDisplayed = wait.until {
+                  true if obj.displayed?
+                }
+              rescue Selenium::WebDriver::Error::TimeOutError => ex
+                Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Timeout waiting for display?: #{_xpath}"
+              end
+            end
+
+
+            if @cmd.match(/^\s*type\!/i)
               Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " clear()"
               obj.clear if isDisplayed
             end
 
             Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " send_keys(#{_val})"
 
-            if isDisplayed
+            if isDisplayed || Scoutui::Base::QBrowser.isFileType?(obj)
 
               if KEYBOARD_LIST.has_key?(_val.strip)
                 KEYBOARD_LIST[_val.strip].call(obj)
@@ -125,9 +132,9 @@ module Scoutui::Commands
                 ## Global replaces
                 _text_to_type = Scoutui::Base::UserVars.instance.get(_v2)
 
-                puts __FILE__ + (__LINE__).to_s + " rawText : #{_text_to_type}"
+                Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " rawText : #{_text_to_type}"
                 _text_to_type = Scoutui::Commands::Utils.instance.expandMacro(_text_to_type)
-                puts __FILE__ + (__LINE__).to_s + " Text to type : #{_text_to_type}"
+                Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Text to type : #{_text_to_type}"
                 obj.send_keys(_text_to_type)
 
                 if !obj.nil? && false
@@ -160,7 +167,7 @@ module Scoutui::Commands
         end
 
       rescue => ex
-        Scoutui::Logger::LogMgr.instance.debug "Error during processing: #{ex}"
+        Scoutui::Logger::LogMgr.instance.debug "Error during processing: #{ex.class}"
         puts __FILE__ + (__LINE__).to_s +  "Backtrace:\n\t#{ex.backtrace.join("\n\t")}"
       end
 

data/lib/scoutui/commands/upload_files.rb

@@ -0,0 +1,75 @@
+
+module Scoutui::Commands
+
+  class UploadFiles < Command
+
+
+
+    def execute(drv, _e=nil)
+
+      Scoutui::Logger::LogMgr.instance.debug __FILE__  + (__LINE__).to_s + " uploadFiles(#{_e})"
+
+      _rc=true
+
+      @drv=drv if !drv.nil?
+
+
+      filelist=_e['page']['with']
+      to=_e['page']['to']
+      submit=_e['page']['submit']
+      close=_e['page']['close']
+      waitList=_e['page']['wait']
+
+      if filelist.is_a?(Array)
+
+        filelist.each do |_f|
+          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + "   upload #{_f}"
+
+          if _e['page'].has_key?('by')
+
+            test_settings={}
+            test_settings['dut']=_e['page']['by']
+       #     Scoutui::Base::VisualTestFramework::processFile(eyeScout, test_settings, strategy=nil)
+            _typeCmd={ 'page' => {'action' => "click(#{_e['page']['by']})"} }
+            _c = Scoutui::Commands::ClickObject.new(_typeCmd)
+            _c.run(driver: @drv, dut: nil)
+          end
+
+          _typeCmd={ 'page' => {'action' => "type(#{to}, #{_f})"} }
+        #  _typeCmd['page']['action']="type(#{to}, #{_f}"
+          _c = Scoutui::Commands::Type.new(_typeCmd, @drv)
+          _c.run(driver: @drv)
+
+      #    puts __FILE__ + (__LINE__).to_s + "  Uploaded - pause"; STDIN.gets;
+
+          _typeCmd={ 'page' => {'action' => "click(#{submit})"} }
+          _c = Scoutui::Commands::ClickObject.new(_typeCmd)
+          _c.run(driver: @drv, dut: nil)
+
+
+          Scoutui::Base::VisualTestFramework::processAsserts(@drv, waitList, false)
+
+          _typeCmd={ 'page' => {'action' => "click(#{close})"} }
+          _c = Scoutui::Commands::ClickObject.new(_typeCmd)
+          _c.run(driver: @drv, dut: nil)
+          puts "++ CLOSED DLG **"; # STDIN.gets
+        end
+
+
+
+      end
+
+
+
+      setResult(rc)
+
+    end
+
+
+
+
+
+  end
+
+
+end

data/lib/scoutui/commands/utils.rb

@@ -15,6 +15,7 @@ module Scoutui::Commands
     def initialize
       @command_list=['pause',
                      'assignvar',
+                     'assignments',
                      'existsAlert',
                      'clickJsAlert',
                      'fillform',
@@ -23,10 +24,12 @@ module Scoutui::Commands
                      'submitform',
                      'type',
                      'click',
+                     'loadrequirements',
                      'mouseover',
                      'navigate',
                      'select',
                      'select_window',
+                     'uploadfiles',
                      'verifyelt',
                      'verifyelement',
                      'verifyform']
@@ -132,7 +135,7 @@ module Scoutui::Commands
         end
       end
 
-      puts __FILE__ + (__LINE__).to_s + " Text to type : #{_text_to_type}"
+      puts __FILE__ + (__LINE__).to_s + " expandMacro : #{_text_to_type}"
 
       _text_to_type.to_s
 
@@ -212,6 +215,9 @@ module Scoutui::Commands
       @timeout.to_i
     end
 
+    def isAssignments?(_action)
+      !_action.match(/^\s*(assignments)\s*$/).nil?
+    end
 
     def isAssignVar?(_action)
       !_action.match(/assign\(([\w]+)\s*\,(.*)\)\s*$/i).nil?
@@ -250,6 +256,10 @@ module Scoutui::Commands
       !_action.match(/fillform\(/i).nil?
     end
 
+    def isLoadRequirements?(_action)
+      !_action.match(/^\s*loadrequirements\s*$/i).nil?
+    end
+
     def isMouseOver?(_action)
       !_action.match(/mouseover\(/).nil?
     end
@@ -274,6 +284,10 @@ module Scoutui::Commands
       !_action.nil? && _action.match(/^\s*select\s*\(/i)
     end
 
+    def isUploadFiles?(_action)
+      !_action.nil? && _action.match(/^\s*uploadfiles\s*$/i)
+    end
+
     def isNavigate?(_action)
       !_action.nil? && _action.match(/(navigate|url)\(/i)
     end
@@ -286,6 +300,8 @@ module Scoutui::Commands
         @totalCommands['pause']+=1
       elsif isAssignVar?(cmd)
         @totalCommands['assignvar']+=1
+      elsif isAssignments?(cmd)
+        @totalCommands['assignments']+=1
       elsif isExistsAlert?(cmd)
         @totalCommands['existsAlert']+=1
       elsif isFrame?(cmd)
@@ -308,12 +324,16 @@ module Scoutui::Commands
         @totalCommands['click']+=1
       elsif isMouseOver?(cmd)
         @totalCommands['mouseover']+=1
+      elsif isLoadRequirements?(cmd)
+        @totalCommands['loadrequirements']+=1
       elsif isSelect?(cmd)
         @totalCommands['select']+=1
       elsif isNavigate?(cmd)
         @totalCommands['navigate']+=1
       elsif isSelectWindow?(cmd)
         @totalCommands['select_window']+=1
+      elsif isUploadFiles?(cmd)
+        @totalCommands['uploadfiles']+=1
       else
         rc=false
       end

data/lib/scoutui/version.rb

@@ -1,3 +1,3 @@
 module Scoutui
-  VERSION = "2.0.3.31.pre"
+  VERSION = "2.0.3.32.pre"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: scoutui
 version: !ruby/object:Gem::Version
-  version: 2.0.3.31.pre
+  version: 2.0.3.32.pre
 platform: ruby
 authors:
 - Peter Kim
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-07-28 00:00:00.000000000 Z
+date: 2016-08-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -237,6 +237,7 @@ files:
 - lib/scoutui/base/q_applitools.rb
 - lib/scoutui/base/q_browser.rb
 - lib/scoutui/base/q_form.rb
+- lib/scoutui/base/requirements.rb
 - lib/scoutui/base/test_scout.rb
 - lib/scoutui/base/test_settings.rb
 - lib/scoutui/base/user_vars.rb
@@ -249,6 +250,7 @@ files:
 - lib/scoutui/commands/fill_form.rb
 - lib/scoutui/commands/highlight.rb
 - lib/scoutui/commands/jsalert/action_jsalert.rb
+- lib/scoutui/commands/load_requirements.rb
 - lib/scoutui/commands/mouse_over.rb
 - lib/scoutui/commands/pause.rb
 - lib/scoutui/commands/select_object.rb
@@ -258,6 +260,7 @@ files:
 - lib/scoutui/commands/switch_frame.rb
 - lib/scoutui/commands/type.rb
 - lib/scoutui/commands/update_url.rb
+- lib/scoutui/commands/upload_files.rb
 - lib/scoutui/commands/utils.rb
 - lib/scoutui/commands/verify_element.rb
 - lib/scoutui/commands/verify_form.rb