lygneo-vines 0.1.1

data/test/stanza_test.rb

@@ -0,0 +1,85 @@
+# encoding: UTF-8
+
+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
+
+  describe 'when stanza contains no addresses' do
+    let(:xml) { node(%Q{<message>hello!</message>}) }
+
+    it 'validates them as nil' do
+      subject.validate_to.must_be_nil
+      subject.validate_from.must_be_nil
+      stream.verify
+    end
+  end
+
+  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
+
+  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
+
+  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
+
+  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
+
+  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
+
+  describe 'when stanza is addressed to a remote jid' do
+    let(:xml) { node(%Q{<message to="#{romeo}">hello!</message>}) }
+
+    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

@@ -0,0 +1,201 @@
+# encoding: UTF-8
+
+require 'test_helper'
+
+describe Vines::Storage::Ldap do
+  ALICE_DN = 'uid=alice@wondlerand.lit,ou=People,dc=wonderland,dc=lit'
+  CONTEXT = {}
+
+  after do
+    CONTEXT.clear
+  end
+
+  describe '#initialize' do
+    it 'raises with missing host and port' do
+      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
+
+    it 'does not raise when using default host and port' 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
+
+    it 'does not raise when given a host and port' 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
+
+    it 'raises when given no parameters' do
+      assert_raises(RuntimeError) do
+        Vines::Storage::Ldap.new {}
+      end
+    end
+
+    it 'raises when given blank parameters' do
+      assert_raises(RuntimeError) do
+        Vines::Storage::Ldap.new do
+          tls
+          dn
+          password
+          basedn
+          object_class
+          user_attr
+          name_attr
+        end
+      end
+    end
+
+    it 'handles boolean false values without raising' 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
+
+  describe '#authenticate' do
+    it 'fails with invalid credentials' do
+      ldap = connect
+      assert_nil ldap.authenticate(nil, nil)
+      assert_nil ldap.authenticate('', '')
+      assert_nil ldap.authenticate('alice@wonderland.lit', ' ')
+      assert_nil ldap.authenticate('bogus"jid@wonderland.lit', 'password')
+      assert_nil ldap.authenticate(Vines::JID.new('alice@wonderland.lit'), '')
+    end
+
+    it 'fails when user not found' do
+      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
+
+    it 'fails when user cannot bind' do
+      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
+
+    it 'authenticates successfully with proper credentials' do
+      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')
+      refute_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
+  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

data/test/storage/local_test.rb

@@ -0,0 +1,59 @@
+# encoding: UTF-8
+
+require 'storage_tests'
+require 'test_helper'
+
+describe Vines::Storage::Local do
+  include StorageTests
+
+  DIR = Dir.mktmpdir
+
+  def setup
+    Dir.mkdir(DIR) unless File.exists?(DIR)
+    %w[user vcard fragment].each do |d|
+      Dir.mkdir(File.join(DIR, d))
+    end
+
+    files = {
+      :empty      => "#{DIR}/user/empty@wonderland.lit",
+      :no_pass    => "#{DIR}/user/no_password@wonderland.lit",
+      :clear_pass => "#{DIR}/user/clear_password@wonderland.lit",
+      :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-#{StorageTests::FRAGMENT_ID}"
+    }
+    File.open(files[:empty], 'w') {|f| f.write('') }
+    File.open(files[:no_pass], 'w') {|f| f.write('foo: bar') }
+    File.open(files[:clear_pass], 'w') {|f| f.write('password: secret') }
+    File.open(files[:bcrypt], 'w') {|f| f.write("password: #{BCrypt::Password.create('secret')}") }
+    File.open(files[:full], 'w') do |f|
+      f.puts("password: #{BCrypt::Password.create('secret')}")
+      f.puts("name: Tester")
+      f.puts("roster:")
+      f.puts("  follower1@wonderland.lit:")
+      f.puts("    name: Follower1")
+      f.puts("    groups: [Group1, Group2]")
+      f.puts("  follower2@wonderland.lit:")
+      f.puts("    name: Follower2")
+      f.puts("    groups: [Group3, Group4]")
+    end
+    File.open(files[:vcard], 'w') {|f| f.write(StorageTests::VCARD.to_xml) }
+    File.open(files[:fragment], 'w') {|f| f.write(StorageTests::FRAGMENT.to_xml) }
+  end
+
+  def teardown
+    FileUtils.remove_entry_secure(DIR)
+  end
+
+  def storage
+    Vines::Storage::Local.new { dir DIR }
+  end
+
+  def test_init
+    assert_raises(RuntimeError) { Vines::Storage::Local.new {} }
+    assert_raises(RuntimeError) { Vines::Storage::Local.new { dir 'bogus' } }
+    assert_raises(RuntimeError) { Vines::Storage::Local.new { dir '/sbin' } }
+    Vines::Storage::Local.new { dir DIR } # shouldn't raise an error
+  end
+end

data/test/storage/mock_redis.rb

