cocaine-framework-ruby 0.11.2

data/lib/version.rb

@@ -0,0 +1,3 @@
+module Cocaine
+  VERSION = '0.11.2'
+end

data/spec/channel_spec.rb

@@ -0,0 +1,160 @@
+require 'rspec'
+
+require_relative '../lib/cocaine/asio/channel'
+require_relative '../lib/cocaine/asio/channel/combiner'
+
+describe Cocaine::Channel do
+  it 'should invoke callback immediately if it has pending data' do
+    done = false
+    channel = Cocaine::Channel.new
+    channel.trigger 'actual'
+    channel.callback { |data|
+      expect(data).to be == 'actual'
+      done = true
+    }
+    done.should == true
+  end
+
+  it 'should invoke errback immediately if it has pending errors' do
+    done = false
+    channel = Cocaine::Channel.new
+    channel.error 'actual'
+    channel.errback { |data|
+      expect(data).to be == 'actual'
+      done = true
+    }
+    done.should == true
+  end
+
+  it 'should invoke callback after triggering' do
+    done = false
+    channel = Cocaine::Channel.new
+    channel.callback { |data|
+      expect(data).to be == 'actual'
+      done = true
+    }
+    channel.trigger 'actual'
+    done.should == true
+  end
+
+  it 'should invoke errback after triggering' do
+    done = false
+    channel = Cocaine::Channel.new
+    channel.errback { |data|
+      expect(data).to be == 'actual'
+      done = true
+    }
+    channel.error 'actual'
+    done.should == true
+  end
+
+  it 'should invoke all callbacks after closed' do
+    counter = 0
+
+    channel = Cocaine::Channel.new
+    channel.trigger 'actual'
+    channel.trigger 'actual'
+
+    channel.callback { |data|
+      expect(data).to be == 'actual'
+      counter += 1
+    }
+    channel.close
+
+    expect counter == 2
+  end
+
+  it 'should raise error when triggered after it was closed' do
+    channel = Cocaine::Channel.new
+    channel.close
+    expect { channel.trigger nil }.to raise_error IllegalStateError
+  end
+
+  it 'should raise error when adding callback after is was closed' do
+    channel = Cocaine::Channel.new
+    channel.close
+    expect { channel.callback {} }.to raise_error IllegalStateError
+  end
+end
+
+describe Cocaine::Channel, '#collect' do
+  it 'should have `collect` method' do
+    Cocaine::Channel.new.collect
+  end
+
+  it 'should return all collected chunks after closing' do
+    flag = false
+    ch = Cocaine::Channel.new
+    ch.trigger 'chunk'
+    ch.trigger 'chmod'
+    ch.trigger 'chang'
+    df = ch.collect
+    df.callback { |chunks|
+      expect(chunks).to eq(%w(chunk chmod chang))
+      flag = true
+    }
+    ch.close
+    expect(flag).to be true
+  end
+
+  it 'should return all collected errors after closing' do
+    flag = false
+    ch = Cocaine::Channel.new
+    ch.error Exception.new 123
+    ch.error Exception.new 456
+    df = ch.collect
+    df.callback { |errors|
+      expect(errors).to eq([Exception.new(123), Exception.new(456)])
+      flag = true
+    }
+    ch.close
+    expect(flag).to be true
+  end
+
+  it 'should fail and return error if only one error comes' do
+    flag = false
+    ch = Cocaine::Channel.new
+    ch.error Exception.new 123
+    df = ch.collect
+    df.errback { |errors|
+      expect(errors).to eq(Exception.new(123))
+      flag = true
+    }
+    ch.close
+    expect(flag).to be true
+  end
+end
+
+
+describe Cocaine::ChannelCombiner do
+  it 'should be' do
+    channel = Cocaine::Channel.new
+    Cocaine::ChannelCombiner.new channel
+  end
+
+  it 'should merge callbacks' do
+    flag = false
+    channel = Cocaine::Channel.new
+    zipper = Cocaine::ChannelCombiner.new channel
+    zipper.callback { |r|
+      expect(r.get).to eq('test')
+      flag = true
+    }
+    channel.trigger('test')
+
+    expect(flag).to be true
+  end
+
+  it 'should merge errorbacks' do
+    flag = false
+    channel = Cocaine::Channel.new
+    zipper = Cocaine::ChannelCombiner.new channel
+    zipper.callback { |r|
+      expect { r.get }.to raise_error(Exception)
+      flag = true
+    }
+    channel.error(Exception.new 'test')
+
+    expect(flag).to be true
+  end
+end

data/spec/connection_spec.rb

