kraken-mobile 1.0.0

data/calabash-android-features-skeleton/my_first.feature

@@ -0,0 +1,11 @@
+Feature: Example feature
+
+  @user1
+  Scenario: As a first user I say hi to a second user
+    Given I wait
+    Then I send a signal to user 2 containing "hi"
+
+  @user2
+  Scenario: As a second user I wait for user 1 to say hi
+    Given I wait for a signal containing "hi"
+    Then I wait

data/calabash-android-features-skeleton/step_definitions/kraken_steps.rb

@@ -0,0 +1 @@
+require 'kraken-mobile/runners/calabash/android/kraken_steps'

data/calabash-android-features-skeleton/support/app_installation_hooks.rb

@@ -0,0 +1,25 @@
+require 'calabash-android/management/app_installation'
+
+AfterConfiguration do |config|
+  FeatureMemory.feature = nil
+end
+
+Before do |scenario|
+  scenario = scenario.scenario_outline if scenario.respond_to?(:scenario_outline)
+
+  feature = scenario.feature
+  if FeatureMemory.feature != feature || ENV['RESET_BETWEEN_SCENARIOS'] == '1'
+    if ENV['RESET_BETWEEN_SCENARIOS'] == '1'
+      log 'New scenario - reinstalling apps'
+    else
+      log 'First scenario in feature - reinstalling apps'
+    end
+    clear_app_data
+    FeatureMemory.feature = feature
+    FeatureMemory.invocation = 1
+  else
+    FeatureMemory.invocation += 1
+  end
+end
+
+FeatureMemory = Struct.new(:feature, :invocation).new

data/calabash-android-features-skeleton/support/app_life_cycle_hooks.rb

@@ -0,0 +1,10 @@
+require 'kraken-mobile/runners/calabash/android/Operations'
+
+Before do |scenario|
+  start_kraken_test_server_in_background scenario
+end
+
+After do |scenario|
+  shutdown_kraken_test_server scenario
+  uninstall_app_with_calabash
+end

data/calabash-android-features-skeleton/support/env.rb

@@ -0,0 +1 @@
+require 'kraken-mobile/runners/calabash/android/cucumber'

data/lib/kraken-mobile.rb

@@ -0,0 +1,29 @@
+require 'kraken-mobile/runners/calabash/android/android_runner'
+require 'kraken-mobile/runners/calabash/monkey/monkey_runner'
+require 'kraken-mobile/constants'
+
+module KrakenMobile
+	class App
+		# Constructors
+		def initialize(options)
+			@options = options
+			@runner = current_runner
+		end
+
+		# Helpers
+		def run_in_parallel
+      @runner.run_in_parallel
+		end
+
+    def current_runner
+      case @options[:runner]
+      when KrakenMobile::Constants::CALABASH_ANDROID
+        Runner::CalabashAndroidRunner.new(@options)
+      when KrakenMobile::Constants::MONKEY
+        Runner::MonkeyRunner.new(@options)
+      else
+        raise "Invalid Kraken runner."
+      end
+    end
+	end
+end

data/lib/kraken-mobile/constants.rb

@@ -0,0 +1,25 @@
+module KrakenMobile
+  module Constants
+    # Runners
+    CALABASH_ANDROID = "calabash-android"
+    MONKEY = "monkey"
+    REPORT_PATH = "./reports"
+    REPORT_DEVICES_FILE_NAME = "devices"
+    REPORT_FILE_NAME = "report"
+    D3_DATA_FILE_NAME = "data"
+
+    # Protocols
+    FILE_PROTOCOL = "file-based"
+    SUPPORTED_PROTOCOLS = [FILE_PROTOCOL]
+
+    # Protocol
+    DEVICE_INBOX_NAME = "inbox"
+    KRAKEN_CONFIGURATION_FILE_NAME = "kraken_settings"
+    DEFAULT_TIMEOUT = 10
+    MONKEY_DEFAULT_TIMEOUT = 5
+
+    # ADB Orientations
+    PORTRAIT = 0
+    LANDSCAPE = 1
+  end
+end

data/lib/kraken-mobile/helpers/command_helper.rb

