vines 0.4.5 → 0.4.6

data/test/config_test.rb

@@ -1,10 +1,8 @@
 # encoding: UTF-8
 
-require 'tmpdir'
-require 'vines'
-require 'minitest/autorun'
+require 'test_helper'
 
-class ConfigTest < MiniTest::Unit::TestCase
+describe Vines::Config do
   def test_missing_host
     assert_raises(RuntimeError) do
       Vines::Config.new do

data/test/contact_test.rb

@@ -1,88 +1,102 @@
 # encoding: UTF-8
 
-require 'vines'
-require 'ext/nokogiri'
-require 'minitest/autorun'
-
-class ContactTest < MiniTest::Unit::TestCase
-  def test_equality
-    alice  = Vines::Contact.new(:jid => 'alice@wonderland.lit')
-    alice2 = Vines::Contact.new(:jid => 'alice@wonderland.lit')
-    hatter = Vines::Contact.new(:jid => 'hatter@wonderland.lit')
-
-    assert_nil alice <=> 42
-
-    assert alice == alice2
-    assert alice.eql?(alice2)
-    assert alice.hash == alice2.hash
-
-    refute alice == hatter
-    refute alice.eql?(hatter)
-    refute alice.hash == hatter.hash
+require 'test_helper'
+
+describe Vines::Contact do
+  subject do
+    Vines::Contact.new(
+      jid: 'alice@wonderland.lit',
+      name: "Alice",
+      groups: %w[Friends Buddies],
+      subscription: 'from')
   end
 
-  def test_initialize_missing_jid_raises
-    assert_raises(ArgumentError) { Vines::Contact.new }
-    assert_raises(ArgumentError) { Vines::Contact.new(:jid => '') }
-  end
+  describe 'contact equality checks' do
+    let(:alice)  { Vines::Contact.new(jid: 'alice@wonderland.lit') }
+    let(:hatter) { Vines::Contact.new(jid: 'hatter@wonderland.lit') }
 
-  def test_initialize_domain_only_jid_does_not_raise
-    contact = Vines::Contact.new(:jid => 'tea.wonderland.lit')
-    assert_equal 'tea.wonderland.lit', contact.jid.to_s
-  end
+    it 'uses class in equality check' do
+      (subject <=> 42).must_be_nil
+    end
 
-  def test_to_roster_xml_sorts_groups
-    contact = Vines::Contact.new(
-      :jid => 'a@wonderland.lit',
-      :name => "Contact 1",
-      :groups => %w[B A])
+    it 'is equal to itself' do
+      assert subject == subject
+      assert subject.eql?(subject)
+      assert subject.hash == subject.hash
+    end
 
-    expected = %q{
-      <item jid="a@wonderland.lit" name="Contact 1" subscription="none">
-        <group>A</group>
-        <group>B</group>
-      </item>
-    }.strip.gsub(/\n/, '').gsub(/\s{2,}/, '')
+    it 'is equal to another contact with the same jid' do
+      assert subject == alice
+      assert subject.eql?(alice)
+      assert subject.hash == alice.hash
+    end
 
-    assert_equal expected, contact.to_roster_xml.to_xml(:indent => 0).gsub(/\n/, '')
+    it 'is not equal to a different jid' do
+      refute subject == hatter
+      refute subject.eql?(hatter)
+      refute subject.hash == hatter.hash
+    end
   end
 
-  def test_send_roster_push
-    contact = Vines::Contact.new(
-      :jid => 'alice@wonderland.lit',
-      :name => "Alice",
-      :groups => %w[Friends Buddies],
-      :subscription => 'from')
-
-    recipient = MiniTest::Mock.new
-    recipient.expect(:user, Vines::User.new(:jid => 'hatter@wonderland.lit'))
-    def recipient.nodes; @nodes; end
-    def recipient.write(node)
-      @nodes ||= []
-      @nodes << node
+  describe 'initialize' do
+    it 'raises when not given a jid' do
+      -> { Vines::Contact.new }.must_raise ArgumentError
+      -> { Vines::Contact.new(jid: '') }.must_raise ArgumentError
     end
 
