aggro 0.0.1 → 0.0.2

data/spec/lib/aggro/saga_status_spec.rb

@@ -0,0 +1,56 @@
+RSpec.describe SagaStatus do
+  subject(:status) { SagaStatus.new saga_id }
+  let(:saga_id) { SecureRandom.uuid }
+
+  let(:event_bus) { spy subscribe: true }
+
+  before do
+    allow(Aggro).to receive(:event_bus).and_return event_bus
+  end
+
+  describe '.new' do
+    it 'should subscribe to the SagaRunner with the saga_runner namespace' do
+      status
+
+      expect(event_bus).to have_received(:subscribe).with saga_id, status
+    end
+  end
+
+  describe 'events' do
+    describe '#started' do
+      it 'should put the status into a pending state' do
+        status._started
+
+        expect(status.state).to eq :pending
+      end
+    end
+
+    describe '#rejected' do
+      it 'should put the status into a rejected state' do
+        status._rejected 'reason'
+
+        expect(status.state).to eq :rejected
+      end
+
+      it 'should set the reason' do
+        status._rejected 'reason'
+
+        expect(status.reason).to eq 'reason'
+      end
+    end
+
+    describe '#rejected' do
+      it 'should put the status into a rejected state' do
+        status._resolved 'value'
+
+        expect(status.state).to eq :fulfilled
+      end
+
+      it 'should set the value' do
+        status._resolved 'value'
+
+        expect(status.value).to eq 'value'
+      end
+    end
+  end
+end

data/spec/lib/aggro/server_spec.rb

@@ -0,0 +1,118 @@
+RSpec.describe Server do
+  subject(:server) { Server.new endpoint, publisher_endpoint }
+
+  let(:endpoint) { 'tcp://127.0.0.1:5000' }
+  let(:publisher_endpoint) { 'tcp://127.0.0.1:6000' }
+  let(:transport_server) { spy }
+  let(:transport_pub) { spy(publish: true) }
+  let(:transport) { spy(server: transport_server, publisher: transport_pub) }
+
+  before do
+    allow(Aggro).to receive(:transport).and_return transport
+  end
+
+  describe '.new' do
+    let(:handler) { server.method(Server::RAW_HANDLER) }
+
+    it 'should get a server which calls handler from current transport' do
+      server
+
+      expect(transport).to have_received(:server).with(endpoint, handler)
+    end
+
+    it 'should designate a handler which responds to raw messages' do
+      raw_message = Message::Heartbeat.new(SecureRandom.uuid).to_s
+
+      expect(handler.call(raw_message)).to be_a Message::OK
+    end
+
+    it 'should start a publisher for the node using the current transport' do
+      server
+
+      expect(transport).to have_received(:publisher).with(publisher_endpoint)
+    end
+  end
+
+  describe '#bind' do
+    it 'should start the transport server' do
+      server.bind
+
+      expect(transport_server).to have_received(:start)
+    end
+  end
+
+  describe '#publish' do
+    it 'publish the events to the publisher transport' do
+      server.publish :events
+
+      expect(transport_pub).to have_received(:publish).with :events
+    end
+  end
+
+  describe '#handle_message' do
+    let(:sender) { SecureRandom.uuid }
+
+    context 'message is a Command' do
+      let(:commandee_id) { SecureRandom.uuid }
+      let(:details) { { name: 'TestCommand', args: { thing: 'puppy' } } }
+      let(:message) { Message::Command.new(sender, commandee_id, details) }
+
+      it 'should delegate to command handler' do
+        handler = spy(call: true)
+        handler_class = spy(new: handler)
+
+        stub_const 'Aggro::Handler::Command', handler_class
+
+        server.handle_message message
+
+        expect(handler_class).to have_received(:new).with(message, server)
+        expect(handler).to have_received(:call)
+      end
+    end
+
+    context 'message is a CreateAggregate' do
+      let(:id) { SecureRandom.uuid }
+      let(:type) { 'Test' }
+      let(:message) { Message::CreateAggregate.new(sender, id, type) }
+
+      it 'should delegate to command handler' do
+        handler = spy(call: true)
+        handler_class = spy(new: handler)
+
+        stub_const 'Aggro::Handler::CreateAggregate', handler_class
+
+        server.handle_message message
+
+        expect(handler_class).to have_received(:new).with(message, server)
+        expect(handler).to have_received(:call)
+      end
+    end
+
+    context 'message is a Heartbeat' do
+      let(:message) { Message::Heartbeat.new(sender) }
+
+      it 'should return an OK message' do
+        expect(server.handle_message(message)).to be_a Message::OK
+      end
+    end
+
+    context 'message is a PublisherEndpointInquiry' do
+      let(:message) { Message::PublisherEndpointInquiry.new(sender) }
+
+      it 'should return an Endpoint message with the publisher endpoint' do
+        response = server.handle_message(message)
+
+        expect(response).to be_a Message::Endpoint
+        expect(response.endpoint).to eq publisher_endpoint
+      end
+    end
+  end
+
+  describe '#stop' do
+    it 'should stop the transport server' do
+      server.stop
+
+      expect(transport_server).to have_received(:stop)
+    end
+  end
+end

