aggro 0.0.1 → 0.0.2

data/spec/lib/aggro/message/ask_spec.rb

@@ -0,0 +1,23 @@
+RSpec.describe Message::Ask do
+  let(:message_type) { Message::Ask::TYPE_CODE }
+  let(:node_id) { SecureRandom.uuid }
+
+  let(:string) { message_type + node_id }
+
+  describe '.parse' do
+    it 'should parse correctly' do
+      message = Message::Ask.parse string
+
+      expect(message).to be_a Message::Ask
+      expect(message.node_id).to eq node_id
+    end
+  end
+
+  describe '#to_s' do
+    it 'should serialize correctly' do
+      serialized = Message::Ask.new(node_id).to_s
+
+      expect(serialized).to eq string
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+RSpec.describe Message::Command do
+  let(:type_code) { Message::Command::TYPE_CODE }
+
+  let(:sender) { SecureRandom.uuid }
+  let(:commandee_id) { SecureRandom.uuid }
+
+  let(:args) { { thing: 'puppy' } }
+  let(:details) { { name: 'TestCommand', args: args } }
+  let(:binary_details) { Marshal.dump(details) }
+  let(:string) { type_code + sender + commandee_id + binary_details }
+
+  let(:message) { Message::Command.new(sender, commandee_id, details) }
+
+  describe '.parse' do
+    it 'should parse correctly' do
+      message = Message::Command.parse string
+
+      expect(message).to be_a Message::Command
+      expect(message.sender).to eq sender
+      expect(message.commandee_id).to eq commandee_id
+      expect(message.details).to eq details
+    end
+  end
+
+  describe '#name' do
+    it 'should return the correct name' do
+      expect(message.name).to eq 'TestCommand'
+    end
+  end
+
+  describe '#to_command' do
+    let(:command_instance) { double }
+    let(:command_klass) { spy(new: command_instance) }
+
+    it 'should build a Command object' do
+      stub_const 'TestCommand', command_klass
+
+      expect(message.to_command).to eq command_instance
+      expect(command_klass).to have_received(:new).with args
+    end
+  end
+
+  describe '#to_s' do
+    it 'should serialize correctly' do
+      serialized = message.to_s
+
+      expect(serialized).to eq string
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+RSpec.describe Message::CreateAggregate do
+  let(:sender) { SecureRandom.uuid }
+  let(:id) { SecureRandom.uuid }
+  let(:type) { 'Test' }
+
+  let(:string) { Message::CreateAggregate::TYPE_CODE + sender + id + type }
+
+  let(:message) { Message::CreateAggregate.new(sender, id, type) }
+
+  describe '.parse' do
+    it 'should parse correctly' do
+      message = Message::CreateAggregate.parse string
+
+      expect(message).to be_a Message::CreateAggregate
+      expect(message.sender).to eq sender
+      expect(message.id).to eq id
+      expect(message.type).to eq type
+    end
+  end
+
+  describe '#to_s' do
+    it 'should serialize correctly' do
+      serialized = message.to_s
+
+      expect(serialized).to eq string
+    end
+  end
+end

data/spec/lib/aggro/message/endpoint_spec.rb

@@ -0,0 +1,23 @@
+RSpec.describe Message::Endpoint do
+  let(:message_type) { Message::Endpoint::TYPE_CODE }
+  let(:endpoint) { SecureRandom.uuid }
+
+  let(:string) { message_type + endpoint }
+
+  describe '.parse' do
+    it 'should parse correctly' do
+      message = Message::Endpoint.parse string
+
+      expect(message).to be_a Message::Endpoint
+      expect(message.endpoint).to eq endpoint
+    end
+  end
+
+  describe '#to_s' do
+    it 'should serialize correctly' do
+      serialized = Message::Endpoint.new(endpoint).to_s
+
+      expect(serialized).to eq string
+    end
+  end
+end

data/spec/lib/aggro/message/events_spec.rb

@@ -0,0 +1,37 @@
+RSpec.describe Message::Events do
+  EVENTS_TYPE_CODE = Message::Events::TYPE_CODE
+
+  let(:id) { SecureRandom.uuid }
+
+  let(:event1) { Event.new :tested_pizza, Time.new, foo: 'bar' }
+  let(:event2) { Event.new :tested_system, Time.new, bar: 'foo' }
+  let(:events) { [event1, event2] }
+
+  let(:binary_events) do
+    events.map { |event| EventSerializer.serialize event }.join
+  end
+  let(:string) { EVENTS_TYPE_CODE + id + binary_events }
+
+  let(:message) { Message::Events.new(id, events) }
+
+  describe '.parse' do
+    it 'should parse correctly' do
+      message = Message::Events.parse string
+
+      parsed_events = message.events.to_a
+
+      expect(message).to be_a Message::Events
+      expect(message.id).to eq id
+      expect(parsed_events.first).to eq events.first
+      expect(parsed_events.last).to eq events.last
+    end
+  end
+
+  describe '#to_s' do
+    it 'should serialize correctly' do
+      serialized = message.to_s
+
+      expect(serialized).to eq string
+    end
+  end
+end

