vines 0.1.0

data/test/stanza/message_test.rb

@@ -0,0 +1,124 @@
+# encoding: UTF-8
+
+require 'vines'
+require 'ext/nokogiri'
+require 'minitest/mock'
+require 'test/unit'
+
+class MessageTest < Test::Unit::TestCase
+  def setup
+    @stream = MiniTest::Mock.new
+  end
+
+  def test_bad_type_returns_error
+    node = node('<message type="bogus">hello!</message>')
+    stanza = Vines::Stanza::Message.new(node, @stream)
+    assert_raise(Vines::StanzaErrors::BadRequest) { stanza.process }
+  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
+    router = MiniTest::Mock.new
+    router.expect(:local?, true, [node])
+    router.expect(:connected_resources, [recipient], [alice.jid.bare])
+
+    @stream.expect(:router, router)
+    @stream.expect(:user, alice)
+    @stream.expect(:broadcast, nil, [node, [recipient]])
+
+    stanza = Vines::Stanza::Message.new(node, @stream)
+    assert_nothing_raised { stanza.process }
+    assert @stream.verify
+    assert router.verify
+    assert recipient.verify
+  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>})
+
+    router = MiniTest::Mock.new
+    router.expect(:local?, true, [node])
+    router.expect(:connected_resources, [], [bogus])
+
+    storage = MiniTest::Mock.new
+    storage.expect(:find_user, nil, [bogus])
+
+    @stream.expect(:router, router)
+    @stream.expect(:storage, storage, [bogus.domain])
+
+    stanza = Vines::Stanza::Message.new(node, @stream)
+    assert_nothing_raised { stanza.process }
+    assert @stream.verify
+    assert router.verify
+    assert storage.verify
+  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>})
+
+    router = MiniTest::Mock.new
+    router.expect(:local?, true, [node])
+    router.expect(:connected_resources, [], [hatter.jid])
+
+    storage = MiniTest::Mock.new
+    storage.expect(:find_user, hatter, [hatter.jid])
+
+    @stream.expect(:router, router)
+    @stream.expect(:storage, storage, [hatter.jid.domain])
+
+    stanza = Vines::Stanza::Message.new(node, @stream)
+    assert_raise(Vines::StanzaErrors::ServiceUnavailable) { stanza.process }
+    assert @stream.verify
+    assert router.verify
+    assert storage.verify
+  end
+
+  def test_message_to_local_user_in_different_domain_is_delivered
+    romeo = Vines::User.new(:jid => 'romeo@verona.lit/balcony')
+    node = node(%Q{<message to="#{romeo.jid}">hello!</message>})
+
+    recipient = MiniTest::Mock.new
+    router = MiniTest::Mock.new
+    router.expect(:local?, true, [node])
+    router.expect(:connected_resources, [recipient], [romeo.jid])
+
+    @stream.expect(:router, router)
+    @stream.expect(:broadcast, nil, [node, [recipient]])
+
+    stanza = Vines::Stanza::Message.new(node, @stream)
+    assert_nothing_raised { stanza.process }
+    assert @stream.verify
+    assert router.verify
+    assert recipient.verify
+  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>})
+
+    router = MiniTest::Mock.new
+    router.expect(:local?, false, [node])
+    router.expect(:route, nil, [expected])
+
+    @stream.expect(:router, router)
+    @stream.expect(:user, alice)
+
+    stanza = Vines::Stanza::Message.new(node, @stream)
+    assert_nothing_raised { stanza.process }
+    assert @stream.verify
+    assert router.verify
+  end
+
+  private
+
+  def node(xml)
+    Nokogiri::XML(xml).root
+  end
+end

data/test/stanza/presence/subscribe_test.rb

