vines 0.4.5 → 0.4.6

data/test/stream/http/request_test.rb

@@ -1,8 +1,6 @@
 # encoding: UTF-8
 
-require 'tmpdir'
-require 'vines'
-require 'minitest/autorun'
+require 'test_helper'
 
 describe Vines::Stream::Http::Request do
   PASSWORD = File.expand_path('../passwords')

data/test/stream/http/sessions_test.rb

@@ -1,9 +1,8 @@
 # encoding: UTF-8
 
-require 'vines'
-require 'minitest/autorun'
+require 'test_helper'
 
-class SessionsTest < MiniTest::Unit::TestCase
+describe Vines::Stream::Http::Sessions do
   class MockSessions < Vines::Stream::Http::Sessions
     def start_timer
       # do nothing

data/test/stream/http/start_test.rb

@@ -1,10 +1,9 @@
 # encoding: UTF-8
 
-require 'vines'
-require 'minitest/autorun'
+require 'test_helper'
 
-class HttpStartTest < MiniTest::Unit::TestCase
-  def setup
+describe Vines::Stream::Http::Start do
+  before do
     @stream = MiniTest::Mock.new
     @state = Vines::Stream::Http::Start.new(@stream)
   end

data/test/stream/parser_test.rb

@@ -1,12 +1,11 @@
 # encoding: UTF-8
 
-require 'vines'
-require 'minitest/autorun'
+require 'test_helper'
 
-class ParserTest < MiniTest::Unit::TestCase
+describe Vines::Stream::Parser do
   STREAM_START = '<stream:stream to="wonderland.lit" xmlns="jabber:client" xmlns:stream="http://etherx.jabber.org/streams">'.freeze
 
-  def setup
+  before do
     @events = []
     @parser = Vines::Stream::Parser.new.tap do |p|
       p.stream_open  {|el| @events << el }

data/test/stream/sasl_test.rb

@@ -1,13 +1,15 @@
 # encoding: UTF-8
 
-require 'vines'
-require 'minitest/autorun'
+require 'test_helper'
 
 describe Vines::Stream::SASL do
+  subject       { Vines::Stream::SASL.new(stream) }
+  let(:stream)  { MiniTest::Mock.new }
+  let(:storage) { MiniTest::Mock.new }
+  let(:romeo)   { Vines::User.new(jid: 'romeo@verona.lit') }
+
   before do
-    @stream = MiniTest::Mock.new
-    @sasl = Vines::Stream::SASL.new(@stream)
-    def @sasl.log
+    def subject.log
       Class.new do
         def method_missing(*args)
           # do nothing
@@ -17,95 +19,104 @@ describe Vines::Stream::SASL do
   end
 
   describe '#plain_auth' do
-    it 'fails with invalid input' do
-      proc { @sasl.plain_auth(nil) }.must_raise Vines::SaslErrors::IncorrectEncoding
-      proc { @sasl.plain_auth('') }.must_raise Vines::SaslErrors::NotAuthorized
-      proc { @sasl.plain_auth('bogus') }.must_raise Vines::SaslErrors::IncorrectEncoding
-      proc { @sasl.plain_auth('=dmVyb25hLmxpdA==') }.must_raise Vines::SaslErrors::IncorrectEncoding
-      proc { @sasl.plain_auth("dmVyb25hLmxpdA==\n") }.must_raise Vines::SaslErrors::IncorrectEncoding
+    before do
+      stream.expect :domain, 'verona.lit'
+    end
+
+    it 'fails with empty input' do
+      -> { subject.plain_auth(nil) }.must_raise Vines::SaslErrors::IncorrectEncoding
+      -> { subject.plain_auth('') }.must_raise Vines::SaslErrors::NotAuthorized
+    end
+
+    it 'fails with plain text' do
+      -> { subject.plain_auth('bogus') }.must_raise Vines::SaslErrors::IncorrectEncoding
+    end
+
+    it 'fails with incorrectly encoded base64 text' do
+      -> { subject.plain_auth('=dmVyb25hLmxpdA==') }.must_raise Vines::SaslErrors::IncorrectEncoding
+      -> { subject.plain_auth("dmVyb25hLmxpdA==\n") }.must_raise Vines::SaslErrors::IncorrectEncoding
     end
 
-    it 'fails when authzid does not match authcid' do
-      @stream.expect(:domain, 'verona.lit')
+    it 'fails when authzid does not match authcid username' do
       encoded = Base64.strict_encode64("juliet@verona.lit\x00romeo\x00secr3t")
