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

Polishing

This commit is contained in:
Sebastien Deleuze 2017-06-09 01:49:56 +03:00
parent 736bf1c502
commit 86580b2358
16 changed files with 668 additions and 674 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

69
spring-beans/src/test/kotlin/org/springframework/beans/factory/BeanFactoryExtensionsTests.kt
View File

@ -4,8 +4,7 @@ import org.junit.Test
import org.junit.runner.RunWith import org.junit.runner.RunWith
import org.mockito.Answers import org.mockito.Answers
import org.mockito.Mock import org.mockito.Mock
import org.mockito.Mockito import org.mockito.Mockito.*
import org.mockito.Mockito.verify
import org.mockito.junit.MockitoJUnitRunner import org.mockito.junit.MockitoJUnitRunner
/** /**
@ -16,43 +15,43 @@ import org.mockito.junit.MockitoJUnitRunner
@RunWith(MockitoJUnitRunner::class) @RunWith(MockitoJUnitRunner::class)
class BeanFactoryExtensionsTests { class BeanFactoryExtensionsTests {
@Mock(answer = Answers.RETURNS_MOCKS) @Mock(answer = Answers.RETURNS_MOCKS)
lateinit var bf: BeanFactory lateinit var bf: BeanFactory
@Test @Test
fun `getBean with KClass`() { fun `getBean with KClass`() {
bf.getBean(Foo::class) bf.getBean(Foo::class)
verify(bf, Mockito.times(1)).getBean(Foo::class.java) verify(bf, times(1)).getBean(Foo::class.java)
} }
@Test @Test
fun `getBean with reified type parameters`() { fun `getBean with reified type parameters`() {
bf.getBean<Foo>() bf.getBean<Foo>()
verify(bf, Mockito.times(1)).getBean(Foo::class.java) verify(bf, times(1)).getBean(Foo::class.java)
} }
@Test @Test
fun `getBean with String and reified type parameters`() { fun `getBean with String and reified type parameters`() {
val name = "foo" val name = "foo"
bf.getBean<Foo>(name) bf.getBean<Foo>(name)
verify(bf, Mockito.times(1)).getBean(name, Foo::class.java) verify(bf, times(1)).getBean(name, Foo::class.java)
} }
@Test @Test
fun `getBean with KClass and varargs`() { fun `getBean with KClass and varargs`() {
val arg1 = "arg1" val arg1 = "arg1"
val arg2 = "arg2" val arg2 = "arg2"
bf.getBean(Foo::class, arg1, arg2) bf.getBean(Foo::class, arg1, arg2)
verify(bf, Mockito.times(1)).getBean(Foo::class.java, arg1, arg2) verify(bf, times(1)).getBean(Foo::class.java, arg1, arg2)
} }
@Test @Test
fun `getBean with reified type parameters and varargs`() { fun `getBean with reified type parameters and varargs`() {
val arg1 = "arg1" val arg1 = "arg1"
val arg2 = "arg2" val arg2 = "arg2"
bf.getBean<Foo>(arg1, arg2) bf.getBean<Foo>(arg1, arg2)
verify(bf, Mockito.times(1)).getBean(Foo::class.java, arg1, arg2) verify(bf, times(1)).getBean(Foo::class.java, arg1, arg2)
} }
class Foo class Foo
} }

196
spring-beans/src/test/kotlin/org/springframework/beans/factory/ListableBeanFactoryExtensionsTests.kt
View File

@ -4,7 +4,7 @@ import org.junit.Test
import org.junit.runner.RunWith import org.junit.runner.RunWith
import org.mockito.Answers import org.mockito.Answers
import org.mockito.Mock import org.mockito.Mock
import org.mockito.Mockito import org.mockito.Mockito.*
import org.mockito.junit.MockitoJUnitRunner import org.mockito.junit.MockitoJUnitRunner
/** /**
@ -13,122 +13,122 @@ import org.mockito.junit.MockitoJUnitRunner
* @author Sebastien Deleuze * @author Sebastien Deleuze
*/ */
@RunWith(MockitoJUnitRunner::class) @RunWith(MockitoJUnitRunner::class)
class ListenableBeanFactoryExtensionsTests { class ListableBeanFactoryExtensionsTests {
@Mock(answer = Answers.RETURNS_MOCKS) @Mock(answer = Answers.RETURNS_MOCKS)
lateinit var lbf: ListableBeanFactory lateinit var lbf: ListableBeanFactory
@Test @Test
fun `getBeanNamesForType with KClass`() { fun `getBeanNamesForType with KClass`() {
lbf.getBeanNamesForType(Foo::class) lbf.getBeanNamesForType(Foo::class)
Mockito.verify(lbf, Mockito.times(1)).getBeanNamesForType(Foo::class.java, true , true) verify(lbf, times(1)).getBeanNamesForType(Foo::class.java, true , true)
} }
@Test @Test
fun `getBeanNamesForType with KClass and Boolean`() { fun `getBeanNamesForType with KClass and Boolean`() {
lbf.getBeanNamesForType(Foo::class, false) lbf.getBeanNamesForType(Foo::class, false)
Mockito.verify(lbf, Mockito.times(1)).getBeanNamesForType(Foo::class.java, false , true) verify(lbf, times(1)).getBeanNamesForType(Foo::class.java, false , true)
} }
@Test @Test
fun `getBeanNamesForType with KClass, Boolean and Boolean`() { fun `getBeanNamesForType with KClass, Boolean and Boolean`() {
lbf.getBeanNamesForType(Foo::class, false, false) lbf.getBeanNamesForType(Foo::class, false, false)
Mockito.verify(lbf, Mockito.times(1)).getBeanNamesForType(Foo::class.java, false , false) verify(lbf, times(1)).getBeanNamesForType(Foo::class.java, false , false)
} }
@Test @Test
fun `getBeanNamesForType with reified type parameters`() { fun `getBeanNamesForType with reified type parameters`() {
lbf.getBeanNamesForType<Foo>() lbf.getBeanNamesForType<Foo>()
Mockito.verify(lbf, Mockito.times(1)).getBeanNamesForType(Foo::class.java, true , true) verify(lbf, times(1)).getBeanNamesForType(Foo::class.java, true , true)
} }
@Test @Test
fun `getBeanNamesForType with reified type parameters and Boolean`() { fun `getBeanNamesForType with reified type parameters and Boolean`() {
lbf.getBeanNamesForType<Foo>(false) lbf.getBeanNamesForType<Foo>(false)
Mockito.verify(lbf, Mockito.times(1)).getBeanNamesForType(Foo::class.java, false , true) verify(lbf, times(1)).getBeanNamesForType(Foo::class.java, false , true)
} }
@Test @Test
fun `getBeanNamesForType with reified type parameters, Boolean and Boolean`() { fun `getBeanNamesForType with reified type parameters, Boolean and Boolean`() {
lbf.getBeanNamesForType<Foo>(false, false) lbf.getBeanNamesForType<Foo>(false, false)
Mockito.verify(lbf, Mockito.times(1)).getBeanNamesForType(Foo::class.java, false , false) verify(lbf, times(1)).getBeanNamesForType(Foo::class.java, false , false)
} }
@Test @Test
fun `getBeansOfType with KClass`() { fun `getBeansOfType with KClass`() {
lbf.getBeansOfType(Foo::class) lbf.getBeansOfType(Foo::class)
Mockito.verify(lbf, Mockito.times(1)).getBeansOfType(Foo::class.java, true , true) verify(lbf, times(1)).getBeansOfType(Foo::class.java, true , true)
} }
@Test @Test
fun `getBeansOfType with KClass and Boolean`() { fun `getBeansOfType with KClass and Boolean`() {
lbf.getBeansOfType(Foo::class, false) lbf.getBeansOfType(Foo::class, false)
Mockito.verify(lbf, Mockito.times(1)).getBeansOfType(Foo::class.java, false , true) verify(lbf, times(1)).getBeansOfType(Foo::class.java, false , true)
} }
@Test @Test
fun `getBeansOfType with KClass, Boolean and Boolean`() { fun `getBeansOfType with KClass, Boolean and Boolean`() {
lbf.getBeansOfType(Foo::class, false, false) lbf.getBeansOfType(Foo::class, false, false)
Mockito.verify(lbf, Mockito.times(1)).getBeansOfType(Foo::class.java, false , false) verify(lbf, times(1)).getBeansOfType(Foo::class.java, false , false)
} }
@Test @Test
fun `getBeansOfType with reified type parameters`() { fun `getBeansOfType with reified type parameters`() {
lbf.getBeansOfType<Foo>() lbf.getBeansOfType<Foo>()
Mockito.verify(lbf, Mockito.times(1)).getBeansOfType(Foo::class.java, true , true) verify(lbf, times(1)).getBeansOfType(Foo::class.java, true , true)
} }
@Test @Test
fun `getBeansOfType with reified type parameters and Boolean`() { fun `getBeansOfType with reified type parameters and Boolean`() {
lbf.getBeansOfType<Foo>(false) lbf.getBeansOfType<Foo>(false)
Mockito.verify(lbf, Mockito.times(1)).getBeansOfType(Foo::class.java, false , true) verify(lbf, times(1)).getBeansOfType(Foo::class.java, false , true)
} }
@Test @Test
fun `getBeansOfType with reified type parameters, Boolean and Boolean`() { fun `getBeansOfType with reified type parameters, Boolean and Boolean`() {
lbf.getBeansOfType<Foo>(false, false) lbf.getBeansOfType<Foo>(false, false)
Mockito.verify(lbf, Mockito.times(1)).getBeansOfType(Foo::class.java, false , false) verify(lbf, times(1)).getBeansOfType(Foo::class.java, false , false)
} }
@Test @Test
fun `getBeanNamesForAnnotation with KClass`() { fun `getBeanNamesForAnnotation with KClass`() {
lbf.getBeanNamesForAnnotation(Bar::class) lbf.getBeanNamesForAnnotation(Bar::class)
Mockito.verify(lbf, Mockito.times(1)).getBeanNamesForAnnotation(Bar::class.java) verify(lbf, times(1)).getBeanNamesForAnnotation(Bar::class.java)
} }
@Test @Test
fun `getBeanNamesForAnnotation with reified type parameters`() { fun `getBeanNamesForAnnotation with reified type parameters`() {
lbf.getBeanNamesForAnnotation<Bar>() lbf.getBeanNamesForAnnotation<Bar>()
Mockito.verify(lbf, Mockito.times(1)).getBeanNamesForAnnotation(Bar::class.java) verify(lbf, times(1)).getBeanNamesForAnnotation(Bar::class.java)
} }
@Test @Test
fun `getBeansWithAnnotation with KClass`() { fun `getBeansWithAnnotation with KClass`() {
lbf.getBeansWithAnnotation(Bar::class) lbf.getBeansWithAnnotation(Bar::class)
Mockito.verify(lbf, Mockito.times(1)).getBeansWithAnnotation(Bar::class.java) verify(lbf, times(1)).getBeansWithAnnotation(Bar::class.java)
} }
@Test @Test
fun `getBeansWithAnnotation with reified type parameters`() { fun `getBeansWithAnnotation with reified type parameters`() {
lbf.getBeansWithAnnotation<Bar>() lbf.getBeansWithAnnotation<Bar>()
Mockito.verify(lbf, Mockito.times(1)).getBeansWithAnnotation(Bar::class.java) verify(lbf, times(1)).getBeansWithAnnotation(Bar::class.java)
} }
@Test @Test
fun `findAnnotationOnBean with String and KClass`() { fun `findAnnotationOnBean with String and KClass`() {
val name = "bar" val name = "bar"
lbf.findAnnotationOnBean(name, Bar::class) lbf.findAnnotationOnBean(name, Bar::class)
Mockito.verify(lbf, Mockito.times(1)).findAnnotationOnBean(name, Bar::class.java) verify(lbf, times(1)).findAnnotationOnBean(name, Bar::class.java)
} }
@Test @Test
fun `findAnnotationOnBean with String and reified type parameters`() { fun `findAnnotationOnBean with String and reified type parameters`() {
val name = "bar" val name = "bar"
lbf.findAnnotationOnBean<Bar>(name) lbf.findAnnotationOnBean<Bar>(name)
Mockito.verify(lbf, Mockito.times(1)).findAnnotationOnBean(name, Bar::class.java) verify(lbf, times(1)).findAnnotationOnBean(name, Bar::class.java)
} }
class Foo class Foo
annotation class Bar annotation class Bar
} }

