cypress-rails 0.8.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b714799f9b2c7cb3d97c1ae15730844d98d530eaaf2ae127aeff8604b4a1e53d
-  data.tar.gz: '094933f5801cc70665318327dfc1b91a4982d4372aee7920a8ad4ab6af9c1b38'
+  metadata.gz: c08ef4f9087d66f0f04df9831568414e757aae3fb83baf6bfd85c0d7a3509312
+  data.tar.gz: aa4baeebd6d8035ca9b9fc6ba91b0c487e9cf3a385a25ee9da92c96e2fd4ce2c
 SHA512:
-  metadata.gz: 3b92614020eb57eba1968e60f1aa6f938d9c3fffd7c19eb254dfaa9e4f1bc352535362e54a4823820376ff22d3a59eb204ca399729275aeb5ad2138d7a745d8c
-  data.tar.gz: a0efc7383d3f055d07717ff2dabc46c212abdee68e7f38890fb3a1968c1277bbc5c0c0387a6353d20f99b8a4a2721f56a39226feb10a02d0e1703e75c889cc11
+  metadata.gz: 15cf818dd04eb1eb89853d2a14839dd54d25ed4c39b21a705fcae507c7cecb12813477913fab43e486a7f80f0bcc4df8cb18cafa0252d3a38c33608b8441c6b7
+  data.tar.gz: 2fa87db917ccc275d14c8dc28f67a55c13a375e13d6a9f25887fc9ad87989d18bb515b2eabab19ef58dcee6da9b098cf1ccabf97ee6a057649468d8f4f740245

data/.github/workflows/main.yml

@@ -7,14 +7,17 @@ jobs:
     runs-on: ubuntu-latest
 
     strategy:
+      fail-fast: false
       matrix:
         ruby-version: ['3.0', '3.1', '3.2', '3.3', '3.4']
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v7
       - uses: ruby/setup-ruby@v1
         with:
           ruby-version: ${{ matrix.ruby-version }}
+          rubygems: latest
+          bundler: latest
           bundler-cache: true
 
       - name: Run root unit tests and lint
@@ -23,26 +26,60 @@ jobs:
           bundle exec rake
 
   example-app-tests:
+    name: example-app-tests (${{ matrix.ruby-version }}, ${{ matrix.rails-version }}, transactional ${{ matrix.transactional-server }})
     runs-on: ubuntu-latest
 
     strategy:
       fail-fast: false
       matrix:
         ruby-version: ['3.0', '3.1', '3.2', '3.3', '3.4']
-        rails-version: ['7.1', '7.2', '8.0']
+        rails-version: ['7.1', '7.2', '8.0', '8.1']
+        transactional-server: ['true']
         exclude:
           - ruby-version: '3.0'
             rails-version: '7.2'
           - ruby-version: '3.0'
             rails-version: '8.0'
+          - ruby-version: '3.0'
+            rails-version: '8.1'
+          - ruby-version: '3.1'
+            rails-version: '8.0'
           - ruby-version: '3.1'
+            rails-version: '8.1'
+        include:
+          - ruby-version: '3.4'
+            rails-version: '7.1'
+            transactional-server: 'false'
+          - ruby-version: '3.4'
+            rails-version: '7.2'
+            transactional-server: 'false'
+          - ruby-version: '3.4'
             rails-version: '8.0'
+            transactional-server: 'false'
+
+    services:
+      postgres:
+        image: postgres:18
+        env:
+          POSTGRES_PASSWORD: postgres
+        ports:
+          - 5432:5432
+        options: >-
+          --health-cmd pg_isready
+          --health-interval 10s
+          --health-timeout 5s
+          --health-retries 5
 
     env:
       BUNDLE_GEMFILE: ${{ github.workspace }}/example/gemfiles/rails_${{ matrix.rails-version }}.gemfile
+      CYPRESS_RAILS_TRANSACTIONAL_SERVER: ${{ matrix.transactional-server }}
+      PGHOST: localhost
+      PGUSER: postgres
+      PGPASSWORD: postgres
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v7
+      - uses: actions/setup-node@v7
       - uses: ruby/setup-ruby@v1
         with:
           ruby-version: ${{ matrix.ruby-version }}

data/CHANGELOG.md

@@ -1,7 +1,26 @@
 # CHANGELOG
 
