vines 0.4.5 → 0.4.6

data/test/cluster/sessions_test.rb

@@ -1,53 +1,46 @@
 # encoding: UTF-8
 
-require 'vines'
-require 'ext/nokogiri'
+require 'test_helper'
 require 'storage/storage_tests'
 require 'storage/mock_redis'
-require 'minitest/autorun'
 
-class ClusterSessionsTest < MiniTest::Unit::TestCase
-  def setup
-    @connection = MockRedis.new
-    @cluster = MiniTest::Mock.new
-    @cluster.expect(:connection, @connection)
-  end
+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' }
 
-  def test_save
-    StorageTests::EMLoop.new do
-      @cluster.expect(:id, 'abc')
-      jid1 = 'alice@wonderland.lit/tea'
-      jid2 = 'alice@wonderland.lit/cake'
-      sessions = Vines::Cluster::Sessions.new(@cluster)
-      sessions.save(jid1, {available: true, interested: true})
-      sessions.save(jid2, {available: false, interested: false})
-      EM.next_tick do
-        session1 = {node: 'abc', available: true, interested: true}
-        session2 = {node: 'abc', available: false, interested: false}
-        assert_equal 2, @connection.db["sessions:alice@wonderland.lit"].size
-        assert_equal session1.to_json, @connection.db["sessions:alice@wonderland.lit"]['tea']
-        assert_equal session2.to_json, @connection.db["sessions:alice@wonderland.lit"]['cake']
-        assert_equal [jid1, jid2], @connection.db["cluster:nodes:abc"].to_a
-        assert @cluster.verify
+  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
 
-  def test_delete
-    StorageTests::EMLoop.new do
-      jid1 = 'alice@wonderland.lit/tea'
-      jid2 = 'alice@wonderland.lit/cake'
-      @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])
+  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])
 
-      sessions = Vines::Cluster::Sessions.new(@cluster)
-      sessions.delete(jid1)
-      EM.next_tick do
-        assert_equal 1, @connection.db["sessions:alice@wonderland.lit"].size
-        assert_equal [jid2], @connection.db["cluster:nodes:abc"].to_a
-        assert @cluster.verify
+        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

data/test/cluster/subscriber_test.rb

@@ -1,94 +1,109 @@
 # encoding: UTF-8
 
-require 'vines'
-require 'ext/nokogiri'
-require 'minitest/autorun'
-
-class ClusterSubscriberTest < MiniTest::Unit::TestCase
-  def setup
-    @connection = MiniTest::Mock.new
-    @cluster = MiniTest::Mock.new
-    @cluster.expect(:id, 'abc')
-  end
-
-  def test_subscribe
-    @cluster.expect(:connect, @connection)
-    @connection.expect(:subscribe, nil, ['cluster:nodes:all'])
-    @connection.expect(:subscribe, nil, ['cluster:nodes:abc'])
-    @connection.expect(:on, nil, [:message])
-    subscriber = Vines::Cluster::Subscriber.new(@cluster)
-    subscriber.subscribe
-    assert @connection.verify
-    assert @cluster.verify
-  end
+require 'test_helper'
 
-  def test_heartbeat
-    now = Time.now.to_i
-    msg = {from: 'node-42', type: 'heartbeat', time: now}.to_json
-    @cluster.expect(:poke, nil, ['node-42', now])
+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 }
 
-    subscriber = Vines::Cluster::Subscriber.new(@cluster)
-    subscriber.send(:on_message, 'cluster:nodes:all', msg)
-    assert @connection.verify
-    assert @cluster.verify
+  before do
+    cluster.expect :id, 'abc'
   end
 
-  def test_online
-    now = Time.now.to_i
-    msg = {from: 'node-42', type: 'online', time: now}.to_json
-    @cluster.expect(:poke, nil, ['node-42', now])
-
-    subscriber = Vines::Cluster::Subscriber.new(@cluster)
-    subscriber.send(:on_message, 'cluster:nodes:all', msg)
-    assert @connection.verify
-    assert @cluster.verify
+  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
 
-  def test_offline
-    now = Time.now.to_i
-    msg = {from: 'node-42', type: 'offline', time: now}.to_json
-    @cluster.expect(:delete_sessions, nil, ['node-42'])
-
-    subscriber = Vines::Cluster::Subscriber.new(@cluster)
-    subscriber.send(:on_message, 'cluster:nodes:all', msg)
-    assert @connection.verify
-    assert @cluster.verify
+  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
 
