spikes 0.4.0

Drop-in feedback collection for static HTML mockups
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
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362

use std::path::Path;

use crate::config::Config;
use crate::error::{Error, Result};

/// Internal run function that returns a Result without side-effects.
/// Separates logic from exit handling for testability.
fn run_internal(json: bool) -> Result<Option<serde_json::Value>> {
    // Check if .spikes/ directory exists - parity with `spikes list`
    // Must be a directory, not just any file type (handles file/symlink edge case)
    if !Path::new(".spikes").is_dir() {
        if json {
            // JSON mode: return structured error as JSON value
            let error_json = serde_json::json!({
                "error": "No .spikes/ directory found. Run 'spikes init' first."
            });
            return Ok(Some(error_json));
        }
        return Err(Error::NoSpikesDir);
    }

    let config = Config::load()?;

    if json {
        let output = serde_json::json!({
            "project": {
                "key": config.effective_project_key()
            },
            "widget": {
                "theme": config.widget.theme,
                "position": config.widget.position,
                "color": config.widget.color,
                "collect_email": config.widget.collect_email
            },
            "remote": {
                "endpoint": config.effective_endpoint(),
                "hosted": config.remote.hosted,
                "has_token": config.remote.token.is_some()
            }
        });
        return Ok(Some(output));
    }

    println!();
    println!("  / Spikes Configuration");
    println!();
    println!("  Project:  {}", config.effective_project_key());
    println!();
    println!("  Widget:");
    println!("    theme:         {}", config.widget.theme);
    println!("    position:      {}", config.widget.position);
    println!("    color:         {}", config.widget.color);
    println!("    collect_email: {}", config.widget.collect_email);
    println!();
    println!("  Remote:");
    if let Some(endpoint) = config.effective_endpoint() {
        println!("    endpoint: {}", endpoint);
        println!("    hosted:   {}", config.remote.hosted);
        println!("    token:    {}", if config.remote.token.is_some() { "(set)" } else { "(not set)" });
    } else {
        println!("    (not configured)");
    }
    println!();
    println!("  Widget tag attributes:");
    println!("    {}", config.widget_attributes());
    println!();

    Ok(None)
}

