framework_gem 0.1.0

data/lib/lib/platform/tivo/tivo_720/tivo_720.rb

@@ -0,0 +1,14 @@
+require './lib/platform/tivo/tivo'
+require './lib/rois/tivo/tivo_720/tivo_720_rois'
+
+# Adds to or modifies the Tivo platform with 720p-specific functionality.
+
+class Tivo720 < Tivo
+
+  # Public: Initializes an Tivo 720p device.
+  def initialize(*args)
+    super(*args)
+    @roi = Tivo720Rois.new(self)
+  end
+
+end

data/lib/lib/platform/web/web.rb

@@ -0,0 +1,51 @@
+require './lib/platform/platform'
+require './lib/selenium/webdriver/webdriver'
+
+# Web adds to or modifies a Platform Web-specific functionality
+
+class Web < Platform
+  include Webdriver
+
+  # Public: Initializes a Web device.
+  def initialize(browser, test_case)
+    super(test_case)
+    @browser = browser
+    @ready = false
+  end
+
+  # Public: Navigates to the specified screen or URL.
+  #
+  # url - String URL to navigate to.
+  #
+  # Returns a Boolean true if successfully navigated, otherwise false.
+  def navigate?(url)
+    unless @ready
+      unless self.init?(browser: @browser)
+        raise 'Failed to launch browser!'
+      end
+      @test_case.add_teardown('Closing browser') { self.close? }
+    end
+    super(url)
+  end
+
+  # Public: Initializes a Web device.
+  #
+  # browser    - Symbol name of browser to launch, can be :firefox, :chrome.
+  # sleep_time - Integer total milliseconds to sleep after establishing the session (default: 0).
+  #
+  # Returns a Boolean true if the device was initialized, otherwise false.
+  def init?(browser, sleep_time: 0.sec)
+    super() do
+      ret = selenium_post(nil, {:browser => browser})
+      if ret.nil?
+        @ready = false
+      else
+        @id = ret['id']
+        sleep(sleep_time)
+        @ready = true
+      end
+      @ready
+    end
+  end
+
+end

data/lib/lib/platform_libs/roku/roku_controller.rb

