framework_gem 0.1.0

data/lib/lib/test_wrapper.rb

@@ -0,0 +1,146 @@
+require './lib/extensions/extensions'
+require './lib/helpers/tmc_helpers/http_helper/http_helper'
+require 'resolv'
+
+# This is the test wrapper, responsible for running tests and reporting iterations.
+class TestWrapper
+  include HttpHelper
+
+  def initialize(args)
+    @args = {}
+    # Parse raw arguments in format NAME=VALUE.
+    args.each do |arg|
+      parts = arg.split('=', 2)
+      @args[parts.first] = parts.last
+    end
+  end
+
+  # Public: Runs a test.
+  #
+  # Returns nothing.
+  def run_test
+    # Fetch arguments
+    path = fetch_required_arg('path')
+    id = fetch_required_arg('id') {|d| d.to_i}
+    job = fetch_required_arg('job')
+    workspace = fetch_optional_arg('workspace')
+    devices = fetch_optional_arg('devices', default: []) {|d| d.split(',').map {|d| d.to_i}}
+    iteration = fetch_optional_arg('iteration', default: 1) {|d| d.to_i}
+    host = fetch_optional_arg('host', default: get_default_host)
+    log = fetch_optional_arg('log')
+    level = fetch_optional_arg('level', default: 'info')
+    auth = fetch_optional_arg('auth')
+    data = fetch_optional_arg('data')
+    unless data.nil?
+      puts 'Developer mode enabled'
+      job = 0
+    end
+    # Load the test and discover the test class, which should be the only subclass of TestCase
+    require './lib/test_case/functional_test_case'
+    require './lib/test_case/performance_test_case'
+    require File.join('.', 'test_cases', path)
+    all_test_cls = ObjectSpace.each_object(Class)
+    test_cls = all_test_cls.find {|c| c < FunctionalTestCase || c < PerformanceTestCase}
+    # Run the test
+    obj = test_cls.new(id, devices, iteration, host, job, log, level, data: data, auth: auth, workspace: workspace)
+    obj.send(:perform)
+  end
+
+  # Public: Ends an iteration.
+  #
+  # Returns nothing.
+  def end_iteration
+    # Fetch arguments
+    job = fetch_required_arg('job')
+    iteration = fetch_required_arg('iteration') {|d| d.to_i}
+    host = fetch_optional_arg('host', default: get_default_host)
+    resume = fetch_optional_arg('resume', default: false) {|r| r.downcase == 'true'}
+    test_data_url = "http://#{host}/api/jobs/#{job}/data"
+    test_data = nil
+    begin
+      resp = web_request(:get, test_data_url)
+      raise resp.body unless resp.code.to_s == '200'
+      test_data = resp.json['testData']
+    rescue Exception => e
+      puts "Failed to fetch test data:\n#{e.message}\n\t#{e.backtrace.join("\n\t")}"
+    end
+    return unless test_data.is_a?(Hash)
+    sword_data = resume ? nil : test_data['sword_data']  # TMC-5391: don't notify SWORD on RESUME
+    unless sword_data.nil?
+      # Notify SWORD that the iteration ended
+      begin
+        params = {test_plan_result_id: sword_data.fetch('test_plan_result_id')}
+        url = "https://#{sword_data.fetch('report_ip')}/test_plan_results/tmc_dsl_end_plan?"
+        url = url.concat(params.collect { |k,v| "#{k}=#{URI::escape(v.to_s)}" }.join('&'))
+        puts "Reporting to legacy end of plan URL: #{url}"
+        resp = web_request(:get, url)
+        raise resp.body unless resp.code.to_s == '200'
+      rescue Exception => e
+        puts "Failed to send results to Sword:\n#{e.message}\n\t#{e.backtrace.join("\n\t")}"
+      end
+    end
+  end
+
+  private
+
+  # Internal: Fetches a required argument.
+  #
+  # name  - String argument name.
+  # block - Block to convert the value (default: no conversion).
+  #
+  # Returns the Object value of the argument.
+  # Raises an ArgumentError if the argument is missing or on failure to convert the argument.
+  def fetch_required_arg(name, &block)
+    parse_args if @args.nil?
+    val = @args[name]
+    if block_given?
+      convert_arg(name, val, &block)
+    elsif val.nil?
+      raise ArgumentError.new("Missing required argument: #{name}")
+    else
+      val
+    end
+  end
+
+  # Internal: Gets default host name/address.
+  def get_default_host
+    local_ip = '127.0.0.1'
+    resolv = Resolv.new([Resolv::Hosts.new])  # look only at the local hosts file
+    # Return the last name that is not 'localhost' or the default local IP
+    resolv.getnames(local_ip).reject {|n| n == 'localhost'}.last || local_ip
+  end
+
+  # Internal: Fetches an optional argument from the environment.
+  #
+  # name    - String argument name.
+  # block   - Block to convert the value (default: no conversion).
+  # default - Object default value (default: nil).
+  #
+  # Returns the Object value of the argument.
+  # Raises an ArgumentError on failure to convert the argument.
+  def fetch_optional_arg(name, default: nil, &block)
+    parse_args if @args.nil?
+    val = @args.fetch(name, default)
+    if block_given? && val != default
+      convert_arg(name, val, &block)
+    else
+      val
+    end
+  end
+
+  # Internal: Converts the specified argument.
+  #
+  # name    - String argument name.
+  # value   - Object argument value.
+  # block   - Block to convert the argument.
+  #
+  # Returns the Object value of the converted argument.
+  # Raises an ArgumentError on failure to convert the argument.
+  def convert_arg(name, value, &block)
+    begin
+      return block.call(value)
+    rescue
+      raise ArgumentError.new("Bad value for argument: #{name}")
+    end
+  end
+end

