vines 0.4.5 → 0.4.6

data/test/stream/component/handshake_test.rb

@@ -1,49 +1,52 @@
 # encoding: UTF-8
 
-require 'vines'
-require 'minitest/autorun'
+require 'test_helper'
 
-class HandshakeTest < MiniTest::Unit::TestCase
-  def setup
-    @stream = MiniTest::Mock.new
-    @state = Vines::Stream::Component::Handshake.new(@stream)
-  end
-
-  def test_invalid_element
-    node = node('<message/>')
-    assert_raises(Vines::StreamErrors::NotAuthorized) { @state.node(node) }
-  end
+describe Vines::Stream::Component::Handshake do
+  subject      { Vines::Stream::Component::Handshake.new(stream) }
+  let(:stream) { MiniTest::Mock.new }
 
-  def test_missing_text
-    @stream.expect(:secret, 'secr3t')
-    node = node('<handshake/>')
-    assert_raises(Vines::StreamErrors::NotAuthorized) { @state.node(node) }
-    assert @stream.verify
+  describe 'when invalid element is received' do
+    it 'raises a not-authorized stream error' do
+      node = node('<message/>')
+       -> { subject.node(node) }.must_raise Vines::StreamErrors::NotAuthorized
+    end
   end
 
-  def test_invalid_secret
-    @stream.expect(:secret, 'secr3t')
-    node = node('<handshake>bogus</handshake>')
-    assert_raises(Vines::StreamErrors::NotAuthorized) { @state.node(node) }
-    assert @stream.verify
+  describe 'when handshake with no text is received' do
+    it 'raises a not-authorized stream error' do
+      stream.expect :secret, 'secr3t'
+      node = node('<handshake/>')
+      -> { subject.node(node) }.must_raise Vines::StreamErrors::NotAuthorized
+      stream.verify
+    end
   end
 
-  def test_valid_secret
-    router = MiniTest::Mock.new
-    router.expect(:<<, nil, [@stream])
-    @stream.expect(:router, router)
-    @stream.expect(:secret, 'secr3t')
-    @stream.expect(:write, nil, ['<handshake/>'])
-    @stream.expect(:advance, nil, [Vines::Stream::Component::Ready.new(@stream)])
-    node = node('<handshake>secr3t</handshake>')
-    @state.node(node)
-    assert @stream.verify
-    assert router.verify
+  describe 'when handshake with invalid secret is received' do
+    it 'raises a not-authorized stream error' do
+      stream.expect :secret, 'secr3t'
+      node = node('<handshake>bogus</handshake>')
+      -> { subject.node(node) }.must_raise Vines::StreamErrors::NotAuthorized
+      stream.verify
+    end
   end
 
-  private
-
-  def node(xml)
-    Nokogiri::XML(xml).root
+  describe 'when good handshake is received' do
+    let(:router) { MiniTest::Mock.new }
+
+    before do
+      router.expect :<<, nil, [stream]
+      stream.expect :router, router
+      stream.expect :secret, 'secr3t'
+      stream.expect :write, nil, ['<handshake/>']
+      stream.expect :advance, nil, [Vines::Stream::Component::Ready.new(stream)]
+    end
+
+    it 'completes the handshake and advances the stream into the ready state' do
+      node = node('<handshake>secr3t</handshake>')
+      subject.node(node)
+      stream.verify
+      router.verify
+    end
   end
 end

data/test/stream/component/ready_test.rb

@@ -1,88 +1,103 @@
 # encoding: UTF-8
 
-require 'tmpdir'
-require 'vines'
-require 'ext/nokogiri'
-require 'minitest/autorun'
-
-class ComponentReadyTest < MiniTest::Unit::TestCase
-  def setup
-    @stream = MiniTest::Mock.new
-    @state  = Vines::Stream::Component::Ready.new(@stream, nil)
-    @config = Vines::Config.new do
+require 'test_helper'
+
+describe Vines::Stream::Component::Ready do
+  subject      { Vines::Stream::Component::Ready.new(stream, nil) }
+  let(:alice)  { Vines::User.new(jid: 'alice@tea.wonderland.lit') }
+  let(:hatter) { Vines::User.new(jid: 'hatter@wonderland.lit') }
+  let(:stream) { MiniTest::Mock.new }
+  let(:config) do
+    Vines::Config.new do
       host 'wonderland.lit' do
         storage(:fs) { dir Dir.tmpdir }
       end
     end
   end
 
-  def test_missing_to_and_from_addresses
-    node = node('<message/>')
-    assert_raises(Vines::StreamErrors::ImproperAddressing) { @state.node(node) }
-    assert @stream.verify
+  before do
+    class << stream
+      attr_accessor :config
+    end
+    stream.config = config
   end
 
