kamerling 0.0.2 → 0.0.3

data/spec/kamerling/server/tcp_spec.rb

@@ -1,46 +1,52 @@
+require 'socket'
 require_relative '../../spec_helper'
+require_relative '../../../lib/kamerling/addr'
+require_relative '../../../lib/kamerling/handler'
+require_relative '../../../lib/kamerling/message'
+require_relative '../../../lib/kamerling/server/tcp'
 
-module Kamerling describe Server::TCP do
-  let(:addr) { Addr['localhost', 1981, :TCP] }
+module Kamerling
+  describe Server::TCP do
+    let(:addr) { Addr['localhost', 1981, :TCP] }
 
-  describe '#addr' do
-    it 'returns the server’s host + port as a TCP addr' do
-      Server::TCP.new(addr: addr).addr.must_equal addr
+    describe '#addr' do
+      it 'returns the server’s host + port as a TCP addr' do
+        Server::TCP.new(addr: addr).addr.must_equal addr
+      end
     end
-  end
 
-  describe '#start' do
-    it 'listens on a TCP port and passes received inputs to the handler' do
-      server = Server::TCP.new addr: addr, handler: handler = fake(:handler)
-      server.start
-      s_addr_foo = TCPSocket.open(*server.addr) do |socket|
-        socket << 'foo'
-        Addr[*socket.local_address.ip_unpack, :TCP]
+    describe '#start' do
+      it 'listens on a TCP port and passes received inputs to the handler' do
+        server = Server::TCP.new(addr: addr, handler: handler = fake(:handler))
+        server.start
+        s_addr_foo = TCPSocket.open(*server.addr) do |socket|
+          socket << 'DATA'
+          Addr[*socket.local_address.ip_unpack, :TCP]
+        end
+        s_addr_bar = TCPSocket.open(*server.addr) do |socket|
+          socket << 'PING'
+          Addr[*socket.local_address.ip_unpack, :TCP]
+        end
+        run_all_threads
+        server.stop
+        handler.must_have_received :handle, [Message.parse('DATA'), s_addr_foo]
+        handler.must_have_received :handle, [Message.parse('PING'), s_addr_bar]
       end
-      s_addr_bar = TCPSocket.open(*server.addr) do |socket|
-        socket << 'bar'
-        Addr[*socket.local_address.ip_unpack, :TCP]
-      end
-      run_all_threads
-      server.stop
-      handler.must_have_received :handle, ['foo', s_addr_foo]
-      handler.must_have_received :handle, ['bar', s_addr_bar]
-    end
 
-    it 'doesn’t blow up on unknown inputs' do
-      server = Server::TCP.new addr: addr, handler: handler = fake(:handler)
-      server.start
-      stub(handler).handle('foo', any(Addr)) { fail Handler::UnknownInput }
-      TCPSocket.open(*server.addr) { |socket| socket << 'foo' }
-      server.stop
+      it 'doesn’t blow up on unknown inputs' do
+        server = Server::TCP.new(addr: addr)
+        server.start
+        TCPSocket.open(*server.addr) { |socket| socket << 'foo' }
+        server.stop
+      end
     end
-  end
 
-  describe '#stop' do
-    it 'stops the server' do
-      server = Server::TCP.new(addr: addr).start
-      server.stop
-      -> { TCPSocket.open(*addr).close }.must_raise Errno::ECONNREFUSED
+    describe '#stop' do
+      it 'stops the server' do
+        server = Server::TCP.new(addr: addr).start
+        server.stop
+        -> { TCPSocket.open(*addr).close }.must_raise Errno::ECONNREFUSED
+      end
     end
   end
-end end
+end

data/spec/kamerling/server/udp_spec.rb

@@ -1,44 +1,50 @@
+require 'socket'
 require_relative '../../spec_helper'
+require_relative '../../../lib/kamerling/addr'
+require_relative '../../../lib/kamerling/handler'
+require_relative '../../../lib/kamerling/message'
+require_relative '../../../lib/kamerling/server/udp'
 
-module Kamerling describe Server::UDP do
-  let(:addr) { Addr['localhost', 1979, :UDP] }
+module Kamerling
+  describe Server::UDP do
+    let(:addr) { Addr['localhost', 1979, :UDP] }
 
