kamerling 0.0.2 → 0.0.3

data/spec/kamerling/mapper_spec.rb

@@ -0,0 +1,151 @@
+require_relative '../spec_helper'
+require_relative '../../lib/kamerling/addr'
+require_relative '../../lib/kamerling/client'
+require_relative '../../lib/kamerling/dispatch'
+require_relative '../../lib/kamerling/mapper'
+require_relative '../../lib/kamerling/project'
+require_relative '../../lib/kamerling/registration'
+require_relative '../../lib/kamerling/result'
+require_relative '../../lib/kamerling/task'
+
+module Kamerling
+  describe Mapper do
+    let(:addr)    { Addr['127.0.0.1', 1979, :TCP]                        }
+    let(:client)  { Client.new(addr: addr, busy: true, type: :FPGA)      }
+    let(:project) { Project.new(name: 'project')                         }
+    let(:task)    { Task.new(data: 'data', done: true, project: project) }
+
+    describe '.from_h' do
+      let(:repos) do
+        {
+          Client  => { client.uuid  => client  },
+          Project => { project.uuid => project },
+          Task    => { task.uuid    => task    },
+        }
+      end
+
+      it 'builds the proper Client from the Hash representation' do
+        hash = {
+          busy: true,
+          host: '127.0.0.1',
+          port: 1979,
+          prot: 'TCP',
+          type: 'FPGA',
+          uuid: client.uuid,
+        }
+        Mapper.from_h(Client, hash).to_h.must_equal client.to_h
+      end
+
+      it 'builds the proper Dispatch from the Hash representation' do
+        dispatch = Dispatch.new(addr: addr, client: client, project: project,
+                                task: task)
+        hash = {
+          client_uuid:   client.uuid,
+          data:          'data',
+          dispatched_at: any(Time),
+          host:          '127.0.0.1',
+          port:          1979,
+          project_uuid:  project.uuid,
+          prot:          'TCP',
+          task_uuid:     task.uuid,
+          uuid:          dispatch.uuid,
+        }
+        mapped = Mapper.from_h(Dispatch, hash, repos: repos)
+        mapped.to_h.must_equal dispatch.to_h
+      end
+
+      it 'builds the proper Project from the Hash representation' do
+        hash = { name: 'project', uuid: project.uuid }
+        Mapper.from_h(Project, hash).to_h.must_equal project.to_h
+      end
+
+      it 'builds the proper Registration from the Hash representation' do
+        reg = Registration.new(addr: addr, client: client, project: project)
+        hash = {
+          client_uuid:   client.uuid,
+          host:          '127.0.0.1',
+          port:          1979,
+          project_uuid:  project.uuid,
+          prot:          'TCP',
+          registered_at: any(Time),
+          uuid:          reg.uuid,
+        }
+        Mapper.from_h(Registration, hash, repos: repos).to_h.must_equal reg.to_h
+      end
+
+      it 'builds the proper Result from the Hash representation' do
+        result = Result.new(addr: addr, client: client, data: 'data',
+                            task: task)
+        hash = {
+          client_uuid: client.uuid,
+          data:        'data',
+          host:        '127.0.0.1',
+          port:        1979,
+          prot:        'TCP',
+          received_at: any(Time),
+          task_uuid:   task.uuid,
+          uuid:        result.uuid,
+        }
+        Mapper.from_h(Result, hash, repos: repos).to_h.must_equal result.to_h
+      end
+
+      it 'builds the proper Task from the Hash representation' do
+        hash = {
+          data:         'data',
+          done:         true,
+          project_uuid: project.uuid,
+          uuid:         task.uuid,
+        }
+        Mapper.from_h(Task, hash, repos: repos).to_h.must_equal task.to_h
+      end
+    end
+
+    describe '.to_h' do
+      it 'returns the proper Hash representation of a Client' do
+        Mapper.to_h(client).must_equal busy: true, host: '127.0.0.1',
+                                       port: 1979, prot: 'TCP',
+                                       type: 'FPGA', uuid: client.uuid
+      end
+
+      it 'returns the proper Hash representation of a Dispatch' do
+        dispatched_at = Time.new(2014, 7, 6, 5, 4, 3)
+        dispatch = Dispatch.new(addr: addr, client: client,
+                                dispatched_at: dispatched_at, project: project,
+                                task: task)
+        Mapper.to_h(dispatch).must_equal client_uuid:   client.uuid,
+                                         dispatched_at: dispatched_at,
+                                         host:          '127.0.0.1',
+                                         port:          1979,
+                                         prot:          'TCP',
+                                         project_uuid:  project.uuid,
+                                         task_uuid:     task.uuid,
+                                         uuid:          dispatch.uuid
+      end
+
+      it 'returns the proper Hash representation of a Registration' do
+        registered_at = Time.new(2014, 7, 6, 5, 4, 3)
+        reg = Registration.new(addr: addr, client: client, project: project,
+                               registered_at: registered_at)
+        Mapper.to_h(reg).must_equal client_uuid: client.uuid, host: '127.0.0.1',
+                                    port: 1979, prot: 'TCP',
+                                    project_uuid: project.uuid,
+                                    registered_at: registered_at, uuid: reg.uuid
+      end
+
+      it 'returns the proper Hash representation of a Result' do
+        received_at = Time.new(2014, 7, 6, 5, 4, 3)
+        result = Result.new(addr: addr, client: client, data: 'res',
+                            received_at: received_at, task: task)
+        Mapper.to_h(result).must_equal client_uuid: client.uuid, data: 'res',
+                                       host: '127.0.0.1', port: 1979,
+                                       prot: 'TCP', received_at: received_at,
+                                       task_uuid: task.uuid, uuid: result.uuid
+      end
+
+      it 'returns the proper Hash representation of a Tag' do
+        Mapper.to_h(task).must_equal data: 'data', done: true,
+                                     project_uuid: project.uuid, uuid: task.uuid
+      end
+    end
+  end
+end

