uvrb 0.1.0

data/spec/uv/fs_event_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe UV::FSEvent do
+  let(:handle_name) { :fs_event }
+  let(:loop) { double() }
+  let(:pointer) { double() }
+  subject { UV::FSEvent.new(loop, pointer) { |e, filename, type| } }
+
+  it_behaves_like 'a handle'
+end

data/spec/uv/idle_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe UV::Idle do
+  let(:handle_name) { :idle }
+  let(:loop) { double() }
+  let(:pointer) { double() }
+  subject { UV::Idle.new(loop, pointer) }
+
+  it_behaves_like 'a handle'
+
+  describe "#start" do
+    it "requires a block" do
+      expect { subject.start }.to raise_error(ArgumentError)
+    end
+
+    it "calls UV.idle_start" do
+      UV.should_receive(:idle_start).with(pointer, subject.method(:on_idle))
+
+      subject.start { |e| }
+    end
+  end
+
+  describe "#stop" do
+    it "calls UV.idle_stop" do
+      UV.should_receive(:idle_stop).with(pointer)
+
+      subject.stop
+    end
+  end
+end

data/spec/uv/loop_spec.rb

@@ -0,0 +1,241 @@
+require 'spec_helper'
+
+describe UV::Loop do
+  let(:loop_pointer) { double() }
+
+  describe ".default" do
+    it "calls UV.loop_default internally" do
+      UV.should_receive(:default_loop).once.and_return(loop_pointer)
+      FFI::AutoPointer.should_receive(:new).once.with(loop_pointer, UV.method(:loop_delete))
+      UV::Loop.default
+    end
+  end
+
+  describe ".new" do
+    it "calls UV.loop_new" do
+      UV.should_receive(:loop_new).once.and_return(loop_pointer)
+      FFI::AutoPointer.should_receive(:new).once.with(loop_pointer, UV.method(:loop_delete))
+      UV::Loop.new
+    end
+  end
+
+  subject do
+    FFI::AutoPointer.should_receive(:new).once.with(loop_pointer, UV.method(:loop_delete)).and_return(loop_pointer)
+    UV::Loop.create(loop_pointer)
+  end
+
+  describe "#run" do
+    it "calls UV.run" do
+      UV.should_receive(:run).with(loop_pointer)
+
+      subject.run
+    end
+  end
+
+  describe "#run_once" do
+    it "calls UV.run_once" do
+      UV.should_receive(:run_once).with(loop_pointer)
+
+      subject.run_once
+    end
+  end
+
+  describe "#update_time" do
+    it "calls UV.update_time" do
+      UV.should_receive(:update_time).with(loop_pointer)
+
+      subject.update_time
+    end
+  end
+
+  describe "#now" do
+    let(:now) { Time.now }
+
+    it "calls UV.now" do
+      UV.should_receive(:now).with(loop_pointer).and_return(now)
+
+      subject.now.should == now
+    end
+  end
+
+  describe "#last_error" do
+    let(:error) { double() }
+
+    it "calls UV.last_error" do
+      UV.should_receive(:last_error).with(loop_pointer).and_return(error)
+      UV.should_receive(:err_name).with(error).and_return("EINVAL")
+      UV.should_receive(:strerror).with(error).and_return("invalid argument")
+
+      subject.last_error.should == UV::Error::EINVAL.new("invalid argument")
+    end
+  end
+
+  describe "#timer" do
+    let(:timer_pointer) { double() }
+    let(:timer) { double() }
+
+    it "calls UV.timer_init" do
+      UV.should_receive(:create_handle).with(:uv_timer).and_return(timer_pointer)
+      UV.should_receive(:timer_init).with(loop_pointer, timer_pointer)
+      UV::Timer.should_receive(:new).with(subject, timer_pointer).and_return(timer)
+
+      subject.timer.should == timer
+    end
+  end
+
+  describe "#tcp" do
+    let(:tcp_pointer) { double() }
+    let(:tcp) { double() }
+
+    it "calls UV.tcp_init" do
+      UV.should_receive(:create_handle).with(:uv_tcp).and_return(tcp_pointer)
+      UV.should_receive(:tcp_init).with(loop_pointer, tcp_pointer)
+      UV::TCP.should_receive(:new).with(subject, tcp_pointer).and_return(tcp)
+
+      subject.tcp.should == tcp
+    end
+  end
+
+  describe "#tty" do
+    let(:tty_pointer) { double() }
+    let(:tty) { double() }
+    let(:fileno) { 6555 }
+
+    before(:each) do
+      UV.should_receive(:create_handle).with(:uv_tty).and_return(tty_pointer)
+      UV::TTY.should_receive(:new).with(subject, tty_pointer).and_return(tty)
+    end
+
+    context "readable" do
+      it "calls UV.tty_init" do
+        UV.should_receive(:tty_init).with(loop_pointer, tty_pointer, fileno, 1)
+
+        subject.tty(fileno, true).should == tty
+      end
+    end
+
+    context "not readable" do
+      it "calls UV.tty_init" do
+        UV.should_receive(:tty_init).with(loop_pointer, tty_pointer, fileno, 0)
+
+        subject.tty(fileno, false).should == tty
+      end
+    end
+  end
+
+  describe "#pipe" do
+    let(:pipe_pointer) { double() }
+    let(:pipe) { double() }
+
+    before(:each) do
+      UV.should_receive(:create_handle).with(:uv_pipe).and_return(pipe_pointer)
+      UV::Pipe.should_receive(:new).with(subject, pipe_pointer).and_return(pipe)
+    end
+
+    context "with ipc" do
+      it "calls UV.pipe_init" do
+        UV.should_receive(:pipe_init).with(loop_pointer, pipe_pointer, 0)
+
+        subject.pipe.should == pipe
+      end
+    end
+
+    context "without ipc" do
+      it "calls UV.pipe_init" do
+        UV.should_receive(:pipe_init).with(loop_pointer, pipe_pointer, 1)
+
+        subject.pipe(true).should == pipe
+      end
+    end
+  end
+
+  describe "#prepare" do
+    let(:prepare_pointer) { double() }
+    let(:prepare) { double() }
+
+    it "calls UV.prepare_init" do
+      UV.should_receive(:create_handle).with(:uv_prepare).and_return(prepare_pointer)
+      UV.should_receive(:prepare_init).with(loop_pointer, prepare_pointer)
+      UV::Prepare.should_receive(:new).with(subject, prepare_pointer).and_return(prepare)
+
+      subject.prepare.should == prepare
+    end
+  end
+
+  describe "#check" do
+    let(:check_pointer) { double() }
+    let(:check) { double() }
+
+    it "calls UV.check_init" do
+      UV.should_receive(:create_handle).with(:uv_check).and_return(check_pointer)
+      UV.should_receive(:check_init).with(loop_pointer, check_pointer)
+      UV::Check.should_receive(:new).with(subject, check_pointer).and_return(check)
+
+      subject.check.should == check
+    end
+  end
+
+  describe "#idle" do
+    let(:idle_pointer) { double() }
+    let(:idle) { double() }
+
+    it "calls UV.idle_init" do
+      UV.should_receive(:create_handle).with(:uv_idle).and_return(idle_pointer)
+      UV.should_receive(:idle_init).with(loop_pointer, idle_pointer)
+      UV::Idle.should_receive(:new).with(subject, idle_pointer).and_return(idle)
+
+      subject.idle.should == idle
+    end
+  end
+
+  describe "#async" do
+    let(:async_pointer) { double() }
+    let(:async_callback) { double() }
+    let(:async) { double() }
+
+    it "requires a block" do
+      expect { subject.async }.to raise_error(ArgumentError)
+    end
+
+    it "calls UV.async_init" do
+      UV.should_receive(:create_handle).with(:uv_async).and_return(async_pointer)
+      UV.should_receive(:async_init).with(loop_pointer, async_pointer, async_callback)
+      UV::Async.should_receive(:new).with(subject, async_pointer).and_return(async)
+      async.should_receive(:callback).once.with(:on_async).and_return(async_callback)
+
+      handle = subject.async { |e| }
+      handle.should == async
+    end
+  end
+
+  describe "#fs" do
+    let(:filesystem) { double() }
+
+    it "instantiates UV::Filesystem" do
+      UV::Filesystem.should_receive(:new).once.with(subject).and_return(filesystem)
+
+      subject.fs.should == filesystem
+    end
+  end
+
+  describe "#fs_event" do
+    let(:filename) { '/path/to/watch' }
+    let(:fs_event_pointer) { double() }
+    let(:fs_event_callback) { double() }
+    let(:fs_event) { double() }
+
+    it "requires a block" do
+      expect { subject.fs_event(filename) }.to raise_error(ArgumentError)
+    end
+
+    it "calls UV.fs_event_init" do
+      UV.should_receive(:create_handle).with(:uv_fs_event).and_return(fs_event_pointer)
+      UV.should_receive(:fs_event_init).with(loop_pointer, fs_event_pointer, filename, fs_event_callback, 0)
+      UV::FSEvent.should_receive(:new).with(subject, fs_event_pointer).and_return(fs_event)
+      fs_event.should_receive(:callback).once.with(:on_fs_event).and_return(fs_event_callback)
+
+      handle = subject.fs_event(filename) { |e, filename, type| }
+      handle.should == fs_event
+    end
+  end
+end

