fastlane-plugin-perfecto 0.1.1 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 82f5d7b6f7e5ea27af278d49c664729a69cf215783ec58cf384a741cd402ebe3
-  data.tar.gz: dae80b7419c950252f8eb2402e92b1a24001ba522711e02c0a34a1304d603687
+  metadata.gz: 5af10b5acb0a274b115a1579efdce4f53759428d387ce3bd89aee501bb24d9aa
+  data.tar.gz: f722fe09bb1cc5c187642ca59bef142f82e75eb2da6b3a0156a569fe38fab0bd
 SHA512:
-  metadata.gz: c1d5dcf6c5f002d5e9a85e7808a5cf9ab000d2b7a96e1ee0ac445ef8635c5cc238332da943ccd8f900ce67fe0a37a303573136a9152a77b2e57ad8ca8aa3343c
-  data.tar.gz: efba9f2a9c5ea6763d006ca40317f851d172bf15bf76cd40bfd91c167e769562bfd7b38cb51c332a457b1040cca0d8af833f751f379c01e6fa79c15ae283aa0a
+  metadata.gz: 458d2df44edf7fd7355552b50640fb6bfc2206085ab512d53c38697116e4dac5d1dea93e154b38e1df3787f5a55f79bcf5fc9fd0dcedf29ac72ddb8ce4f43043
+  data.tar.gz: ebc76b750839a84986cfaff6bdeca39a5258595eaa56d1d1c20ca5a3432a95a7713b341bc0f6b4cab0e196d6d1aaf0c97fca4283dec5d796e7fa116f17b5de1d

data/README.md