@@ -0,0 +1,254 @@
+require 'net/http'
+
+class RokuController
+
+  attr_accessor(:host, :port)
+
+  @@keyport = 8060
+  @@keyDelayInMs = 0.600
+
+  def initialize(args={})
+    # PLEASE DO NOT MODIFY BELOW LINE.
+    @host = args.fetch(:host, nil)
+    @port = args.fetch(:port, 8888)
+    @basepath = '/twctvweb/status/activewindow/'
+    @dut = args[:dut]
+  end
+
+  def initComm(host, port)
+    initialize(:host => host, :port => port)
+  end
+
+
+
+  # Public: intended to type characters on the on screen keyboard
+  #
+  # word - the string to be typed (username or password)
+  def type_string(word)
+    word.each_char do |c|
+      value = "Lit_" + c
+      send_native_key(value)
+    end
+    i = 0
+    while (i < 4)
+      send_key("Down")
+      i = i + 1
+    end
+    send_key("Select")
+  end
+
+  # Public: intended to clear the login screen
+  #
+  # count - number of times to hit the backspace key
+  def clear_string(count)
+    i = 0
+    while (i < count)
+      send_native_key("Backspace")
+      i = i + 1
+    end
+  end
+
+  # Public: send a key directly to the OS
+  # - this can be used instead of navigating the on screen keyboard.
+  #   - different from send_key because the entire keyboard is supported
+  #
+  # value - the number or letter to be sent
+  #
+  def send_native_key(value)
+    http = Net::HTTP.new(@host, @@keyport)
+    http.open_timeout = 2
+    p_key = "/keypress/" + value
+    begin
+      puts "sending " + p_key
+      http.request_post(p_key, "")
+      sleep(@@keyDelayInMs)
+    rescue Timeout::Error
+      puts "Timeout sending " + p_key
+    end
+  end
+
+
+  # Public: send a key directly to the OS
+  #   - different from send_native_key because the entire keyboard is not supported
+  #
+  # key - the remote control key to be sent
+  def send_key(key)
+    http = Net::HTTP.new(@host, @@keyport)
+    http.open_timeout = 2
+
+    begin
+      case key
+        when "Back", "Select", "Up", "Down", "Left", "Right"
+          pkey = "/keypress/" + key
+          puts "Sending " + pkey
+          http.request_post(pkey, "")
+        else
+          pkey = "/keydown/" + key
+          puts "Sending " + pkey
+          http.request_post(pkey, "")
+          sleep(0.1)
+          pkey = "/keyup/" + key
+          http.request_post(pkey, "")
+      end
+      sleep(@@keyDelayInMs)
+    rescue Timeout::Error
+      puts "Timeout sending " + key
+    end
+  end
+
+
+  # Deprecated: fetch the json associated with the element_name
+  #   - does not provide error processing
+  #
+  # element_name - the name of the element to be retrieved
+  def get_text(element_name)
+    puts "\ngetText " + element_name
+    uri = URI(element_name)
+    s = Net::HTTP.get(uri)
+    return s
+  end
+
+
+  # Public: fetches the json text associated with the element_name
+  #   - only waits until timeout
+  #
+  # element_name - the name of the element to be retrieved
+  # timeout - the amount of time to wait in secs
+  def get_text_t(element_name, timeout)
+    path = @basepath + element_name
+    puts "\nget_text_t" + path + ", timeout = " + timeout.to_s
+
+    http = Net::HTTP.new( @host, @port)
+    http.open_timeout = 2
+    http.read_timeout = timeout
+
+    s = nil
+    begin
+      http.start
+      begin
+        http.request_get( path) do |res|
+          s = res.read_body
+        end
+      rescue Timeout::ERROR
+        puts "Timeout reading "
+      end
+    rescue Timeout::Error
+      puts "Timeout connecting "
+    rescue
+      puts "Other network error"
+    end
+    return s
+  end
+
+
+  def get_boolean?(element_name, timeout)
+    s = get_text_t(element_name, timeout)
+    @r = false
+    if (s == "true")
+      @r = true
+    end
+    return @r
+  end
+
+
+  # Public:  waits for an element to be displayed
+  #   - a valid http transaction occurs with no data, here we wait for data requested
+  #
+  #
+  # element_name - the name of the element to be retrieved
+  # timeout - the amount of time to wait in secs
+  def wait_for_element_visible(element_name, timeout)
+    untilTime = Time.now.to_i + timeout
+
+    while (true) do
+      json = get_text_t(element_name, 1)
+      puts json
+      if json == nil
+        return nil
+      end
+      if json != "{}"
+        return json
+      end
+      now = Time.now.to_i
+      if now > untilTime
+        return nil
+      end
+      sleep(1)
+    end
+  end
+
+  # Public: checks to see if an element exists
+  #   - returns immediately
+  #
+  #
+  # element_name - the name of the element to be retrieved
+  def is_visible(element_name)
+    s = get_text_t(element_name,0.3)
+    if (s == nil  || s == "{}")
+      return false
+    else
+      return true
+    end
+  end
+
+  # Public: launch application
+  #   - Id, version and appkeyword details needed for app launch
+  #
+  # version - application version to launch
+  # Id - target application Id {get it from ./query/apps}
+  # appkeyword - application search keyword
+  # Example : app_version='4.2.1', app_Id='dev', app_keyword='Spectrum'
+  def launch_app(app_keyword, app_version, app_Id)
+    http = Net::HTTP.new(@host, @@keyport)
+    http.open_timeout = 2
+
+    begin
+      unless app_version == "" and app_Id == "" and app_keyword ==""
+          launch_tag = "/launch/" + app_Id + "?"+ "version=" + app_version + "&keyword=" + app_keyword
+          puts "Launching " + launch_tag
+          http.request_post(launch_tag, "")
+          sleep(1.0)
+        else
+          puts "Invalid App launch request... "
+      end
+      sleep(@@keyDelayInMs)
+    rescue Timeout::Error
+      puts "Timeout launching app " + app_keyword
+    end
+  end
+  
+  # Public: checks to see if an element exists and if the value is true
+  #   - returns immediately
+  #
+  # element_name - the name of the element to be retrieved
+  def is_true(element_name)
+    s = get_text_t(element_name,0.3)
+    if (s == nil  or  s == "{}")
+      return false
+    else
+      puts "evaluating " + s
+      if s == "true"
+        return true
+      else
+        return false
+      end
+    end
+  end
+
+  # Public: retrieves the visit id used to fetch analytics records from Venona
+  #
+  #
+  def get_visit_id
+    return get_text_t("venona/visitid", 5)
+  end
+
+=begin  
+  private
+
+  
+  def logger
+    @dut.test_case.logger
+  end
+=end  
+
+end

