green 0.0.1 → 0.1

data/spec/green/tcpsocket_spec.rb

@@ -0,0 +1,417 @@
+# based on https://github.com/igrigorik/em-synchrony/pull/127
+
+require 'spec_helper'
+require 'green/socket'
+require 'green/group'
+require 'green/event'
+describe Green::TCPSocket do
+  describe '.new' do
+    describe 'to an open TCP port on an resolvable host' do
+      it 'succeeds'  do
+        Green.spawn do
+          s = Green::TCPServer.new '127.0.0.1', 12345
+          s.accept
+          s.close
+        end
+        Green.spawn do
+          s = Green::TCPSocket.new '127.0.0.1', 12345
+          s.close
+        end.join
+      end
+    end
+
+    describe 'to an unresolvable host' do
+      it 'raises SocketError' do
+        proc {
+          Green::TCPSocket.new 'xxxyyyzzz', 12345
+        }.must_raise SocketError
+      end
+    end
+
+    describe 'to a closed TCP port' do
+      it 'raises Errno::ECONNREFUSED' do
+        proc {
+          Green::TCPSocket.new '127.0.0.1', 12345
+        }.must_raise Errno::ECONNREFUSED
+      end
+    end
+  end
+
+  def in_connect(&blk)
+    server = Green::TCPServer.new '127.0.0.1', 12345
+    s = nil
+    client = nil
+    g = Green::Group.new
+    g.spawn do
+      s = server.accept
+      s.write '1234'      
+    end
+    g.spawn do 
+      client = Green::TCPSocket.new '127.0.0.1', 12345
+    end
+    g.join
+    blk.call s, client
+  ensure
+    s.close rescue nil
+    client.close rescue nil
+    server.close rescue nil
+  end
+  
+  describe '#closed?' do
+    describe 'after calling #close' do
+      it 'returns true' do
+        in_connect do |s, c|
+          c.close
+          c.closed?.must_equal true
+        end
+      end
+    end
+    describe 'after the peer has closed the connection' do
+      describe 'when we\'ve not yet read EOF' do
+        it 'returns false' do
+          in_connect do |s, c|
+            s.close
+            c.read(2).size.must_equal 2
+            c.closed?.must_equal false
+          end
+        end
+      end
+      describe 'when we\'ve read EOF' do
+        it 'returns false' do
+          in_connect do |s, c|
+            s.close
+            c.read(10).size.must_equal 4
+            c.read(10).must_equal nil
+            c.closed?.must_equal false
+          end
+        end
+      end
+    end
+  end
+  
+  describe '#read' do
+    describe 'with a length argument' do
+      describe 'with a possitive length argument' do
+        describe 'when the connection is open' do
+          describe 'with greater or equal than the requested data buffered' do
+            it 'returns the requested data and no more' do
+              in_connect do |s, c|
+                c.read(2).size.must_equal 2
+                c.read(1).size.must_equal 1
+              end
+            end
+          end
+          describe 'with less than the requested data buffered' do
+            it 'blocks' do
+              in_connect do |s, c|
+                blocked = true
+                g = Green.spawn { blocked.must_equal true; s.close }
+                res = c.read(10)
+                blocked = false
+                g.join
+              end
+            end
+          end
+        end
+        describe 'when the peer has closed the connection' do
+          describe 'with no data buffered' do
+            it 'returns nil' do
+              in_connect do |s, c|
+                s.close
+                c.read(4).size.must_equal 4
+                c.read(1).must_equal nil
+              end
+            end
+          end
+          describe 'with less than the requested data buffered' do
+            it 'returns the buffered data' do
+              in_connect do |s, c|
+                s.close
+                c.read(50).size.must_equal 4
+              end
+            end
+          end
+          describe 'with greater or equal than the requested data buffered' do
+            it 'returns the requested data and no more' do
+              in_connect do |s, c|
+                c.read(2).size.must_equal 2
+              end
+            end
+          end
+        end
+        describe 'when we closed the connection' do
+          it 'raises IOError' do
+            in_connect do |s, c|
+              c.close
+              proc {
+                c.read(4)
+              }.must_raise IOError
+            end
+          end
+        end
+      end
+      describe 'with a negative length argument' do
+        it 'raises ArgumentError' do
+          in_connect do |s, c|
+            proc {
+              c.read(-10)
+            }.must_raise ArgumentError
+          end
+        end
+      end
+      describe 'with a zero length argument' do
+        describe 'when the connection is open' do
+          it 'returns an empty string' do
+            in_connect do |s, c|
+              c.read(0).must_equal ""
+            end
+          end
+        end
+        describe 'when the peer has closed the connection' do
+          it 'returns an empty string' do
+            in_connect do |s, c|
+              s.close
+              c.read(0).must_equal ""
+            end
+          end
+        end
+        describe 'when we closed the connection' do
+          it 'raises IOError' do
+            in_connect do |s, c|
+              c.close
+              proc {
+                c.read(0)
+              }.must_raise IOError
+            end
+          end
+        end
+      end
+    end
+    describe 'without a length argument' do
+      describe 'when the connection is open' do
+        it 'blocks until the peer closes the connection and returns all data sent' do
+          in_connect do |s, c|
+            blocked = true
+            Green.hub.timer(0.01) { blocked.must_equal true; s.close }
+            c.read(10).must_equal '1234'
+            blocked = false
+          end
+        end
+      end
+      describe 'when the peer has closed the connection' do
+        describe 'with no data buffered' do
+          it 'returns an empty string' do
+            in_connect do |s, c|
+              s.close
+              c.read
+              c.read.must_equal ""
+            end
+          end
+        end
+        describe 'with data buffered' do
+          it 'returns the buffered data' do
+            in_connect do |s, c|
+              s.close
+              c.read.must_equal "1234"
+            end
+          end
+        end
+      end
+      describe 'when we closed the connection' do
+        it 'raises IOError' do
+          in_connect do |s, c|
+            c.close
+            proc {
+              c.read
+            }.must_raise IOError
+          end
+        end
+      end
+    end
+  end
+  
+  describe '#recv' do
+    describe 'with a length argument' do
+      describe 'with a positive length argument' do
+        describe 'when the connection is open' do
+          describe 'with greater or equal than the requested data buffered' do
+            it 'returns the requested data and no more' do
+              in_connect do |s, c|
+                c.recv(2).size.must_equal 2
+                c.recv(1).size.must_equal 1
+              end
+            end
+          end
+          describe 'with less than the requested data buffered' do
+            it 'return the buffered data' do
+              in_connect do |s, c|
+                c.recv(50).size.must_equal 4
+              end
+            end
+          end
+          describe 'with no buffered data' do
+            it 'blocks' do
+              in_connect do |s, c|
+                c.recv(10)
+                blocked = true
+                g = Green.spawn do
+                  blocked.must_equal true
+                  s.close
+                end
+                c.recv(10)                
+                blocked = false
+                g.join
+              end
+            end
+          end
+        end
+        describe 'when the peer has closed the connection' do
+          describe 'with no data buffered' do
+            it 'returns an empty string' do
+              in_connect do |s, c|
+                s.close
+                c.read(4).size.must_equal 4
+                c.recv(1).must_equal ""
+              end
+            end
+          end
+          describe 'with less than the requested data buffered' do
+            it 'returns the buffered data' do
+              in_connect do |s, c|
+                s.close
+                c.recv(50).size.must_equal 4
+              end
+            end
+          end
+          describe 'with greater or equal than the requested data buffered' do
+            it 'returns the requested data and no more' do
+              in_connect do |s, c|
+                s.close
+                c.recv(2).size.must_equal 2
+              end
+            end
+          end
+        end
+        describe 'when we closed the connection' do
+          it 'raises IOError' do
+            in_connect do |s, c|
+              c.close
+              proc {
+                res = c.recv(4)
+              }.must_raise IOError
+            end
+          end
+        end
+      end
+      describe 'with a negative length argument' do
+        it 'raises ArgumentError' do
+          in_connect do |s, c|
+            proc {
+              c.recv(-10)
+            }.must_raise ArgumentError
+          end
+        end
+      end
+      describe 'with a zero length argument' do
+        describe 'when the connection is open' do
+          it 'returns an empty string' do
+            in_connect do |s, c|
+              c.recv(0).must_equal ""
+            end
+          end
+        end
+        describe 'when the peer has closed the connection' do
+          it 'returns an empty string' do
+            in_connect do |s, c|
+              s.close
+              c.recv(0).must_equal ""
+            end
+          end
+        end
+        describe 'when we closed the connection' do
+          it 'raises IOError' do
+            in_connect do |s, c|
+              c.close
+              proc {
+                c.recv(0)
+              }.must_raise IOError
+            end
+          end
+        end
+      end
+    end
+    describe 'without a length argument' do
+      it 'raises ArgumentError' do
+        in_connect do |s, c|
+          proc {
+            c.recv()
+          }.must_raise ArgumentError
+        end
+      end
+    end
+  end
+  
+  describe '#write' do
+    describe 'when the peer has closed the connection' do
+      it 'raises Errno::EPIPE' do
+        in_connect do |s, c|
+          s.close
+          Green.spawn do
+            Green.sleep 0.01
+            proc {
+              c.write 100000.times.to_a * '' # on small chunks it can not raise exception
+            }.must_raise Errno::EPIPE, Errno::ECONNRESET, Errno::EBADF
+          end.join
+        end
+      end
+    end
+    describe 'when we closed the connection' do
+      it 'raises IOError' do
+        in_connect do |s, c|
+          c.close
+          proc {
+            c.write("foo")
+          }.must_raise IOError
+        end
+      end
+    end
+  end
+  
+  describe '#send' do
+    describe 'when the peer has closed the connection' do
+      it 'raises Errno::EPIPE' do
+        in_connect do |s, c|
+          s.close
+          Green.spawn do
+            Green.sleep 0.01
+            proc {
+              c.send 100000.times.to_a * '', 0
+            }.must_raise Errno::EPIPE, Errno::ECONNRESET, Errno::EBADF
+          end.join
+        end
+      end
+    end
+
+    describe 'when we closed the connection' do
+      it 'raises IOError' do
+        in_connect do |s, c|
+          c.close
+          proc {
+            c.send "foo", 0
+          }.must_raise IOError
+        end
+      end
+    end
+
+    describe 'without a flags argument' do
+      it 'raises ArgumentError' do
+        in_connect do |s, c|
+          proc {
+            c.send 'foo'
+          }.must_raise ArgumentError
+        end
+      end
+    end
+  end
+
+end

