RubyGems - jabber4r-revive - Versions diffs - 0.9.0 - Mend

jabber4r-revive 0.9.0

Files changed (33) hide show

data/.gitignore +4 -0
data/.rspec +3 -0
data/.travis.yml +8 -0
data/CHANGELOG +45 -0
data/Gemfile +3 -0
data/Gemfile.lock +45 -0
data/LICENSE +12 -0
data/README.md +29 -0
data/Rakefile +71 -0
data/jabber4r-revive.gemspec +25 -0
data/lib/jabber4r/bosh_session.rb +224 -0
data/lib/jabber4r/connection.rb +258 -0
data/lib/jabber4r/debugger.rb +61 -0
data/lib/jabber4r/jid.rb +125 -0
data/lib/jabber4r/protocol/iq.rb +260 -0
data/lib/jabber4r/protocol/message.rb +246 -0
data/lib/jabber4r/protocol/parsed_xml_element.rb +208 -0
data/lib/jabber4r/protocol/presence.rb +160 -0
data/lib/jabber4r/protocol/xml_element.rb +144 -0
data/lib/jabber4r/protocol.rb +257 -0
data/lib/jabber4r/rexml_1.8_patch.rb +16 -0
data/lib/jabber4r/roster.rb +322 -0
data/lib/jabber4r/session.rb +615 -0
data/lib/jabber4r/vcard.rb +42 -0
data/lib/jabber4r/version.rb +3 -0
data/lib/jabber4r.rb +33 -0
data/spec/lib/jabber4r/bosh_session_spec.rb +150 -0
data/spec/lib/jabber4r/connection_spec.rb +174 -0
data/spec/lib/jabber4r/debugger_spec.rb +36 -0
data/spec/lib/jabber4r/jid_spec.rb +198 -0
data/spec/spec_helper.rb +11 -0
data/spec/support/mocks/tcp_socket_mock.rb +8 -0
metadata +151 -0

data/lib/jabber4r/vcard.rb ADDED Viewed

@@ -0,0 +1,42 @@
+# License: see LICENSE.txt
+#  Jabber4R - Jabber Instant Messaging Library for Ruby
+#  Copyright (C) 2002  Rich Kilmer <rich@infoether.com>
+#
+module Jabber
+  ##
+  # The VCard class holds the parsed VCard data from the Jabber service.
+  #
+  class VCard
+    attr_accessor :given, :family, :middle, :nickname, :email
+    ##
+    # Factory to create the VCard from the ParsedXMLElement
+    #
+    # je:: [ParsedXMLElement] The VCard as an xml element.
+    # return:: [Jabber::VCard] The newly created VCard.
+    #
+    def VCard.from_element(je)
+      card = VCard.new
+      return card unless je
+      card.given = je.N.GIVEN.element_data
+      card.family = je.N.FAMILY.element_data
+      card.middle = je.N.MIDDLE.element_data
+      card.email = je.EMAIL.element_data
+      card.nickname = je.NICKNAME.element_data
+      return card
+    end
+    ##
+    # Dumps the attributes of the VCard
+    #
+    # return:: [String] The VCard as a string.
    #
+    def to_s
+      "VCARD: [first=#{@given} last=#{@family} nick=#{@nickname} email=#{@email}]"
+    end
+  end
+end

data/lib/jabber4r/version.rb ADDED Viewed

@@ -0,0 +1,3 @@
+module Jabber
+  VERSION = "0.9.0"
+end

data/lib/jabber4r.rb ADDED Viewed

@@ -0,0 +1,33 @@
+# License: see LICENSE.txt
+# Jabber4R - Jabber Instant Messaging Library for Ruby
+# Copyright (C) 2002  Rich Kilmer <rich@infoether.com>
+# The Jabber module is the main namespace for all Jabber modules
+# and classes.
+module Jabber
+  DEBUG = false
+  # Public: Should raise if connection was force closed
+  class ConnectionForceCloseError < StandardError; end
+  # Public: Should raise if received XML data is malformed
+  class XMLMalformedError < StandardError; end
+  # Public: Should raise if authentication failed
+  class AuthenticationError < StandardError; end
+end
+require "jabber4r/debugger"
+require "jabber4r/session"
+require "jabber4r/bosh_session"
+require "jabber4r/protocol"
+require "jabber4r/connection"
+require "jabber4r/protocol/iq"
+require "jabber4r/protocol/presence"
+require "jabber4r/protocol/message"
+require "jabber4r/protocol/xml_element"
+require "jabber4r/protocol/parsed_xml_element"
+require "jabber4r/roster"
+require "jabber4r/jid"
+require "jabber4r/vcard"

