22781579539

Committed 06 Mar 2026 08:53PM UTC coverage: 65.392%. Remained the same

Build # 22781579539

Build Type

push

github

Committed by

ibacher

Commit Message

Fix the Mockito hack

Previously, the way we were controlling mockito resulted in an inconsistent
dependency tree. This fixes the profile so we only need one and updates
the version property instead of the raw dependency.

Run Details

23842 of 36460 relevant lines covered (65.39%)

0.65 hits per line

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

85.29

/api/src/main/java/org/openmrs/util/HandlerUtil.java

/**
 * This Source Code Form is subject to the terms of the Mozilla Public License,
 * v. 2.0. If a copy of the MPL was not distributed with this file, You can
 * obtain one at http://mozilla.org/MPL/2.0/. OpenMRS is also distributed under
 * the terms of the Healthcare Disclaimer located at http://openmrs.org/license.
 *
 * Copyright (C) OpenMRS Inc. OpenMRS is a registered trademark and the OpenMRS
 * graphic logo is a trademark of OpenMRS Inc.
 */
package org.openmrs.util;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.WeakHashMap;

import org.openmrs.annotation.Handler;
import org.openmrs.api.APIException;
import org.openmrs.api.context.Context;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.ApplicationListener;
import org.springframework.context.event.ContextRefreshedEvent;
import org.springframework.stereotype.Component;

/**
 * Utility class that provides useful methods for working with classes that are annotated with the
 * {@link Handler} annotation
 * 
 * @since 1.5
 */
@Component
public class HandlerUtil implements ApplicationListener<ContextRefreshedEvent> {
        
        private static final Logger log = LoggerFactory.getLogger(HandlerUtil.class);
        
        private static volatile Map<Key, List<?>> cachedHandlers = new WeakHashMap<>();
        
        private static class Key {
                
                public final Class<?> handlerType;
                
                public final Class<?> type;
                
                public Key(Class<?> handlerType, Class<?> type) {
                        this.handlerType = handlerType;
                        this.type = type;
                }
                
                @Override
                public int hashCode() {
                        final int prime = 31;
                        int result = 1;
                        result = prime * result + ((handlerType == null) ? 0 : handlerType.hashCode());
                        result = prime * result + ((type == null) ? 0 : type.hashCode());
                        return result;
                }
                
                @Override
                public boolean equals(Object obj) {
                        if (this == obj) {
                                return true;
                        }
                        if (obj == null) {
                                return false;
                        }
                        if (getClass() != obj.getClass()) {
                                return false;
                        }
                        Key other = (Key) obj;
                        if (handlerType == null) {
                                if (other.handlerType != null) {
                                        return false;
                                }
                        } else if (!handlerType.equals(other.handlerType)) {
                                return false;
                        }
                        if (type == null) {
                                return other.type == null;
                        } else {
                                return type.equals(other.type);
                        }
                }
                
        }
        
        public static void clearCachedHandlers() {
                cachedHandlers = new WeakHashMap<>();
        }
        
