rust-nrm 0.2.1

A Rust-based NPM Registry Manager for efficiently managing and switching between npm registries
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

use rust_nrm::utils::cli::{CommandExecutor, Commands};
use rust_nrm::utils::registries::Store;
use tokio::fs;

async fn setup() -> CommandExecutor {
    let store = Store::load().await;
    CommandExecutor::new(store)
}

async fn cleanup() {
    let config_path = dirs::home_dir()
        .expect("Could not find home directory")
        .join(".config")
        .join("rust-nrm")
        .join("registries.toml");
    if config_path.exists() {
        let _ = fs::remove_file(config_path).await;
    }
}

#[tokio::test]
async fn test_list_command() {
    let mut executor = setup().await;
    executor.execute(Commands::Ls).await;
    cleanup().await;
}

#[tokio::test]
async fn test_use_command() {
    let mut executor = setup().await;

    // Test using npm registry
    executor
        .execute(Commands::Use {
            registry: "npm".to_string(),
            local: false,
        })
        .await;

    // Verify by listing registries
    executor.execute(Commands::Ls).await;
    // Note: Since we can't directly access the store, we rely on the Ls command output
    // The actual verification is done through the command output

    cleanup().await;
}

#[tokio::test]
async fn test_add_command() {
    let mut executor = setup().await;

    // Add a test registry
    let name = "test-registry";
    let url = "https://test.registry.com";
    executor
        .execute(Commands::Add {
            registry: name.to_string(),
            url: url.to_string(),
            home: None,
        })
        .await;

    // Verify by trying to use the added registry
    executor
        .execute(Commands::Use {
            registry: name.to_string(),
            local: false,
        })
        .await;

    cleanup().await;
}

#[tokio::test]
async fn test_remove_command() {
    let mut executor = setup().await;

    // First add a registry
    let name = "test-registry";
    executor
        .execute(Commands::Add {
            registry: name.to_string(),
            url: "https://test.com".to_string(),
            home: None,
        })
        .await;

    // Then remove it
    executor
        .execute(Commands::Remove {
            registry: name.to_string(),
        })
        .await;

    // Try to use the removed registry - this should fail but not panic
    executor
        .execute(Commands::Use {
            registry: name.to_string(),
            local: false,
        })
        .await;

    cleanup().await;
}

#[tokio::test]
async fn test_test_command() {
    let mut executor = setup().await;
    
    // Add a test registry that we know will timeout
    executor
        .execute(Commands::Add {
            registry: "test-timeout".to_string(),
            url: "https://registry.does.not.exist.example.com".to_string(),
            home: None,
        })
        .await;
    
    // Run the test command
    executor.execute(Commands::Test).await;
    
    // Clean up
    executor
        .execute(Commands::Remove {
            registry: "test-timeout".to_string(),
        })
        .await;
    
    cleanup().await;
}