-      proc { @sasl.plain_auth(encoded) }.must_raise Vines::SaslErrors::InvalidAuthzid
+      -> { subject.plain_auth(encoded) }.must_raise Vines::SaslErrors::InvalidAuthzid
+      stream.verify
+    end
+
+    it 'fails when authzid does not match authcid domain' do
       encoded = Base64.strict_encode64("romeo@wonderland.lit\x00romeo\x00secr3t")
-      proc { @sasl.plain_auth(encoded) }.must_raise Vines::SaslErrors::InvalidAuthzid
-      @stream.verify.must_equal true
+      -> { subject.plain_auth(encoded) }.must_raise Vines::SaslErrors::InvalidAuthzid
+      stream.verify
+    end
+
+    it 'fails when username and password are missing' do
+      encoded = Base64.strict_encode64("\x00\x00")
+      -> { subject.plain_auth(encoded) }.must_raise Vines::SaslErrors::NotAuthorized
     end
 
     it 'fails when username is missing' do
       encoded = Base64.strict_encode64("\x00\x00secr3t")
-      proc { @sasl.plain_auth(encoded) }.must_raise Vines::SaslErrors::NotAuthorized
-      encoded = Base64.strict_encode64("\x00\x00")
-      proc { @sasl.plain_auth(encoded) }.must_raise Vines::SaslErrors::NotAuthorized
+      -> { subject.plain_auth(encoded) }.must_raise Vines::SaslErrors::NotAuthorized
     end
 
-    it 'fails when password is missing' do
+    it 'fails when password is missing with delimiter' do
       encoded = Base64.strict_encode64("\x00romeo\x00")
-      proc { @sasl.plain_auth(encoded) }.must_raise Vines::SaslErrors::NotAuthorized
+      -> { subject.plain_auth(encoded) }.must_raise Vines::SaslErrors::NotAuthorized
+    end
+
+    it 'fails when password is missing' do
       encoded = Base64.strict_encode64("\x00romeo")
-      proc { @sasl.plain_auth(encoded) }.must_raise Vines::SaslErrors::NotAuthorized
+      -> { subject.plain_auth(encoded) }.must_raise Vines::SaslErrors::NotAuthorized
     end
 
     it 'fails with invalid jid' do
-      @stream.expect(:domain, 'verona.lit')
-      jid = 'a' * 1024
-      encoded = Base64.strict_encode64("\x00#{jid}\x00secr3t")
-      proc { @sasl.plain_auth(encoded) }.must_raise Vines::SaslErrors::NotAuthorized
-      @stream.verify.must_equal true
+      encoded = Base64.strict_encode64("\x00#{'a' * 1024}\x00secr3t")
+      -> { subject.plain_auth(encoded) }.must_raise Vines::SaslErrors::NotAuthorized
+      stream.verify
     end
 
     it 'fails with invalid password' do
-      romeo = Vines::JID.new('romeo@verona.lit')
-      storage = MiniTest::Mock.new
-      storage.expect(:authenticate, nil, [romeo, 'secr3t'])
-      @stream.expect(:domain, 'verona.lit')
-      @stream.expect(:storage, storage)
+      storage.expect :authenticate, nil, [romeo.jid, 'secr3t']
+      stream.expect :storage, storage
 
       encoded = Base64.strict_encode64("\x00romeo\x00secr3t")
-      proc { @sasl.plain_auth(encoded) }.must_raise Vines::SaslErrors::NotAuthorized
-      @stream.verify.must_equal true
-      storage.verify.must_equal true
+      -> { subject.plain_auth(encoded) }.must_raise Vines::SaslErrors::NotAuthorized
+
+      stream.verify
+      storage.verify
     end
 
     it 'passes with valid password' do
-      romeo = Vines::JID.new('romeo@verona.lit')
-      storage = MiniTest::Mock.new
-      storage.expect(:authenticate, Vines::User.new(jid: romeo), [romeo, 'secr3t'])
-      @stream.expect(:domain, 'verona.lit')
-      @stream.expect(:storage, storage)
+      storage.expect :authenticate, romeo, [romeo.jid, 'secr3t']
+      stream.expect :storage, storage
 
       encoded = Base64.strict_encode64("\x00romeo\x00secr3t")
-      @sasl.plain_auth(encoded).must_equal Vines::User.new(jid: romeo)
-      @stream.verify.must_equal true
-      storage.verify.must_equal true
+      subject.plain_auth(encoded).must_equal romeo
+
+      stream.verify
+      storage.verify
     end
 
     it 'passes with valid password and authzid provided by strophe and blather' do
