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

#220 - Add Fluent API for EntityOperations.

Browse Source 
Original pull request: #287.
This commit is contained in:
Mark Paluch
2020-01-24 14:36:53 +01:00
parent 8313630da8
commit 64387d1776
13 changed files with 1542 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

109
src/test/java/org/springframework/data/r2dbc/core/ReactiveDeleteOperationUnitTests.java Normal file
View File

@@ -0,0 +1,109 @@
/*
* Copyright 2020 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.data.r2dbc.core;
import static org.assertj.core.api.Assertions.*;
import static org.springframework.data.r2dbc.query.Criteria.*;
import static org.springframework.data.r2dbc.query.Query.*;
import io.r2dbc.spi.test.MockResult;
import reactor.test.StepVerifier;
import org.junit.Before;
import org.junit.Test;
import org.springframework.data.annotation.Id;
import org.springframework.data.r2dbc.dialect.PostgresDialect;
import org.springframework.data.r2dbc.mapping.SettableValue;
import org.springframework.data.r2dbc.testing.StatementRecorder;
import org.springframework.data.relational.core.mapping.Column;
/**
* Unit test for {@link ReactiveDeleteOperation}.
*
* @author Mark Paluch
*/
public class ReactiveDeleteOperationUnitTests {
DatabaseClient client;
R2dbcEntityTemplate entityTemplate;
StatementRecorder recorder;
@Before
public void before() {
recorder = StatementRecorder.newInstance();
client = DatabaseClient.builder().connectionFactory(recorder)
.dataAccessStrategy(new DefaultReactiveDataAccessStrategy(PostgresDialect.INSTANCE)).build();
entityTemplate = new R2dbcEntityTemplate(client);
}
@Test // gh-220
public void shouldDelete() {
MockResult result = MockResult.builder().rowsUpdated(1).build();
recorder.addStubbing(s -> s.startsWith("DELETE"), result);
entityTemplate.delete(Person.class) //
.matching(query(where("name").is("Walter"))) //
.all() //
.as(StepVerifier::create) //
.expectNext(1) //
.verifyComplete();
StatementRecorder.RecordedStatement statement = recorder.getCreatedStatement(s -> s.startsWith("DELETE"));
assertThat(statement.getSql()).isEqualTo("DELETE FROM person WHERE person.THE_NAME = $1");
assertThat(statement.getBindings()).hasSize(1).containsEntry(0, SettableValue.from("Walter"));
}
@Test // gh-220
public void shouldDeleteInTable() {
MockResult result = MockResult.builder().rowsUpdated(1).build();
recorder.addStubbing(s -> s.startsWith("DELETE"), result);
entityTemplate.delete(Person.class) //
.from("other_table") //
.matching(query(where("name").is("Walter"))) //
.all() //
.as(StepVerifier::create) //
.expectNext(1) //
.verifyComplete();
StatementRecorder.RecordedStatement statement = recorder.getCreatedStatement(s -> s.startsWith("DELETE"));
assertThat(statement.getSql()).isEqualTo("DELETE FROM other_table WHERE other_table.THE_NAME = $1");
}
static class Person {
@Id String id;
@Column("THE_NAME") String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
}

126
src/test/java/org/springframework/data/r2dbc/core/ReactiveInsertOperationUnitTests.java Normal file
View File

@@ -0,0 +1,126 @@
/*
* Copyright 2020 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.data.r2dbc.core;
import static org.assertj.core.api.Assertions.*;
import io.r2dbc.spi.test.MockColumnMetadata;
import io.r2dbc.spi.test.MockResult;
import io.r2dbc.spi.test.MockRow;
import io.r2dbc.spi.test.MockRowMetadata;
import reactor.test.StepVerifier;
import org.junit.Before;
import org.junit.Test;
import org.springframework.data.annotation.Id;
import org.springframework.data.r2dbc.dialect.PostgresDialect;
import org.springframework.data.r2dbc.mapping.SettableValue;
import org.springframework.data.r2dbc.testing.StatementRecorder;
import org.springframework.data.relational.core.mapping.Column;
/**
* Unit test for {@link ReactiveInsertOperation}.
*
* @author Mark Paluch
*/
public class ReactiveInsertOperationUnitTests {
DatabaseClient client;
R2dbcEntityTemplate entityTemplate;
StatementRecorder recorder;
@Before
public void before() {
recorder = StatementRecorder.newInstance();
client = DatabaseClient.builder().connectionFactory(recorder)
.dataAccessStrategy(new DefaultReactiveDataAccessStrategy(PostgresDialect.INSTANCE)).build();
entityTemplate = new R2dbcEntityTemplate(client);
}
@Test // gh-220
public void shouldInsert() {
MockRowMetadata metadata = MockRowMetadata.builder().columnMetadata(MockColumnMetadata.builder().name("id").build())
.build();
MockResult result = MockResult.builder().rowMetadata(metadata)
.row(MockRow.builder().identified("id", Object.class, 42).build()).build();
recorder.addStubbing(s -> s.startsWith("INSERT"), result);
Person person = new Person();
person.setName("Walter");
entityTemplate.insert(Person.class) //
.using(person) //
.as(StepVerifier::create) //
.consumeNextWith(actual -> {
assertThat(actual.id).isEqualTo("42");
}) //
.verifyComplete();
StatementRecorder.RecordedStatement statement = recorder.getCreatedStatement(s -> s.startsWith("INSERT"));
assertThat(statement.getSql()).isEqualTo("INSERT INTO person (THE_NAME) VALUES ($1)");
assertThat(statement.getBindings()).hasSize(1).containsEntry(0, SettableValue.from("Walter"));
}
@Test // gh-220
public void shouldUpdateInTable() {
MockRowMetadata metadata = MockRowMetadata.builder().columnMetadata(MockColumnMetadata.builder().name("id").build())
.build();
MockResult result = MockResult.builder().rowMetadata(metadata)
.row(MockRow.builder().identified("id", Object.class, 42).build()).build();
recorder.addStubbing(s -> s.startsWith("INSERT"), result);
Person person = new Person();
person.setName("Walter");
entityTemplate.insert(Person.class) //
.into("the_table") //
.using(person) //
.as(StepVerifier::create) //
.consumeNextWith(actual -> {
assertThat(actual.id).isEqualTo("42");
}) //
.verifyComplete();
StatementRecorder.RecordedStatement statement = recorder.getCreatedStatement(s -> s.startsWith("INSERT"));
assertThat(statement.getSql()).isEqualTo("INSERT INTO the_table (THE_NAME) VALUES ($1)");
}
static class Person {
@Id String id;
@Column("THE_NAME") String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
}

232
src/test/java/org/springframework/data/r2dbc/core/ReactiveSelectOperationUnitTests.java Normal file
View File

@@ -0,0 +1,232 @@
/*
* Copyright 2020 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.data.r2dbc.core;
import static org.assertj.core.api.Assertions.*;
import static org.springframework.data.r2dbc.query.Criteria.*;
import static org.springframework.data.r2dbc.query.Query.*;
import io.r2dbc.spi.test.MockColumnMetadata;
import io.r2dbc.spi.test.MockResult;
import io.r2dbc.spi.test.MockRow;
import io.r2dbc.spi.test.MockRowMetadata;
import reactor.test.StepVerifier;
import org.junit.Before;
import org.junit.Test;
import org.springframework.data.annotation.Id;
import org.springframework.data.r2dbc.dialect.PostgresDialect;
import org.springframework.data.r2dbc.testing.StatementRecorder;
import org.springframework.data.relational.core.mapping.Column;
/**
* Unit test for {@link ReactiveSelectOperation}.
*
* @author Mark Paluch
*/
public class ReactiveSelectOperationUnitTests {
DatabaseClient client;
R2dbcEntityTemplate entityTemplate;
StatementRecorder recorder;
@Before
public void before() {
recorder = StatementRecorder.newInstance();
client = DatabaseClient.builder().connectionFactory(recorder)
.dataAccessStrategy(new DefaultReactiveDataAccessStrategy(PostgresDialect.INSTANCE)).build();
entityTemplate = new R2dbcEntityTemplate(client);
}
@Test // gh-220
public void shouldSelectAll() {
MockRowMetadata metadata = MockRowMetadata.builder().columnMetadata(MockColumnMetadata.builder().name("id").build())
.build();
MockResult result = MockResult.builder().rowMetadata(metadata)
.row(MockRow.builder().identified("id", Object.class, "Walter").build()).build();
recorder.addStubbing(s -> s.startsWith("SELECT"), result);
entityTemplate.select(Person.class) //
.matching(query(where("name").is("Walter")).limit(10).offset(20)) //
.all() //
.as(StepVerifier::create) //
.expectNextCount(1) //
.verifyComplete();
StatementRecorder.RecordedStatement statement = recorder.getCreatedStatement(s -> s.startsWith("SELECT"));
assertThat(statement.getSql())
.isEqualTo("SELECT person.* FROM person WHERE person.THE_NAME = $1 LIMIT 10 OFFSET 20");
}
@Test // gh-220
public void shouldSelectAs() {
MockRowMetadata metadata = MockRowMetadata.builder().columnMetadata(MockColumnMetadata.builder().name("id").build())
.build();
MockResult result = MockResult.builder().rowMetadata(metadata)
.row(MockRow.builder().identified("id", Object.class, "Walter").build()).build();
recorder.addStubbing(s -> s.startsWith("SELECT"), result);
entityTemplate.select(Person.class) //
.as(PersonProjection.class) //
.matching(query(where("name").is("Walter"))) //
.all() //
.as(StepVerifier::create) //
.expectNextCount(1) //
.verifyComplete();
StatementRecorder.RecordedStatement statement = recorder.getCreatedStatement(s -> s.startsWith("SELECT"));
assertThat(statement.getSql()).isEqualTo("SELECT person.THE_NAME FROM person WHERE person.THE_NAME = $1");
}
@Test // gh-220
public void shouldSelectFromTable() {
MockRowMetadata metadata = MockRowMetadata.builder().columnMetadata(MockColumnMetadata.builder().name("id").build())
.build();
MockResult result = MockResult.builder().rowMetadata(metadata)
.row(MockRow.builder().identified("id", Object.class, "Walter").build()).build();
recorder.addStubbing(s -> s.startsWith("SELECT"), result);
entityTemplate.select(Person.class) //
.from("the_table") //
.matching(query(where("name").is("Walter"))) //
.all() //
.as(StepVerifier::create) //
.expectNextCount(1) //
.verifyComplete();
StatementRecorder.RecordedStatement statement = recorder.getCreatedStatement(s -> s.startsWith("SELECT"));
assertThat(statement.getSql()).isEqualTo("SELECT the_table.* FROM the_table WHERE the_table.THE_NAME = $1");
}
@Test // gh-220
public void shouldSelectFirst() {
MockRowMetadata metadata = MockRowMetadata.builder().columnMetadata(MockColumnMetadata.builder().name("id").build())
.build();
MockResult result = MockResult.builder().rowMetadata(metadata)
.row(MockRow.builder().identified("id", Object.class, "Walter").build()).build();
recorder.addStubbing(s -> s.startsWith("SELECT"), result);
entityTemplate.select(Person.class) //
.matching(query(where("name").is("Walter"))) //
.first() //
.as(StepVerifier::create) //
.expectNextCount(1) //
.verifyComplete();
StatementRecorder.RecordedStatement statement = recorder.getCreatedStatement(s -> s.startsWith("SELECT"));
assertThat(statement.getSql()).isEqualTo("SELECT person.* FROM person WHERE person.THE_NAME = $1 LIMIT 1");
}
@Test // gh-220
public void shouldSelectOne() {
MockRowMetadata metadata = MockRowMetadata.builder().columnMetadata(MockColumnMetadata.builder().name("id").build())
.build();
MockResult result = MockResult.builder().rowMetadata(metadata)
.row(MockRow.builder().identified("id", Object.class, "Walter").build()).build();
recorder.addStubbing(s -> s.startsWith("SELECT"), result);
entityTemplate.select(Person.class) //
.matching(query(where("name").is("Walter"))) //
.one() //
.as(StepVerifier::create) //
.expectNextCount(1) //
.verifyComplete();
StatementRecorder.RecordedStatement statement = recorder.getCreatedStatement(s -> s.startsWith("SELECT"));
assertThat(statement.getSql()).isEqualTo("SELECT person.* FROM person WHERE person.THE_NAME = $1 LIMIT 2");
}
@Test // gh-220
public void shouldSelectExists() {
MockRowMetadata metadata = MockRowMetadata.builder().columnMetadata(MockColumnMetadata.builder().name("id").build())
.build();
MockResult result = MockResult.builder().rowMetadata(metadata)
.row(MockRow.builder().identified("id", Object.class, "Walter").build()).build();
recorder.addStubbing(s -> s.startsWith("SELECT"), result);
entityTemplate.select(Person.class) //
.matching(query(where("name").is("Walter"))) //
.exists() //
.as(StepVerifier::create) //
.expectNext(true) //
.verifyComplete();
StatementRecorder.RecordedStatement statement = recorder.getCreatedStatement(s -> s.startsWith("SELECT"));
assertThat(statement.getSql()).isEqualTo("SELECT person.id FROM person WHERE person.THE_NAME = $1");
}
@Test // gh-220
public void shouldSelectCount() {
MockRowMetadata metadata = MockRowMetadata.builder().columnMetadata(MockColumnMetadata.builder().name("id").build())
.build();
MockResult result = MockResult.builder().rowMetadata(metadata)
.row(MockRow.builder().identified(0, Long.class, 1L).build()).build();
recorder.addStubbing(s -> s.startsWith("SELECT"), result);
entityTemplate.select(Person.class) //
.matching(query(where("name").is("Walter"))) //
.count() //
.as(StepVerifier::create) //
.expectNext(1L) //
.verifyComplete();
StatementRecorder.RecordedStatement statement = recorder.getCreatedStatement(s -> s.startsWith("SELECT"));
assertThat(statement.getSql()).isEqualTo("SELECT COUNT(person.id) FROM person WHERE person.THE_NAME = $1");
}
static class Person {
@Id String id;
@Column("THE_NAME") String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
interface PersonProjection {
String getName();
}
}

111
src/test/java/org/springframework/data/r2dbc/core/ReactiveUpdateOperationUnitTests.java Normal file
View File

@@ -0,0 +1,111 @@
/*
* Copyright 2020 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.data.r2dbc.core;
import static org.assertj.core.api.Assertions.*;
import static org.springframework.data.r2dbc.query.Criteria.*;
import static org.springframework.data.r2dbc.query.Query.*;
import io.r2dbc.spi.test.MockResult;
import reactor.test.StepVerifier;
import org.junit.Before;
import org.junit.Test;
import org.springframework.data.annotation.Id;
import org.springframework.data.r2dbc.dialect.PostgresDialect;
import org.springframework.data.r2dbc.mapping.SettableValue;
import org.springframework.data.r2dbc.query.Update;
import org.springframework.data.r2dbc.testing.StatementRecorder;
import org.springframework.data.relational.core.mapping.Column;
/**
* Unit test for {@link ReactiveUpdateOperation}.
*
* @author Mark Paluch
*/
public class ReactiveUpdateOperationUnitTests {
DatabaseClient client;
R2dbcEntityTemplate entityTemplate;
StatementRecorder recorder;
@Before
public void before() {
recorder = StatementRecorder.newInstance();
client = DatabaseClient.builder().connectionFactory(recorder)
.dataAccessStrategy(new DefaultReactiveDataAccessStrategy(PostgresDialect.INSTANCE)).build();
entityTemplate = new R2dbcEntityTemplate(client);
}
@Test // gh-220
public void shouldUpdate() {
MockResult result = MockResult.builder().rowsUpdated(1).build();
recorder.addStubbing(s -> s.startsWith("UPDATE"), result);
entityTemplate.update(Person.class) //
.matching(query(where("name").is("Walter"))) //
.apply(Update.update("name", "Heisenberg")) //
.as(StepVerifier::create) //
.expectNext(1) //
.verifyComplete();
StatementRecorder.RecordedStatement statement = recorder.getCreatedStatement(s -> s.startsWith("UPDATE"));
assertThat(statement.getSql()).isEqualTo("UPDATE person SET THE_NAME = $1 WHERE person.THE_NAME = $2");
assertThat(statement.getBindings()).hasSize(2).containsEntry(0, SettableValue.from("Heisenberg")).containsEntry(1,
SettableValue.from("Walter"));
}
@Test // gh-220
public void shouldUpdateInTable() {
MockResult result = MockResult.builder().rowsUpdated(1).build();
recorder.addStubbing(s -> s.startsWith("UPDATE"), result);
entityTemplate.update(Person.class) //
.inTable("the_table") //
.matching(query(where("name").is("Walter"))) //
.apply(Update.update("name", "Heisenberg")) //
.as(StepVerifier::create) //
.expectNext(1) //
.verifyComplete();
StatementRecorder.RecordedStatement statement = recorder.getCreatedStatement(s -> s.startsWith("UPDATE"));
assertThat(statement.getSql()).isEqualTo("UPDATE the_table SET THE_NAME = $1 WHERE the_table.THE_NAME = $2");
}
static class Person {
@Id String id;
@Column("THE_NAME") String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
}