anyt-core 1.3.0

data/lib/anyt/ext/minitest.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+ENV["TERM"] = "#{ENV["TERM"]}color" unless ENV["TERM"]&.match?(/color/)
+require "minitest/spec"
+require "minitest/unit"
+require "minitest/reporters"
+
+module Anyt
+  # Common tests helpers
+  module TestHelpers
+    def self.included(base)
+      base.let(:client) { build_client(ignore: %w[ping welcome]) }
+      base.after { @clients&.each { |client| client.close(allow_messages: true) } }
+    end
+
+    def build_client(**args)
+      @clients ||= []
+      Anyt::Client.new(**args).tap do |client|
+        @clients << client
+      end
+    end
+
+    def restart_server!
+      if Anyt.config.use_action_cable
+        remote_client.restart_action_cable
+      else
+        Command.restart
+      end
+    end
+
+    def remote_client
+      @remote_client ||= RemoteControl::Client.connect(Anyt.config.remote_control_port)
+    end
+
+    # Verifies that the actual message Hash is a subset of the expected one
+    # (so we can ignore some irrelevant fields)
+    def assert_message(expected, actual)
+      assert_equal expected, actual.slice(*expected.keys)
+    end
+
+    def assert_includes_message(collection, expected)
+      found = collection.find do |el|
+        el.slice(*expected.keys) == expected
+      end
+
+      assert found, "Expecte #{collection} to include a message matching #{expected}"
+    end
+  end
+end
+
+module Anyt
+  # Namespace for test channels
+  module TestChannels; end
+
+  # Custom #connect handlers management
+  module ConnectHandlers
+    class << self
+      def call(connection)
+        handlers_for(connection).each do |(_, handler)|
+          connection.reject_unauthorized_connection unless
+            connection.instance_eval(&handler)
+        end
+      end
+
+      def add(tag, &block)
+        handlers << [tag, block]
+      end
+
+      private
+
+      def handlers_for(connection)
+        handlers.select do |(tag, _)|
+          connection.params["test"] == tag
+        end
+      end
+
+      def handlers
+        @handlers ||= []
+      end
+    end
+  end
+end
+
+# Kernel extensions
+module Kernel
+  ## Wraps `describe` and include shared helpers
+  private def feature(*args, &block)
+    cls = describe(*args, &block)
+    cls.include Anyt::TestHelpers
+    cls
+  end
+end
+
+# Extend Minitest Spec DSL with custom methodss
+module Minitest::Spec::DSL
+  # Simplified version of `it` which doesn't care
+  # about unique method names
+  def scenario(desc, &block)
+    block ||= proc { skip "(no tests defined)" }
+
+    define_method "test_ #{desc}", &block
+
+    desc
+  end
+
+  # Generates Channel class dynamically and
+  # add memoized helper to access its name
+  def channel(id = nil, &block)
+    class_name = @name.gsub(/\s+/, "_")
+    class_name += "_#{id}" if id
+    class_name += "_channel"
+
+    cls = Class.new(ApplicationCable::Channel, &block)
+
+    Anyt::TestChannels.const_set(class_name.classify, cls)
+
+    helper_name = id ? "#{id}_channel" : "channel"
+
+    let(helper_name) { cls.name }
+  end
+
+  # Add new #connect handler
+  def connect_handler(tag, &block)
+    Anyt::ConnectHandlers.add(tag, &block)
+  end
+end
+
+module Anyt
+  # Patch Minitest load_plugins to disable Rails plugin
+  # See: https://github.com/kern/minitest-reporters/issues/230
+  module MinitestPatch
+    def load_plugins
+      super
+      extensions.delete("rails")
+    end
+  end
+
+  # Patch Spec reporter
+  module ReporterPatch # :nodoc:
+    def record_print_status(test)
+      test_name = test.name.gsub(/^test_/, "").strip
+      print(magenta { pad_test(test_name) })
+      print_colored_status(test)
+      print(" (%.2fs)" % test.time) unless test.time.nil?
+      puts
+    end
+  end
+end
+
+Minitest::Reporters::SpecReporter.prepend Anyt::ReporterPatch
+Minitest.singleton_class.prepend Anyt::MinitestPatch