+## 0.9.0
+
+* **[Breaking]** Require Rails 7.1 or newer
+* **[Breaking]** (relative to 0.8.0) Rename `after_reset_requested` back to
+  `after_state_reset`, and restore the transactional server as the default
+  behavior
+* Bring back the transactional server (and `CYPRESS_RAILS_TRANSACTIONAL_SERVER`),
+  which 0.8.0 had removed. It didn't work reliably to have apps reset their own
+  state under cypress-rails' multi-threaded Puma server
+* `/cypress_rails_reset_state` now resets before responding (returning `200`
+  instead of `202`), rather than deferring the reset to the next request
+
+See [docs/changes-in-0.9.0.md](docs/changes-in-0.9.0.md) for a full comparison
+with both 0.7.1 and 0.8.0.
+
 ## 0.8.0
 
+(Avoid this version due to issues with resetting data during threaded requests.
+0.9.0 is almost entirely compatible with 0.7.1 while still bringing Rails 7.2+
+compatibility, so the breaking changes in this version are for nothing.)
+
 * **[Breaking]** Remove `CYPRESS_RAILS_TRANSACTIONAL_SERVER`. cypress-rails no
   longer wraps the server in a transaction or resets it between tests -
   automatic Rails-version-specific transaction management proved unsustainable

data/README.md

@@ -93,39 +93,35 @@ is a JavaScript-based tool and can't easily manipulate your Rails app directly,
 cypress-rails provides a number of hooks that you can use to manage your test
 data.
 
-cypress-rails itself has no opinion on *how* you reset your database between
-tests. Instead, cypress-rails gives you a hook (`after_reset_requested`) to run
-whatever database-cleaning approach fits your app, such as the
-[database_cleaner](https://github.com/DatabaseCleaner/database_cleaner) gem.
+By default, cypress-rails runs your app inside a database transaction and rolls
+it back between tests, much like a Rails system test. Every thread serving your
+app shares that one transaction, so whatever your tests create is undone on the
+next reset.
 
 Here's what a `config/initializers/cypress_rails.rb` initializer might look
-like, using `database_cleaner-active_record`'s transaction strategy:
+like:
 
 ```ruby
 return unless Rails.env.test?
 
-require "database_cleaner/active_record"
-DatabaseCleaner.strategy = :transaction
-
 CypressRails.hooks.before_server_start do
-  # Called once, before the server is started
-  DatabaseCleaner.start
+  # Called once, before either the transaction or the server is started
+end
+
+CypressRails.hooks.after_transaction_start do
+  # Called after the transaction is started (at launch and after each reset)
 end
 
 CypressRails.hooks.after_server_start do
   # Called once, after the server has booted
 end
 
-CypressRails.hooks.after_reset_requested do
-  # Triggered after `/cypress_rails_reset_state` is called - this is your
-  # chance to actually reset the database
-  DatabaseCleaner.clean
-  DatabaseCleaner.start
+CypressRails.hooks.after_state_reset do
+  # Triggered after `/cypress_rails_reset_state` is called
 end
 
 CypressRails.hooks.before_server_stop do
   # Called once, at_exit
-  DatabaseCleaner.clean
 end
 ```
 
@@ -135,9 +131,17 @@ initializer](/example/config/initializers/cypress_rails_initializer.rb)
 in this repo.)
 
 The gem also provides a special route on the test server:
-`/cypress_rails_reset_state`. Each time it's called, cypress-rails will
-trigger any `after_reset_requested` hooks you've configured at the beginning
-of the next request received by the Rails app.
+`/cypress_rails_reset_state`. Each time it's called, cypress-rails does two
+things before responding:
+
+* If `CYPRESS_RAILS_TRANSACTIONAL_SERVER` is enabled, roll back the transaction
+  and start a new one, resetting the database to how it was when the test run
+  started, then trigger any `after_transaction_start` hooks
+* Trigger any `after_state_reset` hooks you've configured (regardless of the
+  transactional server setting)
+
+If a hook raises an error, the request fails with a 500 status and the error
+message, so the `cy.request` that triggered the reset fails too.
 
 This way, you can easily instruct the server to reset its test state from your
 Cypress tests like so:
