aggro 0.0.1 → 0.0.2

data/spec/lib/aggro/handler/command_spec.rb

@@ -0,0 +1,78 @@
+RSpec.describe Handler::Command do
+  subject(:handler) { Handler::Command.new message, server }
+
+  let(:command) { double }
+  let(:commandee_id) { SecureRandom.uuid }
+  let(:message) { double to_command: command, commandee_id: commandee_id }
+  let(:server) { double }
+
+  let(:node) { double }
+  let(:local) { true }
+  let(:fake_locator) { double local?: local, primary_node: node }
+  let(:locator_class) { double new: fake_locator }
+
+  before do
+    stub_const 'Aggro::Locator', locator_class
+  end
+
+  describe '#call' do
+    context 'comandee is not handled by the server' do
+      let(:node_id) { SecureRandom.uuid }
+      let(:client) { spy post: Message::OK.new }
+      let(:node) { double id: node_id, client: client }
+      let(:local) { false }
+
+      it 'should forward the request to the correct node and return reply' do
+        expect(handler.call).to be_a Message::OK
+        expect(client).to have_received(:post)
+      end
+    end
+
+    context 'local system knows the command' do
+      context 'commandee exists on system' do
+        let(:channel) { spy handles_command?: handles }
+
+        before do
+          fake_channels = { commandee_id => channel }
+          stub_const 'Aggro', double(channels: fake_channels)
+        end
+
+        context 'channel understands command type' do
+          let(:handles) { true }
+
+          it 'should return OK' do
+            expect(handler.call).to be_a Message::OK
+          end
+
+          it 'should forward command to the channel' do
+            handler.call
+
+            expect(channel).to have_received(:forward_command).with command
+          end
+        end
+
+        context 'channel does not understand command type' do
+          let(:handles) { false }
+
+          it 'should return UnhandledOperation' do
+            expect(handler.call).to be_a Message::UnhandledOperation
+          end
+        end
+      end
+
+      context 'commandee does not exist on system' do
+        it 'should return InvalidTarget' do
+          expect(handler.call).to be_a Message::InvalidTarget
+        end
+      end
+    end
+
+    context 'local system does not know the command' do
+      it 'should return UnknownOperation' do
+        allow(message).to receive(:to_command).and_return(nil)
+
+        expect(handler.call).to be_a Message::UnknownOperation
+      end
+    end
+  end
+end

data/spec/lib/aggro/handler/create_aggregate_spec.rb

@@ -0,0 +1,64 @@
+RSpec.describe Handler::CreateAggregate do
+  subject(:handler) { Handler::CreateAggregate.new message, server }
+
+  let(:type) { 'Test' }
+  let(:id) { SecureRandom.uuid }
+  let(:message) { double id: id, type: type }
+  let(:server) { double }
+
+  let(:node) { double }
+  let(:local) { true }
+  let(:fake_locator) { double local?: local, primary_node: node }
+  let(:locator_class) { double new: fake_locator }
+
+  let(:fake_store) { spy(create: true) }
+
+  before do
+    stub_const 'Aggro::Locator', locator_class
+
+    allow(Aggro).to receive(:store).and_return fake_store
+  end
+
+  describe '#call' do
+    context 'id is handled by the server' do
+      it 'should return an OK message' do
+        expect(handler.call).to be_a Message::OK
+      end
+
+      it 'should create the aggregate in the current store' do
+        handler.call
+
+        expect(fake_store).to have_received(:create).with(id, type)
+      end
+
+      context 'does not exist in the channel list' do
+        let(:fake_channels) { {} }
+
+        let(:fake_channel) { double }
+        let(:channel_class) { double new: fake_channel }
+
+        before do
+          allow(Aggro).to receive(:channels).and_return fake_channels
+          stub_const 'Aggro::Channel', channel_class
+        end
+
+        it 'should add a channel for the aggregate to the channels' do
+          handler.call
+
+          expect(fake_channels[id]).to eq fake_channel
+        end
+      end
+    end
+
+    context 'id is not handled by the server' do
+      let(:node_id) { SecureRandom.uuid }
+      let(:node) { double id: node_id }
+      let(:local) { false }
+
+      it 'should return Ask with another node to try' do
+        expect(handler.call).to be_a Message::Ask
+        expect(handler.call.node_id).to eq node_id
+      end
+    end
+  end
+end

data/spec/lib/aggro/handler/get_events_handler_spec.rb