data/spec/green/zmq_spec.rb

@@ -0,0 +1,121 @@
+# -*- coding: utf-8 -*-
+require "spec_helper"
+require 'green/zmq'
+require 'green/group'
+
+describe ZMQ::Socket do
+
+  describe "simple case" do
+    before do
+      @ctx = ZMQ::Context.new
+      @rep = @ctx.socket(ZMQ::REP)
+      @req = @ctx.socket(ZMQ::REQ)
+      @rep.bind('inproc://test')
+      @req.connect('inproc://test')
+    end
+
+    after do
+      @req.close
+      @rep.close
+      @ctx.terminate
+    end
+
+    it "works" do
+      @req.send_string 'hello'
+      Green.spawn do
+        str = ''
+        @rep.recv_string(str)
+        str.must_equal 'hello'
+      end.join
+    end
+  end
+
+  # describe "complex topology" do
+  #   let(:router_endpoint) { "tcp://127.0.0.1:12345" }
+  #   let(:dealer_endpoint) { "tcp://127.0.0.1:12346" }
+  #   before do
+  #     @ctx = ZMQ::Context.new
+  #     @router = @ctx.socket ZMQ::ROUTER
+  #     @dealer = @ctx.socket ZMQ::DEALER
+  #     @router.bind(router_endpoint)
+  #     @dealer.bind(dealer_endpoint)
+  #     @router_green = Green.spawn do
+  #       begin
+  #         strings = []
+  #         while (@router.recv_strings(strings) == 0)
+  #           @dealer.send_strings strings
+  #           strings = []
+  #         end
+  #       ensure
+  #         @router.close
+  #       end
+  #     end
+  #     @dealer_green = Green.spawn do
+  #       begin
+  #         strings = []
+  #         while (@dealer.recv_strings(strings) == 0)
+  #           @router.send_strings strings
+  #           strings = []
+  #         end
+  #       ensure
+  #         @dealer.close
+  #       end
+  #     end
+  #   end
+
+  #   def spawn_workers
+  #     @workers_ctx = ZMQ::Context.new
+  #     @workers = Green::Group.new
+  #     10.times.map do
+  #       @workers.spawn do
+  #         begin
+  #           s = @workers_ctx.socket ZMQ::REP
+  #           s.connect dealer_endpoint
+  #           strings = []
+  #           while (s.recv_strings(strings) == 0)
+  #             s.send_string((strings.first.to_i + 1).to_s)
+  #             strings = []
+  #           end
+  #         ensure
+  #           s.close
+  #         end
+  #       end
+  #     end
+  #   end
+
+  #   it "should increment numbers" do
+  #     ctx = ZMQ::Context.new
+  #     clients = Green::Group.new
+  #     5.times do
+  #       clients.spawn do
+  #         s = ctx.socket ZMQ::REQ
+  #         s.connect router_endpoint
+  #         i = 0
+  #         str = ''
+  #         10.times do
+  #           s.send_string i.to_s
+  #           s.recv_string str
+  #           i = str.to_i
+  #         end
+  #         s.close
+  #         i.must_equal 10
+  #       end
+  #     end
+  #     Green.spawn do
+  #       Green.sleep 1
+  #       spawn_workers
+  #     end
+  #     clients.join
+  #     ctx.terminate
+  #   end
+
+  #   after do
+  #     @workers.kill
+  #     @router_green.kill
+  #     @dealer_green.kill 
+  #     # @ctx.terminate # FIXME
+  #     # @workers_ctx.terminate
+  #   end
+  # end
+end
+

