actioncable 5.0.1 → 6.1.3

data/lib/action_cable/connection/tagged_logger_proxy.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActionCable
   module Connection
     # Allows the use of per-connection tags against the server logger. This wouldn't work using the traditional
@@ -31,8 +33,8 @@ module ActionCable
         end
       end
 
-      protected
-        def log(type, message)
+      private
+        def log(type, message) # :doc:
           tag(@logger) { @logger.send type, message }
         end
     end

data/lib/action_cable/connection/test_case.rb

@@ -0,0 +1,234 @@
+# 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 params: { 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 about 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 set up 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, **request_params)
+          path ||= DEFAULT_PATH
+
+          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/connection/web_socket.rb

@@ -1,11 +1,13 @@
-require 'websocket/driver'
+# frozen_string_literal: true
+
+require "websocket/driver"
 
 module ActionCable
   module Connection
     # Wrap the real socket to minimize the externally-presented API
-    class WebSocket
-      def initialize(env, event_target, event_loop, client_socket_class, protocols: ActionCable::INTERNAL[:protocols])
-        @websocket = ::WebSocket::Driver.websocket?(env) ? client_socket_class.new(env, event_target, event_loop, protocols) : nil
+    class WebSocket # :nodoc:
+      def initialize(env, event_target, event_loop, protocols: ActionCable::INTERNAL[:protocols])
+        @websocket = ::WebSocket::Driver.websocket?(env) ? ClientSocket.new(env, event_target, event_loop, protocols) : nil
       end
 
       def possible?
@@ -32,7 +34,7 @@ module ActionCable
         websocket.rack_response
       end
 
-      protected
+      private
         attr_reader :websocket
     end
   end

data/lib/action_cable/engine.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "rails"
 require "action_cable"
 require "action_cable/helpers/action_cable_helper"
@@ -22,19 +24,19 @@ module ActionCable
 
     initializer "action_cable.set_configs" do |app|
       options = app.config.action_cable
-      options.allowed_request_origins ||= "http://localhost:3000" if ::Rails.env.development?
+      options.allowed_request_origins ||= /https?:\/\/localhost:\d+/ if ::Rails.env.development?
 
       app.paths.add "config/cable", with: "config/cable.yml"
 
       ActiveSupport.on_load(:action_cable) do
         if (config_path = Pathname.new(app.config.paths["config/cable"].first)).exist?
-          self.cable = Rails.application.config_for(config_path).with_indifferent_access
+          self.cable = Rails.application.config_for(config_path).to_h.with_indifferent_access
         end
 
-        previous_connection_class = self.connection_class
-        self.connection_class = -> { 'ApplicationCable::Connection'.safe_constantize || previous_connection_class.call }
+        previous_connection_class = connection_class
+        self.connection_class = -> { "ApplicationCable::Connection".safe_constantize || previous_connection_class.call }
 
-        options.each { |k,v| send("#{k}=", v) }
+        options.each { |k, v| send("#{k}=", v) }
       end
     end
 

data/lib/action_cable/gem_version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActionCable
   # Returns the version of the currently loaded Action Cable as a <tt>Gem::Version</tt>.
   def self.gem_version
@@ -5,9 +7,9 @@ module ActionCable
   end
 
   module VERSION
-    MAJOR = 5
-    MINOR = 0
-    TINY  = 1
+    MAJOR = 6
+    MINOR = 1
+    TINY  = 3
     PRE   = nil
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")

data/lib/action_cable/helpers/action_cable_helper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActionCable
   module Helpers
     module ActionCableHelper
@@ -6,15 +8,15 @@ module ActionCable
       #
       #   <head>
       #     <%= action_cable_meta_tag %>
-      #     <%= javascript_include_tag 'application', 'data-turbolinks-track' => true %>
+      #     <%= javascript_include_tag 'application', 'data-turbolinks-track' => 'reload' %>
       #   </head>
       #
       # This is then used by Action Cable to determine the URL of your WebSocket server.
-      # Your CoffeeScript can then connect to the server without needing to specify the
+      # Your JavaScript can then connect to the server without needing to specify the
       # URL directly:
       #
-      #   #= require cable
-      #   @App = {}
+      #   window.Cable = require("@rails/actioncable")
+      #   window.App = {}
       #   App.cable = Cable.createConsumer()
       #
       # Make sure to specify the correct server location in each of your environment

data/lib/action_cable/remote_connections.rb

