vines 0.4.5 → 0.4.6

data/test/stanza/presence/subscribe_test.rb

@@ -1,70 +1,83 @@
 # encoding: UTF-8
 
-require 'vines'
-require 'ext/nokogiri'
-require 'minitest/autorun'
+require 'test_helper'
 
-class SubscribeTest < MiniTest::Unit::TestCase
-  def test_outbound_subscribe_to_local_jid_but_missing_contact
-    alice = Vines::JID.new('alice@wonderland.lit/tea')
-    hatter = Vines::JID.new('hatter@wonderland.lit')
+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) }
 
-    contact = Vines::Contact.new(:jid => hatter)
+  before do
+    class << stream
+      attr_accessor :user, :nodes
+      def write(node)
+        @nodes ||= []
+        @nodes << node
+      end
+    end
+  end
 
-    user = MiniTest::Mock.new
-    user.expect(:jid, alice)
-    user.expect(:request_subscription, nil, [hatter])
-    user.expect(:contact, contact, [hatter])
+  describe 'outbound subscription to a local jid, but missing contact' do
+    let(:xml) { node(%q{<presence id="42" to="hatter@wonderland.lit" type="subscribe"/>}) }
+    let(:user) { MiniTest::Mock.new }
+    let(:storage) { MiniTest::Mock.new }
+    let(:recipient) { MiniTest::Mock.new }
 
-    storage = MiniTest::Mock.new
-    storage.expect(:save_user, nil, [user])
-    storage.expect(:find_user, nil, [hatter])
+    before do
+      class << user
+        attr_accessor :jid
+      end
+      user.jid = alice
+      user.expect :request_subscription, nil, [hatter]
+      user.expect :contact, contact, [hatter]
 
-    recipient = MiniTest::Mock.new
-    recipient.expect(:user, user)
-    def recipient.nodes; @nodes; end
-    def recipient.write(node)
-      @nodes ||= []
-      @nodes << node
-    end
+      storage.expect :save_user, nil, [user]
+      storage.expect :find_user, nil, [hatter]
 
-    stream = MiniTest::Mock.new
-    stream.expect(:domain, 'wonderland.lit')
-    stream.expect(:storage, storage, ['wonderland.lit'])
-    stream.expect(:user, user)
-    stream.expect(:interested_resources, [recipient], [alice])
-    stream.expect(:update_user_streams, nil, [user])
-    def stream.nodes; @nodes; end
-    def stream.write(node)
-      @nodes ||= []
-      @nodes << node
-    end
+      recipient.expect :user, user
+      class << recipient
+        attr_accessor :nodes
+        def write(node)
+          @nodes ||= []
+          @nodes << node
+        end
+      end
 
-    node = node(%q{<presence id="42" to="hatter@wonderland.lit" type="subscribe"/>})
-    stanza = Vines::Stanza::Presence::Subscribe.new(node, stream)
-    def stanza.route_iq; false; end
-    def stanza.inbound?; false; end
-    def stanza.local?;   true; 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]
 
-    stanza.process
-    assert stream.verify
-    assert user.verify
-    assert storage.verify
-    assert_equal 1, stream.nodes.size
-    assert_equal 1, recipient.nodes.size
+      class << subject
+        def route_iq; false; end
+        def inbound?; false; end
+        def local?;   true;  end
+      end
+    end
 
-    expected = node(%q{<presence from="hatter@wonderland.lit" id="42" to="alice@wonderland.lit" type="unsubscribed"/>})
-    assert_equal expected, stream.nodes[0]
+    it 'rejects the subscription with an unsubscribed response' do
+      subject.process
+      stream.verify
+      user.verify
+      storage.verify
+      stream.nodes.size.must_equal 1
 