data/spec/kamerling/message_spec.rb

@@ -1,70 +1,94 @@
 require_relative '../spec_helper'
+require_relative '../../lib/kamerling/client'
+require_relative '../../lib/kamerling/message'
+require_relative '../../lib/kamerling/project'
+require_relative '../../lib/kamerling/task'
+require_relative '../../lib/kamerling/uuid'
 
-module Kamerling describe Message do
-  let(:mess) do
-    Message.new "DATA\0\0\0\0\0\0\0\0\0\0\0\0" \
-      '16B client  UUID16B project UUID16B task    UUIDsome payload'
-  end
+module Kamerling
+  describe Message do
+    let(:mess) do
+      Message.parse("DATA\0\0\0\0\0\0\0\0\0\0\0\0" \
+        '16B client  UUID16B project UUID16B task    UUIDsome payload')
+    end
 
-  describe '.[]' do
-    it 'constructs a new message' do
-      client  = fake :client,  uuid: UUID.new
-      project = fake :project, uuid: UUID.new
-      task    = fake :task,    uuid: UUID.new
-      message = Message[client: client, payload: 'pay', project: project,
-                        task: task, type: :DATA]
-      message.client_uuid.must_equal client.uuid
-      message.project_uuid.must_equal project.uuid
-      message.task_uuid.must_equal task.uuid
-      message.payload.must_equal 'pay'
-      message.type.must_equal :DATA
+    describe '.build' do
+      it 'constructs a new message' do
+        client  = Client.new
+        project = Project.new
+        task    = Task.new
+        message = Message.build(client: client, payload: 'pay',
+                                project: project, task: task, type: :DATA)
+        message.client_uuid.must_equal client.uuid
+        message.project_uuid.must_equal project.uuid
+        message.task_uuid.must_equal task.uuid
+        message.payload.must_equal 'pay'
+        message.type.must_equal :DATA
+      end
     end
-  end
 
-  describe '.new' do
-    it 'raises on unknown message types' do
-      -> { Message.new 'MESS age' }.must_raise Message::UnknownType
+    describe '.parse' do
+      it 'raises on unknown message types' do
+        -> { Message.parse('MESS age') }.must_raise Message::UnknownType
+      end
+
+      it 'doesn’t raise on empty messages' do
+        Message.parse('')
+      end
     end
 
-    it 'doesn’t raise on empty messages' do
-      Message.new ''
+    describe '#client_type' do
+      it 'returns the client’s type' do
+        mess.client_type.must_equal :"\0\0\0\0"
+        fpga_mess = Message.parse("RGSTFPGA\0\0\0\0\0\0\0\0" \
+                                  '16B client  UUID16B project UUID' \
+                                  '16B task    UUID')
+        fpga_mess.client_type.must_equal :FPGA
+      end
     end
-  end
 
