spectra-xmpp4r-observable 0.5.1

data/test/simple_observer.rb

@@ -0,0 +1,28 @@
+class Observer
+	attr_accessor :delete
+	attr_reader :last, :last_args
+	def initialize(name, time = 0)
+		@name = name
+		@last = ""
+		@last_args = []
+		@delete = false
+		@time = time
+	end
+
+	def update(thing, *args)
+		sleep @time if @time > 0
+		@last = "#{@name}: got an update on #{thing} with args = #{args.join(', ')}"
+		@last_args = args
+		return :delete_me if @delete
+	end
+
+	def check(str)
+		@last == str
+	end
+
+	def clear
+		@last.clear if @last.respond_to?(:clear)
+		@last_args.clear if @last_args.respond_to?(:clear)
+	end
+end
+

data/test/tc_observable_thing.rb

@@ -0,0 +1,211 @@
+$: <<  File.dirname(__FILE__) + "/../lib"
+require 'test/unit'
+require 'observable_thing'
+require 'simple_observer.rb'
+
+class TestObservableThing < Test::Unit::TestCase
+	include ObservableThing
+
+	def setup
+		@observer1 = Observer.new("observer 1")
+		@observer2 = Observer.new("observer 2")
+		@observer3 = Observer.new("observer 3", 10)
+	end
+
+	def teardown
+		@things.clear if defined? @things
+		@things_counter.clear if defined? @things_counter
+		@things_state.clear if defined? @things_state
+	end
+
+	def test_add_observer
+		self.add_observer(:one_thing, @observer1)
+		assert @things.include?(:one_thing)
+		assert @things[:one_thing].include?(@observer1)
+		assert_equal :update, @things[:one_thing][@observer1]
+
+		self.add_observer(:other_thing, @observer2)
+		assert @things.include?(:other_thing)
+		assert @things[:other_thing].include?(@observer2)
+		assert_equal :update, @things[:other_thing][@observer2]
+
+		assert_raise(NoMethodError) {
+			self.add_observer(:other_thing, @observer1, :no_method)
+		}
+	end
+
+	def test_delete_observer
+		self.add_observer(:one_thing, @observer1)
+
+		assert @things[:one_thing].include?(@observer1)
+		self.delete_observer(:one_thing, @observer1)
+		assert ! @things[:one_thing].include?(@observer1)
+	end
+
+	def test_delete_observers
+		self.add_observer(:one_thing, @observer1)
+		self.add_observer(:one_thing, @observer2)
+		self.add_observer(:other_thing, @observer1)
+
+		assert @things[:one_thing].include?(@observer1)
+		assert @things[:one_thing].include?(@observer2)
+		assert @things[:other_thing].include?(@observer1)
+		self.delete_observers(:one_thing)
+		assert ! @things[:one_thing].include?(@observer1)
+		assert ! @things[:one_thing].include?(@observer2)
+		assert @things[:other_thing].include?(@observer1)
+
+		self.add_observer(:one_thing, @observer1)
+		self.add_observer(:one_thing, @observer2)
+		assert ! @things.empty?
+		self.delete_observers
+		assert @things.empty?
+	end
+
+	def test_count_observers
+		self.add_observer(:one_thing, @observer1)
+		self.add_observer(:one_thing, @observer2)
+		self.add_observer(:other_thing, @observer1)
+
+		assert_equal 3, self.count_observers
+		assert_equal 2, self.count_observers(:one_thing)
+		assert_equal 1, self.count_observers(:other_thing)
+	end
+
+	def test_count_notifications
+		self.add_observer(:one_thing, @observer1)
+
+		assert_equal 0, self.count_notifications(:no_thing)
+		assert_equal 0, self.count_notifications(:one_thing)
+
+		self.changed(:one_thing)
+		self.notify_observers(:one_thing, :something)
+
+		assert_equal 0, self.count_notifications(:no_thing)
+		assert_equal 1, self.count_notifications(:one_thing)
+
+		self.changed(:no_thing)
+		self.notify_observers(:no_thing, :something)
+
+		assert_equal 0, self.count_notifications(:no_thing)
+	end
+
+	def test_changed
+		assert ! self.changed?(:something)
+		self.changed(:something)
+		assert self.changed?(:something)
+	end
+
+	def test_notify_observers
+		self.add_observer(:one_thing, @observer1)
+		self.add_observer(:one_thing, @observer2)
+		self.add_observer(:other_thing, @observer1)
+		assert @observer1.check("")
+		assert @observer2.check("")
+
+		self.changed(:one_thing)
+		self.notify_observers(:one_thing, "test")
+		self.wait_notifications
+		assert @observer1.check("observer 1: got an update on one_thing with args = test")
+		assert @observer2.check("observer 2: got an update on one_thing with args = test")
+
+		self.changed(:other_thing)
+		self.notify_observers(:other_thing, "foo", "bar")
+		self.wait_notifications
+		assert @observer1.check("observer 1: got an update on other_thing with args = foo, bar")
+		assert @observer2.check("observer 2: got an update on one_thing with args = test")
+
+		@observer2.delete = true
+		self.changed(:one_thing)
+		self.notify_observers(:one_thing, "foo", "bar")
+		self.wait_notifications
+		assert @observer2.check("observer 2: got an update on one_thing with args = foo, bar")
+		assert @observer1.check("observer 1: got an update on one_thing with args = foo, bar")
+
+		self.changed(:one_thing)
+		self.notify_observers(:one_thing, "fooo", "barr")
+		self.wait_notifications
+		assert @observer2.check("observer 2: got an update on one_thing with args = foo, bar")
+		assert @observer1.check("observer 1: got an update on one_thing with args = fooo, barr")
+
+	end
+
+	def test_pending_notifications?
+		self.add_observer(:delayed_thing, @observer3)
+		1.upto(3) do
+			self.changed(:delayed_thing)
+			self.notify_observers(:delayed_thing, "foo bar")
+		end
+		assert self.pending_notifications?, "should have notifications pending"
+		sleep 15
+		assert ! self.pending_notifications?, "should not have anything pending"
+	end
+
+	def test_wait_notifications
+		time = Time.now
+		self.add_observer(:delayed_thing, @observer3)
+		self.changed(:delayed_thing)
+		self.notify_observers(:delayed_thing, "foo bar")
+		self.wait_notifications
+		dif = Time.now - time
+		assert dif >= 10, "should take around 10 seconds"
+		assert dif < 12, "should not take so long"
+	end
+
+end
+
+class TestQObserver < Test::Unit::TestCase
+
+	def setup
+		@qobserver = QObserver.new
+	end
+
+	def teardown
+		@qobserver = nil
+	end
+
+	def test_queues
+		assert @qobserver.queues.empty?
+		@qobserver.update(:thing1, 123)
+		assert_equal 1, @qobserver.queues.length
+		@qobserver.update(:thing2, 123)
+		assert @qobserver.queues.include?(:thing1)
+		assert @qobserver.queues.include?(:thing2)
+	end
+
+	def test_received?
+		assert ! @qobserver.received?(:thing1)
+		@qobserver.update(:thing1, 123)
+		assert @qobserver.received?(:thing1)
+		extract = @qobserver.received(:thing1)
+		assert ! @qobserver.received?(:thing1)
+	end
+
+	def test_received
+		@qobserver.update(:thing1, 123)
+		@qobserver.update(:thing1, 456)
+		assert ! @qobserver.received?(:nothing)
+		extract = @qobserver.received(:thing1)
+		assert_kind_of Array, extract
+		assert extract.include?([123])
+		assert extract.include?([456])
+		assert ! @qobserver.received?(:thing1)
+
+		@qobserver.update(:thing1, 789)
+		@qobserver.update(:thing1, 890)
+		
+		@qobserver.received(:thing1) do |arg|
+			assert [[789], [890]].include?(arg)
+		end
+	end
+
+	def test_size
+		@qobserver.update(:thing1, 123)
+		assert_equal 1, @qobserver.size(:thing1)
+		assert_equal 0, @qobserver.size(:thing2)
+
+		@qobserver.received(:thing1)
+		assert_equal 0, @qobserver.size(:thing1)
+	end
+
+end

