anyt 1.2.3 → 1.3.0

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

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

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

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

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

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

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

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

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

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

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

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

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