toxiproxy 0.1.3 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: c4abc83dd0b261de59236fbfe5a2e3a0660ca2b0
-  data.tar.gz: 67d9083dd5672fd70cf53365b5d550d86edfca82
+SHA256:
+  metadata.gz: 87ada93994d565f7179ecf9b542e20d98c0e8d0a147ebb96ad9a6db91a1af343
+  data.tar.gz: 2f4a626ed0b4db30f596963485749b22a754695bea9d94de3ee872f233eaae1d
 SHA512:
-  metadata.gz: f0cd49f6f4b93c88a532ca43087a8c54a46907210ccf5693d970b3f8edbdf73a6a5efc550623a8e9ac9fe02be8a59c5790403fc59a52f662907c1a11aa8aa752
-  data.tar.gz: d6dd0670c4505efdf609e41e8938053a6318595ea8176a89724d5e768156ec9f03d5e8043442dd952af83f3f42a54ec110dd6cd3754a7035b9c161719578a1f2
+  metadata.gz: e95bfdfa0351fad12ea9b5baf9020ec34bb1948e3d1d97afa9dcc1fc231d15520b1b937a493a7e3a87bdb4ec8e7f42234e22f5318c8fc564ceb7dd8bc7609348
+  data.tar.gz: 944defb2bfee5378844b38a51400164be70f0ee39806d6f5cded3585ddd61ac6f4bb75229786f948bd5b3afc35a437d09c326575f0ac4e89f24a7f880f2badc9

data/.github/probots.yml

@@ -0,0 +1,2 @@
+enabled:
+  - cla

data/.github/workflows/ci.yml

@@ -0,0 +1,19 @@
+name: Run tests
+on: [push]
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        ruby: [ '2.5', '2.6', '2.7' ]
+    name: Ruby ${{ matrix.ruby }}
+    steps:
+      - uses: actions/checkout@v2
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+          bundler-cache: true # runs 'bundle install' and caches installed gems automatically
+      - name: Install and start toxiproxy
+        run: ./bin/start-toxiproxy.sh
+      - name: Run tests
+        run: bundle exec rake test

data/README.md

@@ -1,5 +1,8 @@
 # toxiproxy-ruby
 