@@ -11,10 +11,13 @@ This project is a [_fastlane_](https://github.com/fastlane/fastlane) plugin. To
 fastlane add_plugin perfecto
 ```
 
-## About perfecto
+## About plugin
 
 This plugin allows you to automatically upload ipa/apk files to Perfecto for manual/automation testing
 
+## Updates
+This plugin uses latest v1 upload media API under the hood and supports all file types.
+
 
 ## Example
 
@@ -33,13 +36,37 @@ lane :test do
   )
 end
 ```
+
+Optional parameters:
+
+```
+    artifactType: ENV["artifactType"],
+    artifactName: ENV["artifactName"],
+```
+
 ### Note: <br>
 Pass the below variable values as environment variables:<br>
-PERFECTO_CLOUDURL  [your perfecto cloud url. E.g.: demo.perfectomobile.com]<br>
-PERFECTO_TOKEN [your perfecto [`security token`](https://developers.perfectomobile.com/display/PD/Generate+security+tokens)]<br>
-PERFECTO_MEDIA_LOCATION	[mention the Perfecto media repository location to upload the file mentioned in file_path. E.g. PUBLIC:Samples/sample.ipa]<br>
-file_path [location of your preferred ipa/apk file which needs to be uploaded to perfecto media repository.]<br>
-slack_webhook [Slack incoming webhook for slack integration. more info: [`here`](https://docs.fastlane.tools/actions/slack/)]<br>
+&nbsp;  * PERFECTO_CLOUDURL  [your perfecto cloud url. E.g.: demo.perfectomobile.com]<br>
+&nbsp;	* PERFECTO_TOKEN [your perfecto [`security token`](https://developers.perfectomobile.com/display/PD/Generate+security+tokens)]<br>
+&nbsp;	* PERFECTO_MEDIA_LOCATION	[mention the Perfecto media repository location to upload the file mentioned in file_path. E.g. PUBLIC:Samples/sample.ipa]<br>
+&nbsp;	* file_path [location of your preferred ipa/apk file which needs to be uploaded to perfecto media repository.]<br>
+&nbsp; * artifactType  [Optional: Defines the artifact types, options: GENERAL, IOS, SIMULATOR, ANDROID, IMAGE, AUDIO, VIDEO, SCRIPT]<br>
+&nbsp; * artifactName  [Optional: Used for the representation of the artifact when downloaded.]<br>
+
+## Run tests for this plugin
+
+To run both the tests, and code style validation, run
+
+```
+rake
+```
+
+To automatically fix many of the styling issues, use
+```
+rubocop -a
+```
+
+## Sample project: <br>
 
 Here's a [`sample project`](https://github.com/PerfectoMobileSA/FastlaneEspressoCircleCISlackSample) which demonstrates the usage of this plugin. 
 
@@ -73,20 +100,6 @@ fastlane android slack_report
 ```
 Report perfecto url to slack
 
-
-## Run tests for this plugin
-
-To run both the tests, and code style validation, run
-
-```
-rake
-```
-
-To automatically fix many of the styling issues, use
-```
-rubocop -a
-```
-
 ## Issues and Feedback
 
 For any other issues and feedback about this plugin, please submit it to this repository.

data/lib/fastlane/plugin/perfecto/actions/perfecto_action.rb

@@ -1,37 +1,38 @@
-require 'fastlane/action'
-require_relative '../helper/perfecto_helper'
-require 'json'
+require "fastlane/action"
+require_relative "../helper/perfecto_helper"
+require "json"
 
 module Fastlane
   module Actions
     module SharedValues
       PERFECTO_MEDIA_FULLPATH ||= :PERFECTO_MEDIA_FULLPATH
     end
-    class PerfectoAction < Action
-      SUPPORTED_FILE_EXTENSIONS = ["ipa", "apk"]
 
+    class PerfectoAction < Action
       def self.run(params)
         # Mandatory parameters
         perfecto_cloudurl = params[:perfecto_cloudurl]
         perfecto_token = params[:perfecto_token]
         filepath = params[:file_path].to_s
         perfecto_media_fullpath = params[:perfecto_media_location]
+        artifact_type = params[:artifactType] || ""
+        artifact_nme = params[:artifactName] || ""
 
         # validates the filepath and perfecto media location file
         UI.message("validating filepath")
         validate_filepath(filepath)
-        UI.message("validating  media location")
-        validate_repopath(perfecto_media_fullpath)
+        UI.message("validating media location")
 
         # uploads the ipa/apk to perfecto media repository
         UI.message("Attempting to upload: " + filepath + " to Perfecto!")
-        Helper::PerfectoHelper.upload_file(perfecto_cloudurl, perfecto_token, filepath, perfecto_media_fullpath)
+        # Helper::PerfectoHelper.upload_file(perfecto_cloudurl, perfecto_token, filepath, perfecto_media_fullpath)
+        Helper::PerfectoHelper.upload_v1(perfecto_cloudurl, perfecto_token, filepath, perfecto_media_fullpath, artifact_type, artifact_nme)
         UI.success("The File in: " + filepath + " is successfully uploaded to Perfecto media location : " + perfecto_media_fullpath)
 
         # Setting the environment variable: PERFECTO_MEDIA_FULLPATH with the perfecto media repository location.
-        ENV['PERFECTO_MEDIA_FULLPATH'] = nil
-        ENV['PERFECTO_MEDIA_FULLPATH'] = perfecto_media_fullpath
-        UI.success("Setting Environment variable PERFECTO_MEDIA_FULLPATH = " + ENV['PERFECTO_MEDIA_FULLPATH'])
+        ENV["PERFECTO_MEDIA_FULLPATH"] = nil
+        ENV["PERFECTO_MEDIA_FULLPATH"] = perfecto_media_fullpath
+        UI.success("Setting Environment variable PERFECTO_MEDIA_FULLPATH = " + ENV["PERFECTO_MEDIA_FULLPATH"])
 
         # Setting the media fullpath in shared values post successful upload in order to be used by other fastlane actions.
         Actions.lane_context[SharedValues::PERFECTO_MEDIA_FULLPATH] = perfecto_media_fullpath
@@ -57,26 +58,11 @@ module Fastlane
       # Validate filepath.
       def self.validate_filepath(filepath)
         UI.user_error!("No file found at filepath parameter location.") unless File.exist?(filepath)
-
-        # Validate file extension.
-        filepath_parts = filepath.split(".")
-        unless filepath_parts.length > 1 && SUPPORTED_FILE_EXTENSIONS.include?(filepath_parts.last)
-          UI.user_error!("filepath is invalid, only files with extensions with .ipa or .apk are allowed to be uploaded.")
-        end
-      end
-
-      # Validate media repo path.
-      def self.validate_repopath(perfecto_media_fullpath)
-        # Validate file extension.
-        filepath_parts = perfecto_media_fullpath.split(".")
-        unless filepath_parts.length > 1 && SUPPORTED_FILE_EXTENSIONS.include?(filepath_parts.last)
-          UI.user_error!("perfecto_media_location is invalid, only files with extensions with .ipa or .apk are allowed to be uploaded.")
-        end
       end
 
       def self.output
         [
-          ['perfecto_media_fullpath', 'Perfecto media repo location']
+          ["perfecto_media_fullpath", "Perfecto media repo location"]
         ]
       end
 
@@ -108,12 +94,22 @@ module Fastlane
                                          UI.user_error!("No perfecto_token given.") if value.to_s.empty?
                                        end),
           FastlaneCore::ConfigItem.new(key: :perfecto_media_location,
-                                        description: "Path to Perfecto media location",
-                                        optional: false,
-                                        is_string: true,
-                                        verify_block: proc do |value|
-                                          UI.user_error!("No perfecto_media_location given.") if value.to_s.empty?
-                                        end),
+                                       description: "Path to Perfecto media location",
+                                       optional: false,
+                                       is_string: true,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("No perfecto_media_location given.") if value.to_s.empty?
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :artifactType,
+                                       description: "Optional, Artifact types: GENERAL, IOS, SIMULATOR, ANDROID, IMAGE, AUDIO, VIDEO, SCRIPT",
+                                       optional: true,
+                                       default_value: "",
+                                       is_string: true),
+          FastlaneCore::ConfigItem.new(key: :artifactName,
+                                       description: "Optional, Used for the representation of the artifact when downloaded",
+                                       optional: true,
+                                       default_value: "",
+                                       is_string: true),
           FastlaneCore::ConfigItem.new(key: :file_path,
                                        description: "Path to the app file",
                                        optional: true,
@@ -128,12 +124,14 @@ module Fastlane
 
       def self.example_code
         [
-          'perfecto',
+          "perfecto",
           'perfecto(
             perfecto_cloudurl: ENV["PERFECTO_CLOUDURL"],
             perfecto_token: ENV["PERFECTO_TOKEN"],
             perfecto_media_location: ENV["PERFECTO_MEDIA_LOCATION"],
-            file_path: "path_to_apk_or_ipa_file"
+            file_path: "path_to_apk_or_ipa_file",
+            artifactType: ENV["artifactType"],
+            artifactName: ENV["artifactName"]
            )'
         ]
       end

data/lib/fastlane/plugin/perfecto/helper/perfecto_helper.rb

@@ -1,7 +1,8 @@
-require 'rest-client'
-require 'uri'
-require 'fastlane_core/ui/ui'
-require 'json'
+require "rest-client"
+require "uri"
+require "fastlane_core/ui/ui"
+require "json"
+require "net/http"
 
 module Fastlane
   UI = FastlaneCore::UI unless Fastlane.const_defined?("UI")
@@ -14,17 +15,18 @@ module Fastlane
       # +perfecto_token+:: Perfecto's security token.
       # +file_path+:: Path to the file to be uploaded.
       # +perfecto_media_fullpath+:: Path to the perfecto media location
+      # DEPRECATED
       def self.upload_file(perfecto_cloudurl, perfecto_token, file_path, perfecto_media_fullpath)
-        unless ENV['http_proxy']
-          RestClient.proxy = ENV['http_proxy']
+        unless ENV["http_proxy"]
+          RestClient.proxy = ENV["http_proxy"]
         end
         response = RestClient::Request.execute(
-          url: 'https://' + perfecto_cloudurl + '/services/repositories/media/' + perfecto_media_fullpath + '?operation=upload&overwrite=true&securityToken=' + URI.encode(perfecto_token, "UTF-8"),
+          url: "https://" + perfecto_cloudurl + "/services/repositories/media/" + perfecto_media_fullpath + "?operation=upload&overwrite=true&securityToken=" + URI.encode(perfecto_token, "UTF-8"),
           method: :post,
           headers: {
-            'Accept' => 'application/json',
-            'Content-Type' => 'application/octet-stream',
-            'Expect' => '100-continue'
+            "Accept" => "application/json",
+            "Content-Type" => "application/octet-stream",
+            "Expect" => "100-continue"
           },
           payload: File.open(file_path, "rb")
         )
@@ -40,6 +42,49 @@ module Fastlane
       rescue StandardError => error
         UI.user_error!("App upload failed!!! Reason : #{error.message}")
       end
+
+      def self.parameters(request_part, key, value)
+        unless value.to_s.strip.empty?
+          return request_part.merge!(key => value)
+        end
+      end
+
+      # Uploads file to Perfecto using new V1 upload API
+      # Params :
+      # +perfecto_cloudurl+:: Perfecto's cloud name.
+      # +perfecto_token+:: Perfecto's security token.
+      # +file_path+:: Path to the file to be uploaded.
+      # +perfecto_media_fullpath+:: Path to the perfecto media location
+      # +artifact_type+:: Artifact Type
+      # +artifact_name+:: Artifact Name
+      def self.upload_v1(perfecto_cloudurl, perfecto_token, file_path, perfecto_media_fullpath, artifact_type, artifact_name)
+        # prepare cloud url
+        if perfecto_cloudurl.include?(".perfectomobile.com")
+          perfecto_cloudurl = perfecto_cloudurl.split(".perfectomobile.com")[0]
+          if perfecto_cloudurl.include?(".app")
+            perfecto_cloudurl = perfecto_cloudurl.split(".app")[0]
+          end
+        end
+
+        url = URI("https://" + perfecto_cloudurl + ".app.perfectomobile.com/repository/api/v1/artifacts")
+        https = Net::HTTP.new(url.host, url.port)
+        https.use_ssl = true
+        request = Net::HTTP::Post.new(url)
+        request["Perfecto-Authorization"] = perfecto_token
+        request_part = { "artifactLocator" => perfecto_media_fullpath, "override" => true }
+        parameters(request_part, "artifactType", artifact_type)
+        parameters(request_part, "artifactName", artifact_name)
+        request_part = request_part.to_json.to_s.gsub("=>", ":")
+        # Debug: puts request_part
+        form_data = [["requestPart", request_part], ["inputStream", File.open(file_path, "rb")]]
+        request.set_form(form_data, "multipart/form-data")
+        response = https.request(request)
+        UI.message(response.inspect)
+        if response.code != "200"
+          # Give error if upload failed.
+          UI.user_error!("App upload failed!!! Reason : #{response}")
+        end
+      end
     end
   end
 end

data/lib/fastlane/plugin/perfecto/version.rb

@@ -1,5 +1,5 @@
 module Fastlane
   module Perfecto
-    VERSION = "0.1.1"
+    VERSION = "0.1.3"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fastlane-plugin-perfecto
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.3
 platform: ruby
 authors:
 - Perfecto
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-01-14 00:00:00.000000000 Z
+date: 2021-09-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pry
@@ -156,7 +156,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 2.0.2
-description: 
+description:
 email: support@perfectomobile.com
 executables: []
 extensions: []
@@ -172,7 +172,7 @@ homepage: https://github.com/PerfectoMobileSA/fastlane-plugin-perfecto
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -187,8 +187,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.4
-signing_key: 
+rubygems_version: 3.1.6
+signing_key:
 specification_version: 4
 summary: This plugin allows you to automatically upload ipa/apk files to Perfecto
   for manual/automation testing