@@ -0,0 +1,97 @@
+# encoding: UTF-8
+
+# A mock redis storage implementation that saves data to an in-memory Hash.
+class MockRedis
+  attr_reader :db
+
+  # Mimic em-hiredis behavior.
+  def self.defer(method)
+    old = instance_method(method)
+    define_method method do |*args, &block|
+      result = old.bind(self).call(*args)
+      deferred = EM::DefaultDeferrable.new
+      deferred.callback(&block) if block
+      EM.next_tick { deferred.succeed(result) }
+      deferred
+    end
+  end
+
+  def initialize
+    @db = {}
+  end
+
+  def del(key)
+    @db.delete(key)
+  end
+  defer :del
+
+  def get(key)
+    @db[key]
+  end
+  defer :get
+
+  def set(key, value)
+    @db[key] = value
+  end
+  defer :set
+
+  def hget(key, field)
+    @db[key][field] rescue nil
+  end
+  defer :hget
+
+  def hdel(key, field)
+    @db[key].delete(field) rescue nil
+  end
+  defer :hdel
+
+  def hgetall(key)
+    (@db[key] || {}).map do |k, v|
+      [k, v]
+    end.flatten
+  end
+  defer :hgetall
+
+  def hset(key, field, value)
+    @db[key] ||= {}
+    @db[key][field] = value
+  end
+  defer :hset
+
+  def hmset(key, *args)
+    @db[key] = Hash[*args]
+  end
+  defer :hmset
+
+  def sadd(key, obj)
+    @db[key] ||= Set.new
+    @db[key] << obj
+  end
+  defer :sadd
+
+  def srem(key, obj)
+    @db[key].delete(obj) rescue nil
+  end
+  defer :srem
+
+  def smembers
+    @db[key].to_a rescue []
+  end
+  defer :smembers
+
+  def flushdb
+    @db.clear
+  end
+  defer :flushdb
+
+  def multi
+    @transaction = true
+  end
+  defer :multi
+
+  def exec
+    raise 'transaction must start with multi' unless @transaction
+    @transaction = false
+  end
+  defer :exec
+end

data/test/storage/null_test.rb

@@ -0,0 +1,29 @@
+# encoding: UTF-8
+
+require 'test_helper'
+
+describe Vines::Storage::Null do
+  before do
+    @storage = Vines::Storage::Null.new
+    @user = Vines::User.new(jid: 'alice@wonderland.lit')
+  end
+
+  def test_find_user_returns_nil
+    assert_nil @storage.find_user(@user.jid)
+    @storage.save_user(@user)
+    assert_nil @storage.find_user(@user.jid)
+  end
+
+  def test_find_vcard_returns_nil
+    assert_nil @storage.find_vcard(@user.jid)
+    @storage.save_vcard(@user.jid, 'card')
+    assert_nil @storage.find_vcard(@user.jid)
+  end
+
+  def test_find_fragment_returns_nil
+    assert_nil @storage.find_fragment(@user.jid, 'node')
+    @storage.save_fragment(@user.jid, 'node')
+    assert_nil @storage.find_fragment(@user.jid, 'node')
+    nil
+  end
+end

data/test/storage/storage_tests.rb

