feat: udpate human sample code

Signed-off-by: Otavio Santana <[email protected]>

Author: otaviojava

jnosql-dynamodb/src/test/java/org/eclipse/jnosql/databases/dynamodb/integration/DynamoDBTemplateIntegrationTest.java

@@ -42,7 +42,7 @@
 
 @EnableAutoWeld
 @AddPackages(value = {Converters.class, EntityConverter.class})
-@AddPackages(Book.class)
+@AddPackages(Magazine.class)
 @AddPackages(DynamoDBTemplate.class)
 @AddExtensions({EntityMetadataExtension.class, DocumentExtension.class, DynamoDBExtension.class})
 @AddPackages(Reflections.class)
@@ -60,78 +60,78 @@ class DynamoDBTemplateIntegrationTest {
 
     @Test
     void shouldInsert() {
-        Book book = new Book(randomUUID().toString(), "Effective Java", 1);
-        template.insert(book);
-        Optional<Book> optional = template.find(Book.class, book.id());
+        Magazine magazine = new Magazine(randomUUID().toString(), "Effective Java", 1);
+        template.insert(magazine);
+        Optional<Magazine> optional = template.find(Magazine.class, magazine.id());
         assertThat(optional).isNotNull().isNotEmpty()
-                .get().isEqualTo(book);
+                .get().isEqualTo(magazine);
     }
 
     @Test
     void shouldUpdate() {
-        Book book = new Book(randomUUID().toString(), "Effective Java", 1);
-        assertThat(template.insert(book))
+        Magazine magazine = new Magazine(randomUUID().toString(), "Effective Java", 1);
+        assertThat(template.insert(magazine))
                 .isNotNull()
-                .isEqualTo(book);
+                .isEqualTo(magazine);
 
-        Book updated = new Book(book.id(), book.title() + " updated", 2);
+        Magazine updated = new Magazine(magazine.id(), magazine.title() + " updated", 2);
 
         assertThat(template.update(updated))
                 .isNotNull()
-                .isNotEqualTo(book);
+                .isNotEqualTo(magazine);
 
-        assertThat(template.find(Book.class, book.id()))
+        assertThat(template.find(Magazine.class, magazine.id()))
                 .isNotNull().get().isEqualTo(updated);
 
     }
 
     @Test
     void shouldFindById() {
-        Book book = new Book(randomUUID().toString(), "Effective Java", 1);
-        assertThat(template.insert(book))
+        Magazine magazine = new Magazine(randomUUID().toString(), "Effective Java", 1);
+        assertThat(template.insert(magazine))
                 .isNotNull()
-                .isEqualTo(book);
+                .isEqualTo(magazine);
 
-        assertThat(template.find(Book.class, book.id()))
-                .isNotNull().get().isEqualTo(book);
+        assertThat(template.find(Magazine.class, magazine.id()))
+                .isNotNull().get().isEqualTo(magazine);
     }
 
     @Test
     void shouldDelete() {
-        Book book = new Book(randomUUID().toString(), "Effective Java", 1);
-        assertThat(template.insert(book))
+        Magazine magazine = new Magazine(randomUUID().toString(), "Effective Java", 1);
+        assertThat(template.insert(magazine))
                 .isNotNull()
-                .isEqualTo(book);
+                .isEqualTo(magazine);
 
-        template.delete(Book.class, book.id());
-        assertThat(template.find(Book.class, book.id()))
+        template.delete(Magazine.class, magazine.id());
+        assertThat(template.find(Magazine.class, magazine.id()))
                 .isNotNull().isEmpty();
     }
 
     @Test
     void shouldDeleteAll() {
         for (int index = 0; index < 20; index++) {
-            Book book = new Book(randomUUID().toString(), "Effective Java", 1);
-            assertThat(template.insert(book))
+            Magazine magazine = new Magazine(randomUUID().toString(), "Effective Java", 1);
+            assertThat(template.insert(magazine))
                     .isNotNull()
-                    .isEqualTo(book);
+                    .isEqualTo(magazine);
         }
 
-        template.delete(Book.class).execute();
-        assertThat(template.select(Book.class).result()).isEmpty();
+        template.delete(Magazine.class).execute();
+        assertThat(template.select(Magazine.class).result()).isEmpty();
     }
 
     @Test
     void shouldUpdateNullValues() {
-        var book = new Book(randomUUID().toString(), "Effective Java", 1);
+        var book = new Magazine(randomUUID().toString(), "Effective Java", 1);
         template.insert(book);
-        template.update(new Book(book.id(), null, 2));
-        Optional<Book> optional = template.select(Book.class).where("id")
+        template.update(new Magazine(book.id(), null, 2));
+        Optional<Magazine> optional = template.select(Magazine.class).where("id")
                 .eq(book.id()).singleResult();
         assertSoftly(softly -> {
             softly.assertThat(optional).isPresent();
-            softly.assertThat(optional).get().extracting(Book::title).isNull();
-            softly.assertThat(optional).get().extracting(Book::edition).isEqualTo(2);
+            softly.assertThat(optional).get().extracting(Magazine::title).isNull();
+            softly.assertThat(optional).get().extracting(Magazine::edition).isEqualTo(2);
         });
     }
 

jnosql-dynamodb/src/test/java/org/eclipse/jnosql/databases/dynamodb/integration/Book.java renamed to jnosql-dynamodb/src/test/java/org/eclipse/jnosql/databases/dynamodb/integration/Magazine.java

@@ -22,7 +22,7 @@
 import java.util.Objects;
 
 @Entity
-public class Book {
+public class Magazine {
 
     @Id("id")
     private String id;
@@ -33,13 +33,13 @@ public class Book {
     @Column("edition")
     private int edition;
 
-    public Book(String id, String title, int edition) {
+    public Magazine(String id, String title, int edition) {
         this.id = id;
         this.title = title;
         this.edition = edition;
     }
 
-    Book() {
+    Magazine() {
     }
 
     public String id() {
@@ -58,10 +58,10 @@ public int edition() {
     public boolean equals(Object o) {
         if (this == o) return true;
         if (o == null || getClass() != o.getClass()) return false;
-        Book book = (Book) o;
-        return edition == book.edition
-                && Objects.equals(id, book.id)
-                && Objects.equals(title, book.title);
+        Magazine magazine = (Magazine) o;
+        return edition == magazine.edition
+                && Objects.equals(id, magazine.id)
+                && Objects.equals(title, magazine.title);
     }
 
     @Override

jnosql-dynamodb/src/test/java/org/eclipse/jnosql/databases/dynamodb/mapping/DefaultDynamoDBTemplateTest.java

@@ -88,7 +88,7 @@ void shouldFindSQLWithTypeAndParameters() {
     @Test
     void shouldDeleteAll(){
         ArgumentCaptor<DeleteQuery> argumentCaptor = ArgumentCaptor.forClass(DeleteQuery.class);
-        template.deleteAll(Person.class);
+        template.deleteAll(Human.class);
         Mockito.verify(manager).delete(argumentCaptor.capture());
         var query = argumentCaptor.getValue();
         SoftAssertions.assertSoftly(soft -> {

jnosql-dynamodb/src/test/java/org/eclipse/jnosql/databases/dynamodb/mapping/DynamoDBExtensionTest.java

@@ -38,7 +38,7 @@
 public class DynamoDBExtensionTest {
 
     @Inject
-    private PersonNoSQLRepository repository;
+    private HumanNoSQLRepository repository;
 
     @Test
     public void shouldSave() {

jnosql-dynamodb/src/test/java/org/eclipse/jnosql/databases/dynamodb/mapping/DynamoDBRepositoryProxyTest.java

@@ -67,9 +67,9 @@ void setUp() {
         DynamoDBRepositoryProxy handler = new DynamoDBRepositoryProxy<>(template,
                 PersonNoSQLRepository.class, converters, entitiesMetadata);
 
-        when(template.insert(any(Person.class))).thenReturn(new Person());
-        when(template.insert(any(Person.class), any(Duration.class))).thenReturn(new Person());
-        when(template.update(any(Person.class))).thenReturn(new Person());
+        when(template.insert(any(Human.class))).thenReturn(new Human());
+        when(template.insert(any(Human.class), any(Duration.class))).thenReturn(new Human());
+        when(template.update(any(Human.class))).thenReturn(new Human());
 
         this.personRepository = (PersonNoSQLRepository) Proxy.newProxyInstance(PersonNoSQLRepository.class.getClassLoader(),
                 new Class[]{PersonNoSQLRepository.class},
@@ -94,32 +94,32 @@ public void shouldFindByNameSQL() {
 
     @Test
     public void shouldSaveUsingInsert() {
-        Person person = Person.of("Ada", 10);
-        personRepository.save(person);
-        verify(template).insert(eq(person));
+        Human human = Human.of("Ada", 10);
+        personRepository.save(human);
+        verify(template).insert(eq(human));
     }
 
 
     @Test
     public void shouldSaveUsingUpdate() {
-        Person person = Person.of("Ada-2", 10);
-        when(template.find(Person.class, "Ada-2")).thenReturn(Optional.of(person));
-        personRepository.save(person);
-        verify(template).update(eq(person));
+        Human human = Human.of("Ada-2", 10);
+        when(template.find(Human.class, "Ada-2")).thenReturn(Optional.of(human));
+        personRepository.save(human);
+        verify(template).update(eq(human));
     }
 
     @Test
     public void shouldDelete(){
         personRepository.deleteById("id");
-        verify(template).delete(Person.class, "id");
+        verify(template).delete(Human.class, "id");
     }
 
 
     @Test
     public void shouldDeleteEntity(){
-        Person person = Person.of("Ada", 10);
-        personRepository.delete(person);
-        verify(template).delete(Person.class, person.getName());
+        Human human = Human.of("Ada", 10);
+        personRepository.delete(human);
+        verify(template).delete(Human.class, human.getName());
     }
 
     @Test
@@ -130,16 +130,16 @@ public void shouldDeleteAll() {
         verify(template).deleteAll(queryCaptor.capture());
 
         Class<?> query = queryCaptor.getValue();
-        Assertions.assertThat(query).isEqualTo(Person.class);
+        Assertions.assertThat(query).isEqualTo(Human.class);
     }
 
-    interface PersonNoSQLRepository extends DynamoDBRepository<Person, String> {
+    interface PersonNoSQLRepository extends DynamoDBRepository<Human, String> {
 
         @PartiQL("select * from Person")
-        List<Person> findAllQuery();
+        List<Human> findAllQuery();
 
         @PartiQL("select * from Person where name= ?")
-        List<Person> findByName(@Param("") String name);
+        List<Human> findByName(@Param("") String name);
     }
 
 }

jnosql-dynamodb/src/test/java/org/eclipse/jnosql/databases/dynamodb/mapping/Person.java renamed to jnosql-dynamodb/src/test/java/org/eclipse/jnosql/databases/dynamodb/mapping/Human.java

@@ -22,7 +22,7 @@
 import java.util.Objects;
 
 @Entity
-public class Person {
+public class Human {
 
     @Id
     private String name;
@@ -46,21 +46,21 @@ public void setAge(Integer age) {
         this.age = age;
     }
 
-    public Person(String name, Integer age) {
+    public Human(String name, Integer age) {
         this.name = name;
         this.age = age;
     }
 
-    public Person() {
+    public Human() {
     }
 
     @Override
     public boolean equals(Object o) {
         if (this == o) return true;
         if (o == null || getClass() != o.getClass()) return false;
-        Person person = (Person) o;
-        return Objects.equals(name, person.name) &&
-                Objects.equals(age, person.age);
+        Human human = (Human) o;
+        return Objects.equals(name, human.name) &&
+                Objects.equals(age, human.age);
     }
 
     @Override
@@ -76,7 +76,7 @@ public String toString() {
                 '}';
     }
 
-    public static Person of(String name, Integer age) {
-        return new Person(name, age);
+    public static Human of(String name, Integer age) {
+        return new Human(name, age);
     }
 }

jnosql-dynamodb/src/test/java/org/eclipse/jnosql/databases/dynamodb/mapping/PersonNoSQLRepository.java renamed to jnosql-dynamodb/src/test/java/org/eclipse/jnosql/databases/dynamodb/mapping/HumanNoSQLRepository.java

@@ -18,5 +18,5 @@
 import jakarta.data.repository.Repository;
 
 @Repository
-public interface PersonNoSQLRepository extends DynamoDBRepository<Person, String> {
+public interface HumanNoSQLRepository extends DynamoDBRepository<Human, String> {
 }