framework_gem 0.1.0 → 0.2.0

data/lib/User_Lib/screen/mobile/ios/ios_login.rb

@@ -1,76 +0,0 @@
-require './lib/screen/mobile/ios/ios_screen'
-require './lib/screen/mobile/login_mobile'
-
-# Defines iOS-specific methods on the Login screen
-
-class IosLogin < IosScreen
-  include LoginMobile
-
-  # Public: Signs into the device.
-  #
-  # username - String username to use (default: nil). If default, value from configuration is used.
-  # password - String password to use (default: nil). If default, value from configuration is used.
-  #
-  # Returns a Boolean true if successfully signed in, otherwise false.
-  def sign_in?(args={})
-    loginfo2 'Signing in to iOS device'
-    username = args[:username] || dut.username
-    password = args[:password] || dut.password
-    return false unless dut.tap?({:name => 'X button', :timeout => 90.sec})
-    return false unless dut.tap?({:text => 'Username'})
-    return false unless dut.type?({:keys => username, :touch => false})
-    return false unless dut.tap?({:text => 'Password', :timeout => 0.sec})
-    return false unless dut.type?({:keys => password, :touch => false})
-    dut.tap?({:name => 'Sign In'})
-  end
-
-  def login?(args={})
-    loginfo2 'Logging in iOS device'
-    return false unless sign_in?(args)
-    #if dut.tap?({:name => 'CONTENT NOTIFICATION???', :timeout => 10.sec})
-    #  loginfo2('Dismissed content notification', false, true)
-    #end
-    if dut.tap?({:name => 'Agree', :timeout => 30.sec})
-      loginfo2('Agreed to Terms')
-    end
-    if dut.tap?({:description => 'OK', :timeout => 10.sec})
-      loginfo2('Dismissed Parental Controls notification')
-    end
-    true
-  end
-
-  # Public: Enters bad login credentials and attempts to sign in.
-  #
-  # username - String username to use (default: 'abc').
-  # password - String password to use (default: 'xyz').
-  #
-  # Returns a Boolean true if successfully signed in after entering bad credentials, otherwise false.
-  def enter_bad_login?(args={})
-    args[:username] ||= 'abc'
-    args[:password] ||= 'xyz'
-    loginfo2 'Entering bad login on iOS device'
-    sign_in?(args)
-  end
-
-  def is_login_invalid?
-    dut.element?({:text => 'Sign In Error', :timeout => 90.sec})
-  end
-
-  # Returns the text in the username field
-  def get_username(args={:timeout => 30.sec})
-    text = dut.element({:type => 'UIATextField', :timeout => args[:timeout]})[:text]
-    text.eql?('Username') ? '' : text
-  end
-
-  # Returns the text in the password field
-  def get_password
-    text = dut.element({:type => 'UIASecureTextField'})[:text]
-    text.eql?('Password') ? '' : text
-  end
-
-  # Returns true if the Sign In button is disabled
-  def cannot_sign_in?
-    dut.element?({:name => 'Sign In', :is_enabled => false})
-  end
-
-end

data/lib/User_Lib/screen/mobile/ios/ios_main_menu.rb

@@ -1,38 +0,0 @@
-require './lib/screen/mobile/ios/ios_screen'
-require './lib/screen/mobile/main_menu_mobile'
-
-# Defines iOS-specific methods on the Main Menu screen
-
-class IosMainMenu < IosScreen
-  include MainMenuMobile
-
-  # Chooses to navigate to the screen with the given name
-  def navigate_to?(name)
-    dut.tap?({:name => name, :many_elements => true})
-  end
-
-  # Override this one because iOS Main Menu is Live TV
-  def navigate_to_live_tv?
-    true
-  end
-
-  # Returns true if the main menu is displayed, otherwise false
-  def displayed?
-    # There is no Main Menu on iOS, so not sure what to look for here
-    false
-  end
-  
-  # Navigate back to main menu
-  def return_to_main_menu?
-  	back_press = 5
-	home = dut.element?({:name => 'Live'}) and dut.element?({:name => 'Guide'}) and dut.element?({:name => 'Settings'})
-	while !home and back_press > 0 do
-		tcfail 'No back button found' unless dut.tap?({:name => 'Back'})
-		home = dut.element?({:name => 'Live'}) and dut.element?({:name => 'Guide'}) and dut.element?({:name => 'Settings'})
-		back_press = back_press - 1
-	end
-	
-	return true
-  end
-
-end

data/lib/User_Lib/screen/mobile/ios/ios_on_demand.rb

