actioncable-next 0.1.0

data/lib/action_cable/connection/test_case.rb

@@ -0,0 +1,294 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+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
+
+    class TestCookies < ActiveSupport::HashWithIndifferentAccess # :nodoc:
+      def []=(name, options)
+        value = options.is_a?(Hash) ? options.symbolize_keys[:value] : options
+        super(name, value)
+      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 < TestCookies
+      def signed
+        @signed ||= TestCookies.new
+      end
+
+      def encrypted
+        @encrypted ||= TestCookies.new
+      end
+    end
+
+    class TestSocket
+      # Make session and cookies available to the connection
+      class Request < ActionDispatch::TestRequest
+        attr_accessor :session, :cookie_jar
+      end
+
+      attr_reader :logger, :request, :transmissions, :closed, :env
+
+      class << self
+        def build_request(path, params: nil, headers: {}, session: {}, env: {}, cookies: nil)
+          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
+
+          Request.create(request_env).tap do |request|
+            request.session = session.with_indifferent_access
+            request.cookie_jar = cookies
+          end
+        end
+      end
+
+      def initialize(request)
+        inner_logger = ActiveSupport::Logger.new(StringIO.new)
+        tagged_logging = ActiveSupport::TaggedLogging.new(inner_logger)
+        @logger = ActionCable::Server::TaggedLoggerProxy.new(tagged_logging, tags: [])
+        @request = request
+        @env = request.env
+        @connection = nil
+        @closed = false
+        @transmissions = []
+      end
+
+      def transmit(data)
+        @transmissions << data.with_indifferent_access
+      end
+
+      def close
+        @closed = true
+      end
+    end
+
+    # TestServer provides test pub/sub and executor implementations
+    class TestServer
+      attr_reader :streams, :config
+
+      def initialize(server)
+        @streams = Hash.new { |h, k| h[k] = [] }
+        @config = server.config
+      end
+
+      alias_method :pubsub, :itself
+      alias_method :executor, :itself
+
+      #== Executor interface ==
+
+      # Inline async calls
+      def post(&work) = work.call
+      # We don't support timers in unit tests yet
+      def timer(_every) = nil
+
+      #== Pub/sub interface ==
+      def subscribe(stream, callback, success_callback = nil)
+        @streams[stream] << callback
+        success_callback&.call
+      end
+
+      def unsubscribe(stream, callback)
+        @streams[stream].delete(callback)
+        @streams.delete(stream) if @streams[stream].empty?
+      end
+    end
+
+    # # Action Cable Connection TestCase
+    #
+    # 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
+
+          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
+
+        attr_reader :connection, :socket, :testserver
+
+        # 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, server: ActionCable.server, **request_params)
+          path ||= DEFAULT_PATH
+
+          @socket = TestSocket.new(TestSocket.build_request(path, **request_params, cookies: cookies))
+          @testserver = Connection::TestServer.new(server)
+          connection = self.class.connection_class.new(@testserver, socket)
+          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
+
+        def transmissions
+          socket&.transmissions || []
+        end
+      end
+
+      include Behavior
+    end
+  end
+end

data/lib/action_cable/deprecator.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionCable
+  def self.deprecator # :nodoc:
+    @deprecator ||= ActiveSupport::Deprecation.new
+  end
+end

data/lib/action_cable/engine.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "rails"
+require "action_cable"
+require "active_support/core_ext/hash/indifferent_access"
+
+module ActionCable
+  class Engine < Rails::Engine # :nodoc:
+    config.action_cable = ActiveSupport::OrderedOptions.new
+    config.action_cable.mount_path = ActionCable::INTERNAL[:default_mount_path]
+    config.action_cable.precompile_assets = true
+
+    initializer "action_cable.deprecator", before: :load_environment_config do |app|
+      app.deprecators[:action_cable] = ActionCable.deprecator
+    end
+
+    initializer "action_cable.helpers" do
+      ActiveSupport.on_load(:action_view) do
+        include ActionCable::Helpers::ActionCableHelper
+      end
+    end
+
+    initializer "action_cable.logger" do
+      ActiveSupport.on_load(:action_cable) { self.logger ||= ::Rails.logger }
+    end
+
+    initializer "action_cable.health_check_application" do
+      ActiveSupport.on_load(:action_cable) {
+        self.health_check_application = ->(env) { Rails::HealthController.action(:show).call(env) }
+      }
+    end
+
+    initializer "action_cable.asset" do
+      config.after_initialize do |app|
+        if app.config.respond_to?(:assets) && app.config.action_cable.precompile_assets
+          app.config.assets.precompile += %w( actioncable.js actioncable.esm.js )
+        end
+      end
+    end
+
+    initializer "action_cable.set_configs" do |app|
+      options = app.config.action_cable
+      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 = app.config_for(config_path).to_h.with_indifferent_access
+        end
+
+        previous_connection_class = connection_class
+        self.connection_class = -> { "ApplicationCable::Connection".safe_constantize || previous_connection_class.call }
+        self.filter_parameters += app.config.filter_parameters
+
+        options.each { |k, v| send("#{k}=", v) }
+      end
+    end
+
+    initializer "action_cable.routes" do
+      config.after_initialize do |app|
+        config = app.config
+        unless config.action_cable.mount_path.nil?
+          app.routes.prepend do
+            mount ActionCable.server => config.action_cable.mount_path, internal: true, anchor: true
+          end
+        end
+      end
+    end
+
+    initializer "action_cable.set_work_hooks" do |app|
+      ActiveSupport.on_load(:action_cable) do
+        ActionCable::Server::Worker.set_callback :work, :around, prepend: true do |_, inner|
+          app.executor.wrap(source: "application.action_cable") do
+            # If we took a while to get the lock, we may have been halted in the meantime.
+            # As we haven't started doing any real work yet, we should pretend that we never
+            # made it off the queue.
+            unless stopping?
+              inner.call
+            end
+          end
+        end
+
+        wrap = lambda do |_, inner|
+          app.executor.wrap(source: "application.action_cable", &inner)
+        end
+        ActionCable::Channel::Base.set_callback :subscribe, :around, prepend: true, &wrap
+        ActionCable::Channel::Base.set_callback :unsubscribe, :around, prepend: true, &wrap
+
+        app.reloader.before_class_unload do
+          ActionCable.server.restart
+        end
+      end
+    end
+  end
+end