data/lib/lib/prereqs/prereqs.rb

@@ -0,0 +1,17 @@
+require 'delegate'
+
+# The Prereqs class is a delegator which passes any methods it does not define--such as `dut' and `logger'--through to
+# the Test Case instance.
+
+class Prereqs < SimpleDelegator
+
+  # Public: Initializes Prereqs. NOT FOR USE IN TESTS.
+  #
+  # test_case - TestCase (or subclass) instance for these prereqs.
+  #
+  # Returns nothing.
+  def initialize(test_case)
+    super(test_case)
+  end
+
+end

data/lib/lib/prereqs/prereqs_for_dut.rb

@@ -0,0 +1,14 @@
+require './lib/prereqs/prereqs'
+
+# The PrereqsForDut class stores all DUT prerequisites.
+
+class PrereqsForDut < Prereqs
+
+  # Public: Checks if the dut is 1080p.
+  #
+  # Returns true if the dut was 1080p, otherwise false.
+  def SAMPLE
+    dut.height == 1080
+  end
+
+end

data/lib/lib/prereqs/prereqs_for_test.rb

@@ -0,0 +1,14 @@
+require './lib/prereqs/prereqs'
+
+# The PrereqsForTest class stores all test prerequisites.
+
+class PrereqsForTest < Prereqs
+
+  # Public: Checks if the back office server can be reached.
+  #
+  # Returns true if the back office server was reached, otherwise false.
+  def SAMPLE
+    ping?('8.8.8.8')
+  end
+
+end

data/lib/lib/remotes/remotes.rb

@@ -0,0 +1,8 @@
+
+# The Remotes class enumerates remotes common to all platforms.
+
+class Remotes
+
+  # No remotes are common to all platforms
+
+end

data/lib/lib/remotes/stb/spectrum/spectrum_remotes.rb

@@ -0,0 +1,22 @@
+
+# The SpectrumRemotes class enumerates remotes common to all Spectrum STBs.
+
+class SpectrumRemotes
+
+  def CHARTER
+    'charter_generic'
+  end
+
+  def CHARTER_WORLD_BOX
+    'charter_wb'
+  end
+
+  def SPECTRUM
+    'spectrum'
+  end
+
+  def SPECTRUM_CISCO
+    'spectrum_cisco'
+  end
+
+end

data/lib/lib/roi/black/black_roi.rb