        /**
         * Retrieves a List of all registered components from the Context that are of the passed
         * handlerType and one or more of the following is true:
         * <ul>
         * <li>The handlerType is annotated as a {@link Handler} that supports the passed type</li>
         * <li>The passed type is null - this effectively returns all components of the passed
         * handlerType</li>
         * </ul>
         * The returned handlers are ordered in the list based upon the order property.
         * 
         * @param handlerType Indicates the type of class to return
         * @param type Indicates the type that the given handlerType must support (or null for any)
         * @return a List of all matching Handlers for the given parameters, ordered by Handler#order
         * <strong>Should</strong> return a list of all classes that can handle the passed type
         * <strong>Should</strong> return classes registered in a module
         * <strong>Should</strong> return an empty list if no classes can handle the passed type
         */
        public static <H, T> List<H> getHandlersForType(Class<H> handlerType, Class<T> type) {
                List<?> list = cachedHandlers.get(new Key(handlerType, type));
                if (list != null) {
                        return (List<H>) list;
                }
                
                List<H> handlers = new ArrayList<>();
                
                // First get all registered components of the passed class
                log.debug("Getting handlers of type " + handlerType + (type == null ? "" : " for class " + type.getName()));
                for (H handler : Context.getRegisteredComponents(handlerType)) {
                        Handler handlerAnnotation = handler.getClass().getAnnotation(Handler.class);
                        // Only consider those that have been annotated as Handlers
                        if (handlerAnnotation != null) {
                                // If no type is passed in return all handlers
                                if (type == null) {
                                        log.debug("Found handler " + handler.getClass());
                                        handlers.add(handler);
                                }
                                // Otherwise, return all handlers that support the passed type
                                else {
                                        for (int i = 0; i < handlerAnnotation.supports().length; i++) {
                                                Class<?> clazz = handlerAnnotation.supports()[i];
                                                if (clazz.isAssignableFrom(type)) {
                                                        log.debug("Found handler: " + handler.getClass());
                                                        handlers.add(handler);
                                                }
                                        }
                                }
                        }
                }
                
                // Return the list of handlers based on the order specified in the Handler annotation
                handlers.sort(Comparator.comparing(o -> getOrderOfHandler(o.getClass())));
                
                Map<Key, List<?>> newCachedHandlers = new WeakHashMap<>(cachedHandlers);
                newCachedHandlers.put(new Key(handlerType, type), handlers);
                cachedHandlers = newCachedHandlers;
                
                return handlers;
        }
        
        /**
         * Retrieves the preferred Handler for a given handlerType and type. A <em>preferred</em>
         * handler is the Handler that has the lowest defined <em>order</em> attribute in it's
         * annotation. If multiple Handlers are found for the passed parameters at the lowest specified
         * order, then an APIException is thrown.
         * 
         * @param handlerType the class that is an annotated {@link Handler} to retrieve
         * @param type the class that the annotated {@link Handler} must support
         * @return the class of the passed handlerType with the lowest configured order
         * <strong>Should</strong> return the preferred handler for the passed handlerType and type
         * <strong>Should</strong> throw a APIException if no handler is found
         * <strong>Should</strong> throw a APIException if multiple preferred handlers are found
         * <strong>Should</strong> should return patient validator for patient
         * <strong>Should</strong> should return person validator for person
         */
        public static <H, T> H getPreferredHandler(Class<H> handlerType, Class<T> type) {
                
                if (handlerType == null || type == null) {
                        throw new IllegalArgumentException("You must specify both a handlerType and a type");
                }
                List<H> handlers = getHandlersForType(handlerType, type);
                if (handlers == null || handlers.isEmpty()) {
                        throw new APIException("handler.type.not.found", new Object[] { handlerType, type });
                }
                
                if (handlers.size() > 1) {
                        int order1 = getOrderOfHandler(handlers.get(0).getClass());
                        int order2 = getOrderOfHandler(handlers.get(1).getClass());
                        if (order1 == order2) {
                                throw new APIException("handler.type.multiple", new Object[] { handlerType, type });
                        }
                }
                
                return handlers.get(0);
        }
        
        /**
         * Utility method to return the order attribute of the {@link Handler} annotation on the passed
         * class. If the passed class does not have a {@link Handler} annotation, a RuntimeException is
         * thrown
         * 
         * @param handlerClass
         * @return the order attribute value
         */
        public static Integer getOrderOfHandler(Class<?> handlerClass) {
                Handler annotation = handlerClass.getAnnotation(Handler.class);
                if (annotation == null) {
                        throw new APIException("class.not.annotated.as.handler", new Object[] { handlerClass });
                }
                return annotation.order();
        }
        
        @Override
        public void onApplicationEvent(ContextRefreshedEvent event) {
                clearCachedHandlers();
        }
}

