framework_gem 0.1.0

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

@@ -0,0 +1,76 @@
+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

@@ -0,0 +1,38 @@
+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

@@ -0,0 +1,371 @@
+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