aggro 0.0.1 → 0.0.2

data/spec/lib/aggro/channel_spec.rb

@@ -0,0 +1,87 @@
+RSpec.describe Channel do
+  subject(:channel) { Channel.new id, 'Cat' }
+
+  let(:id) { SecureRandom.uuid }
+  let(:cat) { spy }
+  let(:cat_class) { double(new: 1, allows?: allowed, responds_to?: responds) }
+
+  let(:allowed) { true }
+  let(:responds) { true }
+
+  before do
+    stub_const 'Cat', cat_class
+    stub_const 'Aggro::ConcurrentActor', double(spawn!: cat)
+  end
+
+  describe '#forward_command' do
+    context 'command is allowed' do
+      it 'should send the command to the aggregate mailbox' do
+        channel.forward_command 'hello'
+
+        expect(cat).to have_received(:<<).with 'hello'
+      end
+    end
+
+    context 'command is not allowed' do
+      let(:allowed) { false }
+
+      it 'should not send the command to the aggregate mailbox' do
+        channel.forward_command 'hello'
+
+        expect(cat).to_not have_received(:<<).with 'hello'
+      end
+    end
+  end
+
+  describe '#handles_command?' do
+    context 'command is allowed' do
+      it 'should should return true' do
+        expect(channel.handles_command?('command')).to be_truthy
+      end
+    end
+
+    context 'command is not allowed' do
+      let(:allowed) { false }
+
+      it 'should return false' do
+        expect(channel.handles_command?('command')).to be_falsey
+      end
+    end
+  end
+
+  describe '#handles?' do
+    context 'query is allowed' do
+      it 'should should return true' do
+        expect(channel.handles_query?('query')).to be_truthy
+      end
+    end
+
+    context 'query is not allowed' do
+      let(:responds) { false }
+
+      it 'should return false' do
+        expect(channel.handles_query?('query')).to be_falsey
+      end
+    end
+  end
+
+  describe '#run_query' do
+    context 'query is allowed' do
+      it 'should send the command to the aggregate mailbox' do
+        channel.run_query 'hello'
+
+        expect(cat).to have_received(:ask).with 'hello'
+      end
+    end
+
+    context 'query is not allowed' do
+      let(:responds) { false }
+
+      it 'should not send the command to the aggregate mailbox' do
+        channel.run_query 'hello'
+
+        expect(cat).to_not have_received(:ask).with 'hello'
+      end
+    end
+  end
+end

data/spec/lib/aggro/client_spec.rb

@@ -0,0 +1,26 @@
+RSpec.describe Client do
+  subject(:client) { Client.new(endpoint) }
+
+  let(:endpoint) { 'tcp://10.0.0.1:4000' }
+
+  describe '#post' do
+    let(:transport) { spy(client: transport_client) }
+    let(:transport_client) { spy(post: 'hi') }
+
+    before do
+      allow(Aggro).to receive(:transport).and_return transport
+      allow(MessageParser).to receive(:parse).and_return 'parsed'
+    end
+
+    it 'should start a server for the node using the current transport' do
+      client.post 'hello'
+
+      expect(transport).to have_received(:client).with(endpoint)
+      expect(transport_client).to have_received(:post).with 'hello'
+    end
+
+    it 'should parse the response with MessageParser' do
+      expect(client.post('hello')).to eq 'parsed'
+    end
+  end
+end

data/spec/lib/aggro/cluster_config_spec.rb

@@ -0,0 +1,33 @@
+RSpec.describe ClusterConfig do
+  subject(:config) { ClusterConfig.new CLUSTER_CONFIG_PATH }
+
+  describe '.new' do
+    context 'node has an existing persisted node name' do
+      it 'should use the existing node name' do
+        @existing_name = ClusterConfig.new(CLUSTER_CONFIG_PATH).node_name
+
+        expect(config.node_name).to eq @existing_name
+      end
+    end
+
+    context 'node is being started for the first time' do
+      it 'should generate a new node name' do
+        expect(config.node_name).to be_a String
+      end
+    end
+  end
+
+  describe '#add_node' do
+    it 'should add the node to the nodes hash' do
+      config.add_node 'test-node', 'localhost:7000'
+
+      expect(config.nodes['test-node']).to eq 'localhost:7000'
+    end
+
+    it 'should persist node list' do
+      ClusterConfig.new(CLUSTER_CONFIG_PATH).add_node 'fluffy', 'localhost:80'
+
+      expect(config.nodes['fluffy']).to eq 'localhost:80'
+    end
+  end
+end

data/spec/lib/aggro/command_spec.rb

