highway 0.0.1 → 1.0.1

data/lib/highway/steps/library/testflight.rb

@@ -0,0 +1,105 @@
+#
+# testflight.rb
+# Copyright © 2019 Netguru S.A. All rights reserved.
+#
+
+require "fastlane"
+
+require "highway/steps/infrastructure"
+
+module Highway
+    module Steps
+      module Library
+
+        class TestFlightStep < Step
+
+          def self.name
+            "testflight"
+          end
+
+          def self.parameters
+            [
+              Parameters::Single.new(
+                name: "apple_id",
+                required: true,
+                type: Types::String.new()
+              ),
+              Parameters::Single.new(
+                name: "app_specific_password",
+                required: false,
+                type: Types::String.new()
+              ),
+              Parameters::Single.new(
+                name: "password",
+                required: false,
+                type: Types::String.new()
+              ),
+              Parameters::Single.new(
+                name: "session",
+                required: false,
+                type: Types::String.new()
+              ),
+              Parameters::Single.new(
+                name: "skip_submission",
+                required: false,
+                default: true,
+                type: Types::Bool.new()
+              ),
+              Parameters::Single.new(
+                name: "skip_waiting_for_build_processing",
+                required: false,
+                default: true,
+                type: Types::Bool.new()
+              ),
+              Parameters::Single.new(
+                name: "team_name",
+                required: false,
+                type: Types::String.new()
+              ),
+              Parameters::Single.new(
+                name: "username",
+                required: true,
+                type: Types::String.regex(/^\S+@\S+\.\S+$/)
+              )
+            ]
+          end
+
+          def self.run(parameters:, context:, report:)
+
+            password = parameters["password"]
+            app_specific_password = parameters["app_specific_password"]
+            session = parameters["session"]
+
+            if password.nil? && app_specific_password.nil?
+              context.interface.fatal!("You need to provide an account password or application specific password! Additionally if you have enabled two-step verification, you will need to provide generated session.")
+            end
+
+            username = parameters["username"]
+            apple_id = parameters["apple_id"]
+            team_name = parameters["team_name"]
+            skip_submission = parameters["skip_submission"]
+            skip_waiting_for_build_processing = parameters["skip_waiting_for_build_processing"]
+
+            env = {
+              "FASTLANE_APPLE_APPLICATION_SPECIFIC_PASSWORD" => app_specific_password,
+              "FASTLANE_PASSWORD" => password,
+              "FASTLANE_SESSION" => session
+            }
+
+            context.with_modified_env(env) {
+              context.run_action("upload_to_testflight", options: {
+                username: username,
+                skip_submission: skip_submission,
+                skip_waiting_for_build_processing: skip_waiting_for_build_processing,
+                apple_id: apple_id,
+                team_name: team_name
+              })
+            }
+  
+          end
+
+        end
+
+      end
+    end
+end

data/lib/highway/steps/library/xcode_archive.rb

