Releasing v0.2.1

Author: Luiz Kowalski

.github/workflows/ruby.yml

@@ -8,7 +8,6 @@ on:
 
 jobs:
   test:
-
     runs-on: ubuntu-latest
     strategy:
       matrix:
@@ -35,7 +34,7 @@ jobs:
     - uses: ruby/setup-ruby@v1
       with:
         ruby-version: ${{ matrix.ruby }}
-        bundler-cache: true # runs bundle install and caches installed gems automatically
+        bundler-cache: true
         bundler: ${{ env.BUNDLER_VERSION || 'latest' }}
     - name: Rubocop
       run: bundle exec rubocop -D

CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## 0.2.1
+
+* Added `ConcurrentRails::Testing` tool
+* Dropped support for Ruby 2.5
+* Added deprecation warning for `ConcurrentRails::Future`
+* Wrapped `touch` and `wait` on Rails' executor as well
+
 ## 0.2.0
 
 * Added delayed futures
@@ -30,15 +37,15 @@
 
 ## 0.1.4
 
-* Fixed `ConcurrentRails::Promises`'s `future` factory so it handles parameters and block correctly
+* Fixed `ConcurrentRails::Promises`'s `future` factory so it handles parameters and blocks correctly
 
 ## 0.1.3
 
 * Dropped support for Ruby and Rails versions that reached EOL
 
 ## 0.1.2
 
-* Fixed depencies for development
+* Fixed dependencies for development
 
 ## 0.1.1
 

Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    concurrent_rails (0.2.0)
+    concurrent_rails (0.2.1)
       rails (>= 5.2)
 
 GEM
@@ -128,7 +128,7 @@ GEM
     rake (13.0.3)
     regexp_parser (2.1.1)
     rexml (3.2.5)
-    rubocop (1.16.0)
+    rubocop (1.17.0)
       parallel (~> 1.10)
       parser (>= 3.0.0.0)
       rainbow (>= 2.2.2, < 4.0)
@@ -157,7 +157,7 @@ GEM
     tzinfo (2.0.4)
       concurrent-ruby (~> 1.0)
     unicode-display_width (2.0.0)
-    websocket-driver (0.7.4)
+    websocket-driver (0.7.5)
       websocket-extensions (>= 0.1.0)
     websocket-extensions (0.1.5)
     zeitwerk (2.4.2)
@@ -174,4 +174,4 @@ DEPENDENCIES
   sqlite3 (~> 1.4)
 
 BUNDLED WITH
-   2.2.19
+   2.2.20

README.md

@@ -83,7 +83,7 @@ All of these callbacks have a bang version (e.g. `on_fulfillment!`). The bang ve
 
 ### (Deprecated) Future
 