-  describe '#start' do
-    it 'listens on an UDP port and passes received inputs to the handler' do
-      server = Server::UDP.new addr: addr, handler: handler = fake(:handler)
-      server.start
-      foo = UDPSocket.new
-      bar = UDPSocket.new
-      foo.send 'foo', 0, *server.addr
-      bar.send 'bar', 0, *server.addr
-      foo_addr = Addr['127.0.0.1', foo.addr[1], :UDP]
-      bar_addr = Addr['127.0.0.1', bar.addr[1], :UDP]
-      run_all_threads
-      server.stop
-      handler.must_have_received :handle, ['foo', foo_addr]
-      handler.must_have_received :handle, ['bar', bar_addr]
-    end
+    describe '#start' do
+      it 'listens on an UDP port and passes received inputs to the handler' do
+        server = Server::UDP.new(addr: addr, handler: handler = fake(:handler))
+        server.start
+        foo = UDPSocket.new
+        bar = UDPSocket.new
+        3.times do
+          foo.send 'DATA', 0, *server.addr
+          bar.send 'PING', 0, *server.addr
+        end
+        run_all_threads
+        server.stop
+        handler.must_have_received :handle, [Message.parse('DATA'), any(Addr)]
+        handler.must_have_received :handle, [Message.parse('PING'), any(Addr)]
+      end
 
-    it 'doesn’t blow up on unknown inputs' do
-      server = Server::UDP.new addr: addr, handler: handler = fake(:handler)
-      server.start
-      stub(handler).handle('foo', any(Addr)) { fail Handler::UnknownInput }
-      UDPSocket.new.send 'foo', 0, *server.addr
-      run_all_threads
-      server.stop
+      it 'doesn’t blow up on unknown inputs' do
+        server = Server::UDP.new(addr: addr)
+        server.start
+        UDPSocket.new.send 'foo', 0, *server.addr
+        run_all_threads
+        server.stop
+      end
     end
-  end
 
-  describe '#stop' do
-    it 'closes the socket (and thus allows rebinding to it)' do
-      Server::UDP.new(addr: addr).start.stop
-      UDPSocket.new.tap { |socket| socket.bind(*addr) }.close
+    describe '#stop' do
+      it 'closes the socket (and thus allows rebinding to it)' do
+        Server::UDP.new(addr: addr).start.stop
+        UDPSocket.new.tap { |socket| socket.bind(*addr) }.close
+      end
     end
-  end
 
-  describe '#addr' do
-    it 'returns the server’s host + port as an UDP addr' do
-      Server::UDP.new(addr: addr).addr.must_equal addr
+    describe '#addr' do
+      it 'returns the server’s host + port as an UDP addr' do
+        Server::UDP.new(addr: addr).addr.must_equal addr
+      end
     end
   end
-end end
+end

data/spec/kamerling/server_runner_spec.rb

@@ -1,65 +1,74 @@
+require 'sequel'
 require_relative '../spec_helper'
+require_relative '../../lib/kamerling/addr'
+require_relative '../../lib/kamerling/repos'
+require_relative '../../lib/kamerling/server_runner'
+require_relative '../../lib/kamerling/server/http'
+require_relative '../../lib/kamerling/server/tcp'
+require_relative '../../lib/kamerling/server/udp'
 
-module Kamerling describe ServerRunner do
-  let(:http)    { fake { Server::HTTP }                       }
-  let(:tcp)     { fake { Server::TCP  }                       }
-  let(:udp)     { fake { Server::UDP  }                       }
-  let(:http_cl) { fake(as: :class) { Server::HTTP }           }
-  let(:tcp_cl)  { fake(as: :class) { Server::TCP  }           }
-  let(:udp_cl)  { fake(as: :class) { Server::UDP  }           }
-  let(:classes) { { http: http_cl, tcp: tcp_cl, udp: udp_cl } }
+module Kamerling
+  describe ServerRunner do
+    let(:http)    { fake { Server::HTTP }                       }
+    let(:tcp)     { fake { Server::TCP  }                       }
+    let(:udp)     { fake { Server::UDP  }                       }
+    let(:http_cl) { fake(as: :class) { Server::HTTP }           }
+    let(:tcp_cl)  { fake(as: :class) { Server::TCP  }           }
+    let(:udp_cl)  { fake(as: :class) { Server::UDP  }           }
+    let(:classes) { { http: http_cl, tcp: tcp_cl, udp: udp_cl } }
 
