kraken-mobile 1.0.4 → 1.0.5

data/lib/kraken-mobile/steps/web/kraken_steps.rb

@@ -0,0 +1,81 @@
+require 'selenium-webdriver'
+require 'uri'
+
+driver = Selenium::WebDriver.for :chrome
+
+Given(/^I navigate to page "([^\"]*)"$/) do |web_url|
+  raise 'ERROR: Invalid URL' if web_url.nil?
+  raise 'ERROR: Invalid URL' unless web_url =~ URI::DEFAULT_PARSER.make_regexp
+
+  driver.navigate.to web_url
+  sleep 2
+end
+
+Then(/^I enter "([^\"]*)" into input field having id "([^\"]*)"$/) do |text, id|
+  driver.find_element(:id, id).send_keys(text)
+  sleep 2
+end
+
+Then(
+  /^I enter "([^\"]*)" into input field having css selector "([^\"]*)"$/
+) do |text, selector|
+  driver.find_element(:css, selector).send_keys(text)
+  sleep 2
+end
+
+Then(/^I click on element having id "(.*?)"$/) do |id|
+  driver.find_element(:id, id).click
+  sleep 2
+end
+
+Then(/^I wait for (\d+) seconds$/) do |seconds|
+  return if seconds.nil?
+
+  sleep seconds.to_i
+end
+
+Then(/^I should see text "(.*?)"$/) do |text|
+  driver.page_source.include?(text)
+end
+
+# Kraken Steps
+Then(
+  /^I send a signal to user (\d+) containing "([^\"]*)"$/
+) do |process_id, signal|
+  device = Device.find_by_process_id(process_id)
+  raise 'ERROR: Device not found' if device.nil?
+  if process_id.to_s == current_process_id.to_s
+    raise 'ERROR: Can\'t send signal to same device'
+  end
+
+  device.write_signal(signal)
+end
+
+Then(/^I wait for a signal containing "([^\"]*)"$/) do |signal|
+  raise 'ERROR: Invalid scenario tag' if @scenario_tags.nil?
+  raise 'ERROR: Invalid scenario tag' if @scenario_tags.grep(/@user/).none?
+
+  device = Device.find_by_process_id(current_process_id)
+  raise 'ERROR: Device not found' if device.nil?
+
+  device.read_signal(signal)
+end
+
+Then(
+  /^I wait for a signal containing "([^\"]*)" for (\d+) seconds$/
+) do |signal, seconds|
+  raise 'ERROR: Invalid scenario tag' if @scenario_tags.nil?
+  raise 'ERROR: Invalid scenario tag' if @scenario_tags.grep(/@user/).none?
+
+  device = Device.find_by_process_id(current_process_id)
+  raise 'ERROR: Device not found' if device.nil?
+
+  device.read_signal(signal, seconds)
+end
+
+private
+
+def current_process_id
+  tag_process_id = @scenario_tags.grep(/@user/).first
+  tag_process_id.delete_prefix('@user')
+end

data/lib/kraken-mobile/test_scenario.rb