data/lib/misc/get_latest_android.sh

@@ -0,0 +1,14 @@
+#!/bin/bash
+url=http://harry.corp.mystrotv.com/jenkins/view/Android%20Jobs/view/TWCTV/job/Android-TWCTV-Daily-Build/lastSuccessfulBuild/artifact/UserInterface/build/outputs/apk/
+
+src=`wget -O - ${url}`
+remote_latest=`echo ${src} | egrep -o "TWC.*?\.apk" | head -2 | tail -1`
+echo "remote latest: $remote_latest"
+local_latest=`ls -l latest.apk 2> /dev/null | egrep -o "TWC.*?$" || echo "TWCNoBuild"`
+echo "local latest: $local_latest"
+if [ "$local_latest" != "$remote_latest" ]; then
+  echo "downloading remote latest..."
+  wget "${url}${remote_latest}" && rm -f latest.apk && ln -s ${remote_latest} latest.apk
+  echo "new local latest: $remote_latest"
+fi
+echo "done."

data/lib/misc/get_latest_ios.sh

@@ -0,0 +1,14 @@
+#!/bin/bash
+url="http://harry.corp.mystrotv.com/jenkins/view/iOS%20Jobs/view/TWC%20TV/job/TWCTVDev-Appium-QA/lastSuccessfulBuild/artifact/TWCTV/build/Debug-iphoneos/"
+
+src=`wget -O - ${url}`
+remote_latest=`echo ${src} | egrep -o "TWC.*?ipa" | tail -1`
+echo "remote latest: $remote_latest"
+local_latest=`ls -l latest.ipa 2> /dev/null | egrep -o "TWC.*?$" || echo "TWCNoBuild"`
+echo "local latest: $local_latest"
+if [ "$local_latest" != "$remote_latest" ]; then
+  echo "downloading remote latest..."
+  wget "${url}${remote_latest}" && rm -f latest.zip && ln -s ${remote_latest} latest.ipa
+  echo "new local latest: $remote_latest"
+fi
+echo "done."

data/lib/package-lock.json

@@ -0,0 +1,3 @@
+{
+  "lockfileVersion": 1
+}

data/lib/run_test.rb

@@ -0,0 +1,4 @@
+require './lib/test_wrapper.rb'
+
+# Pass arguments to wrapper and run test
+TestWrapper.new(ARGV).run_test

data/lib/script_validator.rb

