diaspora-vines 0.1.2

data/test/contact_test.rb

@@ -0,0 +1,102 @@
+# encoding: UTF-8
+
+require 'test_helper'
+
+describe Vines::Contact do
+  subject do
+    Vines::Contact.new(
+      jid: 'alice@wonderland.lit',
+      name: "Alice",
+      groups: %w[Friends Buddies],
+      subscription: 'from')
+  end
+
+  describe 'contact equality checks' do
+    let(:alice)  { Vines::Contact.new(jid: 'alice@wonderland.lit') }
+    let(:hatter) { Vines::Contact.new(jid: 'hatter@wonderland.lit') }
+
+    it 'uses class in equality check' do
+      (subject <=> 42).must_be_nil
+    end
+
+    it 'is equal to itself' do
+      assert subject == subject
+      assert subject.eql?(subject)
+      assert subject.hash == subject.hash
+    end
+
+    it 'is equal to another contact with the same jid' do
+      assert subject == alice
+      assert subject.eql?(alice)
+      assert subject.hash == alice.hash
+    end
+
+    it 'is not equal to a different jid' do
+      refute subject == hatter
+      refute subject.eql?(hatter)
+      refute subject.hash == hatter.hash
+    end
+  end
+
+  describe 'initialize' do
+    it 'raises when not given a jid' do
+      -> { Vines::Contact.new }.must_raise ArgumentError
+      -> { Vines::Contact.new(jid: '') }.must_raise ArgumentError
+    end
+
+    it 'accepts a domain-only jid' do
+      contact = Vines::Contact.new(jid: 'tea.wonderland.lit')
+      contact.jid.to_s.must_equal 'tea.wonderland.lit'
+    end
+  end
+
+  describe '#to_roster_xml' do
+    let(:expected) do
+      node(%q{
+        <item jid="alice@wonderland.lit" name="Alice" subscription="from">
+          <group>Buddies</group>
+          <group>Friends</group>
+        </item>
+      })
+    end
+
+    it 'sorts group names' do
+      subject.to_roster_xml.must_equal expected
+    end
+  end
+
+  describe '#send_roster_push' do
+    let(:recipient) { MiniTest::Mock.new }
+    let(:expected) do
+      node(%q{
+        <iq to="hatter@wonderland.lit" type="set">
+          <query xmlns="jabber:iq:roster">
+          <item jid="alice@wonderland.lit" name="Alice" subscription="from">
+            <group>Buddies</group>
+            <group>Friends</group>
+          </item>
+          </query>
+        </iq>
+      })
+    end
+
+    before do
+      recipient.expect :user, Vines::User.new(jid: 'hatter@wonderland.lit')
+      class << recipient
+        attr_accessor :nodes
+        def write(node)
+          @nodes ||= []
+          @nodes << node
+        end
+      end
+    end
+
+    it '' do
+      subject.send_roster_push(recipient)
+      recipient.verify
+      recipient.nodes.size.must_equal 1
+      recipient.nodes.first.remove_attribute('id') # id is random
+      recipient.nodes.first.must_equal expected
+    end
+  end
+end

data/test/error_test.rb

