quarantine 2.1.3 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6ab8e4aa2ba3c2ab497cb3adfb08b6c14459eab525f26a00f4bc1fb9b27e1084
-  data.tar.gz: ffafe0bdf3508389ae614ab5b8946c4cb9b5303f7697ca4b378b6284f335375f
+  metadata.gz: c846ed3cf614eecefab5610bfb5d693444099fe90b6b429e4c697c16a014e21b
+  data.tar.gz: 5d17a24b4735f4c34af2d0902c0e3a7199750ce592694b5f9fe375928ada9d03
 SHA512:
-  metadata.gz: c4d12718e41b13558f30add75b2a5d5e25f5d29d4e19b55704e7500c1980f7192ed1a8fa3e4fc83e45329486c94bae42bd56f99a718144f42c6884878b926faf
-  data.tar.gz: 283aa10d1dafe98d3e5ed08f1add97facdcfbe6f4a1761759e42677b7dd26fafbc323d958ab81965076a1d19e951e18c67e35e01679ad43e44d622876649641f
+  metadata.gz: cb20ce19d6581b4836486176a080a6204a66f93d609e2b76a5d7bb91886b97e07466026fe45d0d7d4c16b8d2f072212a4ff982f42c40a55d68f42413276a92c4
+  data.tar.gz: bc093985a12b77f636d577b3fed3ab783f5fe206350a759a796097eee93976f42cb2fa199101a853f81d729aa109cce612f6deb4ba75748779281086e2591bca

data/lib/quarantine.rb

@@ -9,23 +9,6 @@ require 'quarantine/databases/base'
 require 'quarantine/databases/dynamo_db'
 require 'quarantine/databases/google_sheets'
 
-module RSpec
-  module Core
-    class Example
-      extend T::Sig
-
-      # The implementation of clear_exception in rspec-retry doesn't work
-      # for examples that use `it_behaves_like`, so we implement our own version that
-      # clear the exception field recursively.
-      sig { void }
-      def clear_exception!
-        @exception = T.let(nil, T.untyped)
-        T.unsafe(self).example.clear_exception! if defined?(example)
-      end
-    end
-  end
-end
-
 class Quarantine
   extend T::Sig
 

data/lib/quarantine/databases/google_sheets.rb

@@ -41,7 +41,13 @@ class Quarantine
         indexes = Hash[parsed_rows.each_with_index.map { |item, idx| [item['id'], idx] }]
 
         items.each do |item|
-          cells = headers.map { |header| item[header].to_s }
+          cells = headers.map do |header|
+            match = header.match(/^(extra_)?(.+)/)
+            extra, name = match[1..]
+            puts "header: #{header}, extra: #{extra}, name: #{name}"
+            value = extra ? item['extra_attributes'][name.to_sym] : item[name]
+            value.to_s
+          end
           row_idx = indexes[item['id']]
           if row_idx
             # Overwrite existing row
@@ -104,8 +110,10 @@ class Quarantine
           hash_row = Hash[headers.zip(row)]
           # TODO: use Google Sheets developer metadata to store type information
           unless hash_row['id'].empty?
-            hash_row['extra_attributes'] = JSON.parse(hash_row['extra_attributes']) if hash_row['extra_attributes']
-            hash_row
+            extra_values, base_values = hash_row.partition{|k, v| k.start_with?('extra_')}
+            base_hash = Hash[base_values]
+            base_hash['extra_attributes'] = Hash[extra_values]
+            base_hash
           end
         end.compact
       end

data/lib/quarantine/rspec_adapter.rb

@@ -1,5 +1,22 @@
 # typed: strict
 
+module RSpec
+  module Core
+    class Example
+      extend T::Sig
+
+      # The implementation of clear_exception in rspec-retry doesn't work
+      # for examples that use `it_behaves_like`, so we implement our own version that
+      # clear the exception field recursively.
+      sig { void }
+      def clear_exception!
+        @exception = T.let(nil, T.untyped)
+        T.unsafe(self).example.clear_exception! if defined?(example)
+      end
+    end
+  end
+end
+
 class Quarantine
   module RSpecAdapter
     extend T::Sig
@@ -52,33 +69,47 @@ class Quarantine
       end
     end
 
+    sig { params(example: RSpec::Core::Example).returns(T.nilable([Symbol, T::Boolean])) }
+    def self.final_status(example)
+      metadata = example.metadata
+
+      # The user may define their own after hook that marks an example as flaky in its metadata.
+      previously_quarantined = Quarantine::RSpecAdapter.quarantine.test_quarantined?(example) || metadata[:flaky]
+
+      if example.exception
+        # The example failed _this try_.
+        if metadata[:retry_attempts] + 1 == metadata[:retry]
+          # The example failed all its retries - if it's already quarantined, keep it that way;
+          # otherwise, mark it as failing.
+          if RSpec.configuration.skip_quarantined_tests && previously_quarantined
+            return [:quarantined, false]
+          else
+            return [:failing, false]
+          end
+        end
+        # The example failed, but it's not the final retry yet, so return nil.
+        return nil
+      elsif metadata[:retry_attempts] > 0
+        # The example passed this time, but failed one or more times before - the definition of a flaky test.
+        return [:quarantined, false]
+      elsif previously_quarantined
+        # The example passed the first time, but it's already marked quarantined, so keep it that way.
+        return [:quarantined, true]
+      else
+        return [:passing, true]
+      end
+    end
+
     # Purpose: binds quarantine to record test statuses
     sig { void }
     def self.bind_on_test
       ::RSpec.configure do |config|
         config.after(:each) do |example|
-          metadata = example.metadata
-
-          # optionally, the upstream RSpec configuration could define an after hook that marks an example as flaky in
-          # the example's metadata
-          quarantined = Quarantine::RSpecAdapter.quarantine.test_quarantined?(example) || metadata[:flaky]
-          if example.exception
-            if metadata[:retry_attempts] + 1 == metadata[:retry]
-              # will record the failed test if it's final retry from the rspec-retry gem
-              if RSpec.configuration.skip_quarantined_tests && quarantined
-                example.clear_exception!
-                Quarantine::RSpecAdapter.quarantine.on_test(example, :quarantined, passed: false)
-              else
-                Quarantine::RSpecAdapter.quarantine.on_test(example, :failing, passed: false)
-              end
-            end
-          elsif metadata[:retry_attempts] > 0
-            # will record the flaky test if it failed the first run but passed a subsequent run
-            Quarantine::RSpecAdapter.quarantine.on_test(example, :quarantined, passed: false)
-          elsif quarantined
-            Quarantine::RSpecAdapter.quarantine.on_test(example, :quarantined, passed: true)
-          else
-            Quarantine::RSpecAdapter.quarantine.on_test(example, :passing, passed: true)
+          result = Quarantine::RSpecAdapter.final_status(example)
+          if result
+            status, passed = result
+            example.clear_exception! if status == :quarantined && !passed
+            Quarantine::RSpecAdapter.quarantine.on_test(example, status, passed: passed)
           end
         end
       end

data/lib/quarantine/version.rb

@@ -1,3 +1,3 @@
 class Quarantine
-  VERSION = '2.1.3'.freeze
+  VERSION = '2.2.0'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: quarantine
 version: !ruby/object:Gem::Version
-  version: 2.1.3
+  version: 2.2.0
 platform: ruby
 authors:
 - Flexport Engineering, Eric Zhu
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-04-15 00:00:00.000000000 Z
+date: 2021-04-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec