anyt 0.8.5 → 1.1.0

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

@@ -11,36 +11,33 @@ module Anyt # :nodoc:
 
     class << self
       attr_accessor :running
+      attr_reader :server
 
       # rubocop: disable Metrics/AbcSize,Metrics/MethodLength
       def start
-        ActionCable.server.config.cable = { "adapter" => "any_cable" }
-        Rails.application.initialize!
-
         AnyCable.logger.debug "Starting RPC server ..."
 
         AnyCable.server_callbacks.each(&:call)
 
-        @server = AnyCable::Server.new(
+        @server = AnyCable::GRPC::Server.new(
           host: AnyCable.config.rpc_host,
-          **AnyCable.config.to_grpc_params,
-          interceptors: AnyCable.middleware.to_a
+          **AnyCable.config.to_grpc_params
         )
 
         AnyCable.middleware.freeze
 
-        @server.start
+        server.start
 
         AnyCable.logger.debug "RPC server started"
       end
       # rubocop: enable Metrics/AbcSize,Metrics/MethodLength
 
       def stop
-        @server.stop
+        server&.stop
       end
     end
 
     AnyCable.connection_factory = ActionCable.server.config.connection_class.call
-    AnyCable.logger = Logger.new(IO::NULL) unless AnyCable.config.debug
+    AnyCable.config.log_level = :fatal unless AnyCable.config.debug
   end
 end

data/lib/anyt/tests.rb

@@ -24,8 +24,6 @@ module Anyt
       #
       # NOTE: We should run this before launching RPC server
 
-      # rubocop:disable Metrics/AbcSize
-      # rubocop:disable Metrics/MethodLength
       def load_tests
         return load_all_tests unless Anyt.config.filter_tests?
 
@@ -33,22 +31,22 @@ module Anyt
         filter = Anyt.config.tests_filter
 
         test_files_patterns.each do |pattern|
-          Dir.glob(pattern).each do |file|
-            if file.match?(filter)
+          Dir.glob(pattern).sort.each do |file|
+            if filter.call(file)
               require file
             else
-              skipped << file.gsub(File.join(__dir__, 'tests/'), '').gsub('_test.rb', '')
+              skipped << file.gsub(File.join(__dir__, "tests/"), "").gsub("_test.rb", "")
             end
           end
         end
 
-        $stdout.print "Skipping tests: #{skipped.join(', ')}\n"
+        $stdout.print "Skipping tests: #{skipped.join(", ")}\n"
       end
 
       # Load all test files
       def load_all_tests
         test_files_patterns.each do |pattern|
-          Dir.glob(pattern).each { |file| require file }
+          Dir.glob(pattern).sort.each { |file| require file }
         end
       end
 

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

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
 feature "Ping" do
-  scenario %{
+  scenario %(
     Client receives pings with timestamps
-  } do
+  ) do
     client = build_client(ignore: ["welcome"])
 
     previous_stamp = 0

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

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
 feature "Welcome" do
-  scenario %{
+  scenario %(
     Client receives "welcome" message
-  } do
+  ) do
     client = build_client(ignore: ["ping"])
     assert_equal client.receive, "type" => "welcome"
   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_equal 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_equal 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_equal ack, client2.receive
+
+    client2.close
+
+    msg = {
+      "identifier" => identifier,
+      "message" => {"data" => "user left: chipollone"}
+    }
+
+    assert_equal msg, client.receive
+  end
+end

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

@@ -0,0 +1,30 @@
+# 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_equal client.receive, "type" => "welcome"
+
+    ActionCable.server.remote_connections.where(uid: "26").disconnect
+
+    # Waiting for https://github.com/rails/rails/pull/39544
+    unless Anyt.config.use_action_cable
+      assert_equal(
+        client.receive,
+        "type" => "disconnect",
+        "reconnect" => true,
+        "reason" => "remote"
+      )
+    end
+
+    client.wait_for_close
+    assert client.closed?
+  end
+end

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

@@ -0,0 +1,28 @@
+# 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_equal client.receive, "type" => "welcome"
+
+    restart_server!
+
+    assert_equal(
+      client.receive,
+      "type" => "disconnect",
+      "reconnect" => true,
+      "reason" => "server_restart"
+    )
+  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_equal client.receive, "type" => "welcome"
+
+    subscribe_request = {command: "subscribe", identifier: {channel: channel}.to_json}
+
+    client.send(subscribe_request)
+
+    ack = {
+      "identifier" => {channel: channel}.to_json, "type" => "confirm_subscription"
+    }
+
+    assert_equal ack, client.receive
+  end
+end

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

@@ -1,52 +1,54 @@
 # frozen_string_literal: true
 
 feature "Request" do
-  connect_handler('request_url') do
-    request.url =~ /test=request_url/
+  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 %{
+  scenario %(
     Url is set during connection
-  } do
-    client = build_client(qs: 'test=request_url')
+  ) do
+    client = build_client(qs: "test=request_url")
     assert_equal client.receive, "type" => "welcome"
   end
 
-  connect_handler('cookies') do
-    cookies[:username] == 'john green'
+  connect_handler("cookies") do
+    cookies[:username] == "john green"
   end
 
-  scenario %{
+  scenario %(
     Reject when required cookies are not set
-  } do
-    client = build_client(qs: 'test=cookies')
+  ) do
+    client = build_client(qs: "test=cookies")
     client.wait_for_close
     assert client.closed?
   end
 
-  scenario %{
+  scenario %(
     Accepts when required cookies are set
-  } do
-    client = build_client(qs: 'test=cookies', cookies: 'username=john green')
+  ) do
+    client = build_client(qs: "test=cookies", cookies: "username=john green")
     assert_equal client.receive, "type" => "welcome"
   end
 
-  connect_handler('headers') do
-    request.headers['X-API-TOKEN'] == 'abc'
+  connect_handler("headers") do
+    request.headers["X-API-TOKEN"] == "abc"
   end
 
-  scenario %{
+  scenario %(
     Reject when required header is missing
-  } do
-    client = build_client(qs: 'test=headers')
+  ) do
+    client = build_client(qs: "test=headers")
     client.wait_for_close
     assert client.closed?
   end
 
-  scenario %{
+  scenario %(
     Accepts when required header is set
-  } do
-    client = build_client(qs: 'test=headers', headers: { 'x-api-token' => 'abc' })
+  ) do
+    client = build_client(qs: "test=headers", headers: {"x-api-token" => "abc"})
     assert_equal client.receive, "type" => "welcome"
   end
 end

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

@@ -0,0 +1,23 @@
+# 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_equal(
+      client.receive,
+      "type" => "disconnect",
+      "reconnect" => false,
+      "reason" => "unauthorized"
+    )
+
+    client.wait_for_close
+    assert client.closed?
+  end
+end

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