@@ -0,0 +1,58 @@
+# encoding: UTF-8
+
+require 'test_helper'
+
+describe Vines::XmppError do
+  describe Vines::SaslErrors do
+    it 'does not require a text element' do
+      expected = %q{<failure xmlns="urn:ietf:params:xml:ns:xmpp-sasl"><temporary-auth-failure/></failure>}
+      Vines::SaslErrors::TemporaryAuthFailure.new.to_xml.must_equal expected
+    end
+
+    it 'includes a text element when message is given' do
+      text = %q{<text xml:lang="en">busted</text>}
+      expected = %q{<failure xmlns="urn:ietf:params:xml:ns:xmpp-sasl"><temporary-auth-failure/>%s</failure>} % text
+      Vines::SaslErrors::TemporaryAuthFailure.new('busted').to_xml.must_equal expected
+    end
+  end
+
+  describe Vines::StreamErrors do
+    it 'does not require a text element' do
+      expected = %q{<stream:error><internal-server-error xmlns="urn:ietf:params:xml:ns:xmpp-streams"/></stream:error>}
+      Vines::StreamErrors::InternalServerError.new.to_xml.must_equal expected
+    end
+
+    it 'includes a text element when message is given' do
+      text = %q{<text xmlns="urn:ietf:params:xml:ns:xmpp-streams" xml:lang="en">busted</text>}
+      expected = %q{<stream:error><internal-server-error xmlns="urn:ietf:params:xml:ns:xmpp-streams"/>%s</stream:error>} % text
+      Vines::StreamErrors::InternalServerError.new('busted').to_xml.must_equal expected
+    end
+  end
+
+  describe Vines::StanzaErrors do
+    it 'raises when given a bad type' do
+      node = node('<message/>')
+      -> { Vines::StanzaErrors::BadRequest.new(node, 'bogus') }.must_raise RuntimeError
+    end
+
+    it 'raises when given a bad stanza' do
+      node = node('<bogus/>')
+      -> { Vines::StanzaErrors::BadRequest.new(node, 'modify') }.must_raise RuntimeError
+    end
+
+    it 'does not require a text element' do
+      error = %q{<error type="modify"><bad-request xmlns="urn:ietf:params:xml:ns:xmpp-stanzas"/></error>}
+      expected = %q{<message from="hatter@wonderland.lit" to="alice@wonderland.lit" type="error">%s</message>} % error
+      node = node(%Q{<message from="alice@wonderland.lit" to="hatter@wonderland.lit"/>})
+      Vines::StanzaErrors::BadRequest.new(node, 'modify').to_xml.must_equal expected
+    end
+
+    it 'includes a text element when message is given' do
+      text = %q{<text xmlns="urn:ietf:params:xml:ns:xmpp-stanzas" xml:lang="en">busted</text>}
+      error = %q{<error type="modify"><bad-request xmlns="urn:ietf:params:xml:ns:xmpp-stanzas"/>%s</error>} % text
+      expected = %q{<message id="42" type="error">%s</message>} % error
+      node = node(%Q{<message id="42"/>})
+      Vines::StanzaErrors::BadRequest.new(node, 'modify', 'busted').to_xml.must_equal expected
+    end
+  end
+end

data/test/ext/nokogiri.rb

@@ -0,0 +1,14 @@
+# encoding: UTF-8
+
+module Nokogiri
+  module XML
+    class Node
+      # Override equality testing so we can use MiniTest::Mock#expect with
+      # Nokogiri::XML::Node arguments. Node's default behavior considers
+      # all nodes unequal.
+      def ==(node)
+        self.to_s == node.to_s
+      end
+    end
+  end
+end

data/test/jid_test.rb

