vines 0.4.5 → 0.4.6

data/test/stanza_test.rb

@@ -1,78 +1,85 @@
 # encoding: UTF-8
 
-require 'tmpdir'
-require 'vines'
-require 'ext/nokogiri'
-require 'minitest/autorun'
-
-class StanzaTest < MiniTest::Unit::TestCase
-  def setup
-    @alice = Vines::JID.new('alice@wonderland.lit/tea')
-    @romeo = Vines::JID.new('romeo@verona.lit/balcony')
-    @stream = MiniTest::Mock.new
-    @config = Vines::Config.new do
+require 'test_helper'
+
+describe Vines::Stanza do
+  subject      { Vines::Stanza::Message.new(xml, stream) }
+  let(:alice)  { Vines::JID.new('alice@wonderland.lit/tea') }
+  let(:romeo)  { Vines::JID.new('romeo@verona.lit/balcony') }
+  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_validate_missing_addresses
-    node = node(%Q{<message>hello!</message>})
-    stanza = Vines::Stanza::Message.new(node, @stream)
-    assert_nil stanza.validate_to
-    assert_nil stanza.validate_from
-    assert @stream.verify
-  end
+  describe 'when stanza contains no addresses' do
+    let(:xml) { node(%Q{<message>hello!</message>}) }
 
-  def test_validate_valid_addresses
-    node = node(%Q{<message from="#{@alice}" to="#{@romeo}">hello!</message>})
-    stanza = Vines::Stanza::Message.new(node, @stream)
-    assert_equal @romeo, stanza.validate_to
-    assert_equal @alice, stanza.validate_from
-    assert @stream.verify
+    it 'validates them as nil' do
+      subject.validate_to.must_be_nil
+      subject.validate_from.must_be_nil
+      stream.verify
+    end
   end
 
-  def test_validate_invalid_addresses
-    node = node(%Q{<message from="a lice@wonderland.lit" to="romeo@v erona.lit">hello!</message>})
-    stanza = Vines::Stanza::Message.new(node, @stream)
-    assert_raises(Vines::StanzaErrors::JidMalformed) { stanza.validate_to }
-    assert_raises(Vines::StanzaErrors::JidMalformed) { stanza.validate_from }
-    assert @stream.verify
+  describe 'when stanza contains valid addresses' do
+    let(:xml) { node(%Q{<message from="#{alice}" to="#{romeo}">hello!</message>}) }
+
+    it 'validates and returns JID objects' do
+      subject.validate_to.must_equal romeo
+      subject.validate_from.must_equal alice
+      stream.verify
+    end
   end
 
-  def test_non_routable_stanza_is_local
-    stanza = Vines::Stanza.new(node('<auth/>'), @stream)
-    assert stanza.local?
-    assert @stream.verify
+  describe 'when stanza contains invalid addresses' do
+    let(:xml) { node(%Q{<message from="a lice@wonderland.lit" to="romeo@v erona.lit">hello!</message>}) }
+
+    it 'raises a jid-malformed stanza error' do
+      -> { subject.validate_to }.must_raise Vines::StanzaErrors::JidMalformed
+      -> { subject.validate_from }.must_raise Vines::StanzaErrors::JidMalformed
+      stream.verify
+    end
   end
 
-  def test_stanza_missing_to_is_local
-    node = node(%Q{<message>hello!</message>})
-    stanza = Vines::Stanza::Message.new(node, @stream)
-    assert stanza.local?
-    assert @stream.verify
+  describe 'when receiving a non-routable stanza type' do
+    let(:xml) { node('<auth/>') }
+
+    it 'handles locally rather than routing' do
+      subject.local?.must_equal true
+      stream.verify
+    end
   end
 
-  def test_stanza_with_local_jid_is_local
-    node = node(%Q{<message to="#{@alice}">hello!</message>})
-    @stream.expect(:config, @config)
-    stanza = Vines::Stanza::Message.new(node, @stream)
-    assert stanza.local?
-    assert @stream.verify
+  describe 'when stanza is missing a to address' do
+    let(:xml) { node(%Q{<message>hello!</message>}) }
+
+    it 'handles locally rather than routing' do
+      subject.local?.must_equal true
+      stream.verify
+    end
   end
 
-  def test_stanza_with_remote_jid_is_not_local
-    node = node(%Q{<message to="#{@romeo}">hello!</message>})
-    @stream.expect(:config, @config)
-    stanza = Vines::Stanza::Message.new(node, @stream)
-    refute stanza.local?
-    assert @stream.verify
+  describe 'when stanza is addressed to a local jid' do
+    let(:xml) { node(%Q{<message to="#{alice}">hello!</message>}) }
+
+    it 'handles locally rather than routing' do
+      stream.expect :config, config
+      subject.local?.must_equal true
+      stream.verify
+    end
   end
 
-  private
+  describe 'when stanza is addressed to a remote jid' do
+    let(:xml) { node(%Q{<message to="#{romeo}">hello!</message>}) }
 
-  def node(xml)
-    Nokogiri::XML(xml).root
+    it 'is not considered a local stanza' do
+      stream.expect :config, config
+      subject.local?.must_equal false
+      stream.verify
+    end
   end
 end

data/test/storage/ldap_test.rb

@@ -1,7 +1,6 @@
 # encoding: UTF-8
 
-require 'vines'
-require 'minitest/autorun'
+require 'test_helper'
 
 describe Vines::Storage::Ldap do
   ALICE_DN = 'uid=alice@wondlerand.lit,ou=People,dc=wonderland,dc=lit'

data/test/storage/local_test.rb

@@ -1,11 +1,9 @@
 # encoding: UTF-8
 
 require 'storage_tests'
-require 'tmpdir'
-require 'vines'
-require 'minitest/autorun'
+require 'test_helper'
 
-class LocalTest < MiniTest::Unit::TestCase
+describe Vines::Storage::Local do
   include StorageTests
 
   DIR = Dir.mktmpdir
@@ -23,7 +21,7 @@ class LocalTest < MiniTest::Unit::TestCase
       :bcrypt     => "#{DIR}/user/bcrypt_password@wonderland.lit",
       :full       => "#{DIR}/user/full@wonderland.lit",
       :vcard      => "#{DIR}/vcard/full@wonderland.lit",
-      :fragment   => "#{DIR}/fragment/full@wonderland.lit-#{FRAGMENT_ID}"
+      :fragment   => "#{DIR}/fragment/full@wonderland.lit-#{StorageTests::FRAGMENT_ID}"
     }
     File.open(files[:empty], 'w') {|f| f.write('') }
     File.open(files[:no_pass], 'w') {|f| f.write('foo: bar') }

data/test/storage/null_test.rb

@@ -1,10 +1,9 @@
 # encoding: UTF-8
 
-require 'vines'
-require 'minitest/autorun'
+require 'test_helper'
 
-class NullStorageTest < MiniTest::Unit::TestCase
-  def setup
+describe Vines::Storage::Null do
+  before do
     @storage = Vines::Storage::Null.new
     @user = Vines::User.new(jid: 'alice@wonderland.lit')
   end

data/test/storage/storage_tests.rb

@@ -1,8 +1,6 @@
 # encoding: UTF-8
 
-require 'vines'
-require 'ext/nokogiri'
-require 'minitest/autorun'
+require 'test_helper'
 
 # Mixin methods for storage implementation test classes. The behavioral
 # tests are the same regardless of implementation so share those methods

data/test/storage_test.rb

@@ -1,8 +1,7 @@
 # encoding: UTF-8
 
 require 'storage_tests'
-require 'vines'
-require 'minitest/autorun'
+require 'test_helper'
 
 describe Vines::Storage do
   ALICE = 'alice@wonderland.lit'.freeze

data/test/store_test.rb

@@ -1,7 +1,6 @@
 # encoding: UTF-8
 