@@ -0,0 +1,38 @@
+module KrakenMobile
+	class CommandHelper
+		def user_is_using_windows
+			RbConfig::CONFIG['host_os'] =~ /cygwin|mswin|mingw|bccwin|wince|emx/
+		end
+
+		def terminal_command_separator
+			user_is_using_windows ? ' & ' : ';'
+		end
+
+		def build_command commands
+			commands.compact*' '
+		end
+
+    # Exports a list of environment variables to the users computer.
+		def build_export_env_command env_variables
+			commands = env_variables.map { |key, value|
+				user_is_using_windows ? "(SET \"#{key}=#{value}\")" : "#{key}=#{value};export #{key}"
+			}
+			commands.join(terminal_command_separator)
+		end
+
+		def execute_command process_number, command
+			output = open("|#{command}", 'r') { |output| show_output(output, process_number)  }
+			exitstatus = $?.exitstatus
+		end
+
+		def show_output(output, process_number)
+			loop do
+				begin
+					line = output.readline()
+					$stdout.print "#{process_number}> #{line}"
+					$stdout.flush
+				end
+			end rescue EOFError
+		end
+	end
+end

data/lib/kraken-mobile/helpers/devices_helper/adb_helper.rb

@@ -0,0 +1,157 @@
+require 'kraken-mobile/models/device'
+require 'kraken-mobile/constants'
+
+module KrakenMobile
+	module DevicesHelper
+		class AdbHelper
+      # ADB command that returns all phones and emulators connected to the computer.
+			def adb_devices_l
+				`adb devices -l`
+			end
+
+      def file_content file_name, device_id
+        `adb -s #{device_id} shell "cat /sdcard/#{file_name} 2> /dev/null"`
+      end
+
+      def write_content_to_device content, file_name, device_id
+        `adb -s #{device_id} shell "echo "#{content}" > /sdcard/#{file_name}"`
+      end
+
+      def create_file_in_device file_name, device_id
+        `adb -s #{device_id} shell "> /sdcard/#{file_name}"`
+      end
+
+      def delete_file_in_device file_name, device_id
+        `adb -s #{device_id} shell "rm -rf /sdcard/#{file_name}"`
+      end
+
+      def device_screen_size device_id
+        `adb -s #{device_id} shell wm size`
+      end
+
+      def device_sdk_version device_id
+        `adb -s #{device_id} shell getprop ro.build.version.sdk`
+      end
+
+      def device_orientation device_id
+        `adb -s #{device_id} shell dumpsys input | grep 'SurfaceOrientation' | awk '{ print $2 }'`
+      end
+
+      def is_device_connected device_id
+        begin
+         adb_devices_l.include?(device_id)
+        rescue
+          false
+        end
+      end
+
+      # Returns an array with all the devices and emulators connected to the computer.
+			def connected_devices
+				begin
+					devices = []
+					list =
+						adb_devices_l.split("\n").each do |line|
+							line_id = extract_device_id(line)
+							line_model = extract_device_model(line)
+							if line_id && line_model
+								device = Models::Device.new(line_id, line_model, devices.size + 1)
+								devices << device
+							end
+						end
+					devices
+				rescue
+					[]
+				end
+			end
+
+      def read_file_content file_name, device_id
+        begin
+          raise "Device #{device_id} not found" unless is_device_connected(device_id)
+          content = file_content("#{file_name}.txt", device_id)
+          content.strip
+        rescue
+          ""
+        end
+      end
+
+      def write_content_to_file content, file_name, device_id
+        begin
+          raise "Device #{device_id} not found" unless is_device_connected(device_id)
+          write_content_to_device(content, "#{file_name}.txt", device_id)
+          true
+        rescue
+          false
+        end
+      end
+
+      def create_file file_name, device_id
+        begin
+          raise "Device #{device_id} not found" unless is_device_connected(device_id)
+          create_file_in_device("#{file_name}.txt", device_id)
+          true
+        rescue
+          false
+        end
+      end
+
+      def delete_file file_name, device_id
+        begin
+          raise "Device #{device_id} not found" unless is_device_connected(device_id)
+          delete_file_in_device("#{file_name}.txt", device_id)
+          true
+        rescue
+          false
+        end
+      end
+
+      # Returns height, width
+      def screen_size device_id
+        begin
+          adb_size = device_screen_size device_id
+          parts = adb_size.strip!.split(" ")
+          size = parts[parts.count-1]
+          return 0,0 if !size.include?("x")
+          size_parts = size.split("x")
+          if orientation(device_id) == KrakenMobile::Constants::PORTRAIT
+            return size_parts[1].to_i, size_parts[0].to_i
+          else
+            return size_parts[0].to_i, size_parts[1].to_i
+          end
+        rescue
+          return 0,0
+        end
+      end
+
+      def sdk_version device_id
+        begin
+          return device_sdk_version device_id
+        rescue
+          return "N/A"
+        end
+      end
+
+      def orientation device_id
+        begin
+          adb_orientation = device_orientation(device_id).strip!
+          return adb_orientation.to_i
+        rescue
+          return KrakenMobile::Constants::PORTRAIT
+        end
+      end
+
+      # Parses the device id from the ADB devices command.
+			def extract_device_id line
+				if line.match(/device(?!s)/)
+					line.split(" ").first
+				end
+			end
+
+      # Parses the device model from the ADB devices command.
+			def extract_device_model line
+				if line.match(/device(?!s)/)
+					line.scan(/model:(.*) device/).flatten.first
+				end
+			end
+		end
+	end
+end

