1  use abundantis::workspace::{PackageInfo, WorkspaceContext};
  2  use std::path::PathBuf;
  3  
  4  #[test]
  5  fn test_package_info_creation() {
  6      let info = PackageInfo {
  7          root: PathBuf::from("/path/to/package"),
  8          name: Some("my-package".into()),
  9          relative_path: "packages/my-package".into(),
 10      };
 11  
 12      assert_eq!(info.root, PathBuf::from("/path/to/package"));
 13      assert_eq!(info.name.as_deref(), Some("my-package"));
 14      assert_eq!(info.relative_path.as_str(), "packages/my-package");
 15  }
 16  
 17  #[test]
 18  fn test_package_info_without_name() {
 19      let info = PackageInfo {
 20          root: PathBuf::from("/path/to/package"),
 21          name: None,
 22          relative_path: ".".into(),
 23      };
 24  
 25      assert_eq!(info.name, None);
 26      assert_eq!(info.relative_path.as_str(), ".");
 27  }
 28  
 29  #[test]
 30  fn test_workspace_context_creation() {
 31      let context = WorkspaceContext {
 32          workspace_root: PathBuf::from("/workspace"),
 33          package_root: PathBuf::from("/workspace/packages/app"),
 34          package_name: Some("app".into()),
 35          env_files: vec![
 36              PathBuf::from("/workspace/.env"),
 37              PathBuf::from("/workspace/packages/app/.env"),
 38          ],
 39      };
 40  
 41      assert_eq!(context.workspace_root, PathBuf::from("/workspace"));
 42      assert_eq!(
 43          context.package_root,
 44          PathBuf::from("/workspace/packages/app")
 45      );
 46      assert_eq!(context.package_name.as_deref(), Some("app"));
 47      assert_eq!(context.env_files.len(), 2);
 48  }
 49  
 50  #[test]
 51  fn test_workspace_context_without_package_name() {
 52      let context = WorkspaceContext {
 53          workspace_root: PathBuf::from("/workspace"),
 54          package_root: PathBuf::from("/workspace"),
 55          package_name: None,
 56          env_files: vec![PathBuf::from("/workspace/.env")],
 57      };
 58  
 59      assert_eq!(context.package_name, None);
 60      assert_eq!(context.env_files.len(), 1);
 61  }
 62  
 63  #[test]
 64  fn test_workspace_context_single_env_file() {
 65      let context = WorkspaceContext {
 66          workspace_root: PathBuf::from("/workspace"),
 67          package_root: PathBuf::from("/workspace"),
 68          package_name: None,
 69          env_files: vec![PathBuf::from("/workspace/.env")],
 70      };
 71  
 72      assert_eq!(context.env_files.len(), 1);
 73      assert_eq!(context.env_files[0], PathBuf::from("/workspace/.env"));
 74  }
 75  
 76  #[test]
 77  fn test_workspace_context_multiple_env_files() {
 78      let context = WorkspaceContext {
 79          workspace_root: PathBuf::from("/workspace"),
 80          package_root: PathBuf::from("/workspace/packages/app"),
 81          package_name: Some("app".into()),
 82          env_files: vec![
 83              PathBuf::from("/workspace/.env"),
 84              PathBuf::from("/workspace/.env.local"),
 85              PathBuf::from("/workspace/packages/app/.env"),
 86              PathBuf::from("/workspace/packages/app/.env.development"),
 87          ],
 88      };
 89  
 90      assert_eq!(context.env_files.len(), 4);
 91  }
 92  
 93  #[test]
 94  fn test_package_info_clone() {
 95      let info1 = PackageInfo {
 96          root: PathBuf::from("/path/to/package"),
 97          name: Some("my-package".into()),
 98          relative_path: "packages/my-package".into(),
 99      };
100  
101      let info2 = info1.clone();
102  
103      assert_eq!(info1.root, info2.root);
104      assert_eq!(info1.name, info2.name);
105      assert_eq!(info1.relative_path, info2.relative_path);
106  }
107  
108  #[test]
109  fn test_workspace_context_clone() {
110      let context1 = WorkspaceContext {
111          workspace_root: PathBuf::from("/workspace"),
112          package_root: PathBuf::from("/workspace/packages/app"),
113          package_name: Some("app".into()),
114          env_files: vec![PathBuf::from("/workspace/.env")],
115      };
116  
117      let context2 = context1.clone();
118  
119      assert_eq!(context1.workspace_root, context2.workspace_root);
120      assert_eq!(context1.package_root, context2.package_root);
121      assert_eq!(context1.package_name, context2.package_name);
122      assert_eq!(context1.env_files, context2.env_files);
123  }
124  
125  #[test]
126  fn test_package_info_with_complex_path() {
127      let info = PackageInfo {
128          root: PathBuf::from("/very/deep/nested/path/to/package"),
129          name: Some("nested-package".into()),
130          relative_path: "deep/nested/path/to/package".into(),
131      };
132  
133      assert!(info.root.to_str().unwrap().len() > 20);
134      assert_eq!(info.name.as_deref(), Some("nested-package"));
135  }
136  
137  #[test]
138  fn test_workspace_context_cascading_scenario() {
139      let context = WorkspaceContext {
140          workspace_root: PathBuf::from("/workspace"),
141          package_root: PathBuf::from("/workspace/packages/app"),
142          package_name: Some("app".into()),
143          env_files: vec![
144              PathBuf::from("/workspace/.env"),
145              PathBuf::from("/workspace/.env.production"),
146              PathBuf::from("/workspace/packages/app/.env"),
147              PathBuf::from("/workspace/packages/app/.env.local"),
148          ],
149      };
150  
151      assert!(context.env_files[0]
152          .to_str()
153          .unwrap()
154          .contains("/workspace/.env"));
155      assert!(context.env_files[2]
156          .to_str()
157          .unwrap()
158          .contains("packages/app"));
159  }
160  
161  #[test]
162  fn test_workspace_context_monorepo_package() {
163      let context = WorkspaceContext {
164          workspace_root: PathBuf::from("/monorepo"),
165          package_root: PathBuf::from("/monorepo/apps/web"),
166          package_name: Some("web".into()),
167          env_files: vec![
168              PathBuf::from("/monorepo/.env"),
169              PathBuf::from("/monorepo/apps/web/.env"),
170          ],
171      };
172  
173      assert_eq!(context.package_name.as_deref(), Some("web"));
174      assert_eq!(context.workspace_root, PathBuf::from("/monorepo"));
175      assert_eq!(context.package_root, PathBuf::from("/monorepo/apps/web"));
176  }
177  
178  #[test]
179  fn test_package_info_equality() {
180      let info1 = PackageInfo {
181          root: PathBuf::from("/path"),
182          name: Some("pkg".into()),
183          relative_path: ".".into(),
184      };
185  
186      let info2 = PackageInfo {
187          root: PathBuf::from("/path"),
188          name: Some("pkg".into()),
189          relative_path: ".".into(),
190      };
191  
192      assert_eq!(info1.root, info2.root);
193      assert_eq!(info1.name, info2.name);
194      assert_eq!(info1.relative_path, info2.relative_path);
195  }
196  
197  #[test]
198  fn test_package_info_inequality() {
199      let info1 = PackageInfo {
200          root: PathBuf::from("/path1"),
201          name: Some("pkg1".into()),
202          relative_path: ".".into(),
203      };
204  
205      let info2 = PackageInfo {
206          root: PathBuf::from("/path2"),
207          name: Some("pkg2".into()),
208          relative_path: ".".into(),
209      };
210  
211      assert_ne!(info1.root, info2.root);
212      assert_ne!(info1.name, info2.name);
213  }
214  
215  #[test]
216  fn test_workspace_context_equality() {
217      let context1 = WorkspaceContext {
218          workspace_root: PathBuf::from("/workspace"),
219          package_root: PathBuf::from("/workspace/pkg"),
220          package_name: Some("pkg".into()),
221          env_files: vec![PathBuf::from("/workspace/.env")],
222      };
223  
224      let context2 = WorkspaceContext {
225          workspace_root: PathBuf::from("/workspace"),
226          package_root: PathBuf::from("/workspace/pkg"),
227          package_name: Some("pkg".into()),
228          env_files: vec![PathBuf::from("/workspace/.env")],
229      };
230  
231      assert_eq!(context1.workspace_root, context2.workspace_root);
232      assert_eq!(context1.package_root, context2.package_root);
233      assert_eq!(context1.package_name, context2.package_name);
234      assert_eq!(context1.env_files, context2.env_files);
235  }
236  
237  #[test]
238  fn test_workspace_context_inequality() {
239      let context1 = WorkspaceContext {
240          workspace_root: PathBuf::from("/workspace1"),
241          package_root: PathBuf::from("/workspace1/pkg"),
242          package_name: Some("pkg1".into()),
243          env_files: vec![PathBuf::from("/workspace1/.env")],
244      };
245  
246      let context2 = WorkspaceContext {
247          workspace_root: PathBuf::from("/workspace2"),
248          package_root: PathBuf::from("/workspace2/pkg"),
249          package_name: Some("pkg2".into()),
250          env_files: vec![PathBuf::from("/workspace2/.env")],
251      };
252  
253      assert_ne!(context1.workspace_root, context2.workspace_root);
254      assert_ne!(context1.package_root, context2.package_root);
255  }
256  
257  #[test]
258  fn test_package_info_debug_format() {
259      let info = PackageInfo {
260          root: PathBuf::from("/path/to/pkg"),
261          name: Some("test-pkg".into()),
262          relative_path: "to/pkg".into(),
263      };
264  
265      let debug_str = format!("{:?}", info);
266      assert!(debug_str.contains("test-pkg"));
267      assert!(debug_str.contains("/path/to/pkg"));
268  }
269  
270  #[test]
271  fn test_workspace_context_debug_format() {
272      let context = WorkspaceContext {
273          workspace_root: PathBuf::from("/workspace"),
274          package_root: PathBuf::from("/workspace/pkg"),
275          package_name: Some("test".into()),
276          env_files: vec![PathBuf::from("/workspace/.env")],
277      };
278  
279      let debug_str = format!("{:?}", context);
280      assert!(debug_str.contains("workspace_root"));
281      assert!(debug_str.contains("package_root"));
282      assert!(debug_str.contains("test"));
283  }
284  
285  #[test]
286  fn test_package_info_with_special_name() {
287      let info = PackageInfo {
288          root: PathBuf::from("/path/pkg-with-dashes"),
289          name: Some("@scope/package-name".into()),
290          relative_path: "pkg-with-dashes".into(),
291      };
292  
293      assert_eq!(info.name.as_deref(), Some("@scope/package-name"));
294  }
295  
296  #[test]
297  fn test_workspace_context_empty_env_files() {
298      let context = WorkspaceContext {
299          workspace_root: PathBuf::from("/workspace"),
300          package_root: PathBuf::from("/workspace/pkg"),
301          package_name: Some("pkg".into()),
302          env_files: vec![],
303      };
304  
305      assert_eq!(context.env_files.len(), 0);
306  }
307  
308  #[test]
309  fn test_workspace_context_no_cascading() {
310      let context = WorkspaceContext {
311          workspace_root: PathBuf::from("/workspace"),
312          package_root: PathBuf::from("/workspace/pkg"),
313          package_name: Some("pkg".into()),
314          env_files: vec![
315              PathBuf::from("/workspace/pkg/.env"),
316              PathBuf::from("/workspace/pkg/.env.local"),
317          ],
318      };
319  
320      assert_eq!(context.env_files.len(), 2);
321      assert!(context.env_files[0].to_str().unwrap().contains("pkg/.env"));
322      assert!(!context.env_files[0]
323          .to_str()
324          .unwrap()
325          .contains("/workspace/.env"));
326  }
327  
328  #[test]
329  fn test_package_info_root_ends_with_slash() {
330      let info = PackageInfo {
331          root: PathBuf::from("/path/to/package/"),
332          name: Some("pkg".into()),
333          relative_path: "to/package".into(),
334      };
335  
336      assert!(info.root.to_str().unwrap().ends_with('/'));
337  }
338  
339  #[test]
340  fn test_workspace_context_package_root_equals_workspace() {
341      let context = WorkspaceContext {
342          workspace_root: PathBuf::from("/workspace"),
343          package_root: PathBuf::from("/workspace"),
344          package_name: None,
345          env_files: vec![PathBuf::from("/workspace/.env")],
346      };
347  
348      assert_eq!(context.workspace_root, context.package_root);
349      assert_eq!(context.package_name, None);
350  }
351  
352  #[test]
353  fn test_package_info_relative_path_dots() {
354      let info = PackageInfo {
355          root: PathBuf::from("/path/../../package"),
356          name: Some("pkg".into()),
357          relative_path: "../../package".into(),
358      };
359  
360      assert_eq!(info.relative_path.as_str(), "../../package");
361  }
362  
363  #[test]
364  fn test_workspace_context_many_env_files() {
365      let mut env_files = Vec::new();
366      for i in 0..10 {
367          env_files.push(PathBuf::from(format!("/workspace/pkg/.env.{}", i)));
368      }
369  
370      let context = WorkspaceContext {
371          workspace_root: PathBuf::from("/workspace"),
372          package_root: PathBuf::from("/workspace/pkg"),
373          package_name: Some("pkg".into()),
374          env_files,
375      };
376  
377      assert_eq!(context.env_files.len(), 10);
378  }
379  
380  #[test]
381  fn test_package_info_with_windows_path() {
382      #[cfg(windows)]
383      let info = PackageInfo {
384          root: PathBuf::from(r"C:\workspace\package"),
385          name: Some("pkg".into()),
386          relative_path: "package".into(),
387      };
388  
389      #[cfg(windows)]
390      {
391          assert_eq!(info.root, PathBuf::from(r"C:\workspace\package"));
392      }
393  }
394  
395  #[test]
396  fn test_package_info_empty_name() {
397      let info = PackageInfo {
398          root: PathBuf::from("/path/pkg"),
399          name: Some("".into()),
400          relative_path: "pkg".into(),
401      };
402  
403      assert_eq!(info.name.as_deref(), Some(""));
404  }