kamerling 0.0.1

data/spec/kamerling/repos_spec.rb

@@ -0,0 +1,136 @@
+require_relative '../spec_helper'
+
+module Kamerling describe Repos do
+  describe '.<<' do
+    it 'shuffles the object into the right repo' do
+      Repos.repos = { Object => repo = fake(:repo) }
+      Repos.<< object = Object.new
+      repo.must_have_received :<<, [object]
+    end
+
+    it 'can be chained' do
+      str_repo, sym_repo = fake(:repo), fake(:repo)
+      Repos.repos = { String => str_repo, Symbol => sym_repo }
+      Repos << 'str' << :sym
+      str_repo.must_have_received :<<, ['str']
+      sym_repo.must_have_received :<<, [:sym]
+    end
+  end
+
+  describe '.[]' do
+    it 'allows querying for repository objects' do
+      client = fake :client, uuid: UUID.new
+      Repos.repos = { Client => {} }
+      Repos[Client][client.uuid].must_be_nil
+      Repos.repos = { Client => { client.uuid => client } }
+      Repos[Client][client.uuid].must_equal client
+    end
+  end
+
+  describe '.clients' do
+    it 'returns all clients' do
+      Repos.repos = { Client => fake(:repo, all: all_clients = fake) }
+      Repos.clients.must_equal all_clients
+    end
+  end
+
+  describe '.clients_for' do
+    it 'returns all clients for the given project' do
+      clients  = [fake(:client), fake(:client)]
+      project  = fake :project
+      regs     = clients.map { |client| fake :registration, client: client }
+      reg_repo = fake :repo
+      stub(reg_repo).related_to(project) { regs }
+      Repos.repos = { Registration => reg_repo }
+      Repos.clients_for(project).must_equal clients
+    end
+  end
+
+  describe '.db=' do
+    it 'auto-migrates the passed db' do
+      db = Sequel.sqlite
+      warn_off { db.tables.wont_include :schema_info }
+      Repos.db = db
+      warn_off { db.tables.must_include :schema_info }
+    end
+  end
+
+  describe '.free_clients_for' do
+    it 'returns free clients for the given project' do
+      busy_client = fake :client, busy: true
+      free_client = fake :client, busy: false
+      busy_reg    = fake :registration, client: busy_client
+      free_reg    = fake :registration, client: free_client
+      project     = fake :project
+      repo        = fake :repo
+      stub(repo).related_to(project) { [busy_reg, free_reg] }
+      Repos.repos = { Registration => repo }
+      Repos.free_clients_for(project).must_equal [free_client]
+    end
+  end
+
+  describe '.next_task_for' do
+    it 'returns the next task for the given project' do
+      project   = fake :project
+      done_task = fake :task, done: true
+      new_task  = fake :task, done: false
+      repo      = fake :repo
+      stub(repo).related_to(project) { [done_task, new_task] }
+      Repos.repos = { Task => repo }
+      Repos.next_task_for(project).must_equal new_task
+    end
+  end
+
+  describe '.project' do
+    it 'returns the project with the given UUID' do
+      gimps = fake :project, uuid: UUID.new
+      Repos.repos = { Project => { gimps.uuid => gimps } }
+      Repos.project(gimps.uuid).must_equal gimps
+    end
+  end
+
+  describe '.projects' do
+    it 'returns all projects' do
+      Repos.repos = { Project => fake(:repo, all: all_projects = fake) }
+      Repos.projects.must_equal all_projects
+    end
+  end
+
+  describe '.tasks_for' do
+    it 'returns all tasks for the given project' do
+      project   = fake :project
+      tasks     = [fake(:task), fake(:task)]
+      task_repo = fake :repo
+      stub(task_repo).related_to(project) { tasks }
+      Repos.repos = { Task => task_repo }
+      Repos.tasks_for(project).must_equal tasks
+    end
+  end
+
+  describe 'when working on actual database' do
+    before { Repos.db = Sequel.sqlite }
+
+    it 'makes sure objects can be stored and retrieved' do
+      addr    = Addr['127.0.0.1', 1981, :TCP]
+      client  = Client.new addr: addr, uuid: UUID.new
+      project = Project.new name: 'project name', uuid: UUID.new
+      task    = Task.new data: 'data', project: project, uuid: UUID.new
+      reg     = Registration.new addr: addr, client: client, project: project
+      res     = Result.new addr: addr, client: client, data: 'da', task: task
+      Repos << client << project << task << reg << res
+      Repos[Client][client.uuid].must_equal client
+      Repos[Project][project.uuid].must_equal project
+      Repos[Registration][reg.uuid].must_equal reg
+      Repos[Result][res.uuid].must_equal res
+      Repos[Task][task.uuid].must_equal task
+    end
+
+    it 'makes sure objects can be updated' do
+      client = Client.new addr: Addr['127.0.0.1', 1979, :TCP], uuid: UUID.new
+      Repos << client
+      client.addr.port = 1981
+      Repos << client
+      Repos[Client][client.uuid].addr.port.must_equal 1981
+    end
+  end
+end end