+`toxiproxy-ruby` `1.x` (latest) is compatible with the Toxiproxy `2.x` series.
+`toxiproxy-ruby` `0.x` is compatible with the Toxiproxy `1.x` series.
+
 [Toxiproxy](https://github.com/shopify/toxiproxy) is a proxy to simulate network
 and system conditions. The Ruby API aims to make it simple to write tests that
 ensure your application behaves appropriately under harsh conditions. Before you
@@ -17,14 +20,19 @@ documentation](https://github.com/shopify/toxiproxy)
 
 ## Usage
 
-The Ruby client communicates with the Toxiproxy daemon via HTTP.
+The Ruby client communicates with the Toxiproxy daemon via HTTP. By default it
+connects to `http://127.0.0.1:8474`, but you can point to any host:
+
+```ruby
+Toxiproxy.host = 'http://toxiproxy.local:5665'
+```
 
 For example, to simulate 1000ms latency on a database server you can use the
 `latency` toxic with the `latency` argument (see the Toxiproxy project for a
 list of all toxics):
 
 ```ruby
-Toxiproxy[:mysql_master].downstream(:latency, latency: 1000).apply do
+Toxiproxy[:mysql_master].toxic(:latency, latency: 1000).apply do
   Shop.first # this took at least 1s
 end
 ```
@@ -55,7 +63,8 @@ Toxiproxy[:cache].upstream(:latency, latency: 1000).apply do
 end
 ```
 
-You can apply many toxics to many connections:
+By default the toxic is applied to the downstream connection, you can be
+explicit and chain them:
 
 ```ruby
 Toxiproxy[/redis/].upstream(:slow_close, delay: 100).downstream(:latency, jitter: 300).apply do
@@ -79,10 +88,15 @@ Toxiproxy.populate([{
   name: "mysql_read_only",
   listen: "localhost:21213",
   upstream: "localhost:3306",
-})
+}])
 ```
 
 This will create the proxies passed, or replace the proxies if they already exist in Toxiproxy.
 It's recommended to do this early as early in boot as possible, see the
-[Toxiproxy README](https://github.com/shopify/toxiproxy#Usage). If you have many
-proxies, we recommend storing the Toxiproxy configs in a configuration file.
+[Toxiproxy README](https://github.com/shopify/toxiproxy#usage). If you have many
+proxies, we recommend storing the Toxiproxy configs in a configuration file and
+deserializing it into `Toxiproxy.populate`.
+
+If you're doing this in Rails, you may have to do this in `config/boot.rb` (as
+early in boot as possible) as older versions of `ActiveRecord` establish a
+database connection as soon as it's loaded.

data/bin/start-toxiproxy.sh

@@ -1,8 +1,17 @@
 #!/bin/bash -e
 
-VERSION='21a264cc75549c3ae837b606eb6e17ea'
+VERSION='v2.1.0'
+TOXIPROXY_LOG_DIR=${CIRCLE_ARTIFACTS:-'/tmp'}
+
+if [[ "$OSTYPE" == "linux"* ]]; then
+    DOWNLOAD_TYPE="linux-amd64"
+elif [[ "$OSTYPE" == "darwin"* ]]; then
+    DOWNLOAD_TYPE="darwin-amd64"
+fi
+
+echo "[dowload toxiproxy for $DOWNLOAD_TYPE]"
+curl --silent -L https://github.com/Shopify/toxiproxy/releases/download/$VERSION/toxiproxy-server-$DOWNLOAD_TYPE -o ./bin/toxiproxy-server
 
 echo "[start toxiproxy]"
-curl --silent http://shopify-vagrant.s3.amazonaws.com/toxiproxy/toxiproxy-$VERSION -o ./bin/toxiproxy
-chmod +x ./bin/toxiproxy
-nohup bash -c "./bin/toxiproxy > ${CIRCLE_ARTIFACTS}/toxiproxy.log 2>&1 &"
+chmod +x ./bin/toxiproxy-server
+nohup bash -c "./bin/toxiproxy-server > ${TOXIPROXY_LOG_DIR}/toxiproxy.log 2>&1 &"

data/lib/toxiproxy.rb

@@ -1,13 +1,16 @@
 require "json"
 require "uri"
 require "net/http"
+require "forwardable"
 
-require "toxiproxy/collection"
 require "toxiproxy/toxic"
 require "toxiproxy/toxic_collection"
+require "toxiproxy/proxy_collection"
 
 class Toxiproxy
-  URI = ::URI.parse("http://127.0.0.1:8474")
+  extend SingleForwardable
+
+  DEFAULT_URI = 'http://127.0.0.1:8474'
   VALID_DIRECTIONS = [:upstream, :downstream]
 
   class NotFound < StandardError; end
@@ -23,29 +26,31 @@ class Toxiproxy
     @enabled  = options[:enabled]
   end
 
-  # Forwardable doesn't support delegating class methods, so we resort to
-  # `define_method` to delegate from Toxiproxy to #all, and from there to the
-  # proxy collection.
-  class << self
-    Collection::METHODS.each do |method|
-      define_method(method) do |*args, &block|
-        self.all.send(method, *args, &block)
-      end
-    end
-  end
+  def_delegators :all, *ProxyCollection::METHODS
 
   # Re-enables all proxies and disables all toxics.
   def self.reset
-    request = Net::HTTP::Get.new("/reset")
-    response = http.request(request)
+    request = Net::HTTP::Post.new("/reset")
+    request["Content-Type"] = "application/json"
+
+    response = http_request(request)
     assert_response(response)
     self
   end
 
+  def self.version
+    return false unless running?
+
+    request = Net::HTTP::Get.new("/version")
+    response = http_request(request)
+    assert_response(response)
+    response.body
+  end
+
   # Returns a collection of all currently active Toxiproxies.
   def self.all
     request = Net::HTTP::Get.new("/proxies")
-    response = http.request(request)
+    response = http_request(request)
     assert_response(response)
 
     proxies = JSON.parse(response.body).map { |name, attrs|
@@ -57,7 +62,12 @@ class Toxiproxy
       })
     }
 
-    Collection.new(proxies)
+    ProxyCollection.new(proxies)
+  end
+
+  # Sets the toxiproxy host to use.
+  def self.host=(host)
+    @uri = host.is_a?(::URI) ? host : ::URI.parse(host)
   end
 
   # Convenience method to create a proxy.
@@ -88,59 +98,69 @@ class Toxiproxy
   def self.populate(*proxies)
     proxies = proxies.first if proxies.first.is_a?(Array)
 
-    proxies.map { |proxy|
-      existing = find_by_name(proxy[:name])
-      if existing && (existing.upstream != proxy[:upstream] || existing.listen != proxy[:listen])
-        existing.destroy
-        existing = false
-      end
-      self.create(proxy) unless existing
-    }.compact
+    request = Net::HTTP::Post.new("/populate")
+    request.body = proxies.to_json
+    request["Content-Type"] = "application/json"
+
+    response = http_request(request)
+    assert_response(response)
+
+    proxies = JSON.parse(response.body).fetch('proxies', []).map do |attrs|
+      self.new({
+        upstream: attrs["upstream"],
+        listen: attrs["listen"],
+        name: attrs["name"],
+        enabled: attrs["enabled"]
+      })
+    end
+
+    ProxyCollection.new(proxies)
   end
 
   def self.running?
-    TCPSocket.new(URI.host, URI.port).close
+    TCPSocket.new(uri.host, uri.port).close
     true
   rescue Errno::ECONNREFUSED, Errno::ECONNRESET
     false
   end
 
   # Set an upstream toxic.
-  def upstream(toxic = nil, attrs = {})
-    return @upstream unless toxic
+  def upstream(type = nil, attrs = {})
+    return @upstream unless type # also alias for the upstream endpoint
 
     collection = ToxicCollection.new([self])
-    collection.upstream(toxic, attrs)
+    collection.upstream(type, attrs)
     collection
   end
 
   # Set a downstream toxic.
-  def downstream(toxic, attrs = {})
+  def downstream(type, attrs = {})
     collection = ToxicCollection.new([self])
-    collection.downstream(toxic, attrs)
+    collection.downstream(type, attrs)
     collection
   end
+  alias_method :toxic, :downstream
+  alias_method :toxicate, :downstream
 
   # Simulates the endpoint is down, by closing the connection and no
   # longer accepting connections. This is useful to simulate critical system
   # failure, such as a data store becoming completely unavailable.
   def down(&block)
     disable
-    begin
-      yield
-    ensure
-      enable
-    end
+    yield
+  ensure
+    enable
   end
 
   # Disables a Toxiproxy. This will drop all active connections and stop the proxy from listening.
   def disable
     request = Net::HTTP::Post.new("/proxies/#{name}")
+    request["Content-Type"] = "application/json"
 
     hash = {enabled: false}
     request.body = hash.to_json
 
-    response = http.request(request)
+    response = http_request(request)
     assert_response(response)
     self
   end
@@ -148,11 +168,12 @@ class Toxiproxy
   # Enables a Toxiproxy. This will cause the proxy to start listening again.
   def enable
     request = Net::HTTP::Post.new("/proxies/#{name}")
+    request["Content-Type"] = "application/json"
 
     hash = {enabled: true}
     request.body = hash.to_json
 
-    response = http.request(request)
+    response = http_request(request)
     assert_response(response)
     self
   end
@@ -162,11 +183,12 @@ class Toxiproxy
   # of this connection.
   def create
     request = Net::HTTP::Post.new("/proxies")
+    request["Content-Type"] = "application/json"
 
     hash = {upstream: upstream, name: name, listen: listen, enabled: enabled}
     request.body = hash.to_json
 
-    response = http.request(request)
+    response = http_request(request)
     assert_response(response)
 
     new = JSON.parse(response.body)
@@ -178,37 +200,54 @@ class Toxiproxy
   # Destroys a Toxiproxy.
   def destroy
     request = Net::HTTP::Delete.new("/proxies/#{name}")
-    response = http.request(request)
+    response = http_request(request)
     assert_response(response)
     self
   end
 
-  # Returns a collection of the current toxics for a direction.
-  def toxics(direction)
-    unless VALID_DIRECTIONS.include?(direction.to_sym)
-      raise InvalidToxic, "Toxic direction must be one of: [#{VALID_DIRECTIONS.join(', ')}], got: #{direction}"
-    end
-
-    request = Net::HTTP::Get.new("/proxies/#{name}/#{direction}/toxics")
-    response = http.request(request)
+  # Returns an array of the current toxics for a direction.
+  def toxics
+    request = Net::HTTP::Get.new("/proxies/#{name}/toxics")
+    response = http_request(request)
     assert_response(response)
 
-    toxics = JSON.parse(response.body).map { |name, attrs|
-      Toxic.new({
-        name: name,
+    JSON.parse(response.body).map { |attrs|
+      Toxic.new(
+        type: attrs['type'],
+        name: attrs['name'],
         proxy: self,
-        direction: direction,
-        attrs: attrs
-      })
+        stream: attrs['stream'],
+        toxicity: attrs['toxicity'],
+        attributes: attrs['attributes'],
+      )
     }
-
-    toxics
   end
 
   private
 
+  def self.http_request(request)
+    ensure_webmock_whitelists_toxiproxy if defined? WebMock
+    http.request(request)
+  end
+
+  def http_request(request)
+    self.class.http_request(request)
+  end
+
+  def self.ensure_webmock_whitelists_toxiproxy
+    endpoint = "#{uri.host}:#{uri.port}"
+    WebMock::Config.instance.allow ||= []
+    unless WebMock::Config.instance.allow.include?(endpoint)
+      WebMock::Config.instance.allow << endpoint
+    end
+  end
+
+  def self.uri
+    @uri ||= ::URI.parse(DEFAULT_URI)
+  end
+
   def self.http
-    @http ||= Net::HTTP.new(URI.host, URI.port)
+    @http ||= Net::HTTP.new(uri.host, uri.port)
   end
 
   def http

data/lib/toxiproxy/{collection.rb → proxy_collection.rb}

@@ -1,5 +1,3 @@
-require "forwardable"
-
 class Toxiproxy
   # ProxyCollection represents a set of proxies. This allows to easily perform
   # actions on every proxy in the collection.
@@ -9,7 +7,7 @@ class Toxiproxy
   # Collection instead of an Array (see MRI). Instead, we delegate methods where
   # it doesn't matter and only allow the filtering methods that really make
   # sense on a proxy collection.
-  class Collection
+  class ProxyCollection
     extend Forwardable
 
     DELEGATED_METHODS = [:length, :size, :count, :find, :each, :map]
@@ -47,13 +45,13 @@ class Toxiproxy
       toxics.downstream(toxic, attrs)
       toxics
     end
+    alias_method :toxicate, :downstream
+    alias_method :toxic, :downstream
 
-    # Disables all proxies in the collection.
     def disable
       @collection.each(&:disable)
     end
 
-    # Enables all proxies in the collection.
     def enable
       @collection.each(&:enable)
     end

data/lib/toxiproxy/toxic.rb

@@ -1,51 +1,49 @@
 class Toxiproxy
   class Toxic
-    attr_reader :name, :proxy, :direction
-    attr_reader :attrs
-
-    def initialize(options)
-      @proxy     = options[:proxy]
-      @name      = options[:name]
-      @direction = options[:direction]
-      @attrs     = options[:attrs] || {}
+    attr_reader :name, :type, :stream, :proxy
+    attr_accessor :attributes, :toxicity
+
+    def initialize(attrs)
+      raise "Toxic type is required" unless attrs[:type]
+      @type = attrs[:type]
+      @stream = attrs[:stream] || 'downstream'
+      @name = attrs[:name] || "#{@type}_#{@stream}"
+      @proxy = attrs[:proxy]
+      @toxicity = attrs[:toxicity] || 1.0
+      @attributes = attrs[:attributes] || {}
     end
 
-    def enabled?
-      attrs['enabled']
-    end
+    def save
+      request = Net::HTTP::Post.new("/proxies/#{proxy.name}/toxics")
+      request["Content-Type"] = "application/json"
 
-    def enable
-      attrs['enabled'] = true
-      save
-    end
+      request.body = as_json
 
-    def disable
-      attrs['enabled'] = false
-      save
-    end
+      response = Toxiproxy.http_request(request)
+      Toxiproxy.assert_response(response)
 
-    def [](name)
-      attrs[name]
-    end
+      json = JSON.parse(response.body)
+      @attributes = json['attributes']
+      @toxicity = json['toxicity']
 
-    def []=(name, value)
-      attrs[name] = value
+      self
     end
 
-    def save
-      unless VALID_DIRECTIONS.include?(direction.to_sym)
-        raise InvalidToxic, "Toxic direction must be one of: [#{VALID_DIRECTIONS.join(', ')}], got: #{direction}"
-      end
-      request = Net::HTTP::Post.new("/proxies/#{proxy.name}/#{direction}/toxics/#{name}")
-
-      request.body = attrs.to_json
-
-      response = Toxiproxy.http.request(request)
+    def destroy
+      request = Net::HTTP::Delete.new("/proxies/#{proxy.name}/toxics/#{name}")
+      response = Toxiproxy.http_request(request)
       Toxiproxy.assert_response(response)
-
-      @attrs = JSON.parse(response.body)
-
       self
     end
+
+    def as_json
+      {
+        name: name,
+        type: type,
+        stream: stream,
+        toxicity: toxicity,
+        attributes: attributes,
+      }.to_json
+    end
   end
 end

data/lib/toxiproxy/toxic_collection.rb

@@ -13,34 +13,48 @@ class Toxiproxy
     end
 
     def apply(&block)
-      @toxics.each(&:enable)
-      yield
-    ensure
-      @toxics.each(&:disable)
+      names = toxics.group_by { |t| [t.name, t.proxy.name] }
+      dups  = names.values.select { |toxics| toxics.length > 1 }
+      if !dups.empty?
+        raise ArgumentError, "There are two toxics with the name #{dups.first[0]} for proxy #{dups.first[1]}, please override the default name (<type>_<direction>)"
+      end
+
+      begin
+        @toxics.each(&:save)
+        yield
+      ensure
+        @toxics.each(&:destroy)
+      end
     end
 
-    def upstream(toxic_name, attrs = {})
+    def upstream(type, attrs = {})
       proxies.each do |proxy|
         toxics << Toxic.new(
-          name: toxic_name,
+          name: attrs.delete('name') || attrs.delete(:name),
+          type: type,
           proxy: proxy,
-          direction: :upstream,
-          attrs: attrs
+          stream: :upstream,
+          toxicity: attrs.delete('toxicitiy') || attrs.delete(:toxicity),
+          attributes: attrs
         )
       end
       self
     end
 
-    def downstream(toxic_name, attrs = {})
+    def downstream(type, attrs = {})
       proxies.each do |proxy|
         toxics << Toxic.new(
-          name: toxic_name,
+          name: attrs.delete('name') || attrs.delete(:name),
+          type: type,
           proxy: proxy,
-          direction: :downstream,
-          attrs: attrs
+          stream: :downstream,
+          toxicity: attrs.delete('toxicitiy') || attrs.delete(:toxicity),
+          attributes: attrs
         )
       end
       self
     end
+    alias_method :toxic, :downstream
+    alias_method :toxicate, :downstream
   end
 end

data/lib/toxiproxy/version.rb

@@ -1,3 +1,3 @@
 class Toxiproxy
-  VERSION = "0.1.3"
+  VERSION = "2.0.0"
 end

data/test/test_helper.rb

@@ -1,2 +1,4 @@
 require 'minitest/autorun'
 require_relative "../lib/toxiproxy"
+require 'webmock/minitest'
+WebMock.disable!

data/test/toxiproxy_test.rb

@@ -24,27 +24,47 @@ class ToxiproxyTest < MiniTest::Unit::TestCase
     assert_equal "test_mysql_master", proxy.name
   end
 
-  def test_enable_and_disable_proxy
+  def test_proxy_not_running_with_bad_host
+    Toxiproxy.host = 'http://0.0.0.0:12345'
+    assert !Toxiproxy.running?, 'toxiproxy should not be running'
+  ensure
+    Toxiproxy.host = Toxiproxy::DEFAULT_URI
+  end
+
+  def test_enable_and_disable_proxy_with_toxic
     with_tcpserver do |port|
       proxy = Toxiproxy.create(upstream: "localhost:#{port}", name: "test_rubby_server")
       listen_addr = proxy.listen
 
-      Toxiproxy::Toxic.new(
-        name: 'latency',
-        proxy: proxy,
-        direction: :upstream,
-        attrs: {'latency' => 123}
-      ).enable
+      Toxiproxy::Toxic.new(type: 'latency', attributes: { latency: 123 }, proxy: proxy).save
 
       proxy.disable
       assert_proxy_unavailable proxy
       proxy.enable
       assert_proxy_available proxy
 
-      latency = proxy.toxics(:upstream).find { |toxic| toxic.name == 'latency' }
-      assert_equal 123, latency['latency']
-      assert latency.enabled?
+      latency = proxy.toxics.find { |toxic| toxic.name == 'latency_downstream' }
 
+      assert_equal 123, latency.attributes['latency']
+      assert_equal listen_addr, proxy.listen
+    end
+  end
+
+  def test_delete_toxic
+    with_tcpserver do |port|
+      proxy = Toxiproxy.create(upstream: "localhost:#{port}", name: "test_rubby_server")
+      listen_addr = proxy.listen
+
+      latency = Toxiproxy::Toxic.new(type: 'latency', attributes: { latency: 123 }, proxy: proxy).save
+
+      assert_proxy_available proxy
+
+      latency = proxy.toxics.find { |toxic| toxic.name == 'latency_downstream' }
+      assert_equal 123, latency.attributes['latency']
+
+      latency.destroy
+
+      assert proxy.toxics.empty?
       assert_equal listen_addr, proxy.listen
     end
   end
@@ -57,20 +77,12 @@ class ToxiproxyTest < MiniTest::Unit::TestCase
       proxy.disable
       assert_proxy_unavailable proxy
 
-      Toxiproxy::Toxic.new(
-        name: 'latency',
-        proxy: proxy,
-        direction: :upstream,
-        attrs: {'latency' => 125}
-      ).enable
+      Toxiproxy::Toxic.new(type: 'latency', attributes: { latency: 123 }, proxy: proxy).save
 
       Toxiproxy.reset
       assert_proxy_available proxy
 
-      latency = proxy.toxics(:upstream).find { |toxic| toxic.name == 'latency' }
-      assert_equal 125, latency['latency']
-      assert !latency.enabled?
-
+      assert proxy.toxics.empty?
       assert_equal listen_addr, proxy.listen
     end
   end
@@ -97,7 +109,7 @@ class ToxiproxyTest < MiniTest::Unit::TestCase
   end
 
   def test_proxies_all_returns_proxy_collection
-    assert_instance_of Toxiproxy::Collection, Toxiproxy.all
+    assert_instance_of Toxiproxy::ProxyCollection, Toxiproxy.all
   end
 
   def test_down_on_proxy_collection_disables_entire_collection
@@ -147,7 +159,7 @@ class ToxiproxyTest < MiniTest::Unit::TestCase
       proxies = Toxiproxy.select { |p| p.upstream == "localhost:#{port}" }
 
       assert_equal 1, proxies.size
-      assert_instance_of Toxiproxy::Collection, proxies
+      assert_instance_of Toxiproxy::ProxyCollection, proxies
     end
   end
 
@@ -158,7 +170,7 @@ class ToxiproxyTest < MiniTest::Unit::TestCase
       proxies = Toxiproxy.grep(/\Atest/)
 
       assert_equal 1, proxies.size
-      assert_instance_of Toxiproxy::Collection, proxies
+      assert_instance_of Toxiproxy::ProxyCollection, proxies
     end
   end
 
@@ -169,7 +181,7 @@ class ToxiproxyTest < MiniTest::Unit::TestCase
       proxies = Toxiproxy[/\Atest/]
 
       assert_equal 1, proxies.size
-      assert_instance_of Toxiproxy::Collection, proxies
+      assert_instance_of Toxiproxy::ProxyCollection, proxies
     end
   end
 
@@ -211,6 +223,24 @@ class ToxiproxyTest < MiniTest::Unit::TestCase
     end
   end
 
+  def test_toxic_applies_a_downstream_toxic
+    with_tcpserver(receive: true) do |port|
+      proxy = Toxiproxy.create(upstream: "localhost:#{port}", name: "test_proxy")
+
+      proxy.toxic(:latency, latency: 100).apply do
+        latency = proxy.toxics.find { |toxic| toxic.name == 'latency_downstream' }
+
+        assert_equal 100, latency.attributes['latency']
+        assert_equal 'downstream', latency.stream
+      end
+    end
+  end
+
+  def test_toxic_default_name_is_type_and_stream
+    toxic = Toxiproxy::Toxic.new(type: "latency", stream: "downstream")
+    assert_equal "latency_downstream", toxic.name
+  end
+
   def test_apply_prolong_toxics
     with_tcpserver(receive: true) do |port|
       proxy = Toxiproxy.create(upstream: "localhost:#{port}", name: "test_proxy")
@@ -328,34 +358,112 @@ class ToxiproxyTest < MiniTest::Unit::TestCase
   end
 
   def test_populate_creates_proxies_update_upstream
-    proxies = [{
-        name: "test_toxiproxy_populate1",
+    proxy_name = "test_toxiproxy_populate1"
+    proxies_config = [{
+        name: proxy_name,
         upstream: "localhost:3306",
         listen: "localhost:22222",
       },
     ]
 
-    proxies = Toxiproxy.populate(proxies)
+    proxies = Toxiproxy.populate(proxies_config)
 
-    proxies = [{
-        name: "test_toxiproxy_populate1",
+    proxies_config = [{
+        name: proxy_name,
         upstream: "localhost:3307",
         listen: "localhost:22222",
       },
     ]
 
-    proxies2 = Toxiproxy.populate(proxies)
+    proxies2 = Toxiproxy.populate(proxies_config)
 
-    assert_equal proxies.first[:upstream], proxies2.first.upstream
-    assert_proxy_available(proxies2.first)
+    refute_equal proxies.find(name: proxy_name).first.upstream,
+      proxies2.find(name: proxy_name).first.upstream
+
+    proxies2.each do |proxy|
+      assert_proxy_available(proxy)
+    end
   end
 
   def test_running_helper
     assert_equal true, Toxiproxy.running?
   end
 
+  def test_version
+    assert_instance_of String, Toxiproxy.version
+  end
+
+  def test_multiple_of_same_toxic_type
+    with_tcpserver(receive: true) do |port|
+      proxy = Toxiproxy.create(upstream: "localhost:#{port}", name: "test_proxy")
+      proxy.toxic(:latency, latency: 100).toxic(:latency, latency: 100, name: "second_latency_downstream").apply do
+        before = Time.now
+
+        socket = connect_to_proxy(proxy)
+        socket.write("omg\n")
+        socket.flush
+        socket.gets
+
+        passed = Time.now - before
+
+        assert_in_delta passed, 0.200, 0.01
+      end
+    end
+  end
+
+  def test_multiple_of_same_toxic_type_with_same_name
+    with_tcpserver(receive: true) do |port|
+      proxy = Toxiproxy.create(upstream: "localhost:#{port}", name: "test_proxy")
+
+      assert_raises ArgumentError do
+        proxy.toxic(:latency, latency: 100).toxic(:latency, latency: 100).apply { }
+      end
+    end
+  end
+
+  def test_invalid_direction
+    with_tcpserver(receive: true) do |port|
+      proxy = Toxiproxy.create(upstream: "localhost:#{port}", name: "test_rubby_server")
+
+      assert_raises Toxiproxy::InvalidToxic do
+        Toxiproxy::Toxic.new(type: 'latency', attributes: { latency: 123 }, proxy: proxy, stream: 'lolstream').save
+      end
+    end
+  end
+
+  def test_whitelists_webmock_when_allow_is_nil
+    with_webmock_enabled do
+      WebMock::Config.instance.allow = nil
+      Toxiproxy.version # This should initialize the list.
+      assert WebMock::Config.instance.allow.include?(@endpoint)
+    end
+  end
+
+  def test_whitelisting_webmock_does_not_override_other_configuration
+    with_webmock_enabled do
+      WebMock::Config.instance.allow = ['some-other-host']
+      Toxiproxy.version
+      # 'some-other-host' should not be overriden.
+      assert WebMock::Config.instance.allow.include?('some-other-host')
+      assert WebMock::Config.instance.allow.include?(@endpoint)
+
+      Toxiproxy.version
+      # Endpoint should not be duplicated.
+      assert_equal 1, WebMock::Config.instance.allow.count(@endpoint)
+    end
+  end
+
   private
 
+  def with_webmock_enabled
+    WebMock.enable!
+    WebMock.disable_net_connect!
+    @endpoint = "#{Toxiproxy.uri.host}:#{Toxiproxy.uri.port}"
+    yield
+  ensure
+    WebMock.disable!
+  end
+
   def assert_proxy_available(proxy)
     connect_to_proxy proxy
   end

data/toxiproxy.gemspec

@@ -10,11 +10,14 @@ Gem::Specification.new do |spec|
   spec.homepage = "https://github.com/Shopify/toxiproxy"
   spec.license = "MIT"
 
+  spec.metadata['allowed_push_host'] = 'https://rubygems.org'
+
   spec.files = `git ls-files`.split("\n")
   spec.test_files = `git ls-files -- {test,spec,features}/*`.split("\n")
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "bundler"
   spec.add_development_dependency "minitest"
   spec.add_development_dependency "rake"
+  spec.add_development_dependency "webmock"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: toxiproxy
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 2.0.0
 platform: ruby
 authors:
 - Simon Eskildsen
@@ -9,22 +9,22 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-02 00:00:00.000000000 Z
+date: 2020-10-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -53,21 +53,36 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  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'
 description: A Ruby library for controlling Toxiproxy. Can be used in resiliency testing.
 email: simon.eskildsen@shopify.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/probots.yml"
+- ".github/workflows/ci.yml"
 - ".gitignore"
 - Gemfile
 - LICENSE
 - README.md
 - Rakefile
 - bin/start-toxiproxy.sh
-- circle.yml
 - lib/toxiproxy.rb
-- lib/toxiproxy/collection.rb
+- lib/toxiproxy/proxy_collection.rb
 - lib/toxiproxy/toxic.rb
 - lib/toxiproxy/toxic_collection.rb
 - lib/toxiproxy/version.rb
@@ -78,7 +93,8 @@ files:
 homepage: https://github.com/Shopify/toxiproxy
 licenses:
 - MIT
-metadata: {}
+metadata:
+  allowed_push_host: https://rubygems.org
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -94,8 +110,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.2.3
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Ruby library for Toxiproxy

data/circle.yml

@@ -1,7 +0,0 @@
-dependencies:
-  override:
-    - bundle install
-    - ./bin/start-toxiproxy.sh
-test:
-  override:
-    - bundle exec rake test