-  def test_missing_from_address
-    node = node(%q{<message to="hatter@wonderland.lit"/>})
-    assert_raises(Vines::StreamErrors::ImproperAddressing) { @state.node(node) }
-    assert @stream.verify
+  describe 'when missing to and from addresses' do
+    it 'raises an improper-addressing stream error' do
+      node = node('<message/>')
+      -> { subject.node(node) }.must_raise Vines::StreamErrors::ImproperAddressing
+      stream.verify
+    end
   end
 
-  def test_missing_to_address
-    node = node(%q{<message from="alice@tea.wonderland.lit"/>})
-    assert_raises(Vines::StreamErrors::ImproperAddressing) { @state.node(node) }
-    assert @stream.verify
+  describe 'when missing from address' do
+    it 'raises an improper-addressing stream error' do
+      node = node(%q{<message to="hatter@wonderland.lit"/>})
+      -> { subject.node(node) }.must_raise Vines::StreamErrors::ImproperAddressing
+      stream.verify
+    end
   end
 
-  def test_invalid_from_address
-    @stream.expect(:remote_domain, 'tea.wonderland.lit')
-    node = node(%q{<message from="alice@bogus.wonderland.lit" to="hatter@wonderland.lit"/>})
-    assert_raises(Vines::StreamErrors::InvalidFrom) { @state.node(node) }
-    assert @stream.verify
+  describe 'when missing to address' do
+    it 'raises an improper-addressing stream error' do
+      node = node(%q{<message from="alice@tea.wonderland.lit"/>})
+      -> { subject.node(node) }.must_raise Vines::StreamErrors::ImproperAddressing
+      stream.verify
+    end
   end
 
-  def test_unsupported_stanza_type
-    node = node('<bogus/>')
-    assert_raises(Vines::StreamErrors::UnsupportedStanzaType) { @state.node(node) }
-    assert @stream.verify
+  describe 'when from address domain does not match component domain' do
+    it 'raises and invalid-from stream error' do
+      stream.expect :remote_domain, 'tea.wonderland.lit'
+      node = node(%q{<message from="alice@bogus.wonderland.lit" to="hatter@wonderland.lit"/>})
+      -> { subject.node(node) }.must_raise Vines::StreamErrors::InvalidFrom
+      stream.verify
+    end
   end
 
-  def test_remote_message_routes
-    node = node(%q{<message from="alice@tea.wonderland.lit" to="romeo@verona.lit"/>})
-    @stream.expect(:remote_domain, 'tea.wonderland.lit')
-    @stream.expect(:config, @config)
-    @stream.expect(:user=, nil, [Vines::User.new(:jid => 'alice@tea.wonderland.lit')])
-
-    @router = MiniTest::Mock.new
-    @router.expect(:route, nil, [node])
-    @stream.expect(:router, @router)
-
-    @state.node(node)
-    assert @stream.verify
-    assert @router.verify
+  describe 'when unrecognized element is received' do
+    it 'raises an unsupported-stanza-type stream error' do
+      node = node('<bogus/>')
+      -> { subject.node(node) }.must_raise Vines::StreamErrors::UnsupportedStanzaType
+      stream.verify
+    end
   end
 
-  def test_local_message_processes
-    node = node(%q{<message from="alice@tea.wonderland.lit" to="hatter@wonderland.lit"/>})
-    @stream.expect(:remote_domain, 'tea.wonderland.lit')
-    @stream.expect(:config, @config)
-    @stream.expect(:user=, nil, [Vines::User.new(:jid => 'alice@tea.wonderland.lit')])
-    @stream.expect(:user, Vines::User.new(:jid => 'alice@tea.wonderland.lit'))
+  describe 'when addressed to a remote jid' do
+    let(:router) { MiniTest::Mock.new }
+    let(:xml) { node(%q{<message from="alice@tea.wonderland.lit" to="romeo@verona.lit"/>}) }
 
-    @recipient = MiniTest::Mock.new
-    @recipient.expect(:user, Vines::User.new(:jid => 'hatter@wonderland.lit'))
-    @recipient.expect(:write, nil, [node])
-
-    @stream.expect(:connected_resources, [@recipient], [Vines::JID.new('hatter@wonderland.lit')])
+    before do
+      router.expect :route, nil, [xml]
+      stream.expect :remote_domain, 'tea.wonderland.lit'
+      stream.expect :user=, nil, [alice]
+      stream.expect :router, router
+    end
 
