blather 0.2.1 → 0.2.2

data/spec/blather/stanza/iq_spec.rb

@@ -8,4 +8,33 @@ describe 'Blather::Stanza::Iq' do
   it 'creates a new Iq stanza defaulted as a get' do
     Stanza::Iq.new.type.must_equal :get
   end
+
+  it 'wont import non-iq stanzas' do
+    lambda { Stanza::Iq.import(XMPPNode.new('foo')) }.must_raise(Blather::ArgumentError)
+  end
+
+  it 'creates a new Stanza::Iq object on import' do
+    Stanza::Iq.import(XMPPNode.new('iq')).must_be_kind_of Stanza::Iq
+  end
+
+  it 'creates a proper object based on its children' do
+    n = XMPPNode.new('iq')
+    n << XMPPNode.new('query')
+    Stanza::Iq.import(n).must_be_kind_of Stanza::Iq::Query
+  end
+
+  it 'ensures type is one of Stanza::Iq::VALID_TYPES' do
+    lambda { Stanza::Iq.new :invalid_type_name }.must_raise(Blather::ArgumentError)
+
+    Stanza::Iq::VALID_TYPES.each do |valid_type|
+      n = Stanza::Iq.new valid_type
+      n.type.must_equal valid_type
+    end
+  end
+
+  Stanza::Iq::VALID_TYPES.each do |valid_type|
+    it "provides a helper (#{valid_type}?) for type #{valid_type}" do
+      Stanza::Iq.new.must_respond_to :"#{valid_type}?"
+    end
+  end
 end

data/spec/blather/stanza/presence/subscription_spec.rb

@@ -71,4 +71,15 @@ describe 'Blather::Stanza::Presence::Subscription' do
     sub.type = :subscribe
     sub.request?.must_equal true
   end
-end
+
+  it "will inherit only another node's attributes" do
+    inheritable = XMPPNode.new 'foo'
+    inheritable.attributes[:bar] = 'baz'
+
+    sub = Stanza::Presence::Subscription.new
+    sub.must_respond_to :inherit
+
+    sub.inherit inheritable
+    sub.attributes[:bar].must_equal 'baz'
+  end
+end

data/spec/blather/stanza/presence_spec.rb

@@ -21,4 +21,33 @@ describe 'Blather::Stanza::Presence' do
     end
   end
 
+  it 'creates a Status object when importing a node with type == nil' do
+    s = Stanza::Presence.import(XMPPNode.new)
+    s.must_be_kind_of Stanza::Presence::Status
+    s.state.must_equal :available
+  end
+
+  it 'creates a Status object when importing a node with type == "unavailable"' do
+    n = XMPPNode.new
+    n.attributes[:type] = :unavailable
+    s = Stanza::Presence.import(n)
+    s.must_be_kind_of Stanza::Presence::Status
+    s.state.must_equal :unavailable
+  end
+
+  it 'creates a Subscription object when importing a node with type == "subscribe"' do
+    n = XMPPNode.new
+    n.attributes[:type] = :subscribe
+    s = Stanza::Presence.import(n)
+    s.must_be_kind_of Stanza::Presence::Subscription
+    s.type.must_equal :subscribe
+  end
+
+  it 'creates a Presence object when importing a node with type equal to something unkown' do
+    n = XMPPNode.new
+    n.attributes[:type] = :foo
+    s = Stanza::Presence.import(n)
+    s.must_be_kind_of Stanza::Presence
+    s.type.must_equal :foo
+  end
 end

data/spec/blather/stanza/pubsub/affiliations_spec.rb

@@ -0,0 +1,46 @@
+require File.join(File.dirname(__FILE__), *%w[.. .. .. spec_helper])
+require File.join(File.dirname(__FILE__), *%w[.. .. .. fixtures pubsub])
+
+describe 'Blather::Stanza::PubSub::Affiliations' do
+  it 'registers itself' do
+    XMPPNode.class_from_registration(:pubsub_affiliations, 'http://jabber.org/protocol/pubsub').must_equal Stanza::PubSub::Affiliations
+  end
+
+  it 'ensures an affiliations node is present on create' do
+    affiliations = Stanza::PubSub::Affiliations.new
+    affiliations.pubsub.children.detect { |n| n.element_name == 'affiliations' }.wont_be_nil
+  end
+
+  it 'ensures an affiliations node exists when calling #affiliations' do
+    affiliations = Stanza::PubSub::Affiliations.new
+    affiliations.pubsub.remove_child :affiliations
+    affiliations.pubsub.children.detect { |n| n.element_name == 'affiliations' }.must_be_nil
+
+    affiliations.affiliations.wont_be_nil
+    affiliations.pubsub.children.detect { |n| n.element_name == 'affiliations' }.wont_be_nil    
+  end
+
+  it 'defaults to a get node' do
+    aff = Stanza::PubSub::Affiliations.new
+    aff.type.must_equal :get
+  end
+
+  it 'sets the host if requested' do
+    aff = Stanza::PubSub::Affiliations.new :get, 'pubsub.jabber.local'
+    aff.to.must_equal JID.new('pubsub.jabber.local')
+  end
+
+  it 'can import an affiliates result node' do
+    node = XML::Document.string(affiliations_xml).root
+
+    affiliations = Stanza::PubSub::Affiliations.new.inherit node
+    affiliations.size.must_equal 5
+    affiliations.list.must_equal({
+      :owner => ['node1', 'node2'],
+      :publisher => ['node3'],
+      :outcast => ['node4'],
+      :member => ['node5'],
+      :none => ['node6']
+    })
+  end
+end

