Skip to content

Commit 1475cde

Browse files
mp911dechristophstrobl
mp911de
authored and
christophstrobl
committed
DATAMONGO-1719 - Polishing.
Use mockito extensions to mimic static imports. Use Lombok's FieldDefaults and NonNull in operations support. Original Pull Request: spring-projects#487
1 parent 4734a29 commit 1475cde

11 files changed

+252
-213
lines changed

‎spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/ExecutableAggregationOperationSupport.java

+11-7
Original file line numberDiff line numberDiff line change
@@ -15,7 +15,10 @@
1515
*/
1616
package org.springframework.data.mongodb.core;
1717

18+
import lombok.AccessLevel;
19+
import lombok.NonNull;
1820
import lombok.RequiredArgsConstructor;
21+
import lombok.experimental.FieldDefaults;
1922

2023
import org.springframework.data.mongodb.core.aggregation.Aggregation;
2124
import org.springframework.data.mongodb.core.aggregation.AggregationResults;
@@ -53,36 +56,37 @@ public <T> ExecutableAggregation<T> aggregateAndReturn(Class<T> domainType) {
5356

5457
Assert.notNull(domainType, "DomainType must not be null!");
5558

56-
return new ExecutableAggregationSupport<>(template, null, domainType, null);
59+
return new ExecutableAggregationSupport<>(template, domainType, null, null);
5760
}
5861