@@ -0,0 +1,193 @@
+require 'kraken-mobile/helpers/feature_analyzer'
+require 'kraken-mobile/mobile/mobile_process'
+require 'kraken-mobile/models/feature_file'
+require 'kraken-mobile/models/web_device'
+require 'kraken-mobile/web/web_process'
+require 'kraken-mobile/utils/reporter'
+require 'kraken-mobile/mobile/adb'
+require 'kraken-mobile/utils/k'
+require 'parallel'
+
+class TestScenario
+  #-------------------------------
+  # Fields
+  #-------------------------------
+  attr_accessor :devices
+  attr_accessor :kraken_app
+  attr_accessor :feature_file
+  attr_accessor :execution_id
+  attr_accessor :reporter
+
+  #-------------------------------
+  # Constructors
+  #-------------------------------
+  def initialize(kraken_app:, feature_file_path:)
+    @feature_file = FeatureFile.new(file_path: feature_file_path)
+    @devices = sample_devices
+    @kraken_app = kraken_app
+    @execution_id = Digest::SHA256.hexdigest(Time.now.to_f.to_s)
+    @reporter = Reporter.new(test_scenario: self)
+  end
+
+  #-------------------------------
+  # Lifecycle
+  #-------------------------------
+  def before_execution
+    delete_all_web_inboxes
+    File.delete(K::DIRECTORY_PATH) if File.exist?(K::DIRECTORY_PATH)
+    File.delete(K::DICTIONARY_PATH) if File.exist?(K::DICTIONARY_PATH)
+    K::PROCESS_STATE_FILE_PATH.each do |_state, file_path|
+      File.delete(file_path) if File.exist?(file_path)
+    end
+    @reporter.create_report_folder_requirements
+  end
+
+  def run
+    unless @feature_file.right_syntax?
+      raise "ERROR: Verify feature file #{@file_path} has one unique @user tag"\
+      ' for each scenario'
+    end
+
+    before_execution
+    execute
+    after_execution
+  end
+
+  def after_execution
+    File.delete(K::DIRECTORY_PATH) if File.exist?(K::DIRECTORY_PATH)
+    File.delete(K::DICTIONARY_PATH) if File.exist?(K::DICTIONARY_PATH)
+    K::PROCESS_STATE_FILE_PATH.each do |_state, file_path|
+      File.delete(file_path) if File.exist?(file_path)
+    end
+    @reporter.save_report
+    notify_scenario_finished
+  end
+
+  #-------------------------------
+  # Methods
+  #-------------------------------
+  def execute
+    Parallel.map_with_index(
+      @devices, in_threads: @devices.count
+    ) do |device, index|
+      user_id = index + 1
+      start_process_for_user_id_in_device(
+        user_id,
+        device
+      )
+    end
+  end
+
+  def self.ready_to_start?
+    process_ids = DeviceProcess.registered_process_ids
+    processes_ready = DeviceProcess.processes_in_state(
+      K::PROCESS_STATES[:ready_to_start]
+    )
+    process_ids.all? do |process_id|
+      processes_ready.include?(process_id) ||
+        Device.find_by_process_id(process_id)&.connected? == false
+    end
+  end
+
+  def self.ready_to_finish?
+    process_ids = DeviceProcess.registered_process_ids
+    processes_finished = DeviceProcess.processes_in_state(
+      K::PROCESS_STATES[:ready_to_finish]
+    )
+    process_ids.all? do |process_id|
+      processes_finished.include?(process_id) ||
+        Device.find_by_process_id(process_id)&.connected? == false
+    end
+  end
+
+  def requires_predefined_devices?
+    !ENV[K::CONFIG_PATH].nil?
+  end
+
+  private
+
+  def start_process_for_user_id_in_device(user_id, device)
+    if device.is_a? AndroidDevice
+      start_mobile_process_for_user_id_in_device(user_id, device)
+    elsif device.is_a? WebDevice
+      start_web_process_for_user_id_in_device(user_id, device)
+    else
+      raise 'ERROR: Platform not supported'
+    end
+  end
+
+  def start_mobile_process_for_user_id_in_device(user_id, device)
+    MobileProcess.new(
+      id: user_id,
+      device: device,
+      test_scenario: self
+    ).run
+  end
+
+  def start_web_process_for_user_id_in_device(user_id, device)
+    WebProcess.new(
+      id: user_id,
+      device: device,
+      test_scenario: self
+    ).run
+  end
+
+  def sample_devices
+    return predefined_devices if requires_predefined_devices?
+
+    (sample_mobile_devices + sample_web_devices).flatten
+  end
+
+  def sample_mobile_devices
+    android_devices = ADB.connected_devices
+    android_devices.sample(
+      @feature_file.number_of_required_mobile_devices
+    )
+  end
+
+  def sample_web_devices
+    web_devices = []
+    @feature_file.number_of_required_web_devices.times do
+      web_devices << WebDevice.factory_create
+    end
+    web_devices
+  end
+
+  def notify_scenario_finished
+    @kraken_app.on_test_scenario_finished
+  end
+
+  def user_id_is_mobile?(user_id)
+    complement_tags = @feature_file.tags_for_user_id(user_id).map(
+      &:downcase
+    )
+    complement_tags.include?('@mobile')
+  end
+
+  def user_id_is_web?(user_id)
+    complement_tags = @feature_file.tags_for_user_id(user_id).map(
+      &:downcase
+    )
+    complement_tags.include?('@web')
+  end
+
+  def delete_all_web_inboxes
+    Dir.glob(".*_#{K::INBOX_FILE_NAME}").each do |file|
+      File.delete(file)
+    end
+  end
+
+  def predefined_devices
+    config_absolute_path = File.expand_path(ENV[K::CONFIG_PATH])
+    file = open(config_absolute_path)
+    content = file.read
+    devices_json = JSON.parse(content).values
+
+    devices_json.map do |device_json|
+      AndroidDevice.new(
+        id: device_json['id'],
+        model: device_json['model']
+      )
+    end
+  end
+end

