Debian Codegraph @

test/fpm_test/test_package_dependencies.f90

raw
1 !> Define tests for the `fpm_dependency` module
2 module test_package_dependencies
3 use fpm_filesystem, only: get_temp_filename
4 use testsuite, only: new_unittest, unittest_t, error_t, test_failed
5 use fpm_filesystem, only: is_dir, join_path, filewrite, mkdir, os_delete_dir, exists
6 use fpm_environment, only: os_is_unix
7 use fpm_os, only: get_current_directory
8 use fpm_dependency
9 use fpm_manifest_dependency
10 use fpm_manifest_metapackages, only: metapackage_config_t
11 use fpm_manifest, only: package_config_t, get_package_data
12 use tomlf, only: toml_table, new_table
13 use fpm_toml, only: toml_key, add_table, set_value, get_value
14 use fpm_settings, only: fpm_global_settings, get_registry_settings, get_global_settings
15 use fpm_downloader, only: downloader_t
16 use fpm_versioning, only: version_t
17 use jonquil, only: json_object, json_value, json_loads, cast_to_object
18
19 implicit none
20 private
21
22 public :: collect_package_dependencies
23
24 character(*), parameter :: tmp_folder = 'tmp'
25 character(*), parameter :: config_file_name = 'config.toml'
26
27 type, extends(dependency_tree_t) :: mock_dependency_tree_t
28 contains
29 procedure, private :: resolve_dependency => resolve_dependency_once
30 end type mock_dependency_tree_t
31
32 type, extends(downloader_t) :: mock_downloader_t
33 contains
34 procedure, nopass :: get_pkg_data, get_file, unpack => unpack_mock_package
35 end type mock_downloader_t
36
37 contains
38
39 !> Collect all exported unit tests
40 subroutine collect_package_dependencies(testsuite)
41
42 !> Collection of tests
43 type(unittest_t), allocatable, intent(out) :: testsuite(:)
44
45 testsuite = [ &
46 & new_unittest("cache-load-dump", test_cache_load_dump), &
47 & new_unittest("cache-dump-load", test_cache_dump_load), &
48 & new_unittest("status-after-load", test_status), &
49 & new_unittest("add-dependencies", test_add_dependencies), &
50 & new_unittest("update-dependencies", test_update_dependencies), &
51 & new_unittest("metapackage-override", test_metapackage_override), &
52 & new_unittest("do-not-update-dependencies", test_non_updated_dependencies), &
53 & new_unittest("registry-dir-not-found", registry_dir_not_found, should_fail=.true.), &
54 & new_unittest("no-versions-in-registry", no_versions_in_registry, should_fail=.true.), &
55 & new_unittest("local-registry-specified-version-not-found", local_registry_specified_version_not_found, should_fail=.true.), &
56 & new_unittest("local-registry-specified-no-manifest", local_registry_specified_no_manifest, should_fail=.true.), &
57 & new_unittest("local-registry-specified-has-manifest", local_registry_specified_has_manifest), &
58 & new_unittest("local-registry-specified-not-a-dir", local_registry_specified_not_a_dir, should_fail=.true.), &
59 & new_unittest("local-registry-unspecified-no-versions", local_registry_unspecified_no_versions, should_fail=.true.), &
60 & new_unittest("local-registry-unspecified-no-manifest", local_registry_unspecified_no_manifest, should_fail=.true.), &
61 & new_unittest("local-registry-unspecified-has-manifest", local_registry_unspecified_has_manifest), &
62 & new_unittest("cache-specified-version-found", cache_specified_version_found), &
63 & new_unittest("specified-version-not-found-in-cache", registry_specified_version_not_found_in_cache), &
64 & new_unittest("registry-specified-version-not-exists", registry_specified_version_not_exists, should_fail=.true.), &
65 & new_unittest("registry-specified-version-other-versions-exist", registry_specified_version_other_versions_exist), &
66 & new_unittest("registry-unspecified-version", registry_unspecified_version), &
67 & new_unittest("registry-unspecified-version_exists_in_cache", registry_unspecified_version_exists_in_cache), &
68 & new_unittest("pkg-data-no-code", pkg_data_no_code, should_fail=.true.), &
69 & new_unittest("pkg-data-corrupt-code", pkg_data_corrupt_code, should_fail=.true.), &
70 & new_unittest("pkg-data-missing-error-message", pkg_data_missing_error_msg, should_fail=.true.), &
71 & new_unittest("pkg-data-error-reading-message", pkg_data_error_reading_msg, should_fail=.true.), &
72 & new_unittest("pkg-data-error-has-message", pkg_data_error_has_msg, should_fail=.true.), &
73 & new_unittest("pkg-data-error-no-data", pkg_data_no_data, should_fail=.true.), &
74 & new_unittest("pkg-data-error-reading-data", pkg_data_error_reading_data, should_fail=.true.), &
75 & new_unittest("pkg-data-requested-version-wrong-key", pkg_data_requested_version_wrong_key, should_fail=.true.), &
76 & new_unittest("pkg-data-no-version-requested-wrong-key", pkg_data_no_version_requested_wrong_key, should_fail=.true.), &
77 & new_unittest("pkg-data-error-reading-latest-version", pkg_data_error_reading_latest_version, should_fail=.true.), &
78 & new_unittest("pkg-data-no-download-url", pkg_data_no_download_url, should_fail=.true.), &
79 & new_unittest("pkg-data-error-reading-donwload-url", pkg_data_error_reading_download_url, should_fail=.true.), &
80 & new_unittest("pkg-data-no-version", pkg_data_no_version, should_fail=.true.), &
81 & new_unittest("pkg-data-error-reading-version", pkg_data_error_reading_version, should_fail=.true.), &
82 & new_unittest("pkg-data-invalid-version", pkg_data_invalid_version, should_fail=.true.) &
83 & ]
84
85 end subroutine collect_package_dependencies
86
87 !> Round trip of the dependency cache from a dependency tree to a TOML document
88 !> to a dependency tree
89 subroutine test_cache_dump_load(error)
90
91 !> Error handling
92 type(error_t), allocatable, intent(out) :: error
93
94 type(dependency_tree_t) :: deps
95 type(dependency_config_t) :: dep
96 integer :: unit
97
98 call new_dependency_tree(deps)
99 call resize(deps%dep, 5)
100 deps%ndep = 3
101 dep%name = "dep1"
102 dep%path = "fpm-tmp1-dir"
103 call new_dependency_node(deps%dep(1), dep, proj_dir=dep%path)
104 dep%name = "dep2"
105 dep%path = "fpm-tmp2-dir"
106 call new_dependency_node(deps%dep(2), dep, proj_dir=dep%path)
107 dep%name = "dep3"
108 dep%path = "fpm-tmp3-dir"
109 call new_dependency_node(deps%dep(3), dep, proj_dir=dep%path)
110
111 open (newunit=unit, status='scratch')
112 call deps%dump_cache(unit, error)
113 if (.not. allocated(error)) then
114 rewind (unit)
115
116 call new_dependency_tree(deps)
117 call resize(deps%dep, 2)
118 call deps%load_cache(unit, error)
119 close (unit)
120 end if
121 if (allocated(error)) return
122
123 if (deps%ndep /= 3) then
124 call test_failed(error, "Expected three dependencies in loaded cache")
125 return
126 end if
127
128 end subroutine test_cache_dump_load
129
130 !> Round trip of the dependency cache from a TOML data structure to
131 !> a dependency tree to a TOML data structure
132 subroutine test_cache_load_dump(error)
133
134 !> Error handling
135 type(error_t), allocatable, intent(out) :: error
136
137 type(toml_table) :: table
138 type(toml_table), pointer :: ptr
139 type(toml_key), allocatable :: list(:)
140 type(dependency_tree_t) :: deps
141
142 table = toml_table()
143 call add_table(table, "dep1", ptr)
144 call set_value(ptr, "version", "1.1.0")
145 call set_value(ptr, "proj-dir", "fpm-tmp1-dir")
146 call add_table(table, "dep2", ptr)
147 call set_value(ptr, "version", "0.55.3")
148 call set_value(ptr, "proj-dir", "fpm-tmp2-dir")
149 call set_value(ptr, "git", "https://github.com/fortran-lang/dep2")
150 call add_table(table, "dep3", ptr)
151 call set_value(ptr, "version", "20.1.15")
152 call set_value(ptr, "proj-dir", "fpm-tmp3-dir")
153 call set_value(ptr, "git", "https://gitlab.com/fortran-lang/dep3")
154 call set_value(ptr, "rev", "c0ffee")
155 call add_table(table, "dep4", ptr)
156 call set_value(ptr, "proj-dir", "fpm-tmp4-dir")
157
158 call new_dependency_tree(deps)
159 call deps%load_cache(table, error)
160 if (allocated(error)) return
161
162 if (deps%ndep /= 4) then
163 call test_failed(error, "Expected four dependencies in loaded cache")
164 return
165 end if
166
167 call table%destroy
168 table = toml_table()
169
170 call deps%dump_cache(table, error)
171 if (allocated(error)) return
172
173 call table%get_keys(list)
174
175 if (size(list) /= 4) then
176 call test_failed(error, "Expected four dependencies in dumped cache")
177 return
178 end if
179
180 end subroutine test_cache_load_dump
181
182 subroutine test_status(error)
183
184 !> Error handling
185 type(error_t), allocatable, intent(out) :: error
186
187 type(toml_table) :: table
188 type(toml_table), pointer :: ptr
189 type(dependency_tree_t) :: deps
190
191 table = toml_table()
192 call add_table(table, "dep1", ptr)
193 call set_value(ptr, "version", "1.1.0")
194 call set_value(ptr, "proj-dir", "fpm-tmp1-dir")
195 call add_table(table, "dep2", ptr)
196 call set_value(ptr, "version", "0.55.3")
197 call set_value(ptr, "proj-dir", "fpm-tmp2-dir")
198 call set_value(ptr, "git", "https://github.com/fortran-lang/dep2")
199
200 call new_dependency_tree(deps)
201 call deps%load_cache(table, error)
202 if (allocated(error)) return
203
204 if (deps%finished()) then
205 call test_failed(error, "Newly initialized dependency tree cannot be reolved")
206 return
207 end if
208
209 end subroutine test_status
210
211 subroutine test_add_dependencies(error)
212
213 !> Error handling
214 type(error_t), allocatable, intent(out) :: error
215
216 type(toml_table) :: table
217 type(toml_table), pointer :: ptr
218 type(mock_dependency_tree_t) :: deps
219 type(dependency_config_t), allocatable :: nodes(:)
220
221 table = toml_table()
222 call add_table(table, "sub1", ptr)
223 call set_value(ptr, "path", "external")
224 call add_table(table, "lin2", ptr)
225 call set_value(ptr, "git", "https://github.com/fortran-lang/lin2")
226 call add_table(table, "pkg3", ptr)
227 call set_value(ptr, "git", "https://gitlab.com/fortran-lang/pkg3")
228 call set_value(ptr, "rev", "c0ffee")
229 call add_table(table, "proj4", ptr)
230 call set_value(ptr, "path", "vendor")
231
232 call new_dependencies(nodes, table, error=error)
233 if (allocated(error)) return
234
235 call new_dependencies(nodes, table, root='.', error=error)
236 if (allocated(error)) return
237
238 call new_dependency_tree(deps%dependency_tree_t)
239 call deps%add(nodes, error)
240 if (allocated(error)) return
241
242 if (deps%finished()) then
243 call test_failed(error, "Newly added nodes cannot be already resolved")
244 return
245 end if
246
247 if (deps%ndep /= 4) then
248 call test_failed(error, "Expected for dependencies in tree")
249 return
250 end if
251
252 ! Do not use polymorphic version due to Ifort issue
253 call resolve_dependencies(deps, ".", error)
254 if (allocated(error)) return
255
256 if (.not. deps%finished()) then
257 call test_failed(error, "Mocked dependency tree must resolve in one step")
258 return
259 end if
260
261 end subroutine test_add_dependencies
262
263 subroutine test_non_updated_dependencies(error)
264
265 !> Error handling
266 type(error_t), allocatable, intent(out) :: error
267
268 type(toml_table) :: cache, manifest
269 type(toml_table), pointer :: ptr
270 type(toml_key), allocatable :: list(:)
271 type(dependency_tree_t) :: cached, manifest_deps
272 integer :: ii
273
274 ! Create a dummy cache
275 cache = toml_table()
276 call add_table(cache, "dep1", ptr)
277 call set_value(ptr, "version", "1.1.0")
278 call set_value(ptr, "proj-dir", "fpm-tmp1-dir")
279 call add_table(cache, "dep2", ptr)
280 call set_value(ptr, "git", "https://gitlab.com/fortran-lang/lin2")
281 call set_value(ptr, "rev", "c0ffee")
282 call set_value(ptr, "proj-dir", "fpm-tmp1-dir")
283 call add_table(cache, "dep3", ptr)
284 call set_value(ptr, "git", "https://gitlab.com/fortran-lang/pkg3")
285 call set_value(ptr, "rev", "t4a")
286 call set_value(ptr, "proj-dir", "fpm-tmp1-dir")
287 call add_table(cache, "dep4", ptr)
288 call set_value(ptr, "version", "1.0.0")
289 call set_value(ptr, "proj-dir", "fpm-tmp1-dir")
290
291 ! Load into a dependency tree
292 call new_dependency_tree(cached)
293 call cached%load_cache(cache, error)
294 if (allocated(error)) return
295 ! Mark all dependencies as "cached"
296 do ii=1,cached%ndep
297 cached%dep(ii)%cached = .true.
298 end do
299 call cache%destroy()
300
301 ! Create a dummy manifest, with different version
302 manifest = toml_table()
303 call add_table(manifest, "dep1", ptr)
304 call set_value(ptr, "version", "1.1.1")
305 call set_value(ptr, "proj-dir", "fpm-tmp1-dir")
306 call add_table(manifest, "dep2", ptr)
307 call set_value(ptr, "git", "https://gitlab.com/fortran-lang/lin4")
308 call set_value(ptr, "rev", "c0ffee")
309 call set_value(ptr, "proj-dir", "fpm-tmp1-dir")
310 call add_table(manifest, "dep3", ptr)
311 call set_value(ptr, "git", "https://gitlab.com/fortran-lang/pkg3")
312 call set_value(ptr, "rev", "t4a")
313 call set_value(ptr, "proj-dir", "fpm-tmp1-dir")
314
315 ! Load dependencies from manifest
316 call new_dependency_tree(manifest_deps)
317 call manifest_deps%load_cache(manifest, error)
318 call manifest%destroy()
319 if (allocated(error)) return
320
321 ! Add cached dependencies afterwards; will flag those that need udpate
322 do ii=1,cached%ndep
323 cached%dep(ii)%cached = .true.
324 call manifest_deps%add(cached%dep(ii), error)
325 if (allocated(error)) return
326 end do
327
328 ! Test that dependencies 1-2 are flagged as "update"
329 if (.not. manifest_deps%dep(1)%update) then
330 call test_failed(error, "Updated dependency (different version) not detected")
331 return
332 end if
333 if (.not. manifest_deps%dep(2)%update) then
334 call test_failed(error, "Updated dependency (git address) not detected")
335 return
336 end if
337
338 ! Test that dependency 3 is flagged as "not update"
339 if (manifest_deps%dep(3)%update) then
340 call test_failed(error, "Updated dependency (git rev) detected, should not be")
341 return
342 end if
343
344 end subroutine test_non_updated_dependencies
345
346 subroutine test_update_dependencies(error)
347
348 !> Error handling
349 type(error_t), allocatable, intent(out) :: error
350
351 type(toml_table) :: cache, manifest
352 type(toml_table), pointer :: ptr
353 type(toml_key), allocatable :: list(:)
354 type(dependency_tree_t) :: cached, manifest_deps
355 integer :: ii
356
357 ! Create a dummy cache
358 cache = toml_table()
359 call add_table(cache, "dep1", ptr)
360 call set_value(ptr, "version", "1.1.0")
361 call set_value(ptr, "proj-dir", "fpm-tmp1-dir")
362 call add_table(cache, "dep2", ptr)
363 call set_value(ptr, "git", "https://gitlab.com/fortran-lang/lin2")
364 call set_value(ptr, "rev", "c0ffee")
365 call set_value(ptr, "proj-dir", "fpm-tmp1-dir")
366 call add_table(cache, "dep3", ptr)
367 call set_value(ptr, "git", "https://gitlab.com/fortran-lang/pkg3")
368 call set_value(ptr, "rev", "t4a")
369 call set_value(ptr, "proj-dir", "fpm-tmp1-dir")
370 call add_table(cache, "dep4", ptr)
371 call set_value(ptr, "version", "1.0.0")
372 call set_value(ptr, "proj-dir", "fpm-tmp1-dir")
373
374 ! Load into a dependency tree
375 call new_dependency_tree(cached)
376 call cached%load_cache(cache, error)
377 if (allocated(error)) return
378 ! Mark all dependencies as "cached"
379 do ii=1,cached%ndep
380 cached%dep(ii)%cached = .true.
381 end do
382 call cache%destroy()
383
384 ! Create a dummy manifest, with different version
385 manifest = toml_table()
386 call add_table(manifest, "dep1", ptr)
387 call set_value(ptr, "version", "1.1.1")
388 call set_value(ptr, "proj-dir", "fpm-tmp1-dir")
389 call add_table(manifest, "dep2", ptr)
390 call set_value(ptr, "git", "https://gitlab.com/fortran-lang/lin4")
391 call set_value(ptr, "rev", "c0ffee")
392 call set_value(ptr, "proj-dir", "fpm-tmp1-dir")
393 call add_table(manifest, "dep3", ptr)
394 call set_value(ptr, "git", "https://gitlab.com/fortran-lang/pkg3")
395 call set_value(ptr, "rev", "l4tte")
396 call set_value(ptr, "proj-dir", "fpm-tmp1-dir")
397
398 ! Load dependencies from manifest
399 call new_dependency_tree(manifest_deps)
400 call manifest_deps%load_cache(manifest, error)
401 call manifest%destroy()
402 if (allocated(error)) return
403
404 ! Add cached dependencies afterwards; will flag those that need udpate
405 do ii=1,cached%ndep
406 cached%dep(ii)%cached = .true.
407 call manifest_deps%add(cached%dep(ii), error)
408 if (allocated(error)) return
409 end do
410
411 ! Test that all dependencies are flagged as "update"
412 if (.not. manifest_deps%dep(1)%update) then
413 call test_failed(error, "Updated dependency (different version) not detected")
414 return
415 end if
416 if (.not. manifest_deps%dep(2)%update) then
417 call test_failed(error, "Updated dependency (git address) not detected")
418 return
419 end if
420 if (.not. manifest_deps%dep(3)%update) then
421 call test_failed(error, "Updated dependency (git rev) not detected")
422 return
423 end if
424
425 end subroutine test_update_dependencies
426
427
428 !> Test that a metapackage is overridden if a regular dependency is provided
429 subroutine test_metapackage_override(error)
430
431 !> Error handling
432 type(error_t), allocatable, intent(out) :: error
433
434 type(toml_table) :: manifest
435 type(toml_table), pointer :: ptr
436 type(dependency_config_t), allocatable :: deps(:)
437 type(metapackage_config_t) :: meta
438 logical :: found
439 integer :: i
440
441 ! Create a dummy manifest, with a standard git dependency for stdlib
442 manifest = toml_table()
443 call add_table(manifest, "stdlib", ptr)
444 call set_value(ptr, "git", "https://github.com/fortran-lang/stdlib")
445 call set_value(ptr, "branch", "stdlib-fpm")
446
447 ! Load dependencies from manifest
448 call new_dependencies(deps, manifest, meta=meta, error=error)
449 if (allocated(error)) return
450
451 ! Check that stdlib is in the regular dependency list
452 found = .false.
453 do i=1,size(deps)
454 if (deps(i)%name=="stdlib") found = .true.
455 end do
456
457 if (.not.found) then
458 call test_failed(error,"standard git-based dependency for stdlib not recognized")
459 return
460 end if
461 call manifest%destroy()
462
463
464 ! Create a dummy manifest, with a version-based metapackage dependency for stdlib
465 manifest = toml_table()
466 call set_value(manifest, "stdlib", "*")
467
468 ! Load dependencies from manifest
469 call new_dependencies(deps, manifest, meta=meta, error=error)
470 if (allocated(error)) return
471
472 ! Check that stdlib is in the metapackage config and not the standard dependencies
473 found = .false.
474 do i=1,size(deps)
475 if (deps(i)%name=="stdlib") found = .true.
476 end do
477
478 if (found) then
479 call test_failed(error,"metapackage dependency for stdlib should not be in the tree")
480 return
481 end if
482 call manifest%destroy()
483
484 if (.not.meta%stdlib%on) then
485 call test_failed(error,"metapackage dependency for stdlib should be in the metapackage config")
486 return
487 end if
488
489 end subroutine test_metapackage_override
490
491 !> Directories for namespace and package name not found in path registry.
492 subroutine registry_dir_not_found(error)
493 type(error_t), allocatable, intent(out) :: error
494
495 type(toml_table) :: table
496 type(dependency_node_t) :: node
497 type(fpm_global_settings) :: global_settings
498 character(len=:), allocatable :: target_dir
499 type(toml_table), pointer :: child
500
501 call new_table(table)
502 table%key = 'test-dep'
503 call set_value(table, 'namespace', 'test-org')
504
505 call new_dependency(node%dependency_config_t, table, error=error)
506 if (allocated(error)) return
507
508 call delete_tmp_folder
509 call mkdir(join_path(tmp_folder, 'cache')) ! Missing directories for namesapce and package name
510
511 call new_table(table)
512 call add_table(table, 'registry', child)
513 call set_value(child, 'path', 'cache')
514
515 call setup_global_settings(global_settings, error)
516 if (allocated(error)) then
517 call delete_tmp_folder; return
518 end if
519
520 call get_registry_settings(child, global_settings, error)
521 if (allocated(error)) then
522 call delete_tmp_folder; return
523 end if
524
525 call node%get_from_registry(target_dir, global_settings, error)
526 if (allocated(error)) then
527 call delete_tmp_folder; return
528 end if
529
530 call delete_tmp_folder
531
532 end subroutine registry_dir_not_found
533
534 !> No versions found in path registry.
535 subroutine no_versions_in_registry(error)
536 type(error_t), allocatable, intent(out) :: error
537
538 type(toml_table) :: table
539 type(dependency_node_t) :: node
540 type(fpm_global_settings) :: global_settings
541 character(len=:), allocatable :: target_dir
542 type(toml_table), pointer :: child
543
544 call new_table(table)
545 table%key = 'test-dep'
546 call set_value(table, 'namespace', 'test-org')
547
548 call new_dependency(node%dependency_config_t, table, error=error)
549 if (allocated(error)) return
550
551 call delete_tmp_folder
552 call mkdir(join_path(tmp_folder, 'cache', 'test-org', 'test-dep'))
553
554 call new_table(table)
555 call add_table(table, 'registry', child)
556 call set_value(child, 'path', 'cache')
557
558 call setup_global_settings(global_settings, error)
559 if (allocated(error)) then
560 call delete_tmp_folder; return
561 end if
562
563 call get_registry_settings(child, global_settings, error)
564 if (allocated(error)) then
565 call delete_tmp_folder; return
566 end if
567
568 call node%get_from_registry(target_dir, global_settings, error)
569 if (allocated(error)) then
570 call delete_tmp_folder; return
571 end if
572
573 call delete_tmp_folder
574
575 end subroutine no_versions_in_registry
576
577 !> Specific version not found in the local registry.
578 subroutine local_registry_specified_version_not_found(error)
579 type(error_t), allocatable, intent(out) :: error
580
581 type(toml_table) :: table
582 type(dependency_node_t) :: node
583 type(fpm_global_settings) :: global_settings
584 character(len=:), allocatable :: target_dir
585 type(toml_table), pointer :: child
586
587 call new_table(table)
588 table%key = 'test-dep'
589 call set_value(table, 'namespace', 'test-org')
590 call set_value(table, 'v', '0.1.0')
591
592 call new_dependency(node%dependency_config_t, table, error=error)
593 if (allocated(error)) return
594
595 call delete_tmp_folder
596 call mkdir(join_path(tmp_folder, 'cache', 'test-org', 'test-dep', '0.0.9'))
597 call mkdir(join_path(tmp_folder, 'cache', 'test-org', 'test-dep', '0.1.1'))
598
599 call new_table(table)
600 call add_table(table, 'registry', child)
601 call set_value(child, 'path', 'cache')
602
603 call setup_global_settings(global_settings, error)
604 if (allocated(error)) then
605 call delete_tmp_folder; return
606 end if
607
608 call get_registry_settings(child, global_settings, error)
609 if (allocated(error)) then
610 call delete_tmp_folder; return
611 end if
612
613 call node%get_from_registry(target_dir, global_settings, error)
614 if (allocated(error)) then
615 call delete_tmp_folder; return
616 end if
617
618 call delete_tmp_folder
619
620 end subroutine local_registry_specified_version_not_found
621
622 !> Target package in path registry does not contain manifest.
623 subroutine local_registry_specified_no_manifest(error)
624 type(error_t), allocatable, intent(out) :: error
625
626 type(toml_table) :: table
627 type(dependency_node_t) :: node
628 type(fpm_global_settings) :: global_settings
629 character(len=:), allocatable :: target_dir
630 type(toml_table), pointer :: child
631
632 call new_table(table)
633 table%key = 'test-dep'
634 call set_value(table, 'namespace', 'test-org')
635 call set_value(table, 'v', '0.1.0')
636
637 call new_dependency(node%dependency_config_t, table, error=error)
638 if (allocated(error)) return
639
640 call delete_tmp_folder
641 call mkdir(join_path(tmp_folder, 'cache', 'test-org', 'test-dep', '0.0.9'))
642 call mkdir(join_path(tmp_folder, 'cache', 'test-org', 'test-dep', '0.1.0'))
643 call mkdir(join_path(tmp_folder, 'cache', 'test-org', 'test-dep', '0.1.1'))
644
645 call new_table(table)
646 call add_table(table, 'registry', child)
647 call set_value(child, 'path', 'cache')
648
649 call setup_global_settings(global_settings, error)
650 if (allocated(error)) then
651 call delete_tmp_folder; return
652 end if
653
654 call get_registry_settings(child, global_settings, error)
655 if (allocated(error)) then
656 call delete_tmp_folder; return
657 end if
658
659 call node%get_from_registry(target_dir, global_settings, error)
660 if (allocated(error)) then
661 call delete_tmp_folder; return
662 end if
663
664 call delete_tmp_folder
665
666 end subroutine local_registry_specified_no_manifest
667
668 !> Target package in path registry contains manifest.
669 subroutine local_registry_specified_has_manifest(error)
670 type(error_t), allocatable, intent(out) :: error
671
672 type(toml_table) :: table
673 type(dependency_node_t) :: node
674 type(fpm_global_settings) :: global_settings
675 character(len=:), allocatable :: target_dir, cwd
676 type(toml_table), pointer :: child
677
678 call new_table(table)
679 table%key = 'test-dep'
680 call set_value(table, 'namespace', 'test-org')
681 call set_value(table, 'v', '0.1.0')
682
683 call new_dependency(node%dependency_config_t, table, error=error)
684 if (allocated(error)) return
685
686 call delete_tmp_folder
687 call mkdir(join_path(tmp_folder, 'cache', 'test-org', 'test-dep', '0.0.0'))
688 call mkdir(join_path(tmp_folder, 'cache', 'test-org', 'test-dep', '0.1.0'))
689 call filewrite(join_path(join_path(tmp_folder, 'cache', 'test-org', 'test-dep', '0.1.0'), 'fpm.toml'), [''])
690 call mkdir(join_path(tmp_folder, 'cache', 'test-org', 'test-dep', '0.2.0'))
691
692 call new_table(table)
693 call add_table(table, 'registry', child)
694 call set_value(child, 'path', 'cache')
695
696 call setup_global_settings(global_settings, error)
697 if (allocated(error)) then
698 call delete_tmp_folder; return
699 end if
700
701 call get_registry_settings(child, global_settings, error)
702 if (allocated(error)) then
703 call delete_tmp_folder; return
704 end if
705
706 call node%get_from_registry(target_dir, global_settings, error)
707 if (allocated(error)) then
708 call delete_tmp_folder; return
709 end if
710
711 call get_current_directory(cwd, error)
712 if (allocated(error)) then
713 call delete_tmp_folder; return
714 end if
715
716 if (target_dir /= join_path(cwd, join_path(tmp_folder, 'cache', 'test-org', 'test-dep', '0.1.0'))) then
717 call test_failed(error, 'target_dir not set correctly')
718 call delete_tmp_folder; return
719 end if
720
721 call delete_tmp_folder
722
723 end subroutine local_registry_specified_has_manifest
724
725 !> Target is a file, not a directory.
726 subroutine local_registry_specified_not_a_dir(error)
727 type(error_t), allocatable, intent(out) :: error
728
729 type(toml_table) :: table
730 type(dependency_node_t) :: node
731 type(fpm_global_settings) :: global_settings
732 character(len=:), allocatable :: target_dir
733 type(toml_table), pointer :: child
734
735 call new_table(table)
736 table%key = 'test-dep'
737 call set_value(table, 'namespace', 'test-org')
738
739 call new_dependency(node%dependency_config_t, table, error=error)
740 if (allocated(error)) return
741
742 call delete_tmp_folder
743 call mkdir(join_path(tmp_folder, 'cache', 'test-org', 'test-dep'))
744 call filewrite(join_path(tmp_folder, 'cache', 'test-org', 'test-dep', '0.1.0'), ['']) ! File, not directory
745
746 call new_table(table)
747 call add_table(table, 'registry', child)
748 call set_value(child, 'path', 'cache')
749
750 call setup_global_settings(global_settings, error)
751 if (allocated(error)) then
752 call delete_tmp_folder; return
753 end if
754
755 call get_registry_settings(child, global_settings, error)
756 if (allocated(error)) then
757 call delete_tmp_folder; return
758 end if
759
760 call node%get_from_registry(target_dir, global_settings, error)
761 if (allocated(error)) then
762 call delete_tmp_folder; return
763 end if
764
765 call delete_tmp_folder
766
767 end subroutine local_registry_specified_not_a_dir
768
769 !> Try fetching the latest version in the local registry, but none are found.
770 !> Compared to no-versions-in-registry, we aren't requesting a specific version here.
771 subroutine local_registry_unspecified_no_versions(error)
772 type(error_t), allocatable, intent(out) :: error
773
774 type(toml_table) :: table
775 type(dependency_node_t) :: node
776 type(fpm_global_settings) :: global_settings
777 character(len=:), allocatable :: target_dir
778 type(toml_table), pointer :: child
779
780 call new_table(table)
781 table%key = 'test-dep'
782 call set_value(table, 'namespace', 'test-org')
783
784 call new_dependency(node%dependency_config_t, table, error=error)
785 if (allocated(error)) return
786
787 call delete_tmp_folder
788 call mkdir(join_path(tmp_folder, 'cache', 'test-org', 'test-dep'))
789
790 call new_table(table)
791 call add_table(table, 'registry', child)
792 call set_value(child, 'path', 'cache')
793
794 call setup_global_settings(global_settings, error)
795 if (allocated(error)) then
796 call delete_tmp_folder; return
797 end if
798
799 call get_registry_settings(child, global_settings, error)
800 if (allocated(error)) then
801 call delete_tmp_folder; return
802 end if
803
804 call node%get_from_registry(target_dir, global_settings, error)
805 if (allocated(error)) then
806 call delete_tmp_folder; return
807 end if
808
809 call delete_tmp_folder
810
811 end subroutine local_registry_unspecified_no_versions
812
813 !> Latest version in the local registry does not have a manifest.
814 subroutine local_registry_unspecified_no_manifest(error)
815 type(error_t), allocatable, intent(out) :: error
816
817 type(toml_table) :: table
818 type(dependency_node_t) :: node
819 type(fpm_global_settings) :: global_settings
820 character(len=:), allocatable :: target_dir, cwd
821 type(toml_table), pointer :: child
822
823 call new_table(table)
824 table%key = 'test-dep'
825 call set_value(table, 'namespace', 'test-org')
826
827 call new_dependency(node%dependency_config_t, table, error=error)
828 if (allocated(error)) return
829
830 call delete_tmp_folder
831 call mkdir(join_path(tmp_folder, 'cache', 'test-org', 'test-dep', '0.0.0'))
832 call mkdir(join_path(tmp_folder, 'cache', 'test-org', 'test-dep', '1.3.0'))
833 call mkdir(join_path(tmp_folder, 'cache', 'test-org', 'test-dep', '1.2.1'))
834
835 call new_table(table)
836 call add_table(table, 'registry', child)
837 call set_value(child, 'path', 'cache')
838
839 call setup_global_settings(global_settings, error)
840 if (allocated(error)) then
841 call delete_tmp_folder; return
842 end if
843
844 call get_registry_settings(child, global_settings, error)
845 if (allocated(error)) then
846 call delete_tmp_folder; return
847 end if
848
849 call node%get_from_registry(target_dir, global_settings, error)
850 if (allocated(error)) then
851 call delete_tmp_folder; return
852 end if
853
854 call get_current_directory(cwd, error)
855 if (allocated(error)) then
856 call delete_tmp_folder; return
857 end if
858
859 if (target_dir /= join_path(cwd, join_path(tmp_folder, 'cache', 'test-org', 'test-dep', '1.3.0'))) then
860 call test_failed(error, 'target_dir not set correctly: '//target_dir//"'")
861 call delete_tmp_folder; return
862 end if
863
864 call delete_tmp_folder
865
866 end subroutine local_registry_unspecified_no_manifest
867
868 !> Latest version in the local registry has a manifest.
869 subroutine local_registry_unspecified_has_manifest(error)
870 type(error_t), allocatable, intent(out) :: error
871
872 type(toml_table) :: table
873 type(dependency_node_t) :: node
874 type(fpm_global_settings) :: global_settings
875 character(len=:), allocatable :: target_dir, cwd
876 type(toml_table), pointer :: child
877
878 call new_table(table)
879 table%key = 'test-dep'
880 call set_value(table, 'namespace', 'test-org')
881
882 call new_dependency(node%dependency_config_t, table, error=error)
883 if (allocated(error)) return
884
885 call delete_tmp_folder
886 call mkdir(join_path(tmp_folder, 'cache', 'test-org', 'test-dep', '0.0.0'))
887 call mkdir(join_path(tmp_folder, 'cache', 'test-org', 'test-dep', '1.3.0'))
888 call filewrite(join_path(join_path(tmp_folder, 'cache', 'test-org', 'test-dep', '1.3.0'), 'fpm.toml'), [''])
889 call mkdir(join_path(tmp_folder, 'cache', 'test-org', 'test-dep', '1.2.1'))
890
891 call new_table(table)
892 call add_table(table, 'registry', child)
893 call set_value(child, 'path', 'cache')
894
895 call setup_global_settings(global_settings, error)
896 if (allocated(error)) then
897 call delete_tmp_folder; return
898 end if
899
900 call get_registry_settings(child, global_settings, error)
901 if (allocated(error)) then
902 call delete_tmp_folder; return
903 end if
904
905 call node%get_from_registry(target_dir, global_settings, error)
906 if (allocated(error)) then
907 call delete_tmp_folder; return
908 end if
909
910 call get_current_directory(cwd, error)
911 if (allocated(error)) then
912 call delete_tmp_folder; return
913 end if
914
915 if (target_dir /= join_path(cwd, join_path(tmp_folder, 'cache', 'test-org', 'test-dep', '1.3.0'))) then
916 call test_failed(error, 'target_dir not set correctly: '//target_dir//"'")
917 call delete_tmp_folder; return
918 end if
919
920 call delete_tmp_folder
921
922 end subroutine local_registry_unspecified_has_manifest
923
924 !> Version specified in manifest, version found in cache.
925 subroutine cache_specified_version_found(error)
926 type(error_t), allocatable, intent(out) :: error
927
928 type(toml_table) :: table
929 type(dependency_node_t) :: node
930 type(fpm_global_settings) :: global_settings
931 character(len=:), allocatable :: target_dir, cwd, path
932 type(toml_table), pointer :: child
933
934 call new_table(table)
935 table%key = 'test-dep'
936 call set_value(table, 'namespace', 'test-org')
937 call set_value(table, 'v', '2.3.0')
938
939 call new_dependency(node%dependency_config_t, table, error=error)
940 if (allocated(error)) return
941
942 call delete_tmp_folder
943 path = join_path(tmp_folder, 'dependencies', 'test-org', 'test-dep', '2.3.0')
944 call mkdir(path)
945 call filewrite(join_path(path, 'fpm.toml'), [''])
946
947 call new_table(table)
948 call add_table(table, 'registry', child) ! No cache_path specified, use default
949
950 call setup_global_settings(global_settings, error)
951 if (allocated(error)) then
952 call delete_tmp_folder; return
953 end if
954
955 call get_registry_settings(child, global_settings, error)
956 if (allocated(error)) then
957 call delete_tmp_folder; return
958 end if
959
960 call node%get_from_registry(target_dir, global_settings, error)
961 if (allocated(error)) then
962 call delete_tmp_folder; return
963 end if
964
965 call get_current_directory(cwd, error)
966 if (allocated(error)) then
967 call delete_tmp_folder; return
968 end if
969
970 if (target_dir /= join_path(cwd, join_path(tmp_folder, 'dependencies', 'test-org', 'test-dep', '2.3.0'))) then
971 call test_failed(error, "Target directory not set correctly: '"//target_dir//"'")
972 call delete_tmp_folder; return
973 end if
974
975 call delete_tmp_folder
976
977 end subroutine cache_specified_version_found
978
979 !> Version specified in manifest, but not found in cache. Therefore download dependency.
980 subroutine registry_specified_version_not_found_in_cache(error)
981 type(error_t), allocatable, intent(out) :: error
982
983 type(toml_table) :: table
984 type(dependency_node_t) :: node
985 type(fpm_global_settings) :: global_settings
986 character(len=:), allocatable :: target_dir, cwd
987 type(toml_table), pointer :: child
988 type(mock_downloader_t) :: mock_downloader
989
990 call new_table(table)
991 table%key = 'test-dep'
992 call set_value(table, 'namespace', 'test-org')
993 call set_value(table, 'v', '0.1.0')
994
995 call new_dependency(node%dependency_config_t, table, error=error)
996 if (allocated(error)) return
997
998 call delete_tmp_folder
999 call mkdir(tmp_folder) ! Dependencies folder doesn't exist
1000
1001 call new_table(table)
1002 call add_table(table, 'registry', child)
1003
1004 call setup_global_settings(global_settings, error)
1005 if (allocated(error)) then
1006 call delete_tmp_folder; return
1007 end if
1008
1009 call get_registry_settings(child, global_settings, error)
1010 if (allocated(error)) then
1011 call delete_tmp_folder; return
1012 end if
1013
1014 call node%get_from_registry(target_dir, global_settings, error, mock_downloader)
1015 if (allocated(error)) then
1016 call delete_tmp_folder; return
1017 end if
1018
1019 call get_current_directory(cwd, error)
1020 if (allocated(error)) then
1021 call delete_tmp_folder; return
1022 end if
1023
1024 if (target_dir /= join_path(cwd, join_path(tmp_folder, 'dependencies', 'test-org', 'test-dep', '0.1.0'))) then
1025 call test_failed(error, "Target directory not set correctly: '"//target_dir//"'")
1026 call delete_tmp_folder; return
1027 end if
1028
1029 call delete_tmp_folder
1030
1031 end subroutine registry_specified_version_not_found_in_cache
1032
1033 !> Version specified in manifest, but not found in cache or registry.
1034 subroutine registry_specified_version_not_exists(error)
1035 type(error_t), allocatable, intent(out) :: error
1036
1037 type(toml_table) :: table
1038 type(dependency_node_t) :: node
1039 type(fpm_global_settings) :: global_settings
1040 character(len=:), allocatable :: target_dir
1041 type(toml_table), pointer :: child
1042 type(mock_downloader_t) :: mock_downloader
1043
1044 call new_table(table)
1045 table%key = 'test-dep'
1046 call set_value(table, 'namespace', 'test-org')
1047 call set_value(table, 'v', '9.9.9')
1048
1049 call new_dependency(node%dependency_config_t, table, error=error)
1050 if (allocated(error)) return
1051
1052 call delete_tmp_folder
1053 call mkdir(tmp_folder)
1054
1055 call new_table(table)
1056 call add_table(table, 'registry', child)
1057
1058 call setup_global_settings(global_settings, error)
1059 if (allocated(error)) then
1060 call delete_tmp_folder; return
1061 end if
1062
1063 call get_registry_settings(child, global_settings, error)
1064 if (allocated(error)) then
1065 call delete_tmp_folder; return
1066 end if
1067
1068 call node%get_from_registry(target_dir, global_settings, error, mock_downloader)
1069 if (allocated(error)) then
1070 call delete_tmp_folder; return
1071 end if
1072
1073 call delete_tmp_folder
1074
1075 end subroutine registry_specified_version_not_exists
1076
1077 subroutine registry_specified_version_other_versions_exist(error)
1078 type(error_t), allocatable, intent(out) :: error
1079
1080 type(toml_table) :: table
1081 type(dependency_node_t) :: node
1082 type(fpm_global_settings) :: global_settings
1083 character(len=:), allocatable :: target_dir
1084 type(toml_table), pointer :: child
1085 type(mock_downloader_t) :: mock_downloader
1086
1087 call new_table(table)
1088 table%key = 'test-dep'
1089 call set_value(table, 'namespace', 'test-org')
1090 call set_value(table, 'v', '0.1.0')
1091
1092 call new_dependency(node%dependency_config_t, table, error=error)
1093 if (allocated(error)) return
1094
1095 call delete_tmp_folder
1096 call mkdir(join_path(tmp_folder, 'dependencies', 'test-org', 'test-dep', '2.1.0'))
1097 call mkdir(join_path(tmp_folder, 'dependencies', 'test-org', 'test-dep', '9.1.0'))
1098
1099 call new_table(table)
1100 call add_table(table, 'registry', child)
1101
1102 call setup_global_settings(global_settings, error)
1103 if (allocated(error)) then
1104 call delete_tmp_folder; return
1105 end if
1106
1107 call get_registry_settings(child, global_settings, error)
1108 if (allocated(error)) then
1109 call delete_tmp_folder; return
1110 end if
1111
1112 call node%get_from_registry(target_dir, global_settings, error, mock_downloader)
1113 if (allocated(error)) then
1114 call delete_tmp_folder; return
1115 end if
1116
1117 call delete_tmp_folder
1118
1119 end subroutine registry_specified_version_other_versions_exist
1120
1121 !> No version specified, get the newest version from the registry.
1122 subroutine registry_unspecified_version(error)
1123 type(error_t), allocatable, intent(out) :: error
1124
1125 type(toml_table) :: table
1126 type(dependency_node_t) :: node
1127 type(fpm_global_settings) :: global_settings
1128 character(len=:), allocatable :: target_dir, cwd
1129 type(toml_table), pointer :: child
1130 type(mock_downloader_t) :: mock_downloader
1131
1132 call new_table(table)
1133 table%key = 'test-dep'
1134 call set_value(table, 'namespace', 'test-org')
1135
1136 call new_dependency(node%dependency_config_t, table, error=error)
1137 if (allocated(error)) return
1138
1139 call delete_tmp_folder
1140 call mkdir(tmp_folder)
1141
1142 call new_table(table)
1143 call add_table(table, 'registry', child)
1144
1145 call setup_global_settings(global_settings, error)
1146 if (allocated(error)) then
1147 call delete_tmp_folder; return
1148 end if
1149
1150 call get_registry_settings(child, global_settings, error)
1151 if (allocated(error)) then
1152 call delete_tmp_folder; return
1153 end if
1154
1155 call node%get_from_registry(target_dir, global_settings, error, mock_downloader)
1156 if (allocated(error)) then
1157 call delete_tmp_folder; return
1158 end if
1159
1160 call get_current_directory(cwd, error)
1161 if (allocated(error)) then
1162 call delete_tmp_folder; return
1163 end if
1164
1165 if (target_dir /= join_path(cwd, join_path(tmp_folder, 'dependencies', 'test-org', 'test-dep', '0.1.0'))) then
1166 call test_failed(error, "Target directory not set correctly: '"//target_dir//"'")
1167 call delete_tmp_folder; return
1168 end if
1169
1170 call delete_tmp_folder
1171
1172 end subroutine registry_unspecified_version
1173
1174 !> No version specified, therefore load package data from the registry. Find out that there is a cached version of
1175 !> the latest package.
1176 subroutine registry_unspecified_version_exists_in_cache(error)
1177 type(error_t), allocatable, intent(out) :: error
1178
1179 type(toml_table) :: table
1180 type(dependency_node_t) :: node
1181 type(fpm_global_settings) :: global_settings
1182 character(len=:), allocatable :: target_dir, cwd
1183 type(toml_table), pointer :: child
1184 type(mock_downloader_t) :: mock_downloader
1185
1186 call new_table(table)
1187 table%key = 'test-dep'
1188 call set_value(table, 'namespace', 'test-org')
1189
1190 call new_dependency(node%dependency_config_t, table, error=error)
1191 if (allocated(error)) return
1192
1193 call delete_tmp_folder
1194 call mkdir(join_path(tmp_folder, 'cache', 'test-org', 'test-dep', '0.0.0'))
1195 call mkdir(join_path(tmp_folder, 'cache', 'test-org', 'test-dep', '0.1.0'))
1196 call filewrite(join_path(join_path(tmp_folder, 'cache', 'test-org', 'test-dep', '0.1.0'), 'fpm.toml'), [''])
1197 call mkdir(join_path(tmp_folder, 'cache', 'test-org', 'test-dep', '1.2.1'))
1198
1199 call new_table(table)
1200 call add_table(table, 'registry', child)
1201
1202 call setup_global_settings(global_settings, error)
1203 if (allocated(error)) then
1204 call delete_tmp_folder; return
1205 end if
1206
1207 call get_registry_settings(child, global_settings, error)
1208 if (allocated(error)) then
1209 call delete_tmp_folder; return
1210 end if
1211
1212 call node%get_from_registry(target_dir, global_settings, error, mock_downloader)
1213 if (allocated(error)) then
1214 call delete_tmp_folder; return
1215 end if
1216
1217 call get_current_directory(cwd, error)
1218 if (allocated(error)) then
1219 call delete_tmp_folder; return
1220 end if
1221
1222 if (target_dir /= join_path(cwd, join_path(tmp_folder, 'dependencies', 'test-org', 'test-dep', '0.1.0'))) then
1223 call test_failed(error, "Target directory not set correctly: '"//target_dir//"'")
1224 call delete_tmp_folder; return
1225 end if
1226
1227 call delete_tmp_folder
1228
1229 end subroutine registry_unspecified_version_exists_in_cache
1230
1231 !> Package data returned from the registry does not contain a code field.
1232 subroutine pkg_data_no_code(error)
1233 type(error_t), allocatable, intent(out) :: error
1234
1235 type(dependency_node_t) :: node
1236 character(:), allocatable :: url
1237 type(version_t) :: version
1238 type(json_object) :: json
1239 class(json_value), allocatable :: j_value
1240
1241 call json_loads(j_value, '{}')
1242 json = cast_to_object(j_value)
1243
1244 call check_and_read_pkg_data(json, node, url, version, error)
1245
1246 end subroutine pkg_data_no_code
1247
1248 !> Error reading status code from package data.
1249 subroutine pkg_data_corrupt_code(error)
1250 type(error_t), allocatable, intent(out) :: error
1251
1252 type(dependency_node_t) :: node
1253 character(:), allocatable :: url
1254 type(version_t) :: version
1255 type(json_object) :: json
1256 class(json_value), allocatable :: j_value
1257
1258 call json_loads(j_value, '{"code": "integer expected"}')
1259 json = cast_to_object(j_value)
1260
1261 call check_and_read_pkg_data(json, node, url, version, error)
1262
1263 end subroutine pkg_data_corrupt_code
1264
1265 subroutine pkg_data_missing_error_msg(error)
1266 type(error_t), allocatable, intent(out) :: error
1267
1268 type(dependency_node_t) :: node
1269 character(:), allocatable :: url
1270 type(version_t) :: version
1271 type(json_object) :: json
1272 class(json_value), allocatable :: j_value
1273
1274 call json_loads(j_value, '{"code": 123}')
1275 json = cast_to_object(j_value)
1276
1277 call check_and_read_pkg_data(json, node, url, version, error)
1278
1279 end subroutine pkg_data_missing_error_msg
1280
1281 subroutine pkg_data_error_reading_msg(error)
1282 type(error_t), allocatable, intent(out) :: error
1283
1284 type(dependency_node_t) :: node
1285 character(:), allocatable :: url
1286 type(version_t) :: version
1287 type(json_object) :: json
1288 class(json_value), allocatable :: j_value
1289
1290 call json_loads(j_value, '{"code": 123, "message": 123}')
1291 json = cast_to_object(j_value)
1292
1293 call check_and_read_pkg_data(json, node, url, version, error)
1294
1295 end subroutine pkg_data_error_reading_msg
1296
1297 subroutine pkg_data_error_has_msg(error)
1298 type(error_t), allocatable, intent(out) :: error
1299
1300 type(dependency_node_t) :: node
1301 character(:), allocatable :: url
1302 type(version_t) :: version
1303 type(json_object) :: json
1304 class(json_value), allocatable :: j_value
1305
1306 call json_loads(j_value, '{"code": 123, "message": "Really bad error message"}')
1307 json = cast_to_object(j_value)
1308
1309 call check_and_read_pkg_data(json, node, url, version, error)
1310
1311 end subroutine pkg_data_error_has_msg
1312
1313 subroutine pkg_data_no_data(error)
1314 type(error_t), allocatable, intent(out) :: error
1315
1316 type(dependency_node_t) :: node
1317 character(:), allocatable :: url
1318 type(version_t) :: version
1319 type(json_object) :: json
1320 class(json_value), allocatable :: j_value
1321
1322 call json_loads(j_value, '{"code": 200}')
1323 json = cast_to_object(j_value)
1324
1325 call check_and_read_pkg_data(json, node, url, version, error)
1326
1327 end subroutine pkg_data_no_data
1328
1329 subroutine pkg_data_error_reading_data(error)
1330 type(error_t), allocatable, intent(out) :: error
1331
1332 type(dependency_node_t) :: node
1333 character(:), allocatable :: url
1334 type(version_t) :: version
1335 type(json_object) :: json
1336 class(json_value), allocatable :: j_value
1337
1338 call json_loads(j_value, '{"code": 200, "data": 123}')
1339 json = cast_to_object(j_value)
1340
1341 call check_and_read_pkg_data(json, node, url, version, error)
1342
1343 end subroutine pkg_data_error_reading_data
1344
1345 subroutine pkg_data_requested_version_wrong_key(error)
1346 type(error_t), allocatable, intent(out) :: error
1347
1348 type(dependency_node_t) :: node
1349 character(:), allocatable :: url
1350 type(version_t) :: version
1351 type(json_object) :: json
1352 class(json_value), allocatable :: j_value
1353
1354 allocate (node%requested_version)
1355 call json_loads(j_value, '{"code": 200, "data": {"latest_version_data": 123}}') ! Expected key: "version_data"
1356 json = cast_to_object(j_value)
1357
1358 call check_and_read_pkg_data(json, node, url, version, error)
1359
1360 end subroutine pkg_data_requested_version_wrong_key
1361
1362 subroutine pkg_data_no_version_requested_wrong_key(error)
1363 type(error_t), allocatable, intent(out) :: error
1364
1365 type(dependency_node_t) :: node
1366 character(:), allocatable :: url
1367 type(version_t) :: version
1368 type(json_object) :: json
1369 class(json_value), allocatable :: j_value
1370
1371 call json_loads(j_value, '{"code": 200, "data": {"version_data": 123}}') ! Expected key: "latest_version_data"
1372 json = cast_to_object(j_value)
1373
1374 call check_and_read_pkg_data(json, node, url, version, error)
1375
1376 end subroutine pkg_data_no_version_requested_wrong_key
1377
1378 subroutine pkg_data_error_reading_latest_version(error)
1379 type(error_t), allocatable, intent(out) :: error
1380
1381 type(dependency_node_t) :: node
1382 character(:), allocatable :: url
1383 type(version_t) :: version
1384 type(json_object) :: json
1385 class(json_value), allocatable :: j_value
1386
1387 call json_loads(j_value, '{"code": 200, "data": {"latest_version_data": 123}}')
1388 json = cast_to_object(j_value)
1389
1390 call check_and_read_pkg_data(json, node, url, version, error)
1391
1392 end subroutine pkg_data_error_reading_latest_version
1393
1394 subroutine pkg_data_no_download_url(error)
1395 type(error_t), allocatable, intent(out) :: error
1396
1397 type(dependency_node_t) :: node
1398 character(:), allocatable :: url
1399 type(version_t) :: version
1400 type(json_object) :: json
1401 class(json_value), allocatable :: j_value
1402
1403 call json_loads(j_value, '{"code": 200, "data": {"latest_version_data": {}}}')
1404 json = cast_to_object(j_value)
1405
1406 call check_and_read_pkg_data(json, node, url, version, error)
1407
1408 end subroutine pkg_data_no_download_url
1409
1410 subroutine pkg_data_error_reading_download_url(error)
1411 type(error_t), allocatable, intent(out) :: error
1412
1413 type(dependency_node_t) :: node
1414 character(:), allocatable :: url
1415 type(version_t) :: version
1416 type(json_object) :: json
1417 class(json_value), allocatable :: j_value
1418
1419 call json_loads(j_value, '{"code": 200, "data": {"latest_version_data": {"download_url": 123}}}')
1420 json = cast_to_object(j_value)
1421
1422 call check_and_read_pkg_data(json, node, url, version, error)
1423
1424 end subroutine pkg_data_error_reading_download_url
1425
1426 subroutine pkg_data_no_version(error)
1427 type(error_t), allocatable, intent(out) :: error
1428
1429 type(dependency_node_t) :: node
1430 character(:), allocatable :: url
1431 type(version_t) :: version
1432 type(json_object) :: json
1433 class(json_value), allocatable :: j_value
1434
1435 call json_loads(j_value, '{"code": 200, "data": {"latest_version_data": {"download_url": "abc"}}}')
1436 json = cast_to_object(j_value)
1437
1438 call check_and_read_pkg_data(json, node, url, version, error)
1439
1440 end subroutine pkg_data_no_version
1441
1442 subroutine pkg_data_error_reading_version(error)
1443 type(error_t), allocatable, intent(out) :: error
1444
1445 type(dependency_node_t) :: node
1446 character(:), allocatable :: url
1447 type(version_t) :: version
1448 type(json_object) :: json
1449 class(json_value), allocatable :: j_value
1450
1451 call json_loads(j_value, '{"code": 200, "data": {"latest_version_data": {"download_url": "abc", "version": 123}}}')
1452 json = cast_to_object(j_value)
1453
1454 call check_and_read_pkg_data(json, node, url, version, error)
1455
1456 end subroutine pkg_data_error_reading_version
1457
1458 subroutine pkg_data_invalid_version(error)
1459 type(error_t), allocatable, intent(out) :: error
1460
1461 type(dependency_node_t) :: node
1462 character(:), allocatable :: url
1463 type(version_t) :: version
1464 type(json_object) :: json
1465 class(json_value), allocatable :: j_value
1466
1467 call json_loads(j_value, '{"code": 200, "data": {"latest_version_data": {"download_url": "abc", "version": "abc"}}}')
1468 json = cast_to_object(j_value)
1469
1470 call check_and_read_pkg_data(json, node, url, version, error)
1471
1472 end subroutine pkg_data_invalid_version
1473
1474 !> Resolve a single dependency node
1475 subroutine resolve_dependency_once(self, dependency, global_settings, root, error)
1476 !> Mock instance of the dependency tree
1477 class(mock_dependency_tree_t), intent(inout) :: self
1478 !> Dependency configuration to add
1479 type(dependency_node_t), intent(inout) :: dependency
1480 !> Global configuration settings.
1481 type(fpm_global_settings), intent(in) :: global_settings
1482 !> Current installation prefix
1483 character(len=*), intent(in) :: root
1484 !> Error handling
1485 type(error_t), allocatable, intent(out) :: error
1486
1487 if (dependency%done) then
1488 call test_failed(error, "Should only visit this node once")
1489 return
1490 end if
1491
1492 dependency%done = .true.
1493
1494 end subroutine resolve_dependency_once
1495
1496 !> Resolve all dependencies in the tree
1497 subroutine resolve_dependencies(self, root, error)
1498 !> Instance of the dependency tree
1499 type(mock_dependency_tree_t), intent(inout) :: self
1500 !> Current installation prefix
1501 character(len=*), intent(in) :: root
1502 !> Error handling
1503 type(error_t), allocatable, intent(out) :: error
1504
1505 type(fpm_global_settings) :: global_settings
1506 integer :: ii
1507
1508 call get_global_settings(global_settings, error)
1509 if (allocated(error)) return
1510
1511 do ii = 1, self%ndep
1512 call resolve_dependency_once(self, self%dep(ii), global_settings, root, error)
1513 if (allocated(error)) exit
1514 end do
1515
1516 if (allocated(error)) return
1517
1518 end subroutine resolve_dependencies
1519
1520 subroutine delete_tmp_folder
1521 if (is_dir(tmp_folder)) call os_delete_dir(os_is_unix(), tmp_folder)
1522 end
1523
1524 subroutine setup_global_settings(global_settings, error)
1525 type(fpm_global_settings), intent(out) :: global_settings
1526 type(error_t), allocatable, intent(out) :: error
1527
1528 character(:), allocatable :: cwd
1529
1530 call get_current_directory(cwd, error)
1531 if (allocated(error)) return
1532
1533 global_settings%path_to_config_folder = join_path(cwd, tmp_folder)
1534 global_settings%config_file_name = config_file_name
1535 end
1536
1537 subroutine get_pkg_data(url, version, tmp_pkg_file, json, error)
1538 character(*), intent(in) :: url
1539 type(version_t), allocatable, intent(in) :: version
1540 character(*), intent(in) :: tmp_pkg_file
1541 type(json_object), intent(out) :: json
1542 type(error_t), allocatable, intent(out) :: error
1543
1544 class(json_value), allocatable :: j_value
1545
1546 if (allocated(version)) then
1547 if (version%s() == '9.9.9') then
1548 call json_loads(j_value, '{"code": 404, "message": "Package not found"}')
1549 else
1550 call json_loads(j_value, '{"code": 200, "data": {"version_data": {"version": "0.1.0", "download_url": "abc"}}}')
1551 end if
1552 else
1553 call json_loads(j_value, '{"code": 200, "data": {"latest_version_data": {"version": "0.1.0", "download_url": "abc"}}}')
1554 end if
1555
1556 json = cast_to_object(j_value)
1557 end
1558
1559 subroutine get_file(url, tmp_pkg_file, error)
1560 character(*), intent(in) :: url
1561 character(*), intent(in) :: tmp_pkg_file
1562 type(error_t), allocatable, intent(out) :: error
1563 end
1564
1565 subroutine unpack_mock_package(tmp_pkg_file, destination, error)
1566 character(*), intent(in) :: tmp_pkg_file
1567 character(*), intent(in) :: destination
1568 type(error_t), allocatable, intent(out) :: error
1569
1570 integer :: stat
1571
1572 call execute_command_line('cp '//tmp_pkg_file//' '//destination, exitstat=stat)
1573
1574 if (stat /= 0) then
1575 call test_failed(error, "Failed to create mock package"); return
1576 end if
1577 end
1578
1579 end module test_package_dependencies