vines 0.4.5 → 0.4.6

data/test/stanza/iq/roster_test.rb

@@ -1,206 +1,229 @@
 # encoding: UTF-8
 
-require 'vines'
-require 'ext/nokogiri'
-require 'minitest/autorun'
+require 'test_helper'
 
-class RosterTest < MiniTest::Unit::TestCase
-  def setup
-    @stream = MiniTest::Mock.new
-  end
+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') }
 
-  def test_roster_get_with_empty_roster
-    alice = Vines::User.new(:jid => 'alice@wonderland.lit')
-    expected = node(%q{<iq id="42" type="result"><query xmlns="jabber:iq:roster"/></iq>})
-    @stream.expect(:write, nil, [expected])
-    @stream.expect(:requested_roster!, nil)
-    @stream.expect(:user, alice)
-
-    node = node(%q{<iq id="42" type="get"><query xmlns='jabber:iq:roster'/></iq>})
-    stanza = Vines::Stanza::Iq::Roster.new(node, @stream)
-    stanza.process
-    assert @stream.verify
+  before do
+    class << stream
+      attr_accessor :domain, :user
+    end
+    stream.user = alice
+    stream.domain = 'wonderland.lit'
   end
 
-  def test_roster_get_with_non_empty_roster
-    alice = Vines::User.new(:jid => 'alice@wonderland.lit')
-    alice.roster << Vines::Contact.new(:jid => 'hatter@wonderland.lit')
-    alice.roster << Vines::Contact.new(:jid => 'cat@wonderland.lit', :groups => ['Friends', 'Cats'])
-
-    expected = 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>}.strip.gsub(/\n|\s{2,}/, ''))
-
-    @stream.expect(:write, nil, [expected])
-    @stream.expect(:requested_roster!, nil)
-    @stream.expect(:user, alice)
-
-    node = node(%q{<iq id="42" type="get"><query xmlns='jabber:iq:roster'/></iq>})
-    stanza = Vines::Stanza::Iq::Roster.new(node, @stream)
-    stanza.process
-    assert @stream.verify
+  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
 
-  def test_roster_get_with_invalid_to_address
-    alice = Vines::User.new(:jid => 'alice@wonderland.lit/tea')
-    @stream.expect(:user, alice)
+  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
 
-    node = node(%q{
-      <iq id="42" type="get" to="romeo@verona.lit">
-        <query xmlns="jabber:iq:roster"/>
-      </iq>}.strip.gsub(/\n|\s{2,}/, ''))
+    before do
+      alice.roster << Vines::Contact.new(jid: 'hatter@wonderland.lit')
+      alice.roster << Vines::Contact.new(jid: 'cat@wonderland.lit', :groups => ['Friends', 'Cats'])
 
-    stanza = Vines::Stanza::Iq::Roster.new(node, @stream)
-    assert_raises(Vines::StanzaErrors::Forbidden) { stanza.process }
-    assert @stream.verify
-  end
+      stream.expect :write, nil, [expected]
+      stream.expect :requested_roster!, nil
+    end
 
-  def test_roster_set_with_invalid_to_address
-    alice = Vines::User.new(:jid => 'alice@wonderland.lit/tea')
-    @stream.expect(:user, alice)
+    it 'sorts groups alphabetically' do
+      subject.process
+      stream.verify
+    end
+  end
 
-    node = node(%q{
-      <iq id="42" type="set" to="romeo@verona.lit">
-        <query xmlns="jabber:iq:roster"/>
-      </iq>}.strip.gsub(/\n|\s{2,}/, ''))
+  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
 
-    stanza = Vines::Stanza::Iq::Roster.new(node, @stream)
-    assert_raises(Vines::StanzaErrors::Forbidden) { stanza.process }
-    assert @stream.verify
+    it 'raises a forbidden stanza error' do
+      -> { subject.process }.must_raise Vines::StanzaErrors::Forbidden
+      stream.verify
+    end
   end
 
-  def test_roster_set_with_no_items
-    node = node(%q{
-      <iq id="42" type="set">
-        <query xmlns="jabber:iq:roster"/>
-      </iq>}.strip.gsub(/\n|\s{2,}/, ''))
+  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
 
-    stanza = Vines::Stanza::Iq::Roster.new(node, @stream)
-    assert_raises(Vines::StanzaErrors::BadRequest) { stanza.process }
-    assert @stream.verify
+    it 'raises a forbidden stanza error' do
+      -> { subject.process }.must_raise Vines::StanzaErrors::Forbidden
+      stream.verify
+    end
   end
 