data/lib/kraken-mobile/utils/feature_reader.rb

@@ -0,0 +1,17 @@
+require 'kraken-mobile/models/feature_file'
+
+module Utils
+  module FeatureReader
+    def feature_files
+      features_dir = File.join(FileUtils.pwd, K::FEATURES_PATH)
+      unless File.exist?(features_dir)
+        raise "ERROR: File or directory '#{features_dir}' does not exists"
+      end
+      # Is a file not directory
+      return [features_dir] if features_dir.include?('.feature')
+
+      files = Dir[File.join(features_dir, '**{,/*/**}/*')].uniq
+      files.grep(/\.feature$/)
+    end
+  end
+end

data/lib/kraken-mobile/utils/k.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module K
+  SEPARATOR = ';' unless defined? SEPARATOR
+  DIRECTORY_PATH = '.device_directory' unless defined? DIRECTORY_PATH
+  DICTIONARY_PATH = 'dictionary.json' unless defined? DICTIONARY_PATH
+  INBOX_FILE_NAME = 'inbox.txt' unless defined? INBOX_FILE_NAME
+  FEATURES_PATH = './features' unless defined? FEATURES_PATH
+  DEFAULT_TIMEOUT_SECONDS = 30 unless defined? DEFAULT_TIMEOUT_SECONDS
+  ANDROID_PORTRAIT = 0 unless defined? ANDROID_PORTRAIT
+  ANDROID_LANDSCAPE = 1 unless defined? ANDROID_LANDSCAPE
+  WEB_PORTRAIT = 1 unless defined? WEB_PORTRAIT
+  MONKEY_DEFAULT_TIMEOUT = 5 unless defined? MONKEY_DEFAULT_TIMEOUT
+  WEB_DEVICE = 'WEB_DEVICE' unless defined? WEB_DEVICE
+  ANDROID_DEVICE = 'ANDROID_DEVICE' unless defined? ANDROID_DEVICE
+  PROPERTIES_PATH = 'PROPERTIES_PATH' unless defined? PROPERTIES_PATH
+  CONFIG_PATH = 'CONFIG_PATH' unless defined? CONFIG_PATH
+  REPORT_PATH = './reports' unless defined? REPORT_PATH
+  FILE_REPORT_NAME = 'report.json' unless defined? FILE_REPORT_NAME
+  D3_DATA_FILE_NAME = 'data.json' unless defined? D3_DATA_FILE_NAME
+
+  unless defined? DEVICES_REPORT_FILE_NAME
+    DEVICES_REPORT_FILE_NAME = 'devices.json'
+  end
+
+  unless defined? REPORT_ASSETS_PATH
+    REPORT_ASSETS_PATH = '../../../../reporter/assets/'
+  end
+
+  unless defined? DEFAULT_START_TIMEOUT_SECONDS
+    DEFAULT_START_TIMEOUT_SECONDS = 600 # 10.minutes
+  end
+
+  unless defined? DEFAULT_FINISH_TIMEOUT_SECONDS
+    DEFAULT_FINISH_TIMEOUT_SECONDS = 600 # 10.minutes
+  end
+
+  unless defined? DEVICES_READY_PATH
+    DEVICES_READY_PATH = '.devices_ready_to_start'
+  end
+
+  unless defined? DEVICES_FINISHED_PATH
+    DEVICES_FINISHED_PATH = '.devices_ready_to_finish'
+  end
+
+  unless defined? PROCESS_STATES
+    PROCESS_STATES = {
+      ready_to_start: 0,
+      ready_to_finish: 1
+    }.freeze
+  end
+
+  unless defined? PROCESS_STATE_FILE_PATH
+    PROCESS_STATE_FILE_PATH = {
+      K::PROCESS_STATES[:ready_to_start] => DEVICES_READY_PATH,
+      K::PROCESS_STATES[:ready_to_finish] => DEVICES_FINISHED_PATH
+    }.freeze
+  end
+
+  unless defined? CALABASH_MONKEY_ACTIONS
+    CALABASH_MONKEY_ACTIONS = [
+      :move,
+      :down,
+      :up
+    ].freeze
+  end
+end

