vines 0.4.5 → 0.4.6

data/test/stanza/iq/version_test.rb

@@ -1,63 +1,64 @@
 # encoding: UTF-8
 
-require 'tmpdir'
-require 'vines'
-require 'ext/nokogiri'
-require 'minitest/autorun'
-
-class VersionTest < MiniTest::Unit::TestCase
-  def setup
-    @stream = MiniTest::Mock.new
-    @config = Vines::Config.new do
+require 'test_helper'
+
+describe Vines::Stanza::Iq::Version do
+  subject      { Vines::Stanza::Iq::Version.new(xml, stream) }
+  let(:alice)  { Vines::User.new(jid: 'alice@wonderland.lit/tea') }
+  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_to_address_routes
-    alice = Vines::User.new(:jid => 'alice@wonderland.lit/tea')
-    node = node(%q{<iq id="42" to="romeo@verona.lit" type="get"><query xmlns="jabber:iq:version"/></iq>})
-
-    router = MiniTest::Mock.new
-    router.expect(:route, nil, [node])
-
-    @stream.expect(:config, @config)
-    @stream.expect(:user, alice)
-    @stream.expect(:router, router)
-
-    stanza = Vines::Stanza::Iq::Version.new(node, @stream)
-    stanza.process
-    assert @stream.verify
-    assert router.verify
+  before do
+    class << stream
+      attr_accessor :config, :user
+    end
+    stream.config = config
+    stream.user = alice
   end
 
-  def test_version_get_returns_result
-    alice = Vines::User.new(:jid => 'alice@wonderland.lit/tea')
-    node = node(%q{<iq id="42" type="get"><query xmlns="jabber:iq:version"/></iq>})
-
-    @stream.expect(:config, @config)
-    @stream.expect(:user, alice)
-    @stream.expect(:domain, 'wonderland.lit')
-
-    expected = node(%Q{
-      <iq from="wonderland.lit" id="42" to="alice@wonderland.lit/tea" type="result">
-        <query xmlns="jabber:iq:version">
-          <name>Vines</name>
-          <version>#{Vines::VERSION}</version>
-        </query>
-      </iq>}.strip.gsub(/\n|\s{2,}/, ''))
+  describe 'when not addressed to the server' do
+    let(:router) { MiniTest::Mock.new }
+    let(:xml) { node(%q{<iq id="42" to="romeo@verona.lit" type="get"><query xmlns="jabber:iq:version"/></iq>}) }
 
-    @stream.expect(:write, nil, [expected])
+    before do
+      router.expect :route, nil, [xml]
+      stream.expect :router, router
+    end
 
-    stanza = Vines::Stanza::Iq::Version.new(node, @stream)
-    stanza.process
-    assert @stream.verify
+    it 'routes the stanza to the recipient jid' do
+      subject.process
+      stream.verify
+      router.verify
+    end
   end
 
-  private
+  describe 'when missing a to address' do
+    let(:xml) { node(%q{<iq id="42" type="get"><query xmlns="jabber:iq:version"/></iq>}) }
+    let(:expected) do
+      node(%Q{
+        <iq from="wonderland.lit" id="42" to="alice@wonderland.lit/tea" type="result">
+          <query xmlns="jabber:iq:version">
+            <name>Vines</name>
+            <version>#{Vines::VERSION}</version>
+          </query>
+        </iq>})
+    end
+
+    before do
+      stream.expect :domain, 'wonderland.lit'
+      stream.expect :domain, 'wonderland.lit'
+      stream.expect :write, nil, [expected]
+    end
 
-  def node(xml)
-    Nokogiri::XML(xml).root
+    it 'returns a version result when missing a to jid' do
+      subject.process
+      stream.verify
+    end
   end
 end

data/test/stanza/iq_test.rb

@@ -1,66 +1,70 @@
 # encoding: UTF-8
 
-require 'tmpdir'
-require 'vines'
-require 'ext/nokogiri'
-require 'minitest/autorun'
+require 'test_helper'
 
-class IqTest < MiniTest::Unit::TestCase
-  def setup
-    @stream = MiniTest::Mock.new
-    @config = Vines::Config.new do
+describe Vines::Stanza::Iq do
+  subject      { Vines::Stanza::Iq.new(xml, stream) }
+  let(:stream) { MiniTest::Mock.new }
+  let(:alice)  { Vines::User.new(jid: 'alice@wonderland.lit/tea') }
+  let(:hatter) { Vines::User.new(jid: 'hatter@wonderland.lit/crumpets') }
+  let(:config) do
+    Vines::Config.new do
       host 'wonderland.lit' do
         storage(:fs) { dir Dir.tmpdir }
       end
     end
   end
 