4
spring-beans/src/test/kotlin/org/springframework/beans/factory/annotation/KotlinAutowiredTests.kt
View File

@ -38,7 +38,7 @@ class KotlinAutowiredTests {
bpp.setBeanFactory(bf) bpp.setBeanFactory(bf)
bf.addBeanPostProcessor(bpp) bf.addBeanPostProcessor(bpp)
var bd = RootBeanDefinition(KotlinBean::class.java) var bd = RootBeanDefinition(KotlinBean::class.java)
bd.setScope(RootBeanDefinition.SCOPE_PROTOTYPE) bd.scope = RootBeanDefinition.SCOPE_PROTOTYPE
bf.registerBeanDefinition("annotatedBean", bd) bf.registerBeanDefinition("annotatedBean", bd)
var tb = TestBean() var tb = TestBean()
bf.registerSingleton("testBean", tb) bf.registerSingleton("testBean", tb)
@ -56,7 +56,7 @@ class KotlinAutowiredTests {
bpp.setBeanFactory(bf) bpp.setBeanFactory(bf)
bf.addBeanPostProcessor(bpp) bf.addBeanPostProcessor(bpp)
var bd = RootBeanDefinition(KotlinBean::class.java) var bd = RootBeanDefinition(KotlinBean::class.java)
bd.setScope(RootBeanDefinition.SCOPE_PROTOTYPE) bd.scope = RootBeanDefinition.SCOPE_PROTOTYPE
bf.registerBeanDefinition("annotatedBean", bd) bf.registerBeanDefinition("annotatedBean", bd)
var kb = bf.getBean("annotatedBean", KotlinBean::class.java) var kb = bf.getBean("annotatedBean", KotlinBean::class.java)

20
spring-context/src/test/kotlin/org/springframework/context/annotation/AnnotationConfigApplicationContextExtensionsTests.kt
View File

@ -12,15 +12,15 @@ import org.springframework.context.support.registerBean
*/ */
class AnnotationConfigApplicationContextExtensionsTests { class AnnotationConfigApplicationContextExtensionsTests {
@Test @Test
fun `Instantiate AnnotationConfigApplicationContext`() { fun `Instantiate AnnotationConfigApplicationContext`() {
val applicationContext = AnnotationConfigApplicationContext { val applicationContext = AnnotationConfigApplicationContext {
registerBean<Foo>() registerBean<Foo>()
} }
applicationContext.refresh() applicationContext.refresh()
assertNotNull(applicationContext) assertNotNull(applicationContext)
assertNotNull(applicationContext.getBean<Foo>()) assertNotNull(applicationContext.getBean<Foo>())
} }
class Foo class Foo
} }

84
spring-jdbc/src/test/kotlin/org/springframework/jdbc/core/JdbcOperationsExtensionsTests.kt
View File

@ -35,123 +35,123 @@ import java.sql.*
@RunWith(MockitoJUnitRunner::class) @RunWith(MockitoJUnitRunner::class)
class JdbcOperationsExtensionsTests { class JdbcOperationsExtensionsTests {
@Mock(answer = Answers.RETURNS_MOCKS) @Mock(answer = Answers.RETURNS_MOCKS)
lateinit var template: JdbcTemplate lateinit var template: JdbcTemplate
@Test @Test
fun `queryForObject with KClass`() { fun `queryForObject with KClass`() {
val sql = "select age from customer where id = 3" val sql = "select age from customer where id = 3"
val requiredType = Int::class val requiredType = Int::class
template.queryForObject(sql, requiredType) template.queryForObject(sql, requiredType)
verify(template, times(1)).queryForObject(sql, requiredType) verify(template, times(1)).queryForObject(sql, requiredType)
} }
@Test @Test
fun `queryForObject with reified type parameters`() { fun `queryForObject with reified type parameters`() {
val sql = "select age from customer where id = 3" val sql = "select age from customer where id = 3"
template.queryForObject<Int>(sql) template.queryForObject<Int>(sql)
verify(template, times(1)).queryForObject(sql, Integer::class.java) verify(template, times(1)).queryForObject(sql, Integer::class.java)
} }
@Test @Test
fun `queryForObject with RowMapper-like function`() { fun `queryForObject with RowMapper-like function`() {
val sql = "select age from customer where id = ?" val sql = "select age from customer where id = ?"
template.queryForObject(sql, 3) { rs: ResultSet, _: Int -> rs.getInt(1) } template.queryForObject(sql, 3) { rs: ResultSet, _: Int -> rs.getInt(1) }
verify(template, times(1)).queryForObject(eq(sql), any<RowMapper<Int>>(), eq(3)) verify(template, times(1)).queryForObject(eq(sql), any<RowMapper<Int>>(), eq(3))
} }
@Test @Test
fun `queryForObject with argTypes`() { fun `queryForObject with argTypes`() {
val sql = "select age from customer where id = ?" val sql = "select age from customer where id = ?"
val args = arrayOf(3) val args = arrayOf(3)
val argTypes = intArrayOf(JDBCType.INTEGER.vendorTypeNumber) val argTypes = intArrayOf(JDBCType.INTEGER.vendorTypeNumber)
val requiredType = Int::class val requiredType = Int::class
template.queryForObject(sql, args, argTypes, requiredType) template.queryForObject(sql, args, argTypes, requiredType)
verify(template, times(1)).queryForObject(sql, args, argTypes, requiredType) verify(template, times(1)).queryForObject(sql, args, argTypes, requiredType)
} }
@Test @Test
fun `queryForObject with reified type parameters and argTypes`() { fun `queryForObject with reified type parameters and argTypes`() {
val sql = "select age from customer where id = ?" val sql = "select age from customer where id = ?"
val args = arrayOf(3) val args = arrayOf(3)
val argTypes = intArrayOf(JDBCType.INTEGER.vendorTypeNumber) val argTypes = intArrayOf(JDBCType.INTEGER.vendorTypeNumber)
template.queryForObject<Int>(sql, args, argTypes) template.queryForObject<Int>(sql, args, argTypes)
verify(template, times(1)).queryForObject(sql, args, argTypes, Integer::class.java) verify(template, times(1)).queryForObject(sql, args, argTypes, Integer::class.java)
} }
@Test @Test
fun `queryForObject with args`() { fun `queryForObject with args`() {
val sql = "select age from customer where id = ?" val sql = "select age from customer where id = ?"
val args = arrayOf(3) val args = arrayOf(3)
template.queryForObject(sql, args, Int::class) template.queryForObject(sql, args, Int::class)
verify(template, times(1)).queryForObject(sql, args, Int::class.java) verify(template, times(1)).queryForObject(sql, args, Int::class.java)
} }
@Test @Test
fun `queryForObject with reified type parameters and args`() { fun `queryForObject with reified type parameters and args`() {
val sql = "select age from customer where id = ?" val sql = "select age from customer where id = ?"
val args = arrayOf(3) val args = arrayOf(3)
template.queryForObject<Int>(sql, args) template.queryForObject<Int>(sql, args)
verify(template, times(1)).queryForObject(sql, args, Integer::class.java) verify(template, times(1)).queryForObject(sql, args, Integer::class.java)
} }
@Test @Test
fun `queryForObject with varargs`() { fun `queryForObject with varargs`() {
val sql = "select age from customer where id = ?" val sql = "select age from customer where id = ?"
template.queryForObject(sql, Int::class, 3) template.queryForObject(sql, Int::class, 3)
verify(template, times(1)).queryForObject(sql, Int::class.java, 3) verify(template, times(1)).queryForObject(sql, Int::class.java, 3)
} }
@Test @Test
fun `queryForList with reified type parameters`() { fun `queryForList with reified type parameters`() {
val sql = "select age from customer where id = 3" val sql = "select age from customer where id = 3"
template.queryForList<Int>(sql) template.queryForList<Int>(sql)
verify(template, times(1)).queryForList(sql, Integer::class.java) verify(template, times(1)).queryForList(sql, Integer::class.java)
} }
@Test @Test
fun `queryForList with reified type parameters and argTypes`() { fun `queryForList with reified type parameters and argTypes`() {
val sql = "select age from customer where id = ?" val sql = "select age from customer where id = ?"
val args = arrayOf(3) val args = arrayOf(3)
val argTypes = intArrayOf(JDBCType.INTEGER.vendorTypeNumber) val argTypes = intArrayOf(JDBCType.INTEGER.vendorTypeNumber)
template.queryForList<Int>(sql, args, argTypes) template.queryForList<Int>(sql, args, argTypes)
verify(template, times(1)).queryForList(sql, args, argTypes, Integer::class.java) verify(template, times(1)).queryForList(sql, args, argTypes, Integer::class.java)
} }
@Test @Test
fun `queryForList with reified type parameters and args`() { fun `queryForList with reified type parameters and args`() {
val sql = "select age from customer where id = ?" val sql = "select age from customer where id = ?"
val args = arrayOf(3) val args = arrayOf(3)
template.queryForList<Int>(sql, args) template.queryForList<Int>(sql, args)
verify(template, times(1)).queryForList(sql, args, Integer::class.java) verify(template, times(1)).queryForList(sql, args, Integer::class.java)
} }
@Test @Test
fun `query with ResultSetExtractor-like function`() { fun `query with ResultSetExtractor-like function`() {
val sql = "select age from customer where id = ?" val sql = "select age from customer where id = ?"
template.query<Int>(sql, 3) { rs -> template.query<Int>(sql, 3) { rs ->
rs.next() rs.next()
rs.getInt(1) rs.getInt(1)
} }
verify(template, times(1)).query(eq(sql), any<ResultSetExtractor<Int>>(), eq(3)) verify(template, times(1)).query(eq(sql), any<ResultSetExtractor<Int>>(), eq(3))
} }
@Test @Test
fun `query with RowCallbackHandler-like function`() { fun `query with RowCallbackHandler-like function`() {
val sql = "select age from customer where id = ?" val sql = "select age from customer where id = ?"
template.query(sql, 3) { rs -> template.query(sql, 3) { rs ->
assertEquals(22, rs.getInt(1)) assertEquals(22, rs.getInt(1))
} }
verify(template, times(1)).query(eq(sql), any<RowCallbackHandler>(), eq(3)) verify(template, times(1)).query(eq(sql), any<RowCallbackHandler>(), eq(3))
} }
@Test @Test
fun `query with RowMapper-like function`() { fun `query with RowMapper-like function`() {
val sql = "select age from customer where id = ?" val sql = "select age from customer where id = ?"
template.query(sql, 3) { rs, _ -> template.query(sql, 3) { rs, _ ->
rs.getInt(1) rs.getInt(1)
} }
verify(template, times(1)).query(eq(sql), any<RowMapper<Int>>(), eq(3)) verify(template, times(1)).query(eq(sql), any<RowMapper<Int>>(), eq(3))
} }
} }

230
spring-web/src/test/kotlin/org/springframework/web/client/RestOperationsExtensionsTests.kt
View File

@ -5,8 +5,7 @@ import org.junit.Test
import org.junit.runner.RunWith import org.junit.runner.RunWith
import org.mockito.Answers import org.mockito.Answers
import org.mockito.Mock import org.mockito.Mock
import org.mockito.Mockito import org.mockito.Mockito.*
import org.mockito.Mockito.verify
import org.mockito.junit.MockitoJUnitRunner import org.mockito.junit.MockitoJUnitRunner
import org.springframework.http.HttpEntity import org.springframework.http.HttpEntity
import org.springframework.http.HttpMethod import org.springframework.http.HttpMethod
@ -21,134 +20,133 @@ import java.net.URI
@RunWith(MockitoJUnitRunner::class) @RunWith(MockitoJUnitRunner::class)
class RestOperationsExtensionsTests { class RestOperationsExtensionsTests {
@Mock(answer = Answers.RETURNS_MOCKS) @Mock(answer = Answers.RETURNS_MOCKS)
lateinit var template: RestOperations lateinit var template: RestOperations
@Test @Test
fun `getForObject with reified type parameters, String and varargs`() { fun `getForObject with reified type parameters, String and varargs`() {
val url = "https://spring.io" val url = "https://spring.io"
val var1 = "var1" val var1 = "var1"
val var2 = "var2" val var2 = "var2"
template.getForObject<Foo>(url, var1, var2) template.getForObject<Foo>(url, var1, var2)
verify(template, Mockito.times(1)).getForObject(url, Foo::class.java, var1, var2) verify(template, times(1)).getForObject(url, Foo::class.java, var1, var2)
} }
@Test @Test
fun `getForObject with reified type parameters, String and Map`() { fun `getForObject with reified type parameters, String and Map`() {
val url = "https://spring.io" val url = "https://spring.io"
val vars = mapOf(Pair("key1", "value1"), Pair("key2", "value2")) val vars = mapOf(Pair("key1", "value1"), Pair("key2", "value2"))
template.getForObject<Foo>(url, vars) template.getForObject<Foo>(url, vars)
verify(template, Mockito.times(1)).getForObject(url, Foo::class.java, vars) verify(template, times(1)).getForObject(url, Foo::class.java, vars)
} }
@Test @Test
fun `getForObject with reified type parameters and URI`() { fun `getForObject with reified type parameters and URI`() {
val url = URI("https://spring.io") val url = URI("https://spring.io")
template.getForObject<Foo>(url) template.getForObject<Foo>(url)
verify(template, Mockito.times(1)).getForObject(url, Foo::class.java) verify(template, times(1)).getForObject(url, Foo::class.java)
} }
@Test @Test
fun `getForEntity with reified type parameters, String and varargs`() { fun `getForEntity with reified type parameters, String and varargs`() {
val url = "https://spring.io" val url = "https://spring.io"
val var1 = "var1" val var1 = "var1"
val var2 = "var2" val var2 = "var2"
template.getForEntity<Foo>(url, var1, var2) template.getForEntity<Foo>(url, var1, var2)
verify(template, Mockito.times(1)).getForEntity(url, Foo::class.java, var1, var2) verify(template, times(1)).getForEntity(url, Foo::class.java, var1, var2)
} }
@Test @Test
fun `postForObject with reified type parameters, String and varargs`() { fun `postForObject with reified type parameters, String and varargs`() {
val url = "https://spring.io" val url = "https://spring.io"
val body: Any = "body" val body: Any = "body"
val var1 = "var1" val var1 = "var1"
val var2 = "var2" val var2 = "var2"
template.postForObject<Foo>(url, body, var1, var2) template.postForObject<Foo>(url, body, var1, var2)
verify(template, Mockito.times(1)).postForObject(url, body, Foo::class.java, var1, var2) verify(template, times(1)).postForObject(url, body, Foo::class.java, var1, var2)
} }
@Test @Test
fun `postForObject with reified type parameters, String and Map`() { fun `postForObject with reified type parameters, String and Map`() {
val url = "https://spring.io" val url = "https://spring.io"
val body: Any = "body" val body: Any = "body"
val vars = mapOf(Pair("key1", "value1"), Pair("key2", "value2")) val vars = mapOf(Pair("key1", "value1"), Pair("key2", "value2"))
template.postForObject<Foo>(url, body, vars) template.postForObject<Foo>(url, body, vars)
verify(template, Mockito.times(1)).postForObject(url, body, Foo::class.java, vars) verify(template, times(1)).postForObject(url, body, Foo::class.java, vars)
} }
@Test @Test
fun `postForObject with reified type parameters`() { fun `postForObject with reified type parameters`() {
val url = "https://spring.io" val url = "https://spring.io"
val body: Any = "body" val body: Any = "body"
template.postForObject<Foo>(url, body) template.postForObject<Foo>(url, body)
verify(template, Mockito.times(1)).postForObject(url, body, Foo::class.java) verify(template, times(1)).postForObject(url, body, Foo::class.java)
} }
@Test @Test
fun `postForEntity with reified type parameters, String and varargs`() { fun `postForEntity with reified type parameters, String and varargs`() {
val url = "https://spring.io" val url = "https://spring.io"
val body: Any = "body" val body: Any = "body"
val var1 = "var1" val var1 = "var1"
val var2 = "var2" val var2 = "var2"
template.postForEntity<Foo>(url, body, var1, var2) template.postForEntity<Foo>(url, body, var1, var2)
verify(template, Mockito.times(1)).postForEntity(url, body, Foo::class.java, var1, var2) verify(template, times(1)).postForEntity(url, body, Foo::class.java, var1, var2)
} }
@Test @Test
fun `postForEntity with reified type parameters, String and Map`() { fun `postForEntity with reified type parameters, String and Map`() {
val url = "https://spring.io" val url = "https://spring.io"
val body: Any = "body" val body: Any = "body"
val vars = mapOf(Pair("key1", "value1"), Pair("key2", "value2")) val vars = mapOf(Pair("key1", "value1"), Pair("key2", "value2"))
template.postForEntity<Foo>(url, body, vars) template.postForEntity<Foo>(url, body, vars)
verify(template, Mockito.times(1)).postForEntity(url, body, Foo::class.java, vars) verify(template, times(1)).postForEntity(url, body, Foo::class.java, vars)
} }
@Test @Test
fun `postForEntity with reified type parameters`() { fun `postForEntity with reified type parameters`() {
val url = "https://spring.io" val url = "https://spring.io"
val body: Any = "body" val body: Any = "body"
template.postForEntity<Foo>(url, body) template.postForEntity<Foo>(url, body)
verify(template, Mockito.times(1)).postForEntity(url, body, Foo::class.java) verify(template, times(1)).postForEntity(url, body, Foo::class.java)
} }
@Test @Test
fun `exchange with reified type parameters, String, HttpMethod, HttpEntity and varargs`() { fun `exchange with reified type parameters, String, HttpMethod, HttpEntity and varargs`() {
val url = "https://spring.io" val url = "https://spring.io"
val method = HttpMethod.GET val method = HttpMethod.GET
val entity = mock<HttpEntity<Foo>>() val entity = mock<HttpEntity<Foo>>()
val var1 = "var1" val var1 = "var1"
val var2 = "var2" val var2 = "var2"
template.exchange<Foo>(url, method, entity, var1, var2) template.exchange<Foo>(url, method, entity, var1, var2)
verify(template, Mockito.times(1)).exchange(url, method, entity, Foo::class.java, var1, var2) verify(template, times(1)).exchange(url, method, entity, Foo::class.java, var1, var2)
} }
@Test @Test
fun `exchange with reified type parameters, String, HttpMethod, HttpEntity and Map`() { fun `exchange with reified type parameters, String, HttpMethod, HttpEntity and Map`() {
val url = "https://spring.io" val url = "https://spring.io"
val method = HttpMethod.GET val method = HttpMethod.GET
val entity = mock<HttpEntity<Foo>>() val entity = mock<HttpEntity<Foo>>()
val vars = mapOf(Pair("key1", "value1"), Pair("key2", "value2")) val vars = mapOf(Pair("key1", "value1"), Pair("key2", "value2"))
template.exchange<Foo>(url, method, entity, vars) template.exchange<Foo>(url, method, entity, vars)
verify(template, Mockito.times(1)).exchange(url, method, entity, Foo::class.java, vars) verify(template, times(1)).exchange(url, method, entity, Foo::class.java, vars)
} }
@Test @Test
fun `exchange with reified type parameters, String, HttpMethod, HttpEntity`() { fun `exchange with reified type parameters, String, HttpMethod, HttpEntity`() {
val url = "https://spring.io" val url = "https://spring.io"
val method = HttpMethod.GET val method = HttpMethod.GET
val entity = mock<HttpEntity<Foo>>() val entity = mock<HttpEntity<Foo>>()
template.exchange<Foo>(url, method, entity) template.exchange<Foo>(url, method, entity)
verify(template, Mockito.times(1)).exchange(url, method, entity, Foo::class.java) verify(template, times(1)).exchange(url, method, entity, Foo::class.java)
} }
@Test @Test
fun `exchange with reified type parameters, String, HttpEntity`() { fun `exchange with reified type parameters, String, HttpEntity`() {
val url = "https://spring.io" val entity = mock<RequestEntity<Foo>>()
val entity = mock<RequestEntity<Foo>>() template.exchange<Foo>(entity)
template.exchange<Foo>(entity) verify(template, times(1)).exchange(entity, Foo::class.java)
verify(template, Mockito.times(1)).exchange(entity, Foo::class.java) }
}
class Foo class Foo
} }

296
spring-web/src/test/kotlin/org/springframework/web/method/annotation/RequestParamMethodArgumentResolverKotlinTests.kt
View File

@ -32,187 +32,187 @@ import org.springframework.web.multipart.support.MissingServletRequestPartExcept
*/ */
class RequestParamMethodArgumentResolverKotlinTests { class RequestParamMethodArgumentResolverKotlinTests {
lateinit var resolver: RequestParamMethodArgumentResolver lateinit var resolver: RequestParamMethodArgumentResolver
lateinit var webRequest: NativeWebRequest lateinit var webRequest: NativeWebRequest
lateinit var binderFactory: WebDataBinderFactory lateinit var binderFactory: WebDataBinderFactory
lateinit var request: MockHttpServletRequest lateinit var request: MockHttpServletRequest
lateinit var nullableParamRequired: MethodParameter lateinit var nullableParamRequired: MethodParameter
lateinit var nullableParamNotRequired: MethodParameter lateinit var nullableParamNotRequired: MethodParameter
lateinit var nonNullableParamRequired: MethodParameter lateinit var nonNullableParamRequired: MethodParameter
lateinit var nonNullableParamNotRequired: MethodParameter lateinit var nonNullableParamNotRequired: MethodParameter
lateinit var nullableMultipartParamRequired: MethodParameter lateinit var nullableMultipartParamRequired: MethodParameter
lateinit var nullableMultipartParamNotRequired: MethodParameter lateinit var nullableMultipartParamNotRequired: MethodParameter
lateinit var nonNullableMultipartParamRequired: MethodParameter lateinit var nonNullableMultipartParamRequired: MethodParameter
lateinit var nonNullableMultipartParamNotRequired: MethodParameter lateinit var nonNullableMultipartParamNotRequired: MethodParameter
@Before @Before
fun setup() { fun setup() {
resolver = RequestParamMethodArgumentResolver(null, true) resolver = RequestParamMethodArgumentResolver(null, true)
request = MockHttpServletRequest() request = MockHttpServletRequest()
val initializer = ConfigurableWebBindingInitializer() val initializer = ConfigurableWebBindingInitializer()
initializer.conversionService = DefaultConversionService() initializer.conversionService = DefaultConversionService()
binderFactory = DefaultDataBinderFactory(initializer) binderFactory = DefaultDataBinderFactory(initializer)
webRequest = ServletWebRequest(request, MockHttpServletResponse()) webRequest = ServletWebRequest(request, MockHttpServletResponse())
val method = ReflectionUtils.findMethod(javaClass, "handle", String::class.java, val method = ReflectionUtils.findMethod(javaClass, "handle", String::class.java,
String::class.java, String::class.java, String::class.java, String::class.java, String::class.java, String::class.java,
MultipartFile::class.java, MultipartFile::class.java, MultipartFile::class.java, MultipartFile::class.java,
MultipartFile::class.java, MultipartFile::class.java) MultipartFile::class.java, MultipartFile::class.java)
nullableParamRequired = SynthesizingMethodParameter(method, 0) nullableParamRequired = SynthesizingMethodParameter(method, 0)
nullableParamNotRequired = SynthesizingMethodParameter(method, 1) nullableParamNotRequired = SynthesizingMethodParameter(method, 1)
nonNullableParamRequired = SynthesizingMethodParameter(method, 2) nonNullableParamRequired = SynthesizingMethodParameter(method, 2)
nonNullableParamNotRequired = SynthesizingMethodParameter(method, 3) nonNullableParamNotRequired = SynthesizingMethodParameter(method, 3)
nullableMultipartParamRequired = SynthesizingMethodParameter(method, 4) nullableMultipartParamRequired = SynthesizingMethodParameter(method, 4)
nullableMultipartParamNotRequired = SynthesizingMethodParameter(method, 5) nullableMultipartParamNotRequired = SynthesizingMethodParameter(method, 5)
nonNullableMultipartParamRequired = SynthesizingMethodParameter(method, 6) nonNullableMultipartParamRequired = SynthesizingMethodParameter(method, 6)
nonNullableMultipartParamNotRequired = SynthesizingMethodParameter(method, 7) nonNullableMultipartParamNotRequired = SynthesizingMethodParameter(method, 7)
} }
@Test @Test
fun resolveNullableRequiredWithParameter() { fun resolveNullableRequiredWithParameter() {
request.addParameter("name", "123") request.addParameter("name", "123")
var result = resolver.resolveArgument(nullableParamRequired, null, webRequest, binderFactory) var result = resolver.resolveArgument(nullableParamRequired, null, webRequest, binderFactory)
assertEquals("123", result) assertEquals("123", result)
} }
@Test @Test
fun resolveNullableRequiredWithoutParameter() { fun resolveNullableRequiredWithoutParameter() {
var result = resolver.resolveArgument(nullableParamRequired, null, webRequest, binderFactory) var result = resolver.resolveArgument(nullableParamRequired, null, webRequest, binderFactory)
assertNull(result) assertNull(result)
} }
@Test @Test
fun resolveNullableNotRequiredWithParameter() { fun resolveNullableNotRequiredWithParameter() {
request.addParameter("name", "123") request.addParameter("name", "123")
var result = resolver.resolveArgument(nullableParamNotRequired, null, webRequest, binderFactory) var result = resolver.resolveArgument(nullableParamNotRequired, null, webRequest, binderFactory)
assertEquals("123", result) assertEquals("123", result)
} }
@Test @Test
fun resolveNullableNotRequiredWithoutParameter() { fun resolveNullableNotRequiredWithoutParameter() {
var result = resolver.resolveArgument(nullableParamNotRequired, null, webRequest, binderFactory) var result = resolver.resolveArgument(nullableParamNotRequired, null, webRequest, binderFactory)
assertNull(result) assertNull(result)
} }
@Test @Test
fun resolveNonNullableRequiredWithParameter() { fun resolveNonNullableRequiredWithParameter() {
request.addParameter("name", "123") request.addParameter("name", "123")
var result = resolver.resolveArgument(nonNullableParamRequired, null, webRequest, binderFactory) var result = resolver.resolveArgument(nonNullableParamRequired, null, webRequest, binderFactory)
assertEquals("123", result) assertEquals("123", result)
} }
@Test(expected = MissingServletRequestParameterException::class) @Test(expected = MissingServletRequestParameterException::class)
fun resolveNonNullableRequiredWithoutParameter() { fun resolveNonNullableRequiredWithoutParameter() {
resolver.resolveArgument(nonNullableParamRequired, null, webRequest, binderFactory) resolver.resolveArgument(nonNullableParamRequired, null, webRequest, binderFactory)
} }
@Test @Test
fun resolveNonNullableNotRequiredWithParameter() { fun resolveNonNullableNotRequiredWithParameter() {
request.addParameter("name", "123") request.addParameter("name", "123")
var result = resolver.resolveArgument(nonNullableParamNotRequired, null, webRequest, binderFactory) var result = resolver.resolveArgument(nonNullableParamNotRequired, null, webRequest, binderFactory)
assertEquals("123", result) assertEquals("123", result)
} }
@Test(expected = TypeCastException::class) @Test(expected = TypeCastException::class)
fun resolveNonNullableNotRequiredWithoutParameter() { fun resolveNonNullableNotRequiredWithoutParameter() {
resolver.resolveArgument(nonNullableParamNotRequired, null, webRequest, binderFactory) as String resolver.resolveArgument(nonNullableParamNotRequired, null, webRequest, binderFactory) as String
} }
@Test @Test
fun resolveNullableRequiredWithMultipartParameter() { fun resolveNullableRequiredWithMultipartParameter() {
val request = MockMultipartHttpServletRequest() val request = MockMultipartHttpServletRequest()
val expected = MockMultipartFile("mfile", "Hello World".toByteArray()) val expected = MockMultipartFile("mfile", "Hello World".toByteArray())
request.addFile(expected) request.addFile(expected)
webRequest = ServletWebRequest(request) webRequest = ServletWebRequest(request)
var result = resolver.resolveArgument(nullableMultipartParamRequired, null, webRequest, binderFactory) var result = resolver.resolveArgument(nullableMultipartParamRequired, null, webRequest, binderFactory)
assertEquals(expected, result) assertEquals(expected, result)
} }
@Test @Test
fun resolveNullableRequiredWithoutMultipartParameter() { fun resolveNullableRequiredWithoutMultipartParameter() {
request.method = HttpMethod.POST.name request.method = HttpMethod.POST.name
request.contentType = MediaType.MULTIPART_FORM_DATA_VALUE request.contentType = MediaType.MULTIPART_FORM_DATA_VALUE
var result = resolver.resolveArgument(nullableMultipartParamRequired, null, webRequest, binderFactory) var result = resolver.resolveArgument(nullableMultipartParamRequired, null, webRequest, binderFactory)
assertNull(result) assertNull(result)
} }
@Test @Test
fun resolveNullableNotRequiredWithMultipartParameter() { fun resolveNullableNotRequiredWithMultipartParameter() {
val request = MockMultipartHttpServletRequest() val request = MockMultipartHttpServletRequest()
val expected = MockMultipartFile("mfile", "Hello World".toByteArray()) val expected = MockMultipartFile("mfile", "Hello World".toByteArray())
request.addFile(expected) request.addFile(expected)
webRequest = ServletWebRequest(request) webRequest = ServletWebRequest(request)
var result = resolver.resolveArgument(nullableMultipartParamNotRequired, null, webRequest, binderFactory) var result = resolver.resolveArgument(nullableMultipartParamNotRequired, null, webRequest, binderFactory)
assertEquals(expected, result) assertEquals(expected, result)
} }
@Test @Test
fun resolveNullableNotRequiredWithoutMultipartParameter() { fun resolveNullableNotRequiredWithoutMultipartParameter() {
request.method = HttpMethod.POST.name request.method = HttpMethod.POST.name
request.contentType = MediaType.MULTIPART_FORM_DATA_VALUE request.contentType = MediaType.MULTIPART_FORM_DATA_VALUE
var result = resolver.resolveArgument(nullableMultipartParamNotRequired, null, webRequest, binderFactory) var result = resolver.resolveArgument(nullableMultipartParamNotRequired, null, webRequest, binderFactory)
assertNull(result) assertNull(result)
} }
@Test @Test
fun resolveNonNullableRequiredWithMultipartParameter() { fun resolveNonNullableRequiredWithMultipartParameter() {
val request = MockMultipartHttpServletRequest() val request = MockMultipartHttpServletRequest()
val expected = MockMultipartFile("mfile", "Hello World".toByteArray()) val expected = MockMultipartFile("mfile", "Hello World".toByteArray())
request.addFile(expected) request.addFile(expected)
webRequest = ServletWebRequest(request) webRequest = ServletWebRequest(request)
var result = resolver.resolveArgument(nonNullableMultipartParamRequired, null, webRequest, binderFactory) var result = resolver.resolveArgument(nonNullableMultipartParamRequired, null, webRequest, binderFactory)
assertEquals(expected, result) assertEquals(expected, result)
} }
@Test(expected = MissingServletRequestPartException::class) @Test(expected = MissingServletRequestPartException::class)
fun resolveNonNullableRequiredWithoutMultipartParameter() { fun resolveNonNullableRequiredWithoutMultipartParameter() {
request.method = HttpMethod.POST.name request.method = HttpMethod.POST.name
request.contentType = MediaType.MULTIPART_FORM_DATA_VALUE request.contentType = MediaType.MULTIPART_FORM_DATA_VALUE
resolver.resolveArgument(nonNullableMultipartParamRequired, null, webRequest, binderFactory) resolver.resolveArgument(nonNullableMultipartParamRequired, null, webRequest, binderFactory)
} }
@Test @Test
fun resolveNonNullableNotRequiredWithMultipartParameter() { fun resolveNonNullableNotRequiredWithMultipartParameter() {
val request = MockMultipartHttpServletRequest() val request = MockMultipartHttpServletRequest()
val expected = MockMultipartFile("mfile", "Hello World".toByteArray()) val expected = MockMultipartFile("mfile", "Hello World".toByteArray())
request.addFile(expected) request.addFile(expected)
webRequest = ServletWebRequest(request) webRequest = ServletWebRequest(request)
var result = resolver.resolveArgument(nonNullableMultipartParamNotRequired, null, webRequest, binderFactory) var result = resolver.resolveArgument(nonNullableMultipartParamNotRequired, null, webRequest, binderFactory)
assertEquals(expected, result) assertEquals(expected, result)
} }
@Test(expected = TypeCastException::class) @Test(expected = TypeCastException::class)
fun resolveNonNullableNotRequiredWithoutMultipartParameter() { fun resolveNonNullableNotRequiredWithoutMultipartParameter() {
request.method = HttpMethod.POST.name request.method = HttpMethod.POST.name
request.contentType = MediaType.MULTIPART_FORM_DATA_VALUE request.contentType = MediaType.MULTIPART_FORM_DATA_VALUE
resolver.resolveArgument(nonNullableMultipartParamNotRequired, null, webRequest, binderFactory) as MultipartFile resolver.resolveArgument(nonNullableMultipartParamNotRequired, null, webRequest, binderFactory) as MultipartFile
} }
@Suppress("unused_parameter") @Suppress("unused_parameter")
fun handle( fun handle(
@RequestParam("name") nullableParamRequired: String?, @RequestParam("name") nullableParamRequired: String?,
@RequestParam("name", required = false) nullableParamNotRequired: String?, @RequestParam("name", required = false) nullableParamNotRequired: String?,
@RequestParam("name") nonNullableParamRequired: String, @RequestParam("name") nonNullableParamRequired: String,
@RequestParam("name", required = false) nonNullableParamNotRequired: String, @RequestParam("name", required = false) nonNullableParamNotRequired: String,
@RequestParam("mfile") nullableMultipartParamRequired: MultipartFile?, @RequestParam("mfile") nullableMultipartParamRequired: MultipartFile?,
@RequestParam("mfile", required = false) nullableMultipartParamNotRequired: MultipartFile?, @RequestParam("mfile", required = false) nullableMultipartParamNotRequired: MultipartFile?,
@RequestParam("mfile") nonNullableMultipartParamRequired: MultipartFile, @RequestParam("mfile") nonNullableMultipartParamRequired: MultipartFile,
@RequestParam("mfile", required = false) nonNullableMultipartParamNotRequired: MultipartFile) { @RequestParam("mfile", required = false) nonNullableMultipartParamNotRequired: MultipartFile) {
} }
} }

34
spring-webflux/src/test/kotlin/org/springframework/web/reactive/function/BodyExtractorsExtensionsTests.kt
View File

@ -14,25 +14,25 @@ import org.mockito.junit.MockitoJUnitRunner
@RunWith(MockitoJUnitRunner::class) @RunWith(MockitoJUnitRunner::class)
class BodyExtractorsExtensionsTests { class BodyExtractorsExtensionsTests {
@Test @Test
fun `toMono with KClass`() { fun `toMono with KClass`() {
assertNotNull(toMono(Foo::class)) assertNotNull(toMono(Foo::class))
} }
@Test @Test
fun `toMono with reified type parameter`() { fun `toMono with reified type parameter`() {
assertNotNull(toMono<Foo>()) assertNotNull(toMono<Foo>())
} }
@Test @Test
fun `toFlux with KClass`() { fun `toFlux with KClass`() {
assertNotNull(toFlux(Foo::class)) assertNotNull(toFlux(Foo::class))
} }
@Test @Test
fun `toFlux with reified type parameter`() { fun `toFlux with reified type parameter`() {
assertNotNull(toFlux<Foo>()) assertNotNull(toFlux<Foo>())
} }
class Foo class Foo
} }

22
spring-webflux/src/test/kotlin/org/springframework/web/reactive/function/BodyInsertersExtensionsTests.kt
View File

@ -16,17 +16,17 @@ import org.reactivestreams.Publisher
@RunWith(MockitoJUnitRunner::class) @RunWith(MockitoJUnitRunner::class)
class BodyInsertersExtensionsTests { class BodyInsertersExtensionsTests {
@Test @Test
fun `fromPublisher with reified type parameters`() { fun `fromPublisher with reified type parameters`() {
val publisher = mock<Publisher<Foo>>() val publisher = mock<Publisher<Foo>>()
assertNotNull(fromPublisher(publisher)) assertNotNull(fromPublisher(publisher))
} }
@Test @Test
fun `fromServerSentEvents with reified type parameters`() { fun `fromServerSentEvents with reified type parameters`() {
val publisher = mock<Publisher<Foo>>() val publisher = mock<Publisher<Foo>>()
assertNotNull(fromServerSentEvents(publisher)) assertNotNull(fromServerSentEvents(publisher))
} }
class Foo class Foo
} }

49
spring-webflux/src/test/kotlin/org/springframework/web/reactive/function/client/ClientResponseExtensionsTests.kt
View File

@ -4,8 +4,7 @@ import org.junit.Test
import org.junit.runner.RunWith import org.junit.runner.RunWith
import org.mockito.Answers import org.mockito.Answers
import org.mockito.Mock import org.mockito.Mock
import org.mockito.Mockito import org.mockito.Mockito.*
import org.mockito.Mockito.verify
import org.mockito.junit.MockitoJUnitRunner import org.mockito.junit.MockitoJUnitRunner
/** /**
@ -16,32 +15,32 @@ import org.mockito.junit.MockitoJUnitRunner
@RunWith(MockitoJUnitRunner::class) @RunWith(MockitoJUnitRunner::class)
class ClientResponseExtensionsTests { class ClientResponseExtensionsTests {
@Mock(answer = Answers.RETURNS_MOCKS) @Mock(answer = Answers.RETURNS_MOCKS)
lateinit var response: ClientResponse lateinit var response: ClientResponse
@Test @Test
fun `bodyToMono with KClass`() { fun `bodyToMono with KClass`() {
response.bodyToMono(Foo::class) response.bodyToMono(Foo::class)
verify(response, Mockito.times(1)).bodyToMono(Foo::class.java) verify(response, times(1)).bodyToMono(Foo::class.java)
} }
@Test @Test
fun `bodyToMono with reified type parameters`() { fun `bodyToMono with reified type parameters`() {
response.bodyToMono<Foo>() response.bodyToMono<Foo>()
verify(response, Mockito.times(1)).bodyToMono(Foo::class.java) verify(response, times(1)).bodyToMono(Foo::class.java)
} }
@Test @Test
fun `bodyToFlux with KClass`() { fun `bodyToFlux with KClass`() {
response.bodyToFlux(Foo::class) response.bodyToFlux(Foo::class)
verify(response, Mockito.times(1)).bodyToFlux(Foo::class.java) verify(response, times(1)).bodyToFlux(Foo::class.java)
} }
@Test @Test
fun `bodyToFlux with reified type parameters`() { fun `bodyToFlux with reified type parameters`() {
response.bodyToFlux<Foo>() response.bodyToFlux<Foo>()
verify(response, Mockito.times(1)).bodyToFlux(Foo::class.java) verify(response, times(1)).bodyToFlux(Foo::class.java)
} }
class Foo class Foo
} }

105
spring-webflux/src/test/kotlin/org/springframework/web/reactive/function/client/WebClientExtensionsTests.kt
View File

@ -5,8 +5,7 @@ import org.junit.Test
import org.junit.runner.RunWith import org.junit.runner.RunWith
import org.mockito.Answers import org.mockito.Answers
import org.mockito.Mock import org.mockito.Mock
import org.mockito.Mockito import org.mockito.Mockito.*
import org.mockito.Mockito.verify
import org.mockito.junit.MockitoJUnitRunner import org.mockito.junit.MockitoJUnitRunner
import org.reactivestreams.Publisher import org.reactivestreams.Publisher
@ -18,67 +17,67 @@ import org.reactivestreams.Publisher
@RunWith(MockitoJUnitRunner::class) @RunWith(MockitoJUnitRunner::class)
class WebClientExtensionsTests { class WebClientExtensionsTests {
@Mock(answer = Answers.RETURNS_MOCKS) @Mock(answer = Answers.RETURNS_MOCKS)
lateinit var requestBodySpec: WebClient.RequestBodySpec lateinit var requestBodySpec: WebClient.RequestBodySpec
@Mock(answer = Answers.RETURNS_MOCKS) @Mock(answer = Answers.RETURNS_MOCKS)
lateinit var responseSpec: WebClient.ResponseSpec lateinit var responseSpec: WebClient.ResponseSpec
@Test @Test
fun `RequestBodySpec#body with Publisher and reified type parameters`() { fun `RequestBodySpec#body with Publisher and reified type parameters`() {
val body = mock<Publisher<Foo>>() val body = mock<Publisher<Foo>>()
requestBodySpec.body(body) requestBodySpec.body(body)
verify(requestBodySpec, Mockito.times(1)).body(body, Foo::class.java) verify(requestBodySpec, times(1)).body(body, Foo::class.java)
} }
@Test @Test
fun `ResponseSpec#bodyToMono with KClass`() { fun `ResponseSpec#bodyToMono with KClass`() {
responseSpec.bodyToMono(Foo::class) responseSpec.bodyToMono(Foo::class)
verify(responseSpec, Mockito.times(1)).bodyToMono(Foo::class.java) verify(responseSpec, times(1)).bodyToMono(Foo::class.java)
} }
@Test @Test
fun `ResponseSpec#bodyToMono with reified type parameters`() { fun `ResponseSpec#bodyToMono with reified type parameters`() {
responseSpec.bodyToMono<Foo>() responseSpec.bodyToMono<Foo>()
verify(responseSpec, Mockito.times(1)).bodyToMono(Foo::class.java) verify(responseSpec, times(1)).bodyToMono(Foo::class.java)
} }
@Test @Test
fun `ResponseSpec#bodyToFlux with KClass`() { fun `ResponseSpec#bodyToFlux with KClass`() {
responseSpec.bodyToFlux(Foo::class) responseSpec.bodyToFlux(Foo::class)
verify(responseSpec, Mockito.times(1)).bodyToFlux(Foo::class.java) verify(responseSpec, times(1)).bodyToFlux(Foo::class.java)
} }
@Test @Test
fun `ResponseSpec#bodyToFlux with reified type parameters`() { fun `ResponseSpec#bodyToFlux with reified type parameters`() {
responseSpec.bodyToFlux<Foo>() responseSpec.bodyToFlux<Foo>()
verify(responseSpec, Mockito.times(1)).bodyToFlux(Foo::class.java) verify(responseSpec, times(1)).bodyToFlux(Foo::class.java)
} }
@Test @Test
fun `ResponseSpec#toEntity with KClass`() { fun `ResponseSpec#toEntity with KClass`() {
responseSpec.toEntity(Foo::class) responseSpec.toEntity(Foo::class)
verify(responseSpec, Mockito.times(1)).toEntity(Foo::class.java) verify(responseSpec, times(1)).toEntity(Foo::class.java)
} }
@Test @Test
fun `ResponseSpec#toEntity with reified type parameters`() { fun `ResponseSpec#toEntity with reified type parameters`() {
responseSpec.toEntity<Foo>() responseSpec.toEntity<Foo>()
verify(responseSpec, Mockito.times(1)).toEntity(Foo::class.java) verify(responseSpec, times(1)).toEntity(Foo::class.java)
} }
@Test @Test
fun `ResponseSpec#toEntityList with KClass`() { fun `ResponseSpec#toEntityList with KClass`() {
responseSpec.toEntityList(Foo::class) responseSpec.toEntityList(Foo::class)
verify(responseSpec, Mockito.times(1)).toEntityList(Foo::class.java) verify(responseSpec, times(1)).toEntityList(Foo::class.java)
} }
@Test @Test
fun `ResponseSpec#toEntityList with reified type parameters`() { fun `ResponseSpec#toEntityList with reified type parameters`() {
responseSpec.toEntityList<Foo>() responseSpec.toEntityList<Foo>()
verify(responseSpec, Mockito.times(1)).toEntityList(Foo::class.java) verify(responseSpec, times(1)).toEntityList(Foo::class.java)
} }
class Foo class Foo
} }

49
spring-webflux/src/test/kotlin/org/springframework/web/reactive/function/server/ServerRequestExtensionsTests.kt
View File

@ -4,8 +4,7 @@ import org.junit.Test
import org.junit.runner.RunWith import org.junit.runner.RunWith
import org.mockito.Answers import org.mockito.Answers
import org.mockito.Mock import org.mockito.Mock
import org.mockito.Mockito import org.mockito.Mockito.*
import org.mockito.Mockito.verify
import org.mockito.junit.MockitoJUnitRunner import org.mockito.junit.MockitoJUnitRunner
import org.springframework.web.reactive.function.server.ServerRequest import org.springframework.web.reactive.function.server.ServerRequest
import org.springframework.web.reactive.function.server.bodyToFlux import org.springframework.web.reactive.function.server.bodyToFlux
@ -19,32 +18,32 @@ import org.springframework.web.reactive.function.server.bodyToMono
@RunWith(MockitoJUnitRunner::class) @RunWith(MockitoJUnitRunner::class)
class ServerRequestExtensionsTests { class ServerRequestExtensionsTests {
@Mock(answer = Answers.RETURNS_MOCKS) @Mock(answer = Answers.RETURNS_MOCKS)
lateinit var request: ServerRequest lateinit var request: ServerRequest
@Test @Test
fun `bodyToMono with KClass`() { fun `bodyToMono with KClass`() {
request.bodyToMono(Foo::class) request.bodyToMono(Foo::class)
verify(request, Mockito.times(1)).bodyToMono(Foo::class.java) verify(request, times(1)).bodyToMono(Foo::class.java)
} }
@Test @Test
fun `bodyToMono with reified type parameters`() { fun `bodyToMono with reified type parameters`() {
request.bodyToMono<Foo>() request.bodyToMono<Foo>()
verify(request, Mockito.times(1)).bodyToMono(Foo::class.java) verify(request, times(1)).bodyToMono(Foo::class.java)
} }
@Test @Test
fun `bodyToFlux with KClass`() { fun `bodyToFlux with KClass`() {
request.bodyToFlux(Foo::class) request.bodyToFlux(Foo::class)
verify(request, Mockito.times(1)).bodyToFlux(Foo::class.java) verify(request, times(1)).bodyToFlux(Foo::class.java)
} }
@Test @Test
fun `bodyToFlux with reified type parameters`() { fun `bodyToFlux with reified type parameters`() {
request.bodyToFlux<Foo>() request.bodyToFlux<Foo>()
verify(request, Mockito.times(1)).bodyToFlux(Foo::class.java) verify(request, times(1)).bodyToFlux(Foo::class.java)
} }
class Foo class Foo
} }

20
spring-webflux/src/test/kotlin/org/springframework/web/reactive/function/server/ServerResponseExtensionsTests.kt
View File

@ -5,7 +5,7 @@ import org.junit.Test
import org.junit.runner.RunWith import org.junit.runner.RunWith
import org.mockito.Answers import org.mockito.Answers
import org.mockito.Mock import org.mockito.Mock
import org.mockito.Mockito import org.mockito.Mockito.*
import org.mockito.junit.MockitoJUnitRunner import org.mockito.junit.MockitoJUnitRunner
import org.reactivestreams.Publisher import org.reactivestreams.Publisher
@ -17,16 +17,16 @@ import org.reactivestreams.Publisher
@RunWith(MockitoJUnitRunner::class) @RunWith(MockitoJUnitRunner::class)
class ServerResponseExtensionsTests { class ServerResponseExtensionsTests {
@Mock(answer = Answers.RETURNS_MOCKS) @Mock(answer = Answers.RETURNS_MOCKS)
lateinit var bodyBuilder: ServerResponse.BodyBuilder lateinit var bodyBuilder: ServerResponse.BodyBuilder
@Test @Test
fun `BodyBuilder#body with Publisher and reified type parameters`() { fun `BodyBuilder#body with Publisher and reified type parameters`() {
val body = mock<Publisher<Foo>>() val body = mock<Publisher<Foo>>()
bodyBuilder.body(body) bodyBuilder.body(body)
Mockito.verify(bodyBuilder, Mockito.times(1)).body(body, Foo::class.java) verify(bodyBuilder, times(1)).body(body, Foo::class.java)
} }
class Foo class Foo
} }

148
spring-webflux/src/test/kotlin/org/springframework/web/reactive/result/method/annotation/RequestParamMethodArgumentResolverKotlinTests.kt
View File

@ -21,95 +21,95 @@ import reactor.test.StepVerifier
*/ */
class RequestParamMethodArgumentResolverKotlinTests { class RequestParamMethodArgumentResolverKotlinTests {
lateinit var resolver: RequestParamMethodArgumentResolver lateinit var resolver: RequestParamMethodArgumentResolver
lateinit var bindingContext: BindingContext lateinit var bindingContext: BindingContext
lateinit var nullableParamRequired: MethodParameter lateinit var nullableParamRequired: MethodParameter
lateinit var nullableParamNotRequired: MethodParameter lateinit var nullableParamNotRequired: MethodParameter
lateinit var nonNullableParamRequired: MethodParameter lateinit var nonNullableParamRequired: MethodParameter
lateinit var nonNullableParamNotRequired: MethodParameter lateinit var nonNullableParamNotRequired: MethodParameter
@Before @Before
fun setup() { fun setup() {
this.resolver = RequestParamMethodArgumentResolver(null, ReactiveAdapterRegistry(), true) this.resolver = RequestParamMethodArgumentResolver(null, ReactiveAdapterRegistry(), true)
val initializer = ConfigurableWebBindingInitializer() val initializer = ConfigurableWebBindingInitializer()
initializer.conversionService = DefaultFormattingConversionService() initializer.conversionService = DefaultFormattingConversionService()
bindingContext = BindingContext(initializer) bindingContext = BindingContext(initializer)
val method = ReflectionUtils.findMethod(javaClass, "handle", String::class.java, val method = ReflectionUtils.findMethod(javaClass, "handle", String::class.java,
String::class.java, String::class.java, String::class.java) String::class.java, String::class.java, String::class.java)
nullableParamRequired = SynthesizingMethodParameter(method, 0) nullableParamRequired = SynthesizingMethodParameter(method, 0)
nullableParamNotRequired = SynthesizingMethodParameter(method, 1) nullableParamNotRequired = SynthesizingMethodParameter(method, 1)
nonNullableParamRequired = SynthesizingMethodParameter(method, 2) nonNullableParamRequired = SynthesizingMethodParameter(method, 2)
nonNullableParamNotRequired = SynthesizingMethodParameter(method, 3) nonNullableParamNotRequired = SynthesizingMethodParameter(method, 3)
} }
@Test @Test
fun resolveNullableRequiredWithParameter() { fun resolveNullableRequiredWithParameter() {
var exchange = MockServerHttpRequest.get("/path?name=123").toExchange() var exchange = MockServerHttpRequest.get("/path?name=123").toExchange()
var result = resolver.resolveArgument(nullableParamRequired, bindingContext, exchange) var result = resolver.resolveArgument(nullableParamRequired, bindingContext, exchange)
StepVerifier.create(result).expectNext("123").expectComplete().verify() StepVerifier.create(result).expectNext("123").expectComplete().verify()
} }
@Test @Test
fun resolveNullableRequiredWithoutParameter() { fun resolveNullableRequiredWithoutParameter() {
var exchange = MockServerHttpRequest.get("/").toExchange() var exchange = MockServerHttpRequest.get("/").toExchange()
var result = resolver.resolveArgument(nullableParamRequired, bindingContext, exchange) var result = resolver.resolveArgument(nullableParamRequired, bindingContext, exchange)
StepVerifier.create(result).expectComplete().verify() StepVerifier.create(result).expectComplete().verify()
} }
@Test @Test
fun resolveNullableNotRequiredWithParameter() { fun resolveNullableNotRequiredWithParameter() {
var exchange = MockServerHttpRequest.get("/path?name=123").toExchange() var exchange = MockServerHttpRequest.get("/path?name=123").toExchange()
var result = resolver.resolveArgument(nullableParamNotRequired, bindingContext, exchange) var result = resolver.resolveArgument(nullableParamNotRequired, bindingContext, exchange)
StepVerifier.create(result).expectNext("123").expectComplete().verify() StepVerifier.create(result).expectNext("123").expectComplete().verify()
} }
@Test @Test
fun resolveNullableNotRequiredWithoutParameter() { fun resolveNullableNotRequiredWithoutParameter() {
var exchange = MockServerHttpRequest.get("/").toExchange() var exchange = MockServerHttpRequest.get("/").toExchange()
var result = resolver.resolveArgument(nullableParamNotRequired, bindingContext, exchange) var result = resolver.resolveArgument(nullableParamNotRequired, bindingContext, exchange)
StepVerifier.create(result).expectComplete().verify() StepVerifier.create(result).expectComplete().verify()
} }
@Test @Test
fun resolveNonNullableRequiredWithParameter() { fun resolveNonNullableRequiredWithParameter() {
var exchange = MockServerHttpRequest.get("/path?name=123").toExchange() var exchange = MockServerHttpRequest.get("/path?name=123").toExchange()
var result = resolver.resolveArgument(nonNullableParamRequired, bindingContext, exchange) var result = resolver.resolveArgument(nonNullableParamRequired, bindingContext, exchange)
StepVerifier.create(result).expectNext("123").expectComplete().verify() StepVerifier.create(result).expectNext("123").expectComplete().verify()
} }
@Test @Test
fun resolveNonNullableRequiredWithoutParameter() { fun resolveNonNullableRequiredWithoutParameter() {
var exchange = MockServerHttpRequest.get("/").toExchange() var exchange = MockServerHttpRequest.get("/").toExchange()
var result = resolver.resolveArgument(nonNullableParamRequired, bindingContext, exchange) var result = resolver.resolveArgument(nonNullableParamRequired, bindingContext, exchange)
StepVerifier.create(result).expectError(ServerWebInputException::class.java).verify() StepVerifier.create(result).expectError(ServerWebInputException::class.java).verify()
} }
@Test @Test
fun resolveNonNullableNotRequiredWithParameter() { fun resolveNonNullableNotRequiredWithParameter() {
var exchange = MockServerHttpRequest.get("/path?name=123").toExchange() var exchange = MockServerHttpRequest.get("/path?name=123").toExchange()
var result = resolver.resolveArgument(nonNullableParamNotRequired, bindingContext, exchange) var result = resolver.resolveArgument(nonNullableParamNotRequired, bindingContext, exchange)
StepVerifier.create(result).expectNext("123").expectComplete().verify() StepVerifier.create(result).expectNext("123").expectComplete().verify()
} }
@Test @Test
fun resolveNonNullableNotRequiredWithoutParameter() { fun resolveNonNullableNotRequiredWithoutParameter() {
var exchange = MockServerHttpRequest.get("/").toExchange() var exchange = MockServerHttpRequest.get("/").toExchange()
var result = resolver.resolveArgument(nonNullableParamNotRequired, bindingContext, exchange) var result = resolver.resolveArgument(nonNullableParamNotRequired, bindingContext, exchange)
StepVerifier.create(result).expectComplete().verify() StepVerifier.create(result).expectComplete().verify()
} }
@Suppress("unused_parameter") @Suppress("unused_parameter")
fun handle( fun handle(
@RequestParam("name") nullableParamRequired: String?, @RequestParam("name") nullableParamRequired: String?,
@RequestParam("name", required = false) nullableParamNotRequired: String?, @RequestParam("name", required = false) nullableParamNotRequired: String?,
@RequestParam("name") nonNullableParamRequired: String, @RequestParam("name") nonNullableParamRequired: String,
@RequestParam("name", required = false) nonNullableParamNotRequired: String) { @RequestParam("name", required = false) nonNullableParamNotRequired: String) {
} }
} }

8
spring-webflux/src/test/kotlin/org/springframework/web/reactive/result/view/script/ScriptTemplateWithBindingsExtensions.kt
View File

@ -5,12 +5,12 @@ package org.springframework.web.reactive.result.view.script
import kotlin.script.templates.standard.ScriptTemplateWithBindings import kotlin.script.templates.standard.ScriptTemplateWithBindings
fun ScriptTemplateWithBindings.include(path: String) = fun ScriptTemplateWithBindings.include(path: String) =
(bindings["include"] as (String) -> String).invoke(path) (bindings["include"] as (String) -> String).invoke(path)
fun ScriptTemplateWithBindings.i18n(code: String) = fun ScriptTemplateWithBindings.i18n(code: String) =
(bindings["i18n"] as (String) -> String).invoke(code) (bindings["i18n"] as (String) -> String).invoke(code)
var ScriptTemplateWithBindings.foo: String var ScriptTemplateWithBindings.foo: String
get() = bindings["foo"] as String get() = bindings["foo"] as String
set(value) { throw UnsupportedOperationException()} set(value) { throw UnsupportedOperationException() }

8
spring-webmvc/src/test/kotlin/org/springframework/web/servlet/view/script/ScriptTemplateWithBindingsExtensions.kt
View File

@ -5,12 +5,12 @@ package org.springframework.web.reactive.result.view.script
import kotlin.script.templates.standard.ScriptTemplateWithBindings import kotlin.script.templates.standard.ScriptTemplateWithBindings
fun ScriptTemplateWithBindings.include(path: String) = fun ScriptTemplateWithBindings.include(path: String) =
(bindings["include"] as (String) -> String).invoke(path) (bindings["include"] as (String) -> String).invoke(path)
fun ScriptTemplateWithBindings.i18n(code: String) = fun ScriptTemplateWithBindings.i18n(code: String) =
(bindings["i18n"] as (String) -> String).invoke(code) (bindings["i18n"] as (String) -> String).invoke(code)
var ScriptTemplateWithBindings.foo: String var ScriptTemplateWithBindings.foo: String
get() = bindings["foo"] as String get() = bindings["foo"] as String
set(value) { throw UnsupportedOperationException()} set(value) { throw UnsupportedOperationException()}