diaspora-vines 0.2.0.develop.2 → 0.2.0.develop.3

data/test/stream/server/auth_test.rb

@@ -1,6 +1,6 @@
 # encoding: UTF-8
 
-require 'test_helper'
+require "test_helper"
 
 describe Vines::Stream::Server::Auth do
   # disable logging for tests
@@ -13,49 +13,58 @@ describe Vines::Stream::Server::Auth do
     class << stream
       attr_accessor :remote_domain
     end
-    stream.remote_domain = 'wonderland.lit'
+    stream.remote_domain = "wonderland.lit"
   end
 
-  describe 'when given a valid authzid' do
+  describe "when given a valid authzid" do
     before do
-      stream.expect :cert_domain_matches?, true, ['wonderland.lit']
-      stream.expect :write, nil, ['<success xmlns="urn:ietf:params:xml:ns:xmpp-sasl"/>']
+      stream.expect :cert_domain_matches?, true, ["wonderland.lit"]
+      stream.expect :write, nil, [%(<success xmlns="urn:ietf:params:xml:ns:xmpp-sasl"/>)]
       stream.expect :advance, nil, [Vines::Stream::Server::FinalRestart]
       stream.expect :reset, nil
-      stream.expect :authentication_mechanisms, ['EXTERNAL']
+      stream.expect :authentication_mechanisms, ["EXTERNAL"]
     end
 
-    it 'passes external auth with empty authzid' do
-      node = external('=')
-      subject.node(node)
-      stream.verify
+    it "passes external auth with empty authzid" do
+      EM.run {
+        node = external("=")
+        subject.node(node)
+        stream.verify
+        EM.stop
+      }
     end
 
-    it 'passes external auth with authzid matching from domain' do
-      node = external(Base64.strict_encode64('wonderland.lit'))
-      subject.node(node)
-      stream.verify
+    it "passes external auth with authzid matching from domain" do
+      EM.run {
+        node = external(Base64.strict_encode64("wonderland.lit"))
+        subject.node(node)
+        stream.verify
+        EM.stop
+      }
     end
   end
 
-  describe 'when given an invalid authzid' do
+  describe "when given an invalid authzid" do
     before do
-      stream.expect :write, nil, ['</stream:stream>']
+      stream.expect :write, nil, ["</stream:stream>"]
       stream.expect :close_connection_after_writing, nil
       stream.expect :error, nil, [Vines::SaslErrors::InvalidAuthzid]
-      stream.expect :authentication_mechanisms, ['EXTERNAL']
+      stream.expect :authentication_mechanisms, ["EXTERNAL"]
     end
 
-    it 'fails external auth with mismatched from domain' do
-      node = external(Base64.strict_encode64('verona.lit'))
-      subject.node(node)
-      stream.verify
+    it "fails external auth with mismatched from domain" do
+      EM.run {
+        node = external(Base64.strict_encode64("verona.lit"))
+        subject.node(node)
+        stream.verify
+        EM.stop
+      }
     end
   end
 
   private
 
   def external(authzid)
