evt-messaging-fixtures 0.0.0.1 → 1.1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 269b46f51f2dd3d63cd7f1655e281cf702300d0a9044b69d96dbc4a26eb7797b
-  data.tar.gz: 2d45a9b841af0036cd172070448ee5dd00caa27137e6ccc31b8b1a11914ced71
+  metadata.gz: c1dfcf9207f5dc4d99225e4d10cedb57c57553910fdae1259b95fd523e82458d
+  data.tar.gz: 71e15c7fe107ebacc567aaaf397126e9c53a4cee639a103d1c3e7fe243afb7ca
 SHA512:
-  metadata.gz: 708b275d3d264c5f6d43ab01db849cabae52cb9cf7b10baee26f985db40e9209c62e68a4d6d6c453a1e22135adf6b58c70f21e3a84b6084427bacd64db691d9a
-  data.tar.gz: 96c40f8d25a8ec8d33acef440b81d815ea2fa2045562e4843ba2a1ff08a94878ff634db7784b160a2e9b0d733359df779dd0d5b3a0db620e7afc574ee0891750
+  metadata.gz: c5c95528f3716e1dd971c70270197eae4e976c4a1f69a92f2ddc0b756284b0aa26897fffb0a95f5552742562dc00b6b436f49d421fb02533254b9f21aaa64a84
+  data.tar.gz: 88a6b5b396274407cd4f0bbe862cb22221e7ed0200299ce083f500a5a80ba9f4edb1333e3681f6c3bac6fd4f34817f5ccc78f7679bb8721d6be89728b210a42b

data/lib/messaging/fixtures.rb

@@ -3,7 +3,8 @@ require 'schema/fixtures'
 require 'entity_store'
 
 require 'messaging/fixtures/defaults'
-require 'messaging/fixtures/input_message'
-require 'messaging/fixtures/written_message'
-require 'messaging/fixtures/write'
+require 'messaging/fixtures/follows'
+require 'messaging/fixtures/metadata'
+require 'messaging/fixtures/message'
+require 'messaging/fixtures/writer'
 require 'messaging/fixtures/handler'

data/lib/messaging/fixtures/controls.rb

@@ -2,6 +2,7 @@ require 'messaging/controls'
 
 require 'messaging/fixtures/controls/id'
 require 'messaging/fixtures/controls/time'
+require 'messaging/fixtures/controls/metadata'
 require 'messaging/fixtures/controls/message'
 require 'messaging/fixtures/controls/event'
 require 'messaging/fixtures/controls/sequence'

data/lib/messaging/fixtures/controls/handler.rb

@@ -45,18 +45,26 @@ module Messaging
 
             if example.alternate_condition?
               alternate_output = Controls::Event::AlternateOutput.follow(input, copy: attributes)
+
               alternate_output.processed_time = time
               alternate_output.sequence = sequence
 
+              alternate_output.metadata.correlation_stream_name = 'someCorrelationStream'
+              alternate_output.metadata.reply_stream_name = 'someReplyStream'
+
               write.(alternate_output, stream_name, expected_version: version)
 
               return
             end
 
             output = Controls::Event::Output.follow(input, copy: attributes)
+
             output.processed_time = time
             output.sequence = sequence
 
+            output.metadata.correlation_stream_name = 'someCorrelationStream'
+            output.metadata.reply_stream_name = 'someReplyStream'
+
             write.(output, stream_name, expected_version: version)
           end
         end
@@ -71,37 +79,3 @@ module Messaging
     end
   end
 end
-__END__
-
-handle Withdraw do |withdraw|
-  account_id = withdraw.account_id
-
-  account, version = store.fetch(account_id, include: :version)
-
-  sequence = withdraw.metadata.global_position
-
-  if account.processed?(sequence)
-    logger.info(tag: :ignored) { "Command ignored (Command: #{withdraw.message_type}, Account ID: #{account_id}, Account Sequence: #{account.sequence}, Withdrawal Sequence: #{sequence})" }
-    return
-  end
-
-  time = clock.iso8601
-
-  stream_name = stream_name(account_id)
-
-  unless account.sufficient_funds?(withdraw.amount)
-    withdrawal_rejected = WithdrawalRejected.follow(withdraw)
-    withdrawal_rejected.time = time
-    withdrawal_rejected.sequence = sequence
-
-    write.(withdrawal_rejected, stream_name, expected_version: version)
-
-    return
-  end
-
-  withdrawn = Withdrawn.follow(withdraw)
-  withdrawn.processed_time = time
-  withdrawn.sequence = sequence
-
-  write.(withdrawn, stream_name, expected_version: version)
-end

