anyt 0.2.0

data/lib/anyt/client.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Anyt
+  # Synchronous websocket client
+  # Based on https://github.com/rails/rails/blob/v5.0.1/actioncable/test/client_test.rb
+  class Client
+    require "websocket-client-simple"
+    require "concurrent"
+
+    class TimeoutError < StandardError; end
+
+    WAIT_WHEN_EXPECTING_EVENT = 5
+    WAIT_WHEN_NOT_EXPECTING_EVENT = 0.5
+
+    # rubocop: disable Metrics/AbcSize
+    # rubocop: disable Metrics/MethodLength
+    def initialize(
+      ignore: [], url: Anyt.config.target_url, qs: "",
+      cookies: "", headers: {}
+    )
+      ignore_message_types = @ignore_message_types = ignore
+      messages = @messages = Queue.new
+      closed = @closed = Concurrent::Event.new
+      has_messages = @has_messages = Concurrent::Semaphore.new(0)
+
+      headers = headers.merge('cookie' => cookies)
+
+      open = Concurrent::Promise.new
+
+      @ws = WebSocket::Client::Simple.connect(
+        url + "?#{qs}",
+        headers: headers
+      ) do |ws|
+        ws.on(:error) do |event|
+          event = RuntimeError.new(event.message) unless event.is_a?(Exception)
+
+          if open.pending?
+            open.fail(event)
+          else
+            messages << event
+            has_messages.release
+          end
+        end
+
+        ws.on(:open) do |_event|
+          open.set(true)
+        end
+
+        ws.on(:message) do |event|
+          if event.type == :close
+            closed.set
+          else
+            message = JSON.parse(event.data)
+
+            next if ignore_message_types.include?(message["type"])
+            messages << message
+            has_messages.release
+          end
+        end
+
+        ws.on(:close) do |_event|
+          closed.set
+        end
+      end
+
+      open.wait!(WAIT_WHEN_EXPECTING_EVENT)
+    end
+    # rubocop: enable Metrics/AbcSize
+    # rubocop: enable Metrics/MethodLength
+
+    def receive(timeout: WAIT_WHEN_EXPECTING_EVENT)
+      raise TimeoutError, "Timed out to receive message" unless
+        @has_messages.try_acquire(1, timeout)
+
+      msg = @messages.pop(true)
+      raise msg if msg.is_a?(Exception)
+
+      msg
+    end
+
+    def send(message)
+      @ws.send(JSON.generate(message))
+    end
+
+    def close
+      sleep WAIT_WHEN_NOT_EXPECTING_EVENT
+
+      raise "#{@messages.size} messages unprocessed" unless @messages.empty?
+
+      @ws.close
+      wait_for_close
+    end
+
+    def wait_for_close
+      @closed.wait(WAIT_WHEN_EXPECTING_EVENT)
+    end
+
+    def closed?
+      @closed.set?
+    end
+  end
+end

data/lib/anyt/command.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Anyt
+  # Runs system command (websocket server)
+  module Command
+    class << self
+      attr_accessor :running
+
+      # rubocop: disable Metrics/MethodLength
+      # rubocop: disable Metrics/AbcSize
+      def run
+        return if @running
+
+        Anycable.logger.debug "Running command: #{Anyt.config.command}"
+
+        out = Anycable.config.debug ? STDOUT : IO::NULL
+
+        @pid = Process.spawn(
+          Anyt.config.command,
+          out: out,
+          err: out
+        )
+
+        Process.detach(@pid)
+
+        Anycable.logger.debug "Command PID: #{@pid}"
+
+        @running = true
+
+        sleep Anyt.config.wait_command
+      end
+      # rubocop: enable Metrics/MethodLength
+      # rubocop: enable Metrics/AbcSize
+
+      def stop
+        return unless @running
+
+        Anycable.logger.debug "Terminate PID: #{@pid}"
+
+        Process.kill("SIGKILL", @pid)
+
+        @running = false
+      end
+
+      def running?
+        @running == true
+      end
+    end
+  end
+end

