action-cable-testing 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6e9a6464f3ec1cc6ee48f51d97f0a8e0bebd34c3fee8f9523f01a6e0b6f19382
-  data.tar.gz: 3db543599b78e0944fa89679d47ab02275c09714b59b134430662a74163cddd8
+  metadata.gz: e9193234672a859c68a8e8d2a68dab7a7ed89b8038f77f3ffd91cd9fc77f4fb8
+  data.tar.gz: e314c6633804c930a8963f9c8b0540214b4e070f9d0c77c29199efc164c1f55f
 SHA512:
-  metadata.gz: 787512840b4dda952c365f770fcfb5858d6cbfb0ce261ca9fcbeb3384fd32a0102f490e4a1e1840a4fa1a3f68b9d4a24a4840322104a33af1a3164036b02bf5b
-  data.tar.gz: 2558049b61e39c42f57bd7a5a98f85522129a7d27001c5721e6525c56ba24136d9de913d579c02fd95205a8653eefed99006da3e722602b3fa7815eae69c9eda
+  metadata.gz: cbe3764f6edf4b3d894b59440c1591a50c6677270102f408314c4fb329e124ae88f903d0ba202125bc59fed96df22e5971734a568a5b84f3a87d59df19d2ecba
+  data.tar.gz: bd252a3a5c11a65606c0da763e53b1a80a88a038e21f231ec902ae2f210d997589414e5b53f77e30ab655cb644a93184e12b3e211a3082160e6ddc6f57c461a5

data/CHANGELOG.md

@@ -2,6 +2,17 @@
 
 ## master
 
+## 0.5.0 (2019-02-24)
+
+- Make compatible with Rails 6. ([@palkan][])
+
+  That allows using RSpec part of the gem with Rails 6
+  (since Action Cable testing will included only in the upcoming RSpec 4).
+
+- Backport Rails 6.0 API changes. ([@palkan][], [@sponomarev][])
+
+  Some APIs have been deprecated (to be removed in 1.0).
+
 ## 0.4.0 (2019-01-10)
 
 - Add stream assert methods and matchers. ([@sponomarev][])

data/README.md

@@ -4,7 +4,11 @@
 
 This gem provides missing testing utils for [Action Cable][].
 