-      romeo = Vines::JID.new('romeo@verona.lit')
-      storage = MiniTest::Mock.new
-      storage.expect(:authenticate, Vines::User.new(jid: romeo), [romeo, 'secr3t'])
-      @stream.expect(:domain, 'verona.lit')
-      @stream.expect(:storage, storage)
+      storage.expect :authenticate, romeo, [romeo.jid, 'secr3t']
+      stream.expect :storage, storage
 
       encoded = Base64.strict_encode64("romeo@Verona.LIT\x00romeo\x00secr3t")
-      @sasl.plain_auth(encoded).must_equal Vines::User.new(jid: romeo)
-      @stream.verify.must_equal true
-      storage.verify.must_equal true
+      subject.plain_auth(encoded).must_equal romeo
+
+      stream.verify
+      storage.verify
     end
 
     it 'passes with valid password and authzid provided by smack' do
-      romeo = Vines::JID.new('romeo@verona.lit')
-      storage = MiniTest::Mock.new
-      storage.expect(:authenticate, Vines::User.new(jid: romeo), [romeo, 'secr3t'])
-      @stream.expect(:domain, 'verona.lit')
-      @stream.expect(:storage, storage)
+      storage.expect :authenticate, romeo, [romeo.jid, 'secr3t']
+      stream.expect :storage, storage
 
       encoded = Base64.strict_encode64("romeo\x00romeo\x00secr3t")
-      @sasl.plain_auth(encoded).must_equal Vines::User.new(jid: romeo)
-      @stream.verify.must_equal true
-      storage.verify.must_equal true
+      subject.plain_auth(encoded).must_equal romeo
+
+      stream.verify
+      storage.verify
     end
 
     it 'raises temporary-auth-failure when storage backend fails' do
@@ -114,51 +125,59 @@ describe Vines::Stream::SASL do
           raise 'boom'
         end
       end.new
-      @stream.expect(:domain, 'verona.lit')
-      @stream.expect(:storage, storage)
 
+      stream.expect :storage, storage
       encoded = Base64.strict_encode64("\x00romeo\x00secr3t")
-      proc { @sasl.plain_auth(encoded) }.must_raise Vines::SaslErrors::TemporaryAuthFailure
-      @stream.verify.must_equal true
+      -> { subject.plain_auth(encoded) }.must_raise Vines::SaslErrors::TemporaryAuthFailure
+      stream.verify
     end
   end
 
   describe '#external_auth' do
-    it 'fails with invalid input' do
-      @stream.expect(:remote_domain, 'verona.lit')
-      proc { @sasl.external_auth(nil) }.must_raise Vines::SaslErrors::IncorrectEncoding
-      proc { @sasl.external_auth('') }.must_raise Vines::SaslErrors::InvalidAuthzid
-      proc { @sasl.external_auth('bogus') }.must_raise Vines::SaslErrors::IncorrectEncoding
-      proc { @sasl.external_auth('=dmVyb25hLmxpdA==') }.must_raise Vines::SaslErrors::IncorrectEncoding
-      proc { @sasl.external_auth("dmVyb25hLmxpdA==\n") }.must_raise Vines::SaslErrors::IncorrectEncoding
-      @stream.verify.must_equal true
+    it 'fails with empty input' do
+      stream.expect :remote_domain, 'verona.lit'
+      -> { subject.external_auth(nil) }.must_raise Vines::SaslErrors::IncorrectEncoding
+      -> { subject.external_auth('') }.must_raise Vines::SaslErrors::InvalidAuthzid
+      stream.verify
+    end
+
+    it 'fails with plain text' do
+      -> { subject.external_auth('bogus') }.must_raise Vines::SaslErrors::IncorrectEncoding
+      stream.verify
+    end
+
+    it 'fails with incorrectly encoded base64 text' do
+      -> { subject.external_auth('=dmVyb25hLmxpdA==') }.must_raise Vines::SaslErrors::IncorrectEncoding
+      -> { subject.external_auth("dmVyb25hLmxpdA==\n") }.must_raise Vines::SaslErrors::IncorrectEncoding
+      stream.verify
     end
 
     it 'passes with empty authzid and matching cert' do
