actioncable 5.2.2.1 → 6.0.2

data/lib/action_cable/connection/authorization.rb

@@ -5,7 +5,7 @@ module ActionCable
     module Authorization
       class UnauthorizedError < StandardError; end
 
-      # Closes the \WebSocket connection if it is open and returns a 404 "File not Found" response.
+      # Closes the WebSocket connection if it is open and returns a 404 "File not Found" response.
       def reject_unauthorized_connection
         logger.error "An unauthorized connection attempt was rejected"
         raise UnauthorizedError

data/lib/action_cable/connection/base.rb

@@ -95,7 +95,12 @@ module ActionCable
       end
 
       # Close the WebSocket connection.
-      def close
+      def close(reason: nil, reconnect: true)
+        transmit(
+          type: ActionCable::INTERNAL[:message_types][:disconnect],
+          reason: reason,
+          reconnect: reconnect
+        )
         websocket.close
       end
 
@@ -136,13 +141,10 @@ module ActionCable
         send_async :handle_close
       end
 
-      # TODO Change this to private once we've dropped Ruby 2.2 support.
-      # Workaround for Ruby 2.2 "private attribute?" warning.
-      protected
+      private
         attr_reader :websocket
         attr_reader :message_buffer
 
-      private
         # The request that initiated the WebSocket connection is available here. This gives access to the environment, cookies, etc.
         def request # :doc:
           @request ||= begin
@@ -173,7 +175,7 @@ module ActionCable
           message_buffer.process!
           server.add_connection(self)
         rescue ActionCable::Connection::Authorization::UnauthorizedError
-          respond_to_invalid_request
+          close(reason: ActionCable::INTERNAL[:disconnect_reasons][:unauthorized], reconnect: false) if websocket.alive?
         end
 
         def handle_close
@@ -214,7 +216,7 @@ module ActionCable
         end
 
         def respond_to_invalid_request
-          close if websocket.alive?
+          close(reason: ActionCable::INTERNAL[:disconnect_reasons][:invalid_request]) if websocket.alive?
 
           logger.error invalid_request_message
           logger.info finished_request_message
@@ -258,3 +260,5 @@ module ActionCable
     end
   end
 end
+
+ActiveSupport.run_load_hooks(:action_cable_connection, ActionCable::Connection::Base)

data/lib/action_cable/connection/message_buffer.rb

@@ -30,13 +30,10 @@ module ActionCable
         receive_buffered_messages
       end
 
-      # TODO Change this to private once we've dropped Ruby 2.2 support.
-      # Workaround for Ruby 2.2 "private attribute?" warning.
-      protected
+      private
         attr_reader :connection
         attr_reader :buffered_messages
 
-      private
         def valid?(message)
           message.is_a?(String)
         end

data/lib/action_cable/connection/stream.rb

@@ -98,8 +98,10 @@ module ActionCable
       def hijack_rack_socket
         return unless @socket_object.env["rack.hijack"]
 
-        @socket_object.env["rack.hijack"].call
-        @rack_hijack_io = @socket_object.env["rack.hijack_io"]
+        # This should return the underlying io according to the SPEC:
+        @rack_hijack_io = @socket_object.env["rack.hijack"].call
+        # Retain existing behaviour if required:
+        @rack_hijack_io ||= @socket_object.env["rack.hijack_io"]
 
         @event_loop.attach(@rack_hijack_io, self)
       end

data/lib/action_cable/connection/subscriptions.rb

@@ -63,12 +63,8 @@ module ActionCable
         subscriptions.each { |id, channel| remove_subscription(channel) }
       end
 
-      # TODO Change this to private once we've dropped Ruby 2.2 support.
-      # Workaround for Ruby 2.2 "private attribute?" warning.
-      protected
-        attr_reader :connection, :subscriptions
-
       private
+        attr_reader :connection, :subscriptions
         delegate :logger, to: :connection
 
         def find(data)

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 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, **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

@@ -34,9 +34,7 @@ module ActionCable
         websocket.rack_response
       end
 
-      # TODO Change this to private once we've dropped Ruby 2.2 support.
-      # Workaround for Ruby 2.2 "private attribute?" warning.
-      protected
+      private
         attr_reader :websocket
     end
   end

data/lib/action_cable/gem_version.rb