-  before do
-    http_addr = Addr['0.0.0.0', 1234, :TCP]
-    tcp_addr  = Addr['0.0.0.0', 3456, :TCP]
-    udp_addr  = Addr['0.0.0.0', 5678, :UDP]
-    stub(http_cl).new(addr: http_addr) { http }
-    stub(tcp_cl).new(addr:  tcp_addr)  { tcp  }
-    stub(udp_cl).new(addr:  udp_addr)  { udp  }
-  end
-
-  describe '.new' do
-    it 'hooks to the given database' do
-      args  = %w(--host 0.0.0.0 --db sqlite::memory:)
-      db    = fake { Sequel::SQLite::Database }
-      orm   = fake :sequel, as: :class
-      stub(orm).connect('sqlite::memory:') { db }
-      repos = fake :repos, as: :class
-      ServerRunner.new args, classes: classes, orm: orm, repos: repos
-      repos.must_have_received :db=, [db]
+    before do
+      http_addr = Addr['0.0.0.0', 1234, :TCP]
+      tcp_addr  = Addr['0.0.0.0', 3456, :TCP]
+      udp_addr  = Addr['0.0.0.0', 5678, :UDP]
+      stub(http_cl).new(addr: http_addr) { http }
+      stub(tcp_cl).new(addr:  tcp_addr)  { tcp  }
+      stub(udp_cl).new(addr:  udp_addr)  { udp  }
     end
-  end
 
-  describe '#join' do
-    it 'joins all the created servers' do
-      args = %w(--host 0.0.0.0 --http 1234)
-      ServerRunner.new(args, classes: classes).join
-      http.must_have_received :join, []
-      tcp.wont_have_received :join,  []
-      udp.wont_have_received :join,  []
+    describe '.new' do
+      it 'hooks to the given database' do
+        args  = %w(--host 0.0.0.0 --db sqlite::memory:)
+        db    = fake { Sequel::SQLite::Database }
+        orm   = fake(:sequel, as: :class)
+        stub(orm).connect('sqlite::memory:') { db }
+        repos = fake(:repos, as: :class)
+        ServerRunner.new args, classes: classes, orm: orm, repos: repos
+        repos.must_have_received :db=, [db]
+      end
     end
-  end
 
-  describe '#start' do
-    it 'starts the servers based on the given command-line parameters' do
-      args = %w(--host 0.0.0.0 --http 1234 --tcp 3456 --udp 5678)
-      ServerRunner.new(args, classes: classes).start
-      http.must_have_received :start, []
-      tcp.must_have_received :start,  []
-      udp.must_have_received :start,  []
+    describe '#join' do
+      it 'joins all the created servers' do
+        args = %w(--host 0.0.0.0 --http 1234)
+        ServerRunner.new(args, classes: classes).join
+        http.must_have_received :join, []
+        tcp.wont_have_received :join,  []
+        udp.wont_have_received :join,  []
+      end
     end
 
-    it 'starts only the servers for which the port was given' do
-      args = %w(--host 0.0.0.0 --http 1234)
-      ServerRunner.new(args, classes: classes).start
-      http.must_have_received :start, []
-      tcp.wont_have_received :start,  []
-      udp.wont_have_received :start,  []
-    end
+    describe '#start' do
+      it 'starts the servers based on the given command-line parameters' do
+        args = %w(--host 0.0.0.0 --http 1234 --tcp 3456 --udp 5678)
+        ServerRunner.new(args, classes: classes).start
+        http.must_have_received :start, []
+        tcp.must_have_received :start,  []
+        udp.must_have_received :start,  []
+      end
+
+      it 'starts only the servers for which the port was given' do
+        args = %w(--host 0.0.0.0 --http 1234)
+        ServerRunner.new(args, classes: classes).start
+        http.must_have_received :start, []
+        tcp.wont_have_received :start,  []
+        udp.wont_have_received :start,  []
+      end
 
-    it 'returns self' do
-      sr = ServerRunner.new [], classes: classes
-      sr.start.must_equal sr
+      it 'returns self' do
+        server_runner = ServerRunner.new([], classes: classes)
+        server_runner.start.must_equal server_runner
+      end
     end
   end
-end end
+end

data/spec/kamerling/settings_spec.rb