data/lib/kraken-mobile/helpers/devices_helper/manager.rb

@@ -0,0 +1,43 @@
+require 'kraken-mobile/models/device'
+require 'kraken-mobile/helpers/devices_helper/adb_helper'
+require 'kraken-mobile/constants'
+require 'json'
+
+module KrakenMobile
+	module DevicesHelper
+    class Manager
+      def initialize(options)
+        @runner_name = options[:runner]
+        @config_path = options[:config_path]
+      end
+
+      def connected_devices
+        if @config_path
+          raise "The path of the configuration file is not valid" unless File.exist?(@config_path) && File.file?(@config_path) && @config_path.end_with?(".json")
+          file = open(@config_path)
+          content = file.read
+          configured_devices = JSON.parse(content)
+          devices = []
+          configured_devices.each do |dev_data|
+            device = Models::Device.new(dev_data["id"], dev_data["model"], devices.size + 1, dev_data["config"])
+            devices << device
+          end
+          devices
+        else
+          device_helper.connected_devices
+        end
+      end
+
+      def device_helper
+        case @runner_name
+        when KrakenMobile::Constants::CALABASH_ANDROID
+          DevicesHelper::AdbHelper.new()
+        when KrakenMobile::Constants::MONKEY
+          DevicesHelper::AdbHelper.new()
+        else
+          raise "Runner is not supported"
+        end
+      end
+    end
+	end
+end

data/lib/kraken-mobile/helpers/feature_analyzer.rb

@@ -0,0 +1,28 @@
+require 'gherkin/parser'
+require 'gherkin/pickles/compiler'
+
+def ensure_features_format files
+  files.each do |file_path|
+    ensure_feature_has_unique_tags file_path
+  end
+end
+
+def ensure_feature_has_unique_tags file_path
+  parser = Gherkin::Parser.new
+  file = open(file_path)
+  content = file.read
+  gherkin_document = parser.parse(content)
+  pickles = Gherkin::Pickles::Compiler.new.compile(gherkin_document)
+  tag_hash = {}
+  pickles.each do |scenario|
+    raise "Scenario '#{scenario[:name]}' can't have more than one @user{int} tag." if scenario[:tags].select{ |tag| tag[:name].start_with? "@user" }.count > 1
+    scenario[:tags].each do |tag|
+      tag_name = tag[:name]
+      if tag_hash[tag_name]
+        raise "Tag #{tag_name} is duplicated. Each feature can only have one @user{:int} tag assigned to a scenario."
+      else
+        tag_hash[tag_name] = tag_name
+      end
+    end
+  end
+end

data/lib/kraken-mobile/helpers/feature_grouper.rb

@@ -0,0 +1,48 @@
+require 'json'
+require 'kraken-mobile/helpers/feature_analyzer'
+
+module KrakenMobile
+  class FeatureGrouper
+    # Returns files in feature_folder distributed equally in group size.
+    def self.distributed_file_groups(feature_folder, group_size)
+      files = feature_files_in_folder feature_folder
+      groups = create_file_groups group_size,files
+      groups
+    end
+
+    # All groups contains all files in feature_folder
+    def self.file_groups(feature_folder, group_size)
+      files = feature_files_in_folder feature_folder
+      ensure_features_format files
+      group_size.times.map { files }
+    end
+
+    def self.create_file_groups group_size, files
+      files_per_group = files.size/group_size
+      number_of_remaining_files = files.size % group_size
+      groups = Array.new(group_size) { []  }
+      groups.each do |group|
+        files_per_group.times {
+          group << files.delete_at(0)
+        }
+      end
+      unless number_of_remaining_files == 0
+        groups[0..(number_of_remaining_files-1)].each do |group|
+          group << files.delete_at(0)
+        end
+      end
+      groups.reject(&:empty?)
+    end
+
+    def self.feature_files_in_folder(feature_dir_or_file)
+      if File.directory?(feature_dir_or_file) # Is a folder containing feature files.
+        files = Dir[File.join(feature_dir_or_file, "**{,/*/**}/*")].uniq
+        files.grep(/\.feature$/)
+      elsif feature_dir_or_file.include?('.feature') # Is a feature file.
+        [feature_dir_or_file]
+      else
+        []
+      end
+    end
+  end
+end

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