@@ -0,0 +1,147 @@
+# encoding: UTF-8
+
+require 'test_helper'
+
+describe Vines::JID do
+  it 'handles empty input' do
+    [nil, ''].each do |text|
+      Vines::JID.new(text) # shouldn't raise an error
+      jid = Vines::JID.new(text)
+      assert_nil jid.node
+      assert_nil jid.resource
+      assert_equal '', jid.domain
+      assert_equal '', jid.to_s
+      assert_equal '', jid.bare.to_s
+      assert jid.empty?
+      refute jid.domain?
+    end
+  end
+
+  it 'raises when a jid part is too long' do
+    Vines::JID.new('n' * 1023) # shouldn't raise an error
+    assert_raises(ArgumentError) { Vines::JID.new('n' * 1024) }
+    assert_raises(ArgumentError) { Vines::JID.new('n', 'd' * 1024) }
+    assert_raises(ArgumentError) { Vines::JID.new('n', 'd', 'r' * 1024) }
+    Vines::JID.new('n' * 1023, 'd' * 1023, 'r' * 1023) # shouldn't raise an error
+  end
+
+  it 'correctly handles domain only jids' do
+    jid = Vines::JID.new('wonderland.lit')
+    assert_equal 'wonderland.lit', jid.to_s
+    assert_equal 'wonderland.lit', jid.domain
+    assert_nil jid.node
+    assert_nil jid.resource
+    assert_equal jid, jid.bare
+    assert jid.domain?
+    refute jid.empty?
+  end
+
+  it 'correctly handles bare jid components' do
+    jid = Vines::JID.new('alice', 'wonderland.lit')
+    assert_equal 'alice@wonderland.lit', jid.to_s
+    assert_equal 'wonderland.lit', jid.domain
+    assert_equal 'alice', jid.node
+    assert_nil jid.resource
+    assert_equal jid, jid.bare
+    refute jid.domain?
+    refute jid.empty?
+  end
+
+  it 'correctly parses bare jids' do
+    jid = Vines::JID.new('alice@wonderland.lit')
+    assert_equal 'alice@wonderland.lit', jid.to_s
+    assert_equal 'wonderland.lit', jid.domain
+    assert_equal 'alice', jid.node
+    assert_nil jid.resource
+    assert_equal jid, jid.bare
+    refute jid.domain?
+    refute jid.empty?
+  end
+
+  it 'correctly handles full jid components' do
+    jid = Vines::JID.new('alice', 'wonderland.lit', 'tea')
+    assert_equal 'alice@wonderland.lit/tea', jid.to_s
+    assert_equal 'wonderland.lit', jid.domain
+    assert_equal 'alice', jid.node
+    assert_equal 'tea', jid.resource
+    refute_equal jid, jid.bare
+    refute jid.domain?
+    refute jid.empty?
+  end
+
+  it 'correctly parses full jids' do
+    jid = Vines::JID.new('alice@wonderland.lit/tea')
+    assert_equal 'alice@wonderland.lit/tea', jid.to_s
+    assert_equal 'wonderland.lit', jid.domain
+    assert_equal 'alice', jid.node
+    assert_equal 'tea', jid.resource
+    refute_equal jid, jid.bare
+    refute jid.domain?
+    refute jid.empty?
+  end
+
+  it 'accepts separator characters in resource part' do
+    jid = Vines::JID.new('alice@wonderland.lit/foo/bar@blarg test')
+    assert_equal 'alice', jid.node
+    assert_equal 'wonderland.lit', jid.domain
+    assert_equal 'foo/bar@blarg test', jid.resource
+  end
+
+  it 'accepts separator characters in resource part with missing node part' do
+    jid = Vines::JID.new('wonderland.lit/foo/bar@blarg')
+    assert_nil jid.node
+    assert_equal 'wonderland.lit', jid.domain
+    assert_equal 'foo/bar@blarg', jid.resource
+    refute jid.domain?
+  end
+
+  it 'accepts strange characters in node part' do
+    jid = Vines::JID.new(%q{nasty!#$%()*+,-.;=?[\]^_`{|}~node@example.com})
+    jid.node.must_equal %q{nasty!#$%()*+,-.;=?[\]^_`{|}~node}
+    jid.domain.must_equal 'example.com'
+    jid.resource.must_be_nil
+  end
+
+  it 'accepts strange characters in resource part' do
+    jid = Vines::JID.new(%q{node@example.com/repulsive !#"$%&'()*+,-./:;<=>?@[\]^_`{|}~resource})
+    jid.node.must_equal 'node'
+    jid.domain.must_equal 'example.com'
+    jid.resource.must_equal %q{repulsive !#"$%&'()*+,-./:;<=>?@[\]^_`{|}~resource}
+  end
+
+  it 'rejects empty jid parts' do
+    assert_raises(ArgumentError) { Vines::JID.new('@wonderland.lit') }
+    assert_raises(ArgumentError) { Vines::JID.new('wonderland.lit/') }
+    assert_raises(ArgumentError) { Vines::JID.new('@') }
+    assert_raises(ArgumentError) { Vines::JID.new('alice@') }
+    assert_raises(ArgumentError) { Vines::JID.new('/') }
+    assert_raises(ArgumentError) { Vines::JID.new('/res') }
+    assert_raises(ArgumentError) { Vines::JID.new('@/') }
+  end
+
+  it 'rejects invalid characters' do
+    assert_raises(ArgumentError) { Vines::JID.new(%q{alice"s@wonderland.lit}) }
+    assert_raises(ArgumentError) { Vines::JID.new(%q{alice&s@wonderland.lit}) }
+    assert_raises(ArgumentError) { Vines::JID.new(%q{alice's@wonderland.lit}) }
+    assert_raises(ArgumentError) { Vines::JID.new(%q{alice:s@wonderland.lit}) }
+    assert_raises(ArgumentError) { Vines::JID.new(%q{alice<s@wonderland.lit}) }
+    assert_raises(ArgumentError) { Vines::JID.new(%q{alice>s@wonderland.lit}) }
+    assert_raises(ArgumentError) { Vines::JID.new("alice\u0000s@wonderland.lit") }
+    assert_raises(ArgumentError) { Vines::JID.new("alice\ts@wonderland.lit") }
+    assert_raises(ArgumentError) { Vines::JID.new("alice\rs@wonderland.lit") }
+    assert_raises(ArgumentError) { Vines::JID.new("alice\ns@wonderland.lit") }
+    assert_raises(ArgumentError) { Vines::JID.new("alice\vs@wonderland.lit") }
+    assert_raises(ArgumentError) { Vines::JID.new("alice\fs@wonderland.lit") }
+    assert_raises(ArgumentError) { Vines::JID.new(" alice@wonderland.lit") }
+    assert_raises(ArgumentError) { Vines::JID.new("alice@wonderland.lit ") }
+    assert_raises(ArgumentError) { Vines::JID.new("alice s@wonderland.lit") }
+    assert_raises(ArgumentError) { Vines::JID.new("alice@w onderland.lit") }
+    assert_raises(ArgumentError) { Vines::JID.new("alice@w\tonderland.lit") }
+    assert_raises(ArgumentError) { Vines::JID.new("alice@w\ronderland.lit") }
+    assert_raises(ArgumentError) { Vines::JID.new("alice@w\nonderland.lit") }
+    assert_raises(ArgumentError) { Vines::JID.new("alice@w\vonderland.lit") }
+    assert_raises(ArgumentError) { Vines::JID.new("alice@w\fonderland.lit") }
+    assert_raises(ArgumentError) { Vines::JID.new("alice@w\u0000onderland.lit") }
+    assert_raises(ArgumentError) { Vines::JID.new("alice@wonderland.lit/\u0000res") }
+  end
+end

data/test/kit_test.rb

@@ -0,0 +1,31 @@
+# encoding: UTF-8
+
+require 'test_helper'
+
+describe Vines::Kit do
+  describe '#hmac' do
+    it 'generates a SHA-512 HMAC' do
+      Vines::Kit.hmac('secret', 'username').length.must_equal 128
+      assert_equal Vines::Kit.hmac('s1', 'u1'), Vines::Kit.hmac('s1', 'u1')
+      refute_equal Vines::Kit.hmac('s1', 'u1'), Vines::Kit.hmac('s2', 'u1')
+      refute_equal Vines::Kit.hmac('s1', 'u1'), Vines::Kit.hmac('s1', 'u2')
+    end
+  end
+
+  describe '#uuid' do
+    it 'returns a random uuid' do
+      ids = Array.new(1000) { Vines::Kit.uuid }
+      assert ids.all? {|id| !id.nil? }
+      assert ids.all? {|id| id.length == 36 }
+      assert ids.all? {|id| id.match(/\w{8}-\w{4}-[4]\w{3}-[89ab]\w{3}-\w{12}/) }
+      ids.uniq.length.must_equal ids.length
+    end
+  end
+
+  describe '#auth_token' do
+    it 'returns a random 128 character token' do
+      Vines::Kit.auth_token.wont_equal Vines::Kit.auth_token
+      Vines::Kit.auth_token.length.must_equal 128
+    end
+  end
+end

data/test/router_test.rb

@@ -0,0 +1,243 @@
+# encoding: UTF-8
+
+require 'test_helper'
+
+describe Vines::Router do
+  subject      { Vines::Router.new(config) }
+  let(:alice)  { Vines::JID.new('alice@wonderland.lit/tea') }
+  let(:hatter) { 'hatter@wonderland.lit/cake' }
+  let(:romeo)  { 'romeo@verona.lit/party' }
+  let(:config) do
+    Vines::Config.new do
+      host 'wonderland.lit' do
+        storage(:fs) { dir Dir.tmpdir }
+        components 'tea' => 'secr3t'
+      end
+    end
+  end
+
+  describe '#connected_resources' do
+    let(:cake) { 'alice@wonderland.lit/cake' }
+    let(:stream1) { stream(alice) }
+    let(:stream2) { stream(cake) }
+
+    it 'is empty before any streams are connected' do
+      subject.connected_resources(alice, alice).size.must_equal 0
+      subject.connected_resources(cake, alice).size.must_equal 0
+      subject.size.must_equal 0
+    end
+
+    it 'returns only one stream matching full jid' do
+      subject << stream1
+      subject << stream2
+
+      streams = subject.connected_resources(alice, alice)
+      streams.size.must_equal 1
+      streams.first.user.jid.must_equal alice
+
+      streams = subject.connected_resources(cake, alice)
+      streams.size.must_equal 1
+      streams.first.user.jid.to_s.must_equal cake
+    end
+
+    it 'returns all streams matching bare jid' do
+      subject << stream1
+      subject << stream2
+
+      streams = subject.connected_resources(alice.bare, alice)
+      streams.size.must_equal 2
+      subject.size.must_equal 2
+    end
+  end
+
+  describe '#connected_resources with permissions' do
+    let(:stream1) { stream(alice) }
+    let(:stream2) { stream(romeo) }
+
+    before do
+      subject << stream1
+      subject << stream2
+    end
+
+    it 'denies access when cross domain messages is off' do
+      subject.connected_resources(alice, romeo).size.must_equal 0
+    end
+
+    it 'allows access when cross domain messages is on' do
+      config.vhost('wonderland.lit').cross_domain_messages true
+      subject.connected_resources(alice, romeo).size.must_equal 1
+    end
+  end
+
+  describe '#available_resources' do
+    let(:cake) { 'alice@wonderland.lit/cake' }
+    let(:stream1) { stream(alice) }
+    let(:stream2) { stream(cake) }
+
+    before do
+      stream1.send 'available?=', true
+      stream2.send 'available?=', false
+    end
+
+    it 'is empty before any streams are connected' do
+      subject.available_resources(alice, alice).size.must_equal 0
+      subject.available_resources(cake, alice).size.must_equal 0
+      subject.size.must_equal 0
+    end
+
+    it 'returns available streams based on bare jid, not full jid' do
+      subject << stream1
+      subject << stream2
+
+      streams = [alice, cake, alice.bare].map do |jid|
+        subject.available_resources(jid, alice)
+      end.flatten
+
+      # should only have found alice's stream
+      streams.size.must_equal 3
+      streams.uniq.size.must_equal 1
+      streams.first.user.jid.must_equal alice
+
+      subject.size.must_equal 2
+    end
+  end
+
+  describe '#interested_resources with no streams' do
+    it 'is empty before any streams are connected' do
+      subject.interested_resources(alice, alice).size.must_equal 0
+      subject.interested_resources(hatter, alice).size.must_equal 0
+      subject.interested_resources(alice, hatter, alice).size.must_equal 0
+      subject.size.must_equal 0
+    end
+  end
+
+  describe '#interested_resources' do
+    let(:stream1) { stream(alice) }
+    let(:stream2) { stream(hatter) }
+
+    before do
+      stream1.send 'interested?=', true
+      stream2.send 'interested?=', false
+      subject << stream1
+      subject << stream2
+    end
+
+    it 'does not find streams for unauthenticated jids' do
+      subject.interested_resources('bogus@wonderland.lit', alice).size.must_equal 0
+    end
+
+    it 'finds interested streams for full jids' do
+      subject.interested_resources(alice, hatter, alice).size.must_equal 1
+      subject.interested_resources([alice, hatter], alice).size.must_equal 1
+      subject.interested_resources(alice, hatter, alice)[0].user.jid.must_equal alice
+    end
+
+    it 'does not find streams for uninterested jids' do
+      subject.interested_resources(hatter, alice).size.must_equal 0
+      subject.interested_resources([hatter], alice).size.must_equal 0
+    end
+
+    it 'finds interested streams for bare jids' do
+      subject.interested_resources(alice.bare, alice).size.must_equal 1
+      subject.interested_resources(alice.bare, alice)[0].user.jid.must_equal alice
+    end
+  end
+
+  describe '#delete' do
+    let(:stream1) { stream(alice) }
+    let(:stream2) { stream(hatter) }
+
+    it 'correctly adds and removes streams' do
+      subject.size.must_equal 0
+
+      subject << stream1
+      subject << stream2
+      subject.size.must_equal 2
+
+      subject.delete(stream2)
+      subject.size.must_equal 1
+
+      subject.delete(stream2)
+      subject.size.must_equal 1
+
+      subject.delete(stream1)
+      subject.size.must_equal 0
+    end
+  end
+
+  describe 'load balanced component streams' do
+    let(:stream1) { component('tea.wonderland.lit') }
+    let(:stream2) { component('tea.wonderland.lit') }
+    let(:stanza)  { node('<message from="alice@wonderland.lit" to="tea.wonderland.lit">test</message>')}
+
+    before do
+      subject << stream1
+      subject << stream2
+    end
+
+    it 'must evenly distribute routed stanzas to both streams' do
+      100.times { subject.route(stanza) }
+
+      (stream1.count + stream2.count).must_equal 100
+      stream1.count.must_be :>, 33
+      stream2.count.must_be :>, 33
+    end
+  end
+
+  describe 'load balanced s2s streams' do
+    let(:stream1) { s2s('wonderland.lit', 'verona.lit') }
+    let(:stream2) { s2s('wonderland.lit', 'verona.lit') }
+    let(:stanza) { node('<message from="alice@wonderland.lit" to="romeo@verona.lit">test</message>') }
+
+    before do
+      config.vhost('wonderland.lit').cross_domain_messages true
+      subject << stream1
+      subject << stream2
+    end
+
+    it 'must evenly distribute routed stanzas to both streams' do
+      100.times { subject.route(stanza) }
+
+      (stream1.count + stream2.count).must_equal 100
+      stream1.count.must_be :>, 33
+      stream2.count.must_be :>, 33
+    end
+  end
+
+  private
+
+  def stream(jid)
+    OpenStruct.new.tap do |stream|
+      stream.send('connected?=', true)
+      stream.stream_type = :client
+      stream.user = Vines::User.new(jid: jid)
+    end
+  end
+
+  def component(jid)
+    OpenStruct.new.tap do |stream|
+      stream.stream_type = :component
+      stream.remote_domain = jid
+      stream.send('ready?=', true)
+      def stream.count; @count || 0; end
+      def stream.write(stanza)
+        @count ||= 0
+        @count += 1
+      end
+    end
+  end
+
+  def s2s(domain, remote_domain)
+    OpenStruct.new.tap do |stream|
+      stream.stream_type = :server
+      stream.domain = domain
+      stream.remote_domain = remote_domain
+      stream.send('ready?=', true)
+      def stream.count; @count || 0; end
+      def stream.write(stanza)
+        @count ||= 0
+        @count += 1
+      end
+    end
+  end
+end

data/test/stanza/iq/disco_info_test.rb

@@ -0,0 +1,78 @@
+# encoding: UTF-8
+
+require 'test_helper'
+
+describe Vines::Stanza::Iq::DiscoInfo do
+  subject      { Vines::Stanza::Iq::DiscoInfo.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 }
+      end
+    end
+  end
+
+  let(:xml) do
+    query = %q{<query xmlns="http://jabber.org/protocol/disco#info"/>}
+    node(%Q{<iq id="42" to="wonderland.lit" type="get">#{query}</iq>})
+  end
+
+  before do
+    class << stream
+      attr_accessor :config, :user
+    end
+    stream.config = config
+    stream.user = alice
+  end
+
+  describe 'when private storage is disabled' do
+    let(:expected) do
+      node(%Q{
+        <iq from="wonderland.lit" id="42" to="#{alice.jid}" type="result">
+          <query xmlns="http://jabber.org/protocol/disco#info">
+            <identity category="server" type="im"/>
+            <feature var="http://jabber.org/protocol/disco#info"/>
+            <feature var="http://jabber.org/protocol/disco#items"/>
+            <feature var="urn:xmpp:ping"/>
+            <feature var="vcard-temp"/>
+            <feature var="jabber:iq:version"/>
+          </query>
+        </iq>
+      })
+    end
+
+    it 'returns info stanza without the private storage feature' do
+      config.vhost('wonderland.lit').private_storage false
+      stream.expect :write, nil, [expected]
+      subject.process
+      stream.verify
+    end
+  end
+
+  describe 'when private storage is enabled' do
+    let(:expected) do
+      node(%Q{
+        <iq from="wonderland.lit" id="42" to="#{alice.jid}" type="result">
+          <query xmlns="http://jabber.org/protocol/disco#info">
+            <identity category="server" type="im"/>
+            <feature var="http://jabber.org/protocol/disco#info"/>
+            <feature var="http://jabber.org/protocol/disco#items"/>
+            <feature var="urn:xmpp:ping"/>
+            <feature var="vcard-temp"/>
+            <feature var="jabber:iq:version"/>
+            <feature var="jabber:iq:private"/>
+          </query>
+        </iq>
+      })
+    end
+
+    it 'announces private storage feature in info stanza result' do
+      config.vhost('wonderland.lit').private_storage true
+      stream.expect :write, nil, [expected]
+      subject.process
+      stream.verify
+    end
+  end
+end