@@ -0,0 +1,162 @@
+#
+# xcode_archive.rb
+# Copyright © 2019 Netguru S.A. All rights reserved.
+#
+
+require "fastlane"
+require "xcodeproj"
+
+require "highway/steps/infrastructure"
+
+module Highway
+  module Steps
+    module Library
+
+      class XcodeArchiveStep < Step
+
+        def self.name
+          "xcode_archive"
+        end
+
+        def self.parameters
+          [
+            Parameters::Single.new(
+              name: "clean",
+              required: false,
+              type: Types::Bool.new(),
+              default: true,
+            ),
+            Parameters::Single.new(
+              name: "configuration",
+              required: false,
+              type: Types::String.new(),
+            ),
+            Parameters::Single.new(
+              name: "flags",
+              required: false,
+              type: Types::Array.new(Types::String.new()),
+              default: [],
+            ),
+            Parameters::Single.new(
+              name: "method",
+              required: true,
+              type: Types::Enum.new("ad-hoc", "app-store", "development", "developer-id", "enterprise", "package"),
+            ),
+            Parameters::Single.new(
+              name: "project",
+              required: true,
+              type: Types::AnyOf.new(
+                project: Types::String.regex(/.+\.xcodeproj/),
+                workspace: Types::String.regex(/.+\.xcworkspace/),
+              ),
+            ),
+            Parameters::Single.new(
+              name: "scheme",
+              required: true,
+              type: Types::String.new(),
+            ),
+            Parameters::Single.new(
+              name: "settings",
+              required: false,
+              type: Types::Hash.new(Types::String.new(), validate: lambda { |dict| dict.keys.all? { |key| /[A-Z_][A-Z0-9_]*/ =~ key } }),
+              default: {},
+            ),
+          ]
+        end
+
+        def self.run(parameters:, context:, report:)
+
+          # Interpret the parameters. At this point they are parsed and
+          # transformed to be recognizable by Fastlane.
+
+          clean = parameters["clean"]
+          scheme = parameters["scheme"]
+          method = parameters["method"]
+
+          configuration = parameters["configuration"]
+          configuration ||= detect_configuration(parameters)
+
+          flags = parameters["flags"].join(" ")
+          settings = parameters["settings"].map { |setting, value| "#{setting}=\"#{value.shellescape}\"" }.join(" ")
+
+          xcargs = flags + settings
+          xcargs = nil if xcargs.empty?
+
+          project_key = parameters["project"][:tag]
+          project_value = parameters["project"][:value]
+
+          # Prepare artifacts. Create temporary directories, get file names that
+          # will be later passed to the build command.
+
+          output_raw_temp_dir = Dir.mktmpdir()
+          output_raw_path = report.prepare_artifact("raw.log")
+
+          output_ipa_path = report.prepare_artifact("archive.ipa")
+          output_ipa_dir = File.dirname(output_ipa_path)
+          output_ipa_file = File.basename(output_ipa_path)
+
+          # Run the build and archival.
+
+          context.run_action("build_ios_app", options: {
+
+            project_key => project_value,
+
+            clean: clean,
+            configuration: configuration,
+            scheme: scheme,
+            export_method: method,
+
+            xcargs: xcargs,
+            export_xcargs: xcargs,
+
+            buildlog_path: output_raw_temp_dir,
+            output_directory: output_ipa_dir,
+            output_name: output_ipa_file,
+
+          })
+
+          # Save the archive and artifacts subreports in the report.
+
+          report[:archive] = {
+            result: :success
+          }
+
+          report[:artifacts] = {
+            ipa: context.fastlane_lane_context[:IPA_OUTPUT_PATH],
+            dsym: context.fastlane_lane_context[:DSYM_OUTPUT_PATH],
+          }
+
+        end
+
+        private
+
+        def self.detect_configuration(parameters)
+          if parameters["project"][:tag] == :project
+            detect_configuration_from_project(parameters["project"][:value], parameters["scheme"])
+          elsif parameters["project"][:tag] == :workspace
+            detect_configuration_from_workspace(parameters["project"][:value], parameters["scheme"])
+          end
+        end
+
+        def self.detect_configuration_from_project(project_path, scheme_name)
+          return nil unless File.exist?(project_path)
+          project_schemes = Xcodeproj::Project.schemes(project_path)
+          return nil unless project_schemes.include?(scheme_name)
+          scheme_path = File.join(project_path, "xcshareddata", "xcschemes", "#{scheme_name}.xcscheme")
+          return nil unless File.exist?(scheme_path)
+          Xcodeproj::XCScheme.new(scheme_path).archive_action.build_configuration
+        end
+
+        def self.detect_configuration_from_workspace(workspace_path, scheme_name)
+          return nil unless File.exist?(workspace_path)
+          workspace = Xcodeproj::Workspace.new_from_xcworkspace(workspace_path)
+          workspace_schemes = workspace.schemes.reject { |k, v| v.include?("Pods/Pods.xcodeproj") }
+          return nil unless workspace_schemes.keys.include?(scheme_name)
+          detect_configuration_from_project(workspace_schemes[scheme_name], scheme_name)
+        end
+
+      end
+
+    end
+  end
+end

data/lib/highway/steps/library/xcode_test.rb