data/lib/kraken-mobile/utils/mobile_cucumber.rb

@@ -0,0 +1,2 @@
+require 'calabash-android/cucumber'
+require 'kraken-mobile/hooks/mobile_kraken_hooks'

data/lib/kraken-mobile/utils/reporter.rb

@@ -0,0 +1,453 @@
+require 'kraken-mobile/utils/k'
+require 'json'
+
+class Reporter
+  #-------------------------------
+  # Fields
+  #-------------------------------
+  PASSED = 'passed'.freeze
+  FAILED = 'failed'.freeze
+  SKIPPED = 'skipped'.freeze
+  PENDING = 'pending'.freeze
+  NOT_DEFINED = 'undefined'.freeze
+  AMBIGUOUS = 'ambiguous'.freeze
+
+  attr_accessor :test_scenario
+
+  #-------------------------------
+  # Constructors
+  #-------------------------------
+  def initialize(test_scenario:)
+    @test_scenario = test_scenario
+  end
+
+  #-------------------------------
+  # Lifecycle
+  #-------------------------------
+  def create_report_folder_requirements
+    create_report_execution_report_folder
+    create_devices_execution_report_folder
+    save_execution_devices_list
+  end
+
+  def save_report
+    generate_each_device_report
+    generate_general_report
+  end
+
+  def generate_general_report
+    erb_file = File.join(
+      File.expand_path('../../../../reporter', __FILE__),
+      'index.html.erb'
+    )
+    html_file = File.join(
+      File.expand_path("#{K::REPORT_PATH}/#{test_execution_id}/"),
+      'index.html'
+    )
+    report_file = open(
+      "#{K::REPORT_PATH}/#{test_execution_id}/#{K::DEVICES_REPORT_FILE_NAME}"
+    )
+    content = report_file.read
+    devices_report = report_by_devices
+    @features_report = fetures_from_report_by_devices(devices_report)
+    data_hash = feature_by_nodes_and_links @features_report
+    open(
+      "#{K::REPORT_PATH}/#{test_execution_id}/assets/js/#{K::D3_DATA_FILE_NAME}",
+      'w'
+    ) do |file|
+      file.puts(data_hash.to_json)
+    end
+    template = File.read(erb_file)
+    result = ERB.new(template).result(binding)
+    File.open(html_file, 'w+') do |f|
+      f.write result
+    end
+  end
+
+  def generate_each_device_report
+    devices.each_with_index do |device, index|
+      generate_device_report(device, index + 1)
+    end
+  end
+
+  def generate_device_report(device, id)
+    process = MobileProcess.new(
+      id: id,
+      device: device,
+      test_scenario: @test_scenario
+    )
+    @apk_path = process.apk_path
+    report_file = open("#{K::REPORT_PATH}/#{test_execution_id}/#{device.id}/#{K::FILE_REPORT_NAME}")
+    content = report_file.read
+    @features = JSON.parse(content)
+    @total_scenarios = total_scenarios @features
+    @device = device
+    @total_failed_scenarios_percentage = total_failed_scenarios_percentage @features
+    @total_passed_scenarios_percentage = total_passed_scenarios_percentage @features
+    @total_passed_features_percentage = total_passed_features_percentage @features
+    @total_failed_features_percentage = total_failed_features_percentage @features
+    erb_file = File.join(File.expand_path('../../../../reporter', __FILE__), "feature_report.html.erb")
+    html_file = File.join(File.expand_path("#{K::REPORT_PATH}/#{test_execution_id}/#{device.id}/"), File.basename(erb_file, '.erb')) #=>"page.html"
+    # Variables
+    template = File.read(erb_file)
+    result = ERB.new(template).result(binding)
+    # write result to file
+    File.open(html_file, 'w+') do |f|
+      f.write result
+    end
+    generate_features_report @features, device
+  end
+
+  #-------------------------------
+  # Methods
+  #-------------------------------
+  def test_execution_id
+    raise 'ERROR: Invalid test scenario' if @test_scenario.nil?
+
+    @test_scenario.execution_id
+  end
+
+  def create_report_execution_report_folder
+    Dir.mkdir(K::REPORT_PATH) unless File.exist?(K::REPORT_PATH)
+    Dir.mkdir("#{K::REPORT_PATH}/#{test_execution_id}")
+    FileUtils.cp_r(
+      File.expand_path(K::REPORT_ASSETS_PATH, __FILE__),
+      "#{K::REPORT_PATH}/#{test_execution_id}/"
+    )
+  end
+
+  def save_execution_devices_list
+    open(
+      "#{K::REPORT_PATH}/#{test_execution_id}/#{K::DEVICES_REPORT_FILE_NAME}",
+      'w'
+    ) do |file|
+      file.puts(devices_json.to_json)
+    end
+  end
+
+  def create_devices_execution_report_folder
+    devices.each do |device|
+      Dir.mkdir(
+        "#{KrakenMobile::Constants::REPORT_PATH}/#{test_execution_id}/"\
+        "#{device.id}"
+      )
+    end
+  end
+
+  private
+
+  def generate_features_report features, device
+    features.each do |feature|
+      generate_feature_report feature, device
+    end
+  end
+
+  def generate_feature_report feature, device
+    Dir.mkdir("#{K::REPORT_PATH}/#{test_execution_id}/#{device.id}/features_report") unless File.exists?("#{K::REPORT_PATH}/#{test_execution_id}/#{device.id}/features_report")
+    file_name = feature_id feature
+    erb_file = File.join(File.expand_path('../../../../reporter', __FILE__), "scenario_report.html.erb")
+    html_file = File.join(File.expand_path("#{K::REPORT_PATH}/#{test_execution_id}/#{device.id}/features_report"), "#{file_name}.html") #=>"page.html"
+    # Variables
+    @feature = feature
+    template = File.read(erb_file)
+    result = ERB.new(template).result(binding)
+    # write result to file
+    File.open(html_file, 'w+') do |f|
+      f.write result
+    end
+  end
+
+  def report_by_devices
+    devices_report = {}
+    devices_json.each do |device|
+      unless File.exist?(
+        "#{K::REPORT_PATH}/#{test_execution_id}/#{device[:id]}/#{K::FILE_REPORT_NAME}"
+      )
+        next
+      end
+
+      report_file = open(
+        "#{K::REPORT_PATH}/#{test_execution_id}/#{device[:id]}/#{K::FILE_REPORT_NAME}"
+      )
+      content = report_file.read
+      devices_report[device[:user]] = JSON.parse(content)
+      devices_report[device[:user]].each do |d| d['device_model'] = device[:model] if !d['device_model'] end
+      devices_report[device[:user]].each do |d| d['device_id'] = device[:id] if !d['device_id'] end
+    end
+    devices_report
+  end
+
+  def fetures_from_report_by_devices report_by_devices
+    features = {}
+    report_by_devices.keys.each do |user_key|
+      report = report_by_devices[user_key]
+      report.each do |feature|
+        features[feature["id"]] = {} if !features[feature["id"]]
+        features[feature["id"]]["name"] = feature["name"] if !features[feature["id"]]["name"] && feature["name"]
+        features[feature["id"]]["devices"] = {} if !features[feature["id"]]["devices"]
+        if feature["elements"] && feature["elements"].count > 0
+          features[feature["id"]]["devices"][user_key] = []
+          if feature["elements"].first["steps"]
+            failed = false
+            feature["elements"].first["steps"].each do |step|
+              next if failed
+              failed = step["result"]["status"] != PASSED
+              image = nil
+              image = step["after"].first["embeddings"].first["data"] if step["after"] && step["after"].count > 0 && step["after"].first["embeddings"] && step["after"].first["embeddings"].count > 0
+              features[feature["id"]]["devices"][user_key] << {
+                name: "#{step['keyword']} #{step['name']}",
+                duration: step["result"]["duration"],
+                image: image,
+                device_model: feature["device_model"],
+                status: failed ? FAILED : PASSED
+              }
+            end
+          end
+        end
+      end
+    end
+    features
+  end
+
+  def feature_by_nodes_and_links features_report
+    features = []
+    features_report.values.each do |feature|
+      features << nodes_and_links(feature["devices"], feature["name"]) if feature["devices"]
+    end
+    features
+  end
+
+  def nodes_and_links feature_report, feature_name
+    last_node_id = 0
+    nodes = [{ name: "", id: "empty", image: nil }]
+    signal_hash = {}
+    links = []
+    feature_report.keys.each do |key|
+      steps = feature_report[key]
+      coming_from_signal = false
+      last_signal = -1
+      steps.each_with_index do |step, index|
+        node_id = last_node_id+1
+        if isReadSignal(step[:name]) && step[:status] == PASSED
+          signal = signalContent(step[:name])
+          already_created_signal = signal_hash[signal] ? true : false
+          signal_hash[signal] = already_created_signal ? signal_hash[signal] : { id: "#{node_id}", receiver: key }
+          node = { name: "Signal: #{signal}, Receiver: #{step[:device_model]}", id: signal_hash[signal][:id], image: nil, status: step[:status] }
+          if already_created_signal
+            entry = nodes.select{ |node| node[:id] == signal_hash[signal][:id] }.first
+            entry[:name] = "Signal: #{signal}, Receiver: #{step[:device_model]}" if entry
+          end
+          source = (coming_from_signal ? last_signal : (index == 0 ? 0 : last_node_id))
+          link = {
+            source: source,
+            target: signal_hash[signal][:id].to_i,
+            value: 1,
+            owner: key,
+            owner_model: step[:device_model]
+          }
+          nodes << node if !already_created_signal
+          links << link
+          last_node_id += 1 if !already_created_signal
+          last_signal = signal_hash[signal][:id].to_i
+          coming_from_signal = true
+        elsif isWriteSignal(step[:name]) && step[:status] == PASSED
+          signal = signalContent(step[:name])
+          receiver = signalReceiver(step[:name])
+          already_created_signal = signal_hash[signal] ? true : false
+          signal_hash[signal] = already_created_signal ? signal_hash[signal] : { id: "#{node_id}", receiver: receiver }
+          node = { name: step[:name], id: signal_hash[signal][:id], image: nil, status: step[:status] }
+          source = (coming_from_signal ? last_signal : (index == 0 ? 0 : last_node_id))
+          link = {
+            source: source,
+            target: signal_hash[signal][:id].to_i,
+            value: 1,
+            owner: key,
+            owner_model: step[:device_model]
+          }
+          nodes << node if !already_created_signal
+          links << link
+          last_node_id += 1 if !already_created_signal
+          last_signal = signal_hash[signal][:id].to_i
+          coming_from_signal = true
+        else
+          node = { name: step[:name], id: "#{node_id}", image: step[:image], status: step[:status] }
+          source = (coming_from_signal ? last_signal : (index == 0 ? 0 : last_node_id))
+          link = {
+            source: source,
+            target: node_id,
+            value: 1,
+            owner: key,
+            owner_model: step[:device_model]
+          }
+          nodes << node
+          links << link
+          last_node_id += 1
+          coming_from_signal = false
+        end
+      end
+    end
+    return {
+      name: feature_name,
+      nodes: nodes,
+      links: links
+    }
+  end
+
+  def isReadSignal step
+    line = step.split(' ')[1..-1].join(' ')
+    (line =~ /^I wait for a signal containing "([^\"]*)"$/ ? true : false) || (line =~ /^I wait for a signal containing "([^\"]*)" for (\d+) seconds$/ ? true : false)
+  end
+
+  def isWriteSignal step
+    line = step.split(' ')[1..-1].join(' ')
+    line =~ /^I send a signal to user (\d+) containing "([^\"]*)"$/ ? true : false
+  end
+
+  def signalContent step
+    line = step.split(' ')[1..-1].join(' ')
+    line.scan(/"([^\"]*)"/).first.first if line.scan(/"([^\"]*)"/).first
+  end
+
+  def signalReceiver step
+    line = step.split(' ')[1..-1].join(' ')
+    line.scan(/(\d+)/).first.first if line.scan(/(\d+)/).first
+  end
+
+  def devices
+    raise 'ERROR: Invalid test scenario' if @test_scenario.nil?
+
+    @test_scenario.devices
+  end
+
+  def devices_json
+    devices.map.with_index do |device, index|
+      height, width = device.screen_size
+      {
+        user: (index + 1), id: device.id,
+        model: device.model, screen_height: height,
+        screen_width: width, sdk: device.sdk_version,
+        type: device.type
+      }
+    end
+  end
+
+  def total_scenarios features
+    how_many = 0
+    features.each do |feature|
+      scenarios = feature["elements"]
+      how_many += scenarios.count if scenarios
+    end
+    how_many
+  end
+
+  def failed_scenarios feature
+    scenarios = feature["elements"]
+    scenarios.select{ |scenario|
+      steps = scenario["steps"]
+      steps.any?{ |step| step["result"] && step["result"]["status"] != PASSED }
+    }
+  end
+
+  def total_passed_scenarios features
+    how_many = 0
+    features.each do |feature|
+      how_many += passed_scenarios(feature).count
+    end
+    how_many
+  end
+
+  def total_failed_scenarios features
+    how_many = 0
+    features.each do |feature|
+      how_many += failed_scenarios(feature).count
+    end
+    how_many
+  end
+
+  def total_passed_features features
+    how_many = 0
+    features.each do |feature|
+      how_many += 1 if feature_passed?(feature)
+    end
+    how_many
+  end
+
+  def total_failed_features features
+    how_many = 0
+    features.each do |feature|
+      how_many += 1 if !feature_passed?(feature)
+    end
+    how_many
+  end
+
+  def feature_passed_scenarios_percentage feature
+    (passed_scenarios(feature).count.to_f/feature["elements"].count.to_f).round(2) * 100.00
+  end
+
+  def feature_failed_scenarios_percentage feature
+    (failed_scenarios(feature).count.to_f/feature["elements"].count.to_f).round(2) * 100.00
+  end
+
+  def total_passed_scenarios_percentage features
+    (total_passed_scenarios(features).to_f/total_scenarios(features).to_f).round(2) * 100.00
+  end
+
+  def total_passed_features_percentage features
+    (total_passed_features(features).to_f/features.count.to_f).round(2) * 100.00
+  end
+
+  def total_failed_scenarios_percentage features
+    (total_failed_scenarios(features).to_f/total_scenarios(features).to_f).round(2) * 100.00
+  end
+
+  def total_failed_features_percentage features
+    (total_failed_features(features).to_f/features.count.to_f).round(2) * 100.00
+  end
+
+  def feature_passed? feature
+    passed_scenarios(feature).count == feature["elements"].count
+  end
+
+  def format_duration(nanoseconds)
+    duration_in_seconds = nanoseconds.to_f/1000000000.0
+    m, s = duration_in_seconds.divmod(60)
+    "#{m}m #{format('%.3f', s)}s"
+  end
+
+  def passed_features features
+    features.select{ |feature| passed_scenarios(feature) == feature["elements"].count }
+  end
+
+  def failed_features features
+    features.select{ |feature| failed_scenarios(feature) == feature["elements"].count }
+  end
+
+  def feature_duration feature
+    scenarios = feature["elements"]
+    how_long = 0
+    scenarios.each do |scenario|
+      how_long += scenario_duration(scenario)
+    end
+    how_long
+  end
+
+  def scenario_duration scenario
+    how_long = 0
+    scenario["steps"].each do |step|
+      how_long += step["result"]["duration"] if step["result"] && step["result"]["duration"]
+    end
+    how_long
+  end
+
+  def passed_scenarios feature
+      scenarios = feature["elements"]
+      scenarios.select{ |scenario|
+        steps = scenario["steps"]
+        steps.all?{ |step| step["result"] && step["result"]["status"] == PASSED }
+      }
+  end
+
+  def feature_id feature
+    Digest::SHA256.hexdigest("#{feature["id"].strip}#{feature["uri"].strip}")
+  end
+end