anyt 1.2.4 → 1.3.0

data/lib/anyt/dummy/application.rb

@@ -1,87 +0,0 @@
-# frozen_string_literal: true
-
-require "rails"
-require "action_controller/railtie"
-require "action_cable/engine"
-
-require "redis"
-require "anycable-rails"
-
-require "action_dispatch/middleware/cookies"
-
-class TestApp < Rails::Application
-  secrets.secret_token = "secret_token"
-  secrets.secret_key_base = "secret_key_base"
-
-  config.logger = Logger.new($stdout)
-  config.log_level = AnyCable.config.log_level
-  config.eager_load = true
-
-  config.paths["config/routes.rb"] << File.join(__dir__, "routes.rb")
-end
-
-DISCONNECT_DELAY = ENV["ANYCABLE_DISCONNECT_DELAY"].to_f
-
-module ApplicationCable
-  class Connection < ActionCable::Connection::Base
-    delegate :params, to: :request
-
-    identified_by :uid
-
-    def connect
-      logger.debug "Connected"
-      Anyt::ConnectHandlers.call(self)
-    end
-
-    def disconnect
-      if DISCONNECT_DELAY > 0
-        sleep DISCONNECT_DELAY
-      end
-      logger.debug "Disconnected"
-    end
-  end
-end
-
-module ApplicationCable
-  class Channel < ActionCable::Channel::Base
-  end
-end
-
-ECHO_DELAY = ENV["ANYCABLE_BENCHMARK_ECHO_DELAY"].to_f
-
-# BenchmarkChannel is useful when running Rails app only or RPC only
-class BenchmarkChannel < ApplicationCable::Channel
-  def subscribed
-    stream_from "all#{stream_id}"
-  end
-
-  def echo(data)
-    if ECHO_DELAY > 0
-      sleep ECHO_DELAY
-    end
-    transmit data
-  end
-
-  def broadcast(data)
-    ActionCable.server.broadcast "all#{stream_id}", data
-    data["action"] = "broadcastResult"
-    transmit data
-  end
-
-  def counter(data)
-    num = data.fetch("num", 100).to_i
-    num.times { ActionCable.server.broadcast "all", {text: "Count: #{_1}"} }
-  end
-
-  private
-
-  def stream_id
-    params[:id] || ""
-  end
-end
-
-ActionCable.server.config.cable = {"adapter" => ENV.fetch("ACTION_CABLE_ADAPTER", "redis")}
-ActionCable.server.config.connection_class = -> { ApplicationCable::Connection }
-ActionCable.server.config.disable_request_forgery_protection = true
-ActionCable.server.config.logger =
-  Rails.logger

data/lib/anyt/dummy/config.ru

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "application"
-
-require_relative "../tests"
-require_relative "../remote_control"
-
-# Start remote control
-Anyt::RemoteControl::Server.start(Anyt.config.remote_control_port)
-
-# Load channels from tests
-Anyt::Tests.load_all_tests
-
-Rails.application.initialize!
-
-run Rails.application

data/lib/anyt/dummy/routes.rb

@@ -1,4 +0,0 @@
-# frozen_string_literal: true
-
-Rails.application.routes.draw do
-end

data/lib/anyt/dummy/tmp/development_secret.txt

@@ -1 +0,0 @@
-fe2ecbcf229d5547a64bcdaa9ef4e543404ca3fc9d4ee83aaa7ddab34b6a378fe090c2b1836c9ebd3e5ebbf01c239ddac95e219358baaefc1afaa04cd07bf78c

data/lib/anyt/ext/minitest.rb

@@ -1,151 +0,0 @@
-# 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

@@ -1,33 +0,0 @@
-# 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

@@ -1,44 +0,0 @@
-# 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

@@ -1,23 +0,0 @@
-# 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

@@ -1,10 +0,0 @@
-# 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

@@ -1,81 +0,0 @@
-# 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

@@ -1,35 +0,0 @@
-# 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

@@ -1,30 +0,0 @@
-# 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

@@ -1,28 +0,0 @@
-# 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

@@ -1,54 +0,0 @@
-# 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

@@ -1,25 +0,0 @@
-# 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