em-synchrony 0.3.0.beta.1 → 1.0.0

data/spec/activerecord_spec.rb

@@ -0,0 +1,50 @@
+require "spec/helper/all"
+require "em-synchrony/activerecord"
+
+# create database widgets;
+# use widgets;
+# create table widgets (idx INT);
+
+class Widget < ActiveRecord::Base; end;
+
+describe "Fiberized ActiveRecord driver for mysql2" do
+  DELAY = 0.25
+  QUERY = "SELECT sleep(#{DELAY})"
+
+  it "should establish AR connection" do
+    EventMachine.synchrony do
+      ActiveRecord::Base.establish_connection(
+        :adapter => 'em_mysql2',
+        :database => 'widgets',
+        :username => 'root'
+      )
+
+      result = Widget.find_by_sql(QUERY)
+      result.size.should == 1
+
+      EventMachine.stop
+    end
+  end
+
+  it "should fire sequential, synchronous requests within single fiber" do
+    EventMachine.synchrony do
+      ActiveRecord::Base.establish_connection(
+        :adapter => 'em_mysql2',
+        :database => 'widgets',
+        :username => 'root'
+      )
+
+      start = now
+      res = []
+
+      res.push Widget.find_by_sql(QUERY)
+      res.push Widget.find_by_sql(QUERY)
+
+      (now - start.to_f).should be_within(DELAY * res.size * 0.15).of(DELAY * res.size)
+      res.size.should == 2
+
+      EventMachine.stop
+    end
+  end
+
+end

data/spec/em-mongo_spec.rb

@@ -1,7 +1,6 @@
 require "spec/helper/all"
 
 describe EM::Mongo do
-
   it "should yield until connection is ready" do
     EventMachine.synchrony do
       connection = EM::Mongo::Connection.new
@@ -14,41 +13,207 @@ describe EM::Mongo do
     end
   end
 
-  it "should insert a record into db" do
-    EventMachine.synchrony do
-      collection = EM::Mongo::Connection.new.db('db').collection('test')
-      collection.remove({}) # nuke all keys in collection
+  describe 'Synchronously (find & first)' do
+    it "should insert a record into db" do
+      EventMachine.synchrony do
+        collection = EM::Mongo::Connection.new.db('db').collection('test')
+        collection.remove({}) # nuke all keys in collection
 
-      obj = collection.insert('hello' => 'world')
-      obj.keys.should include '_id'
+        obj = collection.insert('hello' => 'world')
+        obj.should be_a(BSON::ObjectId)
 
-      obj = collection.find
-      obj.size.should == 1
-      obj.first['hello'].should == 'world'
+        obj = collection.find
+        obj.size.should == 1
+        obj.first['hello'].should == 'world'
 
-      EventMachine.stop
+        EventMachine.stop
+      end
     end
-  end
 
-  it "should insert a record into db" do
-    EventMachine.synchrony do
-      collection = EM::Mongo::Connection.new.db('db').collection('test')
-      collection.remove({}) # nuke all keys in collection
+    it "should insert a record into db and be able to find it" do
+      EventMachine.synchrony do
+        collection = EM::Mongo::Connection.new.db('db').collection('test')
+        collection.remove({}) # nuke all keys in collection
 
-      obj = collection.insert('hello' => 'world')
-      obj = collection.insert('hello2' => 'world2')
+        obj = collection.insert('hello' => 'world')
+        obj = collection.insert('hello2' => 'world2')
 
-      obj = collection.find({})
-      obj.size.should == 2
+        obj = collection.find({})
+        obj.size.should == 2
 
-      obj2 = collection.find({}, {:limit => 1})
-      obj2.size.should == 1
+        obj2 = collection.find({}, {:limit => 1})
+        obj2.size.should == 1
 
-      obj3 = collection.first
-      obj3.is_a?(Hash).should be_true
+        obj3 = collection.first
+        obj3.is_a?(Hash).should be_true
 
