15888493103

Committed 25 Jun 2025 10:27PM UTC coverage: 69.92% (+21.6%) from 48.289%

Build # 15888493103

Build Type

push

github

Committed by

web-flow

Commit Message

RESTWS-983: Build module against openmrs-core 2.4.x and make it the lowest supported version (#662)

* RESTWS-983 Build module against openmrs-core 2.4.x and make it the lowest supported version

* RESTWS-983 Move omod-2.3 and lower classes to omod-2.4

* RESTWS-983 Fixing tests

Run Details

16 of 27 new or added lines in 13 files covered. (59.26%)

9 existing lines in 3 files now uncovered.

9835 of 14066 relevant lines covered (69.92%)

0.7 hits per line

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

84.62

/omod-common/src/main/java/org/openmrs/module/webservices/rest/web/OpenmrsClassScanner.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.module.webservices.rest.web;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.openmrs.util.OpenmrsClassLoader;
import org.springframework.core.io.Resource;
import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
import org.springframework.core.io.support.ResourcePatternResolver;
import org.springframework.core.type.classreading.MetadataReader;
import org.springframework.core.type.classreading.MetadataReaderFactory;
import org.springframework.core.type.classreading.SimpleMetadataReaderFactory;
import org.springframework.core.type.filter.AssignableTypeFilter;
import org.springframework.core.type.filter.TypeFilter;

/**
 * Reflection utilities to search the classpath for classes
 */
public class OpenmrsClassScanner {
        
        protected final Log log = LogFactory.getLog(getClass());
        
        private static final OpenmrsClassScanner instance = new OpenmrsClassScanner();
        
        private final MetadataReaderFactory metadataReaderFactory;
        
        private final ResourcePatternResolver resourceResolver;
        
        OpenmrsClassScanner() {
                
                this.metadataReaderFactory = new SimpleMetadataReaderFactory(OpenmrsClassLoader.getInstance());
                
                this.resourceResolver = new PathMatchingResourcePatternResolver(OpenmrsClassLoader.getInstance());
                
        }
        
        /**
         * @return the instance
         */
        
        public static OpenmrsClassScanner getInstance() {
                
                return instance;
                
        }
        
        /**
         * Searches for classes extending or implementing the given type.
         * 
         * @param <T>
         * @param type
         * @param concrete true if only concrete classes should be returned
         * @return the list of found classes
         * @throws IOException
         */
        
        public <T> List<Class<? extends T>> getClasses(Class<? extends T> type, boolean concrete) throws IOException {
                
                List<Class<? extends T>> types = new ArrayList<Class<? extends T>>();
                
                String pattern = "classpath*:org/openmrs/**/*.class";
                
                Resource[] resources = resourceResolver.getResources(pattern);
                
                TypeFilter typeFilter = new AssignableTypeFilter(type);
                
                for (Resource resource : resources) {
                        
                        try {
                                
                                MetadataReader metadataReader = metadataReaderFactory.getMetadataReader(resource);
                                
                                if (typeFilter.match(metadataReader, metadataReaderFactory)
                                        && concrete == metadataReader.getClassMetadata().isConcrete()) {
                                        
                                        String classname = metadataReader.getClassMetadata().getClassName();
                                        
                                        try {
                                                
                                                @SuppressWarnings("unchecked")
                                                Class<? extends T> metadata = (Class<? extends T>) OpenmrsClassLoader.getInstance()
                                                        .loadClass(classname);
                                                
                                                types.add(metadata);
                                                
                                        }
                                        
                                        catch (ClassNotFoundException e) {
                                                
                                                throw new IOException("Class cannot be loaded: " + classname, e);
                                                
                                        }

                                        
                                }
                                
                        }
                        
                        catch (IOException e) {
                                
                                log.debug("Resource cannot be loaded: " + resource);
                                
                        }
                        
                }
                
                return types;
                
        }
}

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.module.webservices.rest.web;
11
12	import java.io.IOException;
13	import java.util.ArrayList;
14	import java.util.List;
15
16	import org.apache.commons.logging.Log;
17	import org.apache.commons.logging.LogFactory;
18	import org.openmrs.util.OpenmrsClassLoader;
19	import org.springframework.core.io.Resource;
20	import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
21	import org.springframework.core.io.support.ResourcePatternResolver;
22	import org.springframework.core.type.classreading.MetadataReader;
23	import org.springframework.core.type.classreading.MetadataReaderFactory;
24	import org.springframework.core.type.classreading.SimpleMetadataReaderFactory;
25	import org.springframework.core.type.filter.AssignableTypeFilter;
26	import org.springframework.core.type.filter.TypeFilter;
27
28	/**
29	* Reflection utilities to search the classpath for classes
30	*/
31	public class OpenmrsClassScanner {
32
33	protected final Log log = LogFactory.getLog(getClass());	1✔
34
35	private static final OpenmrsClassScanner instance = new OpenmrsClassScanner();	1✔
36
37	private final MetadataReaderFactory metadataReaderFactory;
38
39	private final ResourcePatternResolver resourceResolver;
40
41	OpenmrsClassScanner() {	1✔
42
43	this.metadataReaderFactory = new SimpleMetadataReaderFactory(OpenmrsClassLoader.getInstance());	1✔
44
45	this.resourceResolver = new PathMatchingResourcePatternResolver(OpenmrsClassLoader.getInstance());	1✔
46
47	}	1✔
48
49	/**
50	* @return the instance
51	*/
52
53	public static OpenmrsClassScanner getInstance() {
54
55	return instance;	1✔
56
57	}
58
59	/**
60	* Searches for classes extending or implementing the given type.
61	*
62	* @param <T>
63	* @param type
64	* @param concrete true if only concrete classes should be returned
65	* @return the list of found classes
66	* @throws IOException
67	*/
68
69	public <T> List<Class<? extends T>> getClasses(Class<? extends T> type, boolean concrete) throws IOException {
70
71	List<Class<? extends T>> types = new ArrayList<Class<? extends T>>();	1✔
72
73	String pattern = "classpath:org/openmrs//.class";	1✔
74
75	Resource[] resources = resourceResolver.getResources(pattern);	1✔
76
77	TypeFilter typeFilter = new AssignableTypeFilter(type);	1✔
78
79	for (Resource resource : resources) {	1✔
80
81	try {
82
83	MetadataReader metadataReader = metadataReaderFactory.getMetadataReader(resource);	1✔
84
85	if (typeFilter.match(metadataReader, metadataReaderFactory)	1✔
86	&& concrete == metadataReader.getClassMetadata().isConcrete()) {	1✔
87
88	String classname = metadataReader.getClassMetadata().getClassName();	1✔
89
90	try {
91
92	@SuppressWarnings("unchecked")
93	Class<? extends T> metadata = (Class<? extends T>) OpenmrsClassLoader.getInstance()	1✔
94	.loadClass(classname);	1✔
95
96	types.add(metadata);	1✔
97
98	}
99
100	catch (ClassNotFoundException e) {	×
101
102	throw new IOException("Class cannot be loaded: " + classname, e);	×
103
104	}	1✔
105
106
107	}
108
109	}
110
UNCOV 111	catch (IOException e) {	×
112
UNCOV 113	log.debug("Resource cannot be loaded: " + resource);	×
114
115	}	1✔
116
117	}
118
119	return types;	1✔
120
121	}
122	}

openmrs / openmrs-module-webservices.rest / 15888493103

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