data/spec/blather/stanza/pubsub/items_spec.rb

@@ -0,0 +1,59 @@
+require File.join(File.dirname(__FILE__), *%w[.. .. .. spec_helper])
+require File.join(File.dirname(__FILE__), *%w[.. .. .. fixtures pubsub])
+
+describe 'Blather::Stanza::PubSub::Items' do
+  it 'registers itself' do
+    XMPPNode.class_from_registration(:pubsub_items, 'http://jabber.org/protocol/pubsub').must_equal Stanza::PubSub::Items
+  end
+
+  it 'ensures an items node is present on create' do
+    items = Stanza::PubSub::Items.new
+    items.pubsub.children.detect { |n| n.element_name == 'items' }.wont_be_nil
+  end
+
+  it 'ensures an items node exists when calling #items' do
+    items = Stanza::PubSub::Items.new
+    items.pubsub.remove_child :items
+    items.pubsub.children.detect { |n| n.element_name == 'items' }.must_be_nil
+
+    items.items.wont_be_nil
+    items.pubsub.children.detect { |n| n.element_name == 'items' }.wont_be_nil    
+  end
+
+  it 'defaults to a get node' do
+    aff = Stanza::PubSub::Items.new
+    aff.type.must_equal :get
+  end
+
+  it 'can create an items request node to request all items' do
+    host = 'pubsub.jabber.local'
+    node = 'princely_musings'
+
+    items = Stanza::PubSub::Items.request host, node
+    items.find("//pubsub/items[@node=\"#{node}\"]").size.must_equal 1
+    items.to.must_equal JID.new(host)
+  end
+
+  it 'can create an items request node to request some items' do
+    host = 'pubsub.jabber.local'
+    node = 'princely_musings'
+    items = %w[item1 item2]
+
+    items_xpath = items.map { |i| "@id=\"#{i}\"" } * ' or '
+
+    items = Stanza::PubSub::Items.request host, node, items
+    items.find("//pubsub/items[@node=\"#{node}\"]/item[#{items_xpath}]").size.must_equal 2
+    items.to.must_equal JID.new(host)
+  end
+
+  it 'can create an items request node to request "max_number" of items' do
+    host = 'pubsub.jabber.local'
+    node = 'princely_musings'
+    max = 3
+
+    items = Stanza::PubSub::Items.request host, node, nil, max
+    items.find("//pubsub/items[@node=\"#{node}\" and @max_items=\"#{max}\"]").size.must_equal 1
+    items.to.must_equal JID.new(host)
+  end
+  
+end

data/spec/blather/stanza/pubsub/subscriptions_spec.rb

@@ -0,0 +1,63 @@
+require File.join(File.dirname(__FILE__), *%w[.. .. .. spec_helper])
+
+def subscriptions_xml
+  <<-NODE
+    <iq type='result'
+        from='pubsub.shakespeare.lit'
+        to='francisco@denmark.lit'
+        id='affil1'>
+      <pubsub xmlns='http://jabber.org/protocol/pubsub'>
+        <subscriptions>
+          <subscription node='node1' subscription='subscribed'/>
+          <subscription node='node2' subscription='subscribed'/>
+          <subscription node='node3' subscription='unconfigured'/>
+          <subscription node='node4' subscription='pending'/>
+          <subscription node='node5' subscription='none'/>
+        </subscriptions>
+      </pubsub>
+    </iq>
+  NODE
+end
+
+describe 'Blather::Stanza::PubSub::Subscriptions' do
+  it 'registers itself' do
+    XMPPNode.class_from_registration(:pubsub_subscriptions, 'http://jabber.org/protocol/pubsub').must_equal Stanza::PubSub::Subscriptions
+  end
+
+  it 'ensures an subscriptions node is present on create' do
+    subscriptions = Stanza::PubSub::Subscriptions.new
+    subscriptions.pubsub.children.detect { |n| n.element_name == 'subscriptions' }.wont_be_nil
+  end
+
+  it 'ensures an subscriptions node exists when calling #subscriptions' do
+    subscriptions = Stanza::PubSub::Subscriptions.new
+    subscriptions.pubsub.remove_child :subscriptions
+    subscriptions.pubsub.children.detect { |n| n.element_name == 'subscriptions' }.must_be_nil
+
+    subscriptions.list.wont_be_nil
+    subscriptions.pubsub.children.detect { |n| n.element_name == 'subscriptions' }.wont_be_nil    
+  end
+
+  it 'defaults to a get node' do
+    aff = Stanza::PubSub::Subscriptions.new
+    aff.type.must_equal :get
+  end
+
+  it 'sets the host if requested' do
+    aff = Stanza::PubSub::Subscriptions.new :get, 'pubsub.jabber.local'
+    aff.to.must_equal JID.new('pubsub.jabber.local')
+  end
+
+  it 'can import a subscriptions result node' do
+    node = XML::Document.string(subscriptions_xml).root
+
+    subscriptions = Stanza::PubSub::Subscriptions.new.inherit node
+    subscriptions.size.must_equal 4
+    subscriptions.list.must_equal({
+      :subscribed => ['node1', 'node2'],
+      :unconfigured => ['node3'],
+      :pending => ['node4'],
+      :none => ['node5']
+    })
+  end
+end

data/spec/blather/stanza/pubsub_spec.rb