-    contact.send_roster_push(recipient)
-    assert recipient.verify
-    assert_equal 1, recipient.nodes.size
+    it 'accepts a domain-only jid' do
+      contact = Vines::Contact.new(jid: 'tea.wonderland.lit')
+      contact.jid.to_s.must_equal 'tea.wonderland.lit'
+    end
+  end
 
-    expected = node(%q{
-      <iq to="hatter@wonderland.lit" type="set">
-        <query xmlns="jabber:iq:roster">
+  describe '#to_roster_xml' do
+    let(:expected) do
+      node(%q{
         <item jid="alice@wonderland.lit" name="Alice" subscription="from">
           <group>Buddies</group>
           <group>Friends</group>
         </item>
-        </query>
-      </iq>
-    }.strip.gsub(/\n/, '').gsub(/\s{2,}/, ''))
-    recipient.nodes[0].remove_attribute('id') # id is random
-    assert_equal expected, recipient.nodes[0]
+      })
+    end
+
+    it 'sorts group names' do
+      subject.to_roster_xml.must_equal expected
+    end
   end
 
-  private
+  describe '#send_roster_push' do
+    let(:recipient) { MiniTest::Mock.new }
+    let(:expected) do
+      node(%q{
+        <iq to="hatter@wonderland.lit" type="set">
+          <query xmlns="jabber:iq:roster">
+          <item jid="alice@wonderland.lit" name="Alice" subscription="from">
+            <group>Buddies</group>
+            <group>Friends</group>
+          </item>
+          </query>
+        </iq>
+      })
+    end
 
-  def node(xml)
-    Nokogiri::XML(xml).root
+    before do
+      recipient.expect :user, Vines::User.new(jid: 'hatter@wonderland.lit')
+      class << recipient
+        attr_accessor :nodes
+        def write(node)
+          @nodes ||= []
+          @nodes << node
+        end
+      end
+    end
+
+    it '' do
+      subject.send_roster_push(recipient)
+      recipient.verify
+      recipient.nodes.size.must_equal 1
+      recipient.nodes.first.remove_attribute('id') # id is random
+      recipient.nodes.first.must_equal expected
+    end
   end
 end

data/test/error_test.rb

@@ -1,59 +1,58 @@
 # encoding: UTF-8
 