-    @state.node(node)
-    assert @stream.verify
-    assert @recipient.verify
+    it 'routes rather than handle locally' do
+      subject.node(xml)
+      stream.verify
+      router.verify
+    end
   end
 
-  private
+  describe 'when addressed to a local jid' do
+    let(:recipient) { MiniTest::Mock.new }
+    let(:xml) { node(%q{<message from="alice@tea.wonderland.lit" to="hatter@wonderland.lit"/>}) }
+
+    before do
+      recipient.expect :user, hatter
+      recipient.expect :write, nil, [xml]
+      stream.expect :remote_domain, 'tea.wonderland.lit'
+      stream.expect :user=, nil, [alice]
+      stream.expect :user, alice
+      stream.expect :connected_resources, [recipient], [hatter.jid]
+    end
 
-  def node(xml)
-    Nokogiri::XML(xml).root
+    it 'sends the message to the connected stream' do
+      subject.node(xml)
+      stream.verify
+      recipient.verify
+    end
   end
 end

data/test/stream/component/start_test.rb

@@ -1,30 +1,29 @@
 # encoding: UTF-8
 
-require 'vines'
-require 'minitest/autorun'
+require 'test_helper'
 
-class ComponentStartTest < MiniTest::Unit::TestCase
-  def setup
+describe Vines::Stream::Component::Start do
+  before do
     @stream = MiniTest::Mock.new
     @state = Vines::Stream::Component::Start.new(@stream)
   end
 
-  def test_invalid_element
+  it 'raises not-authorized stream error for invalid element' do
     node = node('<message/>')
     assert_raises(Vines::StreamErrors::NotAuthorized) { @state.node(node) }
   end
 
-  def test_missing_stream_namespace
+  it 'raises not-authorized stream error for missing stream namespace' do
     node = node('<stream:stream/>')
     assert_raises(Vines::StreamErrors::NotAuthorized) { @state.node(node) }
   end
 
-  def test_invalid_stream_namespace
+  it 'raises not-authorized stream error for invalid stream namespace' do
     node = node('<stream:stream xmlns="bogus"/>')
     assert_raises(Vines::StreamErrors::NotAuthorized) { @state.node(node) }
   end
 
-  def test_valid_stream_header
+  it 'advances the state machine for valid stream header' do
     node = node(%q{<stream:stream xmlns:stream="http://etherx.jabber.org/streams" xmlns="jabber:component:accept" to="tea.wonderland.lit"/>})
     @stream.expect(:start, nil, [node])
     @stream.expect(:advance, nil, [Vines::Stream::Component::Handshake.new(@stream)])

data/test/stream/http/auth_test.rb

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

data/test/stream/http/ready_test.rb

@@ -1,94 +1,86 @@
 # encoding: UTF-8
 
-require 'tmpdir'
-require 'vines'
-require 'minitest/autorun'
+require 'test_helper'
 
 describe Vines::Stream::Http::Ready do
-  before do
-    @stream = MiniTest::Mock.new
-    @state = Vines::Stream::Http::Ready.new(@stream, nil)
+  subject      { Vines::Stream::Http::Ready.new(stream, nil) }
+  let(:stream) { MiniTest::Mock.new }
+  let(:alice)  { Vines::User.new(jid: 'alice@wonderland.lit') }
+  let(:hatter) { Vines::User.new(jid: 'hatter@wonderland.lit') }
+  let(:config) do
+    Vines::Config.new do
+      host 'wonderland.lit' do
+        storage(:fs) { dir Dir.tmpdir }
+      end
+    end
   end
 
   it "raises when body element is missing" do
     node = node('<presence type="unavailable"/>')
-    @stream.expect(:valid_session?, true, [nil])
-    -> { @state.node(node) }.must_raise Vines::StreamErrors::NotAuthorized
+    stream.expect :valid_session?, true, [nil]
+    -> { subject.node(node) }.must_raise Vines::StreamErrors::NotAuthorized
   end
 
   it "raises when namespace is missing" do
     node = node('<body rid="42" sid="12"/>')
-    @stream.expect(:valid_session?, true, ['12'])
-    assert_raises(Vines::StreamErrors::NotAuthorized) { @state.node(node) }
-    -> { @state.node(node) }.must_raise Vines::StreamErrors::NotAuthorized
+    stream.expect :valid_session?, true, ['12']
+    -> { subject.node(node) }.must_raise Vines::StreamErrors::NotAuthorized
   end
 
   it "raises when rid attribute is missing" do
     node = node('<body xmlns="http://jabber.org/protocol/httpbind" sid="12"/>')