@@ -0,0 +1,26 @@
+require File.join(File.dirname(__FILE__), *%w[.. .. spec_helper])
+
+describe 'Blather::Stanza::PubSub' do
+  it 'registers itself' do
+    XMPPNode.class_from_registration(:pubsub, 'http://jabber.org/protocol/pubsub').must_equal Stanza::PubSub
+  end
+
+  it 'ensures a pubusb node is present on create' do
+    pubsub = Stanza::PubSub.new
+    pubsub.children.detect { |n| n.element_name == 'pubsub' }.wont_be_nil
+  end
+
+  it 'ensures a pubsub node exists when calling #pubsub' do
+    pubsub = Stanza::PubSub.new
+    pubsub.remove_child :pubsub
+    pubsub.children.detect { |n| n.element_name == 'pubsub' }.must_be_nil
+
+    pubsub.pubsub.wont_be_nil
+    pubsub.children.detect { |n| n.element_name == 'pubsub' }.wont_be_nil
+  end
+
+  it 'sets the host if requested' do
+    aff = Stanza::PubSub.new :get, 'pubsub.jabber.local'
+    aff.to.must_equal JID.new('pubsub.jabber.local')
+  end
+end

data/spec/blather/stanza_spec.rb

@@ -2,7 +2,7 @@ require File.join(File.dirname(__FILE__), *%w[.. spec_helper])
 
 describe 'Blather::Stanza' do
   it 'provides .next_id helper for generating new IDs' do
-    proc { Stanza.next_id }.must_change 'Stanza', :next_id
+    proc { Stanza.next_id }.must_change 'Stanza.next_id'
   end
 
   it 'can import a node' do
@@ -92,4 +92,16 @@ describe 'Blather::Stanza' do
     s.type.wont_be_nil
     s['type'].wont_be_nil
   end
+
+  it 'can be converted into an error by error name' do
+    s = Stanza.new('message')
+    err = s.as_error 'internal-server-error', 'cancel'
+    err.must_be_instance_of StanzaError::InternalServerError
+  end
+
+  it 'can be converted into an error by error class' do
+    s = Stanza.new('message')
+    err = s.as_error StanzaError::InternalServerError, 'cancel'
+    err.must_be_instance_of StanzaError::InternalServerError
+  end
 end

data/spec/blather/stream/client_spec.rb

