wsdirector-core 0.0.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 582448a4834a77dbe5efc80bc149a3bef0eba766
-  data.tar.gz: 9d5ef63857c5da95552ff953a186d1d449c1c5d0
+SHA256:
+  metadata.gz: 950b1fe48bc078969f01feab7a589280a74cdfce92a2472b04a3af35710f634b
+  data.tar.gz: ec42ae09c70ab4d143f4d04506d066a6bab4aad7143246f5803e1465fbe772d4
 SHA512:
-  metadata.gz: fd1a5cba842b179f8a8f4acb864dbefbe9789225c8b8af87833ddaf580600075a5bf3e4916aedc4b88acecf0cee0a2962d840eb8aeea44696e703de1b2ebdaa2
-  data.tar.gz: 831e35a16c6da9f99e09e8b36918d48348503cfeb1c38c57e2d39a5ba66469d223425376ee123a91f4a0a954af267633850a82461e0c4a77845dddb9317d551b
+  metadata.gz: da07984b3fa426e11a49593f30d02036fe694f3519ce11aec26ff93eccdf20104461b77cc8c0c615ae733a207030c1297c5b51e2ffa70f30f15cf4b1387ff0fa
+  data.tar.gz: 126a6108c638b6d314bfa4581ab487e626fb8a59db8d5e5af20473330b749b671dce8a921ad545062e75c781ed76d5cfa275fd69eb18e7fd27bf150734314fea

data/CHANGELOG.md

@@ -0,0 +1,144 @@
+# Change log
+
+## master
+
+## 1.0.0 (2022-09-19)
+
+- Add Phoenix Channels protocol support. ([@palkan][])
+
+- Make `receive` order-independent. ([@palkan][])
+
+Using `receive` now looks up a matching message through all the mailbox (already received or newly arrived messages).
+If you need strict order guarantees, add `ordered: true` to `receive`.
+
+- Add `WSDirector::Snapshot`. ([@palkan][])
+
+- Add `locals` support when running scenarios programmatically. ([@palkan][])
+
+- Add partial receive data matching support (via `data>` field). ([@palkan][])
+
+- Add `connection_options` support (headers, cookies, query). ([@palkan][])
+
+- Add loading custom protocols support. ([@palkan][])
+
+- Allow passing URL without a scheme part. ([@palkan][])
+
+- Add `-vv` option to print action logs. ([@palkan][])
+
+- Add `--subprotocol` support and `connection_options` in the scenario files. ([@palkan][])
+
+- Add `-f/--file` option to specify scenario path. ([@palkan][])
+
+- Drop Ruby 2.5 support.
+
+## 0.5.0 (2021-10-13)
+
+- Add JSON support. ([@wazzuper][])
+
+- Add new commands to CLI.
+
+You can pass a JSON scenario directly to the CLI without creating a file:
+
+```bash
+wsdirector -i '[{"receive": {"data":"welcome"}},{"send":{"data":"send message"}},{"receive":{"data":"receive message"}}]' -u ws://websocket.server:9876
+```
+
+or you can pass it as a JSON file:
+
+```bash
+wsdirector scenario.json -u ws://websocket.server:9876
+```
+
+- Add loop option support. ([@last-in-japan][])
+
+You can specify a `loop` option to perform a similar set of actions multiple times:
+
+```yml
+  # script.yml
+  - client:
+      name: "listeners"
+      loop:
+        multiplier: ":scale" # :scale take number from -s param, and run :scale number of clients in this group
+        actions:
+          - receive:
+              data:
+                type: "welcome"
+          - send:
+              data:
+                command: "subscribe"
+                identifier: "{\"channel\":\"Channel\"}"
+          - receive:
+              data:
+                identifier: "{\"channel\":\"Channel\"}"
+                type: "confirm_subscription"
+          - wait_all
+          - receive:
+              multiplier: ":scale + 1"
+```
+
+Useful in combination with `:scale`.
+
+## 0.4.0 (2020-08-24)
+
+- **Drop Ruby 2.4 support**. ([@palkan][])
+
+- Add sampling support. ([@palkan][])
+
+You can specify a `sample` option for a step to only run this step by specified number of clients from the group:
+
+```yml
+- perform:
+  sample: ":scale / 2"
+  channel: "chat"
+  params:
+    id: 2
+  action: "speak"
+  data:
+    message: "Hello!"
+```
+
+Useful in combination with `:scale`.
+
+**NOTE:** Sample size is always greater or equal to 1.
+
+- Add ERB support. ([@palkan][])
+
+Now you can, for example, access `ENV` from scenarios.
+
+## 0.3.0 (2018-05-02)
+
+- Add `debug` action and options. ([@palkan][])
+
+Allows to print arbitrary messages during the execution.
+
+- Add `sleep` action. ([@palkan][])
+
+- Add `receive_all` action. ([@palkan][])
+
+Allows to handle multiple messages with unspecified order:
+
+```yml
+- receive_all:
+    messages:
+      - data:
+          text: "Hello!"
+        multiplier: ":scale + :scale"
+        channel: "chat"
+        params:
+          id: 2
+      - data:
+          text: "message sent"
+        channel: "chat"
+        params:
+          id: 2
+```
+
+## 0.2.0 (2017-11-05)
+
+- Initial version. ([@palkan][], [@Kirillvs][], [@Grandman][])
+
+[@palkan]: https://github.com/palkan
+[@Kirillvs]: https://github.com/Kirillvs
+[@Grandman]: https://github.com/Grandman
+[@wazzuper]: https://github.com/wazzuper
+[@last-in-japan]: https://github.com/last-in-japan