data/spec/lib/jabber4r/bosh_session_spec.rb ADDED Viewed

@@ -0,0 +1,150 @@
+# coding: utf-8
+require "spec_helper"
+describe Jabber::BoshSession do
+  let(:successful_login) { '<body xmlns="http://jabber.org/protocol/httpbind"><iq type="result" xmlns="jabber:client" id="2034"/></body>' }
+  let(:successful_open_stream) do
+    [
+      '<body xmlns="http://jabber.org/protocol/httpbind" xmlns:xmpp="urn:xmpp:xbosh" xmlns:stream="http://etherx.jabber.org/streams"',
+      'authid="3780309894" sid="ce21410" from="localhost"',
+      'wait="60" requests="2" inactivity="30" maxpause="120" polling="2" ver="1.8" secure="true" />'
+    ].join " "
+  end
+  let(:is_open_stream?) { ->(data) { x = Ox.parse(data); ["1", "localhost"] == [x[:rid], x[:to]] } }
+  let(:is_login?) { ->(data) { x = Ox.parse(data); ["1", "ce21410"] == [x[:rid], x[:sid]] } }
+  let(:bosh_session) { described_class.bind("strech@localhost/resource", "password") }
+  before { Jabber::BoshSession.any_instance.stub(:generate_next_rid).and_return "1" }
+  describe "#bind" do
+    context "when session successfuly binded" do
+      before do
+        stub_request(:post, "http://localhost:5280/http-bind")
+          .with(body: is_open_stream?)
+          .to_return(body: successful_open_stream)
+        stub_request(:post, "http://localhost:5280/http-bind")
+          .with(body: is_login?)
+          .to_return(body: successful_login)
+      end
+      it { expect(bosh_session).to be_alive }
+    end
+    context "when couldn't open stream" do
+      context "when response body missed authid attribute" do
+        let(:malformed_body) { '<body xmlns="http://jabber.org/protocol/httpbind" sid="ce21410" />' }
+        before do
+          stub_request(:post, "http://localhost:5280/http-bind")
+            .with(body: is_open_stream?)
+            .to_return(body: malformed_body)
+          WebMock.should_not have_requested(:post, "http://localhost:5280/http-bind")
+            .with(body: is_login?)
+        end
+        it { expect { bosh_session }.to raise_error Jabber::XMLMalformedError, "Couldn't find <body /> attribute [authid]" }
+      end
+      context "when response body missed sid attribute" do
+        let(:malformed_body) { '<body xmlns="http://jabber.org/protocol/httpbind" authid="3780309894" />' }
+        before do
+          stub_request(:post, "http://localhost:5280/http-bind")
+            .with(body: is_open_stream?)
+            .to_return(body: malformed_body)
+          WebMock.should_not have_requested(:post, "http://localhost:5280/http-bind")
+            .with(body: is_login?)
+        end
+        it { expect { bosh_session }.to raise_error Jabber::XMLMalformedError, "Couldn't find <body /> attribute [sid]" }
+      end
+      context "when response was not 200 OK" do
+        before do
+          stub_request(:post, "http://localhost:5280/http-bind")
+            .with(body: is_open_stream?)
+            .to_return(body: "Foo", status: 401)
+          WebMock.should_not have_requested(:post, "http://localhost:5280/http-bind")
+            .with(body: is_login?)
+        end
+        it { expect { bosh_session }.to raise_error Net::HTTPBadResponse }
+      end
+    end
+    context "when couldn't login in opened stream" do
+      context "when response is a malformed xml without IQ tag" do
+        let(:malformed_body) { '<body xmlns="http://jabber.org/protocol/httpbind"></body>' }
+        before do
+          stub_request(:post, "http://localhost:5280/http-bind")
+            .with(body: is_open_stream?)
+            .to_return(body: successful_open_stream)
+          stub_request(:post, "http://localhost:5280/http-bind")
+            .with(body: is_login?)
+            .to_return(body: malformed_body)
+        end
+        it { expect { bosh_session }.to raise_error Jabber::XMLMalformedError, "Couldn't find xml tag <iq/>" }
+      end
+      context "when response has type not equal 'result'" do
+        let(:malformed_body) { '<body xmlns="http://jabber.org/protocol/httpbind"><iq type="error" xmlns="jabber:client" id="2034"/></body>' }
+        before do
+          stub_request(:post, "http://localhost:5280/http-bind")
+            .with(body: is_open_stream?)
+            .to_return(body: successful_open_stream)
+          stub_request(:post, "http://localhost:5280/http-bind")
+            .with(body: is_login?)
+            .to_return(body: malformed_body)
+        end
+        it { expect { bosh_session }.to raise_error Jabber::AuthenticationError, "Failed to login" }
+      end
+      context "when response was not 200 OK" do
+        before do
+          stub_request(:post, "http://localhost:5280/http-bind")
+            .with(body: is_open_stream?)
+            .to_return(body: successful_open_stream)
+          stub_request(:post, "http://localhost:5280/http-bind")
+            .with(body: is_login?)
+            .to_return(body: "Foo", status: 401)
+        end
+        it { expect { bosh_session }.to raise_error Net::HTTPBadResponse }
+      end
+    end
+  end
+  describe "#to_json" do
+    let(:json) { JSON.parse(bosh_session.to_json) }
+    before do
+      stub_request(:post, "http://localhost:5280/http-bind")
+        .with(body: is_open_stream?)
+        .to_return(body: successful_open_stream)
+      stub_request(:post, "http://localhost:5280/http-bind")
+        .with(body: is_login?)
+        .to_return(body: successful_login)
+    end
+    it { expect(json).to have_key "jid" }
+    it { expect(json).to have_key "rid" }
+    it { expect(json).to have_key "sid" }
+    it { expect(json["jid"]).to eq "strech@localhost/resource"}
+    it { expect(json["rid"]).to eq "1"}
+    it { expect(json["sid"]).to eq "ce21410"}
+  end
+end

