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

98.04

/src/main/java/io/valkyrja/http/message/header/collection/HeaderCollection.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.header.collection;

import io.valkyrja.http.message.header.collection.contract.HeaderCollectionContract;
import io.valkyrja.http.message.header.contract.HeaderContract;
import io.valkyrja.http.message.header.throwable.exception.HttpHeaderInvalidHeaderNameException;
import io.valkyrja.http.message.header.throwable.exception.HttpHeaderInvalidHeaderParamException;
import java.util.Arrays;
import java.util.LinkedHashMap;
import java.util.Locale;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;

public class HeaderCollection implements HeaderCollectionContract {

    protected LinkedHashMap<String, HeaderContract> headers = new LinkedHashMap<>();

    protected int position = 0;

    public HeaderCollection(HeaderContract... headers) {
        setHeaders(headers);
    }

    public static HeaderCollection fromArray(Map<?, ?> data) {
        HeaderContract[] headers = new HeaderContract[data.size()];
        int i = 0;

        for (Map.Entry<?, ?> entry : data.entrySet()) {
            validateHeader(entry.getValue());
            headers[i++] = (HeaderContract) entry.getValue();
        }

        return new HeaderCollection(headers);
    }

    protected static void validateHeader(Object param) {
        if (!(param instanceof HeaderContract)) {
            throw new HttpHeaderInvalidHeaderParamException("Param must be header");
        }
    }

    @Override
    public boolean has(String name) {
        return headers.containsKey(name.toLowerCase(Locale.ROOT));
    }

    @Override
    public HeaderContract get(String name) {
        HeaderContract header = headers.get(name.toLowerCase(Locale.ROOT));

        if (header == null) {
            throw new HttpHeaderInvalidHeaderNameException("Header " + name + " does not exist");
        }

        return header;
    }

    @Override
    public String getHeaderLine(String name) {
        if (!has(name)) {
            return "";
        }

        return get(name).getHeaderLine();
    }

    @Override
    public Map<String, HeaderContract> getAll() {
        return headers;
    }

    @Override
    public Map<String, HeaderContract> getOnly(String... names) {
        Set<String> nameSet = Arrays.stream(names).collect(Collectors.toSet());

        return headers.entrySet().stream()
                .filter(entry -> nameSet.contains(entry.getKey()))
                .collect(
                        Collectors.toMap(
                                Map.Entry::getKey,
                                Map.Entry::getValue,
                                (a, b) -> a,
                                LinkedHashMap::new));
    }

    @Override
    public Map<String, HeaderContract> getAllExcept(String... names) {
        Set<String> nameSet = Arrays.stream(names).collect(Collectors.toSet());

        return headers.entrySet().stream()
                .filter(entry -> !nameSet.contains(entry.getKey()))
                .collect(
                        Collectors.toMap(
                                Map.Entry::getKey,
                                Map.Entry::getValue,
                                (a, b) -> a,
                                LinkedHashMap::new));
    }

    @Override
    public HeaderCollectionContract withHeader(HeaderContract header) {
        HeaderCollection newCollection = copy();
        newCollection.overrideHeader(header);
        return newCollection;
    }

    @Override
    public HeaderCollectionContract withoutHeader(String name) {
        if (!has(name)) {
            return copy();
        }

        String headerName = name.toLowerCase(Locale.ROOT);
        HeaderCollection newCollection = copy();
        newCollection.headers.remove(headerName);
        return newCollection;
    }

    @Override
    public HeaderCollectionContract withHeaders(HeaderContract... headers) {
        HeaderCollection newCollection = copy();
        newCollection.setHeaders(headers);
        return newCollection;
    }

    @Override
    public HeaderCollectionContract withAddedHeaders(HeaderContract... headers) {
        HeaderCollection newCollection = copy();

        for (HeaderContract header : headers) {
            newCollection.addHeader(header);
        }

        return newCollection;
    }