@@ -0,0 +1,381 @@
+require 'kraken-mobile/constants'
+require 'digest'
+require 'json'
+
+module KrakenMobile
+	class Reporter
+
+    PASSED = 'passed'
+    FAILED = 'failed',
+    SKIPPED = 'skipped',
+    PENDING = 'pending',
+    NOT_DEFINED = 'undefined',
+    AMBIGUOUS = 'ambiguous'
+
+    def initialize(execution_id, options)
+      @execution_id = execution_id
+      @options = options
+    end
+
+    #-------------------------------
+    # Generator
+    #-------------------------------
+    def generate_general_report
+      erb_file = File.join(File.expand_path("../../../../reporter/", __FILE__), "index.html.erb")
+      html_file = File.join(File.expand_path("#{KrakenMobile::Constants::REPORT_PATH}/#{@execution_id}/"), "index.html")
+      # Variables
+      report_file = open("#{KrakenMobile::Constants::REPORT_PATH}/#{@execution_id}/#{KrakenMobile::Constants::REPORT_DEVICES_FILE_NAME}.json")
+      content = report_file.read
+      @devices = JSON.parse(content)
+      devices_report = report_by_devices(@devices)
+      @features_report = fetures_from_report_by_devices devices_report
+      data_hash = feature_by_nodes_and_links @features_report
+      file = open("#{KrakenMobile::Constants::REPORT_PATH}/#{@execution_id}/assets/js/#{KrakenMobile::Constants::D3_DATA_FILE_NAME}.json", 'w')
+      file.puts(data_hash.to_json)
+      file.close
+      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 generate_device_report device
+      @apk_path = device.config["apk_path"] ? device.config["apk_path"] : @options[:apk_path]
+      report_file = open("#{KrakenMobile::Constants::REPORT_PATH}/#{@execution_id}/#{device.id}/#{KrakenMobile::Constants::REPORT_FILE_NAME}.json")
+      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("#{KrakenMobile::Constants::REPORT_PATH}/#{@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
+
+    def report_by_devices devices
+      devices_report = {}
+      devices.each do |device|
+        next if !File.exists?("#{KrakenMobile::Constants::REPORT_PATH}/#{@execution_id}/#{device['id']}/#{KrakenMobile::Constants::REPORT_FILE_NAME}.json")
+        report_file = open("#{KrakenMobile::Constants::REPORT_PATH}/#{@execution_id}/#{device['id']}/#{KrakenMobile::Constants::REPORT_FILE_NAME}.json")
+        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 generate_features_report features, device
+      features.each do |feature|
+        generate_feature_report feature, device
+      end
+    end
+
+    def generate_feature_report feature, device
+      Dir.mkdir("#{KrakenMobile::Constants::REPORT_PATH}/#{@execution_id}/#{device.id}/features_report") unless File.exists?("#{KrakenMobile::Constants::REPORT_PATH}/#{@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("#{KrakenMobile::Constants::REPORT_PATH}/#{@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
+
+    # 0: create 1: commit 2: merge
+    def branches features_report
+      branches = {}
+      features_report.keys.each do |key|
+        report = features_report[key]
+        branches[report["hash"]] = {} if !branches[report["hash"]]
+        branches[report["hash"]]["steps"]= [] if !branches[report["hash"]]["steps"]
+        devices = report["devices"]
+        devices.keys.each do |device_key|
+          branches[report["hash"]]["steps"] << { type: 0, name: device_key }
+          feature_steps = devices[device_key][0]["steps"] if devices[device_key].count > 0 && devices[device_key][0]["steps"]
+          feature_steps.each do |step|
+            hash_step = { type: 1, name: device_key}
+            hash_step[:image] = step["after"][0]["embeddings"][0] if step["after"].count > 0 && step["after"][0]["embeddings"] && step["after"][0]["embeddings"].count > 0
+            branches[report["hash"]]["steps"] << hash_step
+          end
+        end
+      end
+      branches
+    end
+
+    #-------------------------------
+    # Helpers
+    #-------------------------------
+    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 feature_id feature
+      Digest::SHA256.hexdigest("#{feature["id"].strip}#{feature["uri"].strip}")
+    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 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
+  end
+end