@@ -151,6 +155,39 @@ beforeEach(() => {
 (Remember, in Cypress, `before` is a before-all hook and `beforeEach` is run
 between each test case!)
 
+### Turning off the transactional server
+
+The transactional server funnels all of your app's database queries through a
+single connection, one at a time, just like a Rails system test. If your tests
+need your app to access the database concurrently, or your app does work that
+can't happen inside a transaction, set `CYPRESS_RAILS_TRANSACTIONAL_SERVER=false`
+and reset your data yourself in an `after_state_reset` hook. For example, with
+[database_cleaner](https://github.com/DatabaseCleaner/database_cleaner) and
+Rails fixtures:
+
+```ruby
+CypressRails.hooks.after_state_reset do
+  DatabaseCleaner[:active_record].clean_with(:truncation)
+  ActiveRecord::FixtureSet.reset_cache
+  ActiveRecord::FixtureSet.create_fixtures(Rails.root.join("test/fixtures"), ["users", "posts"])
+end
+```
+
+A few things to watch out for:
+
+* Don't use database_cleaner's `:transaction` strategy. It only opens a
+  transaction on one of the server's database connections, so requests served
+  on other connections save their changes for real, and those changes survive
+  the reset. (On SQLite, the open transaction also makes other connections'
+  writes fail with "database is locked" errors.)
+* Don't set `DatabaseCleaner.strategy = ...` at the top of an initializer.
+  Before ActiveRecord has loaded, that assignment is silently ignored and
+  database_cleaner's default `:transaction` strategy is used instead.
+* Truncation removes everything, including data loaded in
+  `before_server_start`, so rebuild whatever your tests need in the hook. Call
+  `ActiveRecord::FixtureSet.reset_cache` before reloading fixtures, or they'll
+  be skipped as already loaded.
+
 ## Configuration
 
 ### Environment variables
@@ -171,6 +208,12 @@ preferred environment variables project-wide using a tool like
   requests to the app (e.g. via `cy.visit()`). If you've customized your
   `baseUrl` setting (e.g. in `cypress.config.js`), you'll need to duplicate it with
   this environment variable
+* **CYPRESS_RAILS_TRANSACTIONAL_SERVER** (default: `true`) when true, starts a
+  transaction before launching the server and rolls it back on every reset and
+  on exit, so anything done during `cypress open` or `cypress run` is undone
+  (similar to running a Rails system test). While it's enabled, all of the
+  server's database access shares one connection. See [Turning off the
+  transactional server](#turning-off-the-transactional-server)
 * **CYPRESS_RAILS_CYPRESS_OPTS** (default: _none_) any options you want to
   forward to the Cypress CLI when running its `open` or `run` commands.
 
@@ -196,32 +239,40 @@ $ CYPRESS_RAILS_CYPRESS_OPTS="--browser chromium" bin/rake cypress:run
 ### before_server_start
 
 Pass a block to `CypressRails.hooks.before_server_start` to register a hook that
-will execute before the server has been started. If you use Rails fixtures, it
-may make sense to load them here, so they don't need to be re-inserted for each
-request. This is also a good place to start whatever database-cleaning strategy
-you're using (e.g. `DatabaseCleaner.start`).
+will execute before the server or any transaction has been started. If you use
+Rails fixtures, it may make sense to load them here, so they persist across
+resets instead of being re-inserted each time.
 
 ### after_server_start
 
 Pass a block to `CypressRails.hooks.after_server_start` to register a hook that
-will execute after the server has booted.
+will execute after the server has booted (inside the transaction, if
+`CYPRESS_RAILS_TRANSACTIONAL_SERVER` is enabled).
+
+### after_transaction_start
+
+If there's any custom behavior or state management you want to do inside the
+transaction (so that it's also rolled back each time a reset is triggered),
+pass a block to `CypressRails.hooks.after_transaction_start`. It runs when the
+server launches and after every reset, and only when
+`CYPRESS_RAILS_TRANSACTIONAL_SERVER` is enabled.
 
-### after_reset_requested
+### after_state_reset
 
 Every time the test server receives an HTTP request at
-`/cypress_rails_reset_state`, the `after_reset_requested` hook will be
-triggered at the start of the next request. This is where you should actually
-reset your database (e.g. `DatabaseCleaner.clean` followed by
-`DatabaseCleaner.start`) - cypress-rails does not reset any state on its own.
-To set up the hook, pass a block to `CypressRails.hooks.after_reset_requested`.
+`/cypress_rails_reset_state`, the transaction will be rolled back and restarted
+(if `CYPRESS_RAILS_TRANSACTIONAL_SERVER` is enabled) and then the
+`after_state_reset` hook will be triggered, all before the request responds. To
+set up the hook, pass a block to `CypressRails.hooks.after_state_reset`.
 
 ### before_server_stop
 
 In case you've made any permanent changes to your test database that could
 pollute other test suites or scripts, you can use the `before_server_stop` to
 (assuming everything exits gracefully) clean things up and restore the state
-of your test database. To set up the hook, pass a block to
-`CypressRails.hooks.before_server_stop`.
+of your test database. If `CYPRESS_RAILS_TRANSACTIONAL_SERVER` is enabled, this
+runs after the transaction has been rolled back. To set up the hook, pass a
+block to `CypressRails.hooks.before_server_stop`.
 
 ## Configuring Rails
 

data/cypress-rails.gemspec

@@ -16,17 +16,19 @@ Gem::Specification.new do |spec|
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
   spec.files = Dir.chdir(File.expand_path("..", __FILE__)) do
-    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|example)/}) }
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|example|docs)/}) }
   end
   spec.bindir = "exe"
   spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "railties", ">= 5.2.0"