data/spec/lib/aggro/subscriber_spec.rb

@@ -0,0 +1,59 @@
+RSpec.describe Subscriber do
+  subject(:subscriber) { Subscriber.new(endpoint, callable) }
+
+  let(:callable) { spy }
+  let(:endpoint) { 'tcp://127.0.0.1:6000' }
+  let(:transport_sub) { spy }
+  let(:transport) { spy(subscriber: transport_sub) }
+
+  before do
+    allow(Aggro).to receive(:transport).and_return transport
+  end
+
+  describe '.new' do
+    let(:handler) { subscriber.method(Subscriber::RAW_HANDLER) }
+
+    it 'should get a server which calls handler from current transport' do
+      subscriber
+
+      expect(transport).to have_received(:subscriber).with(endpoint, handler)
+    end
+
+    it 'should designate a handler which parses raw messages' do
+      topic = SecureRandom.uuid
+      raw_message = Message::Events.new(topic, []).to_s
+      handler.call(raw_message)
+
+      expect(callable).to have_received(:call).with(topic, [])
+    end
+  end
+
+  describe '#bind' do
+    it 'should start the transport server' do
+      subscriber.bind
+
+      expect(transport_sub).to have_received(:start)
+    end
+  end
+
+  describe '#handle_message' do
+    context 'message is an Events' do
+      let(:topic) { SecureRandom.uuid }
+      let(:message) { Message::Events.new(topic, []) }
+
+      it 'should call the callback with the topic and events' do
+        subscriber.handle_message message
+
+        expect(callable).to have_received(:call).with(topic, [])
+      end
+    end
+  end
+
+  describe '#stop' do
+    it 'should stop the transport server' do
+      subscriber.stop
+
+      expect(transport_sub).to have_received(:stop)
+    end
+  end
+end

data/spec/lib/aggro/subscription_spec.rb

@@ -0,0 +1,50 @@
+RSpec.describe Subscription do
+  subject(:subscription) { Subscription.new topic, subscriber, ns, filters, 0 }
+
+  let(:topic) { SecureRandom.uuid }
+  let(:subscriber) { double }
+  let(:ns) { :test }
+  let(:filters) { { correlation_id: correlation_id } }
+
+  let(:correlation_id) { SecureRandom.uuid }
+  let(:details) {  { name: 'Sebastian', correlation_id: correlation_id } }
+  let(:event) { double(name: 'added_contact', details: details) }
+
+  let(:invokr) { spy }
+  before { stub_const 'Invokr', invokr }
+
+  describe '#handle_event' do
+    context 'subscriber can handle the event' do
+      before { allow(subscriber).to receive(:handles_event?).and_return true }
+
+      context 'the filters match the event details' do
+        it 'should call the event on the subscriber with the event details' do
+          subscription.handle_event event
+
+          expect(invokr).to have_received(:invoke).with \
+            on: subscriber, method: 'test_added_contact', using: details
+        end
+      end
+
+      context 'the filters do not match the event details' do
+        let(:details) {  { name: 'Sebastian' } }
+
+        it 'should not call the event on the subscriber' do
+          subscription.handle_event event
+
+          expect(invokr).to_not have_received(:invoke)
+        end
+      end
+    end
+
+    context 'subscriber cannot handle the event' do
+      before { allow(subscriber).to receive(:handles_event?).and_return false }
+
+      it 'should not call the event on the subscriber' do
+        subscription.handle_event event
+
+        expect(invokr).to_not have_received(:invoke)
+      end
+    end
+  end
+end

data/spec/lib/aggro/transform/boolean_spec.rb

@@ -0,0 +1,23 @@
+RSpec.describe Transform::Boolean do
+  describe '.deserialize' do
+    it 'should transform the value to a boolean' do
+      expect(Transform::Boolean.deserialize(false)).to eq false
+      expect(Transform::Boolean.deserialize(true)).to eq true
+    end
+
+    it 'should return nil if no boolean appropriate' do
+      expect(Transform::Boolean.deserialize('test')).to eq nil
+    end
+  end
+
+  describe '.serialize' do
+    it 'should pass through value if a bool' do
+      expect(Transform::Boolean.serialize(false)).to eq false
+      expect(Transform::Boolean.serialize(true)).to eq true
+    end
+
+    it 'should return nil if not a bool' do
+      expect(Transform::Boolean.serialize('test')).to eq nil
+    end
+  end
+end

data/spec/lib/aggro/transform/email_spec.rb

@@ -0,0 +1,13 @@
+RSpec.describe Transform::Email do
+  describe '#serialize' do
+    it 'should return the value if valid' do
+      email = 'me@sebastianedwards.co.nz'
+
+      expect(Transform::Email.serialize(email)).to eq email
+    end
+
+    it 'should return nil if invalid' do
+      expect(Transform::Email.serialize('not an id')).to eq nil
+    end
+  end
+end