-  def test_allow_other_iq_to_route
-    alice = Vines::User.new(:jid => 'alice@wonderland.lit/tea')
-    hatter = Vines::User.new(:jid => 'hatter@wonderland.lit/crumpets')
-    node = node(%q{
-      <iq id="42" type="set" to="alice@wonderland.lit/tea" from="hatter@wonderland.lit/crumpets">
-          <si xmlns="http://jabber.org/protocol/si" id="42_si" profile="http://jabber.org/protocol/si/profile/file-transfer">
-            <file xmlns="http://jabber.org/protocol/si/profile/file-transfer" name="file" size="1"/>
-            <feature xmlns="http://jabber.org/protocol/feature-neg">
-              <x xmlns="jabber:x:data" type="form">
-                <field var="stream-method" type="list-single">
-                  <option>
-                    <value>http://jabber.org/protocol/bytestreams</value>
-                  </option>
-                  <option>
-                    <value>http://jabber.org/protocol/ibb</value>
-                  </option>
-                </field>
-              </x>
-            </feature>
-          </si>
-        </iq>
-    }.strip.gsub(/\n|\s{2,}/, ''))
-
-    recipient = MiniTest::Mock.new
-    recipient.expect(:user, alice, [])
-    recipient.expect(:write, nil, [node])
+  before do
+    class << stream
+      attr_accessor :config, :user
+    end
+    stream.user = hatter
+    stream.config = config
+  end
 
-    @stream.expect(:config, @config)
-    @stream.expect(:user, hatter)
-    @stream.expect(:connected_resources, [recipient], [alice.jid])
+  describe 'when addressed to a user rather than the server itself' do
+    let(:recipient) { MiniTest::Mock.new }
+    let(:xml) do
+      node(%q{
+        <iq id="42" type="set" to="alice@wonderland.lit/tea" from="hatter@wonderland.lit/crumpets">
+            <si xmlns="http://jabber.org/protocol/si" id="42_si" profile="http://jabber.org/protocol/si/profile/file-transfer">
+              <file xmlns="http://jabber.org/protocol/si/profile/file-transfer" name="file" size="1"/>
+              <feature xmlns="http://jabber.org/protocol/feature-neg">
+                <x xmlns="jabber:x:data" type="form">
+                  <field var="stream-method" type="list-single">
+                    <option>
+                      <value>http://jabber.org/protocol/bytestreams</value>
+                    </option>
+                    <option>
+                      <value>http://jabber.org/protocol/ibb</value>
+                    </option>
+                  </field>
+                </x>
+              </feature>
+            </si>
+          </iq>
+      })
+    end
 
-    stanza = Vines::Stanza::Iq.new(node, @stream)
-    stanza.process
-    assert @stream.verify
-    assert recipient.verify
-  end
+    before do
+      recipient.expect :user, alice, []
+      recipient.expect :write, nil, [xml]
+      stream.expect :connected_resources, [recipient], [alice.jid]
+    end
 
-  def test_feature_not_implemented
-    node = node('<iq type="set" id="42"/>')
-    stanza = Vines::Stanza::Iq.new(node, @stream)
-    assert_raises(Vines::StanzaErrors::FeatureNotImplemented) { stanza.process }
+    it 'routes the stanza to the users connected resources' do
+      subject.process
+      stream.verify
+      recipient.verify
+    end
   end
 
-  private
+  describe 'when given no type or body elements' do
+    let(:xml) { node('<iq type="set" id="42"/>') }
 
-  def node(xml)
-    Nokogiri::XML(xml).root
+    it 'raises a feature-not-implemented stanza error' do
+      -> { subject.process }.must_raise Vines::StanzaErrors::FeatureNotImplemented
+    end
   end
 end

data/test/stanza/message_test.rb

@@ -1,123 +1,126 @@
 # encoding: UTF-8
 