@@ -3,68 +3,76 @@
 feature "Request" do
   channel(:a) do
     def subscribed
-      stream_from "a"
+      stream_from "request_a"
     end
 
     def unsubscribed
-      ActionCable.server.broadcast("a", data: "user left#{params[:id].presence}")
+      ActionCable.server.broadcast("request_a", {data: "user left"})
     end
   end
 
   channel(:b) do
     def subscribed
-      stream_from "b"
+      stream_from "request_b"
     end
 
     def unsubscribed
-      ActionCable.server.broadcast("b", data: "user left")
+      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]) }
 
-  before do
-    subscribe_request = { command: "subscribe", identifier: { channel: a_channel }.to_json }
+  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"
+      "identifier" => {channel: a_channel}.to_json, "type" => "confirm_subscription"
     }
 
     assert_equal ack, client.receive
 
-    subscribe_request = { command: "subscribe", identifier: { channel: b_channel }.to_json }
+    subscribe_request = {command: "subscribe", identifier: {channel: b_channel}.to_json}
 
     client.send(subscribe_request)
 
     ack = {
-      "identifier" => { channel: b_channel }.to_json, "type" => "confirm_subscription"
+      "identifier" => {channel: b_channel}.to_json, "type" => "confirm_subscription"
     }
 
     assert_equal ack, client.receive