-  def test_roster_set_with_two_items
-    node = node(%q{
-      <iq id="42" type="set">
-        <query xmlns="jabber:iq:roster">
-          <item jid="hatter@wonderland.lit"/>
-          <item jid="cat@wonderland.lit"/>
-        </query>
-      </iq>}.strip.gsub(/\n|\s{2,}/, ''))
-
-    stanza = Vines::Stanza::Iq::Roster.new(node, @stream)
-    assert_raises(Vines::StanzaErrors::BadRequest) { stanza.process }
-    assert @stream.verify
+  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
 
-  def test_roster_set_missing_jid
-    node = node(%q{
-      <iq id="42" type="set">
-        <query xmlns="jabber:iq:roster">
-          <item name="Mad Hatter"/>
-        </query>
-      </iq>}.strip.gsub(/\n|\s{2,}/, ''))
-
-    stanza = Vines::Stanza::Iq::Roster.new(node, @stream)
-    assert_raises(Vines::StanzaErrors::BadRequest) { stanza.process }
-    assert @stream.verify
+  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
 
-  def test_roster_set_with_duplicate_groups
-    alice = Vines::User.new(:jid => 'alice@wonderland.lit/tea')
-    @stream.expect(:user, alice)
-
-    node = 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>}.strip.gsub(/\n|\s{2,}/, ''))
-
-    stanza = Vines::Stanza::Iq::Roster.new(node, @stream)
-    assert_raises(Vines::StanzaErrors::BadRequest) { stanza.process }
-    assert @stream.verify
+  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
 
-  def test_roster_set_with_empty_group
-    alice = Vines::User.new(:jid => 'alice@wonderland.lit/tea')
-    @stream.expect(:user, alice)
-
-    node = 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>}.strip.gsub(/\n|\s{2,}/, ''))
-
-    stanza = Vines::Stanza::Iq::Roster.new(node, @stream)
-    assert_raises(Vines::StanzaErrors::NotAcceptable) { stanza.process }
-    assert @stream.verify
+  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
 
-  def test_roster_set_sends_results
-    alice = Vines::User.new(:jid => 'alice@wonderland.lit/tea')
-    storage = MiniTest::Mock.new
-    storage.expect(:save_user, nil, [alice])
-
-    recipient = MiniTest::Mock.new
-    recipient.expect(:user, alice)
-    def recipient.nodes; @nodes; end
-    def recipient.write(node)
-      @nodes ||= []
-      @nodes << node
-    end
-
-    @stream.expect(:user, alice)
-    @stream.expect(:interested_resources, [recipient], [alice.jid])
-    @stream.expect(:update_user_streams, nil, [alice])
-    @stream.expect(:domain, 'wonderland.lit')
-    @stream.expect(:storage, storage, ['wonderland.lit'])
-    expected = node(%Q{<iq id="42" to="#{alice.jid}" type="result"/>})
-    @stream.expect(:write, nil, [expected])
-
-    node = 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>}.strip.gsub(/\n|\s{2,}/, ''))
-
-    stanza = Vines::Stanza::Iq::Roster.new(node, @stream)
-    stanza.process
-    assert @stream.verify
-    assert storage.verify
-
-    expected = 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>}.strip.gsub(/\n|\s{2,}/, ''))
-    recipient.nodes[0].remove_attribute('id') # id is random
-    assert_equal expected, recipient.nodes[0]
+  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
 
-  private
+  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
 
-  def node(xml)
-    Nokogiri::XML(xml).root
+      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

@@ -1,26 +1,25 @@
 # encoding: UTF-8
 
-require 'vines'
-require 'ext/nokogiri'
-require 'minitest/autorun'
+require 'test_helper'
 
-class SessionTest < MiniTest::Unit::TestCase
-  def test_session
-    stream = MiniTest::Mock.new
-    stream.expect(:domain, 'wonderland.lit')
-    stream.expect(:user, Vines::User.new(jid: 'alice@wonderland.lit/tea'))
-    expected = node(%q{<iq from="wonderland.lit" id="42" to="alice@wonderland.lit/tea" type="result"/>})
-    stream.expect(:write, nil, [expected])
+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') }
 