data/lib/messaging/fixtures/controls/message.rb

@@ -38,6 +38,26 @@ module Messaging
           Metadata.example
         end
 
+        module SomeMessage
+          def self.example
+            Example.new
+          end
+
+          class Example
+            include Messaging::Message
+
+            attribute :some_attribute, String
+          end
+        end
+
+        module Random
+          def self.example_class
+            Class.new do
+              include Messaging::Message
+            end
+          end
+        end
+
         module Metadata
           def self.example
             metadata = Messaging::Message::Metadata.new

data/lib/messaging/fixtures/controls/metadata.rb

@@ -0,0 +1,69 @@
+module Messaging
+  module Fixtures
+    module Controls
+      module Metadata
+        def self.example
+          metadata = Messaging::Message::Metadata.new
+
+          metadata.stream_name = stream_name
+          metadata.position = position
+          metadata.global_position = global_position
+
+          metadata.causation_message_stream_name = causation_message_stream_name
+          metadata.causation_message_position = causation_message_position
+          metadata.causation_message_global_position = causation_message_global_position
+
+          metadata.correlation_stream_name = correlation_stream_name
+
+          metadata.reply_stream_name = reply_stream_name
+
+          metadata.time = time
+
+          metadata.schema_version = schema_version
+
+          metadata
+        end
+
+        def self.stream_name
+          "example:command-#{Entity.id}"
+        end
+
+        def self.position
+          1
+        end
+
+        def self.global_position
+          111
+        end
+
+        def self.causation_message_stream_name
+          Message::Metadata.stream_name
+        end
+
+        def self.causation_message_position
+          Message::Metadata.position
+        end
+
+        def self.causation_message_global_position
+          Message::Metadata.global_position
+        end
+
+        def self.correlation_stream_name
+          'someCorrelationStream'
+        end
+
+        def self.reply_stream_name
+          'someReplyStream'
+        end
+
+        def self.time
+          ::Time.utc(2000, 1, 1, 0, 0, 0, 11)
+        end
+
+        def self.schema_version
+          '1'
+        end
+      end
+    end
+  end
+end

data/lib/messaging/fixtures/defaults.rb

@@ -2,11 +2,11 @@ module Messaging
   module Fixtures
     class Handler
       module Defaults
-        def self.time
+        def self.clock_time
           Time.utc(2000, 1, 1, 0, 0, 0, 11)
         end
 
-        def self.uuid
+        def self.identifier_uuid
           Identifier::UUID.zero
         end
       end

data/lib/messaging/fixtures/follows.rb

@@ -0,0 +1,57 @@
+module Messaging
+  module Fixtures
+    class Follows
+      include TestBench::Fixture
+      include Initializer
+
+      initializer :metadata, :source_metadata
+
+      def self.build(metadata, source_metadata=nil)
+        new(metadata, source_metadata)
+      end
+
+      def call
+        context do
+          if metadata.nil?
+            test "Metadata not nil" do
+              detail "Metadata: nil"
+              refute(metadata.nil?)
+            end
+            return
+          end
+
+          if source_metadata.nil?
+            test "Source metadata not nil" do
+              detail "Source Metadata: nil"
+              refute(source_metadata.nil?)
+            end
+            return
+          end
+
+          call!
+        end
+      end
+
+      def call!
+        test "Follows" do
+          detail "Stream Name: #{source_metadata.stream_name.inspect}"
+          detail "Causation Stream Name: #{metadata.causation_message_stream_name.inspect}"
+
+          detail "Position: #{source_metadata.position.inspect}"
+          detail "Causation Position: #{metadata.causation_message_position.inspect}"
+
+          detail "Global Position: #{source_metadata.global_position.inspect}"
+          detail "Causation Global Position: #{metadata.causation_message_global_position.inspect}"
+
+          detail "Source Correlation Stream Name: #{source_metadata.correlation_stream_name.inspect}"
+          detail "Correlation Stream Name: #{metadata.correlation_stream_name.inspect}"
+
+          detail "Source Reply Stream Name: #{source_metadata.reply_stream_name.inspect}"
+          detail "Reply Stream Name: #{metadata.reply_stream_name.inspect}"
+
+          assert(metadata.follows?(source_metadata))
+        end
+      end
+    end
+  end
+end

data/lib/messaging/fixtures/handler.rb

