root
/
spring-framework
mirror of https://github.com/spring-projects/spring-framework.git
1
0
Fork 0
Code Issues Actions 2 Packages Projects Releases Wiki Activity

Simplify SpEL ExpressionWithConversionTests

This commit is contained in:
Sam Brannen 2025-03-28 15:13:04 +01:00
parent ac7c7ff5b2
commit b8c2780bfe
1 changed files with 32 additions and 65 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

97
spring-expression/src/test/java/org/springframework/expression/spel/ExpressionWithConversionTests.java
View File

@ -1,5 +1,5 @@
/*
* Copyright 2002-2024 the original author or authors.
* Copyright 2002-2025 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@ -16,27 +16,24 @@
package org.springframework.expression.spel;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Set;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.core.MethodParameter;
import org.springframework.core.convert.ConversionService;
import org.springframework.core.convert.TypeDescriptor;
import org.springframework.core.convert.support.DefaultConversionService;
import org.springframework.expression.EvaluationException;
import org.springframework.expression.Expression;
import org.springframework.expression.TypeConverter;
import org.springframework.expression.spel.support.StandardEvaluationContext;
import org.springframework.expression.spel.support.StandardTypeConverter;
import org.springframework.util.ReflectionUtils;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Expression evaluation where the TypeConverter plugged in is the
* Expression evaluation where the TypeConverter plugged in uses the
* {@link org.springframework.core.convert.support.GenericConversionService}.
*
* @author Andy Clement
@ -44,54 +41,43 @@ import static org.assertj.core.api.Assertions.assertThat;
*/
class ExpressionWithConversionTests extends AbstractExpressionTests {
private static List<String> listOfString = new ArrayList<>();
private static TypeDescriptor typeDescriptorForListOfString = null;
private static List<Integer> listOfInteger = new ArrayList<>();
private static TypeDescriptor typeDescriptorForListOfInteger = null;
private static final List<String> listOfString = List.of("1", "2", "3");
private static final List<Integer> listOfInteger = List.of(4, 5, 6);
static {
listOfString.add("1");
listOfString.add("2");
listOfString.add("3");
listOfInteger.add(4);
listOfInteger.add(5);
listOfInteger.add(6);
}
@BeforeEach
void setUp() throws Exception {
ExpressionWithConversionTests.typeDescriptorForListOfString = new TypeDescriptor(ExpressionWithConversionTests.class.getDeclaredField("listOfString"));
ExpressionWithConversionTests.typeDescriptorForListOfInteger = new TypeDescriptor(ExpressionWithConversionTests.class.getDeclaredField("listOfInteger"));
}
private static final TypeDescriptor typeDescriptorForListOfString =
new TypeDescriptor(ReflectionUtils.findField(ExpressionWithConversionTests.class, "listOfString"));
private static TypeDescriptor typeDescriptorForListOfInteger =
new TypeDescriptor(ReflectionUtils.findField(ExpressionWithConversionTests.class, "listOfInteger"));
/**
* Test the service can convert what we are about to use in the expression evaluation tests.
*/
@Test
void testConversionsAvailable() {
TypeConvertorUsingConversionService tcs = new TypeConvertorUsingConversionService();
void conversionsAreSupportedByStandardTypeConverter() {
StandardTypeConverter typeConverter = new StandardTypeConverter();
// ArrayList containing List<Integer> to List<String>
// List<Integer> to List<String>
Class<?> clazz = typeDescriptorForListOfString.getElementTypeDescriptor().getType();
assertThat(clazz).isEqualTo(String.class);
List<?> l = (List<?>) tcs.convertValue(listOfInteger, TypeDescriptor.forObject(listOfInteger), typeDescriptorForListOfString);
List<?> l = (List<?>) typeConverter.convertValue(listOfInteger, TypeDescriptor.forObject(listOfInteger), typeDescriptorForListOfString);
assertThat(l).isNotNull();
// ArrayList containing List<String> to List<Integer>
// List<String> to List<Integer>
clazz = typeDescriptorForListOfInteger.getElementTypeDescriptor().getType();
assertThat(clazz).isEqualTo(Integer.class);
l = (List<?>) tcs.convertValue(listOfString, TypeDescriptor.forObject(listOfString), typeDescriptorForListOfString);
l = (List<?>) typeConverter.convertValue(listOfString, TypeDescriptor.forObject(listOfString), typeDescriptorForListOfString);
assertThat(l).isNotNull();
}
@Test
void testSetParameterizedList() {
void setParameterizedList() {
StandardEvaluationContext context = TestScenarioCreator.getTestEvaluationContext();
Expression e = parser.parseExpression("listOfInteger.size()");
assertThat(e.getValue(context, Integer.class)).isZero();
context.setTypeConverter(new TypeConvertorUsingConversionService());
// Assign a List<String> to the List<Integer> field - the component elements should be converted
parser.parseExpression("listOfInteger").setValue(context,listOfString);
// size now 3
@ -101,7 +87,7 @@ class ExpressionWithConversionTests extends AbstractExpressionTests {
}
@Test
void testCoercionToCollectionOfPrimitive() throws Exception {
void coercionToCollectionOfPrimitive() throws Exception {
class TestTarget {
@SuppressWarnings("unused")
@ -115,28 +101,28 @@ class ExpressionWithConversionTests extends AbstractExpressionTests {
}
StandardEvaluationContext evaluationContext = new StandardEvaluationContext();
TypeConverter typeConverter = evaluationContext.getTypeConverter();
TypeDescriptor collectionType = new TypeDescriptor(new MethodParameter(TestTarget.class.getDeclaredMethod(
"sum", Collection.class), 0));
// The type conversion is possible
assertThat(evaluationContext.getTypeConverter()
.canConvert(TypeDescriptor.valueOf(String.class), collectionType)).isTrue();
assertThat(typeConverter.canConvert(TypeDescriptor.valueOf(String.class), collectionType)).isTrue();
// ... and it can be done successfully
assertThat(evaluationContext.getTypeConverter().convertValue("1,2,3,4", TypeDescriptor.valueOf(String.class), collectionType).toString()).isEqualTo("[1, 2, 3, 4]");
assertThat(typeConverter.convertValue("1,2,3,4", TypeDescriptor.valueOf(String.class), collectionType))
.hasToString("[1, 2, 3, 4]");
evaluationContext.setVariable("target", new TestTarget());
// OK up to here, so the evaluation should be fine...
// ... but this fails
int result = (Integer) parser.parseExpression("#target.sum(#root)").getValue(evaluationContext, "1,2,3,4");
assertThat(result).as("Wrong result: " + result).isEqualTo(10);
int result = parser.parseExpression("#target.sum(#root)").getValue(evaluationContext, "1,2,3,4", int.class);
assertThat(result).isEqualTo(10);
}
@Test
void testConvert() {
void convert() {
Foo root = new Foo("bar");
Collection<String> foos = Collections.singletonList("baz");
Collection<String> foos = Set.of("baz");
StandardEvaluationContext context = new StandardEvaluationContext(root);
@ -163,26 +149,7 @@ class ExpressionWithConversionTests extends AbstractExpressionTests {
expression = parser.parseExpression("setFoos(getFoosAsObjects())");
expression.getValue(context);
baz = root.getFoos().iterator().next();
assertThat(baz.value).isEqualTo("baz");
}
/**
* Type converter that uses the core conversion service.
*/
private static class TypeConvertorUsingConversionService implements TypeConverter {
private final ConversionService service = new DefaultConversionService();
@Override
public boolean canConvert(TypeDescriptor sourceType, TypeDescriptor targetType) {
return this.service.canConvert(sourceType, targetType);
}
@Override
public Object convertValue(Object value, TypeDescriptor sourceType, TypeDescriptor targetType) throws EvaluationException {
return this.service.convert(value, sourceType, targetType);
}
assertThat(baz.value).isEqualTo("quux");
}
@ -205,11 +172,11 @@ class ExpressionWithConversionTests extends AbstractExpressionTests {
}
public Collection<String> getFoosAsStrings() {
return Collections.singletonList("baz");
return Set.of("baz");
}
public Collection<?> getFoosAsObjects() {
return Collections.singletonList("baz");
return Set.of("quux");
}
}