wistefan / tmforum-api / #49

Committed 29 Sep 2023 06:20AM UTC coverage: 67.488% (-4.3%) from 71.815%

Build # #49

Build Type

push

Committed by

Commit Message

Notifications (#23)

* Squashed commits

* Added cache invalidation for entity deletion

* Updated error message

Run Details

618 of 618 new or added lines in 86 files covered. (100.0%)

2794 of 4140 relevant lines covered (67.49%)

0.67 hits per line

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

83.33

/common/src/main/java/org/fiware/tmforum/common/querying/SubscriptionQueryParser.java

package org.fiware.tmforum.common.querying;

import org.fiware.tmforum.common.exception.QueryException;
import org.fiware.tmforum.common.notification.EventConstants;
import org.fiware.tmforum.common.util.StringUtils;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

import static org.fiware.tmforum.common.querying.Operator.EQUALS;

public class SubscriptionQueryParser {

        // Keys for the "well-known" fields
        public static final String FIELDS_KEY = "fields";
        public static final String FIELDS_SEPARATOR = ",";
        public static final String EVENT_TYPE_KEY = "eventType";
        public static final String EVENT_PREFIX = "event.";

        // the ";" in tm-forum parameters is an or
        public static final String TMFORUM_OR_KEY = ";";
        public static final String TMFORUM_AND = "&";


        public static SubscriptionQuery parse(String queryString, List<String> defaultEventGroups) {
                SubscriptionQuery subscriptionQuery = new SubscriptionQuery();

                if (queryString != null && !queryString.isEmpty()) {
                        List<String> parameters;
                        LogicalOperator logicalOperator = LogicalOperator.AND;
                        // tmforum does not define queries combining AND and OR
                        if (queryString.contains(TMFORUM_AND) && queryString.contains(TMFORUM_OR_KEY)) {
                                throw new QueryException("Combining AND(&) and OR(;) on query level is not supported by the TMForum API.");
                        }
                        if (queryString.contains(TMFORUM_AND)) {
                                parameters = Arrays.asList(queryString.split(TMFORUM_AND));
            } else if (queryString.contains(TMFORUM_OR_KEY)) {
                                parameters = Arrays.asList(queryString.split(TMFORUM_OR_KEY));
                                logicalOperator = LogicalOperator.OR;
                        } else {
                                //query is just a single parameter query
                                parameters = List.of(queryString);
                        }

                        List<String> queryParams = new ArrayList<>();
                        parameters.forEach(parameter -> {
                                if (parameter.startsWith(EVENT_TYPE_KEY)) {
                                        subscriptionQuery.addEventType(getParamValue(parameter));
                                } else if (parameter.startsWith(FIELDS_KEY)) {
                                        subscriptionQuery.setFields(parseFields(getParamValue(parameter)));
                                } else {
                                        queryParams.add(removeEventPrefixFromAttributePath(parameter));
                                }
                        });

                        subscriptionQuery.setQuery(String.join(logicalOperator == LogicalOperator.AND ? TMFORUM_AND : TMFORUM_OR_KEY,
                                        queryParams));

                        checkLogicalOperator(logicalOperator, subscriptionQuery);
                }

                if (subscriptionQuery.getEventTypes().isEmpty()) {
                        subscriptionQuery.setEventTypes(
                                        defaultEventGroups.stream().flatMap(eventGroup ->
                                                        EventConstants.ALLOWED_EVENT_TYPES.get(eventGroup).stream().map(
                                                                        eventType -> eventGroup + eventType)).toList());
                }

                subscriptionQuery.setEventGroups(subscriptionQuery.getEventTypes().stream()
                                .map(StringUtils::getEventGroupName).collect(Collectors.toSet()));

                return subscriptionQuery;
        }

        private static void checkLogicalOperator(LogicalOperator logicalOperator, SubscriptionQuery subscriptionQuery) {
                if (logicalOperator == LogicalOperator.OR) {
                        if (!subscriptionQuery.getFields().isEmpty()) {
                                throw new QueryException("Logical operator OR(;) cannot be used with 'fields' selector");
                        }
                        if (!subscriptionQuery.getEventTypes().isEmpty() && !subscriptionQuery.getQuery().isEmpty()) {
                                throw new QueryException("Logical operator OR(;) cannot be used when both 'eventType' and 'query' are defined");
                        }
                } else {
                        if (subscriptionQuery.getEventTypes().size() > 1) {
                                throw new QueryException("Logical operator AND(&) cannot be used when several 'eventType' are defined");
                        }
                }

        }

        private static List<String> parseFields(String fields) {
                return Arrays.stream(fields.split(FIELDS_SEPARATOR))
                                .map(SubscriptionQueryParser::removeEventPrefixFromAttributePath).toList();
        }

        private static String removeEventPrefixFromAttributePath(String attributePath) {
                if (attributePath.startsWith(EVENT_PREFIX)) {
                        return attributePath.substring(attributePath.indexOf(".") + 1);
                } else {
                        return attributePath;
                }
        }

        private static String getParamValue(String parameter) {
                String[] parameterParts = parameter.split(EQUALS.getTmForumOperator().operator());
                if (parameterParts.length != 2) {
                        throw new QueryException(String.format("%s is not a valid %s parameter.",
                                        parameter,
                                        EQUALS.getTmForumOperator().operator()));
                }

                return parameterParts[1];
        }
}

1	package org.fiware.tmforum.common.querying;
2
3	import org.fiware.tmforum.common.exception.QueryException;
4	import org.fiware.tmforum.common.notification.EventConstants;
5	import org.fiware.tmforum.common.util.StringUtils;
6
7	import java.util.ArrayList;
8	import java.util.Arrays;
9	import java.util.List;
10	import java.util.stream.Collectors;
11
12	import static org.fiware.tmforum.common.querying.Operator.EQUALS;
13
14	public class SubscriptionQueryParser {	×
15
16	// Keys for the "well-known" fields
17	public static final String FIELDS_KEY = "fields";
18	public static final String FIELDS_SEPARATOR = ",";
19	public static final String EVENT_TYPE_KEY = "eventType";
20	public static final String EVENT_PREFIX = "event.";
21
22	// the ";" in tm-forum parameters is an or
23	public static final String TMFORUM_OR_KEY = ";";
24	public static final String TMFORUM_AND = "&";
25
26
27	public static SubscriptionQuery parse(String queryString, List<String> defaultEventGroups) {
28	SubscriptionQuery subscriptionQuery = new SubscriptionQuery();	1✔
29
30	if (queryString != null && !queryString.isEmpty()) {	1✔
31	List<String> parameters;
32	LogicalOperator logicalOperator = LogicalOperator.AND;	1✔
33	// tmforum does not define queries combining AND and OR
34	if (queryString.contains(TMFORUM_AND) && queryString.contains(TMFORUM_OR_KEY)) {	1✔
35	throw new QueryException("Combining AND(&) and OR(;) on query level is not supported by the TMForum API.");	×
36	}
37	if (queryString.contains(TMFORUM_AND)) {	1✔
38	parameters = Arrays.asList(queryString.split(TMFORUM_AND));	1✔
39	} else if (queryString.contains(TMFORUM_OR_KEY)) {	1✔
40	parameters = Arrays.asList(queryString.split(TMFORUM_OR_KEY));	1✔
41	logicalOperator = LogicalOperator.OR;	1✔
42	} else {
43	//query is just a single parameter query
44	parameters = List.of(queryString);	1✔
45	}
46
47	List<String> queryParams = new ArrayList<>();	1✔
48	parameters.forEach(parameter -> {	1✔
49	if (parameter.startsWith(EVENT_TYPE_KEY)) {	1✔
50	subscriptionQuery.addEventType(getParamValue(parameter));	1✔
51	} else if (parameter.startsWith(FIELDS_KEY)) {	1✔
52	subscriptionQuery.setFields(parseFields(getParamValue(parameter)));	1✔
53	} else {
54	queryParams.add(removeEventPrefixFromAttributePath(parameter));	1✔
55	}
56	});	1✔
57
58	subscriptionQuery.setQuery(String.join(logicalOperator == LogicalOperator.AND ? TMFORUM_AND : TMFORUM_OR_KEY,	1✔
59	queryParams));
60
61	checkLogicalOperator(logicalOperator, subscriptionQuery);	1✔
62	}
63
64	if (subscriptionQuery.getEventTypes().isEmpty()) {	1✔
65	subscriptionQuery.setEventTypes(	1✔
66	defaultEventGroups.stream().flatMap(eventGroup ->	1✔
67	EventConstants.ALLOWED_EVENT_TYPES.get(eventGroup).stream().map(	1✔
68	eventType -> eventGroup + eventType)).toList());	1✔
69	}
70
71	subscriptionQuery.setEventGroups(subscriptionQuery.getEventTypes().stream()	1✔
72	.map(StringUtils::getEventGroupName).collect(Collectors.toSet()));	1✔
73
74	return subscriptionQuery;	1✔
75	}
76
77	private static void checkLogicalOperator(LogicalOperator logicalOperator, SubscriptionQuery subscriptionQuery) {
78	if (logicalOperator == LogicalOperator.OR) {	1✔
79	if (!subscriptionQuery.getFields().isEmpty()) {	1✔
80	throw new QueryException("Logical operator OR(;) cannot be used with 'fields' selector");	×
81	}
82	if (!subscriptionQuery.getEventTypes().isEmpty() && !subscriptionQuery.getQuery().isEmpty()) {	1✔
83	throw new QueryException("Logical operator OR(;) cannot be used when both 'eventType' and 'query' are defined");	×
84	}
85	} else {
86	if (subscriptionQuery.getEventTypes().size() > 1) {	1✔
87	throw new QueryException("Logical operator AND(&) cannot be used when several 'eventType' are defined");	×
88	}
89	}
90
91	}	1✔
92
93	private static List<String> parseFields(String fields) {
94	return Arrays.stream(fields.split(FIELDS_SEPARATOR))	1✔
95	.map(SubscriptionQueryParser::removeEventPrefixFromAttributePath).toList();	1✔
96	}
97
98	private static String removeEventPrefixFromAttributePath(String attributePath) {
99	if (attributePath.startsWith(EVENT_PREFIX)) {	1✔
100	return attributePath.substring(attributePath.indexOf(".") + 1);	1✔
101	} else {
102	return attributePath;	×
103	}
104	}
105
106	private static String getParamValue(String parameter) {
107	String[] parameterParts = parameter.split(EQUALS.getTmForumOperator().operator());	1✔
108	if (parameterParts.length != 2) {	1✔
109	throw new QueryException(String.format("%s is not a valid %s parameter.",	×
110	parameter,
111	EQUALS.getTmForumOperator().operator()));	×
112	}
113
114	return parameterParts[1];	1✔
115	}
116	}

wistefan / tmforum-api / #49

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