anyt-core 1.3.0

data/lib/anyt/tests/streams/broadcast_test.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+feature "Broadcast data to stream" do
+  channel do
+    def subscribed
+      stream_from "a"
+    end
+  end
+
+  before do
+    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
+
+  scenario %(
+    Broadcast object
+  ) do
+    ActionCable.server.broadcast(
+      "a",
+      {data: {user_id: 1, status: "left", meta: {connection_time: "10s"}}}
+    )
+
+    msg = {
+      "identifier" => {channel: channel}.to_json,
+      "message" => {
+        "data" => {"user_id" => 1, "status" => "left", "meta" => {"connection_time" => "10s"}}
+      }
+    }
+
+    assert_message msg, client.receive
+  end
+
+  scenario %(
+    Broadcast custom string
+  ) do
+    ActionCable.server.broadcast("a", "<script>alert('Message!');</script>")
+
+    msg = {
+      "identifier" => {channel: channel}.to_json,
+      "message" => "<script>alert('Message!');</script>"
+    }
+
+    assert_message msg, client.receive
+  end
+
+  scenario %(
+    Broadcast JSON string
+  ) do
+    ActionCable.server.broadcast("a", '{"script":{"alert":"Message!"}}')
+
+    msg = {
+      "identifier" => {channel: channel}.to_json,
+      "message" => '{"script":{"alert":"Message!"}}'
+    }
+
+    assert_message msg, client.receive
+  end
+end

data/lib/anyt/tests/streams/multiple_clients_test.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+feature "Streams with many clients" do
+  channel do
+    def subscribed
+      stream_from "a"
+    end
+  end
+
+  let(:client2) { build_client(ignore: %w[ping welcome]) }
+
+  before do
+    subscribe_request = {command: "subscribe", identifier: {channel: channel}.to_json}
+
+    client.send(subscribe_request)
+    client2.send(subscribe_request)
+
+    ack = {
+      "identifier" => {channel: channel}.to_json, "type" => "confirm_subscription"
+    }
+
+    assert_message ack, client.receive
+    assert_message ack, client2.receive
+  end
+
+  scenario %(
+    Multiple clients receive messages from stream
+  ) do
+    ActionCable.server.broadcast("a", {data: "X"})
+
+    msg = {"identifier" => {channel: channel}.to_json, "message" => {"data" => "X"}}
+
+    assert_message msg, client.receive
+    assert_message msg, client2.receive
+  end
+
+  scenario %(
+    Client receive messages when another client removes subscription
+  ) do
+    ActionCable.server.broadcast("a", {data: "X"})
+
+    msg = {"identifier" => {channel: channel}.to_json, "message" => {"data" => "X"}}
+
+    assert_message msg, client.receive
+    assert_message msg, client2.receive
+
+    unsubscribe_request = {command: "unsubscribe", identifier: {channel: channel}.to_json}
+
+    client.send(unsubscribe_request)
+
+    # ActionCable doesn't provide an unsubscription ack :(
+    sleep 1
+
+    ActionCable.server.broadcast("a", {data: "Y"})
+
+    msg2 = {"identifier" => {channel: channel}.to_json, "message" => {"data" => "Y"}}
+
+    assert_message msg2, client2.receive
+    assert_raises(Anyt::Client::TimeoutError) { client.receive(timeout: 0.5) }
+  end
+end

data/lib/anyt/tests/streams/multiple_test.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+feature "Multiple streams" do
+  channel do
+    def subscribed
+      stream_from "a"
+      stream_from "b"
+    end
+  end
+
+  before do
+    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
+
+  scenario %(
+    Client receives messages from both streams
+  ) do
+    ActionCable.server.broadcast("a", {data: "X"})
+
+    msg = {"identifier" => {channel: channel}.to_json, "message" => {"data" => "X"}}
+
+    assert_message msg, client.receive
+
+    ActionCable.server.broadcast("b", {data: "Y"})
+
+    msg = {"identifier" => {channel: channel}.to_json, "message" => {"data" => "Y"}}
+
+    assert_message msg, client.receive
+  end
+
+  scenario %(
+    Client does not receive messages from any stream after removing subscription
+  ) do
+    ActionCable.server.broadcast("a", {data: "X"})
+
+    msg = {"identifier" => {channel: channel}.to_json, "message" => {"data" => "X"}}
+
+    assert_message msg, client.receive
+
+    unsubscribe_request = {command: "unsubscribe", identifier: {channel: channel}.to_json}
+
+    client.send(unsubscribe_request)
+
+    # ActionCable doesn't provide an unsubscription ack :(
+    sleep 1
+
+    ActionCable.server.broadcast("a", {data: "Y"})
+    ActionCable.server.broadcast("b", {data: "Z"})
+
+    assert_raises(Anyt::Client::TimeoutError) { client.receive(timeout: 0.5) }
+  end
+end