-  def test_route_stanza
-    stanza = "<message to='alice@wonderland.lit/tea'>hello</message>"
-    node = Nokogiri::XML(stanza).root rescue nil
-    msg = {from: 'node-42', type: 'stanza', stanza: stanza}.to_json
-
-    stream = MiniTest::Mock.new
-    stream.expect(:write, nil, [node])
-    @cluster.expect(:connected_resources, [stream], ['alice@wonderland.lit/tea'])
-
-    subscriber = Vines::Cluster::Subscriber.new(@cluster)
-    subscriber.send(:on_message, 'cluster:nodes:abc', msg)
-    assert stream.verify
-    assert @connection.verify
-    assert @cluster.verify
+  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
 
-  def test_update_user
-    alice = Vines::User.new(jid: 'alice@wonderland.lit/tea')
-    msg = {from: 'node-42', type: 'user', jid: alice.jid.to_s}.to_json
-
-    storage = MiniTest::Mock.new
-    storage.expect(:find_user, alice, [alice.jid.bare])
-
-    stream = MiniTest::Mock.new
-    stream.expect(:user, alice)
+  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
 
-    @cluster.expect(:storage, storage, ['wonderland.lit'])
-    @cluster.expect(:connected_resources, [stream], [alice.jid.bare])
+  describe 'when receiving a stanza routed to my node' do
+    let(:stream) { MiniTest::Mock.new }
+    let(:stanza) { "<message to='alice@wonderland.lit/tea'>hello</message>" }
+    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
+      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
 
-    subscriber = Vines::Cluster::Subscriber.new(@cluster)
-    subscriber.send(:on_message, 'cluster:nodes:abc', msg)
-    assert storage.verify
-    assert stream.verify
-    assert @connection.verify
-    assert @cluster.verify
+  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

data/test/config/host_test.rb

@@ -1,10 +1,8 @@
 # encoding: UTF-8
 
-require 'tmpdir'
-require 'vines'
-require 'minitest/autorun'
+require 'test_helper'
 
-class HostTest < MiniTest::Unit::TestCase
+describe Vines::Config::Host do
   def test_missing_storage
     assert_raises(RuntimeError) do
       Vines::Config.new do

data/test/config/pubsub_test.rb

@@ -1,181 +1,187 @@
 # encoding: UTF-8
 
-require 'tmpdir'
-require 'vines'
-require 'ext/nokogiri'
-require 'minitest/autorun'
+require 'test_helper'
 
-class ConfigPubSubTest < MiniTest::Unit::TestCase
-  def setup
+describe Vines::Config::PubSub do
+  subject { config.pubsub('topics.wonderland.lit') }
+  let(:alice) { Vines::JID.new('alice@wonderland.lit') }
+  let(:romeo) { Vines::JID.new('romeo@verona.lit') }
+  let(:config) do
     @config = Vines::Config.new do
       host 'wonderland.lit' do
         storage(:fs) { dir Dir.tmpdir }
         pubsub 'topics'
       end
     end
-    @pubsub = @config.pubsub('topics.wonderland.lit')
   end
 
-  def test_add_node
+  it 'adds and deletes a topic node' do
     topic = 'rhode_island_is_neither_a_road_nor_an_island'
-    refute @pubsub.node?(topic)
-    @pubsub.add_node(topic)
-    assert @pubsub.node?(topic)
-    @pubsub.delete_node(topic)
-    refute @pubsub.node?(topic)
+    refute subject.node?(topic)
+    subject.add_node(topic)
+    assert subject.node?(topic)
+    subject.delete_node(topic)
+    refute subject.node?(topic)
   end
 
-  def test_delete_missing_node
+  it 'ignores deleting a missing topic node' do
     topic = 'kittens_vs_puppies'
-    refute @pubsub.node?(topic)
-    @pubsub.delete_node(topic)
-    refute @pubsub.node?(topic)
+    refute subject.node?(topic)
+    subject.delete_node(topic)
+    refute subject.node?(topic)
   end
 
-  def test_subscribe_with_jid
+  it 'subscribes a jid to a node' do
     topic = 'with_jid'
     jid = Vines::JID.new('alice@wonderland.lit')
-    @pubsub.add_node(topic)
-    @pubsub.subscribe(topic, jid)
-    assert @pubsub.subscribed?(topic, jid.to_s)
-    assert @pubsub.subscribed?(topic, jid)
+    subject.add_node(topic)
+    subject.subscribe(topic, jid)
+    assert subject.subscribed?(topic, jid.to_s)
+    assert subject.subscribed?(topic, jid)
   end
 
