golden_rose 0.1.0 → 1.0.0.pre

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 760134cb39e5e84e51797d064d8fc4b3d0e772c6
-  data.tar.gz: 8c7386d6714e8070b30dc08d171dc4b8ed0fecf0
+  metadata.gz: 87af3920c30c7c90ea498eaea2646802c77f4024
+  data.tar.gz: 645e890496f6343dba1f30041a4f2757303d224e
 SHA512:
-  metadata.gz: 7911d91360192b462d5bb6fb84caa94ec511325279cdea31b8510a4a0bc7a84ed0b155ccec786a567edf97be6c06100d10c39920d13b470efd1f91a9a57805bb
-  data.tar.gz: 14035a0968b6809fad19fd6845227cae7407cc46cf6f281144590f75afd813247ae0141ca8133e0201f31a8023150afe6da9092a7217a2ddd6dad3ee51794065
+  metadata.gz: e284409105b20bac7246a24ca1b81e2633ba05659fbcbd918d8f74342154797197a5dd0eeef4df011baeeba24ff8daf7fa655954f847c8eac550c9724289b650
+  data.tar.gz: 2d9368a84c7255be44b7803079a0b6e100e16b3c7eab4a45afbb8be63fbb694984387deafc5e044035fbb7decd2bd8f4e5e0175f35224408d32f210896f52439

data/.gitignore

@@ -7,3 +7,4 @@
 /pkg/
 /spec/reports/
 /tmp/
+/goldenrose

data/README.md

@@ -1,6 +1,7 @@
 # GoldenRose
 