data/LICENSE.txt

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2017 Vladimir Dementyev
+Copyright (c) 2017-2022 palkan
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -1,38 +1,353 @@
-# Wsdirector::Core
+[![Cult Of Martians](http://cultofmartians.com/assets/badges/badge.svg)](http://cultofmartians.com/tasks/websocket-director.html)
+[![Gem Version](https://badge.fury.io/rb/wsdirector-cli.svg)](https://rubygems.org/gems/wsdirector-cli)
+[![Build](https://github.com/palkan/wsdirector/workflows/Build/badge.svg)](https://github.com/palkan/wsdirector/actions)
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/wsdirector/core`. To experiment with that code, run `bin/console` for an interactive prompt.
+# WebSocket Director
 
-TODO: Delete this and the text above, and describe your gem
+Command line tool for testing WebSocket servers using scenarios.
+
+Suitable for testing any websocket server implementation, like [Action Cable](https://github.com/rails/rails/tree/master/actioncable), [AnyCable](https://anycable.io), [Phoenix Channels](https://hexdocs.pm/phoenix/channels.html), [GraphQL WS](https://github.com/enisdenjo/graphql-ws) and so on.
 
 ## Installation
 
-Add this line to your application's Gemfile:
+Install CLI:
+
+```sh
+gem install wsdirector-cli
+```
+
+Or use WebSockets Director as a library (see below for intructions):
 
 ```ruby
-gem 'wsdirector-core'
+# Gemfile
+gem "wsdirector-core", "~> 1.0"
 ```
 
-And then execute:
+## Usage
 
-    $ bundle
+Create YAML file with simple testing script:
 
-Or install it yourself as:
+```yml
+# script.yml
+- receive: "Welcome" # expect to receive message
+- send:
+    data: "send message" # send message, all messages in data will be parse to json
+- receive:
+    data: "receive message" # expect to receive json message
+```
 
-    $ gem install wsdirector-core
+and run it with this command:
 
-## Usage
+```bash
+wsdirector -f script.yml -u ws://websocket.server:9876/ws
+
+#=> 1 clients, 0 failures
+```
+
+You can also use positional arguments:
+
+```sh
+wsdirector script.yml ws://websocket.server:9876/ws
+```
+
+You can create more complex scenarios with multiple client groups:
+
+```yml
+# script.yml
+- client: # first clients group
+    name: "publisher" # optional group name
+    multiplier: ":scale" # :scale take number from -s param, and run :scale number of clients in this group
+    actions:
+      - receive:
+          data: "Welcome"
+      - wait_all # makes all clients in all groups wait untill every client get this point (global barrier)
+      - send:
+          data: "test message"
+- client:
+    name: "listeners"
+    multiplier: ":scale * 2"
+    actions:
+      - receive:
+          data: "Welcome"
+      - wait_all
+      - receive:
+          multiplier: ":scale" # you can use multiplier with any action
+          data: "test message"
+```
+
+Run with scale factor:
+
+```bash
+wsdirector -f script.yml -u ws://websocket.server:9876 -s 10
+
+#=> Group publisher: 10 clients, 0 failures
+#=> Group listeners: 20 clients, 0 failures
+```
+
+The simpliest scenario is just checking that socket is succesfully connected:
+
+```yml
+- client:
+    name: connection check
+    # no actions
+```
+
+Run with loop option:
+
+```yml
+  # script.yml
+  - client:
+      name: "listeners"
+      loop:
+        multiplier: ":scale" # :scale take number from -s param, and run :scale number of clients in this group
+        actions:
+          - receive:
+              data:
+                type: "welcome"
+          - send:
+              data:
+                command: "subscribe"
+                identifier: "{\"channel\":\"Channel\"}"
+          - receive:
+              data:
+                identifier: "{\"channel\":\"Channel\"}"
+                type: "confirm_subscription"
+          - wait_all
+          - receive:
+              multiplier: ":scale + 1"
+```
+
+By default, `receive` action expects the exact `data` match. In some cases, it's useful to only match the specified keys (inclusion). For that, you can use `data>` field instead:
+
+```yml
+- client:
+  actions:
+    - receive:
+        data:
+          type: "welcome"
+    - send:
+        data:
+          command: "subscribe"
+          identifier: "{\"channel\":\"Channel\"}"
+    - receive:
+        data>:
+          type: "confirm_subscription"
+```
+
+Also you can pass a JSON file with some testing scripts:
+
+```bash
+wsdirector -f scenario.json -u ws://websocket.server:9876
+```
+
+or pass a JSON scenario directly to the CLI without creating a file:
+
+```bash
+wsdirector -i '[{"receive": {"data":"welcome"}},{"send":{"data":"send message"}},{"receive":{"data":"receive message"}}]' -u ws://websocket.server:9876
+```
+
+Type `wsdirector --help` to check all commands.
+
+### Receive order
+
+By default, the `receive` action scans through all available or newly added message to find a matching one.
+If you want to check the order of incoming messages, add the `ordered: true` option to the `receive` action.
+
+### Connection configuration
+
+You can specify client's headers, cookies or query string params via the `connection_options` directive:
+
+```yml
+- client:
+    connection_options:
+      headers:
+        "X-API-KEY": "secret"
+      query:
+        token: "123"
+      cookies:
+        session_id: "2022"
+```
+
+**NOTE**: Query string params could also be passed as a part of the URL. Specifying them in the scenario allows you to provide values via the interpolation.
+
+### Using as a library
+
+You can integrate WS Director into your library or application by using its APIs:
 
-TODO: Write usage instructions here
+```ruby
+# Could be a file path or JSON-encoded string as well
+scenario = [
+  {
+    send: {
+      data: "ping"
+    }
+  },
+  {
+    receive: {
+      data: "pong"
+    }
+  }
+]
+
+result = WSDirector.run(scenario, url: "ws://my.ws.server:4949/live")
+result.success? #=> true of false
+result.groups #=> result data for each client group
+```
+
+If you're using YAML-based scenarios, you can also pass local variables to be used with ERB via the `locals` option:
+
+```yml
+- client:
+    connection_options:
+      headers:
+        "X-API-TOKEN": <%= token %>
+```
+
+```ruby
+token = UserToken.generate
+WSDirector.run(scenario, url: "ws://my.ws.server:4949/live", locals: {token:})
+```
+
+### Protocols
+
+WSDirector uses protocols to handle provide convinient actions for some popular protocols.
+
+#### ActionCable Example
+
+Channel code:
+
+```ruby
+class ChatChannel < ApplicationCable::Channel
+  def subscribed
+    stream_from "chat_test"
+  end
+
+  def echo(data)
+    transmit data
+  end
+
+  def broadcast(data)
+    ActionCable.server.broadcast "chat_test", data
+  end
+end
+```
+
+Scenario:
+
+```yml
+- client:
+    multiplier: ":scale"
+    name: "publisher"
+    protocol: "action_cable"
+    actions:
+      - subscribe:
+          channel: "ChatChannel"
+      - wait_all
+      - perform:
+          channel: "ChatChannel"
+          action: "broadcast"
+          data:
+            text: "hello"
+- client:
+    name: "listener"
+    protocol: "action_cable"
+    actions:
+      - subscribe:
+          channel: "ChatChannel"
+      - wait_all
+      - receive:
+          channel: "ChatChannel"
+          data:
+            text: "hello"
+```
+
+#### Phoenix Channels
+
+With "phoenix" protocol, you can use communicate with a [Phoenix Channels](https://hexdocs.pm/phoenix/channels.html) server:
+
+```yml
+- client:
+    protocol: phoenix
+    multiplier: ":scale"
+    actions:
+      - join:
+          topic: room:lobby
+      - wait_all
+      - send:
+          topic: room:lobby
+          event: new_msg
+          data:
+            body: "Hey from WS director!"
+      - receive:
+          topic: room:lobby
+          multiplier: ":scale"
+          event: new_msg
+          data:
+            body: "Hey from WS director!"
+```
+
+**IMPORTANT**: We support only v2 version of the Channels protocol.
+
+#### Custom protocols
+
+You can define your own protocol and load it dynamically:
+
+```ruby
+# It's important to put a custom protocol class under WSDirector::Protocols
+module WSDirector::Protocols
+  class CustomProtocol < Base
+    def send_ping_and_receive_pong
+      send("data" => {"type" => "ping"})
+      receive("data" => {"type" => "pong"})
+    end
+  end
+end
+```
+
+Now you can load it via the `-r` option:
+
+```sh
+$ wsdirector -u localhost:3232/ws -i '["send_ping_and_receive_pong"]' -r ./path/to/custom_protocol.rb -vv
+
+hh:mm:ss client=default_1 Connecting
+hh:mm:ss client=default_1 Connected (45ms)
+hh:mm:ss client=default_1 Sent message: {"type":"ping"}
+hh:mm:ss client=default_1 Receive message: {"type":"pong"}
+hh:mm:ss client=default_1 Received message: {"type":"pong"} (21ms)
+```
+
+## Testing frameworks integration
+
+WSDirector does not provide any specific helpers for RSpec or Minitest. Instead, we provide an example setup, which you could adjust to your needs (and which is too small to be a part of the library).
+
+The example below implies running tests against an Action Cable server with a token-based authentication
+
+```ruby
+module WSDirectorTestHelper
+  def run_websocket_scenario(path, token:, url: ActionCable.server.config.url, **options)
+    url = "#{url}?jid=#{token}"
+    scenario = Rails.root.join "spec" / "fixtures" / "wsdirector" / path
+
+    WSDirector.run(scenario, url:, **options)
+  end
+end
+
+# In RSpec, you can include this modules via the configuration
+RSpec.configure do |config|
+  # Here we only add this helper to system tests
+  config.include WSDirectorTestHelper, type: :system
+end
+```
 
-## Development
+## Future Ideas
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+- Report timings (per-client and aggregates)
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+- What else? [Submit an issue!](https://github.com/palkan/wsdirector/issues/new)
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/wsdirector-core.
+Bug reports and pull requests are welcome on GitHub at https://github.com/palkan/wsdirector.
 
 ## License
 

data/bin/wsdirector

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+
+lib_path = File.expand_path("../lib", __dir__)
+$LOAD_PATH.unshift(lib_path) unless $LOAD_PATH.include?(lib_path)
+
+require "wsdirector-cli"
+
+begin
+  WSDirector::CLI.new.run
+rescue => e
+  raise e if $DEBUG
+  STDERR.puts e.message
+  STDERR.puts e.backtrace.take(10).join("\n") if ENV["WSDIRECTOR_DEBUG"] == "1"
+  exit 1
+end

data/lib/wsdirector/cli.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+require "optparse"
+require "uri"
+
+require "wsdirector"
+
+module WSDirector
+  # Command line interface for WsDirector
+  class CLI
+    class Configuration
+      attr_accessor :ws_url, :scenario_path, :colorize, :scale,
+        :sync_timeout, :json_scenario, :subprotocol, :verbose
+
+      def initialize
+        reset!
+      end
+
+      def colorize?
+        colorize == true
+      end
+
+      # Restore to defaults
+      def reset!
+        @scale = 1
+        @colorize = $stdout.tty?
+        @sync_timeout = 5
+      end
+    end
+
+    attr_reader :config
+
+    def run
+      @config = Configuration.new
+
+      parse_args!
+
+      begin
+        require "colorize" if config.colorize?
+      rescue LoadError
+        config.colorize = false
+        warn "Install colorize to use colored output"
+      end
+
+      connection_options = {
+        subprotocol: config.subprotocol
+      }.compact
+
+      scenario = config.scenario_path || config.json_scenario
+
+      config.ws_url = "ws://#{config.ws_url}" unless config.ws_url.start_with?(/wss?:\/\//)
+
+      url = config.ws_url
+      scale = config.scale
+      sync_timeout = config.sync_timeout
+      colorize = config.colorize
+
+      logger = $stdout if config.verbose
+
+      result = WSDirector.run(
+        scenario,
+        url:,
+        connection_options:,
+        scale:,
+        sync_timeout:,
+        logger:,
+        colorize:
+      )
+
+      puts "\n\n" if config.verbose
+
+      result.print_summary(colorize: config.colorize?)
+      result.success? || exit(1)
+    end
+
+    private
+
+    FILE_FORMAT = /.+.(json|yml)\z/
+    private_constant :FILE_FORMAT
+
+    def parse_args!
+      parser = OptionParser.new do |opts|
+        opts.banner = "Usage: wsdirector scenario_path ws_url [options]"
+
+        opts.on("-s SCALE", "--scale=SCALE", Integer, "Scale factor") do
+          config.scale = _1
+        end
+
+        opts.on("-t TIMEOUT", "--timeout=TIMEOUT", Integer, "Synchronization (wait_all) timeout") do
+          config.sync_timeout = _1
+        end
+
+        opts.on("-i JSON", "--include=JSON", String, "Include JSON to parse") do
+          config.json_scenario = _1
+        end
+
+        opts.on("-u URL", "--url=URL", Object, "Websocket server URL") do
+          config.ws_url = _1
+        end
+
+        opts.on("-f PATH", "--file=PATH", String, "Scenario path") do
+          config.scenario_path = _1
+        end
+
+        opts.on("--subprotocol=VALUE", String, "WebSocket subprotocol") do
+          config.subprotocol = _1
+        end
+
+        opts.on("-c", "--[no-]color", "Colorize output") do
+          config.colorize = _1
+        end
+
+        opts.on("-v", "--version", "Print version") do
+          $stdout.puts WSDirector::VERSION
+          exit 0
+        end
+
+        opts.on("-vv", "Print verbose logs") do
+          config.verbose = true
+        end
+
+        opts.on("-r", "--require=PATH", "Load Ruby file (e.g., protocol)") do
+          Kernel.load(_1)
+        end
+      end
+
+      parser.parse!
+
+      unless config.scenario_path
+        config.scenario_path = ARGV.grep(FILE_FORMAT).last
+      end
+
+      unless config.ws_url
+        config.ws_url = ARGV.grep(URI::DEFAULT_PARSER.make_regexp).last
+      end
+
+      check_for_errors
+    end
+
+    def check_for_errors
+      if config.json_scenario.nil?
+        raise(Error, "Scenario is missing") unless config.scenario_path
+
+        unless File.file?(config.scenario_path)
+          raise(Error, "File doesn't exist # config.scenario_path}")
+        end
+      end
+
+      raise(Error, "Websocket server url is missing") unless config.ws_url
+    end
+  end
+end