-require 'vines'
-require 'minitest/autorun'
-
-class ErrorTest < MiniTest::Unit::TestCase
-  def test_sasl_error_without_text
-    expected = %q{<failure xmlns="urn:ietf:params:xml:ns:xmpp-sasl"><temporary-auth-failure/></failure>}
-    assert_equal expected, Vines::SaslErrors::TemporaryAuthFailure.new.to_xml
-  end
-
-  def test_sasl_error_with_text
-    text = %q{<text xml:lang="en">busted</text>}
-    expected = %q{<failure xmlns="urn:ietf:params:xml:ns:xmpp-sasl"><temporary-auth-failure/>%s</failure>} % text
-    assert_equal expected, Vines::SaslErrors::TemporaryAuthFailure.new('busted').to_xml
-  end
-
-  def test_stream_error_without_text
-    expected = %q{<stream:error><internal-server-error xmlns="urn:ietf:params:xml:ns:xmpp-streams"/></stream:error>}
-    assert_equal expected, Vines::StreamErrors::InternalServerError.new.to_xml
-  end
-
-  def test_stream_error_with_text
-    text = %q{<text xmlns="urn:ietf:params:xml:ns:xmpp-streams" xml:lang="en">busted</text>}
-    expected = %q{<stream:error><internal-server-error xmlns="urn:ietf:params:xml:ns:xmpp-streams"/>%s</stream:error>} % text
-    assert_equal expected, Vines::StreamErrors::InternalServerError.new('busted').to_xml
-  end
-
-  def test_stanza_error_with_bad_type
-    node = node('<message/>')
-    assert_raises(RuntimeError) { Vines::StanzaErrors::BadRequest.new(node, 'bogus') }
-  end
-
-  def test_stanza_error_with_bad_stanza
-    node = node('<bogus/>')
-    assert_raises(RuntimeError) { Vines::StanzaErrors::BadRequest.new(node, 'modify') }
-  end
-
-  def test_stanza_error_without_text
-    error = %q{<error type="modify"><bad-request xmlns="urn:ietf:params:xml:ns:xmpp-stanzas"/></error>}
-    expected = %q{<message from="hatter@wonderland.lit" to="alice@wonderland.lit" type="error">%s</message>} % error
-    node = node(%Q{<message from="alice@wonderland.lit" to="hatter@wonderland.lit"/>})
-    assert_equal expected, Vines::StanzaErrors::BadRequest.new(node, 'modify').to_xml
-  end
-
-  def test_stanza_error_with_text
-    text = %q{<text xmlns="urn:ietf:params:xml:ns:xmpp-stanzas" xml:lang="en">busted</text>}
-    error = %q{<error type="modify"><bad-request xmlns="urn:ietf:params:xml:ns:xmpp-stanzas"/>%s</error>} % text
-    expected = %q{<message id="42" type="error">%s</message>} % error
-    node = node(%Q{<message id="42"/>})
-    assert_equal expected, Vines::StanzaErrors::BadRequest.new(node, 'modify', 'busted').to_xml
-  end
-
-  private
-
-  def node(xml)
-    Nokogiri::XML(xml).root
+require 'test_helper'
+
+describe Vines::XmppError do
+  describe Vines::SaslErrors do
+    it 'does not require a text element' do
+      expected = %q{<failure xmlns="urn:ietf:params:xml:ns:xmpp-sasl"><temporary-auth-failure/></failure>}
+      Vines::SaslErrors::TemporaryAuthFailure.new.to_xml.must_equal expected
+    end
+
+    it 'includes a text element when message is given' do
+      text = %q{<text xml:lang="en">busted</text>}
+      expected = %q{<failure xmlns="urn:ietf:params:xml:ns:xmpp-sasl"><temporary-auth-failure/>%s</failure>} % text
+      Vines::SaslErrors::TemporaryAuthFailure.new('busted').to_xml.must_equal expected
+    end
+  end
+
+  describe Vines::StreamErrors do
+    it 'does not require a text element' do
+      expected = %q{<stream:error><internal-server-error xmlns="urn:ietf:params:xml:ns:xmpp-streams"/></stream:error>}
+      Vines::StreamErrors::InternalServerError.new.to_xml.must_equal expected
+    end
+
+    it 'includes a text element when message is given' do
+      text = %q{<text xmlns="urn:ietf:params:xml:ns:xmpp-streams" xml:lang="en">busted</text>}
+      expected = %q{<stream:error><internal-server-error xmlns="urn:ietf:params:xml:ns:xmpp-streams"/>%s</stream:error>} % text
+      Vines::StreamErrors::InternalServerError.new('busted').to_xml.must_equal expected
+    end
+  end
+
+  describe Vines::StanzaErrors do
+    it 'raises when given a bad type' do
+      node = node('<message/>')
+      -> { Vines::StanzaErrors::BadRequest.new(node, 'bogus') }.must_raise RuntimeError
+    end
+
+    it 'raises when given a bad stanza' do
+      node = node('<bogus/>')
+      -> { Vines::StanzaErrors::BadRequest.new(node, 'modify') }.must_raise RuntimeError
+    end
+
+    it 'does not require a text element' do
+      error = %q{<error type="modify"><bad-request xmlns="urn:ietf:params:xml:ns:xmpp-stanzas"/></error>}
+      expected = %q{<message from="hatter@wonderland.lit" to="alice@wonderland.lit" type="error">%s</message>} % error
+      node = node(%Q{<message from="alice@wonderland.lit" to="hatter@wonderland.lit"/>})
+      Vines::StanzaErrors::BadRequest.new(node, 'modify').to_xml.must_equal expected
+    end
+
+    it 'includes a text element when message is given' do
+      text = %q{<text xmlns="urn:ietf:params:xml:ns:xmpp-stanzas" xml:lang="en">busted</text>}
+      error = %q{<error type="modify"><bad-request xmlns="urn:ietf:params:xml:ns:xmpp-stanzas"/>%s</error>} % text
+      expected = %q{<message id="42" type="error">%s</message>} % error
+      node = node(%Q{<message id="42"/>})
+      Vines::StanzaErrors::BadRequest.new(node, 'modify', 'busted').to_xml.must_equal expected
+    end
   end
 end

data/test/jid_test.rb

@@ -1,7 +1,6 @@
 # encoding: UTF-8
 