-  describe '#client_uuid' do
-    it 'returns the client UUID' do
-      mess.client_uuid.must_equal '31364220-636c-6965-6e74-202055554944'
+    describe '#client_uuid' do
+      it 'returns the client UUID' do
+        mess.client_uuid.must_equal '31364220-636c-6965-6e74-202055554944'
+      end
     end
-  end
 
-  describe '#payload' do
-    it 'returns the result payload' do
-      mess.payload.must_equal 'some payload'
+    describe '#payload' do
+      it 'returns the result payload' do
+        mess.payload.must_equal 'some payload'
+      end
     end
-  end
 
-  describe '#project_uuid' do
-    it 'returns the project UUID' do
-      mess.project_uuid.must_equal '31364220-7072-6f6a-6563-742055554944'
+    describe '#project_uuid' do
+      it 'returns the project UUID' do
+        mess.project_uuid.must_equal '31364220-7072-6f6a-6563-742055554944'
+      end
     end
-  end
 
-  describe '#task_uuid' do
-    it 'returns the task UUID' do
-      mess.task_uuid.must_equal '31364220-7461-736b-2020-202055554944'
+    describe '#task_uuid' do
+      it 'returns the task UUID' do
+        mess.task_uuid.must_equal '31364220-7461-736b-2020-202055554944'
+      end
     end
-  end
 
-  describe '#to_s' do
-    it 'returns the raw bytes' do
-      mess.to_s.must_equal "#{mess.type}\0\0\0\0\0\0\0\0\0\0\0\0" \
-        '16B client  UUID16B project UUID16B task    UUIDsome payload'
+    describe '#to_hex' do
+      it 'returns a hex representation of the message' do
+        assert mess.to_hex.start_with?('44 41 54 41')
+        assert mess.to_hex.end_with?('70 61 79 6c 6f 61 64')
+      end
+    end
+
+    describe '#to_s' do
+      it 'returns the raw bytes' do
+        mess.to_s.must_equal "#{mess.type}\0\0\0\0\0\0\0\0\0\0\0\0" \
+          '16B client  UUID16B project UUID16B task    UUIDsome payload'
+      end
     end
-  end
 
-  describe '#type' do
-    it 'returns the message type' do
-      mess.type.must_match(/\A[A-Z]{4}\z/)
+    describe '#type' do
+      it 'returns the message type' do
+        mess.type.must_match(/\A[A-Z]{4}\z/)
+      end
     end
   end
-end end
+end

data/spec/kamerling/net_dispatcher_spec.rb

@@ -1,21 +1,27 @@
+require 'socket'
 require_relative '../spec_helper'
+require_relative '../../lib/kamerling/addr'
+require_relative '../../lib/kamerling/message'
+require_relative '../../lib/kamerling/net_dispatcher'
 
-module Kamerling describe NetDispatcher do
-  describe '#dispatch' do
-    it 'dispatches messages to TCP clients' do
-      server = TCPServer.open 0
-      thread = Thread.new { server.accept.read }
-      addr   = Addr[server.addr[3], server.addr[1], :TCP]
-      NetDispatcher.dispatch addr, 'foo'
-      thread.value.must_equal 'foo'
-    end
+module Kamerling
+  describe NetDispatcher do
+    describe '#dispatch' do
+      it 'dispatches messages to TCP clients' do
+        server = TCPServer.open(0)
+        thread = Thread.new { server.accept.read }
+        addr   = Addr[server.addr[3], server.addr[1], :TCP]
+        NetDispatcher.dispatch addr, Message.parse('PING')
+        thread.value.must_equal 'PING'
+      end
 
-    it 'dispatches messages to UDP clients' do
-      server = UDPSocket.new.tap { |s| s.bind '127.0.0.1', 0 }
-      thread = Thread.new { server.recvfrom(2**16).first }
-      addr   = Addr[server.addr[3], server.addr[1], :UDP]
-      NetDispatcher.dispatch addr, 'foo'
-      thread.value.must_equal 'foo'
+      it 'dispatches messages to UDP clients' do
+        server = UDPSocket.new.tap { |s| s.bind '127.0.0.1', 0 }
+        thread = Thread.new { server.recvfrom(2**16).first }
+        addr   = Addr[server.addr[3], server.addr[1], :UDP]
+        NetDispatcher.dispatch addr, Message.parse('PING')
+        thread.value.must_equal 'PING'
+      end
     end
   end
-end end
+end

data/spec/kamerling/receiver_spec.rb

@@ -1,23 +1,33 @@
 require_relative '../spec_helper'