data/test/tc_thread_store.rb

@@ -0,0 +1,75 @@
+$: <<  File.dirname(__FILE__) + "/../lib"
+require 'test/unit'
+require 'thread_store'
+
+class TestThreadStore < Test::Unit::TestCase
+	def setup
+		@ts = ThreadStore.new
+	end
+
+	def teardown
+		@ts.kill!
+	end
+
+	def test_initialize
+		ts1 = ThreadStore.new
+		assert_equal 100, ts1.max
+
+		ts2 = ThreadStore.new(50)
+		assert_equal 50, ts2.max
+
+		ts3 = ThreadStore.new(0)
+		assert_equal 0, ts3.max
+
+		ts4 = ThreadStore.new(-1)
+		assert_equal 0, ts4.max
+	end
+
+	def test_add_more_than_max
+		@ts = ThreadStore.new
+		1.upto(200) do |n|
+			@ts.add Thread.new { sleep 10 while true }
+		end
+		assert @ts.size <= @ts.max
+		@ts.add Thread.new { sleep 10 while true }
+		assert @ts.size <= @ts.max
+		@ts.kill!
+
+		@ts = ThreadStore.new(0)
+		1.upto(200) do |n|
+			@ts.add Thread.new { sleep 10 while true }
+		end
+		assert 200, @ts.size
+	end
+
+	def test_auto_kill
+		@ts = ThreadStore.new(10)
+		1.upto(10) do |n|
+			@ts.add Thread.new { sleep 10 }
+		end
+		assert_equal 10, @ts.size
+		sleep 15
+		assert_equal 0, @ts.size
+	end
+
+	def test_kill!
+		@ts = ThreadStore.new(10)
+		1.upto(10) do |n|
+			@ts.add Thread.new { sleep 10 }
+		end
+		assert_equal 10, @ts.size
+		@ts.kill!
+		assert_equal 0, @ts.size
+	end
+
+	def test_keep
+		@ts = ThreadStore.new(0)
+		1.upto(100) do |n|
+			@ts.add Thread.new { sleep 10 while true }
+		end
+		assert_equal 100, @ts.size
+		@ts.keep(50)
+		assert_equal 50, @ts.size
+	end
+
+end