-require 'vines'
-require 'minitest/autorun'
+require 'test_helper'
 
 describe Vines::JID do
   it 'handles empty input' do

data/test/kit_test.rb

@@ -1,26 +1,31 @@
 # encoding: UTF-8
 
-require 'vines'
-require 'minitest/autorun'
+require 'test_helper'
 
-class KitTest < MiniTest::Unit::TestCase
-  def test_hmac
-    assert_equal 128, Vines::Kit.hmac('secret', 'username').length
-    assert_equal Vines::Kit.hmac('s1', 'u1'), Vines::Kit.hmac('s1', 'u1')
-    refute_equal Vines::Kit.hmac('s1', 'u1'), Vines::Kit.hmac('s2', 'u1')
-    refute_equal Vines::Kit.hmac('s1', 'u1'), Vines::Kit.hmac('s1', 'u2')
+describe Vines::Kit do
+  describe '#hmac' do
+    it 'generates a SHA-512 HMAC' do
+      Vines::Kit.hmac('secret', 'username').length.must_equal 128
+      assert_equal Vines::Kit.hmac('s1', 'u1'), Vines::Kit.hmac('s1', 'u1')
+      refute_equal Vines::Kit.hmac('s1', 'u1'), Vines::Kit.hmac('s2', 'u1')
+      refute_equal Vines::Kit.hmac('s1', 'u1'), Vines::Kit.hmac('s1', 'u2')
+    end
   end
 
-  def test_uuid
-    ids = Array.new(1000) { Vines::Kit.uuid }
-    assert ids.all? {|id| !id.nil? }
-    assert ids.all? {|id| id.length == 36 }
-    assert ids.all? {|id| id.match(/\w{8}-\w{4}-[4]\w{3}-[89ab]\w{3}-\w{12}/) }
-    assert_equal ids.length, ids.uniq.length
+  describe '#uuid' do
+    it 'returns a random uuid' do
+      ids = Array.new(1000) { Vines::Kit.uuid }
+      assert ids.all? {|id| !id.nil? }
+      assert ids.all? {|id| id.length == 36 }
+      assert ids.all? {|id| id.match(/\w{8}-\w{4}-[4]\w{3}-[89ab]\w{3}-\w{12}/) }
+      ids.uniq.length.must_equal ids.length
+    end
   end
 
-  def test_auth_token
-    refute_equal Vines::Kit.auth_token, Vines::Kit.auth_token
-    assert_equal 128, Vines::Kit.auth_token.length
+  describe '#auth_token' do
+    it 'returns a random 128 character token' do
+      Vines::Kit.auth_token.wont_equal Vines::Kit.auth_token
+      Vines::Kit.auth_token.length.must_equal 128
+    end
   end
 end

data/test/router_test.rb

@@ -1,202 +1,243 @@
 # encoding: UTF-8
 
-require 'tmpdir'
-require 'vines'
-require 'minitest/autorun'
-
-class RouterTest < MiniTest::Unit::TestCase
-  def setup
-    @alice = Vines::JID.new('alice@wonderland.lit/tea')
-    @config = Vines::Config.new do
+require 'test_helper'
+
+describe Vines::Router do
+  subject      { Vines::Router.new(config) }
+  let(:alice)  { Vines::JID.new('alice@wonderland.lit/tea') }
+  let(:hatter) { 'hatter@wonderland.lit/cake' }
+  let(:romeo)  { 'romeo@verona.lit/party' }
+  let(:config) do
+    Vines::Config.new do
       host 'wonderland.lit' do
         storage(:fs) { dir Dir.tmpdir }
         components 'tea' => 'secr3t'
       end
     end
-    @router = Vines::Router.new(@config)
   end
 
-  def test_connected_resources
-    cake = 'alice@wonderland.lit/cake'
-    assert_equal 0, @router.connected_resources(@alice, @alice).size
-    assert_equal 0, @router.connected_resources(cake, @alice).size
-    assert_equal 0, @router.size
+  describe '#connected_resources' do
+    let(:cake) { 'alice@wonderland.lit/cake' }
+    let(:stream1) { stream(alice) }
+    let(:stream2) { stream(cake) }
 