data/lib/anyt/remote_control.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require "drb/drb"
+
+module Anyt
+  # Invoke commands within the running Ruby (Action Cable) server
+  module RemoteControl
+    class Server
+      class << self
+        alias_method :start, :new
+      end
+
+      def initialize(port)
+        DRb.start_service(
+          "druby://localhost:#{port}",
+          Client.new
+        )
+      end
+    end
+
+    class Client
+      def self.connect(port)
+        DRb.start_service
+
+        DRbObject.new_with_uri("druby://localhost:#{port}")
+      end
+
+      def restart_action_cable
+        ActionCable.server.restart
+      end
+    end
+  end
+end

data/lib/anyt/rpc.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "anyt/dummy/application"
+require "anycable-rails"
+require "redis"
+
+module Anyt # :nodoc:
+  # Runs AnyCable RPC server in the background
+  class RPC
+    using AsyncHelpers
+
+    attr_accessor :running
+    attr_reader :server
+
+    def start
+      AnyCable.logger.debug "Starting RPC server ..."
+
+      AnyCable.server_callbacks.each(&:call)
+
+      @server = AnyCable::GRPC::Server.new(
+        host: AnyCable.config.rpc_host,
+        **AnyCable.config.to_grpc_params
+      )
+
+      if defined?(::AnyCable::Middlewares::EnvSid)
+        AnyCable.middleware.use(::AnyCable::Middlewares::EnvSid)
+      end
+
+      AnyCable.middleware.freeze
+
+      server.start
+
+      AnyCable.logger.debug "RPC server started"
+    end
+    # rubocop: enable Metrics/AbcSize,Metrics/MethodLength
+
+    def stop
+      server&.stop
+    end
+
+    AnyCable.connection_factory = ActionCable.server.config.connection_class.call
+    AnyCable.config.log_level = :fatal unless AnyCable.config.debug
+  end
+end

data/lib/anyt/tests/core/ping_test.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+feature "Ping" do
+  scenario %(
+    Client receives pings with timestamps
+  ) do
+    client = build_client(ignore: ["welcome"])
+
+    previous_stamp = 0
+
+    2.times do
+      ping = client.receive
+
+      current_stamp = ping["message"]
+
+      assert_equal "ping", ping["type"]
+      assert_kind_of Integer, current_stamp
+      refute_operator previous_stamp, :>=, current_stamp
+
+      previous_stamp = current_stamp
+    end
+  end
+end

data/lib/anyt/tests/core/welcome_test.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+feature "Welcome" do
+  scenario %(
+    Client receives "welcome" message
+  ) do
+    client = build_client(ignore: ["ping"])
+    assert_message({"type" => "welcome"}, client.receive)
+  end
+end

data/lib/anyt/tests/features/channel_state_test.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+feature "Channel state" do
+  channel do
+    state_attr_accessor :user, :count
+
+    def subscribed
+      self.user = {name: params["name"]}
+      self.count = 1
+
+      stream_from "state_counts"
+    end
+
+    def tick
+      self.count += 2
+      transmit({count: count, name: user[:name]})
+    end
+
+    def unsubscribed
+      return unless params["notify_disconnect"]
+
+      ActionCable.server.broadcast("state_counts", {data: "user left: #{user[:name]}"})
+    end
+  end
+
+  let(:identifier) { {channel: channel, name: "chipolino"}.to_json }
+
+  let(:client2) { build_client(ignore: %w[ping welcome]) }
+  let(:identifier2) { {channel: channel, name: "chipollone", notify_disconnect: true}.to_json }
+
+  before do
+    subscribe_request = {command: "subscribe", identifier: identifier}
+
+    client.send(subscribe_request)
+
+    ack = {
+      "identifier" => identifier, "type" => "confirm_subscription"
+    }
+
+    assert_message ack, client.receive
+  end
+
+  scenario %(
+    Channel state is kept between commands
+  ) do
+    perform_request = {
+      :command => "message",
+      :identifier => identifier,
+      "data" => {"action" => "tick"}.to_json
+    }
+
+    client.send(perform_request)
+
+    msg = {"identifier" => identifier, "message" => {"count" => 3, "name" => "chipolino"}}
+
+    assert_message msg, client.receive
+  end
+
+  scenario %(
+    Channel state is available in #unsubscribe callbacks
+  ) do
+    subscribe_request = {command: "subscribe", identifier: identifier2}
+
+    client2.send(subscribe_request)
+
+    ack = {
+      "identifier" => identifier2, "type" => "confirm_subscription"
+    }
+
+    assert_message ack, client2.receive
+
+    client2.close
+
+    msg = {
+      "identifier" => identifier,
+      "message" => {"data" => "user left: chipollone"}
+    }
+
+    assert_message msg, client.receive
+  end
+end

