test_bench-isolated 0 → 2.0.0.0

data/lib/test_bench_isolated/test_bench/telemetry/event_data/serialization.rb

@@ -0,0 +1,172 @@
+module TestBenchIsolated
+  module TestBench
+    class Telemetry
+      class EventData
+        module Serialization
+          Error = Class.new(RuntimeError)
+  
+          def self.dump(event_data)
+            type = event_data.type.to_s
+            process_id = dump_value(event_data.process_id)
+            time = dump_value(event_data.time)
+            data = event_data.data
+  
+            text = String.new(encoding: 'BINARY')
+  
+            text << type
+  
+            text << "\t"
+            text << process_id
+  
+            text << "\t"
+            text << time
+  
+            data.each do |value|
+              text << "\t"
+              text << dump_value(value)
+            end
+  
+            text << "\r\n"
+            text
+          end
+  
+          def self.dump_value(value)
+            case value
+            when Integer
+              value.to_s
+            when Time
+              value.strftime('%Y-%m-%dT%H:%M:%S.%NZ')
+            when NilClass
+              ''
+            when TrueClass, FalseClass
+              value.to_s
+            when String
+              value.dump
+            end
+          end
+  
+          def self.load(text)
+            match_data = Pattern.match(text)
+            if match_data.nil?
+              raise Error, "Cannot deserialize #{text.inspect}"
+            end
+  
+            type = match_data['type'].to_sym
+            process_id = load_value(match_data['process_id'])
+            time = load_value(match_data['time_attribute'])
+  
+            event_data = EventData.new
+            event_data.type = type
+            event_data.process_id = process_id
+            event_data.time = time
+            event_data.data = []
+  
+            data_text = match_data['data']
+  
+            data_text.insert(0, "\t")
+            data_text.scan(/\t([^\t]*)/) do |(value_text)|
+              value = load_value(value_text)
+              event_data.data << value
+            end
+  
+            event_data
+          end
+  
+          def self.load_value(value_text)
+            match_data = Pattern.match_value(value_text)
+  
+            if match_data['integer']
+              Integer(value_text)
+            elsif match_data['time']
+              year = match_data['year'].to_i
+              month = match_data['month'].to_i
+              day = match_data['day'].to_i
+              hour = match_data['hour'].to_i
+              minute = match_data['minute'].to_i
+              second = match_data['second'].to_i
+  
+              nanosecond = match_data['nanosecond'].to_i
+              usec = Rational(nanosecond, 1_000)
+  
+              Time.utc(year, month, day, hour, minute, second, usec)
+            elsif match_data['nil']
+              nil
+            elsif match_data['true']
+              true
+            elsif match_data['false']
+              false
+            elsif match_data['string']
+              value_text.undump
+            end
+          end
+  
+          module Pattern
+            def self.match(data)
+              event_data.match(data)
+            end
+  
+            def self.match_value(value_text)
+              value_pattern.match(value_text)
+            end
+  
+            def self.event_data
+              @event_data ||= %r{\A#{type}\t#{process_id}\t#{time_attribute}\t#{data}\r\n\z}
+            end
+  
+            def self.type
+              %r{(?<type>[A-Z][[:alnum:]]+)}
+            end
+  
+            def self.process_id
+              %r{(?<process_id>#{integer})}
+            end
+  
+            def self.value_pattern
+              @value_pattern ||= %r{\A#{value}\z}
+            end
+  
+            def self.time_attribute
+              %r{(?<time_attribute>#{time})}
+            end
+  
+            def self.data
+              %r{(?<data>#{value}(?:\t#{value})*)}
+            end
+  
+            def self.value
+              %r{#{integer}|#{time}|#{self.nil}|#{boolean}|#{string}}
+            end
+  
+            def self.integer
+              %r{(?<integer>[[:digit:]]+)}
+            end
+  
+            def self.time
+              year = %r{(?<year>[[:digit:]]{4})}
+              month = %r{(?<month>[[:digit:]]{2})}
+              day = %r{(?<day>[[:digit:]]{2})}
+              hour = %r{(?<hour>[[:digit:]]{2})}
+              minute = %r{(?<minute>[[:digit:]]{2})}
+              second = %r{(?<second>[[:digit:]]{2})}
+              nanosecond = %r{(?<nanosecond>[[:digit:]]{9})}
+  
+              %r{(?<time>#{year}-#{month}-#{day}T#{hour}:#{minute}:#{second}\.#{nanosecond}Z)}
+            end
+  
+            def self.nil
+              %r{(?<nil>(?=[\t\r\z])?)}
+            end
+  
+            def self.boolean
+              %r{(?<true>true)|(?<false>false)}
+            end
+  
+            def self.string
+              %r{(?<string>".*")}
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/test_bench_isolated/test_bench/telemetry/event_data.rb

@@ -0,0 +1,15 @@
+module TestBenchIsolated
+  module TestBench
+    class Telemetry
+      EventData = Struct.new(:type, :process_id, :time, :data) do
+        def self.load(text)
+          EventData::Serialization.load(text)
+        end
+  
+        def dump
+          EventData::Serialization.dump(self)
+        end
+      end
+    end
+  end
+end

data/lib/test_bench_isolated/test_bench/telemetry/sink/file.rb

@@ -0,0 +1,33 @@
+module TestBenchIsolated
+  module TestBench
+    class Telemetry
+      module Sink
+        class File
+          include Sink
+  
+          attr_reader :io
+  
+          def initialize(io)
+            @io = io
+          end
+  
+          def self.open(path, &block)
+            ::File.open(path, 'w') do |io|
+              instance = new(io)
+  
+              block.(instance, io)
+  
+              return instance
+            end
+          end
+  
+          def receive(event_data)
+            text = event_data.dump
+  
+            io.write(text)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/test_bench_isolated/test_bench/telemetry/sink/handler/event_registry.rb

@@ -0,0 +1,44 @@
+module TestBenchIsolated
+  module TestBench
+    class Telemetry
+      module Sink
+        module Handler
+          class EventRegistry
+            Error = Class.new(RuntimeError)
+  
+            def event_classes
+              @event_classes ||= {}
+            end
+            attr_writer :event_classes
+  
+            def event_types
+              event_classes.keys
+            end
+  
+            def get(event_type)
+              event_classes.fetch(event_type) do
+                raise Error, "#{event_type} isn't registered"
+              end
+            end
+  
+            def register(event_class)
+              if registered?(event_class)
+                raise Error, "#{event_class} is already registered"
+              end
+  
+              event_type = event_class.event_type
+  
+              event_classes[event_type] = event_class
+            end
+  
+            def registered?(event_class)
+              event_type = event_class.event_type
+  
+              event_classes.key?(event_type)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/test_bench_isolated/test_bench/telemetry/sink/handler.rb

@@ -0,0 +1,128 @@
+module TestBenchIsolated
+  module TestBench
+    class Telemetry
+      module Sink
+        module Handler
+          def self.included(cls)
+            cls.class_exec do
+              include Sink
+              include Receive
+  
+              extend HandlerMethod
+              extend HandleMacro
+            end
+          end
+  
+          module Receive
+            def receive(event_data)
+              handle(event_data)
+            end
+          end
+  
+          def handle(event_or_event_data)
+            handles = handle?(event_or_event_data)
+  
+            if handles
+              if event_or_event_data.is_a?(Event)
+                event = event_or_event_data
+              else
+                event_data = event_or_event_data
+                event_type = event_data.type
+                event_class = self.class.event_registry.get(event_type)
+  
+                event = Event::Import.(event_data, event_class)
+              end
+  
+              handler_method = handler_method(event)
+  
+              if method(handler_method).parameters.any?
+                __send__(handler_method, event)
+              else
+                __send__(handler_method)
+              end
+  
+              event
+            elsif respond_to?(:handle_event_data)
+              if event_or_event_data.is_a?(Event)
+                event_data = Event::Export.(event_or_event_data)
+              else
+                event_data = event_or_event_data
+              end
+  
+              handle_event_data(event_data)
+  
+              event_data
+            else
+              nil
+            end
+          end
+  
+          def handle?(...)
+            handler_method = handler_method(...)
+  
+            not handler_method.nil?
+          end
+  
+          def handler_method(event_or_event_data)
+            handler_method = self.class.handler_method(event_or_event_data)
+  
+            if respond_to?(handler_method)
+              handler_method
+            else
+              nil
+            end
+          end
+  
+          module HandleMacro
+            def handle_macro(event_class, &block)
+              event_registry.register(event_class)
+  
+              event_type = event_class.event_type
+  
+              handler_method = HandlerMethod.get(event_type)
+  
+              define_method(handler_method, &block)
+            end
+            alias :handle :handle_macro
+  
+            def event_registry
+              @event_registry ||= EventRegistry.new
+            end
+          end
+  
+          module HandlerMethod
+            def handler_method(event_or_event_data)
+              if event_or_event_data.is_a?(Event)
+                event = event_or_event_data
+                event_type = event.event_type
+              else
+                event_data = event_or_event_data
+                event_type = event_data.type
+              end
+  
+              HandlerMethod.get(event_type)
+            end
+  
+            def self.get(event_type)
+              handler_methods[event_type]
+            end
+  
+            def self.handler_methods
+              @handler_methods ||= Hash.new do |handler_methods, event_type|
+                handler_method = get!(event_type)
+  
+                handler_methods[event_type] = handler_method
+              end
+            end
+  
+            def self.get!(event_type)
+              event_name = Event::EventName.get(event_type)
+  
+              :"handle_#{event_name}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/test_bench_isolated/test_bench/telemetry/sink/projection.rb

@@ -0,0 +1,134 @@
+module TestBenchIsolated
+  module TestBench
+    class Telemetry
+      module Sink
+        module Projection
+          def self.included(cls)
+            cls.class_exec do
+              include Sink
+              include Receive
+  
+              extend ReceiverNameMacro
+  
+              extend ApplyMethod
+              extend ApplyMacro
+            end
+          end
+  
+          attr_accessor :receiver
+  
+          def initialize(receiver)
+            @receiver = receiver
+          end
+  
+          module Receive
+            def receive(event_data)
+              apply(event_data)
+            end
+          end
+  
+          def apply(event_or_event_data)
+            applies = apply?(event_or_event_data)
+  
+            if applies
+              if event_or_event_data.is_a?(Event)
+                event = event_or_event_data
+              else
+                event_data = event_or_event_data
+                event_type = event_data.type
+                event_class = self.class.event_registry.get(event_type)
+  
+                event = Event::Import.(event_data, event_class)
+              end
+  
+              apply_method = apply_method(event)
+  
+              if method(apply_method).parameters.any?
+                __send__(apply_method, event)
+              else
+                __send__(apply_method)
+              end
+  
+              event
+            elsif respond_to?(:apply_event_data)
+              if event_or_event_data.is_a?(Event)
+                event_data = Event::Export.(event_or_event_data)
+              else
+                event_data = event_or_event_data
+              end
+  
+              apply_event_data(event_data)
+  
+              event_data
+            else
+              nil
+            end
+          end
+          alias :call :apply
+  
+          def apply?(...)
+            apply_method = apply_method(...)
+  
+            not apply_method.nil?
+          end
+  
+          def apply_method(event_or_event_data)
+            apply_method = self.class.apply_method(event_or_event_data)
+  
+            if respond_to?(apply_method)
+              apply_method
+            else
+              nil
+            end
+          end
+  
+          module ReceiverNameMacro
+            def receiver_name_macro(receiver_name)
+              define_method(receiver_name) do
+                receiver
+              end
+            end
+            alias :receiver_name :receiver_name_macro
+          end
+  
+          module ApplyMacro
+            def apply_macro(event_class, &block)
+              event_registry.register(event_class)
+  
+              event_type = event_class.event_type
+  
+              apply_method = ApplyMethod.get(event_type)
+  
+              define_method(apply_method, &block)
+            end
+            alias :apply :apply_macro
+  
+            def event_registry
+              @event_registry ||= Handler::EventRegistry.new
+            end
+          end
+  
+          module ApplyMethod
+            def apply_method(event_or_event_data)
+              if event_or_event_data.is_a?(Event)
+                event = event_or_event_data
+                event_type = event.event_type
+              else
+                event_data = event_or_event_data
+                event_type = event_data.type
+              end
+  
+              ApplyMethod.get(event_type)
+            end
+  
+            def self.get(event_type)
+              event_name = Event::EventName.get(event_type)
+  
+              :"apply_#{event_name}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/test_bench_isolated/test_bench/telemetry/sink.rb

@@ -0,0 +1,13 @@
+module TestBenchIsolated
+  module TestBench
+    class Telemetry
+      module Sink
+        ReceiveError = Class.new(RuntimeError)
+  
+        def receive(event_data)
+          raise ReceiveError, "Sink #{self.class} doesn't implement receive"
+        end
+      end
+    end
+  end
+end

data/lib/test_bench_isolated/test_bench/telemetry/substitute/sink.rb

@@ -0,0 +1,85 @@
+module TestBenchIsolated
+  module TestBench
+    class Telemetry
+      module Substitute
+        class Sink
+          MatchError = Class.new(RuntimeError)
+  
+          include Telemetry::Sink
+  
+          def self.read(path)
+            file_text = ::File.read(path)
+  
+            instance = new
+  
+            file_text.each_line do |event_data_text|
+              event_data = Telemetry::EventData.load(event_data_text)
+  
+              instance.receive(event_data)
+            end
+  
+            instance
+          end
+  
+          def received_events
+            @received_events ||= []
+          end
+  
+          def receive(event_data)
+            received_events << event_data
+          end
+  
+          def received?(event_data)
+            received_events.include?(event_data)
+          end
+  
+          def one_event?(...)
+            !one_event(...).nil?
+          end
+  
+          def one_event(...)
+            events = events(...)
+  
+            if events.count > 1
+              event_type = events.first.event_type
+              raise MatchError, "More than one event matches (Type: #{event_type.inspect}, Matching Events: #{events.count})"
+            end
+  
+            events.first
+          end
+  
+          def any_event?(...)
+            events(...).any?
+          end
+          alias :event? :any_event?
+  
+          def events(event_class, **attributes)
+            event_type = event_class.event_type
+  
+            events = []
+  
+            received_events.each do |event_data|
+              event_types_correspond = event_data.type == event_type
+  
+              if event_types_correspond
+                event = Event::Import.(event_data, event_class)
+  
+                attributes_correspond = attributes.all? do |attribute, compare_value|
+                  value = event.public_send(attribute)
+  
+                  value == compare_value
+                end
+  
+                if attributes_correspond
+                  events << event
+                end
+              end
+            end
+  
+            events
+          end
+        end
+      end
+    end
+  end
+end

data/lib/test_bench_isolated/test_bench/telemetry/substitute.rb

@@ -0,0 +1,34 @@
+module TestBenchIsolated
+  module TestBench
+    class Telemetry
+      module Substitute
+        def self.build
+          Telemetry.build
+        end
+  
+        class Telemetry < Telemetry
+          attr_accessor :process_id
+          attr_accessor :current_time
+  
+          def sink
+            @sink ||= Substitute::Sink.new
+          end
+          attr_writer :sink
+  
+          def self.build
+            instance = new
+            instance.register(instance.sink)
+            instance
+          end
+  
+          def one_event?(...) = sink.one_event?(...)
+          def one_event(...) = sink.one_event(...)
+          def any_event?(...) = sink.any_event?(...)
+          alias :event? :any_event?
+          def events(...) = sink.events(...)
+          def recorded?(...) = sink.received?(...)
+        end
+      end
+    end
+  end
+end