-    stream1, stream2 = stream(@alice), stream(cake)
-    @router << stream1
-    @router << stream2
+    it 'is empty before any streams are connected' do
+      subject.connected_resources(alice, alice).size.must_equal 0
+      subject.connected_resources(cake, alice).size.must_equal 0
+      subject.size.must_equal 0
+    end
+
+    it 'returns only one stream matching full jid' do
+      subject << stream1
+      subject << stream2
 
-    assert_equal 1, @router.connected_resources(@alice, @alice).size
-    assert_equal @alice, @router.connected_resources(@alice, @alice)[0].user.jid
+      streams = subject.connected_resources(alice, alice)
+      streams.size.must_equal 1
+      streams.first.user.jid.must_equal alice
 
-    assert_equal 1, @router.connected_resources(cake, @alice).size
-    assert_equal cake, @router.connected_resources(cake, @alice)[0].user.jid.to_s
+      streams = subject.connected_resources(cake, alice)
+      streams.size.must_equal 1
+      streams.first.user.jid.to_s.must_equal cake
+    end
 
-    assert_equal 2, @router.connected_resources(@alice.bare, @alice).size
-    assert_equal 2, @router.size
-    assert stream1.verify
-    assert stream2.verify
+    it 'returns all streams matching bare jid' do
+      subject << stream1
+      subject << stream2
+
+      streams = subject.connected_resources(alice.bare, alice)
+      streams.size.must_equal 2
+      subject.size.must_equal 2
+    end
   end
 
-  def test_connected_resources_checks_allowed
-    romeo = 'romeo@verona.lit/party'
-    stream1, stream2 = stream(@alice), stream(romeo)
-    @router << stream1
-    @router << stream2
+  describe '#connected_resources with permissions' do
+    let(:stream1) { stream(alice) }
+    let(:stream2) { stream(romeo) }
 
-    assert_equal 2, @router.size
-    assert_equal 0, @router.connected_resources(@alice, romeo).size
-    @config.vhost('wonderland.lit').cross_domain_messages true
-    assert_equal 1, @router.connected_resources(@alice, romeo).size
+    before do
+      subject << stream1
+      subject << stream2
+    end
+
+    it 'denies access when cross domain messages is off' do
+      subject.connected_resources(alice, romeo).size.must_equal 0
+    end
 
-    assert stream1.verify
-    assert stream2.verify
+    it 'allows access when cross domain messages is on' do
+      config.vhost('wonderland.lit').cross_domain_messages true
+      subject.connected_resources(alice, romeo).size.must_equal 1
+    end
   end
 
-  def test_available_resources
-    cake = 'alice@wonderland.lit/cake'
-    assert_equal 0, @router.available_resources(@alice, @alice).size
-    assert_equal 0, @router.available_resources(cake, @alice).size
-    assert_equal 0, @router.size
+  describe '#available_resources' do
+    let(:cake) { 'alice@wonderland.lit/cake' }
+    let(:stream1) { stream(alice) }
+    let(:stream2) { stream(cake) }
 
-    stream1, stream2 = stream(@alice), stream(cake)
-    stream1.expect(:available?, true)
-    stream2.expect(:available?, false)
-    @router << stream1
-    @router << stream2
+    before do
+      stream1.send 'available?=', true
+      stream2.send 'available?=', false
+    end
 
-    assert_equal 1, @router.available_resources(@alice, @alice).size
-    assert_equal @alice, @router.available_resources(@alice, @alice)[0].user.jid
+    it 'is empty before any streams are connected' do
+      subject.available_resources(alice, alice).size.must_equal 0
+      subject.available_resources(cake, alice).size.must_equal 0
+      subject.size.must_equal 0
+    end
+
+    it 'returns available streams based on bare jid, not full jid' do
+      subject << stream1
+      subject << stream2
 
-    assert_equal 1, @router.available_resources(cake, @alice).size
-    assert_equal @alice, @router.available_resources(cake, @alice)[0].user.jid
+      streams = [alice, cake, alice.bare].map do |jid|
+        subject.available_resources(jid, alice)
+      end.flatten
 
-    assert_equal 1, @router.available_resources(@alice.bare, @alice).size
-    assert_equal @alice, @router.available_resources(@alice.bare, @alice)[0].user.jid
+      # should only have found alice's stream
+      streams.size.must_equal 3
+      streams.uniq.size.must_equal 1
+      streams.first.user.jid.must_equal alice
 
