1  use abundantis::config::{
  2      AbundantisConfig, CacheConfig, FileMergeMode, FileResolutionConfig, InterpolationConfig,
  3      InterpolationFeatures, MonorepoProviderType, ResolutionConfig, SourcePrecedence,
  4      WorkspaceConfig,
  5  };
  6  
  7  #[test]
  8  fn test_workspace_config_default() {
  9      let config = WorkspaceConfig::default();
 10      assert_eq!(config.provider, None);
 11      assert!(!config.cascading);
 12      assert!(config.roots.is_empty());
 13      assert_eq!(config.roots.len(), 0);
 14      assert_eq!(config.env_files.len(), 4);
 15      assert_eq!(config.ignores.len(), 5);
 16  }
 17  
 18  #[test]
 19  fn test_workspace_config_env_files_default() {
 20      let config = WorkspaceConfig::default();
 21      assert_eq!(config.env_files[0].as_str(), ".env");
 22      assert_eq!(config.env_files[1].as_str(), ".env.local");
 23      assert_eq!(config.env_files[2].as_str(), ".env.development");
 24      assert_eq!(config.env_files[3].as_str(), ".env.production");
 25  }
 26  
 27  #[test]
 28  fn test_workspace_config_ignores_default() {
 29      let config = WorkspaceConfig::default();
 30      assert!(config.ignores.contains(&"**/node_modules/**".into()));
 31      assert!(config.ignores.contains(&"**/.git/**".into()));
 32      assert!(config.ignores.contains(&"**/target/**".into()));
 33      assert!(config.ignores.contains(&"**/dist/**".into()));
 34      assert!(config.ignores.contains(&"**/build/**".into()));
 35  }
 36  
 37  #[test]
 38  fn test_resolution_config_default() {
 39      let config = ResolutionConfig::default();
 40      assert_eq!(config.precedence.len(), 2);
 41      assert_eq!(config.precedence[0], SourcePrecedence::Shell);
 42      assert_eq!(config.precedence[1], SourcePrecedence::File);
 43      assert!(config.type_check);
 44  }
 45  
 46  #[test]
 47  fn test_resolution_config_file_merge_default() {
 48      let config = ResolutionConfig::default();
 49      assert_eq!(config.files.mode, FileMergeMode::Merge);
 50      assert_eq!(config.files.order.len(), 2);
 51      assert_eq!(config.files.order[0].as_str(), ".env");
 52      assert_eq!(config.files.order[1].as_str(), ".env.local");
 53  }
 54  
 55  #[test]
 56  fn test_interpolation_config_default() {
 57      let config = InterpolationConfig::default();
 58      assert!(config.enabled);
 59      assert_eq!(config.max_depth, 64);
 60  }
 61  
 62  #[test]
 63  fn test_interpolation_features_default() {
 64      let config = InterpolationConfig::default();
 65      assert!(config.features.defaults);
 66      assert!(config.features.alternates);
 67      assert!(config.features.recursion);
 68      assert!(!config.features.commands);
 69  }
 70  
 71  #[test]
 72  fn test_cache_config_default() {
 73      let config = CacheConfig::default();
 74      assert!(config.enabled);
 75      assert_eq!(config.hot_cache_size, 1000);
 76      assert_eq!(config.ttl, std::time::Duration::from_secs(300));
 77  }
 78  
 79  #[test]
 80  fn test_abundantis_config_default() {
 81      let config = AbundantisConfig::default();
 82      assert_eq!(config.workspace.provider, None);
 83      assert!(config.interpolation.enabled);
 84      assert!(config.cache.enabled);
 85  }
 86  
 87  #[test]
 88  fn test_monorepo_provider_types() {
 89      let providers = [
 90          MonorepoProviderType::Turbo,
 91          MonorepoProviderType::Nx,
 92          MonorepoProviderType::Lerna,
 93          MonorepoProviderType::Pnpm,
 94          MonorepoProviderType::Npm,
 95          MonorepoProviderType::Yarn,
 96          MonorepoProviderType::Cargo,
 97          MonorepoProviderType::Custom,
 98      ];
 99  
100      assert_eq!(providers.len(), 8);
101  }
102  
103  #[test]
104  fn test_source_precedence_types() {
105      let precedences = [
106          SourcePrecedence::Shell,
107          SourcePrecedence::File,
108          SourcePrecedence::Remote,
109      ];
110  
111      assert_eq!(precedences.len(), 3);
112  }
113  
114  #[test]
115  fn test_file_merge_mode_types() {
116      assert_eq!(FileMergeMode::Merge, FileMergeMode::Merge);
117      assert_eq!(FileMergeMode::Override, FileMergeMode::Override);
118      assert_ne!(FileMergeMode::Merge, FileMergeMode::Override);
119  }
120  
121  #[test]
122  fn test_workspace_config_with_provider() {
123      let config = WorkspaceConfig {
124          provider: Some(MonorepoProviderType::Turbo),
125          ..Default::default()
126      };
127  
128      assert_eq!(config.provider, Some(MonorepoProviderType::Turbo));
129  }
130  
131  #[test]
132  fn test_workspace_config_with_cascading() {
133      let config = WorkspaceConfig {
134          cascading: true,
135          ..Default::default()
136      };
137  
138      assert!(config.cascading);
139  }
140  
141  #[test]
142  fn test_workspace_config_with_custom_roots() {
143      let config = WorkspaceConfig {
144          roots: vec!["apps/*".into(), "packages/*".into()],
145          ..Default::default()
146      };
147  
148      assert_eq!(config.roots.len(), 2);
149      assert_eq!(config.roots[0].as_str(), "apps/*");
150      assert_eq!(config.roots[1].as_str(), "packages/*");
151  }
152  
153  #[test]
154  fn test_workspace_config_with_env_files() {
155      let config = WorkspaceConfig {
156          env_files: vec![".env".into(), ".env.production".into()],
157          ..Default::default()
158      };
159  
160      assert_eq!(config.env_files.len(), 2);
161  }
162  
163  #[test]
164  fn test_resolution_config_with_precedence() {
165      let config = ResolutionConfig {
166          precedence: vec![SourcePrecedence::File, SourcePrecedence::Shell],
167          ..Default::default()
168      };
169  
170      assert_eq!(config.precedence.len(), 2);
171      assert_eq!(config.precedence[0], SourcePrecedence::File);
172      assert_eq!(config.precedence[1], SourcePrecedence::Shell);
173  }
174  
175  #[test]
176  fn test_resolution_config_without_type_check() {
177      let config = ResolutionConfig {
178          type_check: false,
179          ..Default::default()
180      };
181  
182      assert!(!config.type_check);
183  }
184  
185  #[test]
186  fn test_file_resolution_config_with_mode() {
187      let config = FileResolutionConfig {
188          mode: FileMergeMode::Override,
189          ..Default::default()
190      };
191  
192      assert_eq!(config.mode, FileMergeMode::Override);
193  }
194  
195  #[test]
196  fn test_file_resolution_config_with_order() {
197      let config = FileResolutionConfig {
198          order: vec![".env.production".into(), ".env".into()],
199          ..Default::default()
200      };
201  
202      assert_eq!(config.order.len(), 2);
203      assert_eq!(config.order[0].as_str(), ".env.production");
204  }
205  
206  #[test]
207  fn test_interpolation_config_disabled() {
208      let config = InterpolationConfig {
209          enabled: false,
210          ..Default::default()
211      };
212  
213      assert!(!config.enabled);
214  }
215  
216  #[test]
217  fn test_interpolation_config_with_max_depth() {
218      let config = InterpolationConfig {
219          max_depth: 100,
220          ..Default::default()
221      };
222  
223      assert_eq!(config.max_depth, 100);
224  }
225  
226  #[test]
227  fn test_interpolation_features_with_commands() {
228      let config = InterpolationFeatures {
229          commands: true,
230          ..Default::default()
231      };
232  
233      assert!(config.commands);
234  }
235  
236  #[test]
237  fn test_interpolation_features_all_enabled() {
238      let config = InterpolationFeatures {
239          defaults: true,
240          alternates: true,
241          recursion: true,
242          commands: true,
243      };
244  
245      assert!(config.defaults);
246      assert!(config.alternates);
247      assert!(config.recursion);
248      assert!(config.commands);
249  }
250  
251  #[test]
252  fn test_cache_config_disabled() {
253      let config = CacheConfig {
254          enabled: false,
255          ..Default::default()
256      };
257  
258      assert!(!config.enabled);
259  }
260  
261  #[test]
262  fn test_cache_config_with_hot_cache_size() {
263      let config = CacheConfig {
264          hot_cache_size: 500,
265          ..Default::default()
266      };
267  
268      assert_eq!(config.hot_cache_size, 500);
269  }
270  
271  #[test]
272  fn test_cache_config_with_ttl() {
273      let config = CacheConfig {
274          ttl: std::time::Duration::from_secs(600),
275          ..Default::default()
276      };
277  
278      assert_eq!(config.ttl, std::time::Duration::from_secs(600));
279  }
280  
281  #[test]
282  fn test_source_precedence_equality() {
283      assert_eq!(SourcePrecedence::Shell, SourcePrecedence::Shell);
284      assert_eq!(SourcePrecedence::File, SourcePrecedence::File);
285      assert_eq!(SourcePrecedence::Remote, SourcePrecedence::Remote);
286  
287      assert_ne!(SourcePrecedence::Shell, SourcePrecedence::File);
288      assert_ne!(SourcePrecedence::File, SourcePrecedence::Remote);
289  }
290  
291  #[test]
292  fn test_monorepo_provider_type_hash() {
293      use std::collections::HashSet;
294      let mut set = HashSet::new();
295      set.insert(MonorepoProviderType::Turbo);
296      set.insert(MonorepoProviderType::Nx);
297      set.insert(MonorepoProviderType::Lerna);
298      set.insert(MonorepoProviderType::Pnpm);
299      set.insert(MonorepoProviderType::Npm);
300      set.insert(MonorepoProviderType::Yarn);
301      set.insert(MonorepoProviderType::Cargo);
302      set.insert(MonorepoProviderType::Custom);
303  
304      assert_eq!(set.len(), 8);
305  }
306  
307  #[test]
308  fn test_config_clone() {
309      let config = AbundantisConfig::default();
310      let cloned = config.clone();
311  
312      assert_eq!(config.workspace.provider, cloned.workspace.provider);
313      assert_eq!(
314          config.interpolation.max_depth,
315          cloned.interpolation.max_depth
316      );
317  }
318  
319  #[test]
320  fn test_workspace_config_with_multiple_roots() {
321      let config = WorkspaceConfig {
322          roots: vec!["apps/*".into(), "packages/*".into(), "services/*".into()],
323          ..Default::default()
324      };
325  
326      assert_eq!(config.roots.len(), 3);
327  }
328  
329  #[test]
330  fn test_resolution_config_with_multiple_precedence() {
331      let config = ResolutionConfig {
332          precedence: vec![
333              SourcePrecedence::Remote,
334              SourcePrecedence::Shell,
335              SourcePrecedence::File,
336          ],
337          ..Default::default()
338      };
339  
340      assert_eq!(config.precedence.len(), 3);
341      assert_eq!(config.precedence[0], SourcePrecedence::Remote);
342  }
343  
344  #[test]
345  fn test_interpolation_config_zero_max_depth() {
346      let config = InterpolationConfig {
347          max_depth: 0,
348          ..Default::default()
349      };
350  
351      assert_eq!(config.max_depth, 0);
352  }
353  
354  #[test]
355  fn test_cache_config_zero_ttl() {
356      let config = CacheConfig {
357          ttl: std::time::Duration::from_secs(0),
358          ..Default::default()
359      };
360  
361      assert_eq!(config.ttl, std::time::Duration::ZERO);
362  }
363  
364  #[test]
365  fn test_interpolation_features_all_disabled() {
366      let config = InterpolationFeatures {
367          defaults: false,
368          alternates: false,
369          recursion: false,
370          commands: false,
371      };
372  
373      assert!(!config.defaults);
374      assert!(!config.alternates);
375      assert!(!config.recursion);
376      assert!(!config.commands);
377  }
378  
379  #[test]
380  fn test_file_resolution_config_multiple_order() {
381      let config = FileResolutionConfig {
382          order: vec![
383              ".env.production".into(),
384              ".env.staging".into(),
385              ".env.development".into(),
386              ".env.local".into(),
387              ".env".into(),
388          ],
389          ..Default::default()
390      };
391  
392      assert_eq!(config.order.len(), 5);
393  }
394  
395  #[test]
396  fn test_cache_config_large_hot_cache() {
397      let config = CacheConfig {
398          hot_cache_size: 10000,
399          ..Default::default()
400      };
401  
402      assert_eq!(config.hot_cache_size, 10000);
403  }
404  
405  #[test]
406  fn test_workspace_config_with_ignores() {
407      let config = WorkspaceConfig {
408          ignores: vec![
409              "**/node_modules/**".into(),
410              "**/.next/**".into(),
411              "**/dist/**".into(),
412          ],
413          ..Default::default()
414      };
415  
416      assert_eq!(config.ignores.len(), 3);
417  }
418  
419  #[test]
420  fn test_source_precedence_copy() {
421      let p1 = SourcePrecedence::Shell;
422      let p2 = p1;
423      assert_eq!(p1, p2);
424  }
425  
426  #[test]
427  fn test_monorepo_provider_copy() {
428      let p1 = MonorepoProviderType::Turbo;
429      let p2 = p1;
430      assert_eq!(p1, p2);
431  }
432  
433  #[test]
434  fn test_file_merge_mode_copy() {
435      let m1 = FileMergeMode::Merge;
436      let m2 = m1;
437      assert_eq!(m1, m2);
438  }
439  
440  #[test]
441  fn test_config_default_all_modules() {
442      let config = AbundantisConfig::default();
443      assert!(!config.workspace.env_files.is_empty());
444      assert!(!config.workspace.ignores.is_empty());
445      assert!(!config.resolution.precedence.is_empty());
446      assert!(config.interpolation.enabled);
447      assert!(config.cache.enabled);
448  }