-`ConcurrentRails::Future` will execute your code in a separated thread and you can check the progress of it whenever you need it. When the task is ready, you can access the result with `#result` function:
+`ConcurrentRails::Future` will execute your code in a separate thread and you can check the progress of it whenever you need it. When the task is ready, you can access the result with `#result` function:
 
 ```ruby
 irb(main):001:0> future = ConcurrentRails::Future.new do
@@ -173,6 +173,37 @@ irb(main):007:0> multi.errors
 
 It is worth mention that a failed proc will return `nil`.
 
+## Testing
+If you are using RSpec, you will notice that it might not play well with threads. ActiveRecord opens a database connection for every thread and since RSpec tests are wrapped in a transaction, by the time you promise tries to access something on the database, for example, a user, gems like Database Cleaner probably already triggered and deleted the user, resulting in `ActiveRecord::RecordNotFound` errors. You have a couple of solutions like disable transactional fixtures if you are using it or update the Database Cleaner strategy (that will result in much slower tests).
+Since none of these solutions were satisfactory to me, I created `ConcurrentRails::Testing` with two strategies: `immediate!` and `fake!`. When you wrap a Promise's `future` with `immediate!`, the executor gets replaced from `:io` to `:immediate`. It still returns a promise anyway. This is not the case with `fake!` strategy: it executes the task outside the `ConcurrentRails` engine and returns whatever `.value` would return:
+
+`immediate!` strategy:
+```ruby
+irb(main):001:1* result = ConcurrentRails::Testing.immediate! do
+irb(main):002:1*       ConcurrentRails::Promises.future { 42 }
+irb(main):003:0> end
+=>
+#<ConcurrentRails::Promises:0x000000013e5fc870 
+...
+irb(main):004:0> result.class
+=> ConcurrentRails::Promises # <-- Still a `ConcurrentRails::Promises` class
+irb(main):005:0> result.executor
+=> :immediate # <-- default executor (:io) gets replaced
+```
+
+`fake!` strategy:
+
+```ruby
+irb(main):001:1* result = ConcurrentRails::Testing.fake! do
+irb(main):002:1*       ConcurrentRails::Promises.future { 42 }
+irb(main):003:0> end
+=> 42 # <-- yields the task but does not return a Promise
+irb(main):004:0> result.class
+=> Integer
+```
+
+## Further reading
+
 For more information on how Futures work and how Rails handle multithread check these links:
 
 [Future documentation](https://github.com/ruby-concurrency/concurrent-ruby/blob/master/docs-source/future.md)
@@ -184,7 +215,7 @@ For more information on how Futures work and how Rails handle multithread check
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'concurrent_rails', '~> 0.2.0'
+gem 'concurrent_rails', '~> 0.2.1'
 ```
 
 And then execute:

lib/concurrent_rails.rb

@@ -4,4 +4,5 @@
 require 'concurrent_rails/multi'
 require 'concurrent_rails/promises'
 require 'concurrent_rails/railtie'
+require 'concurrent_rails/testing'
 require 'concurrent_rails/version'

lib/concurrent_rails/promises.rb

@@ -64,6 +64,8 @@ def wait(timeout = nil)
 
     delegate :state, :reason, :rejected?, :resolved?, :fulfilled?, to: :instance
 
+    attr_reader :executor
+
     private
 
     def rails_wrapped(&block)
@@ -76,6 +78,6 @@ def permit_concurrent_loads(&block)
       end
     end
 
-    attr_reader :executor, :instance
+    attr_reader :instance
   end
 end

lib/concurrent_rails/testing.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module ConcurrentRails
+  class Testing
+    class << self
+      attr_reader :execution_mode
+
+      %i[immediate fake].each do |exec_method|
+        define_method("#{exec_method}!") do |&task|
+          @execution_mode = exec_method
+          result = task.call
+          @execution_mode = :real
+
+          result
+        end
+
+        define_method("#{exec_method}?") do
+          execution_mode == exec_method
+        end
+      end
+
+      module TestingFuture
+        def future(*args, &task)
+          if ConcurrentRails::Testing.immediate?
+            future_on(:immediate, *args, &task)
+          elsif ConcurrentRails::Testing.fake?
+            yield
+          else
+            super
+          end
+        end
+      end
+
+      ConcurrentRails::Promises.extend(TestingFuture)
+    end
+  end
+end

lib/concurrent_rails/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ConcurrentRails
-  VERSION = '0.2.0'
+  VERSION = '0.2.1'
 end

test/immediate_adapter_test.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class ImmediateAdapterTest < ActiveSupport::TestCase
+  test 'should override :io executor when using `immediate!`' do
+    result = ConcurrentRails::Testing.immediate! do
+      ConcurrentRails::Promises.future { 42 }
+    end
+
+    assert_equal(:immediate, result.executor)
+    assert_instance_of(ConcurrentRails::Promises, result)
+  end
+
+  test 'should not return a promise when using `fake!`' do
+    result = ConcurrentRails::Testing.fake! do
+      ConcurrentRails::Promises.future { 42 }
+    end
+
+    assert_equal(42, result)
+  end
+end