data/spec/green_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Green do
+  describe ".spawn" do
+    it "should spawn greens" do
+      g = Green.spawn do
+        :hello
+      end
+      g.join.must_equal :hello
+    end
+  end
+
+  describe "sleep" do
+    it "should set sleep" do
+      t = Time.now
+      Green.spawn do
+        Green.sleep 0.1
+      end.join
+      (Time.now - t).must_be :>, 0.1
+    end
+  end
+
+  describe "timeouts" do
+    it "should set timeout" do
+      t = Time.now
+      Green.spawn do
+        begin
+          Green.timeout(0.01) do
+            Green.sleep 0.1
+          end
+        rescue Timeout::Error
+        end
+      end.join
+      (Time.now - t).must_be :<, 0.1
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,32 @@
+require 'bundler'
+ENV['BUNDLE_GEMFILE'] = File.expand_path('../../Gemfile', __FILE__)
+Bundler.setup
+
+require 'minitest/spec'
+require 'minitest/autorun'
+require 'minitest/reporters'
+
+require 'helpers'
+
+require 'green'
+
+MiniTest::Unit.runner = MiniTest::SuiteRunner.new
+MiniTest::Unit.runner.reporters << MiniTest::Reporters::SpecReporter.new
+
+
+# class MiniTest::Spec
+#   def teardown
+#     g = Green.current
+#     Green.hub.callback { g.switch }
+#     Green.hub.switch
+#     puts "Callback: #{Green.hub.callbacks.size}; Timers: #{Green.hub.timers.size}; Cancels: #{Green.hub.cancel_timers.size}"
+#     puts Green.hub.callbacks.inspect
+#   end
+# end
+
+# at_exit {
+#   loop do
+#     MiniTest::Unit.new.run
+#     break if MiniTest::Unit.runner.errors != 0
+#   end
+# }