-[![License](https://img.shields.io/badge/license-MIT-green.svg?style=flat)](https://github.com/PGSSoft/GoldenRose/blob/master/LICENSE)
+[![Gem](https://img.shields.io/gem/v/golden_rose.svg)](https://rubygems.org/gems/golden_rose)
+[![License](https://img.shields.io/github/license/PGSSoft/GoldenRose.svg)](https://github.com/PGSSoft/GoldenRose/blob/master/LICENSE.txt)
 
 A tool for generating reports from Xcode results bundle.
 
@@ -28,17 +29,21 @@ xcodebuild -workspace MyProject.xcworkspace \
 - Generate reports with GoldenRose:
 
 ```bash
-golden_rose generate MyApp.test_result
+golden_rose generate MyApp.test_result [options]
 ```
 
-The tool will generate a report in html format in the current directory.
+The tool will generate a report in html format in the  `goldenrose` directory under the current directory.
+
+### golden_rose command options
+* -o --output - specifies output directory, `goldenrose` by default
+* -f --force-save - if typed then the whole destination directory will be overwritten
 
 ## Features
 
 - [x] UI Automation tests
 - [x] Reading from ZIP files
-- [ ] Unit tests reports
-- [ ] Build logs
+- [x] Unit tests reports
+- [x] Build logs
 - [ ] Code coverage
 - [ ] Fastlane integration
 - [ ] JUnit reports

data/golden_rose.gemspec

@@ -12,7 +12,7 @@ Gem::Specification.new do |spec|
   spec.summary       = %q{A tool for generating reports from Xcode results bundle.}
   spec.description   = %q{A tool for generating reports from Xcode results bundle.
   Analyze results bundle directory created by Xcode during building, testing, running and generates HTML report with results.}
-  spec.homepage      = "https://github.com/PGSSoft/golden_rose"
+  spec.homepage      = "https://github.com/PGSSoft/GoldenRose"
   spec.license       = "MIT"
 
   spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
@@ -25,8 +25,10 @@ Gem::Specification.new do |spec|
   spec.add_dependency "rubyzip"
   spec.add_dependency "thor"
   spec.add_dependency "tilt"
+  spec.add_dependency "rubytree", "~> 0.9.7"
 
   spec.add_development_dependency "bundler", "~> 1.10"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec"
+  spec.add_development_dependency "pry"
 end

data/lib/golden_rose/build_log/build_section.rb

@@ -0,0 +1,56 @@
+module GoldenRose
+  module BuildLog
+    class BuildSection
+      attr_reader :name, :path, :errors
+
+      def initialize(section_logs)
+        @name = section_logs.match(/([a-zA-Z]+(\s[a-zA-Z]+)*)/).to_s
+        @path = match_path(@name, section_logs)
+        @errors = extract_errors(section_logs)
+      end
+
+      def file
+        @file ||= if path?
+                    last_element = @path.split('/').last
+                    last_element if last_element.include?('.')
+                  end
+      end
+
+      def directory
+        @directory ||= file? ? @path.gsub(file, '') : @path
+      end
+
+      def file?
+        !(file.nil? || file.empty?)
+      end
+
+      def path?
+        !(@path.nil? || @path.empty?)
+      end
+
+      def errors?
+        !success?
+      end
+
+      def success?
+        @errors.nil? || @errors.empty?
+      end
+
+      private
+
+      def match_path(name, section_logs)
+        path_patern = /(\/\w([[[\w|-]|\s]\+]*\/?)*(\.[a-zA-Z]+)?)/
+        matched = section_logs.match(/#{name} #{path_patern}/)
+        matched[1] if matched
+      end
+
+      def extract_errors(section_logs)
+        error_strings = section_logs.scan(/error:.[^\r]*/)
+        return if error_strings.empty?
+        error_strings.map do |err|
+          err.gsub(/error:\s*/, '')
+        end
+      end
+    end
+  end
+end

data/lib/golden_rose/build_log/build_target.rb

@@ -0,0 +1,21 @@
+module GoldenRose
+  module BuildLog
+    class BuildTarget
+      attr_reader :head, :sections, :target_name, :project_name
+
+      def initialize(target_logs)
+        @head, *sections = target_logs.scan(/.*?BuildLogSection\d+/i)
+        @target_name = @head.split.first
+        @sections = sections.map { |section| BuildSection.new(section) }
+        @project_name = match_project_name(@target_name, @head)
+      end
+
+      private
+
+      def match_project_name(target_name, head)
+        matched = head.match(/#{target_name} OF PROJECT ([^\/.]*) WITH/)
+        matched[1] if matched
+      end
+    end
+  end
+end

data/lib/golden_rose/build_log/parser.rb

@@ -0,0 +1,40 @@
+module GoldenRose
+  module BuildLog
+    class Parser
+      def initialize(log_path)
+        @log_path = log_path
+      end
+
+      def parse!
+        @build_targets = build_targets_logs.map do |target|
+          BuildTarget.new(target)
+        end
+      end
+
+      def logs
+        @logs ||= read_unzip_xcactivitylog
+      end
+
+      def read_unzip_xcactivitylog
+        XcactivitylogReader.read(@log_path)
+      end
+
+      def build_targets_logs
+        @build_targets_logs ||= parse_build_target_array
+      end
+
+      def parse_build_target_array
+        _, *build_targets_array = logs.split('=== BUILD TARGET')
+        ommit_short_build_target(build_targets_array)
+      end
+
+      def ommit_short_build_target(build_targets_array)
+        build_targets_array.map.with_index do |item, idx|
+          patern = item[/.*===/]
+          next_item = build_targets_array[idx + 1]
+          next_item && next_item[0..patern.size - 1] == patern ? nil : item
+        end.compact
+      end
+    end
+  end
+end

data/lib/golden_rose/build_log.rb

@@ -0,0 +1,3 @@
+require "golden_rose/build_log/build_target"
+require "golden_rose/build_log/parser"
+require "golden_rose/build_log/build_section"

data/lib/golden_rose/child_item.rb

@@ -1,28 +1,87 @@
 # Used for setting single subtest details
 # It represents last level of tests
+require 'tree'
+require 'securerandom'
 
 module GoldenRose
   class ChildItem < SubtestItem
-    attr_reader :status, :time, :failures
+    ActivitySummary = Struct.new(
+      :uuid, :finish_time_interval, :start_time_interval, :title,
+      :has_screenshot_data, :has_snapshot
+    ) do
+      def started_at
+        start_time_interval ? Time.at(start_time_interval) : nil
+      end
+
+      def finished_at
+        finish_time_interval ? Time.at(finish_time_interval) : nil
+      end
+
+      def start_time
+        started_at ? started_at.strftime("%H:%M:%S.%L") : nil
+      end
+
+      def finish_time
+        finished_at ? finished_at.strftime("%H:%M:%S.%L") : nil
+      end
+    end
+
+    attr_reader :status, :time, :failures, :activity_summaries, :uuid
 
     def initialize(source_subtest)
       @status = source_subtest["TestStatus"].downcase
       set_time(source_subtest)
       set_failures(source_subtest)
-
+      @activity_summaries = if source_subtest["ActivitySummaries"]
+                              build_activity_summaries(source_subtest["ActivitySummaries"])
+                            end
+      @uuid = ::SecureRandom.uuid
       super
     end
 
+    def has_activity_summaries
+      @activity_summaries && !(@activity_summaries.children.nil? || @activity_summaries.children.empty?)
+    end
+
+    def instance
+      self
+    end
+
+    def last_activity_with_screenshot
+      arr = [];
+      return unless @activity_summaries
+      @activity_summaries.each do |node|
+        next if node.is_root? || !node.content.has_screenshot_data
+        arr << { uuid: node.content.uuid, timestamp: node.content.start_time_interval}
+      end
+      arr.max_by { |node| node[:timestamp] }
+    end
+
     private
 
     def set_time(source_subtest)
-      last_time  = source_subtest["ActivitySummaries"].last["FinishTimeInterval"]
-      first_time = source_subtest["ActivitySummaries"].first["StartTimeInterval"]
+      counted_time = source_subtest['Duration'] || count_time_by_interval(source_subtest)
+      return unless counted_time
+      @time = "#{signif_round(counted_time)}s"
+    end
 
-      return unless last_time && first_time
+    # Rounds to 2 significant digits after comma
+    def signif_round(time)
+      return 0.0 if time == 0
+      return time.round(2) if time >= 0.005
+      time_str = "%f" % time
+      first_decimal_digit_idx = time_str.index(time_str[/[1-9]/])
+      rounded = time.round(first_decimal_digit_idx)
+      rounded_str = "%f" % rounded
+      rounded_str[/\d.0*[1-9]+/]
+    end
 
-      counted_time = last_time - first_time
-      @time = "#{counted_time.round(2)}s"
+    def count_time_by_interval(source_subtest)
+      sum_node = source_subtest['ActivitySummaries']
+      last_time = sum_node ? sum_node.last['FinishTimeInterval'] : nil
+      first_time = sum_node ? sum_node.first['StartTimeInterval'] : nil
+      return unless last_time && first_time
+      last_time - first_time
     end
 
     def set_failures(source_subtest)
@@ -36,8 +95,31 @@ module GoldenRose
       end
     end
 
+    def build_activity_summaries(activity_summaries, node = nil)
+      return unless activity_summaries
+      node ||= Tree::TreeNode.new("ROOT", "Root Content")
+
+      activity_summaries.map do |activity_summary|
+        content = ActivitySummary.new(
+          activity_summary['UUID'],
+          activity_summary['FinishTimeInterval'],
+          activity_summary['StartTimeInterval'],
+          activity_summary['Title'],
+          activity_summary['HasScreenshotData'],
+          activity_summary['HasSnapshot']
+        )
+        child = if activity_summary['SubActivities']
+                  build_activity_summaries(activity_summary['SubActivities'], Tree::TreeNode.new(content.uuid, content))
+                else
+                  Tree::TreeNode.new(content.uuid, content)
+                end
+        node << child if child
+      end
+      node
+    end
+
     def hashable_attributes
-      %i(name status time failures)
+      %i(name status time failures uuid has_activity_summaries activity_summaries instance)
     end
   end
-end
+end

data/lib/golden_rose/class_configurator.rb

@@ -0,0 +1,49 @@
+module GoldenRose
+  class ClassConfigurator
+
+    def initialize(source_type, folder_path, output_path)
+      @source_type = source_type
+      @folder_path = folder_path
+      @output_path = output_path
+    end
+
+    def self.configure(source_type, folder_path, output_path)
+      new(source_type, folder_path, output_path).configure
+    end
+
+    def configure
+      add_screenshot_to_each_test
+    end
+
+    private
+
+    def add_screenshot_to_each_test
+      source_type = @source_type
+      folder_path = @folder_path
+      output_path = @output_path
+
+      FileUtils.remove_dir(@output_path + "/screenshots", true)
+
+      GoldenRose::ChildItem.class_eval do
+        @@source_type = source_type
+        @@folder_path = folder_path
+        @@output_path = output_path
+
+        def screenshot
+          return @screenshot if @screenshot
+          screenshot_item = last_activity_with_screenshot
+          return unless screenshot_item
+          dest_path = @@output_path + "/screenshots"
+          FileUtils.mkdir_p dest_path
+          source_path = "Attachments/Screenshot_#{screenshot_item[:uuid]}.png"
+
+          screen = FileResource.new(:screenshoot, @@source_type, @@folder_path, source_path,
+                                    "#{dest_path}/Screenshot_#{screenshot_item[:uuid]}.png")
+          @screenshot = screen.path
+        end
+      end
+    end
+
+
+  end
+end

data/lib/golden_rose/cli/app.rb

@@ -3,18 +3,27 @@ require "thor"
 module GoldenRose
   module CLI
     class App < Thor
+      DEFAULT_OUTPUT_DIR = 'goldenrose'
+
       desc "generate <path_to_folder_or_zip>", "Generate report from a folder"
       method_option :output, type: :string, aliases: "-o"
+      method_option "force-save", type: :boolean, aliases: "-f"
 
       def generate(folder_path)
         say("Started formatting report...")
-        GoldenRose::generate(folder_path, options[:output])
-        say("Report generated in #{options[:output] || Dir.pwd}/index.html", :green)
+        GoldenRose::generate(folder_path, output, options['force-save'])
+        say("Report generated in #{options[:output] || Dir.pwd + '/' + DEFAULT_OUTPUT_DIR}/index.html", :green)
       rescue GoldenRose::GeneratingError => e
         say(e.message, :yellow)
       rescue StandardError => e
         say("Error during running generator.", :red)
       end
+
+      private
+
+      def output
+        options[:output] || DEFAULT_OUTPUT_DIR
+      end
     end
   end
-end
+end

data/lib/golden_rose/execution_details.rb

@@ -1,57 +1,37 @@
 module GoldenRose
   class ExecutionDetails
-    def initialize(parsed_plist, items)
-      @parsed_plist = parsed_plist
-      @items = items
-    end
-
-    def name
-      @parsed_plist["TestableSummaries"].first['TestName']
-    end
-
-    def formatted_time
-      hours = total_time / (60 * 60)
-      minutes = (total_time / 60) % 60
-      seconds = total_time % 60
-
-      "".tap do |time|
-        time << "#{pluralized(hours, 'hour')}, " if hours > 0
-        time << "#{pluralized(minutes, 'minute')} and " if minutes > 0
-        time << "#{pluralized(seconds, 'second')}"
-      end
-    end
+    attr_reader :testable_summaries
 
-    def failures_count
-      @items.reduce(0) { |count, item| count + item[:failures_count].to_i }
-    end
-
-    def total_tests_count
-      @items.reduce(0) { |count, item| count + item[:subtests].count }
-    end
-
-    def passing_count
-      total_tests_count - failures_count
+    def initialize(parsed_plist)
+      @parsed_plist = parsed_plist
+      @testable_summaries = create_testable_summaries
     end
 
     def model_name
-      @parsed_plist["RunDestination"]["TargetDevice"]["ModelName"]
+      @parsed_plist['RunDestination']['TargetDevice']['ModelName']
+    rescue
+      'Undefined'
     end
 
     def os_version
-      @parsed_plist["RunDestination"]["TargetDevice"]["OperatingSystemVersion"]
+      @parsed_plist['RunDestination']['TargetDevice']['OperatingSystemVersion']
+    rescue
+      'Undefined'
     end
 
-    def total_time
-      @items.reduce(0) do |time, item|
-        subtests_time = item[:subtests].reduce(0) do |time, item|
-          time + item[:time].to_f
-        end
-        time + subtests_time
-      end.round
+    def project_name
+      @parsed_plist['TestableSummaries'].first['ProjectPath'].split('/').first.sub(/\..+/, '')
+    rescue
+      nil
     end
 
-    def pluralized(number, noun)
-      "#{number} #{noun}#{'s' if number != 1}"
+    private
+
+    def create_testable_summaries
+      raise GeneratingError, 'Testable summaries not present.' unless @parsed_plist['TestableSummaries']
+      @parsed_plist['TestableSummaries'].map do |testable_summary|
+        TestableSummary.new(testable_summary)
+      end
     end
   end
-end
+end

data/lib/golden_rose/file_resource.rb

@@ -0,0 +1,98 @@
+require 'zip'
+require 'securerandom'
+
+module GoldenRose
+  class FileResource
+    attr_reader :path, :file_name, :folder_path, :source_type, :resource_type
+
+    TEST_SUMMARIES_FILE_NAME = 'action_TestSummaries.plist'
+    INFO_FILE_NAME = 'Info.plist'
+    ALLOWED_RESOURCE_TYPES = [
+      :test_summaries_plist,
+      :info_plist,
+      :build_log,
+      :screenshoot
+    ]
+
+    def initialize(type, source_type, folder_path, file_name = nil, destination = nil)
+      @resource_type = validate_resource_type(type)
+      @source_type = source_type
+      @folder_path = folder_path
+      @destination = destination
+      initialize_filename(file_name)
+      open_source
+    rescue Zip::Error, Errno::ENOENT
+      raise GeneratingError, "Could not open the folder #{folder_path}."
+    end
+
+    def extension
+      @file_name.split('.').last
+    end
+
+    def delete_extracted_file
+      return unless @path
+      File.delete(@path) if source_type == :zip
+    end
+
+    private
+
+    def initialize_filename(file_name)
+      @file_name = case @resource_type
+                   when :test_summaries_plist then TEST_SUMMARIES_FILE_NAME
+                   when :info_plist then INFO_FILE_NAME
+                   else file_name
+                   end
+    end
+
+    def validate_resource_type(type)
+      return type if ALLOWED_RESOURCE_TYPES.include? type
+      fail ArgumentError, "FileResource of #{type} type is disallowed!"
+    end
+
+    def open_source
+      case @source_type
+      when :zip then open_zip
+      when :dir then open_directory(@file_name)
+      end
+    end
+
+    def compare_file_path(expected_path, file_path)
+      path_array = file_path.split('/').reverse
+      expected_path.split('/').reverse.map.with_index do |val, idx|
+        path_array[idx] == val
+      end.all?
+    end
+
+    def open_zip
+      Zip::File.open(folder_path) do |zip_file|
+        entry = zip_file.find do |entry|
+          compare_file_path(@file_name, entry.name)
+        end
+        if entry
+          uuid = ::SecureRandom.uuid
+          @path = if @destination
+                    File.join(GoldenRose.root, "/#{@destination}")
+                  else
+                    File.join(GoldenRose.root, "/source_#{uuid}.#{extension}")
+                  end
+          entry.extract(path)
+        end
+      end
+    end
+
+    def open_directory(file_name)
+      unless @destination
+        @path = Dir.glob("#{folder_path}/**/#{file_name}").first
+        return
+      end
+      source_path = Dir.glob("#{folder_path}/**/#{file_name}").first
+      cp_file(source_path, @destination)
+      dest_arr = @destination.split('/')
+      @path = dest_arr[1..dest_arr.length].join('/')
+    end
+
+    def cp_file(source, destination)
+      FileUtils.cp(source, destination)
+    end
+  end
+end

data/lib/golden_rose/generators/html_format.rb

@@ -3,24 +3,87 @@
 require "haml"
 require "tilt/haml"
 require "pathname"
+require 'fileutils'
 
 module GoldenRose
   module Generators
     class HtmlFormat
-      def initialize(results, output_path = nil)
-        @details     = results.details
-        @items       = results.items
+      def initialize(results, build_logs, output_path = nil, force_save = false)
+        @details     = results
+        @build_logs = build_logs
         @output_path = output_path || ""
+        @force_save = force_save || false
       end
 
       def output
-        file_path = Pathname(@output_path) + "index.html"
+        prepare_output_paths
+        make_output_html("index.html", "index.haml")
+        generate_test_logs if @details
+      end
+
+      def render_partial(path)
+        full_path = "#{GoldenRose.root}/lib/golden_rose/templates/#{path}"
+        render_haml_partial(full_path)
+      end
+
+      def render_asset(file_name, type: :js)
+        asset_path =
+          case type.to_sym
+          when :js then "#{GoldenRose.root}/lib/golden_rose/templates/assets/javascript/"
+          when :css then "#{GoldenRose.root}/lib/golden_rose/templates/assets/styles/"
+          end
+        render_haml_partial(asset_path + file_name)
+      end
+
+
+      def render_subactivities(subactivities)
+        return unless subactivities
+        full_path = "#{GoldenRose.root}/lib/golden_rose/templates/_test_logs.haml"
+        partial = Tilt::HamlTemplate.new(full_path)
+        return unless subactivities.children
+        partial.render(self, activity_summaries:  subactivities.children)
+      end
+
+      def generate_test_logs
+        return unless @details.testable_summaries
+        @details.testable_summaries.each do |testable_summary|
+          testable_summary_name = testable_summary.name
+          next unless testable_summary.items
+          testable_summary.items.each do |item|
+            next unless item[:subtests]
+            item[:subtests].each do |subtest|
+              next unless subtest[:activity_summaries]
+              locals = {
+                testable_summary_name: testable_summary_name, item: item, subtest: subtest,
+                activity_summaries: subtest[:activity_summaries].children
+              }
+              make_output_html("test_logs/#{subtest[:uuid]}.html", "test_logs/index.haml", locals)
+            end
+          end
+        end
+      end
+
+      private
+
+      def render_haml_partial(path)
+        partial = Tilt::HamlTemplate.new(path)
+        partial.render(self)
+      end
+
+      def prepare_output_paths
+        FileUtils.remove_dir(@output_path, true) if @force_save
+        FileUtils.remove_dir(@output_path + "/test_logs", true)
+        FileUtils.mkdir_p @output_path + "/test_logs"
+      end
+
+      def make_output_html(relative_file_path, relative_template, *locals)
+        file_path = Pathname(@output_path) + relative_file_path
         file = File.new(file_path, "w+")
-        template_path = File.join(GoldenRose::root, "/lib/golden_rose/templates/index.haml")
+        template_path = File.join(GoldenRose::root, "/lib/golden_rose/templates/#{relative_template}")
         template = Tilt::HamlTemplate.new(template_path)
-        file.puts template.render(self)
+        file.puts template.render(self, *locals)
         file.close
       end
     end
   end
-end
+end