kamerling 0.0.2 → 0.0.3

data/spec/kamerling/registration_spec.rb

@@ -0,0 +1,17 @@
+require_relative '../spec_helper'
+require_relative '../../lib/kamerling/registration'
+
+module Kamerling
+  describe Registration do
+    describe '#registered_at' do
+      it 'defaults to the current time' do
+        registered_at = Registration.new.registered_at
+        assert registered_at.between?(Time.now - 1, Time.now + 1)
+      end
+
+      it 'defaults to the time of Registration’s creation' do
+        Registration.new.registered_at.wont_equal Registration.new.registered_at
+      end
+    end
+  end
+end

data/spec/kamerling/repo_spec.rb

@@ -1,60 +1,76 @@
+require 'sequel'
 require_relative '../spec_helper'
+require_relative '../../lib/kamerling/mapper'
+require_relative '../../lib/kamerling/project'
+require_relative '../../lib/kamerling/repo'
+require_relative '../../lib/kamerling/uuid'
+require_relative '../../lib/kamerling/uuid_entity'
 
-module Kamerling describe Repo do
-  Tune = Class.new(UUIDEntity) { attribute :genre, Symbol }
+module Kamerling
+  describe Repo do
+    Tune = Class.new(UUIDEntity) { attrs genre: Symbol }
 
-  describe '#<<' do
-    it 'passes the Hash version of an object to the source' do
-      tune   = Tune.new genre: :chap_hop
-      source = fake Sequel::Dataset
-      mock(source) << { genre: :chap_hop, uuid: tune.uuid }
-      Repo.new(Tune, source) << tune
-    end
+    describe '#<<' do
+      it 'passes the Hash version of an object to the source via a mapper' do
+        tune   = Tune.new(genre: :chap_hop)
+        source = fake(Sequel::Dataset)
+        Repo.new(Tune, source) << tune
+        source.must_have_received :<<, [tune.to_h]
+      end
 
-    it 'updates the source’s version if it exists there' do
-      dataset = fake Sequel::Dataset
-      source  = fake Sequel::Dataset
-      tune    = Tune.new genre: :chap_hop
-      stub(source).<<(tune.to_h) { fail Sequel::UniqueConstraintViolation }
-      stub(source).where(uuid: tune.uuid) { dataset }
-      Repo.new(Tune, source) << tune
-      dataset.must_have_received :update, [tune.to_h]
+      it 'updates the source’s version if it exists there' do
+        dataset = fake(Sequel::Dataset)
+        source  = fake(Sequel::Dataset)
+        tune    = Tune.new(genre: :chap_hop)
+        stub(source).<<(tune.to_h) { fail Sequel::UniqueConstraintViolation }
+        stub(source).where(uuid: tune.uuid) { dataset }
+        Repo.new(Tune, source) << tune
+        dataset.must_have_received :update, [tune.to_h]
+      end
     end
-  end
 
-  describe '#[]' do
-    it 'hydrates the object found in the repo' do
-      uuid   = UUID.new
-      source = { { uuid: uuid } => { genre: :chap_hop, uuid: uuid } }
-      Repo.new(Tune, source)[uuid]
-        .must_equal Tune.new genre: :chap_hop, uuid: uuid
-    end
+    describe '#[]' do
+      it 'hydrates the object found in the repo via a mapper' do
+        tune   = Tune.new(genre: :chap_hop)
+        hash   = { genre: :chap_hop, uuid: tune.uuid }
+        source = { { uuid: tune.uuid } => hash }
+        mapper = fake(:mapper, as: :class)
+        stub(mapper).from_h(Tune, hash) { tune }
+        retrieved = Repo.new(Tune, source, mapper: mapper)[tune.uuid]
+        retrieved.to_h.must_equal tune.to_h
+      end
 
-    it 'raises NotFound if the object is not found in the repo' do
-      -> { Repo.new(Tune, {})[UUID.new] }.must_raise Repo::NotFound
+      it 'raises NotFound if the object is not found in the repo' do
+        -> { Repo.new(Tune, {})[UUID.new] }.must_raise Repo::NotFound
+      end
     end
-  end
 
-  describe '#all' do
-    it 'returns all objects' do
-      tune = Tune.new genre: :chap_hop, uuid: UUID.new
-      source = fake Sequel::Dataset,
-                    all: [{ genre: :chap_hop, uuid: tune.uuid }]
-      Repo.new(Tune, source).all.must_equal [tune]
+    describe '#all' do
+      it 'returns all objects via a mapper' do
+        tune = Tune.new(genre: :chap_hop)
+        source = fake(Sequel::Dataset, all: [genre: :chap_hop, uuid: tune.uuid])
+        mapper = fake(:mapper, as: :class, from_h: tune)
+        Repo.new(Tune, source, mapper: mapper).all.must_equal [tune]
+      end
     end
-  end
 