@@ -1,6 +1,8 @@
 module Messaging
   module Fixtures
     class Handler
+      Error = Class.new(RuntimeError)
+
       include TestBench::Fixture
       include Initializer
 
@@ -9,14 +11,14 @@ module Messaging
         entity.sequence
       end
 
-      initializer :handler, :input_message, :entity, :entity_version, :time, :uuid, :action
+      initializer :handler, :input_message, :entity, :entity_version, :clock_time, :identifier_uuid, :test_block
 
-      def self.build(handler, input_message, entity=nil, entity_version=nil, time: nil, uuid: nil, &action)
-        instance = new(handler, input_message, entity, entity_version, time, uuid, action)
+      def self.build(handler, input_message, entity=nil, entity_version=nil, clock_time: nil, identifier_uuid: nil, &test_block)
+        instance = new(handler, input_message, entity, entity_version, clock_time, identifier_uuid, test_block)
 
         set_store_entity(handler, entity, entity_version)
-        set_clock_time(handler, time)
-        set_identifier_uuid(handler, uuid)
+        set_clock_time(handler, clock_time)
+        set_identifier_uuid(handler, identifier_uuid)
 
         instance
       end
@@ -27,23 +29,23 @@ module Messaging
         handler.store.add(entity.id, entity, entity_version)
       end
 
-      def self.set_clock_time(handler, time)
-        if time.nil?
+      def self.set_clock_time(handler, clock_time)
+        if clock_time.nil?
           if handler.respond_to?(:clock)
-            handler.clock.now = Defaults.time
+            handler.clock.now = Defaults.clock_time
           end
         else
-          handler.clock.now = time
+          handler.clock.now = clock_time
         end
       end
 
-      def self.set_identifier_uuid(handler, uuid)
-        if uuid.nil?
+      def self.set_identifier_uuid(handler, identifier_uuid)
+        if identifier_uuid.nil?
           if handler.respond_to?(:identifier)
-            handler.identifier.set(Defaults.uuid)
+            handler.identifier.set(Defaults.identifier_uuid)
           end
         else
-          handler.identifier.set(uuid)
+          handler.identifier.set(identifier_uuid)
         end
       end
 
@@ -51,52 +53,69 @@ module Messaging
         context "Handler: #{handler.class.name.split('::').last}" do
           detail "Handler Class: #{handler.class.name}"
 
+          if test_block.nil?
+            raise Error, "Handler fixture must be executed with a block"
+          end
+
           detail "Entity Class: #{entity.class.name}"
-          detail "Entity Data: #{entity&.attributes}"
+          detail "Entity Data: #{entity&.attributes.inspect}"
 
-          handler.(input_message)
+          if not clock_time.nil?
+            detail "Clock Time: #{clock_time.inspect}"
+          end
 
-          if not action.nil?
-            action.call(self)
+          if not identifier_uuid.nil?
+            detail "Identifier UUID: #{identifier_uuid}"
           end
+
+          handler.(input_message)
+
+          test_block.call(self)
         end
       end
 
-      def assert_write(message_class, &action)
-        fixture = fixture(Write, handler.write, message_class, &action)
+      def assert_input_message(&test_block)
+        context_name = "Input Message"
+        if not input_message.nil?
+          context_name = "#{context_name}: #{input_message.class.message_type}"
+        end
 
-        output_message = fixture.message
+        fixture(Message, input_message, title_context_name: context_name, &test_block)
+      end
 
-        if not output_message.nil?
-          TestBench::Fixture.build(WrittenMessage, output_message, input_message, session: test_session)
-        else
-          Mimic.(WrittenMessage)
+      def assert_written_message(written_message, &test_block)
+        context_name = "Written Message"
+        if not written_message.nil?
+          context_name = "#{context_name}: #{written_message.class.message_type}"
         end
+
+        fixture(Message, written_message, input_message, title_context_name: context_name, &test_block)
+      end
+
+      def assert_write(message_class, &test_block)
+        fixture = fixture(Writer, handler.write, message_class, &test_block)
+        fixture.message
       end
 
       def refute_write(message_class=nil)
         writer = handler.write
 
-        context_title = "No Write"
+        context_name = "No Write"
         if not message_class.nil?
-          write_telemetry_data = Write.get_data(writer, message_class)
+          write_telemetry_data = Writer.get_data(writer, message_class)
           written = !write_telemetry_data.nil?
-          context_title = "#{context_title}: #{message_class.message_type}"
+          context_name = "#{context_name}: #{message_class.message_type}"
         else
           written = writer.written?
         end
 