data/lib/anyt/tests/features/remote_disconnect_test.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+feature "Remote disconnect" do
+  connect_handler("uid") do
+    self.uid = request.params["uid"]
+    uid.present?
+  end
+
+  scenario %(
+   Close single connection by id
+  ) do
+    client = build_client(qs: "test=uid&uid=26", ignore: %w[ping])
+    assert_message({"type" => "welcome"}, client.receive)
+
+    # Prevent race conditions when we send disconnect before internal channel subscription has been made
+    # (only for Action Cable)
+    sleep 1
+    ActionCable.server.remote_connections.where(uid: "26").disconnect
+
+    # Waiting for https://github.com/rails/rails/pull/39544
+    unless Anyt.config.use_action_cable
+      assert_message(
+        {
+          "type" => "disconnect",
+          "reconnect" => true,
+          "reason" => "remote"
+        },
+        client.receive
+      )
+    end
+
+    client.wait_for_close
+    assert client.closed?
+  end
+end

data/lib/anyt/tests/features/server_restart_test.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+feature "Server restart" do
+  connect_handler("reasons") do
+    next false if request.params[:reason] == "unauthorized"
+    true
+  end
+
+  scenario %(
+    Client receives disconnect message
+  ) do
+    client = build_client(
+      qs: "test=reasons&reason=server_restart",
+      ignore: %(ping)
+    )
+
+    assert_message({"type" => "welcome"}, client.receive)
+
+    restart_server!
+
+    assert_message(
+      {
+        "type" => "disconnect",
+        "reconnect" => true,
+        "reason" => "server_restart"
+      },
+      client.receive
+    )
+  end
+end

data/lib/anyt/tests/request/channel_test.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+feature "Request" do
+  channel do
+    delegate :params, to: :connection
+
+    def subscribed
+      reject unless params[:token] == "secret"
+    end
+  end
+
+  scenario %(
+    Channel has access to request
+  ) do
+    client = build_client(qs: "token=secret", ignore: %w[ping])
+    assert_message({"type" => "welcome"}, client.receive)
+
+    subscribe_request = {command: "subscribe", identifier: {channel: channel}.to_json}
+
+    client.send(subscribe_request)
+
+    ack = {
+      "identifier" => {channel: channel}.to_json, "type" => "confirm_subscription"
+    }
+
+    assert_message ack, client.receive
+  end
+end

data/lib/anyt/tests/request/connection_test.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+feature "Request" do
+  target_host = URI.parse(Anyt.config.target_url).host
+
+  connect_handler("request_url") do
+    request.url =~ /test=request_url/ && request.host == target_host
+  end
+
+  scenario %(
+    Url is set during connection
+  ) do
+    client = build_client(qs: "test=request_url")
+    assert_message({"type" => "welcome"}, client.receive)
+  end
+
+  connect_handler("cookies") do
+    cookies[:username] == "john green"
+  end
+
+  scenario %(
+    Reject when required cookies are not set
+  ) do
+    client = build_client(qs: "test=cookies")
+    client.wait_for_close
+    assert client.closed?
+  end
+
+  scenario %(
+    Accepts when required cookies are set
+  ) do
+    client = build_client(qs: "test=cookies", cookies: "username=john green")
+    assert_message({"type" => "welcome"}, client.receive)
+  end
+
+  connect_handler("headers") do
+    request.headers["X-API-TOKEN"] == "abc"
+  end
+
+  scenario %(
+    Reject when required header is missing
+  ) do
+    client = build_client(qs: "test=headers")
+    client.wait_for_close
+    assert client.closed?
+  end
+
+  scenario %(
+    Accepts when required header is set
+  ) do
+    client = build_client(qs: "test=headers", headers: {"x-api-token" => "abc"})
+    assert_message({"type" => "welcome"}, client.receive)
+  end
+end

data/lib/anyt/tests/request/disconnect_reasons_test.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+feature "Request" do
+  connect_handler("reasons") do
+    next false if request.params[:reason] == "unauthorized"
+    true
+  end
+
+  scenario %(
+    Receives disconnect message when rejected
+  ) do
+    client = build_client(qs: "test=reasons&reason=unauthorized")
+    assert_message(
+      {
+        "type" => "disconnect",
+        "reconnect" => false,
+        "reason" => "unauthorized"
+      },
+      client.receive
+    )
+
+    client.wait_for_close
+    assert client.closed?
+  end
+end