data/test/tc_xmpp4r-observable.rb

@@ -0,0 +1,178 @@
+$: <<  File.dirname(__FILE__)
+$: <<  File.dirname(__FILE__) + "/../lib"
+require 'test/unit'
+require 'timeout'
+require 'xmpp4r-observable'
+require 'simple_observer'
+
+class TestJabberObservable < Test::Unit::TestCase
+	def setup
+		@@connections ||= {}
+
+		if @@connections.include?(:client1)
+			@client1 = @@connections[:client1]
+			@client2 = @@connections[:client2]
+			@client1.subs.accept = true
+			@client2.subs.accept = true
+			@jid1_raw = @@connections[:jid1_raw]
+			@jid2_raw = @@connections[:jid2_raw]
+			@jid1 = @jid1_raw.strip.to_s
+			@jid2 = @jid2_raw.strip.to_s
+			@domain1 = @jid1_raw.domain
+			@domain2 = @jid2_raw.domain
+			@message_observer = Observer.new("message_observer")
+			@subscription_observer = Observer.new("subscription_observer")
+			return true
+		end
+
+		logins = []
+		begin
+			logins = File.readlines(File.expand_path("~/.xmpp4r-observable-test-config")).map! { |login| login.split(" ") }
+			raise StandardError unless logins.size == 2
+		rescue => e
+			puts "\nConfiguration Error!\n\nYou must make available two unique Jabber accounts in order for the tests to pass."
+			puts "Place them in ~/.xmpp4r-observable-test-config, one per line like so:\n\n"
+			puts "user1@example.com/res password"
+			puts "user2@example.com/res password\n\n"
+			raise e
+		end
+
+		@@connections[:client1] = Jabber::Observable.new(*logins[0])
+		@@connections[:client2] = Jabber::Observable.new(*logins[1])
+
+		@@connections[:jid1_raw] = Jabber::JID.new(logins[0][0])
+		@@connections[:jid2_raw] = Jabber::JID.new(logins[1][0])
+
+		# Force load the client and roster, just to be safe.
+		@@connections[:client1].roster
+		@@connections[:client2].roster
+
+		# Re-run this method to setup the local instance variables the first time.
+		setup
+	end
+
+	def test_ensure_the_jabber_clients_are_connected_after_setup
+		assert @client1.client.is_connected?
+		assert @client2.client.is_connected?
+	end
+
+	def test_remove_users_from_our_roster_should_succeed
+		@client2.subs.remove(@jid1)
+		@client1.subs.remove(@jid2)
+
+		assert_before 60 do
+			assert_equal false, @client1.subs.subscribed_to?(@jid2)
+			assert_equal false, @client2.subs.subscribed_to?(@jid1)
+		end
+	end
+
+	def test_add_users_to_our_roster_should_succeed_with_automatic_approval
+		@client1.subs.remove(@jid2)
+		@client2.subs.remove(@jid1)
+
+		assert_before 10 do
+			assert_equal false, @client1.subs.subscribed_to?(@jid2)
+			assert_equal false, @client2.subs.subscribed_to?(@jid1)
+		end
+
+		@client1.add_observer(:new_subscription, @subscription_observer)
+		@subscription_observer.clear
+		@client1.subs.add(@jid2)
+
+		assert_before 10 do
+			assert @client1.subs.subscribed_to?(@jid2)
+		end
+
+		assert_equal 1, @subscription_observer.last_args.size
+		assert_equal @jid2, @subscription_observer.last_args[0][0].jid.strip.to_s
+		@client1.delete_observer(:new_subscription, @subscription_observer)
+		@subscription_observer.clear
+	end
+
+	def test_disable_auto_accept_subscription_requests
+		@client1.subs.remove(@jid2)
+		@client2.subs.remove(@jid1)
+
+		assert_before(60) do
+			assert ! @client1.subs.subscribed_to?(@jid2)
+			assert ! @client2.subs.subscribed_to?(@jid1)
+		end
+
+		@client1.add_observer(:subscription_request, @subscription_observer)
+		@client1.subs.accept = false
+		@subscription_observer.clear
+		assert ! @client1.subs.accept?
+		
+		assert_before(60) { assert @subscription_observer.last.empty? }
+
+		@client2.subs.add(@jid1)
+
+		assert_before(60) do
+			assert ! @subscription_observer.last.empty?
+		end
+
+		assert_equal @jid2, @subscription_observer.last_args[0][0].jid.strip.to_s
+		assert_equal :subscribe, @subscription_observer.last_args[0][1].type
+
+		@client1.delete_observer(:subscription_request, @subscription_observer)
+		@subscription_observer.clear
+	end
+
+	def test_automatically_reconnect
+		@client1.client.close
+
+		sleep 2
+		assert_equal false, @client1.connected?
+
+		@client2.add_observer(:message, @message_observer)
+
+		assert @message_observer.last.empty?
+		@client1.deliver(@jid2, "Testing")
+
+		sleep 2
+		assert @client1.connected?
+		assert @client1.roster.instance_variable_get('@stream').is_connected?
+		sleep 2
+		assert ! @message_observer.last.empty?
+	end
+
+	def test_disconnect_doesnt_allow_auto_reconnects
+		@client1.disconnect
+
+		assert_equal false, @client1.connected?
+		
+		assert_raises Jabber::ConnectionError do
+			@client1.deliver(@jid2, "testing")
+		end
+
+		@client1.reconnect
+	end
+
+	private
+
+	def assert_before(seconds, &block)
+		error = nil
+
+		# This is for Ruby 1.9.1 compatibility
+		assertion_exception_class = begin
+			MiniTest::Assertion
+		rescue NameError
+			Test::Unit::AssertionFailedError
+		end
+
+		begin
+			Timeout::timeout(seconds) {
+				begin
+					yield
+				rescue assertion_exception_class => e
+					error = e
+					sleep 0.5
+					retry
+				end
+			}
+		rescue Timeout::Error
+			raise error
+		end
+	end
+
+end