em-synchrony 1.0.0 → 1.0.1

data/spec/connection_pool_spec.rb

@@ -9,7 +9,7 @@ describe EventMachine::Synchrony::ConnectionPool do
     EventMachine.run do
 
       db = EventMachine::Synchrony::ConnectionPool.new(size: 1) do
-        EventMachine::MySQL.new(host: "localhost")
+        Mysql2::EM::Client.new
       end
 
       Fiber.new {
@@ -33,7 +33,7 @@ describe EventMachine::Synchrony::ConnectionPool do
     EventMachine.run do
 
       db = EventMachine::Synchrony::ConnectionPool.new(size: 2) do
-        EventMachine::MySQL.new(host: "localhost")
+        Mysql2::EM::Client.new
       end
 
       Fiber.new {
@@ -57,7 +57,7 @@ describe EventMachine::Synchrony::ConnectionPool do
     EventMachine.run do
 
       db = EventMachine::Synchrony::ConnectionPool.new(size: 2) do
-        EventMachine::MySQL.new(host: "localhost")
+        Mysql2::EM::Client.new
       end
 
       Fiber.new {
@@ -88,7 +88,7 @@ describe EventMachine::Synchrony::ConnectionPool do
     EventMachine.run do
 
       db = EventMachine::Synchrony::ConnectionPool.new(size: 5) do
-        EventMachine::MySQL.new(host: "localhost")
+        Mysql2::EM::Client.new
       end
 
       Fiber.new {

data/spec/em-mongo_spec.rb

@@ -230,4 +230,30 @@ describe EM::Mongo do
       EventMachine.stop
     end
   end
+
+  context "authentication" do
+    # these specs only get asserted if you run mongod with the --auth flag
+    it "successfully authenticates" do
+      # For this spec you will need to add this user to the database
+      #
+      # From the Mongo shell:
+      # > use db
+      # > db.addUser('test', 'test')
+      EventMachine.synchrony do
+        database = EM::Mongo::Connection.new.db('db')
+        database.authenticate('test', 'test').should == true
+        EventMachine.stop
+      end
+    end
+
+    it "raises an AuthenticationError if it cannot authenticate" do
+      EventMachine.synchrony do
+        database = EM::Mongo::Connection.new.db('db')
+        proc {
+          database.authenticate('test', 'wrong_password')
+        }.should raise_error(EventMachine::Mongo::AuthenticationError, "auth fails")
+        EventMachine.stop
+      end
+    end
+  end
 end

data/spec/helper/all.rb

@@ -10,19 +10,13 @@ require 'lib/em-synchrony/em-memcache'
 require 'lib/em-synchrony/em-mongo'
 require 'lib/em-synchrony/em-redis'
 require 'lib/em-synchrony/em-hiredis'
+require 'lib/em-synchrony/amqp'
 
 require 'helper/tolerance_matcher'
 require 'helper/stub-http-server'
 
 def now(); Time.now.to_f; end
 
-def silence_warnings()
-  old_verbose, $VERBOSE = $VERBOSE, nil
-  yield
-ensure
-  $VERBOSE = old_verbose
-end
-
 RSpec.configure do |config|
   config.include(Sander6::CustomMatchers)
 end

data/spec/hiredis_spec.rb

@@ -11,6 +11,29 @@ describe EM::Hiredis do
     end
   end
 
+  it "should work with compact connect syntax" do
+    EventMachine.synchrony do
+      redis = EM::Hiredis.connect
+
+      redis.set('a', 'bar')
+      redis.get('a').should == 'bar'
+
+      EM.stop
+    end
+  end
+
+  it "should work with manual db select" do
+    EventMachine.synchrony do
+      redis = EM::Hiredis.connect 'redis://127.0.0.1:6379'
+      redis.select(0)
+
+      redis.set('a', 'baz')
+      redis.get('a').should == 'baz'
+
+      EM.stop
+    end
+  end
+
   it "should get/set records synchronously" do
     EventMachine.synchrony do
       redis = EM::Hiredis::Client.connect
@@ -26,7 +49,7 @@ describe EM::Hiredis do
   it "should incr/decr key synchronously" do
     EventMachine.synchrony do
       redis = EM::Hiredis::Client.connect
-      redis.delete('key')
+      redis.del('key')
 
       redis.incr('key')
       redis.get('key').to_i.should == 1

data/spec/http_spec.rb

@@ -59,24 +59,24 @@ describe EventMachine::HttpRequest do
       EventMachine.stop
     end
   end
-  
+
   it "should terminate immediately in case of connection errors" do
     EventMachine.synchrony do
-      response = EventMachine::HttpRequest.new(CONNECTION_ERROR_URL).get
+      response = EventMachine::HttpRequest.new(CONNECTION_ERROR_URL, :connection_timeout => 0.1).get
       response.error.should_not be_nil
-      
+
       EventMachine.stop
     end
   end
-  
+
   it "should process inactivity timeout correctly" do
     EventMachine.synchrony do
       s = StubServer.new("HTTP/1.0 200 OK\r\nConnection: close\r\n\r\nFoo", 5)
-      
+
       start = now
-      r = EventMachine::HttpRequest.new(URL, :inactivity_timeout => 0.5).get
-      (now - start.to_f).should be_within(0.2).of(0.5)
-      
+      r = EventMachine::HttpRequest.new(URL, :inactivity_timeout => 0.1).get
+      (now - start.to_f).should be_within(0.2).of(0.1)
+
       s.stop
       EventMachine.stop
     end

data/spec/multi_spec.rb

@@ -0,0 +1,13 @@
+require "helper/all"
+
+describe EM::Synchrony do
+  describe "Multi" do
+    it "should require unique keys for each deferrable" do
+      lambda do
+        m = EM::Synchrony::Multi.new
+        m.add :df1, EM::DefaultDeferrable.new
+        m.add :df1, EM::DefaultDeferrable.new
+      end.should raise_error("Duplicate Multi key")
+    end
+  end
+end

data/spec/mysql2_spec.rb

@@ -107,4 +107,17 @@ describe Mysql2::EM::Client do
     end
   end
 
+  it "errback should not catch exception thrown from callback" do
+    class ErrbackShouldNotCatchThis < Exception; end
+    proc {
+      EM.synchrony do
+        db = Mysql2::EM::Client.new
+        res = db.query QUERY
+        raise ErrbackShouldNotCatchThis.new("errback should not catch this")
+
+        EventMachine.stop
+      end
+    }.should raise_error(ErrbackShouldNotCatchThis)
+  end
+
 end

data/spec/synchrony_spec.rb

@@ -1,14 +1,33 @@
 require "helper/all"
 
-describe EM::Synchrony, "#sync" do
-  it "returns immediately if the syncee already succeeded" do
-    args = stub("args")
-    
-    Fiber.new {
-      df = EM::DefaultDeferrable.new
-      df.succeed args
-      
-      EM::Synchrony.sync(df).should == args
-    }.resume
+describe EM::Synchrony do
+  describe "#sync" do
+    it "returns immediately if the syncee already succeeded" do
+      args = stub("args")
+
+      Fiber.new {
+        df = EM::DefaultDeferrable.new
+        df.succeed args
+        EM::Synchrony.sync(df).should == args
+
+        df = EM::DefaultDeferrable.new
+        df.succeed nil
+        EM::Synchrony.sync(df).should == nil
+      }.resume
+    end
+  end
+
+  describe "#next_tick" do
+    it "should wrap next_tick into a Fiber context" do
+      Fiber.new {
+        df = EM::DefaultDeferrable.new
+
+        EM::Synchrony.next_tick do
+          df.succeed args
+          EM::Synchrony.sync(df).should == args
+        end
+      }.resume
+    end
   end
+
 end

data/spec/tcpsocket_spec.rb

@@ -17,4 +17,14 @@ describe EventMachine::Synchrony::TCPSocket  do
       EM.stop
     end
   end
+
+  it 'should accept "send" when wrapped in a connection pool' do
+    EventMachine.synchrony do
+      @socket = EventMachine::Synchrony::ConnectionPool.new(size: 1) do
+        EventMachine::Synchrony::TCPSocket.new 'eventmachine.rubyforge.org', 80
+      end
+      @socket.send("GET / HTTP1.1\r\n\r\n").class.should be(Fixnum)
+      EM.stop
+    end
+  end
 end

data/spec/thread_spec.rb

@@ -0,0 +1,191 @@
+require "spec/helper/all"
+
+describe EventMachine::Synchrony::Thread::Mutex do
+  let(:m) { EM::Synchrony::Thread::Mutex.new }
+  it "should synchronize" do
+    EM.synchrony do
+      i = 0
+      f1 = Fiber.new do
+        m.synchronize do
+          f = Fiber.current
+          EM.next_tick { f.resume }
+          Fiber.yield
+          i += 1
+        end
+      end.resume
+      f1 = Fiber.new do
+        m.synchronize do
+          i.should eql(1)
+          EM.stop
+        end
+      end.resume
+    end
+  end
+
+  describe "lock" do
+    describe "when mutex already locked" do
+
+      it "should raise ThreadError" do
+        f = Fiber.new do
+          m.lock
+          Fiber.yield
+          m.lock
+        end
+        f.resume
+        proc { f.resume }.should raise_error(FiberError)
+      end
+    end
+  end
+
+  describe "sleep" do
+    describe "without timeout" do
+      it "should sleep until resume" do
+        EM.synchrony do
+          m.lock
+          i = 0
+          f = Fiber.current
+          EM.next_tick { i += 1; f.resume }
+          res = m.sleep
+          i.should eql(1)
+          EM.stop
+        end
+      end
+
+      it "should release lock" do
+        EM.synchrony do
+          i = 0
+          Fiber.new do 
+            m.lock
+            f = Fiber.current
+            EM.next_tick { f.resume }
+            Fiber.yield
+            i += 1
+            m.sleep
+          end.resume
+          Fiber.new do 
+            m.lock
+            i.should eql(1)
+            EM.stop
+          end.resume
+        end
+      end
+
+      it "should wait unlock after resume" do
+        EM.synchrony do
+          i = 0
+          f1 = Fiber.new do 
+            m.lock
+            m.sleep
+            i.should eql(1)
+            EM.stop
+          end
+          f2 = Fiber.new do 
+            m.lock
+            f1.resume
+            i += 1
+            m.unlock
+          end
+          f1.resume
+          f2.resume
+        end
+      end
+      
+      describe "with timeout" do
+        it "should sleep for timeout" do
+          EM.synchrony do
+            m.lock
+            i = 0
+            EM.next_tick { i += 1 }
+            m.sleep(0.05)
+            i.should eql(1)
+            EM.stop
+          end
+        end
+        describe "and resume before timeout" do
+          it "should not raise any execptions" do
+            EM.synchrony do
+              m.lock
+              f = Fiber.current
+              EM.next_tick { f.resume }
+              m.sleep(0.05)
+              EM.add_timer(0.1) { EM.stop }
+            end
+          end
+          it "should resume in nested Fiber" do
+            EM.synchrony do
+              f = Fiber.new do
+                m.synchronize do
+                  t = m.sleep(0.05)
+                  t.should >= 0.05
+                end
+                EM.stop
+              end
+              f.resume
+            end
+          end
+        end
+      end
+    end
+  end
+  describe EventMachine::Synchrony::Thread::ConditionVariable do
+    let(:c){ EM::Synchrony::Thread::ConditionVariable.new }
+    it "should wakeup waiter" do
+      i = ''
+      EM.synchrony do
+        f1 = Fiber.new do
+          m.synchronize do
+            i << 'a'
+            c.wait(m)
+            i << 'c'
+          end
+          EM.stop
+        end.resume
+        f2 = Fiber.new do
+          i << 'b'
+          c.signal
+        end.resume
+      end
+      i.should == 'abc'
+    end
+    it 'should allow to play ping-pong' do
+      i = ''
+      EM.synchrony do
+        f1 = Fiber.new do
+          m.synchronize do
+            i << 'pi'
+            c.wait(m)
+            i << '-po'
+            c.signal
+          end
+        end.resume
+        f2 = Fiber.new do
+          m.synchronize do
+            i << 'ng'
+            c.signal
+            c.wait(m)
+            i << 'ng'
+          end
+          EM.stop
+        end.resume
+      end
+      i.should == 'ping-pong'
+    end
+    it 'should not raise, when timer wakes up fiber between `signal` and `next_tick`' do
+      proc {
+        EM.synchrony do
+          f = Fiber.new do
+            m.synchronize do
+              c.wait(m, 0.0001)
+            end
+            EM.add_timer(0.001){ EM.stop }
+          end
+          i = 0
+          f.resume
+          EM.next_tick{
+            c.signal
+          }
+        end
+      }.should_not raise_error
+    end
+  end
+end