rainforest-cli 1.6.5 → 1.7.0

data/lib/{rainforest/cli → rainforest_cli}/runner.rb

@@ -9,6 +9,11 @@ module RainforestCli
     end
 
     def run
+      if options.wait?
+        wait_for_run_completion(options.run_id)
+        return true
+      end
+
       if options.import_file_name && options.import_name
         delete_generator(options.import_name)
         CSVImporter.new(options.import_name, options.import_file_name, options.token).import
@@ -26,9 +31,20 @@ module RainforestCli
         exit 1
       end
 
+      run_id = response.fetch('id')
+      logger.info "Issued run #{run_id}"
+
       if options.foreground?
-        run_id = response.fetch('id')
-        wait_for_run_completion(run_id)
+        response = wait_for_run_completion(run_id)
+        if options.junit_file?
+          reporter = Reporter.new(options)
+          reporter.run_id = run_id
+          reporter.report
+        end
+
+        if response['result'] != 'passed'
+          exit 1
+        end
       else
         true
       end
@@ -37,7 +53,6 @@ module RainforestCli
     def wait_for_run_completion(run_id)
       running = true
       while running
-        Kernel.sleep 5
         response = client.get("/runs/#{run_id}", {}, retries_on_failures: true)
         if response
           state_details = response.fetch('state_details')
@@ -50,15 +65,14 @@ module RainforestCli
             running = false
           end
         end
+        Kernel.sleep 5 if running
       end
 
       if response['frontend_url']
         logger.info "The detailed results are available at #{response['frontend_url']}"
       end
 
-      if response['result'] != 'passed'
-        exit 1
-      end
+      return response
     end
 
     def make_create_run_options

data/lib/{rainforest/cli → rainforest_cli}/test_parser.rb

@@ -1,70 +1,9 @@
 # frozen_string_literal: true
-module RainforestCli::TestParser
-  class EmbeddedTest < Struct.new(:rfml_id, :redirect)
-    def type
-      :test
-    end
-
-    def to_s
-      "--> embed: #{rfml_id}"
-    end
-
-    def redirection
-      redirect || 'true'
-    end
-
-    def to_element(primary_key_id)
-      {
-        type: 'test',
-        redirection: redirection,
-        element: {
-          id: primary_key_id
-        }
-      }
-    end
-  end
-
-  class Step < Struct.new(:action, :response, :redirect)
-    def type
-      :step
-    end
 
-    def redirection
-      redirect || 'true'
-    end
-
-    def to_s
-      "#{action} --> #{response}"
-    end
-
-    def to_element
-      {
-        type: 'step',
-        redirection: redirection,
-        element: {
-          action: action,
-          response: response
-        }
-      }
-    end
-  end
-
-  class Test < Struct.new(
-    :file_name,
-    :rfml_id,
-    :description,
-    :title,
-    :start_uri,
-    :site_id,
-    :steps,
-    :errors,
-    :tags,
-    :browsers
-  )
-    def embedded_ids
-      steps.inject([]) { |embeds, step| step.type == :test ? embeds + [step.rfml_id] : embeds }
-    end
-  end
+module RainforestCli::TestParser
+  require 'rainforest_cli/test_parser/test'
+  require 'rainforest_cli/test_parser/step'
+  require 'rainforest_cli/test_parser/embedded_test'
 
   class Error < Struct.new(:line, :reason)
     def to_s

data/lib/rainforest_cli/test_parser/embedded_test.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+class RainforestCli::TestParser::EmbeddedTest < Struct.new(:rfml_id, :redirect)
+  def type
+    :test
+  end
+
+  def to_s
+    "--> embed: #{rfml_id}"
+  end
+
+  def has_uploadable_files?
+    false
+  end
+end

data/lib/rainforest_cli/test_parser/step.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+class RainforestCli::TestParser::Step < Struct.new(:action, :response, :redirect)
+  UPLOADABLE_REGEX = /{{ *file\.(download|screenshot)\(([^\)]+)\) *}}/
+
+  def type
+    :step
+  end
+
+  def to_s
+    "#{action} --> #{response}"
+  end
+
+  def has_uploadable_files?
+    uploadable_in_action.any? || uploadable_in_response.any?
+  end
+
+  def uploadable_in_action
+    action.scan(UPLOADABLE_REGEX)
+  end
+
+  def uploadable_in_response
+    response.scan(UPLOADABLE_REGEX)
+  end
+end