@@ -0,0 +1,31 @@
+require 'rspec'
+require 'msgpack'
+
+require_relative '../lib/cocaine/asio/connection'
+require_relative '../lib/cocaine/client/dispatcher'
+require_relative '../lib/cocaine/protocol'
+
+require_relative 'stub_server'
+
+describe Cocaine::Connection do
+  it 'should transmit received data to decoder' do
+    EventMachine::run {
+      msg = [4, 1, [['0.0.0.0', 0], 0, {0 => 'method'}].to_msgpack]
+      encoded_msg = msg.to_msgpack
+      server = StubServer.new(response: encoded_msg)
+
+      decoder = double()
+      expect(decoder).to receive(:feed).with(encoded_msg) do |&arg|
+        arg.call(msg)
+      end
+      EventMachine.connect '127.0.0.1', 9053, Cocaine::Connection, decoder do |conn|
+        dispatcher = Cocaine::ClientDispatcher.new conn
+        channel = dispatcher.invoke 0, 'bullshit'
+        channel.callback {
+          server.stop
+          EventMachine::stop
+        }
+      end
+    }
+  end
+end

data/spec/health_spec.rb

@@ -0,0 +1,19 @@
+require 'rspec'
+
+require_relative '../lib/cocaine/server/health'
+
+describe Cocaine::HealthManager do
+  it 'should be' do
+    d = double()
+    Cocaine::HealthManager.new d
+  end
+
+  it 'should stop event loop if nobody takes breath to it until timeout' do
+    EM.run do
+      d = double()
+      d.should_receive(:send_heartbeat).with(0).once
+      health = Cocaine::HealthManager.new d, disown: 0.0, heartbeat: 0.1
+      health.start()
+    end
+  end
+end

data/spec/service_spec.rb