@@ -0,0 +1,48 @@
+########################v#######################
+# DEPRECATED, SEE tools/syntax_checker.rb
+################################################
+
+class ScriptValidator
+
+  # Public: Validate the specified script.
+  #
+  # path - String path to script to validate.
+  #
+  # Returns nothing.
+  # Raises an exception if script validation failed.
+  def validate(path)
+    require './lib/test_case/test_case.rb'
+    require './lib/test_case/functional_test_case.rb'
+    require './lib/test_case/performance_test_case.rb'
+    allowed_constants = Module.constants
+    allowed_methods = (Module.public_methods + Module.private_methods + Module.methods).uniq
+    # Require the script and then check new methods and constants
+    begin
+      load path
+      (Module.public_methods + Module.private_methods + Module.methods).uniq.each do |m|
+        raise "Script file defines illegal method: #{m}" unless allowed_methods.include?(m)
+      end
+      tests_defined = 0
+      Module.constants.reject {|c| allowed_constants.include?(c)}.each do |c|
+        cls = Module.const_get(c)
+        # Only allow new subclasses of Functional or Performance TestCase
+        raise "Script file defines illegal constant: #{c}" unless cls.is_a?(Class)
+        raise "Script class #{c} is not a test case" unless cls < FunctionalTestCase || cls < PerformanceTestCase
+        tests_defined += 1
+        allowed_script_constants = TestCase.constants
+        cls.constants.each do |tc|
+          raise "Test class defines illegal constant: #{tc}" unless allowed_script_constants.include?(tc)
+        end
+        raise "`run' method not defined in test class" unless cls.instance_methods(false).include?(:run)
+      end
+      raise 'Test class not defined in script file' if tests_defined == 0
+      raise 'Multiple test classes defined in script file' if tests_defined > 1
+    rescue Exception => e
+      STDERR.puts e.message
+      exit(1)
+    end
+  end
+
+end
+
+ScriptValidator.new.validate(ARGV.first)

data/lib/syntax_eval.rb