data/spec/lib/aggro/transform/id_spec.rb

@@ -0,0 +1,70 @@
+RSpec.describe Transform::ID do
+  REGEX = Transform::ID::ID_REGEX
+
+  context 'generate flag is true' do
+    subject(:transformer) { Transform::ID.new generate: true }
+
+    describe '#deserialize' do
+      it 'should return the value if valid ID value' do
+        id = SecureRandom.uuid
+
+        expect(transformer.deserialize(id)).to eq id
+      end
+
+      it 'should generate a new ID if invalid value' do
+        expect(transformer.deserialize('not an id')).to_not eq 'not an id'
+        expect(transformer.deserialize('not an id')).to match REGEX
+      end
+
+      it 'should generate a new ID if nil value' do
+        expect(transformer.deserialize(nil)).to_not eq nil
+        expect(transformer.deserialize(nil)).to match REGEX
+      end
+    end
+
+    describe '#serialize' do
+      it 'should return the value if valid' do
+        id = SecureRandom.uuid
+
+        expect(transformer.serialize(id)).to eq id
+      end
+
+      it 'should return a generated ID if invalid' do
+        expect(transformer.serialize('not an id')).to_not eq 'not an id'
+        expect(transformer.serialize('not an id')).to match REGEX
+      end
+    end
+  end
+
+  context 'generate flag is false or unset' do
+    subject(:transformer) { Transform::ID.new }
+
+    describe '#deserialize' do
+      it 'should return the value if valid ID value' do
+        id = SecureRandom.uuid
+
+        expect(transformer.deserialize(id)).to eq id
+      end
+
+      it 'should return nil if invalid value' do
+        expect(transformer.deserialize('not an id')).to eq nil
+      end
+
+      it 'should return nil if nil value' do
+        expect(transformer.deserialize(nil)).to eq nil
+      end
+    end
+
+    describe '#serialize' do
+      it 'should return the value if valid' do
+        id = SecureRandom.uuid
+
+        expect(transformer.serialize(id)).to eq id
+      end
+
+      it 'should return nil if invalid' do
+        expect(transformer.serialize('not an id')).to eq nil
+      end
+    end
+  end
+end

data/spec/lib/aggro/transform/integer_spec.rb

@@ -0,0 +1,30 @@
+RSpec.describe Transform::Integer do
+  describe '.deserialize' do
+    it 'should transform the value to a fixnum' do
+      expect(Transform::Integer.deserialize(666)).to eq 666
+      expect(Transform::Integer.deserialize('200')).to eq 200
+    end
+
+    it 'should ignore extraneous characters' do
+      expect(Transform::Integer.deserialize('$6,000')).to eq 6000
+    end
+
+    it 'should round decimals down to nearest integer' do
+      expect(Transform::Integer.deserialize('8.0000')).to eq 8
+      expect(Transform::Integer.deserialize('6.4')).to eq 6
+      expect(Transform::Integer.deserialize('9.6')).to eq 9
+      expect(Transform::Integer.deserialize(12.7)).to eq 12
+    end
+
+    it 'should return nil if no number appropriate' do
+      expect(Transform::Integer.deserialize('test')).to eq nil
+    end
+  end
+
+  describe '.serialize' do
+    it 'should transform the value to a fixnum' do
+      expect(Transform::Integer.serialize(666)).to eq 666
+      expect(Transform::Integer.serialize('200')).to eq 200
+    end
+  end
+end

data/spec/lib/aggro/transform/money_spec.rb

@@ -0,0 +1,34 @@
+require 'money'
+require 'monetize'
+
+RSpec.describe Transform::Money do
+  let(:ten_usd) { Money.new(1000, 'USD') }
+  let(:five_nzd) { Money.new(500, 'NZD') }
+
+  describe '.deserialize' do
+    it 'should transform strings to a Money' do
+      expect(Transform::Money.deserialize('$10.00 USD')).to eq ten_usd
+      expect(Transform::Money.deserialize('$5.00 NZD')).to eq five_nzd
+    end
+
+    it 'should default to USD' do
+      expect(Transform::Money.deserialize('$10.00')).to eq ten_usd
+      expect(Transform::Money.deserialize('$5.00')).to_not eq five_nzd
+    end
+
+    it 'should accept an integer' do
+      expect(Transform::Money.deserialize(10)).to eq ten_usd
+    end
+
+    it 'should return nil if not a string' do
+      expect(Transform::Money.deserialize(true)).to eq nil
+    end
+  end
+
+  describe '.serialize' do
+    it 'should transform the value to a string' do
+      expect(Transform::Money.serialize(ten_usd)).to eq '$10.00 USD'
+      expect(Transform::Money.serialize(five_nzd)).to eq '$5.00 NZD'
+    end
+  end
+end