-    assert_equal 2, @router.size
-    assert stream1.verify
-    assert stream2.verify
+      subject.size.must_equal 2
+    end
   end
 
-  def test_interested_resources
-    hatter = 'hatter@wonderland.lit/cake'
-    assert_equal 0, @router.interested_resources(@alice, @alice).size
-    assert_equal 0, @router.interested_resources(hatter, @alice).size
-    assert_equal 0, @router.interested_resources(@alice, hatter, @alice).size
-    assert_equal 0, @router.size
+  describe '#interested_resources with no streams' do
+    it 'is empty before any streams are connected' do
+      subject.interested_resources(alice, alice).size.must_equal 0
+      subject.interested_resources(hatter, alice).size.must_equal 0
+      subject.interested_resources(alice, hatter, alice).size.must_equal 0
+      subject.size.must_equal 0
+    end
+  end
 
-    stream1, stream2 = stream(@alice), stream(hatter)
-    stream1.expect(:interested?, true)
-    stream2.expect(:interested?, false)
-    @router << stream1
-    @router << stream2
+  describe '#interested_resources' do
+    let(:stream1) { stream(alice) }
+    let(:stream2) { stream(hatter) }
 
-    assert_equal 0, @router.interested_resources('bogus@wonderland.lit', @alice).size
+    before do
+      stream1.send 'interested?=', true
+      stream2.send 'interested?=', false
+      subject << stream1
+      subject << stream2
+    end
 
-    assert_equal 1, @router.interested_resources(@alice, hatter, @alice).size
-    assert_equal 1, @router.interested_resources([@alice, hatter], @alice).size
-    assert_equal @alice, @router.interested_resources(@alice, hatter, @alice)[0].user.jid
+    it 'does not find streams for unauthenticated jids' do
+      subject.interested_resources('bogus@wonderland.lit', alice).size.must_equal 0
+    end
 
-    assert_equal 0, @router.interested_resources(hatter, @alice).size
-    assert_equal 0, @router.interested_resources([hatter], @alice).size
+    it 'finds interested streams for full jids' do
+      subject.interested_resources(alice, hatter, alice).size.must_equal 1
+      subject.interested_resources([alice, hatter], alice).size.must_equal 1
+      subject.interested_resources(alice, hatter, alice)[0].user.jid.must_equal alice
+    end
 
-    assert_equal 1, @router.interested_resources(@alice.bare, @alice).size
-    assert_equal @alice, @router.interested_resources(@alice.bare, @alice)[0].user.jid
+    it 'does not find streams for uninterested jids' do
+      subject.interested_resources(hatter, alice).size.must_equal 0
+      subject.interested_resources([hatter], alice).size.must_equal 0
+    end
 
-    assert_equal 2, @router.size
-    assert stream1.verify
-    assert stream2.verify
+    it 'finds interested streams for bare jids' do
+      subject.interested_resources(alice.bare, alice).size.must_equal 1
+      subject.interested_resources(alice.bare, alice)[0].user.jid.must_equal alice
+    end
   end
 
-  def test_delete
-    hatter = 'hatter@wonderland.lit/cake'
-    assert_equal 0, @router.size
-
-    stream1, stream2 = stream(@alice), stream(hatter)
-    @router << stream1
-    @router << stream2
+  describe '#delete' do
+    let(:stream1) { stream(alice) }
+    let(:stream2) { stream(hatter) }
 
-    assert_equal 2, @router.size
+    it 'correctly adds and removes streams' do
+      subject.size.must_equal 0
 
-    @router.delete(stream2)
-    assert_equal 1, @router.size
+      subject << stream1
+      subject << stream2
+      subject.size.must_equal 2
 
-    @router.delete(stream2)
-    assert_equal 1, @router.size
+      subject.delete(stream2)
+      subject.size.must_equal 1
 
-    @router.delete(stream1)
-    assert_equal 0, @router.size
+      subject.delete(stream2)
+      subject.size.must_equal 1
 
-    assert stream1.verify
-    assert stream2.verify
+      subject.delete(stream1)
+      subject.size.must_equal 0
+    end
   end
 