-  describe '#related_to' do
-    it 'returns objects related to the given object' do
-      tunes   = [Tune.new(genre: :ragga), Tune.new(genre: :reggae)]
-      project = fake :project, uuid: UUID.new
-      results = [
-        { genre: :ragga, uuid: tunes.first.uuid },
-        { genre: :reggae, uuid: tunes.last.uuid },
-      ]
-      source = fake Sequel::Dataset
-      stub(source).where(project_uuid: project.uuid) { results }
-      Repo.new(Tune, source).related_to(project).must_equal tunes
+    describe '#related_to' do
+      it 'returns objects related to the given object via a mapper' do
+        ragga   = Tune.new(genre: :ragga)
+        reggae  = Tune.new(genre: :reggae)
+        project = Project.new
+        results = [
+          { genre: :ragga,  uuid: ragga.uuid  },
+          { genre: :reggae, uuid: reggae.uuid },
+        ]
+        source = fake(Sequel::Dataset)
+        stub(source).where(project_uuid: project.uuid) { results }
+        mapper = fake(:mapper, as: :class)
+        stub(mapper).from_h(Tune, genre: :ragga,  uuid: ragga.uuid)  { ragga  }
+        stub(mapper).from_h(Tune, genre: :reggae, uuid: reggae.uuid) { reggae }
+        repo = Repo.new(Tune, source, mapper: mapper)
+        repo.related_to(project).must_equal [ragga, reggae]
+      end
     end
   end
-end end
+end

data/spec/kamerling/repos_spec.rb

@@ -1,136 +1,148 @@
+require 'sequel'
 require_relative '../spec_helper'
+require_relative '../../lib/kamerling/addr'
+require_relative '../../lib/kamerling/client'
+require_relative '../../lib/kamerling/project'
+require_relative '../../lib/kamerling/registration'
+require_relative '../../lib/kamerling/repo'
+require_relative '../../lib/kamerling/repos'
+require_relative '../../lib/kamerling/result'
+require_relative '../../lib/kamerling/task'
+require_relative '../../lib/kamerling/uuid'
 
-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
+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]
+      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
-  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
+    describe '.[]' do
+      it 'allows querying for repository objects' do
+        client = Client.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
-  end
 
-  describe '.clients' do
-    it 'returns all clients' do
-      Repos.repos = { Client => fake(:repo, all: all_clients = fake) }
-      Repos.clients.must_equal all_clients
+    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
-  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
+    describe '.clients_for' do
+      it 'returns all clients for the given project' do
+        clients  = [Client.new, Client.new]
+        project  = Project.new
+        regs     = clients.map { |client| Registration.new(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
-  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 }
+    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
-  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]
+    describe '.free_clients_for' do
+      it 'returns free clients for the given project' do
+        busy_client = Client.new(busy: true)
+        free_client = Client.new(busy: false)
+        busy_reg    = Registration.new(client: busy_client)
+        free_reg    = Registration.new(client: free_client)
+        project     = Project.new
+        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
-  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
+    describe '.next_task_for' do
+      it 'returns the next task for the given project' do
+        project   = Project.new
+        done_task = Task.new(done: true)
+        new_task  = Task.new(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
-  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
+    describe '.project' do
+      it 'returns the project with the given UUID' do
+        gimps = Project.new
+        Repos.repos = { Project => { gimps.uuid => gimps } }
+        Repos.project(gimps.uuid).must_equal gimps
+      end
     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
+    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
-  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
+    describe '.tasks_for' do
+      it 'returns all tasks for the given project' do
+        project   = Project.new
+        tasks     = [Task.new, Task.new]
+        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
-  end
 
-  describe 'when working on actual database' do
-    before { Repos.db = Sequel.sqlite }
+    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 stored and retrieved' do
+        addr    = Addr['127.0.0.1', 1981, :TCP]
+        client  = Client.new(addr: addr)
+        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
+      it 'makes sure objects can be updated' do
+        client = Client.new(addr: Addr['127.0.0.1', 1979, :TCP])
+        Repos << client
+        client.busy = true
+        Repos << client
+        assert Repos[Client][client.uuid].busy
+      end
     end
   end
-end end
+end

data/spec/kamerling/result_spec.rb

@@ -0,0 +1,16 @@
+require_relative '../spec_helper'
+require_relative '../../lib/kamerling/result'
+
+module Kamerling
+  describe Result do
+    describe '#received_at' do
+      it 'defaults to the current time' do
+        assert Result.new.received_at.between?(Time.now - 1, Time.now + 1)
+      end
+
+      it 'defaults to the time of Result’s creation' do
+        Result.new.received_at.wont_equal Result.new.received_at
+      end
+    end
+  end
+end

data/spec/kamerling/server/http_spec.rb

@@ -1,22 +1,27 @@
+require 'net/http'
+require 'uri'
 require_relative '../../spec_helper'
+require_relative '../../../lib/kamerling/server/http'
 
-module Kamerling describe Server::HTTP do
-  let(:addr) { Addr['localhost', 2009, :TCP] }
+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
+    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
-  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
+    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 end
+end