27860136669

Committed 20 Jun 2026 04:26AM UTC coverage: 99.098%. First build

Build # 27860136669

Build Type

Pull #27

github

Committed by

web-flow

Commit Message

Merge 91f5f6083 into 9d8ae9377

Pull Request Pull Request #27: [Tests] Reach 100% branch coverage

Coverage Stats

1540 of 1598 branches covered (96.37%)

Branch coverage included in aggregate %.

57 of 64 new or added lines in 17 files covered. (89.06%)

5713 of 5721 relevant lines covered (99.86%)

4.35 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

95.24

/src/main/java/io/valkyrja/http/message/file/collection/UploadedFileCollection.java

/*
 * This file is part of the Valkyrja Framework package.
 *
 * (c) Melech Mizrachi <melechmizrachi@gmail.com>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

package io.valkyrja.http.message.file.collection;

import io.valkyrja.http.message.file.collection.contract.UploadedFileCollectionContract;
import io.valkyrja.http.message.file.contract.UploadedFileContract;
import io.valkyrja.http.message.file.throwable.exception.UploadedFileInvalidKeyException;
import io.valkyrja.http.message.file.throwable.exception.UploadedFileInvalidParamException;
import java.util.Arrays;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;

public class UploadedFileCollection implements UploadedFileCollectionContract {

    protected Map<String, UploadedFileContract> files = new LinkedHashMap<>();

    public UploadedFileCollection(Map<String, UploadedFileContract> files) {
        this.files = new LinkedHashMap<>(files);
    }

    public static UploadedFileCollection fromArray(Map<String, UploadedFileContract> data) {
        for (UploadedFileContract value : data.values()) {
            validateFile(value);
        }
        return new UploadedFileCollection(data);
    }

    protected static void validateFile(UploadedFileContract file) {
        if (file == null) {
            throw new UploadedFileInvalidParamException(
                    "File must be an UploadedFileContract instance");
        }
    }

    @Override
    public boolean has(String key) {
        return files.containsKey(key);
    }

    @Override
    public UploadedFileContract get(String key) {
        if (!files.containsKey(key)) {
            throw new UploadedFileInvalidKeyException(
                    "The provided key '" + key + "' does not exist in the collection");
        }
        return files.get(key);
    }

    @Override
    public Map<String, UploadedFileContract> getAll() {
        return new LinkedHashMap<>(files);
    }

    @Override
    public Map<String, UploadedFileContract> getOnly(String... keys) {
        Set<String> keySet = Arrays.stream(keys).collect(Collectors.toSet());
        return files.entrySet().stream()
                .filter(e -> keySet.contains(e.getKey()))
                .collect(
                        Collectors.toMap(
                                Map.Entry::getKey,
                                Map.Entry::getValue,
                                (a, b) -> a,
                                LinkedHashMap::new));
    }

    @Override
    public Map<String, UploadedFileContract> getAllExcept(String... keys) {
        Set<String> keySet = Arrays.stream(keys).collect(Collectors.toSet());
        return files.entrySet().stream()
                .filter(e -> !keySet.contains(e.getKey()))
                .collect(
                        Collectors.toMap(
                                Map.Entry::getKey,
                                Map.Entry::getValue,
                                (a, b) -> a,
                                LinkedHashMap::new));
    }

    @Override
    public UploadedFileCollectionContract with(Map<String, UploadedFileContract> collection) {
        UploadedFileCollection copy = new UploadedFileCollection(files);
        copy.files = new LinkedHashMap<>(collection);
        return copy;
    }

    @Override
    public UploadedFileCollectionContract withAdded(Map<String, UploadedFileContract> collection) {
        UploadedFileCollection copy = new UploadedFileCollection(files);
        copy.files.putAll(collection);
        return copy;
    }
}

1	/*
2	* This file is part of the Valkyrja Framework package.
3	*
4	* (c) Melech Mizrachi <melechmizrachi@gmail.com>
5	*
6	* For the full copyright and license information, please view the LICENSE
7	* file that was distributed with this source code.
8	*/
9
10	package io.valkyrja.http.message.file.collection;
11
12	import io.valkyrja.http.message.file.collection.contract.UploadedFileCollectionContract;
13	import io.valkyrja.http.message.file.contract.UploadedFileContract;
14	import io.valkyrja.http.message.file.throwable.exception.UploadedFileInvalidKeyException;
15	import io.valkyrja.http.message.file.throwable.exception.UploadedFileInvalidParamException;
16	import java.util.Arrays;
17	import java.util.LinkedHashMap;
18	import java.util.Map;
19	import java.util.Set;
20	import java.util.stream.Collectors;
21
22	public class UploadedFileCollection implements UploadedFileCollectionContract {
23
24	protected Map<String, UploadedFileContract> files = new LinkedHashMap<>();	5✔
25
26	public UploadedFileCollection(Map<String, UploadedFileContract> files) {	2✔
27	this.files = new LinkedHashMap<>(files);	6✔
28	}	1✔
29
30	public static UploadedFileCollection fromArray(Map<String, UploadedFileContract> data) {
31	for (UploadedFileContract value : data.values()) {	11✔
32	validateFile(value);	2✔
33	}	1✔
34	return new UploadedFileCollection(data);	5✔
35	}
36
37	protected static void validateFile(UploadedFileContract file) {
38	if (file == null) {	2✔
39	throw new UploadedFileInvalidParamException(	5✔
40	"File must be an UploadedFileContract instance");
41	}
42	}	1✔
43
44	@Override
45	public boolean has(String key) {
46	return files.containsKey(key);	5✔
47	}
48
49	@Override
50	public UploadedFileContract get(String key) {
51	if (!files.containsKey(key)) {	5✔
52	throw new UploadedFileInvalidKeyException(	6✔
53	"The provided key '" + key + "' does not exist in the collection");
54	}
55	return files.get(key);	6✔
56	}
57
58	@Override
59	public Map<String, UploadedFileContract> getAll() {
60	return new LinkedHashMap<>(files);	6✔
61	}
62
63	@Override
64	public Map<String, UploadedFileContract> getOnly(String... keys) {
65	Set<String> keySet = Arrays.stream(keys).collect(Collectors.toSet());	6✔
66	return files.entrySet().stream()	7✔
67	.filter(e -> keySet.contains(e.getKey()))	10✔
68	.collect(	2✔
69	Collectors.toMap(	1✔
70	Map.Entry::getKey,
71	Map.Entry::getValue,
NEW 72	(a, b) -> a,	×
73	LinkedHashMap::new));
74	}
75
76	@Override
77	public Map<String, UploadedFileContract> getAllExcept(String... keys) {
78	Set<String> keySet = Arrays.stream(keys).collect(Collectors.toSet());	6✔
79	return files.entrySet().stream()	7✔
80	.filter(e -> !keySet.contains(e.getKey()))	14✔
81	.collect(	2✔
82	Collectors.toMap(	1✔
83	Map.Entry::getKey,
84	Map.Entry::getValue,
NEW 85	(a, b) -> a,	×
86	LinkedHashMap::new));
87	}
88
89	@Override
90	public UploadedFileCollectionContract with(Map<String, UploadedFileContract> collection) {
91	UploadedFileCollection copy = new UploadedFileCollection(files);	6✔
92	copy.files = new LinkedHashMap<>(collection);	6✔
93	return copy;	2✔
94	}
95
96	@Override
97	public UploadedFileCollectionContract withAdded(Map<String, UploadedFileContract> collection) {
98	UploadedFileCollection copy = new UploadedFileCollection(files);	6✔
99	copy.files.putAll(collection);	4✔
100	return copy;	2✔
101	}
102	}

valkyrjaio / valkyrja-java / 27860136669

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous