vines 0.1.0

data/test/storage/local_test.rb

@@ -0,0 +1,54 @@
+# encoding: UTF-8
+
+require 'storage_tests'
+require 'vines'
+require 'test/unit'
+
+class LocalTest < Test::Unit::TestCase
+  include StorageTests
+
+  def setup
+    @files = {
+      :empty      => './empty@wonderland.lit.user',
+      :no_pass    => './no_password@wonderland.lit.user',
+      :clear_pass => './clear_password@wonderland.lit.user',
+      :bcrypt     => './bcrypt_password@wonderland.lit.user',
+      :full       => './full@wonderland.lit.user',
+      :vcard      => './full@wonderland.lit.vcard'
+    }
+    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("  contact1@wonderland.lit:")
+      f.puts("    name: Contact1")
+      f.puts("    groups: [Group1, Group2]")
+      f.puts("  contact2@wonderland.lit:")
+      f.puts("    name: Contact2")
+      f.puts("    groups: [Group3, Group4]")
+    end
+    File.open(@files[:vcard], 'w') {|f| f.write(StorageTests::VCARD.to_xml) }
+  end
+
+  def teardown
+    misc = %w[user vcard].map {|ext| "./save_user@domain.tld.#{ext}" }
+    [*misc, *@files.values].each do |f|
+      File.delete(f) if File.exist?(f)
+    end
+  end
+
+  def storage
+    Vines::Storage::Local.new { dir '.' }
+  end
+
+  def test_init
+    assert_raise(RuntimeError) { Vines::Storage::Local.new {} }
+    assert_raise(RuntimeError) { Vines::Storage::Local.new { dir 'bogus' } }
+    assert_raise(RuntimeError) { Vines::Storage::Local.new { dir '/sbin' } }
+    assert_nothing_raised { Vines::Storage::Local.new { dir '.' } }
+  end
+end

data/test/storage/redis_test.rb

@@ -0,0 +1,75 @@
+# encoding: UTF-8
+
+require 'storage_tests'
+require 'vines'
+require 'test/unit'
+
+class RedisTest < Test::Unit::TestCase
+  include StorageTests
+
+  MOCK_REDIS = Class.new do
+    def initialize
+      @db = {}
+    end
+    def get(key)
+      EM.next_tick { yield @db[key] }
+    end
+    def hgetall(key)
+      EM.next_tick { yield @db[key] || {} }
+    end
+    def set(key, value)
+      @db[key] = value
+      EM.next_tick { yield if block_given? }
+    end
+    def hmset(key, *args)
+      @db[key] = Hash[*args]
+      EM.next_tick { yield if block_given? }
+    end
+    def del(key)
+      @db.delete(key)
+      EM.next_tick { yield if block_given? }
+    end
+    def flushdb
+      @db.clear
+      EM.next_tick { yield if block_given? }
+    end
+  end.new
+
+  def setup
+    EMLoop.new do
+      db = MOCK_REDIS
+      db.set('user:empty@wonderland.lit', {}.to_json)
+      db.set('user:no_password@wonderland.lit', {'foo' => 'bar'}.to_json)
+      db.set('user:clear_password@wonderland.lit', {'password' => 'secret'}.to_json)
+      db.set('user:bcrypt_password@wonderland.lit', {'password' => BCrypt::Password.create('secret')}.to_json)
+      db.set('user:full@wonderland.lit', {
+        'password' => BCrypt::Password.create('secret'),
+        'name' => 'Tester'
+      }.to_json)
+      db.hmset('roster:full@wonderland.lit', 
+        'contact1@wonderland.lit',
+        {'name' => 'Contact1', 'groups' => %w[Group1 Group2]}.to_json,
+        'contact2@wonderland.lit',
+        {'name' => 'Contact2', 'groups' => %w[Group3 Group4]}.to_json)
+      db.set('vcard:full@wonderland.lit', {'card' => StorageTests::VCARD.to_xml}.to_json)
+    end
+  end
+
+  def teardown
+    MOCK_REDIS.flushdb
+  end
+
+  def storage
+    storage = Vines::Storage::Redis.new { host 'localhost'; port 6397 }
+    def storage.redis; RedisTest::MOCK_REDIS; end
+    storage
+  end
+
+  def test_init
+    EMLoop.new do
+      assert_nothing_raised { Vines::Storage::Redis.new {} }
+      assert_nothing_raised { Vines::Storage::Redis.new { host 'localhost' } }
+      assert_nothing_raised { Vines::Storage::Redis.new { host'localhost'; port '6379' } }
+    end
+  end
+end