@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/module/redefine_method"
+
 module ActionCable
   # If you need to disconnect a given connection, you can go through the
   # RemoteConnections. You can find the connections you're looking for by
@@ -41,20 +45,21 @@ module ActionCable
 
         # Uses the internal channel to disconnect the connection.
         def disconnect
-          server.broadcast internal_channel, type: 'disconnect'
+          server.broadcast internal_channel, type: "disconnect"
         end
 
         # Returns all the identifiers that were applied to this connection.
-        def identifiers
+        redefine_method :identifiers do
           server.connection_identifiers
         end
 
-        private
+        protected
           attr_reader :server
 
+        private
           def set_identifier_instance_vars(ids)
             raise InvalidIdentifiersError unless valid_identifiers?(ids)
-            ids.each { |k,v| instance_variable_set("@#{k}", v) }
+            ids.each { |k, v| instance_variable_set("@#{k}", v) }
           end
 
           def valid_identifiers?(ids)

data/lib/action_cable/server.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActionCable
   module Server
     extend ActiveSupport::Autoload
@@ -9,7 +11,6 @@ module ActionCable
       autoload :Configuration
 
       autoload :Worker
-      autoload :ActiveRecordConnectionManagement, 'action_cable/server/worker/active_record_connection_management'
     end
   end
 end

data/lib/action_cable/server/base.rb

@@ -1,4 +1,6 @@
-require 'monitor'
+# frozen_string_literal: true
+
+require "monitor"
 
 module ActionCable
   module Server
@@ -10,31 +12,36 @@ module ActionCable
       include ActionCable::Server::Broadcasting
       include ActionCable::Server::Connections
 
-      cattr_accessor(:config, instance_accessor: true) { ActionCable::Server::Configuration.new }
+      cattr_accessor :config, instance_accessor: false, default: ActionCable::Server::Configuration.new
+
+      attr_reader :config
 
       def self.logger; config.logger; end
       delegate :logger, to: :config
 
       attr_reader :mutex
 
-      def initialize
+      def initialize(config: self.class.config)
+        @config = config
         @mutex = Monitor.new
         @remote_connections = @event_loop = @worker_pool = @pubsub = nil
       end
 
-      # Called by Rack to setup the server.
+      # Called by Rack to set up the server.
       def call(env)
         setup_heartbeat_timer
         config.connection_class.call.new(self, env).process
       end
 
-      # Disconnect all the connections identified by `identifiers` on this server or any others via RemoteConnections.
+      # Disconnect all the connections identified by +identifiers+ on this server or any others via RemoteConnections.
       def disconnect(identifiers)
         remote_connections.where(identifiers).disconnect
       end
 
       def restart
-        connections.each(&:close)
+        connections.each do |connection|
+          connection.close(reason: ActionCable::INTERNAL[:disconnect_reasons][:server_restart])
+        end
 
         @mutex.synchronize do
           # Shutdown the worker pool
@@ -53,20 +60,20 @@ module ActionCable
       end
 
       def event_loop
-        @event_loop || @mutex.synchronize { @event_loop ||= config.event_loop_class.new }
+        @event_loop || @mutex.synchronize { @event_loop ||= ActionCable::Connection::StreamEventLoop.new }
       end
 
       # The worker pool is where we run connection callbacks and channel actions. We do as little as possible on the server's main thread.
       # The worker pool is an executor service that's backed by a pool of threads working from a task queue. The thread pool size maxes out
-      # at 4 worker threads by default. Tune the size yourself with config.action_cable.worker_pool_size.
+      # at 4 worker threads by default. Tune the size yourself with <tt>config.action_cable.worker_pool_size</tt>.
       #
       # Using Active Record, Redis, etc within your channel actions means you'll get a separate connection from each thread in the worker pool.
       # Plan your deployment accordingly: 5 servers each running 5 Puma workers each running an 8-thread worker pool means at least 200 database
       # connections.
       #
       # Also, ensure that your database connection pool size is as least as large as your worker pool size. Otherwise, workers may oversubscribe
-      # the db connection pool and block while they wait for other workers to release their connections. Use a smaller worker pool or a larger
-      # db connection pool instead.
+      # the database connection pool and block while they wait for other workers to release their connections. Use a smaller worker pool or a larger
+      # database connection pool instead.
       def worker_pool
         @worker_pool || @mutex.synchronize { @worker_pool ||= ActionCable::Server::Worker.new(max_size: config.worker_pool_size) }
       end