@@ -0,0 +1,151 @@
+# The SyntaxEval class is used to get syntax completion options for a given library/class and code snippet.
+# To test this class, navigate to the directory containing `dsllib' and run the following:
+#   c:\Jruby\bin\jruby.exe dsllib\test_libraries\platform\mobile\ios\ios_phone\ios_phone.rb IosPhone dut.
+#
+# To debug, enable the DEBUG flag below. Otherwise, STDERR and STDOUT are suppressed. *****
+
+require 'set'
+require 'delegate'
+require 'stringio'
+
+DEBUG = false
+# Not sure where these come from, but they are also base methods
+ADDL_METHODS = [:to_i, :to_f, :&, :|, :^]
+
+class SyntaxEval
+
+  # Public: Get elapsed time.
+  def print_elapsed
+    return unless DEBUG
+    puts "ELAPSED TIME: #{Time.now - @start_time}"
+  end
+
+  # Public: Get and print syntax completions
+  def print_completion(args)
+    for_class = []
+    for_base = []
+    special = []
+    if DEBUG
+      @start_time = Time.now
+    else
+      stdout, stderr = [$stdout, $stderr] # get handle to STDOUT and STDERR
+      $stdout = StringIO.new              # suppress STDOUT
+      $stderr = StringIO.new              # suppress STDERR
+    end
+    begin
+      case args.size
+        when 2
+          ctx = args[0]                               # code for context object, i.e. "10"
+          code = args[1]                              # code to evaluate, i.e. ".times"
+          type = :native
+        when 3
+          require args[0]                             # library path, i.e. "dsllib\test_libraries\platform\platform.rb"
+          ctx = self.class.const_get(args[1].to_sym)  # actual class name for context object, i.e. "Platform"
+          code = args[2] || ''                        # code to evaluate, i.e. ".screens"
+          type = :tmc
+        else
+          raise 'Invalid number of arguments for syntax evaluation!'
+      end
+      if DEBUG
+        puts "CONTEXT: #{ctx}"
+        puts "CODE: #{code}"
+        puts "TYPE: #{type}"
+      end
+      print_elapsed
+      case type
+        when :native
+          obj = eval(ctx)
+          if DEBUG
+            puts "NATIVE OBJECT: #{obj.inspect}"
+          end
+        when :tmc
+          obj = nil
+          if code.empty?
+            # Just get public methods for the class if no code is given
+            obj = ctx
+          else
+            # Evaluate the code in the context of a new instance of the class
+            oargs = []
+            while obj.nil?
+              begin
+                # Try to init the class
+                obj = ctx.new(*oargs)
+              rescue ArgumentError
+                # Keep adding nil parameters until we don't get an ArgumentError
+                oargs << nil
+              end
+            end
+          end
+          if DEBUG
+            puts "TMC OBJECT: #{obj.inspect}"
+          end
+        else
+          raise 'Invalid type!'
+      end
+      print_elapsed
+      # Send the code to our new instance of the class to get the object for which we need syntax
+      code.split('.')[1..-1].each do |m|
+        begin
+          if DEBUG
+            puts "SENDING TO OBJECT: #{m.to_sym.inspect}"
+          end
+          obj = obj.send(m)
+          if DEBUG
+            puts "OBJECT NOW: #{obj.inspect}"
+          end
+        rescue NoMethodError => e
+          if DEBUG
+            puts "USING NIL OBJECT BECAUSE: #{e.message}\n\t#{e.backtrace.join("\n\t")}"
+          end
+          obj = nil
+          break
+        rescue Exception => e
+          if DEBUG
+            puts "USING GENERIC OBJECT BECAUSE: #{e.message}\n\t#{e.backtrace.join("\n\t")}"
+          end
+          obj = Object.new
+          break
+        end
+      end
+      print_elapsed
+      unless obj.nil?
+        # Get the object's base methods
+        if obj.is_a?(SimpleDelegator)
+          for_base = SimpleDelegator.new(Object).public_methods
+        else
+          for_base = Object.new.public_methods
+        end
+        for_base = (for_base + ADDL_METHODS).uniq
+        # Get the object's instance methods
+        for_class = Set.new(obj.public_methods).difference(for_base).to_a
+        # Get rid of duplicate camelcase functions if Java object
+        for_class.reject! {|m| m.to_s =~ /[A-Z]/} if obj.inspect.include?('Java:')
+        # Get any special methods
+        special = obj.respond_to?(:special_methods, true) ? obj.send(:special_methods) : []
+      end
+    rescue => e
+      stderr.write(e.message)
+      exit 1
+    ensure
+      unless DEBUG
+        $stdout = stdout  # restore STDOUT
+        $stderr = stderr  # restore STDERR
+      end
+      # Print the results. The TMC server expects this format; PLEASE DO NOT CHANGE IT.
+      if DEBUG
+        puts 'CLASS NAME:'
+      end
+      puts ">#{obj.class.name}"
+      if DEBUG
+        puts 'METHODS FOR CLASS/BASE/SPECIAL:'
+      end
+      [for_class, for_base, special].each do |methods|
+        puts ">#{methods.join(',')}"
+      end
+      print_elapsed
+    end
+  end
+
+end
+
+SyntaxEval.new.print_completion(ARGV)

data/lib/tools/convert_old_scripts.rb