data/lib/anyt/tests/streams/single_test.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+feature "Single stream" do
+  channel do
+    def subscribed
+      stream_from "a"
+    end
+  end
+
+  before do
+    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
+
+  scenario %(
+    Client receives messages from the stream
+  ) do
+    ActionCable.server.broadcast("a", {data: "X"})
+
+    msg = {"identifier" => {channel: channel}.to_json, "message" => {"data" => "X"}}
+
+    assert_message msg, client.receive
+
+    ActionCable.server.broadcast("a", {data: "Y"})
+
+    msg = {"identifier" => {channel: channel}.to_json, "message" => {"data" => "Y"}}
+
+    assert_message msg, client.receive
+  end
+
+  scenario %(
+    Client does not receive messages from the stream after removing subscription
+  ) do
+    ActionCable.server.broadcast("a", {data: "X"})
+
+    msg = {"identifier" => {channel: channel}.to_json, "message" => {"data" => "X"}}
+
+    assert_message msg, client.receive
+
+    unsubscribe_request = {command: "unsubscribe", identifier: {channel: channel}.to_json}
+
+    client.send(unsubscribe_request)
+
+    # ActionCable doesn't provide an unsubscription ack :(
+    sleep 1
+
+    ActionCable.server.broadcast("a", {data: "Y"})
+
+    assert_raises(Anyt::Client::TimeoutError) { client.receive(timeout: 0.5) }
+  end
+
+  scenario %(
+    Client receives multiple messages when subscribed to the same channel
+    with different params
+  ) do
+    subscribe_request = {command: "subscribe", identifier: {channel: channel, some_param: "test"}.to_json}
+
+    client.send(subscribe_request)
+
+    ack = {
+      "identifier" => {channel: channel, some_param: "test"}.to_json, "type" => "confirm_subscription"
+    }
+
+    assert_message ack, client.receive
+
+    ActionCable.server.broadcast("a", {data: "XX"})
+
+    msg = {"identifier" => {channel: channel}.to_json, "message" => {"data" => "XX"}}
+    msg2 = {"identifier" => {channel: channel, some_param: "test"}.to_json, "message" => {"data" => "XX"}}
+
+    received = client.receive, client.receive
+
+    assert_includes_message received, msg
+    assert_includes_message received, msg2
+  end
+end

data/lib/anyt/tests/streams/stop_test.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+feature "Stop streams" do
+  channel do
+    def subscribed
+      stream_from "a"
+      stream_from "b"
+    end
+
+    def ping(data)
+      ActionCable.server.broadcast data["name"], {reply: "pong"}
+    end
+
+    def unfollow(data)
+      stop_stream_from data["name"]
+    end
+  end
+
+  before do
+    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
+
+  scenario %(
+    Client unsubscribes from the stream
+  ) do
+    skip if Anyt.config.use_action_cable && (::ActionCable::VERSION::MAJOR < 6 || ::ActionCable::VERSION::MINOR < 1)
+
+    ActionCable.server.broadcast("a", {data: "X"})
+
+    msg = {"identifier" => {channel: channel}.to_json, "message" => {"data" => "X"}}
+
+    assert_message msg, client.receive
+
+    perform_request = {
+      :command => "message",
+      :identifier => {channel: channel}.to_json,
+      "data" => {"action" => "unfollow", "name" => "a"}.to_json
+    }
+    client.send(perform_request)
+    sleep 0.2 # give some time to commit unsubscribe
+
+    ActionCable.server.broadcast("a", {data: "Y"})
+    sleep 0.2 # "a" should be broadcasted first
+    ActionCable.server.broadcast("b", {data: "Z"})
+
+    msg = {"identifier" => {channel: channel}.to_json, "message" => {"data" => "Z"}}
+    assert_message msg, client.receive
+  end
+end

data/lib/anyt/tests/subscriptions/ack_test.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+feature "Subscription aknowledgement" do
+  channel
+
+  channel("rejector") do
+    def subscribed
+      reject
+    end
+  end
+
+  scenario %(
+    Client receives subscription confirmation
+  ) do
+    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
+
+  scenario %(
+    Client receives subscription rejection
+  ) do
+    subscribe_request = {command: "subscribe", identifier: {channel: rejector_channel}.to_json}
+
+    client.send(subscribe_request)
+
+    ack = {
+      "identifier" => {channel: rejector_channel}.to_json, "type" => "reject_subscription"
+    }
+
+    assert_message ack, client.receive
+  end
+end

