aggro 0.0.1 → 0.0.2

data/spec/lib/aggro/message_parser_spec.rb

@@ -0,0 +1,16 @@
+RSpec.describe MessageParser do
+  subject(:router) { MessageRouter.new }
+
+  let(:message_class) { spy(parse: double) }
+
+  before do
+    stub_const 'Aggro::MESSAGE_TYPES', '01' => message_class
+  end
+
+  describe '.parse' do
+    it 'should parse messages via message parse function' do
+      MessageParser.parse '01'
+      expect(message_class).to have_received(:parse).with '01'
+    end
+  end
+end

data/spec/lib/aggro/message_router_spec.rb

@@ -0,0 +1,35 @@
+RSpec.describe MessageRouter do
+  subject(:router) { MessageRouter.new }
+
+  let(:message) { message_class.new }
+  let(:message_class) { Class.new }
+
+  before do
+    stub_const 'Aggro::MESSAGE_TYPES', '01' => message_class
+  end
+
+  describe '#attach_handler' do
+    it 'should attach a given callable to handle a specific message type' do
+      callable = ->(parsed) { parsed }
+
+      router.attach_handler message_class, callable
+
+      expect(router.handles?(message_class)).to be_truthy
+    end
+
+    it 'should attach a given block to handle a specific message type' do
+      router.attach_handler(message_class) { |parsed| parsed }
+
+      expect(router.handles?(message_class)).to be_truthy
+    end
+  end
+
+  describe '#route' do
+    it 'should route messages to the correct code' do
+      router.attach_handler(message_class) { |msg| @msg = msg }
+      router.route message
+
+      expect(@msg).to eq message
+    end
+  end
+end

data/spec/lib/aggro/nanomsg_transport/socket_error_spec.rb

@@ -0,0 +1,21 @@
+RSpec.describe NanomsgTransport::SocketError do
+  subject(:error) { NanomsgTransport::SocketError.new 5 }
+
+  let(:nanomsg_api) { spy nn_strerror: 'No u' }
+
+  before do
+    stub_const 'NNCore::LibNanomsg', nanomsg_api
+  end
+
+  describe '#to_s' do
+    it 'should ask nanomsg for the meaning of the errno' do
+      error.to_s
+
+      expect(nanomsg_api).to have_received(:nn_strerror).with 5
+    end
+
+    it 'should provide a human readable error message' do
+      expect(error.to_s).to eq "Last nanomsg API call failed with 'No u'"
+    end
+  end
+end

data/spec/lib/aggro/nanomsg_transport_spec.rb

@@ -0,0 +1,37 @@
+RSpec.describe NanomsgTransport do
+  let(:host) { 'tcp://127.0.0.1:7250' }
+  let(:message) { SecureRandom.hex }
+
+  xit 'should work for REQREP' do
+    server = NanomsgTransport.server(host) { |rec| @rec = rec }.start
+    client = NanomsgTransport.client host
+
+    client.post message
+
+    server.stop
+    client.close_socket
+
+    expect(@rec).to eq message
+  end
+
+  it 'should work for PUBSUB' do
+    publisher = NanomsgTransport.publisher(host)
+    publisher.open_socket
+
+    @reced = []
+
+    subscriber = NanomsgTransport.subscriber(host) { |rec| @reced << rec }
+    subscriber.add_subscription('foo').start
+
+    sleep 0.1
+
+    publisher.publish 'foobar'
+    publisher.publish 'bazbar'
+
+    publisher.close_socket
+    subscriber.stop
+
+    expect(@reced).to include 'foobar'
+    expect(@reced).to_not include 'bazbar'
+  end
+end

data/spec/lib/aggro/node_list_spec.rb

@@ -0,0 +1,38 @@
+RSpec.describe NodeList do
+  subject(:node_list) { NodeList.new }
+
+  let(:second_node_list) { NodeList.new }
+
+  let(:id) { SecureRandom.uuid }
+
+  let(:servers) { 10.times.map { |i| "localhost:#{5000 + i}" } }
+  let(:nodes) { servers.map { |server| Node.new(server, server) } }
+
+  describe '#add' do
+    it 'should add the node to the list of nodes' do
+      nodes.each { |node| node_list.add node }
+
+      expect(node_list.nodes.length).to eq nodes.length
+    end
+  end
+
+  describe '#nodes_for' do
+    before do
+      nodes.each { |node| node_list.add node }
+    end
+
+    it 'should get a number of nodes equal to the replication factor' do
+      expect(node_list.nodes_for(id, 4).length).to eq 4
+    end
+
+    it 'should have a default replication factor of 3' do
+      expect(node_list.nodes_for(id).length).to eq 3
+    end
+
+    it 'should give the same servers regardless of order of node addition' do
+      nodes.shuffle.each { |node| second_node_list.add node }
+
+      expect(node_list.nodes_for(id)).to eq second_node_list.nodes_for(id)
+    end
+  end
+end

