Skip to main content

zombienet_configuration/
network.rs

1use std::{
2    cell::RefCell,
3    collections::HashSet,
4    fs,
5    marker::PhantomData,
6    path::{Path, PathBuf},
7    rc::Rc,
8};
9
10use anyhow::anyhow;
11use regex::{Captures, Regex};
12use serde::{Deserialize, Serialize};
13use support::{
14    constants::{NO_ERR_DEF_BUILDER, RELAY_NOT_NONE, THIS_IS_A_BUG, VALID_REGEX},
15    replacer::apply_env_replacements,
16};
17use tracing::trace;
18
19use crate::{
20    custom_process,
21    global_settings::{GlobalSettings, GlobalSettingsBuilder},
22    hrmp_channel::{self, HrmpChannelConfig, HrmpChannelConfigBuilder},
23    jamchain::{self, JamchainConfig, JamchainConfigBuilder},
24    parachain::{self, ParachainConfig, ParachainConfigBuilder},
25    relaychain::{self, RelaychainConfig, RelaychainConfigBuilder},
26    shared::{
27        errors::{ConfigError, ValidationError},
28        helpers::{generate_unique_node_name_from_names, merge_errors, merge_errors_vecs},
29        macros::states,
30        node::{GroupNodeConfig, NodeConfig},
31        types::{Arg, AssetLocation, Chain, Command, Image, ValidationContext},
32    },
33    types::ParaId,
34    CustomProcess, CustomProcessBuilder, RegistrationStrategy,
35};
36
37/// A network configuration, composed of a relaychain (or a JAM chain), parachains and HRMP
38/// channels.
39///
40/// The JAM chain takes the place of the relaychain, so a network has one or the other, never
41/// both.
42#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
43pub struct NetworkConfig {
44    #[serde(rename = "settings", default = "GlobalSettings::default")]
45    global_settings: GlobalSettings,
46    relaychain: Option<RelaychainConfig>,
47    jamchain: Option<JamchainConfig>,
48    #[serde(skip_serializing_if = "std::vec::Vec::is_empty", default)]
49    parachains: Vec<ParachainConfig>,
50    #[serde(skip_serializing_if = "std::vec::Vec::is_empty", default)]
51    hrmp_channels: Vec<HrmpChannelConfig>,
52    #[serde(skip_serializing_if = "std::vec::Vec::is_empty", default)]
53    custom_processes: Vec<CustomProcess>,
54}
55
56impl NetworkConfig {
57    /// The global settings of the network.
58    pub fn global_settings(&self) -> &GlobalSettings {
59        &self.global_settings
60    }
61
62    /// The relay chain of the network.
63    pub fn relaychain(&self) -> &RelaychainConfig {
64        self.relaychain
65            .as_ref()
66            .expect(&format!("{RELAY_NOT_NONE}, {THIS_IS_A_BUG}"))
67    }
68
69    /// The relay chain of the network, `None` for a JAM network.
70    pub fn try_relaychain(&self) -> Option<&RelaychainConfig> {
71        self.relaychain.as_ref()
72    }
73
74    /// The jam chain of the network.
75    pub fn jamchain(&self) -> Option<&JamchainConfig> {
76        if let Some(jamconfig) = &self.jamchain {
77            Some(jamconfig)
78        } else {
79            None
80        }
81    }
82
83    /// The parachains of the network.
84    pub fn parachains(&self) -> Vec<&ParachainConfig> {
85        self.parachains.iter().collect::<Vec<_>>()
86    }
87
88    /// The HRMP channels of the network.
89    pub fn hrmp_channels(&self) -> Vec<&HrmpChannelConfig> {
90        self.hrmp_channels.iter().collect::<Vec<_>>()
91    }
92
93    /// The Custom process to spawn
94    pub fn custom_processes(&self) -> Vec<&CustomProcess> {
95        self.custom_processes.iter().collect::<Vec<_>>()
96    }
97
98    /// Set the parachain.
99    fn set_parachains(&mut self, parachains: Vec<ParachainConfig>) {
100        self.parachains = parachains;
101    }
102
103    /// A helper function to dump the network configuration to a TOML string.
104    pub fn dump_to_toml(&self) -> Result<String, toml::ser::Error> {
105        // This regex is used to replace the "" enclosed u128 value to a raw u128 because u128 is not supported for TOML serialization/deserialization.
106        let re = Regex::new(r#""U128%(?<u128_value>\d+)""#)
107            .expect(&format!("{VALID_REGEX} {THIS_IS_A_BUG}"));
108        let toml_string = toml::to_string_pretty(&self)?;
109
110        Ok(re.replace_all(&toml_string, "$u128_value").to_string())
111    }
112
113    /// A helper function to load a network configuration from a TOML file.
114    pub fn load_from_toml_with_settings(
115        path: &str,
116        settings: &GlobalSettings,
117    ) -> Result<NetworkConfig, anyhow::Error> {
118        let mut network_config = NetworkConfig::load_from_toml(path)?;
119        network_config.global_settings = settings.clone();
120        Ok(network_config)
121    }
122
123    /// A helper function to load a network configuration from a TOML file.
124    pub fn load_from_toml(path: &str) -> Result<NetworkConfig, anyhow::Error> {
125        let file_path = PathBuf::from(path).canonicalize()?;
126        let network_definition_dir = file_path
127            .parent()
128            .ok_or(anyhow!("should have a base dir"))?;
129        trace!(
130            "file_dir for replacer: {:?}",
131            network_definition_dir.as_os_str()
132        );
133        let file_str = fs::read_to_string(path)
134            .map_err(|e| anyhow!("Failed to read configuration file '{}': {}", path, e))?;
135
136        Self::load_from_toml_string_with_base_dir(&file_str, network_definition_dir)
137    }
138
139    /// A helper function to load a network configuration from a TOML string.
140    ///
141    /// Relative paths (e.g. `command = "./bin/polkadot"`) are resolved against the current
142    /// working directory, since there is no configuration file to use as base. Use
143    /// [`NetworkConfig::load_from_toml_string_with_base_dir`] to resolve them against a
144    /// specific directory instead.
145    pub fn load_from_toml_string(toml_data: &str) -> Result<NetworkConfig, anyhow::Error> {
146        let base_dir = std::env::current_dir()?;
147
148        Self::load_from_toml_string_with_base_dir(toml_data, &base_dir)
149    }
150
151    /// A helper function to load a network configuration from a TOML string, resolving
152    /// relative paths (e.g. `command = "./bin/polkadot"`) against `base_dir`.
153    pub fn load_from_toml_string_with_base_dir(
154        toml_text: &str,
155        base_dir: &Path,
156    ) -> Result<NetworkConfig, anyhow::Error> {
157        let re: Regex = Regex::new(r"(?<field_name>(initial_)?balance)\s+=\s+(?<u128_value>\d+)")
158            .expect(&format!("{VALID_REGEX} {THIS_IS_A_BUG}"));
159
160        let re_paths: Regex = Regex::new(r#"(?<field_name>(default_)?(command|db_snapshot|chain_spec_path|genesis_wasm_path|genesis_state_path))\s+=\s+\"(?<value_string>[a-zA-Z0-9\.\/]+)\""#)
161            .expect(&format!("{VALID_REGEX} {THIS_IS_A_BUG}"));
162        // a file on this host, so any character a path may hold
163        let re_local_paths: Regex = Regex::new(
164            r#"(?m)(?<field_name>(?:^|[\s{,])local_path)\s*=\s*"(?<value_string>[^"]+)""#,
165        )
166        .expect(&format!("{VALID_REGEX} {THIS_IS_A_BUG}"));
167
168        let path_replacer = |caps: &Captures| {
169            trace!("cmd replacer captures: {:?}", caps);
170            let cmd = maybe_absolute(&caps["value_string"], base_dir);
171            let line = format!("{} = \"{cmd}\"", &caps["field_name"]);
172            trace!("line after replacer: {line}");
173            line
174        };
175
176        let toml_text = re.replace_all(toml_text, "$field_name = \"$u128_value\"");
177        let toml_text = re_paths.replace_all(&toml_text, &path_replacer);
178        let toml_text = re_local_paths.replace_all(&toml_text, &path_replacer);
179
180        trace!("toml text to parse: {}", toml_text);
181        // apply replacements from env in toml
182        let toml_text = apply_env_replacements(&toml_text);
183        trace!("toml text after replacements: {}", toml_text);
184        let mut network_config: NetworkConfig = toml::from_str(&toml_text)?;
185        trace!("parsed config {network_config:#?}");
186
187        // A network is rooted either in a relaychain or in a JAM chain.
188        if network_config.relaychain.is_none() && network_config.jamchain.is_none() {
189            Err(anyhow!("Relay chain or Jam definition does not exist."))?
190        }
191
192        if let Some(jamchain) = network_config.jamchain.as_mut() {
193            if let Some(error) = jamchain.spec_source_errors().into_iter().next() {
194                return Err(ConfigError::Jamchain(error).into());
195            }
196            jamchain.resolve_relative_paths(base_dir);
197        }
198
199        // Keep track of node names to ensure uniqueness, shared between the nodes of the
200        // root chain and the collators.
201        let mut names = HashSet::new();
202
203        if let Some(relaychain) = network_config.relaychain.as_mut() {
204            // retrieve the defaults relaychain for assigning to nodes if needed
205            let mut relaychain_default_command: Option<Command> =
206                relaychain.default_command().cloned();
207
208            if relaychain_default_command.is_none() {
209                relaychain_default_command = relaychain.command().cloned();
210            }
211
212            let relaychain_default_image: Option<Image> = relaychain.default_image().cloned();
213
214            let relaychain_default_db_snapshot: Option<AssetLocation> =
215                relaychain.default_db_snapshot().cloned();
216
217            let default_args: Vec<Arg> = relaychain.default_args().into_iter().cloned().collect();
218
219            let mut nodes: Vec<NodeConfig> = relaychain.nodes().into_iter().cloned().collect();
220
221            let group_nodes: Vec<GroupNodeConfig> = relaychain
222                .group_node_configs()
223                .into_iter()
224                .cloned()
225                .collect();
226
227            if let Some(group) = group_nodes.iter().find(|n| n.count == 0) {
228                return Err(anyhow!(
229                    "Group node '{}' must have a count greater than 0.",
230                    group.base_config.name()
231                ));
232            }
233
234            // Validation checks for relay
235            TryInto::<Chain>::try_into(relaychain.chain().as_str())?;
236            if let Some(default_image) = &relaychain_default_image {
237                TryInto::<Image>::try_into(default_image.clone())?;
238            }
239            if let Some(default_command) = &relaychain_default_command {
240                TryInto::<Command>::try_into(default_command.clone())?;
241            }
242
243            for node in nodes.iter_mut() {
244                if relaychain_default_command.is_some() {
245                    // we modify only nodes which don't already have a command
246                    if node.command.is_none() {
247                        node.command.clone_from(&relaychain_default_command);
248                    }
249                }
250
251                if relaychain_default_image.is_some() && node.image.is_none() {
252                    node.image.clone_from(&relaychain_default_image);
253                }
254
255                if relaychain_default_db_snapshot.is_some() && node.db_snapshot.is_none() {
256                    node.db_snapshot.clone_from(&relaychain_default_db_snapshot);
257                }
258
259                if !default_args.is_empty() && node.args().is_empty() {
260                    node.set_args(default_args.clone());
261                }
262
263                let unique_name = generate_unique_node_name_from_names(node.name(), &mut names);
264                node.name = unique_name;
265            }
266
267            relaychain.set_nodes(nodes);
268        }
269
270        let mut parachains: Vec<ParachainConfig> =
271            network_config.parachains().into_iter().cloned().collect();
272
273        for para in parachains.iter_mut() {
274            // retrieve the defaults parachain for assigning to collators if needed
275            let parachain_default_command: Option<Command> = para.default_command().cloned();
276
277            let parachain_default_image: Option<Image> = para.default_image().cloned();
278
279            let parachain_default_db_snapshot: Option<AssetLocation> =
280                para.default_db_snapshot().cloned();
281
282            let default_args: Vec<Arg> = para.default_args().into_iter().cloned().collect();
283
284            let group_collators: Vec<GroupNodeConfig> = para
285                .group_collators_configs()
286                .into_iter()
287                .cloned()
288                .collect();
289
290            if let Some(group) = group_collators.iter().find(|n| n.count == 0) {
291                return Err(anyhow!(
292                    "Group node '{}' must have a count greater than 0.",
293                    group.base_config.name()
294                ));
295            }
296
297            let mut collators: Vec<NodeConfig> = para.collators.clone();
298
299            for collator in collators.iter_mut() {
300                populate_collator_with_defaults(
301                    collator,
302                    &parachain_default_command,
303                    &parachain_default_image,
304                    &parachain_default_db_snapshot,
305                    &default_args,
306                );
307                let unique_name = generate_unique_node_name_from_names(collator.name(), &mut names);
308                collator.name = unique_name;
309            }
310
311            para.collators = collators;
312
313            if let Some(mut collator) = para.collator.clone() {
314                populate_collator_with_defaults(
315                    &mut collator,
316                    &parachain_default_command,
317                    &parachain_default_image,
318                    &parachain_default_db_snapshot,
319                    &default_args,
320                );
321                let unique_name = generate_unique_node_name_from_names(collator.name(), &mut names);
322                collator.name = unique_name;
323                para.collator = Some(collator);
324            }
325        }
326
327        network_config.set_parachains(parachains);
328
329        // Validation checks for parachains
330        network_config.parachains().iter().for_each(|parachain| {
331            if let Some(default_image) = parachain.default_image() {
332                let _ = TryInto::<Image>::try_into(default_image.as_str());
333            }
334            if let Some(default_command) = parachain.default_command() {
335                let _ = TryInto::<Command>::try_into(default_command.as_str());
336            }
337        });
338
339        // Custom processes bypass their builder here, so apply its rules (see
340        // `CustomProcess::validate`), and a name that is not already a node's
341        // (they share one registry on the running network).
342        let mut errors: Vec<String> = vec![];
343        for process in &network_config.custom_processes {
344            if names.contains(process.name()) {
345                errors.push(format!(
346                    "custom_processes['{}'].name: already used by a node or custom process",
347                    process.name()
348                ));
349            }
350            names.insert(process.name().to_string());
351            if let Err(port_errors) = process.validate() {
352                errors.extend(
353                    port_errors
354                        .into_iter()
355                        .map(|e| format!("custom_processes['{}'].{e}", process.name())),
356                );
357            }
358        }
359        if let Err(dependency_errors) =
360            custom_process::validate_custom_processes(&network_config.custom_processes)
361        {
362            errors.extend(dependency_errors);
363        }
364        if !errors.is_empty() {
365            Err(anyhow!(errors.join("\n")))?
366        }
367
368        Ok(network_config)
369    }
370}
371
372fn maybe_absolute(cmd: &str, base_dir: &Path) -> String {
373    if cmd.starts_with(".") {
374        let mut full = PathBuf::from(base_dir);
375        full.push(cmd);
376        trace!("full_path: {:?}", full);
377        std::path::absolute(&full)
378            .expect(&format!(
379                "absolute path shoud be valid: {:?}",
380                full.as_os_str()
381            ))
382            .to_string_lossy()
383            .to_string()
384    } else {
385        cmd.to_string()
386    }
387}
388
389fn populate_collator_with_defaults(
390    collator: &mut NodeConfig,
391    parachain_default_command: &Option<Command>,
392    parachain_default_image: &Option<Image>,
393    parachain_default_db_snapshot: &Option<AssetLocation>,
394    default_args: &[Arg],
395) {
396    if parachain_default_command.is_some() {
397        // we modify only nodes which don't already have a command
398        if collator.command.is_none() {
399            collator.command.clone_from(parachain_default_command);
400        }
401    }
402
403    if parachain_default_image.is_some() && collator.image.is_none() {
404        collator.image.clone_from(parachain_default_image);
405    }
406
407    if parachain_default_db_snapshot.is_some() && collator.db_snapshot.is_none() {
408        collator
409            .db_snapshot
410            .clone_from(parachain_default_db_snapshot);
411    }
412
413    if !default_args.is_empty() && collator.args().is_empty() {
414        collator.set_args(default_args.to_owned());
415    }
416}
417
418states! {
419    Initial,
420    Buildable
421}
422
423/// A network configuration builder, used to build a [`NetworkConfig`] declaratively with fields validation.
424///
425/// # Example:
426///
427/// ```
428/// use zombienet_configuration::NetworkConfigBuilder;
429///
430/// let network_config = NetworkConfigBuilder::new()
431///     .with_relaychain(|relaychain| {
432///         relaychain
433///             .with_chain("polkadot")
434///             .with_random_nominators_count(10)
435///             .with_default_resources(|resources| {
436///                 resources
437///                     .with_limit_cpu("1000m")
438///                     .with_request_memory("1Gi")
439///                     .with_request_cpu(100_000)
440///             })
441///             .with_validator(|node| node.with_name("node").with_command("command"))
442///             .with_validator(|node| node.with_name("node1").with_command("command"))
443///     })
444///     .with_parachain(|parachain| {
445///         parachain
446///             .with_id(1000)
447///             .with_chain("myparachain1")
448///             .with_initial_balance(100_000)
449///             .with_default_image("myimage:version")
450///             .with_collator(|collator| {
451///                 collator
452///                     .with_name("collator1")
453///                     .with_command("command1")
454///                     .validator(true)
455///             })
456///     })
457///     .with_parachain(|parachain| {
458///         parachain
459///             .with_id(2000)
460///             .with_chain("myparachain2")
461///             .with_initial_balance(50_0000)
462///             .with_collator(|collator| {
463///                 collator
464///                     .with_name("collator2")
465///                     .with_command("command2")
466///                     .validator(true)
467///             })
468///     })
469///     .with_hrmp_channel(|hrmp_channel1| {
470///         hrmp_channel1
471///             .with_sender(1)
472///             .with_recipient(2)
473///             .with_max_capacity(200)
474///             .with_max_message_size(500)
475///     })
476///     .with_hrmp_channel(|hrmp_channel2| {
477///         hrmp_channel2
478///             .with_sender(2)
479///             .with_recipient(1)
480///             .with_max_capacity(100)
481///             .with_max_message_size(250)
482///     })
483///     .with_global_settings(|global_settings| {
484///         global_settings
485///             .with_network_spawn_timeout(1200)
486///             .with_node_spawn_timeout(240)
487///     })
488///     .build();
489///
490/// assert!(network_config.is_ok())
491/// ```
492pub struct NetworkConfigBuilder<State> {
493    config: NetworkConfig,
494    validation_context: Rc<RefCell<ValidationContext>>,
495    errors: Vec<anyhow::Error>,
496    _state: PhantomData<State>,
497}
498
499impl Default for NetworkConfigBuilder<Initial> {
500    fn default() -> Self {
501        Self {
502            config: NetworkConfig {
503                global_settings: GlobalSettingsBuilder::new()
504                    .build()
505                    .expect(&format!("{NO_ERR_DEF_BUILDER}, {THIS_IS_A_BUG}")),
506                relaychain: None,
507                jamchain: None,
508                parachains: vec![],
509                hrmp_channels: vec![],
510                custom_processes: vec![],
511            },
512            validation_context: Default::default(),
513            errors: vec![],
514            _state: PhantomData,
515        }
516    }
517}
518
519impl<A> NetworkConfigBuilder<A> {
520    fn transition<B>(
521        config: NetworkConfig,
522        validation_context: Rc<RefCell<ValidationContext>>,
523        errors: Vec<anyhow::Error>,
524    ) -> NetworkConfigBuilder<B> {
525        NetworkConfigBuilder {
526            config,
527            errors,
528            validation_context,
529            _state: PhantomData,
530        }
531    }
532
533    /// Set the default tiny configuration for JAM
534    /// id: dev
535    /// 6 validators with names jam0..jam5
536    /// 1 ordinary with name jam-or
537    /// NO corevm builder
538    /// NO corevm monitor
539    fn setup_tiny_jamchain(self) -> NetworkConfigBuilder<Buildable> {
540        let mut builder = JamchainConfigBuilder::new(self.validation_context.clone())
541            .with_id("dev")
542            .with_validator(|n| n.with_name("jam0"));
543
544        for i in 1..6 {
545            builder = builder.with_validator(|n| n.with_name(&format!("jam{i}")));
546        }
547
548        let builder = builder.with_ordinary(|n| n.with_name("jam-or"));
549
550        match builder.build() {
551            Ok(jamchain) => Self::transition(
552                NetworkConfig {
553                    jamchain: Some(jamchain),
554                    ..self.config
555                },
556                self.validation_context,
557                self.errors,
558            ),
559            Err(errors) => Self::transition(self.config, self.validation_context, errors),
560        }
561    }
562}
563
564impl NetworkConfigBuilder<Initial> {
565    pub fn new() -> NetworkConfigBuilder<Initial> {
566        Self::default()
567    }
568
569    /// uses the default options for both the relay chain and the validator nodes
570    /// the only required fields are the name of the validator nodes,
571    /// and the name of the relay chain ("rococo-local", "polkadot", etc.)
572    pub fn with_chain_and_nodes(
573        relay_name: &str,
574        node_names: Vec<String>,
575    ) -> NetworkConfigBuilder<Buildable> {
576        let network_config = NetworkConfigBuilder::new().with_relaychain(|relaychain| {
577            let mut relaychain_with_node =
578                relaychain.with_chain(relay_name).with_validator(|node| {
579                    node.with_name(node_names.first().unwrap_or(&"".to_string()))
580                });
581
582            for node_name in node_names.iter().skip(1) {
583                relaychain_with_node = relaychain_with_node
584                    .with_validator(|node_builder| node_builder.with_name(node_name));
585            }
586            relaychain_with_node
587        });
588
589        Self::transition(
590            network_config.config,
591            network_config.validation_context,
592            network_config.errors,
593        )
594    }
595
596    /// Set the relay chain using a nested [`RelaychainConfigBuilder`].
597    pub fn with_relaychain(
598        self,
599        f: impl FnOnce(
600            RelaychainConfigBuilder<relaychain::Initial>,
601        ) -> RelaychainConfigBuilder<relaychain::WithAtLeastOneNode>,
602    ) -> NetworkConfigBuilder<Buildable> {
603        match f(RelaychainConfigBuilder::new(
604            self.validation_context.clone(),
605        ))
606        .build()
607        {
608            Ok(relaychain) => Self::transition(
609                NetworkConfig {
610                    relaychain: Some(relaychain),
611                    ..self.config
612                },
613                self.validation_context,
614                self.errors,
615            ),
616            Err(errors) => Self::transition(self.config, self.validation_context, errors),
617        }
618    }
619
620    /// Set the jam chain using a nested [`JamchainConfigBuilder`].
621    pub fn with_jamchain(
622        self,
623        f: impl FnOnce(
624            JamchainConfigBuilder<jamchain::Initial>,
625        ) -> JamchainConfigBuilder<jamchain::WithAtLeastOneNode>,
626    ) -> NetworkConfigBuilder<Buildable> {
627        match f(JamchainConfigBuilder::new(self.validation_context.clone())).build() {
628            Ok(jamchain) => Self::transition(
629                NetworkConfig {
630                    jamchain: Some(jamchain),
631                    ..self.config
632                },
633                self.validation_context,
634                self.errors,
635            ),
636            Err(errors) => Self::transition(self.config, self.validation_context, errors),
637        }
638    }
639
640    /// Set the default tiny configuration for JAM
641    /// see [`setup_tiny_jamchain`] fn.
642    pub fn with_tiny_jamchain(self) -> NetworkConfigBuilder<Buildable> {
643        self.setup_tiny_jamchain()
644    }
645}
646
647impl NetworkConfigBuilder<Buildable> {
648    // Allow to set jam/relay in buildable state (override if already set)
649
650    /// Set the relay chain using a nested [`RelaychainConfigBuilder`].
651    pub fn with_relaychain(
652        self,
653        f: impl FnOnce(
654            RelaychainConfigBuilder<relaychain::Initial>,
655        ) -> RelaychainConfigBuilder<relaychain::WithAtLeastOneNode>,
656    ) -> NetworkConfigBuilder<Buildable> {
657        match f(RelaychainConfigBuilder::new(
658            self.validation_context.clone(),
659        ))
660        .build()
661        {
662            Ok(relaychain) => Self::transition(
663                NetworkConfig {
664                    relaychain: Some(relaychain),
665                    ..self.config
666                },
667                self.validation_context,
668                self.errors,
669            ),
670            Err(errors) => Self::transition(self.config, self.validation_context, errors),
671        }
672    }
673
674    /// Set the jam chain using a nested [`JamchainConfigBuilder`].
675    pub fn with_jamchain(
676        self,
677        f: impl FnOnce(
678            JamchainConfigBuilder<jamchain::Initial>,
679        ) -> JamchainConfigBuilder<jamchain::WithAtLeastOneNode>,
680    ) -> NetworkConfigBuilder<Buildable> {
681        match f(JamchainConfigBuilder::new(self.validation_context.clone())).build() {
682            Ok(jamchain) => Self::transition(
683                NetworkConfig {
684                    jamchain: Some(jamchain),
685                    ..self.config
686                },
687                self.validation_context,
688                self.errors,
689            ),
690            Err(errors) => Self::transition(self.config, self.validation_context, errors),
691        }
692    }
693
694    /// Set the default tiny configuration for JAM
695    /// see [`setup_tiny_jamchain`] fn.
696    pub fn with_tiny_jamchain(self) -> NetworkConfigBuilder<Buildable> {
697        self.setup_tiny_jamchain()
698    }
699
700    /// Set the global settings using a nested [`GlobalSettingsBuilder`].
701    pub fn with_global_settings(
702        self,
703        f: impl FnOnce(GlobalSettingsBuilder) -> GlobalSettingsBuilder,
704    ) -> Self {
705        match f(GlobalSettingsBuilder::new()).build() {
706            Ok(global_settings) => Self::transition(
707                NetworkConfig {
708                    global_settings,
709                    ..self.config
710                },
711                self.validation_context,
712                self.errors,
713            ),
714            Err(errors) => Self::transition(
715                self.config,
716                self.validation_context,
717                merge_errors_vecs(self.errors, errors),
718            ),
719        }
720    }
721
722    /// Add a parachain using a nested [`ParachainConfigBuilder`].
723    pub fn with_parachain(
724        self,
725        f: impl FnOnce(
726            ParachainConfigBuilder<parachain::states::Initial, parachain::states::Bootstrap>,
727        ) -> ParachainConfigBuilder<
728            parachain::states::WithAtLeastOneCollator,
729            parachain::states::Bootstrap,
730        >,
731    ) -> Self {
732        match f(ParachainConfigBuilder::new(self.validation_context.clone())).build() {
733            Ok(parachain) => Self::transition(
734                NetworkConfig {
735                    parachains: [self.config.parachains, vec![parachain]].concat(),
736                    ..self.config
737                },
738                self.validation_context,
739                self.errors,
740            ),
741            Err(errors) => Self::transition(
742                self.config,
743                self.validation_context,
744                merge_errors_vecs(self.errors, errors),
745            ),
746        }
747    }
748
749    /// uses default settings for setting for:
750    /// - the parachain,
751    /// - the global settings
752    /// - the hrmp channels
753    ///
754    /// the only required parameters are the names of the collators as a vector,
755    /// and the id of the parachain
756    pub fn with_parachain_id_and_collators(self, id: u32, collator_names: Vec<String>) -> Self {
757        if collator_names.is_empty() {
758            return Self::transition(
759                self.config,
760                self.validation_context,
761                merge_errors(
762                    self.errors,
763                    ConfigError::Parachain(id, ValidationError::CantBeEmpty().into()).into(),
764                ),
765            );
766        }
767
768        self.with_parachain(|parachain| {
769            let mut parachain_config = parachain.with_id(id).with_collator(|collator| {
770                collator
771                    .with_name(collator_names.first().unwrap_or(&"".to_string()))
772                    .validator(true)
773            });
774
775            for collator_name in collator_names.iter().skip(1) {
776                parachain_config = parachain_config
777                    .with_collator(|collator| collator.with_name(collator_name).validator(true));
778            }
779            parachain_config
780        })
781
782        // TODO: if need to set global settings and hrmp channels
783        // we can also do in here
784    }
785
786    /// Add an HRMP channel using a nested [`HrmpChannelConfigBuilder`].
787    pub fn with_hrmp_channel(
788        self,
789        f: impl FnOnce(
790            HrmpChannelConfigBuilder<hrmp_channel::Initial>,
791        ) -> HrmpChannelConfigBuilder<hrmp_channel::WithRecipient>,
792    ) -> Self {
793        let new_hrmp_channel = f(HrmpChannelConfigBuilder::new()).build();
794
795        Self::transition(
796            NetworkConfig {
797                hrmp_channels: [self.config.hrmp_channels, vec![new_hrmp_channel]].concat(),
798                ..self.config
799            },
800            self.validation_context,
801            self.errors,
802        )
803    }
804
805    /// Add a custom process using a nested [`CustomProcessBuilder`].
806    ///
807    /// Processes and nodes share one registry on the running network, so the
808    /// name must be free. Declare processes after the nodes: a node declared
809    /// later with a process's name is renamed (`<name>-1`), as it would be
810    /// after another node, where a process taking a node's name is an error.
811    pub fn with_custom_process(
812        self,
813        f: impl FnOnce(
814            CustomProcessBuilder<custom_process::WithOutName, custom_process::WithOutCmd>,
815        )
816            -> CustomProcessBuilder<custom_process::WithName, custom_process::WithCmd>,
817    ) -> Self {
818        match f(CustomProcessBuilder::new()).build() {
819            Ok(custom_process) => {
820                // Processes and nodes share one registry on the running network,
821                // so a process may not take a node's name. Recording it also keeps
822                // a node declared later from taking the process's.
823                let taken = !self
824                    .validation_context
825                    .borrow_mut()
826                    .used_nodes_names
827                    .insert(custom_process.name().to_string());
828                if taken {
829                    return Self::transition(
830                        self.config,
831                        self.validation_context,
832                        merge_errors(
833                            self.errors,
834                            ConfigError::CustomProcess(
835                                custom_process.name().to_string(),
836                                anyhow!("name: already used by a node or custom process"),
837                            )
838                            .into(),
839                        ),
840                    );
841                }
842                Self::transition(
843                    NetworkConfig {
844                        custom_processes: [self.config.custom_processes, vec![custom_process]]
845                            .concat(),
846                        ..self.config
847                    },
848                    self.validation_context,
849                    self.errors,
850                )
851            },
852            Err((name, errors)) => Self::transition(
853                self.config,
854                self.validation_context,
855                merge_errors_vecs(
856                    self.errors,
857                    errors
858                        .into_iter()
859                        .map(|error| ConfigError::CustomProcess(name.clone(), error).into())
860                        .collect::<Vec<_>>(),
861                ),
862            ),
863        }
864    }
865
866    /// Seals the builder and returns a [`NetworkConfig`] if there are no validation errors, else returns errors.
867    pub fn build(self) -> Result<NetworkConfig, Vec<anyhow::Error>> {
868        let mut paras_to_register: HashSet<ParaId> = Default::default();
869        let mut num_of_requested_cores = 0;
870
871        let mut errs: Vec<anyhow::Error> = self
872            .config
873            .parachains
874            .iter()
875            .filter_map(|para| {
876                if let Some(cores) = para.num_cores() {
877                    num_of_requested_cores += cores;
878                } else if let Some(RegistrationStrategy::InGenesis) = para.registration_strategy() {
879                    // add 1 by default
880                    num_of_requested_cores += 1;
881                }
882
883                if let Some(RegistrationStrategy::Manual) = para.registration_strategy() {
884                    return None;
885                };
886
887                if paras_to_register.insert(para.id()) {
888                    None
889                } else {
890                    // already in the set
891                    Some(anyhow!(
892                        "ParaId {} already set to be registered, only one should be.",
893                        para.id()
894                    ))
895                }
896            })
897            .collect();
898
899        if let Err(dependency_errors) =
900            custom_process::validate_custom_processes(&self.config.custom_processes)
901        {
902            errs.extend(dependency_errors.into_iter().map(|e| anyhow!(e)));
903        }
904
905        // ensure we can make this check
906        if let Some(rc_config) = self.config.relaychain.as_ref() {
907            // check we have num_validators >= num_requested_cores
908            let mut num_validators = rc_config.nodes().iter().fold(0u32, |mut acc, node| {
909                if node.is_validator {
910                    acc += 1;
911                }
912
913                acc
914            });
915
916            let node_groups = rc_config.group_node_configs();
917            for ng in &node_groups {
918                if ng.base_config.is_validator {
919                    num_validators += ng.count as u32;
920                }
921            }
922
923            if num_validators < num_of_requested_cores {
924                errs.push(anyhow!("Number of assigned cores at genesis {num_of_requested_cores} is greater than validators ({num_validators})"));
925            }
926        }
927
928        if !self.errors.is_empty() || !errs.is_empty() {
929            let mut ret_errs = self.errors;
930            ret_errs.append(&mut errs);
931            return Err(ret_errs);
932        }
933
934        Ok(self.config)
935    }
936}
937
938#[cfg(test)]
939mod tests {
940    use std::path::PathBuf;
941
942    use super::*;
943    use crate::{
944        parachain::RegistrationStrategy, types::JamNodeMode, DependencyCondition, ProcessEnvVar,
945    };
946
947    #[test]
948    fn network_config_builder_should_succeeds_and_returns_a_network_config() {
949        let network_config = NetworkConfigBuilder::new()
950            .with_relaychain(|relaychain| {
951                relaychain
952                    .with_chain("polkadot")
953                    .with_random_nominators_count(10)
954                    .with_validator(|node| node.with_name("node").with_command("command"))
955                    .with_validator(|node| node.with_name("node-1").with_command("command"))
956            })
957            .with_parachain(|parachain| {
958                parachain
959                    .with_id(1)
960                    .with_chain("myparachain1")
961                    .with_initial_balance(100_000)
962                    .with_collator(|collator| {
963                        collator
964                            .with_name("collator1")
965                            .with_command("command1")
966                            .validator(true)
967                    })
968            })
969            .with_parachain(|parachain| {
970                parachain
971                    .with_id(2)
972                    .with_chain("myparachain2")
973                    .with_initial_balance(0)
974                    .with_collator(|collator| {
975                        collator
976                            .with_name("collator2")
977                            .with_command("command2")
978                            .validator(true)
979                    })
980            })
981            .with_hrmp_channel(|hrmp_channel1| {
982                hrmp_channel1
983                    .with_sender(1)
984                    .with_recipient(2)
985                    .with_max_capacity(200)
986                    .with_max_message_size(500)
987            })
988            .with_hrmp_channel(|hrmp_channel2| {
989                hrmp_channel2
990                    .with_sender(2)
991                    .with_recipient(1)
992                    .with_max_capacity(100)
993                    .with_max_message_size(250)
994            })
995            .with_global_settings(|global_settings| {
996                global_settings
997                    .with_network_spawn_timeout(1200)
998                    .with_node_spawn_timeout(240)
999            })
1000            .build()
1001            .unwrap();
1002
1003        // relaychain
1004        assert_eq!(network_config.relaychain().chain().as_str(), "polkadot");
1005        assert_eq!(network_config.relaychain().nodes().len(), 2);
1006        let &node = network_config.relaychain().nodes().first().unwrap();
1007        assert_eq!(node.name(), "node");
1008        assert_eq!(node.command().unwrap().as_str(), "command");
1009        assert!(node.is_validator());
1010        assert_eq!(
1011            network_config
1012                .relaychain()
1013                .random_nominators_count()
1014                .unwrap(),
1015            10
1016        );
1017
1018        // parachains
1019        assert_eq!(network_config.parachains().len(), 2);
1020
1021        // parachain1
1022        let &parachain1 = network_config.parachains().first().unwrap();
1023        assert_eq!(parachain1.id(), 1);
1024        assert_eq!(parachain1.collators().len(), 1);
1025        let &collator = parachain1.collators().first().unwrap();
1026        assert_eq!(collator.name(), "collator1");
1027        assert_eq!(collator.command().unwrap().as_str(), "command1");
1028        assert!(collator.is_validator());
1029        assert_eq!(parachain1.initial_balance(), 100_000);
1030        assert_eq!(parachain1.unique_id(), "1");
1031
1032        // parachain2
1033        let &parachain2 = network_config.parachains().last().unwrap();
1034        assert_eq!(parachain2.id(), 2);
1035        assert_eq!(parachain2.collators().len(), 1);
1036        let &collator = parachain2.collators().first().unwrap();
1037        assert_eq!(collator.name(), "collator2");
1038        assert_eq!(collator.command().unwrap().as_str(), "command2");
1039        assert!(collator.is_validator());
1040        assert_eq!(parachain2.initial_balance(), 0);
1041
1042        // hrmp_channels
1043        assert_eq!(network_config.hrmp_channels().len(), 2);
1044
1045        // hrmp_channel1
1046        let &hrmp_channel1 = network_config.hrmp_channels().first().unwrap();
1047        assert_eq!(hrmp_channel1.sender(), 1);
1048        assert_eq!(hrmp_channel1.recipient(), 2);
1049        assert_eq!(hrmp_channel1.max_capacity(), 200);
1050        assert_eq!(hrmp_channel1.max_message_size(), 500);
1051
1052        // hrmp_channel2
1053        let &hrmp_channel2 = network_config.hrmp_channels().last().unwrap();
1054        assert_eq!(hrmp_channel2.sender(), 2);
1055        assert_eq!(hrmp_channel2.recipient(), 1);
1056        assert_eq!(hrmp_channel2.max_capacity(), 100);
1057        assert_eq!(hrmp_channel2.max_message_size(), 250);
1058
1059        // global settings
1060        assert_eq!(
1061            network_config.global_settings().network_spawn_timeout(),
1062            1200
1063        );
1064        assert_eq!(network_config.global_settings().node_spawn_timeout(), 240);
1065        assert!(network_config.global_settings().tear_down_on_failure());
1066    }
1067
1068    #[test]
1069    fn network_config_builder_should_fails_and_returns_multiple_errors_if_relaychain_is_invalid() {
1070        let errors = NetworkConfigBuilder::new()
1071            .with_relaychain(|relaychain| {
1072                relaychain
1073                    .with_chain("polkadot")
1074                    .with_random_nominators_count(10)
1075                    .with_default_image("invalid.image")
1076                    .with_validator(|node| node.with_name("node").with_command("invalid command"))
1077            })
1078            .with_parachain(|parachain| {
1079                parachain
1080                    .with_id(1)
1081                    .with_chain("myparachain")
1082                    .with_initial_balance(100_000)
1083                    .with_collator(|collator| {
1084                        collator
1085                            .with_name("collator1")
1086                            .with_command("command1")
1087                            .validator(true)
1088                    })
1089            })
1090            .build()
1091            .unwrap_err();
1092
1093        assert_eq!(errors.len(), 2);
1094        assert_eq!(
1095            errors.first().unwrap().to_string(),
1096            "relaychain.default_image: 'invalid.image' doesn't match regex '^([ip]|[hostname]/)?[tag_name]:[tag_version]?$'"
1097        );
1098        assert_eq!(
1099            errors.get(1).unwrap().to_string(),
1100            "relaychain.nodes['node'].command: 'invalid command' shouldn't contains whitespace"
1101        );
1102    }
1103
1104    #[test]
1105    fn network_config_builder_should_fails_and_returns_multiple_errors_if_parachain_is_invalid() {
1106        let errors = NetworkConfigBuilder::new()
1107            .with_relaychain(|relaychain| {
1108                relaychain
1109                    .with_chain("polkadot")
1110                    .with_random_nominators_count(10)
1111                    .with_validator(|node| node.with_name("node").with_command("command"))
1112            })
1113            .with_parachain(|parachain| {
1114                parachain
1115                    .with_id(1000)
1116                    .with_chain("myparachain")
1117                    .with_initial_balance(100_000)
1118                    .with_collator(|collator| {
1119                        collator
1120                            .with_name("collator1")
1121                            .with_command("invalid command")
1122                            .with_image("invalid.image")
1123                            .validator(true)
1124                    })
1125            })
1126            .build()
1127            .unwrap_err();
1128
1129        assert_eq!(errors.len(), 2);
1130        assert_eq!(
1131            errors.first().unwrap().to_string(),
1132            "parachain[1000].collators['collator1'].command: 'invalid command' shouldn't contains whitespace"
1133        );
1134        assert_eq!(
1135            errors.get(1).unwrap().to_string(),
1136            "parachain[1000].collators['collator1'].image: 'invalid.image' doesn't match regex '^([ip]|[hostname]/)?[tag_name]:[tag_version]?$'"
1137        );
1138    }
1139
1140    #[test]
1141    fn network_config_builder_should_fails_and_returns_multiple_errors_if_multiple_parachains_are_invalid(
1142    ) {
1143        let errors = NetworkConfigBuilder::new()
1144            .with_relaychain(|relaychain| {
1145                relaychain
1146                    .with_chain("polkadot")
1147                    .with_random_nominators_count(10)
1148                    .with_validator(|node| node.with_name("node").with_command("command"))
1149            })
1150            .with_parachain(|parachain| {
1151                parachain
1152                    .with_id(1000)
1153                    .with_chain("myparachain1")
1154                    .with_initial_balance(100_000)
1155                    .with_collator(|collator| {
1156                        collator
1157                            .with_name("collator1")
1158                            .with_command("invalid command")
1159                    })
1160            })
1161            .with_parachain(|parachain| {
1162                parachain
1163                    .with_id(2000)
1164                    .with_chain("myparachain2")
1165                    .with_initial_balance(100_000)
1166                    .with_collator(|collator| {
1167                        collator
1168                            .with_name("collator2")
1169                            .validator(true)
1170                            .with_resources(|resources| {
1171                                resources
1172                                    .with_limit_cpu("1000m")
1173                                    .with_request_memory("1Gi")
1174                                    .with_request_cpu("invalid")
1175                            })
1176                    })
1177            })
1178            .build()
1179            .unwrap_err();
1180
1181        assert_eq!(errors.len(), 2);
1182        assert_eq!(
1183            errors.first().unwrap().to_string(),
1184            "parachain[1000].collators['collator1'].command: 'invalid command' shouldn't contains whitespace"
1185        );
1186        assert_eq!(
1187            errors.get(1).unwrap().to_string(),
1188            "parachain[2000].collators['collator2'].resources.request_cpu: 'invalid' doesn't match regex '^\\d+(.\\d+)?(m|K|M|G|T|P|E|Ki|Mi|Gi|Ti|Pi|Ei)?$'"
1189        );
1190    }
1191
1192    #[test]
1193    fn network_config_builder_should_fails_and_returns_multiple_errors_if_global_settings_is_invalid(
1194    ) {
1195        let errors = NetworkConfigBuilder::new()
1196            .with_relaychain(|relaychain| {
1197                relaychain
1198                    .with_chain("polkadot")
1199                    .with_random_nominators_count(10)
1200                    .with_validator(|node| node.with_name("node").with_command("command"))
1201            })
1202            .with_parachain(|parachain| {
1203                parachain
1204                    .with_id(1000)
1205                    .with_chain("myparachain")
1206                    .with_initial_balance(100_000)
1207                    .with_collator(|collator| {
1208                        collator
1209                            .with_name("collator")
1210                            .with_command("command")
1211                            .validator(true)
1212                    })
1213            })
1214            .with_global_settings(|global_settings| {
1215                global_settings
1216                    .with_local_ip("127.0.0000.1")
1217                    .with_raw_bootnodes_addresses(vec!["/ip4//tcp/45421"])
1218            })
1219            .build()
1220            .unwrap_err();
1221
1222        assert_eq!(errors.len(), 2);
1223        assert_eq!(
1224            errors.first().unwrap().to_string(),
1225            "global_settings.local_ip: invalid IP address syntax"
1226        );
1227        assert_eq!(
1228            errors.get(1).unwrap().to_string(),
1229            "global_settings.bootnodes_addresses[0]: '/ip4//tcp/45421' failed to parse: invalid IPv4 address syntax"
1230        );
1231    }
1232
1233    #[test]
1234    fn network_config_builder_should_fails_and_returns_multiple_errors_if_multiple_fields_are_invalid(
1235    ) {
1236        let errors = NetworkConfigBuilder::new()
1237            .with_relaychain(|relaychain| {
1238                relaychain
1239                    .with_chain("polkadot")
1240                    .with_random_nominators_count(10)
1241                    .with_validator(|node| node.with_name("node").with_command("invalid command"))
1242            })
1243            .with_parachain(|parachain| {
1244                parachain
1245                    .with_id(1000)
1246                    .with_chain("myparachain")
1247                    .with_initial_balance(100_000)
1248                    .with_collator(|collator| {
1249                        collator
1250                            .with_name("collator")
1251                            .with_command("command")
1252                            .with_image("invalid.image")
1253                    })
1254            })
1255            .with_global_settings(|global_settings| global_settings.with_local_ip("127.0.0000.1"))
1256            .build()
1257            .unwrap_err();
1258
1259        assert_eq!(errors.len(), 3);
1260        assert_eq!(
1261            errors.first().unwrap().to_string(),
1262            "relaychain.nodes['node'].command: 'invalid command' shouldn't contains whitespace"
1263        );
1264        assert_eq!(
1265            errors.get(1).unwrap().to_string(),
1266            "parachain[1000].collators['collator'].image: 'invalid.image' doesn't match regex '^([ip]|[hostname]/)?[tag_name]:[tag_version]?$'"
1267        );
1268        assert_eq!(
1269            errors.get(2).unwrap().to_string(),
1270            "global_settings.local_ip: invalid IP address syntax"
1271        );
1272    }
1273
1274    #[test]
1275    fn network_config_should_be_dumpable_to_a_toml_config_for_a_small_network() {
1276        let network_config = NetworkConfigBuilder::new()
1277            .with_relaychain(|relaychain| {
1278                relaychain
1279                    .with_chain("rococo-local")
1280                    .with_default_command("polkadot")
1281                    .with_default_image("docker.io/parity/polkadot:latest")
1282                    .with_default_args(vec![("-lparachain", "debug").into()])
1283                    .with_validator(|node| node.with_name("alice"))
1284                    .with_validator(|node| {
1285                        node.with_name("bob")
1286                            .invulnerable(false)
1287                            .bootnode(true)
1288                            .with_args(vec![("--database", "paritydb-experimental").into()])
1289                    })
1290            })
1291            .build()
1292            .unwrap();
1293
1294        let got = network_config.dump_to_toml().unwrap();
1295        let expected = fs::read_to_string("./testing/snapshots/0000-small-network.toml").unwrap();
1296        assert_eq!(got, expected);
1297    }
1298
1299    #[test]
1300    fn network_config_should_be_dumpable_to_a_toml_config_for_a_big_network() {
1301        let network_config = NetworkConfigBuilder::new()
1302            .with_relaychain(|relaychain| {
1303                relaychain
1304                    .with_chain("polkadot")
1305                    .with_default_command("polkadot")
1306                    .with_default_image("docker.io/parity/polkadot:latest")
1307                    .with_default_resources(|resources| {
1308                        resources
1309                            .with_request_cpu(100000)
1310                            .with_request_memory("500M")
1311                            .with_limit_cpu("10Gi")
1312                            .with_limit_memory("4000M")
1313                    })
1314                    .with_validator(|node| {
1315                        node.with_name("alice")
1316                            .with_initial_balance(1_000_000_000)
1317                            .bootnode(true)
1318                            .invulnerable(true)
1319                    })
1320                    .with_validator(|node| node.with_name("bob").invulnerable(true).bootnode(true))
1321            })
1322            .with_parachain(|parachain| {
1323                parachain
1324                    .with_id(1000)
1325                    .with_chain("myparachain")
1326                    .with_chain_spec_path("/path/to/my/chain/spec.json")
1327                    .with_registration_strategy(RegistrationStrategy::UsingExtrinsic)
1328                    .onboard_as_parachain(false)
1329                    .with_default_db_snapshot("https://storage.com/path/to/db_snapshot.tgz")
1330                    .with_collator(|collator| {
1331                        collator
1332                            .with_name("john")
1333                            .bootnode(true)
1334                            .invulnerable(true)
1335                            .with_initial_balance(5_000_000_000)
1336                    })
1337                    .with_fullnode(|collator| {
1338                        collator
1339                            .with_name("charles")
1340                            .bootnode(true)
1341                            .invulnerable(true)
1342                            .with_initial_balance(0)
1343                    })
1344                    .with_collator(|collator| {
1345                        collator
1346                            .with_name("frank")
1347                            .invulnerable(false)
1348                            .bootnode(true)
1349                            .with_initial_balance(1_000_000_000)
1350                    })
1351            })
1352            .with_parachain(|parachain| {
1353                parachain
1354                    .with_id(2000)
1355                    .with_chain("myotherparachain")
1356                    .with_chain_spec_path("/path/to/my/other/chain/spec.json")
1357                    .with_collator(|collator| {
1358                        collator
1359                            .with_name("mike")
1360                            .bootnode(true)
1361                            .invulnerable(true)
1362                            .with_initial_balance(5_000_000_000)
1363                    })
1364                    .with_fullnode(|collator| {
1365                        collator
1366                            .with_name("georges")
1367                            .bootnode(true)
1368                            .invulnerable(true)
1369                            .with_initial_balance(0)
1370                    })
1371                    .with_collator(|collator| {
1372                        collator
1373                            .with_name("victor")
1374                            .invulnerable(false)
1375                            .bootnode(true)
1376                            .with_initial_balance(1_000_000_000)
1377                    })
1378            })
1379            .with_hrmp_channel(|hrmp_channel| {
1380                hrmp_channel
1381                    .with_sender(1000)
1382                    .with_recipient(2000)
1383                    .with_max_capacity(150)
1384                    .with_max_message_size(5000)
1385            })
1386            .with_hrmp_channel(|hrmp_channel| {
1387                hrmp_channel
1388                    .with_sender(2000)
1389                    .with_recipient(1000)
1390                    .with_max_capacity(200)
1391                    .with_max_message_size(8000)
1392            })
1393            .with_custom_process(|c| c.with_name("eth-rpc").with_command("eth-rpc"))
1394            .build()
1395            .unwrap();
1396
1397        let got = network_config.dump_to_toml().unwrap();
1398        let expected = fs::read_to_string("./testing/snapshots/0001-big-network.toml").unwrap();
1399        assert_eq!(got, expected);
1400    }
1401
1402    #[test]
1403    fn network_config_builder_should_be_dumplable_to_a_toml_config_a_overrides_default_correctly() {
1404        let network_config = NetworkConfigBuilder::new()
1405            .with_relaychain(|relaychain| {
1406                relaychain
1407                    .with_chain("polkadot")
1408                    .with_default_command("polkadot")
1409                    .with_default_image("docker.io/parity/polkadot:latest")
1410                    .with_default_args(vec![("-name", "value").into(), "--flag".into()])
1411                    .with_default_db_snapshot("https://storage.com/path/to/db_snapshot.tgz")
1412                    .with_default_resources(|resources| {
1413                        resources
1414                            .with_request_cpu(100000)
1415                            .with_request_memory("500M")
1416                            .with_limit_cpu("10Gi")
1417                            .with_limit_memory("4000M")
1418                    })
1419                    .with_validator(|node| {
1420                        node.with_name("alice")
1421                            .with_initial_balance(1_000_000_000)
1422                            .bootnode(true)
1423                            .invulnerable(true)
1424                    })
1425                    .with_validator(|node| {
1426                        node.with_name("bob")
1427                            .invulnerable(true)
1428                            .bootnode(true)
1429                            .with_image("mycustomimage:latest")
1430                            .with_command("my-custom-command")
1431                            .with_db_snapshot("https://storage.com/path/to/other/db_snapshot.tgz")
1432                            .with_resources(|resources| {
1433                                resources
1434                                    .with_request_cpu(1000)
1435                                    .with_request_memory("250Mi")
1436                                    .with_limit_cpu("5Gi")
1437                                    .with_limit_memory("2Gi")
1438                            })
1439                            .with_args(vec![("-myothername", "value").into()])
1440                    })
1441            })
1442            .with_parachain(|parachain| {
1443                parachain
1444                    .with_id(1000)
1445                    .with_chain("myparachain")
1446                    .with_chain_spec_path("/path/to/my/chain/spec.json")
1447                    .with_default_db_snapshot("https://storage.com/path/to/other_snapshot.tgz")
1448                    .with_default_command("my-default-command")
1449                    .with_default_image("mydefaultimage:latest")
1450                    .with_collator(|collator| {
1451                        collator
1452                            .with_name("john")
1453                            .bootnode(true)
1454                            .invulnerable(true)
1455                            .with_initial_balance(5_000_000_000)
1456                            .with_command("my-non-default-command")
1457                            .with_image("anotherimage:latest")
1458                    })
1459                    .with_fullnode(|collator| {
1460                        collator
1461                            .with_name("charles")
1462                            .bootnode(true)
1463                            .invulnerable(true)
1464                            .with_initial_balance(0)
1465                    })
1466            })
1467            .build()
1468            .unwrap();
1469
1470        let got = network_config.dump_to_toml().unwrap();
1471        let expected =
1472            fs::read_to_string("./testing/snapshots/0002-overridden-defaults.toml").unwrap();
1473        assert_eq!(got, expected);
1474    }
1475
1476    #[test]
1477    fn the_toml_config_with_custom_settings() {
1478        let settings = GlobalSettingsBuilder::new()
1479            .with_base_dir("/tmp/test-demo")
1480            .build()
1481            .unwrap();
1482
1483        let load_from_toml = NetworkConfig::load_from_toml_with_settings(
1484            "./testing/snapshots/0000-small-network.toml",
1485            &settings,
1486        )
1487        .unwrap();
1488
1489        assert_eq!(
1490            Some(PathBuf::from("/tmp/test-demo").as_path()),
1491            load_from_toml.global_settings.base_dir()
1492        );
1493    }
1494
1495    #[test]
1496    fn the_toml_config_should_be_imported_and_match_a_network() {
1497        let load_from_toml =
1498            NetworkConfig::load_from_toml("./testing/snapshots/0000-small-network.toml").unwrap();
1499
1500        let expected = NetworkConfigBuilder::new()
1501            .with_relaychain(|relaychain| {
1502                relaychain
1503                    .with_chain("rococo-local")
1504                    .with_default_command("polkadot")
1505                    .with_default_image("docker.io/parity/polkadot:latest")
1506                    .with_default_args(vec![("-lparachain=debug").into()])
1507                    .with_validator(|node| {
1508                        node.with_name("alice")
1509                            .validator(true)
1510                            .invulnerable(true)
1511                            .bootnode(false)
1512                            .with_initial_balance(2000000000000)
1513                    })
1514                    .with_validator(|node| {
1515                        node.with_name("bob")
1516                            .with_args(vec![("--database", "paritydb-experimental").into()])
1517                            .invulnerable(false)
1518                            .bootnode(true)
1519                            .with_initial_balance(2000000000000)
1520                    })
1521            })
1522            .build()
1523            .unwrap();
1524
1525        // We need to assert parts of the network config separately because the expected one contains the chain default context which
1526        // is used for dumbing to tomp while the
1527        // while loaded
1528        assert_eq!(
1529            expected.relaychain().chain(),
1530            load_from_toml.relaychain().chain()
1531        );
1532        assert_eq!(
1533            expected.relaychain().default_args(),
1534            load_from_toml.relaychain().default_args()
1535        );
1536        assert_eq!(
1537            expected.relaychain().default_command(),
1538            load_from_toml.relaychain().default_command()
1539        );
1540        assert_eq!(
1541            expected.relaychain().default_image(),
1542            load_from_toml.relaychain().default_image()
1543        );
1544
1545        // Check the nodes without the Chain Default Context
1546        expected
1547            .relaychain()
1548            .nodes()
1549            .iter()
1550            .zip(load_from_toml.relaychain().nodes().iter())
1551            .for_each(|(expected_node, loaded_node)| {
1552                assert_eq!(expected_node.name(), loaded_node.name());
1553                assert_eq!(expected_node.command(), loaded_node.command());
1554                assert_eq!(expected_node.args(), loaded_node.args());
1555                assert_eq!(
1556                    expected_node.is_invulnerable(),
1557                    loaded_node.is_invulnerable()
1558                );
1559                assert_eq!(expected_node.is_validator(), loaded_node.is_validator());
1560                assert_eq!(expected_node.is_bootnode(), loaded_node.is_bootnode());
1561                assert_eq!(
1562                    expected_node.initial_balance(),
1563                    loaded_node.initial_balance()
1564                );
1565            });
1566    }
1567
1568    #[test]
1569    fn the_toml_config_without_settings_should_be_imported_and_match_a_network() {
1570        let load_from_toml = NetworkConfig::load_from_toml(
1571            "./testing/snapshots/0004-small-network-without-settings.toml",
1572        )
1573        .unwrap();
1574
1575        let expected = NetworkConfigBuilder::new()
1576            .with_relaychain(|relaychain| {
1577                relaychain
1578                    .with_chain("rococo-local")
1579                    .with_default_command("polkadot")
1580                    .with_validator(|node| node.with_name("alice"))
1581                    .with_validator(|node| node.with_name("bob"))
1582            })
1583            .build()
1584            .unwrap();
1585
1586        assert_eq!(
1587            load_from_toml.global_settings().network_spawn_timeout(),
1588            expected.global_settings().network_spawn_timeout()
1589        )
1590    }
1591
1592    #[test]
1593    fn the_toml_config_should_be_imported_and_match_a_network_with_parachains() {
1594        let load_from_toml =
1595            NetworkConfig::load_from_toml("./testing/snapshots/0001-big-network.toml").unwrap();
1596
1597        let expected = NetworkConfigBuilder::new()
1598            .with_relaychain(|relaychain| {
1599                relaychain
1600                    .with_chain("polkadot")
1601                    .with_default_command("polkadot")
1602                    .with_default_image("docker.io/parity/polkadot:latest")
1603                    .with_default_resources(|resources| {
1604                        resources
1605                            .with_request_cpu(100000)
1606                            .with_request_memory("500M")
1607                            .with_limit_cpu("10Gi")
1608                            .with_limit_memory("4000M")
1609                    })
1610                    .with_validator(|node| {
1611                        node.with_name("alice")
1612                            .with_initial_balance(1_000_000_000)
1613                            .bootnode(true)
1614                            .invulnerable(true)
1615                    })
1616                    .with_validator(|node| node.with_name("bob").invulnerable(true).bootnode(true))
1617            })
1618            .with_parachain(|parachain| {
1619                parachain
1620                    .with_id(1000)
1621                    .with_chain("myparachain")
1622                    .with_chain_spec_path("/path/to/my/chain/spec.json")
1623                    .with_registration_strategy(RegistrationStrategy::UsingExtrinsic)
1624                    .onboard_as_parachain(false)
1625                    .with_default_db_snapshot("https://storage.com/path/to/db_snapshot.tgz")
1626                    .with_collator(|collator| {
1627                        collator
1628                            .with_name("john")
1629                            .bootnode(true)
1630                            .invulnerable(true)
1631                            .with_initial_balance(5_000_000_000)
1632                    })
1633                    .with_fullnode(|collator| {
1634                        collator
1635                            .with_name("charles")
1636                            .bootnode(true)
1637                            .invulnerable(true)
1638                            .with_initial_balance(0)
1639                    })
1640                    .with_collator(|collator| {
1641                        collator
1642                            .with_name("frank")
1643                            .invulnerable(false)
1644                            .bootnode(true)
1645                            .with_initial_balance(1_000_000_000)
1646                    })
1647            })
1648            .with_parachain(|parachain| {
1649                parachain
1650                    .with_id(2000)
1651                    .with_chain("myotherparachain")
1652                    .with_chain_spec_path("/path/to/my/other/chain/spec.json")
1653                    .with_collator(|collator| {
1654                        collator
1655                            .with_name("mike")
1656                            .bootnode(true)
1657                            .invulnerable(true)
1658                            .with_initial_balance(5_000_000_000)
1659                    })
1660                    .with_fullnode(|collator| {
1661                        collator
1662                            .with_name("georges")
1663                            .bootnode(true)
1664                            .invulnerable(true)
1665                            .with_initial_balance(0)
1666                    })
1667                    .with_collator(|collator| {
1668                        collator
1669                            .with_name("victor")
1670                            .invulnerable(false)
1671                            .bootnode(true)
1672                            .with_initial_balance(1_000_000_000)
1673                    })
1674            })
1675            .with_hrmp_channel(|hrmp_channel| {
1676                hrmp_channel
1677                    .with_sender(1000)
1678                    .with_recipient(2000)
1679                    .with_max_capacity(150)
1680                    .with_max_message_size(5000)
1681            })
1682            .with_hrmp_channel(|hrmp_channel| {
1683                hrmp_channel
1684                    .with_sender(2000)
1685                    .with_recipient(1000)
1686                    .with_max_capacity(200)
1687                    .with_max_message_size(8000)
1688            })
1689            .build()
1690            .unwrap();
1691
1692        // Check the relay chain
1693        assert_eq!(
1694            expected.relaychain().default_resources(),
1695            load_from_toml.relaychain().default_resources()
1696        );
1697
1698        // Check the nodes without the Chain Default Context
1699        expected
1700            .relaychain()
1701            .nodes()
1702            .iter()
1703            .zip(load_from_toml.relaychain().nodes().iter())
1704            .for_each(|(expected_node, loaded_node)| {
1705                assert_eq!(expected_node.name(), loaded_node.name());
1706                assert_eq!(expected_node.command(), loaded_node.command());
1707                assert_eq!(expected_node.args(), loaded_node.args());
1708                assert_eq!(expected_node.is_validator(), loaded_node.is_validator());
1709                assert_eq!(expected_node.is_bootnode(), loaded_node.is_bootnode());
1710                assert_eq!(
1711                    expected_node.initial_balance(),
1712                    loaded_node.initial_balance()
1713                );
1714                assert_eq!(
1715                    expected_node.is_invulnerable(),
1716                    loaded_node.is_invulnerable()
1717                );
1718            });
1719
1720        expected
1721            .parachains()
1722            .iter()
1723            .zip(load_from_toml.parachains().iter())
1724            .for_each(|(expected_parachain, loaded_parachain)| {
1725                assert_eq!(expected_parachain.id(), loaded_parachain.id());
1726                assert_eq!(expected_parachain.chain(), loaded_parachain.chain());
1727                assert_eq!(
1728                    expected_parachain.chain_spec_path(),
1729                    loaded_parachain.chain_spec_path()
1730                );
1731                assert_eq!(
1732                    expected_parachain.registration_strategy(),
1733                    loaded_parachain.registration_strategy()
1734                );
1735                assert_eq!(
1736                    expected_parachain.onboard_as_parachain(),
1737                    loaded_parachain.onboard_as_parachain()
1738                );
1739                assert_eq!(
1740                    expected_parachain.default_db_snapshot(),
1741                    loaded_parachain.default_db_snapshot()
1742                );
1743                assert_eq!(
1744                    expected_parachain.default_command(),
1745                    loaded_parachain.default_command()
1746                );
1747                assert_eq!(
1748                    expected_parachain.default_image(),
1749                    loaded_parachain.default_image()
1750                );
1751                assert_eq!(
1752                    expected_parachain.collators().len(),
1753                    loaded_parachain.collators().len()
1754                );
1755                expected_parachain
1756                    .collators()
1757                    .iter()
1758                    .zip(loaded_parachain.collators().iter())
1759                    .for_each(|(expected_collator, loaded_collator)| {
1760                        assert_eq!(expected_collator.name(), loaded_collator.name());
1761                        assert_eq!(expected_collator.command(), loaded_collator.command());
1762                        assert_eq!(expected_collator.image(), loaded_collator.image());
1763                        assert_eq!(
1764                            expected_collator.is_validator(),
1765                            loaded_collator.is_validator()
1766                        );
1767                        assert_eq!(
1768                            expected_collator.is_bootnode(),
1769                            loaded_collator.is_bootnode()
1770                        );
1771                        assert_eq!(
1772                            expected_collator.is_invulnerable(),
1773                            loaded_collator.is_invulnerable()
1774                        );
1775                        assert_eq!(
1776                            expected_collator.initial_balance(),
1777                            loaded_collator.initial_balance()
1778                        );
1779                    });
1780            });
1781
1782        expected
1783            .hrmp_channels()
1784            .iter()
1785            .zip(load_from_toml.hrmp_channels().iter())
1786            .for_each(|(expected_hrmp_channel, loaded_hrmp_channel)| {
1787                assert_eq!(expected_hrmp_channel.sender(), loaded_hrmp_channel.sender());
1788                assert_eq!(
1789                    expected_hrmp_channel.recipient(),
1790                    loaded_hrmp_channel.recipient()
1791                );
1792                assert_eq!(
1793                    expected_hrmp_channel.max_capacity(),
1794                    loaded_hrmp_channel.max_capacity()
1795                );
1796                assert_eq!(
1797                    expected_hrmp_channel.max_message_size(),
1798                    loaded_hrmp_channel.max_message_size()
1799                );
1800            });
1801    }
1802
1803    #[test]
1804    fn the_toml_config_should_be_imported_and_match_a_network_with_overriden_defaults() {
1805        let load_from_toml =
1806            NetworkConfig::load_from_toml("./testing/snapshots/0002-overridden-defaults.toml")
1807                .unwrap();
1808
1809        let expected = NetworkConfigBuilder::new()
1810            .with_relaychain(|relaychain| {
1811                relaychain
1812                    .with_chain("polkadot")
1813                    .with_default_command("polkadot")
1814                    .with_default_image("docker.io/parity/polkadot:latest")
1815                    .with_default_args(vec![("-name", "value").into(), "--flag".into()])
1816                    .with_default_db_snapshot("https://storage.com/path/to/db_snapshot.tgz")
1817                    .with_default_resources(|resources| {
1818                        resources
1819                            .with_request_cpu(100000)
1820                            .with_request_memory("500M")
1821                            .with_limit_cpu("10Gi")
1822                            .with_limit_memory("4000M")
1823                    })
1824                    .with_validator(|node| {
1825                        node.with_name("alice")
1826                            .with_initial_balance(1_000_000_000)
1827                            .bootnode(true)
1828                            .invulnerable(true)
1829                    })
1830                    .with_validator(|node| {
1831                        node.with_name("bob")
1832                            .invulnerable(true)
1833                            .bootnode(true)
1834                            .with_image("mycustomimage:latest")
1835                            .with_command("my-custom-command")
1836                            .with_db_snapshot("https://storage.com/path/to/other/db_snapshot.tgz")
1837                            .with_resources(|resources| {
1838                                resources
1839                                    .with_request_cpu(1000)
1840                                    .with_request_memory("250Mi")
1841                                    .with_limit_cpu("5Gi")
1842                                    .with_limit_memory("2Gi")
1843                            })
1844                            .with_args(vec![("-myothername", "value").into()])
1845                    })
1846            })
1847            .with_parachain(|parachain| {
1848                parachain
1849                    .with_id(1000)
1850                    .with_chain("myparachain")
1851                    .with_chain_spec_path("/path/to/my/chain/spec.json")
1852                    .with_default_db_snapshot("https://storage.com/path/to/other_snapshot.tgz")
1853                    .with_default_command("my-default-command")
1854                    .with_default_image("mydefaultimage:latest")
1855                    .with_collator(|collator| {
1856                        collator
1857                            .with_name("john")
1858                            .bootnode(true)
1859                            .validator(true)
1860                            .invulnerable(true)
1861                            .with_initial_balance(5_000_000_000)
1862                            .with_command("my-non-default-command")
1863                            .with_image("anotherimage:latest")
1864                    })
1865                    .with_fullnode(|collator| {
1866                        collator
1867                            .with_name("charles")
1868                            .bootnode(true)
1869                            .invulnerable(true)
1870                            .with_initial_balance(0)
1871                    })
1872            })
1873            .build()
1874            .unwrap();
1875
1876        expected
1877            .parachains()
1878            .iter()
1879            .zip(load_from_toml.parachains().iter())
1880            .for_each(|(expected_parachain, loaded_parachain)| {
1881                assert_eq!(expected_parachain.id(), loaded_parachain.id());
1882                assert_eq!(expected_parachain.chain(), loaded_parachain.chain());
1883                assert_eq!(
1884                    expected_parachain.chain_spec_path(),
1885                    loaded_parachain.chain_spec_path()
1886                );
1887                assert_eq!(
1888                    expected_parachain.registration_strategy(),
1889                    loaded_parachain.registration_strategy()
1890                );
1891                assert_eq!(
1892                    expected_parachain.onboard_as_parachain(),
1893                    loaded_parachain.onboard_as_parachain()
1894                );
1895                assert_eq!(
1896                    expected_parachain.default_db_snapshot(),
1897                    loaded_parachain.default_db_snapshot()
1898                );
1899                assert_eq!(
1900                    expected_parachain.default_command(),
1901                    loaded_parachain.default_command()
1902                );
1903                assert_eq!(
1904                    expected_parachain.default_image(),
1905                    loaded_parachain.default_image()
1906                );
1907                assert_eq!(
1908                    expected_parachain.collators().len(),
1909                    loaded_parachain.collators().len()
1910                );
1911                expected_parachain
1912                    .collators()
1913                    .iter()
1914                    .zip(loaded_parachain.collators().iter())
1915                    .for_each(|(expected_collator, loaded_collator)| {
1916                        assert_eq!(expected_collator.name(), loaded_collator.name());
1917                        assert_eq!(expected_collator.command(), loaded_collator.command());
1918                        assert_eq!(expected_collator.image(), loaded_collator.image());
1919                        assert_eq!(
1920                            expected_collator.is_validator(),
1921                            loaded_collator.is_validator()
1922                        );
1923                        assert_eq!(
1924                            expected_collator.is_bootnode(),
1925                            loaded_collator.is_bootnode()
1926                        );
1927                        assert_eq!(
1928                            expected_collator.is_invulnerable(),
1929                            loaded_collator.is_invulnerable()
1930                        );
1931                        assert_eq!(
1932                            expected_collator.initial_balance(),
1933                            loaded_collator.initial_balance()
1934                        );
1935                    });
1936            });
1937    }
1938
1939    #[test]
1940    fn with_chain_and_nodes_works() {
1941        let network_config = NetworkConfigBuilder::with_chain_and_nodes(
1942            "rococo-local",
1943            vec!["alice".to_string(), "bob".to_string()],
1944        )
1945        .build()
1946        .unwrap();
1947
1948        // relaychain
1949        assert_eq!(network_config.relaychain().chain().as_str(), "rococo-local");
1950        assert_eq!(network_config.relaychain().nodes().len(), 2);
1951        let mut node_names = network_config.relaychain().nodes().into_iter();
1952        let node1 = node_names.next().unwrap().name();
1953        assert_eq!(node1, "alice");
1954        let node2 = node_names.next().unwrap().name();
1955        assert_eq!(node2, "bob");
1956
1957        // parachains
1958        assert_eq!(network_config.parachains().len(), 0);
1959    }
1960
1961    #[test]
1962    fn with_chain_and_nodes_should_fail_with_empty_relay_name() {
1963        let errors = NetworkConfigBuilder::with_chain_and_nodes("", vec!["alice".to_string()])
1964            .build()
1965            .unwrap_err();
1966
1967        assert_eq!(
1968            errors.first().unwrap().to_string(),
1969            "relaychain.chain: can't be empty"
1970        );
1971    }
1972
1973    #[test]
1974    fn with_chain_and_nodes_should_fail_with_empty_node_list() {
1975        let errors = NetworkConfigBuilder::with_chain_and_nodes("rococo-local", vec![])
1976            .build()
1977            .unwrap_err();
1978
1979        assert_eq!(
1980            errors.first().unwrap().to_string(),
1981            "relaychain.nodes[''].name: can't be empty"
1982        );
1983    }
1984
1985    #[test]
1986    fn with_chain_and_nodes_should_fail_with_empty_node_name() {
1987        let errors = NetworkConfigBuilder::with_chain_and_nodes(
1988            "rococo-local",
1989            vec!["alice".to_string(), "".to_string()],
1990        )
1991        .build()
1992        .unwrap_err();
1993
1994        assert_eq!(
1995            errors.first().unwrap().to_string(),
1996            "relaychain.nodes[''].name: can't be empty"
1997        );
1998    }
1999
2000    #[test]
2001    fn with_parachain_id_and_collators_works() {
2002        let network_config = NetworkConfigBuilder::with_chain_and_nodes(
2003            "rococo-local",
2004            vec!["alice".to_string(), "bob".to_string()],
2005        )
2006        .with_parachain_id_and_collators(
2007            100,
2008            vec!["collator1".to_string(), "collator2".to_string()],
2009        )
2010        .build()
2011        .unwrap();
2012
2013        // relaychain
2014        assert_eq!(network_config.relaychain().chain().as_str(), "rococo-local");
2015        assert_eq!(network_config.relaychain().nodes().len(), 2);
2016        let mut node_names = network_config.relaychain().nodes().into_iter();
2017        let node1 = node_names.next().unwrap().name();
2018        assert_eq!(node1, "alice");
2019        let node2 = node_names.next().unwrap().name();
2020        assert_eq!(node2, "bob");
2021
2022        // parachains
2023        assert_eq!(network_config.parachains().len(), 1);
2024        let &parachain1 = network_config.parachains().first().unwrap();
2025        assert_eq!(parachain1.id(), 100);
2026        assert_eq!(parachain1.collators().len(), 2);
2027        let mut collator_names = parachain1.collators().into_iter();
2028        let collator1 = collator_names.next().unwrap().name();
2029        assert_eq!(collator1, "collator1");
2030        let collator2 = collator_names.next().unwrap().name();
2031        assert_eq!(collator2, "collator2");
2032
2033        assert_eq!(parachain1.initial_balance(), 2_000_000_000_000);
2034    }
2035
2036    #[test]
2037    fn with_parachain_id_and_collators_should_fail_with_empty_collator_list() {
2038        let errors =
2039            NetworkConfigBuilder::with_chain_and_nodes("polkadot", vec!["alice".to_string()])
2040                .with_parachain_id_and_collators(1, vec![])
2041                .build()
2042                .unwrap_err();
2043
2044        assert_eq!(
2045            errors.first().unwrap().to_string(),
2046            "parachain[1].can't be empty"
2047        );
2048    }
2049
2050    #[test]
2051    fn with_parachain_id_and_collators_should_fail_with_empty_collator_name() {
2052        let errors =
2053            NetworkConfigBuilder::with_chain_and_nodes("polkadot", vec!["alice".to_string()])
2054                .with_parachain_id_and_collators(1, vec!["collator1".to_string(), "".to_string()])
2055                .build()
2056                .unwrap_err();
2057
2058        assert_eq!(
2059            errors.first().unwrap().to_string(),
2060            "parachain[1].collators[''].name: can't be empty"
2061        );
2062    }
2063
2064    #[test]
2065    fn wasm_override_in_toml_should_work() {
2066        let load_from_toml = NetworkConfig::load_from_toml(
2067            "./testing/snapshots/0005-small-networl-with-wasm-override.toml",
2068        )
2069        .unwrap();
2070
2071        let expected = NetworkConfigBuilder::new()
2072            .with_relaychain(|relaychain| {
2073                relaychain
2074                    .with_chain("rococo-local")
2075                    .with_default_command("polkadot")
2076                    .with_wasm_override("/some/path/runtime.wasm")
2077                    .with_validator(|node| node.with_name("alice"))
2078                    .with_validator(|node| node.with_name("bob"))
2079            })
2080            .with_parachain(|p| {
2081                p.with_id(1000)
2082                    .with_wasm_override("https://some.com/runtime.wasm")
2083                    .with_collator(|c| c.with_name("john"))
2084            })
2085            .build()
2086            .unwrap();
2087
2088        assert_eq!(
2089            load_from_toml.relaychain().wasm_override(),
2090            expected.relaychain().wasm_override()
2091        );
2092        assert_eq!(
2093            load_from_toml.parachains()[0].wasm_override(),
2094            expected.parachains()[0].wasm_override()
2095        );
2096    }
2097
2098    #[test]
2099    fn multiple_paras_with_same_id_should_work() {
2100        let network_config = NetworkConfigBuilder::new()
2101            .with_relaychain(|relaychain| {
2102                relaychain
2103                    .with_chain("polkadot")
2104                    .with_fullnode(|node| node.with_name("node").with_command("command"))
2105                    .with_validator(|n| n.with_name("v"))
2106                    .with_validator(|n| n.with_name("v1"))
2107            })
2108            .with_parachain(|parachain| {
2109                parachain
2110                    .with_id(1)
2111                    .with_chain("myparachain1")
2112                    .with_collator(|collator| {
2113                        collator.with_name("collator1").with_command("command1")
2114                    })
2115            })
2116            .with_parachain(|parachain| {
2117                parachain
2118                    .with_id(1)
2119                    .with_chain("myparachain1")
2120                    .with_registration_strategy(RegistrationStrategy::Manual)
2121                    .with_collator(|collator| {
2122                        collator.with_name("collator2").with_command("command1")
2123                    })
2124            })
2125            .build()
2126            .unwrap();
2127
2128        let &parachain2 = network_config.parachains().last().unwrap();
2129        assert_eq!(parachain2.unique_id(), "1-1");
2130    }
2131
2132    #[test]
2133    fn multiple_paras_with_same_id_both_for_register_should_fail() {
2134        let errors = NetworkConfigBuilder::new()
2135            .with_relaychain(|relaychain| {
2136                relaychain
2137                    .with_chain("polkadot")
2138                    .with_fullnode(|node| node.with_name("node").with_command("command"))
2139            })
2140            .with_parachain(|parachain| {
2141                parachain
2142                    .with_id(1)
2143                    .with_chain("myparachain1")
2144                    .with_collator(|collator| {
2145                        collator.with_name("collator1").with_command("command1")
2146                    })
2147            })
2148            .with_parachain(|parachain| {
2149                parachain
2150                    .with_id(1)
2151                    .with_chain("myparachain1")
2152                    // .with_registration_strategy(RegistrationStrategy::UsingExtrinsic)
2153                    .with_collator(|collator| {
2154                        collator.with_name("collator2").with_command("command1")
2155                    })
2156            })
2157            .build()
2158            .unwrap_err();
2159
2160        assert_eq!(
2161            errors.first().unwrap().to_string(),
2162            "ParaId 1 already set to be registered, only one should be."
2163        );
2164    }
2165
2166    #[test]
2167    fn network_config_should_work_from_toml_without_chain_name() {
2168        let loaded_from_toml =
2169            NetworkConfig::load_from_toml("./testing/snapshots/0006-without-rc-chain-name.toml")
2170                .unwrap();
2171
2172        assert_eq!(
2173            "rococo-local",
2174            loaded_from_toml.relaychain().chain().as_str()
2175        );
2176    }
2177
2178    #[test]
2179    fn network_config_should_work_from_toml_with_duplicate_name_between_collator_and_relay_node() {
2180        let loaded_from_toml = NetworkConfig::load_from_toml(
2181            "./testing/snapshots/0007-small-network_w_parachain_w_duplicate_node_names.toml",
2182        )
2183        .unwrap();
2184
2185        assert_eq!(
2186            loaded_from_toml
2187                .relaychain()
2188                .nodes()
2189                .iter()
2190                .filter(|n| n.name() == "alice")
2191                .count(),
2192            1
2193        );
2194        assert_eq!(
2195            loaded_from_toml
2196                .parachains()
2197                .iter()
2198                .flat_map(|para| para.collators())
2199                .filter(|n| n.name() == "alice-1")
2200                .count(),
2201            1
2202        );
2203    }
2204
2205    #[test]
2206    fn raw_spec_override_in_toml_should_work() {
2207        let load_from_toml = NetworkConfig::load_from_toml(
2208            "./testing/snapshots/0008-small-network-with-raw-spec-override.toml",
2209        )
2210        .unwrap();
2211
2212        let expected = NetworkConfigBuilder::new()
2213            .with_relaychain(|relaychain| {
2214                relaychain
2215                    .with_chain("rococo-local")
2216                    .with_default_command("polkadot")
2217                    .with_raw_spec_override("/some/path/raw_spec_override.json")
2218                    .with_validator(|node| node.with_name("alice"))
2219                    .with_validator(|node| node.with_name("bob"))
2220            })
2221            .with_parachain(|p| {
2222                p.with_id(1000)
2223                    .with_raw_spec_override("https://some.com/raw_spec_override.json")
2224                    .with_collator(|c| c.with_name("john"))
2225            })
2226            .build()
2227            .unwrap();
2228
2229        assert_eq!(
2230            load_from_toml.relaychain().raw_spec_override(),
2231            expected.relaychain().raw_spec_override()
2232        );
2233        assert_eq!(
2234            load_from_toml.parachains()[0].raw_spec_override(),
2235            expected.parachains()[0].raw_spec_override()
2236        );
2237    }
2238
2239    const TOML_WITH_RELATIVE_PATHS: &str = r#"
2240[relaychain]
2241chain = "rococo-local"
2242default_command = "./bin/polkadot"
2243chain_spec_path = "./rc.json"
2244
2245[[relaychain.nodes]]
2246name = "alice"
2247validator = true
2248command = "polkadot"
2249"#;
2250
2251    #[test]
2252    fn toml_string_should_resolve_relative_paths_against_the_given_base_dir() {
2253        let config = NetworkConfig::load_from_toml_string_with_base_dir(
2254            TOML_WITH_RELATIVE_PATHS,
2255            Path::new("/tmp/some-base-dir"),
2256        )
2257        .unwrap();
2258
2259        assert_eq!(
2260            config.relaychain().default_command().unwrap().as_str(),
2261            "/tmp/some-base-dir/bin/polkadot"
2262        );
2263        assert_eq!(
2264            config.relaychain().chain_spec_path().unwrap().to_string(),
2265            "/tmp/some-base-dir/rc.json"
2266        );
2267        // non-relative values are left untouched
2268        assert_eq!(
2269            config.relaychain().nodes()[0].command().unwrap().as_str(),
2270            "polkadot"
2271        );
2272    }
2273
2274    #[test]
2275    fn toml_string_should_resolve_relative_paths_against_the_cwd_by_default() {
2276        let from_cwd = NetworkConfig::load_from_toml_string(TOML_WITH_RELATIVE_PATHS).unwrap();
2277        let expected = NetworkConfig::load_from_toml_string_with_base_dir(
2278            TOML_WITH_RELATIVE_PATHS,
2279            &std::env::current_dir().unwrap(),
2280        )
2281        .unwrap();
2282
2283        assert_eq!(from_cwd, expected);
2284    }
2285
2286    #[test]
2287    fn toml_string_and_toml_file_should_produce_the_same_config() {
2288        let path = "./testing/snapshots/0006-without-rc-chain-name.toml";
2289        let from_file = NetworkConfig::load_from_toml(path).unwrap();
2290
2291        let file_path = PathBuf::from(path).canonicalize().unwrap();
2292        let base_dir = file_path.parent().unwrap();
2293        let from_string = NetworkConfig::load_from_toml_string_with_base_dir(
2294            &fs::read_to_string(path).unwrap(),
2295            base_dir,
2296        )
2297        .unwrap();
2298
2299        assert_eq!(from_file, from_string);
2300
2301        // and the relative paths were actually rewritten, not just rewritten identically
2302        assert_eq!(
2303            from_string
2304                .relaychain()
2305                .chain_spec_path()
2306                .unwrap()
2307                .to_string(),
2308            base_dir.join("rc.json").to_string_lossy()
2309        );
2310        assert_eq!(
2311            from_string.parachains()[0]
2312                .chain_spec_path()
2313                .unwrap()
2314                .to_string(),
2315            base_dir.join("parachain.json").to_string_lossy()
2316        );
2317    }
2318
2319    #[test]
2320    fn with_jamchain() {
2321        let network_config = NetworkConfigBuilder::new()
2322            .with_relaychain(|relaychain| {
2323                relaychain
2324                    .with_chain("westend")
2325                    .with_default_command("polkadot")
2326                    .with_default_image("docker.io/parity/polkadot:stable2603-3")
2327                    .with_validator(|n| n.with_name("validator-0"))
2328                    .with_validator(|n| n.with_name("validator-1"))
2329            })
2330            .with_parachain(|parachain| {
2331                parachain
2332                    .with_id(1004)
2333                    .with_chain_spec_path("https://raw.githubusercontent.com/paritytech/polkadot-sdk/104e66f7114ea3322187b4b93255bb9f3f4d5005/cumulus/zombienet/zombienet-sdk/tests/zombie_ci/statement_store/people-westend-local-spec.json")
2334                    .with_collator_group(|g| {
2335                        g.with_count(100)
2336                        .with_base_node(|n|{
2337                            n.with_name("collator")
2338                            .with_command("polkadot-parachain")
2339                            .with_args(vec!["--enable-statement-store".into()])
2340                            .with_image("docker.io/parity/polkadot-parachain:stable2603-3")
2341                        })
2342                })
2343            })
2344            .with_jamchain(|jamchain| {
2345                jamchain
2346                .with_id("dev")
2347                .with_validator(|jamnode|{
2348                    jamnode.with_name("jam1")
2349                })
2350            })
2351            .build()
2352            .unwrap();
2353
2354        let toml_string = network_config.dump_to_toml().unwrap();
2355        println!("{}", toml_string);
2356    }
2357
2358    /// v0.7.0 files could pick the node's `gen-spec` with these keys. They are gone, and
2359    /// silently dropping them would spawn a different genesis than asked for, so they are
2360    /// refused with a pointer to what replaces them.
2361    #[test]
2362    fn jamchain_removed_spec_fields_are_refused() {
2363        let cases = [
2364            (
2365                "chain_spec_command = \"polkajam\"\n",
2366                "chain_spec_command: removed",
2367            ),
2368            (
2369                "[jamchain.genesis_overrides]\nassigners = { \"0\" = 5 }\n",
2370                "genesis_overrides: removed, use `[jamchain.genesis]`",
2371            ),
2372        ];
2373        for (field, expected) in cases {
2374            let toml = format!(
2375                "[jamchain]\nid = \"dev\"\n{field}\n[[jamchain.nodes]]\nname = \"jam0\"\nmode = \"validator\"\n"
2376            );
2377
2378            let error = NetworkConfig::load_from_toml_string(&toml).unwrap_err();
2379
2380            assert!(error.to_string().contains(expected), "{error}");
2381        }
2382    }
2383
2384    #[test]
2385    fn jamchain_genesis_is_loaded_from_toml_with_paths_resolved() {
2386        let toml = r#"
2387[jamchain]
2388id = "dev"
2389
2390[jamchain.genesis]
2391bootstrap_service = "./blobs/bootstrap.jam"
2392
2393[jamchain.genesis.services.5]
2394code = "blobs/svc.jam"
2395balance = 1000
2396preimages = ["https://example.com/auth.jam"]
2397
2398[jamchain.genesis.auth_queues]
23990 = [{ code = "/abs/auth.jam" }]
24001 = ["null"]
2401
2402[jamchain.genesis.privileges]
2403assign = { 0 = 5 }
2404
2405[[jamchain.nodes]]
2406name = "jam0"
2407mode = "validator"
2408"#;
2409        let loaded =
2410            NetworkConfig::load_from_toml_string_with_base_dir(toml, Path::new("/net")).unwrap();
2411        let genesis = loaded.jamchain().unwrap().genesis().expect("a genesis");
2412
2413        assert_eq!(
2414            genesis.bootstrap_service(),
2415            Some(&AssetLocation::from("/net/./blobs/bootstrap.jam"))
2416        );
2417        let service = &genesis.services()[&5];
2418        assert_eq!(service.code(), &AssetLocation::from("/net/blobs/svc.jam"));
2419        assert_eq!(service.balance(), crate::JamBalance::Exact(1000));
2420        assert_eq!(
2421            service.preimages(),
2422            &[AssetLocation::from("https://example.com/auth.jam")]
2423        );
2424        assert_eq!(
2425            genesis.auth_queues()[&0],
2426            vec![crate::JamAuthorizer::code("/abs/auth.jam")]
2427        );
2428        assert_eq!(genesis.privileges().assign()[&0], 5);
2429
2430        let reloaded =
2431            NetworkConfig::load_from_toml_string(&loaded.dump_to_toml().unwrap()).unwrap();
2432        assert_eq!(reloaded.jamchain(), loaded.jamchain());
2433    }
2434
2435    #[test]
2436    fn the_jam_genesis_example_loads() {
2437        let config =
2438            NetworkConfig::load_from_toml("../examples/examples/configs/jam-genesis.toml").unwrap();
2439
2440        let jamchain = config.jamchain().unwrap();
2441        let genesis = jamchain.genesis().expect("the example has a genesis");
2442        let service = &genesis.services()[&5];
2443        assert!(service
2444            .code()
2445            .to_string()
2446            .ends_with("/configs/./blobs/my-service.jam"));
2447        assert_eq!(service.balance(), crate::JamBalance::MinimumPlus(1_000_000));
2448        assert_eq!(genesis.privileges().assign()[&0], 5);
2449        assert_eq!(jamchain.nodes().len(), 7);
2450    }
2451
2452    #[test]
2453    fn jamchain_toml_with_conflicting_spec_sources_is_refused() {
2454        let error = NetworkConfig::load_from_toml_string(
2455            r#"
2456[jamchain]
2457id = "dev"
2458chain_spec_path = "/specs/jam.json"
2459
2460[jamchain.genesis]
2461
2462[[jamchain.nodes]]
2463name = "jam0"
2464mode = "validator"
2465"#,
2466        )
2467        .unwrap_err();
2468
2469        assert!(
2470            error
2471                .to_string()
2472                .contains("genesis: can't be used with `chain_spec_path`"),
2473            "{error}"
2474        );
2475    }
2476
2477    #[test]
2478    fn genesis_patch_round_trips_through_toml() {
2479        let toml = r#"
2480[relaychain]
2481chain = "rococo-local"
2482default_command = "polkadot"
2483
2484[[relaychain.genesis_patch]]
2485op = "add"
2486path = "/balances/balances/-"
2487value = ["5FHneW46xGXgs5mUiveU4sbTyGBzmstUspZC92UhjJM694ty", 1000000000000]
2488
2489[[relaychain.genesis_patch]]
2490op = "replace"
2491path = "/staking/minimumValidatorCount"
2492value = 7
2493
2494[[relaychain.nodes]]
2495name = "alice"
2496
2497[[parachains]]
2498id = 100
2499default_command = "polkadot-parachain"
2500
2501[[parachains.genesis_patch]]
2502op = "remove"
2503path = "/sudo"
2504
2505[[parachains.collators]]
2506name = "collator"
2507"#;
2508        let loaded = NetworkConfig::load_from_toml_string(toml).unwrap();
2509        let relay_patch = loaded.relaychain().genesis_patch().unwrap();
2510        assert_eq!(relay_patch.0.len(), 2);
2511        assert_eq!(
2512            serde_json::to_value(&relay_patch.0[1]).unwrap(),
2513            serde_json::json!({"op": "replace", "path": "/staking/minimumValidatorCount", "value": 7})
2514        );
2515        let para_patch = loaded.parachains()[0].genesis_patch().unwrap();
2516        assert_eq!(
2517            serde_json::to_value(para_patch).unwrap(),
2518            serde_json::json!([{"op": "remove", "path": "/sudo"}])
2519        );
2520
2521        let reloaded =
2522            NetworkConfig::load_from_toml_string(&loaded.dump_to_toml().unwrap()).unwrap();
2523        assert_eq!(reloaded.relaychain().genesis_patch(), Some(relay_patch));
2524        assert_eq!(reloaded.parachains()[0].genesis_patch(), Some(para_patch));
2525    }
2526
2527    #[test]
2528    fn jamchain_toml_without_relaychain_works() {
2529        let config = NetworkConfig::load_from_toml_string(
2530            r#"
2531[jamchain]
2532id = "dev"
2533default_command = "polkajam"
2534
2535[[jamchain.nodes]]
2536name = "jam0"
2537mode = "validator"
2538
2539[[jamchain.nodes]]
2540name = "jam-or"
2541mode = "ordinary"
2542"#,
2543        )
2544        .unwrap();
2545
2546        assert!(config.try_relaychain().is_none());
2547        let jamchain = config.jamchain().unwrap();
2548        assert_eq!(jamchain.id().as_str(), "dev");
2549        assert_eq!(jamchain.nodes().len(), 2);
2550        assert_eq!(jamchain.nodes()[1].mode(), &JamNodeMode::Ordinary);
2551    }
2552
2553    #[test]
2554    fn jamchain_toml_with_parachains_works() {
2555        let config = NetworkConfig::load_from_toml_string(
2556            r#"
2557[jamchain]
2558id = "dev"
2559default_command = "polkajam"
2560
2561[[jamchain.nodes]]
2562name = "jam-or"
2563mode = "ordinary"
2564
2565[[parachains]]
2566id = 1000
2567default_command = "polkadot-omni-node"
2568default_args = ["--jam-rpc-url http://{{ZOMBIE:jam-or:rpc_uri}}"]
2569
2570[[parachains.collators]]
2571name = "collator"
2572
2573[[parachains.collators]]
2574name = "collator"
2575"#,
2576        )
2577        .unwrap();
2578
2579        assert!(config.try_relaychain().is_none());
2580        assert!(config.jamchain().is_some());
2581
2582        let para = config.parachains()[0];
2583        assert_eq!(para.id(), 1000);
2584
2585        // the parachain defaults are applied to the collators, and their names deduplicated
2586        let collators = para.collators();
2587        assert_eq!(collators.len(), 2);
2588        assert_eq!(collators[0].name(), "collator");
2589        assert_eq!(collators[1].name(), "collator-1");
2590        for collator in collators {
2591            assert_eq!(collator.command().unwrap().as_str(), "polkadot-omni-node");
2592            assert_eq!(
2593                collator.args(),
2594                vec![&Arg::Option(
2595                    "--jam-rpc-url".into(),
2596                    "http://{{ZOMBIE:jam-or:rpc_uri}}".into()
2597                )]
2598            );
2599        }
2600    }
2601
2602    #[test]
2603    fn toml_without_relaychain_nor_jamchain_fails() {
2604        let err = NetworkConfig::load_from_toml_string(
2605            r#"
2606[[parachains]]
2607id = 1000
2608"#,
2609        )
2610        .unwrap_err();
2611
2612        assert_eq!(
2613            err.to_string(),
2614            "Relay chain or Jam definition does not exist."
2615        );
2616    }
2617
2618    #[test]
2619    fn with_tiny_jamchain() {
2620        let network_config = NetworkConfigBuilder::new()
2621            .with_relaychain(|relaychain| {
2622                relaychain
2623                    .with_chain("westend")
2624                    .with_default_command("polkadot")
2625                    .with_default_image("docker.io/parity/polkadot:stable2603-3")
2626                    .with_validator(|n| n.with_name("validator-0"))
2627                    .with_validator(|n| n.with_name("validator-1"))
2628            })
2629            .with_tiny_jamchain()
2630            .build()
2631            .unwrap();
2632
2633        let toml_string = network_config.dump_to_toml().unwrap();
2634        println!("{}", toml_string);
2635    }
2636    #[test]
2637    fn demo_denis() {
2638        let network_config = NetworkConfigBuilder::new()
2639            .with_relaychain(|relaychain| {
2640                relaychain
2641                    .with_chain("westend")
2642                    .with_default_command("polkadot")
2643                    .with_default_image("docker.io/parity/polkadot:stable2603-3")
2644                    .with_validator(|n| n.with_name("validator-0"))
2645                    .with_validator(|n| n.with_name("validator-1"))
2646            })
2647            .with_parachain(|parachain| {
2648                parachain
2649                    .with_id(1004)
2650                    .with_chain_spec_path("https://raw.githubusercontent.com/paritytech/polkadot-sdk/104e66f7114ea3322187b4b93255bb9f3f4d5005/cumulus/zombienet/zombienet-sdk/tests/zombie_ci/statement_store/people-westend-local-spec.json")
2651                    .with_collator_group(|g| {
2652                        g.with_count(100)
2653                        .with_base_node(|n|{
2654                            n.with_name("collator")
2655                            .with_command("polkadot-parachain")
2656                            .with_args(vec!["--enable-statement-store".into()])
2657                            .with_image("docker.io/parity/polkadot-parachain:stable2603-3")
2658                        })
2659                })
2660            })
2661            .build()
2662            .unwrap();
2663
2664        let toml_string = network_config.dump_to_toml().unwrap();
2665        println!("{}", toml_string);
2666    }
2667
2668    #[test]
2669    fn node_names_loaded_from_toml_are_made_valid_for_every_provider() {
2670        // zombie-bite writes `Collator-<id>`, which no kubernetes pod can be named.
2671        let network_config = NetworkConfig::load_from_toml_string(
2672            r#"
2673            [relaychain]
2674            chain = "rococo-local"
2675            default_command = "polkadot"
2676
2677            [[relaychain.nodes]]
2678            name = "Alice"
2679
2680            [[relaychain.nodes]]
2681            name = "my_node"
2682
2683            [[parachains]]
2684            id = 1000
2685            chain = "asset-hub-rococo"
2686            default_command = "polkadot-parachain"
2687
2688            [[parachains.collators]]
2689            name = "Collator-1000"
2690            "#,
2691        )
2692        .unwrap();
2693
2694        let validators: Vec<&str> = network_config
2695            .relaychain()
2696            .nodes()
2697            .iter()
2698            .map(|node| node.name())
2699            .collect();
2700        assert_eq!(validators, ["alice", "my-node"]);
2701        assert_eq!(
2702            network_config.parachains()[0].collators()[0].name(),
2703            "collator-1000"
2704        );
2705    }
2706
2707    /// A one-node relaychain with the given `[[custom_processes]]` entries.
2708    fn load_with_processes(processes: &str) -> Result<NetworkConfig, anyhow::Error> {
2709        NetworkConfig::load_from_toml_string(&format!(
2710            r#"
2711            [relaychain]
2712            chain = "rococo-local"
2713            default_command = "polkadot"
2714
2715            [[relaychain.nodes]]
2716            name = "alice"
2717
2718            [[custom_processes]]
2719            {processes}
2720            "#
2721        ))
2722    }
2723
2724    #[test]
2725    fn custom_process_lifecycle_loads_from_toml_and_is_validated() {
2726        let config = load_with_processes(
2727            r#"
2728            name = "init"
2729            command = "sh"
2730            one_shot = true
2731            timeout = 30
2732
2733            [[custom_processes]]
2734            name = "api"
2735            command = "api"
2736            ports = [{ name = "http", port = 8080 }]
2737            ready_check = { http = { port = "http", path = "/health" }, interval = 2 }
2738            timeout = 120
2739            depends_on = ["init", { name = "cache", condition = "service_started" }]
2740
2741            [[custom_processes]]
2742            name = "cache"
2743            command = "cache"
2744            "#,
2745        )
2746        .unwrap();
2747        let processes = config.custom_processes();
2748        let api = processes[1];
2749        assert_eq!(api.timeout(), Some(120));
2750        assert_eq!(api.ready_check().unwrap().interval, 2);
2751        assert_eq!(api.depends_on().len(), 2);
2752        assert_eq!(
2753            api.depends_on()[1].condition,
2754            Some(DependencyCondition::ServiceStarted)
2755        );
2756        assert!(processes[0].one_shot());
2757        let dumped = config.dump_to_toml().unwrap();
2758        let reloaded = NetworkConfig::load_from_toml_string(&dumped).unwrap();
2759        assert_eq!(reloaded.custom_processes(), config.custom_processes());
2760
2761        // the cross-process rules apply on this path too
2762        let err = load_with_processes(
2763            r#"
2764            name = "api"
2765            command = "api"
2766            ports = [{ name = "http", port = 8080 }]
2767            ready_check = { http = { port = "http", path = "health" } }
2768            depends_on = [{ name = "cache", condition = "service_healthy" }]
2769
2770            [[custom_processes]]
2771            name = "cache"
2772            command = "cache"
2773            depends_on = ["api"]
2774            "#,
2775        )
2776        .unwrap_err()
2777        .to_string();
2778        assert!(
2779            err.contains("http path 'health' must start with '/'"),
2780            "{err}"
2781        );
2782        assert!(err.contains("'cache' cannot be service_healthy"), "{err}");
2783        assert!(err.contains("cycle among api, cache"), "{err}");
2784    }
2785
2786    #[test]
2787    fn custom_process_files_and_secret_env_load_from_toml_and_dump_back() {
2788        let config = load_with_processes(
2789            r#"
2790            name = "api"
2791            command = "api"
2792            env = [
2793                { name = "RUST_LOG", value = "info" },
2794                { name = "TURN_SECRET", secret = { name = "turn", key = "secret" } },
2795            ]
2796            injected_files = [
2797                { local_path = "./sql/init.sql", remote_path = "/schema/init.sql" },
2798                { local_path="./my-scripts/run_me.sh", remote_path = "/run.sh", mode = "0755" },
2799            ]
2800            "#,
2801        )
2802        .unwrap();
2803        let api = config.custom_processes()[0];
2804        assert_eq!(
2805            api.env()[1],
2806            ProcessEnvVar::from_secret("TURN_SECRET", "turn", "secret")
2807        );
2808        // a `./` path is resolved against the TOML's directory, as `command` is
2809        let run = &api.injected_files()[1];
2810        assert!(
2811            run.local_path.is_absolute() && run.local_path.ends_with("my-scripts/run_me.sh"),
2812            "{run:?}"
2813        );
2814        assert_eq!(run.remote_path.as_path(), std::path::Path::new("/run.sh"));
2815        assert_eq!(run.mode, "0755");
2816        let dumped = config.dump_to_toml().unwrap();
2817        let reloaded = NetworkConfig::load_from_toml_string(&dumped).unwrap();
2818        assert_eq!(reloaded.custom_processes(), config.custom_processes());
2819
2820        let err = load_with_processes(
2821            r#"
2822            name = "api"
2823            command = "api"
2824            injected_files = [{ local_path = "./run.sh", remote_path = "run.sh" }]
2825            "#,
2826        )
2827        .unwrap_err()
2828        .to_string();
2829        assert!(
2830            err.contains("remote_path 'run.sh' must be an absolute path"),
2831            "{err}"
2832        );
2833    }
2834
2835    #[test]
2836    fn custom_process_ports_and_resources_load_from_toml_and_dump_back() {
2837        let network_config = load_with_processes(
2838            r#"
2839            name = "ipfs"
2840            command = "ipfs"
2841            image = "docker.io/ipfs/kubo:v0.39.0"
2842            args = ["daemon"]
2843            ports = [{ name = "api", port = 5001 }, { name = "gateway", port = 8080 }]
2844
2845            [custom_processes.resources]
2846            limits = { cpu = "500m", memory = "512Mi" }
2847
2848            [[custom_processes]]
2849            name = "eth-rpc"
2850            command = "eth-rpc"
2851            "#,
2852        )
2853        .unwrap();
2854
2855        let processes = network_config.custom_processes();
2856        assert_eq!(processes.len(), 2);
2857        let ipfs = processes[0];
2858        assert_eq!(
2859            ipfs.ports()
2860                .iter()
2861                .map(|p| (p.name.as_str(), p.port))
2862                .collect::<Vec<_>>(),
2863            [("api", 5001), ("gateway", 8080)]
2864        );
2865        assert_eq!(
2866            ipfs.resources().unwrap().limit_cpu().unwrap().as_str(),
2867            "500m"
2868        );
2869        assert!(processes[1].ports().is_empty());
2870        assert!(processes[1].resources().is_none());
2871
2872        // What is dumped loads back to the same config: ports and resources included.
2873        let dumped = network_config.dump_to_toml().unwrap();
2874        assert!(dumped.contains("[[custom_processes.ports]]"));
2875        let reloaded = NetworkConfig::load_from_toml_string(&dumped).unwrap();
2876        assert_eq!(
2877            reloaded.custom_processes(),
2878            network_config.custom_processes()
2879        );
2880    }
2881
2882    #[test]
2883    fn custom_processes_loaded_from_toml_are_validated() {
2884        // A port name k8s would reject, caught before anything is spawned.
2885        let err = load_with_processes(
2886            r#"
2887            name = "eth-rpc"
2888            command = "eth-rpc"
2889            ports = [{ name = "json_rpc", port = 8545 }]
2890            "#,
2891        )
2892        .unwrap_err();
2893        assert!(
2894            err.to_string()
2895                .contains("custom_processes['eth-rpc'].ports: port name 'json_rpc'"),
2896            "{err}"
2897        );
2898
2899        // A process may not take a node's name: they share one registry.
2900        let err = load_with_processes(
2901            r#"
2902            name = "alice"
2903            command = "eth-rpc"
2904            "#,
2905        )
2906        .unwrap_err();
2907        assert!(
2908            err.to_string()
2909                .contains("custom_processes['alice'].name: already used by a node"),
2910            "{err}"
2911        );
2912    }
2913
2914    #[test]
2915    fn a_custom_process_name_is_rejected_where_a_node_name_would_be_corrected() {
2916        let err = load_with_processes(
2917            r#"
2918            name = "eth_rpc"
2919            command = "eth-rpc"
2920            "#,
2921        )
2922        .unwrap_err();
2923        assert!(
2924            err.to_string()
2925                .contains("custom_processes['eth_rpc'].name: 'eth_rpc' must be"),
2926            "{err}"
2927        );
2928        assert!(err.to_string().contains("(e.g. 'eth-rpc')"), "{err}");
2929
2930        let err = load_with_processes(
2931            r#"
2932            name = ""
2933            command = "eth-rpc"
2934            "#,
2935        )
2936        .unwrap_err();
2937        assert!(
2938            err.to_string()
2939                .contains("custom_processes[''].name: can't be empty"),
2940            "{err}"
2941        );
2942
2943        let errors = NetworkConfigBuilder::new()
2944            .with_relaychain(|r| {
2945                r.with_chain("rococo-local")
2946                    .with_default_command("polkadot")
2947                    .with_validator(|node| node.with_name("alice"))
2948            })
2949            .with_custom_process(|c| c.with_name("Eth-RPC").with_command("eth-rpc"))
2950            .build()
2951            .unwrap_err();
2952        assert!(
2953            errors
2954                .iter()
2955                .any(|e| e.to_string().contains("custom_processes['Eth-RPC'].name:")),
2956            "{errors:?}"
2957        );
2958    }
2959
2960    #[test]
2961    fn a_custom_process_may_not_take_a_node_name_in_the_builder() {
2962        let errors = NetworkConfigBuilder::new()
2963            .with_relaychain(|r| {
2964                r.with_chain("rococo-local")
2965                    .with_default_command("polkadot")
2966                    .with_validator(|node| node.with_name("alice"))
2967            })
2968            .with_custom_process(|c| c.with_name("alice").with_command("eth-rpc"))
2969            .build()
2970            .unwrap_err();
2971        assert!(
2972            errors.iter().any(|e| e
2973                .to_string()
2974                .contains("already used by a node or custom process")),
2975            "{errors:?}"
2976        );
2977    }
2978}