/// Show current configuration
pub fn run(json: bool) -> Result<()> {
    match run_internal(json) {
        Ok(Some(json_value)) => {
            // Check if this is an error response
            if json_value.get("error").is_some() {
                // JSON error mode: print to stdout and exit non-zero
                println!(
                    "{}",
                    serde_json::to_string_pretty(&json_value)
                        .expect("Failed to serialize JSON")
                );
                std::process::exit(1);
            }
            // Normal JSON success output
            println!(
                "{}",
                serde_json::to_string_pretty(&json_value)
                    .expect("Failed to serialize JSON")
            );
            Ok(())
        }
        Ok(None) => Ok(()),
        Err(e) => Err(e),
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::fs;
    use tempfile::TempDir;
    use std::sync::Mutex;

    // Use a mutex to prevent parallel test execution for tests that change current directory
    static TEST_MUTEX: Mutex<()> = Mutex::new(());

    #[test]
    fn test_config_requires_spikes_dir() {
        let _lock = TEST_MUTEX.lock().unwrap();
        let temp_dir = TempDir::new().unwrap();

        let original_cwd = std::env::current_dir().unwrap();
        std::env::set_current_dir(temp_dir.path()).unwrap();

        // Without .spikes/ directory, config should fail with NoSpikesDir
        let result = run_internal(false);
        assert!(result.is_err());
        assert!(matches!(result.unwrap_err(), Error::NoSpikesDir));

        std::env::set_current_dir(original_cwd).unwrap();
    }

    #[test]
    fn test_config_requires_spikes_dir_json() {
        let _lock = TEST_MUTEX.lock().unwrap();
        let temp_dir = TempDir::new().unwrap();

        let original_cwd = std::env::current_dir().unwrap();
        std::env::set_current_dir(temp_dir.path()).unwrap();

        // Without .spikes/ directory, config --json should return a JSON error value
        // (via run_internal, which doesn't call exit())
        let result = run_internal(true);
        assert!(result.is_ok(), "run_internal should succeed and return JSON error");
        
        let json_value = result.unwrap();
        assert!(json_value.is_some(), "should return JSON value");
        
        let json = json_value.unwrap();
        assert!(json.get("error").is_some(), "JSON should contain error field");
        
        let error_msg = json.get("error").unwrap().as_str().unwrap();
        assert!(error_msg.contains(".spikes/"), "Error should mention .spikes/");
        assert!(error_msg.contains("spikes init"), "Error should reference 'spikes init'");

        std::env::set_current_dir(original_cwd).unwrap();
    }

    #[test]
    fn test_config_succeeds_with_spikes_dir() {
        let _lock = TEST_MUTEX.lock().unwrap();
        let temp_dir = TempDir::new().unwrap();
        let spikes_dir = temp_dir.path().join(".spikes");
        fs::create_dir_all(&spikes_dir).unwrap();

        // Create a minimal config.toml
        let config_content = concat!(
            "[project]\n",
            "key = \"test-project\"\n",
            "\n",
            "[widget]\n",
            "theme = \"dark\"\n",
            "position = \"bottom-right\"\n",
            "color = \"#e74c3c\"\n",
            "collect_email = false\n",
            "\n",
            "[remote]\n",
            "hosted = true\n",
            "endpoint = \"https://spikes.sh\"\n"
        );
        fs::write(spikes_dir.join("config.toml"), config_content).unwrap();

        let original_cwd = std::env::current_dir().unwrap();
        std::env::set_current_dir(temp_dir.path()).unwrap();

        // With .spikes/ directory and config, config should succeed
        // Use run_internal which returns None for success (no JSON output)
        let result = run_internal(false);
        assert!(result.is_ok(), "config should succeed when .spikes/ exists: {:?}", result);
        assert!(result.unwrap().is_none(), "Success in non-JSON mode should return None");

        std::env::set_current_dir(original_cwd).unwrap();
    }

    #[test]
    fn test_config_json_succeeds_with_spikes_dir() {
        let _lock = TEST_MUTEX.lock().unwrap();
        let temp_dir = TempDir::new().unwrap();
        let spikes_dir = temp_dir.path().join(".spikes");
        fs::create_dir_all(&spikes_dir).unwrap();

        // Create a minimal config.toml
        let config_content = concat!(
            "[project]\n",
            "key = \"test-project\"\n",
            "\n",
            "[widget]\n",
            "theme = \"dark\"\n",
            "position = \"bottom-right\"\n",
            "color = \"#e74c3c\"\n",
            "collect_email = false\n",
            "\n",
            "[remote]\n",
            "hosted = true\n",
            "endpoint = \"https://spikes.sh\"\n"
        );
        fs::write(spikes_dir.join("config.toml"), config_content).unwrap();

        let original_cwd = std::env::current_dir().unwrap();
        std::env::set_current_dir(temp_dir.path()).unwrap();

        // With .spikes/ directory and config, config --json should succeed
        // Use run_internal which returns Some(JSON) for success in JSON mode
        let result = run_internal(true);
        assert!(result.is_ok(), "config --json should succeed when .spikes/ exists: {:?}", result);
        
        let json_value = result.unwrap();
        assert!(json_value.is_some(), "JSON mode should return Some(JSON value)");
        
        let json = json_value.unwrap();
        assert!(json.get("project").is_some(), "JSON should contain project");
        assert!(json.get("widget").is_some(), "JSON should contain widget");
        assert!(json.get("remote").is_some(), "JSON should contain remote");
        
        // Verify hosted flag is present
        let remote = json.get("remote").unwrap();
        assert_eq!(remote.get("hosted").unwrap().as_bool(), Some(true));

        std::env::set_current_dir(original_cwd).unwrap();
    }

    /// Regression test: .spikes as a file (not directory) should fail with NoSpikesDir
    /// This ensures parity with `spikes list` behavior per VAL-CROSS-007
    #[test]
    fn test_config_requires_spikes_dir_not_file() {
        let _lock = TEST_MUTEX.lock().unwrap();
        let temp_dir = TempDir::new().unwrap();

        // Create .spikes as a FILE, not a directory
        let spikes_file = temp_dir.path().join(".spikes");
        fs::write(&spikes_file, "not a directory").unwrap();

        let original_cwd = std::env::current_dir().unwrap();
        std::env::set_current_dir(temp_dir.path()).unwrap();

        // When .spikes is a file, config should fail with NoSpikesDir
        // (same as spikes list behavior - parity check)
        let result = run_internal(false);
        assert!(result.is_err(), "config should fail when .spikes is a file");
        assert!(matches!(result.unwrap_err(), Error::NoSpikesDir),
            "config should return NoSpikesDir when .spikes is a file, not a directory");

        // Also verify spikes list fails the same way (parity)
        let list_result = crate::storage::load_spikes();
        assert!(list_result.is_err(), "list should fail when .spikes is a file");
        assert!(matches!(list_result.unwrap_err(), Error::NoSpikesDir),
            "list should return NoSpikesDir when .spikes is a file, not a directory");

        std::env::set_current_dir(original_cwd).unwrap();
    }

    /// Regression test: .spikes as a file with --json flag
    #[test]
    fn test_config_requires_spikes_dir_not_file_json() {
        let _lock = TEST_MUTEX.lock().unwrap();
        let temp_dir = TempDir::new().unwrap();

        // Create .spikes as a FILE, not a directory
        let spikes_file = temp_dir.path().join(".spikes");
        fs::write(&spikes_file, "not a directory").unwrap();

        let original_cwd = std::env::current_dir().unwrap();
        std::env::set_current_dir(temp_dir.path()).unwrap();

        // When .spikes is a file, config --json should return a JSON error value
        // (via run_internal, which doesn't call exit())
        let result = run_internal(true);
        assert!(result.is_ok(), "config --json (via run_internal) should return JSON error");
        
        let json_value = result.unwrap();
        assert!(json_value.is_some(), "should return JSON value");
        
        let json = json_value.unwrap();
        assert!(json.get("error").is_some(), "JSON should contain error field");
        
        let error_msg = json.get("error").unwrap().as_str().unwrap();
        assert!(error_msg.contains(".spikes/"), "Error should mention .spikes/");
        assert!(error_msg.contains("spikes init"), "Error should reference 'spikes init'");

        std::env::set_current_dir(original_cwd).unwrap();
    }

    #[test]
    fn test_config_shows_correct_hosted_endpoint() {
        let _lock = TEST_MUTEX.lock().unwrap();
        let temp_dir = TempDir::new().unwrap();
        let spikes_dir = temp_dir.path().join(".spikes");
        fs::create_dir_all(&spikes_dir).unwrap();

        // Create a config with hosted=true
        let config_content = concat!(
            "[remote]\n",
            "hosted = true\n",
            "endpoint = \"https://spikes.sh\"\n"
        );
        fs::write(spikes_dir.join("config.toml"), config_content).unwrap();

        let original_cwd = std::env::current_dir().unwrap();
        std::env::set_current_dir(temp_dir.path()).unwrap();

        // Load the config and verify it has the correct hosted settings
        let config = Config::load().unwrap();
        assert_eq!(config.effective_endpoint(), Some("https://spikes.sh".to_string()));
        assert!(config.remote.hosted);

        std::env::set_current_dir(original_cwd).unwrap();
    }

    /// Regression test for VAL-CONFIG-016: `spikes config --json` in uninitialized
    /// directory should emit structured JSON error with `error` field, not plain text.
    /// 
    /// This test verifies both paths:
    /// 1. json=false: returns Err(Error::NoSpikesDir) with plain text message
    /// 2. json=true: returns Ok(Some(json)) with {"error": "..."} structure
    #[test]
    fn test_config_json_error_contains_init_guidance() {
        let _lock = TEST_MUTEX.lock().unwrap();
        let temp_dir = TempDir::new().unwrap();

        let original_cwd = std::env::current_dir().unwrap();
        std::env::set_current_dir(temp_dir.path()).unwrap();

        // Test non-JSON path: should return Err with NoSpikesDir
        let result = run_internal(false);
        assert!(result.is_err());
        
        let err = result.unwrap_err();
        assert!(matches!(err, Error::NoSpikesDir), "Should return NoSpikesDir error");
        
        // Verify error message mentions both .spikes/ and spikes init
        let err_string = err.to_string();
        assert!(err_string.contains(".spikes/"), "Error should mention .spikes/ directory: {}", err_string);
        assert!(err_string.contains("spikes init"), "Error should reference 'spikes init' command: {}", err_string);

        // Test JSON path: should return Ok with JSON error
        let json_result = run_internal(true);
        assert!(json_result.is_ok(), "JSON mode should return Ok with JSON error");
        
        let json_value = json_result.unwrap();
        assert!(json_value.is_some(), "JSON mode should return Some(JSON)");
        
        let json = json_value.unwrap();
        assert!(json.get("error").is_some(), "JSON should contain error field");
        
        let error_msg = json.get("error").unwrap().as_str().unwrap();
        assert!(error_msg.contains(".spikes/"), "JSON error should mention .spikes/");
        assert!(error_msg.contains("spikes init"), "JSON error should reference 'spikes init'");

        std::env::set_current_dir(original_cwd).unwrap();
    }
}