data/spec/kamerling/server/http_spec.rb

@@ -0,0 +1,22 @@
+require_relative '../../spec_helper'
+
+module Kamerling describe Server::HTTP do
+  let(:addr) { Addr['localhost', 2009, :TCP] }
+
+  describe '#addr' do
+    it 'returns the server’s host + port as a TCP addr' do
+      Server::HTTP.new(addr: addr).addr.must_equal addr
+    end
+  end
+
+  describe '#start, #stop' do
+    it 'starts/stops a HTTP server on the given host and port' do
+      capture_io do
+        server = Server::HTTP.new(addr: addr).start
+        uri = URI.parse 'http://localhost:2009'
+        Net::HTTP.get_response(uri).must_be_kind_of Net::HTTPSuccess
+        server.stop
+      end
+    end
+  end
+end end

data/spec/kamerling/server/tcp_spec.rb

@@ -0,0 +1,46 @@
+require_relative '../../spec_helper'
+
+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
+    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]
+      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)) { raise Handler::UnknownInput }
+      TCPSocket.open(*server.addr) { |socket| socket << 'foo' }
+      server.stop
+    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
+    end
+  end
+end end

data/spec/kamerling/server/udp_spec.rb

@@ -0,0 +1,44 @@
+require_relative '../../spec_helper'
+
+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
+
+    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)) { raise Handler::UnknownInput }
+      UDPSocket.new.send 'foo', 0, *server.addr
+      run_all_threads
+      server.stop
+    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
+    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
+    end
+  end
+end end

data/spec/kamerling/server_runner_spec.rb

@@ -0,0 +1,65 @@
+require_relative '../spec_helper'
+
+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]
+    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,  []
+    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,  []
+    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
+    end
+  end
+end end

data/spec/kamerling/task_dispatcher_spec.rb

@@ -0,0 +1,23 @@
+require_relative '../spec_helper'
+
+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]
+      stub(repos).next_task_for(project) { task }
+      stub(repos).free_clients_for(project) { [client] }
+      net_dispatcher = fake :net_dispatcher
+
+      TaskDispatcher.new(net_dispatcher: net_dispatcher, repos: repos).dispatch
+
+      net_dispatcher.must_have_received :dispatch, [addr,
+        "DATA#{"\0" * 12}16B client  UUID16B project UUID16B task    UUIDdata"]
+      client.must_have_received :busy=, [true]
+      repos.must_have_received :<<, [client]
+    end
+  end
+end end

data/spec/kamerling/task_spec.rb

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

data/spec/kamerling/uuid_object_spec.rb