data/spec/lib/aggro/message/get_events_spec.rb

@@ -0,0 +1,33 @@
+RSpec.describe Message::GetEvents do
+  let(:message_type) { Message::GetEvents::TYPE_CODE }
+  let(:sender) { SecureRandom.uuid }
+  let(:id) { SecureRandom.uuid }
+  let(:from_version) { 0 }
+
+  let(:string) { message_type + sender + id + from_version.to_s }
+
+  describe '.parse' do
+    it 'should parse correctly' do
+      message = Message::GetEvents.parse string
+
+      expect(message).to be_a Message::GetEvents
+      expect(message.sender).to eq sender
+      expect(message.id).to eq id
+      expect(message.from_version).to eq from_version
+    end
+  end
+
+  describe '#to_s' do
+    it 'should serialize correctly' do
+      serialized = Message::GetEvents.new(sender, id, from_version).to_s
+
+      expect(serialized).to eq string
+    end
+
+    it 'should use 0 as a default from_version' do
+      serialized = Message::GetEvents.new(sender, id, nil).to_s
+
+      expect(serialized).to eq string
+    end
+  end
+end

data/spec/lib/aggro/message/heartbeat_spec.rb

@@ -0,0 +1,23 @@
+RSpec.describe Message::Heartbeat do
+  let(:message_type) { Message::Heartbeat::TYPE_CODE }
+  let(:sender) { SecureRandom.uuid }
+
+  let(:string) { message_type + sender }
+
+  describe '.parse' do
+    it 'should parse correctly' do
+      message = Message::Heartbeat.parse string
+
+      expect(message).to be_a Message::Heartbeat
+      expect(message.sender).to eq sender
+    end
+  end
+
+  describe '#to_s' do
+    it 'should serialize correctly' do
+      serialized = Message::Heartbeat.new(sender).to_s
+
+      expect(serialized).to eq string
+    end
+  end
+end

data/spec/lib/aggro/message/invalid_target_spec.rb

@@ -0,0 +1,28 @@
+RSpec.describe Message::InvalidTarget do
+  let(:message_type) { Message::InvalidTarget::TYPE_CODE }
+
+  let(:string) { message_type }
+
+  describe '.new' do
+    it 'should reuse the same singleton object' do
+      expect(Message::InvalidTarget.new.object_id).to eq \
+        Message::InvalidTarget.new.object_id
+    end
+  end
+
+  describe '.parse' do
+    it 'should parse correctly' do
+      message = Message::InvalidTarget.parse string
+
+      expect(message).to be_a Message::InvalidTarget
+    end
+  end
+
+  describe '#to_s' do
+    it 'should serialize correctly' do
+      serialized = Message::InvalidTarget.new.to_s
+
+      expect(serialized).to eq string
+    end
+  end
+end

data/spec/lib/aggro/message/ok_spec.rb

@@ -0,0 +1,27 @@
+RSpec.describe Message::OK do
+  let(:message_type) { Message::OK::TYPE_CODE }
+
+  let(:string) { message_type }
+
+  describe '.new' do
+    it 'should reuse the same singleton object' do
+      expect(Message::OK.new.object_id).to eq Message::OK.new.object_id
+    end
+  end
+
+  describe '.parse' do
+    it 'should parse correctly' do
+      message = Message::OK.parse string
+
+      expect(message).to be_a Message::OK
+    end
+  end
+
+  describe '#to_s' do
+    it 'should serialize correctly' do
+      serialized = Message::OK.new.to_s
+
+      expect(serialized).to eq string
+    end
+  end
+end

data/spec/lib/aggro/message/publisher_endpoint_inquiry_spec.rb