-  def test_subscribe_remote_jid_not_allowed
+  it 'does not allow remote jids to subscribe to a node by default' do
     topic = 'remote_jids_failed'
     jid = 'romeo@verona.lit'
-    @pubsub.add_node(topic)
-    @pubsub.subscribe(topic, jid)
-    refute @pubsub.subscribed?(topic, jid)
+    subject.add_node(topic)
+    subject.subscribe(topic, jid)
+    refute subject.subscribed?(topic, jid)
   end
 
-  def test_subscribe_remote_jid_is_allowed
+  it 'allows remote jid subscriptions when cross domain messages are enabled' do
     topic = 'remote_jids_allowed'
     jid = 'romeo@verona.lit'
-    @config.vhost('wonderland.lit').cross_domain_messages true
-    @pubsub.add_node(topic)
-    @pubsub.subscribe(topic, jid)
-    assert @pubsub.subscribed?(topic, jid)
+    config.vhost('wonderland.lit').cross_domain_messages true
+    subject.add_node(topic)
+    subject.subscribe(topic, jid)
+    assert subject.subscribed?(topic, jid)
   end
 
-  def test_subscribe_missing_node
+  it 'ignores subscribing to a missing node' do
     topic = 'bogus'
     jid = 'alice@wonderland.lit'
-    refute @pubsub.node?(topic)
-    @pubsub.subscribe(topic, jid)
-    refute @pubsub.node?(topic)
-    refute @pubsub.subscribed?(topic, jid)
+    refute subject.node?(topic)
+    subject.subscribe(topic, jid)
+    refute subject.node?(topic)
+    refute subject.subscribed?(topic, jid)
   end
 
-  def test_unsubscribe_deletes_node
+  it 'deletes the node after unsubscribing' do
     topic = 'delete_me'
     jid = 'alice@wonderland.lit/tea'
-    @pubsub.add_node(topic)
-    @pubsub.subscribe(topic, jid)
-    assert @pubsub.subscribed?(topic, jid)
-    @pubsub.unsubscribe(topic, jid)
-    refute @pubsub.subscribed?(topic, jid)
-    refute @pubsub.node?(topic)
+    subject.add_node(topic)
+    subject.subscribe(topic, jid)
+    assert subject.subscribed?(topic, jid)
+    subject.unsubscribe(topic, jid)
+    refute subject.subscribed?(topic, jid)
+    refute subject.node?(topic)
   end
 
-  def test_unsubscribe_all
+  it 'unsubscribes a jid from all topics' do
     topic = 'pirates_vs_ninjas'
     topic2 = 'pirates_vs_ninjas_2'
     jid = 'alice@wonderland.lit'
     jid2 = 'hatter@wonderland.lit'
-    @pubsub.add_node(topic)
-    @pubsub.add_node(topic2)
-
-    @pubsub.subscribe(topic, jid)
-    @pubsub.subscribe(topic, jid2)
-    @pubsub.subscribe(topic2, jid)
-    assert @pubsub.subscribed?(topic, jid)
-    assert @pubsub.subscribed?(topic, jid2)
-    assert @pubsub.subscribed?(topic2, jid)
-
-    @pubsub.unsubscribe_all(jid)
-    refute @pubsub.node?(topic2)
-    refute @pubsub.subscribed?(topic, jid)
-    refute @pubsub.subscribed?(topic2, jid)
-    assert @pubsub.subscribed?(topic, jid2)
+    subject.add_node(topic)
+    subject.add_node(topic2)
+
+    subject.subscribe(topic, jid)
+    subject.subscribe(topic, jid2)
+    subject.subscribe(topic2, jid)
+    assert subject.subscribed?(topic, jid)
+    assert subject.subscribed?(topic, jid2)
+    assert subject.subscribed?(topic2, jid)
+
+    subject.unsubscribe_all(jid)
+    refute subject.node?(topic2)
+    refute subject.subscribed?(topic, jid)
+    refute subject.subscribed?(topic2, jid)
+    assert subject.subscribed?(topic, jid2)
   end
 