@@ -0,0 +1,52 @@
+RSpec.describe Command do
+  class TestCommand
+    include Command
+
+    generate_id :thing_id
+
+    id :owner_id
+    string :thing
+    validates :thing, presence: true
+
+    integer :times
+  end
+
+  subject(:command) { TestCommand.new thing: 'puppy', times: '100' }
+
+  describe '#attributes' do
+    it 'should return a hash of attributes' do
+      expect(command.attributes).to be_a Hash
+      expect(command.attributes[:thing]).to eq 'puppy'
+    end
+  end
+
+  describe '#serialized_attributes' do
+    it 'should return a hash of attributes run through the transforms' do
+      expect(command.serialized_attributes).to be_a Hash
+      expect(command.serialized_attributes[:times]).to eq 100
+    end
+  end
+
+  describe '#to_details' do
+    it 'should return a hash containing the command name and arguments' do
+      details = command.to_details
+
+      expect(details).to be_a Hash
+      expect(details[:name]).to eq 'TestCommand'
+      expect(details[:args][:thing_id]).to match Transform::ID::ID_REGEX
+      expect(details[:args][:thing]).to eq 'puppy'
+      expect(details[:args][:times]).to eq 100
+      expect(details[:args][:owner_id]).to eq nil
+    end
+  end
+
+  describe '#valid?' do
+    it 'should return true if command is valid' do
+      expect(command.valid?).to be_truthy
+    end
+
+    it 'should return false if command is not valid' do
+      expect(TestCommand.new.valid?).to be_falsey
+    end
+  end
+end

data/spec/lib/aggro/concurrent_actor_spec.rb

@@ -0,0 +1,44 @@
+RSpec.describe ConcurrentActor do
+  subject(:actor) { ConcurrentActor.new aggregate }
+
+  let(:aggregate) { spy }
+
+  class TestCommand
+    include Command
+  end
+
+  class TestQuery
+    include Query
+  end
+
+  describe '#on_message' do
+    context 'the message is a command' do
+      it 'should send the message to the aggregate' do
+        message = TestCommand.new
+
+        actor.on_message message
+
+        expect(aggregate).to have_received(:apply_command).with(message)
+      end
+    end
+
+    context 'the message is a query' do
+      it 'should send the message to the aggregate' do
+        message = TestQuery.new
+
+        actor.on_message message
+
+        expect(aggregate).to have_received(:run_query).with(message)
+      end
+    end
+
+    context 'the message is not a query or command' do
+      it 'should not send the message to the aggregate' do
+        actor.on_message :terminate!
+
+        expect(aggregate).to_not have_received(:apply_command)
+        expect(aggregate).to_not have_received(:run_query)
+      end
+    end
+  end
+end

data/spec/lib/aggro/event_bus_spec.rb

@@ -0,0 +1,20 @@
+RSpec.describe EventBus do
+  subject(:event_bus) { EventBus.new }
+
+  let(:fake_server) { spy }
+
+  let(:topic) { SecureRandom.uuid }
+  let(:event) { :event! }
+
+  before do
+    allow(Aggro).to receive(:server).and_return fake_server
+  end
+
+  describe '#publish' do
+    it 'should publish an event via the given publisher' do
+      event_bus.publish topic, event
+
+      expect(fake_server).to have_received(:publish).with Message::Events
+    end
+  end
+end

data/spec/lib/aggro/event_serializer_spec.rb

@@ -0,0 +1,28 @@
+RSpec.describe EventSerializer do
+  let(:data) { { one: 9000, two: 'pizza', three: ['foo', 123] } }
+  let(:event) { Event.new :tested_system, Time.new(2015), data }
+  describe '.serialize' do
+    it 'should convert a hash to some serialized form' do
+      serialized = EventSerializer.serialize event
+
+      expect(serialized).to be_a String
+    end
+  end
+
+  describe '.deserialize' do
+    it 'should convert serialized data back to the original form' do
+      revived = EventSerializer.deserialize EventSerializer.serialize(event)
+
+      expect(revived.name).to eq :tested_system
+
+      expect(revived.occured_at).to eq Time.new(2015)
+
+      expect(revived.details).to be_a Hash
+      expect(revived.details.keys.length).to eq 3
+      expect(revived.details[:one]).to eq 9000
+      expect(revived.details[:two]).to eq 'pizza'
+      expect(revived.details[:three].first).to eq 'foo'
+      expect(revived.details[:three].last).to eq 123
+    end
+  end
+end

data/spec/lib/aggro/file_store/reader_spec.rb