@@ -7,10 +7,10 @@ module ActionCable
   end
 
   module VERSION
-    MAJOR = 5
-    MINOR = 2
+    MAJOR = 6
+    MINOR = 0
     TINY  = 2
-    PRE   = "1"
+    PRE   = nil
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
   end

data/lib/action_cable/server/base.rb

@@ -12,14 +12,17 @@ module ActionCable
       include ActionCable::Server::Broadcasting
       include ActionCable::Server::Connections
 
-      cattr_accessor :config, instance_accessor: true, default: 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
@@ -36,7 +39,9 @@ module ActionCable
       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

data/lib/action_cable/server/worker.rb

@@ -56,14 +56,12 @@ module ActionCable
 
       def invoke(receiver, method, *args, connection:, &block)
         work(connection) do
-          begin
-            receiver.send method, *args, &block
-          rescue Exception => e
-            logger.error "There was an exception - #{e.class}(#{e.message})"
-            logger.error e.backtrace.join("\n")
+          receiver.send method, *args, &block
+        rescue Exception => e
+          logger.error "There was an exception - #{e.class}(#{e.message})"
+          logger.error e.backtrace.join("\n")
 
-            receiver.handle_exception if receiver.respond_to?(:handle_exception)
-          end
+          receiver.handle_exception if receiver.respond_to?(:handle_exception)
         end
       end
 

data/lib/action_cable/subscription_adapter.rb

@@ -5,6 +5,7 @@ module ActionCable
     extend ActiveSupport::Autoload
 
     autoload :Base
+    autoload :Test
     autoload :SubscriberMap
     autoload :ChannelPrefix
   end

data/lib/action_cable/subscription_adapter/postgresql.rb

@@ -8,13 +8,15 @@ require "digest/sha1"
 module ActionCable
   module SubscriptionAdapter
     class PostgreSQL < Base # :nodoc:
+      prepend ChannelPrefix
+
       def initialize(*)
         super
         @listener = nil
       end
 
       def broadcast(channel, payload)
-        with_connection do |pg_conn|
+        with_broadcast_connection do |pg_conn|
           pg_conn.exec("NOTIFY #{pg_conn.escape_identifier(channel_identifier(channel))}, '#{pg_conn.escape_string(payload)}'")
         end
       end
@@ -31,14 +33,24 @@ module ActionCable
         listener.shutdown
       end
 
-      def with_connection(&block) # :nodoc:
-        ActiveRecord::Base.connection_pool.with_connection do |ar_conn|
-          pg_conn = ar_conn.raw_connection
+      def with_subscriptions_connection(&block) # :nodoc:
+        ar_conn = ActiveRecord::Base.connection_pool.checkout.tap do |conn|
+          # Action Cable is taking ownership over this database connection, and
+          # will perform the necessary cleanup tasks
+          ActiveRecord::Base.connection_pool.remove(conn)
+        end
+        pg_conn = ar_conn.raw_connection
 
-          unless pg_conn.is_a?(PG::Connection)
-            raise "The Active Record database must be PostgreSQL in order to use the PostgreSQL Action Cable storage adapter"
-          end
+        verify!(pg_conn)
+        yield pg_conn
+      ensure
+        ar_conn.disconnect!
+      end
 
+      def with_broadcast_connection(&block) # :nodoc:
+        ActiveRecord::Base.connection_pool.with_connection do |ar_conn|
+          pg_conn = ar_conn.raw_connection
+          verify!(pg_conn)
           yield pg_conn
         end
       end
@@ -52,6 +64,12 @@ module ActionCable
           @listener || @server.mutex.synchronize { @listener ||= Listener.new(self, @server.event_loop) }
         end
 
+        def verify!(pg_conn)
+          unless pg_conn.is_a?(PG::Connection)
+            raise "The Active Record database must be PostgreSQL in order to use the PostgreSQL Action Cable storage adapter"
+          end
+        end
+
         class Listener < SubscriberMap
           def initialize(adapter, event_loop)
             super()
@@ -67,7 +85,7 @@ module ActionCable
           end
 
           def listen
-            @adapter.with_connection do |pg_conn|
+            @adapter.with_subscriptions_connection do |pg_conn|
               catch :shutdown do
                 loop do
                   until @queue.empty?