Spring/spring-framework
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Polishing

Browse Source
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
Download Patch File Download Diff File Expand all files Collapse all files

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)
class BodyExtractorsExtensionsTests {
@Test
fun `toMono with KClass`() {
assertNotNull(toMono(Foo::class))
}
@Test
fun `toMono with KClass`() {
assertNotNull(toMono(Foo::class))
}
@Test
fun `toMono with reified type parameter`() {
assertNotNull(toMono<Foo>())
}
@Test
fun `toMono with reified type parameter`() {
assertNotNull(toMono<Foo>())
}
@Test
fun `toFlux with KClass`() {
assertNotNull(toFlux(Foo::class))
}
@Test
fun `toFlux with KClass`() {
assertNotNull(toFlux(Foo::class))
}
@Test
fun `toFlux with reified type parameter`() {
assertNotNull(toFlux<Foo>())
}
@Test
fun `toFlux with reified type parameter`() {
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)
class BodyInsertersExtensionsTests {
@Test
fun `fromPublisher with reified type parameters`() {
val publisher = mock<Publisher<Foo>>()
assertNotNull(fromPublisher(publisher))
}
@Test
fun `fromPublisher with reified type parameters`() {
val publisher = mock<Publisher<Foo>>()
assertNotNull(fromPublisher(publisher))
}
@Test
fun `fromServerSentEvents with reified type parameters`() {
val publisher = mock<Publisher<Foo>>()
assertNotNull(fromServerSentEvents(publisher))
}
@Test
fun `fromServerSentEvents with reified type parameters`() {
val publisher = mock<Publisher<Foo>>()
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.mockito.Answers
import org.mockito.Mock
import org.mockito.Mockito
import org.mockito.Mockito.verify
import org.mockito.Mockito.*
import org.mockito.junit.MockitoJUnitRunner
/**
@@ -16,32 +15,32 @@ import org.mockito.junit.MockitoJUnitRunner
@RunWith(MockitoJUnitRunner::class)
class ClientResponseExtensionsTests {
@Mock(answer = Answers.RETURNS_MOCKS)
lateinit var response: ClientResponse
@Mock(answer = Answers.RETURNS_MOCKS)
lateinit var response: ClientResponse
@Test
fun `bodyToMono with KClass`() {
response.bodyToMono(Foo::class)
verify(response, Mockito.times(1)).bodyToMono(Foo::class.java)
}
@Test
fun `bodyToMono with KClass`() {
response.bodyToMono(Foo::class)
verify(response, times(1)).bodyToMono(Foo::class.java)
}
@Test
fun `bodyToMono with reified type parameters`() {
response.bodyToMono<Foo>()
verify(response, Mockito.times(1)).bodyToMono(Foo::class.java)
}
@Test
fun `bodyToMono with reified type parameters`() {
response.bodyToMono<Foo>()
verify(response, times(1)).bodyToMono(Foo::class.java)
}
@Test
fun `bodyToFlux with KClass`() {
response.bodyToFlux(Foo::class)
verify(response, Mockito.times(1)).bodyToFlux(Foo::class.java)
}
@Test
fun `bodyToFlux with KClass`() {
response.bodyToFlux(Foo::class)
verify(response, times(1)).bodyToFlux(Foo::class.java)
}
@Test
fun `bodyToFlux with reified type parameters`() {
response.bodyToFlux<Foo>()
verify(response, Mockito.times(1)).bodyToFlux(Foo::class.java)
}
@Test
fun `bodyToFlux with reified type parameters`() {
response.bodyToFlux<Foo>()
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.mockito.Answers
import org.mockito.Mock
import org.mockito.Mockito
import org.mockito.Mockito.verify
import org.mockito.Mockito.*
import org.mockito.junit.MockitoJUnitRunner
import org.reactivestreams.Publisher
@@ -18,67 +17,67 @@ import org.reactivestreams.Publisher
@RunWith(MockitoJUnitRunner::class)
class WebClientExtensionsTests {
@Mock(answer = Answers.RETURNS_MOCKS)
lateinit var requestBodySpec: WebClient.RequestBodySpec
@Mock(answer = Answers.RETURNS_MOCKS)
lateinit var requestBodySpec: WebClient.RequestBodySpec
@Mock(answer = Answers.RETURNS_MOCKS)
lateinit var responseSpec: WebClient.ResponseSpec
@Mock(answer = Answers.RETURNS_MOCKS)
lateinit var responseSpec: WebClient.ResponseSpec
@Test
fun `RequestBodySpec#body with Publisher and reified type parameters`() {
val body = mock<Publisher<Foo>>()
requestBodySpec.body(body)
verify(requestBodySpec, Mockito.times(1)).body(body, Foo::class.java)
}
@Test
fun `RequestBodySpec#body with Publisher and reified type parameters`() {
val body = mock<Publisher<Foo>>()
requestBodySpec.body(body)
verify(requestBodySpec, times(1)).body(body, Foo::class.java)
}
@Test
fun `ResponseSpec#bodyToMono with KClass`() {
responseSpec.bodyToMono(Foo::class)
verify(responseSpec, Mockito.times(1)).bodyToMono(Foo::class.java)
}
@Test
fun `ResponseSpec#bodyToMono with KClass`() {
responseSpec.bodyToMono(Foo::class)
verify(responseSpec, times(1)).bodyToMono(Foo::class.java)
}
@Test
fun `ResponseSpec#bodyToMono with reified type parameters`() {
responseSpec.bodyToMono<Foo>()
verify(responseSpec, Mockito.times(1)).bodyToMono(Foo::class.java)
}
@Test
fun `ResponseSpec#bodyToMono with reified type parameters`() {
responseSpec.bodyToMono<Foo>()
verify(responseSpec, times(1)).bodyToMono(Foo::class.java)
}
@Test
fun `ResponseSpec#bodyToFlux with KClass`() {
responseSpec.bodyToFlux(Foo::class)
verify(responseSpec, Mockito.times(1)).bodyToFlux(Foo::class.java)
}
@Test
fun `ResponseSpec#bodyToFlux with KClass`() {
responseSpec.bodyToFlux(Foo::class)
verify(responseSpec, times(1)).bodyToFlux(Foo::class.java)
}
@Test
fun `ResponseSpec#bodyToFlux with reified type parameters`() {
responseSpec.bodyToFlux<Foo>()
verify(responseSpec, Mockito.times(1)).bodyToFlux(Foo::class.java)
}
@Test
fun `ResponseSpec#bodyToFlux with reified type parameters`() {
responseSpec.bodyToFlux<Foo>()
verify(responseSpec, times(1)).bodyToFlux(Foo::class.java)
}
@Test
fun `ResponseSpec#toEntity with KClass`() {
responseSpec.toEntity(Foo::class)
verify(responseSpec, Mockito.times(1)).toEntity(Foo::class.java)
}
@Test
fun `ResponseSpec#toEntity with KClass`() {
responseSpec.toEntity(Foo::class)
verify(responseSpec, times(1)).toEntity(Foo::class.java)
}
@Test
fun `ResponseSpec#toEntity with reified type parameters`() {
responseSpec.toEntity<Foo>()
verify(responseSpec, Mockito.times(1)).toEntity(Foo::class.java)
}
@Test
fun `ResponseSpec#toEntity with reified type parameters`() {
responseSpec.toEntity<Foo>()
verify(responseSpec, times(1)).toEntity(Foo::class.java)
}
@Test
fun `ResponseSpec#toEntityList with KClass`() {
responseSpec.toEntityList(Foo::class)
verify(responseSpec, Mockito.times(1)).toEntityList(Foo::class.java)
}
@Test
fun `ResponseSpec#toEntityList with KClass`() {
responseSpec.toEntityList(Foo::class)
verify(responseSpec, times(1)).toEntityList(Foo::class.java)
}
@Test
fun `ResponseSpec#toEntityList with reified type parameters`() {
responseSpec.toEntityList<Foo>()
verify(responseSpec, Mockito.times(1)).toEntityList(Foo::class.java)
}
@Test
fun `ResponseSpec#toEntityList with reified type parameters`() {
responseSpec.toEntityList<Foo>()
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.mockito.Answers
import org.mockito.Mock
import org.mockito.Mockito
import org.mockito.Mockito.verify
import org.mockito.Mockito.*
import org.mockito.junit.MockitoJUnitRunner
import org.springframework.web.reactive.function.server.ServerRequest
import org.springframework.web.reactive.function.server.bodyToFlux
@@ -19,32 +18,32 @@ import org.springframework.web.reactive.function.server.bodyToMono
@RunWith(MockitoJUnitRunner::class)
class ServerRequestExtensionsTests {
@Mock(answer = Answers.RETURNS_MOCKS)
lateinit var request: ServerRequest
@Mock(answer = Answers.RETURNS_MOCKS)
lateinit var request: ServerRequest
@Test
fun `bodyToMono with KClass`() {
request.bodyToMono(Foo::class)
verify(request, Mockito.times(1)).bodyToMono(Foo::class.java)
}
@Test
fun `bodyToMono with KClass`() {
request.bodyToMono(Foo::class)
verify(request, times(1)).bodyToMono(Foo::class.java)
}
@Test
fun `bodyToMono with reified type parameters`() {
request.bodyToMono<Foo>()
verify(request, Mockito.times(1)).bodyToMono(Foo::class.java)
}
@Test
fun `bodyToMono with reified type parameters`() {
request.bodyToMono<Foo>()
verify(request, times(1)).bodyToMono(Foo::class.java)
}
@Test
fun `bodyToFlux with KClass`() {
request.bodyToFlux(Foo::class)
verify(request, Mockito.times(1)).bodyToFlux(Foo::class.java)
}
@Test
fun `bodyToFlux with KClass`() {
request.bodyToFlux(Foo::class)
verify(request, times(1)).bodyToFlux(Foo::class.java)
}
@Test
fun `bodyToFlux with reified type parameters`() {
request.bodyToFlux<Foo>()
verify(request, Mockito.times(1)).bodyToFlux(Foo::class.java)
}
@Test
fun `bodyToFlux with reified type parameters`() {
request.bodyToFlux<Foo>()
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.mockito.Answers
import org.mockito.Mock
import org.mockito.Mockito
import org.mockito.Mockito.*
import org.mockito.junit.MockitoJUnitRunner
import org.reactivestreams.Publisher
@@ -17,16 +17,16 @@ import org.reactivestreams.Publisher
@RunWith(MockitoJUnitRunner::class)
class ServerResponseExtensionsTests {
@Mock(answer = Answers.RETURNS_MOCKS)
lateinit var bodyBuilder: ServerResponse.BodyBuilder
@Mock(answer = Answers.RETURNS_MOCKS)
lateinit var bodyBuilder: ServerResponse.BodyBuilder
@Test
fun `BodyBuilder#body with Publisher and reified type parameters`() {
val body = mock<Publisher<Foo>>()
bodyBuilder.body(body)
Mockito.verify(bodyBuilder, Mockito.times(1)).body(body, Foo::class.java)
}
@Test
fun `BodyBuilder#body with Publisher and reified type parameters`() {
val body = mock<Publisher<Foo>>()
bodyBuilder.body(body)
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 {
lateinit var resolver: RequestParamMethodArgumentResolver
lateinit var bindingContext: BindingContext
lateinit var resolver: RequestParamMethodArgumentResolver
lateinit var bindingContext: BindingContext
lateinit var nullableParamRequired: MethodParameter
lateinit var nullableParamNotRequired: MethodParameter
lateinit var nonNullableParamRequired: MethodParameter
lateinit var nonNullableParamNotRequired: MethodParameter
lateinit var nullableParamRequired: MethodParameter
lateinit var nullableParamNotRequired: MethodParameter
lateinit var nonNullableParamRequired: MethodParameter
lateinit var nonNullableParamNotRequired: MethodParameter
@Before
fun setup() {
this.resolver = RequestParamMethodArgumentResolver(null, ReactiveAdapterRegistry(), true)
val initializer = ConfigurableWebBindingInitializer()
initializer.conversionService = DefaultFormattingConversionService()
bindingContext = BindingContext(initializer)
@Before
fun setup() {
this.resolver = RequestParamMethodArgumentResolver(null, ReactiveAdapterRegistry(), true)
val initializer = ConfigurableWebBindingInitializer()
initializer.conversionService = DefaultFormattingConversionService()
bindingContext = BindingContext(initializer)
val method = ReflectionUtils.findMethod(javaClass, "handle", String::class.java,
String::class.java, String::class.java, String::class.java)
val method = ReflectionUtils.findMethod(javaClass, "handle", String::class.java,
String::class.java, String::class.java, String::class.java)
nullableParamRequired = SynthesizingMethodParameter(method, 0)
nullableParamNotRequired = SynthesizingMethodParameter(method, 1)
nonNullableParamRequired = SynthesizingMethodParameter(method, 2)
nonNullableParamNotRequired = SynthesizingMethodParameter(method, 3)
}
nullableParamRequired = SynthesizingMethodParameter(method, 0)
nullableParamNotRequired = SynthesizingMethodParameter(method, 1)
nonNullableParamRequired = SynthesizingMethodParameter(method, 2)
nonNullableParamNotRequired = SynthesizingMethodParameter(method, 3)
}
@Test
fun resolveNullableRequiredWithParameter() {
var exchange = MockServerHttpRequest.get("/path?name=123").toExchange()
var result = resolver.resolveArgument(nullableParamRequired, bindingContext, exchange)
StepVerifier.create(result).expectNext("123").expectComplete().verify()
}
@Test
fun resolveNullableRequiredWithParameter() {
var exchange = MockServerHttpRequest.get("/path?name=123").toExchange()
var result = resolver.resolveArgument(nullableParamRequired, bindingContext, exchange)
StepVerifier.create(result).expectNext("123").expectComplete().verify()
}
@Test
fun resolveNullableRequiredWithoutParameter() {
var exchange = MockServerHttpRequest.get("/").toExchange()
var result = resolver.resolveArgument(nullableParamRequired, bindingContext, exchange)
StepVerifier.create(result).expectComplete().verify()
}
@Test
fun resolveNullableRequiredWithoutParameter() {
var exchange = MockServerHttpRequest.get("/").toExchange()
var result = resolver.resolveArgument(nullableParamRequired, bindingContext, exchange)
StepVerifier.create(result).expectComplete().verify()
}
@Test
fun resolveNullableNotRequiredWithParameter() {
var exchange = MockServerHttpRequest.get("/path?name=123").toExchange()
var result = resolver.resolveArgument(nullableParamNotRequired, bindingContext, exchange)
StepVerifier.create(result).expectNext("123").expectComplete().verify()
}
@Test
fun resolveNullableNotRequiredWithParameter() {
var exchange = MockServerHttpRequest.get("/path?name=123").toExchange()
var result = resolver.resolveArgument(nullableParamNotRequired, bindingContext, exchange)
StepVerifier.create(result).expectNext("123").expectComplete().verify()
}
@Test
fun resolveNullableNotRequiredWithoutParameter() {
var exchange = MockServerHttpRequest.get("/").toExchange()
var result = resolver.resolveArgument(nullableParamNotRequired, bindingContext, exchange)
StepVerifier.create(result).expectComplete().verify()
}
@Test
fun resolveNullableNotRequiredWithoutParameter() {
var exchange = MockServerHttpRequest.get("/").toExchange()
var result = resolver.resolveArgument(nullableParamNotRequired, bindingContext, exchange)
StepVerifier.create(result).expectComplete().verify()
}
@Test
fun resolveNonNullableRequiredWithParameter() {
var exchange = MockServerHttpRequest.get("/path?name=123").toExchange()
var result = resolver.resolveArgument(nonNullableParamRequired, bindingContext, exchange)
StepVerifier.create(result).expectNext("123").expectComplete().verify()
}
@Test
fun resolveNonNullableRequiredWithParameter() {
var exchange = MockServerHttpRequest.get("/path?name=123").toExchange()
var result = resolver.resolveArgument(nonNullableParamRequired, bindingContext, exchange)
StepVerifier.create(result).expectNext("123").expectComplete().verify()
}
@Test
fun resolveNonNullableRequiredWithoutParameter() {
var exchange = MockServerHttpRequest.get("/").toExchange()
var result = resolver.resolveArgument(nonNullableParamRequired, bindingContext, exchange)
StepVerifier.create(result).expectError(ServerWebInputException::class.java).verify()
}
@Test
fun resolveNonNullableRequiredWithoutParameter() {
var exchange = MockServerHttpRequest.get("/").toExchange()
var result = resolver.resolveArgument(nonNullableParamRequired, bindingContext, exchange)
StepVerifier.create(result).expectError(ServerWebInputException::class.java).verify()
}
@Test
fun resolveNonNullableNotRequiredWithParameter() {
var exchange = MockServerHttpRequest.get("/path?name=123").toExchange()
var result = resolver.resolveArgument(nonNullableParamNotRequired, bindingContext, exchange)
StepVerifier.create(result).expectNext("123").expectComplete().verify()
}
@Test
fun resolveNonNullableNotRequiredWithParameter() {
var exchange = MockServerHttpRequest.get("/path?name=123").toExchange()
var result = resolver.resolveArgument(nonNullableParamNotRequired, bindingContext, exchange)
StepVerifier.create(result).expectNext("123").expectComplete().verify()
}
@Test
fun resolveNonNullableNotRequiredWithoutParameter() {
var exchange = MockServerHttpRequest.get("/").toExchange()
var result = resolver.resolveArgument(nonNullableParamNotRequired, bindingContext, exchange)
StepVerifier.create(result).expectComplete().verify()
}
@Test
fun resolveNonNullableNotRequiredWithoutParameter() {
var exchange = MockServerHttpRequest.get("/").toExchange()
var result = resolver.resolveArgument(nonNullableParamNotRequired, bindingContext, exchange)
StepVerifier.create(result).expectComplete().verify()
}
@Suppress("unused_parameter")
fun handle(
@RequestParam("name") nullableParamRequired: String?,
@RequestParam("name", required = false) nullableParamNotRequired: String?,
@RequestParam("name") nonNullableParamRequired: String,
@RequestParam("name", required = false) nonNullableParamNotRequired: String) {
}
@Suppress("unused_parameter")
fun handle(
@RequestParam("name") nullableParamRequired: String?,
@RequestParam("name", required = false) nullableParamNotRequired: String?,
@RequestParam("name") nonNullableParamRequired: 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
fun ScriptTemplateWithBindings.include(path: String) =
(bindings["include"] as (String) -> String).invoke(path)
(bindings["include"] as (String) -> String).invoke(path)
fun ScriptTemplateWithBindings.i18n(code: String) =
(bindings["i18n"] as (String) -> String).invoke(code)
(bindings["i18n"] as (String) -> String).invoke(code)
var ScriptTemplateWithBindings.foo: String
get() = bindings["foo"] as String
set(value) { throw UnsupportedOperationException()}
get() = bindings["foo"] as String
set(value) { throw UnsupportedOperationException() }