data/lib/anyt/config.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "anyway"
+
+module Anyt
+  # Anyt configuration
+  class Config < Anyway::Config
+    attr_config :command,
+                :only_tests,
+                target_url: "ws://localhost:9292/",
+                wait_command: 2
+
+    def filter_tests?
+      !only_tests.nil?
+    end
+
+    def tests_filter
+      @tests_filter ||= begin
+        /(#{only_tests.join('|')})/
+      end
+    end
+  end
+end

data/lib/anyt/dummy/application.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "rails"
+require "action_cable"
+require "action_dispatch/middleware/cookies"
+
+module ApplicationCable
+  class Connection < ActionCable::Connection::Base
+    delegate :params, to: :request
+
+    def connect
+      logger.info "Connected"
+      Anyt::ConnectHandlers.call(self)
+    end
+
+    def disconnect
+      logger.info "Disconnected"
+    end
+  end
+end
+
+module ApplicationCable
+  class Channel < ActionCable::Channel::Base
+  end
+end
+
+ActionCable.server.config.cable = { "adapter" => "redis" }
+ActionCable.server.config.connection_class = -> { ApplicationCable::Connection }
+ActionCable.server.config.disable_request_forgery_protection = true
+ActionCable.server.config.logger =
+  Rails.logger = Logger.new(STDOUT).tap { |l| l.level = Logger::DEBUG }

data/lib/anyt/dummy/config.ru

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative "./application"
+
+require_relative "../tests"
+
+# Load channels from tests
+Anyt::Tests.load_all_tests
+
+run ActionCable.server

data/lib/anyt/ext/minitest.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require "minitest/spec"
+require "minitest/reporters"
+
+module Anyt
+  # Common tests helpers
+  module TestHelpers
+    def self.included(base)
+      base.let(:client) { build_client(ignore: %w[ping welcome]) }
+    end
+
+    def build_client(*args)
+      Anyt::Client.new(*args)
+    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 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/rpc.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Anyt # :nodoc:
+  require "anyt/dummy/application"
+  require "anycable"
+
+  # Runs AnyCable RPC server in the background
+  module RPC
+    using AsyncHelpers
+
+    class << self
+      attr_accessor :running
+
+      def start
+        Anycable.logger.debug "Starting RPC server ..."
+
+        @thread = Thread.new { Anycable::Server.start }
+        @thread.abort_on_exception = true
+
+        wait(2) { running? }
+
+        Anycable.logger.debug "RPC server started"
+      end
+
+      def stop
+        return unless running?
+
+        Anycable::Server.grpc_server.stop
+      end
+
+      def running?
+        Anycable::Server.grpc_server&.running_state == :running
+      end
+    end
+
+    Anycable.configure do |config|
+      config.connection_factory = ActionCable.server.config.connection_class.call
+    end
+  end
+end

data/lib/anyt/tests.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Anyt
+  # Loads and runs test cases
+  module Tests
+    require "anyt/client"
+    require_relative "ext/minitest"
+
+    class << self
+      # 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
+
+      # rubocop:disable Metrics/AbcSize
+      # rubocop:disable Metrics/MethodLength
+      def load_tests
+        return load_all_tests unless Anyt.config.filter_tests?
+
+        pattern = File.expand_path("tests/**/*.rb", __dir__)
+        skipped = []
+        filter = Anyt.config.tests_filter
+
+        Dir.glob(pattern).each do |file|
+          if file.match?(filter)
+            require file
+          else
+            skipped << file.gsub(File.join(__dir__, 'tests/'), '').gsub('_test.rb', '')
+          end
+        end
+
+        $stdout.print "Skipping tests: #{skipped.join(', ')}\n"
+      end
+
+      # Load all test files
+      def load_all_tests
+        pattern = File.expand_path("tests/**/*.rb", __dir__)
+
+        Dir.glob(pattern).each { |file| require file }
+      end
+    end
+  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["type"], "ping"
+      assert_kind_of Integer, current_stamp
+      refute_operator previous_stamp, :>=, current_stamp
+
+      previous_stamp = current_stamp
+    end
+  end
+end