-        context context_title do
+        context context_name do
           detail "Message Class: #{message_class.inspect}"
           test "Not written" do
             refute(written)
           end
         end
       end
-
-      def assert_input_message(attributes=nil, &action)
-        fixture = fixture(InputMessage, input_message, &action)
-      end
     end
   end
 end

data/lib/messaging/fixtures/message.rb

@@ -0,0 +1,124 @@
+module Messaging
+  module Fixtures
+    class Message
+      Error = Class.new(RuntimeError)
+
+      include TestBench::Fixture
+      include Initializer
+
+      def message_class
+        message.class
+      end
+
+      def message_type
+        message_class.name.split('::').last
+      end
+
+      def source_message_class
+        source_message.class
+      end
+
+      def source_message_type
+        source_message_class.name.split('::').last
+      end
+
+      def title_context_name
+        @title_context_name ||= "Message"
+      end
+
+      initializer :message, :source_message, na(:title_context_name), :test_block
+
+      def self.build(message, source_message=nil, title_context_name: nil, &test_block)
+        new(message, source_message, title_context_name, test_block)
+      end
+
+      def call
+        context_name = title_context_name
+
+        context context_name do
+          if test_block.nil?
+            raise Error, "Message fixture must be executed with a block"
+          end
+
+          if message.nil?
+            test "Not nil" do
+              detail "Message: nil"
+              detail "Remaining message tests are skipped"
+              refute(message.nil?)
+            end
+            return
+          end
+
+          detail "Message Class: #{message_class.name}"
+
+          if not source_message.nil?
+            detail "Source Message Class: #{source_message_class.name}"
+          end
+
+          test_block.call(self)
+        end
+      end
+
+      def assert_attributes_assigned(attribute_names=nil)
+        fixture(
+          Schema::Fixtures::Assignment,
+          message,
+          attribute_names,
+          print_title_context: false,
+          attributes_context_name: "Attributes Assigned"
+        )
+      end
+      alias :assert_all_attributes_assigned :assert_attributes_assigned
+
+      def assert_attributes_copied(attribute_names=nil)
+        if source_message.nil?
+          test "Source message not nil" do
+            detail "Source Message: nil"
+            refute(source_message.nil?)
+          end
+          return
+        end
+
+        fixture(
+          Schema::Fixtures::Equality,
+          source_message,
+          message,
+          attribute_names,
+          ignore_class: true,
+          print_title_context: false,
+          attributes_context_name: "Attributes Copied: #{source_message_type} => #{message_type}"
+        )
+      end
+
+      def assert_metadata(&test_block)
+        fixture(
+          Metadata,
+          message.metadata,
+          source_message&.metadata,
+          &test_block
+        )
+      end
+
+      def assert_follows
+        metadata = message.metadata
+        source_metadata = source_message&.metadata
+
+        fixture(Follows, metadata, source_metadata)
+      end
+
+      def assert_attribute_value(name, value)
+        context "Attribute Value" do
+          attribute_value = message.public_send(name)
+
+          test "#{name}" do
+            detail "Attribute Value: #{attribute_value.inspect}"
+            detail "Compare Value: #{value.inspect}"
+
+            assert(attribute_value == value)
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/messaging/fixtures/metadata.rb

