cleanup

Author: viviveevee

crates/icp-cli/src/commands/mod.rs

@@ -254,7 +254,7 @@ impl Context {
             artifacts: Arc::new(crate::store_artifact::MockInMemoryArtifactStore::new()),
             project: Arc::new(icp::MockProjectLoader::minimal()),
             identity: Arc::new(icp::identity::MockIdentityLoader::anonymous()),
-            network: Arc::new(icp::network::MockNetworkAccessor::localhost()),
+            network: Arc::new(icp::network::MockNetworkAccessor::new()),
             agent: Arc::new(icp::agent::Creator),
             builder: Arc::new(icp::canister::build::UnimplementedMockBuilder),
             syncer: Arc::new(icp::canister::sync::UnimplementedMockSyncer),
@@ -543,7 +543,7 @@ mod context_tests {
         let ctx = Context {
             project: Arc::new(MockProjectLoader::complex()),
             network: Arc::new(
-                MockNetworkAccessor::localhost()
+                MockNetworkAccessor::new()
                     .with_network(
                         "local",
                         NetworkAccess {
@@ -588,6 +588,27 @@ mod context_tests {
         ));
     }
 
+    #[tokio::test]
+    async fn test_get_agent_for_env_network_not_configured() {
+        // Environment exists in project but its network not configured in MockNetworkAccessor
+        let ctx = Context {
+            project: Arc::new(MockProjectLoader::complex()),
+            // MockNetworkAccessor has no networks configured
+            ..Context::mocked()
+        };
+
+        let result = ctx
+            .get_agent_for_env(&IdentitySelection::Anonymous, "nonexistent")
+            .await;
+
+        assert!(matches!(
+            result,
+            Err(GetAgentForEnvError::NetworkAccess {
+                source: icp::network::AccessError::Unexpected(_)
+            })
+        ));
+    }
+
     #[tokio::test]
     async fn test_get_agent_for_network_success() {
         use icp::network::access::NetworkAccess;
@@ -596,7 +617,7 @@ mod context_tests {
 
         let ctx = Context {
             project: Arc::new(MockProjectLoader::complex()),
-            network: Arc::new(MockNetworkAccessor::localhost().with_network(
+            network: Arc::new(MockNetworkAccessor::new().with_network(
                 "local",
                 NetworkAccess {
                     default_effective_canister_id: None,
@@ -631,6 +652,27 @@ mod context_tests {
         ));
     }
 
+    #[tokio::test]
+    async fn test_get_agent_for_network_not_configured() {
+        // Network exists in project but not configured in MockNetworkAccessor
+        let ctx = Context {
+            project: Arc::new(MockProjectLoader::complex()),
+            // MockNetworkAccessor has no networks configured
+            ..Context::mocked()
+        };
+
+        let result = ctx
+            .get_agent_for_network(&IdentitySelection::Anonymous, "nonexistent")
+            .await;
+
+        assert!(matches!(
+            result,
+            Err(GetAgentForNetworkError::NetworkAccess {
+                source: icp::network::AccessError::Unexpected(_)
+            })
+        ));
+    }
+
     #[tokio::test]
     async fn test_get_agent_for_url_success() {
         let ctx = Context::mocked();

crates/icp-cli/src/store_artifact.rs

@@ -89,11 +89,7 @@ impl Access for ArtifactStore {
 }
 
 #[cfg(test)]
-/// In-memory mock implementation of `Access` for testing purposes.
-///
-/// This mock stores artifacts (WASM bytes) in a HashMap instead of on disk,
-/// making it suitable for tests that need a working artifact store without
-/// file system interactions.
+/// In-memory mock implementation of `Access`.
 pub(crate) struct MockInMemoryArtifactStore {
     store: Mutex<HashMap<String, Vec<u8>>>,
 }

crates/icp-cli/src/store_id.rs

@@ -182,11 +182,7 @@ impl Access for IdStore {
 }
 
 #[cfg(test)]
-/// In-memory mock implementation of `Access` for testing purposes.
-///
-/// This mock stores canister IDs in a HashMap instead of on disk,
-/// making it suitable for tests that need a working ID store without
-/// file system interactions.
+/// In-memory mock implementation of `Access`.
 pub(crate) struct MockInMemoryIdStore {
     store: Mutex<HashMap<Key, Principal>>,
 }

crates/icp/src/canister/build.rs

@@ -109,11 +109,8 @@ impl Build for Builder {
 }
 
 #[cfg(any(test, feature = "test-features"))]
-/// Unimplemented mock implementation of `Build` for testing purposes.
-///
+/// Unimplemented mock implementation of `Build`.
 /// All methods panic with `unimplemented!()` when called.
-/// This is useful for tests that need to construct a context but don't
-/// actually use the build functionality.
 pub struct UnimplementedMockBuilder;
 
 #[cfg(any(test, feature = "test-features"))]

crates/icp/src/canister/sync.rs

@@ -101,11 +101,8 @@ impl Synchronize for Syncer {
 }
 
 #[cfg(any(test, feature = "test-features"))]
-/// Unimplemented mock implementation of `Synchronize` for testing purposes.
-///
+/// Unimplemented mock implementation of `Synchronize`.
 /// All methods panic with `unimplemented!()` when called.
-/// This is useful for tests that need to construct a context but don't
-/// actually use the sync functionality.
 pub struct UnimplementedMockSyncer;
 
 #[cfg(any(test, feature = "test-features"))]

crates/icp/src/directories.rs

@@ -146,11 +146,8 @@ impl Access for Directories {
 }
 
 #[cfg(feature = "test-features")]
-/// Unimplemented mock implementation of `Access` for testing purposes.
-///
+/// Unimplemented mock implementation of `Access`.
 /// All methods panic with `unimplemented!()` when called.
-/// This is useful for tests that need to construct a `Context` but don't
-/// actually use the directory functionality.
 #[derive(Debug, Clone)]
 pub struct UnimplementedMockDirs;
 

crates/icp/src/identity/mod.rs

@@ -116,10 +116,6 @@ impl Load for Loader {
 use std::collections::HashMap;
 
 #[cfg(any(test, feature = "test-features"))]
-/// Mock identity loader for testing.
-///
-/// Allows configuring multiple identities that can be selected by name.
-/// Supports default, anonymous, and named identity selections.
 pub struct MockIdentityLoader {
     /// The default identity to return when IdentitySelection::Default is used
     default: Arc<dyn Identity>,

crates/icp/src/lib.rs

@@ -156,10 +156,7 @@ impl<T: Load> Load for Lazy<T, Project> {
 
 #[cfg(any(test, feature = "test-features"))]
 /// Mock project loader for testing.
-///
 /// Returns a pre-configured `Project` when `load()` is called.
-/// This is useful for tests that need a project but don't want to
-/// deal with file system interactions or project manifest parsing.
 pub struct MockProjectLoader {
     project: Project,
 }

crates/icp/src/network/mod.rs

@@ -143,54 +143,43 @@ impl Access for Accessor {
 use std::collections::HashMap;
 
 #[cfg(any(test, feature = "test-features"))]
-/// Mock network access provider for testing.
-///
-/// Allows configuring network access details for specific networks.
-/// Supports a default fallback for networks not explicitly configured.
 pub struct MockNetworkAccessor {
-    /// Default network access to return for unconfigured networks
-    default: NetworkAccess,
-
     /// Network-specific access configurations by network name
     networks: HashMap<String, NetworkAccess>,
 }
 
 #[cfg(any(test, feature = "test-features"))]
 impl MockNetworkAccessor {
-    /// Creates a new mock network accessor with the given default.
-    pub fn new(default: NetworkAccess) -> Self {
+    /// Creates a new empty mock network accessor.
+    pub fn new() -> Self {
         Self {
-            default,
             networks: HashMap::new(),
         }
     }
 
-    /// Creates a mock with localhost:8000 as the default.
-    pub fn localhost() -> Self {
-        Self::new(NetworkAccess::new("http://localhost:8000"))
-    }
-
     /// Adds a network-specific access configuration.
     pub fn with_network(mut self, name: impl Into<String>, access: NetworkAccess) -> Self {
         self.networks.insert(name.into(), access);
         self
     }
+}
 
-    /// Sets the default network access.
-    pub fn with_default(mut self, access: NetworkAccess) -> Self {
-        self.default = access;
-        self
+#[cfg(any(test, feature = "test-features"))]
+impl Default for MockNetworkAccessor {
+    fn default() -> Self {
+        Self::new()
     }
 }
 
 #[cfg(any(test, feature = "test-features"))]
 #[async_trait]
 impl Access for MockNetworkAccessor {
     async fn access(&self, network: &Network) -> Result<NetworkAccess, AccessError> {
-        Ok(self
-            .networks
-            .get(&network.name)
-            .cloned()
-            .unwrap_or_else(|| self.default.clone()))
+        self.networks.get(&network.name).cloned().ok_or_else(|| {
+            AccessError::Unexpected(anyhow::anyhow!(
+                "network '{}' not configured in mock",
+                network.name
+            ))
+        })
     }
 }