diaspora-vines 0.1.2

data/test/stanza/iq/disco_items_test.rb

@@ -0,0 +1,49 @@
+# 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{<query xmlns="http://jabber.org/protocol/disco#items"/>}
+      node(%Q{<iq id="42" to="wonderland.lit" type="get">#{query}</iq>})
+    end
+
+    let(:result) do
+      node(%q{
+        <iq from="wonderland.lit" id="42" to="alice@wonderland.lit/home" type="result">
+          <query xmlns="http://jabber.org/protocol/disco#items">
+            <item jid="cake.wonderland.lit"/>
+            <item jid="tea.wonderland.lit"/>
+          </query>
+        </iq>
+      })
+    end
+
+    it 'includes component domains in output' do
+      stream.expect :write, nil, [result]
+      subject.process
+      stream.verify
+    end
+  end
+end

data/test/stanza/iq/private_storage_test.rb

@@ -0,0 +1,184 @@
+# 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{<query xmlns="jabber:iq:private"><one xmlns="a"/></query>}
+      node(%Q{<iq id="42" type="get">#{query}</iq>})
+    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{<query xmlns="jabber:iq:private"><one xmlns="a"/></query>}
+      node(%Q{<iq id="42" to="hatter@wonderland.lit" type="get">#{query}</iq>})
+    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{<query xmlns="jabber:iq:private"></query>}
+      node(%Q{<iq id="42" type="get">#{query}</iq>})
+    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{<query xmlns="jabber:iq:private"><one xmlns="a"/><two xmlns="b"/></query>}
+      node(%Q{<iq id="42" type="get">#{query}</iq>})
+    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{<query xmlns="jabber:iq:private"><one/></query>}
+      node = node(%Q{<iq id="42" type="get">#{query}</iq>})
+    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{<query xmlns="jabber:iq:private"><one xmlns="a"/></query>}
+      node(%Q{<iq id="42" type="get">#{query}</iq>})
+    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{<query xmlns="jabber:iq:private"><one xmlns="a"/></query>}
+      node = node(%Q{<iq id="42" type="get">#{query}</iq>})
+    end
+
+    before do
+      data = %q{<one xmlns="a"><child>data</child></one>}
+      query = %Q{<query xmlns="jabber:iq:private">#{data}</query>}
+      expected = node(%Q{<iq from="#{alice.jid}" id="42" to="#{alice.jid}" type="result">#{query}</iq>})
+
+      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{<iq from="#{alice.jid}" id="42" to="#{alice.jid}" type="result"/>}) }
+
+    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{<query xmlns="jabber:iq:private"></query>}
+        node(%Q{<iq id="42" type="set">#{query}</iq>})
+      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{<query xmlns="jabber:iq:private"><one xmlns="a"/></query>}
+        node(%Q{<iq id="42" type="set">#{query}</iq>})
+      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{<query xmlns="jabber:iq:private"><one xmlns="a"/><two xmlns="a"/></query>}
+        node(%Q{<iq id="42" type="set">#{query}</iq>})
+      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

data/test/stanza/iq/roster_test.rb

@@ -0,0 +1,229 @@
+# 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{<iq id="42" type="get"><query xmlns='jabber:iq:roster'/></iq>}) }
+    let(:expected) { node(%q{<iq id="42" type="result"><query xmlns="jabber:iq:roster"/></iq>}) }
+
+    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{<iq id="42" type="get"><query xmlns='jabber:iq:roster'/></iq>}) }
+    let(:expected) do
+      node(%q{
+        <iq id="42" type="result">
+          <query xmlns="jabber:iq:roster">
+            <item jid="cat@wonderland.lit" subscription="none">
+              <group>Cats</group>
+              <group>Friends</group>
+            </item>
+            <item jid="hatter@wonderland.lit" subscription="none"/>
+          </query>
+        </iq>})
+    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{
+        <iq id="42" type="get" to="romeo@verona.lit">
+          <query xmlns="jabber:iq:roster"/>
+        </iq>})
+    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{
+        <iq id="42" type="set" to="romeo@verona.lit">
+          <query xmlns="jabber:iq:roster"/>
+        </iq>})
+    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{
+        <iq id="42" type="set">
+          <query xmlns="jabber:iq:roster"/>
+        </iq>})
+    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{
+        <iq id="42" type="set">
+          <query xmlns="jabber:iq:roster">
+            <item jid="hatter@wonderland.lit"/>
+            <item jid="cat@wonderland.lit"/>
+          </query>
+        </iq>})
+    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{
+        <iq id="42" type="set">
+          <query xmlns="jabber:iq:roster">
+            <item name="Mad Hatter"/>
+          </query>
+        </iq>})
+    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{
+        <iq id="42" type="set">
+          <query xmlns="jabber:iq:roster">
+            <item jid="hatter@wonderland.lit" name="Mad Hatter">
+              <group>Friends</group>
+              <group>Friends</group>
+            </item>
+          </query>
+        </iq>})
+    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{
+        <iq id="42" type="set">
+          <query xmlns="jabber:iq:roster">
+            <item jid="hatter@wonderland.lit" name="Mad Hatter">
+              <group></group>
+            </item>
+          </query>
+        </iq>})
+    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{
+        <iq id="42" type="set">
+          <query xmlns="jabber:iq:roster">
+            <item jid="hatter@wonderland.lit" name="Mad Hatter">
+              <group>Friends</group>
+            </item>
+          </query>
+        </iq>})
+    end
+
+    let(:expected) do
+      node(%q{
+        <iq to="alice@wonderland.lit/tea" type="set">
+          <query xmlns="jabber:iq:roster">
+            <item jid="hatter@wonderland.lit" name="Mad Hatter" subscription="none">
+              <group>Friends</group>
+            </item>
+          </query>
+        </iq>})
+    end
+
+    let(:storage) { MiniTest::Mock.new }
+    let(:recipient) { MiniTest::Mock.new }
+    let(:result) { node(%Q{<iq id="42" to="#{alice.jid}" type="result"/>}) }
+
+    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

data/test/stanza/iq/session_test.rb

@@ -0,0 +1,25 @@
+# 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{<iq id="42" type="set"><session xmlns="urn:ietf:params:xml:ns:xmpp-session"/></iq>}) }
+    let(:result) { node(%q{<iq from="wonderland.lit" id="42" to="alice@wonderland.lit/tea" type="result"/>}) }
+
+    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

data/test/stanza/iq/vcard_test.rb

@@ -0,0 +1,146 @@
+# 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{<vCard xmlns="vcard-temp"><FN>#{name}</FN></vCard>})
+  end
+
+  def get(to)
+    card = '<vCard xmlns="vcard-temp"/>'
+    iq(id: 42, to: to, type: 'get', body: card)
+  end
+
+  def set(to)
+    card = '<vCard xmlns="vcard-temp"><FN>Alice</FN></vCard>'
+    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

data/test/stanza/iq/version_test.rb

@@ -0,0 +1,64 @@
+# 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{<iq id="42" to="romeo@verona.lit" type="get"><query xmlns="jabber:iq:version"/></iq>}) }
+
+    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{<iq id="42" type="get"><query xmlns="jabber:iq:version"/></iq>}) }
+    let(:expected) do
+      node(%Q{
+        <iq from="wonderland.lit" id="42" to="alice@wonderland.lit/tea" type="result">
+          <query xmlns="jabber:iq:version">
+            <name>Vines</name>
+            <version>#{Vines::VERSION}</version>
+          </query>
+        </iq>})
+    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