@@ -0,0 +1,23 @@
+RSpec.describe Message::PublisherEndpointInquiry do
+  let(:message_type) { Message::PublisherEndpointInquiry::TYPE_CODE }
+  let(:sender) { SecureRandom.uuid }
+
+  let(:string) { message_type + sender }
+
+  describe '.parse' do
+    it 'should parse correctly' do
+      message = Message::PublisherEndpointInquiry.parse string
+
+      expect(message).to be_a Message::PublisherEndpointInquiry
+      expect(message.sender).to eq sender
+    end
+  end
+
+  describe '#to_s' do
+    it 'should serialize correctly' do
+      serialized = Message::PublisherEndpointInquiry.new(sender).to_s
+
+      expect(serialized).to eq string
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+RSpec.describe Message::Query do
+  let(:type_code) { Message::Query::TYPE_CODE }
+
+  let(:sender) { SecureRandom.uuid }
+  let(:queryable_id) { SecureRandom.uuid }
+
+  let(:args) { { thing: 'puppy' } }
+  let(:details) { { name: 'TestQuery', args: args } }
+  let(:binary_details) { Marshal.dump details }
+  let(:string) { type_code + sender + queryable_id + binary_details }
+
+  let(:message) { Message::Query.new(sender, queryable_id, details) }
+
+  describe '.parse' do
+    it 'should parse correctly' do
+      message = Message::Query.parse string
+
+      expect(message).to be_a Message::Query
+      expect(message.sender).to eq sender
+      expect(message.queryable_id).to eq queryable_id
+      expect(message.details).to eq details
+    end
+  end
+
+  describe '#name' do
+    it 'should return the correct name' do
+      expect(message.name).to eq 'TestQuery'
+    end
+  end
+
+  describe '#to_query' do
+    let(:query_instance) { double }
+    let(:query_klass) { spy(new: query_instance) }
+
+    it 'should build a Query object' do
+      stub_const 'TestQuery', query_klass
+
+      expect(message.to_query).to eq query_instance
+      expect(query_klass).to have_received(:new).with args
+    end
+  end
+
+  describe '#to_s' do
+    it 'should serialize correctly' do
+      serialized = message.to_s
+
+      expect(serialized).to eq string
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+RSpec.describe Message::StartSaga do
+  let(:sender) { SecureRandom.uuid }
+  let(:id) { SecureRandom.uuid }
+
+  let(:args) { { thing: 'puppy' } }
+  let(:details) { { name: 'TestSaga', args: args } }
+  let(:binary_details) { Marshal.dump details }
+  let(:type_code) { Message::StartSaga::TYPE_CODE }
+  let(:string) { type_code + sender + id + binary_details }
+
+  let(:message) { Message::StartSaga.new(sender, id, details) }
+
+  describe '.parse' do
+    it 'should parse correctly' do
+      message = Message::StartSaga.parse string
+
+      expect(message).to be_a Message::StartSaga
+      expect(message.sender).to eq sender
+      expect(message.id).to eq id
+      expect(message.details).to eq details
+    end
+  end
+
+  describe '#name' do
+    it 'should return the correct name' do
+      expect(message.name).to eq 'TestSaga'
+    end
+  end
+
+  describe '#to_s' do
+    it 'should serialize correctly' do
+      serialized = message.to_s
+
+      expect(serialized).to eq string
+    end
+  end
+end

data/spec/lib/aggro/message/unhandled_operation_spec.rb

@@ -0,0 +1,28 @@
+RSpec.describe Message::UnhandledOperation do
+  let(:message_type) { Message::UnhandledOperation::TYPE_CODE }
+
+  let(:string) { message_type }
+
+  describe '.new' do
+    it 'should reuse the same singleton object' do
+      expect(Message::UnhandledOperation.new.object_id).to eq \
+      Message::UnhandledOperation.new.object_id
+    end
+  end
+
+  describe '.parse' do
+    it 'should parse correctly' do
+      message = Message::UnhandledOperation.parse string
+
+      expect(message).to be_a Message::UnhandledOperation
+    end
+  end
+
+  describe '#to_s' do
+    it 'should serialize correctly' do
+      serialized = Message::UnhandledOperation.new.to_s
+
+      expect(serialized).to eq string
+    end
+  end
+end

data/spec/lib/aggro/message/unknown_operation_spec.rb

@@ -0,0 +1,28 @@
+RSpec.describe Message::UnknownOperation do
+  let(:message_type) { Message::UnknownOperation::TYPE_CODE }
+
+  let(:string) { message_type }
+
+  describe '.new' do
+    it 'should reuse the same singleton object' do
+      expect(Message::UnknownOperation.new.object_id).to eq \
+        Message::UnknownOperation.new.object_id
+    end
+  end
+
+  describe '.parse' do
+    it 'should parse correctly' do
+      message = Message::UnknownOperation.parse string
+
+      expect(message).to be_a Message::UnknownOperation
+    end
+  end
+
+  describe '#to_s' do
+    it 'should serialize correctly' do
+      serialized = Message::UnknownOperation.new.to_s
+
+      expect(serialized).to eq string
+    end
+  end
+end