@@ -0,0 +1,92 @@
+module Messaging
+  module Fixtures
+    class Metadata
+      Error = Class.new(RuntimeError)
+
+      include TestBench::Fixture
+      include Initializer
+
+      initializer :metadata, :source_metadata, :test_block
+
+      def self.build(metadata, source_metadata=nil, &test_block)
+        new(metadata, source_metadata, test_block)
+      end
+
+      def call
+        context "Metadata" do
+          if test_block.nil?
+            raise Error, "Metadata fixture must be executed with a block"
+          end
+
+          if metadata.nil?
+            test "Not nil" do
+              detail "Metadata: nil"
+
+              if not test_block.nil?
+                detail "Remaining message tests are skipped"
+              end
+
+              refute(metadata.nil?)
+            end
+            return
+          end
+
+          test_block.call(self)
+        end
+      end
+
+      def assert_attributes_assigned(attribute_names=nil, context_title_qualifier: nil)
+        attribute_names ||= Messaging::Message::Metadata.all_attribute_names
+
+        attributes_context_title = "#{context_title_qualifier} Attributes Assigned".lstrip
+
+        fixture(
+          Schema::Fixtures::Assignment,
+          metadata,
+          attribute_names,
+          print_title_context: false,
+          attributes_context_name: attributes_context_title
+        )
+      end
+
+      def assert_source_attributes_assigned
+        attribute_names = Messaging::Message::Metadata.source_attribute_names
+        assert_attributes_assigned(attribute_names, context_title_qualifier: 'Source')
+      end
+
+      def assert_workflow_attributes_assigned
+        attribute_names = Messaging::Message::Metadata.workflow_attribute_names
+        assert_attributes_assigned(attribute_names, context_title_qualifier: 'Workflow')
+      end
+
+      def assert_causation_attributes_assigned
+        attribute_names = Messaging::Message::Metadata.causation_attribute_names
+        assert_attributes_assigned(attribute_names, context_title_qualifier: 'Causation')
+      end
+
+      def assert_correlation_stream_name(correlation_stream_name)
+        metadata_value = metadata.correlation_stream_name
+
+        test "correlation_stream_name" do
+          detail "Metadata Value: #{metadata_value}"
+          detail "Compare Value: #{correlation_stream_name}"
+          assert(metadata_value == correlation_stream_name)
+        end
+      end
+
+      def assert_reply_stream_name(reply_stream_name)
+        metadata_value = metadata.reply_stream_name
+
+        test "reply_stream_name" do
+          detail "Metadata Value: #{metadata_value}"
+          detail "Compare Value: #{reply_stream_name}"
+          assert(metadata_value == reply_stream_name)
+        end
+      end
+
+      def assert_follows
+        fixture(Follows, metadata, source_metadata)
+      end
+    end
+  end
+end

data/lib/messaging/fixtures/{write.rb → writer.rb}

@@ -1,14 +1,14 @@
 module Messaging
   module Fixtures
-    class Write
+    class Writer
       Error = Class.new(RuntimeError)
 
       include TestBench::Fixture
       include Initializer
 
-      initializer :message, :stream_name, :expected_version, :reply_stream_name, :action
+      initializer :message_class, :message, :stream_name, :expected_version, :reply_stream_name, :test_block
 
-      def self.build(writer, message_class, &action)
+      def self.build(writer, message_class, &test_block)
         data = get_data(writer, message_class)
 
         message = data&.message
@@ -16,7 +16,7 @@ module Messaging
         expected_version = data&.expected_version
         reply_stream_name = data&.reply_stream_name
 
-        new(message, stream_name, expected_version, reply_stream_name, action)
+        new(message_class, message, stream_name, expected_version, reply_stream_name, test_block)
       end
 
       def self.get_data(writer, message_class)
@@ -38,22 +38,28 @@ module Messaging
       end
 
       def call
-        message_class = message&.class
+        context_name = "Write: #{message_class.message_type}"
+
+        context context_name do
+          if test_block.nil?
+            raise Error, "Write fixture must be executed with a block"
+          end
 
-        context "Write: #{message_class&.message_type || 'nil'}" do
           detail "Message Class: #{message_class.inspect}"
 
           written = !message.nil?
 
           test "Written" do
+            if not written
+              detail "Remaining message tests are skipped"
+            end
+
             assert(written)
           end
 
-          return if !written || action.nil?
+          return if not written
 
-          if not action.nil?
-            action.call(self)
-          end
+          test_block.call(self)
         end
 
         message

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: evt-messaging-fixtures
 version: !ruby/object:Gem::Version
-  version: 0.0.0.1
+  version: 1.1.2.0
 platform: ruby
 authors:
 - The Eventide Project
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-08-02 00:00:00.000000000 Z
+date: 2020-08-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: evt-entity_store
@@ -65,19 +65,21 @@ files:
 - lib/messaging/fixtures/controls/handler.rb
 - lib/messaging/fixtures/controls/id.rb
 - lib/messaging/fixtures/controls/message.rb
+- lib/messaging/fixtures/controls/metadata.rb
 - lib/messaging/fixtures/controls/sequence.rb
 - lib/messaging/fixtures/controls/store.rb
 - lib/messaging/fixtures/controls/time.rb
 - lib/messaging/fixtures/defaults.rb
+- lib/messaging/fixtures/follows.rb
 - lib/messaging/fixtures/handler.rb
-- lib/messaging/fixtures/input_message.rb
-- lib/messaging/fixtures/write.rb
-- lib/messaging/fixtures/written_message.rb
+- lib/messaging/fixtures/message.rb
+- lib/messaging/fixtures/metadata.rb
+- lib/messaging/fixtures/writer.rb
 homepage: https://github.com/eventide-project/messaging-fixtures
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -93,7 +95,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.1.2
-signing_key: 
+signing_key:
 specification_version: 4
 summary: TestBench fixtures for the Messaging library
 test_files: []

