aggro 0.0.1 → 0.0.2

data/lib/aggro/subscription.rb

@@ -0,0 +1,41 @@
+module Aggro
+  # Private: Handles invoking events on a subscriber object.
+  class Subscription
+    def initialize(topic, subscriber, namespace, filters, at_version)
+      @topic = topic
+      @subscriber = subscriber
+      @namespace = namespace
+      @filters = filters
+      @at_version = at_version
+      @canceled = false
+    end
+
+    def cancel
+      Aggro.event_bus.unsubscribe @topic, self unless @canceled
+      @canceled = true
+    end
+
+    def handle_event(event)
+      return if @canceled
+
+      invoke(event) if handles_event?(event) && matches_filter?(event)
+    end
+
+    private
+
+    def handles_event?(event)
+      @subscriber.handles_event? event.name, @namespace
+    end
+
+    def invoke(event)
+      Invokr.invoke method: "#{@namespace}_#{event.name}",
+                    using: event.details, on: @subscriber
+    end
+
+    def matches_filter?(event)
+      @filters.all? do |filter_key, filter_value|
+        event.details[filter_key] == filter_value
+      end
+    end
+  end
+end

data/lib/aggro/transform/boolean.rb

@@ -0,0 +1,16 @@
+module Aggro
+  module Transform
+    # Private: Transforms boolean representations.
+    module Boolean
+      module_function
+
+      def deserialize(value)
+        value if value == false || value == true
+      end
+
+      def serialize(value)
+        value if value == false || value == true
+      end
+    end
+  end
+end

data/lib/aggro/transform/email.rb