+require_relative '../../lib/kamerling/addr'
+require_relative '../../lib/kamerling/client'
+require_relative '../../lib/kamerling/message'
+require_relative '../../lib/kamerling/receiver'
+require_relative '../../lib/kamerling/repo'
+require_relative '../../lib/kamerling/repos'
+require_relative '../../lib/kamerling/result'
+require_relative '../../lib/kamerling/task'
 
-module Kamerling describe Receiver do
-  describe '#receive' do
-    fakes :addr, :client, :task
-
-    it 'saves the result and updates client and task' do
-      repos = fake :repos, as: :class
-      stub(repos).<<(any_args) { repos }
-      stub(repos).[](Client)   { fake :repo, :[] => client }
-      stub(repos).[](Task)     { fake :repo, :[] => task   }
-      Receiver.new.receive addr: addr, client_uuid: client.uuid, data: 'data',
-                           repos: repos, task_uuid: task.uuid
-      result = Result.new addr: addr, client: client, data: 'data', task: task,
-                          uuid: anything
-      client.must_have_received :busy=, [false]
-      task.must_have_received   :done=, [true]
-      repos.must_have_received  :<<,    [client]
-      repos.must_have_received  :<<,    [task]
-      repos.must_have_received  :<<,    [result]
+module Kamerling
+  describe Receiver do
+    describe '.receive' do
+      it 'saves the result and updates client and task' do
+        addr   = Addr.new
+        client = Client.new(busy: true)
+        task   = Task.new(done: false)
+        repos  = fake(:repos, as: :class)
+        stub(repos).<<(any_args) { repos }
+        stub(repos).[](Client)   { fake(:repo, :[] => client) }
+        stub(repos).[](Task)     { fake(:repo, :[] => task)   }
+        message = Message.build(client: client, payload: 'data',
+                                project: Project.new, task: task, type: :RSLT)
+        Receiver.receive addr: addr, message: message, repos: repos
+        refute client.busy
+        assert task.done
+        repos.must_have_received :<<, [client]
+        repos.must_have_received :<<, [any(Result)]
+        repos.must_have_received :<<, [task]
+      end
     end
   end
-end end
+end

data/spec/kamerling/registrar_spec.rb

@@ -1,20 +1,48 @@
 require_relative '../spec_helper'
+require_relative '../../lib/kamerling/addr'
+require_relative '../../lib/kamerling/client'
+require_relative '../../lib/kamerling/message'
+require_relative '../../lib/kamerling/project'
+require_relative '../../lib/kamerling/registration'
+require_relative '../../lib/kamerling/registrar'
+require_relative '../../lib/kamerling/repo'
 
-module Kamerling describe Registrar do
-  describe '#register' do
-    fakes :addr, :client, :project, :repo
+module Kamerling
+  describe Registrar do
+    describe '.register' do
+      let(:addr)    { Addr.new    }
+      let(:client)  { Client.new  }
+      let(:project) { Project.new }
 
-    it 'registers that the given client can do the given project' do
-      repos = {
-        Client       => { client.uuid  => client  },
-        Project      => { project.uuid => project },
-        Registration => repo,
-      }
-      Registrar.new.register addr: addr, client_uuid: client.uuid,
-                             project_uuid: project.uuid, repos: repos
-      registration = Registration.new addr: addr, client: client,
-                                      project: project, uuid: anything
-      repo.must_have_received :<<, [registration]
+      let(:mess) do
+        Message.build(client: client, payload: 'data', project: project,
+                      task: Task.new, type: :RGST)
+      end
+
+      let(:repos) { fake(:repos, as: :class) }
+
+      before do
+        stub(repos).[](Client)       { fake(:repo, :[] => client)  }
+        stub(repos).[](Project)      { fake(:repo, :[] => project) }
+        stub(repos).[](Registration) { fake(:repo)                 }
+      end
+
+      it 'registers that the given client can do the given project' do
+        Registrar.register addr: addr, message: mess, repos: repos
+        repos.must_have_received :<<, [any(Registration)]
+      end
+
+      it 'updates the clien’t addr' do
+        Registrar.register addr: addr, message: mess, repos: repos
+        repos.must_have_received :<<, [client]
+      end
+
+      it 'doesn’t blow up when a new client tries to register' do
+        empty_repo = fake(:repo, :[] => -> { fail Repo::NotFound })
+        stub(repos).[](Client) { empty_repo }
+        Registrar.register addr: addr, message: mess, repos: repos
+        repos.must_have_received :<<, [client]
+      end
     end
   end
-end end
+end