Make our traits object safe and implement the ReviveDevNodePolkaVMResolc target. (#159)

* Generate schema for the metadata file

* Groundwork for dyn traits

* Make the ethereum node trait object compatible

* Allow for compilers to be created in the dyn trait

* Add more identifiers to the platform

* Implement the dyn compiler trait for compilers

* Support the dyn compiler in the builder pattern

* Introduce a geth platform

* Provide a common node implementation for substrate chains

* Add all of the platforms that we support

* Add a way to convert platform identifier into a platform

* Replace infra with the dyn infra

* Remoe all references to leader and follower

* Remove the old traits

* Remove an un-needed dependency

* Update the default values for the platforms

* Final set of renames

* Update the default values of the cli

* Update tests

crates/report/src/aggregator.rs

@@ -11,8 +11,9 @@ use std::{
 use alloy_primitives::Address;
 use anyhow::{Context as _, Result};
 use indexmap::IndexMap;
+use revive_dt_common::types::PlatformIdentifier;
 use revive_dt_compiler::{CompilerInput, CompilerOutput, Mode};
-use revive_dt_config::{Context, TestingPlatform};
+use revive_dt_config::Context;
 use revive_dt_format::{case::CaseIdx, corpus::Corpus, metadata::ContractInstance};
 use semver::Version;
 use serde::Serialize;
@@ -84,11 +85,8 @@ impl ReportAggregator {
                 RunnerEvent::TestIgnored(event) => {
                     self.handle_test_ignored_event(*event);
                 }
-                RunnerEvent::LeaderNodeAssigned(event) => {
-                    self.handle_leader_node_assigned_event(*event);
-                }
-                RunnerEvent::FollowerNodeAssigned(event) => {
-                    self.handle_follower_node_assigned_event(*event);
+                RunnerEvent::NodeAssigned(event) => {
+                    self.handle_node_assigned_event(*event);
                 }
                 RunnerEvent::PreLinkContractsCompilationSucceeded(event) => {
                     self.handle_pre_link_contracts_compilation_succeeded_event(*event)
@@ -257,28 +255,15 @@ impl ReportAggregator {
         let _ = self.listener_tx.send(event);
     }
 
-    fn handle_leader_node_assigned_event(&mut self, event: LeaderNodeAssignedEvent) {
+    fn handle_node_assigned_event(&mut self, event: NodeAssignedEvent) {
         let execution_information = self.execution_information(&ExecutionSpecifier {
             test_specifier: event.test_specifier,
             node_id: event.id,
-            node_designation: NodeDesignation::Leader,
+            platform_identifier: event.platform_identifier,
         });
         execution_information.node = Some(TestCaseNodeInformation {
             id: event.id,
-            platform: event.platform,
-            connection_string: event.connection_string,
-        });
-    }
-
-    fn handle_follower_node_assigned_event(&mut self, event: FollowerNodeAssignedEvent) {
-        let execution_information = self.execution_information(&ExecutionSpecifier {
-            test_specifier: event.test_specifier,
-            node_id: event.id,
-            node_designation: NodeDesignation::Follower,
-        });
-        execution_information.node = Some(TestCaseNodeInformation {
-            id: event.id,
-            platform: event.platform,
+            platform_identifier: event.platform_identifier,
             connection_string: event.connection_string,
         });
     }
@@ -413,14 +398,11 @@ impl ReportAggregator {
         specifier: &ExecutionSpecifier,
     ) -> &mut ExecutionInformation {
         let test_case_report = self.test_case_report(&specifier.test_specifier);
-        match specifier.node_designation {
-            NodeDesignation::Leader => test_case_report
-                .leader_execution_information
-                .get_or_insert_default(),
-            NodeDesignation::Follower => test_case_report
-                .follower_execution_information
-                .get_or_insert_default(),
-        }
+        test_case_report
+            .platform_execution
+            .entry(specifier.platform_identifier)
+            .or_default()
+            .get_or_insert_default()
     }
 }
 
@@ -455,12 +437,8 @@ pub struct TestCaseReport {
     /// Information on the status of the test case and whether it succeeded, failed, or was ignored.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub status: Option<TestCaseStatus>,
-    /// Information related to the execution on the leader.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub leader_execution_information: Option<ExecutionInformation>,
-    /// Information related to the execution on the follower.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub follower_execution_information: Option<ExecutionInformation>,
+    /// Information related to the execution on one of the platforms.
+    pub platform_execution: BTreeMap<PlatformIdentifier, Option<ExecutionInformation>>,
 }
 
 /// Information related to the status of the test. Could be that the test succeeded, failed, or that
@@ -488,18 +466,18 @@ pub enum TestCaseStatus {
     },
 }
 
-/// Information related to the leader or follower node that's being used to execute the step.
+/// Information related to the platform node that's being used to execute the step.
 #[derive(Clone, Debug, Serialize)]
 pub struct TestCaseNodeInformation {
     /// The ID of the node that this case is being executed on.
     pub id: usize,
     /// The platform of the node.
-    pub platform: TestingPlatform,
+    pub platform_identifier: PlatformIdentifier,
     /// The connection string of the node.
     pub connection_string: String,
 }
 
-/// Execution information tied to the leader or the follower.
+/// Execution information tied to the platform.
 #[derive(Clone, Debug, Default, Serialize)]
 pub struct ExecutionInformation {
     /// Information related to the node assigned to this test case.

crates/report/src/common.rs

@@ -2,7 +2,7 @@
 
 use std::{path::PathBuf, sync::Arc};
 
-use revive_dt_common::define_wrapper_type;
+use revive_dt_common::{define_wrapper_type, types::PlatformIdentifier};
 use revive_dt_compiler::Mode;
 use revive_dt_format::{case::CaseIdx, input::StepIdx};
 use serde::{Deserialize, Serialize};
@@ -22,18 +22,12 @@ pub struct TestSpecifier {
 }
 
 /// An absolute path for a test that also includes information about the node that it's assigned to
-/// and whether it's the leader or follower.
+/// and what platform it belongs to.
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub struct ExecutionSpecifier {
     pub test_specifier: Arc<TestSpecifier>,
     pub node_id: usize,
-    pub node_designation: NodeDesignation,
-}
-
-#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub enum NodeDesignation {
-    Leader,
-    Follower,
+    pub platform_identifier: PlatformIdentifier,
 }
 
 #[derive(Clone, Debug, PartialEq, Eq, Hash)]

crates/report/src/runner_event.rs

@@ -6,8 +6,8 @@ use std::{collections::BTreeMap, path::PathBuf, sync::Arc};
 use alloy_primitives::Address;
 use anyhow::Context as _;
 use indexmap::IndexMap;
+use revive_dt_common::types::PlatformIdentifier;
 use revive_dt_compiler::{CompilerInput, CompilerOutput};
-use revive_dt_config::TestingPlatform;
 use revive_dt_format::metadata::Metadata;
 use revive_dt_format::{corpus::Corpus, metadata::ContractInstance};
 use semver::Version;
@@ -412,14 +412,14 @@ macro_rules! define_event {
                 pub fn execution_specific_reporter(
                     &self,
                     node_id: impl Into<usize>,
-                    node_designation: impl Into<$crate::common::NodeDesignation>
+                    platform_identifier: impl Into<PlatformIdentifier>
                 ) -> [< $ident ExecutionSpecificReporter >] {
                     [< $ident ExecutionSpecificReporter >] {
                         reporter: self.reporter.clone(),
                         execution_specifier: Arc::new($crate::common::ExecutionSpecifier {
                             test_specifier: self.test_specifier.clone(),
                             node_id: node_id.into(),
-                            node_designation: node_designation.into(),
+                            platform_identifier: platform_identifier.into(),
                         })
                     }
                 }
@@ -434,7 +434,7 @@ macro_rules! define_event {
             }
 
             /// A reporter that's tied to a specific execution of the test case such as execution on
-            /// a specific node like the leader or follower.
+            /// a specific node from a specific platform.
             #[derive(Clone, Debug)]
             pub struct [< $ident ExecutionSpecificReporter >] {
                 $vis reporter: [< $ident Reporter >],
@@ -520,25 +520,14 @@ define_event! {
             /// A reason for the failure of the test.
             reason: String,
         },
-        /// An event emitted when the test case is assigned a leader node.
-        LeaderNodeAssigned {
+        /// An event emitted when the test case is assigned a platform node.
+        NodeAssigned {
             /// A specifier for the test that the assignment is for.
             test_specifier: Arc<TestSpecifier>,
             /// The ID of the node that this case is being executed on.
             id: usize,
-            /// The platform of the node.
-            platform: TestingPlatform,
-            /// The connection string of the node.
-            connection_string: String,
-        },
-        /// An event emitted when the test case is assigned a follower node.
-        FollowerNodeAssigned {
-            /// A specifier for the test that the assignment is for.
-            test_specifier: Arc<TestSpecifier>,
-            /// The ID of the node that this case is being executed on.
-            id: usize,
-            /// The platform of the node.
-            platform: TestingPlatform,
+            /// The identifier of the platform used.
+            platform_identifier: PlatformIdentifier,
             /// The connection string of the node.
             connection_string: String,
         },