class Scoutui::ApplicationModel::QModel

Attributes

_file[RW]
app_model[RW]

Public Class Methods

isPageObject?(_locator) click to toggle source
# File lib/scoutui/appmodel/q_model.rb, line 10
def self.isPageObject?(_locator)
  _locator.is_a?(String)? _locator.match(/^\s*page\s*\(\s*[\w\d_\-]+\s*\)/) : nil
end
new(f=nil) click to toggle source
# File lib/scoutui/appmodel/q_model.rb, line 14
def initialize(f=nil)

  if !f.nil?
    @_file=f
    loadPages(@_file)
  end

end

Public Instance Methods

flattenPageObject(h, path="") click to toggle source
# File lib/scoutui/appmodel/q_model.rb, line 196
def flattenPageObject(h, path="")
  rc=iterate(h, path)
  if rc.is_a?(Array)
    return rc[0]
  end

  nil
end
getAppModel() click to toggle source
# File lib/scoutui/appmodel/q_model.rb, line 23
def getAppModel()
  @app_model
end
getPageElement(s) click to toggle source

getPageElement(“page(login).get(login_form).get(button)”)

# File lib/scoutui/appmodel/q_model.rb, line 55
def getPageElement(s)
  Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " getPageElement(#{s})"

  if s.match(/^\s*\//) || s.match(/^\s*css\s*=/i) || s.match(/^\s*#/)
    Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " getPageElement(#{s} return nil"
    return nil
  end

  hit=@app_model

  nodes = s.split(/\./)

  nodes.each { |elt|

    Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " process #{elt}"
    getter = elt.split(/\(/)[0]
    _obj = elt.match(/\((.*)\)/)[1]

    Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " getter : #{getter}  obj: #{_obj}" if Scoutui::Utils::TestUtils.instance.isDebug?

    if getter.downcase.match(/(page|pg)/)
      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " -- process page --"  if Scoutui::Utils::TestUtils.instance.isDebug?
      hit=@app_model[_obj]
    elsif getter.downcase=='get'

      if !hit.nil? && hit.has_key?(_obj)
        hit=hit[_obj]
      else
        Scoutui::Logger::LogMgr.instance.warn __FILE__ + (__LINE__).to_s + " Missing getter : #{_obj.to_s}"
        return nil
      end

    else
      Scoutui::Logger::LogMgr.instance.warn __FILE__ + (__LINE__).to_s + " getter : #{getter} is unknown."
      return nil
    end
    Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " HIT => #{hit}" if Scoutui::Utils::TestUtils.instance.isDebug?
  }

  hit

end
hits(parent, h, condition, _action, pg) click to toggle source
# File lib/scoutui/appmodel/q_model.rb, line 110
def hits(parent, h, condition, _action, pg)
  #  Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " collect_item_attributes(#{h})"
  result = []


  if h.is_a?(Hash)

    h.each do |k, v|
      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Key: #{k} => #{v}"
      if k == condition
        #  h[k].each {|k, v| result[k] = v } # <= tweak here
        if !v.is_a?(Array) && v.match(/^\s*#{_action}\s*\((.*)\)\s*$/i)

          pageObject=v.match(/^\s*#{_action}\s*\((.*)\)\s*$/i)[1]

          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " <pg, pageObject> : <#{pg}, #{pageObject}>"
          #         result[k] = v

          #          Scoutui::Logger::LogMgr.instance.debug '*******************'
          #          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " HIT : #{h[k]}"
          #          result << { h[k] => v }

          if pg.nil?
            result << parent
          elsif pg == pageObject
            result << parent

          end

        elsif v.is_a?(Array)

          v.each do |vh|
            Scoutui::Logger::LogMgr.instance.debug " =====> #{vh}"

            if vh.is_a?(Hash) && vh.has_key?(condition) && vh[condition].match(/^\s*#{_action}\s*/i)

              pageObject=vh[condition].match(/^\s*#{_action}\s*\((.*)\)\s*$/i)[1]


              Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " matched on #{_action}, pg:#{pg}, #{pageObject}"

              if pg.nil?
                result << parent
              elsif pg == pageObject
                result << parent
              end

            end

          end

        end

      elsif v.is_a? Hash
        if parent.nil?
          _rc = hits("page(#{k})", h[k], condition, _action, pg)
        else
          _rc = hits("#{parent}.get(#{k})", h[k], condition, _action, pg)
        end


        if !(_rc.nil? || _rc.empty?)


          result << _rc

          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " ADDING  #{k} : #{_rc}"
          #           Scoutui::Logger::LogMgr.instance.debug "====> #{k} : #{_rc.class} : #{_rc.length}"


          result.flatten!
        end


      end
    end

  end



  result=nil if result.empty?
  Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " result : #{result}"
  result
end
itemize(condition='visible_when', _action='hover', _pgObj=nil) click to toggle source

visible_when: hover(page(x).get(y).get(z))

# File lib/scoutui/appmodel/q_model.rb, line 101
def itemize(condition='visible_when', _action='hover', _pgObj=nil)
  @results=hits(nil, @app_model, condition, _action, _pgObj)

  Scoutui::Logger::LogMgr.instance.debug "[itemize] => #{@results}"

  @results
end
iterate(h, path="") click to toggle source
# File lib/scoutui/appmodel/q_model.rb, line 205
    def iterate(h, path="")
      rc=true
      assertions=[]

      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " ===== iterate(#{h}, #{path}) ====="

      if h.is_a?(String)
        Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " => process #{h}"
        if h.match(/^\s*(page)\s*\(.*\)\s*$/i)
          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " => process Page #{h}"
          page_elt = getPageElement(h)
          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " => #{page_elt}"
          assertions << iterate(page_elt, path)
        else
          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " UNKNOWN: #{h}"
          assertions << "#{h} : unknown"
        end

      elsif h.is_a?(Hash) && h.has_key?('locator')

        Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " == add #{h} =="
        assertions << { :path => path, :data => h }

      elsif h.is_a?(Hash)

        Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + "Keys.size: #{h.keys[0]}"

        if h.keys.size==1 && h[h.keys[0]].is_a?(Hash) && h[h.keys[0]].has_key?('locator')

          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " add assertion #{h}"
          assertions << { :path => path, :data => h }

        elsif h.keys.size==1 && h[h.keys[0]].is_a?(Hash)

          # "id": {
          # }

          _id = h.keys[0]
          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " LocatorID : #{_id}"

          if true
          h[_id].each_pair { |_k, _h|

            Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " | id(#{_id}) => #{_k}, #{_h}"

            if _h.keys.size==1 && _h[_h.keys[0]].is_a?(Hash) && !_h[_h.keys[0]].has_key?('locator')
              Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " id(#{_id}) => #{_h}"
              _a = iterate(_h, "#{path}.#{_id}")
              _a.each do |_e|
                assertions << _e
              end
            elsif _h.keys.size==1 && _h[_h.keys[0]].is_a?(Hash) && _h[_h.keys[0]].has_key?('locator')
              assertions << { :path => "#{path}.#{_id}", :data => h[_h.keys[0]] }
            elsif _h.is_a?(Hash) && _h.has_key?('locator')
              assertions << { :path => "#{path}.#{_id}.#{_k}", :data => _h }
            else
              Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " | id(#{path}.#{_id}.#{_k}) - #{_h}"

              _h.each do |k, v|
#                Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " processing #{_id}.#{k}, #{v}"
                if v.is_a?(Hash) && v.has_key?('locator')
                  Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " processing #{_id}.#{_k}.#{k}"
                elsif v.is_a?(Hash) || v.is_a?(Array)
                  Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " processing #{_id}.#{k} - #{v}"
                  _a = iterate(v, "#{path}.#{_id}.#{k}")
                  _a.each do |_e|
                    assertions << _e
                  end
                else
                  Scoutui::Logger::LogMgr.instance.debug("Assert => k is #{k}, value is #{v}")
             #     assertions << "#{k} #{v}"
                  rc=rc && true
                end
              end

              Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " adding assertions id(#{_id}.#{_k}) - #{_h}"
              assertions << "id(#{_id}.#{_k}) - #{_h}"
            end

          }
          end



        else

          Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " ** process #{h} **"
          _list=Array.new
          h.each do |k, v|
            if v.is_a?(Hash) && v.has_key?('locator')

              Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " add to assertion #{k} => #{v}"
              _list.push({ :path => "#{path}.get(#{k})", :dat => v })

              Scoutui::Logger::LogMgr.instance.debug " _list ==> #{_list}"
            elsif v.is_a?(Hash) || v.is_a?(Array)

              # login_form => {"userid"=>{"locator"=>"#userid"}, "password"=>{"locator"=>"#pass"}}


              Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " >>>>  #{k} => #{v} <<<<<"


              _a = iterate(v, "#{path}.get(#{k})")
              _a.each do |_e|
                assertions << _e
              end
            else
              Scoutui::Logger::LogMgr.instance.debug(__FILE__ + (__LINE__).to_s + " k is #{k}, value is #{v}")
              assertions << "#{k} #{v}"
            end
          end

         # assertions << _list.flatten
          if !_list.empty?
            _list.each do |_e|
              assertions << _e
            end
          end

        end

      else
        Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " Huh?"
        assertions << nil
      end

      Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " assertions => #{assertions}"
      assertions

    end
loadPages(jlist) click to toggle source
# File lib/scoutui/appmodel/q_model.rb, line 27
def loadPages(jlist)

  json_list=[]
  if jlist.kind_of?(String)
    json_list << jlist
  else
    json_list=jlist
  end

  jsonData={}
  json_list.each  { |f|
    Scoutui::Logger::LogMgr.instance.debug __FILE__ + (__LINE__).to_s + " JSON.parse(#{f})"

    begin
      data_hash = JSON.parse File.read(f)
      jsonData.merge!(data_hash)
    rescue JSON::ParserError
      Scoutui::Logger::LogMgr.instance.fatal "raise JSON::ParseError - #{f.to_s}"
      raise "JSONLoadError"
    end

  }
  Scoutui::Logger::LogMgr.instance.debug "merged jsonData => " + jsonData.to_json
  @app_model = jsonData
end