-  def test_publish
-    topic = 'pirates_vs_ninjas'
-    alice = Vines::JID.new('alice@wonderland.lit')
-    romeo = Vines::JID.new('romeo@verona.lit')
-
-    @config.vhost('wonderland.lit').cross_domain_messages true
-    def @config.router
-      unless @mock_router
-        @mock_router = MiniTest::Mock.new
-        def @mock_router.nodes; @nodes; end
-        def @mock_router.route(node)
+  describe 'when publishing a message to a topic node' do
+    let(:xml) do
+      node(%q{
+        <iq type='set' to='topics.wonderland.lit'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub'>
+            <publish node='pirates_vs_ninjas'>
+              <item id='item_42'>
+                <entry xmlns='http://www.w3.org/2005/Atom'>
+                  <title>Test</title>
+                  <summary>This is a summary.</summary>
+                </entry>
+              </item>
+            </publish>
+          </pubsub>
+        </iq>})
+    end
+
+    let(:recipient) do
+      recipient = MiniTest::Mock.new
+      recipient.expect :user, Vines::User.new(jid: alice)
+      class << recipient
+        attr_accessor :nodes
+        def write(node)
           @nodes ||= []
           @nodes << node
         end
       end
-      @mock_router
+      recipient
     end
 
-    recipient = recipient(alice)
-    @config.router.expect(:connected_resources, [recipient], [alice, 'topics.wonderland.lit'])
-
-    @pubsub.add_node(topic)
-    @pubsub.subscribe(topic, alice)
-    @pubsub.subscribe(topic, romeo)
-    assert @pubsub.subscribed?(topic, alice)
-    assert @pubsub.subscribed?(topic, romeo)
-
-    node = node(%q{
-      <iq type='set' to='topics.wonderland.lit'>
-        <pubsub xmlns='http://jabber.org/protocol/pubsub'>
-          <publish node='pirates_vs_ninjas'>
-            <item id='item_42'>
-              <entry xmlns='http://www.w3.org/2005/Atom'>
-                <title>Test</title>
-                <summary>This is a summary.</summary>
-              </entry>
-            </item>
-          </publish>
-        </pubsub>
-      </iq>
-    }.strip.gsub(/\n|\s{2,}/, ''))
-    expected = node.clone
-
-    @pubsub.publish(topic, node)
-
-    assert @config.router.verify
-    assert recipient.verify
-
-    # id is random
-    refute_nil recipient.nodes[0]['id']
-    refute_nil @config.router.nodes[0]['id']
-    recipient.nodes[0].remove_attribute('id')
-    @config.router.nodes[0].remove_attribute('id')
-
-    expected['to'] = 'alice@wonderland.lit'
-    expected['from'] = 'topics.wonderland.lit'
-    assert_equal expected, recipient.nodes[0]
-
-    expected['to'] = 'romeo@verona.lit'
-    assert_equal expected, @config.router.nodes[0]
-  end
+    before do
+      router = MiniTest::Mock.new
+      router.expect :connected_resources, [recipient], [alice, 'topics.wonderland.lit']
+      class << router
+        attr_accessor :nodes
+        def route(node)
+          @nodes ||= []
+          @nodes << node
+        end
+      end
+
+      class << config
+        attr_accessor :router
+      end
+      config.router = router
+      config.vhost('wonderland.lit').cross_domain_messages true
+
+      subject.add_node(topic)
+      subject.subscribe(topic, alice)
+      subject.subscribe(topic, romeo)
+    end
+
+    let(:topic) { 'pirates_vs_ninjas' }
+
+    it 'writes the message to local connected resource streams' do
+      expected = xml.clone
+      expected['to'] = 'alice@wonderland.lit'
+      expected['from'] = 'topics.wonderland.lit'
 
-  private
+      subject.publish(topic, xml)
+      config.router.verify
+      recipient.verify
 
-  def recipient(jid)
-    recipient = MiniTest::Mock.new
-    recipient.expect(:user, Vines::User.new(jid: jid))
-    def recipient.nodes; @nodes; end
-    def recipient.write(node)
-      @nodes ||= []
-      @nodes << node
+      # id is random
+      received = recipient.nodes.first
+      received['id'].wont_be_nil
+      received.remove_attribute('id')
+      received.must_equal expected
     end
-    recipient
-  end
 
-  def node(xml)
-    Nokogiri::XML(xml).root
+    it 'routes the message to remote jids' do
+      expected = xml.clone
+      expected['to'] = 'romeo@verona.lit'
+      expected['from'] = 'topics.wonderland.lit'
+
+      subject.publish(topic, xml)
+      config.router.verify
+
+      # id is random
+      routed = config.router.nodes.first
+      routed['id'].wont_be_nil
+      routed.remove_attribute('id')
+      routed.must_equal expected
+    end
   end
 end