data/test/storage/sql_test.rb

@@ -0,0 +1,55 @@
+# encoding: UTF-8
+
+require 'storage_tests'
+require 'vines'
+require 'test/unit'
+
+class SqlTest < Test::Unit::TestCase
+  include StorageTests
+
+  DB_FILE = "./xmpp_testcase.db"
+  ActiveRecord::Migration.verbose = false
+
+  def setup
+    storage.create_schema(:force => true)
+    Vines::Storage::Sql::User.new(:jid => 'empty@wonderland.lit', :name => '', :password => '').save
+    Vines::Storage::Sql::User.new(:jid => 'no_password@wonderland.lit', :name => '', :password => '').save
+    Vines::Storage::Sql::User.new(:jid => 'clear_password@wonderland.lit', :name => '',
+      :password => 'secret').save
+    Vines::Storage::Sql::User.new(:jid => 'bcrypt_password@wonderland.lit', :name => '',
+      :password => BCrypt::Password.create('secret')).save
+    groups = %w[Group1 Group2 Group3 Group4].map do |name|
+      Vines::Storage::Sql::Group.find_or_create_by_name(name)
+    end
+    full = Vines::Storage::Sql::User.new(
+      :jid => 'full@wonderland.lit',
+      :name => 'Tester',
+      :password => BCrypt::Password.create('secret'),
+      :vcard => StorageTests::VCARD.to_xml)
+    full.contacts << Vines::Storage::Sql::Contact.new(
+      :jid => 'contact1@wonderland.lit',
+      :name => 'Contact1',
+      :groups => groups[0, 2],
+      :subscription => 'both')
+    full.contacts << Vines::Storage::Sql::Contact.new(
+      :jid => 'contact2@wonderland.lit',
+      :name => 'Contact2',
+      :groups => groups[2, 2],
+      :subscription => 'both')
+    full.save
+  end
+
+  def teardown
+    File.delete(DB_FILE) if File.exist?(DB_FILE)
+  end
+
+  def storage
+    Vines::Storage::Sql.new { adapter 'sqlite3'; database DB_FILE }
+  end
+
+  def test_init
+    assert_raise(RuntimeError) { Vines::Storage::Sql.new {} }
+    assert_raise(RuntimeError) { Vines::Storage::Sql.new { adapter 'postgresql' } }
+    assert_nothing_raised { Vines::Storage::Sql.new { adapter 'sqlite3'; database ':memory:' } }
+  end
+end

data/test/storage/storage_tests.rb

@@ -0,0 +1,134 @@
+# encoding: UTF-8
+
+require 'vines'
+require 'ext/nokogiri'
+require 'test/unit'
+
+# Mixin methods for storage implementation test classes. The behavioral
+# tests are the same regardless of implementation so share those methods
+# here.
+module StorageTests
+  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')
+      assert_not_nil user
+      assert_equal('bcrypt_password@wonderland.lit', user.jid.to_s)
+
+      user = db.authenticate('full@wonderland.lit', 'secret')
+      assert_not_nil user
+      assert_equal 'Tester', user.name
+      assert_equal 'full@wonderland.lit', user.jid.to_s
+
+      assert_equal 2, user.roster.length
+      assert_equal 'contact1@wonderland.lit', user.roster[0].jid.to_s
+      assert_equal 'Contact1', 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 'contact2@wonderland.lit', user.roster[1].jid.to_s
+      assert_equal 'Contact2', 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')
+      assert_not_nil user
+      assert_equal 'full@wonderland.lit', user.jid.to_s
+
+      user = db.find_user(Vines::JID.new('full@wonderland.lit'))
+      assert_not_nil user
+      assert_equal 'full@wonderland.lit', user.jid.to_s
+
+      user = db.find_user(Vines::JID.new('full@wonderland.lit/resource'))
+      assert_not_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::Contact.new(
+        :jid => 'contact1@domain.tld/resource2',
+        :name => 'Contact 1')
+      db.save_user(user)
+      user = db.find_user('save_user@domain.tld')
+      assert_not_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 'contact1@domain.tld', user.roster[0].jid.to_s
+      assert_equal 'Contact 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')
+      assert_not_nil card
+      assert_equal VCARD, card
+
+      card = db.find_vcard(Vines::JID.new('full@wonderland.lit'))
+      assert_not_nil card
+      assert_equal VCARD, card
+
+      card = db.find_vcard(Vines::JID.new('full@wonderland.lit/resource'))
+      assert_not_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')
+      assert_not_nil card
+      assert_equal VCARD, card
+    end
+  end
+end