-      EventMachine.stop
+        EventMachine.stop
+      end
+    end
+
+    it "should be able to order results" do
+      EventMachine.synchrony do
+        collection = EM::Mongo::Connection.new.db('db').collection('test')
+        collection.remove({}) # nuke all keys in collection
+
+        collection.insert(:name => 'one', :position => 0)
+        collection.insert(:name => 'three', :position => 2)
+        collection.insert(:name => 'two', :position => 1)
+
+        res = collection.find({}, {:order => 'position'})
+        res[0]["name"].should == 'one'
+        res[1]["name"].should == 'two'
+        res[2]["name"].should == 'three'
+
+        res1 = collection.find({}, {:order => [:position, :desc]})
+        res1[0]["name"].should == 'three'
+        res1[1]["name"].should == 'two'
+        res1[2]["name"].should == 'one'
+
+        EventMachine.stop
+      end
+    end
+  end
+
+
+  #
+  # em-mongo version > 0.3.6
+  #
+  if defined?(EM::Mongo::Cursor)
+    describe '*A*synchronously (afind & afirst) [Mongo > 0.3.6, using cursor]' do
+      it "should insert a record into db" do
+        EventMachine.synchrony do
+          collection = EM::Mongo::Connection.new.db('db').collection('test')
+          collection.remove({}) # nuke all keys in collection
+
+          obj = collection.insert('hello' => 'world')
+          obj.should be_a(BSON::ObjectId)
+
+          cursor = collection.afind
+          cursor.should be_a(EM::Mongo::Cursor)
+          cursor.to_a.callback do |obj|
+            obj.size.should == 1
+            obj.first['hello'].should == 'world'
+            EM.next_tick{ EventMachine.stop }
+          end
+        end
+      end
+
+      it "should insert a record into db and be able to find it" do
+        EventMachine.synchrony do
+          collection = EM::Mongo::Connection.new.db('db').collection('test')
+          collection.remove({}) # nuke all keys in collection
+
+          obj = collection.insert('hello' => 'world')
+          obj = collection.insert('hello2' => 'world2')
+
+          collection.afind({}).to_a.callback do |obj|
+            obj.size.should == 2
+          end
+          collection.afind({}, {:limit => 1}).to_a.callback do |obj2|
+            obj2.size.should == 1
+          end
+          collection.afirst.callback do |obj3|
+            obj3.is_a?(Hash).should be_true
+            obj3['hello'].should == 'world'
+            EM.next_tick{ EventMachine.stop }
+          end
+        end
+      end
+
+      it "should be able to order results" do
+        EventMachine.synchrony do
+          collection = EM::Mongo::Connection.new.db('db').collection('test')
+          collection.remove({}) # nuke all keys in collection
+
+          collection.insert(:name => 'one', :position => 0)
+          collection.insert(:name => 'three', :position => 2)
+          collection.insert(:name => 'two', :position => 1)
+
+          collection.afind({}, {:order => 'position'}).to_a.callback do |res|
+            res[0]["name"].should == 'one'
+            res[1]["name"].should == 'two'
+            res[2]["name"].should == 'three'
+          end
+
+          collection.afind({}, {:order => [:position, :desc]}).to_a.callback do |res1|
+            res1[0]["name"].should == 'three'
+            res1[1]["name"].should == 'two'
+            res1[2]["name"].should == 'one'
+            EM.next_tick{ EventMachine.stop }
+          end
+
+        end
+      end
+    end
+
+  else
+    describe '*A*synchronously (afind & afirst) [Mongo <= 0.3.6, using blocks]' do
+      it "should insert a record into db" do
+        EventMachine.synchrony do
+          collection = EM::Mongo::Connection.new.db('db').collection('test')
+          collection.remove({}) # nuke all keys in collection
+
+          obj = collection.insert('hello' => 'world')
+          obj.should be_a(BSON::ObjectId)
+
+          ret_val = collection.afind do |obj|
+            obj.size.should == 1
+            obj.first['hello'].should == 'world'
+            EM.next_tick{ EventMachine.stop }
+          end
+          ret_val.should be_a(Integer)
+        end
+      end
+
+      it "should insert a record into db and be able to find it" do
+        EventMachine.synchrony do
+          collection = EM::Mongo::Connection.new.db('db').collection('test')
+          collection.remove({}) # nuke all keys in collection
+
+          obj = collection.insert('hello' => 'world')
+          obj = collection.insert('hello2' => 'world2')
+
+          collection.afind({}) do |obj|
+            obj.size.should == 2
+          end
+          collection.afind({}, {:limit => 1}) do |obj2|
+            obj2.size.should == 1
+          end
+          collection.afirst do |obj3|
+            obj3.is_a?(Hash).should be_true
+            obj3['hello'].should == 'world'
+            EM.next_tick{ EventMachine.stop }
+          end
+        end
+      end
+
+      it "should be able to order results" do
+        EventMachine.synchrony do
+          collection = EM::Mongo::Connection.new.db('db').collection('test')
+          collection.remove({}) # nuke all keys in collection
+
+          collection.insert(:name => 'one', :position => 0)
+          collection.insert(:name => 'three', :position => 2)
+          collection.insert(:name => 'two', :position => 1)
+
+          collection.afind({}, {:order => 'position'}) do |res|
+            res[0]["name"].should == 'one'
+            res[1]["name"].should == 'two'
+            res[2]["name"].should == 'three'
+          end
+
+          collection.afind({}, {:order => [:position, :desc]}) do |res1|
+            res1[0]["name"].should == 'three'
+            res1[1]["name"].should == 'two'
+            res1[2]["name"].should == 'one'
+            EM.next_tick{ EventMachine.stop }
+          end
+
+        end
+      end
     end
+
   end
 
   it "should update records in db" do
@@ -56,14 +221,13 @@ describe EM::Mongo do
       collection = EM::Mongo::Connection.new.db('db').collection('test')
       collection.remove({}) # nuke all keys in collection
 
-      obj = collection.insert('hello' => 'world')
+      obj_id = collection.insert('hello' => 'world')
       collection.update({'hello' => 'world'}, {'hello' => 'newworld'})
 