data/spec/lib/jabber4r/connection_spec.rb ADDED Viewed

@@ -0,0 +1,174 @@
+# coding: utf-8
+require "spec_helper"
+describe Jabber::Connection do
+  let(:socket) { TCPSocketMock.new }
+  let(:connection) { described_class.new "localhost" }
+  before { TCPSocket.stub(:new).and_return socket }
+  describe "#connect" do
+    before { connection.connect }
+    it { expect(connection).to be_connected }
+    it { expect(connection.poll_thread).to be_alive }
+    it { expect(connection.parser_thread).to be_alive }
+    it { expect(connection.socket).not_to be_closed }
+  end
+  describe "#close" do
+    before { connection.connect }
+    before { connection.close; sleep 0.01 }
+    it { expect(connection).to be_disconnected }
+    it { expect(connection.poll_thread).not_to be_alive }
+    it { expect(connection.parser_thread).not_to be_alive }
+    it { expect(connection.socket).to be_closed }
+  end
+  describe "#add_filter" do
+    context "when filter name and block is given" do
+      before { connection.add_filter("hello") { 1 } }
+      it { expect(connection.filters).to have_key "hello" }
+    end
+    context "when only filter name give" do
+      it { expect { connection.add_filter("hello") }.to raise_error ArgumentError }
+    end
+  end
+  describe "#remove_filter" do
+    before { connection.add_filter("hello") { 1 } }
+    it { expect(connection.filters).to have_key "hello" }
+    it "should remove filter" do
+      connection.remove_filter("hello")
+      expect(connection.filters).not_to have_key "hello"
+    end
+  end
+  describe "#send" do
+    let(:handler) { proc { 1 } }
+    before { connection.connect }
+    before { Thread.stub(:current).and_return "current" }
+    context "when own handler is given" do
+      before { connection.send("hello", handler) }
+      it { expect(connection.handlers).to have_key "current" }
+      it { expect(connection.handlers["current"]).to eq handler }
+      describe "socket" do
+        it { expect(socket.to_s).to eq "hello" }
+      end
+    end
+    context "when only block is given" do
+      before { connection.send("hello") { 1 } }
+      it { expect(connection.handlers).to have_key "current" }
+    end
+    context "when handler and block are given" do
+      before { connection.send("hello", handler) { 1 } }
+      it { expect(connection.handlers).to have_key "current" }
+      it { expect(connection.handlers["current"]).to eq handler }
+    end
+    context "when no handlers and block are given" do
+      before { connection.send("hello") }
+      it { expect(connection.handlers).to be_empty }
+    end
+  end
+  describe "#receive" do
+    let(:thread) { double("Pseudo thread", alive?: true) }
+    let(:element) { double("XML Element", element_consumed?: false) }
+    let(:consume) { ->(element) { element.stub(:element_consumed?).and_return true } }
+    let(:skip) { ->(element) { element.stub(:element_consumed?).and_return false } }
+    before { connection.stub :register_parsing_thread }
+    before { connection.stub :register_polling_thread }
+    context "when handlers are not empty" do
+      context "when filters are empty" do
+        before do
+          thread.should_receive(:wakeup)
+          connection.stub(:handlers).and_return({thread => consume})
+          connection.receive(element)
+        end
+        it { expect(connection.handlers).to be_empty }
+        it { expect(connection.filters).to be_empty }
+      end
+      context "when filters are not empty" do
+        context "when handler consume element" do
+          before do
+            thread.should_receive(:wakeup)
+            skip.should_not_receive(:call)
+            connection.stub(:handlers).and_return({thread => consume})
+            connection.stub(:filters).and_return({f1: skip})
+            connection.receive(element)
+          end
+          it { expect(connection.handlers).to be_empty }
+          it { expect(connection.filters).not_to be_empty }
+        end
+        context "when handler doesn't consume element" do
+          before do
+            thread.should_not_receive(:wakeup)
+            consume.should_receive(:call).and_call_original
+            connection.stub(:handlers).and_return({thread => skip})
+            connection.stub(:filters).and_return({f1: consume})
+            connection.receive(element)
+          end
+          it { expect(connection.handlers).not_to be_empty }
+          it { expect(connection.filters).not_to be_empty }
+        end
+      end
+    end
+    context "when handlers are empty" do
+      context "when filters are empty" do
+        before do
+          thread.should_not_receive(:wakeup)
+          connection.should_receive(:wait_for_consume?).and_return false
+          connection.receive(element)
+        end
+        it { expect(connection.handlers).to be_empty }
+        it { expect(connection.filters).to be_empty }
+      end
+      context "when filters are not empty" do
+        before do
+          thread.should_not_receive(:wakeup)
+          consume.should_receive(:call).and_call_original
+          connection.stub(:filters).and_return({f1: consume})
+          connection.receive(element)
+        end
+        it { expect(connection.handlers).to be_empty }
+        it { expect(connection.filters).not_to be_empty }
+      end
+    end
+    # TODO : When socket is empty?
+  end
+end