@@ -1,371 +0,0 @@
-require './lib/screen/mobile/ios/ios_screen'
-require './lib/screen/mobile/on_demand_mobile'
-
-
-# Defines iOS-specific methods on the On Demand screen
-
-class IosOnDemand < IosScreen
-  include OnDemandMobile
-
-  # Returns true if the given category is found, otherwise false
-  def category?(category)
-    logger.info("Checking if category #{category.inspect} is visible")
-    dut.element?({:name => category, :type => 'UIACollectionCell', :is_visible => true, :many_elements => true})
-  end
-
-  # Returns true if successfully selected the given category, otherwise false
-  def select_category?(category)
-    logger.info("Selecting category #{category.inspect}")
-    dut.tap?({:name => category, :type => 'UIACollectionCell', :is_visible => true, :many_elements => true})
-  end
-
-  # Returns a list of the visible titles in list view as an array of strings
-  def get_visible_titles
-    logger.info('Getting visible titles')
-    year_regex = /^(19\d{2}|2\d{3})$/
-    titles = until_same(:timeout => 5.min) do
-      ts = dut.elements({:selector => 'UIATarget.localTarget().frontMostApp().windows()[0].tableViews()[0].visibleCells()',
-                         :min => 1, :info => [:name], :timeout => 5.min}) || []
-      bad_titles = ts.select { |title| title =~ year_regex }
-      logger.info("WARNING: rejecting bad titles: #{bad_titles.inspect}") unless bad_titles.empty?
-      ts.reject { |title| title =~ year_regex }
-    end
-    logger.info("Visible titles: #{titles.inspect}")
-    tcfail 'Some titles did not load!' if titles.count('Loading...') > 0
-    titles
-  end
-
-  # Returns a list of all titles in the current category
-  def get_all_titles(args={})
-    allow_empty = args.fetch(:allow_empty, true)
-    logger.info('Getting all titles')
-    titles = until_same(:allow_empty => allow_empty, :timeout => 30.min) do
-      if dut.is_tablet?
-        sel = 'UIATarget.localTarget().frontMostApp().windows()[0].tableViews()[0].cells()'
-        dut.elements({:selector => sel, :info => [:name]})
-      else
-        dut.elements({:type => 'UIATableCell', :info => [:name]})
-      end
-    end
-    total = titles.count
-    titles = titles.reject { |t| t == 'Loading...' }
-    logger.info("*** WARNING *** Found #{total - titles.count} loading titles") if titles.count < total
-    logger.info("Titles: #{titles.inspect}")
-    titles
-  end
-
-  # Returns a list of the visible assets in grid view as an array of strings
-  def get_visible_assets(args={})
-    logger.info('Getting visible assets')
-    # TODO: one of the parents is just a generic element, so this is probably going to break fast and often...
-    uia_element_index = dut.is_tablet? ? 6 : 5
-    elements = args.fetch(:elements, false)
-    assets = until_same(:timeout => 5.min) do
-      sel = "UIATarget.localTarget().frontMostApp().windows()[0].elements()[#{uia_element_index}].collectionViews()[0].visibleCells()"
-      dut.elements({:selector => sel, :is_on_screen => true, :min => 1, :info => [:x, :y, :width, :height], :timeout => 2.min})
-    end
-    logger.info("Visible assets: #{assets.map {|e| "x: #{e[:x]} y: #{e[:y]}" }.inspect}")
-    #tcfail 'Some assets did not load!' if assets.count('Loading...') > 0
-    elements ? assets : assets.map {|e| "x: #{e[:x]} y: #{e[:y]}" }  #TODO: map this to the name when available
-  end
-
-  # Returns a list of the Featured visible assets in grid view as an array of strings or, optionally, elements
-  def get_visible_featured_assets(args={})
-    category = args[:category]
-    msg = 'Getting visible Featured assets'
-    msg += " for category: #{category}" unless category.nil?
-    logger.info(msg)
-    # Get visible categories
-    categories = get_visible_categories(:elements => true)
-    tcfail 'Failed to locate any visible categories!' if categories.empty?
-    # Get only the assets that are within a visible category
-    assets = []
-    categories.each do |cat|
-      if category.nil? || (cat[:name].eql?(category))
-        res = dut.resolution
-        i = cat[:index] - 1  # use the index from the category search
-        # Normally we could use visibleCells() here, but for some reason none of the visible cells are have visible:true
-        selector = "UIATarget.localTarget().frontMostApp().windows()[0].tableViews()[0].visibleCells()[#{i}].collectionViews()[0].cells()"
-        elems = dut.elements({:selector => selector, :min => 1, :info => [:x, :y], :timeout => 5.min}) || []
-        # All elements that are on the visible part of the X axis (except at X:0) are actually visible
-        assets += elems.select { |e| e[:x] > 0 && e[:x] < res[:width] }
-      end
-    end
-    assets.map! { |asset| "x: #{asset[:x]} y: #{asset[:y]}" }  #TODO: map this to the name when available
-    logger.info("Visible assets: #{assets.inspect}")
-    #tcfail 'Some assets did not load!' if assets.count('Loading...') > 0
-    assets
-  end
-
-  # Returns a list of the visible networks as an array of strings
-  def get_visible_networks(args={})
-    logger.info('Getting visible networks')
-    visible_area = networks_scroll_area
-    elements = args.fetch(:elements, false)
-    elems = []
-    names = until_same(:timeout => 5.min) do
-      elems.clear
-      elems += dut.elements({:type => 'UIACollectionCell', :name => '', :is_visible => true, :min => 1,
-                             :info => [:x, :y, :width, :height], :timeout => 2.min}) | []
-      # Reject any not in the visible area
-      elems.reject! { |e| e[:y] < visible_area[:y] || (e[:y] + e[:height]) > (visible_area[:y] + visible_area[:height])}
-      elems.map { |e| "x: #{e[:x]} y: #{e[:y]}" }  #TODO: map this to the name when available
-    end
-    logger.info("Visible networks: #{names.inspect}")
-    #tcfail 'Some assets did not load!' if assets.count('Loading...') > 0
-    elements ? elems : names
-  end
-
-  def select_view_all?(n)
-    logger.info("Selecting View All ##{n}")
-    y_pct = n == 1 ? 0.95 : 0.05
-    dut.tap?({:name => 'VOD MajorCategory ViewAll Butt', :is_visible => true, :y => y_pct, :index => n})
-  end
-
-  # Returns the visible minor categories
-  def get_visible_categories(args={})
-    logger.info('Getting visible categories')
-    elements = args.fetch(:elements, false)
-    info = args.fetch(:info, []) + [:name, :y, :height]
-    res = dut.resolution
-    search_data = {:selector => 'UIATarget.localTarget().frontMostApp().windows()[0].tableViews()[0].visibleCells()',
-                   :min => 1, :info => info.uniq, :timeout => 5.min}
-    categories = []
-    names = []
-    last_names = nil
-    until names == last_names
-      last_names = names
-      categories = dut.elements(search_data).reject do |cat|
-        # Filter out any that are less than 75% visible
-        pct_visible = (cat[:y] < 0 ? -cat[:y] : res[:height] - cat[:y]).to_f / cat[:height]
-        if pct_visible < 0.75
-          logger.info("Rejected category ##{cat[:index]}: #{cat[:name]}")
-          true
-        else
-          false
-        end
-      end
-      names = categories.map { |c| c[:name] }
-    end
-    logger.info("Visible categories: #{names.inspect}")
-    elements ? categories : names
-  end
-
-  # Returns the number of visible View All buttons
-  def visible_view_all_count
-    logger.info('Getting visible View All count')
-    (dut.elements({:name => 'VOD MajorCategory ViewAll Butt', :is_visible => true, :many_elements => true, :min => 1}) || []).count
-  end
-
-  # Returns the scroll area for the given category
-  def category_scroll_area(category)
-    logger.info("Getting scroll area for category: #{category}")
-    cats = get_visible_categories(:elements => true)
-    tcfail 'Did not find any categories!' if cats.empty?
-    cat = cats.select { |c| c[:name].eql?(category) }.first
-    tcfail 'Failed to get category!' if cat.nil?
-    areas = dut.elements({:type => 'UIACollectionView', :is_visible => true, :min => 2, :timeout => 3.min}) || []
-    tcfail 'Did not find enough scroll areas!' if areas.count < 2
-    areas.shift  # the first one is the major category menu
-    # Return the one that is within the desired category's area
-    area = areas.select { |a| a[:y] > cat[:y] && a[:y] < (cat[:y] + cat[:height]) }.last
-    tcfail 'Failed to get scroll area!' if area.nil?
-    # Only the bottom x% for the top one and the top x% for the rest
-    new_height = area[:height] * 0.33
-    if cat == cats.first
-      area[:y] = area[:y] + (area[:height] - new_height)
-    end
-    area[:height] = new_height
-    logger.info("Got scroll area: [#{area[:x]}, #{area[:y]}, #{area[:width]}, #{area[:height]}]")
-    area
-  end
-
-  # Returns the time elapsed text as a string
-  def time_elapsed_text
-    logger.info('Getting time elapsed text')
-    dut.element({:name => 'regexp:^\d+:\d+$', :info => [:name], :timeout => 2.min})
-  end
-
-  # Taps the content window
-  def tap_content
-    logger.info('Tapping content window')
-    tcfail 'Failed to tap content!' unless dut.tap?({:type => 'UIAWindow', :index => 1})
-  end
-
-  # Returns true if successfully stopped playing asset, otherwise false
-  def stop?
-    logger.info('Stopping playback')
-    # Try to wait until the controls are invisible (unless set to persist)
-    dut.element({:name => 'Done', :is_visible => false, :timeout => 10.sec})
-    # Now get the Done option
-    done = dut.element({:name => 'Done', :info => [:is_visible, :x, :y, :width, :height]})
-    unless done[:is_visible]
-      tap_content
-    end
-    dut.tap?({:x => done[:x] + (done[:width] * 0.5), :y => done[:y] + (done[:height] * 0.5), :coordinates => true})
-  end
-
-  # Selects a random list asset and returns the title
-  def select_random_list_title
-    logger.info('Selecting a random list title')
-    # Scroll a random number of times
-    tcfail 'Failed to scroll!' unless scroll_down?((0..3), :area => list_scroll_area)
-    visible_titles = get_visible_titles
-    title = visible_titles[rand(visible_titles.count)]
-    y_pct = title == visible_titles.last ? 0.05 : 0.95
-    tcfail 'Failed to select asset!' unless dut.tap?({:name => title, :type => 'UIATableCell', :is_visible => true,
-                                                      :y => y_pct, :many_elements => true})
-    if is_pin_prompt?
-      tcfail 'Failed to enter PIN!' unless enter_pin?
-    end
-    logger.info("Selected list title: #{title}")
-    title
-  end
-
-  # Selects a random grid asset and returns the title
-  def select_random_grid_title
-    logger.info('Selecting a random grid title')
-    # Scroll a random number of times
-    tcfail 'Failed to scroll!' unless scroll_down?((0..3), :area => grid_scroll_area)
-    assets = get_visible_assets(:elements => true)
-    tcfail 'Found no visible assets!' if assets.count == 0
-    asset = assets[assets.count > 1 ? rand(assets.count) : 0]
-    x = asset[:x] + (asset[:width] * 0.5)
-    y_pct = asset[:y] > (dut.resolution[:height] * 0.5) ? 0.05 : 0.95  # 5% for bottom half of screen, else 95%
-    y = asset[:y] + (asset[:height] * y_pct)
-    tcfail 'Failed to select asset!' unless dut.tap?({:x => x, :y => y, :coordinates => true})
-    if is_pin_prompt?
-      tcfail 'Failed to enter PIN!' unless enter_pin?
-    end
-    title = dut.screens.product_page.title  # TODO: when available, get title before clicking
-    logger.info("Selected grid title: #{title}")
-    title
-  end
-
-  # Selects a random network and returns the title
-  def select_random_network
-    logger.info('Selecting a random network')
-    # Scroll a random number of times
-    tcfail 'Failed to scroll!' unless scroll_down?((0..3), :area => networks_scroll_area)
-    # Pick a random network
-    visible_networks = get_visible_networks(:elements => true)
-    network = visible_networks[rand(visible_networks.count)]
-    x = network[:x] + (network[:height] * 0.5)  # middle
-    y = network[:y] + (network[:width] * 0.5)  # middle
-    # Don't select the first or last 3 as they could be partially hidden
-    tcfail 'Failed to select network!' unless dut.tap?({:x => x, :y => y, :coordinates => true})
-    if is_pin_prompt?
-      tcfail 'Failed to enter PIN!' unless enter_pin?
-    end
-    title = dut.screens.product_page.title  # TODO: when available, get title before clicking
-    logger.info("Selected network: #{title}")
-    title
-  end
-
-  # Selects a random network sub-category and returns the title
-  def select_random_network_category
-    logger.info('Selecting a random network sub-category')
-    if dut.element?({:name => '#', :type => 'UIAStaticText'})
-      logger.info('No sub-categories found')
-      nil
-    else
-      title = select_random_list_title
-      logger.info("Selected sub-category: #{title}")
-      title
-    end
-  end
-
-  # Selects a random Featured asset, optionally from the given category, and returns the name
-  def select_random_featured_asset(args={})
-    category = args[:category]
-    logger.info('Selecting a random Featured asset')
-    if category.nil?
-      # Scroll a random number of times
-      tcfail 'Failed to scroll!' unless scroll_down?((0..3), :area => scroll_area)
-    end
-    # Get visible categories
-    categories = get_visible_categories(:elements => true)
-    categories = categories.select { |cat| cat[:name].eql?(category) } unless category.nil?
-    tcfail 'Failed to locate any visible categories!' if categories.empty?
-    # Select an asset from a random visible category
-    i = categories.count > 1 ? rand(categories.count) : 0
-    logger.info("Selecting a random asset from category: #{categories[i][:name]}")
-    # Normally we could use visibleCells() here, but for some reason the visible cells do not have visible:true
-    res = dut.resolution
-    selector = "UIATarget.localTarget().frontMostApp().windows()[0].tableViews()[0].visibleCells()[#{i}].collectionViews()[0].cells()"
-    assets = dut.elements({:selector => selector, :min => 1, :info => [:x, :y, :width, :height], :timeout => 5.min}) || []
-    # All elements that are on the visible part of the X axis (except at X:0) are actually visible
-    visible = assets.select { |a| a[:x] > 0 && a[:x] < res[:width] }
-    tcfail 'Failed to find any visible assets!' if visible.empty?
-    asset = visible[visible.count > 1 ? rand(visible.count) : 0]
-    x = asset[:x] + (asset[:width] * 0.05)  # left side
-    y = asset[:y] + (asset[:height] * (asset[:y] > res[:height] * 0.5 ? 0.05 : 0.95))  # top if on bottom half of screen
-    tcfail 'Failed to select asset!' unless dut.tap?({:x => x, :y => y, :coordinates => true})
-    if is_pin_prompt?
-      tcfail 'Failed to enter PIN!' unless enter_pin?
-    end
-    sleep(5.sec)
-    title = dut.screens.product_page.title  # TODO: when available, get title before clicking
-    logger.info("Selected featured asset: #{title}")
-    title
-  end
-
-  def current_category
-    logger.info('Getting current category')
-    cat = dut.element({:type => 'UIAStaticText', :index => 1, :info => [:name]})
-    logger.info("Current category: #{cat}")
-    cat
-  end
-
-  # Returns the list scroll area
-  def list_scroll_area
-    logger.info('Getting list scroll area')
-    scroll_area = dut.element({:type => 'UIATableView', :info => [:x, :y, :width, :height]})
-    tcfail 'Failed to find list scroll area!' if scroll_area.nil?
-    scroll_area
-  end
-
-  # Returns the grid scroll area
-  def grid_scroll_area
-    logger.info('Getting grid scroll area')
-    list_scroll_area
-  end
-
-  # Returns the networks scroll area
-  def networks_scroll_area
-    logger.info('Getting networks scroll area')
-    scroll_area = dut.element({:type => 'UIACollectionView', :index => 2, :timeout => 2.min})
-    tcfail 'Failed to find networks scroll area!' if scroll_area.nil?
-    scroll_area
-  end
-
-  # Returns the main scroll area
-  def scroll_area
-    logger.info('Getting main scroll area')
-    scroll_area = dut.element({:selector => 'UIATarget.localTarget().frontMostApp().windows()[0].tableViews()[0]'})
-    tcfail 'Failed to find scroll area!' if scroll_area.nil?
-    scroll_area
-  end
-
-  # Returns the name of the highlighted category
-  def highlighted_category
-    logger.info('Getting highlighted category')
-    cat = dut.element({:type => 'UIACollectionCell', :text => '1', :info => [:name]})
-    tcfail 'Failed to find highlighted category!' if cat.nil?
-    logger.info("Highlighted category: #{cat}")
-    cat
-  end
-
-  # Returns true if the alphabet picker is visible, otherwise false
-  def alphabet_picker_visible?
-    logger.info('Checking if alphabet picker is visible')
-    dut.element?({:name => '#', :type => 'UIAStaticText', :many_elements => true})
-  end
-
-  # Returns true if successfully picked the given letter from the alphabet picker, otherwise false
-  def pick_alphabet?(letter)
-    logger.info("Picking alphabet '#{letter}'")
-    dut.tap?({:name => letter, :type => 'UIAStaticText', :many_elements => true})
-  end
-
-end