@@ -0,0 +1,182 @@
+# encoding: UTF-8
+
+require 'test_helper'
+
+# Mixin methods for storage implementation test classes. The behavioral
+# tests are the same regardless of implementation so share those methods
+# here.
+module StorageTests
+  FRAGMENT_ID = Digest::SHA1.hexdigest("characters:urn:wonderland")
+
+  FRAGMENT = Nokogiri::XML(%q{
+    <characters xmlns="urn:wonderland">
+      <character>Alice</character>
+    </characters>
+  }.strip).root
+
+  VCARD = Nokogiri::XML(%q{
+    <vCard xmlns="vcard-temp">
+      <FN>Alice in Wonderland</FN>
+    </vCard>
+  }.strip).root
+
+  class EMLoop
+    def initialize
+      EM.run do
+        Fiber.new do
+          yield
+          EM.stop
+        end.resume
+      end
+    end
+  end
+
+  def test_authenticate
+    EMLoop.new do
+      db = storage
+      assert_nil db.authenticate(nil, nil)
+      assert_nil db.authenticate(nil, 'secret')
+      assert_nil db.authenticate('bogus', nil)
+      assert_nil db.authenticate('bogus', 'secret')
+      assert_nil db.authenticate('empty@wonderland.lit', 'secret')
+      assert_nil db.authenticate('no_password@wonderland.lit', 'secret')
+      assert_nil db.authenticate('clear_password@wonderland.lit', 'secret')
+
+      user = db.authenticate('bcrypt_password@wonderland.lit', 'secret')
+      refute_nil user
+      assert_equal('bcrypt_password@wonderland.lit', user.jid.to_s)
+
+      user = db.authenticate('full@wonderland.lit', 'secret')
+      refute_nil user
+      assert_equal 'Tester', user.name
+      assert_equal 'full@wonderland.lit', user.jid.to_s
+
+      assert_equal 2, user.roster.length
+      assert_equal 'follower1@wonderland.lit', user.roster[0].jid.to_s
+      assert_equal 'Follower1', user.roster[0].name
+      assert_equal 2, user.roster[0].groups.length
+      assert_equal 'Group1', user.roster[0].groups[0]
+      assert_equal 'Group2', user.roster[0].groups[1]
+
+      assert_equal 'follower2@wonderland.lit', user.roster[1].jid.to_s
+      assert_equal 'Follower2', user.roster[1].name
+      assert_equal 2, user.roster[1].groups.length
+      assert_equal 'Group3', user.roster[1].groups[0]
+      assert_equal 'Group4', user.roster[1].groups[1]
+    end
+  end
+
+  def test_find_user
+    EMLoop.new do
+      db = storage
+      user = db.find_user(nil)
+      assert_nil user
+
+      user = db.find_user('full@wonderland.lit')
+      refute_nil user
+      assert_equal 'full@wonderland.lit', user.jid.to_s
+
+      user = db.find_user(Vines::JID.new('full@wonderland.lit'))
+      refute_nil user
+      assert_equal 'full@wonderland.lit', user.jid.to_s
+
+      user = db.find_user(Vines::JID.new('full@wonderland.lit/resource'))
+      refute_nil user
+      assert_equal 'full@wonderland.lit', user.jid.to_s
+    end
+  end
+
+  def test_save_user
+    EMLoop.new do
+      db = storage
+      user = Vines::User.new(
+        :jid => 'save_user@domain.tld/resource1',
+        :name => 'Save User',
+        :password => 'secret')
+      user.roster << Vines::Follower.new(
+        :jid => 'follower1@domain.tld/resource2',
+        :name => 'Follower 1')
+      db.save_user(user)
+      user = db.find_user('save_user@domain.tld')
+      refute_nil user
+      assert_equal 'save_user@domain.tld', user.jid.to_s
+      assert_equal 'Save User', user.name
+      assert_equal 1, user.roster.length
+      assert_equal 'follower1@domain.tld', user.roster[0].jid.to_s
+      assert_equal 'Follower 1', user.roster[0].name
+    end
+  end
+
+  def test_find_vcard
+    EMLoop.new do
+      db = storage
+      card = db.find_vcard(nil)
+      assert_nil card
+
+      card = db.find_vcard('full@wonderland.lit')
+      refute_nil card
+      assert_equal VCARD, card
+
+      card = db.find_vcard(Vines::JID.new('full@wonderland.lit'))
+      refute_nil card
+      assert_equal VCARD, card
+
+      card = db.find_vcard(Vines::JID.new('full@wonderland.lit/resource'))
+      refute_nil card
+      assert_equal VCARD, card
+    end
+  end
+
+  def test_save_vcard
+    EMLoop.new do
+      db = storage
+      db.save_user(Vines::User.new(:jid => 'save_user@domain.tld'))
+      db.save_vcard('save_user@domain.tld/resource1', VCARD)
+      card = db.find_vcard('save_user@domain.tld')
+      refute_nil card
+      assert_equal VCARD, card
+    end
+  end
+
+  def test_find_fragment
+    EMLoop.new do
+      db = storage
+      root = Nokogiri::XML(%q{<characters xmlns="urn:wonderland"/>}).root
+      bad_name = Nokogiri::XML(%q{<not_characters xmlns="urn:wonderland"/>}).root
+      bad_ns = Nokogiri::XML(%q{<characters xmlns="not:wonderland"/>}).root
+
+      node = db.find_fragment(nil, nil)
+      assert_nil node
+
+      node = db.find_fragment('full@wonderland.lit', bad_name)
+      assert_nil node
+
+      node = db.find_fragment('full@wonderland.lit', bad_ns)
+      assert_nil node
+
+      node = db.find_fragment('full@wonderland.lit', root)
+      refute_nil node
+      assert_equal FRAGMENT, node
+
+      node = db.find_fragment(Vines::JID.new('full@wonderland.lit'), root)
+      refute_nil node
+      assert_equal FRAGMENT, node
+
+      node = db.find_fragment(Vines::JID.new('full@wonderland.lit/resource'), root)
+      refute_nil node
+      assert_equal FRAGMENT, node
+    end
+  end
+
+  def test_save_fragment
+    EMLoop.new do
+      db = storage
+      root = Nokogiri::XML(%q{<characters xmlns="urn:wonderland"/>}).root
+      db.save_user(Vines::User.new(:jid => 'save_user@domain.tld'))
+      db.save_fragment('save_user@domain.tld/resource1', FRAGMENT)
+      node = db.find_fragment('save_user@domain.tld', root)
+      refute_nil node
+      assert_equal FRAGMENT, node
+    end
+  end
+end