@@ -0,0 +1,787 @@
+require File.join(File.dirname(__FILE__), *%w[.. .. spec_helper])
+
+describe 'Blather::Stream::Client' do
+  class MockServer; end
+  module ServerMock
+    def receive_data(data)
+      @server ||= MockServer.new
+      @server.receive_data data, self
+    end
+  end
+
+  def mocked_server(times = nil, &block)
+    @client ||= mock()
+    @client.stubs(:stopped) unless @client.respond_to?(:stopped)
+    @client.stubs(:jid=) unless @client.respond_to?(:jid=)
+
+    MockServer.any_instance.expects(:receive_data).send(*(times ? [:times, times] : [:at_least, 1])).with &block
+    EventMachine::run {
+      # Mocked server
+      EventMachine::start_server '127.0.0.1', 12345, ServerMock
+
+      # Stream connection
+      EM.connect('127.0.0.1', 12345, Stream::Client, @client, @jid || JID.new('n@d/r'), 'pass') { |c| @stream = c }
+    }
+  end
+
+  it 'can be started' do
+    client = mock()
+    params = [client, 'n@d/r', 'pass', 'host', 1234]
+    EM.expects(:connect).with do |*parms|
+      parms[0] == 'host'  &&
+      parms[1] == 1234    &&
+      parms[3] == client  &&
+      parms[5] == 'pass'  &&
+      parms[4] == JID.new('n@d/r')
+    end
+
+    Stream::Client.start *(params)
+  end
+
+  it 'can figure out the host to use based on the jid' do
+    client = mock()
+    params = [client, 'n@d/r', 'pass', 'd', 5222]
+    EM.expects(:connect).with do |*parms|
+      parms[0] == 'd'     &&
+      parms[1] == 5222    &&
+      parms[3] == client  &&
+      parms[5] == 'pass'  &&
+      parms[4] == JID.new('n@d/r')
+    end
+
+    Stream::Client.start client, 'n@d/r', 'pass'
+  end
+
+  it 'starts the stream once the connection is complete' do
+    mocked_server(1) { |val, _| EM.stop; val.must_match(/stream:stream/) }
+  end
+
+  it 'sends stanzas to the client when the stream is ready' do
+    @client = mock()
+    @client.expects(:call).with do |n|
+      EM.stop
+      n.kind_of?(Stanza::Message) && @stream.ready?.must_equal(true)
+    end
+
+    mocked_server(1) do |val, server|
+      val.must_match(/stream:stream/)
+      server.send_data "<?xml version='1.0'?><stream:stream xmlns='jabber:client' xmlns:stream='http://etherx.jabber.org/streams'>"
+      server.send_data "<message to='a@b/c' from='d@e/f' type='chat' xml:lang='en'><body>Message!</body></message>"
+    end
+  end
+
+  it 'puts itself in the stopped state and calls @client.stopped when stopped' do
+    @client = mock()
+    @client.expects(:stopped).at_least_once
+
+    started = false
+    mocked_server(2) do |val, server|
+      if !started
+        started = true
+        server.send_data "<?xml version='1.0'?><stream:stream xmlns='jabber:client' xmlns:stream='http://etherx.jabber.org/streams'>"
+        server.send_data "<stream:features><bind xmlns='urn:ietf:params:xml:ns:xmpp-bind' /></stream:features>"
+        val.must_match(/stream:stream/)
+
+      else
+        EM.stop
+        @stream.stopped?.must_equal false
+        @stream.unbind
+        @stream.stopped?.must_equal true
+
+      end
+    end
+  end
+
+  it 'will be in the negotiating state during feature negotiations' do
+    state = nil
+    @client = mock()
+    @client.stubs(:stream_started)
+    @client.expects(:call).with do |n|
+      EM.stop
+      state.must_equal(:negotiated) && @stream.negotiating?.must_equal(false)
+    end
+
+    mocked_server(2) do |val, server|
+      case state
+      when nil
+        state = :started
+        server.send_data "<?xml version='1.0'?><stream:stream xmlns='jabber:client' xmlns:stream='http://etherx.jabber.org/streams'>"
+        server.send_data "<stream:features><session xmlns='urn:ietf:params:xml:ns:xmpp-session' /></stream:features>"
+        true
+
+      when :started
+        state = :negotiated
+        @stream.negotiating?.must_equal(true)
+        server.send_data "<iq from='d' type='result' id='#{val[/id="([^"]+)"/,1]}' />"
+        server.send_data "<message to='a@b/c' from='d@e/f' type='chat' xml:lang='en'><body>Message!</body></message>"
+        true
+
+      else
+        EM.stop
+        false
+
+      end
+    end
+  end
+
+  it 'stops when sent </stream:stream>' do
+    state = nil
+    mocked_server(3) do |val, server|
+      case state
+      when nil
+        state = :started
+        server.send_data "<?xml version='1.0'?><stream:stream xmlns='jabber:client' xmlns:stream='http://etherx.jabber.org/streams' version='1.0' xml:lang='en'>"
+        server.send_data "<stream:features><bind xmlns='urn:ietf:params:xml:ns:xmpp-bind' /></stream:features>"
+        val.must_match(/stream:stream/)
+
+      when :started
+        state = :stopped
+        server.send_data '</stream:stream>'
+        @stream.stopped?.must_equal false
+
+      when :stopped
+        EM.stop
+        @stream.stopped?.must_equal true
+        val.must_equal '</stream:stream>'
+
+      else
+        EM.stop
+        false
+
+      end
+    end
+  end
+
+  it 'sends client an error on stream:error' do
+    @client = mock()
+    @client.expects(:call).with do |v|
+      v.must_be_instance_of(StreamError::Conflict)
+      v.text.must_equal 'Already signed in'
+      v.to_s.must_equal "Stream Error (conflict): #{v.text}"
+    end
+
+    state = nil
+    mocked_server(3) do |val, server|
+      case state
+      when nil
+        state = :started
+        server.send_data "<?xml version='1.0'?><stream:stream xmlns='jabber:client' xmlns:stream='http://etherx.jabber.org/streams' version='1.0'>"
+        server.send_data "<stream:features><bind xmlns='urn:ietf:params:xml:ns:xmpp-bind' /></stream:features>"
+        val.must_match(/stream:stream/)
+
+      when :started
+        state = :stopped
+        server.send_data "<stream:error><conflict xmlns='urn:ietf:params:xml:ns:xmpp-streams' />"
+        server.send_data "<text xmlns='urn:ietf:params:xml:ns:xmpp-streams'>Already signed in</text></stream:error>"
+
+      when :stopped
+        EM.stop
+        val.must_equal "</stream:stream>"
+
+      else
+        EM.stop
+        false
+
+      end
+    end
+  end
+
+  it 'starts TLS when asked' do
+    state = nil
+    mocked_server(3) do |val, server|
+      case state
+      when nil
+        state = :started
+        server.send_data "<?xml version='1.0'?><stream:stream xmlns='jabber:client' xmlns:stream='http://etherx.jabber.org/streams'><stream:features><starttls xmlns='urn:ietf:params:xml:ns:xmpp-tls' /></stream:features>"
+        val.must_match(/stream:stream/)
+
+      when :started
+        state = :tls
+        @stream.expects(:start_tls)
+        server.send_data "<proceed xmlns='urn:ietf:params:xml:ns:xmpp-tls'/>"
+        val.must_match(/starttls/)
+
+      when :tls
+        EM.stop
+        true
+
+      else
+        EM.stop
+        false
+
+      end
+    end
+  end
+
+  it 'will fail if TLS negotiation fails' do
+    state = nil
+    @client = mock()
+    @client.expects(:call).with { |v| v.must_be_kind_of TLSFailure }
+    mocked_server(3) do |val, server|
+      case state
+      when nil
+        state = :started
+        server.send_data "<?xml version='1.0'?><stream:stream xmlns='jabber:client' xmlns:stream='http://etherx.jabber.org/streams'><stream:features><starttls xmlns='urn:ietf:params:xml:ns:xmpp-tls' /></stream:features>"
+        val.must_match(/stream:stream/)
+
+      when :started
+        state = :tls
+        @stream.expects(:start_tls).never
+        server.send_data "<failure xmlns='urn:ietf:params:xml:ns:xmpp-tls'/></stream:stream>"
+        val.must_match(/starttls/)
+
+      when :tls
+        EM.stop
+        val.must_equal "</stream:stream>"
+
+      else
+        EM.stop
+        false
+
+      end
+    end
+  end
+
+  it 'will fail if a bad node comes through TLS negotiations' do
+    state = nil
+    @client = mock()
+    @client.expects(:call).with do |v|
+      v.must_be_kind_of UnknownResponse
+      v.node.element_name.must_equal 'foo-bar'
+    end
+    mocked_server(3) do |val, server|
+      case state
+      when nil
+        state = :started
+        server.send_data "<?xml version='1.0'?><stream:stream xmlns='jabber:client' xmlns:stream='http://etherx.jabber.org/streams'><stream:features><starttls xmlns='urn:ietf:params:xml:ns:xmpp-tls' /></stream:features>"
+        val.must_match(/stream:stream/)
+
+      when :started
+        state = :tls
+        @stream.expects(:start_tls).never
+        server.send_data "<foo-bar xmlns='urn:ietf:params:xml:ns:xmpp-tls'/></stream:stream>"
+        val.must_match(/starttls/)
+
+      when :tls
+        EM.stop
+        val.must_equal "</stream:stream>"
+
+      else
+        EM.stop
+        false
+
+      end
+    end
+  end
+
+  it 'connects via SASL MD5 when asked' do
+    Time.any_instance.stubs(:to_f).returns(1.1)
+    state = nil
+
+    mocked_server(5) do |val, server|
+      case state
+      when nil
+        state = :started
+        server.send_data "<?xml version='1.0'?><stream:stream xmlns='jabber:client' xmlns:stream='http://etherx.jabber.org/streams'><stream:features><mechanisms xmlns='urn:ietf:params:xml:ns:xmpp-sasl'><mechanism>DIGEST-MD5</mechanism></mechanisms></stream:features>"
+        val.must_match(/stream:stream/)
+
+      when :started
+        state = :auth_sent
+        server.send_data "<challenge xmlns='urn:ietf:params:xml:ns:xmpp-sasl'>cmVhbG09InNvbWVyZWFsbSIsbm9uY2U9Ik9BNk1HOXRFUUdtMmhoIixxb3A9ImF1dGgiLGNoYXJzZXQ9dXRmLTgsYWxnb3JpdGhtPW1kNS1zZXNzCg==</challenge>"
+        val.must_match(/auth.*DIGEST\-MD5/)
+
+      when :auth_sent
+        state = :response1_sent
+        server.send_data "<challenge xmlns='urn:ietf:params:xml:ns:xmpp-sasl'>cnNwYXV0aD1lYTQwZjYwMzM1YzQyN2I1NTI3Yjg0ZGJhYmNkZmZmZAo=</challenge>"
+        val.must_equal('<response xmlns="urn:ietf:params:xml:ns:xmpp-sasl">bm9uY2U9Ik9BNk1HOXRFUUdtMmhoIixjaGFyc2V0PXV0Zi04LHVzZXJuYW1lPSJuIixyZWFsbT0ic29tZXJlYWxtIixjbm9uY2U9Ijc3N2Q0NWJiYmNkZjUwZDQ5YzQyYzcwYWQ3YWNmNWZlIixuYz0wMDAwMDAwMSxxb3A9YXV0aCxkaWdlc3QtdXJpPSJ4bXBwL2QiLHJlc3BvbnNlPTZiNTlhY2Q1ZWJmZjhjZTA0NTYzMGFiMDU2Zjg3MTdm</response>')
+
+      when :response1_sent
+        state = :response2_sent
+        server.send_data "<success xmlns='urn:ietf:params:xml:ns:xmpp-sasl' />"
+        val.must_match(%r{<response xmlns="urn:ietf:params:xml:ns:xmpp-sasl"\s?/>})
+
+      when :response2_sent
+        EM.stop
+        state = :complete
+        val.must_match(/stream:stream/)
+
+      else
+        EM.stop
+        false
+
+      end
+    end
+  end
+
+  it 'will connect via SSL PLAIN when asked' do
+    state = nil
+    mocked_server(3) do |val, server|
+      case state
+      when nil
+        state = :started
+        server.send_data "<?xml version='1.0'?><stream:stream xmlns='jabber:client' xmlns:stream='http://etherx.jabber.org/streams'><stream:features><mechanisms xmlns='urn:ietf:params:xml:ns:xmpp-sasl'><mechanism>PLAIN</mechanism></mechanisms></stream:features>"
+        val.must_match(/stream:stream/)
+
+      when :started
+        state = :auth_sent
+        server.send_data "<success xmlns='urn:ietf:params:xml:ns:xmpp-sasl' />"
+        val.must_equal('<auth xmlns="urn:ietf:params:xml:ns:xmpp-sasl" mechanism="PLAIN">bkBkAG4AcGFzcw==</auth>')
+
+      when :auth_sent
+        EM.stop
+        state = :complete
+        val.must_match(/stream:stream/)
+
+      else
+        EM.stop
+        false
+
+      end
+    end
+  end
+
+  it 'will connect via SSL ANONYMOUS when asked' do
+    state = nil
+
+    mocked_server(3) do |val, server|
+      case state
+      when nil
+        state = :started
+        server.send_data "<?xml version='1.0'?><stream:stream xmlns='jabber:client' xmlns:stream='http://etherx.jabber.org/streams'><stream:features><mechanisms xmlns='urn:ietf:params:xml:ns:xmpp-sasl'><mechanism>ANONYMOUS</mechanism></mechanisms></stream:features>"
+        val.must_match(/stream:stream/)
+
+      when :started
+        state = :auth_sent
+        server.send_data "<success xmlns='urn:ietf:params:xml:ns:xmpp-sasl' />"
+        val.must_equal('<auth xmlns="urn:ietf:params:xml:ns:xmpp-sasl" mechanism="ANONYMOUS">bg==</auth>')
+
+      when :auth_sent
+        EM.stop
+        state = :complete
+        val.must_match(/stream:stream/)
+
+      else
+        EM.stop
+        false
+
+      end
+    end
+  end
+
+  it 'tried each possible mechanism until it fails completely' do
+    state = nil
+    @client = mock()
+    @client.expects(:call).with do |n|
+      n.must_be_kind_of(SASLError)
+      n.must_be_instance_of SASLError::NotAuthorized
+    end
+
+    mocked_server(5) do |val, server|
+      case state
+      when nil
+        state = :started
+        server.send_data "<?xml version='1.0'?><stream:stream xmlns='jabber:client' xmlns:stream='http://etherx.jabber.org/streams'><stream:features><mechanisms xmlns='urn:ietf:params:xml:ns:xmpp-sasl'><mechanism>DIGEST-MD5</mechanism><mechanism>PLAIN</mechanism><mechanism>ANONYMOUS</mechanism></mechanisms></stream:features>"
+        val.must_match(/stream:stream/)
+
+      when :started
+        state = :failed_md5
+        server.send_data "<failure xmlns='urn:ietf:params:xml:ns:xmpp-sasl'><not-authorized /></failure>"
+        val.must_match(/mechanism="DIGEST-MD5"/)
+
+      when :failed_md5
+        state = :failed_plain
+        server.send_data "<failure xmlns='urn:ietf:params:xml:ns:xmpp-sasl'><not-authorized /></failure>"
+        val.must_match(/mechanism="PLAIN"/)
+
+      when :failed_plain
+        state = :failed_anon
+        server.send_data "<failure xmlns='urn:ietf:params:xml:ns:xmpp-sasl'><not-authorized /></failure>"
+        val.must_match(/mechanism="ANONYMOUS"/)
+
+      when :failed_anon
+        EM.stop
+        state = :complete
+        val.must_match(/\/stream:stream/)
+
+      else
+        EM.stop
+        false
+
+      end
+    end
+  end
+
+  it 'tries each mechanism until it succeeds' do
+    state = nil
+    mocked_server(4) do |val, server|
+      case state
+      when nil
+        state = :started
+        server.send_data "<?xml version='1.0'?><stream:stream xmlns='jabber:client' xmlns:stream='http://etherx.jabber.org/streams'><stream:features><mechanisms xmlns='urn:ietf:params:xml:ns:xmpp-sasl'><mechanism>DIGEST-MD5</mechanism><mechanism>PLAIN</mechanism><mechanism>ANONYMOUS</mechanism></mechanisms></stream:features>"
+        val.must_match(/stream:stream/)
+
+      when :started
+        state = :failed_md5
+        server.send_data "<failure xmlns='urn:ietf:params:xml:ns:xmpp-sasl'><not-authorized /></failure>"
+        val.must_match(/mechanism="DIGEST-MD5"/)
+
+      when :failed_md5
+        state = :plain_sent
+        server.send_data "<success xmlns='urn:ietf:params:xml:ns:xmpp-sasl' />"
+        val.must_match(/mechanism="PLAIN"/)
+
+      when :plain_sent
+        EM.stop
+        val.must_match(/stream:stream/)
+
+      else
+        EM.stop
+        false
+
+      end
+    end
+  end
+
+  it 'sends client an error when an unknown mechanism is sent' do
+    @client = mock()
+    @client.expects(:call).with { |v| v.must_be_kind_of(Stream::SASL::UnknownMechanism) }
+    started = false
+    mocked_server(2) do |val, server|
+      if !started
+        started = true
+        server.send_data "<?xml version='1.0'?><stream:stream xmlns='jabber:client' xmlns:stream='http://etherx.jabber.org/streams'>"
+        server.send_data "<stream:features><mechanisms xmlns='urn:ietf:params:xml:ns:xmpp-sasl'><mechanism>UNKNOWN</mechanism></mechanisms></stream:features>"
+        val.must_match(/stream:stream/)
+
+      else
+        EM.stop
+        val.must_match(/failure(.*)invalid\-mechanism/)
+
+      end
+    end
+  end
+
+  %w[ aborted
+      incorrect-encoding
+      invalid-authzid
+      invalid-mechanism
+      mechanism-too-weak
+      not-authorized
+      temporary-auth-failure
+  ].each do |error_type|
+    it "fails on #{error_type}" do
+      @client = mock()
+      @client.expects(:call).with do |n|
+        n.must_be_instance_of SASLError.class_from_registration(error_type)
+      end
+      state = nil
+      mocked_server(3) do |val, server|
+        case state
+        when nil
+          state = :started
+          server.send_data "<?xml version='1.0'?><stream:stream xmlns='jabber:client' xmlns:stream='http://etherx.jabber.org/streams'><stream:features><mechanisms xmlns='urn:ietf:params:xml:ns:xmpp-sasl'><mechanism>PLAIN</mechanism></mechanisms></stream:features>"
+          val.must_match(/stream:stream/)
+
+        when :started
+          state = :auth_sent
+          server.send_data "<failure xmlns='urn:ietf:params:xml:ns:xmpp-sasl'><#{error_type} /></failure>"
+          val.must_equal('<auth xmlns="urn:ietf:params:xml:ns:xmpp-sasl" mechanism="PLAIN">bkBkAG4AcGFzcw==</auth>')
+
+        when :auth_sent
+          EM.stop
+          state = :complete
+          val.must_match(/\/stream:stream/)
+
+        else
+          EM.stop
+          false
+
+        end
+      end
+    end
+  end
+
+  it 'fails when an unkown node comes through during SASL negotiation' do
+    @client = mock()
+    @client.expects(:call).with do |n|
+      n.must_be_instance_of UnknownResponse
+      n.node.element_name.must_equal 'foo-bar'
+    end
+    state = nil
+    mocked_server(3) do |val, server|
+      case state
+      when nil
+        state = :started
+        server.send_data "<?xml version='1.0'?><stream:stream xmlns='jabber:client' xmlns:stream='http://etherx.jabber.org/streams'><stream:features><mechanisms xmlns='urn:ietf:params:xml:ns:xmpp-sasl'><mechanism>PLAIN</mechanism></mechanisms></stream:features>"
+        val.must_match(/stream:stream/)
+
+      when :started
+        state = :auth_sent
+        server.send_data "<foo-bar />"
+        val.must_equal('<auth xmlns="urn:ietf:params:xml:ns:xmpp-sasl" mechanism="PLAIN">bkBkAG4AcGFzcw==</auth>')
+
+      when :auth_sent
+        EM.stop
+        state = :complete
+        val.must_match(/\/stream:stream/)
+
+      else
+        EM.stop
+        false
+
+      end
+    end
+  end
+
+  it 'will bind to a resource set by the server' do
+    state = nil
+    class Client; attr_accessor :jid; end
+    @client = Client.new
+    @jid = JID.new('n@d')
+
+    mocked_server(3) do |val, server|
+      case state
+      when nil
+        state = :started
+        server.send_data "<?xml version='1.0'?><stream:stream xmlns='jabber:client' xmlns:stream='http://etherx.jabber.org/streams'><stream:features><bind xmlns='urn:ietf:params:xml:ns:xmpp-bind' /></stream:features>"
+        val.must_match(/stream:stream/)
+
+      when :started
+        state = :complete
+        val =~ %r{<iq[^>]+id="([^"]+)"}
+        server.send_data "<iq type='result' id='#{$1}'><bind xmlns='urn:ietf:params:xml:ns:xmpp-bind'><jid>#{@jid}/server_resource</jid></bind></iq>"
+        server.send_data "<stream:features><bind xmlns='urn:ietf:params:xml:ns:xmpp-bind' /></stream:features>"
+        val.must_match(%r{<bind xmlns="urn:ietf:params:xml:ns:xmpp-bind"\s?/>})
+
+      when :complete
+        EM.stop
+        @client.jid.must_equal JID.new('n@d/server_resource')
+
+      else
+        EM.stop
+        false
+
+      end
+    end
+  end
+
+  it 'will bind to a resource set by the client' do
+    state = nil
+    class Client; attr_accessor :jid; end
+    @client = Client.new
+    @jid = JID.new('n@d/r')
+
+    mocked_server(3) do |val, server|
+      case state
+      when nil
+        state = :started
+        server.send_data "<?xml version='1.0'?><stream:stream xmlns='jabber:client' xmlns:stream='http://etherx.jabber.org/streams'><stream:features><bind xmlns='urn:ietf:params:xml:ns:xmpp-bind' /></stream:features>"
+        val.must_match(/stream:stream/)
+
+      when :started
+        state = :complete
+        val =~ %r{<iq[^>]+id="([^"]+)"}
+        server.send_data "<iq type='result' id='#{$1}'><bind xmlns='urn:ietf:params:xml:ns:xmpp-bind'><jid>#{@jid}</jid></bind></iq>"
+        server.send_data "<stream:features><bind xmlns='urn:ietf:params:xml:ns:xmpp-bind' /></stream:features>"
+        val.must_match(%r{<bind xmlns="urn:ietf:params:xml:ns:xmpp-bind"><resource>r</resource></bind>})
+
+      when :complete
+        EM.stop
+        @client.jid.must_equal JID.new('n@d/r')
+
+      else
+        EM.stop
+        false
+
+      end
+    end
+  end
+
+  it 'will return an error if resource binding errors out' do
+    state = nil
+    @client = mock()
+    @client.expects(:call).with do |n|
+      n.must_be_instance_of StanzaError::BadRequest
+    end
+    mocked_server(3) do |val, server|
+      case state
+      when nil
+        state = :started
+        server.send_data "<?xml version='1.0'?><stream:stream xmlns='jabber:client' xmlns:stream='http://etherx.jabber.org/streams'><stream:features><bind xmlns='urn:ietf:params:xml:ns:xmpp-bind' /></stream:features>"
+        val.must_match(/stream:stream/)
+
+      when :started
+        state = :complete
+        val =~ %r{<iq[^>]+id="([^"]+)"}
+        server.send_data "<iq type='error' id='#{$1}'><bind xmlns='urn:ietf:params:xml:ns:xmpp-bind'><resource>r</resource></bind><error type='modify'><bad-request xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/></error></iq>"
+        val.must_match(%r{<bind xmlns="urn:ietf:params:xml:ns:xmpp-bind"><resource>r</resource></bind>})
+
+      when :complete
+        EM.stop
+        val.must_match(/\/stream:stream/)
+
+      else
+        EM.stop
+        false
+
+      end
+    end
+  end
+
+  it 'will return an error if an unkown node comes through during resouce binding' do
+    state = nil
+    @client = mock()
+    @client.expects(:call).with do |n|
+      n.must_be_instance_of UnknownResponse
+      n.node.element_name.must_equal 'foo-bar'
+    end
+    mocked_server(3) do |val, server|
+      case state
+      when nil
+        state = :started
+        server.send_data "<?xml version='1.0'?><stream:stream xmlns='jabber:client' xmlns:stream='http://etherx.jabber.org/streams'><stream:features><bind xmlns='urn:ietf:params:xml:ns:xmpp-bind' /></stream:features>"
+        val.must_match(/stream:stream/)
+
+      when :started
+        state = :complete
+        val =~ %r{<iq[^>]+id="([^"]+)"}
+        server.send_data "<foo-bar />"
+        val.must_match(%r{<bind xmlns="urn:ietf:params:xml:ns:xmpp-bind"><resource>r</resource></bind>})
+
+      when :complete
+        EM.stop
+        val.must_match(/\/stream:stream/)
+
+      else
+        EM.stop
+        false
+
+      end
+    end
+  end
+
+  it 'will establish a session if requested' do
+    state = nil
+    @client = mock()
+    @client.expects(:stream_started)
+
+    mocked_server(3) do |val, server|
+      case state
+      when nil
+        state = :started
+        server.send_data "<?xml version='1.0'?><stream:stream xmlns='jabber:client' xmlns:stream='http://etherx.jabber.org/streams'>"
+        server.send_data "<stream:features><session xmlns='urn:ietf:params:xml:ns:xmpp-session' /></stream:features>"
+        val.must_match(/stream:stream/)
+
+      when :started
+        state = :completed
+        server.send_data "<iq from='d' type='result' id='#{val[/id="([^"]+)"/,1]}' />"
+        server.send_data "<stream:features><bind xmlns='urn:ietf:params:xml:ns:xmpp-bind' /></stream:features>"
+        val.must_match(%r{<iq id="[^"]+" type="set" to="d"><session xmlns="urn:ietf:params:xml:ns:xmpp-session"\s?/></iq>})
+
+      when :completed
+        EM.stop
+        true
+
+      else
+        EM.stop
+        false
+
+      end
+    end
+  end
+
+  it 'will return an error if session establishment errors out' do
+    state = nil
+    @client = mock()
+    @client.expects(:call).with do |n|
+      n.must_be_instance_of StanzaError::InternalServerError
+    end
+    mocked_server(3) do |val, server|
+      case state
+      when nil
+        state = :started
+        server.send_data "<?xml version='1.0'?><stream:stream xmlns='jabber:client' xmlns:stream='http://etherx.jabber.org/streams'>"
+        server.send_data "<stream:features><session xmlns='urn:ietf:params:xml:ns:xmpp-session' /></stream:features>"
+        val.must_match(/stream:stream/)
+
+      when :started
+        state = :completed
+        server.send_data "<iq from='d' type='error' id='#{val[/id="([^"]+)"/,1]}'><session xmlns='urn:ietf:params:xml:ns:xmpp-session'/><error type='wait'><internal-server-error xmlns='urn:ietf:params:xml:ns:xmpp-stanzas'/></error></iq>"
+        val.must_match(%r{<iq id="[^"]+" type="set" to="d"><session xmlns="urn:ietf:params:xml:ns:xmpp-session"\s?/></iq>})
+
+      when :completed
+        EM.stop
+        val.must_match(/\/stream:stream/)
+
+      else
+        EM.stop
+        false
+
+      end
+    end
+  end
+
+  it 'will return an error if an unknown node come through during session establishment' do
+    state = nil
+    @client = mock()
+    @client.expects(:call).with do |n|
+      n.must_be_instance_of UnknownResponse
+      n.node.element_name.must_equal 'foo-bar'
+    end
+    mocked_server(3) do |val, server|
+      case state
+      when nil
+        state = :started
+        server.send_data "<?xml version='1.0'?><stream:stream xmlns='jabber:client' xmlns:stream='http://etherx.jabber.org/streams'>"
+        server.send_data "<stream:features><session xmlns='urn:ietf:params:xml:ns:xmpp-session' /></stream:features>"
+        val.must_match(/stream:stream/)
+
+      when :started
+        state = :completed
+        server.send_data '<foo-bar />'
+        val.must_match(%r{<iq id="[^"]+" type="set" to="d"><session xmlns="urn:ietf:params:xml:ns:xmpp-session"\s?/></iq>})
+
+      when :completed
+        EM.stop
+        val.must_match(/\/stream:stream/)
+
+      else
+        EM.stop
+        false
+
+      end
+    end
+  end
+
+  it 'sends client an error on parse error' do
+    @client = mock()
+    @client.expects(:call).with do |v|
+      v.must_be_kind_of ParseError
+      v.message.must_match(/generate\-parse\-error/)
+    end
+    state = nil
+    mocked_server(3) do |val, server|
+      case state
+      when nil
+        state = :started
+        server.send_data "<?xml version='1.0'?><stream:stream xmlns='jabber:client' xmlns:stream='http://etherx.jabber.org/streams' version='1.0'>"
+        server.send_data "<stream:features><bind xmlns='urn:ietf:params:xml:ns:xmpp-bind' /></stream:features>"
+        val.must_match(/stream:stream/)
+
+      when :started
+        state = :parse_error
+        server.send_data "</generate-parse-error>"
+
+      when :parse_error
+        EM.stop
+        val.must_equal "</stream:stream>"
+
+      else
+        EM.stop
+        false
+
+      end
+    end
+  end
+end