+  spec.add_dependency "railties", ">= 7.1"
   spec.add_dependency "puma", ">= 3.8.0"
 
   spec.add_development_dependency "bundler"
   spec.add_development_dependency "rake", "~> 13.0"
   spec.add_development_dependency "minitest", "~> 5.0"
   spec.add_development_dependency "standard", ">= 0.2.0"
+  spec.add_development_dependency "activerecord"
+  spec.add_development_dependency "sqlite3"
 end

data/lib/cypress-rails/config.rb

@@ -2,7 +2,7 @@ require_relative "env"
 
 module CypressRails
   class Config
-    attr_accessor :rails_dir, :cypress_dir, :host, :port, :base_path, :cypress_cli_opts
+    attr_accessor :rails_dir, :cypress_dir, :host, :port, :base_path, :transactional_server, :cypress_cli_opts
 
     def initialize(
       rails_dir: Env.fetch("CYPRESS_RAILS_DIR", default: Dir.pwd),
@@ -10,6 +10,7 @@ module CypressRails
       host: Env.fetch("CYPRESS_RAILS_HOST", default: "127.0.0.1"),
       port: Env.fetch("CYPRESS_RAILS_PORT"),
       base_path: Env.fetch("CYPRESS_RAILS_BASE_PATH", default: "/"),
+      transactional_server: Env.fetch("CYPRESS_RAILS_TRANSACTIONAL_SERVER", type: :boolean, default: true),
       cypress_cli_opts: Env.fetch("CYPRESS_RAILS_CYPRESS_OPTS", default: "")
     )
       @rails_dir = rails_dir
@@ -17,6 +18,7 @@ module CypressRails
       @host = host
       @port = port
       @base_path = base_path
+      @transactional_server = transactional_server
       @cypress_cli_opts = cypress_cli_opts
     end
 
@@ -30,6 +32,7 @@ module CypressRails
          CYPRESS_RAILS_HOST....................#{host.inspect}
          CYPRESS_RAILS_PORT....................#{port.inspect}
          CYPRESS_RAILS_BASE_PATH...............#{base_path.inspect}
+         CYPRESS_RAILS_TRANSACTIONAL_SERVER....#{transactional_server.inspect}
          CYPRESS_RAILS_CYPRESS_OPTS............#{cypress_cli_opts.inspect}
 
       DESC

data/lib/cypress-rails/initializer_hooks.rb

@@ -16,8 +16,12 @@ module CypressRails
       register(:after_server_start, blk)
     end
 
-    def after_reset_requested(&blk)
-      register(:after_reset_requested, blk)
+    def after_transaction_start(&blk)
+      register(:after_transaction_start, blk)
+    end
+
+    def after_state_reset(&blk)
+      register(:after_state_reset, blk)
     end
 
     def before_server_stop(&blk)

data/lib/cypress-rails/launches_cypress.rb

@@ -1,6 +1,7 @@
 require_relative "finds_bin"
 require_relative "config"
 require_relative "initializer_hooks"
+require_relative "manages_transactions"
 require_relative "starts_rails_server"
 
 module CypressRails
@@ -14,9 +15,14 @@ module CypressRails
     def call(command, config)
       puts config
       @initializer_hooks.run(:before_server_start)