data/lib/anyt/tests/request/disconnection_test.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+feature "Request" do
+  channel(:a) do
+    def subscribed
+      stream_from "request_a"
+    end
+
+    def unsubscribed
+      ActionCable.server.broadcast("request_a", {data: "user left"})
+    end
+  end
+
+  channel(:b) do
+    def subscribed
+      stream_from "request_b"
+    end
+
+    def unsubscribed
+      ActionCable.server.broadcast("request_b", {data: "user left"})
+    end
+  end
+
+  channel(:c) do
+    def subscribed
+      stream_from "request_c"
+    end
+
+    def unsubscribed
+      ActionCable.server.broadcast("request_c", {data: "user left#{params[:id].presence}"})
+    end
+  end
+
+  let(:client2) { build_client(ignore: %w[ping welcome]) }
+
+  scenario %(
+    Client disconnect invokes #unsubscribe callbacks
+    for different channels
+  ) do
+    subscribe_request = {command: "subscribe", identifier: {channel: a_channel}.to_json}
+
+    client.send(subscribe_request)
+
+    ack = {
+      "identifier" => {channel: a_channel}.to_json, "type" => "confirm_subscription"
+    }
+
+    assert_message ack, client.receive
+
+    subscribe_request = {command: "subscribe", identifier: {channel: b_channel}.to_json}
+
+    client.send(subscribe_request)
+
+    ack = {
+      "identifier" => {channel: b_channel}.to_json, "type" => "confirm_subscription"
+    }
+
+    assert_message ack, client.receive
+
+    subscribe_request = {command: "subscribe", identifier: {channel: a_channel}.to_json}
+
+    client2.send(subscribe_request)
+
+    ack = {
+      "identifier" => {channel: a_channel}.to_json, "type" => "confirm_subscription"
+    }
+
+    assert_message ack, client2.receive
+
+    subscribe_request = {command: "subscribe", identifier: {channel: b_channel}.to_json}
+
+    client2.send(subscribe_request)
+
+    ack = {
+      "identifier" => {channel: b_channel}.to_json, "type" => "confirm_subscription"
+    }
+
+    assert_message ack, client2.receive
+
+    client2.close
+
+    msg = {
+      "identifier" => {channel: a_channel}.to_json,
+      "message" => {"data" => "user left"}
+    }
+    msg2 = {
+      "identifier" => {channel: b_channel}.to_json,
+      "message" => {"data" => "user left"}
+    }
+
+    msgs = [client.receive, client.receive]
+
+    assert_includes_message msgs, msg
+    assert_includes_message msgs, msg2
+  end
+
+  scenario %(
+    Client disconnect invokes #unsubscribe callbacks
+    for multiple subscriptions from the same channel
+  ) do
+    subscribe_request = {command: "subscribe", identifier: {channel: c_channel}.to_json}
+
+    client.send(subscribe_request)
+
+    ack = {
+      "identifier" => {channel: c_channel}.to_json, "type" => "confirm_subscription"
+    }
+
+    assert_message ack, client.receive
+
+    subscribe_request = {command: "subscribe", identifier: {channel: c_channel, id: 1}.to_json}
+
+    client2.send(subscribe_request)
+
+    ack = {
+      "identifier" => {channel: c_channel, id: 1}.to_json, "type" => "confirm_subscription"
+    }
+
+    assert_message ack, client2.receive
+
+    subscribe_request = {command: "subscribe", identifier: {channel: c_channel, id: 2}.to_json}
+
+    client2.send(subscribe_request)
+
+    ack = {
+      "identifier" => {channel: c_channel, id: 2}.to_json, "type" => "confirm_subscription"
+    }
+
+    assert_message ack, client2.receive
+
+    client2.close
+
+    msg = {
+      "identifier" => {channel: c_channel}.to_json,
+      "message" => {"data" => "user left1"}
+    }
+
+    msg2 = {
+      "identifier" => {channel: c_channel}.to_json,
+      "message" => {"data" => "user left2"}
+    }
+
+    msgs = [client.receive, client.receive]
+
+    assert_includes_message msgs, msg
+    assert_includes_message msgs, msg2
+  end
+end