@@ -0,0 +1,45 @@
+RSpec.describe Handler::GetEvents do
+  subject(:handler) { Handler::GetEvents.new message, server }
+
+  let(:type) { 'Test' }
+  let(:id) { SecureRandom.uuid }
+  let(:message) { double id: id, from_version: 0 }
+  let(:server) { double }
+
+  let(:node) { double }
+  let(:local) { true }
+  let(:fake_locator) { double local?: local, primary_node: node }
+  let(:locator_class) { double new: fake_locator }
+
+  let(:stream) { double id: id, type: type, events: [] }
+  let(:fake_store) { spy(read: [stream]) }
+
+  before do
+    stub_const 'Aggro::Locator', locator_class
+
+    allow(Aggro).to receive(:store).and_return fake_store
+  end
+
+  describe '#call' do
+    context 'id is handled by the server' do
+      it 'should return an Events message' do
+        response = handler.call
+
+        expect(response).to be_a Message::Events
+        expect(response.id).to eq id
+        expect(response.events).to eq []
+      end
+    end
+
+    context 'id is not handled by the server' do
+      let(:node_id) { SecureRandom.uuid }
+      let(:node) { double id: node_id }
+      let(:local) { false }
+
+      it 'should return Ask with another node to try' do
+        expect(handler.call).to be_a Message::Ask
+        expect(handler.call.node_id).to eq node_id
+      end
+    end
+  end
+end

data/spec/lib/aggro/handler/query_spec.rb

@@ -0,0 +1,78 @@
+RSpec.describe Handler::Query do
+  subject(:handler) { Handler::Query.new message, server }
+
+  let(:query) { double }
+  let(:queryable_id) { SecureRandom.uuid }
+  let(:message) { double to_query: query, queryable_id: queryable_id }
+  let(:server) { double }
+
+  let(:node) { double }
+  let(:local) { true }
+  let(:fake_locator) { double local?: local, primary_node: node }
+  let(:locator_class) { double new: fake_locator }
+
+  before do
+    stub_const 'Aggro::Locator', locator_class
+  end
+
+  describe '#call' do
+    context 'comandee is not handled by the server' do
+      let(:node_id) { SecureRandom.uuid }
+      let(:client) { spy post: Message::Result.new }
+      let(:node) { double id: node_id, client: client }
+      let(:local) { false }
+
+      it 'should forward the request to the correct node and return reply' do
+        expect(handler.call).to be_a Message::Result
+        expect(client).to have_received(:post)
+      end
+    end
+
+    context 'local system knows the query' do
+      context 'queryee exists on system' do
+        let(:channel) { spy handles_query?: handles }
+
+        before do
+          fake_channels = { queryable_id => channel }
+          stub_const 'Aggro', double(channels: fake_channels)
+        end
+
+        context 'channel understands query type' do
+          let(:handles) { true }
+
+          it 'should return Result' do
+            expect(handler.call).to be_a Message::Result
+          end
+
+          it 'should forward query to the channel' do
+            handler.call
+
+            expect(channel).to have_received(:run_query).with query
+          end
+        end
+
+        context 'channel does not understand query type' do
+          let(:handles) { false }
+
+          it 'should return UnhandledOperation' do
+            expect(handler.call).to be_a Message::UnhandledOperation
+          end
+        end
+      end
+
+      context 'queryee does not exist on system' do
+        it 'should return InvalidTarget' do
+          expect(handler.call).to be_a Message::InvalidTarget
+        end
+      end
+    end
+
+    context 'local system does not know the query' do
+      it 'should return UnknownOperation' do
+        allow(message).to receive(:to_query).and_return(nil)
+
+        expect(handler.call).to be_a Message::UnknownOperation
+      end
+    end
+  end
+end

data/spec/lib/aggro/handler/start_saga_spec.rb

@@ -0,0 +1,64 @@
+RSpec.describe Handler::StartSaga do
+  subject(:handler) { Handler::StartSaga.new message, server }
+
+  class TestSaga
+    include Saga
+  end
+
+  let(:id) { SecureRandom.uuid }
+  let(:args) { { test: 'foo' } }
+  let(:message) { double name: 'TestSaga', id: id, args: args }
+  let(:server) { double }
+
+  let(:node) { double }
+  let(:local) { true }
+  let(:fake_locator) { double local?: local, primary_node: node }
+  let(:locator_class) { double new: fake_locator }
+
+  before do
+    stub_const 'Aggro::Locator', locator_class
+  end
+
+  describe '#call' do
+    context 'saga is handled by the server' do
+      let(:channel) { spy }
+
+      before do
+        stub_const 'Aggro::Channel', double(new: channel)
+      end
+
+      context 'channel understands command type' do
+        it 'should return OK' do
+          expect(handler.call).to be_a Message::OK
+        end
+
+        it 'should send :start to the channel' do
+          handler.call
+
+          expect(channel).to have_received(:forward_command).with \
+            SagaRunner::StartSaga
+        end
+      end
+
+      context 'saga is not handled by the server' do
+        let(:node_id) { SecureRandom.uuid }
+        let(:client) { spy post: Message::OK.new }
+        let(:node) { double id: node_id, client: client }
+        let(:local) { false }
+
+        it 'should forward the request to the correct node and return reply' do
+          expect(handler.call).to be_a Message::OK
+          expect(client).to have_received(:post)
+        end
+      end
+    end
+
+    context 'local system does not know the command' do
+      it 'should return an UnknownOperation' do
+        allow(message).to receive(:name).and_return('NotReal')
+
+        expect(handler.call).to be_a Message::UnknownOperation
+      end
+    end
+  end
+end