-**NOTE:** this gem is just a combination of two PRs to Rails itself ([#23211](https://github.com/rails/rails/pull/23211) and [#27191](https://github.com/rails/rails/pull/27191)) and (hopefully) will be merged into Rails eventually.
+**NOTE:** this gem [has](https://github.com/rails/rails/pull/33659) [been](https://github.com/rails/rails/pull/33969) [merged](https://github.com/rails/rails/pull/34845) into Rails 6.0.
+
+If you're using Minitest – you don't need this gem anymore.
+
+If you're using RSpec < 4, you still can use this gem to write Action Cable specs even for Rails 6.
 
 
 ## Installation
@@ -60,6 +64,41 @@ class ExampleTest < ActionDispatch::IntegrationTest
 end
 ```
 
+If you want to test the broadcasting made with `Channel.broadcast_to`, you should use
+`Channel.broadcasting_for`\* to generate an underlying stream name and **use Rails 6 compatibility refinement**:
+
+```ruby
+# app/jobs/chat_relay_job.rb
+class ChatRelayJob < ApplicationJob
+  def perform_later(room, message)
+    ChatChannel.broadcast_to room, text: message
+  end
+end
+
+
+# test/jobs/chat_relay_job_test.rb
+require "test_helper"
+
+# Activate Rails 6 compatible API (for `broadcasting_for`)
+using ActionCable::Testing::Rails6
+
+class ChatRelayJobTest < ActiveJob::TestCase
+  include ActionCable::TestHelper
+
+  test "broadcast message to room" do
+    room = rooms(:all)
+
+    assert_broadcast_on(ChatChannel.broadcasting_for(room), text: "Hi!") do
+      ChatRelayJob.perform_now(room, "Hi!")
+    end
+  end
+end
+```
+
+\* **NOTE:** in Rails 6.0 you should use `.broadcasting_for`, but it's not backward compatible
+and we cannot use it in Rails 5.x. See https://github.com/rails/rails/pull/35021.
+Note also, that this feature hasn't been released in Rails 6.0.0.beta1, so you still need the refinement.
+
 ### Channels Testing
 
 Channels tests are written as follows:
@@ -166,8 +205,10 @@ For example:
 module ApplicationCable
   class ConnectionTest < ActionCable::Connection::TestCase
     def test_connects_with_cookies
+      cookies.signed[:user_id] = users[:john].id
+
       # Simulate a connection
-      connect cookies: { user_id: users[:john].id }
+      connect
 
       # Asserts that the connection identifier is correct
       assert_equal "John", connection.user.name

data/lib/action_cable/testing.rb

@@ -3,24 +3,19 @@
 require "action_cable/testing/version"
 
 require "action_cable"
+require "action_cable/testing/rails_six"
 
-module ActionCable
-  autoload :TestCase
-  autoload :TestHelper
+# These has been merged into Rails 6
+unless ActionCable::VERSION::MAJOR >= 6
+  require "action_cable/testing/test_helper"
+  require "action_cable/testing/test_case"
 
-  module Channel
-    eager_autoload do
-      autoload :TestCase
-    end
-  end
+  require "action_cable/testing/channel/test_case"
 
-  module Connection
-    eager_autoload do
-      autoload :TestCase
-    end
-  end
+  require "action_cable/testing/connection/test_case"
 
-  module SubscriptionAdapter
-    autoload :Test
-  end
+  # We cannot move subsription adapter under 'testing/' path,
+  # 'cause Action Cable uses this path when resolving an
+  # adapter from its name (in the config.yml)
+  require "action_cable/subscription_adapter/test"
 end

data/lib/action_cable/{channel → testing/channel}/test_case.rb

@@ -10,7 +10,7 @@ module ActionCable
     class NonInferrableChannelError < ::StandardError
       def initialize(name)
         super "Unable to determine the channel to test from #{name}. " +
-          "You'll need to specify it using tests YourChannel in your " +
+          "You'll need to specify it using `tests YourChannel` in your " +
           "test case definition."
       end
     end
@@ -150,14 +150,13 @@ module ActionCable
 
         include ActiveSupport::Testing::ConstantLookup
         include ActionCable::TestHelper
-        include ActionCable::Connection::TestCase::Behavior
 
         CHANNEL_IDENTIFIER = "test_stub"
 
         included do
           class_attribute :_channel_class
 
-          attr_reader :subscription
+          attr_reader :connection, :subscription
 
           def streams
             ActiveSupport::Deprecation.warn "Use appropriate `assert_has_stream`, `assert_has_stream_for`, `assert_no_streams` " +
@@ -242,6 +241,16 @@ module ActionCable
           connection.transmissions.map { |data| data["message"] }.compact
         end
 
+        # Enhance TestHelper assertions to handle non-String
+        # broadcastings
+        def assert_broadcasts(stream_or_object, *args)
+          super(broadcasting_for(stream_or_object), *args)
+        end
+
+        def assert_broadcast_on(stream_or_object, *args)
+          super(broadcasting_for(stream_or_object), *args)
+        end
+
         # Asserts that no streams have been started.
         #
         #   def test_assert_no_started_stream

data/lib/action_cable/testing/connection/test_case.rb

@@ -0,0 +1,242 @@
+# frozen_string_literal: true
+
+require "active_support"
+require "active_support/test_case"
+require "active_support/core_ext/hash/indifferent_access"
+require "action_dispatch"
+require "action_dispatch/http/headers"
+require "action_dispatch/testing/test_request"
+
+module ActionCable
+  module Connection
+    class NonInferrableConnectionError < ::StandardError
+      def initialize(name)
+        super "Unable to determine the connection to test from #{name}. " +
+          "You'll need to specify it using `tests YourConnection` in your " +
+          "test case definition."
+      end
+    end
+
+    module Assertions
+      # Asserts that the connection is rejected (via +reject_unauthorized_connection+).
+      #
+      #   # Asserts that connection without user_id fails
+      #   assert_reject_connection { connect cookies: { user_id: '' } }
+      def assert_reject_connection(&block)
+        assert_raises(Authorization::UnauthorizedError, "Expected to reject connection but no rejection was made", &block)
+      end
+    end
+
+    # We don't want to use the whole "encryption stack" for connection
+    # unit-tests, but we want to make sure that users test against the correct types
+    # of cookies (i.e. signed or encrypted or plain)
+    class TestCookieJar < ActiveSupport::HashWithIndifferentAccess
+      def signed
+        self[:signed] ||= {}.with_indifferent_access
+      end
+
+      def encrypted
+        self[:encrypted] ||= {}.with_indifferent_access
+      end
+    end
+
+    class TestRequest < ActionDispatch::TestRequest
+      attr_accessor :session, :cookie_jar
+    end
+
+    module TestConnection
+      attr_reader :logger, :request
+
+      def initialize(request)
+        inner_logger = ActiveSupport::Logger.new(StringIO.new)
+        tagged_logging = ActiveSupport::TaggedLogging.new(inner_logger)
+        @logger = ActionCable::Connection::TaggedLoggerProxy.new(tagged_logging, tags: [])
+        @request = request
+        @env = request.env
+      end
+    end
+
+    # Unit test Action Cable connections.
+    #
+    # Useful to check whether a connection's +identified_by+ gets assigned properly
+    # and that any improper connection requests are rejected.
+    #
+    # == Basic example
+    #
+    # Unit tests are written as follows:
+    #
+    # 1. Simulate a connection attempt by calling +connect+.
+    # 2. Assert state, e.g. identifiers, has been assigned.
+    #
+    #
+    #   class ApplicationCable::ConnectionTest < ActionCable::Connection::TestCase
+    #     def test_connects_with_proper_cookie
+    #       # Simulate the connection request with a cookie.
+    #       cookies["user_id"] = users(:john).id
+    #
+    #       connect
+    #
+    #       # Assert the connection identifier matches the fixture.
+    #       assert_equal users(:john).id, connection.user.id
+    #     end
+    #
+    #     def test_rejects_connection_without_proper_cookie
+    #       assert_reject_connection { connect }
+    #     end
+    #   end
+    #
+    # +connect+ accepts additional information the HTTP request with the
+    # +params+, +headers+, +session+ and Rack +env+ options.
+    #
+    #   def test_connect_with_headers_and_query_string
+    #     connect params: { user_id: 1 }, headers: { "X-API-TOKEN" => "secret-my" }
+    #
+    #     assert_equal "1", connection.user.id
+    #     assert_equal "secret-my", connection.token
+    #   end
+    #
+    #   def test_connect_with_params
+    #     connect params: { user_id: 1 }
+    #
+    #     assert_equal "1", connection.user.id
+    #   end
+    #
+    # You can also setup the correct cookies before the connection request:
+    #
+    #   def test_connect_with_cookies
+    #     # Plain cookies:
+    #     cookies["user_id"] = 1
+    #
+    #     # Or signed/encrypted:
+    #     # cookies.signed["user_id"] = 1
+    #     # cookies.encrypted["user_id"] = 1
+    #
+    #     connect
+    #
+    #     assert_equal "1", connection.user_id
+    #   end
+    #
+    # == Connection is automatically inferred
+    #
+    # ActionCable::Connection::TestCase will automatically infer the connection under test
+    # from the test class name. If the channel cannot be inferred from the test
+    # class name, you can explicitly set it with +tests+.
+    #
+    #   class ConnectionTest < ActionCable::Connection::TestCase
+    #     tests ApplicationCable::Connection
+    #   end
+    #
+    class TestCase < ActiveSupport::TestCase
+      module Behavior
+        extend ActiveSupport::Concern
+
+        DEFAULT_PATH = "/cable"
+
+        include ActiveSupport::Testing::ConstantLookup
+        include Assertions
+
+        included do
+          class_attribute :_connection_class
+
+          attr_reader :connection
+
+          ActiveSupport.run_load_hooks(:action_cable_connection_test_case, self)
+        end
+
+        module ClassMethods
+          def tests(connection)
+            case connection
+            when String, Symbol
+              self._connection_class = connection.to_s.camelize.constantize
+            when Module
+              self._connection_class = connection
+            else
+              raise NonInferrableConnectionError.new(connection)
+            end
+          end
+
+          def connection_class
+            if connection = self._connection_class
+              connection
+            else
+              tests determine_default_connection(name)
+            end
+          end
+
+          def determine_default_connection(name)
+            connection = determine_constant_from_test_name(name) do |constant|
+              Class === constant && constant < ActionCable::Connection::Base
+            end
+            raise NonInferrableConnectionError.new(name) if connection.nil?
+            connection
+          end
+        end
+
+        # Performs connection attempt to exert #connect on the connection under test.
+        #
+        # Accepts request path as the first argument and the following request options:
+        #
+        # - params – url parameters (Hash)
+        # - headers – request headers (Hash)
+        # - session – session data (Hash)
+        # - env – additional Rack env configuration (Hash)
+        def connect(path = ActionCable.server.config.mount_path, cookies: nil, **request_params)
+          path ||= DEFAULT_PATH
+
+          unless cookies.nil?
+            ActiveSupport::Deprecation.warn(
+              "Use `cookies[:param] = value` (or `cookies.signed[:param] = value`). " \
+              "Passing `cookies` as the `connect` option is deprecated and is going to be removed in version 1.0"
+            )
+            cookies.each { |k, v| self.cookies[k] = v }
+          end
+
+          connection = self.class.connection_class.allocate
+          connection.singleton_class.include(TestConnection)
+          connection.send(:initialize, build_test_request(path, request_params))
+          connection.connect if connection.respond_to?(:connect)
+
+          # Only set instance variable if connected successfully
+          @connection = connection
+        end
+
+        # Exert #disconnect on the connection under test.
+        def disconnect
+          raise "Must be connected!" if connection.nil?
+
+          connection.disconnect if connection.respond_to?(:disconnect)
+          @connection = nil
+        end
+
+        def cookies
+          @cookie_jar ||= TestCookieJar.new
+        end
+
+        private
+          def build_test_request(path, params: nil, headers: {}, session: {}, env: {})
+            wrapped_headers = ActionDispatch::Http::Headers.from_hash(headers)
+
+            uri = URI.parse(path)
+
+            query_string = params.nil? ? uri.query : params.to_query
+
+            request_env = {
+              "QUERY_STRING" => query_string,
+              "PATH_INFO" => uri.path
+            }.merge(env)
+
+            if wrapped_headers.present?
+              ActionDispatch::Http::Headers.from_hash(request_env).merge!(wrapped_headers)
+            end
+
+            TestRequest.create(request_env).tap do |request|
+              request.session = session.with_indifferent_access
+              request.cookie_jar = cookies
+            end
+          end
+      end
+
+      include Behavior
+    end
+  end
+end

data/lib/action_cable/testing/rails_six.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module ActionCable
+  module Testing
+    # Enables Rails 6 compatible API via Refinements.
+    #
+    # Use this to write Rails 6 compatible tests (not every Rails 6 API
+    # could be backported).
+    #
+    # Usage:
+    #   # my_test.rb
+    #   require "test_helper"
+    #
+    #   using ActionCable::Testing::Syntax
+    module Rails6
+      begin
+        # Has been added only after 6.0.0.beta1
+        unless ActionCable::Channel.respond_to?(:serialize_broadcasting)
+          refine ActionCable::Channel::Broadcasting::ClassMethods do
+            def broadcasting_for(model)
+              super([channel_name, model])
+            end
+          end
+        end
+
+        SUPPORTED = true
+      rescue TypeError
+        warn "Your Ruby version doesn't suppport Module refinements. " \
+             "Rails 6 compatibility refinement could not be applied"
+
+        SUPPORTED = false
+      end
+    end
+  end
+end

data/lib/action_cable/{test_helper.rb → testing/test_helper.rb}

@@ -3,7 +3,7 @@
 module ActionCable
   # Provides helper methods for testing Action Cable broadcasting
   module TestHelper
-    CHANNEL_NOT_FOUND = ArgumentError.new("Broadcastnig channel can't be infered. Please, specify it with `:channel`")
+    CHANNEL_NOT_FOUND = ArgumentError.new("Broadcasting channel can't be infered. Please, specify it with `:channel`")
 
     def before_setup # :nodoc:
       server = ActionCable.server
@@ -45,6 +45,8 @@ module ActionCable
     #   end
     #
     def assert_broadcasts(target, number, channel: nil)
+      warn_deprecated_channel! unless channel.nil?
+
       stream = stream(target, channel)
 
       if block_given?
@@ -98,6 +100,8 @@ module ActionCable
     #   end
     #
     def assert_broadcast_on(target, data, channel: nil)
+      warn_deprecated_channel! unless channel.nil?
+
       # Encode to JSON and back–we want to use this value to compare
       # with decoded JSON.
       # Comparing JSON strings doesn't work due to the order if the keys.
@@ -138,9 +142,17 @@ module ActionCable
         return target if target.is_a?(String)
 
         channel ||= @subscription
-        raise CHANNEL_NOT_FOUND unless channel && channel.respond_to?(:channel_name)
+        return target unless channel && channel.respond_to?(:channel_name)
 
         channel.broadcasting_for([channel.channel_name, target])
       end
+
+      def warn_deprecated_channel!
+        ActiveSupport::Deprecation.warn(
+          "Passing channel class is deprecated and will be removed in version 1.0. " \
+          "Use `Channel.broadcasting_for(object) to build a stream name instead and " \
+          "add `using ActionCable::Testing::Rails6` to your test file."
+        )
+      end
   end
 end

data/lib/action_cable/testing/version.rb

@@ -2,6 +2,6 @@
 
 module ActionCable
   module Testing
-    VERSION = "0.4.0"
+    VERSION = "0.5.0"
   end
 end

data/lib/rspec/rails/example/channel_example_group.rb

@@ -21,6 +21,7 @@ if defined?(ActionCable)
       module ChannelExampleGroup
         extend ActiveSupport::Concern
         include RSpec::Rails::RailsExampleGroup
+        include ActionCable::Connection::TestCase::Behavior
         include ActionCable::Channel::TestCase::Behavior
 
         # Class-level DSL for channel specs.

data/lib/rspec/rails/matchers/action_cable/have_broadcasted_to.rb

@@ -160,7 +160,7 @@ module RSpec
           def check_channel_presence
             return if @channel.present? && @channel.respond_to?(:channel_name)
 
-            error_msg = "Broadcastnig channel can't be infered. Please, specify it with `from_channel`"
+            error_msg = "Broadcasting channel can't be infered. Please, specify it with `from_channel`"
             raise ArgumentError, error_msg
           end
         end

metadata

@@ -1,27 +1,27 @@
 --- !ruby/object:Gem::Specification
 name: action-cable-testing
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Vladimir Dementyev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-01-10 00:00:00.000000000 Z
+date: 2019-02-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: actioncable
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '5.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '5.0'
 - !ruby/object:Gem::Dependency
@@ -147,14 +147,15 @@ files:
 - LICENSE.txt
 - README.md
 - lib/action-cable-testing.rb
-- lib/action_cable/channel/test_case.rb
-- lib/action_cable/connection/test_case.rb
 - lib/action_cable/subscription_adapter/test.rb
-- lib/action_cable/test_case.rb
-- lib/action_cable/test_helper.rb
 - lib/action_cable/testing.rb
+- lib/action_cable/testing/channel/test_case.rb
+- lib/action_cable/testing/connection/test_case.rb
+- lib/action_cable/testing/rails_six.rb
 - lib/action_cable/testing/rspec.rb
 - lib/action_cable/testing/rspec/features.rb
+- lib/action_cable/testing/test_case.rb
+- lib/action_cable/testing/test_helper.rb
 - lib/action_cable/testing/version.rb
 - lib/generators/rspec/channel/channel_generator.rb
 - lib/generators/rspec/channel/templates/channel_spec.rb.erb
@@ -177,7 +178,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.3.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="

data/lib/action_cable/connection/test_case.rb

@@ -1,201 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support"
-require "active_support/test_case"
-require "active_support/core_ext/hash/indifferent_access"
-require "action_dispatch"
-require "action_dispatch/testing/test_request"
-
-module ActionCable
-  module Connection
-    class NonInferrableConnectionError < ::StandardError
-      def initialize(name)
-        super "Unable to determine the connection to test from #{name}. " +
-          "You'll need to specify it using tests YourConnection in your " +
-          "test case definition."
-      end
-    end
-
-    module Assertions
-      # Asserts that the connection is rejected (via +reject_unauthorized_connection+).
-      #
-      #   # Asserts that connection without user_id fails
-      #   assert_reject_connection { connect cookies: { user_id: '' } }
-      def assert_reject_connection(&block)
-        res =
-          begin
-            block.call
-            false
-          rescue ActionCable::Connection::Authorization::UnauthorizedError
-            true
-          end
-
-        assert res, "Expected to reject connection but no rejection were made"
-      end
-    end
-
-    class TestRequest < ActionDispatch::TestRequest
-      attr_reader :cookie_jar
-      attr_accessor :session
-
-      module CookiesStub
-        # Stub signed cookies
-        def signed
-          self
-        end
-
-        # Stub encrypted cookies
-        def encrypted
-          self
-        end
-      end
-
-      def cookie_jar=(val)
-        @cookie_jar = val.tap do |h|
-          h.singleton_class.include(CookiesStub)
-        end
-      end
-    end
-
-    module TestConnection
-      attr_reader :logger, :request
-
-      def initialize(path, cookies, headers, session)
-        inner_logger = ActiveSupport::Logger.new(StringIO.new)
-        tagged_logging = ActiveSupport::TaggedLogging.new(inner_logger)
-        @logger = ActionCable::Connection::TaggedLoggerProxy.new(tagged_logging, tags: [])
-
-        uri = URI.parse(path)
-        env = {
-          "QUERY_STRING" => uri.query,
-          "PATH_INFO" => uri.path
-        }.merge(build_headers(headers))
-
-        @request = TestRequest.create(env)
-        @request.cookie_jar = cookies.with_indifferent_access
-        @request.session = session.with_indifferent_access
-      end
-
-      def build_headers(headers)
-        headers.each_with_object({}) do |(k, v), obj|
-          k = k.upcase
-          k.tr!("-", "_")
-          obj["HTTP_#{k}"] = v
-        end
-      end
-    end
-
-    # Superclass for Action Cable connection unit tests.
-    #
-    # == Basic example
-    #
-    # Unit tests are written as follows:
-    # 1. First, one uses the +connect+ method to simulate connection.
-    # 2. Then, one asserts whether the current state is as expected (e.g. identifiers).
-    #
-    # For example:
-    #
-    #   module ApplicationCable
-    #     class ConnectionTest < ActionCable::Connection::TestCase
-    #       def test_connects_with_cookies
-    #         # Simulate a connection
-    #         connect cookies: { user_id: users[:john].id }
-    #
-    #         # Asserts that the connection identifier is correct
-    #         assert_equal "John", connection.user.name
-    #     end
-    #
-    #     def test_does_not_connect_without_user
-    #       assert_reject_connection do
-    #         connect
-    #       end
-    #     end
-    #   end
-    #
-    # You can also provide additional information about underlying HTTP request:
-    #   def test_connect_with_headers_and_query_string
-    #     connect "/cable?user_id=1", headers: { "X-API-TOKEN" => 'secret-my' }
-    #
-    #     assert_equal connection.user_id, "1"
-    #   end
-    #
-    # == Connection is automatically inferred
-    #
-    # ActionCable::Connection::TestCase will automatically infer the connection under test
-    # from the test class name. If the channel cannot be inferred from the test
-    # class name, you can explicitly set it with +tests+.
-    #
-    #   class ConnectionTest < ActionCable::Connection::TestCase
-    #     tests ApplicationCable::Connection
-    #   end
-    #
-    class TestCase < ActiveSupport::TestCase
-      module Behavior
-        extend ActiveSupport::Concern
-
-        include ActiveSupport::Testing::ConstantLookup
-        include Assertions
-
-        included do
-          class_attribute :_connection_class
-
-          attr_reader :connection
-
-          ActiveSupport.run_load_hooks(:action_cable_connection_test_case, self)
-        end
-
-        module ClassMethods
-          def tests(connection)
-            case connection
-            when String, Symbol
-              self._connection_class = connection.to_s.camelize.constantize
-            when Module
-              self._connection_class = connection
-            else
-              raise NonInferrableConnectionError.new(connection)
-            end
-          end
-
-          def connection_class
-            if connection = self._connection_class
-              connection
-            else
-              tests determine_default_connection(name)
-            end
-          end
-
-          def determine_default_connection(name)
-            connection = determine_constant_from_test_name(name) do |constant|
-              Class === constant && constant < ActionCable::Connection::Base
-            end
-            raise NonInferrableConnectionError.new(name) if connection.nil?
-            connection
-          end
-        end
-
-        # Performs connection attempt (i.e. calls #connect method).
-        #
-        # Accepts request path as the first argument and cookies and headers as options.
-        def connect(path = "/cable", cookies: {}, headers: {}, session: {})
-          connection = self.class.connection_class.allocate
-          connection.singleton_class.include(TestConnection)
-          connection.send(:initialize, path, cookies, headers, session)
-          connection.connect if connection.respond_to?(:connect)
-
-          # Only set instance variable if connected successfully
-          @connection = connection
-        end
-
-        # Disconnect the connection under test (i.e. calls #disconnect)
-        def disconnect
-          raise "Must be connected!" if connection.nil?
-
-          connection.disconnect if connection.respond_to?(:disconnect)
-          @connection = nil
-        end
-      end
-
-      include Behavior
-    end
-  end
-end