+      if config.transactional_server
+        ManagesTransactions.instance.begin_transaction
+        @initializer_hooks.run(:after_transaction_start)
+      end
       server = @starts_rails_server.call(
         host: config.host,
-        port: config.port
+        port: config.port,
+        transactional_server: config.transactional_server
       )
       bin = @finds_bin.call(config.cypress_dir)
 
@@ -46,6 +52,13 @@ module CypressRails
       @at_exit_hooks_have_fired ||= false # avoid warning
       return if @at_exit_hooks_have_fired
 
+      if config.transactional_server
+        begin
+          ManagesTransactions.instance.rollback_transaction
+        rescue => e
+          warn e.full_message
+        end
+      end
       @initializer_hooks.run(:before_server_stop)
 
       @at_exit_hooks_have_fired = true

data/lib/cypress-rails/manages_transactions.rb

@@ -0,0 +1,76 @@
+module CypressRails
+  class ManagesTransactions
+    def self.instance
+      @instance ||= new
+    end
+
+    module MinitestLifecycle
+      def before_setup
+      end
+
+      def after_teardown
+      end
+    end
+
+    def begin_transaction
+      return unless defined?(ActiveRecord::TestFixtures)
+
+      # A connection this thread already holds wouldn't be the pinned one
+      release_connections_held_by_this_thread
+      on_owner_thread { fixtures.before_setup }
+    end
+
+    def rollback_transaction
+      return unless defined?(ActiveRecord::TestFixtures)
+
+      begin
+        on_owner_thread { fixtures.after_teardown }
+      ensure
+        release_connections_held_by_this_thread
+      end
+    end
+
+    private
+
+    def initialize
+      @jobs = Queue.new
+      # Rails 7.1 keys a pinned connection to the thread that pinned it, and a
+      # Puma thread's end-of-request cleanup would check it back in, so a
+      # dedicated thread that never serves requests owns the transaction.
+      @owner = Thread.new do
+        loop do
+          job, result = @jobs.pop
+          begin
+            result << [:ok, job.call]
+          rescue Exception => e # standard:disable Lint/RescueException
+            result << [:error, e]
+          end
+        end
+      end
+    end
+
+    def on_owner_thread(&job)
+      result = Queue.new
+      @jobs << [job, result]
+      status, value = result.pop
+      raise value if status == :error
+      value
+    end
+
+    def release_connections_held_by_this_thread
+      ActiveRecord::Base.connection_handler.clear_active_connections!(:all)
+    end
+
+    def fixtures
+      @fixtures ||= Class.new {
+        # Must be included before TestFixtures, or its hooks never run
+        include MinitestLifecycle
+        include ActiveRecord::TestFixtures
+
+        def name
+          "cypress-rails"
+        end
+      }.new
+    end
+  end
+end

data/lib/cypress-rails/resets_state.rb

@@ -1,14 +1,43 @@
 require_relative "config"
 require_relative "initializer_hooks"
+require_relative "manages_transactions"
 
 module CypressRails
   class ResetsState
-    def initialize
-      @initializer_hooks = InitializerHooks.instance
+    LOCK = Mutex.new
+
+    def initialize(
+      transactional_server:,
+      manages_transactions: nil,
+      initializer_hooks: InitializerHooks.instance,
+      wrap: ->(&block) { Rails.application.reloader.wrap(&block) }
+    )
+      @transactional_server = transactional_server
+      @manages_transactions = manages_transactions
+      @initializer_hooks = initializer_hooks
+      @wrap = wrap
     end
 
     def call
-      @initializer_hooks.run(:after_reset_requested)
+      LOCK.synchronize do
+        if @transactional_server
+          # Outside the reloader: waiting on the owner thread while holding a
+          # reloader share could deadlock against a code reload
+          manages_transactions.rollback_transaction
+          manages_transactions.begin_transaction
+        end
+
+        @wrap.call do
+          @initializer_hooks.run(:after_transaction_start) if @transactional_server
+          @initializer_hooks.run(:after_state_reset)
+        end
+      end
+    end
+
+    private
+
+    def manages_transactions
+      @manages_transactions ||= ManagesTransactions.instance
     end
   end
 end

data/lib/cypress-rails/server.rb

@@ -23,7 +23,9 @@ module CypressRails
       host:,
       port:,
       reportable_errors: [Exception],