data/spec/lib/aggro/node_spec.rb

@@ -0,0 +1,44 @@
+RSpec.describe Node do
+  subject(:node) { Node.new('flashing-sparkle') }
+
+  describe '#client' do
+    it 'should return a client for the node using the current transport' do
+      expect(node.client).to be_a Client
+    end
+  end
+
+  describe '#publisher_endpoint' do
+    context 'node returns an Endpoint message' do
+      it 'should ask the node for the publisher endpoint' do
+        endpoint = Message::Endpoint.new('endpoint')
+        allow(node).to receive(:client).and_return(double post: endpoint)
+
+        expect(node.publisher_endpoint).to eq 'endpoint'
+      end
+    end
+
+    context 'node does not return an Endpoint message' do
+      it 'should ask the node for the publisher endpoint' do
+        allow(node).to receive(:client).and_return(double post: 'not endpoint')
+
+        expect { node.publisher_endpoint }.to raise_error
+      end
+    end
+  end
+
+  describe '#to_s' do
+    let(:moved_node) { Node.new('flashing-sparkle') }
+    let(:other_node) { Node.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/projection_spec.rb

@@ -0,0 +1,22 @@
+RSpec.describe Projection do
+  class CatSerializer
+    include Aggro::Projection
+  end
+
+  subject(:projection) { CatSerializer.new id }
+
+  let(:id) { SecureRandom.uuid }
+  let(:event_bus) { spy }
+
+  before do
+    allow(Aggro).to receive(:event_bus).and_return(event_bus)
+  end
+
+  describe '.new' do
+    it 'should subscribe itself to events for the given ID' do
+      projection
+
+      expect(event_bus).to have_received(:subscribe).with id, projection
+    end
+  end
+end

data/spec/lib/aggro/query_spec.rb

@@ -0,0 +1,47 @@
+RSpec.describe Query do
+  class TestQuery
+    include Query
+
+    string :term
+    validates :term, presence: true
+
+    integer :times
+  end
+
+  subject(:query) { TestQuery.new term: 'puppy', times: '100' }
+
+  describe '#attributes' do
+    it 'should return a hash of attributes' do
+      expect(query.attributes).to be_a Hash
+      expect(query.attributes[:term]).to eq 'puppy'
+    end
+  end
+
+  describe '#serialized_attributes' do
+    it 'should return a hash of attributes run through the transforms' do
+      expect(query.serialized_attributes).to be_a Hash
+      expect(query.serialized_attributes[:times]).to eq 100
+    end
+  end
+
+  describe '#to_details' do
+    it 'should return a hash containing the query name and arguments' do
+      details = query.to_details
+
+      expect(details).to be_a Hash
+      expect(details[:name]).to eq 'TestQuery'
+      expect(details[:args][:term]).to eq 'puppy'
+      expect(details[:args][:times]).to eq 100
+    end
+  end
+
+  describe '#valid?' do
+    it 'should return true if query is valid' do
+      expect(query.valid?).to be_truthy
+    end
+
+    it 'should return false if query is not valid' do
+      expect(TestQuery.new.valid?).to be_falsey
+    end
+  end
+end

data/spec/lib/aggro/saga_runner_spec.rb

@@ -0,0 +1,84 @@
+RSpec.describe SagaRunner do
+  subject(:runner) { SagaRunner.new id }
+
+  let(:id) { SecureRandom.uuid }
+
+  let(:causation_id) { SecureRandom.uuid }
+  let(:correlation_id) { SecureRandom.uuid }
+  let(:saga) { spy causation_id: causation_id, correlation_id: correlation_id }
+  let(:handler) { -> { @ran = true } }
+  let(:saga_class) do
+    double new: saga, initial: :first_step, handler_for_step: handler
+  end
+
+  before do
+    stub_const 'TestSaga', saga_class
+
+    config = double(server_node?: true, node_name: SecureRandom.uuid, nodes: [])
+    allow(Aggro).to receive(:cluster_config).and_return config
+  end
+
+  describe '#apply_command' do
+    context 'the command is a StartSaga' do
+      let(:details) { { test: 'foo' } }
+      let(:command) do
+        SagaRunner::StartSaga.new name: 'TestSaga', id: id, details: details
+      end
+
+      it 'should create a new saga based on the given name' do
+        runner.send :apply_command, command
+        expect(saga_class).to have_received(:new)
+      end
+
+      it 'should set @runner on the saga' do
+        runner.send :apply_command, command
+        expect(saga.instance_variable_get(:@runner)).to eq runner
+      end
+
+      it 'should execute the initial step' do
+        runner.send :apply_command, command
+        expect(saga.instance_variable_get(:@ran)).to be_truthy
+      end
+    end
+  end
+
+  describe '#reject' do
+    let(:proxy) { spy }
+
+    before do
+      allow(runner).to receive(:did).and_return proxy
+      runner.instance_variable_set :@saga, saga
+    end
+
+    it 'should call the rejected event' do
+      runner.reject 'reason'
+
+      expect(proxy).to have_received(:rejected).with reason: 'reason'
+    end
+  end
+
+  describe '#resolve' do
+    let(:proxy) { spy }
+
+    before do
+      allow(runner).to receive(:did).and_return proxy
+      runner.instance_variable_set :@saga, saga
+    end
+
+    it 'should call the resolved event' do
+      runner.resolve 'value'
+
+      expect(proxy).to have_received(:resolved).with value: 'value'
+    end
+  end
+
+  describe '#did' do
+    it 'should set the @_context with @details' do
+      runner.instance_variable_set :@details,  foo: 'bar'
+
+      runner.send :did
+
+      expect(runner.instance_variable_get(:@_context)[:foo]).to eq 'bar'
+    end
+  end
+end

data/spec/lib/aggro/saga_spec.rb

@@ -0,0 +1,126 @@
+RSpec.describe Saga do
+  class PizzaMaker
+    include Saga
+
+    generate_id :pizza_id
+    id :oven_id
+    string :dough_type
+
+    initial :prepare_dough
+
+    step :prepare_dough do
+      pizza = Pizza.create.command(command1)
+
+      bind pizza do
+        def started_to_be_made
+          transition_to :add_toppings
+        end
+
+        def failed_to_start_making
+          reject "I couldn't makea the pizza"
+        end
+      end
+    end
+
+    step :add_toppings do
+      pizza = Pizza.find(pizza_id).command(command2)
+
+      bind pizza do
+        def started_to_be_made
+          transition_to :cook
+        end
+
+        def failed_to_add_toppings
+          reject "I couldn't topa the pizza"
+        end
+      end
+    end
+
+    step :cook do
+      oven = Oven.find(oven_id).command(command3)
+
+      bind oven do
+        def cooked_thing
+          resolve pizza_id
+        end
+
+        def failed_to_cook_thing
+          reject "I couldn't cooka the pizza"
+        end
+      end
+    end
+  end
+
+  subject(:saga) { PizzaMaker.new(oven_id: oven_id, dough_type: 'yummy') }
+
+  let(:oven_id) { SecureRandom.uuid }
+
+  let(:client) { spy }
+  let(:node) { double(client: client) }
+  let(:fake_locator) { double primary_node: node }
+  let(:locator_class) { double new: fake_locator }
+
+  let(:fake_status) { double }
+  let(:saga_status_class) { double new: fake_status }
+
+  before do
+    stub_const 'Aggro::Locator', locator_class
+    stub_const 'Aggro::SagaStatus', saga_status_class
+
+    allow(client).to receive(:post).and_return Message::OK.new
+  end
+
+  describe '#start' do
+    before do
+      saga.start
+
+      expect(client).to have_received(:post).with Message::StartSaga
+    end
+
+    it 'should return a SagaStatus' do
+      expect(saga.start).to eq fake_status
+    end
+  end
+
+  describe '#transition' do
+    it 'should call transition on the runner' do
+      runner = spy transition: true
+      saga.instance_variable_set(:@runner, runner)
+      saga.send :transition, :add_toppings
+
+      expect(runner).to have_received(:transition).with :add_toppings
+    end
+
+    it 'should fail if no runner' do
+      expect { saga.send :transition, :add_toppings }.to raise_error
+    end
+  end
+
+  describe '#resolve' do
+    it 'should call transition on the runner' do
+      runner = spy resolve: true
+      saga.instance_variable_set(:@runner, runner)
+      saga.send :resolve, 'value'
+
+      expect(runner).to have_received(:resolve).with 'value'
+    end
+
+    it 'should fail if no runner' do
+      expect { saga.send :resolve, 'value' }.to raise_error
+    end
+  end
+
+  describe '#reject' do
+    it 'should call transition on the runner' do
+      runner = spy reject: true
+      saga.instance_variable_set(:@runner, runner)
+      saga.send :reject, 'reason'
+
+      expect(runner).to have_received(:reject).with 'reason'
+    end
+
+    it 'should fail if no runner' do
+      expect { saga.send :reject, 'reason' }.to raise_error
+    end
+  end
+end