jabber4r-revive 0.9.0 → 0.10.0

data/spec/lib/jabber4r/connection_spec.rb

@@ -1,174 +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
+# 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

@@ -1,36 +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
+# 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

@@ -1,198 +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
+# 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 domain given" do
+        subject { described_class.new "user@localhost" }
+
+        its(:node) { should eq "user" }
+        its(:domain) { should eq "localhost" }
+        its(:resource) { should be_nil }
+      end
+
+      context "when node, domain and resource given" do
+        subject { described_class.new "user@localhost/attach" }
+
+        its(:node) { should eq "user" }
+        its(:domain) { 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 domain given" do
+        subject { described_class.new "user", "localhost" }
+
+        its(:node) { should eq "user" }
+        its(:domain) { should eq "localhost" }
+      end
+
+      context "when domain and resource given" do
+        subject { described_class.new "user", "localhost", "attach" }
+
+        its(:node) { should eq "user" }
+        its(:domain) { should eq "localhost" }
+        its(:resource) { should eq "attach" }
+      end
+
+      context "when node is fully loaded and domain, resource given" do
+        subject { described_class.new "user@example.com/bind", "localhost", "attach" }
+
+        its(:node) { should eq "user" }
+        its(:domain) { 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 domain and domain exists" do
+      subject { described_class.new("strech", "localhost").to_s }
+
+      it { should eq "strech@localhost" }
+    end
+
+    context "when only domain 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