-require 'tmpdir'
-require 'vines'
-require 'ext/nokogiri'
-require 'minitest/autorun'
-
-class MessageTest < MiniTest::Unit::TestCase
-  def setup
-    @stream = MiniTest::Mock.new
-    @config = Vines::Config.new do
+require 'test_helper'
+
+describe Vines::Stanza::Message do
+  subject      { Vines::Stanza::Message.new(xml, stream) }
+  let(:stream) { MiniTest::Mock.new }
+  let(:alice)  { Vines::User.new(jid: 'alice@wonderland.lit/tea') }
+  let(:romeo)  { Vines::User.new(jid: 'romeo@verona.lit/balcony') }
+  let(:config) do
+    Vines::Config.new do
       host 'wonderland.lit' do
         storage(:fs) { dir Dir.tmpdir }
       end
     end
   end
 
-  def test_bad_type_returns_error
-    node = node('<message type="bogus">hello!</message>')
-    stanza = Vines::Stanza::Message.new(node, @stream)
-    assert_raises(Vines::StanzaErrors::BadRequest) { stanza.process }
+  before do
+    class << stream
+      attr_accessor :config, :user
+    end
+    stream.user = alice
+    stream.config = config
   end
 
-  def test_missing_to_address_is_sent_to_sender
-    alice = Vines::User.new(:jid => 'alice@wonderland.lit/tea')
-    node = node('<message>hello!</message>')
-
-    recipient = MiniTest::Mock.new
-    recipient.expect(:user, alice)
-    recipient.expect(:write, nil, [node])
-
-    @stream.expect(:user, alice)
-    @stream.expect(:connected_resources, [recipient], [alice.jid.bare])
+  describe 'when message type attribute is invalid' do
+    let(:xml) { node('<message type="bogus">hello!</message>') }
 
-    stanza = Vines::Stanza::Message.new(node, @stream)
-    stanza.process
-    assert @stream.verify
-    assert recipient.verify
+    it 'raises a bad-request stanza error' do
+      -> { subject.process }.must_raise Vines::StanzaErrors::BadRequest
+    end
   end
 
-  def test_message_to_non_user_is_ignored
-    bogus = Vines::JID.new('bogus@wonderland.lit/cake')
-    node = node(%Q{<message to="#{bogus}">hello!</message>})
-
-    storage = MiniTest::Mock.new
-    storage.expect(:find_user, nil, [bogus])
+  describe 'when the to address is missing' do
+    let(:xml) { node('<message>hello!</message>') }
+    let(:recipient) { MiniTest::Mock.new }
 
-    @stream.expect(:config, @config)
-    @stream.expect(:storage, storage, [bogus.domain])
-    @stream.expect(:connected_resources, [], [bogus])
+    before do
+      recipient.expect :user, alice
+      recipient.expect :write, nil, [xml]
+      stream.expect :connected_resources, [recipient], [alice.jid.bare]
+    end
 
-    stanza = Vines::Stanza::Message.new(node, @stream)
-    stanza.process
-    assert @stream.verify
-    assert storage.verify
+    it 'sends the message to the senders connected streams' do
+      subject.process
+      stream.verify
+      recipient.verify
+    end
   end
 
-  def test_message_to_offline_user_returns_error
-    hatter = Vines::User.new(:jid => 'hatter@wonderland.lit/cake')
-    node = node(%Q{<message to="#{hatter.jid}">hello!</message>})
-
-    storage = MiniTest::Mock.new
-    storage.expect(:find_user, hatter, [hatter.jid])
+  describe 'when addressed to a non-user' do
+    let(:bogus) { Vines::JID.new('bogus@wonderland.lit/cake') }
+    let(:xml) { node(%Q{<message to="#{bogus}">hello!</message>}) }
+    let(:storage) { MiniTest::Mock.new }
 
-    @stream.expect(:config, @config)
-    @stream.expect(:storage, storage, [hatter.jid.domain])
-    @stream.expect(:connected_resources, [], [hatter.jid])
+    before do
+      storage.expect :find_user, nil, [bogus]
+      stream.expect :storage, storage, [bogus.domain]
+      stream.expect :connected_resources, [], [bogus]
+    end
 
-    stanza = Vines::Stanza::Message.new(node, @stream)
-    assert_raises(Vines::StanzaErrors::ServiceUnavailable) { stanza.process }
-    assert @stream.verify
-    assert storage.verify
+    it 'ignores the stanza' do
+      subject.process
+      stream.verify
+      storage.verify
+    end
   end
 