-require 'vines'
-require 'minitest/autorun'
+require 'test_helper'
 
 describe Vines::Store do
   before do

data/test/stream/client/auth_test.rb

@@ -1,7 +1,6 @@
 # encoding: UTF-8
 
-require 'vines'
-require 'minitest/autorun'
+require 'test_helper'
 
 describe Vines::Stream::Client::Auth do
   # disable logging for tests
@@ -27,113 +26,112 @@ describe Vines::Stream::Client::Auth do
     end
   end
 
-  before do
-    @stream = MiniTest::Mock.new
-    @state = Vines::Stream::Client::Auth.new(@stream)
-  end
+  subject      { Vines::Stream::Client::Auth.new(stream) }
+  let(:stream) { MiniTest::Mock.new }
 
   describe 'error handling' do
     it 'rejects invalid element' do
       node = node('<bogus/>')
-      assert_raises(Vines::StreamErrors::NotAuthorized) { @state.node(node) }
+      -> { subject.node(node) }.must_raise Vines::StreamErrors::NotAuthorized
     end
 
     it 'rejects invalid element in sasl namespace' do
       node = node(%Q{<bogus xmlns="#{Vines::NAMESPACES[:sasl]}"/>})
-      assert_raises(Vines::StreamErrors::NotAuthorized) { @state.node(node) }
+      -> { subject.node(node) }.must_raise Vines::StreamErrors::NotAuthorized
     end
 
     it 'rejects auth elements missing sasl namespace' do
       node = node('<auth/>')
-      assert_raises(Vines::StreamErrors::NotAuthorized) { @state.node(node) }
+      -> { subject.node(node) }.must_raise Vines::StreamErrors::NotAuthorized
     end
 
     it 'rejects auth element with invalid namespace' do
       node = node('<auth xmlns="bogus"/>')
-      assert_raises(Vines::StreamErrors::NotAuthorized) { @state.node(node) }
+      -> { subject.node(node) }.must_raise Vines::StreamErrors::NotAuthorized
     end
 
     it 'rejects valid auth element missing mechanism' do
-      @stream.expect(:error, nil, [Vines::SaslErrors::InvalidMechanism])
-      @stream.expect(:authentication_mechanisms, ['PLAIN'])
+      stream.expect :error, nil, [Vines::SaslErrors::InvalidMechanism]
+      stream.expect :authentication_mechanisms, ['PLAIN']
       node = node(%Q{<auth xmlns="#{Vines::NAMESPACES[:sasl]}">tokens</auth>})
-      @state.node(node)
-      assert @stream.verify
+      subject.node(node)
+      stream.verify
     end
 
     it 'rejects valid auth element with invalid mechanism' do
-      @stream.expect(:error, nil, [Vines::SaslErrors::InvalidMechanism])
-      @stream.expect(:authentication_mechanisms, ['PLAIN'])
+      stream.expect :error, nil, [Vines::SaslErrors::InvalidMechanism]
+      stream.expect :authentication_mechanisms, ['PLAIN']
       node = node(%Q{<auth xmlns="#{Vines::NAMESPACES[:sasl]}" mechanism="bogus">tokens</auth>})
-      @state.node(node)
-      assert @stream.verify
+      subject.node(node)
+      stream.verify
     end
   end
 
   describe 'plain auth' do
     it 'rejects valid mechanism missing base64 text' do
-      @stream.expect(:error, nil, [Vines::SaslErrors::MalformedRequest])
-      node = node(%Q{<auth xmlns="#{Vines::NAMESPACES[:sasl]}" mechanism="PLAIN"></auth>})
-      @state.node(node)
-      assert @stream.verify
+      stream.expect :error, nil, [Vines::SaslErrors::MalformedRequest]
+      node = plain('')
+      subject.node(node)
+      stream.verify
     end
 
     it 'rejects invalid base64 text' do
