You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@grails.apache.org by bo...@apache.org on 2026/10/20 00:46:46 UTC
(grails-core) 02/07: Merge sync10/refactor/java-to-groovy-spring-security into refactor/java-to-groovy-testing-support
This is an automated email from the ASF dual-hosted git repository.
borinquenkid pushed a commit to branch groovyism/testing-support
in repository https://gitbox.apache.org/repos/asf/grails-core.git
commit 14f791e99915e9b9241b0f60a68f930b442a4451
Merge: 1300186e89 699b7cdf2d
Author: Walter Duque de Estrada <wb...@mac.com>
AuthorDate: Thu Oct 15 21:47:29 2026 -0500
Merge sync10/refactor/java-to-groovy-spring-security into refactor/java-to-groovy-testing-support
# Conflicts:
# grails-test-suite-base/src/main/groovy/org/grails/support/MockApplicationContext.java
AGENTS.md | 6 +-
THREAT_MODEL.md | 2 +-
.../org/apache/grails/buildsrc/SbomPlugin.groovy | 2 +-
.../apache/grails/buildsrc/SbomPluginSpec.groovy | 9 ++
.../buildsrc/scan/VulnerabilityScanPlugin.groovy | 8 +-
dependencies.gradle | 71 ++++----------
gradle.properties | 8 +-
.../controllers/GrailsSecurityHeadersFilter.groovy | 19 ++--
...ailsSecurityHeadersAutoConfigurationSpec.groovy | 26 +++++
.../test/groovy/grails/util/GrailsUtilTests.groovy | 2 +-
...eanFactoryInitializationAotProcessorSpec.groovy | 6 +-
.../VarargsBeanRegistrationAotProcessorSpec.groovy | 4 +-
.../grails/plugins/CoreGrailsPluginAotSpec.groovy | 6 +-
.../groovy/org/grails/gorm/graphql/Schema.groovy | 11 ++-
.../gorm/graphql/QueryComplexityLimitsSpec.groovy | 105 +++++++++++++++++++++
.../gorm/graphql/SchemaInterceptorSpec.groovy | 87 +++++++++++++++++
grails-doc/src/en/guide/conf/config/logging.adoc | 2 +-
.../src/en/guide/deployment/deploymentTasks.adoc | 1 +
grails-doc/src/en/guide/introduction/whatsNew.adoc | 8 +-
.../src/en/guide/upgrading/upgrading90x.adoc | 105 ++++++++++++++++++++-
...eanFactoryInitializationAotProcessorSpec.groovy | 4 +-
.../developer/skills/grails-developer/SKILL.md | 4 +-
.../grails/support/MockApplicationContext.groovy | 8 +-
.../support/MockApplicationContextSpec.groovy | 62 ++++++++++++
threat-model.yaml | 2 +-
25 files changed, 471 insertions(+), 97 deletions(-)
diff --cc grails-test-suite-base/src/main/groovy/org/grails/support/MockApplicationContext.groovy
index 73a2627b0a,0000000000..f14f4f5c7f
mode 100644,000000..100644
--- a/grails-test-suite-base/src/main/groovy/org/grails/support/MockApplicationContext.groovy
+++ b/grails-test-suite-base/src/main/groovy/org/grails/support/MockApplicationContext.groovy
@@@ -1,507 -1,0 +1,513 @@@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.grails.support
+
+import jakarta.servlet.ServletContext
+import java.lang.annotation.Annotation
+import java.nio.charset.StandardCharsets
+
+import groovy.transform.CompileStatic
+import org.jspecify.annotations.NonNull
+import org.springframework.beans.BeansException
+import org.springframework.beans.factory.BeanCreationException
+import org.springframework.beans.factory.BeanFactory
+import org.springframework.beans.factory.NoSuchBeanDefinitionException
+import org.springframework.beans.factory.ObjectProvider
+import org.springframework.beans.factory.config.AutowireCapableBeanFactory
+import org.springframework.beans.factory.support.DefaultListableBeanFactory
+import org.springframework.context.ApplicationContext
+import org.springframework.context.ApplicationEvent
+import org.springframework.context.MessageSource
+import org.springframework.context.MessageSourceResolvable
+import org.springframework.context.NoSuchMessageException
++import org.springframework.core.ParameterizedTypeReference
+import org.springframework.core.ResolvableType
+import org.springframework.core.env.Environment
+import org.springframework.core.io.AbstractResource
+import org.springframework.core.io.ClassPathResource
+import org.springframework.core.io.Resource
+import org.springframework.mock.web.MockServletContext
+import org.springframework.util.AntPathMatcher
+import org.springframework.util.PathMatcher
+import org.springframework.web.context.WebApplicationContext
+import org.springframework.web.context.support.StandardServletEnvironment
+
+import grails.util.GrailsStringUtils
+
+@CompileStatic
+class MockApplicationContext extends GroovyObjectSupport implements WebApplicationContext {
+
+ Date startupDate = new Date()
+ Map<String, Object> beans = new HashMap<>()
+ List<Resource> resources = new ArrayList<>()
+ List<String> ignoredClassLocations = new ArrayList<>()
+ PathMatcher pathMatcher = new AntPathMatcher()
+ ServletContext servletContext = new MockServletContext()
+
+ void registerMockBean(String name, Object instance) {
+ beans.put(name, instance)
+ }
+
+ /**
+ * Registers a mock resource. Path separator: "/"
+ * @param location the location of the resource. Example: /WEB-INF/grails-app/i18n/messages.properties
+ */
+ void registerMockResource(String location) {
+ resources.add(new ClassPathResource(GrailsStringUtils.trimStart(location, '/')))
+ }
+
+ /**
+ * Registers a mock resource. Path separator: "/"
+ * @param location the location of the resource. Example: /WEB-INF/grails-app/i18n/messages.properties
+ */
+ void registerMockResource(String location, String contents) {
+ resources.add(new MockResource(GrailsStringUtils.trimStart(location, '/'), contents))
+ }
+
+ /**
+ * Unregisters a mock resource. Path separator: "/"
+ * @param location the location of the resource. Example: /WEB-INF/grails-app/i18n/messages.properties
+ */
+ void unregisterMockResource(String location) {
+ for (Iterator<Resource> it = resources.iterator(); it.hasNext();) {
+ MockResource mockResource = (MockResource) it.next()
+ if (mockResource.location.equals(location)) {
+ it.remove()
+ }
+ }
+ }
+
+ /**
+ * Registers a resource that should not be found on the classpath. Path separator: "/"
+ * @param location the location of the resource. Example: /WEB-INF/grails-app/i18n/messages.properties
+ */
+ void registerIgnoredClassPathLocation(String location) {
+ ignoredClassLocations.add(location)
+ }
+
+ /**
+ * Unregisters a resource that should not be found on the classpath. Path separator: "/"
+ * @param location the location of the resource. Example: /WEB-INF/grails-app/i18n/messages.properties
+ */
+ void unregisterIgnoredClassPathLocation(String location) {
+ ignoredClassLocations.remove(location)
+ }
+
+ ApplicationContext getParent() {
+ throw new UnsupportedOperationException('Method not supported by implementation')
+ }
+
+ String getId() {
+ return 'MockApplicationContext'
+ }
+
+ String getApplicationName() {
+ return getId()
+ }
+
+ String getDisplayName() {
+ return getId()
+ }
+
+ long getStartupDate() {
+ return startupDate.getTime()
+ }
+
+ void publishEvent(ApplicationEvent event) {
+ // do nothing
+ }
+
+ @Override
+ void publishEvent(Object event) {
+
+ }
+
+ boolean containsBeanDefinition(String beanName) {
+ return beans.containsKey(beanName)
+ }
+
+ int getBeanDefinitionCount() {
+ return beans.size()
+ }
+
+ String[] getBeanDefinitionNames() {
+ return beans.keySet().toArray(new String[beans.keySet().size()])
+ }
+
+ @Override
+ def <T> ObjectProvider<T> getBeanProvider(Class<T> requiredType, boolean allowEagerInit) {
+ return getBeanProvider(requiredType)
+ }
+
+ @Override
+ def <T> ObjectProvider<T> getBeanProvider(ResolvableType requiredType, boolean allowEagerInit) {
+ return getBeanProvider(requiredType)
+ }
+
+ @Override
+ String[] getBeanNamesForType(ResolvableType type) {
+ return new String[0]
+ }
+
+ @Override
+ String[] getBeanNamesForType(ResolvableType type, boolean includeNonSingletons, boolean allowEagerInit) {
+ return new String[0]
+ }
+
+ @SuppressWarnings([ 'unchecked', 'rawtypes' ])
+ String[] getBeanNamesForType(Class type) {
+ List<String> beanNames = new ArrayList<>()
+ for (String beanName in beans.keySet()) {
+ if (type.isAssignableFrom(beans.get(beanName).getClass())) {
+ beanNames.add(beanName)
+ }
+ }
+ return beanNames.toArray(new String[beanNames.size()])
+ }
+
+ @SuppressWarnings('rawtypes')
+ String[] getBeanNamesForType(Class type, boolean includePrototypes, boolean includeFactoryBeans) {
+ return getBeanNamesForType(type)
+ }
+
+ @SuppressWarnings('unchecked')
+ def <T> Map<String, T> getBeansOfType(Class<T> type) throws BeansException {
+ String[] beanNames = getBeanNamesForType(type)
+ Map<String, T> newMap = new HashMap<>()
+ for (int i = 0; i < beanNames.length; i++) {
+ String beanName = beanNames[i]
+ newMap.put(beanName, (T) getBean(beanName))
+ }
+ return newMap
+ }
+
+ def <T> Map<String, T> getBeansOfType(Class<T> type, boolean includeNonSingletons, boolean allowEagerInit) throws BeansException {
+ return getBeansOfType(type)
+ }
+
+ def <A extends Annotation> A findAnnotationOnBean(String name, Class<A> annotation) {
+ Object o = getBean(name)
+ if (o != null) {
+ return o.getClass().getAnnotation(annotation)
+ }
+ return null
+ }
+
+ @Override
+ def <A extends Annotation> A findAnnotationOnBean(String beanName, Class<A> annotationType, boolean allowFactoryBeanInit) throws NoSuchBeanDefinitionException {
+ return findAnnotationOnBean(beanName, annotationType)
+ }
+
+ Map<String, Object> getBeansWithAnnotation(Class<? extends Annotation> annotation) throws BeansException {
+ Map<String, Object> submap = new HashMap<>()
+ for (Object beanName in beans.keySet()) {
+ Object bean = beans.get(beanName)
+ if (bean != null && bean.getClass().getAnnotation(annotation) != null) {
+ submap.put(beanName.toString(), bean)
+ }
+ }
+ return submap
+ }
+
+ @NonNull
+ @Override
+ def <A extends Annotation> Set<A> findAllAnnotationsOnBean(@NonNull String beanName, @NonNull Class<A> annotationType, boolean allowFactoryBeanInit) throws NoSuchBeanDefinitionException {
+ throw new UnsupportedOperationException('This method was added in Spring 6 API but has not yet been implemented in Grails MockApplicationContext')
+ }
+
+ /**
+ * Find all names of beans whose {@code Class} has the supplied {@link Annotation}
+ * type, without creating any bean instances yet.
+ * @param annotationType the type of annotation to look for
+ * @return the names of all matching beans
+ * @since 2.4
+ */
+ String[] getBeanNamesForAnnotation(Class<? extends Annotation> annotationType) {
+ List<String> beanNamesList = new ArrayList<>()
+ for (Object beanName in beans.keySet()) {
+ Object bean = beans.get(beanName)
+ if (bean != null && bean.getClass().getAnnotation(annotationType) != null) {
+ beanNamesList.add(beanName.toString())
+ }
+ }
+ return beanNamesList.toArray(new String[beanNamesList.size()])
+ }
+
+ Object getBean(String name) throws BeansException {
+ if (!beans.containsKey(name)) {
+ throw new NoSuchBeanDefinitionException(name)
+ }
+ return beans.get(name)
+ }
+
+ @SuppressWarnings('unchecked')
+ def <T> T getBean(String name, Class<T> requiredType) throws BeansException {
+ if (!beans.containsKey(name)) {
+ throw new NoSuchBeanDefinitionException(name)
+ }
+
+ if (requiredType != null && !requiredType.isAssignableFrom(beans.get(name).getClass())) {
+ throw new NoSuchBeanDefinitionException(name)
+ }
+
+ return (T) beans.get(name)
+ }
+
++ @Override
++ def <T> T getBean(String name, ParameterizedTypeReference<T> requiredType) throws BeansException {
++ return (T) getBean(name, ResolvableType.forType(requiredType.getType()).toClass())
++ }
++
+ def <T> T getBean(Class<T> tClass) throws BeansException {
+ final Map<String, T> map = getBeansOfType(tClass)
+ if (map.isEmpty()) {
+ throw new NoSuchBeanDefinitionException(tClass, 'No bean found for type: ' + tClass.getName())
+ }
+ return map.values().iterator().next()
+ }
+
+ Object getBean(String name, Object... args) throws BeansException {
+ return getBean(name)
+ }
+
+ @Override
+ Object getProperty(String name) {
+ if (beans.containsKey(name)) {
+ return beans.get(name)
+ }
+
+ return super.getProperty(name)
+ }
+
+ boolean containsBean(String name) {
+ return beans.containsKey(name)
+ }
+
+ boolean isSingleton(String name) {
+ throw new UnsupportedOperationException('Method not supported by implementation')
+ }
+
+ boolean isPrototype(String s) {
+ throw new UnsupportedOperationException('Method not supported by implementation')
+ }
+
+ @Override
+ boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException {
+ return isTypeMatch(name, typeToMatch.getRawClass())
+ }
+
+ @SuppressWarnings('rawtypes')
+ boolean isTypeMatch(String name, Class aClass) {
+ return aClass.isInstance(getBean(name))
+ }
+
+ @SuppressWarnings([ 'unchecked', 'rawtypes' ])
+ Class getType(String name) throws NoSuchBeanDefinitionException {
+ if (!beans.containsKey(name)) {
+ throw new NoSuchBeanDefinitionException(name)
+ }
+
+ return beans.get(name).getClass()
+ }
+
+ @Override
+ Class<?> getType(String name, boolean allowFactoryBeanInit) throws NoSuchBeanDefinitionException {
+ return getType(name)
+ }
+
+ String[] getAliases(String name) {
+ return new String[0]
+ }
+
+ BeanFactory getParentBeanFactory() {
+ return null
+ }
+
+ String getMessage(String code, Object[] args, String defaultMessage, Locale locale) {
+ MessageSource messageSource = (MessageSource) getBean('messageSource')
+ if (messageSource == null) {
+ throw new BeanCreationException('No bean [messageSource] found in MockApplicationContext')
+ }
+ return messageSource.getMessage(code, args, defaultMessage, locale)
+ }
+
+ String getMessage(String code, Object[] args, Locale locale) throws NoSuchMessageException {
+ MessageSource messageSource = (MessageSource) getBean('messageSource')
+ if (messageSource == null) {
+ throw new BeanCreationException('No bean [messageSource] found in MockApplicationContext')
+ }
+ return messageSource.getMessage(code, args, locale)
+ }
+
+ String getMessage(MessageSourceResolvable resolvable, Locale locale) throws NoSuchMessageException {
+ MessageSource messageSource = (MessageSource) getBean('messageSource')
+ if (messageSource == null) {
+ throw new BeanCreationException('No bean [messageSource] found in MockApplicationContext')
+ }
+ return messageSource.getMessage(resolvable, locale)
+ }
+
+ Resource[] getResources(String locationPattern) throws IOException {
+ if (locationPattern.startsWith('classpath:') || locationPattern.startsWith('file:')) {
+ throw new UnsupportedOperationException("Location patterns 'classpath:' and 'file:' not supported by implementation")
+ }
+
+ locationPattern = GrailsStringUtils.trimStart(locationPattern, '/') // starting with "**/" is OK
+ List<Resource> result = new ArrayList<>()
+ for (Resource res in resources) {
+ String path = res instanceof ClassPathResource ? ((ClassPathResource) res).getPath() : res.getDescription()
+ if (pathMatcher.match(locationPattern, path)) {
+ result.add(res)
+ }
+ }
+ return result.toArray(new Resource[0])
+ }
+
+ Resource getResource(String location) {
+ for (Resource mockResource in resources) {
+ if (pathMatcher.match(mockResource.getDescription(), GrailsStringUtils.trimStart(location, '/'))) {
+ return mockResource
+ }
+ }
+ // Check for ignored resources and return null instead of a classpath resource in that case.
+ for (String resourceLocation in ignoredClassLocations) {
+ if (pathMatcher.match(
+ GrailsStringUtils.trimStart(location, '/'),
+ GrailsStringUtils.trimStart(resourceLocation, '/'))) {
+ return null
+ }
+ }
+
+ return new ClassPathResource(location)
+ }
+
+ boolean containsLocalBean(String arg0) {
+ throw new UnsupportedOperationException('Method not supported by implementation')
+ }
+
+ AutowireCapableBeanFactory getAutowireCapableBeanFactory() throws IllegalStateException {
+ return new DefaultListableBeanFactory()
+ }
+
+ ClassLoader getClassLoader() {
+ return getClass().getClassLoader()
+ }
+
+ ServletContext getServletContext() {
+ return servletContext
+ }
+
+ void setServletContext(ServletContext servletContext) {
+ this.servletContext = servletContext
+ }
+
+ Environment getEnvironment() {
+ return new StandardServletEnvironment()
+ }
+
+ class MockResource extends AbstractResource {
+
+ private String contents = ''
+ private String location
+
+ MockResource(String location) {
+ this.location = location
+ }
+
+ MockResource(String location, String contents) {
+ this(location)
+ this.contents = contents
+ }
+
+ @Override
+ boolean exists() {
+ return true
+ }
+
+ String getDescription() {
+ return location
+ }
+
+ InputStream getInputStream() throws IOException {
+ return new ByteArrayInputStream(contents.getBytes(StandardCharsets.UTF_8))
+ }
+ }
+
+ @Override
+ def <T> T getBean(Class<T> requiredType, Object... args)
+ throws BeansException {
+ return getBean(requiredType)
+ }
+
+ @Override
+ def <T> ObjectProvider<T> getBeanProvider(Class<T> requiredType) {
+ return new ObjectProvider<T>() {
+ @Override
+ T getObject(Object... args) throws BeansException {
+ return (T) getBean(requiredType)
+ }
+
+ @Override
+ T getIfAvailable() throws BeansException {
+ return (T) getBean(requiredType)
+ }
+
+ @Override
+ T getIfUnique() throws BeansException {
+ return (T) getBean(requiredType)
+ }
+
+ @Override
+ T getObject() throws BeansException {
+ return (T) getBean(requiredType)
+ }
+ }
+ }
+
+ @Override
+ def <T> ObjectProvider<T> getBeanProvider(ResolvableType requiredType) {
+ return new ObjectProvider<T>() {
+ @Override
+ T getObject(Object... args) throws BeansException {
+ return (T) getBean(requiredType.toClass())
+ }
+
+ @Override
+ T getIfAvailable() throws BeansException {
+ return (T) getBean(requiredType.toClass())
+ }
+
+ @Override
+ T getIfUnique() throws BeansException {
+ return (T) getBean(requiredType.toClass())
+ }
+
+ @Override
+ T getObject() throws BeansException {
+ return (T) getBean(requiredType.toClass())
+ }
+ }
+ }
+
+ @Override
- def <T> ObjectProvider<T> getBeanProvider(org.springframework.core.ParameterizedTypeReference<T> requiredType) {
++ def <T> ObjectProvider<T> getBeanProvider(ParameterizedTypeReference<T> requiredType) {
+ return getBeanProvider(ResolvableType.forType(requiredType.getType()))
+ }
+
+}