-    node(%Q{<auth xmlns="urn:ietf:params:xml:ns:xmpp-sasl" mechanism="EXTERNAL">#{authzid}</auth>})
+    node(%(<auth xmlns="urn:ietf:params:xml:ns:xmpp-sasl" mechanism="EXTERNAL">#{authzid}</auth>))
   end
 end

data/test/stream/server/outbound/auth_dialback_result_test.rb

@@ -1,6 +1,6 @@
 # encoding: UTF-8
 
-require 'test_helper'
+require "test_helper"
 
 describe Vines::Stream::Server::Outbound::AuthDialbackResult do
   before do
@@ -9,24 +9,39 @@ describe Vines::Stream::Server::Outbound::AuthDialbackResult do
   end
 
   def test_invalid_stanza
-    node = node('<message/>')
-    assert_raises(Vines::StreamErrors::NotAuthorized) { @state.node(node) }
-    assert @stream.verify
+    EM.run {
+      node = node("<message/>")
+      assert_raises(Vines::StreamErrors::NotAuthorized) { @state.node(node) }
+      assert @stream.verify
+      EM.stop
+    }
   end
 
   def test_invalid_result
-    node = node(%Q{<db:result xmlns:db="#{Vines::NAMESPACES[:legacy_dialback]}" from="remote.host" to="local.host" type="invalid"/>})
-    @stream.expect(:close_connection, nil)
-    @state.node(node)
-    assert @stream.verify
+    EM.run {
+      node = node(
+        %(<db:result xmlns:db="#{Vines::NAMESPACES[:legacy_dialback]}" ) +
+        %(from="remote.host" to="local.host" type="invalid"/>)
+      )
+      @stream.expect(:close_connection, nil)
+      @state.node(node)
+      assert @stream.verify
+      EM.stop
+    }
   end
 
   def test_valid_result
-    node = node(%Q{<db:result xmlns:db="#{Vines::NAMESPACES[:legacy_dialback]}" from="remote.host" to="local.host" type="valid"/>})
-    @stream.expect(:advance, nil, [Vines::Stream::Server::Ready])
-    @stream.expect(:notify_connected, nil)
-    @state.node(node)
-    assert @stream.verify
+    EM.run {
+      node = node(
+        %(<db:result xmlns:db="#{Vines::NAMESPACES[:legacy_dialback]}" ) +
+        %(from="remote.host" to="local.host" type="valid"/>)
+      )
+      @stream.expect(:advance, nil, [Vines::Stream::Server::Ready])
+      @stream.expect(:notify_connected, nil)
+      @state.node(node)
+      assert @stream.verify
+      EM.stop
+    }
   end
 
   private

data/test/stream/server/outbound/auth_external_test.rb

@@ -1,6 +1,6 @@
 # encoding: UTF-8
 
-require 'test_helper'
+require "test_helper"
 
 describe Vines::Stream::Server::Outbound::AuthExternal do
   before do
@@ -9,62 +9,92 @@ describe Vines::Stream::Server::Outbound::AuthExternal do
   end
 
   def test_invalid_element
-    node = node('<message/>')
-    assert_raises(Vines::StreamErrors::NotAuthorized) { @state.node(node) }
+    EM.run {
+      node = node("<message/>")
+      assert_raises(Vines::StreamErrors::NotAuthorized) { @state.node(node) }
+      EM.stop
+    }
   end
 
   def test_invalid_sasl_element
-    node = node(%Q{<message xmlns="#{Vines::NAMESPACES[:sasl]}"/>})
-    assert_raises(Vines::StreamErrors::NotAuthorized) { @state.node(node) }
+    EM.run {
+      node = node(%(<message xmlns="#{Vines::NAMESPACES[:sasl]}"/>))
+      assert_raises(Vines::StreamErrors::NotAuthorized) { @state.node(node) }
+      EM.stop
+    }
   end
 
   def test_missing_namespace
-    node = node('<stream:features/>')
-    assert_raises(Vines::StreamErrors::NotAuthorized) { @state.node(node) }
+    EM.run {
+      node = node("<stream:features/>")
+      assert_raises(Vines::StreamErrors::NotAuthorized) { @state.node(node) }
+      EM.stop
+    }
   end
 
   def test_invalid_namespace
-    node = node('<stream:features xmlns="bogus"/>')
-    assert_raises(Vines::StreamErrors::NotAuthorized) { @state.node(node) }
+    EM.run {
+      node = node(%(<stream:features xmlns="bogus"/>))
+      assert_raises(Vines::StreamErrors::NotAuthorized) { @state.node(node) }
+      EM.stop
+    }
   end
 
   def test_missing_mechanisms
-    node = node(%Q{<stream:features xmlns:stream="http://etherx.jabber.org/streams"/>})
-    assert_raises(Vines::StreamErrors::NotAuthorized) { @state.node(node) }
+    EM.run {
+      node = node(%(<stream:features xmlns:stream="#{Vines::NAMESPACES[:stream]}"/>))
+      assert_raises(Vines::StreamErrors::NotAuthorized) { @state.node(node) }
+      EM.stop
+    }
   end
 
   def test_missing_mechanisms_namespace
-    node = node(%Q{<stream:features xmlns:stream="http://etherx.jabber.org/streams"><mechanisms/></stream:features>})
-    assert_raises(Vines::StreamErrors::NotAuthorized) { @state.node(node) }
+    EM.run {
+      node = node(%(<stream:features xmlns:stream="#{Vines::NAMESPACES[:stream]}"><mechanisms/></stream:features>))
+      assert_raises(Vines::StreamErrors::NotAuthorized) { @state.node(node) }
+      EM.stop
+    }
   end
 
   def test_missing_mechanism
-    mechanisms = %q{<mechanisms xmlns="urn:ietf:params:xml:ns:xmpp-sasl"/>}
-    node = node(%Q{<stream:features xmlns:stream="http://etherx.jabber.org/streams">#{mechanisms}</stream:features>})
-    assert_raises(Vines::StreamErrors::NotAuthorized) { @state.node(node) }
+    EM.run {
+      mechanisms = %(<mechanisms xmlns="#{Vines::NAMESPACES[:sasl]}"/>)
+      node = node(%(<stream:features xmlns:stream="#{Vines::NAMESPACES[:stream]}">#{mechanisms}</stream:features>))
+      assert_raises(Vines::StreamErrors::NotAuthorized) { @state.node(node) }
+      EM.stop
+    }
   end
 
   def test_missing_mechanism_text
-    mechanisms = %q{<mechanisms xmlns="urn:ietf:params:xml:ns:xmpp-sasl"><mechanism></mechanism></mechanisms>}
-    node = node(%Q{<stream:features xmlns:stream="http://etherx.jabber.org/streams">#{mechanisms}</stream:features>})
-    assert_raises(Vines::StreamErrors::NotAuthorized) { @state.node(node) }
+    EM.run {
+      mechanisms = %(<mechanisms xmlns="#{Vines::NAMESPACES[:sasl]}"><mechanism></mechanism></mechanisms>)
+      node = node(%(<stream:features xmlns:stream="#{Vines::NAMESPACES[:stream]}">#{mechanisms}</stream:features>))
+      assert_raises(Vines::StreamErrors::NotAuthorized) { @state.node(node) }
+      EM.stop
+    }
   end
 
   def test_invalid_mechanism_text
-    mechanisms = %q{<mechanisms xmlns="urn:ietf:params:xml:ns:xmpp-sasl"><mechanism>BOGUS</mechanism></mechanisms>}
-    node = node(%Q{<stream:features xmlns:stream="http://etherx.jabber.org/streams">#{mechanisms}</stream:features>})
-    assert_raises(Vines::StreamErrors::NotAuthorized) { @state.node(node) }
+    EM.run {
+      mechanisms = %(<mechanisms xmlns="#{Vines::NAMESPACES[:sasl]}"><mechanism>BOGUS</mechanism></mechanisms>)
+      node = node(%(<stream:features xmlns:stream="#{Vines::NAMESPACES[:stream]}">#{mechanisms}</stream:features>))
+      assert_raises(Vines::StreamErrors::NotAuthorized) { @state.node(node) }
+      EM.stop
+    }
   end
 
   def test_valid_mechanism
-    @stream.expect(:domain, 'wonderland.lit')
-    expected = %Q{<auth xmlns="urn:ietf:params:xml:ns:xmpp-sasl" mechanism="EXTERNAL">d29uZGVybGFuZC5saXQ=</auth>}
-    @stream.expect(:write, nil, [expected])
-    @stream.expect(:advance, nil, [Vines::Stream::Server::Outbound::AuthExternalResult.new(@stream)])
-    mechanisms = %q{<mechanisms xmlns="urn:ietf:params:xml:ns:xmpp-sasl"><mechanism>EXTERNAL</mechanism></mechanisms>}
-    node = node(%Q{<stream:features xmlns:stream="http://etherx.jabber.org/streams">#{mechanisms}</stream:features>})
-    @state.node(node)
-    assert @stream.verify
+    EM.run {
+      @stream.expect(:domain, "wonderland.lit")
+      expected = %(<auth xmlns="#{Vines::NAMESPACES[:sasl]}" mechanism="EXTERNAL">d29uZGVybGFuZC5saXQ=</auth>)
+      @stream.expect(:write, nil, [expected])
+      @stream.expect(:advance, nil, [Vines::Stream::Server::Outbound::AuthExternalResult.new(@stream)])
+      mechanisms = %(<mechanisms xmlns="#{Vines::NAMESPACES[:sasl]}"><mechanism>EXTERNAL</mechanism></mechanisms>)
+      node = node(%(<stream:features xmlns:stream="#{Vines::NAMESPACES[:stream]}">#{mechanisms}</stream:features>))
+      @state.node(node)
+      assert @stream.verify
+      EM.stop
+    }
   end
 
   private

data/test/stream/server/outbound/auth_restart_test.rb

@@ -1,6 +1,6 @@
 # encoding: UTF-8
 
-require 'test_helper'
+require "test_helper"
 
 describe Vines::Stream::Server::Outbound::AuthRestart do
   before do
@@ -9,40 +9,64 @@ describe Vines::Stream::Server::Outbound::AuthRestart do
   end
 
   def test_missing_namespace
-    node = node('<stream:stream/>')
-    assert_raises(Vines::StreamErrors::NotAuthorized) { @state.node(node) }
-    assert @stream.verify
+    EM.run {
+      node = node("<stream:stream/>")
+      assert_raises(Vines::StreamErrors::NotAuthorized) { @state.node(node) }
+      assert @stream.verify
+      EM.stop
+    }
   end
 
   def test_invalid_namespace
-    node = node(%Q{<stream:stream xmlns="#{Vines::NAMESPACES[:stream]}"/>})
-    assert_raises(Vines::StreamErrors::NotAuthorized) { @state.node(node) }
+    EM.run {
+      node = node(%(<stream:stream xmlns="#{Vines::NAMESPACES[:stream]}"/>))
+      assert_raises(Vines::StreamErrors::NotAuthorized) { @state.node(node) }
+      EM.stop
+    }
   end
 
   def test_valid_stream
-    node = node(%Q{<stream:stream xmlns='jabber:client' xmlns:stream='#{Vines::NAMESPACES[:stream]}' xml:lang='en' id='1234' from='host.com' version='1.0'>})
-    @stream.expect(:advance, nil, [Vines::Stream::Server::Outbound::AuthExternal])
-    @stream.expect(:dialback_retry?, false)
-    @state.node(node)
-    assert @stream.verify
+    EM.run {
+      node = node(
+        %(<stream:stream xmlns="jabber:client" xmlns:stream="#{Vines::NAMESPACES[:stream]}" ) +
+        %(xml:lang="en" id="1234" from="host.com" version="1.0">)
+      )
+      @stream.expect(:advance, nil, [Vines::Stream::Server::Outbound::AuthExternal])
+      @stream.expect(:dialback_retry?, false)
+      @state.node(node)
+      assert @stream.verify
+      EM.stop
+    }
   end
 
   def test_valid_stream_restart
-    node = node(%Q{<stream:stream xmlns='jabber:client' xmlns:stream='#{Vines::NAMESPACES[:stream]}' xml:lang='en' id='1234' from='host.com' version='1.0'>})
-    @stream.expect(:advance, nil, [Vines::Stream::Server::Outbound::Auth])
-    @stream.expect(:outbound_tls_required?, false)
-    @stream.expect(:dialback_retry?, true)
-    @state.node(node)
-    assert @stream.verify
+    EM.run {
+      node = node(
+        %(<stream:stream xmlns="jabber:client" xmlns:stream="#{Vines::NAMESPACES[:stream]}" ) +
+        %(xml:lang="en" id="1234" from="host.com" version="1.0">)
+      )
+      @stream.expect(:advance, nil, [Vines::Stream::Server::Outbound::Auth])
+      @stream.expect(:outbound_tls_required?, false)
+      @stream.expect(:dialback_retry?, true)
+      @state.node(node)
+      assert @stream.verify
+      EM.stop
+    }
   end
 
   def test_valid_stream_required_tls
-    node = node(%Q{<stream:stream xmlns='jabber:client' xmlns:stream='#{Vines::NAMESPACES[:stream]}' xml:lang='en' id='1234' from='host.com' version='1.0'>})
-    @stream.expect(:close_connection, nil)
-    @stream.expect(:outbound_tls_required?, true)
-    @stream.expect(:dialback_retry?, true)
-    @state.node(node)
-    assert @stream.verify
+    EM.run {
+      node = node(
+        %(<stream:stream xmlns="jabber:client" xmlns:stream="#{Vines::NAMESPACES[:stream]}") +
+        %( xml:lang="en" id="1234" from="host.com" version="1.0">)
+      )
+      @stream.expect(:close_connection, nil)
+      @stream.expect(:outbound_tls_required?, true)
+      @stream.expect(:dialback_retry?, true)
+      @state.node(node)
+      assert @stream.verify
+      EM.stop
+    }
   end
 
   private

data/test/stream/server/outbound/auth_test.rb

@@ -1,6 +1,6 @@
 # encoding: UTF-8
 
-require 'test_helper'
+require "test_helper"
 
 class OperatorWrapper
   def <<(stream)
@@ -30,57 +30,79 @@ describe Vines::Stream::Server::Outbound::Auth do
   end
 
   def test_missing_children
-    node = node('<stream:features/>')
-    @stream.expect(:dialback_verify_key?, false)
-    @stream.expect(:outbound_tls_required, nil, [Boolean])
-    assert_raises(Vines::StreamErrors::NotAuthorized) { @state.node(node) }
-    assert @stream.verify
+    EM.run {
+      node = node("<stream:features/>")
+      @stream.expect(:dialback_verify_key?, false)
+      @stream.expect(:outbound_tls_required, nil, [Boolean])
+      assert_raises(Vines::StreamErrors::NotAuthorized) { @state.node(node) }
+      assert @stream.verify
+      EM.stop
+    }
   end
 
   def test_invalid_children
-    node = node(%Q{<stream:features><message/></stream:features>})
-    @stream.expect(:dialback_verify_key?, false)
-    @stream.expect(:outbound_tls_required, nil, [Boolean])
-    assert_raises(Vines::StreamErrors::NotAuthorized) { @state.node(node) }
-    assert @stream.verify
+    EM.run {
+      node = node(%(<stream:features><message/></stream:features>))
+      @stream.expect(:dialback_verify_key?, false)
+      @stream.expect(:outbound_tls_required, nil, [Boolean])
+      assert_raises(Vines::StreamErrors::NotAuthorized) { @state.node(node) }
+      assert @stream.verify
+      EM.stop
+    }
   end
 
   def test_valid_stream_features
-    node = node(%Q{<stream:features xmlns:stream="#{Vines::NAMESPACES[:stream]}"><starttls xmlns="#{Vines::NAMESPACES[:tls]}"><required/></starttls><dialback xmlns="#{Vines::NAMESPACES[:dialback]}"/></stream:features>})
-    starttls = "<starttls xmlns='#{Vines::NAMESPACES[:tls]}'/>"
-    @stream.expect(:dialback_verify_key?, false)
-    @stream.expect(:outbound_tls_required, nil, [Boolean])
-    @stream.expect(:advance, nil, [Vines::Stream::Server::Outbound::TLSResult])
-    @stream.expect(:write, nil, [starttls])
-    @state.node(node)
-    assert @stream.verify
+    EM.run {
+      node = node(
+        %(<stream:features xmlns:stream="#{Vines::NAMESPACES[:stream]}">) +
+        %(<starttls xmlns="#{Vines::NAMESPACES[:tls]}"><required/></starttls>) +
+        %(<dialback xmlns="#{Vines::NAMESPACES[:dialback]}"/></stream:features>)
+      )
+      starttls = %(<starttls xmlns='#{Vines::NAMESPACES[:tls]}'/>)
+      @stream.expect(:dialback_verify_key?, false)
+      @stream.expect(:outbound_tls_required, nil, [Boolean])
+      @stream.expect(:advance, nil, [Vines::Stream::Server::Outbound::TLSResult])
+      @stream.expect(:write, nil, [starttls])
+      @state.node(node)
+      assert @stream.verify
+      EM.stop
+    }
   end
 
   def test_dialback_feature_only
-    node = node(%Q{<stream:features xmlns:stream="#{Vines::NAMESPACES[:stream]}"><dialback xmlns="#{Vines::NAMESPACES[:dialback]}"/></stream:features>})
-    @stream.expect(:dialback_verify_key?, false)
-    @stream.expect(:router, OperatorWrapper.new)
-    @stream.expect(:domain, "local.host")
-    @stream.expect(:remote_domain, "remote.host")
-    @stream.expect(:domain, "local.host")
-    @stream.expect(:remote_domain, "remote.host")
-    @stream.expect(:id, "1234")
-    @stream.expect(:write, nil, [String])
-    @stream.expect(:outbound_tls_required, nil, [Boolean])
-    @stream.expect(:advance, nil, [Vines::Stream::Server::Outbound::AuthDialbackResult])
-    @stream.expect(:state, StateWrapper.new)
-    @state.node(node)
-    assert @stream.verify
+    EM.run {
+      node = node(
+        %(<stream:features xmlns:stream="#{Vines::NAMESPACES[:stream]}">) +
+        %(<dialback xmlns="#{Vines::NAMESPACES[:dialback]}"/></stream:features>)
+      )
+      @stream.expect(:dialback_verify_key?, false)
+      @stream.expect(:router, OperatorWrapper.new)
+      @stream.expect(:domain, "local.host")
+      @stream.expect(:remote_domain, "remote.host")
+      @stream.expect(:domain, "local.host")
+      @stream.expect(:remote_domain, "remote.host")
+      @stream.expect(:id, "1234")
+      @stream.expect(:write, nil, [String])
+      @stream.expect(:outbound_tls_required, nil, [Boolean])
+      @stream.expect(:advance, nil, [Vines::Stream::Server::Outbound::AuthDialbackResult])
+      @stream.expect(:state, StateWrapper.new)
+      @state.node(node)
+      assert @stream.verify
+      EM.stop
+    }
   end
 
   def test_dialback_verify_key
-    node = node('<stream:stream/>')
-    @stream.expect(:advance, nil, [Vines::Stream::Server::Outbound::Authoritative])
-    @stream.expect(:dialback_verify_key?, true)
-    @stream.expect(:callback!, nil)
-    @stream.expect(:outbound_tls_required, nil, [Boolean])
-    @state.node(node)
-    assert @stream.verify
+    EM.run {
+      node = node("<stream:stream/>")
+      @stream.expect(:advance, nil, [Vines::Stream::Server::Outbound::Authoritative])
+      @stream.expect(:dialback_verify_key?, true)
+      @stream.expect(:callback!, nil)
+      @stream.expect(:outbound_tls_required, nil, [Boolean])
+      @state.node(node)
+      assert @stream.verify
+      EM.stop
+    }
   end
 
   private