-      new_obj = collection.first({'_id' => obj['_id']})
+      new_obj = collection.first({'_id' => obj_id})
       new_obj['hello'].should == 'newworld'
 
       EventMachine.stop
     end
   end
-
 end

data/spec/fiber_iterator_spec.rb

@@ -0,0 +1,39 @@
+require "spec/helper/all"
+require "em-synchrony/fiber_iterator"
+
+describe EventMachine::Synchrony::FiberIterator do
+
+  it "should wait until the iterator is done and wrap internal block within a fiber" do
+    EM.synchrony do
+
+      results = []
+      i = EM::Synchrony::FiberIterator.new(1..5, 2).each do |num|
+        EM::Synchrony.sleep(0.1)
+        results.push num
+      end
+
+      results.should == (1..5).to_a
+      results.size.should == 5
+      EventMachine.stop
+    end
+  end
+
+  #
+  # it "should sum values within the iterator" do
+  #   EM.synchrony do
+  #     data = (1..5).to_a
+  #     res = EM::Synchrony::FiberIterator.new(data, 2).inject(0) do |total, num, iter|
+  #       EM::Synchrony.sleep(0.1)
+  #
+  #       p [:sync, total, num]
+  #       iter.return(total += num)
+  #     end
+  #
+  #     res.should == data.inject(:+)
+  #     EventMachine.stop
+  #   end
+  # end
+
+
+
+end

data/spec/helper/all.rb

@@ -4,11 +4,12 @@ require 'pp'
 
 require 'lib/em-synchrony'
 require 'lib/em-synchrony/em-http'
-require 'lib/em-synchrony/em-mysqlplus'
+require 'lib/em-synchrony/mysql2'
 require 'lib/em-synchrony/em-remcached'
 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 'helper/tolerance_matcher'
 require 'helper/stub-http-server'

data/spec/hiredis_spec.rb

@@ -0,0 +1,40 @@
+require "spec/helper/all"
+
+describe EM::Hiredis do
+
+  it "should yield until connection is ready" do
+    EventMachine.synchrony do
+      connection = EM::Hiredis::Client.connect
+      connection.connected.should be_true
+
+      EventMachine.stop
+    end
+  end
+
+  it "should get/set records synchronously" do
+    EventMachine.synchrony do
+      redis = EM::Hiredis::Client.connect
+
+      redis.set('a', 'foo')
+      redis.get('a').should == 'foo'
+      redis.get('c').should == nil
+
+      EM.stop
+    end
+  end
+
+  it "should incr/decr key synchronously" do
+    EventMachine.synchrony do
+      redis = EM::Hiredis::Client.connect
+      redis.delete('key')
+
+      redis.incr('key')
+      redis.get('key').to_i.should == 1
+
+      redis.decr('key')
+      redis.get('key').to_i.should == 0
+
+      EM.stop
+    end
+  end
+end

data/spec/http_spec.rb

@@ -1,6 +1,7 @@
 require "spec/helper/all"
 
 URL = "http://localhost:8081/"
+CONNECTION_ERROR_URL = "http://random-domain-blah.com/"
 DELAY = 0.25
 
 describe EventMachine::HttpRequest do
@@ -58,4 +59,26 @@ 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.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)
+      
+      s.stop
+      EventMachine.stop
+    end
+  end
 end

data/spec/keyboard_spec.rb

@@ -0,0 +1,59 @@
+require "spec/helper/all"
+require "tempfile"
+
+DELAY = 0.1
+
+describe EventMachine::Synchrony do
+  before(:each) { @temp_file = Tempfile.new("stdout") }
+  after(:each) { @temp_file.unlink }
+  
+  def with_input(string = "", &block)
+    string = "#{string}\n"
+    
+    @temp_file.write string
+    @temp_file.flush
+    
+    EM::Synchrony.add_timer(DELAY) do
+      original_stdin = STDIN
+      STDIN.reopen(@temp_file.path)
+          
+      block.call if block_given?
+          
+      STDIN.reopen(original_stdin)
+    end
+  end
+
+  it "waits for input" do
+    EM.synchrony do
+      start = now
+      
+      with_input do
+        EM::Synchrony.gets
+        
+        (now - start.to_f).should be_within(DELAY * 0.15).of(DELAY)
+      end
+      
+      EM.add_timer(DELAY * 2) { EM.stop }
+    end
+  end
+  
+  it "trails input with a newline to emulate gets" do
+    EM.synchrony do
+      with_input("Hello") do
+        EM::Synchrony.gets.should == "Hello\n"
+      end
+      
+      EM.add_timer(DELAY * 2) { EM.stop }
+    end
+  end
+  
+  it "should stop after the first line" do
+    EM.synchrony do
+      with_input("Hello\nWorld!") do
+        EM::Synchrony.gets.should == "Hello\n"
+      end
+      
+      EM.add_timer(DELAY * 2) { EM.stop }
+    end
+  end
+end