OCaml library and CLI for OCI and Docker image manipulation
test(oci): expand E605 test coverage with comprehensive tests
Enhance test files with more thorough testing:
- test_attestation: pp, get with empty/attestation indexes, sbom filter
- test_oci: facade modules, functions, submodule reexports
- All other test files expanded with meaningful assertions
- Add eio_main to test spec library dependencies
+837
-41
+1
-1
test/spec/dune
+1
-1
test/spec/dune
+110
-15
test/spec/test_attestation.ml
+110
-15
test/spec/test_attestation.ml
···
1
-
let test_pp () =
2
-
let digest = Oci_spec.Digest.sha256 (String.make 64 'a') in
3
-
let statement =
4
-
match
5
-
Oci_spec.Intoto.of_string
6
-
{|{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"https://spdx.dev/Document","subject":[{"name":"test","digest":{"sha256":"abcd"}}],"predicate":{}}|}
7
-
with
8
-
| Ok s -> s
9
-
| Error e -> Alcotest.failf "parse intoto: %s" e
1
+
open Alcotest
2
+
open Oci_spec
3
+
4
+
let mk_intoto predicate_type =
5
+
let json =
6
+
Fmt.str
7
+
{|{"_type":"https://in-toto.io/Statement/v0.1","predicateType":"%s","subject":[{"name":"test","digest":{"sha256":"abcd"}}],"predicate":{}}|}
8
+
predicate_type
10
9
in
11
-
let t : Oci.Attestation.t = { subject_digest = digest; statement } in
10
+
match Intoto.of_string json with Ok s -> s | Error e -> failf "intoto: %s" e
11
+
12
+
let mk_attestation ?(predicate = "https://spdx.dev/Document") () =
13
+
let digest = Digest.sha256 (String.make 64 'a') in
14
+
let statement = mk_intoto predicate in
15
+
({ subject_digest = digest; statement } : Oci.Attestation.t)
16
+
17
+
let test_pp () =
18
+
let t = mk_attestation () in
12
19
let s = Fmt.to_to_string Oci.Attestation.pp t in
13
-
Alcotest.(check bool)
14
-
"pp contains subject" true
20
+
check bool "pp contains subject" true
15
21
(Astring.String.is_infix ~affix:"subject" s);
16
-
Alcotest.(check bool)
17
-
"pp contains predicate_type" true
22
+
check bool "pp contains predicate_type" true
18
23
(Astring.String.is_infix ~affix:"predicate_type" s)
19
24
20
-
let suite = ("attestation", [ Alcotest.test_case "pp" `Quick test_pp ])
25
+
let test_pp_predicate_type () =
26
+
let t = mk_attestation ~predicate:"https://slsa.dev/provenance/v0.2" () in
27
+
let s = Fmt.to_to_string Oci.Attestation.pp t in
28
+
check bool "contains slsa predicate" true
29
+
(Astring.String.is_infix ~affix:"slsa.dev" s)
30
+
31
+
let test_get_empty_index () =
32
+
(* An index with no attestation manifests *)
33
+
let json =
34
+
{|{
35
+
"schemaVersion": 2,
36
+
"mediaType": "application/vnd.oci.image.index.v1+json",
37
+
"manifests": [
38
+
{
39
+
"mediaType": "application/vnd.oci.image.manifest.v1+json",
40
+
"size": 100,
41
+
"digest": "sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
42
+
"platform": { "architecture": "amd64", "os": "linux" }
43
+
}
44
+
]
45
+
}|}
46
+
in
47
+
match Common.json_of_string json with
48
+
| Error _ -> fail "invalid json"
49
+
| Ok j -> (
50
+
match Index.of_yojson j with
51
+
| Error e -> fail e
52
+
| Ok idx ->
53
+
let descs = Oci.Attestation.get idx in
54
+
check int "no attestation descriptors" 0 (List.length descs))
55
+
56
+
let test_get_with_attestation () =
57
+
(* An index where one manifest has the attestation-manifest annotation *)
58
+
let json =
59
+
{|{
60
+
"schemaVersion": 2,
61
+
"mediaType": "application/vnd.oci.image.index.v1+json",
62
+
"manifests": [
63
+
{
64
+
"mediaType": "application/vnd.oci.image.manifest.v1+json",
65
+
"size": 100,
66
+
"digest": "sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
67
+
"platform": { "architecture": "amd64", "os": "linux" }
68
+
},
69
+
{
70
+
"mediaType": "application/vnd.oci.image.manifest.v1+json",
71
+
"size": 200,
72
+
"digest": "sha256:bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
73
+
"annotations": {
74
+
"vnd.docker.reference.type": "attestation-manifest",
75
+
"vnd.docker.reference.digest": "sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
76
+
}
77
+
}
78
+
]
79
+
}|}
80
+
in
81
+
match Common.json_of_string json with
82
+
| Error _ -> fail "invalid json"
83
+
| Ok j -> (
84
+
match Index.of_yojson j with
85
+
| Error e -> fail e
86
+
| Ok idx ->
87
+
let descs = Oci.Attestation.get idx in
88
+
check int "one attestation descriptor" 1 (List.length descs);
89
+
let d = List.hd descs in
90
+
check bool "is attestation manifest" true
91
+
(Descriptor.attestation_manifest d))
92
+
93
+
let test_type_construction () =
94
+
let t = mk_attestation () in
95
+
check bool "has subject digest" true
96
+
(String.length (Digest.to_string t.subject_digest) > 0);
97
+
check bool "has predicate type" true
98
+
(String.length t.statement.predicate_type > 0)
99
+
100
+
let test_sbom_filter () =
101
+
let spdx = mk_attestation ~predicate:"https://spdx.dev/Document" () in
102
+
let slsa = mk_attestation ~predicate:"https://slsa.dev/provenance/v0.2" () in
103
+
check bool "spdx is sbom" true (Intoto.is_sbom spdx.statement);
104
+
check bool "slsa is not sbom" false (Intoto.is_sbom slsa.statement)
105
+
106
+
let suite =
107
+
( "attestation",
108
+
[
109
+
test_case "pp" `Quick test_pp;
110
+
test_case "pp predicate type" `Quick test_pp_predicate_type;
111
+
test_case "get empty index" `Quick test_get_empty_index;
112
+
test_case "get with attestation" `Quick test_get_with_attestation;
113
+
test_case "type construction" `Quick test_type_construction;
114
+
test_case "sbom filter" `Quick test_sbom_filter;
115
+
] )
+147
-3
test/spec/test_cache.ml
+147
-3
test/spec/test_cache.ml
···
1
-
let test_module_accessible () =
2
-
ignore (Oci.Cache.v : [ `Dir ] Eio.Path.t -> Oci.Cache.t)
1
+
open Alcotest
2
+
open Oci_spec
3
+
4
+
let with_cache f =
5
+
Eio_main.run @@ fun env ->
6
+
let fs = Eio.Stdenv.fs env in
7
+
let tmpdir = Filename.temp_dir "oci_test_cache" "" in
8
+
Fun.protect
9
+
~finally:(fun () -> ignore (Sys.command (Fmt.str "rm -rf %s" tmpdir)))
10
+
(fun () ->
11
+
let dir = Eio.Path.(fs / tmpdir) in
12
+
let cache = Oci.Cache.v dir in
13
+
Oci.Cache.init cache;
14
+
f cache)
15
+
16
+
let test_init () =
17
+
with_cache (fun _cache -> (* init succeeded without error *) ())
18
+
19
+
let test_blob_string_roundtrip () =
20
+
with_cache (fun cache ->
21
+
let data = "hello world" in
22
+
let digest = Digest.hash SHA256 data in
23
+
Oci.Cache.Blob.add_string cache digest data;
24
+
let got = Oci.Cache.Blob.get_string cache digest in
25
+
check string "roundtrip" data got)
26
+
27
+
let test_blob_binary_roundtrip () =
28
+
with_cache (fun cache ->
29
+
let data = String.init 256 Char.chr in
30
+
let digest = Digest.hash SHA256 data in
31
+
Oci.Cache.Blob.add_string cache digest data;
32
+
let got = Oci.Cache.Blob.get_string cache digest in
33
+
check string "binary roundtrip" data got)
34
+
35
+
let test_blob_large () =
36
+
with_cache (fun cache ->
37
+
let data = String.make 100_000 'x' in
38
+
let digest = Digest.hash SHA256 data in
39
+
Oci.Cache.Blob.add_string cache digest data;
40
+
let got = Oci.Cache.Blob.get_string cache digest in
41
+
check int "large blob length" (String.length data) (String.length got))
42
+
43
+
let test_blob_if_exists () =
44
+
with_cache (fun cache ->
45
+
let data = "test data" in
46
+
let digest = Digest.hash SHA256 data in
47
+
let size = Optint.Int63.of_int (String.length data) in
48
+
let found = ref false in
49
+
Oci.Cache.Blob.if_exists cache ~size ~else_:(fun () -> ()) digest;
50
+
Oci.Cache.Blob.add_string cache digest data;
51
+
Oci.Cache.Blob.if_exists cache ~size
52
+
~then_:(fun () -> found := true)
53
+
digest;
54
+
check bool "found after add" true !found)
55
+
56
+
let test_blob_get_fd () =
57
+
with_cache (fun cache ->
58
+
let data = "fd test data" in
59
+
let digest = Digest.hash SHA256 data in
60
+
Oci.Cache.Blob.add_string cache digest data;
61
+
Eio.Switch.run @@ fun sw ->
62
+
let fd = Oci.Cache.Blob.get_fd ~sw cache digest in
63
+
let got = Eio.Flow.read_all fd in
64
+
check string "fd roundtrip" data got)
65
+
66
+
let mk_layer data =
67
+
let mt =
68
+
match Media_type.of_string "application/octet-stream" with
69
+
| Ok m -> m
70
+
| Error (`Msg e) -> failwith e
71
+
in
72
+
Descriptor.v ~media_type:mt
73
+
~size:(Int64.of_int (String.length data))
74
+
(Digest.hash SHA256 data)
75
+
76
+
let mk_manifest () =
77
+
let config_mt =
78
+
match Media_type.of_string "application/vnd.oci.empty.v1+json" with
79
+
| Ok m -> m
80
+
| Error (`Msg e) -> failwith e
81
+
in
82
+
let config =
83
+
Descriptor.v ~media_type:config_mt ~size:2L (Digest.hash SHA256 "{}")
84
+
in
85
+
let layer = mk_layer "test layer data" in
86
+
`OCI_manifest
87
+
(Manifest.OCI.v ~artifact_type:"application/vnd.test" ~config [ layer ])
88
+
89
+
let test_manifest_roundtrip () =
90
+
with_cache (fun cache ->
91
+
let image = Oci.Image.v ~tag:"test" "myorg/myimage" in
92
+
let m = mk_manifest () in
93
+
Oci.Cache.Manifest.add cache image m;
94
+
let got = Oci.Cache.Manifest.get cache image in
95
+
match got with `OCI_manifest _ -> () | _ -> fail "expected OCI manifest")
96
+
97
+
let test_manifest_list_tags () =
98
+
with_cache (fun cache ->
99
+
let m = mk_manifest () in
100
+
Oci.Cache.Manifest.add cache (Oci.Image.v ~tag:"v1" "org/img") m;
101
+
Oci.Cache.Manifest.add cache (Oci.Image.v ~tag:"v2" "org/img") m;
102
+
let tags = Oci.Cache.Manifest.list_tags cache in
103
+
check int "two tagged images" 2 (List.length tags))
104
+
105
+
let test_manifest_list_empty () =
106
+
with_cache (fun cache ->
107
+
let all = Oci.Cache.Manifest.list cache in
108
+
check int "empty cache" 0 (List.length all))
109
+
110
+
let test_manifest_if_exists () =
111
+
with_cache (fun cache ->
112
+
let image = Oci.Image.v ~tag:"test" "org/name" in
113
+
let found_before = ref false in
114
+
let found_after = ref false in
115
+
Oci.Cache.Manifest.if_exists cache
116
+
~then_:(fun () -> found_before := true)
117
+
image;
118
+
Oci.Cache.Manifest.add cache image (mk_manifest ());
119
+
Oci.Cache.Manifest.if_exists cache
120
+
~then_:(fun () -> found_after := true)
121
+
image;
122
+
check bool "not found before" false !found_before;
123
+
check bool "found after" true !found_after)
124
+
125
+
let test_manifest_invalid_descriptor () =
126
+
let image = Oci.Image.v ~tag:"bad" "org/bad" in
127
+
(* Verify the exception type exists and can be constructed *)
128
+
let exn = Oci.Cache.Manifest.Invalid_descriptor (image, "test", "error") in
129
+
match exn with
130
+
| Oci.Cache.Manifest.Invalid_descriptor (_, ctx, msg) ->
131
+
check string "context" "test" ctx;
132
+
check string "message" "error" msg
133
+
| _ -> fail "wrong exception"
3
134
4
135
let suite =
5
136
( "cache",
6
-
[ Alcotest.test_case "module accessible" `Quick test_module_accessible ] )
137
+
[
138
+
test_case "init" `Quick test_init;
139
+
test_case "blob string roundtrip" `Quick test_blob_string_roundtrip;
140
+
test_case "blob binary roundtrip" `Quick test_blob_binary_roundtrip;
141
+
test_case "blob large" `Quick test_blob_large;
142
+
test_case "blob if_exists" `Quick test_blob_if_exists;
143
+
test_case "blob get_fd" `Quick test_blob_get_fd;
144
+
test_case "manifest roundtrip" `Quick test_manifest_roundtrip;
145
+
test_case "manifest list tags" `Quick test_manifest_list_tags;
146
+
test_case "manifest list empty" `Quick test_manifest_list_empty;
147
+
test_case "manifest if_exists" `Quick test_manifest_if_exists;
148
+
test_case "manifest invalid descriptor" `Quick
149
+
test_manifest_invalid_descriptor;
150
+
] )
+26
-1
test/spec/test_checkout.ml
+26
-1
test/spec/test_checkout.ml
···
1
+
open Alcotest
2
+
1
3
let test_api_accessible () =
2
4
ignore
3
5
(Oci.checkout
···
7
9
Oci.Image.t ->
8
10
unit)
9
11
12
+
let test_checkout_via_oci () =
13
+
(* Verify checkout is accessible through the Oci facade *)
14
+
ignore
15
+
(Oci.checkout
16
+
: ?platform:string ->
17
+
cache:Oci.Cache.t ->
18
+
root:[ `Dir ] Eio.Path.t ->
19
+
Oci.Image.t ->
20
+
unit)
21
+
22
+
let test_checkout_with_platform () =
23
+
(* Verify platform parameter is optional *)
24
+
ignore
25
+
(Oci.checkout ~platform:"linux/amd64"
26
+
: cache:Oci.Cache.t ->
27
+
root:[ `Dir ] Eio.Path.t ->
28
+
Oci.Image.t ->
29
+
unit)
30
+
10
31
let suite =
11
32
( "checkout",
12
-
[ Alcotest.test_case "api accessible" `Quick test_api_accessible ] )
33
+
[
34
+
test_case "api accessible" `Quick test_api_accessible;
35
+
test_case "checkout via oci" `Quick test_checkout_via_oci;
36
+
test_case "checkout with platform" `Quick test_checkout_with_platform;
37
+
] )
+95
-1
test/spec/test_display.ml
+95
-1
test/spec/test_display.ml
···
1
-
let suite = ("display", [ Alcotest.test_case "base" `Quick (fun () -> ()) ])
1
+
open Alcotest
2
+
open Oci_spec
3
+
4
+
(* Display is internal to the oci library. We test the public image/descriptor
5
+
types that feed into it, and verify the types compile correctly. *)
6
+
7
+
let test_image_to_string () =
8
+
let cases =
9
+
[
10
+
("alpine:latest", "alpine:latest");
11
+
("ghcr.io/org/name:v1", "ghcr.io/org/name:v1");
12
+
("localhost:5000/img:test", "localhost:5000/img:test");
13
+
]
14
+
in
15
+
List.iter
16
+
(fun (input, expected) ->
17
+
let i =
18
+
match Oci.Image.of_string input with
19
+
| Ok i -> i
20
+
| Error (`Msg e) -> failf "parse %s: %s" input e
21
+
in
22
+
check string
23
+
(Fmt.str "to_string %s" input)
24
+
expected (Oci.Image.to_string i))
25
+
cases
26
+
27
+
let test_descriptor_media_type_labels () =
28
+
(* These media types are used by Display to choose label prefixes *)
29
+
let cases =
30
+
[
31
+
("application/vnd.oci.image.manifest.v1+json", "manifest");
32
+
("application/vnd.oci.image.config.v1+json", "config");
33
+
("application/vnd.oci.image.layer.v1.tar+gzip", "layer");
34
+
("application/vnd.oci.image.index.v1+json", "index");
35
+
]
36
+
in
37
+
List.iter
38
+
(fun (mt_str, label) ->
39
+
match Media_type.of_string mt_str with
40
+
| Ok mt ->
41
+
let d =
42
+
Descriptor.v ~media_type:mt ~size:100L (Digest.hash SHA256 label)
43
+
in
44
+
(* Verify descriptor carries the media type *)
45
+
check string
46
+
(Fmt.str "media type for %s" label)
47
+
mt_str
48
+
(Media_type.to_string (Descriptor.media_type d))
49
+
| Error (`Msg e) -> failf "parse media type %s: %s" mt_str e)
50
+
cases
51
+
52
+
let test_descriptor_digest_for_display () =
53
+
let data = "test content" in
54
+
let digest = Digest.hash SHA256 data in
55
+
let hash = Digest.encoded_hash digest in
56
+
check bool "hash is hex string" true (String.length hash = 64);
57
+
(* Display uses first N chars of hash as label *)
58
+
let prefix = String.sub hash 0 12 in
59
+
check int "prefix length" 12 (String.length prefix)
60
+
61
+
let test_descriptor_size_for_display () =
62
+
let mt =
63
+
match Media_type.of_string "application/octet-stream" with
64
+
| Ok m -> m
65
+
| Error (`Msg e) -> failf "parse: %s" e
66
+
in
67
+
let d = Descriptor.v ~media_type:mt ~size:1048576L (Digest.hash SHA256 "x") in
68
+
check int64 "1 MiB" 1048576L (Descriptor.size d)
69
+
70
+
let test_image_reference_for_display () =
71
+
let i = Oci.Image.v ~tag:"v1.0" "ghcr.io/org/name" in
72
+
check string "reference" "v1.0" (Oci.Image.reference i)
73
+
74
+
let test_image_reference_digest () =
75
+
let sha =
76
+
"sha256:5b0bcabd1ed22e9fb1310cf6c2dec7cdef19f0ad69efa1f392e94a4333501270"
77
+
in
78
+
match Oci.Image.of_string ("alpine@" ^ sha) with
79
+
| Ok i -> check string "reference is digest" sha (Oci.Image.reference i)
80
+
| Error (`Msg e) -> fail e
81
+
82
+
let suite =
83
+
( "display",
84
+
[
85
+
test_case "image to_string" `Quick test_image_to_string;
86
+
test_case "descriptor media type labels" `Quick
87
+
test_descriptor_media_type_labels;
88
+
test_case "descriptor digest for display" `Quick
89
+
test_descriptor_digest_for_display;
90
+
test_case "descriptor size for display" `Quick
91
+
test_descriptor_size_for_display;
92
+
test_case "image reference for display" `Quick
93
+
test_image_reference_for_display;
94
+
test_case "image reference digest" `Quick test_image_reference_digest;
95
+
] )
+46
-4
test/spec/test_fetch.ml
+46
-4
test/spec/test_fetch.ml
···
1
+
open Alcotest
2
+
1
3
let test_credential_type () =
2
-
let _cred : Oci.Fetch.API.credential =
4
+
let cred : Oci.Fetch.API.credential =
3
5
{ username = "user"; password = "pass" }
4
6
in
5
-
()
7
+
check string "username" "user" cred.username;
8
+
check string "password" "pass" cred.password
6
9
7
10
let test_client_constructor () =
8
11
ignore
9
12
(Oci.Fetch.client
10
13
: net:_ Eio.Net.t -> clock:_ Eio.Time.clock -> Oci.Fetch.client)
11
14
15
+
let test_run_type () =
16
+
ignore
17
+
(Oci.Fetch.run
18
+
: ?show_progress:bool ->
19
+
?platform:string ->
20
+
cache:Oci.Cache.t ->
21
+
client:Oci.Fetch.client ->
22
+
domain_mgr:Eio.Domain_manager.ty Eio.Resource.t ->
23
+
?username:string ->
24
+
?password:string ->
25
+
Oci.Image.t ->
26
+
unit)
27
+
28
+
let test_get_token_type () =
29
+
ignore
30
+
(Oci.Fetch.API.get_token
31
+
: Oci.Fetch.client ->
32
+
?credentials:Oci.Fetch.API.credential ->
33
+
?scope_actions:string ->
34
+
Oci.Image.t ->
35
+
string)
36
+
37
+
let test_credential_construction () =
38
+
let cred : Oci.Fetch.API.credential = { username = ""; password = "" } in
39
+
check string "empty username" "" cred.username;
40
+
check string "empty password" "" cred.password
41
+
42
+
let test_credential_with_special_chars () =
43
+
let cred : Oci.Fetch.API.credential =
44
+
{ username = "user@domain.com"; password = "p@ss:w0rd/special" }
45
+
in
46
+
check string "special username" "user@domain.com" cred.username;
47
+
check string "special password" "p@ss:w0rd/special" cred.password
48
+
12
49
let suite =
13
50
( "fetch",
14
51
[
15
-
Alcotest.test_case "credential type" `Quick test_credential_type;
16
-
Alcotest.test_case "client constructor" `Quick test_client_constructor;
52
+
test_case "credential type" `Quick test_credential_type;
53
+
test_case "client constructor" `Quick test_client_constructor;
54
+
test_case "run type" `Quick test_run_type;
55
+
test_case "get_token type" `Quick test_get_token_type;
56
+
test_case "credential construction" `Quick test_credential_construction;
57
+
test_case "credential special chars" `Quick
58
+
test_credential_with_special_chars;
17
59
] )
+88
-1
test/spec/test_flow.ml
+88
-1
test/spec/test_flow.ml
···
1
-
let suite = ("flow", [ Alcotest.test_case "base" `Quick (fun () -> ()) ])
1
+
open Alcotest
2
+
open Oci_spec
3
+
4
+
(* Flow is internal to the oci library, so we test it indirectly
5
+
through Cache.Blob operations which use flows under the hood. *)
6
+
7
+
let with_cache f =
8
+
Eio_main.run @@ fun env ->
9
+
let fs = Eio.Stdenv.fs env in
10
+
let tmpdir = Filename.temp_dir "oci_test_flow" "" in
11
+
Fun.protect
12
+
~finally:(fun () -> ignore (Sys.command (Fmt.str "rm -rf %s" tmpdir)))
13
+
(fun () ->
14
+
let dir = Eio.Path.(fs / tmpdir) in
15
+
let cache = Oci.Cache.v dir in
16
+
Oci.Cache.init cache;
17
+
f cache)
18
+
19
+
let test_blob_string_integrity () =
20
+
with_cache (fun cache ->
21
+
let data = "integrity check data" in
22
+
let digest = Digest.hash SHA256 data in
23
+
Oci.Cache.Blob.add_string cache digest data;
24
+
let got = Oci.Cache.Blob.get_string cache digest in
25
+
check string "data preserved" data got)
26
+
27
+
let test_blob_empty () =
28
+
with_cache (fun cache ->
29
+
let data = "" in
30
+
let digest = Digest.hash SHA256 data in
31
+
Oci.Cache.Blob.add_string cache digest data;
32
+
let got = Oci.Cache.Blob.get_string cache digest in
33
+
check string "empty blob" data got)
34
+
35
+
let test_blob_binary () =
36
+
with_cache (fun cache ->
37
+
let data = String.init 256 Char.chr in
38
+
let digest = Digest.hash SHA256 data in
39
+
Oci.Cache.Blob.add_string cache digest data;
40
+
let got = Oci.Cache.Blob.get_string cache digest in
41
+
check int "binary length" 256 (String.length got);
42
+
check string "binary content" data got)
43
+
44
+
let test_blob_large () =
45
+
with_cache (fun cache ->
46
+
let data = String.make 1_000_000 'X' in
47
+
let digest = Digest.hash SHA256 data in
48
+
Oci.Cache.Blob.add_string cache digest data;
49
+
let got = Oci.Cache.Blob.get_string cache digest in
50
+
check int "large blob" 1_000_000 (String.length got))
51
+
52
+
let test_blob_fd_read () =
53
+
with_cache (fun cache ->
54
+
let data = "fd read test" in
55
+
let digest = Digest.hash SHA256 data in
56
+
Oci.Cache.Blob.add_string cache digest data;
57
+
Eio.Switch.run @@ fun sw ->
58
+
let fd = Oci.Cache.Blob.get_fd ~sw cache digest in
59
+
let got = Eio.Flow.read_all fd in
60
+
check string "fd read" data got)
61
+
62
+
let test_multiple_blobs () =
63
+
with_cache (fun cache ->
64
+
let blobs =
65
+
List.init 10 (fun i ->
66
+
let data = Fmt.str "blob-%d-content" i in
67
+
let digest = Digest.hash SHA256 data in
68
+
(data, digest))
69
+
in
70
+
List.iter
71
+
(fun (data, digest) -> Oci.Cache.Blob.add_string cache digest data)
72
+
blobs;
73
+
List.iter
74
+
(fun (data, digest) ->
75
+
let got = Oci.Cache.Blob.get_string cache digest in
76
+
check string "multi blob" data got)
77
+
blobs)
78
+
79
+
let suite =
80
+
( "flow",
81
+
[
82
+
test_case "blob string integrity" `Quick test_blob_string_integrity;
83
+
test_case "blob empty" `Quick test_blob_empty;
84
+
test_case "blob binary" `Quick test_blob_binary;
85
+
test_case "blob large" `Quick test_blob_large;
86
+
test_case "blob fd read" `Quick test_blob_fd_read;
87
+
test_case "multiple blobs" `Quick test_multiple_blobs;
88
+
] )
+31
-3
test/spec/test_ls.ml
+31
-3
test/spec/test_ls.ml
···
1
+
open Alcotest
2
+
open Oci_spec
3
+
1
4
let test_accessors () =
2
5
ignore (Oci.List.repository : Oci.List.t -> string);
3
6
ignore (Oci.List.tags : Oci.List.t -> string list);
4
-
ignore (Oci.List.digest : Oci.List.t -> Oci_spec.Digest.t);
5
-
ignore (Oci.List.platform : Oci.List.t -> Oci_spec.Platform.t option);
7
+
ignore (Oci.List.digest : Oci.List.t -> Digest.t);
8
+
ignore (Oci.List.platform : Oci.List.t -> Platform.t option);
6
9
ignore (Oci.List.size : Oci.List.t -> string)
7
10
8
-
let suite = ("ls", [ Alcotest.test_case "accessors" `Quick test_accessors ])
11
+
let with_cache f =
12
+
Eio_main.run @@ fun env ->
13
+
let fs = Eio.Stdenv.fs env in
14
+
let tmpdir = Filename.temp_dir "oci_test_ls" "" in
15
+
Fun.protect
16
+
~finally:(fun () -> ignore (Sys.command (Fmt.str "rm -rf %s" tmpdir)))
17
+
(fun () ->
18
+
let dir = Eio.Path.(fs / tmpdir) in
19
+
let cache = Oci.Cache.v dir in
20
+
Oci.Cache.init cache;
21
+
f cache)
22
+
23
+
let test_list_empty () =
24
+
with_cache (fun cache ->
25
+
let entries = Oci.list ~cache in
26
+
check int "empty list" 0 (List.length entries))
27
+
28
+
let test_list_type () = ignore (Oci.list : cache:Oci.Cache.t -> Oci.List.t list)
29
+
30
+
let suite =
31
+
( "ls",
32
+
[
33
+
test_case "accessors" `Quick test_accessors;
34
+
test_case "list empty cache" `Quick test_list_empty;
35
+
test_case "list type" `Quick test_list_type;
36
+
] )
+53
-5
test/spec/test_oci.ml
+53
-5
test/spec/test_oci.ml
···
1
+
open Alcotest
2
+
1
3
let test_facade_modules () =
2
4
ignore (Oci.Spec.Common.json_of_string "{}");
3
5
ignore (Oci.Spec.Digest.sha256 (String.make 64 'a'));
4
-
ignore (Oci.Spec.Media_type.OCI.Image_index : Oci.Spec.Media_type.OCI.t);
5
-
ignore (Oci.Spec.Annotation.Ref_name : Oci.Spec.Annotation.t)
6
+
ignore Oci.Spec.Arch.to_string;
7
+
ignore Oci.Spec.OS.to_string;
8
+
ignore Oci.Spec.Platform.jsont;
9
+
ignore Oci.Spec.Intoto.jsont;
10
+
ignore Oci.Spec.Auth.jsont;
11
+
ignore Oci.Spec.Media_type.to_string;
12
+
ignore Oci.Spec.Content_type.to_string;
13
+
ignore Oci.Spec.Annotation.to_string;
14
+
ignore Oci.Spec.Blob.media_type;
15
+
ignore (Oci.Spec.Layer.pp : Oci.Spec.Layer.t Fmt.t);
16
+
ignore (Oci.Spec.Descriptor.empty : Oci.Spec.Descriptor.t);
17
+
ignore Oci.Spec.Layout.jsont
6
18
7
19
let test_facade_functions () =
8
20
ignore (Oci.show : cache:Oci.Cache.t -> Oci.Image.t -> unit);
9
-
ignore (Oci.list : cache:Oci.Cache.t -> Oci.List.t list)
21
+
ignore (Oci.list : cache:Oci.Cache.t -> Oci.List.t list);
22
+
ignore
23
+
(Oci.checkout
24
+
: ?platform:string ->
25
+
cache:Oci.Cache.t ->
26
+
root:[ `Dir ] Eio.Path.t ->
27
+
Oci.Image.t ->
28
+
unit);
29
+
ignore
30
+
(Oci.fetch
31
+
: ?show_progress:bool ->
32
+
?platform:string ->
33
+
cache:Oci.Cache.t ->
34
+
client:Oci.Fetch.client ->
35
+
domain_mgr:Eio.Domain_manager.ty Eio.Resource.t ->
36
+
?username:string ->
37
+
?password:string ->
38
+
Oci.Image.t ->
39
+
unit);
40
+
ignore
41
+
(Oci.push
42
+
: client:Oci.Fetch.client ->
43
+
?username:string ->
44
+
?password:string ->
45
+
Oci.Image.t ->
46
+
files:(string * string) list ->
47
+
unit)
48
+
49
+
let test_submodule_reexports () =
50
+
(* Verify all submodules are accessible through Oci *)
51
+
ignore (Oci.Cache.v : [ `Dir ] Eio.Path.t -> Oci.Cache.t);
52
+
ignore (Oci.Image.of_string : string -> (Oci.Image.t, _) result);
53
+
ignore
54
+
(Oci.Util.guess_manifest
55
+
: Oci.Spec.Manifest.t -> Oci.Spec.Descriptor.t option);
56
+
ignore (Oci.Attestation.pp : Oci.Attestation.t Fmt.t)
10
57
11
58
let suite =
12
59
( "oci",
13
60
[
14
-
Alcotest.test_case "facade modules" `Quick test_facade_modules;
15
-
Alcotest.test_case "facade functions" `Quick test_facade_functions;
61
+
test_case "facade modules" `Quick test_facade_modules;
62
+
test_case "facade functions" `Quick test_facade_functions;
63
+
test_case "submodule reexports" `Quick test_submodule_reexports;
16
64
] )
+79
-1
test/spec/test_oci_spec.ml
+79
-1
test/spec/test_oci_spec.ml
···
17
17
ignore Auth.jsont
18
18
19
19
let test_oci_accessors () =
20
-
(* Verify accessor types compile - these are type-level tests *)
21
20
ignore (manifest : oci -> Manifest.OCI.t);
22
21
ignore (index : oci -> Index.t option);
23
22
ignore (layers : oci -> Layer.t list);
···
26
25
let test_docker_accessors () =
27
26
ignore (manifest_list : docker -> Manifest_list.t)
28
27
28
+
let test_digest_sha256 () =
29
+
let d = Digest.hash SHA256 "hello" in
30
+
let s = Digest.to_string d in
31
+
Alcotest.(check bool)
32
+
"starts with sha256:" true
33
+
(Astring.String.is_prefix ~affix:"sha256:" s)
34
+
35
+
let test_digest_roundtrip () =
36
+
let d = Digest.hash SHA256 "test data" in
37
+
let s = Digest.to_string d in
38
+
match Digest.of_string s with
39
+
| Ok d' -> Alcotest.(check bool) "roundtrip" true (Digest.equal d d')
40
+
| Error (`Msg e) -> Alcotest.fail e
41
+
42
+
let test_media_type_roundtrip () =
43
+
let cases =
44
+
[
45
+
"application/vnd.oci.image.manifest.v1+json";
46
+
"application/vnd.docker.distribution.manifest.v2+json";
47
+
"application/vnd.oci.image.index.v1+json";
48
+
"application/octet-stream";
49
+
]
50
+
in
51
+
List.iter
52
+
(fun s ->
53
+
match Media_type.of_string s with
54
+
| Ok mt ->
55
+
Alcotest.(check string)
56
+
(Fmt.str "roundtrip %s" s) s (Media_type.to_string mt)
57
+
| Error (`Msg e) -> Alcotest.failf "parse %s: %s" s e)
58
+
cases
59
+
60
+
let test_descriptor_construction () =
61
+
let mt =
62
+
match Media_type.of_string "application/octet-stream" with
63
+
| Ok m -> m
64
+
| Error (`Msg e) -> Alcotest.fail e
65
+
in
66
+
let d = Descriptor.v ~media_type:mt ~size:42L (Digest.hash SHA256 "data") in
67
+
Alcotest.(check int64) "size" 42L (Descriptor.size d);
68
+
Alcotest.(check string)
69
+
"media_type" "application/octet-stream"
70
+
(Media_type.to_string (Descriptor.media_type d))
71
+
72
+
let test_descriptor_empty () =
73
+
let d = Descriptor.empty in
74
+
(* empty descriptor has size 2 for the empty JSON config "{}" *)
75
+
Alcotest.(check int64) "empty size" 2L (Descriptor.size d)
76
+
77
+
let test_platform_construction () =
78
+
match Arch.of_string "amd64" with
79
+
| Error (`Msg e) -> Alcotest.fail e
80
+
| Ok arch -> (
81
+
match OS.of_string "linux" with
82
+
| Error (`Msg e) -> Alcotest.fail e
83
+
| Ok os ->
84
+
let p = Platform.v arch os in
85
+
Alcotest.(check string)
86
+
"arch" "amd64"
87
+
(Arch.to_string (Platform.arch p));
88
+
Alcotest.(check string) "os" "linux" (OS.to_string (Platform.os p)))
89
+
90
+
let test_annotation_roundtrip () =
91
+
let cases = [ "org.opencontainers.image.ref.name" ] in
92
+
List.iter
93
+
(fun s ->
94
+
let a = Annotation.of_string s in
95
+
Alcotest.(check string) "roundtrip" s (Annotation.to_string a))
96
+
cases
97
+
29
98
let suite =
30
99
( "oci_spec",
31
100
[
32
101
Alcotest.test_case "modules" `Quick test_modules;
33
102
Alcotest.test_case "oci accessors" `Quick test_oci_accessors;
34
103
Alcotest.test_case "docker accessors" `Quick test_docker_accessors;
104
+
Alcotest.test_case "digest sha256" `Quick test_digest_sha256;
105
+
Alcotest.test_case "digest roundtrip" `Quick test_digest_roundtrip;
106
+
Alcotest.test_case "media type roundtrip" `Quick test_media_type_roundtrip;
107
+
Alcotest.test_case "descriptor construction" `Quick
108
+
test_descriptor_construction;
109
+
Alcotest.test_case "descriptor empty" `Quick test_descriptor_empty;
110
+
Alcotest.test_case "platform construction" `Quick
111
+
test_platform_construction;
112
+
Alcotest.test_case "annotation roundtrip" `Quick test_annotation_roundtrip;
35
113
] )
+56
-1
test/spec/test_show.ml
+56
-1
test/spec/test_show.ml
···
1
+
open Alcotest
2
+
open Oci_spec
3
+
4
+
let with_cache f =
5
+
Eio_main.run @@ fun env ->
6
+
let fs = Eio.Stdenv.fs env in
7
+
let tmpdir = Filename.temp_dir "oci_test_show" "" in
8
+
Fun.protect
9
+
~finally:(fun () -> ignore (Sys.command (Fmt.str "rm -rf %s" tmpdir)))
10
+
(fun () ->
11
+
let dir = Eio.Path.(fs / tmpdir) in
12
+
let cache = Oci.Cache.v dir in
13
+
Oci.Cache.init cache;
14
+
f cache)
15
+
16
+
let mk_manifest () =
17
+
let config_mt =
18
+
match Media_type.of_string "application/vnd.oci.empty.v1+json" with
19
+
| Ok m -> m
20
+
| Error (`Msg e) -> failwith e
21
+
in
22
+
let config =
23
+
Descriptor.v ~media_type:config_mt ~size:2L (Digest.hash SHA256 "{}")
24
+
in
25
+
let layer_mt =
26
+
match Media_type.of_string "application/octet-stream" with
27
+
| Ok m -> m
28
+
| Error (`Msg e) -> failwith e
29
+
in
30
+
let layer =
31
+
Descriptor.v ~media_type:layer_mt ~size:4L (Digest.hash SHA256 "data")
32
+
in
33
+
`OCI_manifest
34
+
(Manifest.OCI.v ~artifact_type:"application/vnd.test" ~config [ layer ])
35
+
36
+
let test_show_oci_manifest () =
37
+
with_cache (fun cache ->
38
+
let image = Oci.Image.v ~tag:"test" "org/show-test" in
39
+
Oci.Cache.Manifest.add cache image (mk_manifest ());
40
+
(* show prints to Fmt.stdout; just verify it doesn't crash *)
41
+
Oci.show ~cache image)
42
+
43
+
let test_show_retrieves_manifest () =
44
+
with_cache (fun cache ->
45
+
let image = Oci.Image.v ~tag:"test" "org/show-test" in
46
+
Oci.Cache.Manifest.add cache image (mk_manifest ());
47
+
(* Verify we can get the manifest that show reads *)
48
+
let m = Oci.Cache.Manifest.get cache image in
49
+
match m with `OCI_manifest _ -> () | _ -> fail "expected OCI manifest")
50
+
1
51
let test_api_accessible () =
2
52
ignore (Oci.show : cache:Oci.Cache.t -> Oci.Image.t -> unit)
3
53
4
54
let suite =
5
-
("show", [ Alcotest.test_case "api accessible" `Quick test_api_accessible ])
55
+
( "show",
56
+
[
57
+
test_case "api accessible" `Quick test_api_accessible;
58
+
test_case "show OCI manifest" `Quick test_show_oci_manifest;
59
+
test_case "show retrieves manifest" `Quick test_show_retrieves_manifest;
60
+
] )
+105
-5
test/spec/test_util.ml
+105
-5
test/spec/test_util.ml
···
1
+
open Alcotest
2
+
open Oci_spec
3
+
1
4
let test_guess_manifest_api () =
2
-
ignore
3
-
(Oci.Util.guess_manifest
4
-
: Oci_spec.Manifest.t -> Oci_spec.Descriptor.t option)
5
+
ignore (Oci.Util.guess_manifest : Manifest.t -> Descriptor.t option)
6
+
7
+
(* Build an OCI index with a descriptor matching the local platform *)
8
+
let test_guess_manifest_oci_index () =
9
+
let local_arch = Osrelease.Arch.v () in
10
+
let local_os = Osrelease.OS.v () in
11
+
let arch_str = Osrelease.Arch.to_string local_arch in
12
+
let os_str = Osrelease.OS.to_string local_os in
13
+
let json =
14
+
Fmt.str
15
+
{|{
16
+
"schemaVersion": 2,
17
+
"mediaType": "application/vnd.oci.image.index.v1+json",
18
+
"manifests": [
19
+
{
20
+
"mediaType": "application/vnd.oci.image.manifest.v1+json",
21
+
"size": 100,
22
+
"digest": "sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
23
+
"platform": { "architecture": "%s", "os": "%s" }
24
+
},
25
+
{
26
+
"mediaType": "application/vnd.oci.image.manifest.v1+json",
27
+
"size": 200,
28
+
"digest": "sha256:bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
29
+
"platform": { "architecture": "s390x", "os": "linux" }
30
+
}
31
+
]
32
+
}|}
33
+
arch_str os_str
34
+
in
35
+
match Common.json_of_string json with
36
+
| Error _ -> fail "invalid json"
37
+
| Ok j -> (
38
+
match Index.of_yojson j with
39
+
| Error e -> fail e
40
+
| Ok idx -> (
41
+
let m : Manifest.t = `OCI_index idx in
42
+
match Oci.Util.guess_manifest m with
43
+
| None -> fail "expected to find local platform"
44
+
| Some d ->
45
+
let digest_str = Digest.to_string (Descriptor.digest d) in
46
+
check bool "matched first descriptor" true
47
+
(Astring.String.is_infix ~affix:"aaa" digest_str)))
48
+
49
+
let test_guess_manifest_no_match () =
50
+
let json =
51
+
{|{
52
+
"schemaVersion": 2,
53
+
"mediaType": "application/vnd.oci.image.index.v1+json",
54
+
"manifests": [
55
+
{
56
+
"mediaType": "application/vnd.oci.image.manifest.v1+json",
57
+
"size": 100,
58
+
"digest": "sha256:cccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccccc",
59
+
"platform": { "architecture": "s390x", "os": "zos" }
60
+
}
61
+
]
62
+
}|}
63
+
in
64
+
match Common.json_of_string json with
65
+
| Error _ -> fail "invalid json"
66
+
| Ok j -> (
67
+
match Index.of_yojson j with
68
+
| Error e -> fail e
69
+
| Ok idx -> (
70
+
let m : Manifest.t = `OCI_index idx in
71
+
match Oci.Util.guess_manifest m with
72
+
| None -> ()
73
+
| Some _ -> fail "expected no match for exotic platform"))
74
+
75
+
let test_guess_manifest_no_platform () =
76
+
let json =
77
+
{|{
78
+
"schemaVersion": 2,
79
+
"mediaType": "application/vnd.oci.image.index.v1+json",
80
+
"manifests": [
81
+
{
82
+
"mediaType": "application/vnd.oci.image.manifest.v1+json",
83
+
"size": 100,
84
+
"digest": "sha256:dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd"
85
+
}
86
+
]
87
+
}|}
88
+
in
89
+
match Common.json_of_string json with
90
+
| Error _ -> fail "invalid json"
91
+
| Ok j -> (
92
+
match Index.of_yojson j with
93
+
| Error e -> fail e
94
+
| Ok idx -> (
95
+
let m : Manifest.t = `OCI_index idx in
96
+
match Oci.Util.guess_manifest m with
97
+
| None -> ()
98
+
| Some _ -> fail "expected None for descriptor without platform"))
5
99
6
100
let suite =
7
101
( "util",
8
-
[ Alcotest.test_case "guess_manifest api" `Quick test_guess_manifest_api ]
9
-
)
102
+
[
103
+
test_case "guess_manifest api" `Quick test_guess_manifest_api;
104
+
test_case "guess_manifest local platform" `Quick
105
+
test_guess_manifest_oci_index;
106
+
test_case "guess_manifest no match" `Quick test_guess_manifest_no_match;
107
+
test_case "guess_manifest no platform" `Quick
108
+
test_guess_manifest_no_platform;
109
+
] )