@@ -0,0 +1,264 @@
+#
+# xcode_test.rb
+# Copyright © 2019 Netguru S.A. All rights reserved.
+#
+
+require "highway/steps/infrastructure"
+
+module Highway
+  module Steps
+    module Library
+
+      class XcodeTestStep < Step
+
+        def self.name
+          "xcode_test"
+        end
+
+        def self.parameters
+          [
+            Parameters::Single.new(
+              name: "clean",
+              type: Types::Bool.new(),
+              required: false,
+              default: true,
+            ),
+            Parameters::Single.new(
+              name: "configuration",
+              type: Types::String.new(),
+              required: false,
+            ),
+            Parameters::Single.new(
+              name: "device",
+              type: Types::String.new(),
+              required: false,
+            ),
+            Parameters::Single.new(
+              name: "flags",
+              type: Types::Array.new(Types::String.new()),
+              required: false,
+              default: [],
+            ),
+            Parameters::Single.new(
+              name: "project",
+              type: Types::AnyOf.new(
+                project: Types::String.regex(/.+\.xcodeproj/),
+                workspace: Types::String.regex(/.+\.xcworkspace/),
+              ),
+              required: true,
+            ),
+            Parameters::Single.new(
+              name: "scheme",
+              type: Types::String.new(),
+              required: true,
+            ),
+            Parameters::Single.new(
+              name: "skip_build",
+              type: Types::Bool.new(),
+              required: false,
+              default: false,
+            ),
+            Parameters::Single.new(
+              name: "settings",
+              type: Types::Hash.new(Types::String.new(), validate: lambda { |dict| dict.keys.all? { |key| /[A-Z_][A-Z0-9_]*/ =~ key } }),
+              required: false,
+              default: {},
+            ),
+            Parameters::Single.new(
+              name: "code_coverage",
+              type: Types::Bool.new(),
+              required: false,
+            )
+          ]
+        end
+
+        def self.run(parameters:, context:, report:)
+
+          # Interpret the parameters. At this point they are parsed and
+          # transformed to be recognizable by Fastlane.
+
+          clean = parameters["clean"]
+          configuration = parameters["configuration"]
+          device = parameters["device"]
+          scheme = parameters["scheme"]
+          skip_build = parameters["skip_build"]
+          code_coverage = parameters["code_coverage"]
+
+          flags = parameters["flags"].join(" ")
+          settings = parameters["settings"].map { |setting, value| "#{setting}=\"#{value.shellescape}\"" }.join(" ")
+
+          xcargs = flags + settings
+          xcargs = nil if xcargs.empty?
+
+          project_key = parameters["project"][:tag]
+          project_value = parameters["project"][:value]
+
+          # Prepare artifacts. Create temporary directories, get file names that
+          # will be later passed to the build command.
+
+          output_raw_temp_dir = Dir.mktmpdir()
+          output_raw_path = report.prepare_artifact("raw.log")
+
+          output_html_path = report.prepare_artifact("report.html")
+          output_junit_path = report.prepare_artifact("report.junit")
+
+          output_html_file = File.basename(output_html_path)
+          output_junit_file = File.basename(output_junit_path)
+
+          # Configure xcpretty. Set custom locations of report artifacts so that
+          # we can track them accurately.
+
+          output_dir = context.artifacts_dir
+          output_types = ["html", "junit"].join(",")
+          output_files = [output_html_file, output_junit_file].join(",")
+
+          # Prepare temporary variables.
+
+          report_test = {}
+          report_artifacts = {}
+          rescued_error = nil
+
+          # Run the build and test.
+
+          begin
+
+            context.run_action("run_tests", options: {
+
+              project_key => project_value,
+
+              clean: clean,
+              configuration: configuration,
+              device: device,
+              scheme: scheme,
+              code_coverage: code_coverage,
+              skip_build: skip_build,
+
+              xcargs: xcargs,
+
+              buildlog_path: output_raw_temp_dir,
+              output_directory: output_dir,
+              output_types: output_types,
+              output_files: output_files,
+
+            })
+
+          rescue FastlaneCore::Interface::FastlaneBuildFailure => error
+
+            # A compile error occured. Save it to be re-raised later.
+
+            report_test[:result] = :error
+            rescued_error = error
+
+          rescue FastlaneCore::Interface::FastlaneTestFailure => error
+
+            # A test failure occured. Save it to be re-raised later.
+
+            report_test[:result] = :failure
+            rescued_error = error
+
+          else
+
+            # Build succeeded!
+
+            report_test[:result] = :success
+
+          end
+
+          # Now the real fun begins. Move the raw xcodebuild log from temporary
+          # directory to artifacts directory.
+
+          output_raw_temp_path = Dir.glob(File.join(output_raw_temp_dir, "*.log")).first
+          unless output_raw_temp_path.nil?
+            FileUtils.mv(output_raw_temp_path, output_raw_path)
+          end
+
+          # Save the artifact paths in the subreport.
+
+          report_artifacts[:raw] = output_raw_path
+          report_artifacts[:html] = output_html_path
+          report_artifacts[:junit] = output_junit_path
+
+          # Load the raw log and pipe it through xcpretty with a JSON formatter.
+          # That will output a machine-readable information about everything
+          # that happened in the build.
+
+          xcpretty_json_formatter_path = context.run_sh("xcpretty-json-formatter", bundle_exec: true, silent: true)
+          temp_json_report_path = File.join(Dir.mktmpdir(), "report.json")
+
+          context.with_modified_env({"XCPRETTY_JSON_FILE_OUTPUT" => temp_json_report_path}) do
+            context.run_sh(["cat", output_raw_path, "| xcpretty --formatter", xcpretty_json_formatter_path], bundle_exec: true, silent: true)
+          end
+
+          # Export JSON file report to environment variable
+
+          context.env["XCODE_TEST_JSON_REPORT_PATH"] = temp_json_report_path
+
+          # Load the build report and a JUnit report into memory.
+
+          junit_report = Scan::TestResultParser.new.parse_result(File.read(output_junit_path))
+          if File.exist?(temp_json_report_path)
+            xcode_report = JSON.parse(File.read(temp_json_report_path))
+          else
+            xcode_report = Hash.new()
+          end
+
+          # Extract test numbers from JUnit report.
+
+          report_test_count = {}
+
+          report_test_count[:all] = junit_report[:tests]
+          report_test_count[:failed] = junit_report[:failures]
+          report_test_count[:succeeded] = report_test_count[:all] - report_test_count[:failed]
+
+          report_test[:count] = report_test_count
+
+          # Extract compile errors from the build report.
+
+          report_test_errors = []
+
+          report_test_errors += xcode_report.fetch("file_missing_errors", []).map { |entry|
+            {location: File.basename(entry["file_path"]), reason: entry["reason"]}
+          }
+
+          report_test_errors += xcode_report.fetch("compile_errors", []).map { |entry|
+            {location: File.basename(entry["file_path"]), reason: entry["reason"]}
+          }
+
+          report_test_errors += xcode_report.fetch("undefined_symbols_errors", []).map { |entry|
+            {location: entry["symbol"], reason: entry["message"]}
+          }
+
+          report_test_errors += xcode_report.fetch("format_duplicate_symbols", []).map {
+            {location: nil, reason: entry["message"]}
+          }
+
+          report_test_errors += xcode_report.fetch("errors", []).map { |entry|
+            {location: nil, reason: entry}
+          }
+
+          report_test[:errors] = report_test_errors
+
+          # Extract test failures from the build report.
+
+          report_test_failures = xcode_report.fetch("tests_failures", {}).values.flatten.map { |entry|
+            {location: entry["test_case"], reason: entry["reason"]}
+          }
+
+          report_test[:failures] = report_test_failures
+
+          # Save the test and artifacts subreports in the report.
+
+          report[:test] = report_test
+          report[:artifacts] = report_artifacts
+
+          # Re-raise the error after the report is finally prepared.
+
+          raise rescued_error if rescued_error != nil
+
+        end
+
+      end
+
+    end
+  end
+end