My solution

pom.xml

@@ -13,9 +13,16 @@
         <maven.compiler.source>17</maven.compiler.source>
         <maven.compiler.target>17</maven.compiler.target>
         <lombok.version>1.18.22</lombok.version>
+        <junit5.version>5.10.1</junit5.version>
     </properties>
 
     <dependencies>
+        <dependency>
+            <groupId>org.apache.commons</groupId>
+            <artifactId>commons-lang3</artifactId>
+            <version>3.12.0</version>
+        </dependency>
+
         <dependency>
             <groupId>org.postgresql</groupId>
             <artifactId>postgresql</artifactId>
@@ -33,7 +40,20 @@
         <dependency>
             <groupId>org.junit.jupiter</groupId>
             <artifactId>junit-jupiter-engine</artifactId>
-            <version>5.8.2</version>
+            <version>${junit5.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <!-- https://mvnrepository.com/artifact/org.assertj/assertj-core -->
+        <dependency>
+            <groupId>org.assertj</groupId>
+            <artifactId>assertj-core</artifactId>
+            <version>3.25.2</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter-params</artifactId>
+            <version>${junit5.version}</version>
             <scope>test</scope>
         </dependency>
         <dependency>

src/main/java/com/dmdev/dao/Dao.java

@@ -1,17 +1,25 @@
 package com.dmdev.dao;
 
+import com.dmdev.entity.BaseEntity;
+
 import java.util.List;
 import java.util.Optional;
 
-public interface Dao<K, T> {
+public interface Dao<K, T extends BaseEntity<K>> {
+
+    default T upsert(T entity) {
+        return entity.getId() != null
+                ? update(entity)
+                : insert(entity);
+    }
 
     List<T> findAll();
 
     Optional<T> findById(K id);
 
     boolean delete(K id);
 
-    void update(T entity);
+    T update(T entity);
 
-    T save(T entity);
+    T insert(T entity);
 }

src/main/java/com/dmdev/dao/UserDao.java → src/main/java/com/dmdev/dao/SubscriptionDao.java

@@ -1,77 +1,72 @@
 package com.dmdev.dao;
 
-import com.dmdev.entity.Gender;
-import com.dmdev.entity.Role;
-import com.dmdev.entity.User;
+import com.dmdev.entity.Provider;
+import com.dmdev.entity.Status;
+import com.dmdev.entity.Subscription;
 import com.dmdev.util.ConnectionManager;
-import lombok.NoArgsConstructor;
 import lombok.SneakyThrows;
 
-import java.sql.Date;
 import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
+import java.sql.Timestamp;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Optional;
 
 import static java.sql.Statement.RETURN_GENERATED_KEYS;
-import static lombok.AccessLevel.PRIVATE;
 
-@NoArgsConstructor(access = PRIVATE)
-public class UserDao implements Dao<Integer, User> {
+public class SubscriptionDao implements Dao<Integer, Subscription> {
 
-    private static final UserDao INSTANCE = new UserDao();
+    private static final SubscriptionDao INSTANCE = new SubscriptionDao();
 
     private static final String GET_ALL_SQL = """
             SELECT
                 id,
+                user_id,
                 name,
-                birthday,
-                email,
-                password,
-                role,
-                gender
-            FROM users
+                provider,
+                expiration_date,
+                status
+            FROM subscription
             """;
     private static final String GET_BY_ID_SQL = GET_ALL_SQL + " WHERE id = ?";
-    private static final String GET_BY_EMAIL_AND_PASSWORD_SQL = GET_ALL_SQL + " WHERE email = ? AND password = ?";
+    private static final String GET_BY_USER_ID_SQL = GET_ALL_SQL + " WHERE user_id = ?";
+    private static final String DELETE_BY_ID_SQL = "DELETE FROM subscription WHERE id = ?";
     private static final String SAVE_SQL =
-            "INSERT INTO users (name, birthday, email, password, role, gender) VALUES (?, ?, ?, ?, ?, ?)";
-    private static final String DELETE_BY_ID_SQL = "DELETE FROM users WHERE id = ?";
+            "INSERT INTO subscription (user_id, name, provider, expiration_date, status) VALUES (?, ?, ?, ?, ?)";
     private static final String UPDATE_BY_ID_SQL = """
-            UPDATE users
-            SET name = ?,
-                birthday = ?,
-                email = ?,
-                password = ?,
-                role = ?,
-                gender = ?
+            UPDATE subscription
+            SET user_id = ?,
+                name = ?,
+                provider = ?,
+                expiration_date = ?,
+                status = ?
             WHERE id = ?
             """;
 
-    public static UserDao getInstance() {
+    public static SubscriptionDao getInstance() {
         return INSTANCE;
     }
 
     @Override
     @SneakyThrows
-    public List<User> findAll() {
+    public List<Subscription> findAll() {
         try (var connection = ConnectionManager.get();
              var preparedStatement = connection.prepareStatement(GET_ALL_SQL)) {
             var resultSet = preparedStatement.executeQuery();
-            List<User> users = new ArrayList<>();
+            List<Subscription> subscriptions = new ArrayList<>();
             while (resultSet.next()) {
-                users.add(buildEntity(resultSet));
+                subscriptions.add(buildEntity(resultSet));
             }
 
-            return users;
+            return subscriptions;
         }
     }
 
     @Override
     @SneakyThrows
-    public Optional<User> findById(Integer id) {
+    public Optional<Subscription> findById(Integer id) {
         try (var connection = ConnectionManager.get();
              var preparedStatement = connection.prepareStatement(GET_BY_ID_SQL)) {
             preparedStatement.setObject(1, id);
@@ -85,76 +80,77 @@ public Optional<User> findById(Integer id) {
 
     @Override
     @SneakyThrows
-    public User save(User entity) {
+    public boolean delete(Integer id) {
         try (var connection = ConnectionManager.get();
-             var preparedStatement = connection.prepareStatement(SAVE_SQL, RETURN_GENERATED_KEYS)) {
-            prepareStatementToUpsert(preparedStatement, entity);
-
-            preparedStatement.executeUpdate();
-
-            var generatedKeys = preparedStatement.getGeneratedKeys();
-            generatedKeys.next();
-            entity.setId(generatedKeys.getObject("id", Integer.class));
+             var preparedStatement = connection.prepareStatement(DELETE_BY_ID_SQL)) {
+            preparedStatement.setObject(1, id);
 
-            return entity;
+            return preparedStatement.executeUpdate() > 0;
         }
     }
 
+    @Override
     @SneakyThrows
-    public Optional<User> findByEmailAndPassword(String email, String password) {
+    public Subscription update(Subscription entity) {
         try (var connection = ConnectionManager.get();
-             var preparedStatement = connection.prepareStatement(GET_BY_EMAIL_AND_PASSWORD_SQL)) {
-            preparedStatement.setString(1, email);
-            preparedStatement.setString(2, password);
+             var preparedStatement = connection.prepareStatement(UPDATE_BY_ID_SQL)) {
+            prepareStatementToUpsert(preparedStatement, entity);
+            preparedStatement.setObject(6, entity.getId());
 
-            var resultSet = preparedStatement.executeQuery();
-            return resultSet.next()
-                    ? Optional.of(buildEntity(resultSet))
-                    : Optional.empty();
+            preparedStatement.executeUpdate();
+            return entity;
         }
     }
 
     @Override
     @SneakyThrows
-    public boolean delete(Integer id) {
+    public Subscription insert(Subscription entity) {
         try (var connection = ConnectionManager.get();
-             var preparedStatement = connection.prepareStatement(DELETE_BY_ID_SQL)) {
-            preparedStatement.setObject(1, id);
+             var preparedStatement = connection.prepareStatement(SAVE_SQL, RETURN_GENERATED_KEYS)) {
+            prepareStatementToUpsert(preparedStatement, entity);
 
-            return preparedStatement.executeUpdate() > 0;
+            preparedStatement.executeUpdate();
+
+            var generatedKeys = preparedStatement.getGeneratedKeys();
+            generatedKeys.next();
+            entity.setId(generatedKeys.getObject("id", Integer.class));
+
+            return entity;
         }
     }
 
-    @Override
     @SneakyThrows
-    public void update(User entity) {
+    public List<Subscription> findByUserId(Integer userId) {
         try (var connection = ConnectionManager.get();
-             var preparedStatement = connection.prepareStatement(UPDATE_BY_ID_SQL)) {
-            prepareStatementToUpsert(preparedStatement, entity);
-            preparedStatement.setObject(7, entity.getId());
+             var preparedStatement = connection.prepareStatement(GET_BY_USER_ID_SQL)) {
+            preparedStatement.setObject(1, userId);
 
-            preparedStatement.executeUpdate();
+            var resultSet = preparedStatement.executeQuery();
+            List<Subscription> subscriptions = new ArrayList<>();
+            while (resultSet.next()) {
+                subscriptions.add(buildEntity(resultSet));
+            }
+
+            return subscriptions;
         }
     }
 
-    private User buildEntity(ResultSet resultSet) throws SQLException {
-        return User.builder()
+    private Subscription buildEntity(ResultSet resultSet) throws SQLException {
+        return Subscription.builder()
                 .id(resultSet.getObject("id", Integer.class))
+                .userId(resultSet.getObject("user_id", Integer.class))
                 .name(resultSet.getObject("name", String.class))
-                .birthday(resultSet.getObject("birthday", Date.class).toLocalDate())
-                .email(resultSet.getObject("email", String.class))
-                .password(resultSet.getObject("password", String.class))
-                .role(Role.find(resultSet.getObject("role", String.class)).orElse(null))
-                .gender(Gender.find(resultSet.getObject("gender", String.class)).orElse(null))
+                .provider(Provider.valueOf(resultSet.getObject("provider", String.class)))
+                .expirationDate(resultSet.getObject("expiration_date", Timestamp.class).toInstant())
+                .status(Status.valueOf(resultSet.getObject("status", String.class)))
                 .build();
     }
 
-    private void prepareStatementToUpsert(PreparedStatement preparedStatement, User entity) throws SQLException {
-        preparedStatement.setObject(1, entity.getName());
-        preparedStatement.setObject(2, entity.getBirthday());
-        preparedStatement.setObject(3, entity.getEmail());
-        preparedStatement.setObject(4, entity.getPassword());
-        preparedStatement.setObject(5, entity.getRole() != null ? entity.getRole().name() : null);
-        preparedStatement.setObject(6, entity.getGender() != null ? entity.getGender().name() : null);
+    private void prepareStatementToUpsert(PreparedStatement preparedStatement, Subscription entity) throws SQLException {
+        preparedStatement.setObject(1, entity.getUserId());
+        preparedStatement.setObject(2, entity.getName());
+        preparedStatement.setObject(3, entity.getProvider().name());
+        preparedStatement.setObject(4, Timestamp.from(entity.getExpirationDate()));
+        preparedStatement.setObject(5, entity.getStatus().name());
     }
 }

src/main/java/com/dmdev/dto/CreateSubscriptionDto.java

@@ -0,0 +1,15 @@
+package com.dmdev.dto;
+
+import lombok.Builder;
+import lombok.Value;
+
+import java.time.Instant;
+
+@Value
+@Builder
+public class CreateSubscriptionDto {
+    Integer userId;
+    String name;
+    String provider;
+    Instant expirationDate;
+}

src/main/java/com/dmdev/dto/CreateUserDto.java

@@ -12,4 +12,4 @@ public class CreateUserDto {
     String password;
     String role;
     String gender;
-}
+}

src/main/java/com/dmdev/entity/BaseEntity.java

@@ -0,0 +1,6 @@
+package com.dmdev.entity;
+
+public interface BaseEntity<K> {
+
+    K getId();
+}

src/main/java/com/dmdev/entity/Gender.java

@@ -12,4 +12,4 @@ public static Optional<Gender> find(String gender) {
                 .filter(it -> it.name().equals(gender))
                 .findFirst();
     }
-}
+}

src/main/java/com/dmdev/entity/Provider.java

@@ -0,0 +1,18 @@
+package com.dmdev.entity;
+
+import java.util.Arrays;
+import java.util.Optional;
+
+public enum Provider {
+    GOOGLE, APPLE;
+
+    public static Provider findByName(String name) {
+        return findByNameOpt(name).orElseThrow();
+    }
+
+    public static Optional<Provider> findByNameOpt(String name) {
+        return Arrays.stream(values())
+                .filter(provider -> provider.name().equalsIgnoreCase(name))
+                .findFirst();
+    }
+}

src/main/java/com/dmdev/entity/Role.java

@@ -12,4 +12,4 @@ public static Optional<Role> find(String role) {
                 .filter(it -> it.name().equals(role))
                 .findFirst();
     }
-}
+}

src/main/java/com/dmdev/entity/Status.java

@@ -0,0 +1,5 @@
+package com.dmdev.entity;
+
+public enum Status {
+    ACTIVE, CANCELED, EXPIRED
+}