-  def test_message_to_local_user_in_different_domain_is_delivered
-    alice = Vines::User.new(:jid => 'alice@wonderland.lit/tea')
-    romeo = Vines::User.new(:jid => 'romeo@verona.lit/balcony')
-    node = node(%Q{<message to="#{romeo.jid}">hello!</message>})
-    expected = node(%Q{<message to="#{romeo.jid}" from="#{alice.jid}">hello!</message>})
-
-    recipient = MiniTest::Mock.new
-    recipient.expect(:user, romeo)
-    recipient.expect(:write, nil, [expected])
+  describe 'when addressed to an offline user' do
+    let(:hatter) { Vines::User.new(jid: 'hatter@wonderland.lit/cake') }
+    let(:xml) { node(%Q{<message to="#{hatter.jid}">hello!</message>}) }
+    let(:storage) { MiniTest::Mock.new }
 
-    @config.host 'verona.lit' do
-      storage(:fs) { dir Dir.tmpdir }
+    before do
+      storage.expect :find_user, hatter, [hatter.jid]
+      stream.expect :storage, storage, [hatter.jid.domain]
+      stream.expect :connected_resources, [], [hatter.jid]
     end
 
-    @stream.expect(:config, @config)
-    @stream.expect(:user, alice)
-    @stream.expect(:connected_resources, [recipient], [romeo.jid])
-
-    stanza = Vines::Stanza::Message.new(node, @stream)
-    stanza.process
-    assert @stream.verify
-    assert recipient.verify
+    it 'raises a service-unavailable stanza error' do
+      -> { subject.process }.must_raise Vines::StanzaErrors::ServiceUnavailable
+      stream.verify
+      storage.verify
+    end
   end
 
-  def test_message_to_remote_user_is_routed
-    alice = Vines::User.new(:jid => 'alice@wonderland.lit/tea')
-    romeo = Vines::User.new(:jid => 'romeo@verona.lit/balcony')
-    node = node(%Q{<message to="#{romeo.jid}">hello!</message>})
-    expected = node(%Q{<message to="#{romeo.jid}" from="#{alice.jid}">hello!</message>})
+  describe 'when address to a local user in a different domain' do
+    let(:xml) { node(%Q{<message to="#{romeo.jid}">hello!</message>}) }
+    let(:expected) { node(%Q{<message to="#{romeo.jid}" from="#{alice.jid}">hello!</message>}) }
+    let(:recipient) { MiniTest::Mock.new }
+
+    before do
+      recipient.expect :user, romeo
+      recipient.expect :write, nil, [expected]
 
-    router = MiniTest::Mock.new
-    @stream.expect(:config, @config)
-    router.expect(:route, nil, [expected])
+      config.host 'verona.lit' do
+        storage(:fs) { dir Dir.tmpdir }
+      end
 
-    @stream.expect(:router, router)
-    @stream.expect(:user, alice)
+      stream.expect :connected_resources, [recipient], [romeo.jid]
+    end
 
-    stanza = Vines::Stanza::Message.new(node, @stream)
-    stanza.process
-    assert @stream.verify
-    assert router.verify
+    it 'delivers the stanza to the user' do
+      subject.process
+      stream.verify
+      recipient.verify
+    end
   end
 
-  private
+  describe 'when addressed to a remote user' do
+    let(:xml) { node(%Q{<message to="#{romeo.jid}">hello!</message>}) }
+    let(:expected) { node(%Q{<message to="#{romeo.jid}" from="#{alice.jid}">hello!</message>}) }
+    let(:router) { MiniTest::Mock.new }
 
-  def node(xml)
-    Nokogiri::XML(xml).root
+    before do
+      router.expect :route, nil, [expected]
+      stream.expect :router, router
+    end
+
+    it 'routes rather than handle locally' do
+      subject.process
+      stream.verify
+      router.verify
+    end
   end
 end

data/test/stanza/presence/probe_test.rb

@@ -1,11 +1,8 @@
 # encoding: UTF-8
 
-require 'tmpdir'
-require 'vines'
-require 'ext/nokogiri'
-require 'minitest/autorun'
+require 'test_helper'
 
-class ProbeTest < MiniTest::Unit::TestCase
+describe Vines::Stanza::Presence::Probe do
   def setup
     @alice = Vines::JID.new('alice@wonderland.lit/tea')
     @stream = MiniTest::Mock.new