toxiproxy 0.1.4 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 841ffa13a93004733dc2adfa28c71bc641ee5981
-  data.tar.gz: dbbf44472e95affc62b5143685ce50429924ce9e
+  metadata.gz: 3198b51c84d89ef6d0b26c989ee633e4def9c4e9
+  data.tar.gz: 65dd1628c34e6e4ba4ff7b387b9f1136ff66cfa1
 SHA512:
-  metadata.gz: d27b3bec80952c35dec464d1b9cc3d952651af99e209d397a80695f0bd6573749e10846785866f6bb851bd02e4a7437a88f2d27979b46a2b42e3a616a913c2dc
-  data.tar.gz: b4171531e74753276229f73163afcb44a41b0e4df88929c4746deabed8d4114c5e12060705034e3221a43d6bdc640d7d1a7018303d9f3a06ce91c5be51fdd759
+  metadata.gz: 4c91be80c0853f0ad1a8ce5b504f757a99e2b458c61e0a809da82c6918d8f796e8f51377d6580f100cde96b27b16adbf2f686befc67e2a0167c92a28b5582875
+  data.tar.gz: b44f5c8d012507b5b4321c80f3ced96f19c9d33114941c6a7ef924b858ce6596324744d2c805aa494b23d049d7119e213d0928f3c100a2f944b0b38d1bd896b4

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
@@ -29,7 +32,7 @@ For example, to simulate 1000ms latency on a database server you can use the
 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
 ```
@@ -60,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
@@ -90,4 +94,9 @@ Toxiproxy.populate([{
 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.
+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,9 +1,9 @@
 #!/bin/bash -e
 
-VERSION='21a264cc75549c3ae837b606eb6e17ea'
+VERSION='v2.0.0rc2'
 TOXIPROXY_LOG_DIR=${CIRCLE_ARTIFACTS:-'/tmp'}
 
 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 > ${TOXIPROXY_LOG_DIR}/toxiproxy.log 2>&1 &"
+curl --silent -L https://github.com/Shopify/toxiproxy/releases/download/$VERSION/toxiproxy-server-linux-amd64 -o ./bin/toxiproxy-server
+chmod +x ./bin/toxiproxy-server
+nohup bash -c "./bin/toxiproxy-server > ${TOXIPROXY_LOG_DIR}/toxiproxy.log 2>&1 &"

data/lib/toxiproxy.rb

@@ -3,9 +3,9 @@ require "uri"
 require "net/http"
 require "forwardable"
 
-require "toxiproxy/collection"
 require "toxiproxy/toxic"
 require "toxiproxy/toxic_collection"
+require "toxiproxy/proxy_collection"
 
 class Toxiproxy
   extend SingleForwardable
@@ -26,16 +26,25 @@ class Toxiproxy
     @enabled  = options[:enabled]
   end
 
-  def_delegators :all, *Collection::METHODS
+  def_delegators :all, *ProxyCollection::METHODS
 
   # Re-enables all proxies and disables all toxics.
   def self.reset
-    request = Net::HTTP::Get.new("/reset")
+    request = Net::HTTP::Post.new("/reset")
     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")
@@ -51,7 +60,7 @@ class Toxiproxy
       })
     }
 
-    Collection.new(proxies)
+    ProxyCollection.new(proxies)
   end
 
   # Sets the toxiproxy host to use.
@@ -105,20 +114,22 @@ class Toxiproxy
   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
@@ -180,26 +191,22 @@ class Toxiproxy
     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")
+  # 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

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

@@ -7,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]
@@ -45,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,48 @@
 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, :attributes, :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")
 
-    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
-
+    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.4"
+  VERSION = "1.0.0"
 end

data/test/toxiproxy_test.rb

@@ -31,27 +31,40 @@ class ToxiproxyTest < MiniTest::Unit::TestCase
     Toxiproxy.host = Toxiproxy::DEFAULT_URI
   end
 
-  def test_enable_and_disable_proxy
+  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
@@ -64,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
@@ -104,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
@@ -154,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
 
@@ -165,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
 
@@ -176,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
 
@@ -218,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")
@@ -361,6 +384,48 @@ class ToxiproxyTest < MiniTest::Unit::TestCase
     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
+
   private
 
   def assert_proxy_available(proxy)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: toxiproxy
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 1.0.0
 platform: ruby
 authors:
 - Simon Eskildsen
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-02-03 00:00:00.000000000 Z
+date: 2016-04-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -67,7 +67,7 @@ files:
 - 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