    @Override
    public HeaderCollectionContract withoutHeaders(String... names) {
        HeaderCollection newCollection = copy();

        for (String name : names) {
            newCollection.removeHeader(name);
        }

        return newCollection;
    }

    protected void removeHeader(String name) {
        if (!has(name)) {
            return;
        }

        headers.remove(name.toLowerCase(Locale.ROOT));
    }

    protected void overrideHeader(HeaderContract header) {
        String name = header.getNormalizedName();
        headers.put(name, header);
    }

    protected void addHeader(HeaderContract header) {
        String name = header.getNormalizedName();

        if (!has(name)) {
            headers.put(name, header);
            return;
        }

        HeaderContract existingHeader = get(name);
        headers.put(name, existingHeader.withAddedValues(header.getValues().toArray()));
    }

    protected void setHeaders(HeaderContract... originalHeaders) {
        LinkedHashMap<String, HeaderContract> newHeaders = new LinkedHashMap<>();

        for (HeaderContract header : originalHeaders) {
            String headerName = header.getNormalizedName();
            newHeaders.put(headerName, header);
        }

        this.headers = newHeaders;
    }

    protected HeaderCollection copy() {
        HeaderCollection newCollection = new HeaderCollection();
        newCollection.headers = new LinkedHashMap<>(this.headers);
        newCollection.position = this.position;
        return newCollection;
    }
}

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.header.collection;
11
12	import io.valkyrja.http.message.header.collection.contract.HeaderCollectionContract;
13	import io.valkyrja.http.message.header.contract.HeaderContract;
14	import io.valkyrja.http.message.header.throwable.exception.HttpHeaderInvalidHeaderNameException;
15	import io.valkyrja.http.message.header.throwable.exception.HttpHeaderInvalidHeaderParamException;
16	import java.util.Arrays;
17	import java.util.LinkedHashMap;
18	import java.util.Locale;
19	import java.util.Map;
20	import java.util.Set;
21	import java.util.stream.Collectors;
22
23	public class HeaderCollection implements HeaderCollectionContract {
24
25	protected LinkedHashMap<String, HeaderContract> headers = new LinkedHashMap<>();	5✔
26
27	protected int position = 0;	3✔
28
29	public HeaderCollection(HeaderContract... headers) {	2✔
30	setHeaders(headers);	3✔
31	}	1✔
32
33	public static HeaderCollection fromArray(Map<?, ?> data) {
34	HeaderContract[] headers = new HeaderContract[data.size()];	4✔
35	int i = 0;	2✔
36
37	for (Map.Entry<?, ?> entry : data.entrySet()) {	11✔
38	validateHeader(entry.getValue());	3✔
39	headers[i++] = (HeaderContract) entry.getValue();	7✔
40	}	1✔
41
42	return new HeaderCollection(headers);	5✔
43	}
44
45	protected static void validateHeader(Object param) {
46	if (!(param instanceof HeaderContract)) {	3✔
47	throw new HttpHeaderInvalidHeaderParamException("Param must be header");	5✔
48	}
49	}	1✔
50
51	@Override
52	public boolean has(String name) {
53	return headers.containsKey(name.toLowerCase(Locale.ROOT));	7✔
54	}
55
56	@Override
57	public HeaderContract get(String name) {
58	HeaderContract header = headers.get(name.toLowerCase(Locale.ROOT));	8✔
59
60	if (header == null) {	2✔
61	throw new HttpHeaderInvalidHeaderNameException("Header " + name + " does not exist");	6✔
62	}
63
64	return header;	2✔
65	}
66
67	@Override
68	public String getHeaderLine(String name) {
69	if (!has(name)) {	4✔
70	return "";	2✔
71	}
72
73	return get(name).getHeaderLine();	5✔
74	}
75
76	@Override
77	public Map<String, HeaderContract> getAll() {
78	return headers;	3✔
79	}
80
81	@Override
82	public Map<String, HeaderContract> getOnly(String... names) {
83	Set<String> nameSet = Arrays.stream(names).collect(Collectors.toSet());	6✔
84
85	return headers.entrySet().stream()	7✔
86	.filter(entry -> nameSet.contains(entry.getKey()))	10✔
87	.collect(	2✔
88	Collectors.toMap(	1✔
89	Map.Entry::getKey,
90	Map.Entry::getValue,
NEW 91	(a, b) -> a,	×
92	LinkedHashMap::new));
93	}
94
95	@Override
96	public Map<String, HeaderContract> getAllExcept(String... names) {
97	Set<String> nameSet = Arrays.stream(names).collect(Collectors.toSet());	6✔
98
99	return headers.entrySet().stream()	7✔
100	.filter(entry -> !nameSet.contains(entry.getKey()))	14✔
101	.collect(	2✔
102	Collectors.toMap(	1✔
103	Map.Entry::getKey,
104	Map.Entry::getValue,
NEW 105	(a, b) -> a,	×
106	LinkedHashMap::new));
107	}
108
109	@Override
110	public HeaderCollectionContract withHeader(HeaderContract header) {
111	HeaderCollection newCollection = copy();	3✔
112	newCollection.overrideHeader(header);	3✔
113	return newCollection;	2✔
114	}
115
116	@Override
117	public HeaderCollectionContract withoutHeader(String name) {
118	if (!has(name)) {	4✔
119	return copy();	3✔
120	}
121
122	String headerName = name.toLowerCase(Locale.ROOT);	4✔
123	HeaderCollection newCollection = copy();	3✔
124	newCollection.headers.remove(headerName);	5✔
125	return newCollection;	2✔
126	}
127
128	@Override
129	public HeaderCollectionContract withHeaders(HeaderContract... headers) {
130	HeaderCollection newCollection = copy();	3✔
131	newCollection.setHeaders(headers);	3✔
132	return newCollection;	2✔
133	}
134
135	@Override
136	public HeaderCollectionContract withAddedHeaders(HeaderContract... headers) {
137	HeaderCollection newCollection = copy();	3✔
138
139	for (HeaderContract header : headers) {	16✔
140	newCollection.addHeader(header);	3✔
141	}
142
143	return newCollection;	2✔
144	}
145
146	@Override
147	public HeaderCollectionContract withoutHeaders(String... names) {
148	HeaderCollection newCollection = copy();	3✔
149
150	for (String name : names) {	16✔
151	newCollection.removeHeader(name);	3✔
152	}
153
154	return newCollection;	2✔
155	}
156
157	protected void removeHeader(String name) {
158	if (!has(name)) {	4✔
159	return;	1✔
160	}
161
162	headers.remove(name.toLowerCase(Locale.ROOT));	7✔
163	}	1✔
164
165	protected void overrideHeader(HeaderContract header) {
166	String name = header.getNormalizedName();	3✔
167	headers.put(name, header);	6✔
168	}	1✔
169
170	protected void addHeader(HeaderContract header) {
171	String name = header.getNormalizedName();	3✔
172
173	if (!has(name)) {	4✔
174	headers.put(name, header);	6✔
175	return;	1✔
176	}
177
178	HeaderContract existingHeader = get(name);	4✔
179	headers.put(name, existingHeader.withAddedValues(header.getValues().toArray()));	10✔
180	}	1✔
181
182	protected void setHeaders(HeaderContract... originalHeaders) {
183	LinkedHashMap<String, HeaderContract> newHeaders = new LinkedHashMap<>();	4✔
184
185	for (HeaderContract header : originalHeaders) {	16✔
186	String headerName = header.getNormalizedName();	3✔
187	newHeaders.put(headerName, header);	5✔
188	}
189
190	this.headers = newHeaders;	3✔
191	}	1✔
192
193	protected HeaderCollection copy() {
194	HeaderCollection newCollection = new HeaderCollection();	6✔
195	newCollection.headers = new LinkedHashMap<>(this.headers);	7✔
196	newCollection.position = this.position;	4✔
197	return newCollection;	2✔
198	}
199	}

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