data/test/storage_test.rb

@@ -0,0 +1,90 @@
+# encoding: UTF-8
+
+require 'storage_tests'
+require 'vines'
+require 'minitest/mock'
+require 'test/unit'
+
+class StorageTest < Test::Unit::TestCase
+  ALICE = 'alice@wonderland.lit'.freeze
+
+  class MockLdapStorage < Vines::Storage
+    attr_reader :authenticate_calls, :find_user_calls, :save_user_calls
+
+    def initialize(found_user=nil)
+      @found_user = found_user
+      @authenticate_calls = @find_user_calls = @save_user_calls = 0
+      @ldap = MiniTest::Mock.new
+    end
+
+    def authenticate(username, password)
+      @authenticate_calls += 1
+      nil
+    end
+    wrap_ldap :authenticate
+
+    def find_user(jid)
+      @find_user_calls += 1
+      @found_user
+    end
+
+    def save_user(user)
+      @save_user_calls += 1
+    end
+  end
+
+  def test_authenticate_with_ldap_missing_password
+    StorageTests::EMLoop.new do
+      storage = MockLdapStorage.new
+      user = storage.authenticate(ALICE, '')
+      assert_nil user
+      assert_equal 0, storage.authenticate_calls
+      assert_equal 0, storage.find_user_calls
+      assert_equal 0, storage.save_user_calls
+      assert storage.ldap.verify
+    end
+  end
+
+  def test_authenticate_with_ldap_bad_password
+    StorageTests::EMLoop.new do
+      storage = MockLdapStorage.new
+      storage.ldap.expect(:authenticate, nil, [ALICE, 'bogus'])
+      user = storage.authenticate(ALICE, 'bogus')
+      assert_nil user
+      assert_equal 0, storage.authenticate_calls
+      assert_equal 0, storage.find_user_calls
+      assert_equal 0, storage.save_user_calls
+      assert storage.ldap.verify
+    end
+  end
+
+  def test_authenticate_with_ldap_user_exists_in_database
+    StorageTests::EMLoop.new do
+      alice = Vines::User.new(:jid => ALICE)
+      storage = MockLdapStorage.new(alice)
+      storage.ldap.expect(:authenticate, alice, [ALICE, 'secr3t'])
+      user = storage.authenticate(ALICE, 'secr3t')
+      assert_not_nil user
+      assert_equal ALICE, user.jid.to_s
+      assert_equal 0, storage.authenticate_calls
+      assert_equal 1, storage.find_user_calls
+      assert_equal 0, storage.save_user_calls
+      assert storage.ldap.verify
+    end
+  end
+
+  def test_authenticate_with_ldap_save_user_to_database
+    StorageTests::EMLoop.new do
+      alice = Vines::User.new(:jid => ALICE)
+      storage = MockLdapStorage.new
+      storage.ldap.expect(:authenticate, alice, [ALICE, 'secr3t'])
+      user = storage.authenticate(ALICE, 'secr3t')
+      assert_not_nil user
+      assert_equal ALICE, user.jid.to_s
+      assert_equal 0, storage.authenticate_calls
+      assert_equal 1, storage.find_user_calls
+      assert_equal 1, storage.save_user_calls
+      assert storage.ldap.verify
+    end
+  end
+end

data/test/stream/client/auth_test.rb