-    node = node(%q{<iq id="42" type="set"><session xmlns="urn:ietf:params:xml:ns:xmpp-session"/></iq>})
-    stanza = Vines::Stanza::Iq::Session.new(node, stream)
-    stanza.process
-    assert stream.verify
-  end
+  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"/>}) }
 
-  private
+    before do
+      stream.expect :domain, 'wonderland.lit'
+      stream.expect :user, alice
+      stream.expect :write, nil, [result]
+    end
 
-  def node(xml)
-    Nokogiri::XML(xml).root
+    it 'just returns a result to satisy older clients' do
+      subject.process
+      stream.verify
+    end
   end
 end

data/test/stanza/iq/vcard_test.rb

@@ -1,14 +1,14 @@
 # encoding: UTF-8
 
-require 'tmpdir'
-require 'vines'
-require 'ext/nokogiri'
-require 'minitest/autorun'
-
-class VcardTest < MiniTest::Unit::TestCase
-  def setup
-    @stream = MiniTest::Mock.new
-    @config = Vines::Config.new do
+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 }
@@ -16,130 +16,131 @@ class VcardTest < MiniTest::Unit::TestCase
     end
   end
 
-  def test_vcard_get_on_remote_jid_routes
-    alice = Vines::User.new(:jid => 'alice@wonderland.lit/tea')
-    node = node(%q{<iq id="42" to="romeo@verona.lit" type="get"><vCard xmlns="vcard-temp"/></iq>})
+  before do
+    class << stream
+      attr_accessor :config, :domain, :user
+    end
+    stream.config = config
+    stream.domain = 'wonderland.lit'
+    stream.user = alice
+  end
 
-    router = MiniTest::Mock.new
-    router.expect(:route, nil, [node])
+  describe 'when getting vcard' do
+    describe 'and addressed to a remote jid' do
+      let(:xml) { get('romeo@verona.lit') }
+      let(:router) { MiniTest::Mock.new }
 
-    @stream.expect(:config, @config)
-    @stream.expect(:user, alice)
-    @stream.expect(:router, router)
+      before do
+        router.expect :route, nil, [xml]
+        stream.expect :router, router
+      end
 
-    stanza = Vines::Stanza::Iq::Vcard.new(node, @stream)
-    stanza.process
-    assert @stream.verify
-    assert router.verify
-  end
+      it 'routes rather than handle locally' do
+        subject.process
+        stream.verify
+        router.verify
+      end
+    end
 
-  def test_vcard_get_missing_to_address
-    alice = Vines::User.new(:jid => 'alice@wonderland.lit/tea')
-    node = node(%q{<iq id="42" type="get"><vCard xmlns="vcard-temp"/></iq>})
-
-    card = node(%q{<vCard xmlns="vcard-temp"><FN>Alice in Wonderland</FN></vCard>})
-
-    storage = MiniTest::Mock.new
-    storage.expect(:find_vcard, card, [alice.jid.bare])
-
-    @stream.expect(:config, @config)
-    @stream.expect(:user, alice)
-    @stream.expect(:domain, 'wonderland.lit')
-    @stream.expect(:storage, storage, ['wonderland.lit'])
-    expected = node(%q{
-      <iq id="42" to="alice@wonderland.lit/tea" type="result">
-        <vCard xmlns="vcard-temp">
-          <FN>Alice in Wonderland</FN>
-        </vCard>
-      </iq>}.strip.gsub(/\n|\s{2,}/, ''))
-    @stream.expect(:write, nil, [expected])
-
-    stanza = Vines::Stanza::Iq::Vcard.new(node, @stream)
-    stanza.process
-    assert @stream.verify
-    assert storage.verify
-  end
+    describe 'and missing to address' do
+      let(:xml) { get('') }
+      let(:card) { vcard('Alice') }
+      let(:expected) { result(alice.jid, '', card) }
 