-  def test_multiple_component_streams_are_load_balanced
-    stream1 = component('tea.wonderland.lit')
-    stream2 = component('tea.wonderland.lit')
-    @router << stream1
-    @router << stream2
-    stanza = Nokogiri::XML('<message from="alice@wonderland.lit" to="tea.wonderland.lit">test</message>').root
-    100.times { @router.route(stanza) }
-
-    assert_equal 100, stream1.count + stream2.count
-    assert stream1.count > 33
-    assert stream2.count > 33
-    assert stream1.verify
-    assert stream2.verify
+  describe 'load balanced component streams' do
+    let(:stream1) { component('tea.wonderland.lit') }
+    let(:stream2) { component('tea.wonderland.lit') }
+    let(:stanza)  { node('<message from="alice@wonderland.lit" to="tea.wonderland.lit">test</message>')}
+
+    before do
+      subject << stream1
+      subject << stream2
+    end
+
+    it 'must evenly distribute routed stanzas to both streams' do
+      100.times { subject.route(stanza) }
+
+      (stream1.count + stream2.count).must_equal 100
+      stream1.count.must_be :>, 33
+      stream2.count.must_be :>, 33
+    end
   end
 
-  def test_multiple_s2s_streams_are_load_balanced
-    @config.vhost('wonderland.lit').cross_domain_messages true
-    stream1 = s2s('wonderland.lit', 'verona.lit')
-    stream2 = s2s('wonderland.lit', 'verona.lit')
-    @router << stream1
-    @router << stream2
-    stanza = Nokogiri::XML('<message from="alice@wonderland.lit" to="romeo@verona.lit">test</message>').root
-    100.times { @router.route(stanza) }
-
-    assert_equal 100, stream1.count + stream2.count
-    assert stream1.count > 33
-    assert stream2.count > 33
-    assert stream1.verify
-    assert stream2.verify
+  describe 'load balanced s2s streams' do
+    let(:stream1) { s2s('wonderland.lit', 'verona.lit') }
+    let(:stream2) { s2s('wonderland.lit', 'verona.lit') }
+    let(:stanza) { node('<message from="alice@wonderland.lit" to="romeo@verona.lit">test</message>') }
+
+    before do
+      config.vhost('wonderland.lit').cross_domain_messages true
+      subject << stream1
+      subject << stream2
+    end
+
+    it 'must evenly distribute routed stanzas to both streams' do
+      100.times { subject.route(stanza) }
+
+      (stream1.count + stream2.count).must_equal 100
+      stream1.count.must_be :>, 33
+      stream2.count.must_be :>, 33
+    end
   end
 
   private
 
   def stream(jid)
-    stream = MiniTest::Mock.new
-    stream.expect(:connected?, true)
-    stream.expect(:stream_type, :client)
-    stream.expect(:user, Vines::User.new(jid: jid))
-    stream
+    OpenStruct.new.tap do |stream|
+      stream.send('connected?=', true)
+      stream.stream_type = :client
+      stream.user = Vines::User.new(jid: jid)
+    end
   end
 
   def component(jid)
-    stream = MiniTest::Mock.new
-    stream.expect(:stream_type, :component)
-    stream.expect(:remote_domain, jid)
-    stream.expect(:ready?, true)
-    def stream.count; @count || 0; end
-    def stream.write(stanza)
-      @count ||= 0
-      @count += 1
-    end
-    stream
+    OpenStruct.new.tap do |stream|
+      stream.stream_type = :component
+      stream.remote_domain = jid
+      stream.send('ready?=', true)
+      def stream.count; @count || 0; end
+      def stream.write(stanza)
+        @count ||= 0
+        @count += 1
+      end
+    end
   end
 
   def s2s(domain, remote_domain)
-    stream = MiniTest::Mock.new
-    stream.expect(:stream_type, :server)
-    stream.expect(:domain, domain)
-    stream.expect(:remote_domain, remote_domain)
-    stream.expect(:ready?, true)
-    def stream.count; @count || 0; end
-    def stream.write(stanza)
-      @count ||= 0
-      @count += 1
-    end
-    stream
+    OpenStruct.new.tap do |stream|
+      stream.stream_type = :server
+      stream.domain = domain
+      stream.remote_domain = remote_domain
+      stream.send('ready?=', true)
+      def stream.count; @count || 0; end
+      def stream.write(stanza)
+        @count ||= 0
+        @count += 1
+      end
+    end
   end
 end