data/lib/rainforest_cli/test_parser/test.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+class RainforestCli::TestParser::Test < Struct.new(
+  :file_name,
+  :rfml_id,
+  :description,
+  :title,
+  :start_uri,
+  :site_id,
+  :steps,
+  :errors,
+  :tags,
+  :browsers
+)
+  def embedded_ids
+    steps.inject([]) { |embeds, step| step.type == :test ? embeds + [step.rfml_id] : embeds }
+  end
+
+  def to_json
+    {
+      start_uri: start_uri || '/',
+      title: title,
+      site_id: site_id,
+      description: description,
+      source: 'rainforest-cli',
+      tags: tags.uniq,
+      rfml_id: rfml_id,
+      browsers: browser_json,
+    }
+  end
+
+  def browser_json
+    browsers.map do |b|
+      {'state' => 'enabled', 'name' => b}
+    end
+  end
+
+  def has_uploadable_files?
+    steps.any?(&:has_uploadable_files?)
+  end
+end

data/lib/{rainforest/cli → rainforest_cli}/uploader.rb

@@ -4,6 +4,8 @@ require 'parallel'
 require 'ruby-progressbar'
 
 class RainforestCli::Uploader
+  require 'rainforest_cli/uploader/uploadable_parser'
+
   attr_reader :test_files, :remote_tests, :validator
 
   def initialize(options)
@@ -26,6 +28,33 @@ class RainforestCli::Uploader
     each_in_parallel(rfml_tests) { |rfml_test| upload_test(rfml_test) }
   end
 
+  def create_test_obj(rfml_test)
+    parse_uploadables!(rfml_test) if rfml_test.has_uploadable_files?
+
+    elements = rfml_test.steps.map do |step|
+      element = case step.type
+                when :test then { id: primary_key_dictionary[step.rfml_id] }
+                when :step then { action: step.action, response: step.response }
+                else
+                  logger.fatal "Unable to parse step type: #{step.type} in #{rfml_test.file_name}"
+                  exit 1
+                end
+      {
+        type: step.type,
+        redirection: step.redirect || true,
+        element: element,
+      }
+    end
+
+    rfml_test.to_json.merge(elements: elements)
+  end
+
+  def parse_uploadables!(rfml_test)
+    test_id = primary_key_dictionary[rfml_test.rfml_id]
+    uploaded_files = http_client.get("/tests/#{test_id}/files")
+    UploadableParser.new(rfml_test, test_id, uploaded_files).parse_files!
+  end
+
   private
 
   def each_in_parallel(tests, &blk)
@@ -52,7 +81,7 @@ class RainforestCli::Uploader
       title: rfml_test.title,
       start_uri: rfml_test.start_uri,
       rfml_id: rfml_test.rfml_id,
-      source: 'rainforest-cli'
+      source: 'rainforest-cli',
     }
     rf_test = Rainforest::Test.create(test_obj)
 
@@ -79,31 +108,7 @@ class RainforestCli::Uploader
     RainforestCli.logger
   end
 
-  def create_test_obj(rfml_test)
-    test_obj = {
-      start_uri: rfml_test.start_uri || '/',
-      title: rfml_test.title,
-      site_id: rfml_test.site_id,
-      description: rfml_test.description,
-      source: 'rainforest-cli',
-      tags: rfml_test.tags.uniq,
-      rfml_id: rfml_test.rfml_id
-    }
-
-    test_obj[:elements] = rfml_test.steps.map do |step|
-      if step.respond_to?(:rfml_id)
-        step.to_element(primary_key_dictionary[step.rfml_id])
-      else
-        step.to_element
-      end
-    end
-
-    unless rfml_test.browsers.empty?
-      test_obj[:browsers] = rfml_test.browsers.map do|b|
-        {'state' => 'enabled', 'name' => b}
-      end
-    end
-
-    test_obj
+  def http_client
+    RainforestCli.http_client
   end
 end

data/lib/rainforest_cli/uploader/multi_form_post_request.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+require 'httparty'
+
+class RainforestCli::Uploader::MultiFormPostRequest
+  BOUNDARY = 'RainforestCli'
+
+  class Param < Struct.new(:param_name, :value)
+    def to_multipart
+      <<-EOS
+Content-Disposition: form-data; name="#{param_name}"\r
+\r
+#{value}\r
+      EOS
+    end
+  end
+
+  class FileParam < Struct.new(:param_name, :file)
+    def to_multipart
+      <<-EOS
+Content-Disposition: form-data; name="#{param_name}"; filename="#{File.basename(file.path)}"\r
+Content-Type: #{MimeMagic.by_path(file.path)}\r
+Content-Transfer-Encoding: binary\r
+\r
+#{file.read.strip}\r
+      EOS
+    end
+  end
+
+  class << self
+    def request(url, params)
+      HTTParty.post(url, body: make_body(params), headers: headers)
+    end
+
+    def make_body(params)
+      fp = []
+      params.each do |k, v|
+        if v.respond_to?(:read)
+          fp.push(FileParam.new(k, v))
+        else
+          fp.push(Param.new(k, v))
+        end
+      end
+      fp.map { |p| "--#{BOUNDARY}\n#{p.to_multipart}" }.join + "--#{BOUNDARY}--"
+    end
+
+    def headers
+      { 'Content-type' => "multipart/form-data, boundary=#{BOUNDARY}" }
+    end
+  end
+end