data/lib/action_cable/gem_version.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionCable
+  # Returns the currently loaded version of Action Cable as a `Gem::Version`.
+  def self.gem_version
+    Gem::Version.new VERSION::STRING
+  end
+
+  module VERSION
+    MAJOR = 8
+    MINOR = 0
+    TINY  = 0
+    PRE   = "alpha"
+
+    STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
+  end
+end

data/lib/action_cable/helpers/action_cable_helper.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionCable
+  module Helpers
+    module ActionCableHelper
+      # Returns an "action-cable-url" meta tag with the value of the URL specified in
+      # your configuration. Ensure this is above your JavaScript tag:
+      #
+      #     <head>
+      #       <%= action_cable_meta_tag %>
+      #       <%= javascript_include_tag 'application', 'data-turbo-track' => 'reload' %>
+      #     </head>
+      #
+      # This is then used by Action Cable to determine the URL of your WebSocket
+      # server. Your JavaScript can then connect to the server without needing to
+      # specify the URL directly:
+      #
+      #     import Cable from "@rails/actioncable"
+      #     window.Cable = Cable
+      #     window.App = {}
+      #     App.cable = Cable.createConsumer()
+      #
+      # Make sure to specify the correct server location in each of your environment
+      # config files:
+      #
+      #     config.action_cable.mount_path = "/cable123"
+      #     <%= action_cable_meta_tag %> would render:
+      #     => <meta name="action-cable-url" content="/cable123" />
+      #
+      #     config.action_cable.url = "ws://actioncable.com"
+      #     <%= action_cable_meta_tag %> would render:
+      #     => <meta name="action-cable-url" content="ws://actioncable.com" />
+      #
+      def action_cable_meta_tag
+        tag "meta", name: "action-cable-url", content: (
+          ActionCable.server.config.url ||
+          ActionCable.server.config.mount_path ||
+          raise("No Action Cable URL configured -- please configure this at config.action_cable.url")
+        )
+      end
+    end
+  end
+end

data/lib/action_cable/remote_connections.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "active_support/core_ext/module/redefine_method"
+
+module ActionCable
+  # # Action Cable Remote Connections
+  #
+  # If you need to disconnect a given connection, you can go through the
+  # RemoteConnections. You can find the connections you're looking for by
+  # searching for the identifier declared on the connection. For example:
+  #
+  #     module ApplicationCable
+  #       class Connection < ActionCable::Connection::Base
+  #         identified_by :current_user
+  #         ....
+  #       end
+  #     end
+  #
+  #     ActionCable.server.remote_connections.where(current_user: User.find(1)).disconnect
+  #
+  # This will disconnect all the connections established for `User.find(1)`,
+  # across all servers running on all machines, because it uses the internal
+  # channel that all of these servers are subscribed to.
+  #
+  # By default, server sends a "disconnect" message with "reconnect" flag set to
+  # true. You can override it by specifying the `reconnect` option:
+  #
+  #     ActionCable.server.remote_connections.where(current_user: User.find(1)).disconnect(reconnect: false)
+  class RemoteConnections
+    attr_reader :server
+
+    def initialize(server)
+      @server = server
+    end
+
+    def where(identifier)
+      RemoteConnection.new(server, identifier)
+    end
+
+    # # Action Cable Remote Connection
+    #
+    # Represents a single remote connection found via
+    # `ActionCable.server.remote_connections.where(*)`. Exists solely for the
+    # purpose of calling #disconnect on that connection.
+    class RemoteConnection
+      class InvalidIdentifiersError < StandardError; end
+
+      include Connection::Identification, Connection::InternalChannel
+
+      def initialize(server, ids)
+        @server = server
+        set_identifier_instance_vars(ids)
+      end
+
+      # Uses the internal channel to disconnect the connection.
+      def disconnect(reconnect: true)
+        server.broadcast internal_channel, { type: "disconnect", reconnect: reconnect }
+      end
+
+      # Returns all the identifiers that were applied to this connection.
+      redefine_method :identifiers do
+        server.connection_identifiers
+      end
+
+      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) }
+        end
+
+        def valid_identifiers?(ids)
+          keys = ids.keys
+          identifiers.all? { |id| keys.include?(id) }
+        end
+    end
+  end
+end