-  def test_vcard_get_another_user_includes_from_address
-    alice = Vines::User.new(:jid => 'alice@wonderland.lit/tea')
-    node = node(%q{<iq id="42" to="hatter@wonderland.lit" type="get"><vCard xmlns="vcard-temp"/></iq>})
-
-    card = node(%q{<vCard xmlns="vcard-temp"><FN>Mad Hatter</FN></vCard>})
-
-    storage = MiniTest::Mock.new
-    storage.expect(:find_vcard, card, [Vines::JID.new('hatter@wonderland.lit')])
-
-    @stream.expect(:config, @config)
-    @stream.expect(:user, alice)
-    @stream.expect(:storage, storage, ['wonderland.lit'])
-    expected = node(%q{
-      <iq from="hatter@wonderland.lit" id="42" to="alice@wonderland.lit/tea" type="result">
-        <vCard xmlns="vcard-temp">
-          <FN>Mad Hatter</FN>
-        </vCard>
-      </iq>}.strip.gsub(/\n|\s{2,}/, ''))
-    @stream.expect(:write, nil, [expected])
-
-    stanza = Vines::Stanza::Iq::Vcard.new(node, @stream)
-    stanza.process
-    assert @stream.verify
-    assert storage.verify
-  end
+      before do
+        storage.expect :find_vcard, card, [alice.jid.bare]
+        stream.expect :storage, storage, ['wonderland.lit']
+        stream.expect :write, nil, [expected]
+      end
 
-  def test_missing_vcard_get_returns_item_not_found
-    alice = Vines::User.new(:jid => 'alice@wonderland.lit/tea')
-    node = node(%q{<iq id="42" type="get"><vCard xmlns="vcard-temp"/></iq>})
+      it 'sends vcard for authenticated jid' do
+        subject.process
+        stream.verify
+        storage.verify
+      end
+    end
 
-    storage = MiniTest::Mock.new
-    storage.expect(:find_vcard, nil, [alice.jid.bare])
+    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) }
 
-    @stream.expect(:config, @config)
-    @stream.expect(:user, alice)
-    @stream.expect(:domain, 'wonderland.lit')
-    @stream.expect(:storage, storage, ['wonderland.lit'])
+      before do
+        storage.expect :find_vcard, card, [hatter]
+        stream.expect :storage, storage, ['wonderland.lit']
+        stream.expect :write, nil, [expected]
+      end
 
-    stanza = Vines::Stanza::Iq::Vcard.new(node, @stream)
-    assert_raises(Vines::StanzaErrors::ItemNotFound) { stanza.process }
-    assert @stream.verify
-    assert storage.verify
-  end
+      it 'succeeds and returns vcard with from address' do
+        subject.process
+        stream.verify
+        storage.verify
+      end
+    end
 
-  def test_vcard_set_on_another_user_returns_forbidden
-    alice = Vines::User.new(:jid => 'alice@wonderland.lit/tea')
-    node = node(%q{<iq id="42" to="hatter@wonderland.lit" type="set"><vCard xmlns="vcard-temp"><FN>Alice</FN></vCard></iq>})
+    describe 'for missing vcard' do
+      let(:xml) { get('') }
 
-    @stream.expect(:config, @config)
-    @stream.expect(:user, alice)
+      before do
+        storage.expect :find_vcard, nil, [alice.jid.bare]
+        stream.expect :storage, storage, ['wonderland.lit']
+      end
 
-    stanza = Vines::Stanza::Iq::Vcard.new(node, @stream)
-    assert_raises(Vines::StanzaErrors::Forbidden) { stanza.process }
-    assert @stream.verify
+      it 'returns an item-not-found stanza error' do
+        -> { subject.process }.must_raise Vines::StanzaErrors::ItemNotFound
+        stream.verify
+        storage.verify
+      end
+    end
   end
 
-  def test_vcard_set_returns_result
-    alice = Vines::User.new(:jid => 'alice@wonderland.lit/tea')
-    node = node(%q{<iq id="42" type="set"><vCard xmlns="vcard-temp"><FN>Alice</FN></vCard></iq>})
-    card = node(%q{<vCard xmlns="vcard-temp"><FN>Alice</FN></vCard>})
-
-    storage = MiniTest::Mock.new
-    storage.expect(:save_vcard, nil, [alice.jid, card])
-
-    @stream.expect(:config, @config)
-    @stream.expect(:user, alice)
-    @stream.expect(:domain, 'wonderland.lit')
-    @stream.expect(:storage, storage, ['wonderland.lit'])
-    expected = node(%q{<iq id="42" to="alice@wonderland.lit/tea" type="result"/>})
-    @stream.expect(:write, nil, [expected])
-
-    stanza = Vines::Stanza::Iq::Vcard.new(node, @stream)
-    stanza.process
-    assert @stream.verify
-    assert storage.verify
+  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 node(xml)
-    Nokogiri::XML(xml).root
+  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