framework_gem 0.1.0

data/lib/dsllib/common/utils/server_components_utils.rb

@@ -0,0 +1,130 @@
+#Test automation script version# TA-5.5.mdn released time stamp: 12-03-12 14:40:20
+
+require './dsllib/common/mas_db/mas_conductor'
+require './dsllib/common/utils/tmc_utils'
+require './dsllib/common/mas_db/mas_db'
+require './dsllib/common/dncs/dncs_utils'
+require './dsllib/common/mas_db/mas_rest_services'
+
+# These methods is used to verify server side components e.g. dncs, mas
+# Use these utility methods once per TMC rack
+
+# MAS conductor check
+def _verify_mas_conductor
+  mas_conductor_check_failure = []
+
+  begin
+    timeout = fetch_screensaver_timeout
+    mas_conductor_check_failure.push('Screen Saver Timeout') if timeout.empty?
+  rescue StandardError => e
+    mas_conductor_check_failure.push('Screen Saver Timeout')
+  end
+
+  begin
+    pin_entry_parameters = fetch_pin_entry_parameters
+    mas_conductor_check_failure.push('Pin entry parameters') if pin_entry_parameters.empty?
+  rescue StandardError => e
+    mas_conductor_check_failure.push('Pin entry parameters')
+  end
+
+  begin
+    tuning_settings = fetch_tuning_settings
+    mas_conductor_check_failure.push('Tuning settings') if tuning_settings.empty?
+  rescue StandardError => e
+    mas_conductor_check_failure.push('Tuning settings')
+  end
+
+  begin
+    dvr_parameters = fetch_dvr_parameters
+    mas_conductor_check_failure.push('DVR parameters') if dvr_parameters.empty?
+  rescue StandardError => e
+    mas_conductor_check_failure.push('DVR parameters')
+  end
+
+  begin
+    timeout = fetch_timeout_parameters
+    mas_conductor_check_failure.push('Timeout parameters') if timeout.empty?
+  rescue StandardError => e
+    mas_conductor_check_failure.push('Timeout parameters')
+  end
+
+  return mas_conductor_check_failure
+end
+
+def _verify_mas_db
+  mas_db_check_success = []
+  mas_db_check_failure = []
+  # MAS db check
+
+  begin
+    channels = mas_db_get_channels
+    mas_db_check_success.push('Channels for default region')
+  rescue StandardError => e
+    mas_db_check_failure.push('Channels for default region')
+  end
+
+  return mas_db_check_failure
+end
+
+def _verify_mas_commands
+  mas_commands_check_success = []
+  mas_commands_check_failure = []
+  # MAS commands check
+
+  begin
+    ip_address = fetch_ip
+    mas_commands_check_success.push('Fetch IP of the box')
+  rescue StandardError => e
+    mas_commands_check_failure.push('Fetch IP of the box')
+  end
+
+  return mas_commands_check_failure
+end
+
+def _verify_dncs_commands
+  dncs_commands_check_success = []
+  dncs_commands_check_failure = []
+  # DNCS commands check
+
+  begin
+    pkg_name = fetch_option(:guide_package_name)
+    pkg_exists = verify_package_on_dncs [pkg_name]
+    dncs_commands_check_success.push('Verify package')
+  rescue StandardError => e
+    dncs_commands_check_failure.push('Verify package')
+  end
+
+  return dncs_commands_check_failure
+end
+
+def _verify_rest_services
+  rest_services_check_success = []
+  rest_services_check_failure = []
+  # REST service check
+
+  begin
+    resp_xml = mas_webservice_menumanager_get_access_menu
+    tcfail "Failed to get tabs for [Access Menu] using rest services" if (mas_webservice_menumanager_get_access_menu_categories resp_xml).empty?
+    rest_services_check_success.push('Access Menu tabs')
+  rescue StandardError => e
+    rest_services_check_failure.push('Access Menu tabs')
+  end
+
+  return rest_services_check_failure
+end
+
+def _verify_soap_services
+  soap_services_check_success = []
+  soap_services_check_failure = []
+  # SOAP service check
+
+  begin
+    od_channel = fetch_option(:a_mod_channel).split(',')[0].to_i
+    tcfail "No tabs found for OD channel : #{od_channel}" if od_screen_categories_on_od_channel(od_channel).empty?
+    soap_services_check_success.push('OD channel categories')
+  rescue StandardError => e
+    soap_services_check_failure.push('OD channel categories')
+  end
+
+  return soap_services_check_failure
+end

