feat(events): Event Simulator scenarios and simulation unit tests

hathor/builder/builder.py

@@ -83,6 +83,7 @@ def __init__(self) -> None:
 
         self._event_manager: Optional[EventManager] = None
         self._event_ws_factory: Optional[EventWebsocketFactory] = None
+        self._enable_event_queue: Optional[bool] = None
 
         self._rocksdb_path: Optional[str] = None
         self._rocksdb_storage: Optional[RocksDBStorage] = None
@@ -126,7 +127,6 @@ def build(self) -> BuildArtifacts:
         consensus_algorithm = ConsensusAlgorithm(soft_voided_tx_ids, pubsub)
 
         wallet = self._get_or_create_wallet()
-        event_storage = self._get_or_create_event_storage()
         event_manager = self._get_or_create_event_manager()
         tx_storage = self._get_or_create_tx_storage()
         indexes = tx_storage.indexes
@@ -158,20 +158,22 @@ def build(self) -> BuildArtifacts:
         if self._full_verification is not None:
             kwargs['full_verification'] = self._full_verification
 
+        if self._enable_event_queue is not None:
+            kwargs['enable_event_queue'] = self._enable_event_queue
+
         manager = HathorManager(
             reactor,
             pubsub=pubsub,
             consensus_algorithm=consensus_algorithm,
             peer_id=peer_id,
             tx_storage=tx_storage,
-            event_storage=event_storage,
+            event_manager=event_manager,
             network=self._network,
             wallet=wallet,
             rng=self._rng,
             checkpoints=self._checkpoints,
             capabilities=self._capabilities,
             environment_info=get_environment_info(self._cmdline, peer_id.id),
-            event_manager=event_manager,
             **kwargs
         )
 
@@ -299,8 +301,8 @@ def _get_or_create_event_storage(self) -> EventStorage:
 
         return self._event_storage
 
-    def _get_or_create_event_manager(self) -> Optional[EventManager]:
-        if self._event_manager is None and self._event_ws_factory is not None:
+    def _get_or_create_event_manager(self) -> EventManager:
+        if self._event_manager is None:
             self._event_manager = EventManager(
                 reactor=self._get_reactor(),
                 pubsub=self._get_or_create_pubsub(),
@@ -385,6 +387,7 @@ def enable_wallet_index(self) -> 'Builder':
 
     def enable_event_manager(self, *, event_ws_factory: EventWebsocketFactory) -> 'Builder':
         self.check_if_can_modify()
+        self._enable_event_queue = True
         self._event_ws_factory = event_ws_factory
         return self
 

hathor/builder/cli_builder.py

@@ -143,19 +143,15 @@ def create_manager(self, reactor: PosixReactorBase, args: Namespace) -> HathorMa
 
         pubsub = PubSubManager(reactor)
 
-        event_manager: Optional[EventManager] = None
         if args.x_enable_event_queue:
             self.event_ws_factory = EventWebsocketFactory(reactor, event_storage)
-            event_manager = EventManager(
-                event_storage=event_storage,
-                event_ws_factory=self.event_ws_factory,
-                pubsub=pubsub,
-                reactor=reactor,
-                emit_load_events=args.x_emit_load_events
-            )
-        else:
-            self.check_or_raise(not args.x_emit_load_events, '--x-emit-load-events cannot be used without '
-                                                             '--x-enable-event-queue')
+
+        event_manager = EventManager(
+            event_storage=event_storage,
+            event_ws_factory=self.event_ws_factory,
+            pubsub=pubsub,
+            reactor=reactor
+        )
 
         if args.wallet_index and tx_storage.indexes is not None:
             self.log.debug('enable wallet indexes')
@@ -181,7 +177,6 @@ def create_manager(self, reactor: PosixReactorBase, args: Namespace) -> HathorMa
             network=network,
             hostname=hostname,
             tx_storage=tx_storage,
-            event_storage=event_storage,
             event_manager=event_manager,
             wallet=self.wallet,
             stratum_port=args.stratum,
@@ -191,7 +186,8 @@ def create_manager(self, reactor: PosixReactorBase, args: Namespace) -> HathorMa
             enable_sync_v2=enable_sync_v2,
             consensus_algorithm=consensus_algorithm,
             environment_info=get_environment_info(args=str(args), peer_id=peer_id.id),
-            full_verification=full_verification
+            full_verification=full_verification,
+            enable_event_queue=bool(args.x_enable_event_queue)
         )
 
         if args.allow_mining_without_peers:
@@ -235,7 +231,7 @@ def create_manager(self, reactor: PosixReactorBase, args: Namespace) -> HathorMa
 
             self.manager.enable_event_queue = True
             self.log.info('--x-enable-event-queue flag provided. '
-                          'The events detected by the full node will be stored and retrieved to clients')
+                          'The events detected by the full node will be stored and can be retrieved by clients')
 
         for description in args.listen:
             self.manager.add_listen_address(description)
@@ -508,7 +504,7 @@ def create_resources(self, args: Namespace) -> server.Site:
         ws_factory.subscribe(self.manager.pubsub)
 
         # Event websocket resource
-        if args.x_enable_event_queue and self.event_ws_factory is not None:
+        if args.x_enable_event_queue:
             root.putChild(b'event_ws', WebSocketResource(self.event_ws_factory))
             root.putChild(b'event', EventResource(self.manager._event_manager))
 

hathor/cli/events_simulator/events_simulator.py

@@ -37,7 +37,7 @@ def execute(args: Namespace) -> None:
 
     storage = EventMemoryStorage()
 
-    for event in args.scenario.get_events():
+    for event in args.scenario.value:
         storage.save_event(event)
 
     factory = EventWebsocketFactory(reactor, storage)