@@ -0,0 +1,26 @@
+module Aggro
+  module Transform
+    # Private: Transforms integer representations.
+    module Email
+      EMAIL_REGEX = %r{
+        \A([-a-z0-9!\#$%&'*+/=?^_`{|}~]+\.)*
+        [-a-z0-9!\#$%&'*+/=?^_`{|}~]+
+        @
+        ((?:[-a-z0-9]+\.)+
+        [a-z]{2,})\Z
+      }xi
+
+      module_function
+
+      def deserialize(value)
+        value = value.to_s
+
+        value if value.match(EMAIL_REGEX)
+      end
+
+      def serialize(value)
+        deserialize value
+      end
+    end
+  end
+end

data/lib/aggro/transform/id.rb

@@ -0,0 +1,34 @@
+module Aggro
+  module Transform
+    # Private: Transforms integer representations.
+    class ID
+      ID_REGEX = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/
+
+      def initialize(generate: false)
+        @generate = generate
+      end
+
+      def deserialize(value)
+        value = value.to_s
+
+        return value if value.match(ID_REGEX)
+
+        generate_id if should_generate_id?
+      end
+
+      def serialize(value)
+        deserialize value
+      end
+
+      private
+
+      def generate_id
+        SecureRandom.uuid
+      end
+
+      def should_generate_id?
+        @generate == true
+      end
+    end
+  end
+end

data/lib/aggro/transform/integer.rb

@@ -0,0 +1,22 @@
+module Aggro
+  module Transform
+    # Private: Transforms integer representations.
+    module Integer
+      module_function
+
+      def deserialize(value)
+        if value.is_a?(::String)
+          string = value.gsub(/[^\d\.]/, '')
+
+          string == '' ? nil : string.to_i
+        else
+          value.to_i
+        end
+      end
+
+      def serialize(value)
+        value.to_i
+      end
+    end
+  end
+end

data/lib/aggro/transform/money.rb

@@ -0,0 +1,22 @@
+module Aggro
+  module Transform
+    # Private: Transforms money representations.
+    module Money
+      module_function
+
+      def deserialize(value)
+        if value.is_a? ::String
+          Monetize.parse(value)
+        elsif value.is_a? ::Integer
+          Monetize.parse(value.to_s)
+        elsif value.is_a? ::Money
+          value
+        end
+      end
+
+      def serialize(value)
+        value.format with_currency: true if value.is_a? ::Money
+      end
+    end
+  end
+end

data/lib/aggro/transform/noop.rb

@@ -0,0 +1,16 @@
+module Aggro
+  module Transform
+    # Private: No op transform.
+    module NOOP
+      module_function
+
+      def deserialize(value)
+        value
+      end
+
+      def serialize(value)
+        value
+      end
+    end
+  end
+end

data/lib/aggro/transform/string.rb

@@ -0,0 +1,16 @@
+module Aggro
+  module Transform
+    # Private: Transforms string representations.
+    module String
+      module_function
+
+      def deserialize(value)
+        value.to_s
+      end
+
+      def serialize(value)
+        value.to_s
+      end
+    end
+  end
+end

data/lib/aggro/transform/time_interval.rb

@@ -0,0 +1,24 @@
+module Aggro
+  module Transform
+    # Private: Transforms money representations.
+    module TimeInterval
+      module_function
+
+      def deserialize(value)
+        if value.is_a? ::String
+          ::TimeInterval.parse(value)
+        elsif interval? value
+          value
+        end
+      end
+
+      def interval?(value)
+        value.class.parents.include? ::TimeInterval
+      end
+
+      def serialize(value)
+        value.iso8601 if interval? value
+      end
+    end
+  end
+end

data/lib/aggro/version.rb

@@ -1,3 +1,3 @@
 module Aggro
-  VERSION = '0.0.1'
+  VERSION = '0.0.2'
 end

data/spec/lib/aggro/abstract_store_spec.rb

@@ -0,0 +1,15 @@
+RSpec.describe AbstractStore do
+  subject(:store) { AbstractStore.new }
+
+  describe '#read' do
+    it 'should raise not implemented error' do
+      expect { store.read(double) }.to raise_error NotImplementedError
+    end
+  end
+
+  describe '#write' do
+    it 'should raise not implemented error' do
+      expect { store.write(double) }.to raise_error NotImplementedError
+    end
+  end
+end

data/spec/lib/aggro/aggregate_ref_spec.rb

@@ -1,23 +1,74 @@
-require 'spec_helper'
-
-describe AggregateRef do
-  subject(:ref) { AggregateRef.new(id) }
+RSpec.describe AggregateRef do
+  subject(:ref) { AggregateRef.new(id, type) }
 
   let(:id) { SecureRandom.uuid }
-  let(:fake_ring) { double(node_for: '10.0.0.70') }
+  let(:type) { 'type' }
+
+  let(:response) { Message::OK.new }
+  let(:client) { spy post: response }
+  let(:node) { double(client: client) }
+  let(:fake_locator) { double(primary_node: node) }
 
   before do
-    allow(Aggro).to receive(:hash_ring).and_return fake_ring
+    allow(ref).to receive(:locator).and_return(fake_locator)
   end
 
-  describe '#server' do
-    it 'should return the server on which the aggregate lives' do
-      expect(ref.server).to eq '10.0.0.70'
+  describe '#command' do
+    it 'should send the command to the aggregate via the client' do
+      command = double(to_details: { name: 'TestCommand' })
+
+      ref.command command
+
+      expect(client).to have_received(:post).with kind_of Message::Command
     end
+  end
+
+  describe '#create' do
+    context 'the node also thinks it is the relavent node' do
+      let(:response) { Message::OK.new }
+
+      it 'should send a CreateAggregate message to the relavent node' do
+        ref.create
+
+        expect(client).to have_received(:post).with(Message::CreateAggregate)
+      end
+    end
+
+    context 'the node does not think it is the right node for id' do
+      let(:response) { Message::Ask.new(SecureRandom.uuid) }
+
+      it 'should raise an error' do
+        expect { ref.create }.to raise_error
+      end
+    end
+  end
+
+  describe '#query' do
+    let(:query) { double to_details: { name: 'TestQuery' } }
+
+    context 'the response is not an error' do
+      let(:response) { Message::Result.new 'hello' }
+
+      it 'should send the command to the aggregate via the client' do
+        ref.query query
+
+        expect(client).to have_received(:post).with kind_of Message::Query
+      end
+
+      it 'should return the result value' do
+        result = ref.query(query)
+
+        expect(result).to eq 'hello'
+      end
+    end
+
+    context 'the response is an error' do
+      let(:error) { RuntimeError.new 'Something went wrong' }
+      let(:response) { Message::Result.new QueryError.new error }
 
-    it 'should memorize the lookup to reduce hashing' do
-      expect(fake_ring).to receive(:node_for).once
-      5.times { ref.server }
+      it 'should return the result value' do
+        expect { ref.query(query) }.to raise_error 'Something went wrong'
+      end
     end
   end
 end

data/spec/lib/aggro/aggregate_spec.rb

@@ -0,0 +1,207 @@
+require 'json'
+
+RSpec.describe Aggregate do
+  class GiveSomething
+    include Aggro::Command
+
+    string :thing
+    money :value
+  end
+
+  class CheckThings
+    include Aggro::Query
+  end
+
+  class CatSerializer
+    include Aggro::Projection
+
+    def serialize
+      JSON.dump data
+    end
+
+    events do
+      def gave_thing(thing)
+        things << thing
+      end
+    end
+
+    private
+
+    def data
+      @data ||= { things: things }
+    end
+
+    def things
+      @things ||= []
+    end
+  end
+
+  class Cat
+    include Aggregate
+
+    attr_reader :executed_self
+    attr_reader :executed_command
+    attr_reader :executed_money
+
+    def things_i_have
+      @things ||= []
+    end
+
+    projection :json, via: CatSerializer
+
+    allows GiveSomething do |command|
+      @executed_self = self
+      @executed_command = command
+
+      did.gave_thing
+    end
+
+    responds_to CheckThings do
+      things_i_have
+    end
+
+    events do
+      def gave_thing(thing, value)
+        things_i_have << thing
+        @executed_money = value
+      end
+    end
+  end
+
+  subject(:aggregate) { Cat.new(id) }
+
+  let(:id) { SecureRandom.uuid }
+  let(:command) { GiveSomething.new thing: 'milk', value: '$100 NZD' }
+  let(:query) { CheckThings.new }
+
+  let(:existing_event) do
+    Event.new(:gave_thing, Time.now, thing: 'cake', value: Money.new(100))
+  end
+  let(:response) { Message::Events.new(id, [existing_event]) }
+  let(:client) { double(post: response) }
+  let(:publisher_endpoint) { 'tcp://127.0.0.1:6000' }
+  let(:node) { double(client: client, publisher_endpoint: publisher_endpoint) }
+  let(:fake_locator) { double primary_node: node }
+  let(:locator_class) { double new: fake_locator }
+
+  let(:id) { SecureRandom.uuid }
+
+  let(:fake_server) { spy publish: true }
+
+  before do
+    stub_const 'Aggro::Locator', locator_class
+    allow(Aggro).to receive(:server).and_return fake_server
+  end
+
+  describe '.allows' do
+    it 'should register a command handler' do
+      Cat.allows(Fixnum) { true }
+
+      expect(Cat.allows?(1)).to be_truthy
+    end
+  end
+
+  describe '.allows?' do
+    context 'input command has a registeded handler' do
+      it 'should return true' do
+        expect(Cat.allows?(GiveSomething.new)).to be_truthy
+      end
+    end
+
+    context 'input command does not have a registed handler' do
+      it 'should return false' do
+        expect(Cat.allows?('')).to be_falsey
+      end
+    end
+  end
+
+  describe '.create' do
+    let(:id) { SecureRandom.uuid }
+    let(:aggregate_ref) { double create: true }
+    let(:aggregate_ref_class) { spy(new: aggregate_ref) }
+    let(:response) { Message::OK.new }
+
+    before do
+      stub_const 'Aggro::Locator', locator_class
+      stub_const 'Aggro::AggregateRef', aggregate_ref_class
+    end
+
+    it 'should send a CreateAggregate message to the relavent node' do
+      Cat.create id
+
+      expect(aggregate_ref).to have_received(:create)
+    end
+  end
+
+  describe '.find' do
+    let(:aggregate_ref) { double }
+    let(:aggregate_ref_class) { spy(new: aggregate_ref) }
+
+    let(:id) { SecureRandom.uuid }
+
+    before do
+      stub_const 'Aggro::AggregateRef', aggregate_ref_class
+    end
+
+    it 'should return an AggregateRef for the aggregate' do
+      expect(Cat.find(id)).to eq aggregate_ref
+      expect(aggregate_ref_class).to have_received(:new).with id, 'Cat'
+    end
+  end
+
+  describe '.new' do
+    let(:event_bus) { spy }
+
+    before do
+      allow(Aggro).to receive(:event_bus).and_return(event_bus)
+    end
+
+    it 'should subscribe itself to events for the given ID' do
+      aggregate
+
+      expect(event_bus).to have_received(:subscribe).with id, aggregate
+    end
+  end
+
+  describe '#apply_command' do
+    it 'should execute the handler with the aggregate as self' do
+      aggregate.send :apply_command, command
+
+      expect(aggregate.executed_self).to eq aggregate
+    end
+
+    it 'should preserve types' do
+      aggregate.send :apply_command, command
+
+      expect(aggregate.executed_money).to be_a Money
+    end
+
+    it 'should execute the handler with the command as an argument' do
+      aggregate.send :apply_command, command
+
+      expect(aggregate.executed_command).to eq command
+    end
+
+    it 'should have the existing event applied' do
+      expect(aggregate.things_i_have).to include 'cake'
+    end
+
+    it 'should apply events via the #did proxy' do
+      aggregate.send :apply_command, command
+
+      expect(aggregate.things_i_have).to include 'milk'
+    end
+
+    it 'should apply event to the projections' do
+      aggregate.send :apply_command, command
+
+      expect(aggregate.json.serialize).to eq '{"things":["cake","milk"]}'
+    end
+  end
+
+  describe '#run_query' do
+    it 'should return the result of the query method' do
+      expect(aggregate.send(:run_query, query)).to eq ['cake']
+    end
+  end
+end