data/lib/rainforest_cli/uploader/uploadable_parser.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+require 'mimemagic'
+require 'rainforest_cli/uploader/multi_form_post_request'
+
+class RainforestCli::Uploader::UploadableParser
+  def initialize(rfml_test, test_id, uploaded_files)
+    @rfml_test = rfml_test
+    @test_id = test_id
+    @uploaded_files = uploaded_files
+  end
+
+  def parse_files!
+    @rfml_test.steps.each do |step|
+      next if step.type == :test
+      parse_action_files(step) if step.uploadable_in_action
+      parse_response_files(step) if step.uploadable_in_response
+    end
+  end
+
+  def parse_action_files(step)
+    step.uploadable_in_action.each do |match|
+      step.action = replace_paths_in_text(step.action, match)
+    end
+  end
+
+  def parse_response_files(step)
+    step.uploadable_in_response.each do |match|
+      step.response = replace_paths_in_text(step.response, match)
+    end
+  end
+
+  def replace_paths_in_text(text, match)
+    step_var, relative_file_path = match
+    file_path = File.expand_path(File.join(test_directory, relative_file_path))
+
+    unless File.exist?(file_path)
+      logger.warn "\tError for test: #{@rfml_test.file_name}:"
+      logger.warn "\t\tNo such file exists: #{File.basename(file_path)}"
+      return text
+    end
+
+    file = File.open(file_path, 'rb')
+    aws_info = get_aws_upload_info(file)
+
+    sig = aws_info['file_signature'][0...6]
+    if step_var == 'screenshot'
+      text.gsub(relative_file_path, "#{aws_info['file_id']}, #{sig}")
+    elsif step_var == 'download'
+      text.gsub(relative_file_path, "#{aws_info['file_id']}, #{sig}, #{File.basename(file_path)}")
+    end
+  end
+
+  def get_aws_upload_info(file)
+    if file_already_uploaded?(file)
+      aws_info = get_uploaded_data(file)
+    else
+      aws_info = upload_to_rainforest(file)
+      add_file_to_uploaded_collection(file, aws_info)
+      upload_to_aws(file, aws_info)
+    end
+
+    aws_info
+  end
+
+  def upload_to_rainforest(file)
+    logger.info "\tUploading file metadata for #{file.path}..."
+
+    resp = http_client.post(
+      "/tests/#{@test_id}/files",
+      mime_type: MimeMagic.by_path(file).to_s,
+      size: file.size,
+      name: File.basename(file.path),
+      digest: file_digest(file)
+    )
+
+    if resp['aws_url'].nil?
+      logger.fatal "\tThere was a problem with uploading your file: #{file_path}."
+      logger.fatal "\t\t#{resp.to_json}"
+      exit 2
+    end
+
+    resp
+  end
+
+  def upload_to_aws(file, aws_info)
+    logger.info "\tUploading file data for #{file.path}..."
+
+    resp = RainforestCli::Uploader::MultiFormPostRequest.request(
+      aws_info['aws_url'],
+      'key' => aws_info['aws_key'],
+      'AWSAccessKeyId' => aws_info['aws_access_id'],
+      'acl' => aws_info['aws_acl'],
+      'policy' => aws_info['aws_policy'],
+      'signature' => aws_info['aws_signature'],
+      'Content-Type' => MimeMagic.by_path(file),
+      'file' => file,
+    )
+
+    unless resp.code.between?(200, 299)
+      logger.fatal "\tThere was a problem with uploading your file: #{file.path}."
+      logger.fatal "\t\t#{resp.to_json}"
+      exit 3
+    end
+  end
+
+  def add_file_to_uploaded_collection(file, aws_info)
+    @uploaded_files.push({
+                           'id' => aws_info['file_id'],
+                           'signature' => aws_info['file_signature'],
+                           'digest' => file_digest(file),
+                         })
+  end
+
+  def file_already_uploaded?(file)
+    @uploaded_files.any? { |f| f['digest'] == file_digest(file) }
+  end
+
+  def get_uploaded_data(file)
+    file_data = @uploaded_files.find { |f| f['digest'] == file_digest(file) }
+    {
+      'file_signature' => file_data['signature'],
+      'file_id' => file_data['id'],
+    }
+  end
+
+  private
+
+  def file_digest(file)
+    Digest::MD5.file(file).hexdigest
+  end
+
+  def test_directory
+    @test_directory ||= File.dirname(@rfml_test.file_name)
+  end
+
+  def http_client
+    RainforestCli.http_client
+  end
+
+  def logger
+    RainforestCli.logger
+  end
+end