-      @stream.expect(:remote_domain, 'verona.lit')
-      @stream.expect(:cert_domain_matches?, true, ['verona.lit'])
-      @sasl.external_auth('=').must_equal true
-      @stream.verify.must_equal true
+      stream.expect :remote_domain, 'verona.lit'
+      stream.expect :cert_domain_matches?, true, ['verona.lit']
+      subject.external_auth('=').must_equal true
+      stream.verify
     end
 
     it 'fails with empty authzid and non-matching cert' do
-      @stream.expect(:remote_domain, 'verona.lit')
-      @stream.expect(:cert_domain_matches?, false, ['verona.lit'])
-      proc { @sasl.external_auth('=') }.must_raise Vines::SaslErrors::NotAuthorized
-      @stream.verify.must_equal true
+      stream.expect :remote_domain, 'verona.lit'
+      stream.expect :cert_domain_matches?, false, ['verona.lit']
+      -> { subject.external_auth('=') }.must_raise Vines::SaslErrors::NotAuthorized
+      stream.verify
     end
 
     it 'fails when authzid does not match stream from address' do
-      @stream.expect(:remote_domain, 'not.verona.lit')
-      proc { @sasl.external_auth('dmVyb25hLmxpdA==') }.must_raise Vines::SaslErrors::InvalidAuthzid
-      @stream.verify.must_equal true
+      stream.expect :remote_domain, 'not.verona.lit'
+      -> { subject.external_auth('dmVyb25hLmxpdA==') }.must_raise Vines::SaslErrors::InvalidAuthzid
+      stream.verify
     end
 
     it 'passes when authzid matches stream from address' do
-      @stream.expect(:remote_domain, 'verona.lit')
-      @stream.expect(:cert_domain_matches?, true, ['verona.lit'])
-      @sasl.external_auth('dmVyb25hLmxpdA==').must_equal true
-      @stream.verify.must_equal true
+      stream.expect :remote_domain, 'verona.lit'
+      stream.expect :remote_domain, 'verona.lit'
+      stream.expect :cert_domain_matches?, true, ['verona.lit']
+      subject.external_auth('dmVyb25hLmxpdA==').must_equal true
+      stream.verify
     end
   end
 end

data/test/stream/server/auth_test.rb

@@ -1,57 +1,61 @@
 # encoding: UTF-8
 
-require 'vines'
-require 'minitest/autorun'
+require 'test_helper'
 
 describe Vines::Stream::Server::Auth do
   # disable logging for tests
   Class.new.extend(Vines::Log).log.level = Logger::FATAL
 
+  subject      { Vines::Stream::Server::Auth.new(stream) }
+  let(:stream) { MiniTest::Mock.new }
+
   before do
-    @stream = MiniTest::Mock.new
-    @state = Vines::Stream::Server::Auth.new(@stream)
+    class << stream
+      attr_accessor :remote_domain
+    end
+    stream.remote_domain = 'wonderland.lit'
   end
 
-  describe 'external auth' do
-    it 'passes with empty authzid' do
-      @stream.expect(:remote_domain, 'wonderland.lit')
-      @stream.expect(:cert_domain_matches?, true, ['wonderland.lit'])
-      @stream.expect(:write, nil, ['<success xmlns="urn:ietf:params:xml:ns:xmpp-sasl"/>'])
-      @stream.expect(:advance, nil, [Vines::Stream::Server::FinalRestart])
-      @stream.expect(:reset, nil)
-      @stream.expect(:authentication_mechanisms, ['EXTERNAL'])
-      node = node(%Q{<auth xmlns="urn:ietf:params:xml:ns:xmpp-sasl" mechanism="EXTERNAL">=</auth>})
-      @state.node(node)
-      assert @stream.verify
+  describe 'when given a valid authzid' do
+    before do
+      stream.expect :cert_domain_matches?, true, ['wonderland.lit']
+      stream.expect :write, nil, ['<success xmlns="urn:ietf:params:xml:ns:xmpp-sasl"/>']
+      stream.expect :advance, nil, [Vines::Stream::Server::FinalRestart]
+      stream.expect :reset, nil
+      stream.expect :authentication_mechanisms, ['EXTERNAL']
+    end
+
+    it 'passes external auth with empty authzid' do
+      node = external('=')
+      subject.node(node)
+      stream.verify
     end
 