-    query = %q{<query xmlns="jabber:iq:roster"><item jid="hatter@wonderland.lit" subscription="none"/></query>}
-    expected = node(%Q{<iq to="alice@wonderland.lit/tea" type="set">#{query}</iq>})
-    recipient.nodes[0].remove_attribute('id') # id is random
-    assert_equal expected, recipient.nodes[0]
-  end
+      expected = node(%q{<presence from="hatter@wonderland.lit" id="42" to="alice@wonderland.lit" type="unsubscribed"/>})
+      stream.nodes.first.must_equal expected
+    end
 
-  private
+    it 'sends a roster set to the interested resources with subscription none' do
+      subject.process
+      recipient.nodes.size.must_equal 1
 
-  def node(xml)
-    Nokogiri::XML(xml).root
+      query = %q{<query xmlns="jabber:iq:roster"><item jid="hatter@wonderland.lit" subscription="none"/></query>}
+      expected = node(%Q{<iq to="alice@wonderland.lit/tea" type="set">#{query}</iq>})
+      recipient.nodes.first.remove_attribute('id') # id is random
+      recipient.nodes.first.must_equal expected
+    end
   end
 end

data/test/stanza/pubsub/create_test.rb

@@ -1,138 +1,116 @@
 # encoding: UTF-8
 
-require 'tmpdir'
-require 'vines'
-require 'ext/nokogiri'
-require 'minitest/autorun'
-
-class CreatePubSubTest < MiniTest::Unit::TestCase
-  def setup
-    @user = Vines::User.new(jid: 'alice@wonderland.lit/tea')
-    @config = Vines::Config.new do
+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
-    @stream = MiniTest::Mock.new
-    @stream.expect(:config, @config)
-    @stream.expect(:user, @user)
   end
 
-  def test_missing_to_address_raises
-    node = node(%q{
-      <iq type='set' id='42'>
-        <pubsub xmlns='http://jabber.org/protocol/pubsub'>
-          <create node='game_13'/>
-        </pubsub>
-      </iq>
-    }.strip.gsub(/\n|\s{2,}/, ''))
+  before do
+    class << stream
+      attr_accessor :config, :nodes, :user
+      def write(node)
+        @nodes ||= []
+        @nodes << node
+      end
+    end
+    stream.config = config
+    stream.user = user
+  end
 
-    @stream.expect(:domain, 'wonderland.lit')
+  describe 'when missing a to address' do
+    let(:xml) { create('') }
 
-    stanza = Vines::Stanza::PubSub::Create.new(node, @stream)
-    assert_raises(Vines::StanzaErrors::FeatureNotImplemented) { stanza.process }
-    assert @stream.verify
+    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
 
-  def test_server_domain_to_address_raises
-    node = node(%q{
-      <iq type='set' to='wonderland.lit' id='42'>
-        <pubsub xmlns='http://jabber.org/protocol/pubsub'>
-          <create node='game_13'/>
-        </pubsub>
-      </iq>
-    }.strip.gsub(/\n|\s{2,}/, ''))
-
-    stanza = Vines::Stanza::PubSub::Create.new(node, @stream)
-    assert_raises(Vines::StanzaErrors::FeatureNotImplemented) { stanza.process }
-    assert @stream.verify
-  end
+  describe 'when addressed to bare server domain' do
+    let(:xml) { create('wonderland.lit') }
 
-  def test_non_pubsub_to_address_routes
-    node = node(%q{
-      <iq type='set' to='bogus.wonderland.lit' id='42'>
-        <pubsub xmlns='http://jabber.org/protocol/pubsub'>
-          <create node='game_13'/>
-        </pubsub>
-      </iq>
-    }.strip.gsub(/\n|\s{2,}/, ''))
-
-    router = MiniTest::Mock.new
-    router.expect(:route, nil, [node])
-    @stream.expect(:router, router)
-
-    stanza = Vines::Stanza::PubSub::Create.new(node, @stream)
-    stanza.process
-    assert @stream.verify
-    assert router.verify
+    it 'raises a feature-not-implemented stanza error' do
+      -> { subject.process }.must_raise Vines::StanzaErrors::FeatureNotImplemented
+      stream.verify
+    end
   end
 
-  def test_multiple_create_elements_raises
-    node = node(%q{
-      <iq type='set' to='games.wonderland.lit' id='42'>
-        <pubsub xmlns='http://jabber.org/protocol/pubsub'>
-          <create node='game_13'/>
-          <create node='game_14'/>
-        </pubsub>
-      </iq>
-    }.strip.gsub(/\n|\s{2,}/, ''))
-
-    stanza = Vines::Stanza::PubSub::Create.new(node, @stream)
-    assert_raises(Vines::StanzaErrors::BadRequest) { stanza.process }
-    assert @stream.verify
-  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
 
-  def test_create_duplicate_node_raises
-    node = node(%q{
-      <iq type='set' to='games.wonderland.lit' id='42'>
-        <pubsub xmlns='http://jabber.org/protocol/pubsub'>
-          <create node='game_13'/>
-        </pubsub>
-      </iq>
-    }.strip.gsub(/\n|\s{2,}/, ''))
-
-    stanza = Vines::Stanza::PubSub::Create.new(node, @stream)
-    def stanza.pubsub
-      pubsub = MiniTest::Mock.new
-      pubsub.expect(:node?, true, ['game_13'])
-      pubsub
+    it 'routes rather than handle locally' do
+      subject.process
+      stream.verify
+      router.verify
     end
-    assert_raises(Vines::StanzaErrors::Conflict) { stanza.process }
-    assert @stream.verify
   end
 
-  def test_good_stanza_processes
-    node = node(%q{
-      <iq type='set' to='games.wonderland.lit' id='42'>
-        <pubsub xmlns='http://jabber.org/protocol/pubsub'>
-          <create node='game_13'/>
-        </pubsub>
-      </iq>
-    }.strip.gsub(/\n|\s{2,}/, ''))
-
-    def @stream.nodes; @nodes; end
-    def @stream.write(node)
-      @nodes ||= []
-      @nodes << node
+  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
 
-    stanza = Vines::Stanza::PubSub::Create.new(node, @stream)
-    stanza.process
+  describe 'when attempting to create duplicate nodes' do
+    let(:pubsub) { MiniTest::Mock.new }
+    let(:xml) { create('games.wonderland.lit') }
 
-    assert @stream.verify
-    assert_equal 1, @stream.nodes.size
+    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
 
-    expected = %q{<iq from="games.wonderland.lit" id="42" to="alice@wonderland.lit/tea" type="result">}
-    expected << %q{<pubsub xmlns="http://jabber.org/protocol/pubsub"><create node="game_13"/></pubsub>}
-    expected << %q{</iq>}
-    expected = node(expected)
-    assert_equal expected, @stream.nodes[0]
+  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 node(xml)
-    Nokogiri::XML(xml).root
+  def create(to, multiple=false)
+    extra_create = "<create node='game_14'/>" if multiple
+    body = %Q{
+      <pubsub xmlns='http://jabber.org/protocol/pubsub'>
+        <create node='game_13'/>
+        #{extra_create}
+      </pubsub>}
+    iq(type: 'set', to: to, id: 42, body: body)
+  end
+
+  def result(to, from)
+    body = '<pubsub xmlns="http://jabber.org/protocol/pubsub"><create node="game_13"/></pubsub>'
+    iq(from: from, id: 42, to: to, type: 'result', body: body)
   end
 end

data/test/stanza/pubsub/delete_test.rb

@@ -1,142 +1,169 @@
 # encoding: UTF-8
 
-require 'tmpdir'
-require 'vines'
-require 'ext/nokogiri'
-require 'minitest/autorun'
-
-class DeletePubSubTest < MiniTest::Unit::TestCase
-  def setup
-    @user = Vines::User.new(jid: 'alice@wonderland.lit/tea')
-    @config = Vines::Config.new do
+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
-    @stream = MiniTest::Mock.new
-    @stream.expect(:config, @config)
-    @stream.expect(:user, @user)
   end
 
-  def test_missing_to_address_raises
-    node = node(%q{
-      <iq type='set' id='42'>
-        <pubsub xmlns='http://jabber.org/protocol/pubsub'>
-          <delete node='game_13'/>
-        </pubsub>
-      </iq>
-    }.strip.gsub(/\n|\s{2,}/, ''))
+  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
 
-    @stream.expect(:domain, 'wonderland.lit')
+  describe 'when missing a to address' do
+    let(:xml) do
+      node(%q{
+        <iq type='set' id='42'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub'>
+            <delete node='game_13'/>
+          </pubsub>
+        </iq>
+      })
+    end
 
-    stanza = Vines::Stanza::PubSub::Delete.new(node, @stream)
-    assert_raises(Vines::StanzaErrors::FeatureNotImplemented) { stanza.process }
-    assert @stream.verify
+    it 'raises a feature-not-implemented stanza error' do
+      -> { subject.process }.must_raise Vines::StanzaErrors::FeatureNotImplemented
+      stream.verify
+    end
   end
 
-  def test_server_domain_to_address_raises
-    node = node(%q{
-      <iq type='set' to='wonderland.lit' id='42'>
-        <pubsub xmlns='http://jabber.org/protocol/pubsub'>
-          <delete node='game_13'/>
-        </pubsub>
-      </iq>
-    }.strip.gsub(/\n|\s{2,}/, ''))
-
-    stanza = Vines::Stanza::PubSub::Delete.new(node, @stream)
-    assert_raises(Vines::StanzaErrors::FeatureNotImplemented) { stanza.process }
-    assert @stream.verify
+  describe 'when addressed to a bare server domain jid' do
+    let(:xml) do
+      node(%q{
+        <iq type='set' to='wonderland.lit' id='42'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub'>
+            <delete node='game_13'/>
+          </pubsub>
+        </iq>
+      })
+    end
+
+    it 'raises a feature-not-implemented stanza error' do
+      -> { subject.process }.must_raise Vines::StanzaErrors::FeatureNotImplemented
+      stream.verify
+    end
   end
 
-  def test_non_pubsub_to_address_routes
-    node = node(%q{
-      <iq type='set' to='bogus.wonderland.lit' id='42'>
-        <pubsub xmlns='http://jabber.org/protocol/pubsub'>
-          <delete node='game_13'/>
-        </pubsub>
-      </iq>
-    }.strip.gsub(/\n|\s{2,}/, ''))
-
-    router = MiniTest::Mock.new
-    router.expect(:route, nil, [node])
-    @stream.expect(:router, router)
-
-    stanza = Vines::Stanza::PubSub::Delete.new(node, @stream)
-    stanza.process
-    assert @stream.verify
-    assert router.verify
+  describe 'when addressed to a non-pubsub address' do
+    let(:router) { MiniTest::Mock.new }
+    let(:xml) do
+      node(%q{
+        <iq type='set' to='bogus.wonderland.lit' id='42'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub'>
+            <delete node='game_13'/>
+          </pubsub>
+        </iq>
+      })
+    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
 
-  def test_multiple_delete_elements_raises
-    node = node(%q{
-      <iq type='set' to='games.wonderland.lit' id='42'>
-        <pubsub xmlns='http://jabber.org/protocol/pubsub'>
-          <delete node='game_13'/>
-          <delete node='game_14'/>
-        </pubsub>
-      </iq>
-    }.strip.gsub(/\n|\s{2,}/, ''))
-
-    stanza = Vines::Stanza::PubSub::Delete.new(node, @stream)
-    assert_raises(Vines::StanzaErrors::BadRequest) { stanza.process }
-    assert @stream.verify
+  describe 'when stanza contains multiple delete elements' do
+    let(:xml) do
+      node(%q{
+        <iq type='set' to='games.wonderland.lit' id='42'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub'>
+            <delete node='game_13'/>
+            <delete node='game_14'/>
+          </pubsub>
+        </iq>
+      })
+    end
+
+    it 'raises a bad-request stanza error' do
+      -> { subject.process }.must_raise Vines::StanzaErrors::BadRequest
+      stream.verify
+    end
   end
 
-  def test_delete_missing_node_raises
-    node = node(%q{
-      <iq type='set' to='games.wonderland.lit' id='42'>
-        <pubsub xmlns='http://jabber.org/protocol/pubsub'>
-          <delete node='game_13'/>
-        </pubsub>
-      </iq>
-    }.strip.gsub(/\n|\s{2,}/, ''))
-
-    stanza = Vines::Stanza::PubSub::Delete.new(node, @stream)
-    assert_raises(Vines::StanzaErrors::ItemNotFound) { stanza.process }
-    assert @stream.verify
+  describe 'when deleting a missing node' do
+    let(:xml) do
+      node(%q{
+        <iq type='set' to='games.wonderland.lit' id='42'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub'>
+            <delete node='game_13'/>
+          </pubsub>
+        </iq>
+      })
+    end
+
+    it 'raises an item-not-found stanza error' do
+      -> { subject.process }.must_raise Vines::StanzaErrors::ItemNotFound
+      stream.verify
+    end
   end
 
-  def test_good_stanza_processes
-    node = node(%q{
-      <iq type='set' to='games.wonderland.lit' id='42'>
-        <pubsub xmlns='http://jabber.org/protocol/pubsub'>
-          <delete node='game_13'/>
-        </pubsub>
-      </iq>
-    }.strip.gsub(/\n|\s{2,}/, ''))
-
-    def @stream.nodes; @nodes; end
-    def @stream.write(node)
-      @nodes ||= []
-      @nodes << node
-    end
-
-    stanza = Vines::Stanza::PubSub::Delete.new(node, @stream)
-    def stanza.mock_pubsub; @mock_pubsub; end
-    def stanza.pubsub
-      unless @mock_pubsub
-        xml = %q{<message><event xmlns="http://jabber.org/protocol/pubsub#event"><delete node="game_13"/></event></message>}
-        @mock_pubsub = MiniTest::Mock.new
-        @mock_pubsub.expect(:node?, true, ['game_13'])
-        @mock_pubsub.expect(:publish, nil, ['game_13', Nokogiri::XML(xml).root])
-        @mock_pubsub.expect(:delete_node, nil, ['game_13'])
-      end
-      @mock_pubsub
+  describe 'when valid stanza is received' do
+    let(:pubsub) { MiniTest::Mock.new }
+    let(:xml) do
+      node(%q{
+        <iq type='set' to='games.wonderland.lit' id='42'>
+          <pubsub xmlns='http://jabber.org/protocol/pubsub'>
+            <delete node='game_13'/>
+          </pubsub>
+        </iq>
+      })
     end
-    stanza.process
 
-    assert @stream.verify
-    assert stanza.mock_pubsub.verify
-    assert_equal 1, @stream.nodes.size
+    let(:result) { node(%Q{<iq from="games.wonderland.lit" id="42" to="#{alice.jid}" type="result"/>}) }
 
-    expected = node(%q{<iq from="games.wonderland.lit" id="42" to="alice@wonderland.lit/tea" type="result"/>})
-    assert_equal expected, @stream.nodes[0]
-  end
+    let(:broadcast) do
+      node(%q{
+        <message>
+          <event xmlns="http://jabber.org/protocol/pubsub#event">
+            <delete node="game_13"/>
+          </event>
+        </message>})
+    end
 
-  private
+    before do
+      pubsub.expect :node?, true, ['game_13']
+      pubsub.expect :publish, nil, ['game_13', broadcast]
+      pubsub.expect :delete_node, nil, ['game_13']
+    end
 
-  def node(xml)
-    Nokogiri::XML(xml).root
+    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