data/lib/dsllib/common/utils/stb_health_check_utils.rb

@@ -0,0 +1,92 @@
+#Test automation script version# TA-5.5.mdn released time stamp: 12-03-12 14:40:20
+
+require 'net/smtp'
+require './dsllib/common/utils/tmc_utils'
+
+# This file is having utility methods for STB health check
+
+def _verify_screen_launch
+  begin
+    info_banner_launch_and_verify
+    guide_launch_and_verify
+    settings_launch_and_verify
+    access_menu_launch_and_verify
+    find_shows_launch_and_verify
+    if stb_capable_of?'DVR'
+      show_list_launch_and_verify
+    end
+    press_exit_sleep # exit to fullscreen
+  rescue StandardError => e
+    loginfo "Screen launch and verify failed : #{e.message}"
+    return false
+  end
+
+  return true
+end
+
+def _verify_home_channel
+  begin
+    home_channel = fetch_option(:a_home_channel)
+    press_exit_sleep
+    tune_immediately_to home_channel
+    return false unless (info_banner_launch_and_verify_channel_number home_channel, 5)
+    return false unless fullscreen_video_playing?(20)
+    return true
+  rescue StandardError => e
+    return false
+  end
+end
+
+def _verify_default_pc_pin
+  begin
+    settings_launch_and_verify
+    result = settings_screen_verify_parental_control_pin(fetch_option(:parental_pin).to_s)
+    press_exit_sleep # exit to fullscreen
+    return result
+  rescue StandardError => e
+    return false
+  end
+end
+
+def _verify_default_purchase_pin
+  begin
+    settings_launch_and_verify
+    result = settings_screen_verify_purchase_pin(fetch_option(:purchase_pin).to_s)
+    press_exit_sleep # exit to fullscreen
+    return result
+  rescue StandardError => e
+    return false
+  end
+end
+
+def _verify_default_screen_language
+  return settings_screen_launch_and_verify_language('english')
+end
+
+# Use it to send email with specified message to a support distribution list.
+# The subject of the email will contain TMC Rack IP and STB Id on which the calling script is running.
+# Attachments are not supported yet.
+def email_dl(subject, message, attachments = nil)
+
+  full_message =<<EOF
+From: TMC #{fetch_rack_ip} <localhost>
+To: <undisclosed recipients>
+Subject: #{subject}
+Content-Type: text/plain
+
+This message is automatically generated. Do not reply. 
+
+#{message}
+EOF
+
+  begin
+    smtp = Net::SMTP.new 'smtp.gmail.com', 587
+    smtp.enable_starttls
+    smtp.start('localhost', fetch_option(:gmail_userid), fetch_option(:gmail_passwd), :login) do
+      to_addresses = fetch_option(:support_dl).split(',')
+      to_addresses.each do |to_addr|
+        smtp.send_message(full_message, fetch_option(:gmail_userid), to_addr.strip)
+      end
+    end
+  end
+end

data/lib/dsllib/common/utils/sword_utils.rb