-    @stream.expect(:valid_session?, true, ['12'])
-    -> { @state.node(node) }.must_raise Vines::StreamErrors::NotAuthorized
+    stream.expect :valid_session?, true, ['12']
+    -> { subject.node(node) }.must_raise Vines::StreamErrors::NotAuthorized
   end
 
   it "raises when session id is invalid" do
-    @stream.expect(:valid_session?, false, ['12'])
+    stream.expect :valid_session?, false, ['12']
     node = node('<body xmlns="http://jabber.org/protocol/httpbind" rid="42" sid="12"/>')
-    -> { @state.node(node) }.must_raise Vines::StreamErrors::NotAuthorized
-    assert @stream.verify
+    -> { subject.node(node) }.must_raise Vines::StreamErrors::NotAuthorized
+    stream.verify
   end
 
   it "processes when body element is empty" do
     node = node('<body xmlns="http://jabber.org/protocol/httpbind" rid="42" sid="12"/>')
-    @stream.expect(:valid_session?, true, ['12'])
-    @stream.expect(:parse_body, [], [node])
-    @state.node(node)
-    assert @stream.verify
+    stream.expect :valid_session?, true, ['12']
+    stream.expect :parse_body, [], [node]
+    subject.node(node)
+    stream.verify
   end
 
-  it "processes all stanzas in one body element" do
-    alice = Vines::User.new(jid: 'alice@wonderland.lit')
-    hatter = Vines::User.new(jid: 'hatter@wonderland.lit')
-
-    config = Vines::Config.new do
-      host 'wonderland.lit' do
-        storage(:fs) { dir Dir.tmpdir }
-      end
+  describe 'when receiving multiple stanzas in one body element' do
+    let(:recipient) { MiniTest::Mock.new }
+    let(:bogus) { node('<message type="bogus">raises stanza error</message>') }
+    let(:ok) { node('<message to="hatter@wonderland.lit">but processes this message</message>') }
+    let(:xml) { node(%Q{<body xmlns="http://jabber.org/protocol/httpbind" rid="42" sid="12">#{bogus}#{ok}</body>}) }
+    let(:raises) { Vines::Stanza.from_node(bogus, stream) }
+    let(:processes) { Vines::Stanza.from_node(ok, stream) }
+
+    before do
+      recipient.expect :user, hatter
+      recipient.expect :write, nil, [Vines::Stanza::Message]
+
+      stream.expect :valid_session?, true, ['12']
+      stream.expect :parse_body, [raises, processes], [xml]
+      stream.expect :error, nil, [Vines::StanzaErrors::BadRequest]
+      stream.expect :config, config
+      stream.expect :user, alice
+      stream.expect :connected_resources, [recipient], [hatter.jid]
     end
 
-    bogus = node('<message type="bogus">raises stanza error</message>')
-    ok = node('<message to="hatter@wonderland.lit">but processes this message</message>')
-    node = node(%Q{<body xmlns="http://jabber.org/protocol/httpbind" rid="42" sid="12">#{bogus}#{ok}</body>})
-
-    raises = Vines::Stanza.from_node(bogus, @stream)
-    processes = Vines::Stanza.from_node(ok, @stream)
-
-    recipient = MiniTest::Mock.new
-    recipient.expect(:user, hatter)
-    recipient.expect(:write, nil, [Vines::Stanza::Message])
-
-    @stream.expect(:valid_session?, true, ['12'])
-    @stream.expect(:parse_body, [raises, processes], [node])
-    @stream.expect(:error, nil, [Vines::StanzaErrors::BadRequest])
-    @stream.expect(:config, config)
-    @stream.expect(:user, alice)
-    @stream.expect(:connected_resources, [recipient], [hatter.jid])
-
-    @state.node(node)
-    assert @stream.verify
-    assert recipient.verify
+    it 'processes all stanzas' do
+      subject.node(xml)
+      stream.verify
+      recipient.verify
+    end
   end
 
   it "terminates the session" do
     node = node('<body xmlns="http://jabber.org/protocol/httpbind" rid="42" sid="12" type="terminate"/>')
-    @stream.expect(:valid_session?, true, ['12'])
-    @stream.expect(:parse_body, [], [node])
-    @stream.expect(:terminate, nil)
-    @state.node(node)
-    assert @stream.verify
-  end
-
-  private
-
-  def node(xml)
-    Nokogiri::XML(xml).root
+    stream.expect :valid_session?, true, ['12']
+    stream.expect :parse_body, [], [node]
+    stream.expect :terminate, nil
+    subject.node(node)
+    stream.verify
   end
 end