-  end
 
-  scenario %{
-    Client disconnect invokes #unsubscribe callbacks
-    for different channels
-  } do
-    subscribe_request = { command: "subscribe", identifier: { channel: a_channel }.to_json }
+    subscribe_request = {command: "subscribe", identifier: {channel: a_channel}.to_json}
 
     client2.send(subscribe_request)
 
     ack = {
-      "identifier" => { channel: a_channel }.to_json, "type" => "confirm_subscription"
+      "identifier" => {channel: a_channel}.to_json, "type" => "confirm_subscription"
     }
 
     assert_equal ack, client2.receive
 
-    subscribe_request = { command: "subscribe", identifier: { channel: b_channel }.to_json }
+    subscribe_request = {command: "subscribe", identifier: {channel: b_channel}.to_json}
 
     client2.send(subscribe_request)
 
     ack = {
-      "identifier" => { channel: b_channel }.to_json, "type" => "confirm_subscription"
+      "identifier" => {channel: b_channel}.to_json, "type" => "confirm_subscription"
     }
 
     assert_equal ack, client2.receive
@@ -72,12 +80,12 @@ feature "Request" do
     client2.close
 
     msg = {
-      "identifier" => { channel: a_channel }.to_json,
-      "message" => { "data" => "user left" }
+      "identifier" => {channel: a_channel}.to_json,
+      "message" => {"data" => "user left"}
     }
     msg2 = {
-      "identifier" => { channel: b_channel }.to_json,
-      "message" => { "data" => "user left" }
+      "identifier" => {channel: b_channel}.to_json,
+      "message" => {"data" => "user left"}
     }
 
     msgs = [client.receive, client.receive]
@@ -86,26 +94,36 @@ feature "Request" do
     assert_includes msgs, msg2
   end
 
-  scenario %{
+  scenario %(
     Client disconnect invokes #unsubscribe callbacks
     for multiple subscriptions from the same channel
-  } do
-    subscribe_request = { command: "subscribe", identifier: { channel: a_channel, id: 1 }.to_json }
+  ) 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_equal ack, client.receive
+
+    subscribe_request = {command: "subscribe", identifier: {channel: c_channel, id: 1}.to_json}
 
     client2.send(subscribe_request)
 
     ack = {
-      "identifier" => { channel: a_channel, id: 1 }.to_json, "type" => "confirm_subscription"
+      "identifier" => {channel: c_channel, id: 1}.to_json, "type" => "confirm_subscription"
     }
 
     assert_equal ack, client2.receive
 
-    subscribe_request = { command: "subscribe", identifier: { channel: a_channel, id: 2 }.to_json }
+    subscribe_request = {command: "subscribe", identifier: {channel: c_channel, id: 2}.to_json}
 
     client2.send(subscribe_request)
 
     ack = {
-      "identifier" => { channel: a_channel, id: 2 }.to_json, "type" => "confirm_subscription"
+      "identifier" => {channel: c_channel, id: 2}.to_json, "type" => "confirm_subscription"
     }
 
     assert_equal ack, client2.receive
@@ -113,13 +131,13 @@ feature "Request" do
     client2.close
 
     msg = {
-      "identifier" => { channel: a_channel }.to_json,
-      "message" => { "data" => "user left1" }
+      "identifier" => {channel: c_channel}.to_json,
+      "message" => {"data" => "user left1"}
     }
 
     msg2 = {
-      "identifier" => { channel: a_channel }.to_json,
-      "message" => { "data" => "user left2" }
+      "identifier" => {channel: c_channel}.to_json,
+      "message" => {"data" => "user left2"}
     }
 
     msgs = [client.receive, client.receive]