-    it 'passes when authzid matches from domain' do
-      @stream.expect(:remote_domain, 'wonderland.lit')
-      @stream.expect(:cert_domain_matches?, true, ['wonderland.lit'])
-      @stream.expect(:write, nil, ['<success xmlns="urn:ietf:params:xml:ns:xmpp-sasl"/>'])
-      @stream.expect(:advance, nil, [Vines::Stream::Server::FinalRestart])
-      @stream.expect(:reset, nil)
-      @stream.expect(:authentication_mechanisms, ['EXTERNAL'])
-      node = node(%Q{<auth xmlns="urn:ietf:params:xml:ns:xmpp-sasl" mechanism="EXTERNAL">#{Base64.strict_encode64('wonderland.lit')}</auth>})
-      @state.node(node)
-      assert @stream.verify
+    it 'passes external auth with authzid matching from domain' do
+      node = external(Base64.strict_encode64('wonderland.lit'))
+      subject.node(node)
+      stream.verify
+    end
+  end
+
+  describe 'when given an invalid authzid' do
+    before do
+      stream.expect :write, nil, ['</stream:stream>']
+      stream.expect :close_connection_after_writing, nil
+      stream.expect :error, nil, [Vines::SaslErrors::InvalidAuthzid]
+      stream.expect :authentication_mechanisms, ['EXTERNAL']
     end
 
-    it 'fails when authzid does not match from domain' do
-      @stream.expect(:remote_domain, 'wonderland.lit')
-      @stream.expect(:write, nil, ['</stream:stream>'])
-      @stream.expect(:close_connection_after_writing, nil)
-      @stream.expect(:error, nil, [Vines::SaslErrors::InvalidAuthzid])
-      @stream.expect(:authentication_mechanisms, ['EXTERNAL'])
-      node = node(%Q{<auth xmlns="urn:ietf:params:xml:ns:xmpp-sasl" mechanism="EXTERNAL">#{Base64.strict_encode64('verona.lit')}</auth>})
-      @state.node(node)
-      assert @stream.verify
+    it 'fails external auth with mismatched from domain' do
+      node = external(Base64.strict_encode64('verona.lit'))
+      subject.node(node)
+      stream.verify
     end
   end
 
   private
 
-  def node(xml)
-    Nokogiri::XML(xml).root
+  def external(authzid)
+    node(%Q{<auth xmlns="urn:ietf:params:xml:ns:xmpp-sasl" mechanism="EXTERNAL">#{authzid}</auth>})
   end
 end

data/test/stream/server/outbound/auth_test.rb

@@ -1,10 +1,9 @@
 # encoding: UTF-8
 
-require 'vines'
-require 'minitest/autorun'
+require 'test_helper'
 
-class OutboundAuthTest < MiniTest::Unit::TestCase
-  def setup
+describe Vines::Stream::Server::Outbound::Auth do
+  before do
     @stream = MiniTest::Mock.new
     @state = Vines::Stream::Server::Outbound::Auth.new(@stream)
   end

data/test/stream/server/ready_test.rb

@@ -1,93 +1,93 @@
 # encoding: UTF-8
 
-require 'vines'
-require 'minitest/autorun'
+require 'test_helper'
 
-class ServerReadyTest < MiniTest::Unit::TestCase
-  STANZAS = []
+describe Vines::Stream::Server::Ready do
+  subject      { Vines::Stream::Server::Ready.new(stream, nil) }
+  let(:stream) { MiniTest::Mock.new }
 
-  def setup
-    @stream = MiniTest::Mock.new
-    @state = Vines::Stream::Server::Ready.new(@stream, nil)
-    def @state.to_stanza(node)
-      Vines::Stanza.from_node(node, @stream).tap do |stanza|
+  SERVER_STANZAS = []
+
+  before do
+    def subject.to_stanza(node)
+      Vines::Stanza.from_node(node, stream).tap do |stanza|
         def stanza.process
-          ServerReadyTest::STANZAS << self
+          SERVER_STANZAS << self
         end if stanza
       end
     end
   end
 
-  def teardown
-    STANZAS.clear
+  after do
+    SERVER_STANZAS.clear
   end
 
-  def test_good_node_processes
+  it 'processes a valid node' do
     config = MiniTest::Mock.new
     config.expect(:local_jid?, true, [Vines::JID.new('romeo@verona.lit')])
 
-    @stream.expect(:config, config)
-    @stream.expect(:remote_domain, 'wonderland.lit')
-    @stream.expect(:domain, 'verona.lit')
-    @stream.expect(:user=, nil, [Vines::User.new(jid: 'alice@wonderland.lit')])
+    stream.expect(:config, config)
+    stream.expect(:remote_domain, 'wonderland.lit')
+    stream.expect(:domain, 'verona.lit')
+    stream.expect(:user=, nil, [Vines::User.new(jid: 'alice@wonderland.lit')])
 
     node = node(%Q{<message from="alice@wonderland.lit" to="romeo@verona.lit"/>})
-    @state.node(node)
-    assert_equal 1, STANZAS.size
-    assert @stream.verify
+    subject.node(node)
+    assert_equal 1, SERVER_STANZAS.size
+    assert stream.verify
     assert config.verify
   end
 
-  def test_unsupported_stanza_type
+  it 'raises unsupported-stanza-type stream error' do
     node = node('<bogus/>')
-    assert_raises(Vines::StreamErrors::UnsupportedStanzaType) { @state.node(node) }
-    assert STANZAS.empty?
-    assert @stream.verify
+    -> { subject.node(node) }.must_raise Vines::StreamErrors::UnsupportedStanzaType
+    assert SERVER_STANZAS.empty?
+    assert stream.verify
   end
 
-  def test_improper_addressing_missing_to
+  it 'raises improper-addressing stream error when to address is missing' do
     node = node(%Q{<message from="alice@wonderland.lit"/>})
-    assert_raises(Vines::StreamErrors::ImproperAddressing) { @state.node(node) }
-    assert STANZAS.empty?
-    assert @stream.verify
+    -> { subject.node(node) }.must_raise Vines::StreamErrors::ImproperAddressing
+    assert SERVER_STANZAS.empty?
+    assert stream.verify
   end
 
-  def test_improper_addressing_invalid_to
+  it 'raises jid-malformed stanza error when to address is invalid' do
     node = node(%Q{<message from="alice@wonderland.lit" to=" "/>})
-    assert_raises(Vines::StanzaErrors::JidMalformed) { @state.node(node) }
-    assert STANZAS.empty?
-    assert @stream.verify
+    -> { subject.node(node) }.must_raise Vines::StanzaErrors::JidMalformed
+    assert SERVER_STANZAS.empty?
+    assert stream.verify
   end
 
-  def test_improper_addressing_missing_from
+  it 'raises improper-addressing stream error' do
     node = node(%Q{<message to="romeo@verona.lit"/>})
-    assert_raises(Vines::StreamErrors::ImproperAddressing) { @state.node(node) }
-    assert STANZAS.empty?
-    assert @stream.verify
+    -> { subject.node(node) }.must_raise Vines::StreamErrors::ImproperAddressing
+    assert SERVER_STANZAS.empty?
+    assert stream.verify
   end
 
-  def test_improper_addressing_invalid_from
+  it 'raises jid-malformed stanza error for invalid from address' do
     node = node(%Q{<message from=" " to="romeo@verona.lit"/>})
-    assert_raises(Vines::StanzaErrors::JidMalformed) { @state.node(node) }
-    assert STANZAS.empty?
-    assert @stream.verify
+    -> { subject.node(node) }.must_raise Vines::StanzaErrors::JidMalformed
+    assert SERVER_STANZAS.empty?
+    assert stream.verify
   end
 
-  def test_invalid_from
-    @stream.expect(:remote_domain, 'wonderland.lit')
+  it 'raises invalid-from stream error' do
+    stream.expect(:remote_domain, 'wonderland.lit')
     node = node(%Q{<message from="alice@bogus.lit" to="romeo@verona.lit"/>})
-    assert_raises(Vines::StreamErrors::InvalidFrom) { @state.node(node) }
-    assert STANZAS.empty?
-    assert @stream.verify
+    -> { subject.node(node) }.must_raise Vines::StreamErrors::InvalidFrom
+    assert SERVER_STANZAS.empty?
+    assert stream.verify
   end
 
-  def test_host_unknown
-    @stream.expect(:remote_domain, 'wonderland.lit')
-    @stream.expect(:domain, 'verona.lit')
+  it 'raises host-unknown stream error' do
+    stream.expect(:remote_domain, 'wonderland.lit')
+    stream.expect(:domain, 'verona.lit')
     node = node(%Q{<message from="alice@wonderland.lit" to="romeo@bogus.lit"/>})
-    assert_raises(Vines::StreamErrors::HostUnknown) { @state.node(node) }
-    assert STANZAS.empty?
-    assert @stream.verify
+    -> { subject.node(node) }.must_raise Vines::StreamErrors::HostUnknown
+    assert SERVER_STANZAS.empty?
+    assert stream.verify
   end
 
   private