@@ -0,0 +1,36 @@
+require_relative '../spec_helper'
+require_relative '../../lib/kamerling/addr'
+require_relative '../../lib/kamerling/settings'
+
+module Kamerling
+  describe Settings do
+    let(:args) { %w(--db db --host 0.0.0.0 --http 2009 --tcp 1981 --udp 1979) }
+
+    describe '.new' do
+      it 'has sane defaults' do
+        Settings.new([]).db.must_equal   'sqlite::memory:'
+        Settings.new([]).host.must_equal '127.0.0.1'
+      end
+
+      it 'parses the passed settings' do
+        settings = Settings.new(args)
+        settings.db.must_equal   'db'
+        settings.host.must_equal '0.0.0.0'
+        settings.http.must_equal 2009
+        settings.tcp.must_equal  1981
+        settings.udp.must_equal  1979
+      end
+    end
+
+    describe '#server_addrs' do
+      it 'returns the server Addrs' do
+        Settings.new([]).server_addrs.must_equal({})
+        Settings.new(args).server_addrs.must_equal(
+          http: Addr['0.0.0.0', 2009, :TCP],
+          tcp:  Addr['0.0.0.0', 1981, :TCP],
+          udp:  Addr['0.0.0.0', 1979, :UDP],
+        )
+      end
+    end
+  end
+end

data/spec/kamerling/task_dispatcher_spec.rb

@@ -1,23 +1,46 @@
 require_relative '../spec_helper'
+require_relative '../../lib/kamerling/addr'
+require_relative '../../lib/kamerling/client'
+require_relative '../../lib/kamerling/dispatch'
+require_relative '../../lib/kamerling/message'
+require_relative '../../lib/kamerling/net_dispatcher'
+require_relative '../../lib/kamerling/project'
+require_relative '../../lib/kamerling/repos'
+require_relative '../../lib/kamerling/task'
+require_relative '../../lib/kamerling/task_dispatcher'
+require_relative '../../lib/kamerling/uuid'
 
-module Kamerling describe TaskDispatcher do
-  describe '#dispatch' do
-    it 'dispatches tasks to free clients and marks them as busy' do
-      addr    = fake :addr
-      client  = fake :client, addr: addr, uuid: UUID['16B client  UUID']
-      project = fake :project, uuid: UUID['16B project UUID']
-      task    = fake :task, data: 'data', uuid: UUID['16B task    UUID']
-      repos   = fake :repos, as: :class, projects: [project]
+module Kamerling
+  describe TaskDispatcher do
+    let(:addr)           { Addr.new                                      }
+    let(:client)         { Client.new(addr: addr)                        }
+    let(:net_dispatcher) { fake(:net_dispatcher, as: :class)             }
+    let(:project)        { Project.new                                   }
+    let(:repos)          { fake(:repos, as: :class, projects: [project]) }
+    let(:task)           { Task.new(data: 'data')                        }
+
+    before do
       stub(repos).next_task_for(project) { task }
       stub(repos).free_clients_for(project) { [client] }
-      net_dispatcher = fake :net_dispatcher, as: :class
+      td = TaskDispatcher.new(net_dispatcher: net_dispatcher, repos: repos)
+      td.dispatch_all
+    end
+
+    describe '#dispatch_all' do
+      it 'dispatches tasks to free clients' do
+        message = Message.build(client: client, payload: 'data',
+                                project: project, task: task, type: :DATA)
+        net_dispatcher.must_have_received :dispatch, [addr, message]
+      end
 
-      TaskDispatcher.new(net_dispatcher: net_dispatcher, repos: repos).dispatch
+      it 'marks clients as busy and persists the change' do
+        assert client.busy
+        repos.must_have_received :<<, [client]
+      end
 
-      header = "DATA#{"\0" * 12}16B client  UUID16B project UUID16B task    "
-      net_dispatcher.must_have_received :dispatch, [addr, header + 'UUIDdata']
-      client.must_have_received :busy=, [true]
-      repos.must_have_received :<<, [client]
+      it 'creates and stores a Dispatch object along the way' do
+        repos.must_have_received :<<, [any(Dispatch)]
+      end
     end
   end
-end end
+end

data/spec/kamerling/task_spec.rb

@@ -1,9 +1,13 @@
 require_relative '../spec_helper'
+require_relative '../../lib/kamerling/project'
+require_relative '../../lib/kamerling/task'
 