data/spec/uv/pipe_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe UV::Pipe do
+  let(:handle_name) { :pipe }
+  let(:loop) { double() }
+  let(:pointer) { double() }
+  subject { UV::Pipe.new(loop, pointer) }
+
+  it_behaves_like 'a handle'
+  it_behaves_like 'a stream'
+
+  describe "#open" do
+    let(:fileno) { 6555 }
+
+    it "calls UV.pipe_open" do
+      UV.should_receive(:pipe_open).with(pointer, fileno)
+
+      subject.open(fileno)
+    end
+  end
+
+  describe "#bind" do
+    let(:name) { "/tmp/filename.ipc" }
+
+    it "calls UV.pipe_bind" do
+      UV.should_receive(:pipe_bind).with(pointer, name)
+
+      subject.bind(name)
+    end
+  end
+
+  describe "#connect" do
+    let(:name) { "/tmp/filename.ipc" }
+    let(:connect_request) { double() }
+
+    it "requires a block" do
+      expect{ subject.connect(name) }.to raise_error(ArgumentError)
+    end
+
+    it "calls UV.pipe_connect" do
+      UV.should_receive(:create_request).with(:uv_connect).and_return(connect_request)
+      UV.should_receive(:pipe_connect).with(connect_request, pointer, name, subject.method(:on_connect))
+
+      subject.connect(name) { |e| }
+    end
+  end
+
+  describe "#pending_instances=" do
+    it "calls UV.pipe_pending_instances" do
+      UV.should_receive(:pipe_pending_instances).with(pointer, 5)
+      subject.pending_instances = 5
+    end
+  end
+end

