test_bench-telemetry 2.0.0.1 → 2.1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fc9eba5d7d92a1f3103d807e39010ab95c5d332d9f11189c6ee1001ff76eb1e6
-  data.tar.gz: 5cfe64718b363c2b054e93273097185ecce46ee1f0e03282213993aedc0293a0
+  metadata.gz: 72c55974ef010c548b9527049d02155e13a077de5b0029b54a87ce562613ab9f
+  data.tar.gz: a003ad9fec17e7ac5900ebdd146679232c68489acdf98b37d767427ca8b86ee5
 SHA512:
-  metadata.gz: 9393cef19bf91ad537f917056ec971159347604ff4a4e794a2320f53036b0610610ee976b0a6b0d084c692b0d375effe5370ef88f2a6e901b7316ba5e2321d98
-  data.tar.gz: 6018103538a85fca142e4034b3f10a3f4ed8a9b4ce403fb5262d7d514488223d538a7cb9b8c557b587bd341cae44095c80d8031bfdf304c22629e5a81e316b8e
+  metadata.gz: b37377fc81d039affad9fc2b9b2b2b6c95f530186b3c05c4d876255cb3fce5cf7b3891dbdae22bf7a3421be40494710106ac3143994c3e24d9ded2d8815dfc2f
+  data.tar.gz: 14dc73d0d4dea00ed153eb6d950dfef9d66275401fe55b39e64946d5e71870ab978668a504f517adae0496f8d10e1926c336c2e41cab49d9f9fdda638e765ab9

data/lib/test_bench/telemetry/controls/event/event_data.rb

@@ -0,0 +1,15 @@
+module TestBench
+  class Telemetry
+    module Controls
+      module Event
+        module EventData
+          def event_data
+            event = self.example
+
+            Telemetry::Event::Export.(event)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/test_bench/telemetry/controls/event/metadata.rb

@@ -0,0 +1,70 @@
+module TestBench
+  class Telemetry
+    module Controls
+      module Event
+        module Metadata
+          def self.example(process_id: nil, time: nil)
+            if process_id == :none
+              process_id = nil
+            else
+              process_id ||= self.process_id
+            end
+
+            if time == :none
+              time = nil
+            else
+              time ||= self.time
+            end
+
+            metadata = Telemetry::Event::Metadata.new
+            metadata.process_id = process_id
+            metadata.time = time
+            metadata
+          end
+
+          def self.other_example
+            Other.example
+          end
+
+          def self.random
+            Random.example
+          end
+
+          def self.process_id
+            Controls::ProcessID.example
+          end
+
+          def self.time
+            Controls::Time.example
+          end
+
+          module Other
+            def self.example(process_id: nil, time: nil)
+              process_id ||= self.process_id
+              time ||= self.time
+
+              Metadata.example(process_id:, time:)
+            end
+
+            def self.process_id
+              Controls::ProcessID.other_example
+            end
+
+            def self.time
+              Controls::Time.other_example
+            end
+          end
+
+          module Random
+            def self.example(process_id: nil, time: nil)
+              process_id ||= Controls::ProcessID.random
+              time ||= Controls::Time.random
+
+              Metadata.example(process_id:, time:)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/test_bench/telemetry/controls/event.rb

@@ -2,72 +2,133 @@ module TestBench
   class Telemetry
     module Controls
       module Event
-        def self.example(some_string=nil)
-          some_string ||= self.some_string
-
-          event = Example.new
-          event.some_string = some_string
-          event.some_integer = some_integer
-          event.some_boolean = some_boolean
-          event.some_other_boolean = some_other_boolean
-          event.time = time
+        extend EventData
+
+        def self.example(some_attribute: nil, some_other_attribute: nil, event_class: nil, metadata: nil, process_id: nil, time: nil)
+          some_attribute ||= self.some_attribute
+          some_other_attribute ||= self.some_other_attribute
+
+          metadata ||= Metadata.example(process_id:, time:)
+          event_class ||= SomeEvent
+
+          event = event_class.new
+          event.some_attribute = some_attribute
+          event.some_other_attribute = some_other_attribute
+          event.metadata = metadata
           event
         end
 