1	/**
2	* This Source Code Form is subject to the terms of the Mozilla Public License,
3	* v. 2.0. If a copy of the MPL was not distributed with this file, You can
4	* obtain one at http://mozilla.org/MPL/2.0/. OpenMRS is also distributed under
5	* the terms of the Healthcare Disclaimer located at http://openmrs.org/license.
6	*
7	* Copyright (C) OpenMRS Inc. OpenMRS is a registered trademark and the OpenMRS
8	* graphic logo is a trademark of OpenMRS Inc.
9	*/
10	package org.openmrs.util;
11
12	import java.util.ArrayList;
13	import java.util.Comparator;
14	import java.util.List;
15	import java.util.Map;
16	import java.util.WeakHashMap;
17
18	import org.openmrs.annotation.Handler;
19	import org.openmrs.api.APIException;
20	import org.openmrs.api.context.Context;
21	import org.slf4j.Logger;
22	import org.slf4j.LoggerFactory;
23	import org.springframework.context.ApplicationListener;
24	import org.springframework.context.event.ContextRefreshedEvent;
25	import org.springframework.stereotype.Component;
26
27	/**
28	* Utility class that provides useful methods for working with classes that are annotated with the
29	* {@link Handler} annotation
30	*
31	* @since 1.5
32	*/
33	@Component
34	public class HandlerUtil implements ApplicationListener<ContextRefreshedEvent> {	1✔
35
36	private static final Logger log = LoggerFactory.getLogger(HandlerUtil.class);	1✔
37
38	private static volatile Map<Key, List<?>> cachedHandlers = new WeakHashMap<>();	1✔
39
40	private static class Key {
41
42	public final Class<?> handlerType;
43
44	public final Class<?> type;
45
46	public Key(Class<?> handlerType, Class<?> type) {	1✔
47	this.handlerType = handlerType;	1✔
48	this.type = type;	1✔
49	}	1✔
50
51	@Override
52	public int hashCode() {
53	final int prime = 31;	1✔
54	int result = 1;	1✔
55	result = prime * result + ((handlerType == null) ? 0 : handlerType.hashCode());	1✔
56	result = prime * result + ((type == null) ? 0 : type.hashCode());	1✔
57	return result;	1✔
58	}
59
60	@Override
61	public boolean equals(Object obj) {
62	if (this == obj) {	1✔
63	return true;	×
64	}
65	if (obj == null) {	1✔
66	return false;	×
67	}
68	if (getClass() != obj.getClass()) {	1✔
69	return false;	×
70	}
71	Key other = (Key) obj;	1✔
72	if (handlerType == null) {	1✔
73	if (other.handlerType != null) {	×
74	return false;	×
75	}
76	} else if (!handlerType.equals(other.handlerType)) {	1✔
77	return false;	×
78	}
79	if (type == null) {	1✔
80	return other.type == null;	×
81	} else {
82	return type.equals(other.type);	1✔
83	}
84	}
85
86	}
87
88	public static void clearCachedHandlers() {
89	cachedHandlers = new WeakHashMap<>();	1✔
90	}	1✔
91
92	/**
93	* Retrieves a List of all registered components from the Context that are of the passed
94	* handlerType and one or more of the following is true:
95	* <ul>
96	* <li>The handlerType is annotated as a {@link Handler} that supports the passed type</li>
97	* <li>The passed type is null - this effectively returns all components of the passed
98	* handlerType</li>
99	* </ul>
100	* The returned handlers are ordered in the list based upon the order property.
101	*
102	* @param handlerType Indicates the type of class to return
103	* @param type Indicates the type that the given handlerType must support (or null for any)
104	* @return a List of all matching Handlers for the given parameters, ordered by Handler#order
105	* <strong>Should</strong> return a list of all classes that can handle the passed type
106	* <strong>Should</strong> return classes registered in a module
107	* <strong>Should</strong> return an empty list if no classes can handle the passed type
108	*/
109	public static <H, T> List<H> getHandlersForType(Class<H> handlerType, Class<T> type) {
110	List<?> list = cachedHandlers.get(new Key(handlerType, type));	1✔
111	if (list != null) {	1✔
112	return (List<H>) list;	1✔
113	}
114
115	List<H> handlers = new ArrayList<>();	1✔
116
117	// First get all registered components of the passed class
118	log.debug("Getting handlers of type " + handlerType + (type == null ? "" : " for class " + type.getName()));	1✔
119	for (H handler : Context.getRegisteredComponents(handlerType)) {	1✔
120	Handler handlerAnnotation = handler.getClass().getAnnotation(Handler.class);	1✔
121	// Only consider those that have been annotated as Handlers
122	if (handlerAnnotation != null) {	1✔
123	// If no type is passed in return all handlers
124	if (type == null) {	1✔
125	log.debug("Found handler " + handler.getClass());	1✔
126	handlers.add(handler);	1✔
127	}
128	// Otherwise, return all handlers that support the passed type
129	else {
130	for (int i = 0; i < handlerAnnotation.supports().length; i++) {	1✔
131	Class<?> clazz = handlerAnnotation.supports()[i];	1✔
132	if (clazz.isAssignableFrom(type)) {	1✔
133	log.debug("Found handler: " + handler.getClass());	1✔
134	handlers.add(handler);	1✔
135	}
136	}
137	}
138	}
139	}	1✔
140
141	// Return the list of handlers based on the order specified in the Handler annotation
142	handlers.sort(Comparator.comparing(o -> getOrderOfHandler(o.getClass())));	1✔
143
144	Map<Key, List<?>> newCachedHandlers = new WeakHashMap<>(cachedHandlers);	1✔
145	newCachedHandlers.put(new Key(handlerType, type), handlers);	1✔
146	cachedHandlers = newCachedHandlers;	1✔
147
148	return handlers;	1✔
149	}
150
151	/**
152	* Retrieves the preferred Handler for a given handlerType and type. A <em>preferred</em>
153	* handler is the Handler that has the lowest defined <em>order</em> attribute in it's
154	* annotation. If multiple Handlers are found for the passed parameters at the lowest specified
155	* order, then an APIException is thrown.
156	*
157	* @param handlerType the class that is an annotated {@link Handler} to retrieve
158	* @param type the class that the annotated {@link Handler} must support
159	* @return the class of the passed handlerType with the lowest configured order
160	* <strong>Should</strong> return the preferred handler for the passed handlerType and type
161	* <strong>Should</strong> throw a APIException if no handler is found
162	* <strong>Should</strong> throw a APIException if multiple preferred handlers are found
163	* <strong>Should</strong> should return patient validator for patient
164	* <strong>Should</strong> should return person validator for person
165	*/
166	public static <H, T> H getPreferredHandler(Class<H> handlerType, Class<T> type) {
167
168	if (handlerType == null \|\| type == null) {	1✔
169	throw new IllegalArgumentException("You must specify both a handlerType and a type");	×
170	}
171	List<H> handlers = getHandlersForType(handlerType, type);	1✔
172	if (handlers == null \|\| handlers.isEmpty()) {	1✔
173	throw new APIException("handler.type.not.found", new Object[] { handlerType, type });	1✔
174	}
175
176	if (handlers.size() > 1) {	1✔
177	int order1 = getOrderOfHandler(handlers.get(0).getClass());	1✔
178	int order2 = getOrderOfHandler(handlers.get(1).getClass());	1✔
179	if (order1 == order2) {	1✔
180	throw new APIException("handler.type.multiple", new Object[] { handlerType, type });	×
181	}
182	}
183
184	return handlers.get(0);	1✔
185	}
186
187	/**
188	* Utility method to return the order attribute of the {@link Handler} annotation on the passed
189	* class. If the passed class does not have a {@link Handler} annotation, a RuntimeException is
190	* thrown
191	*
192	* @param handlerClass
193	* @return the order attribute value
194	*/
195	public static Integer getOrderOfHandler(Class<?> handlerClass) {
196	Handler annotation = handlerClass.getAnnotation(Handler.class);	1✔
197	if (annotation == null) {	1✔
198	throw new APIException("class.not.annotated.as.handler", new Object[] { handlerClass });	×
199	}
200	return annotation.order();	1✔
201	}
202
203	@Override
204	public void onApplicationEvent(ContextRefreshedEvent event) {
205	clearCachedHandlers();	1✔
206	}	1✔
207	}

openmrs / openmrs-core / 22781579539

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