@@ -0,0 +1,100 @@
+DRY_RUN = false  # set 'true' to test (files will not be changed)
+WORD_REGEX = '[A-Za-z0-9_#]'
+CONVERSIONS = {
+    # ORDER IS IMPORTANT HERE
+    /(?<!#{WORD_REGEX})require\s*["']\.?\/?dsllib[^"']+performance_test_case\s*["']/ => "require './lib/test_case/performance_test_case'",
+    /(?<!#{WORD_REGEX})require\s*["']\.?\/?dsllib[^"']+functional_test_case\s*["']/ => "require './lib/test_case/functional_test_case'",
+    /(^\s*(?:before_test|set_log_test_name|tcstart|process_status|after_test)[^\r\n]*$)/ => '',
+    /\$options(?=[\[\s\.])/ => 'test_data',
+    /(?<!#{WORD_REGEX})(?:fetch_option|fetch_string)(?=[\s\(])/ => 'test_data.fetch',
+    /(?<!#{WORD_REGEX})tcfail(?=[\s\(])/ => 'fail',
+    /(?<!#{WORD_REGEX})tc(?:invalid|unsupported)(?=[\s\(])/ => 'error',
+    /(?<!#{WORD_REGEX})(loginfo[2-4])\s*\(?\s*(['"])[^\1]*?(?<!\\)\2\s*(?!,)/ => 'logger.info',                     # with no params. DO NOT COMBINE
+    /(?<!#{WORD_REGEX})(loginfo|logoptimized|logpartial)\s*\(?\s*(['"])[^\1]*?(?<!\\)\2\s*(?!,)/ => 'logger.info',  # with no params
+    /(?<!#{WORD_REGEX})(logdebug)\s*\(?\s*(['"])[^\1]*?(?<!\\)\2\s*(?!,)/ => 'logger.debug',                        # with no params
+    /(?<!#{WORD_REGEX})(api_press_key\s*\(?\s*(['"])([^\1]*?)(?<!\\)\2\s*,\s*(?:sleep_time\s*=)?\s*([^\s\r\n\)\}]+))[\s\r\n\)\}]/ => nil,
+}
+
+def read_file(file)
+  File.open(file, 'r') { |f| f.read }
+end
+
+def write_file(file, text)
+  File.open(file, 'w') { |f| f.write(text) }
+end
+
+def convert_code?(file)
+  new_file = file.end_with?('.tmc') ? file.sub(/\.tmc$/, '.rb') : nil
+  puts "\nCONVERTING: #{file}#{new_file.nil? ? '' : " => #{new_file}"}"
+  content = "\n" + read_file(file)
+  converted = content.dup.gsub("\t", '  ')
+  # convert DSL test to OO
+  dsl = content.match(/begin((?:\r|\n|.)*(process_status|after_test)(?:\r|\n|.)*)rescue StandardError(?:\r|\n|.)*$/)
+  unless dsl.nil?
+    type = dsl[2] == 'process_status' ? 'Functional' : 'Performance'
+    req = "require './lib/test_case/#{type.downcase}_test_case.rb'"
+    cls = "class Test < #{type}TestCase"
+    converted.sub!(dsl[0], "#{req}\n\n#{cls}\n\n  def run#{dsl[1]}  end\nend")
+  end
+  # do conversions
+  CONVERSIONS.each do |regex, replacement|
+    content.scan(regex).uniq.each do |r|
+      if r.is_a?(Array)
+        if r[0].start_with?('api_press_key')
+          replacement = "dut.press_key('#{r[2]}', sleep_time: #{r[3]})"
+        end
+        r = r.first
+      end
+      puts "#{r} => #{replacement}"
+      converted.gsub!(r, replacement)
+    end
+  end
+  # replace any remaining requires
+  content.scan(/(?<!#{WORD_REGEX})require\s*["']\.?\/?dsllib[^"']+["']/).uniq.each do |r|
+    replacement = '#' + r
+    puts "#{r} => #{replacement}"
+    converted.gsub!(r, replacement)
+  end
+
+  if content != converted
+    # save file, eliminating .tmc extensions
+    write_file(file, converted) unless DRY_RUN
+    unless new_file.nil?
+      File.rename(file, new_file) unless DRY_RUN
+    end
+    true
+  else
+    false
+  end
+end
+
+# enumerate files to convert
+if ARGV.empty?
+  tests = Dir.glob('./test_cases/**/*.rb') + Dir.glob('./test_cases/**/*.tmc')
+  screens = Dir.glob('./lib/screen/**/*.rb')
+elsif ARGV.any? {|a| %w(-h --h -? --?).include?(a)}
+  puts 'USAGE:    ruby.exe convert_old_scripts.rb [PATH] [PATH] [PATH] [...]'
+  puts
+  puts 'EXAMPLES: ruby.exe convert_old_scripts.rb'
+  puts '          ruby.exe convert_old_scripts.rb ./test_cases/roku/**/*.rb'
+  exit(0)
+else
+  tests = ARGV.select {|p| p.include?('/test_cases/')}.map {|p| Dir.glob(p)}.flatten
+  screens = ARGV.select {|p| p.include?('/screen/')}.map {|p| Dir.glob(p)}.flatten
+end
+
+# convert test cases
+converted_tests = []
+tests.each do |file|
+  converted_tests << file if convert_code?(file)
+end
+
+# convert screens
+converted_screens = []
+screens.each do |file|
+  converted_screens << file if convert_code?(file)
+end
+
+# summarize results
+puts "\nConverted #{converted_tests.count}/#{tests.count} tests"
+puts "Converted #{converted_screens.count}/#{screens.count} screens"