data/lib/messaging/fixtures/input_message.rb

@@ -1,52 +0,0 @@
-module Messaging
-  module Fixtures
-    class InputMessage
-      Error = Class.new(RuntimeError)
-
-      include TestBench::Fixture
-      include Initializer
-
-      initializer :input_message, :action
-
-      def self.build(input_message, &action)
-        new(input_message, action)
-      end
-
-      def call
-        input_message_class = input_message.class
-
-        context "Input Message: #{input_message_class.message_type}" do
-          detail "Input Message Class: #{input_message_class.name}"
-
-          if not action.nil?
-            action.call(self)
-          end
-        end
-      end
-
-      def assert_attributes_assigned(attribute_names=nil)
-        fixture(
-          Schema::Fixtures::Assignment,
-          input_message,
-          attribute_names,
-          print_title_context: false,
-          attributes_context_name: "Attributes Assigned"
-        )
-      end
-
-      def assert_metadata_attributes_assigned(attribute_names=nil)
-        attribute_names = [:stream_name, :position, :global_position]
-
-        metadata = input_message.metadata
-
-        fixture(
-          Schema::Fixtures::Assignment,
-          metadata,
-          attribute_names,
-          print_title_context: false,
-          attributes_context_name: "Metadata Attributes Assigned"
-        )
-      end
-    end
-  end
-end

data/lib/messaging/fixtures/written_message.rb

@@ -1,84 +0,0 @@
-module Messaging
-  module Fixtures
-    class WrittenMessage
-      Error = Class.new(RuntimeError)
-
-      include TestBench::Fixture
-      include Initializer
-
-      initializer :output_message, :input_message
-
-      def self.build(output_message, input_message)
-        new(output_message, input_message)
-      end
-
-      def call(&action)
-        input_message_class = input_message.class
-        output_message_class = output_message.class
-
-        context "Written Message: #{output_message_class.message_type}" do
-          detail "Input Message Class: #{input_message_class.name}"
-          detail "Written Message Class: #{output_message_class.name}"
-
-          if not action.nil?
-            action.call(self)
-          end
-        end
-      end
-
-      def assert_follows
-        input_message_type = input_message.class.message_type
-        output_message_type = output_message.class.message_type
-
-        test "Follows: #{input_message_type}" do
-          detail "#{input_message_type} Stream Name: #{input_message.metadata.stream_name.inspect}"
-          detail "#{output_message_type} Causation Stream Name: #{output_message.metadata.causation_message_stream_name.inspect}"
-
-          detail "#{input_message_type} Position: #{input_message.metadata.position.inspect}"
-          detail "#{output_message_type} Causation Position: #{output_message.metadata.causation_message_position.inspect}"
-
-          detail "#{input_message_type} Global Position: #{input_message.metadata.global_position.inspect}"
-          detail "#{output_message_type} Causation Global Position: #{output_message.metadata.causation_message_global_position.inspect}"
-
-          detail "#{input_message_type} Reply Stream Name: #{input_message.metadata.reply_stream_name.inspect}"
-          detail "#{output_message_type} Reply Stream Name: #{output_message.metadata.reply_stream_name.inspect}"
-
-          assert(output_message.follows?(input_message))
-        end
-      end
-
-      def ___assert_attributes_copied(attribute_names=nil)
-        fixture(
-          Schema::Fixtures::Equality,
-          input_message,
-          output_message,
-          attribute_names,
-          ignore_class: true,
-          title_context_name: "Attributes Copied: #{input_message.class.message_type} => #{output_message.class.message_type}"
-        )
-      end
-
-      def assert_attributes_copied(attribute_names=nil)
-        fixture(
-          Schema::Fixtures::Equality,
-          input_message,
-          output_message,
-          attribute_names,
-          ignore_class: true,
-          print_title_context: false,
-          attributes_context_name: "Attributes Copied: #{input_message.class.message_type} => #{output_message.class.message_type}"
-        )
-      end
-
-      def assert_attributes_assigned(attribute_names=nil)
-        fixture(
-          Schema::Fixtures::Assignment,
-          output_message,
-          attribute_names,
-          print_title_context: false,
-          attributes_context_name: "Attributes Assigned: #{output_message.class.message_type}"
-        )
-      end
-    end
-  end
-end