-      @stream.expect(:error, nil, [Vines::SaslErrors::IncorrectEncoding])
-      @stream.expect(:authentication_mechanisms, ['PLAIN'])
-      node = node(%Q{<auth xmlns="#{Vines::NAMESPACES[:sasl]}" mechanism="PLAIN">tokens</auth>})
-      @state.node(node)
-      assert @stream.verify
+      stream.expect :error, nil, [Vines::SaslErrors::IncorrectEncoding]
+      stream.expect :authentication_mechanisms, ['PLAIN']
+      node = plain('tokens')
+      subject.node(node)
+      stream.verify
     end
 
     it 'rejects invalid password' do
-      @stream.expect(:storage, MockStorage.new)
-      @stream.expect(:domain, 'wonderland.lit')
-      @stream.expect(:error, nil, [Vines::SaslErrors::NotAuthorized])
-      @stream.expect(:authentication_mechanisms, ['PLAIN'])
-      node = node(%Q{<auth xmlns="#{Vines::NAMESPACES[:sasl]}" mechanism="PLAIN">#{Base64.strict_encode64("\x00alice\x00bogus")}</auth>})
-      @state.node(node)
-      assert @stream.verify
+      stream.expect :storage, MockStorage.new
+      stream.expect :domain, 'wonderland.lit'
+      stream.expect :error, nil, [Vines::SaslErrors::NotAuthorized]
+      stream.expect :authentication_mechanisms, ['PLAIN']
+      node = plain(Base64.strict_encode64("\x00alice\x00bogus"))
+      subject.node(node)
+      stream.verify
     end
 
     it 'passes with valid password' do
       user = Vines::User.new(jid: 'alice@wonderland.lit')
-      @stream.expect(:reset, nil)
-      @stream.expect(:domain, 'wonderland.lit')
-      @stream.expect(:storage, MockStorage.new)
-      @stream.expect(:user=, nil, [user])
-      @stream.expect(:write, nil, [%Q{<success xmlns="#{Vines::NAMESPACES[:sasl]}"/>}])
-      @stream.expect(:advance, nil, [Vines::Stream::Client::BindRestart])
-      @stream.expect(:authentication_mechanisms, ['PLAIN'])
-      node = node(%Q{<auth xmlns="#{Vines::NAMESPACES[:sasl]}" mechanism="PLAIN">#{Base64.strict_encode64("\x00alice\x00secr3t")}</auth>})
-      @state.node(node)
-      assert @stream.verify
+      stream.expect :reset, nil
+      stream.expect :domain, 'wonderland.lit'
+      stream.expect :storage, MockStorage.new
+      stream.expect :user=, nil, [user]
+      stream.expect :write, nil, [%Q{<success xmlns="#{Vines::NAMESPACES[:sasl]}"/>}]
+      stream.expect :advance, nil, [Vines::Stream::Client::BindRestart]
+      stream.expect :authentication_mechanisms, ['PLAIN']
+      node = plain(Base64.strict_encode64("\x00alice\x00secr3t"))
+      subject.node(node)
+      stream.verify
     end
 
     it 'raises policy-violation after max auth attempts is reached' do
-      @stream.expect(:domain, 'wonderland.lit')
-      @stream.expect(:authentication_mechanisms, ['PLAIN'])
-      @stream.expect(:storage, MockStorage.new)
-      node = proc do
-        node(%Q{<auth xmlns="#{Vines::NAMESPACES[:sasl]}" mechanism="PLAIN">#{Base64.strict_encode64("\x00alice\x00bogus")}</auth>})
-      end
-
-      @stream.expect(:error, nil, [Vines::SaslErrors::NotAuthorized])
-      @state.node(node.call)
-      assert @stream.verify
-
-      @state.node(node.call)
-      assert @stream.verify
-
-      @stream.expect(:error, nil, [Vines::StreamErrors::PolicyViolation])
-      @state.node(node.call)
-      assert @stream.verify
+      stream.expect :domain, 'wonderland.lit'
+      stream.expect :storage, MockStorage.new
+      node = -> { plain(Base64.strict_encode64("\x00alice\x00bogus")) }
+
+      stream.expect :authentication_mechanisms, ['PLAIN']
+      stream.expect :error, nil, [Vines::SaslErrors::NotAuthorized]
+      subject.node(node.call)
+      stream.verify
+
+      stream.expect :authentication_mechanisms, ['PLAIN']
+      stream.expect :error, nil, [Vines::SaslErrors::NotAuthorized]
+      subject.node(node.call)
+      stream.verify
+
+      stream.expect :authentication_mechanisms, ['PLAIN']
+      stream.expect :error, nil, [Vines::StreamErrors::PolicyViolation]
+      subject.node(node.call)
+      stream.verify
     end
   end
 
   private
 
-  def node(xml)
-    Nokogiri::XML(xml).root
+  def plain(authzid)
+    node(%Q{<auth xmlns="#{Vines::NAMESPACES[:sasl]}" mechanism="PLAIN">#{authzid}</auth>})
   end
 end

data/test/stream/client/ready_test.rb

@@ -1,12 +1,11 @@
 # encoding: UTF-8
 
-require 'vines'
-require 'minitest/autorun'
+require 'test_helper'
 
-class ClientReadyTest < MiniTest::Unit::TestCase
+describe Vines::Stream::Client::Ready do
   STANZAS = []
 
-  def setup
+  before do
     @stream = MiniTest::Mock.new
     @state = Vines::Stream::Client::Ready.new(@stream, nil)
     def @state.to_stanza(node)
@@ -17,24 +16,24 @@ class ClientReadyTest < MiniTest::Unit::TestCase
         stanza.expect(:process, nil)
         stanza.expect(:validate_to, nil)
         stanza.expect(:validate_from, nil)
-        ClientReadyTest::STANZAS << stanza
+        STANZAS << stanza
         stanza
       end
     end
   end
 
-  def teardown
+  after do
     STANZAS.clear
   end
 
-  def test_good_node_processes
+  it 'processes a valid node' do
     node = node('<message/>')
     @state.node(node)
     assert_equal 1, STANZAS.size
     assert STANZAS.map {|s| s.verify }.all?
   end
 
-  def test_unsupported_stanza_type
+  it 'raises an unsupported-stanza-type stream error for invalid node' do
     node = node('<bogus/>')
     assert_raises(Vines::StreamErrors::UnsupportedStanzaType) { @state.node(node) }
     assert STANZAS.empty?

data/test/stream/client/session_test.rb

@@ -1,26 +1,27 @@
 # encoding: UTF-8
 
-require 'vines'
-require 'minitest/autorun'
+require 'test_helper'
 
-class ClientSessionTest < MiniTest::Unit::TestCase
-  def setup
-    @stream = MiniTest::Mock.new
-    @stream.expect(:config, nil)
-  end
-
-  def test_equality
-    one = Vines::Stream::Client::Session.new(@stream)
-    two = Vines::Stream::Client::Session.new(@stream)
+describe Vines::Stream::Client::Session do
+  subject       { Vines::Stream::Client::Session.new(stream) }
+  let(:another) { Vines::Stream::Client::Session.new(stream) }
+  let(:stream)  { OpenStruct.new(config: nil) }
 
-    assert_nil one <=> 42
+  describe 'session equality checks' do
+    it 'uses class in equality check' do
+      (subject <=> 42).must_be_nil
+    end
 
-    assert one == one
-    assert one.eql?(one)
-    assert one.hash == one.hash
+    it 'is equal to itself' do
+      assert subject == subject
+      assert subject.eql?(subject)
+      assert subject.hash == subject.hash
+    end
 
-    refute one == two
-    refute one.eql?(two)
-    refute one.hash == two.hash
+    it 'is not equal to another session' do
+      refute subject == another
+      refute subject.eql?(another)
+      refute subject.hash == another.hash
+    end
   end
 end