-      extra_middleware: [])
+      extra_middleware: [],
+      initializer_hooks: InitializerHooks.instance,
+      puma: Puma)
       @app = app
       @extra_middleware = extra_middleware
       @server_thread = nil # suppress warnings
@@ -33,7 +35,8 @@ module CypressRails
       @port ||= Server.ports[port_key]
       @port ||= find_available_port(host)
       @checker = Checker.new(@host, @port)
-      @initializer_hooks = InitializerHooks.instance
+      @initializer_hooks = initializer_hooks
+      @puma = puma
     end
 
     def reset_error!
@@ -72,7 +75,7 @@ module CypressRails
         Server.ports[port_key] = port
 
         @server_thread = Thread.new {
-          Puma.create(middleware, port, host)
+          @puma.create(middleware, port, host)
         }
 
         timer = Timer.new(60)
@@ -80,8 +83,10 @@ module CypressRails
           raise "Rack application timed out during boot" if timer.expired?
 
           @server_thread.join(0.1)
-          @initializer_hooks.run(:after_server_start)
         end
+
+        # Once the server is up, so slow hooks don't count against the timeout
+        @initializer_hooks.run(:after_server_start)
       end
 
       self

data/lib/cypress-rails/starts_rails_server.rb

@@ -1,28 +1,26 @@
-require_relative "tracks_resets"
+require_relative "resets_state"
 require_relative "server"
 
 module CypressRails
   class StartsRailsServer
-    def call(host:, port:)
-      configure_rails_to_run_our_state_reset_on_every_request!
-      app = create_rack_app
+    def call(host:, port:, transactional_server:)
+      app = create_rack_app(transactional_server)
       Server.new(app, host: host, port: port).tap do |server|
         server.boot
       end
     end
 
-    def configure_rails_to_run_our_state_reset_on_every_request!
-      Rails.application.executor.to_run do
-        TracksResets.instance.reset_state_if_needed
-      end
-    end
-
-    def create_rack_app
+    def create_rack_app(transactional_server)
       Rack::Builder.new do
         map "/cypress_rails_reset_state" do
           run lambda { |env|
-            TracksResets.instance.reset_needed!
-            [202, {"Content-Type" => "text/plain"}, ["Accepted"]]
+            begin
+              ResetsState.new(transactional_server: transactional_server).call
+              [200, {"content-type" => "text/plain"}, ["Reset"]]
+            rescue => e
+              warn e.full_message
+              [500, {"content-type" => "text/plain"}, ["#{e.class}: #{e.message}"]]
+            end
           }
         end
         map "/" do

data/lib/cypress-rails/version.rb

@@ -1,3 +1,3 @@
 module CypressRails
-  VERSION = "0.8.0"
+  VERSION = "0.9.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cypress-rails
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.9.0
 platform: ruby
 authors:
 - Justin Searls
@@ -15,14 +15,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 5.2.0
+        version: '7.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 5.2.0
+        version: '7.1'
 - !ruby/object:Gem::Dependency
   name: puma
   requirement: !ruby/object:Gem::Requirement
@@ -93,6 +93,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.2.0
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 email:
 - searls@gmail.com
 executables:
@@ -120,6 +148,7 @@ files:
 - lib/cypress-rails/init.rb
 - lib/cypress-rails/initializer_hooks.rb
 - lib/cypress-rails/launches_cypress.rb
+- lib/cypress-rails/manages_transactions.rb
 - lib/cypress-rails/open.rb
 - lib/cypress-rails/railtie.rb
 - lib/cypress-rails/rake.rb
@@ -131,7 +160,6 @@ files:
 - lib/cypress-rails/server/puma.rb
 - lib/cypress-rails/server/timer.rb
 - lib/cypress-rails/starts_rails_server.rb
-- lib/cypress-rails/tracks_resets.rb
 - lib/cypress-rails/version.rb
 - script/test
 - script/test_example_app

data/lib/cypress-rails/tracks_resets.rb

@@ -1,26 +0,0 @@
-require_relative "resets_state"
-
-module CypressRails
-  class TracksResets
-    def self.instance
-      @instance ||= new
-    end
-
-    def reset_needed!
-      @reset_needed = true
-    end
-
-    def reset_state_if_needed
-      if @reset_needed
-        ResetsState.new.call
-        @reset_needed = false
-      end
-    end
-
-    private
-
-    def initialize
-      @reset_needed = false
-    end
-  end
-end