@@ -0,0 +1,125 @@
+require './lib/roi/roi'
+require './lib/mixins/can_have_special_methods'
+
+# The BlackRoi class defines a black Roi and its methods
+
+class BlackRoi < Roi
+  include CanHaveSpecialMethods
+
+  attr_accessor(:blackness)
+
+  # Public: Initializes a black Roi.
+  #
+  # dut        - Platform (or subclass) instance to which this Roi belongs.
+  # x          - Integer x coordinate (default: nil).
+  # y          - Integer y coordinate (default: nil).
+  # width      - Integer width (default: nil).
+  # height     - Integer height (default: nil).
+  # rectangle  - Hash defining rectangle with keys :x, :y, :width, :height (default: nil).
+  # element    - Hash same as rectangle (default: nil).
+  # blackness  - Integer blackness percent 0 - 100 (default: 80).
+  # ref_img    - String path to reference image (default: nil).
+  #
+  # Returns nothing.
+  def initialize(dut, args={})
+    super(dut, args)
+    @blackness = args.fetch(:blackness, 80)
+    @similarity = @blackness
+    @dsl_black_roi = nil
+    @max_lvl = 255.0
+  end
+
+  # Public: Gets the blackness level.
+  #
+  # Returns the Integer blackness level (0 - 255).
+  def level
+    lvl = @max_lvl - ((@blackness / 100.0) * @max_lvl)
+    ret = lvl.to_i
+    ret += 1 if lvl > ret  # always round up
+    ret
+  end
+
+  # Public: Gets black Roi info.
+  #
+  # Returns a tidy String with black Roi info.
+  def info
+    "#{super} Blackness=#{@blackness}"
+  end
+
+  # Public: Checks if screen exceeds the black threshold as defined in the given ROI.
+  #         Corresponds to: api_is_screen_black?
+  #
+  # key          - String name of key to press to trigger evaluation (default: nil).
+  #                If default, no keys will be pressed.
+  # delay        - Integer total milliseconds to delay before starting evaluation (default: 0).
+  # timeout      - Integer total milliseconds to allow before timing out (default: 0).
+  # verifies_for - Integer total milliseconds for which the ROI must verify in order to succeed (default: 0).
+  #                If default, the ROI must only verify once.
+  # priority     - Symbol representing evaluation priority used to throttle CPU usage (default: :normal):
+  #                :critical   - Sleep 10 milliseconds between intensive tasks (should be used sparingly).
+  #                :high       - Sleep 100 milliseconds between intensive tasks.
+  #                :normal     - Sleep 1 second between intensive tasks (default).
+  #                :low        - Sleep 10 seconds between intensive tasks.
+  #                :background - Sleep 1 minute between intensive tasks (should be used sparingly).
+  # log_every    - Integer interval in milliseconds between logs (default: 1000).
+  #
+  # Returns a Boolean true if the screen is black before the timeout, otherwise false.
+  def displayed?(args={})
+    logger.info('Checking if black is displayed')
+    frame = args[:frame]
+    verify(args) do
+      if frame.nil?
+        # Check blackness on the screen
+        json = get_json_for_match
+        result = test_case.send(:tmc_post, "/api/roi/black/actions/#{dut.slot}", json: json)['value']
+        logger.roi(self, args.merge(message: "Screen is#{result ? '' : ' not'} at least #{blackness}% black",
+                                    use_last_image: true))
+      else
+        # Check blackness in the frame
+        json = get_json_for_match(frame: frame)
+        result = test_case.send(:tmc_post, '/api/roi/black/actions', json: json)['value']
+        logger.roi(self, args.merge(message: "Frame is#{result ? '' : ' not'} at least #{blackness}% black",
+                                    screenshot: false))
+      end
+      result
+    end
+  end
+  special_method(:displayed?)
+
+  # Public: Gets the blackness of the region defined in the Roi.
+  #
+  # Returns the Integer blackness level (0 - 255) of the Roi region.
+  def retrieve(args={})
+    logger.info('Retrieving blackness')
+    frame = args[:frame]
+    value(args) do
+      if frame.nil?
+        # Get blackness from the screen
+        json = get_json_for_get
+        lvl = test_case.send(:tmc_post, "/api/roi/black/actions/#{dut.slot}", json: json)['value']
+      else
+        # Get blackness from the frame
+        json = get_json_for_get(frame: frame)
+        lvl = test_case.send(:tmc_post, '/api/roi/black/actions', json: json)['value']
+      end
+      blk = level2blackness(lvl)
+      logger.roi(self, args.merge(message: "Retrieved blackness: #{blk}%", use_last_image: frame.nil?,
+                                  screenshot: frame.nil?))
+      blk
+    end
+  end
+  special_method(:retrieve)
+
+  private
+
+  # Internal: Returns the ROI as a hash.
+  def to_json(ref_img: nil)
+    super(ref_img: ref_img).merge(threshold: level)
+  end
+
+  # Internal: Converts level to blackness.
+  def level2blackness(lvl)
+    (((@max_lvl - lvl) / @max_lvl) * 100).round
+  end
+
+end