@@ -0,0 +1,101 @@
+require_relative '../spec_helper'
+
+module Kamerling describe '.UUIDObject' do
+  describe '.from_h' do
+    it 'deserialises the object from a Hash' do
+      Trivial = Kamerling.UUIDObject :question
+      Trivial.from_h(question: :answer).question.must_equal :answer
+    end
+
+    it 'deserialises addr' do
+      Netable = Kamerling.UUIDObject :addr
+      Netable.from_h(host: '127.0.0.1', port: 1981, prot: :TCP).addr
+        .must_equal Addr['127.0.0.1', 1981, :TCP]
+    end
+
+    it 'deserialises {client,project,task}_uuid' do
+      client  = fake :client,  uuid: UUID.new
+      project = fake :project, uuid: UUID.new
+      task    = fake :task,    uuid: UUID.new
+      Complete = Kamerling.UUIDObject :client, :project, :task
+      repos = {
+        Client  => { client.uuid  => client  },
+        Project => { project.uuid => project },
+        Task    => { task.uuid    => task    },
+      }
+      hash = { client_uuid: client.uuid, project_uuid: project.uuid,
+        task_uuid: task.uuid, uuid: UUID.new }
+      complete = Complete.from_h hash, repos: repos
+      complete.client.must_equal  client
+      complete.project.must_equal project
+      complete.task.must_equal    task
+    end
+  end
+
+  describe '.new' do
+    it 'creates a class with an UUID property defaulting to a random UUID' do
+      AttrLess = Kamerling.UUIDObject
+      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
+    end
+
+    it 'allows setting custom properties and raises when they lack defaults' do
+      FooFul = Kamerling.UUIDObject :foo
+      FooFul.new(foo: 'bar').foo.must_equal 'bar'
+      -> { FooFul.new }.must_raise RuntimeError
+    end
+
+    it 'allows setting properties’ default procs' do
+      ProcFul = Kamerling.UUIDObject rand: -> { rand }
+      ProcFul.new.rand.wont_equal ProcFul.new.rand
+    end
+
+    it 'allows setting properties’ default values' do
+      ValFul = Kamerling.UUIDObject bar: :baz
+      ValFul.new.bar.must_equal :baz
+    end
+  end
+
+  describe '#==' do
+    it 'reports UUID-based euqality' do
+      Actor = Kamerling.UUIDObject :name
+      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 = Kamerling.UUIDObject :param
+      Hashble.new(param: :val).to_h.must_equal param: :val, uuid: anything
+    end
+
+    it 'serialises addr' do
+      Addrble = Kamerling.UUIDObject :addr
+      addrble = Addrble.new addr: Addr['127.0.0.1', 1981, :TCP]
+      addrble.to_h.must_equal host: '127.0.0.1', port: 1981, prot: 'TCP',
+        uuid: anything
+    end
+
+    it 'serialises client' do
+      Clintable = Kamerling.UUIDObject :client
+      clintable = Clintable.new client: client = Client.new(addr: fake(:addr))
+      clintable.to_h.must_equal client_uuid: client.uuid, uuid: anything
+    end
+
+    it 'serialises project' do
+      Projable = Kamerling.UUIDObject :project
+      projable = Projable.new project: project = Project.new(name: 'name')
+      projable.to_h.must_equal project_uuid: project.uuid, uuid: anything
+    end
+
+    it 'serialises task' do
+      project = fake :project
+      Tskble = Kamerling.UUIDObject :task
+      tskble = Tskble.new task: task = Task.new(data: 'data', project: project)
+      tskble.to_h.must_equal task_uuid: task.uuid, uuid: anything
+    end
+  end
+end end

data/spec/kamerling/uuid_spec.rb

@@ -0,0 +1,24 @@
+require_relative '../spec_helper'
+
+module Kamerling describe UUID do
+  describe '.[]' do
+    it 'creates a normal UUID representation from binary data' do
+      uuid = '31364220-7072-6f6a-6563-742055554944'
+      UUID['16B project UUID'].must_equal uuid
+    end
+  end
+
+  describe '.bin' do
+    it 'returns the binary representation of an UUID' do
+      UUID.bin('31364220-7072-6f6a-6563-742055554944')
+        .must_equal '16B project UUID'
+    end
+  end
+
+  describe '.new' do
+    it 'creates a new random UUID' do
+      UUID.new.must_match(/\A\h{8}-\h{4}-\h{4}-\h{4}-\h{12}\z/)
+      UUID.new.wont_equal UUID.new
+    end
+  end
+end end

data/spec/spec_helper.rb

@@ -0,0 +1,26 @@
+require 'bundler/setup'
+require 'minitest/autorun'
+require 'minitest/focus'
+require 'minitest/pride'
+require 'bogus/minitest/spec'
+require 'net/http'
+require 'rack/test'
+require 'kamerling'
+
+Bogus.configure { |config| config.search_modules << Kamerling }
+
+module MiniTest::Spec::DSL
+  def fakes *args
+    args.map { |arg| fake arg }
+  end
+end
+
+class MiniTest::Spec
+  include Rack::Test::Methods
+end
+
+Thread.abort_on_exception = true
+
+def run_all_threads
+  sleep 0.001
+end