@@ -0,0 +1,75 @@
+# encoding: UTF-8
+
+require 'vines'
+require 'ext/nokogiri'
+require 'minitest/mock'
+require 'test/unit'
+
+class SubscribeTest < Test::Unit::TestCase
+  def test_outbound_subscribe_to_local_jid_but_missing_contact
+    alice = Vines::JID.new('alice@wonderland.lit/tea')
+    hatter = Vines::JID.new('hatter@wonderland.lit')
+
+    contact = Vines::Contact.new(:jid => hatter)
+
+    user = MiniTest::Mock.new
+    user.expect(:jid, alice)
+    user.expect(:request_subscription, nil, [hatter.to_s])
+    user.expect(:contact, contact, [hatter])
+
+    storage = MiniTest::Mock.new
+    storage.expect(:save_user, nil, [user])
+    storage.expect(:find_user, nil, [hatter])
+
+    recipient = MiniTest::Mock.new
+    recipient.expect(:user, Vines::User.new(:jid => hatter))
+    def recipient.nodes; @nodes; end
+    def recipient.write(node)
+      @nodes ||= []
+      @nodes << node
+    end
+
+    router = MiniTest::Mock.new
+    router.expect(:interested_resources, [recipient], [alice])
+
+    stream = MiniTest::Mock.new
+    stream.expect(:domain, 'wonderland.lit')
+    stream.expect(:storage, storage, ['wonderland.lit'])
+    stream.expect(:user, user)
+    stream.expect(:router, router)
+    stream.expect(:update_user_streams, nil, [user])
+    def stream.nodes; @nodes; end
+    def stream.write(node)
+      @nodes ||= []
+      @nodes << node
+    end
+
+    node = node(%q{<presence id="42" to="hatter@wonderland.lit" type="subscribe"/>})
+    stanza = Vines::Stanza::Presence::Subscribe.new(node, stream)
+    def stanza.route_iq; false; end
+    def stanza.inbound?; false; end
+    def stanza.local?;   true; end
+
+    stanza.process
+    assert stream.verify
+    assert user.verify
+    assert storage.verify
+    assert router.verify
+    assert_equal 1, stream.nodes.size
+    assert_equal 1, recipient.nodes.size
+
+    expected = node(%q{<presence from="hatter@wonderland.lit" id="42" to="alice@wonderland.lit" type="unsubscribed"/>})
+    assert_equal expected, stream.nodes[0]
+
+    query = %q{<query xmlns="jabber:iq:roster"><item jid="hatter@wonderland.lit" subscription="none"/></query>}
+    expected = node(%Q{<iq to="alice@wonderland.lit/tea" type="set">#{query}</iq>})
+    recipient.nodes[0].remove_attribute('id') # id is random
+    assert_equal expected, recipient.nodes[0]
+  end
+
+  private
+
+  def node(xml)
+    Nokogiri::XML(xml).root
+  end
+end

data/test/storage/couchdb_test.rb

@@ -0,0 +1,102 @@
+# encoding: UTF-8
+
+require 'storage_tests'
+require 'vines'
+require 'test/unit'
+
+class CouchDBTest < Test::Unit::TestCase
+  include StorageTests
+
+  URL = 'http://localhost:5984/xmpp_testcase'.freeze
+
+  def setup
+    EMLoop.new do
+      database(:put)
+      save_doc({'_id' => 'user:empty@wonderland.lit'})
+
+      save_doc({
+        '_id'  => 'user:no_password@wonderland.lit',
+        'type' => 'User',
+        'foo'  => 'bar'})
+
+      save_doc({
+        '_id'      => 'user:clear_password@wonderland.lit',
+        'type'     => 'User',
+        'password' => 'secret'})
+
+      save_doc({
+        '_id'      => 'user:bcrypt_password@wonderland.lit',
+        'type'     => 'User',
+        'password' => BCrypt::Password.create('secret')})
+
+      save_doc({
+        '_id'      => 'user:full@wonderland.lit',
+        'type'     => 'User',
+        'password' => BCrypt::Password.create('secret'),
+        'name'     => 'Tester',
+        'roster'   => {
+          'contact1@wonderland.lit' => {
+            'name'   => 'Contact1',
+            'groups' => %w[Group1 Group2]
+          },
+          'contact2@wonderland.lit' => {
+            'name'   => 'Contact2',
+            'groups' => %w[Group3 Group4]
+          }
+        }
+      })
+
+      save_doc({
+        '_id'  => 'vcard:full@wonderland.lit',
+        'type' => 'Vcard',
+        'card' => StorageTests::VCARD.to_xml
+      })
+    end
+  end
+
+  def teardown
+    EMLoop.new do
+      database(:delete)
+    end
+  end
+
+  def save_doc(doc)
+    fiber = Fiber.current
+    http = EM::HttpRequest.new(URL).post(
+      :head => {'Content-Type' => 'application/json'},
+      :body => doc.to_json)
+    http.callback { fiber.resume }
+    http.errback { raise 'save_doc failed' }
+    Fiber.yield
+  end
+
+  def database(method=:put)
+    fiber = Fiber.current
+    http = EM::HttpRequest.new(URL).send(method)
+    http.callback { fiber.resume }
+    http.errback { raise "#{method} database failed" }
+    Fiber.yield
+  end
+
+  def storage
+    Vines::Storage::CouchDB.new do
+      host 'localhost'
+      port 5984
+      database 'xmpp_testcase'
+    end
+  end
+
+  def test_init
+    EMLoop.new do
+      assert_raise(RuntimeError) { Vines::Storage::CouchDB.new {} }
+      assert_raise(RuntimeError) { Vines::Storage::CouchDB.new { host 'localhost' } }
+      assert_nothing_raised do
+        Vines::Storage::CouchDB.new do
+          host 'localhost'
+          port '5984'
+          database 'test'
+        end
+      end
+    end
+  end
+end

data/test/storage/ldap_test.rb

@@ -0,0 +1,207 @@
+# encoding: UTF-8
+
+require 'vines'
+require 'minitest/mock'
+require 'test/unit'
+
+class LdapTest < Test::Unit::TestCase
+  ALICE_DN = 'uid=alice@wondlerand.lit,ou=People,dc=wonderland,dc=lit'
+  CONTEXT = {}
+
+  def setup
+  end
+
+  def teardown
+    CONTEXT.clear
+  end
+
+  def test_missing_host_and_port
+    assert_raises(RuntimeError) do
+      Vines::Storage::Ldap.new(nil, nil) do
+        tls true
+        dn 'cn=Directory Manager'
+        password 'secr3t'
+        basedn 'dc=wonderland,dc=lit'
+        object_class 'person'
+        user_attr 'uid'
+        name_attr 'cn'
+      end
+    end
+  end
+
+  def test_default_host_and_port
+    assert_nothing_raised do
+      Vines::Storage::Ldap.new do
+        tls true
+        dn 'cn=Directory Manager'
+        password 'secr3t'
+        basedn 'dc=wonderland,dc=lit'
+        object_class 'person'
+        user_attr 'uid'
+        name_attr 'cn'
+      end
+    end
+  end
+
+  def test_configured_host_and_port
+    assert_nothing_raised do
+      Vines::Storage::Ldap.new('0.0.0.1', 42) do
+        tls true
+        dn 'cn=Directory Manager'
+        password 'secr3t'
+        basedn 'dc=wonderland,dc=lit'
+        object_class 'person'
+        user_attr 'uid'
+        name_attr 'cn'
+      end
+    end
+  end
+
+  def test_missing_parameters
+    assert_raises(RuntimeError) do
+      Vines::Storage::Ldap.new {}
+    end
+  end
+
+  def test_blank_parameters
+    assert_raises(RuntimeError) do
+      Vines::Storage::Ldap.new do
+        tls
+        dn
+        password
+        basedn
+        object_class
+        user_attr
+        name_attr
+      end
+    end
+  end
+
+  # Make sure we properly handle boolean false values.
+  def test_false_tls
+    assert_nothing_raised do
+      Vines::Storage::Ldap.new do
+        tls false
+        dn 'cn=Directory Manager'
+        password 'secr3t'
+        basedn 'dc=wonderland,dc=lit'
+        object_class 'person'
+        user_attr 'uid'
+        name_attr 'cn'
+      end
+    end
+  end
+
+  def test_authenticate_with_missing_credentials
+    ldap = connect
+    assert_nil ldap.authenticate(nil, nil)
+    assert_nil ldap.authenticate('', '')
+    assert_nil ldap.authenticate('user', ' ')
+  end
+
+  def test_authenticate_user_not_found
+    CONTEXT.merge!({
+      :mock_ldap => MiniTest::Mock.new,
+      :connect_calls => 0
+    })
+    ldap = connect
+    def ldap.connect(dn, password)
+      CONTEXT[:connect_calls] += 1
+      raise unless 'cn=Directory Manager' == dn
+      raise unless 'secr3t' == password
+
+      clas = Net::LDAP::Filter.eq('objectClass', 'person')
+      uid = Net::LDAP::Filter.eq('uid', 'alice@wonderland.lit')
+
+      mock = CONTEXT[:mock_ldap]
+      mock.expect(:search, [], [{:attributes => ['cn', 'mail'], :filter => clas & uid}])
+    end
+    assert_nil ldap.authenticate('alice@wonderland.lit', 'passw0rd')
+    assert CONTEXT[:mock_ldap]
+    assert_equal 1, CONTEXT[:connect_calls]
+  end
+
+  def test_authenticate_user_fails_bind
+    CONTEXT.merge!({
+      :credentials => [
+        {:dn => 'cn=Directory Manager', :password => 'secr3t'},
+        {:dn => ALICE_DN, :password => 'passw0rd'}
+      ],
+      :mock_ldap => MiniTest::Mock.new,
+      :mock_entry => MiniTest::Mock.new,
+      :connect_calls => 0
+    })
+    ldap = connect
+    def ldap.connect(dn, password)
+      credentials = CONTEXT[:credentials][CONTEXT[:connect_calls]]
+      CONTEXT[:connect_calls] += 1
+      raise unless credentials[:dn] == dn && credentials[:password] == password
+
+      clas = Net::LDAP::Filter.eq('objectClass', 'person')
+      uid = Net::LDAP::Filter.eq('uid', 'alice@wonderland.lit')
+
+      entry = CONTEXT[:mock_entry]
+      entry.expect(:dn, ALICE_DN)
+
+      mock = CONTEXT[:mock_ldap]
+      mock.expect(:search, [entry], [{:attributes => ['cn', 'mail'], :filter => clas & uid}])
+      mock.expect(:bind, false)
+    end
+    assert_nil ldap.authenticate('alice@wonderland.lit', 'passw0rd')
+    assert_equal 2, CONTEXT[:connect_calls]
+    assert CONTEXT[:mock_entry].verify
+    assert CONTEXT[:mock_ldap].verify
+  end
+
+  def test_authenticate_success
+    CONTEXT.merge!({
+      :credentials => [
+        {:dn => 'cn=Directory Manager', :password => 'secr3t'},
+        {:dn => ALICE_DN, :password => 'passw0rd'}
+      ],
+      :mock_ldap => MiniTest::Mock.new,
+      :mock_entry => MiniTest::Mock.new,
+      :connect_calls => 0
+    })
+    ldap = connect
+    def ldap.connect(dn, password)
+      credentials = CONTEXT[:credentials][CONTEXT[:connect_calls]]
+      CONTEXT[:connect_calls] += 1
+      raise unless credentials[:dn] == dn && credentials[:password] == password
+
+      clas = Net::LDAP::Filter.eq('objectClass', 'person')
+      uid = Net::LDAP::Filter.eq('uid', 'alice@wonderland.lit')
+
+      entry = CONTEXT[:mock_entry]
+      entry.expect(:dn, ALICE_DN)
+      entry.expect(:[], ['Alice Liddell'], ['cn'])
+
+      mock = CONTEXT[:mock_ldap]
+      mock.expect(:search, [entry], [{:attributes => ['cn', 'mail'], :filter => clas & uid}])
+      mock.expect(:bind, true)
+    end
+    user = ldap.authenticate('alice@wonderland.lit', 'passw0rd')
+    assert_not_nil user
+    assert_equal 'alice@wonderland.lit', user.jid.to_s
+    assert_equal 'Alice Liddell', user.name
+    assert_equal [], user.roster
+
+    assert_equal 2, CONTEXT[:connect_calls]
+    assert CONTEXT[:mock_entry].verify
+    assert CONTEXT[:mock_ldap].verify
+  end
+
+  private
+
+  def connect
+    Vines::Storage::Ldap.new('0.0.0.0', 636) do
+      tls true
+      dn 'cn=Directory Manager'
+      password 'secr3t'
+      basedn 'dc=wonderland,dc=lit'
+      object_class 'person'
+      user_attr 'uid'
+      name_attr 'cn'
+    end
+  end
+end