data/spec/lib/aggro/local_node_spec.rb

@@ -0,0 +1,52 @@
+RSpec.describe LocalNode do
+  subject(:node) { LocalNode.new('flashing-sparkle') }
+
+  let(:fake_server) { spy(handle_message: 'OK') }
+
+  describe '#client' do
+    before do
+      allow(Aggro).to receive(:server).and_return(fake_server)
+    end
+
+    it 'should return a Client-like object which locally routes messages' do
+      node.client.post 'MSG'
+      expect(fake_server).to have_received(:handle_message).with('MSG')
+    end
+  end
+
+  describe '#endpoint' do
+    before do
+      allow(Aggro).to receive(:port).and_return 6000
+    end
+
+    it 'should have a local TCP endpoint with the correct port' do
+      expect(node.endpoint).to eq 'tcp://127.0.0.1:6000'
+    end
+  end
+
+  describe '#publisher_endpoint' do
+    before do
+      allow(Aggro).to receive(:publisher_port).and_return 7000
+    end
+
+    it 'should have a local TCP endpoint with the correct port' do
+      expect(node.publisher_endpoint).to eq 'tcp://127.0.0.1:7000'
+    end
+  end
+
+  describe '#to_s' do
+    let(:moved_node) { LocalNode.new('flashing-sparkle') }
+    let(:other_node) { LocalNode.new('dancing-sparkle') }
+
+    let(:ring) { ConsistentHashing::Ring.new }
+    let(:hasher) { ring.method(:hash_key) }
+
+    it 'should be consistently hashed the same if id matches' do
+      expect(hasher.call(node)).to eq hasher.call(moved_node)
+    end
+
+    it 'should be consistently hashed differently if id differs' do
+      expect(hasher.call(node)).to_not eq hasher.call(other_node)
+    end
+  end
+end

data/spec/lib/aggro/locator_spec.rb

@@ -0,0 +1,61 @@
+RSpec.describe Locator do
+  subject(:locator) { Locator.new id }
+
+  let(:id) { SecureRandom.uuid }
+  let(:node) { Node.new('flashing-sparkle', '10.0.0.70') }
+  let(:other_node) { Node.new('winking-tiger', '10.0.0.90') }
+  let(:nodes) { [node, other_node] }
+  let(:node_list) { spy(nodes_for: nodes, state: 'initial') }
+
+  before do
+    allow(Aggro).to receive(:node_list).and_return node_list
+  end
+
+  describe '#local?' do
+    context 'primary node is a LocalNode' do
+      let(:node) { LocalNode.new('flashing-sparkle') }
+
+      it 'should return true' do
+        expect(locator.local?).to be_truthy
+      end
+    end
+
+    context 'primary node is not a LocalNode' do
+      it 'should return true' do
+        expect(locator.local?).to be_falsey
+      end
+    end
+  end
+
+  describe '#nodes' do
+    it 'should return the nodes on which the aggregate should persist' do
+      expect(locator.nodes.first.endpoint).to eq '10.0.0.70'
+    end
+
+    it 'should memorize the lookup to reduce hashing' do
+      5.times { locator.nodes }
+
+      expect(node_list).to have_received(:nodes_for).once
+    end
+
+    it 'should forget memorized servers if ring state changes' do
+      locator.nodes
+      allow(node_list).to receive(:state).and_return('changed')
+      locator.nodes
+
+      expect(node_list).to have_received(:nodes_for).twice
+    end
+  end
+
+  describe '#primary_node' do
+    it 'should return the first associated node' do
+      expect(locator.primary_node).to eq node
+    end
+  end
+
+  describe '#secondary_nodes' do
+    it 'should return the rest of the associated nodes' do
+      expect(locator.secondary_nodes).to eq [other_node]
+    end
+  end
+end