5962
/**
6063
* @author Christoph Strobl
6164
* @since 2.0
6265
*/
6366
@RequiredArgsConstructor
67+
@FieldDefaults(level = AccessLevel.PRIVATE, makeFinal = true)
6468
static class ExecutableAggregationSupport<T>
6569
implements AggregationWithAggregation<T>, ExecutableAggregation<T>, TerminatingAggregation<T> {
6670

67-
private final MongoTemplate template;
68-
private final Aggregation aggregation;
69-
private final Class<T> domainType;
70-
private final String collection;
71+
@NonNull MongoTemplate template;
72+
@NonNull Class<T> domainType;
73+
Aggregation aggregation;
74+
String collection;
7175

7276
@Override
7377
public AggregationWithAggregation<T> inCollection(String collection) {
7478

7579
Assert.hasText(collection, "Collection must not be null nor empty!");
7680

77-
return new ExecutableAggregationSupport<>(template, aggregation, domainType, collection);
81+
return new ExecutableAggregationSupport<>(template, domainType, aggregation, collection);
7882
}
7983

8084
@Override
8185
public TerminatingAggregation<T> by(Aggregation aggregation) {
8286

8387
Assert.notNull(aggregation, "Aggregation must not be null!");
8488

85-
return new ExecutableAggregationSupport<>(template, aggregation, domainType, collection);
89+
return new ExecutableAggregationSupport<>(template, domainType, aggregation, collection);
8690
}
8791

8892
@Override

‎spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/ExecutableFindOperationSupport.java

+9-5
Original file line numberDiff line numberDiff line change
@@ -15,7 +15,10 @@
1515
*/
1616
package org.springframework.data.mongodb.core;
1717

18+
import lombok.AccessLevel;
19+
import lombok.NonNull;
1820
import lombok.RequiredArgsConstructor;
21+
import lombok.experimental.FieldDefaults;
1922

2023
import java.util.List;
2124
import java.util.Optional;
@@ -74,14 +77,15 @@ public <T> ExecutableFind<T> query(Class<T> domainType) {
7477
* @since 2.0
7578
*/
7679
@RequiredArgsConstructor
80+
@FieldDefaults(level = AccessLevel.PRIVATE, makeFinal = true)
7781
static class ExecutableFindSupport<T>
7882
implements ExecutableFind<T>, FindWithCollection<T>, FindWithProjection<T>, FindWithQuery<T> {
7983

80-
private final MongoTemplate template;
81-
private final Class<?> domainType;
82-
private final Class<T> returnType;
83-
private final String collection;
84-
private final Query query;
84+
@NonNull MongoTemplate template;
85+
@NonNull Class<?> domainType;
86+
Class<T> returnType;
87+
String collection;
88+
Query query;
8589

8690
@Override
8791
public FindWithProjection<T> inCollection(String collection) {

‎spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/ExecutableInsertOperationSupport.java

+8-4
Original file line numberDiff line numberDiff line change
@@ -15,11 +15,14 @@
1515
*/
1616
package org.springframework.data.mongodb.core;
1717

18+
import lombok.AccessLevel;
19+
import lombok.NonNull;
1820
import lombok.RequiredArgsConstructor;
1921

2022
import java.util.ArrayList;
2123
import java.util.Collection;
2224

25+
import lombok.experimental.FieldDefaults;
2326
import org.springframework.data.mongodb.core.BulkOperations.BulkMode;
2427
import org.springframework.util.Assert;
2528
import org.springframework.util.StringUtils;
@@ -63,12 +66,13 @@ public <T> ExecutableInsert<T> insert(Class<T> domainType) {
6366
* @since 2.0
6467
*/
6568
@RequiredArgsConstructor
69+
@FieldDefaults(level = AccessLevel.PRIVATE, makeFinal = true)
6670
static class ExecutableInsertSupport<T> implements ExecutableInsert<T> {
6771

68-
private final MongoTemplate template;
69-
private final Class<T> domainType;
70-
private final String collection;
71-
private final BulkMode bulkMode;
72+
@NonNull MongoTemplate template;
73+
@NonNull Class<T> domainType;
74+
String collection;
75+
BulkMode bulkMode;
7276

7377
@Override
7478
public void one(T object) {

‎spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/ExecutableRemoveOperationSupport.java

+11-7
Original file line numberDiff line numberDiff line change
@@ -15,7 +15,10 @@
1515
*/
1616
package org.springframework.data.mongodb.core;
1717

18+
import lombok.AccessLevel;
19+
import lombok.NonNull;
1820
import lombok.RequiredArgsConstructor;
21+
import lombok.experimental.FieldDefaults;
1922

2023
import java.util.List;
2124

@@ -56,35 +59,36 @@ public <T> ExecutableRemove<T> remove(Class<T> domainType) {
5659

5760
Assert.notNull(domainType, "DomainType must not be null!");
5861

59-
return new ExecutableRemoveSupport<>(tempate, null, domainType, null);
62+
return new ExecutableRemoveSupport<>(tempate, domainType, null, null);
6063
}
6164

6265
/**
6366
* @author Christoph Strobl
6467
* @since 2.0
6568
*/
6669
@RequiredArgsConstructor
70+
@FieldDefaults(level = AccessLevel.PRIVATE, makeFinal = true)
6771
static class ExecutableRemoveSupport<T> implements ExecutableRemove<T>, RemoveWithCollection<T> {
6872

69-
private final MongoTemplate template;
70-
private final Query query;
71-
private final Class<T> domainType;
72-
private final String collection;
73+
@NonNull MongoTemplate template;
74+
@NonNull Class<T> domainType;
75+
Query query;
76+
String collection;
7377

7478
@Override
7579
public RemoveWithQuery<T> inCollection(String collection) {
7680

7781
Assert.hasText(collection, "Collection must not be null nor empty!");
7882

79-
return new ExecutableRemoveSupport<>(template, query, domainType, collection);
83+
return new ExecutableRemoveSupport<>(template, domainType, query, collection);
8084
}
8185

8286
@Override
8387
public TerminatingRemove<T> matching(Query query) {
8488

8589
Assert.notNull(query, "Query must not be null!");
8690

87-
return new ExecutableRemoveSupport<>(template, query, domainType, collection);
91+
return new ExecutableRemoveSupport<>(template, domainType, query, collection);
8892
}
8993

9094
@Override

‎spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/ExecutableUpdateOperationSupport.java

+15-11
Original file line numberDiff line numberDiff line change
@@ -15,7 +15,10 @@
1515
*/
1616
package org.springframework.data.mongodb.core;
1717

18+
import lombok.AccessLevel;
19+
import lombok.NonNull;
1820
import lombok.RequiredArgsConstructor;
21+
import lombok.experimental.FieldDefaults;
1922

2023
import java.util.Optional;
2124

@@ -56,38 +59,39 @@ public <T> ExecutableUpdate<T> update(Class<T> domainType) {
5659

5760
Assert.notNull(domainType, "DomainType must not be null!");
5861

59-
return new ExecutableUpdateSupport<>(template, null, domainType, null, null, null);
62+
return new ExecutableUpdateSupport<>(template, domainType, null, null, null, null);
6063
}
6164

6265
/**
6366
* @author Christoph Strobl
6467
* @since 2.0
6568
*/
6669
@RequiredArgsConstructor
70+
@FieldDefaults(level = AccessLevel.PRIVATE, makeFinal = true)
6771
static class ExecutableUpdateSupport<T>
6872
implements ExecutableUpdate<T>, UpdateWithCollection<T>, UpdateWithQuery<T>, TerminatingUpdate<T> {
6973

70-
private final MongoTemplate template;
71-
private final Query query;
72-
private final Class<T> domainType;
73-
private final Update update;
74-
private final String collection;
75-
private final FindAndModifyOptions options;
74+
@NonNull MongoTemplate template;
75+
@NonNull Class<T> domainType;
76+
Query query;
77+
Update update;
78+
String collection;
79+
FindAndModifyOptions options;
7680

7781
@Override
7882
public TerminatingUpdate<T> apply(Update update) {
7983

8084
Assert.notNull(update, "Update must not be null!");
8185

82-
return new ExecutableUpdateSupport<>(template, query, domainType, update, collection, options);
86+
return new ExecutableUpdateSupport<>(template, domainType, query, update, collection, options);
8387
}
8488

8589
@Override
8690
public UpdateWithQuery<T> inCollection(String collection) {
8791

8892
Assert.hasText(collection, "Collection must not be null nor empty!");
8993

90-
return new ExecutableUpdateSupport<>(template, query, domainType, update, collection, options);
94+
return new ExecutableUpdateSupport<>(template, domainType, query, update, collection, options);
9195
}
9296

9397
@Override
@@ -114,7 +118,7 @@ public UpdateWithUpdate<T> matching(Query query) {
114118

115119
Assert.notNull(query, "Query must not be null!");
116120

117-
return new ExecutableUpdateSupport<>(template, query, domainType, update, collection, options);
121+
return new ExecutableUpdateSupport<>(template, domainType, query, update, collection, options);
118122
}
119123

120124
@Override
@@ -127,7 +131,7 @@ public TerminatingFindAndModify<T> withOptions(FindAndModifyOptions options) {
127131

128132
Assert.notNull(options, "Options must not be null!");
129133

130-
return new ExecutableUpdateSupport<>(template, query, domainType, update, collection, options);
134+
return new ExecutableUpdateSupport<>(template, domainType, query, update, collection, options);
131135
}
132136

133137
private UpdateResult doUpdate(boolean multi, boolean upsert) {

‎spring-data-mongodb/src/test/kotlin/org/springframework/data/mongodb/core/ExecutableAggregationOperationExtensionsTests.kt

+6-2
Original file line numberDiff line numberDiff line change
@@ -15,6 +15,7 @@
1515
*/
1616
package org.springframework.data.mongodb.core
1717

18+
import com.nhaarman.mockito_kotlin.verify
1819
import example.first.First
1920
import org.junit.Test
2021
import org.junit.runner.RunWith
@@ -25,6 +26,7 @@ import org.mockito.junit.MockitoJUnitRunner
2526

2627
/**
2728
* @author Sebastien Deleuze
29+
* @author Mark Paluch
2830
*/
2931
@RunWith(MockitoJUnitRunner::class)
3032
class ExecutableAggregationOperationExtensionsTests {
@@ -34,13 +36,15 @@ class ExecutableAggregationOperationExtensionsTests {
3436

3537
@Test // DATAMONGO-1689
3638
fun `aggregateAndReturn(KClass) extension should call its Java counterpart`() {
39+
3740
operation.aggregateAndReturn(First::class)
38-
Mockito.verify(operation, Mockito.times(1)).aggregateAndReturn(First::class.java)
41+
verify(operation).aggregateAndReturn(First::class.java)
3942
}
4043

4144
@Test // DATAMONGO-1689
4245
fun `aggregateAndReturn() with reified type parameter extension should call its Java counterpart`() {
46+
4347
operation.aggregateAndReturn<First>()
44-
Mockito.verify(operation, Mockito.times(1)).aggregateAndReturn(First::class.java)
48+
verify(operation).aggregateAndReturn(First::class.java)
4549
}
4650
}

‎spring-data-mongodb/src/test/kotlin/org/springframework/data/mongodb/core/ExecutableFindOperationExtensionsTests.kt

+36-30
Original file line numberDiff line numberDiff line change
@@ -15,47 +15,53 @@
1515
*/
1616
package org.springframework.data.mongodb.core
1717

18+
import com.nhaarman.mockito_kotlin.verify
1819
import example.first.First
1920
import org.junit.Test
2021
import org.junit.runner.RunWith
2122
import org.mockito.Answers
2223
import org.mockito.Mock
23-
import org.mockito.Mockito
2424
import org.mockito.junit.MockitoJUnitRunner
2525

2626
/**
2727
* @author Sebastien Deleuze
28+
* @author Mark Paluch
2829
*/
2930
@RunWith(MockitoJUnitRunner::class)
3031
class ExecutableFindOperationExtensionsTests {
3132

32-
@Mock(answer = Answers.RETURNS_MOCKS)
33-
lateinit var operation: ExecutableFindOperation
34-
35-
@Mock(answer = Answers.RETURNS_MOCKS)
36-
lateinit var operationWithProjection: ExecutableFindOperation.FindOperationWithProjection<First>
37-
38-
@Test // DATAMONGO-1689
39-
fun `ExecutableFindOperation#query(KClass) extension should call its Java counterpart`() {
40-
operation.query(First::class)
41-
Mockito.verify(operation, Mockito.times(1)).query(First::class.java)
42-
}
43-
44-
@Test // DATAMONGO-1689
45-
fun `ExecutableFindOperation#query() with reified type parameter extension should call its Java counterpart`() {
46-
operation.query<First>()
47-
Mockito.verify(operation, Mockito.times(1)).query(First::class.java)
48-
}
49-
50-
@Test // DATAMONGO-1689
51-
fun `ExecutableFindOperation#FindOperationWithProjection#asType(KClass) extension should call its Java counterpart`() {
52-
operationWithProjection.asType(First::class)
53-
Mockito.verify(operationWithProjection, Mockito.times(1)).`as`(First::class.java)
54-
}
55-
56-
@Test // DATAMONGO-1689
57-
fun `ExecutableFindOperation#FindOperationWithProjection#asType() with reified type parameter extension should call its Java counterpart`() {
58-
operationWithProjection.asType()
59-
Mockito.verify(operationWithProjection, Mockito.times(1)).`as`(First::class.java)
60-
}
33+
@Mock(answer = Answers.RETURNS_MOCKS)
34+
lateinit var operation: ExecutableFindOperation
35+
36+
@Mock(answer = Answers.RETURNS_MOCKS)
37+
lateinit var operationWithProjection: ExecutableFindOperation.FindWithProjection<First>
38+
39+
@Test // DATAMONGO-1689
40+
fun `ExecutableFindOperation#query(KClass) extension should call its Java counterpart`() {
41+
42+
operation.query(First::class)
43+
verify(operation).query(First::class.java)
44+
}
45+
46+
@Test // DATAMONGO-1689
47+
fun `ExecutableFindOperation#query() with reified type parameter extension should call its Java counterpart`() {
48+
49+
operation.query<First>()
50+
verify(operation).query(First::class.java)
51+
}
52+
53+
@Test // DATAMONGO-1689
54+
fun `ExecutableFindOperation#FindOperationWithProjection#asType(KClass) extension should call its Java counterpart`() {
55+
56+
operationWithProjection.asType(First::class)
57+
verify(operationWithProjection).`as`(First::class.java)
58+
}
59+
60+
@Test // DATAMONGO-1689
61+
fun `ExecutableFindOperation#FindOperationWithProjection#asType() with reified type parameter extension should call its Java counterpart`() {
62+
63+
operationWithProjection.asType()
64+
verify(operationWithProjection).`as`(First::class.java)
65+
}
66+
6167
}

0 commit comments

Comments
 (0)