@@ -0,0 +1,393 @@
+#Test automation script version# TA-5.5.mdn released time stamp: 12-03-12 14:40:20
+
+require 'net/http'
+require 'uri'
+require 'json'
+require 'base64'
+
+module SwordUtils
+
+  #
+  # Attach screenshot to sword if we're talking to it.
+  #
+  # Takes screenshot of current STB and stores it to sword and on TMC.
+  #
+  #
+  def sword_attach_screenshot(comment = "Screenshot from TMC", return_title = nil, ss_filename = nil)
+    if test_data[:tmc_current_screenshots].nil?
+      test_data[:tmc_current_screenshots] = []
+    end
+    tmc_current_screenshots = Hash[test_data[:tmc_current_screenshots]]
+    if tmc_current_screenshots[@id].nil?
+      test_data[:tmc_current_screenshots] = tmc_current_screenshots.update(@id => 1).to_a  # can't use hash because of integer keys
+    end
+    begin
+      stampTime = Time.now
+
+      if ss_filename.nil?
+        #      stamp="hp_" + index.to_s + stampTime.strftime("_%d-%b-%Y-%H_%M_%S_#{(stampTime.to_f * 1000.0).to_i % 1000}")
+        ss_filename = "sword_job_#{@sword_job_id}_iter_#{@iteration}_screenshot_#{tmc_current_screenshots[@id]}.jpg"
+        tmc_current_screenshots[@id] += 1
+        test_data[:tmc_current_screenshots] = tmc_current_screenshots.to_a  # can't use hash because of integer keys
+        data = dut.capture_screen(filename: ss_filename, format: :raw)
+      else
+        resp = tmc_get("/images/#{ss_filename}", attr: :body)
+        # TODO: vvv legacy, remove after 19.2 is deployed
+        if resp.include?('base64Jpeg')
+          resp = JSON.parse(resp)
+          data = Base64.decode64(resp['base64Jpeg'])
+          # TODO: ^^^ legacy, remove after 19.2 is deployed
+        else
+          data = resp
+        end
+      end
+      path = ss_filename.sub(/\.jpg$/, '')
+
+      # TODO: 300+ scripts hard-coded this to true. It does not appear to have been used in SWORD, ever.
+      #if $options[:sword_store_screenshots].nil?
+      #  logger.info "Program option sword_store_screenshots is nil, not storing to sword."
+      #  logger.info "Attach screenshot: referenceImage=#{ss_filename}"
+      #else
+      if is_sword?
+        worked =_attach_media_sample(path, data, 'image/jpeg', comment, return_title)
+        if worked == 'true'
+          logger.info "Screenshot sent to sword. referenceImage=#{ss_filename}"
+          logger.info "Test case result ID reported to me: #{@sword_test_case_result_id}"
+        end
+      else
+        logger.info "Attach screenshot: referenceImage=#{ss_filename}"
+      end
+      endTime = Time.now
+      secsrun = endTime.to_f - stampTime.to_f
+      logger.info "Screenshot took #{secsrun} seconds to complete."
+
+    rescue => e
+      logger.info "sword_attach_screenshot failed - #{e.message}"
+    end
+    ss_filename
+  end
+
+  #
+  # Record a MP3 on the server and attach it to sword. This will delay for
+  # however long it takes to record the MP3 file. Recording time is already
+  # in seconds and does not need the .sec qualifier. Default duration is
+  # 10 seconds.
+  #
+  def sword_record_mp3(duration = 10000, comment = "MP3 From TMC", return_title = nil)
+    if test_data[:tmc_current_mp3s].nil?
+      test_data[:tmc_current_mp3s] = []
+    end
+    tmc_current_mp3s = Hash[test_data[:tmc_current_mp3s]]
+    if tmc_current_mp3s[@id].nil?
+      test_data[:tmc_current_mp3s] = tmc_current_mp3s.update(@id => 1).to_a  # can't use hash because of integer keys
+    end
+
+    filename = nil
+
+    begin
+      filename = dut.capture_audio(duration)[:audio]
+      data = tmc_get("/audio/play/#{filename}").body
+      sleep (duration + 2).sec
+      if is_sword?
+        worked = _attach_media_sample(filename.gsub(/\.mp3$/, ''), data, "audio/mp3", comment, return_title)
+        if (worked == "true")
+          logger.info "MP3 sent to sword"
+          logger.info "Test case result ID reported to me: #{@sword_test_case_result_id}"
+          logger.info "MP3 filename: #{filename}"
+        end
+      else
+        # It's not really an image, but maybe TMC can just pick
+        # it up and play it
+        logger.info "Recorded MP3. referenceImage=#{filename}"
+      end
+    rescue => e
+      logger.info "sword_record_mp3 failed"
+    end
+
+    return filename
+
+  end
+
+  private
+
+  # TODO: temporary, picks an id if the test does not have a device
+  def get_id
+    device? ? dut.id : 0
+  end
+
+  # TODO: temporary, picks an ip if the test does not have a device
+  def get_ip
+    (device? ? dut.ip_address : nil) || '127.0.0.1'
+  end
+
+  def output_results(result_value, tcr_auto_detail_text, return_value, start_time, stop_time, args = {})
+    _output_results(get_id, get_ip, options[:user_id], tcr_auto_detail_text, return_value, result_value, start_time,
+                    stop_time, args)
+  end
+
+  def script_end_end
+    if is_sword?
+      _script_end(get_id, get_ip, :END)
+    end
+  end
+
+  def _script_end(tmc_stb_id, tmc_system_ip, status)
+    params = {
+        :test_plan_result_id => @sword_test_plan_result_id,
+        :test_case_result_id => @sword_test_case_result_id,
+        :tmc_stb_id => tmc_stb_id,
+        :tmc_system_ip => tmc_system_ip,
+        :status => status,
+        :tcrad_id => @sword_tcr_auto_detail_id
+    }
+    begin
+      url = "#{@sword_base_url}#{@sword_finish_url}"
+      query = params.collect { |k,v| "#{k}=#{URI::escape(v.to_s)}" }.join('&')
+      url += "?#{query}" unless query.empty?
+      logger.debug("Reporting URL: #{url}")
+      web_get(url)
+    rescue => ex
+      logger.error("Failed to report end to Sword #{ex}")
+    end
+  end
+
+  def _output_results(tmc_stb_id, tmc_system_ip, user_id, tcr_auto_detail_text, return_value, result_value, start_time,
+                      stop_time, args = {})
+    if test_data[:reporting_mode] == 'twb'
+      # do the twb stuff here...
+      logger.info('Preparing final case report to TWB...')
+      uri = 'http://charter.testworkbench.com/ords/test/'
+      test_suite_name = options[:twb_suite_name]
+      program_application_name = options[:program_application_name]
+      twb_screenshot = options[:twb_post_screenshot]
+      suite_instance_id = twb_get_suite_instance_id(:twb_suite_name => test_suite_name)
+      case_instance_id = twb_get_case_instance_id(:twb_suite_name => test_suite_name)
+      # POST Test Step
+      result = result_value
+      result = 'Passed' if result_value == :PASS
+      result = 'Failed' if result_value == :FAIL
+      return_msg = twb_post_teststep(
+          :description => tcr_auto_detail_text,
+          :result_value => result,
+          :suite_instance_id => suite_instance_id,
+          :case_instance_id => case_instance_id,
+          :twb_suite_name => test_suite_name,
+          :program_application_name => program_application_name,
+          :uri => uri+'teststep/'
+      )
+      if return_msg.nil?
+        logger.info('Failed to post Teststep!')
+        return
+      end
+      # POST screenshot
+      if twb_screenshot == 'true'
+        twb_post_screenshot(
+            :twb_suite_name => test_suite_name,
+            :suite_instance_id => suite_instance_id,
+            :case_instance_id => case_instance_id,
+            :verify_mode => 0
+        )
+      end
+      # Wipe case_instance_id
+      twb_clear_case_id(:twb_suite_name => test_suite_name)
+      #######################
+      #### END TWB logic ####
+      #######################
+    end
+    return unless is_sword?
+    is_perf = self.is_a?(PerformanceTestCase)
+    if is_perf && result_value.is_a?(Symbol)
+      logger.warn("Not reporting #{result_value} verdict for performance test")
+      return
+    end
+    # do the normal sword stuff here...
+    logger.debug("Report grouping: #{@sword_report_grouping}") unless @sword_report_grouping.nil?
+    if args[:execution_metric].nil?
+      tcr_id = @sword_test_case_result_id
+    else
+      # If an execution metric is given, use the corresponding test case result id
+      tcr_id = @sword_report_grouping.find {|g| g[:execution_metric] == args[:execution_metric]}[:test_case_result_id]
+    end
+
+    # Recently the End of Plan SWORD Utility script
+    # ("/text_cases/utility/send_end_of_plan")
+    # was updated from a DSL script to an OO script.
+    # In order to facilitate this, I've added a "switch" to report
+    # to the end of plan endpoint ('/test_plan_results/tmc_dsl_end_plan?')
+    # instead of the end of case endpoint ('/test_plan_results/tmc_dsl_results?')
+    # whenever the End of Plan script is run.
+    # $options[:sword_end_of_plan] is set to Boolean true in the End of Plan script.
+    # I'm assuming this will be deprecated once the new Execution Engine is complete
+    # but for now this is neccessary to ensure that SWORD knows when a Plan ends and
+    # when a Plan needs to loop multiple times.
+    # --mbarnes
+
+    params = {
+        :test_plan_result_id => @sword_test_plan_result_id,
+        :test_case_result_id => tcr_id,
+        :tmc_stb_id => tmc_stb_id,
+        :tmc_system_ip => tmc_system_ip,
+        :hardware_unit_id => @sword_hardware_unit_id,
+        :sword_iteration => iteration,
+        :user_id => user_id,
+        :tcr_auto_detail_text => tcr_auto_detail_text,
+        :start_epoch => start_time.is_a?(Integer) ? from_epoch_time(start_time) : start_time,
+        :stop_epoch => stop_time.is_a?(Integer) ? from_epoch_time(stop_time) : stop_time,
+        :return_value => return_value,
+        :result_value => result_value,
+        :tcrad_id => @sword_tcr_auto_detail_id
+    }
+
+    unless args[:return_title].nil?
+      params[:return_title] = args[:return_title]
+    end
+
+    begin
+      url = "#{@sword_base_url}#{@sword_result_url}"
+      url = url.concat(params.collect { |k,v| "#{k}=#{URI::escape(v.to_s)}" }.join('&'))
+      logger.debug "Reporting URL: #{url}"
+      web_get(url)
+    rescue => ex
+      logger.error("Failed to send results to Sword:\n#{ex}", screenshot: false)
+    end
+  end
+
+  #
+  # Attach a media sample (Audio MP3 or Jpeg screenshot) to sword via
+  # rest interface.
+  #
+  # Parameters:
+  # filename - media sample file name
+  # attachment_comment - Comment for attachment (Not currently shown in
+  #                      sword.
+  # test_case_result_id - Current test case result ID.
+  # return_title (optional) - If you're attaching to parameterized test
+  # results, this should be set to the current return title for the
+  # current result.
+  #
+  # This will only try to write to sword if the test is configurd to write
+  # to sword (I'm pretty sure options[:db_write] indicates that.)
+  #
+  def _attach_media_sample(title, data, attachment_type, attachment_comment = "Media sample from TMC", return_title = nil)
+
+    logger.info 'In _attach_media_samples'
+    logger.info "Title: #{title}"
+    logger.info "Test case name: #{options[:test_case_name]}"
+    logger.info "Test case reslt id: #{@sword_test_case_result_id}"
+    logger.info "Sword HW ID: #{@sword_hardware_unit_id}"
+    logger.info "Sword iteration: #{iteration}"
+    logger.info "Data: #{data.length} bytes"
+    logger.info "STB ID: #{dut.id}"
+
+    retval = is_sword? ? 'true' : nil
+    if retval == "true"
+      logger.info "Recording media sample to sword"
+      begin
+        # This DOES read the whole file into memory, which could
+        # potentially crash... things. Perhaps we should set a top
+        # bound on allowed filesize to stuff into sword...
+
+        #
+        # TODO: Sword is going to have to look up tcrad ID on
+        # sword side and add it to attachment as :attachable_id.
+        # It needs this info in a ocuple of places on the receiving side
+        #
+        tcrad_id = @sword_tcr_auto_detail_id
+        if (nil == tcrad_id || tcrad_id.empty?)
+          tcrad_id = nil
+        end
+
+        encoded_data = Base64.encode64(data).gsub(/\n/, '')
+        params = {
+
+            # attachment :attachable_id set in sword attachments
+            # controller
+            :attachment => { :attachment_file_title => "#{title}.jpg",
+                             :attachment_title => title,
+                             :comment_text => attachment_comment,
+                             :create_user_id => current_user['id'],
+                             :content_type => attachment_type,
+                             :attachable_type => "TcrAutoDetail"
+            },
+            :encoded_file => encoded_data,
+            :commit => "Commit",
+            :test_plan_result_id => @sword_test_plan_result_id,
+            :test_case_result_id => @sword_test_case_result_id,
+            :hardware_unit_id => @sword_hardware_unit_id,
+            :sword_iteration => iteration,
+            :from_tmc => "true",
+        }
+        if nil != tcrad_id
+          params[:tcrad_id] = tcrad_id
+        end
+        if (nil != return_title)
+          params[:return_title] = return_title
+        end
+        url = "#{@sword_base_url}/attachments"
+        # url = url.concat(params.collect { |k,v| "#{k}=#{URI::escape(v.to_s)}" }.join('&'))
+        # logger.info url
+        # response = Net::HTTP.post_form(URI.parse(url), params)
+        logger.info "Attaching media sample to sword: #{title}"
+        response = web_post(url, :json => params)
+        if response.body.include?("Success")
+          tcr_arr = response.body.split("=")
+          if (nil != tcr_arr[1] && !tcr_arr[1].empty?)
+            @sword_tcr_auto_detail_id = tcr_arr[1]
+          end
+        end
+
+        logger.debug "Retrieved tcrad ID: #{@sword_tcr_auto_detail_id}"
+        logger.debug "Response to http post: #{response.code} : #{response.message}"
+      rescue => e
+        logger.error "Failed to attach media sample to sword: #{e}"
+        retval = "false"
+      end
+    end
+    return retval
+  end
+
+  # Reports any kind of result to SWORD
+  #
+  # Arguments:
+  # result               -- must be one of:
+  #                         :running          report Pass
+  #                         :pass, passed     report Pass
+  #                         :fail, failed     report Fail
+  #                         :error            report Error
+  #                         :perf, done       report Performance
+  # start_time           -- start time as a Time object
+  # stop_time            -- stop time as a Time object
+  # return_value         -- numeric return value (optional, default 0)
+  # tcr_auto_detail_text -- text to report, only for functional tests (optional, default "Test Passed" or "Test Failed")
+  # execution_metric     -- execution metric for which to report (optional)
+  # return_title         -- return title to report (optional)
+  # TODO: NO SCRIPT SHOULD CALL THIS METHOD
+  def report_to_sword(result, start_time, stop_time, args = {})
+    start_time = start_time.to_f
+    stop_time = stop_time.to_f
+    if self.is_a?(FunctionalTestCase)
+      return_value = args.delete(:return_value) || 0
+      tcrad_text = args.delete(:tcr_auto_detail_text) || "Test #{result}"
+      case result.to_s.downcase.to_sym
+        when nil, :'not run', :running, :passed, :pass
+          output_results(:PASS, tcrad_text, return_value, start_time, stop_time, args)
+        when :failed, :fail
+          output_results(:FAIL, tcrad_text, return_value, start_time, stop_time, args)
+        when :error
+          output_results(:ERROR, tcrad_text, return_value, start_time, stop_time, args)
+        else
+          raise "Invalid result type #{result}."
+      end
+    else
+      # TODO: update this logic once we move calculation of pass/fail for perf into TMC
+      case result.to_s.downcase.to_sym
+        #when nil, :'not run', :running, :passed, :pass
+        when :error, :failed, :fail
+          # no-op on error/fail, so that the status remains "not run"
+          logger.warn('Not posting any result to SWORD for error/fail status.')
+        else
+          post_result(start_time, stop_time, args[:return_value], args)
+      end
+    end
+  end
+end