lygneo-vines 0.1.1

data/test/stanza/iq_test.rb

@@ -0,0 +1,70 @@
+# 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{
+        <iq id="42" type="set" to="alice@wonderland.lit/tea" from="hatter@wonderland.lit/crumpets">
+            <si xmlns="http://jabber.org/protocol/si" id="42_si" profile="http://jabber.org/protocol/si/profile/file-transfer">
+              <file xmlns="http://jabber.org/protocol/si/profile/file-transfer" name="file" size="1"/>
+              <feature xmlns="http://jabber.org/protocol/feature-neg">
+                <x xmlns="jabber:x:data" type="form">
+                  <field var="stream-method" type="list-single">
+                    <option>
+                      <value>http://jabber.org/protocol/bytestreams</value>
+                    </option>
+                    <option>
+                      <value>http://jabber.org/protocol/ibb</value>
+                    </option>
+                  </field>
+                </x>
+              </feature>
+            </si>
+          </iq>
+      })
+    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('<iq type="set" id="42"/>') }
+
+    it 'raises a feature-not-implemented stanza error' do
+      -> { subject.process }.must_raise Vines::StanzaErrors::FeatureNotImplemented
+    end
+  end
+end

data/test/stanza/message_test.rb

@@ -0,0 +1,126 @@
+# 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('<message type="bogus">hello!</message>') }
+
+    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('<message>hello!</message>') }
+    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{<message to="#{bogus}">hello!</message>}) }
+    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{<message to="#{hatter.jid}">hello!</message>}) }
+    let(:storage) { MiniTest::Mock.new }
+
+    before do
+      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{<message to="#{romeo.jid}">hello!</message>}) }
+    let(:expected) { node(%Q{<message to="#{romeo.jid}" from="#{alice.jid}">hello!</message>}) }
+    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{<message to="#{romeo.jid}">hello!</message>}) }
+    let(:expected) { node(%Q{<message to="#{romeo.jid}" from="#{alice.jid}">hello!</message>}) }
+    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

data/test/stanza/presence/probe_test.rb

@@ -0,0 +1,50 @@
+# 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{<presence id="42" type="probe"/>})
+    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{<presence id="42" to="romeo@verona.lit" type="probe"/>})
+    stanza = Vines::Stanza::Presence::Probe.new(node, @stream)
+    def stanza.inbound?; false; end
+
+    expected = node(%Q{<presence id="42" to="romeo@verona.lit" type="probe" from="#{@alice}"/>})
+    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

data/test/stanza/presence/subscribe_test.rb

@@ -0,0 +1,83 @@
+# 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(:follower) { Vines::Follower.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 follower' 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 }
+
+    before do
+      class << user
+        attr_accessor :jid
+      end
+      user.jid = alice
+      user.expect :request_subscription, nil, [hatter]
+      user.expect :follower, follower, [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{<presence from="hatter@wonderland.lit" id="42" to="alice@wonderland.lit" type="unsubscribed"/>})
+      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{<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

@@ -0,0 +1,116 @@
+# 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 = "<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

@@ -0,0 +1,169 @@
+# 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{
+        <iq type='set' 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
+
+  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
+
+  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
+
+  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
+
+  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
+
+  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
+
+    let(:result) { node(%Q{<iq from="games.wonderland.lit" id="42" to="#{alice.jid}" type="result"/>}) }
+
+    let(:broadcast) do
+      node(%q{
+        <message>
+          <event xmlns="http://jabber.org/protocol/pubsub#event">
+            <delete node="game_13"/>
+          </event>
+        </message>})
+    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