-        def self.some_string = 'some-string'
-        def self.some_integer = 11
-        def self.some_boolean = true
-        def self.some_other_boolean = false
-        def self.time = Time.example
-
-        SomeEvent = TestBench::Telemetry::Event.define(
-          :some_string,
-          :some_integer,
-          :some_boolean,
-          :some_other_boolean,
-          :some_optional
-        )
-        Example = SomeEvent
-
-        SomeOtherEvent = TestBench::Telemetry::Event.define
-        OtherExample = SomeOtherEvent
-
-        module Type
-          def self.example = SomeEvent.event_type
-          def self.other_example = SomeOtherEvent.event_type
-          def self.random = :"#{example}#{Random.string}"
+        def self.other_example
+          Other.example
         end
 
-        module Data
-          def self.example(event_type: nil)
-            event_type ||= SomeEvent.event_type
+        def self.random
+          Random.example(event_class:)
+        end
 
-            time_iso8601 = Time::ISO8601.example
+        def self.event_class
+          SomeEvent
+        end
 
-            %{#{event_type}\t"some-string"\t11\ttrue\tfalse\t\t#{time_iso8601}\r\n}
+        def self.some_attribute
+          'some-value'
+        end
+
+        def self.some_other_attribute
+          'some-alternate-value'
+        end
+
+        def self.process_id
+          Controls::EventData.process_id
+        end
+
+        def self.time
+          Controls::EventData.time
+        end
+
+        SomeEvent = TestBench::Telemetry::Event.define(:some_attribute, :some_other_attribute)
+        SomeOtherEvent = TestBench::Telemetry::Event.define(:some_attribute, :some_other_attribute)
+
+        module Other
+          extend EventData
+
+          def self.example(some_attribute: nil, some_other_attribute: nil, metadata: nil, process_id: nil, time: nil)
+            some_attribute ||= self.some_attribute
+            some_other_attribute ||= self.some_other_attribute
+            metadata ||= Metadata::Other.example(process_id:, time:)
+
+            Event.example(some_attribute:, some_other_attribute:, event_class:, metadata:)
           end
 
-          module Malformed
-            module Empty
-              def self.example = ''
-            end
+          def self.event_class
+            SomeOtherEvent
+          end
+
+          def self.some_attribute
+            'some-other-value'
+          end
 
-            module NoData
-              def self.example = "SomeEvent\r\n"
+          def self.some_other_attribute
+            'some-other-alternate-value'
+          end
+        end
+
+        module Random
+          extend EventData
+
+          def self.example(some_attribute: nil, some_other_attribute: nil, event_class: nil, metadata: nil, process_id: nil, time: nil)
+            some_attribute ||= self.some_attribute
+            some_other_attribute ||= self.some_other_attribute
+            event_class ||= self.event_class
+            metadata ||= Metadata::Random.example(process_id:, time:)
+
+            Event.example(some_attribute:, some_other_attribute:, event_class:, metadata:)
+          end
+
+          def self.event_class
+            if Controls::Random.boolean
+              SomeEvent
+            else
+              SomeOtherEvent
             end
+          end
+
+          def self.some_attribute
+            suffix = Controls::Random.string
+
+            "#{Event.some_attribute}-#{suffix}"
+          end
 
-            module IncorrectEventType
-              def self.example
-                Data.example(event_type:)
-              end
+          def self.some_other_attribute
+            suffix = Controls::Random.string
 
-              def self.event_type = :not_pascal_cased
+            "#{Event.some_other_attribute}-#{suffix}"
+          end
+        end
+
+        module Data
+          def self.example
+            some_attribute = Event.some_attribute
+            some_other_attribute = Event.some_other_attribute
+
+            [some_attribute, some_other_attribute]
+          end
+
+          module Other
+            def self.example
+              some_attribute = Event::Other.some_attribute
+              some_other_attribute = Event::Other.some_other_attribute
+
+              [some_attribute, some_other_attribute]
             end
+          end
+
+          module Random
+            def self.example
+              some_attribute = Event::Random.some_attribute
+              some_other_attribute = Event::Random.some_other_attribute
 
-            module IncorrectNewlines
-              def self.example
-                %{SomeEvent\t\t\n}
-              end
+              [some_attribute, some_other_attribute]
             end
           end
         end

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

@@ -0,0 +1,129 @@
+module TestBench
+  class Telemetry
+    module Controls
+      module EventData
+        def self.example(type: nil, process_id: nil, time: nil, data: nil)
+          type ||= self.type
+          process_id ||= self.process_id
+          time ||= self.time
+          data ||= self.data
+
+          event_data = Telemetry::EventData.new
+          event_data.type = type
+          event_data.process_id = process_id
+          event_data.time = time
+          event_data.data = data
+          event_data
+        end
+
+        def self.random
+          Random.example
+        end
+
+        def self.type
+          Type.example
+        end
+
+        def self.process_id
+          ProcessID.example
+        end
+
+        def self.time
+          Time.example
+        end
+
+        def self.data
+          Data.example
+        end
+
+        module Random
+          def self.example(type: nil, process_id: nil, time: nil, data: nil)
+            type ||= Type.random
+            process_id ||= ProcessID.random
+            time ||= Time.random
+            data ||= Data.random
+
+            EventData.example(type:, process_id:, time:, data:)
+          end
+        end
+
+        module Type
+          def self.example
+            :SomeEvent
+          end
+
+          def self.other_example
+            :SomeOtherEvent
+          end
+
+          def self.random
+            :"#{example}#{Controls::Random.string}"
+          end
+        end
+
+        module Data
+          def self.example
+            [
+              nil,
+              true,
+              false,
+              11,
+              'some-string',
+              Time.example
+            ]
+          end
+
+          def self.random
+            [
+              nil,
+              Controls::Random.boolean,
+              Controls::Random.boolean,
+              Controls::Random.integer,
+              Controls::Random.string,
+              Time.random
+            ]
+          end
+        end
+
+        module Text
+          def self.example(type: nil, process_id: nil, time: nil)
+            type ||= EventData.type
+            process_id ||= EventData.process_id
+            time ||= EventData.time
+
+            time_iso8601 = Time::ISO8601.example(time)
+
+            "#{type}\t#{process_id}\t#{time_iso8601}\t\ttrue\tfalse\t11\t\"some-string\"\t#{time_iso8601}\r\n"
+          end
+
+          module Malformed
+            module Empty
+              def self.example
+                ''
+              end
+            end
+
+            module IncorrectEventType
+              def self.example
+                Text.example(type:)
+              end
+
+              def self.type
+                :not_pascal_cased
+              end
+            end
+
+            module IncorrectNewlines
+              def self.example
+                text = Text.example
+                text.chomp!("\r\n")
+                text << "\n"
+                text
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/test_bench/telemetry/controls/file.rb

@@ -0,0 +1,84 @@
+module TestBench
+  class Telemetry
+    module Controls
+      module File
+        def self.example(...)
+          Temporary.example(...)
+        end
+
+        def self.random
+          Random.example
+        end
+
+        module Random
+          def self.example(...)
+            Temporary::Random.example(...)
+          end
+        end
+
+        module Name
+          def self.example(basename: nil, extension: nil)
+            basename ||= self.basename
+            extension ||= self.extension
+
+            "#{basename}#{extension}"
+          end
+
+          def self.random
+            Random.example
+          end
+
+          def self.basename
+            'some-file'
+          end
+
+          def self.extension
+            '.some-ext'
+          end
+
+          module Random
+            def self.example(basename: nil, extension: nil)
+              extension ||= self.extension
+
+              basename = Basename.example(basename:)
+
+              Name.example(basename:, extension:)
+            end
+
+            def self.extension
+              suffix = Controls::Random.string[0..4]
+
+              "#{Name.extension}-#{suffix}"
+            end
+
+            module Basename
+              def self.example(basename: nil)
+                basename ||= Name.basename
+
+                suffix = Controls::Random.string
+
+                "#{basename}-#{suffix}"
+              end
+            end
+          end
+        end
+
+        module Temporary
+          def self.example(...)
+            filename = Name.example(...)
+
+            ::File.join('tmp', filename)
+          end
+
+          module Random
+            def self.example(...)
+              filename = Name::Random.example(...)
+
+              ::File.join('tmp', filename)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/test_bench/telemetry/controls/handler.rb

@@ -2,72 +2,77 @@ module TestBench
   class Telemetry
     module Controls
       module Handler
-        def self.example(&block)
-          if block.nil?
-            cls = Example
-          else
-            cls = example_class(&block)
-          end
-
-          cls.new
+        def self.example
+          Example.new
         end
 
-        def self.example_class(&block)
-          Class.new do
-            include TestBench::Telemetry::Sink::Handler
+        class Example
+          include Telemetry::Sink::Handler
 
-            if not block.nil?
-              class_exec(&block)
-            end
-          end
-        end
+          attr_accessor :handled_event
+          attr_accessor :handled_event_data
 
-        module Event
-          def self.example(data=nil)
-            data ||= self.data
+          handle Event::SomeEvent do |some_event|
+            self.handled_event = some_event
+          end
 
-            Controls::Event.example(data)
+          def handle_event_data(event_data)
+            self.handled_event_data = event_data
           end
 
-          def self.data = 'some-data'
+          def handled?(event=nil)
+            return false if handled_event.nil?
 
-          def self.other_example
-            Controls::Event::OtherExample.new
+            return true if event.nil?
+
+            event == handled_event
           end
 
-          Example = Controls::Event::Example
-          OtherExample = Controls::Event::OtherExample
+          def handled_event_data?(event_data)
+            self.handled_event_data == event_data
+          end
         end
 
-        module Method
-          def self.example(event_type=nil)
-            event_type ||= Event::Example.event_type
+        module NoHandler
+          def self.example
+            Example.new
+          end
 
-            event_type_method_cased = TestBench::Telemetry::Event::Type.method_cased(event_type)
+          class Example
+            include Telemetry::Sink::Handler
+          end
+        end
 
-            :"handle_#{event_type_method_cased}"
+        module NoArgument
+          def self.example
+            Example.new
           end
 
-          def self.other_example
-            event_type = Event::OtherExample.event_type
+          class Example
+            include Telemetry::Sink::Handler
 
-            example(event_type)
+            attr_accessor :handled_event
+            def handled? = !!handled_event
+
+            handle Event::SomeEvent do
+              self.handled_event = true
+            end
           end
         end
 
-        Example = example_class do
-          attr_accessor :data
+        module Method
+          def self.example(event_type=nil)
+            event_type ||= Event::SomeEvent.event_type
+
+            event_name = TestBench::Telemetry::Event::EventName.get(event_type)
 
-          handle Event::Example do |data|
-            self.data = data
+            :"handle_#{event_name}"
           end
 
-          def handled?(data=nil)
-            if data.nil?
-              !self.data.nil?
-            else
-              data == self.data
-            end
+          def self.other_example
+            event_type = Event::SomeOtherEvent.event_type
+
+            example(event_type)
           end
         end
       end

data/lib/test_bench/telemetry/controls/{detail_level.rb → process_id.rb}

@@ -1,13 +1,17 @@
 module TestBench
   class Telemetry
     module Controls
-      module DetailLevel
+      module ProcessID
         def self.example
-          1
+          11111
+        end
+
+        def self.other_example
+          22222
         end
 
         def self.random
-          Random.integer % 11
+          Random.integer
         end
       end
     end

data/lib/test_bench/telemetry/controls/projection/receiver.rb

@@ -0,0 +1,31 @@
+module TestBench
+  class Telemetry
+    module Controls
+      module Projection
+        module Receiver
+          def self.example
+            Example.new
+          end
+
+          class Example
+            def events
+              @events ||= []
+            end
+
+            def event(event)
+              events << event
+            end
+
+            def event?(event=nil)
+              if not event.nil?
+                events.include?(event)
+              else
+                events.any?
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end