-module Kamerling describe Task do
-  describe '#done' do
-    it 'defaults to false' do
-      Task.new(data: 'data', project: fake(:project)).done.must_equal false
+module Kamerling
+  describe Task do
+    describe '#done' do
+      it 'defaults to false' do
+        refute Task.new(data: 'data', project: Project.new).done
+      end
     end
   end
-end end
+end

data/spec/kamerling/uuid_entity_spec.rb

@@ -1,35 +1,63 @@
 require_relative '../spec_helper'
+require_relative '../../lib/kamerling/uuid_entity'
 
-module Kamerling describe UUIDEntity do
-  describe '.from_h' do
-    it 'deserialises the object from a Hash' do
-      Trivial = Class.new(UUIDEntity) { attribute :question, Symbol }
-      Trivial.from_h(question: :answer).question.must_equal :answer
+module Kamerling
+  describe UUIDEntity do
+    describe '.attrs' do
+      it 'allows defining attributes in a key → class manner' do
+        person = Class.new(UUIDEntity) { attrs name: String, born: Integer }
+        person.attribute_set.map(&:name).must_equal %i(uuid name born)
+      end
     end
-  end
 
-  describe '.new' do
-    it 'creates a class with an UUID property defaulting to a random UUID' do
-      AttrLess = Class.new UUIDEntity
-      AttrLess.new.uuid.must_match(/\A\h{8}-\h{4}-\h{4}-\h{4}-\h{12}\z/)
-      AttrLess.new.uuid.wont_equal AttrLess.new.uuid
+    describe '.defaults' do
+      it 'allows defining attribute defaults' do
+        song = Class.new(UUIDEntity) do
+          attrs title: String, genre: Symbol
+          defaults genre: :ragga
+        end
+        song.new.genre.must_equal :ragga
+      end
     end
-  end
 
-  describe '#==' do
-    it 'reports UUID-based euqality' do
-      Actor = Class.new(UUIDEntity) { attribute :name, Symbol }
-      Actor.new(name: :laurel).wont_equal Actor.new name: :laurel
-      uuid = UUID.new
-      Actor.new(name: :laurel, uuid: uuid)
-        .must_equal Actor.new name: :hardy, uuid: uuid
+    describe '.new' do
+      it 'creates a class with an UUID property defaulting to a random UUID' do
+        attr_less = Class.new(UUIDEntity)
+        attr_less.new.uuid.must_match(/\A\h{8}-\h{4}-\h{4}-\h{4}-\h{12}\z/)
+        attr_less.new.uuid.wont_equal attr_less.new.uuid
+      end
+
+      it 'deserialises the object from a Hash' do
+        trivial = Class.new(UUIDEntity) { attrs question: Symbol }
+        trivial.new(question: :answer).question.must_equal :answer
+      end
     end
-  end
 
-  describe '#to_h' do
-    it 'serialises the object to a Hash' do
-      Hashble = Class.new(UUIDEntity) { attribute :param, Symbol }
-      Hashble.new(param: :val).to_h.must_equal param: :val, uuid: any(String)
+    describe '#==' do
+      it 'reports UUID-based euqality' do
+        actor = Class.new(UUIDEntity) { attrs name: Symbol }
+        actor.new(name: :laurel).wont_equal actor.new(name: :laurel)
+        uuid = UUID.new
+        actor.new(name: :laurel, uuid: uuid)
+          .must_equal actor.new(name: :hardy, uuid: uuid)
+      end
+    end
+
+    describe '#to_h' do
+      it 'serialises the object to a Hash' do
+        hashble = Class.new(UUIDEntity) { attrs param: Symbol }
+        hashble.new(param: :val).to_h.must_equal param: :val, uuid: any(String)
+      end
+
+      it 'serialises related UUIDEntities' do
+        child  = Class.new(UUIDEntity) { attrs name: String }
+        parent = Class.new(UUIDEntity) { attrs child: child, name: String }
+        zosia  = child.new(name: 'Zosia')
+        marta  = parent.new(child: zosia, name: 'Marta')
+        zosia_hash = { name: 'Zosia', uuid: zosia.uuid }
+        marta_hash = { child: zosia_hash, name: 'Marta', uuid: marta.uuid }
+        marta.to_h.must_equal marta_hash
+      end
     end
   end
-end end
+end