@@ -0,0 +1,32 @@
+RSpec.describe FileStore::Reader do
+  subject(:reader) { FileStore::Reader.new data_io, index_io }
+
+  let(:data) { { one: 9000, two: 'pizza', three: ['foo', 123] } }
+  let(:existing_event) { Event.new :tested_pizza, Time.new(2014), data }
+
+  let(:data_content) { EventSerializer.serialize(existing_event) }
+  let(:index_content) { Marshal.dump data_content.bytesize }
+
+  let(:data_io) { StringIO.new(data_content, 'rb') }
+  let(:index_io) { StringIO.new(index_content, 'rb') }
+
+  describe '#read' do
+    context 'files have stored events' do
+      it 'should return an Enumerable of events' do
+        result = reader.read
+
+        expect(result).to respond_to :each
+        expect(result.to_a[0]).to eq existing_event
+      end
+    end
+
+    context 'files have no content' do
+      let(:data_content) { '' }
+      let(:index_content) { '' }
+
+      it 'should return an empty Enumerable' do
+        expect(reader.read.to_a).to eq []
+      end
+    end
+  end
+end

data/spec/lib/aggro/file_store/writer_spec.rb

@@ -0,0 +1,67 @@
+RSpec.describe FileStore::Writer do
+  subject(:writer) { FileStore::Writer.new(data_io, index_io) }
+
+  let(:data_content) { '' }
+  let(:index_content) { '' }
+
+  let(:data_io) { StringIO.new(data_content, 'a+b') }
+  let(:index_io) { StringIO.new(index_content, 'a+b') }
+
+  let(:id) { SecureRandom.uuid }
+
+  let(:data) { { one: 9000, two: 'pizza', three: ['foo', 123] } }
+  let(:event_one) { Event.new 'tested_system', Time.new(2015), data }
+  let(:event_two) { Event.new 'logged_in', Time.new(2015, 2), data }
+  let(:events) { [event_one, event_two] }
+
+  describe '#write' do
+    it 'should write event data to the data file' do
+      writer.write(events)
+
+      data_io.rewind
+      expect(data_io.read.length).to be > 0
+    end
+
+    it 'should write an offsets to the index file for each event' do
+      writer.write(events)
+
+      index_io.rewind
+      offsets = ObjectStream.new(index_io, type: 'marshal').to_a
+      expect(offsets.length).to eq 2
+    end
+
+    context 'when files already contain data' do
+      let(:existing_event) { Event.new 'tested_pizza', Time.new(2014), data }
+      let(:data_content) { EventSerializer.serialize(existing_event) }
+      let(:index_content) { Marshal.dump data_content.bytesize }
+
+      it 'should write event data to the data file' do
+        writer.write(events)
+
+        data_io.rewind
+        expect(data_io.read.length).to be > 0
+      end
+
+      it 'should write an offsets to the index file for each event' do
+        writer.write(events)
+
+        index_io.rewind
+        offsets = ObjectStream.new(index_io, type: 'marshal').to_a
+        expect(offsets.length).to eq 3
+      end
+
+      it 'should write corrent offsets for each event' do
+        writer.write(events)
+
+        index_io.rewind
+        offsets = ObjectStream.new(index_io, type: 'marshal').to_a
+
+        expect do
+          EventSerializer.deserialize data_content[0...(offsets[0])]
+          EventSerializer.deserialize data_content[offsets[0]...offsets[1]]
+          EventSerializer.deserialize data_content[offsets[1]...offsets[2]]
+        end.to_not raise_error
+      end
+    end
+  end
+end

data/spec/lib/aggro/file_store_spec.rb

@@ -0,0 +1,51 @@
+RSpec.describe FileStore do
+  subject(:store) { FileStore.new STORE_DIR }
+
+  let(:data_io) { StringIO.new }
+  let(:index_io) { StringIO.new }
+
+  let(:id) { SecureRandom.uuid }
+  let(:type) { 'Test' }
+
+  let(:data) { { one: 9000, two: 'pizza', three: ['foo', 123] } }
+  let(:event_one) { Event.new :tested_system, Time.new(2015), data }
+  let(:event_two) { Event.new :logged_in, Time.new(2015, 2), data }
+  let(:events) { [event_one, event_two] }
+
+  let(:event_stream) { EventStream.new id, type, events }
+
+  describe '#create' do
+    before do
+      FileStore.new(STORE_DIR).create(SecureRandom.uuid, type)
+      FileStore.new(STORE_DIR).create(SecureRandom.uuid, type)
+    end
+
+    it 'should be able to restore written data' do
+      all = store.all
+
+      expect(all.length).to eq 2
+      expect(all.first.type).to eq type
+      expect(all.last.type).to eq type
+    end
+  end
+
+  describe '#read' do
+    before do
+      FileStore.new(STORE_DIR).create(id, type).write([event_stream])
+    end
+
+    it 'should be able to restore written data' do
+      restored_stream = store.read([id]).first
+
+      expect(restored_stream.id).to eq id
+      expect(restored_stream.type).to eq type
+      expect(restored_stream.events.to_a).to eq events
+    end
+  end
+
+  describe '#write' do
+    it 'should write data to disk' do
+      expect { store.write [event_stream] }.to_not raise_error
+    end
+  end
+end