data/spec/lib/jabber4r/debugger_spec.rb ADDED Viewed

@@ -0,0 +1,36 @@
+# coding: utf-8
+require "spec_helper"
+describe Jabber::Debugger do
+  let(:debugger) { described_class.clone.instance }
+  before { described_class.stub(:instance).and_return debugger }
+  describe "#initialize" do
+    it { expect(described_class).not_to be_enabled }
+  end
+  describe "#enable" do
+    before { described_class.enable! }
+    it { expect(described_class).to be_enabled }
+  end
+  describe "#disable" do
+    before { described_class.disable! }
+    it { expect(described_class).not_to be_enabled }
+  end
+  describe "#logger=" do
+    let(:logger) { double("Logger") }
+    before { described_class.logger = logger }
+    it { expect(debugger.logger).to eq logger }
+  end
+  describe "generated methods" do
+    it { expect(described_class).to respond_to :warn }
+    it { expect(described_class).to respond_to :info }
+    it { expect(described_class).to respond_to :debug }
+  end
+end

data/spec/lib/jabber4r/jid_spec.rb ADDED Viewed

@@ -0,0 +1,198 @@
+# coding: utf-8
+require "spec_helper"
+describe Jabber::JID do
+  describe "#initialize" do
+    context "when need parse jid from string" do
+      context "when only node given" do
+        it { expect { described_class.new "user" }.to raise_error ArgumentError }
+      end
+      context "when node and host given" do
+        subject { described_class.new "user@localhost" }
+        its(:node) { should eq "user" }
+        its(:host) { should eq "localhost" }
+        its(:resource) { should be_nil }
+      end
+      context "when node, host and resource given" do
+        subject { described_class.new "user@localhost/attach" }
+        its(:node) { should eq "user" }
+        its(:host) { should eq "localhost" }
+        its(:resource) { should eq "attach" }
+      end
+      context "when empty string given" do
+        it { expect { described_class.new "" }.to raise_error ArgumentError }
+      end
+    end
+    context "when extra arguments given" do
+      context "when only host given" do
+        subject { described_class.new "user", "localhost" }
+        its(:node) { should eq "user" }
+        its(:host) { should eq "localhost" }
+      end
+      context "when host and resource given" do
+        subject { described_class.new "user", "localhost", "attach" }
+        its(:node) { should eq "user" }
+        its(:host) { should eq "localhost" }
+        its(:resource) { should eq "attach" }
+      end
+      context "when node is fully loaded and host, resource given" do
+        subject { described_class.new "user@example.com/bind", "localhost", "attach" }
+        its(:node) { should eq "user" }
+        its(:host) { should eq "localhost" }
+        its(:resource) { should eq "attach" }
+      end
+    end
+  end
+  describe "#strip" do
+    subject { described_class.new(args).strip }
+    context "when JID has no resource" do
+      let(:args) { "strech@localhost" }
+      its(:to_s) { should eq "strech@localhost" }
+    end
+    context "when JID has no resource" do
+      let(:args) { "strech@localhost/pewpew" }
+      its(:to_s) { should eq "strech@localhost" }
+    end
+  end
+  describe "#strip!" do
+    subject { described_class.new(args).strip! }
+    context "when JID has no resource" do
+      let(:args) { "strech@localhost" }
+      its(:to_s) { should eq "strech@localhost" }
+      its(:resource) { should be_nil }
+    end
+    context "when JID has no resource" do
+      let(:args) { "strech@localhost/pewpew" }
+      its(:to_s) { should eq "strech@localhost" }
+      its(:resource) { should be_nil }
+    end
+  end
+  describe "#hash" do
+    let(:hash) { "strech@pewpew/one".hash }
+    subject { described_class.new "strech@pewpew/one" }
+    its(:hash) { should eq hash }
+  end
+  describe "#to_s" do
+    context "when only host and domain exists" do
+      subject { described_class.new("strech", "localhost").to_s }
+      it { should eq "strech@localhost" }
+    end
+    context "when only host and domain exists" do
+      subject { described_class.new("strech", "localhost", "attach-resource").to_s }
+      it { should eq "strech@localhost/attach-resource" }
+    end
+  end
+  describe "#==" do
+    subject { jid1 == jid2 }
+    context "when jids are equal" do
+      let(:jid1) { described_class.new "strech@localhost" }
+      let(:jid2) { described_class.new "strech@localhost" }
+      it { should be_true }
+    end
+    context "when jids are not equal" do
+      let(:jid1) { described_class.new "strech@localhost" }
+      let(:jid2) { described_class.new "strech@localhost/resource1" }
+      it { should be_false }
+    end
+  end
+  describe "#same?" do
+    subject { jid1.same? jid2 }
+    context "when jids are equal" do
+      context "when jid1 and jid2 has no resource" do
+        let(:jid1) { described_class.new "strech@localhost" }
+        let(:jid2) { described_class.new "strech@localhost" }
+        it { should be_true }
+      end
+      context "when jid1 has resource, but jid2 not" do
+        let(:jid1) { described_class.new "strech@localhost/pewpew" }
+        let(:jid2) { described_class.new "strech@localhost" }
+        it { should be_true }
+      end
+      context "when jid1 and jid2 has resources" do
+        let(:jid1) { described_class.new "strech@localhost/pewpew" }
+        let(:jid2) { described_class.new "strech@localhost/hola" }
+        it { should be_true }
+      end
+    end
+    context "when jids are not equal" do
+      context "when jid1 and jid2 has no resource" do
+        let(:jid1) { described_class.new "strech@localhost" }
+        let(:jid2) { described_class.new "strech@gmail.com" }
+        it { should be_false }
+      end
+      context "when jid1 has resource, but jid2 not" do
+        let(:jid1) { described_class.new "strech@localhost/pewpew" }
+        let(:jid2) { described_class.new "strech@gmail.com" }
+        it { should be_false }
+      end
+      context "when jid1 and jid2 has resources" do
+        let(:jid1) { described_class.new "strech@localhost/pewpew" }
+        let(:jid2) { described_class.new "strech@gmail.com/hola" }
+        it { should be_false }
+      end
+    end
+  end
+  describe "::to_jid" do
+    subject { Jabber::JID.to_jid jid }
+    context "when jid is a Jabber::JID" do
+      let(:jid) { described_class.new "strech@localhost" }
+      its(:object_id) { should eq jid.object_id }
+      its(:to_s) { should eq "strech@localhost" }
+    end
+    context "when jid is a String" do
+      let(:jid) { "strech@localhost/resource" }
+      its(:object_id) { should_not eq jid.object_id }
+      its(:to_s) { should eq "strech@localhost/resource" }
+    end
+  end
+end