wsdirector-cli 0.2.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 12469915784ca778073f50ab6b6157c73c014bee
+  data.tar.gz: '09f32425b8005d8cade46678259222286f4eff8b'
+SHA512:
+  metadata.gz: 1985ee2404b98a54e9a63f40b35db59e139738f9d4d3f3eeb79bc451533f97f3a85c0f2abebdb5aa473e8a7f836a4597bdf058d6bd8cf8c016d85226545606b4
+  data.tar.gz: 55994d15c789a8f8c3bad3b2847a9d274a7ed581081e5928c071c6daeb6f4a1e2d225e844e7499364bf051982dca87cd28e4e9f4f563deb52c22bbe9087e1be6

data/CHANGELOG.md

@@ -0,0 +1,9 @@
+# Change log
+
+## 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

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 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
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,143 @@
+[![Gem Version](https://badge.fury.io/rb/wsdirector-cli.svg)](https://rubygems.org/gems/wsdirector-cli) [![CircleCI](https://circleci.com/gh/palkan/wsdirector.svg?style=svg)](https://circleci.com/gh/palkan/wsdirector) 
+
+# WebSocket Director
+
+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), [Websocket Eventmachine Server](https://github.com/imanel/websocket-eventmachine-server), [Litecable](https://github.com/palkan/litecable) and so on.
+
+<a href="https://evilmartians.com/">
+<img src="https://evilmartians.com/badges/sponsored-by-evil-martians.svg" alt="Sponsored by Evil Martians" width="236" height="54"></a>
+
+## Installation
+
+```bash
+  $ gem install wsdirector-cli
+```
+
+## Usage
+
+Create YAML file with simle testing script:
+
+```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
+```
+
+and run it with this command:
+
+```bash
+wsdirector script.yml ws://websocket.server:9876/ws
+
+#=> 1 clients, 0 failures
+```
+
+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 script.yml 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
+```
+
+### Protocols
+
+WSDirector uses protocols to handle different actions.
+Currently, we support "base" protocol (with `send`, `receive`, `wait_all` actions) and "action_cable" protocol, which extends "base" with `subscribe` and `perform` actions.
+
+#### 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"
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/palkan/wsdirector.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/bin/wsdirector

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+
+require "rubygems"
+
+$:.unshift(File.expand_path(__dir__ + "/../lib"))
+
+require "wsdirector/cli"
+
+begin
+  WSDirector::CLI.new.tap { |cli| cli.run }
+rescue => e
+  STDERR.puts e.message
+  STDERR.puts e.backtrace.join("\n")
+  exit 1
+end

data/lib/wsdirector.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require "concurrent"
+require "yaml"
+require "json"
+
+require "wsdirector/version"
+require "wsdirector/configuration"
+
+# Command line tool for testing websocket servers using scenarios.
+module WSDirector
+  class Error < StandardError
+  end
+
+  class << self
+    def config
+      @config ||= Configuration.new
+    end
+  end
+end
+
+require "wsdirector/cli"

data/lib/wsdirector/cli.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require "optparse"
+
+require "wsdirector"
+require "wsdirector/scenario_reader"
+require "wsdirector/runner"
+
+module WSDirector
+  # Command line interface for WsDirector
+  class CLI
+    def initialize; end
+
+    def run
+      parse_args!
+
+      begin
+        require "colorize" if WSDirector.config.colorize?
+      rescue LoadError
+        WSDirector.config.colorize = false
+        warn "Install colorize to use colored output"
+      end
+
+      scenario = WSDirector::ScenarioReader.parse(
+        WSDirector.config.scenario_path
+      )
+
+      if WSDirector::Runner.new(scenario).start
+        exit 0
+      else
+        exit 1
+      end
+    rescue Error => e
+      STDERR.puts e.message
+      exit 1
+    end
+
+    private
+
+    def parse_args!
+      # rubocop: disable Metrics/LineLength
+      parser = OptionParser.new do |opts|
+        opts.banner = "Usage: wsdirector scenario_path ws_url [options]"
+
+        opts.on("-s SCALE", "--scale=SCALE", Integer, "Scale factor") do |v|
+          WSDirector.config.scale = v
+        end
+
+        opts.on("-t TIMEOUT", "--timeout=TIMEOUT", Integer, "Synchronization (wait_all) timeout") do |v|
+          WSDirector.config.sync_timeout = v
+        end
+
+        opts.on("-c", "--[no-]color", "Colorize output") do |v|
+          WSDirector.config.colorize = v
+        end
+
+        opts.on("-v", "--version", "Print versin") do
+          STDOUT.puts WSDirector::VERSION
+          exit 0
+        end
+      end
+      # rubocop: enable Metrics/LineLength
+
+      parser.parse!
+
+      WSDirector.config.scenario_path = ARGV[0]
+      WSDirector.config.ws_url = ARGV[1]
+
+      raise(Error, "Scenario path is missing") if WSDirector.config.scenario_path.nil?
+
+      raise(Error, "File doesn't exist #{WSDirector.config.scenario_path}") unless
+        File.file?(WSDirector.config.scenario_path)
+
+      raise(Error, "Websocket server url is missing") if WSDirector.config.ws_url.nil?
+    end
+  end
+end

data/lib/wsdirector/client.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "websocket-client-simple"
+
+module WSDirector
+  # WebSocket client
+  class Client
+    WAIT_WHEN_EXPECTING_EVENT = 5
+
+    attr_reader :ws
+
+    # Create new WebSocket client and connect to WSDirector
+    # ws URL.
+    #
+    # Optionally provide an ignore pattern (to ignore incoming message,
+    # for example, pings)
+    def initialize(ignore: nil)
+      @ignore = ignore
+      has_messages = @has_messages = Concurrent::Semaphore.new(0)
+      messages = @messages = Queue.new
+      path = WSDirector.config.ws_url
+      open = Concurrent::Promise.new
+      client = self
+
+      @ws = WebSocket::Client::Simple.connect(path) do |ws|
+        ws.on(:open) do |_event|
+          open.set(true)
+        end
+
+        ws.on :message do |msg|
+          data = msg.data
+          next if data.empty?
+          next if client.ignored?(data)
+          messages << data
+          has_messages.release
+        end
+
+        ws.on :error do |e|
+          messages << Error.new("WebSocket Error #{e.inspect} #{e.backtrace}")
+        end
+      end
+
+      open.wait!(WAIT_WHEN_EXPECTING_EVENT)
+    rescue Errno::ECONNREFUSED
+      raise Error, "Failed to connect to #{path}"
+    end
+
+    def receive(timeout = WAIT_WHEN_EXPECTING_EVENT)
+      @has_messages.try_acquire(1, timeout)
+      msg = @messages.pop(true)
+      raise msg if msg.is_a?(Exception)
+      msg
+    end
+
+    def send(msg)
+      @ws.send(msg)
+    end
+
+    def ignored?(msg)
+      return false unless @ignore
+      @ignore.any? { |pattern| msg =~ pattern }
+    end
+  end
+end

data/lib/wsdirector/clients_holder.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module WSDirector
+  # Acts as a re-usable global barrier for a fixed number of clients.
+  # Barrier is reset if sucessfully passed in time.
+  class ClientsHolder
+    def initialize(count)
+      @barrier = Concurrent::CyclicBarrier.new(count)
+    end
+
+    def wait_all
+      result = barrier.wait(WSDirector.config.sync_timeout)
+      raise Error, "Timeout (#{WSDirector.config.sync_timeout}s) exceeded for #wait_all" unless
+        result
+      barrier.reset
+      result
+    end
+
+    private
+
+    attr_reader :barrier
+  end
+end

data/lib/wsdirector/configuration.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module WSDirector
+  # WSDirector configuration
+  class Configuration
+    attr_accessor :ws_url, :scenario_path, :colorize, :scale,
+                  :sync_timeout
+
+    def initialize
+      reset!
+    end
+
+    def colorize?
+      colorize == true
+    end
+
+    # Restore to defaults
+    def reset!
+      @scale = 1
+      @colorize = false
+      @sync_timeout = 5
+    end
+  end
+end

data/lib/wsdirector/ext/deep_dup.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module WSDirector
+  module Ext
+    # Extend Object through refinements
+    module DeepDup
+      refine ::Hash do
+        # Based on ActiveSupport http://api.rubyonrails.org/classes/Hash.html#method-i-deep_dup
+        def deep_dup
+          each_with_object(dup) do |(key, value), hash|
+            hash[key] = if value.is_a?(::Hash) || value.is_a?(::Array)
+                          value.deep_dup
+                        else
+                          value
+                        end
+          end
+        end
+      end
+
+      refine ::Array do
+        # From ActiveSupport http://api.rubyonrails.org/classes/Array.html#method-i-deep_dup
+        def deep_dup
+          map do |value|
+            if value.is_a?(::Hash) || value.is_a?(::Array)
+              value.deep_dup
+            else
+              value
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/wsdirector/printer.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module WSDirector
+  # Print messages (optionally colorized) to STDOUT
+  class Printer
+    def self.out(message, color = nil)
+      message = message.colorize(color) if WSDirector.config.colorize? && color
+      $stdout.puts(message)
+    end
+  end
+end

data/lib/wsdirector/protocols.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "wsdirector/protocols/base"
+require "wsdirector/protocols/action_cable"
+
+module WSDirector
+  ID2CLASS = {
+    "base" => "Base",
+    "action_cable" => "ActionCable"
+  }.freeze
+
+  module Protocols # :nodoc:
+    # Raised when received not expected message
+    class UnmatchedExpectationError < WSDirector::Error; end
+    # Raised when nothing has been received
+    class NoMessageError < WSDirector::Error; end
+
+    class << self
+      def get(id)
+        raise Error, "Unknown protocol: #{id}" unless ID2CLASS.key?(id)
+        class_name = ID2CLASS.fetch(id)
+        const_get(class_name)
+      end
+    end
+  end
+end

data/lib/wsdirector/protocols/action_cable.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module WSDirector
+  module Protocols
+    # ActionCable protocol
+    class ActionCable < Base
+      WELCOME_MSG = { type: "welcome" }.to_json
+      PING_IGNORE = /['"]type['"]:\s*['"]ping['"]/
+
+      # Add ping ignore and make sure that we receive Welcome message
+      def init_client(**options)
+        options[:ignore] ||= [PING_IGNORE]
+
+        super(**options)
+
+        receive("data" => WELCOME_MSG)
+      end
+
+      def subscribe(step)
+        identifier = extract_identifier(step)
+
+        client.send({ command: "subscribe", identifier: identifier }.to_json)
+
+        begin
+          receive(
+            "data" => { "type" => "confirm_subscription", "identifier" => identifier }
+          )
+        rescue UnmatchedExpectationError => e
+          raise unless e.message =~ /reject_subscription/
+          raise UnmatchedExpectationError, "Subscription rejected to #{identifier}"
+        end
+      end
+
+      def perform(step)
+        identifier = extract_identifier(step)
+        action = step.delete("action")
+
+        raise Error, "Action is missing" unless action
+
+        data = step.fetch("data", {}).merge(action: action).to_json
+
+        client.send({ command: "message", data: data, identifier: identifier }.to_json)
+      end
+
+      def receive(step)
+        return super unless step.key?("channel")
+
+        identifier = extract_identifier(step)
+        message = step.fetch("data", {})
+        super("data" => { "identifier" => identifier, "message" => message })
+      end
+
+      private
+
+      def extract_identifier(step)
+        channel = step.delete("channel")
+        step.fetch("params", {}).merge(channel: channel).to_json
+      end
+    end
+  end
+end

data/lib/wsdirector/protocols/base.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module WSDirector
+  module Protocols
+    # Base protocol describes basic actions
+    class Base
+      def initialize(task)
+        @task = task
+      end
+
+      def init_client(**options)
+        @client = build_client(**options)
+      end
+
+      def handle_step(step)
+        type = step.delete("type")
+        raise Error, "Unknown step: #{type}" unless respond_to?(type)
+        public_send(type, step)
+      end
+
+      def receive(step)
+        expected = step.fetch("data")
+        received = client.receive
+        receive_matches?(expected, received)
+      rescue ThreadError
+        raise NoMessageError, "Expected to receive #{expected} but nothing has been received"
+      end
+
+      def send(step)
+        data = step.fetch("data")
+        data = JSON.generate(data) if data.is_a?(Hash)
+        client.send(data)
+      end
+
+      def wait_all(_step)
+        task.global_holder.wait_all
+      end
+
+      def to_proc
+        proc { |step| handle_step(step) }
+      end
+
+      private
+
+      attr_reader :client, :task
+
+      def build_client(**options)
+        Client.new(**options)
+      end
+
+      def receive_matches?(expected, received)
+        received = JSON.parse(received) if expected.is_a?(Hash)
+
+        raise UnmatchedExpectationError, prepare_receive_error(expected, received) if
+          received != expected
+      end
+
+      def prepare_receive_error(expected, received)
+        <<~MSG
+          Action failed: #receive
+             -- expected: #{expected}
+             ++ got: #{received}
+        MSG
+      end
+    end
+  end
+end

data/lib/wsdirector/result.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module WSDirector
+  # Handle results from all clients from the group
+  class Result
+    attr_reader :group, :errors
+
+    def initialize(group)
+      @group = group
+      @errors = Concurrent::Array.new
+
+      @all = Concurrent::AtomicFixnum.new(0)
+      @failures = Concurrent::AtomicFixnum.new(0)
+    end
+
+    # Called when client successfully finished it's work
+    def succeed
+      all.increment
+    end
+
+    # Called when client failed
+    def failed(error_message)
+      errors << error_message
+      all.increment
+      failures.increment
+    end
+
+    def success?
+      failures.value.zero?
+    end
+
+    def total_count
+      all.value
+    end
+
+    def failures_count
+      failures.value
+    end
+
+    private
+
+    attr_reader :all, :success, :failures
+  end
+end

data/lib/wsdirector/results_holder.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "wsdirector/printer"
+
+module WSDirector
+  # Holds all results for all groups of clients
+  class ResultsHolder
+    def initialize
+      @groups = Concurrent::Map.new
+    end
+
+    def success?
+      @groups.values.all?(&:success?)
+    end
+
+    def print_summary
+      single_group = groups.size == 1
+      groups.each do |group, result|
+        color = result.success? ? :green : :red
+        prefix = single_group ? "" : "Group #{group}: "
+        Printer.out(
+          "#{prefix}#{result.total_count} clients, #{result.failures_count} failures\n",
+          color
+        )
+
+        unless result.success?
+          print_errors(result.errors)
+          Printer.out "\n"
+        end
+      end
+    end
+
+    def <<(result)
+      groups[result.group] = result
+    end
+
+    private
+
+    attr_reader :groups
+
+    def print_errors(errors)
+      Printer.out "\n"
+      errors.each.with_index do |error, i|
+        Printer.out "#{i + 1}) #{error}\n", :red
+      end
+    end
+  end
+end

data/lib/wsdirector/runner.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "wsdirector/clients_holder"
+require "wsdirector/results_holder"
+require "wsdirector/result"
+require "wsdirector/task"
+require "wsdirector/ext/deep_dup"
+
+module WSDirector
+  # Initiates all clients as a separate tasks (=threads)
+  class Runner
+    using WSDirector::Ext::DeepDup
+
+    def initialize(scenario)
+      @scenario = scenario
+      @total_count = scenario["total"]
+      @global_holder = ClientsHolder.new(total_count)
+      @results_holder = ResultsHolder.new
+    end
+
+    def start
+      Thread.abort_on_exception = true
+
+      tasks = scenario["clients"].flat_map do |client|
+        result = Result.new(client.fetch("name"))
+        results_holder << result
+
+        Array.new(client.fetch("multiplier")) do
+          Thread.new do
+            Task.new(client.deep_dup, global_holder: global_holder, result: result)
+                .run
+          end
+        end
+      end
+
+      tasks.each(&:join)
+      results_holder.print_summary
+      results_holder.success?
+    end
+
+    private
+
+    attr_reader :scenario, :total_count, :global_holder, :results_holder
+  end
+end

data/lib/wsdirector/scenario_reader.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module WSDirector
+  # Read and parse YAML scenario
+  class ScenarioReader
+    MULTIPLIER_FORMAT = /^[-+*\\\d ]+$/
+
+    class << self
+      def parse(file_path)
+        contents = YAML.load_file(file_path)
+
+        if contents.first.key?("client")
+          parse_multiple_scenarios(contents)
+        else
+          { "total" => 1, "clients" => [parse_simple_scenario(contents)] }
+        end
+      end
+
+      private
+
+      def handle_steps(steps)
+        steps.flat_map do |step|
+          if step.is_a?(Hash)
+            type, data = step.to_a.first
+            multiplier = parse_multiplier(data.delete("multiplier") || "1")
+            Array.new(multiplier) { { "type" => type }.merge(data) }
+          else
+            { "type" => step }
+          end
+        end
+      end
+
+      def parse_simple_scenario(
+          steps,
+          multiplier: 1, name: "default", ignore: nil, protocol: "base"
+      )
+        {
+          "multiplier" => multiplier,
+          "steps" => handle_steps(steps),
+          "name" => name,
+          "ignore" => ignore,
+          "protocol" => protocol
+        }
+      end
+
+      def parse_multiple_scenarios(definitions)
+        total_count = 0
+        clients = definitions.map.with_index do |client, i|
+          _, client = client.to_a.first
+          multiplier = parse_multiplier(client.delete("multiplier") || "1")
+          name = client.delete("name") || (i + 1).to_s
+          total_count += multiplier
+          ignore = parse_ingore(client.fetch("ignore", nil))
+          parse_simple_scenario(
+            client.fetch("actions", []),
+            multiplier: multiplier,
+            name: name,
+            ignore: ignore,
+            protocol: client.fetch("protocol", "base")
+          )
+        end
+        { "total" => total_count, "clients" => clients }
+      end
+
+      def parse_multiplier(str)
+        prepared = str.to_s.gsub(":scale", WSDirector.config.scale.to_s)
+        raise WSDirector::Error, "Unknown multiplier format: #{str}" unless
+          prepared =~ MULTIPLIER_FORMAT
+
+        eval(prepared) # rubocop:disable Security/Eval
+      end
+
+      def parse_ingore(str)
+        return unless str
+
+        Array(str)
+      end
+    end
+  end
+end

data/lib/wsdirector/task.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "wsdirector/client"
+require "wsdirector/protocols"
+
+module WSDirector
+  # Single client operator
+  class Task
+    attr_reader :global_holder, :client
+
+    def initialize(config, global_holder:, result:)
+      @ignore = config.fetch("ignore")
+      @steps = config.fetch("steps")
+      @global_holder = global_holder
+      @result = result
+
+      protocol_class = Protocols.get(config.fetch("protocol", "base"))
+      @protocol = protocol_class.new(self)
+    end
+
+    def run
+      connect!
+
+      steps.each(&protocol)
+
+      result.succeed
+    rescue Error => e
+      result.failed(e.message)
+    end
+
+    private
+
+    attr_reader :steps, :result, :protocol
+
+    def connect!
+      protocol.init_client(ignore: @ignore)
+    end
+  end
+end

data/lib/wsdirector/version.rb

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

metadata

@@ -0,0 +1,237 @@
+--- !ruby/object:Gem::Specification
+name: wsdirector-cli
+version: !ruby/object:Gem::Version
+  version: 0.2.1
+platform: ruby
+authors:
+- Kirill Arkhipov
+- Grandman
+- palkan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-11-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: websocket-client-simple
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.5
+- !ruby/object:Gem::Dependency
+  name: colorize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: websocket-eventmachine-server
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.1
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: litecable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+- !ruby/object:Gem::Dependency
+  name: puma
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.6'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.9'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.50'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.50'
+description: Command line tool for testing websocket servers using scenarios.
+email:
+- kirillvs@mail.ru
+- root@grandman73.ru
+- dementiev.vm@gmail.com
+executables:
+- wsdirector
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- bin/wsdirector
+- lib/wsdirector.rb
+- lib/wsdirector/cli.rb
+- lib/wsdirector/client.rb
+- lib/wsdirector/clients_holder.rb
+- lib/wsdirector/configuration.rb
+- lib/wsdirector/ext/deep_dup.rb
+- lib/wsdirector/printer.rb
+- lib/wsdirector/protocols.rb
+- lib/wsdirector/protocols/action_cable.rb
+- lib/wsdirector/protocols/base.rb
+- lib/wsdirector/result.rb
+- lib/wsdirector/results_holder.rb
+- lib/wsdirector/runner.rb
+- lib/wsdirector/scenario_reader.rb
+- lib/wsdirector/task.rb
+- lib/wsdirector/version.rb
+homepage: https://github.com/palkan/wsdirector
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.13
+signing_key: 
+specification_version: 4
+summary: Command line tool for testing websocket servers using scenarios.
+test_files: []