@@ -0,0 +1,127 @@
+# encoding: UTF-8
+
+require 'vines'
+require 'minitest/mock'
+require 'test/unit'
+
+class ClientAuthTest < Test::Unit::TestCase
+  # disable logging for tests
+  Class.new.extend(Vines::Log).log.level = Logger::FATAL
+
+  class MockStorage < Vines::Storage
+    def initialize(raise_error=false)
+      @raise_error = raise_error
+    end
+
+    def authenticate(username, password)
+      raise 'temp auth fail' if @raise_error
+      user = Vines::User.new(:jid => 'alice@wonderland.lit')
+      users = {'alice@wonderland.lit' => 'secr3t'}
+      (users.key?(username) && (users[username] == password)) ? user : nil
+    end
+
+    def find_user(jid)
+    end
+
+    def save_user(user)
+    end
+  end
+
+  def setup
+    @stream = MiniTest::Mock.new
+    @state = Vines::Stream::Client::Auth.new(@stream)
+  end
+
+  def test_invalid_element
+    node = node('<bogus/>')
+    assert_raise(Vines::StreamErrors::NotAuthorized) { @state.node(node) }
+  end
+
+  def test_invalid_sasl_element
+    node = node(%Q{<bogus xmlns="#{Vines::NAMESPACES[:sasl]}"/>})
+    assert_raise(Vines::StreamErrors::NotAuthorized) { @state.node(node) }
+  end
+
+  def test_missing_namespace
+    node = node('<auth/>')
+    assert_raise(Vines::StreamErrors::NotAuthorized) { @state.node(node) }
+  end
+
+  def test_invalid_namespace
+    node = node('<auth xmlns="bogus"/>')
+    assert_raise(Vines::StreamErrors::NotAuthorized) { @state.node(node) }
+  end
+
+  def test_missing_mechanism
+    @stream.expect(:error, nil, [Vines::SaslErrors::InvalidMechanism.new])
+    node = node(%Q{<auth xmlns="#{Vines::NAMESPACES[:sasl]}">tokens</auth>})
+    assert_nothing_raised { @state.node(node) }
+    assert @stream.verify
+  end
+
+  def test_invalid_mechanism
+    @stream.expect(:error, nil, [Vines::SaslErrors::InvalidMechanism.new])
+    node = node(%Q{<auth xmlns="#{Vines::NAMESPACES[:sasl]}" mechanism="bogus">tokens</auth>})
+    assert_nothing_raised { @state.node(node) }
+    assert @stream.verify
+  end
+
+  def test_missing_text
+    @stream.expect(:error, nil, [Vines::SaslErrors::MalformedRequest.new])
+    node = node(%Q{<auth xmlns="#{Vines::NAMESPACES[:sasl]}" mechanism="PLAIN"></auth>})
+    assert_nothing_raised { @state.node(node) }
+    assert @stream.verify
+  end
+
+  def test_plain_auth_storage_error
+    @stream.expect(:storage, MockStorage.new(true))
+    @stream.expect(:error, nil, [Vines::SaslErrors::TemporaryAuthFailure.new])
+    node = node(%Q{<auth xmlns="#{Vines::NAMESPACES[:sasl]}" mechanism="PLAIN">tokens</auth>})
+    assert_nothing_raised { @state.node(node) }
+    assert @stream.verify
+  end
+
+  def test_plain_auth_invalid_password
+    @stream.expect(:storage, MockStorage.new)
+    @stream.expect(:error, nil, [Vines::SaslErrors::NotAuthorized.new])
+    node = node(%Q{<auth xmlns="#{Vines::NAMESPACES[:sasl]}" mechanism="PLAIN">#{Base64.encode64("alice@wonderland.lit\000\000bogus")}</auth>})
+    assert_nothing_raised { @state.node(node) }
+    assert @stream.verify
+  end
+
+  def test_plain_auth_valid_password
+    user = Vines::User.new(:jid => 'alice@wonderland.lit')
+    @stream.expect(:storage, MockStorage.new)
+    @stream.expect(:user, user)
+    @stream.expect(:user=, nil, [user])
+    @stream.expect(:write, nil, [%Q{<success xmlns="#{Vines::NAMESPACES[:sasl]}"/>}])
+    @stream.expect(:advance, nil, [Vines::Stream::Client::BindRestart.new(@stream)])
+    node = node(%Q{<auth xmlns="#{Vines::NAMESPACES[:sasl]}" mechanism="PLAIN">#{Base64.encode64("alice@wonderland.lit\000\000secr3t")}</auth>})
+    assert_nothing_raised { @state.node(node) }
+    assert @stream.verify
+  end
+
+  def test_max_auth_attempts_policy_violation
+    @stream.expect(:storage, MockStorage.new)
+    node = proc do
+      node(%Q{<auth xmlns="#{Vines::NAMESPACES[:sasl]}" mechanism="PLAIN">#{Base64.encode64("alice@wonderland.lit\000\000bogus")}</auth>})
+    end
+
+    @stream.expect(:error, nil, [Vines::SaslErrors::NotAuthorized.new])
+    assert_nothing_raised { @state.node(node.call) }
+    assert @stream.verify
+
+    assert_nothing_raised { @state.node(node.call) }
+    assert @stream.verify
+
+    @stream.expect(:error, nil, [Vines::StreamErrors::PolicyViolation.new])
+    assert_nothing_raised { @state.node(node.call) }
+    assert @stream.verify
+  end
+
+  private
+
+  def node(xml)
+    Nokogiri::XML(xml).root
+  end
+end