data/lib/anyt/tests/subscriptions/params_test.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+feature "Subscription with params" do
+  channel
+
+  scenario %(
+    Client subscribes to the same channel with different params
+  ) do
+    subscribe_request = {command: "subscribe", identifier: {channel: channel, id: 1}.to_json}
+
+    client.send(subscribe_request)
+
+    ack = {
+      "identifier" => {channel: channel, id: 1}.to_json, "type" => "confirm_subscription"
+    }
+
+    assert_message ack, client.receive
+
+    subscribe_request_2 = {command: "subscribe", identifier: {channel: channel, id: 2}.to_json}
+
+    client.send(subscribe_request_2)
+
+    ack = {
+      "identifier" => {channel: channel, id: 2}.to_json, "type" => "confirm_subscription"
+    }
+
+    assert_message ack, client.receive
+  end
+end

data/lib/anyt/tests/subscriptions/perform_test.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require "anyt/utils"
+using Anyt::AsyncHelpers
+
+feature "Subscription perform methods" do
+  channel do
+    def tick
+      transmit("tock")
+    end
+
+    def echo(data)
+      transmit({response: data["text"]})
+    end
+  end
+
+  before do
+    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
+
+  scenario %(
+    Client perform actions without arguments
+  ) do
+    perform_request = {
+      :command => "message",
+      :identifier => {channel: channel}.to_json,
+      "data" => {"action" => "tick"}.to_json
+    }
+
+    client.send(perform_request)
+
+    msg = {"identifier" => {channel: channel}.to_json, "message" => "tock"}
+
+    assert_message msg, client.receive
+  end
+
+  scenario %(
+    Client perform actions with arguments
+  ) do
+    perform_request = {
+      :command => "message",
+      :identifier => {channel: channel}.to_json,
+      "data" => {"action" => "echo", "text" => "hello"}.to_json
+    }
+
+    client.send(perform_request)
+
+    msg = {"identifier" => {channel: channel}.to_json, "message" => {"response" => "hello"}}
+
+    assert_message msg, client.receive
+  end
+end

data/lib/anyt/tests/subscriptions/transmissions_test.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+feature "Subscription transmissions" do
+  channel do
+    def subscribed
+      transmit("hello")
+      transmit("world")
+    end
+  end
+
+  scenario %(
+    Client receives transmissions from #subscribed callback
+  ) do
+    subscribe_request = {command: "subscribe", identifier: {channel: channel}.to_json}
+
+    client.send(subscribe_request)
+
+    msg = {"identifier" => {channel: channel}.to_json, "message" => "hello"}
+
+    assert_message msg, client.receive
+
+    msg = {"identifier" => {channel: channel}.to_json, "message" => "world"}
+
+    assert_message msg, client.receive
+
+    ack = {
+      "identifier" => {channel: channel}.to_json, "type" => "confirm_subscription"
+    }
+
+    assert_message ack, client.receive
+  end
+end

data/lib/anyt/tests.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "anyt"
+require "anyt/client"
+require_relative "ext/minitest"
+
+module Anyt
+  # Loads and runs test cases
+  module Tests
+    class << self
+      DEFAULT_PATTERNS = [
+        File.expand_path("tests/**/*.rb", __dir__)
+      ].freeze
+
+      # Run all loaded tests
+      def run
+        Minitest::Reporters.use! Minitest::Reporters::SpecReporter.new
+
+        AnyCable.logger.debug "Run tests against: #{Anyt.config.target_url}"
+        Minitest.run
+      end
+
+      # Load tests code (filtered if present)
+      #
+      # NOTE: We should run this before launching RPC server
+
+      def load_tests
+        return load_all_tests unless Anyt.config.filter_tests?
+
+        skipped = []
+        filter = Anyt.config.tests_filter
+
+        test_files_patterns.each do |pattern|
+          Dir.glob(pattern).sort.each do |file|
+            if filter.call(file)
+              require file
+            else
+              skipped << file.gsub(File.join(__dir__, "tests/"), "").gsub("_test.rb", "")
+            end
+          end
+        end
+
+        $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).sort.each { |file| require file }
+        end
+      end
+
+      private
+
+      def test_files_patterns
+        @test_files_patterns ||= DEFAULT_PATTERNS.dup.tap do |patterns|
+          patterns << Anyt.config.tests_path if Anyt.config.tests_path
+        end
+      end
+    end
+  end
+end

data/lib/anyt/utils/async_helpers.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Anyt
+  module AsyncHelpers # :nodoc:
+    refine Object do
+      # Wait for block to return true of raise error
+      def wait(timeout = 1)
+        until yield
+          sleep 0.1
+          timeout -= 0.1
+          raise "Timeout error" unless timeout.positive?
+        end
+      end
+    end
+  end
+end

data/lib/anyt/utils.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require "anyt/utils/async_helpers"

data/lib/anyt/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Anyt
+  VERSION = "1.3.0"
+end

data/lib/anyt.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "anyt/version"
+require "anyt/config"
+require "anyt/utils"
+
+# AnyCable conformance testing tool
+module Anyt
+  class << self
+    def config
+      @config ||= Config.new
+    end
+  end
+end