data/spec/uv/prepare_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe UV::Prepare do
+  let(:handle_name) { :prepare }
+  let(:loop) { double() }
+  let(:pointer) { double() }
+  subject { UV::Prepare.new(loop, pointer) }
+
+  it_behaves_like 'a handle'
+
+  describe "#start" do
+    it "requires a block" do
+      expect { subject.start }.to raise_error(ArgumentError)
+    end
+
+    it "calls UV.prepare_start" do
+      UV.should_receive(:prepare_start).with(pointer, subject.method(:on_prepare))
+
+      subject.start { |e| }
+    end
+  end
+
+  describe "#stop" do
+    it "calls UV.prepare_stop" do
+      UV.should_receive(:prepare_stop).with(pointer)
+
+      subject.stop
+    end
+  end
+end

data/spec/uv/tcp_spec.rb

@@ -0,0 +1,134 @@
+require 'spec_helper'
+
+describe UV::TCP do
+  let(:handle_name) { :tcp }
+  let(:loop) { double() }
+  let(:pointer) { double() }
+  subject { UV::TCP.new(loop, pointer) }
+
+  it_behaves_like 'a handle'
+  it_behaves_like 'a stream'
+
+  describe "#bind" do
+    let(:ip_addr) { double() }
+    let(:port) { 0 }
+
+    context "ipv4" do
+      let(:ip) { "0.0.0.0" }
+
+      it "calls UV.tcp_bind" do
+        UV.should_receive(:ip4_addr).with(ip, port).and_return(ip_addr)
+        UV.should_receive(:tcp_bind).with(pointer, ip_addr)
+
+        subject.bind(ip, port)
+      end
+    end
+
+    context "ipv6" do
+      let(:ip) { "::" }
+
+      it "calls UV.tcp_bind6" do
+        UV.should_receive(:ip6_addr).with(ip, port).and_return(ip_addr)
+        UV.should_receive(:tcp_bind6).with(pointer, ip_addr)
+
+        subject.bind(ip, port)
+      end
+    end
+  end
+
+  describe "#connect" do
+    let(:connect_request) { double() }
+    let(:ip_addr) { double() }
+    let(:port) { 0 }
+
+    it "requires a block" do
+      expect { subject.connect("0.0.0.0", port) }.to raise_error(ArgumentError)
+    end
+
+    context "ipv4" do
+      let(:ip) { "0.0.0.0" }
+
+      it "calls UV.tcp_connect" do
+        UV.should_receive(:create_request).with(:uv_connect).and_return(connect_request)
+        UV.should_receive(:ip4_addr).with(ip, port).and_return(ip_addr)
+        UV.should_receive(:tcp_connect).with(connect_request, pointer, ip_addr, subject.method(:on_connect))
+
+        subject.connect(ip, port) { |e| }
+      end
+    end
+
+    context "ipv6" do
+      let(:ip) { "::" }
+
+      it "calls UV.tcp_connect6" do
+        UV.should_receive(:create_request).with(:uv_connect).and_return(connect_request)
+        UV.should_receive(:ip6_addr).with(ip, port).and_return(ip_addr)
+        UV.should_receive(:tcp_connect6).with(connect_request, pointer, ip_addr, subject.method(:on_connect))
+
+        subject.connect(ip, port) { |e| }
+      end
+    end
+  end
+
+  # describe "#sockname" do
+  #   let(:sockaddr) { double() }
+  #   let(:len) { 15 }
+  # 
+  #   it "calls UV.tcp_getsockname" do
+  #     UV.should_receive(:tcp_getsockname).with(pointer, sockaddr, len)
+  #   end
+  # end
+  # 
+  # describe "#peername" do
+  # end
+
+  describe "#enable_nodelay" do
+    it "calls UV.tcp_nodelay" do
+      UV.should_receive(:tcp_nodelay).with(pointer, 1)
+
+      subject.enable_nodelay
+    end
+  end
+
+  describe "#disable_nodelay" do
+    it "calls UV.tcp_nodelay" do
+      UV.should_receive(:tcp_nodelay).with(pointer, 0)
+
+      subject.disable_nodelay
+    end
+  end
+
+  describe "#enable_keepalive" do
+    let(:keepalive_delay) { 150 }
+
+    it "calls UV.tcp_keepalive" do
+      UV.should_receive(:tcp_keepalive).with(pointer, 1, keepalive_delay)
+
+      subject.enable_keepalive(keepalive_delay)
+    end
+  end
+
+  describe "#disable_keepalive" do
+    it "calls UV.tcp_keepalive" do
+      UV.should_receive(:tcp_keepalive).with(pointer, 0, 0)
+
+      subject.disable_keepalive
+    end
+  end
+
+  describe "#enable_simultaneous_accepts" do
+    it "calls UV.tcp_simultaneous_accepts" do
+      UV.should_receive(:tcp_simultaneous_accepts).with(pointer, 1)
+
+      subject.enable_simultaneous_accepts
+    end
+  end
+
+  describe "#disable_simultaneous_accepts" do
+    it "calls UV.tcp_simultaneous_accepts" do
+      UV.should_receive(:tcp_simultaneous_accepts).with(pointer, 0)
+
+      subject.disable_simultaneous_accepts
+    end
+  end
+end