@@ -0,0 +1,322 @@
+require 'rspec'
+
+require_relative '../lib/cocaine/client/service'
+require_relative '../lib/cocaine/protocol'
+require_relative '../lib/cocaine/synchrony/service'
+require_relative '../lib/cocaine/testing/mock_server'
+
+require_relative 'stub_server'
+
+
+describe Cocaine::Locator do
+  it 'should send correct message to the locator while resolving service' do
+    EM.run do
+      expected = {endpoint: ['127.0.0.1', 10054], version: 1, api: {0 => 'start_app', 1 => 'pause_app', 2 => 'list'}}
+      server = CocaineRuntimeMock.new
+      server.register 'node', 1, expected
+      server.run
+
+      locator = Cocaine::Locator.new
+      locator.resolve('node').callback { |endpoint, version, api|
+        expect(endpoint).to eq(expected[:endpoint])
+        expect(version).to eq(expected[:version])
+        expect(api).to eq(expected[:api])
+        EM.stop()
+      }.errback {
+        fail('Failed')
+        EM.stop()
+      }
+    end
+  end
+
+  it 'should trigger errorback if locator cannot be reached' do
+    EM.run do
+      locator = Cocaine::Locator.new
+      locator.resolve('node-when-locator-not-reached').callback {
+        fail('Failed')
+        EM.stop()
+      }.errback { |err|
+        expect(err).to eq(Cocaine::ConnectionError.new)
+        EM.stop()
+      }
+    end
+  end
+
+  it 'should trigger errorback is service can not be resolved' do
+    EM.run do
+      server = CocaineRuntimeMock.new
+      server.on 'locator', [0, 1, ['node']], [Error.new(1, 'service is not available')]
+      server.run
+
+      locator = Cocaine::Locator.new
+      locator.resolve('node').callback {
+        fail('Failed')
+        EM.stop()
+      }.errback { |err|
+        expect(err).to be_a(Cocaine::ServiceError)
+        EM.stop()
+      }
+    end
+  end
+end
+
+describe Cocaine::Service do
+  it 'should connect to the provided endpoint' do
+    flag = false
+    EM.run do
+      expected = {endpoint: ['127.0.0.1', 10054], version: 1, api: {0 => 'start_app', 1 => 'pause_app', 2 => 'list'}}
+      server = CocaineRuntimeMock.new
+      server.register 'node', 1, expected
+      server.when('node').connected do
+        flag = true
+        EM.stop
+      end
+      server.run
+
+      node = Cocaine::Service.new 'node'
+      node.connect
+    end
+    expect(flag).to be true
+  end
+
+  it 'should provide methods dynamically' do
+    flag = false
+    EM.run do
+      expected = {endpoint: ['127.0.0.1', 10054], version: 1, api: {0 => 'start_app', 1 => 'pause_app', 2 => 'list'}}
+      server = CocaineRuntimeMock.new
+      server.register 'node', 1, expected
+      server.when('node').message([2, 1, []]) do
+        flag = true
+        EM.stop
+        ['app']
+      end
+      server.run
+
+      node = Cocaine::Service.new 'node'
+      node.connect.callback {
+        node.list
+      }.errback { |err|
+        fail("Failed: #{err}")
+        EM.stop
+      }
+    end
+    expect(flag).to be true
+  end
+
+  it 'should return error if service cannot be reached' do
+    EM.synchrony do
+      server = CocaineRuntimeMock.new
+      server.on 'locator',
+                [0, 1, ['node']],
+                [[['127.0.0.1', 10054], 1, {0 => 'start_app', 1 => 'pause_app', 2 => 'list'}]]
+      server.run
+
+      node = Cocaine::Service.new 'node'
+      node.connect.callback {
+        fail('Failed')
+        EM.stop
+      }.errback { |err|
+        expect(err).to be_a(Cocaine::ConnectionError)
+        EM.stop
+      }
+    end
+  end
+
+  it 'should return future with error if service throws error' do
+    counter = 0
+    EM.synchrony do
+      expected = {endpoint: ['127.0.0.1', 10054], version: 1, api: {0 => 'list'}}
+      server = CocaineRuntimeMock.new
+      server.register 'node', 1, expected
+      server.when('node').message([0, 1, []]) do
+        [Error.new(1, 'wtf')]
+      end
+      server.run
+
+      expected = [Cocaine::ServiceError, ChokeEvent]
+      node = Cocaine::Service.new 'node'
+      node.connect.callback {
+        node.list.callback { |future|
+          expect { future.get }.to raise_error expected[counter]
+          counter += 1
+          EM.stop if counter == 2
+        }
+      }.errback {
+        fail('Failed')
+        EM.stop
+      }
+    end
+    expect(counter).to be 2
+  end
+end
+
+describe Cocaine::Synchrony::Service do
+  it 'should synchrony connect to the service' do
+    flag = false
+    EM.synchrony do
+      expected = {endpoint: ['127.0.0.1', 10054], version: 1, api: {}}
+      server = CocaineRuntimeMock.new
+      server.register 'mock-app', 1, expected
+      server.when('mock-app').connected do
+        flag = true
+        EM.stop
+      end
+      server.run
+
+      Cocaine::Synchrony::Service.new 'mock-app'
+    end
+    expect(flag).to be true
+  end
+
+  it 'should throw error on locator connect failure' do
+    EM.synchrony do
+      expect { Cocaine::Synchrony::Service.new 'mock-app' }.to raise_error Cocaine::ConnectionError
+      EM.stop
+    end
+  end
+
+  it 'should throw error on connect failure' do
+    EM.synchrony do
+      server = CocaineRuntimeMock.new
+      server.on 'locator',
+                [0, 1, ['mock-app']],
+                [[['127.0.0.1', 10054], 1, {0 => 'start_app', 1 => 'pause_app', 2 => 'list'}]]
+      server.run
+
+      expect { Cocaine::Synchrony::Service.new 'mock-app' }.to raise_error Cocaine::ConnectionError
+      EM.stop
+    end
+  end
+
+  it 'should synchrony read exactly one chunk' do
+    EM.synchrony do
+      expected = {endpoint: ['127.0.0.1', 10054], version: 1, api: {0 => 'enqueue', 1 => 'info'}}
+      server = CocaineRuntimeMock.new
+      server.register 'mock-app', 1, expected
+      server.when('mock-app').message([0, 1, ['ping', 'message']]) { ['chunk#1'] }
+      server.run
+
+      service = Cocaine::Synchrony::Service.new 'mock-app'
+      ch = service.enqueue('ping', 'message')
+      msg = ch.read
+      expect(msg).to eq('chunk#1')
+      EM.stop
+    end
+  end
+
+  it 'should synchrony read exactly three chunks' do
+    EM.synchrony do
+      expected = {endpoint: ['127.0.0.1', 10054], version: 1, api: {0 => 'enqueue', 1 => 'info'}}
+      server = CocaineRuntimeMock.new
+      server.register 'mock-app', 1, expected
+      server.when('mock-app').message([0, 1, ['ping', 'message']]) { ['chunk#1', 'chunk#2', 'chunk#3'] }
+      server.run
+
+      service = Cocaine::Synchrony::Service.new 'mock-app'
+      ch = service.enqueue('ping', 'message')
+      msg = [nil] * 3
+      msg[0] = ch.read
+      msg[1] = ch.read
+      msg[2] = ch.read
+      expect(msg).to eq(['chunk#1', 'chunk#2', 'chunk#3'])
+      EM.stop
+    end
+  end
+
+  it 'should synchrony partial read chunks via collect' do
+    EM.synchrony do
+      expected = {endpoint: ['127.0.0.1', 10054], version: 1, api: {0 => 'enqueue', 1 => 'info'}}
+      server = CocaineRuntimeMock.new
+      server.register 'mock-app', 1, expected
+      server.when('mock-app').message([0, 1, ['ping', 'message']]) { ['chunk#1', 'chunk#2', 'chunk#3'] }
+      server.run
+
+      service = Cocaine::Synchrony::Service.new 'mock-app'
+      ch = service.enqueue('ping', 'message')
+      actual = ch.collect(2)
+      expect(actual).to eq(['chunk#1', 'chunk#2'])
+      EM.stop
+    end
+  end
+
+  it 'should synchrony fully read chunks via collect' do
+    EM.synchrony do
+      expected = {endpoint: ['127.0.0.1', 10054], version: 1, api: {0 => 'enqueue', 1 => 'info'}}
+      server = CocaineRuntimeMock.new
+      server.register 'mock-app', 1, expected
+      server.when('mock-app').message([0, 1, ['ping', 'message']]) { ['chunk#1', 'chunk#2', 'chunk#3'] }
+      server.run
+
+      service = Cocaine::Synchrony::Service.new 'mock-app'
+      ch = service.enqueue('ping', 'message')
+      actual = ch.collect(3)
+      expect(actual).to eq(['chunk#1', 'chunk#2', 'chunk#3'])
+      EM.stop
+    end
+  end
+
+  it 'should synchrony read chunks until choke' do
+    EM.synchrony do
+      expected = {endpoint: ['127.0.0.1', 10054], version: 1, api: {0 => 'enqueue', 1 => 'info'}}
+      server = CocaineRuntimeMock.new
+      server.register 'mock-app', 1, expected
+      server.when('mock-app').message([0, 1, ['ping', 'message']]) { ['chunk#1', 'chunk#2', 'chunk#3'] }
+      server.run
+
+      service = Cocaine::Synchrony::Service.new 'mock-app'
+      ch = service.enqueue('ping', 'message')
+      actual = ch.collect()
+      expect(actual).to eq(['chunk#1', 'chunk#2', 'chunk#3'])
+      EM.stop
+    end
+  end
+
+  it 'should synchrony iterate chunks with each method' do
+    EM.synchrony do
+      expected = {endpoint: ['127.0.0.1', 10054], version: 1, api: {0 => 'enqueue', 1 => 'info'}}
+      server = CocaineRuntimeMock.new
+      server.register 'mock-app', 1, expected
+      server.when('mock-app').message([0, 1, ['ping', 'message']]) { ['chunk#1', 'chunk#2', 'chunk#3'] }
+      server.run
+
+      results = []
+      service = Cocaine::Synchrony::Service.new 'mock-app'
+      ch = service.enqueue('ping', 'message')
+      ch.each do |result|
+        results.push result
+      end
+      expect(results).to eq(['chunk#1', 'chunk#2', 'chunk#3'])
+      EM.stop
+    end
+  end
+
+  it 'should throw error on error received while single fetching' do
+    EM.synchrony do
+      expected = {endpoint: ['127.0.0.1', 10054], version: 1, api: {0 => 'enqueue', 1 => 'info'}}
+      server = CocaineRuntimeMock.new
+      server.register 'mock-app', 1, expected
+      server.when('mock-app').message([0, 1, ['ping', 'message']]) { [Error.new(1, 'Some error occurred')] }
+      server.run
+
+      service = Cocaine::Synchrony::Service.new 'mock-app'
+      ch = service.enqueue('ping', 'message')
+      expect { ch.read }.to raise_error Cocaine::ServiceError
+      EM.stop
+    end
+  end
+
+  it 'should throw error on error received while collect fetching' do
+    EM.synchrony do
+      expected = {endpoint: ['127.0.0.1', 10054], version: 1, api: {0 => 'enqueue', 1 => 'info'}}
+      server = CocaineRuntimeMock.new
+      server.register 'mock-app', 1, expected
+      server.when('mock-app').message([0, 1, ['ping', 'message']]) { ['chunk#1', Error.new(1, 'Some error occurred')] }
+      server.run
+
+      service = Cocaine::Synchrony::Service.new 'mock-app'
+      ch = service.enqueue('ping', 'message')
+      expect { ch.collect }.to raise_error Cocaine::ServiceError
+      EM.stop
+    end
+  end
+end