diaspora-vines-0.2.0.develop.4/ 0000775 0001750 0001750 00000000000 12654271406 016447 5 ustar sudheesh sudheesh diaspora-vines-0.2.0.develop.4/metadata.yml 0000664 0001750 0001750 00000031723 12654271406 020760 0 ustar sudheesh sudheesh --- !ruby/object:Gem::Specification
name: diaspora-vines
version: !ruby/object:Gem::Version
version: 0.2.0.develop.4
platform: ruby
authors:
- David Graham
- Lukas Matt
autorequire:
bindir: bin
cert_chain: []
date: 2015-10-10 00:00:00.000000000 Z
dependencies:
- !ruby/object:Gem::Dependency
name: bcrypt
requirement: !ruby/object:Gem::Requirement
requirements:
- - "~>"
- !ruby/object:Gem::Version
version: '3.1'
type: :runtime
prerelease: false
version_requirements: !ruby/object:Gem::Requirement
requirements:
- - "~>"
- !ruby/object:Gem::Version
version: '3.1'
- !ruby/object:Gem::Dependency
name: em-hiredis
requirement: !ruby/object:Gem::Requirement
requirements:
- - "~>"
- !ruby/object:Gem::Version
version: 0.3.0
type: :runtime
prerelease: false
version_requirements: !ruby/object:Gem::Requirement
requirements:
- - "~>"
- !ruby/object:Gem::Version
version: 0.3.0
- !ruby/object:Gem::Dependency
name: eventmachine
requirement: !ruby/object:Gem::Requirement
requirements:
- - "~>"
- !ruby/object:Gem::Version
version: 1.0.8
type: :runtime
prerelease: false
version_requirements: !ruby/object:Gem::Requirement
requirements:
- - "~>"
- !ruby/object:Gem::Version
version: 1.0.8
- !ruby/object:Gem::Dependency
name: http_parser.rb
requirement: !ruby/object:Gem::Requirement
requirements:
- - "~>"
- !ruby/object:Gem::Version
version: '0.6'
type: :runtime
prerelease: false
version_requirements: !ruby/object:Gem::Requirement
requirements:
- - "~>"
- !ruby/object:Gem::Version
version: '0.6'
- !ruby/object:Gem::Dependency
name: nokogiri
requirement: !ruby/object:Gem::Requirement
requirements:
- - "~>"
- !ruby/object:Gem::Version
version: '1.6'
type: :runtime
prerelease: false
version_requirements: !ruby/object:Gem::Requirement
requirements:
- - "~>"
- !ruby/object:Gem::Version
version: '1.6'
- !ruby/object:Gem::Dependency
name: activerecord
requirement: !ruby/object:Gem::Requirement
requirements:
- - "~>"
- !ruby/object:Gem::Version
version: '4.1'
type: :runtime
prerelease: false
version_requirements: !ruby/object:Gem::Requirement
requirements:
- - "~>"
- !ruby/object:Gem::Version
version: '4.1'
- !ruby/object:Gem::Dependency
name: pronto
requirement: !ruby/object:Gem::Requirement
requirements:
- - "~>"
- !ruby/object:Gem::Version
version: 0.4.2
type: :development
prerelease: false
version_requirements: !ruby/object:Gem::Requirement
requirements:
- - "~>"
- !ruby/object:Gem::Version
version: 0.4.2
- !ruby/object:Gem::Dependency
name: pronto-rubocop
requirement: !ruby/object:Gem::Requirement
requirements:
- - "~>"
- !ruby/object:Gem::Version
version: 0.4.4
type: :development
prerelease: false
version_requirements: !ruby/object:Gem::Requirement
requirements:
- - "~>"
- !ruby/object:Gem::Version
version: 0.4.4
- !ruby/object:Gem::Dependency
name: rails
requirement: !ruby/object:Gem::Requirement
requirements:
- - "~>"
- !ruby/object:Gem::Version
version: '4.1'
type: :development
prerelease: false
version_requirements: !ruby/object:Gem::Requirement
requirements:
- - "~>"
- !ruby/object:Gem::Version
version: '4.1'
- !ruby/object:Gem::Dependency
name: sqlite3
requirement: !ruby/object:Gem::Requirement
requirements:
- - "~>"
- !ruby/object:Gem::Version
version: 1.3.9
type: :development
prerelease: false
version_requirements: !ruby/object:Gem::Requirement
requirements:
- - "~>"
- !ruby/object:Gem::Version
version: 1.3.9
- !ruby/object:Gem::Dependency
name: minitest
requirement: !ruby/object:Gem::Requirement
requirements:
- - "~>"
- !ruby/object:Gem::Version
version: '5.8'
type: :development
prerelease: false
version_requirements: !ruby/object:Gem::Requirement
requirements:
- - "~>"
- !ruby/object:Gem::Version
version: '5.8'
- !ruby/object:Gem::Dependency
name: rake
requirement: !ruby/object:Gem::Requirement
requirements:
- - "~>"
- !ruby/object:Gem::Version
version: '10.3'
type: :development
prerelease: false
version_requirements: !ruby/object:Gem::Requirement
requirements:
- - "~>"
- !ruby/object:Gem::Version
version: '10.3'
description: Diaspora-vines is a Vines fork build for diaspora integration. DO NOT
use it unless you know what you are doing!
email:
- david@negativecode.com
- lukas@zauberstuhl.de
executables:
- vines
extensions: []
extra_rdoc_files: []
files:
- Gemfile
- LICENSE
- README.md
- Rakefile
- bin/vines
- conf/certs/README
- conf/certs/ca-bundle.crt
- conf/config.rb
- lib/vines.rb
- lib/vines/cli.rb
- lib/vines/cluster.rb
- lib/vines/cluster/connection.rb
- lib/vines/cluster/publisher.rb
- lib/vines/cluster/pubsub.rb
- lib/vines/cluster/sessions.rb
- lib/vines/cluster/subscriber.rb
- lib/vines/command/cert.rb
- lib/vines/command/restart.rb
- lib/vines/command/start.rb
- lib/vines/command/stop.rb
- lib/vines/config.rb
- lib/vines/config/diaspora.rb
- lib/vines/config/host.rb
- lib/vines/config/port.rb
- lib/vines/config/pubsub.rb
- lib/vines/contact.rb
- lib/vines/daemon.rb
- lib/vines/error.rb
- lib/vines/jid.rb
- lib/vines/kit.rb
- lib/vines/log.rb
- lib/vines/node.rb
- lib/vines/router.rb
- lib/vines/stanza.rb
- lib/vines/stanza/dialback.rb
- lib/vines/stanza/iq.rb
- lib/vines/stanza/iq/auth.rb
- lib/vines/stanza/iq/disco_info.rb
- lib/vines/stanza/iq/disco_items.rb
- lib/vines/stanza/iq/error.rb
- lib/vines/stanza/iq/ping.rb
- lib/vines/stanza/iq/private_storage.rb
- lib/vines/stanza/iq/query.rb
- lib/vines/stanza/iq/result.rb
- lib/vines/stanza/iq/roster.rb
- lib/vines/stanza/iq/session.rb
- lib/vines/stanza/iq/vcard.rb
- lib/vines/stanza/iq/version.rb
- lib/vines/stanza/message.rb
- lib/vines/stanza/presence.rb
- lib/vines/stanza/presence/error.rb
- lib/vines/stanza/presence/probe.rb
- lib/vines/stanza/presence/subscribe.rb
- lib/vines/stanza/presence/subscribed.rb
- lib/vines/stanza/presence/unavailable.rb
- lib/vines/stanza/presence/unsubscribe.rb
- lib/vines/stanza/presence/unsubscribed.rb
- lib/vines/stanza/pubsub.rb
- lib/vines/stanza/pubsub/create.rb
- lib/vines/stanza/pubsub/delete.rb
- lib/vines/stanza/pubsub/publish.rb
- lib/vines/stanza/pubsub/subscribe.rb
- lib/vines/stanza/pubsub/unsubscribe.rb
- lib/vines/storage.rb
- lib/vines/storage/local.rb
- lib/vines/storage/null.rb
- lib/vines/storage/sql.rb
- lib/vines/store.rb
- lib/vines/stream.rb
- lib/vines/stream/client.rb
- lib/vines/stream/client/auth.rb
- lib/vines/stream/client/auth_restart.rb
- lib/vines/stream/client/bind.rb
- lib/vines/stream/client/bind_restart.rb
- lib/vines/stream/client/closed.rb
- lib/vines/stream/client/ready.rb
- lib/vines/stream/client/session.rb
- lib/vines/stream/client/start.rb
- lib/vines/stream/client/tls.rb
- lib/vines/stream/component.rb
- lib/vines/stream/component/handshake.rb
- lib/vines/stream/component/ready.rb
- lib/vines/stream/component/start.rb
- lib/vines/stream/http.rb
- lib/vines/stream/http/auth.rb
- lib/vines/stream/http/bind.rb
- lib/vines/stream/http/bind_restart.rb
- lib/vines/stream/http/ready.rb
- lib/vines/stream/http/request.rb
- lib/vines/stream/http/session.rb
- lib/vines/stream/http/sessions.rb
- lib/vines/stream/http/start.rb
- lib/vines/stream/parser.rb
- lib/vines/stream/sasl.rb
- lib/vines/stream/server.rb
- lib/vines/stream/server/auth.rb
- lib/vines/stream/server/auth_method.rb
- lib/vines/stream/server/auth_restart.rb
- lib/vines/stream/server/final_restart.rb
- lib/vines/stream/server/outbound/auth.rb
- lib/vines/stream/server/outbound/auth_dialback_result.rb
- lib/vines/stream/server/outbound/auth_external.rb
- lib/vines/stream/server/outbound/auth_external_result.rb
- lib/vines/stream/server/outbound/auth_restart.rb
- lib/vines/stream/server/outbound/authoritative.rb
- lib/vines/stream/server/outbound/final_features.rb
- lib/vines/stream/server/outbound/final_restart.rb
- lib/vines/stream/server/outbound/start.rb
- lib/vines/stream/server/outbound/tls_result.rb
- lib/vines/stream/server/ready.rb
- lib/vines/stream/server/start.rb
- lib/vines/stream/state.rb
- lib/vines/token_bucket.rb
- lib/vines/user.rb
- lib/vines/version.rb
- lib/vines/xmpp_server.rb
- test/cluster/publisher_test.rb
- test/cluster/sessions_test.rb
- test/cluster/subscriber_test.rb
- test/config/host_test.rb
- test/config/pubsub_test.rb
- test/config_test.rb
- test/contact_test.rb
- test/error_test.rb
- test/ext/nokogiri.rb
- test/jid_test.rb
- test/kit_test.rb
- test/router_test.rb
- test/stanza/iq/disco_info_test.rb
- test/stanza/iq/disco_items_test.rb
- test/stanza/iq/private_storage_test.rb
- test/stanza/iq/roster_test.rb
- test/stanza/iq/session_test.rb
- test/stanza/iq/vcard_test.rb
- test/stanza/iq/version_test.rb
- test/stanza/iq_test.rb
- test/stanza/message_test.rb
- test/stanza/presence/probe_test.rb
- test/stanza/presence/subscribe_test.rb
- test/stanza/pubsub/create_test.rb
- test/stanza/pubsub/delete_test.rb
- test/stanza/pubsub/publish_test.rb
- test/stanza/pubsub/subscribe_test.rb
- test/stanza/pubsub/unsubscribe_test.rb
- test/stanza_test.rb
- test/storage/local_test.rb
- test/storage/mock_redis.rb
- test/storage/null_test.rb
- test/storage/sql_schema.rb
- test/storage/sql_test.rb
- test/storage/storage_tests.rb
- test/store_test.rb
- test/stream/client/auth_test.rb
- test/stream/client/ready_test.rb
- test/stream/client/session_test.rb
- test/stream/component/handshake_test.rb
- test/stream/component/ready_test.rb
- test/stream/component/start_test.rb
- test/stream/http/auth_test.rb
- test/stream/http/ready_test.rb
- test/stream/http/request_test.rb
- test/stream/http/sessions_test.rb
- test/stream/http/start_test.rb
- test/stream/parser_test.rb
- test/stream/sasl_test.rb
- test/stream/server/auth_method_test.rb
- test/stream/server/auth_test.rb
- test/stream/server/outbound/auth_dialback_result_test.rb
- test/stream/server/outbound/auth_external_test.rb
- test/stream/server/outbound/auth_restart_test.rb
- test/stream/server/outbound/auth_test.rb
- test/stream/server/outbound/authoritative_test.rb
- test/stream/server/outbound/start_test.rb
- test/stream/server/ready_test.rb
- test/stream/server/start_test.rb
- test/test_helper.rb
- test/token_bucket_test.rb
- test/user_test.rb
homepage: https://diasporafoundation.org
licenses:
- MIT
metadata: {}
post_install_message:
rdoc_options: []
require_paths:
- lib
required_ruby_version: !ruby/object:Gem::Requirement
requirements:
- - ">="
- !ruby/object:Gem::Version
version: 1.9.3
required_rubygems_version: !ruby/object:Gem::Requirement
requirements:
- - ">"
- !ruby/object:Gem::Version
version: 1.3.1
requirements: []
rubyforge_project:
rubygems_version: 2.4.5.1
signing_key:
specification_version: 4
summary: Diaspora-vines is a Vines fork build for diaspora integration.
test_files:
- test/error_test.rb
- test/test_helper.rb
- test/storage/local_test.rb
- test/storage/mock_redis.rb
- test/storage/sql_schema.rb
- test/storage/sql_test.rb
- test/storage/null_test.rb
- test/storage/storage_tests.rb
- test/ext/nokogiri.rb
- test/contact_test.rb
- test/store_test.rb
- test/cluster/sessions_test.rb
- test/cluster/publisher_test.rb
- test/cluster/subscriber_test.rb
- test/config_test.rb
- test/stream/parser_test.rb
- test/stream/client/ready_test.rb
- test/stream/client/auth_test.rb
- test/stream/client/session_test.rb
- test/stream/sasl_test.rb
- test/stream/http/sessions_test.rb
- test/stream/http/start_test.rb
- test/stream/http/ready_test.rb
- test/stream/http/auth_test.rb
- test/stream/http/request_test.rb
- test/stream/component/start_test.rb
- test/stream/component/ready_test.rb
- test/stream/component/handshake_test.rb
- test/stream/server/start_test.rb
- test/stream/server/ready_test.rb
- test/stream/server/auth_test.rb
- test/stream/server/auth_method_test.rb
- test/stream/server/outbound/start_test.rb
- test/stream/server/outbound/auth_restart_test.rb
- test/stream/server/outbound/auth_external_test.rb
- test/stream/server/outbound/auth_test.rb
- test/stream/server/outbound/auth_dialback_result_test.rb
- test/stream/server/outbound/authoritative_test.rb
- test/token_bucket_test.rb
- test/router_test.rb
- test/user_test.rb
- test/stanza/message_test.rb
- test/stanza/presence/subscribe_test.rb
- test/stanza/presence/probe_test.rb
- test/stanza/pubsub/publish_test.rb
- test/stanza/pubsub/delete_test.rb
- test/stanza/pubsub/create_test.rb
- test/stanza/pubsub/unsubscribe_test.rb
- test/stanza/pubsub/subscribe_test.rb
- test/stanza/iq_test.rb
- test/stanza/iq/roster_test.rb
- test/stanza/iq/vcard_test.rb
- test/stanza/iq/disco_info_test.rb
- test/stanza/iq/private_storage_test.rb
- test/stanza/iq/session_test.rb
- test/stanza/iq/version_test.rb
- test/stanza/iq/disco_items_test.rb
- test/jid_test.rb
- test/stanza_test.rb
- test/config/host_test.rb
- test/config/pubsub_test.rb
- test/kit_test.rb
diaspora-vines-0.2.0.develop.4/README.md 0000644 0001750 0001750 00000001027 12654271406 017724 0 ustar sudheesh sudheesh Diaspora XMPP Integration
=========================
**master** [  ](https://travis-ci.org/diaspora/vines)
**develop** [  ](https://travis-ci.org/diaspora/vines)
This XMPP server was forked from [Negativecode](http://www.getvines.org/)
and was slimmed down for [Diaspora](https://diasporafoundation.org) usage only!
**DO NOT** use this vines version unless you know what you're doing!!
diaspora-vines-0.2.0.develop.4/test/ 0000775 0001750 0001750 00000000000 12654271406 017426 5 ustar sudheesh sudheesh diaspora-vines-0.2.0.develop.4/test/store_test.rb 0000644 0001750 0001750 00000012171 12654271406 022146 0 ustar sudheesh sudheesh # encoding: UTF-8
require 'test_helper'
describe Vines::Store do
let(:dir) { 'conf/certs' }
let(:domain_pair) { certificate('wonderland.lit') }
let(:wildcard_pair) { certificate('*.wonderland.lit') }
subject { Vines::Store.new(dir) }
before do
@files =
save('wonderland.lit', domain_pair) +
save('wildcard.lit', wildcard_pair) +
save('duplicate.lit', domain_pair)
end
after do
@files.each do |name|
File.delete(name) if File.exists?(name)
end
end
describe 'creating a store' do
it 'parses certificate files' do
refute subject.certs.empty?
assert_equal OpenSSL::X509::Certificate, subject.certs.first.class
end
it 'ignores expired certificates' do
assert subject.certs.all? {|c| c.not_after > Time.new }
end
it 'does not raise an error for duplicate certificates' do
assert Vines::Store.new(dir)
end
end
describe 'files_for_domain' do
it 'handles invalid input' do
assert_nil subject.files_for_domain(nil)
assert_nil subject.files_for_domain('')
end
it 'finds files by name' do
refute_nil subject.files_for_domain('wonderland.lit')
cert, key = subject.files_for_domain('wonderland.lit')
assert_certificate_matches_key cert, key
assert_equal 'wonderland.lit.crt', File.basename(cert)
assert_equal 'wonderland.lit.key', File.basename(key)
end
it 'finds files for wildcard' do
refute_nil subject.files_for_domain('foo.wonderland.lit')
cert, key = subject.files_for_domain('foo.wonderland.lit')
assert_certificate_matches_key cert, key
assert_equal 'wildcard.lit.crt', File.basename(cert)
assert_equal 'wildcard.lit.key', File.basename(key)
end
end
describe 'trusted?' do
it 'does not trust malformed certificates' do
refute subject.trusted?('bogus')
end
it 'does not trust unsigned certificates' do
pair = certificate('something.lit')
refute subject.trusted?(pair.cert)
end
end
describe 'domain?' do
it 'handles invalid input' do
pair = certificate('wonderland.lit')
refute subject.domain?(nil, nil)
refute subject.domain?(pair.cert, nil)
refute subject.domain?(pair.cert, '')
refute subject.domain?(nil, '')
assert subject.domain?(pair.cert, 'wonderland.lit')
end
it 'verifies certificate subject domains' do
pair = certificate('wonderland.lit')
refute subject.domain?(pair.cert, 'bogus')
refute subject.domain?(pair.cert, 'www.wonderland.lit')
assert subject.domain?(pair.cert, 'wonderland.lit')
end
it 'verifies certificate subject alt domains' do
pair = certificate('wonderland.lit', 'www.wonderland.lit')
refute subject.domain?(pair.cert, 'bogus')
refute subject.domain?(pair.cert, 'tea.wonderland.lit')
assert subject.domain?(pair.cert, 'www.wonderland.lit')
assert subject.domain?(pair.cert, 'wonderland.lit')
end
it 'verifies certificate wildcard domains' do
pair = certificate('wonderland.lit', '*.wonderland.lit')
refute subject.domain?(pair.cert, 'bogus')
refute subject.domain?(pair.cert, 'one.two.wonderland.lit')
assert subject.domain?(pair.cert, 'tea.wonderland.lit')
assert subject.domain?(pair.cert, 'www.wonderland.lit')
assert subject.domain?(pair.cert, 'wonderland.lit')
end
end
private
# A public certificate + private key pair.
Pair = Struct.new(:cert, :key)
def assert_certificate_matches_key(cert, key)
refute_nil cert
refute_nil key
cert = OpenSSL::X509::Certificate.new(File.read(cert))
key = OpenSSL::PKey::RSA.new(File.read(key))
assert_equal cert.public_key.to_s, key.public_key.to_s
end
def certificate(domain, altname=nil)
# Use small key so tests are fast.
key = OpenSSL::PKey::RSA.generate(512)
name = OpenSSL::X509::Name.parse("/C=US/ST=Colorado/L=Denver/O=Test/CN=#{domain}")
cert = OpenSSL::X509::Certificate.new
cert.version = 2
cert.subject = name
cert.issuer = name
cert.serial = Time.now.to_i
cert.public_key = key.public_key
cert.not_before = Time.now
cert.not_after = Time.now + 3600
if altname
factory = OpenSSL::X509::ExtensionFactory.new
factory.subject_certificate = cert
factory.issuer_certificate = cert
cert.extensions = [
%w[subjectKeyIdentifier hash],
%w[subjectAltName] << [domain, altname].map {|n| "DNS:#{n}" }.join(',')
].map {|k, v| factory.create_ext(k, v) }
end
cert.sign key, OpenSSL::Digest::SHA1.new
Pair.new(cert.to_pem, key.to_pem)
end
# Write the domain's certificate and private key files to the filesystem for
# the store to use.
#
# domain - The domain name String to use in the file name (e.g. wonderland.lit).
# pair - The Pair containing the public certificate and private key data.
#
# Returns a String Array of file names that were written.
def save(domain, pair)
crt = File.expand_path("#{domain}.crt", dir)
key = File.expand_path("#{domain}.key", dir)
File.open(crt, 'w') {|f| f.write(pair.cert) }
File.open(key, 'w') {|f| f.write(pair.key) }
[crt, key]
end
end
diaspora-vines-0.2.0.develop.4/test/kit_test.rb 0000644 0001750 0001750 00000001711 12654271406 021577 0 ustar sudheesh sudheesh # encoding: UTF-8
require 'test_helper'
describe Vines::Kit do
describe '#hmac' do
it 'generates a SHA-512 HMAC' do
Vines::Kit.hmac('secret', 'username').length.must_equal 128
assert_equal Vines::Kit.hmac('s1', 'u1'), Vines::Kit.hmac('s1', 'u1')
refute_equal Vines::Kit.hmac('s1', 'u1'), Vines::Kit.hmac('s2', 'u1')
refute_equal Vines::Kit.hmac('s1', 'u1'), Vines::Kit.hmac('s1', 'u2')
end
end
describe '#uuid' do
it 'returns a random uuid' do
ids = Array.new(1000) { Vines::Kit.uuid }
assert ids.all? {|id| !id.nil? }
assert ids.all? {|id| id.length == 36 }
assert ids.all? {|id| id.match(/\w{8}-\w{4}-[4]\w{3}-[89ab]\w{3}-\w{12}/) }
ids.uniq.length.must_equal ids.length
end
end
describe '#auth_token' do
it 'returns a random 128 character token' do
Vines::Kit.auth_token.wont_equal Vines::Kit.auth_token
Vines::Kit.auth_token.length.must_equal 128
end
end
end
diaspora-vines-0.2.0.develop.4/test/user_test.rb 0000644 0001750 0001750 00000005705 12654271406 021775 0 ustar sudheesh sudheesh # encoding: UTF-8
require 'test_helper'
describe Vines::User do
subject { Vines::User.new(jid: 'alice@wonderland.lit', name: 'Alice', password: 'secr3t') }
describe 'user equality checks' do
let(:alice) { Vines::User.new(jid: 'alice@wonderland.lit') }
let(:hatter) { Vines::User.new(jid: 'hatter@wonderland.lit') }
it 'uses class in equality check' do
(subject <=> 42).must_be_nil
end
it 'is equal to itself' do
assert subject == subject
assert subject.eql?(subject)
assert subject.hash == subject.hash
end
it 'is equal to another user with the same jid' do
assert subject == alice
assert subject.eql?(alice)
assert subject.hash == alice.hash
end
it 'is not equal to a different jid' do
refute subject == hatter
refute subject.eql?(hatter)
refute subject.hash == hatter.hash
end
end
describe 'initialize' do
it 'raises when not given a jid' do
-> { Vines::User.new }.must_raise ArgumentError
-> { Vines::User.new(jid: '') }.must_raise ArgumentError
end
it 'has an empty roster' do
subject.roster.wont_be_nil
subject.roster.size.must_equal 0
end
end
describe '#update_from' do
let(:updated) { Vines::User.new(jid: 'alice2@wonderland.lit', name: 'Alice 2', password: "secr3t 2") }
before do
subject.roster << Vines::Contact.new(jid: 'hatter@wonderland.lit', name: "Hatter")
updated.roster << Vines::Contact.new(jid: 'cat@wonderland.lit', name: "Cheshire")
end
it 'updates jid, name, and password' do
subject.update_from(updated)
subject.jid.to_s.must_equal 'alice@wonderland.lit'
subject.name.must_equal 'Alice 2'
subject.password.must_equal 'secr3t 2'
end
it 'overwrites the entire roster' do
subject.update_from(updated)
subject.roster.size.must_equal 1
subject.roster.first.must_equal updated.roster.first
end
it 'clones roster entries' do
subject.update_from(updated)
updated.roster.first.name = 'Updated Contact 2'
subject.roster.first.name.must_equal 'Cheshire'
end
end
describe '#to_roster_xml' do
let(:expected) do
node(%q{
ABC
})
end
before do
subject.roster << Vines::Contact.new(jid: 'b@wonderland.lit', name: "Contact 2", groups: %w[C])
subject.roster << Vines::Contact.new(jid: 'a@wonderland.lit', name: "Contact 1", groups: %w[B A])
end
it 'sorts group names' do
subject.to_roster_xml(42).must_equal expected
end
end
end
diaspora-vines-0.2.0.develop.4/test/ext/ 0000775 0001750 0001750 00000000000 12654271406 020226 5 ustar sudheesh sudheesh diaspora-vines-0.2.0.develop.4/test/ext/nokogiri.rb 0000644 0001750 0001750 00000000473 12654271406 022376 0 ustar sudheesh sudheesh # encoding: UTF-8
module Nokogiri
module XML
class Node
# Override equality testing so we can use MiniTest::Mock#expect with
# Nokogiri::XML::Node arguments. Node's default behavior considers
# all nodes unequal.
def ==(node)
self.to_s == node.to_s
end
end
end
end diaspora-vines-0.2.0.develop.4/test/cluster/ 0000775 0001750 0001750 00000000000 12654271406 021107 5 ustar sudheesh sudheesh diaspora-vines-0.2.0.develop.4/test/cluster/sessions_test.rb 0000644 0001750 0001750 00000003532 12654271406 024342 0 ustar sudheesh sudheesh # encoding: UTF-8
require 'test_helper'
require 'storage/storage_tests'
require 'storage/mock_redis'
describe Vines::Cluster::Sessions do
subject { Vines::Cluster::Sessions.new(cluster) }
let(:connection) { MockRedis.new }
let(:cluster) { OpenStruct.new(id: 'abc', connection: connection) }
let(:jid1) { 'alice@wonderland.lit/tea' }
let(:jid2) { 'alice@wonderland.lit/cake' }
describe 'when saving to the cluster' do
it 'writes to a redis hash' do
StorageTests::EMLoop.new do
subject.save(jid1, {available: true, interested: true})
subject.save(jid2, {available: false, interested: false})
EM.next_tick do
session1 = {node: 'abc', available: true, interested: true}
session2 = {node: 'abc', available: false, interested: false}
connection.db["sessions:alice@wonderland.lit"].size.must_equal 2
connection.db["sessions:alice@wonderland.lit"]['tea'].must_equal session1.to_json
connection.db["sessions:alice@wonderland.lit"]['cake'].must_equal session2.to_json
connection.db["cluster:nodes:abc"].to_a.must_equal [jid1, jid2]
end
end
end
end
describe 'when deleting from the cluster' do
it 'removes from a redis hash' do
StorageTests::EMLoop.new do
connection.db["sessions:alice@wonderland.lit"] = {}
connection.db["sessions:alice@wonderland.lit"]['tea'] = {node: 'abc', available: true}.to_json
connection.db["sessions:alice@wonderland.lit"]['cake'] = {node: 'abc', available: true}.to_json
connection.db["cluster:nodes:abc"] = Set.new([jid1, jid2])
subject.delete(jid1)
EM.next_tick do
connection.db["sessions:alice@wonderland.lit"].size.must_equal 1
connection.db["cluster:nodes:abc"].to_a.must_equal [jid2]
end
end
end
end
end
diaspora-vines-0.2.0.develop.4/test/cluster/publisher_test.rb 0000644 0001750 0001750 00000002654 12654271406 024475 0 ustar sudheesh sudheesh # encoding: UTF-8
require 'test_helper'
describe Vines::Cluster::Publisher do
subject { Vines::Cluster::Publisher.new(cluster) }
let(:connection) { MiniTest::Mock.new }
let(:cluster) { MiniTest::Mock.new }
before do
cluster.expect :id, 'abc'
cluster.expect :connection, connection
end
describe '#broadcast' do
before do
msg = {from: 'abc', type: 'online', time: Time.now.to_i}.to_json
connection.expect :publish, nil, ["cluster:nodes:all", msg]
end
it 'publishes the message to every cluster node' do
subject.broadcast(:online)
connection.verify
cluster.verify
end
end
describe '#route' do
let(:stanza) { "hello" }
before do
msg = {from: 'abc', type: 'stanza', stanza: stanza}.to_json
connection.expect :publish, nil, ["cluster:nodes:node-42", msg]
end
it 'publishes the message to just one cluster node' do
subject.route(stanza, "node-42")
connection.verify
cluster.verify
end
end
describe '#update_user' do
let(:jid) { Vines::JID.new('alice@wonderland.lit') }
before do
msg = {from: 'abc', type: 'user', jid: jid.to_s}.to_json
connection.expect :publish, nil, ["cluster:nodes:node-42", msg]
end
it 'publishes the new user to just one cluster node' do
subject.update_user(jid, "node-42")
connection.verify
cluster.verify
end
end
end
diaspora-vines-0.2.0.develop.4/test/cluster/subscriber_test.rb 0000644 0001750 0001750 00000006530 12654271406 024640 0 ustar sudheesh sudheesh # encoding: UTF-8
require 'test_helper'
describe Vines::Cluster::Subscriber do
subject { Vines::Cluster::Subscriber.new(cluster) }
let(:connection) { MiniTest::Mock.new }
let(:cluster) { MiniTest::Mock.new }
let(:now) { Time.now.to_i }
before do
cluster.expect :id, 'abc'
end
describe '#subscribe' do
before do
cluster.expect :connect, connection
connection.expect :subscribe, nil, ['cluster:nodes:all']
connection.expect :subscribe, nil, ['cluster:nodes:abc']
connection.expect :on, nil, [:message]
end
it 'subscribes to its own channel and the broadcast channel' do
subject.subscribe
connection.verify
cluster.verify
end
end
describe 'when receiving a heartbeat broadcast message' do
before do
cluster.expect :poke, nil, ['node-42', now]
end
it 'pokes the session manager for the broadcasting node' do
msg = {from: 'node-42', type: 'heartbeat', time: now}.to_json
subject.send(:on_message, 'cluster:nodes:all', msg)
connection.verify
cluster.verify
end
end
describe 'when receiving an initial online broadcast message' do
before do
cluster.expect :poke, nil, ['node-42', now]
end
it 'pokes the session manager for the broadcasting node' do
msg = {from: 'node-42', type: 'online', time: now}.to_json
subject.send(:on_message, 'cluster:nodes:all', msg)
connection.verify
cluster.verify
end
end
describe 'when receiving an offline broadcast message' do
before do
cluster.expect :delete_sessions, nil, ['node-42']
end
it 'deletes the sessions for the broadcasting node' do
msg = {from: 'node-42', type: 'offline', time: now}.to_json
subject.send(:on_message, 'cluster:nodes:all', msg)
connection.verify
cluster.verify
end
end
describe 'when receiving a stanza routed to my node' do
let(:stream) { MiniTest::Mock.new }
let(:stanza) { "hello" }
let(:xml) { Nokogiri::XML(stanza).root }
before do
stream.expect :write, nil, [xml]
cluster.expect :connected_resources, [stream], ['alice@wonderland.lit/tea']
end
it 'writes the stanza to the connected user streams' do
# NOTE https://github.com/diaspora/vines/issues/68
skip "This fails randomly! Skipping it for later investigations."
msg = {from: 'node-42', type: 'stanza', stanza: stanza}.to_json
subject.send(:on_message, 'cluster:nodes:abc', msg)
stream.verify
connection.verify
cluster.verify
end
end
describe 'when receiving a user update message to my node' do
let(:alice) { Vines::User.new(jid: 'alice@wonderland.lit/tea') }
let(:storage) { MiniTest::Mock.new }
let(:stream) { MiniTest::Mock.new }
before do
storage.expect :find_user, alice, [alice.jid.bare]
stream.expect :user, alice
cluster.expect :storage, storage, ['wonderland.lit']
cluster.expect :connected_resources, [stream], [alice.jid.bare]
end
it 'reloads the user from storage and updates their connected streams' do
msg = {from: 'node-42', type: 'user', jid: alice.jid.to_s}.to_json
subject.send(:on_message, 'cluster:nodes:abc', msg)
storage.verify
stream.verify
connection.verify
cluster.verify
end
end
end
diaspora-vines-0.2.0.develop.4/test/stanza/ 0000775 0001750 0001750 00000000000 12654271406 020726 5 ustar sudheesh sudheesh diaspora-vines-0.2.0.develop.4/test/stanza/message_test.rb 0000644 0001750 0001750 00000007044 12654271406 023741 0 ustar sudheesh sudheesh # encoding: UTF-8
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
before do
class << stream
attr_accessor :config, :user
end
stream.user = alice
stream.config = config
end
describe 'when message type attribute is invalid' do
let(:xml) { node('hello!') }
it 'raises a bad-request stanza error' do
-> { subject.process }.must_raise Vines::StanzaErrors::BadRequest
end
end
describe 'when the to address is missing' do
let(:xml) { node('hello!') }
let(:recipient) { MiniTest::Mock.new }
before do
recipient.expect :user, alice
recipient.expect :write, nil, [xml]
stream.expect :connected_resources, [recipient], [alice.jid.bare]
end
it 'sends the message to the senders connected streams' do
subject.process
stream.verify
recipient.verify
end
end
describe 'when addressed to a non-user' do
let(:bogus) { Vines::JID.new('bogus@wonderland.lit/cake') }
let(:xml) { node(%Q{hello!}) }
let(:storage) { MiniTest::Mock.new }
before do
storage.expect :find_user, nil, [bogus]
stream.expect :storage, storage, [bogus.domain]
stream.expect :connected_resources, [], [bogus]
end
it 'ignores the stanza' do
subject.process
stream.verify
storage.verify
end
end
describe 'when addressed to an offline user' do
let(:hatter) { Vines::User.new(jid: 'hatter@wonderland.lit/cake') }
let(:xml) { node(%Q{hello!}) }
let(:storage) { MiniTest::Mock.new }
before do
skip # due offline message implementation
storage.expect :find_user, hatter, [hatter.jid]
stream.expect :storage, storage, [hatter.jid.domain]
stream.expect :connected_resources, [], [hatter.jid]
end
it 'raises a service-unavailable stanza error' do
-> { subject.process }.must_raise Vines::StanzaErrors::ServiceUnavailable
stream.verify
storage.verify
end
end
describe 'when address to a local user in a different domain' do
let(:xml) { node(%Q{hello!}) }
let(:expected) { node(%Q{hello!}) }
let(:recipient) { MiniTest::Mock.new }
before do
recipient.expect :user, romeo
recipient.expect :write, nil, [expected]
config.host 'verona.lit' do
storage(:fs) { dir Dir.tmpdir }
end
stream.expect :connected_resources, [recipient], [romeo.jid]
end
it 'delivers the stanza to the user' do
subject.process
stream.verify
recipient.verify
end
end
describe 'when addressed to a remote user' do
let(:xml) { node(%Q{hello!}) }
let(:expected) { node(%Q{hello!}) }
let(:router) { MiniTest::Mock.new }
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
diaspora-vines-0.2.0.develop.4/test/stanza/presence/ 0000775 0001750 0001750 00000000000 12654271406 022532 5 ustar sudheesh sudheesh diaspora-vines-0.2.0.develop.4/test/stanza/presence/subscribe_test.rb 0000644 0001750 0001750 00000005055 12654271406 026102 0 ustar sudheesh sudheesh # encoding: UTF-8
require 'test_helper'
describe Vines::Stanza::Presence::Subscribe do
subject { Vines::Stanza::Presence::Subscribe.new(xml, stream) }
let(:stream) { MiniTest::Mock.new }
let(:alice) { Vines::JID.new('alice@wonderland.lit/tea') }
let(:hatter) { Vines::JID.new('hatter@wonderland.lit') }
let(:contact) { Vines::Contact.new(jid: hatter) }
before do
class << stream
attr_accessor :user, :nodes
def write(node)
@nodes ||= []
@nodes << node
end
end
end
describe 'outbound subscription to a local jid, but missing contact' do
let(:xml) { node(%q{}) }
let(:user) { MiniTest::Mock.new }
let(:storage) { MiniTest::Mock.new }
let(:recipient) { MiniTest::Mock.new }
before do
class << user
attr_accessor :jid
end
user.jid = alice
user.expect :request_subscription, nil, [hatter]
user.expect :contact, contact, [hatter]
storage.expect :save_user, nil, [user]
storage.expect :find_user, nil, [hatter]
recipient.expect :user, user
class << recipient
attr_accessor :nodes
def write(node)
@nodes ||= []
@nodes << node
end
end
stream.user = user
stream.expect :domain, 'wonderland.lit'
stream.expect :storage, storage, ['wonderland.lit']
stream.expect :storage, storage, ['wonderland.lit']
stream.expect :interested_resources, [recipient], [alice]
stream.expect :update_user_streams, nil, [user]
class << subject
def route_iq; false; end
def inbound?; false; end
def local?; true; end
end
end
it 'rejects the subscription with an unsubscribed response' do
subject.process
stream.verify
user.verify
storage.verify
stream.nodes.size.must_equal 1
expected = node(%q{})
stream.nodes.first.must_equal expected
end
it 'sends a roster set to the interested resources with subscription none' do
subject.process
recipient.nodes.size.must_equal 1
query = %q{}
expected = node(%Q{#{query}})
recipient.nodes.first.remove_attribute('id') # id is random
recipient.nodes.first.must_equal expected
end
end
end
diaspora-vines-0.2.0.develop.4/test/stanza/presence/probe_test.rb 0000644 0001750 0001750 00000002455 12654271406 025231 0 ustar sudheesh sudheesh # encoding: UTF-8
require 'test_helper'
describe Vines::Stanza::Presence::Probe do
def setup
@alice = Vines::JID.new('alice@wonderland.lit/tea')
@stream = MiniTest::Mock.new
@config = Vines::Config.new do
host 'wonderland.lit' do
storage(:fs) { dir Dir.tmpdir }
end
end
end
def test_missing_to_address_raises
node = node(%q{})
stanza = Vines::Stanza::Presence::Probe.new(node, @stream)
def stanza.inbound?; false; end
@stream.expect(:user, Vines::User.new(jid: @alice))
assert_raises(Vines::StanzaErrors::BadRequest) { stanza.process }
assert @stream.verify
end
def test_to_remote_address_routes
node = node(%q{})
stanza = Vines::Stanza::Presence::Probe.new(node, @stream)
def stanza.inbound?; false; end
expected = node(%Q{})
router = MiniTest::Mock.new
router.expect(:route, nil, [expected])
@stream.expect(:router, router)
@stream.expect(:user, Vines::User.new(jid: @alice))
@stream.expect(:config, @config)
stanza.process
assert @stream.verify
assert router.verify
end
private
def node(xml)
Nokogiri::XML(xml).root
end
end
diaspora-vines-0.2.0.develop.4/test/stanza/iq/ 0000775 0001750 0001750 00000000000 12654271406 021337 5 ustar sudheesh sudheesh diaspora-vines-0.2.0.develop.4/test/stanza/iq/private_storage_test.rb 0000644 0001750 0001750 00000012704 12654271406 026123 0 ustar sudheesh sudheesh # encoding: UTF-8
require 'test_helper'
describe Vines::Stanza::Iq::PrivateStorage do
subject { Vines::Stanza::Iq::PrivateStorage.new(xml, stream) }
let(:alice) { Vines::User.new(jid: 'alice@wonderland.lit/tea') }
let(:storage) { MiniTest::Mock.new }
let(:stream) { MiniTest::Mock.new }
let(:config) do
Vines::Config.new do
host 'wonderland.lit' do
storage(:fs) { dir Dir.tmpdir }
private_storage true
end
end
end
before do
class << stream
attr_accessor :config, :domain, :user
end
stream.config = config
stream.user = alice
stream.domain = 'wonderland.lit'
end
describe 'when private storage feature is disabled' do
let(:xml) do
query = %q{}
node(%Q{#{query}})
end
before do
config.vhost('wonderland.lit').private_storage false
end
it 'raises a service-unavailable stanza error' do
-> { subject.process }.must_raise Vines::StanzaErrors::ServiceUnavailable
stream.verify
end
end
describe 'when retrieving a fragment for another user jid' do
let(:xml) do
query = %q{}
node(%Q{#{query}})
end
it 'raises a forbidden stanza error' do
-> { subject.process }.must_raise Vines::StanzaErrors::Forbidden
stream.verify
end
end
describe 'when get stanza contains zero child elements' do
let(:xml) do
query = %q{}
node(%Q{#{query}})
end
it 'raises a not-acceptable stanza error' do
-> { subject.process }.must_raise Vines::StanzaErrors::NotAcceptable
stream.verify
end
end
describe 'when get stanza contains more than one child element' do
let(:xml) do
query = %q{}
node(%Q{#{query}})
end
it 'raises a not-acceptable stanza error' do
-> { subject.process }.must_raise Vines::StanzaErrors::NotAcceptable
stream.verify
end
end
describe 'when get stanza is missing a namespace' do
let(:xml) do
query = %q{}
node = node(%Q{#{query}})
end
it 'raises a not-acceptable stanza error' do
-> { subject.process }.must_raise Vines::StanzaErrors::NotAcceptable
stream.verify
end
end
describe 'when get stanza is missing fragment' do
let(:xml) do
query = %q{}
node(%Q{#{query}})
end
before do
storage.expect :find_fragment, nil, [alice.jid, xml.elements[0].elements[0]]
stream.expect :storage, storage, ['wonderland.lit']
end
it 'raises an item-not-found stanza error' do
-> { subject.process }.must_raise Vines::StanzaErrors::ItemNotFound
stream.verify
storage.verify
end
end
describe 'when get finds fragment successfully' do
let(:xml) do
query = %q{}
node = node(%Q{#{query}})
end
before do
data = %q{data}
query = %Q{#{data}}
expected = node(%Q{#{query}})
storage.expect :find_fragment, node(data), [alice.jid, xml.elements[0].elements[0]]
stream.expect :storage, storage, ['wonderland.lit']
stream.expect :write, nil, [expected]
end
it 'writes a response to the stream' do
subject.process
stream.verify
storage.verify
end
end
describe 'when saving a fragment' do
let(:result) { node(%Q{}) }
before do
storage.expect :save_fragment, nil, [alice.jid, xml.elements[0].elements[0]]
stream.expect :storage, storage, ['wonderland.lit']
stream.expect :write, nil, [result]
end
describe 'and stanza contains zero child elements' do
let(:xml) do
query = %q{}
node(%Q{#{query}})
end
it 'raises a not-acceptable stanza error' do
-> { subject.process }.must_raise Vines::StanzaErrors::NotAcceptable
end
end
describe 'and a single single fragment saves successfully' do
let(:xml) do
query = %q{}
node(%Q{#{query}})
end
it 'writes a result to the stream' do
subject.process
stream.verify
storage.verify
end
end
describe 'and two fragments save successfully' do
let(:xml) do
query = %q{}
node(%Q{#{query}})
end
before do
storage.expect :save_fragment, nil, [alice.jid, xml.elements[0].elements[1]]
stream.expect :storage, storage, ['wonderland.lit']
end
it 'writes a result to the stream' do
subject.process
stream.verify
storage.verify
end
end
end
end
diaspora-vines-0.2.0.develop.4/test/stanza/iq/session_test.rb 0000644 0001750 0001750 00000001425 12654271406 024406 0 ustar sudheesh sudheesh # encoding: UTF-8
require 'test_helper'
describe Vines::Stanza::Iq::Session do
subject { Vines::Stanza::Iq::Session.new(xml, stream) }
let(:stream) { MiniTest::Mock.new }
let(:alice) { Vines::User.new(jid: 'alice@wonderland.lit/tea') }
describe 'when session initiation is requested' do
let(:xml) { node(%q{}) }
let(:result) { node(%q{}) }
before do
stream.expect :domain, 'wonderland.lit'
stream.expect :user, alice
stream.expect :write, nil, [result]
end
it 'just returns a result to satisy older clients' do
subject.process
stream.verify
end
end
end
diaspora-vines-0.2.0.develop.4/test/stanza/iq/version_test.rb 0000644 0001750 0001750 00000003166 12654271406 024414 0 ustar sudheesh sudheesh # encoding: UTF-8
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
before do
class << stream
attr_accessor :config, :user
end
stream.config = config
stream.user = alice
end
describe 'when not addressed to the server' do
let(:router) { MiniTest::Mock.new }
let(:xml) { node(%q{}) }
before do
router.expect :route, nil, [xml]
stream.expect :router, router
end
it 'routes the stanza to the recipient jid' do
subject.process
stream.verify
router.verify
end
end
describe 'when missing a to address' do
let(:xml) { node(%q{}) }
let(:expected) do
node(%Q{
Vines#{Vines::VERSION}})
end
before do
stream.expect :domain, 'wonderland.lit'
stream.expect :domain, 'wonderland.lit'
stream.expect :write, nil, [expected]
end
it 'returns a version result when missing a to jid' do
subject.process
stream.verify
end
end
end
diaspora-vines-0.2.0.develop.4/test/stanza/iq/disco_items_test.rb 0000644 0001750 0001750 00000002405 12654271406 025224 0 ustar sudheesh sudheesh # encoding: UTF-8
require 'test_helper'
describe Vines::Stanza::Iq::DiscoItems do
subject { Vines::Stanza::Iq::DiscoItems.new(xml, stream) }
let(:stream) { MiniTest::Mock.new }
let(:alice) { Vines::User.new(jid: 'alice@wonderland.lit/home') }
let(:config) do
Vines::Config.new do
host 'wonderland.lit' do
storage(:fs) { dir Dir.tmpdir }
components 'tea' => 'secr3t', 'cake' => 'passw0rd'
end
end
end
before do
class << stream
attr_accessor :config, :user
end
stream.config = config
stream.user = alice
end
describe 'when querying server items' do
let(:xml) do
query = %q{}
node(%Q{#{query}})
end
let(:result) do
node(%q{
})
end
it 'includes component domains in output' do
stream.expect :write, nil, [result]
subject.process
stream.verify
end
end
end
diaspora-vines-0.2.0.develop.4/test/stanza/iq/vcard_test.rb 0000644 0001750 0001750 00000007224 12654271406 024025 0 ustar sudheesh sudheesh # encoding: UTF-8
require 'test_helper'
describe Vines::Stanza::Iq::Vcard do
subject { Vines::Stanza::Iq::Vcard.new(xml, stream) }
let(:alice) { Vines::User.new(jid: 'alice@wonderland.lit/tea') }
let(:stream) { MiniTest::Mock.new }
let(:storage) { MiniTest::Mock.new }
let(:config) do
Vines::Config.new do
host 'wonderland.lit' do
cross_domain_messages true
storage(:fs) { dir Dir.tmpdir }
end
end
end
before do
class << stream
attr_accessor :config, :domain, :user
end
stream.config = config
stream.domain = 'wonderland.lit'
stream.user = alice
end
describe 'when getting vcard' do
describe 'and addressed to a remote jid' do
let(:xml) { get('romeo@verona.lit') }
let(:router) { MiniTest::Mock.new }
before do
router.expect :route, nil, [xml]
stream.expect :router, router
end
it 'routes rather than handle locally' do
subject.process
stream.verify
router.verify
end
end
describe 'and missing to address' do
let(:xml) { get('') }
let(:card) { vcard('Alice') }
let(:expected) { result(alice.jid, '', card) }
before do
storage.expect :find_vcard, card, [alice.jid.bare]
stream.expect :storage, storage, ['wonderland.lit']
stream.expect :write, nil, [expected]
end
it 'sends vcard for authenticated jid' do
subject.process
stream.verify
storage.verify
end
end
describe 'for another user' do
let(:xml) { get(hatter) }
let(:card) { vcard('Hatter') }
let(:hatter) { Vines::JID.new('hatter@wonderland.lit') }
let(:expected) { result(alice.jid, hatter, card) }
before do
storage.expect :find_vcard, card, [hatter]
stream.expect :storage, storage, ['wonderland.lit']
stream.expect :write, nil, [expected]
end
it 'succeeds and returns vcard with from address' do
subject.process
stream.verify
storage.verify
end
end
describe 'for missing vcard' do
let(:xml) { get('') }
before do
storage.expect :find_vcard, nil, [alice.jid.bare]
stream.expect :storage, storage, ['wonderland.lit']
end
it 'returns an item-not-found stanza error' do
-> { subject.process }.must_raise Vines::StanzaErrors::ItemNotFound
stream.verify
storage.verify
end
end
end
describe 'when setting vcard' do
describe 'and addressed to another user' do
let(:xml) { set('hatter@wonderland.lit') }
it 'raises a forbidden stanza error' do
-> { subject.process }.must_raise Vines::StanzaErrors::Forbidden
stream.verify
end
end
describe 'and missing to address' do
let(:xml) { set('') }
let(:card) { vcard('Alice') }
let(:expected) { result(alice.jid) }
before do
storage.expect :save_vcard, nil, [alice.jid, card]
stream.expect :storage, storage, ['wonderland.lit']
stream.expect :write, nil, [expected]
end
it 'succeeds and returns an iq result' do
subject.process
stream.verify
storage.verify
end
end
end
private
def vcard(name)
node(%Q{#{name}})
end
def get(to)
card = ''
iq(id: 42, to: to, type: 'get', body: card)
end
def set(to)
card = 'Alice'
iq(id: 42, to: to, type: 'set', body: card)
end
def result(to, from=nil, card=nil)
iq(from: from, id: 42, to: to, type: 'result', body: card)
end
end
diaspora-vines-0.2.0.develop.4/test/stanza/iq/disco_info_test.rb 0000644 0001750 0001750 00000004635 12654271406 025045 0 ustar sudheesh sudheesh # encoding: UTF-8
require 'test_helper'
describe Vines::Stanza::Iq::DiscoInfo do
subject { Vines::Stanza::Iq::DiscoInfo.new(xml, stream) }
let(:stream) { MiniTest::Mock.new }
let(:alice) { Vines::User.new(jid: 'alice@wonderland.lit/home') }
let(:config) do
Vines::Config.new do
host 'wonderland.lit' do
storage(:fs) { dir Dir.tmpdir }
end
end
end
let(:xml) do
query = %q{}
node(%Q{#{query}})
end
before do
class << stream
attr_accessor :config, :user
end
stream.config = config
stream.user = alice
end
describe 'when private storage is disabled' do
let(:expected) do
node(%Q{
})
end
it 'returns info stanza without the private storage feature' do
config.vhost('wonderland.lit').private_storage false
stream.expect :write, nil, [expected]
subject.process
stream.verify
end
end
describe 'when private storage is enabled' do
let(:expected) do
node(%Q{
})
end
it 'announces private storage feature in info stanza result' do
config.vhost('wonderland.lit').private_storage true
stream.expect :write, nil, [expected]
subject.process
stream.verify
end
end
end
diaspora-vines-0.2.0.develop.4/test/stanza/iq/roster_test.rb 0000644 0001750 0001750 00000014304 12654271406 024241 0 ustar sudheesh sudheesh # encoding: UTF-8
require 'test_helper'
describe Vines::Stanza::Iq::Roster do
subject { Vines::Stanza::Iq::Roster.new(xml, stream) }
let(:stream) { MiniTest::Mock.new }
let(:alice) { Vines::User.new(jid: 'alice@wonderland.lit/tea') }
before do
class << stream
attr_accessor :domain, :user
end
stream.user = alice
stream.domain = 'wonderland.lit'
end
describe 'when retrieving an empty roster' do
let(:xml) { node(%q{}) }
let(:expected) { node(%q{}) }
before do
stream.expect :write, nil, [expected]
stream.expect :requested_roster!, nil
end
it 'returns an empty stanza' do
subject.process
stream.verify
end
end
describe 'when retrieving a non-empty roster' do
let(:xml) { node(%q{}) }
let(:expected) do
node(%q{
CatsFriends})
end
before do
alice.roster << Vines::Contact.new(jid: 'hatter@wonderland.lit')
alice.roster << Vines::Contact.new(jid: 'cat@wonderland.lit', :groups => ['Friends', 'Cats'])
stream.expect :write, nil, [expected]
stream.expect :requested_roster!, nil
end
it 'sorts groups alphabetically' do
subject.process
stream.verify
end
end
describe 'when requesting a roster for another user' do
let(:xml) do
node(%q{
})
end
it 'raises a forbidden stanza error' do
-> { subject.process }.must_raise Vines::StanzaErrors::Forbidden
stream.verify
end
end
describe 'when saving a roster for another user' do
let(:xml) do
node(%q{
})
end
it 'raises a forbidden stanza error' do
-> { subject.process }.must_raise Vines::StanzaErrors::Forbidden
stream.verify
end
end
describe 'when saving a roster with no items' do
let(:xml) do
node(%q{
})
end
it 'raises a bad-request stanza error' do
-> { subject.process }.must_raise Vines::StanzaErrors::BadRequest
stream.verify
end
end
describe 'when updating a roster with more than one item' do
let(:xml) do
node(%q{
})
end
it 'raises a bad-request stanza error' do
-> { subject.process }.must_raise Vines::StanzaErrors::BadRequest
stream.verify
end
end
describe 'when adding a roster item without a jid attribute' do
let(:xml) do
node(%q{
})
end
it 'raises a bad-request stanza error' do
-> { subject.process }.must_raise Vines::StanzaErrors::BadRequest
stream.verify
end
end
describe 'when adding a roster item with duplicate groups' do
let(:xml) do
node(%q{
FriendsFriends})
end
it 'raises a bad-request stanza error' do
-> { subject.process }.must_raise Vines::StanzaErrors::BadRequest
stream.verify
end
end
describe 'when adding a roster item with an empty group name' do
let(:xml) do
node(%q{
})
end
it 'raises a not-acceptable stanza error' do
-> { subject.process }.must_raise Vines::StanzaErrors::NotAcceptable
stream.verify
end
end
describe 'when saving a roster successfully' do
let(:xml) do
node(%q{
Friends})
end
let(:expected) do
node(%q{
Friends})
end
let(:storage) { MiniTest::Mock.new }
let(:recipient) { MiniTest::Mock.new }
let(:result) { node(%Q{}) }
before do
storage.expect :save_user, nil, [alice]
recipient.expect :user, alice
def recipient.nodes; @nodes; end
def recipient.write(node)
@nodes ||= []
@nodes << node
end
stream.expect :interested_resources, [recipient], [alice.jid]
stream.expect :update_user_streams, nil, [alice]
stream.expect :storage, storage, ['wonderland.lit']
stream.expect :write, nil, [result]
end
it 'sends a result to the sender' do
subject.process
stream.verify
storage.verify
end
it 'sends the new roster item to the interested streams' do
subject.process
recipient.nodes.first.remove_attribute('id') # id is random
recipient.nodes.first.must_equal expected
end
end
end
diaspora-vines-0.2.0.develop.4/test/stanza/iq_test.rb 0000644 0001750 0001750 00000004243 12654271406 022724 0 ustar sudheesh sudheesh # encoding: UTF-8
require 'test_helper'
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
before do
class << stream
attr_accessor :config, :user
end
stream.user = hatter
stream.config = config
end
describe 'when addressed to a user rather than the server itself' do
let(:recipient) { MiniTest::Mock.new }
let(:xml) do
node(%q{
})
end
before do
recipient.expect :user, alice, []
recipient.expect :write, nil, [xml]
stream.expect :connected_resources, [recipient], [alice.jid]
end
it 'routes the stanza to the users connected resources' do
subject.process
stream.verify
recipient.verify
end
end
describe 'when given no type or body elements' do
let(:xml) { node('') }
it 'raises a feature-not-implemented stanza error' do
-> { subject.process }.must_raise Vines::StanzaErrors::FeatureNotImplemented
end
end
end
diaspora-vines-0.2.0.develop.4/test/stanza/pubsub/ 0000775 0001750 0001750 00000000000 12654271406 022226 5 ustar sudheesh sudheesh diaspora-vines-0.2.0.develop.4/test/stanza/pubsub/create_test.rb 0000644 0001750 0001750 00000006017 12654271406 025057 0 ustar sudheesh sudheesh # encoding: UTF-8
require 'test_helper'
describe Vines::Stanza::PubSub::Create do
subject { Vines::Stanza::PubSub::Create.new(xml, stream) }
let(:user) { 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 }
pubsub 'games'
end
end
end
before do
class << stream
attr_accessor :config, :nodes, :user
def write(node)
@nodes ||= []
@nodes << node
end
end
stream.config = config
stream.user = user
end
describe 'when missing a to address' do
let(:xml) { create('') }
it 'raises a feature-not-implemented stanza error' do
stream.expect :domain, 'wonderland.lit'
-> { subject.process }.must_raise Vines::StanzaErrors::FeatureNotImplemented
stream.verify
end
end
describe 'when addressed to bare server domain' do
let(:xml) { create('wonderland.lit') }
it 'raises a feature-not-implemented stanza error' do
-> { subject.process }.must_raise Vines::StanzaErrors::FeatureNotImplemented
stream.verify
end
end
describe 'when addressed to a non-pubsub component' do
let(:router) { MiniTest::Mock.new }
let(:xml) { create('bogus.wonderland.lit') }
before do
router.expect :route, nil, [xml]
stream.expect :router, router
end
it 'routes rather than handle locally' do
subject.process
stream.verify
router.verify
end
end
describe 'when attempting to create multiple nodes' do
let(:xml) { create('games.wonderland.lit', true) }
it 'raises a bad-request stanza error' do
-> { subject.process }.must_raise Vines::StanzaErrors::BadRequest
stream.verify
end
end
describe 'when attempting to create duplicate nodes' do
let(:pubsub) { MiniTest::Mock.new }
let(:xml) { create('games.wonderland.lit') }
it 'raises a conflict stanza error' do
pubsub.expect :node?, true, ['game_13']
subject.stub :pubsub, pubsub do
-> { subject.process }.must_raise Vines::StanzaErrors::Conflict
end
stream.verify
pubsub.verify
end
end
describe 'when given a valid stanza' do
let(:xml) { create('games.wonderland.lit') }
let(:expected) { result(user.jid, 'games.wonderland.lit') }
it 'sends an iq result stanza to sender' do
subject.process
stream.nodes.size.must_equal 1
stream.nodes.first.must_equal expected
stream.verify
end
end
private
def create(to, multiple=false)
extra_create = "" if multiple
body = %Q{
#{extra_create}
}
iq(type: 'set', to: to, id: 42, body: body)
end
def result(to, from)
body = ''
iq(from: from, id: 42, to: to, type: 'result', body: body)
end
end
diaspora-vines-0.2.0.develop.4/test/stanza/pubsub/subscribe_test.rb 0000644 0001750 0001750 00000013204 12654271406 025571 0 ustar sudheesh sudheesh # encoding: UTF-8
require 'test_helper'
describe Vines::Stanza::PubSub::Subscribe do
subject { Vines::Stanza::PubSub::Subscribe.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 }
pubsub 'games'
end
end
end
before do
class << stream
attr_accessor :config, :domain, :nodes, :user
def write(node)
@nodes ||= []
@nodes << node
end
end
stream.config = config
stream.user = alice
stream.domain = 'wonderland.lit'
end
describe 'when missing a to address' do
let(:xml) do
node(%q{
})
end
it 'raises a feature-not-implemented stanza error' do
-> { subject.process }.must_raise Vines::StanzaErrors::FeatureNotImplemented
stream.verify
end
end
describe 'when addressed to a bare server domain' do
let(:xml) do
node(%q{
})
end
it 'raises a feature-not-implemented stanza error' do
-> { subject.process }.must_raise Vines::StanzaErrors::FeatureNotImplemented
stream.verify
end
end
describe 'when addressed to a non-pubsub address' do
let(:router) { MiniTest::Mock.new }
let(:xml) do
node(%q{
})
end
it 'routes rather than handle locally' do
router.expect :route, nil, [xml]
stream.expect :router, router
subject.process
stream.verify
router.verify
end
end
describe 'when stanza contains multiple subscribe elements' do
let(:xml) do
node(%q{
})
end
it 'raises a bad-request stanza error' do
-> { subject.process }.must_raise Vines::StanzaErrors::BadRequest
stream.verify
end
end
describe 'when stanza is missing a subscribe element' do
let(:xml) do
node(%q{
})
end
it 'raises an item-not-found stanza error' do
-> { subject.process }.must_raise Vines::StanzaErrors::ItemNotFound
stream.verify
end
end
describe 'when attempting to subscribe to a node twice' do
let(:pubsub) { MiniTest::Mock.new }
let(:xml) do
node(%q{
})
end
before do
pubsub.expect :node?, true, ['game_13']
pubsub.expect :subscribed?, true, ['game_13', alice.jid]
end
it 'raises a policy-violation stanza error' do
subject.stub :pubsub, pubsub do
-> { subject.process }.must_raise Vines::StanzaErrors::PolicyViolation
end
stream.verify
pubsub.verify
end
end
describe 'when subscribing with an illegal jid' do
let(:xml) do
node(%q{
})
end
it 'raises a bad-request stanza error' do
-> { subject.process }.must_raise Vines::StanzaErrors::BadRequest
stream.verify
end
end
describe 'when subscribing with a valid stanza' do
let(:xml) do
node(%q{
})
end
let(:expected) do
node(%q{
})
end
let(:pubsub) { MiniTest::Mock.new }
before do
pubsub.expect :node?, true, ['game_13']
pubsub.expect :subscribed?, false, ['game_13', alice.jid]
pubsub.expect :subscribe, nil, ['game_13', alice.jid]
end
it 'writes a result stanza to the stream' do
subject.stub :pubsub, pubsub do
subject.process
end
stream.verify
pubsub.verify
stream.nodes.size.must_equal 1
stream.nodes.first.must_equal expected
end
end
end
diaspora-vines-0.2.0.develop.4/test/stanza/pubsub/unsubscribe_test.rb 0000644 0001750 0001750 00000007711 12654271406 026142 0 ustar sudheesh sudheesh # encoding: UTF-8
require 'test_helper'
describe Vines::Stanza::PubSub::Unsubscribe do
subject { Vines::Stanza::PubSub::Unsubscribe.new(xml, stream) }
let(:user) { 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 }
pubsub 'games'
end
end
end
before do
class << stream
attr_accessor :config, :nodes, :user
def write(node)
@nodes ||= []
@nodes << node
end
end
stream.config = config
stream.user = user
end
describe 'when missing a to address' do
let(:xml) { unsubscribe('') }
it 'raises a feature-not-implemented stanza error' do
stream.expect :domain, 'wonderland.lit'
-> { subject.process }.must_raise Vines::StanzaErrors::FeatureNotImplemented
stream.verify
end
end
describe 'when addressed to bare server domain' do
let(:xml) { unsubscribe('wonderland.lit') }
it 'raises a feature-not-implemented stanza error' do
-> { subject.process }.must_raise Vines::StanzaErrors::FeatureNotImplemented
stream.verify
end
end
describe 'when addressed to a non-pubsub component' do
let(:router) { MiniTest::Mock.new }
let(:xml) { unsubscribe('bogus.wonderland.lit') }
before do
router.expect :route, nil, [xml]
stream.expect :router, router
end
it 'routes rather than handle locally' do
subject.process
stream.verify
router.verify
end
end
describe 'when attempting to unsubscribe from multiple nodes' do
let(:xml) { unsubscribe('games.wonderland.lit', true) }
it 'raises a bad-request stanza error' do
-> { subject.process }.must_raise Vines::StanzaErrors::BadRequest
stream.verify
end
end
describe 'when unsubscribing from a missing node' do
let(:xml) { unsubscribe('games.wonderland.lit') }
it 'raises an item-not-found stanza error' do
-> { subject.process }.must_raise Vines::StanzaErrors::ItemNotFound
stream.verify
end
end
describe 'when unsubscribing without a subscription' do
let(:pubsub) { MiniTest::Mock.new }
let(:xml) { unsubscribe('games.wonderland.lit') }
before do
pubsub.expect :node?, true, ['game_13']
pubsub.expect :subscribed?, false, ['game_13', user.jid]
end
it 'raises an unexpected-request stanza error' do
subject.stub :pubsub, pubsub do
-> { subject.process }.must_raise Vines::StanzaErrors::UnexpectedRequest
end
stream.verify
pubsub.verify
end
end
describe 'when unsubscribing an illegal jid' do
let(:xml) { unsubscribe('games.wonderland.lit', false, 'not_alice@wonderland.lit/tea') }
it 'raises a forbidden stanza error' do
-> { subject.process }.must_raise Vines::StanzaErrors::Forbidden
stream.verify
end
end
describe 'when given a valid stanza' do
let(:pubsub) { MiniTest::Mock.new }
let(:xml) { unsubscribe('games.wonderland.lit') }
let(:expected) { result(user.jid, 'games.wonderland.lit') }
before do
pubsub.expect :node?, true, ['game_13']
pubsub.expect :subscribed?, true, ['game_13', user.jid]
pubsub.expect :unsubscribe, nil, ['game_13', user.jid]
end
it 'sends an iq result stanza to sender' do
subject.stub :pubsub, pubsub do
subject.process
end
stream.nodes.size.must_equal 1
stream.nodes.first.must_equal expected
stream.verify
pubsub.verify
end
end
private
def unsubscribe(to, multiple=false, jid=user.jid)
extra = "" if multiple
body = %Q{
#{extra}
}
iq(type: 'set', to: to, id: 42, body: body)
end
def result(to, from)
iq(from: from, id: 42, to: to, type: 'result')
end
end
diaspora-vines-0.2.0.develop.4/test/stanza/pubsub/publish_test.rb 0000644 0001750 0001750 00000021273 12654271406 025263 0 ustar sudheesh sudheesh # encoding: UTF-8
require 'test_helper'
describe Vines::Stanza::PubSub::Publish do
subject { Vines::Stanza::PubSub::Publish.new(xml, stream) }
let(:user) { 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 }
pubsub 'games'
end
end
end
before do
class << stream
attr_accessor :config, :nodes, :user
def write(node)
@nodes ||= []
@nodes << node
end
end
stream.config = config
stream.user = user
end
describe 'when missing a to address' do
let(:xml) { publish('') }
it 'raises a feature-not-implemented stanza error' do
stream.expect(:domain, 'wonderland.lit')
-> { subject.process }.must_raise Vines::StanzaErrors::FeatureNotImplemented
stream.verify
end
end
describe 'when addressed to bare server domain' do
let(:xml) { publish('wonderland.lit') }
it 'raises a feature-not-implemented stanza error' do
-> { subject.process }.must_raise Vines::StanzaErrors::FeatureNotImplemented
stream.verify
end
end
describe 'when addressed to a non-pubsub component' do
let(:router) { MiniTest::Mock.new }
let(:xml) { publish('bogus.wonderland.lit') }
before do
router.expect :route, nil, [xml]
stream.expect :router, router
end
it 'routes rather than handle locally' do
subject.process
stream.verify
router.verify
end
end
describe 'when publishing to multiple nodes' do
let(:xml) do
node(%q{
TestThis is a summary.TestThis is a summary.
})
end
it 'raises a bad-request stanza error' do
-> { subject.process }.must_raise Vines::StanzaErrors::BadRequest
stream.verify
end
end
describe 'when publishing multiple items' do
let(:pubsub) { MiniTest::Mock.new }
let(:xml) do
node(%q{
TestThis is a summary.bad
})
end
it 'raises a bad-request stanza error' do
pubsub.expect :node?, true, ['game_13']
subject.stub :pubsub, pubsub do
-> { subject.process }.must_raise Vines::StanzaErrors::BadRequest
end
stream.verify
pubsub.verify
end
end
describe 'when publishing one item with multiple payloads' do
let(:pubsub) { MiniTest::Mock.new }
let(:xml) do
node(%q{
TestThis is a summary.bad
})
end
it 'raises a bad-request stanza error' do
pubsub.expect :node?, true, ['game_13']
subject.stub :pubsub, pubsub do
-> { subject.process }.must_raise Vines::StanzaErrors::BadRequest
end
stream.verify
pubsub.verify
end
end
describe 'when publishing with no payload' do
let(:pubsub) { MiniTest::Mock.new }
let(:xml) do
node(%q{
})
end
it 'raises a bad-request stanza error' do
pubsub.expect :node?, true, ['game_13']
subject.stub :pubsub, pubsub do
-> { subject.process }.must_raise Vines::StanzaErrors::BadRequest
end
stream.verify
pubsub.verify
end
end
describe 'when publishing to a missing node' do
let(:xml) { publish('games.wonderland.lit') }
it 'raises an item-not-found stanza error' do
-> { subject.process }.must_raise Vines::StanzaErrors::ItemNotFound
stream.verify
end
end
describe 'when publishing an item without an id' do
let(:pubsub) { MiniTest::Mock.new }
let(:xml) { publish('games.wonderland.lit', '') }
let(:broadcast) { message_broadcast('') }
let(:response) do
node(%q{
})
end
before do
pubsub.expect :node?, true, ['game_13']
def pubsub.published; @published; end
def pubsub.publish(node, message)
@published ||= []
@published << [node, message]
end
end
it 'generates an item id in the response' do
subject.stub :pubsub, pubsub do
subject.process
end
stream.verify
pubsub.verify
stream.nodes.size.must_equal 1
# id is random
item = stream.nodes.first.xpath('ns:pubsub/ns:publish/ns:item',
'ns' => 'http://jabber.org/protocol/pubsub').first
item['id'].wont_be_nil
item.remove_attribute('id')
stream.nodes.first.must_equal response
end
it 'broadcasts the message with the generated item id' do
subject.stub :pubsub, pubsub do
subject.process
end
stream.verify
pubsub.verify
stream.nodes.size.must_equal 1
published_node, published_message = *pubsub.published[0]
published_node.must_equal 'game_13'
# id is random
item = published_message.xpath('ns:event/ns:items/ns:item',
'ns' => 'http://jabber.org/protocol/pubsub#event').first
item['id'].wont_be_nil
item.remove_attribute('id')
published_message.must_equal broadcast
end
end
describe 'when publishing a valid stanza' do
let(:pubsub) { MiniTest::Mock.new }
let(:xml) { publish('games.wonderland.lit') }
let(:response) { result(user.jid, 'games.wonderland.lit') }
let(:broadcast) { message_broadcast('item_42') }
it 'broadcasts and returns result to sender' do
pubsub.expect :node?, true, ['game_13']
pubsub.expect :publish, nil, ['game_13', broadcast]
subject.stub :pubsub, pubsub do
subject.process
end
stream.nodes.size.must_equal 1
stream.nodes.first.must_equal response
stream.verify
pubsub.verify
end
end
private
def message_broadcast(item_id)
item_id = (item_id.nil? || item_id.empty?) ? ' ' : " id='#{item_id}' "
node(%Q{
TestThis is a summary.})
end
def publish(to, item_id='item_42')
item_id = "id='#{item_id}'" unless item_id.nil? || item_id.empty?
body = %Q{
TestThis is a summary.}
iq(type: 'set', to: to, id: 42, body: body)
end
def result(to, from)
iq(from: from, id: 42, to: to, type: 'result')
end
end
diaspora-vines-0.2.0.develop.4/test/stanza/pubsub/delete_test.rb 0000644 0001750 0001750 00000010265 12654271406 025056 0 ustar sudheesh sudheesh # encoding: UTF-8
require 'test_helper'
describe Vines::Stanza::PubSub::Delete do
subject { Vines::Stanza::PubSub::Delete.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 }
pubsub 'games'
end
end
end
before do
class << stream
attr_accessor :config, :domain, :nodes, :user
def write(node)
@nodes ||= []
@nodes << node
end
end
stream.config = config
stream.domain = 'wonderland.lit'
stream.user = alice
end
describe 'when missing a to address' do
let(:xml) do
node(%q{
})
end
it 'raises a feature-not-implemented stanza error' do
-> { subject.process }.must_raise Vines::StanzaErrors::FeatureNotImplemented
stream.verify
end
end
describe 'when addressed to a bare server domain jid' do
let(:xml) do
node(%q{
})
end
it 'raises a feature-not-implemented stanza error' do
-> { subject.process }.must_raise Vines::StanzaErrors::FeatureNotImplemented
stream.verify
end
end
describe 'when addressed to a non-pubsub address' do
let(:router) { MiniTest::Mock.new }
let(:xml) do
node(%q{
})
end
before do
router.expect :route, nil, [xml]
stream.expect :router, router
end
it 'routes rather than handle locally' do
subject.process
stream.verify
router.verify
end
end
describe 'when stanza contains multiple delete elements' do
let(:xml) do
node(%q{
})
end
it 'raises a bad-request stanza error' do
-> { subject.process }.must_raise Vines::StanzaErrors::BadRequest
stream.verify
end
end
describe 'when deleting a missing node' do
let(:xml) do
node(%q{
})
end
it 'raises an item-not-found stanza error' do
-> { subject.process }.must_raise Vines::StanzaErrors::ItemNotFound
stream.verify
end
end
describe 'when valid stanza is received' do
let(:pubsub) { MiniTest::Mock.new }
let(:xml) do
node(%q{
})
end
let(:result) { node(%Q{}) }
let(:broadcast) do
node(%q{
})
end
before do
pubsub.expect :node?, true, ['game_13']
pubsub.expect :publish, nil, ['game_13', broadcast]
pubsub.expect :delete_node, nil, ['game_13']
end
it 'broadcasts the delete to subscribers' do
subject.stub :pubsub, pubsub do
subject.process
end
stream.verify
pubsub.verify
end
it 'sends a result stanza to sender' do
subject.stub :pubsub, pubsub do
subject.process
end
stream.nodes.size.must_equal 1
stream.nodes.first.must_equal result
end
end
end
diaspora-vines-0.2.0.develop.4/test/token_bucket_test.rb 0000644 0001750 0001750 00000002167 12654271406 023473 0 ustar sudheesh sudheesh # encoding: UTF-8
require 'test_helper'
describe Vines::TokenBucket do
subject { Vines::TokenBucket.new(10, 1) }
it 'raises with invalid capacity and rate values' do
-> { Vines::TokenBucket.new(0, 1) }.must_raise ArgumentError
-> { Vines::TokenBucket.new(1, 0) }.must_raise ArgumentError
-> { Vines::TokenBucket.new(-1, 1) }.must_raise ArgumentError
-> { Vines::TokenBucket.new(1, -1) }.must_raise ArgumentError
end
it 'does not allow taking a negative number of tokens' do
-> { subject.take(-1) }.must_raise ArgumentError
end
it 'does not allow taking more tokens than its capacity' do
refute subject.take(11)
end
it 'allows taking all tokens, but no more' do
assert subject.take(10)
refute subject.take(1)
end
it 'refills over time' do
assert subject.take(10)
refute subject.take(1)
Time.stub(:new, Time.now + 1) do
assert subject.take(1)
refute subject.take(1)
end
end
it 'does not refill over capacity' do
assert subject.take(10)
refute subject.take(1)
Time.stub(:new, Time.now + 15) do
refute subject.take(11)
end
end
end
diaspora-vines-0.2.0.develop.4/test/storage/ 0000775 0001750 0001750 00000000000 12654271406 021072 5 ustar sudheesh sudheesh diaspora-vines-0.2.0.develop.4/test/storage/mock_redis.rb 0000644 0001750 0001750 00000003047 12654271406 023540 0 ustar sudheesh sudheesh # 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 diaspora-vines-0.2.0.develop.4/test/storage/local_test.rb 0000644 0001750 0001750 00000004023 12654271406 023545 0 ustar sudheesh sudheesh # 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(" 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) }
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
diaspora-vines-0.2.0.develop.4/test/storage/sql_schema.rb 0000644 0001750 0001750 00000021142 12654271406 023534 0 ustar sudheesh sudheesh module SqlSchema
def fibered
EM.run do
Fiber.new do
yield
EM.stop
end.resume
end
end
def fragment_id
Digest::SHA1.hexdigest("characters:urn:wonderland")
end
def fragment
Nokogiri::XML(%q{
Alice
}.strip).root
end
def db_file
Rails.application.config.database_configuration["development"]["database"]
end
def storage
Vines::Storage::Sql.new
end
def create_schema(args={})
args[:force] ||= false
# disable stdout logging
ActiveRecord::Migration.verbose = false
ActiveRecord::Schema.define do
create_table "people", :force => true do |t|
t.string "guid", :null => false
t.text "url", :null => false
t.string "diaspora_handle", :null => false
t.text "serialized_public_key", :null => false
t.integer "owner_id"
t.datetime "created_at", :null => false
t.datetime "updated_at", :null => false
t.boolean "closed_account", :default => false
t.integer "fetch_status", :default => 0
end
add_index "people", ["diaspora_handle"], :name => "index_people_on_diaspora_handle", :unique => true
add_index "people", ["guid"], :name => "index_people_on_guid", :unique => true
add_index "people", ["owner_id"], :name => "index_people_on_owner_id", :unique => true
create_table "profiles", force: true do |t|
t.string "diaspora_handle"
t.string "first_name", limit: 127
t.string "last_name", limit: 127
t.string "image_url"
t.string "image_url_small"
t.string "image_url_medium"
t.date "birthday"
t.string "gender"
t.text "bio"
t.boolean "searchable", default: true, null: false
t.integer "person_id", null: false
t.datetime "created_at", null: false
t.datetime "updated_at", null: false
t.string "location"
t.string "full_name", limit: 70
t.boolean "nsfw", default: false
end
add_index "profiles", ["full_name", "searchable"], name: "index_profiles_on_full_name_and_searchable", using: :btree
add_index "profiles", ["full_name"], name: "index_profiles_on_full_name", using: :btree
add_index "profiles", ["person_id"], name: "index_profiles_on_person_id", using: :btree
create_table "aspects", :force => true do |t|
t.string "name", :null => false
t.integer "user_id", :null => false
t.datetime "created_at", :null => false
t.datetime "updated_at", :null => false
t.boolean "contacts_visible", :default => true, :null => false
t.integer "order_id"
t.boolean "chat_enabled", default: false
end
add_index "aspects", ["user_id", "contacts_visible"], :name => "index_aspects_on_user_id_and_contacts_visible"
add_index "aspects", ["user_id"], :name => "index_aspects_on_user_id"
create_table "aspect_memberships", :force => true do |t|
t.integer "aspect_id", :null => false
t.integer "contact_id", :null => false
t.datetime "created_at", :null => false
t.datetime "updated_at", :null => false
end
add_index "aspect_memberships", ["aspect_id", "contact_id"], :name => "index_aspect_memberships_on_aspect_id_and_contact_id", :unique => true
add_index "aspect_memberships", ["aspect_id"], :name => "index_aspect_memberships_on_aspect_id"
add_index "aspect_memberships", ["contact_id"], :name => "index_aspect_memberships_on_contact_id"
create_table "contacts", :force => true do |t|
t.integer "user_id", :null => false
t.integer "person_id", :null => false
t.datetime "created_at", :null => false
t.datetime "updated_at", :null => false
t.boolean "sharing", :default => false, :null => false
t.boolean "receiving", :default => false, :null => false
end
add_index "contacts", ["person_id"], :name => "index_contacts_on_person_id"
add_index "contacts", ["user_id", "person_id"], :name => "index_contacts_on_user_id_and_person_id", :unique => true
create_table "chat_contacts", :force => true do |t|
t.integer "user_id", :null => false
t.string "jid", :null => false
t.string "name"
t.string "ask", :limit => 128
t.string "subscription", :limit => 128, :null => false
t.text "groups"
end
add_index "chat_contacts", ["user_id", "jid"], :name => "index_chat_contacts_on_user_id_and_jid", :unique => true
create_table "chat_fragments", :force => true do |t|
t.integer "user_id", :null => false
t.string "root", :limit => 256, :null => false
t.string "namespace", :limit => 256, :null => false
t.text "xml", :null => false
end
add_index "chat_fragments", ["user_id"], :name => "index_chat_fragments_on_user_id", :unique => true
create_table "chat_offline_messages", force: true do |t|
t.string "from", null: false
t.string "to", null: false
t.text "message", null: false
t.datetime "created_at", null: false
end
create_table "users", :force => true do |t|
t.string "username"
t.text "serialized_private_key"
t.boolean "getting_started", :default => true, :null => false
t.boolean "disable_mail", :default => false, :null => false
t.string "language"
t.string "email", :default => "", :null => false
t.string "encrypted_password", :default => "", :null => false
t.string "invitation_token", :limit => 60
t.datetime "invitation_sent_at"
t.string "reset_password_token"
t.datetime "remember_created_at"
t.integer "sign_in_count", :default => 0
t.datetime "current_sign_in_at"
t.datetime "last_sign_in_at"
t.string "current_sign_in_ip"
t.string "last_sign_in_ip"
t.datetime "created_at", :null => false
t.datetime "updated_at", :null => false
t.string "invitation_service", :limit => 127
t.string "invitation_identifier", :limit => 127
t.integer "invitation_limit"
t.integer "invited_by_id"
t.string "invited_by_type"
t.string "authentication_token", :limit => 30
t.string "unconfirmed_email"
t.string "confirm_email_token", :limit => 30
t.datetime "locked_at"
t.boolean "show_community_spotlight_in_stream", :default => true, :null => false
t.boolean "auto_follow_back", :default => false
t.integer "auto_follow_back_aspect_id"
t.text "hidden_shareables"
t.datetime "reset_password_sent_at"
t.datetime "last_seen"
end
add_index "users", ["authentication_token"], :name => "index_users_on_authentication_token", :unique => true
add_index "users", ["email"], :name => "index_users_on_email"
add_index "users", ["invitation_service", "invitation_identifier"], :name => "index_users_on_invitation_service_and_invitation_identifier", :unique => true
add_index "users", ["invitation_token"], :name => "index_users_on_invitation_token"
add_index "users", ["username"], :name => "index_users_on_username", :unique => true
#add_foreign_key "aspect_memberships", "aspects", name: "aspect_memberships_aspect_id_fk", dependent: :delete
#add_foreign_key "aspect_memberships", "contacts", name: "aspect_memberships_contact_id_fk", dependent: :delete
#add_foreign_key "contacts", "people", name: "contacts_person_id_fk", dependent: :delete
end
end
end
diaspora-vines-0.2.0.develop.4/test/storage/null_test.rb 0000644 0001750 0001750 00000001346 12654271406 023432 0 ustar sudheesh sudheesh # 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
diaspora-vines-0.2.0.develop.4/test/storage/sql_test.rb 0000644 0001750 0001750 00000020664 12654271406 023263 0 ustar sudheesh sudheesh # encoding: UTF-8
require "test_helper"
require "storage/sql_schema"
module Diaspora
class Application < Rails::Application
def config.database_configuration
{
"development" => {
"adapter" => "sqlite3",
"database" => "test.db"
}
}
end
end
end
describe Vines::Storage::Sql do
include SqlSchema
def setup
_config = Vines::Config.configure do
max_offline_msgs 1
host "wonderland.lit" do
storage :fs do
dir Dir.tmpdir
end
end
end
@test_user = {
name: "test", url: "http://remote.host/",
image_url: "http://path.to/image.png", jid: "test@local.host", email: "test@test.de",
password: "$2a$10$c2G6rHjGeamQIOFI0c1/b.4mvFBw4AfOtgVrAkO1QPMuAyporj5e6", # pppppp
token: "1234"
}
return if File.exist?(db_file)
# create sql schema
storage && create_schema(force: true)
Vines::Storage::Sql::User.new(
username: @test_user[:name], email: @test_user[:email],
encrypted_password: @test_user[:password],
authentication_token: @test_user[:token]
).save
Vines::Storage::Sql::Person.new(
owner_id: 1,
guid: "1697a4b0198901321e9b10e6ba921ce9",
url: @test_user[:url],
serialized_public_key: "some pub key",
diaspora_handle: @test_user[:jid]
).save
Vines::Storage::Sql::Profile.new(
person_id: 1,
last_name: "Hirsch",
first_name: "Harry",
diaspora_handle: @test_user[:jid],
image_url: @test_user[:image_url]
).save
Vines::Storage::Sql::Contact.new(
user_id: 1, person_id: 1,
sharing: true, receiving: true
).save
Vines::Storage::Sql::Aspect.new(
user_id: 1, name: "without_chat",
contacts_visible: true, order_id: nil
).save
Vines::Storage::Sql::AspectMembership.new(
# without_chat
aspect_id: 1, contact_id: 1
).save
end
after do
# since we create the database once we
# have to reset it after every test run
Vines::Storage::Sql::ChatOfflineMessage.all.each(&:destroy)
end
def test_save_message
fibered do
db = storage
assert_nil db.save_message("", "", "")
assert_nil db.save_message("dude@valid@jid", "dude2@valid.jid", "")
assert_nil db.save_message("dude@valid@jid", "", "test")
assert_nil db.save_message("", "dude2@valid.jid", "test")
db.save_message(@test_user[:jid], "someone@inthe.void", "test")
msgs = Vines::Storage::Sql::ChatOfflineMessage.where(:to => "someone@inthe.void")
assert_equal 1, msgs.count
assert_equal "someone@inthe.void", msgs.first.to
assert_equal @test_user[:jid], msgs.first.from
assert_equal "test", msgs.first.message
db.save_message("someone@else.void", "someone@inthe.void", "test2")
msgs = Vines::Storage::Sql::ChatOfflineMessage.where(:to => "someone@inthe.void")
assert_equal 1, msgs.count # due max limit equals one (see max_offline_msgs)
assert_equal "someone@inthe.void", msgs.first.to
assert_equal "someone@else.void", msgs.first.from
assert_equal "test2", msgs.first.message # should be latest message
end
end
def test_find_avatar_by_jid
fibered do
db = storage
assert_nil db.find_avatar_by_jid("")
assert_nil db.find_avatar_by_jid("someone@inthe.void")
image_path = db.find_avatar_by_jid(@test_user[:jid])
assert_equal @test_user[:image_url], image_path
end
end
def test_find_messages
fibered do
db = storage
assert_nil db.find_messages("")
assert_equal 0, db.find_messages("someone@inthe.void").keys.count
Vines::Storage::Sql::ChatOfflineMessage.new(
from: @test_user[:jid], to: "someone@inthe.void", message: "test"
).save
msgs = db.find_messages("someone@inthe.void")
assert_equal 1, msgs.keys.count
msgs.each {|_, msg|
assert_equal "someone@inthe.void", msg[:to]
assert_equal @test_user[:jid], msg[:from]
assert_equal "test", msg[:message]
}
end
end
def test_destroy_message
fibered do
db = storage
Vines::Storage::Sql::ChatOfflineMessage.new(
from: @test_user[:jid], to: "someone@inthe.void", message: "test"
).save
Vines::Storage::Sql::ChatOfflineMessage.all.each do |com|
db.destroy_message(com.id)
end
count = Vines::Storage::Sql::ChatOfflineMessage.count(id: 1)
assert_equal 0, count
end
end
def test_aspect_chat_enabled
fibered do
db = storage
user = db.find_user(@test_user[:jid])
assert_equal 0, user.roster.length
aspect = Vines::Storage::Sql::Aspect.where(:id => 1)
aspect.update_all(name: "with_chat", chat_enabled: true)
user = db.find_user(@test_user[:jid])
assert_equal 1, user.roster.length
end
end
def test_save_user
fibered do
db = storage
user = Vines::User.new(jid: "test2@test.de",
name: "test2@test.de", password: "secret")
db.save_user(user)
assert_nil db.find_user("test2@test.de")
end
end
def test_find_user
fibered do
db = storage
user = db.find_user(nil)
assert_nil user
user = db.find_user(@test_user[:jid])
assert (user != nil), "no user found"
assert_equal @test_user[:name], user.name
user.roster do |contact|
assert_equal "Harry Hirsch", contact.name
end
user = db.find_user(Vines::JID.new(@test_user[:jid]))
assert (user != nil), "no user found"
assert_equal @test_user[:name], user.name
user = db.find_user(Vines::JID.new("#{@test_user[:jid]}/resource"))
assert (user != nil), "no user found"
assert_equal @test_user[:name], user.name
end
end
def test_authenticate
fibered do
db = storage
assert_nil db.authenticate(nil, nil)
assert_nil db.authenticate(nil, "secret")
assert_nil db.authenticate("bogus", nil)
# user credential auth
pepper = "065eb8798b181ff0ea2c5c16aee0ff8b70e04e2ee6bd6e08b49da46924223e39127d5335e466207d42bf2a045c12be5f90e92012a4f05f7fc6d9f3c875f4c95b"
user = db.authenticate(@test_user[:jid], "pppppp#{pepper}")
assert (user != nil), "no user found"
assert_equal @test_user[:name], user.name
# user token auth
user = db.authenticate(@test_user[:jid], @test_user[:token])
assert (user != nil), "no user found"
assert_equal @test_user[:name], user.name
end
end
def test_find_vcard
fibered do
db = storage
xml = db.find_vcard(@test_user[:jid])
assert (xml != nil), "no vcard found"
doc = node(xml)
assert_equal "Harry Hirsch", doc.search("FN").text
assert_equal "Harry", doc.search("GIVEN").text
assert_equal "Hirsch", doc.search("FAMILY").text
assert_equal @test_user[:url], doc.search("URL").text
assert_equal @test_user[:image_url], doc.search("EXTVAL").text
end
end
def test_save_vcard
fibered do
assert_nil storage.save_vcard(@test_user[:jid], "")
end
end
def test_find_fragment
skip("not working probably")
fibered do
db = storage
root = Nokogiri::XML(%()).root
bad_name = Nokogiri::XML(%()).root
bad_ns = Nokogiri::XML(%()).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)
assert (node != nil), "node should include fragment"
assert_equal fragment.to_s, node.to_s
node = db.find_fragment(Vines::JID.new("full@wonderland.lit"), root)
assert (node != nil), "node should include fragment"
assert_equal fragment.to_s, node.to_s
node = db.find_fragment(Vines::JID.new("full@wonderland.lit/resource"), root)
assert (node != nil), "node should include fragment"
assert_equal fragment.to_s, node.to_s
end
end
def test_save_fragment
skip("not working probably")
fibered do
db = storage
root = Nokogiri::XML(%()).root
db.save_fragment("test@test.de/resource1", fragment)
node = db.find_fragment("test@test.de", root)
assert (node != nil), "node should include fragment"
assert_equal fragment.to_s, node.to_s
end
end
end
diaspora-vines-0.2.0.develop.4/test/storage/storage_tests.rb 0000644 0001750 0001750 00000012563 12654271406 024312 0 ustar sudheesh sudheesh # 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{
Alice
}.strip).root
VCARD = Nokogiri::XML(%q{
Alice in Wonderland
}.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 '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')
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::Contact.new(
:jid => 'contact1@domain.tld/resource2',
:name => 'Contact 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 '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')
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{}).root
bad_name = Nokogiri::XML(%q{}).root
bad_ns = Nokogiri::XML(%q{}).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{}).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
diaspora-vines-0.2.0.develop.4/test/stanza_test.rb 0000644 0001750 0001750 00000004532 12654271406 022314 0 ustar sudheesh sudheesh # 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{hello!}) }
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{hello!}) }
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{hello!}) }
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('') }
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{hello!}) }
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{hello!}) }
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{hello!}) }
it 'is not considered a local stanza' do
stream.expect :config, config
subject.local?.must_equal false
stream.verify
end
end
end
diaspora-vines-0.2.0.develop.4/test/jid_test.rb 0000644 0001750 0001750 00000013554 12654271406 021566 0 ustar sudheesh sudheesh # encoding: UTF-8
require 'test_helper'
describe Vines::JID do
it 'handles empty input' do
[nil, ''].each do |text|
Vines::JID.new(text) # shouldn't raise an error
jid = Vines::JID.new(text)
assert_nil jid.node
assert_nil jid.resource
assert_equal '', jid.domain
assert_equal '', jid.to_s
assert_equal '', jid.bare.to_s
assert jid.empty?
refute jid.domain?
end
end
it 'raises when a jid part is too long' do
Vines::JID.new('n' * 1023) # shouldn't raise an error
assert_raises(ArgumentError) { Vines::JID.new('n' * 1024) }
assert_raises(ArgumentError) { Vines::JID.new('n', 'd' * 1024) }
assert_raises(ArgumentError) { Vines::JID.new('n', 'd', 'r' * 1024) }
Vines::JID.new('n' * 1023, 'd' * 1023, 'r' * 1023) # shouldn't raise an error
end
it 'correctly handles domain only jids' do
jid = Vines::JID.new('wonderland.lit')
assert_equal 'wonderland.lit', jid.to_s
assert_equal 'wonderland.lit', jid.domain
assert_nil jid.node
assert_nil jid.resource
assert_equal jid, jid.bare
assert jid.domain?
refute jid.empty?
end
it 'correctly handles bare jid components' do
jid = Vines::JID.new('alice', 'wonderland.lit')
assert_equal 'alice@wonderland.lit', jid.to_s
assert_equal 'wonderland.lit', jid.domain
assert_equal 'alice', jid.node
assert_nil jid.resource
assert_equal jid, jid.bare
refute jid.domain?
refute jid.empty?
end
it 'correctly parses bare jids' do
jid = Vines::JID.new('alice@wonderland.lit')
assert_equal 'alice@wonderland.lit', jid.to_s
assert_equal 'wonderland.lit', jid.domain
assert_equal 'alice', jid.node
assert_nil jid.resource
assert_equal jid, jid.bare
refute jid.domain?
refute jid.empty?
end
it 'correctly handles full jid components' do
jid = Vines::JID.new('alice', 'wonderland.lit', 'tea')
assert_equal 'alice@wonderland.lit/tea', jid.to_s
assert_equal 'wonderland.lit', jid.domain
assert_equal 'alice', jid.node
assert_equal 'tea', jid.resource
refute_equal jid, jid.bare
refute jid.domain?
refute jid.empty?
end
it 'correctly parses full jids' do
jid = Vines::JID.new('alice@wonderland.lit/tea')
assert_equal 'alice@wonderland.lit/tea', jid.to_s
assert_equal 'wonderland.lit', jid.domain
assert_equal 'alice', jid.node
assert_equal 'tea', jid.resource
refute_equal jid, jid.bare
refute jid.domain?
refute jid.empty?
end
it 'accepts separator characters in resource part' do
jid = Vines::JID.new('alice@wonderland.lit/foo/bar@blarg test')
assert_equal 'alice', jid.node
assert_equal 'wonderland.lit', jid.domain
assert_equal 'foo/bar@blarg test', jid.resource
end
it 'accepts separator characters in resource part with missing node part' do
jid = Vines::JID.new('wonderland.lit/foo/bar@blarg')
assert_nil jid.node
assert_equal 'wonderland.lit', jid.domain
assert_equal 'foo/bar@blarg', jid.resource
refute jid.domain?
end
it 'accepts strange characters in node part' do
jid = Vines::JID.new(%q{nasty!#$%()*+,-.;=?[\]^_`{|}~node@example.com})
jid.node.must_equal %q{nasty!#$%()*+,-.;=?[\]^_`{|}~node}
jid.domain.must_equal 'example.com'
jid.resource.must_be_nil
end
it 'accepts strange characters in resource part' do
jid = Vines::JID.new(%q{node@example.com/repulsive !#"$%&'()*+,-./:;<=>?@[\]^_`{|}~resource})
jid.node.must_equal 'node'
jid.domain.must_equal 'example.com'
jid.resource.must_equal %q{repulsive !#"$%&'()*+,-./:;<=>?@[\]^_`{|}~resource}
end
it 'rejects empty jid parts' do
assert_raises(ArgumentError) { Vines::JID.new('@wonderland.lit') }
assert_raises(ArgumentError) { Vines::JID.new('wonderland.lit/') }
assert_raises(ArgumentError) { Vines::JID.new('@') }
assert_raises(ArgumentError) { Vines::JID.new('alice@') }
assert_raises(ArgumentError) { Vines::JID.new('/') }
assert_raises(ArgumentError) { Vines::JID.new('/res') }
assert_raises(ArgumentError) { Vines::JID.new('@/') }
end
it 'rejects invalid characters' do
assert_raises(ArgumentError) { Vines::JID.new(%q{alice"s@wonderland.lit}) }
assert_raises(ArgumentError) { Vines::JID.new(%q{alice&s@wonderland.lit}) }
assert_raises(ArgumentError) { Vines::JID.new(%q{alice's@wonderland.lit}) }
assert_raises(ArgumentError) { Vines::JID.new(%q{alice:s@wonderland.lit}) }
assert_raises(ArgumentError) { Vines::JID.new(%q{alices@wonderland.lit}) }
assert_raises(ArgumentError) { Vines::JID.new("alice\u0000s@wonderland.lit") }
assert_raises(ArgumentError) { Vines::JID.new("alice\ts@wonderland.lit") }
assert_raises(ArgumentError) { Vines::JID.new("alice\rs@wonderland.lit") }
assert_raises(ArgumentError) { Vines::JID.new("alice\ns@wonderland.lit") }
assert_raises(ArgumentError) { Vines::JID.new("alice\vs@wonderland.lit") }
assert_raises(ArgumentError) { Vines::JID.new("alice\fs@wonderland.lit") }
assert_raises(ArgumentError) { Vines::JID.new(" alice@wonderland.lit") }
assert_raises(ArgumentError) { Vines::JID.new("alice@wonderland.lit ") }
assert_raises(ArgumentError) { Vines::JID.new("alice s@wonderland.lit") }
assert_raises(ArgumentError) { Vines::JID.new("alice@w onderland.lit") }
assert_raises(ArgumentError) { Vines::JID.new("alice@w\tonderland.lit") }
assert_raises(ArgumentError) { Vines::JID.new("alice@w\ronderland.lit") }
assert_raises(ArgumentError) { Vines::JID.new("alice@w\nonderland.lit") }
assert_raises(ArgumentError) { Vines::JID.new("alice@w\vonderland.lit") }
assert_raises(ArgumentError) { Vines::JID.new("alice@w\fonderland.lit") }
assert_raises(ArgumentError) { Vines::JID.new("alice@w\u0000onderland.lit") }
assert_raises(ArgumentError) { Vines::JID.new("alice@wonderland.lit/\u0000res") }
end
end
diaspora-vines-0.2.0.develop.4/test/test_helper.rb 0000644 0001750 0001750 00000003021 12654271406 022263 0 ustar sudheesh sudheesh # encoding: UTF-8
require 'tmpdir'
require 'vines'
require 'ext/nokogiri'
require 'minitest/autorun'
require 'rails/all'
# A simple hook allowing you to run a block of code after everything is done running
# In this case we want to delete the old sqlite database in case we run rake-test twice
Minitest.after_run {
db_file = "test.db"
File.delete(db_file) if File.exist?(db_file)
puts "After_run hook deleted #{db_file}"
}
class MiniTest::Spec
# Build an xml node with the given attributes. This is useful as a
# quick way to build a node to use as expected stanza output from a
# Stream#write call.
#
# options - The Hash of xml attributes to include on the iq element. Attribute
# values of nil or empty? are excluded from the generated element.
# :body - The String xml content to include in the iq element.
#
# Examples
#
# iq(from: from, id: 42, to: to, type: 'result', body: card)
#
# Returns a Nokogiri::XML::Node.
def iq(options)
body = options.delete(:body)
options.delete_if {|k, v| v.nil? || v.to_s.empty? }
attrs = options.map {|k, v| "#{k}=\"#{v}\"" }.join(' ')
node("#{body}")
end
# Parse xml into a nokogiri node. Strip excessive whitespace from the xml
# content before parsing because it affects comparisons in MiniTest::Mock
# expectations.
#
# xml - The String of xml content to parse.
#
# Returns a Nokogiri::XML::Node.
def node(xml)
xml = xml.strip.gsub(/\n|\s{2,}/, '')
Nokogiri::XML(xml).root
end
end
diaspora-vines-0.2.0.develop.4/test/router_test.rb 0000644 0001750 0001750 00000015504 12654271406 022335 0 ustar sudheesh sudheesh # encoding: UTF-8
require 'test_helper'
describe Vines::Router do
subject { Vines::Router.new(config) }
let(:alice) { Vines::JID.new('alice@wonderland.lit/tea') }
let(:hatter) { 'hatter@wonderland.lit/cake' }
let(:romeo) { 'romeo@verona.lit/party' }
let(:config) do
Vines::Config.new do
host 'wonderland.lit' do
storage(:fs) { dir Dir.tmpdir }
components 'tea' => 'secr3t'
end
end
end
describe '#connected_resources' do
let(:cake) { 'alice@wonderland.lit/cake' }
let(:stream1) { stream(alice) }
let(:stream2) { stream(cake) }
it 'is empty before any streams are connected' do
subject.connected_resources(alice, alice).size.must_equal 0
subject.connected_resources(cake, alice).size.must_equal 0
subject.size.must_equal 0
end
it 'returns only one stream matching full jid' do
subject << stream1
subject << stream2
streams = subject.connected_resources(alice, alice)
streams.size.must_equal 1
streams.first.user.jid.must_equal alice
streams = subject.connected_resources(cake, alice)
streams.size.must_equal 1
streams.first.user.jid.to_s.must_equal cake
end
it 'returns all streams matching bare jid' do
subject << stream1
subject << stream2
streams = subject.connected_resources(alice.bare, alice)
streams.size.must_equal 2
subject.size.must_equal 2
end
end
describe '#connected_resources with permissions' do
let(:stream1) { stream(alice) }
let(:stream2) { stream(romeo) }
before do
subject << stream1
subject << stream2
end
it 'denies access when cross domain messages is off' do
subject.connected_resources(alice, romeo).size.must_equal 0
end
it 'allows access when cross domain messages is on' do
config.vhost('wonderland.lit').cross_domain_messages true
subject.connected_resources(alice, romeo).size.must_equal 1
end
end
describe '#available_resources' do
let(:cake) { 'alice@wonderland.lit/cake' }
let(:stream1) { stream(alice) }
let(:stream2) { stream(cake) }
before do
stream1.send 'available?=', true
stream2.send 'available?=', false
end
it 'is empty before any streams are connected' do
subject.available_resources(alice, alice).size.must_equal 0
subject.available_resources(cake, alice).size.must_equal 0
subject.size.must_equal 0
end
it 'returns available streams based on bare jid, not full jid' do
subject << stream1
subject << stream2
streams = [alice, cake, alice.bare].map do |jid|
subject.available_resources(jid, alice)
end.flatten
# should only have found alice's stream
streams.size.must_equal 3
streams.uniq.size.must_equal 1
streams.first.user.jid.must_equal alice
subject.size.must_equal 2
end
end
describe '#interested_resources with no streams' do
it 'is empty before any streams are connected' do
subject.interested_resources(alice, alice).size.must_equal 0
subject.interested_resources(hatter, alice).size.must_equal 0
subject.interested_resources(alice, hatter, alice).size.must_equal 0
subject.size.must_equal 0
end
end
describe '#interested_resources' do
let(:stream1) { stream(alice) }
let(:stream2) { stream(hatter) }
before do
stream1.send 'interested?=', true
stream2.send 'interested?=', false
subject << stream1
subject << stream2
end
it 'does not find streams for unauthenticated jids' do
subject.interested_resources('bogus@wonderland.lit', alice).size.must_equal 0
end
it 'finds interested streams for full jids' do
subject.interested_resources(alice, hatter, alice).size.must_equal 1
subject.interested_resources([alice, hatter], alice).size.must_equal 1
subject.interested_resources(alice, hatter, alice)[0].user.jid.must_equal alice
end
it 'does not find streams for uninterested jids' do
subject.interested_resources(hatter, alice).size.must_equal 0
subject.interested_resources([hatter], alice).size.must_equal 0
end
it 'finds interested streams for bare jids' do
subject.interested_resources(alice.bare, alice).size.must_equal 1
subject.interested_resources(alice.bare, alice)[0].user.jid.must_equal alice
end
end
describe '#delete' do
let(:stream1) { stream(alice) }
let(:stream2) { stream(hatter) }
it 'correctly adds and removes streams' do
subject.size.must_equal 0
subject << stream1
subject << stream2
subject.size.must_equal 2
subject.delete(stream2)
subject.size.must_equal 1
subject.delete(stream2)
subject.size.must_equal 1
subject.delete(stream1)
subject.size.must_equal 0
end
end
describe 'load balanced component streams' do
let(:stream1) { component('tea.wonderland.lit') }
let(:stream2) { component('tea.wonderland.lit') }
let(:stanza) { node('test')}
before do
subject << stream1
subject << stream2
end
it 'must evenly distribute routed stanzas to both streams' do
100.times { subject.route(stanza) }
(stream1.count + stream2.count).must_equal 100
stream1.count.must_be :>, 33
stream2.count.must_be :>, 33
end
end
describe 'load balanced s2s streams' do
let(:stream1) { s2s('wonderland.lit', 'verona.lit') }
let(:stream2) { s2s('wonderland.lit', 'verona.lit') }
let(:stanza) { node('test') }
before do
config.vhost('wonderland.lit').cross_domain_messages true
subject << stream1
subject << stream2
end
it 'must evenly distribute routed stanzas to both streams' do
100.times { subject.route(stanza) }
(stream1.count + stream2.count).must_equal 100
stream1.count.must_be :>, 33
stream2.count.must_be :>, 33
end
end
private
def stream(jid)
OpenStruct.new.tap do |stream|
stream.send('connected?=', true)
stream.stream_type = :client
stream.user = Vines::User.new(jid: jid)
end
end
def component(jid)
OpenStruct.new.tap do |stream|
stream.stream_type = :component
stream.remote_domain = jid
stream.send('ready?=', true)
def stream.count; @count || 0; end
def stream.write(stanza)
@count ||= 0
@count += 1
end
end
end
def s2s(domain, remote_domain)
OpenStruct.new.tap do |stream|
stream.stream_type = :server
stream.domain = domain
stream.remote_domain = remote_domain
stream.send('ready?=', true)
def stream.count; @count || 0; end
def stream.write(stanza)
@count ||= 0
@count += 1
end
end
end
end
diaspora-vines-0.2.0.develop.4/test/stream/ 0000775 0001750 0001750 00000000000 12654271406 020721 5 ustar sudheesh sudheesh diaspora-vines-0.2.0.develop.4/test/stream/component/ 0000775 0001750 0001750 00000000000 12654271406 022723 5 ustar sudheesh sudheesh diaspora-vines-0.2.0.develop.4/test/stream/component/ready_test.rb 0000644 0001750 0001750 00000006124 12654271406 025414 0 ustar sudheesh sudheesh # encoding: UTF-8
require 'test_helper'
describe Vines::Stream::Component::Ready do
subject { Vines::Stream::Component::Ready.new(stream, nil) }
let(:alice) { Vines::User.new(jid: 'alice@tea.wonderland.lit') }
let(:hatter) { Vines::User.new(jid: 'hatter@wonderland.lit') }
let(:stream) { MiniTest::Mock.new }
let(:config) do
Vines::Config.new do
host 'wonderland.lit' do
storage(:fs) { dir Dir.tmpdir }
end
end
end
before do
class << stream
attr_accessor :config
end
stream.config = config
end
describe 'when missing to and from addresses' do
it 'raises an improper-addressing stream error' do
node = node('')
-> { subject.node(node) }.must_raise Vines::StreamErrors::ImproperAddressing
stream.verify
end
end
describe 'when missing from address' do
it 'raises an improper-addressing stream error' do
node = node(%q{})
-> { subject.node(node) }.must_raise Vines::StreamErrors::ImproperAddressing
stream.verify
end
end
describe 'when missing to address' do
it 'raises an improper-addressing stream error' do
node = node(%q{})
-> { subject.node(node) }.must_raise Vines::StreamErrors::ImproperAddressing
stream.verify
end
end
describe 'when from address domain does not match component domain' do
it 'raises and invalid-from stream error' do
stream.expect :remote_domain, 'tea.wonderland.lit'
node = node(%q{})
-> { subject.node(node) }.must_raise Vines::StreamErrors::InvalidFrom
stream.verify
end
end
describe 'when unrecognized element is received' do
it 'raises an unsupported-stanza-type stream error' do
node = node('')
-> { subject.node(node) }.must_raise Vines::StreamErrors::UnsupportedStanzaType
stream.verify
end
end
describe 'when addressed to a remote jid' do
let(:router) { MiniTest::Mock.new }
let(:xml) { node(%q{}) }
before do
router.expect :route, nil, [xml]
stream.expect :remote_domain, 'tea.wonderland.lit'
stream.expect :user=, nil, [alice]
stream.expect :router, router
end
it 'routes rather than handle locally' do
subject.node(xml)
stream.verify
router.verify
end
end
describe 'when addressed to a local jid' do
let(:recipient) { MiniTest::Mock.new }
let(:xml) { node(%q{}) }
before do
recipient.expect :user, hatter
recipient.expect :write, nil, [xml]
stream.expect :remote_domain, 'tea.wonderland.lit'
stream.expect :user=, nil, [alice]
stream.expect :user, alice
stream.expect :connected_resources, [recipient], [hatter.jid]
end
it 'sends the message to the connected stream' do
subject.node(xml)
stream.verify
recipient.verify
end
end
end
diaspora-vines-0.2.0.develop.4/test/stream/component/handshake_test.rb 0000644 0001750 0001750 00000003072 12654271406 026235 0 ustar sudheesh sudheesh # encoding: UTF-8
require 'test_helper'
describe Vines::Stream::Component::Handshake do
subject { Vines::Stream::Component::Handshake.new(stream) }
let(:stream) { MiniTest::Mock.new }
describe 'when invalid element is received' do
it 'raises a not-authorized stream error' do
node = node('')
-> { subject.node(node) }.must_raise Vines::StreamErrors::NotAuthorized
end
end
describe 'when handshake with no text is received' do
it 'raises a not-authorized stream error' do
stream.expect :secret, 'secr3t'
node = node('')
-> { subject.node(node) }.must_raise Vines::StreamErrors::NotAuthorized
stream.verify
end
end
describe 'when handshake with invalid secret is received' do
it 'raises a not-authorized stream error' do
stream.expect :secret, 'secr3t'
node = node('bogus')
-> { subject.node(node) }.must_raise Vines::StreamErrors::NotAuthorized
stream.verify
end
end
describe 'when good handshake is received' do
let(:router) { MiniTest::Mock.new }
before do
router.expect :<<, nil, [stream]
stream.expect :router, router
stream.expect :secret, 'secr3t'
stream.expect :write, nil, ['']
stream.expect :advance, nil, [Vines::Stream::Component::Ready.new(stream)]
end
it 'completes the handshake and advances the stream into the ready state' do
node = node('secr3t')
subject.node(node)
stream.verify
router.verify
end
end
end
diaspora-vines-0.2.0.develop.4/test/stream/component/start_test.rb 0000644 0001750 0001750 00000002307 12654271406 025444 0 ustar sudheesh sudheesh # encoding: UTF-8
require 'test_helper'
describe Vines::Stream::Component::Start do
before do
@stream = MiniTest::Mock.new
@state = Vines::Stream::Component::Start.new(@stream)
end
it 'raises not-authorized stream error for invalid element' do
node = node('')
assert_raises(Vines::StreamErrors::NotAuthorized) { @state.node(node) }
end
it 'raises not-authorized stream error for missing stream namespace' do
node = node('')
assert_raises(Vines::StreamErrors::NotAuthorized) { @state.node(node) }
end
it 'raises not-authorized stream error for invalid stream namespace' do
node = node('')
assert_raises(Vines::StreamErrors::NotAuthorized) { @state.node(node) }
end
it 'advances the state machine for valid stream header' do
node = node(%q{})
@stream.expect(:start, nil, [node])
@stream.expect(:advance, nil, [Vines::Stream::Component::Handshake.new(@stream)])
@state.node(node)
assert @stream.verify
end
private
def node(xml)
Nokogiri::XML(xml).root
end
end
diaspora-vines-0.2.0.develop.4/test/stream/client/ 0000775 0001750 0001750 00000000000 12654271406 022177 5 ustar sudheesh sudheesh diaspora-vines-0.2.0.develop.4/test/stream/client/ready_test.rb 0000644 0001750 0001750 00000001750 12654271406 024670 0 ustar sudheesh sudheesh # encoding: UTF-8
require 'test_helper'
describe Vines::Stream::Client::Ready do
STANZAS = []
before do
@stream = MiniTest::Mock.new
@state = Vines::Stream::Client::Ready.new(@stream, nil)
def @state.to_stanza(node)
if node.name == 'bogus'
nil
else
stanza = MiniTest::Mock.new
stanza.expect(:process, nil)
stanza.expect(:validate_to, nil)
stanza.expect(:validate_from, nil)
STANZAS << stanza
stanza
end
end
end
after do
STANZAS.clear
end
it 'processes a valid node' do
node = node('')
@state.node(node)
assert_equal 1, STANZAS.size
assert STANZAS.map {|s| s.verify }.all?
end
it 'raises an unsupported-stanza-type stream error for invalid node' do
node = node('')
assert_raises(Vines::StreamErrors::UnsupportedStanzaType) { @state.node(node) }
assert STANZAS.empty?
end
private
def node(xml)
Nokogiri::XML(xml).root
end
end
diaspora-vines-0.2.0.develop.4/test/stream/client/auth_test.rb 0000644 0001750 0001750 00000010717 12654271406 024530 0 ustar sudheesh sudheesh # encoding: UTF-8
require 'test_helper'
describe Vines::Stream::Client::Auth do
# 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)
username = username.to_s
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
subject { Vines::Stream::Client::Auth.new(stream) }
let(:stream) { MiniTest::Mock.new }
describe 'error handling' do
it 'rejects invalid element' do
node = node('')
-> { subject.node(node) }.must_raise Vines::StreamErrors::NotAuthorized
end
it 'rejects invalid element in sasl namespace' do
node = node(%Q{})
-> { subject.node(node) }.must_raise Vines::StreamErrors::NotAuthorized
end
it 'rejects auth elements missing sasl namespace' do
node = node('')
-> { subject.node(node) }.must_raise Vines::StreamErrors::NotAuthorized
end
it 'rejects auth element with invalid namespace' do
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']
node = node(%Q{tokens})
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']
node = node(%Q{tokens})
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 = 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 = 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 = 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{}]
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 :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 plain(authzid)
node(%Q{#{authzid}})
end
end
diaspora-vines-0.2.0.develop.4/test/stream/client/session_test.rb 0000644 0001750 0001750 00000001301 12654271406 025237 0 ustar sudheesh sudheesh # encoding: UTF-8
require 'test_helper'
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) }
describe 'session equality checks' do
it 'uses class in equality check' do
(subject <=> 42).must_be_nil
end
it 'is equal to itself' do
assert subject == subject
assert subject.eql?(subject)
assert subject.hash == subject.hash
end
it 'is not equal to another session' do
refute subject == another
refute subject.eql?(another)
refute subject.hash == another.hash
end
end
end
diaspora-vines-0.2.0.develop.4/test/stream/http/ 0000775 0001750 0001750 00000000000 12654271406 021700 5 ustar sudheesh sudheesh diaspora-vines-0.2.0.develop.4/test/stream/http/ready_test.rb 0000644 0001750 0001750 00000006037 12654271406 024374 0 ustar sudheesh sudheesh # encoding: UTF-8
require 'test_helper'
describe Vines::Stream::Http::Ready do
subject { Vines::Stream::Http::Ready.new(stream, nil) }
let(:stream) { MiniTest::Mock.new }
let(:alice) { Vines::User.new(jid: 'alice@wonderland.lit') }
let(:hatter) { Vines::User.new(jid: 'hatter@wonderland.lit') }
let(:config) do
Vines::Config.new do
host 'wonderland.lit' do
storage(:fs) { dir Dir.tmpdir }
end
end
end
it "raises when body element is missing" do
node = node('')
stream.expect :valid_session?, true, [nil]
-> { subject.node(node) }.must_raise Vines::StreamErrors::NotAuthorized
end
it "raises when namespace is missing" do
node = node('')
stream.expect :valid_session?, true, ['12']
-> { subject.node(node) }.must_raise Vines::StreamErrors::NotAuthorized
end
it "raises when rid attribute is missing" do
node = node('')
stream.expect :valid_session?, true, ['12']
-> { subject.node(node) }.must_raise Vines::StreamErrors::NotAuthorized
end
it "raises when session id is invalid" do
stream.expect :valid_session?, false, ['12']
node = node('
')
-> { subject.node(node) }.must_raise Vines::StreamErrors::NotAuthorized
stream.verify
end
it "processes when body element is empty" do
node = node('