diff --git a/src/main/java/data_access/UserDatabase.java b/src/main/java/data_access/UserDatabase.java index a88e97df..59c6bd10 100644 --- a/src/main/java/data_access/UserDatabase.java +++ b/src/main/java/data_access/UserDatabase.java @@ -48,6 +48,7 @@ public boolean UserExists(String username, String email) { /** * Checks if a user with given Username exists. */ + //TODO: this method can be be simplified to "return UserExists(username, "");" @Override public boolean UserExists(String username) { for(User user: this.accountList){ @@ -83,6 +84,7 @@ public void createUser(String username, String password, String email, String ty */ @Override // To be edited to get user from the array format rather than the serialized format. + //TODO: for loop can be replaced with enhanced for loop public User getUser(String username) { User ans = null; for (int i = 0; i < (this.accountList.size()); i++) { @@ -101,15 +103,8 @@ public List getList() { ObjectInputStream in = new ObjectInputStream(fileIn)) { users = (ArrayList) in.readObject(); - /* - while(true){ - try{ - Entities.User_Entities.User user = (Entities.User_Entities.User) in.readObject(); - users.add(user);} - catch(EOFException e){ - break; - }*/ return users; + //TODO: this is not a good use of exceptions, but I could not find any other way to do it. }catch(EOFException e){ return users; } catch (IOException | ClassNotFoundException ex) { diff --git a/src/main/java/emoji_manager/msg/Sender.java b/src/main/java/emoji_manager/msg/Sender.java index 2e63867c..53e93058 100644 --- a/src/main/java/emoji_manager/msg/Sender.java +++ b/src/main/java/emoji_manager/msg/Sender.java @@ -1,4 +1,4 @@ -package main.java.emoji_manager.msg; +package emoji_manager.msg; import java.net.DatagramPacket; import java.net.DatagramSocket; diff --git a/src/main/java/entities/user_entities/User.java b/src/main/java/entities/user_entities/User.java index 4817552d..46fbfd36 100644 --- a/src/main/java/entities/user_entities/User.java +++ b/src/main/java/entities/user_entities/User.java @@ -16,8 +16,6 @@ public abstract class User implements Serializable, Changeable, Loginable, UserA protected String email; protected ArrayList userChats; - boolean verified = false; - boolean online = false; public User(String username, String password, String email, ArrayList userChats){ this.username = username; this.password = password; diff --git a/src/main/java/entities/user_entities/UserFactory.java b/src/main/java/entities/user_entities/UserFactory.java index f013ed39..b299fdb3 100644 --- a/src/main/java/entities/user_entities/UserFactory.java +++ b/src/main/java/entities/user_entities/UserFactory.java @@ -1,10 +1,11 @@ package entities.user_entities; -import entities.chat.Chat; -import entities.user_entities.*; import java.util.ArrayList; public class UserFactory { - //Following the factory design pattern, just in case in the future we decide to add various different types of Users + /* + Following the factory design pattern, just in case in the future we decide to add various different types of Users, + with different privileges + */ public static User BirthUser(String Username, String Password, String Email, String type){ return new BasicUser(Username, Password, Email, new ArrayList<>()); } diff --git a/src/main/java/interface_adapters/login_interface_adapters/UserChatsPresenter.java b/src/main/java/interface_adapters/login_interface_adapters/UserChatsPresenter.java new file mode 100644 index 00000000..7c1a18fc --- /dev/null +++ b/src/main/java/interface_adapters/login_interface_adapters/UserChatsPresenter.java @@ -0,0 +1,55 @@ +package interface_adapters.login_interface_adapters; + +import use_cases.user_login_use_cases.UserLoginOutputBoundary; + +import java.util.ArrayList; +import java.util.List; +/** + * Just a bunch of getters and setters + * **/ +public class UserChatsPresenter implements UserLoginOutputBoundary { + private List chats; + private boolean notExists; + private boolean notMatched; + private String username; + + public UserChatsPresenter(){ + this.chats = new ArrayList<>(); + } + + @Override + public void setUsername(String username) { + this.username = username; + } + + @Override + public void setChats(List chats) { + this.chats = chats; + } + public List getChats(){ + return this.chats; + } + + @Override + public void setUserNotExists(boolean notExists) { + this.notExists = notExists; + } + + public boolean isNotExists() { + return notExists; + } + + @Override + public void setPasswordNotMatched(boolean notMatched) { + this.notMatched = notMatched; + } + + @Override + public String getUsername() { + return this.username; + } + + public boolean isNotMatched() { + return notMatched; + } +} diff --git a/src/main/java/interface_adapters/login_interface_adapters/UserLoginGateway.java b/src/main/java/interface_adapters/login_interface_adapters/UserLoginGateway.java deleted file mode 100644 index 9fff9cd8..00000000 --- a/src/main/java/interface_adapters/login_interface_adapters/UserLoginGateway.java +++ /dev/null @@ -1,24 +0,0 @@ -package interface_adapters.login_interface_adapters; -import interface_adapters.user_search_IA.UserRetriever; -public class UserLoginGateway { - public UserRetriever database; - - String credential; - String password; - public UserLoginGateway(String credential, String password, UserRetriever database){ - this.database = database; - this.credential = credential; - this.password = password; - } - - public String getPassword(){ - return this.password; - } - public String getCredential(){ - return this.credential; - } - public UserRetriever getDatabase(){ - return this.database; - } - -} diff --git a/src/main/java/interface_adapters/login_interface_adapters/UserLoginPresenter.java b/src/main/java/interface_adapters/login_interface_adapters/UserLoginPresenter.java new file mode 100644 index 00000000..ee42323c --- /dev/null +++ b/src/main/java/interface_adapters/login_interface_adapters/UserLoginPresenter.java @@ -0,0 +1,42 @@ +package interface_adapters.login_interface_adapters; + +import data_access.Database; +import use_cases.user_login_use_cases.UserLoginInputBoundary; +/** + * Presenter object that gets info from the view, and passes it to the login use case objects in order + * to implement login + * **/ +public class UserLoginPresenter { + private final UserLoginInputBoundary loginGuard; + private String username; + private String password; + Database database; + private UserLoginViewI loginView; + + public UserLoginPresenter(Database database, UserLoginInputBoundary loginGuard){ + this.database = database; + this.loginGuard = loginGuard; + } + /** + * Passes info from the view into loginInteractor(use case interactor object) + **/ + public void tryLogin() { + loginGuard.login(this.username, this.password); + loginView.setChatsPresenter(loginGuard.getChatsPresenter()); + loginView.display(); + } + /** + * Gets the info from the view + * **/ + public void setLoginCredentials(String username, String password) { + this.username = username; + this.password = password; + } + /** + * Sets the screen that will update the view after login + **/ + public void setLoginView(UserLoginViewI loginView){ + this.loginView = loginView; + } + +} diff --git a/src/main/java/interface_adapters/login_interface_adapters/UserLoginViewI.java b/src/main/java/interface_adapters/login_interface_adapters/UserLoginViewI.java new file mode 100644 index 00000000..cbac29d0 --- /dev/null +++ b/src/main/java/interface_adapters/login_interface_adapters/UserLoginViewI.java @@ -0,0 +1,10 @@ +package interface_adapters.login_interface_adapters; + +import use_cases.user_login_use_cases.UserLoginOutputBoundary; +/** + * ViewInterface that will update the view after login + * **/ +public interface UserLoginViewI { + void display(); + void setChatsPresenter(UserLoginOutputBoundary outputBoundary); +} diff --git a/src/main/java/interface_adapters/user_registration_interface_adapters/UserExistsOutputView.java b/src/main/java/interface_adapters/user_registration_interface_adapters/UserExistsOutputView.java new file mode 100644 index 00000000..5858d650 --- /dev/null +++ b/src/main/java/interface_adapters/user_registration_interface_adapters/UserExistsOutputView.java @@ -0,0 +1,28 @@ +package interface_adapters.user_registration_interface_adapters; +/** + * Presenter interface that presents information, or gets input from user + * */ +public interface UserExistsOutputView { + /** + * Gets the verification code from the user + * */ + void getVerificationCredentials(); + /** + * Presents that the user exists in the database + * */ + /*TODO: Currently this violates Interface segregation principle, as the bottom method has nothing to do with + getting verification credentials.*/ + void presentUserExistsMessage(); + /** + * Gets the code from the input boundary object + * @param code Verification code + * */ + void getCode(int code); + /** + * Gets the user credentials from the input boundary object + * @param email Email address of the user + * @param password Password of the user + * @param username Username of the user + * */ + void getUserCredentials(String username, String password, String email); +} diff --git a/src/main/java/interface_adapters/user_registration_interface_adapters/UserExistsPresenter.java b/src/main/java/interface_adapters/user_registration_interface_adapters/UserExistsPresenter.java new file mode 100644 index 00000000..203ab6dc --- /dev/null +++ b/src/main/java/interface_adapters/user_registration_interface_adapters/UserExistsPresenter.java @@ -0,0 +1,49 @@ +package interface_adapters.user_registration_interface_adapters; + +import data_access.Database; +import use_cases.user_registration_use_cases.VerificationCodeDeliveryManager; +import use_cases.user_registration_use_cases.createMailMan; + +/** + * This is the class responsible for getting processing the input given by user, and either allowing verification, + * presenting the 'user exists' message, and sending the verification code, depending on the business logic + * */ +public class UserExistsPresenter { + private final VerificationCodeDeliveryManager verCodeDeliveryManager; + Database database; + UserExistsOutputView existsOutputBoundary; + + public UserExistsPresenter(Database database, UserExistsOutputView existsOutputBoundary, createMailMan mailMan){ + this.database = database; + this.existsOutputBoundary = existsOutputBoundary; + //The responsibility of dealing with verification is passed onto this class + this.verCodeDeliveryManager = new VerificationCodeDeliveryManager(mailMan); + } + /** + * Proceeds to verification and sends code, or presents an error message, depending on whether a user with + * such credentials is in the database. + * @param username Username + * @param email Email + * @param password Password + * */ + + public void register(String username, String password, String email) { + if(!database.UserExists(username, email)){ + //This may need to change if verCodeDeliveryManager decides not to create integer codes. + int code = this.verCodeDeliveryManager.getVerCode(); + existsOutputBoundary.getCode(code); + existsOutputBoundary.getUserCredentials(username, password, email); + existsOutputBoundary.getVerificationCredentials(); + this.verCodeDeliveryManager.deliverCode(email); + }else{ + existsOutputBoundary.presentUserExistsMessage(); + } + } + /** + * Sets the verification stream given by the user, to send the code + * @param type The verification stream + * */ + public void setCodeDeliveryMethod(String type) { + this.verCodeDeliveryManager.setMailMan(type); + } +} diff --git a/src/main/java/interface_adapters/user_registration_interface_adapters/UserVerificationOutputView.java b/src/main/java/interface_adapters/user_registration_interface_adapters/UserVerificationOutputView.java new file mode 100644 index 00000000..cee1b432 --- /dev/null +++ b/src/main/java/interface_adapters/user_registration_interface_adapters/UserVerificationOutputView.java @@ -0,0 +1,7 @@ +package interface_adapters.user_registration_interface_adapters; + +public interface UserVerificationOutputView { + void getLoginCredentials(); + void cannotVerify(); + +} diff --git a/src/main/java/interface_adapters/user_registration_interface_adapters/UserVerificationPresenter.java b/src/main/java/interface_adapters/user_registration_interface_adapters/UserVerificationPresenter.java new file mode 100644 index 00000000..b194f2ec --- /dev/null +++ b/src/main/java/interface_adapters/user_registration_interface_adapters/UserVerificationPresenter.java @@ -0,0 +1,48 @@ +package interface_adapters.user_registration_interface_adapters; + +import data_access.Database; + +public class UserVerificationPresenter { + private final Database database; + private String username; + private String password; + private String email; + + private final UserVerificationOutputView verificationOutputBoundary; + + private int code; + + public UserVerificationPresenter(Database database, UserVerificationOutputView verificationOutputBoundary){ + this.database = database; + this.verificationOutputBoundary = verificationOutputBoundary; + } + /** + * Compares code with this.code, if they match, the program will proceed to ask for login credentials + * Else, it will present a message that verification is not possible + * @param code code inputted by the user + * */ + public void verify(int code) { + System.out.println(this.code); + if(code == this.code){ + database.createUser(this.username, this.password, this.email, "Basic"); + verificationOutputBoundary.getLoginCredentials(); + }else{ + verificationOutputBoundary.cannotVerify(); + } + + } + /** + * Sets the code to compare for verification + * @param code verification code*/ + public void setCode(int code) { + this.code = code; + } + /** + * Sets the user credentials for this object + * */ + public void setCredentials(String username, String password, String email){ + this.username = username; + this.password = password; + this.email = email; + } +} diff --git a/src/main/java/use_cases/user_registration_use_cases/userRegCredentialsRetriever.java b/src/main/java/interface_adapters/user_registration_interface_adapters/userRegCredentialsRetriever.java similarity index 55% rename from src/main/java/use_cases/user_registration_use_cases/userRegCredentialsRetriever.java rename to src/main/java/interface_adapters/user_registration_interface_adapters/userRegCredentialsRetriever.java index 1d4951cb..cf2e0fd6 100644 --- a/src/main/java/use_cases/user_registration_use_cases/userRegCredentialsRetriever.java +++ b/src/main/java/interface_adapters/user_registration_interface_adapters/userRegCredentialsRetriever.java @@ -1,4 +1,4 @@ -package use_cases.user_registration_use_cases; +package interface_adapters.user_registration_interface_adapters; public interface userRegCredentialsRetriever { void getUserCredentials(); diff --git a/src/main/java/interface_adapters/user_search_IA/UserPresenterClass.java b/src/main/java/interface_adapters/user_search_IA/UserPresenterClass.java index 5fa974fc..7f03bbed 100644 --- a/src/main/java/interface_adapters/user_search_IA/UserPresenterClass.java +++ b/src/main/java/interface_adapters/user_search_IA/UserPresenterClass.java @@ -6,7 +6,7 @@ /** * User_search_IA.UserPresenter makes us implement showProfile to invert the dependency */ -public class UserPresenterClass implements UserPresenter{ +public class UserPresenterClass implements UserPresenter { @Override public String showProfile(String username) { // setting up access to the database of users: diff --git a/src/main/java/screens/login_screen/AppScreenCreator.java b/src/main/java/screens/login_screen/AppScreenCreator.java new file mode 100644 index 00000000..c0e8802a --- /dev/null +++ b/src/main/java/screens/login_screen/AppScreenCreator.java @@ -0,0 +1,47 @@ +package screens.login_screen; +import interface_adapters.appscreen.AppScreenLoader; +import interface_adapters.login_interface_adapters.UserLoginViewI; +import use_cases.user_login_use_cases.UserLoginOutputBoundary; + +import java.util.ArrayList; +/** + * Responsible for creating the view once User presses login + * **/ +public class AppScreenCreator implements UserLoginViewI { + private boolean userNotExists; + private boolean passNotMatched; + AppScreenLoader appScreenLoader; + public AppScreenCreator(){ + } + /** + * Opens the chats of the user + * **/ + @Override + public void display() { + if(userNotExists|| passNotMatched){ + showUnableToLogin(); + }else{ + /*this.appScreen = new AppScreen(username, chats);*/ + //Could be null pointer exception if setChatsPresenter is not called before the below + appScreenLoader.openScreen(); + } + } + /** + * Shows a frame that displays a message + * **/ + private void showUnableToLogin() { + System.out.println("unable to login"); + } + /** + * Gets the info from the presenter in order to output info into the screen + * **/ + @Override + public void setChatsPresenter(UserLoginOutputBoundary chatsPresenter){ + String username = chatsPresenter.getUsername(); + ArrayList chats = (ArrayList) chatsPresenter.getChats(); + this.userNotExists = chatsPresenter.isNotExists(); + this.passNotMatched = chatsPresenter.isNotMatched(); + appScreenLoader = new AppScreenLoader(username, chats); + } + +} diff --git a/src/main/java/screens/login_screen/UserLoginUI.java b/src/main/java/screens/login_screen/UserLoginUI.java index 6d4140dd..d72968ae 100644 --- a/src/main/java/screens/login_screen/UserLoginUI.java +++ b/src/main/java/screens/login_screen/UserLoginUI.java @@ -1,21 +1,41 @@ package screens.login_screen; +import data_access.Database; +import data_access.UserDatabase; +import interface_adapters.login_interface_adapters.UserChatsPresenter; +import interface_adapters.login_interface_adapters.UserLoginViewI; import use_cases.user_login_use_cases.UserLoginInputBoundary; -import use_cases.user_registration_use_cases.UserVerificationOutputBoundary; +import interface_adapters.login_interface_adapters.UserLoginPresenter; +import use_cases.user_login_use_cases.UserLoginInteractor2; +import interface_adapters.user_registration_interface_adapters.UserVerificationOutputView; import javax.swing.*; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; +import java.io.File; /** This is the screen on which the user enters his credentials in order to login **/ -public class UserLoginUI implements ActionListener, UserVerificationOutputBoundary { +public class UserLoginUI implements ActionListener, UserVerificationOutputView { - private final UserLoginInputBoundary loginInteractor; + private final UserLoginPresenter loginPresenter; JTextField credentialText; JPasswordField passwordText; - public UserLoginUI(UserLoginInputBoundary loginInteractor){ - this.loginInteractor = loginInteractor; + public UserLoginUI(UserLoginPresenter loginPresenter){ + UserLoginViewI loginViewI = new AppScreenCreator(); + this.loginPresenter = loginPresenter; + this.loginPresenter.setLoginView(loginViewI); } + //For Testing Purposes + public static void main(String[] args){ + Database userDB = new UserDatabase(new File("new")); + UserLoginInputBoundary inputBoundary = new UserLoginInteractor2(userDB, new UserChatsPresenter()); + UserLoginPresenter loginPresenter1 = new UserLoginPresenter(userDB, inputBoundary); + UserLoginUI loginUI = new UserLoginUI(loginPresenter1); + loginUI.getLoginCredentials(); + } + /** + * Frame to input login credentials + * **/ @Override public void getLoginCredentials(){ JFrame loginFrame = new JFrame(); @@ -48,7 +68,11 @@ public void getLoginCredentials(){ loginFrame.setVisible(true); } - + /** + * If the verification code is not right, this message shows up + * TODO: this has nothing to do with entering login credentials, so this is a violation of Interface segregation + * principles + * **/ @Override public void cannotVerify() { JFrame cannotVerifyFrame = new JFrame(); @@ -69,7 +93,7 @@ public void cannotVerify() { public void actionPerformed(ActionEvent e) { String username = credentialText.getText(); String password = passwordText.getText(); - loginInteractor.setLoginCredentials(username, password); - loginInteractor.tryLogin(); + loginPresenter.setLoginCredentials(username, password); + loginPresenter.tryLogin(); } } diff --git a/src/main/java/screens/user_registration_screen/UserRegistrationUI.java b/src/main/java/screens/user_registration_screen/UserRegistrationUI.java index 730d4641..34ff2a24 100644 --- a/src/main/java/screens/user_registration_screen/UserRegistrationUI.java +++ b/src/main/java/screens/user_registration_screen/UserRegistrationUI.java @@ -1,9 +1,12 @@ package screens.user_registration_screen; import data_access.Database; import data_access.UserDatabase; -import use_cases.user_registration_use_cases.UserExistsInputBoundary; -import use_cases.user_registration_use_cases.UserExistsInteractor; -import use_cases.user_registration_use_cases.userRegCredentialsRetriever; +import interface_adapters.login_interface_adapters.UserChatsPresenter; +import interface_adapters.user_registration_interface_adapters.*; +import screens.login_screen.UserLoginUI; +import use_cases.user_login_use_cases.UserLoginInteractor2; +import interface_adapters.login_interface_adapters.UserLoginPresenter; +import use_cases.user_registration_use_cases.*; import javax.swing.*; import java.awt.event.ActionEvent; @@ -12,7 +15,7 @@ /** This is screen on which the User enters his credentials in order to login**/ public class UserRegistrationUI implements ActionListener, userRegCredentialsRetriever { - private final UserExistsInputBoundary verifyUser; + private final UserExistsPresenter verifyUser; private JTextField usernameText; private JTextField passwordText; private JTextField emailText; @@ -22,9 +25,12 @@ public class UserRegistrationUI implements ActionListener, userRegCredentialsRet */ private JTextField deliveryText; - public UserRegistrationUI(UserExistsInputBoundary verifyUser) { - this.verifyUser = verifyUser; + public UserRegistrationUI(UserExistsPresenter existsInputBoundary) { + this.verifyUser = existsInputBoundary; } + /** + * Creates the frame on which the user inputs account registration credentials + * **/ @Override public void getUserCredentials(){ //Front end related objects @@ -80,10 +86,16 @@ public void getUserCredentials(){ } public static void main(String[] args){ - //Testing purposes - Database testDB = new UserDatabase(new File("user_accounts")); - UserExistsInputBoundary interactor = new UserExistsInteractor(testDB); - new UserRegistrationUI(interactor).getUserCredentials(); + Database testDB = new UserDatabase(new File("new")); + UserLoginInteractor2 userLoginInteractor2 = new UserLoginInteractor2(testDB, new UserChatsPresenter()); + UserLoginPresenter userLoginPresenter = new UserLoginPresenter(testDB, userLoginInteractor2); + UserVerificationOutputView loginUI = new UserLoginUI(userLoginPresenter); + UserVerificationPresenter verificationInteractor = new UserVerificationPresenter(testDB, loginUI); + UserExistsOutputView verificationScreen = new UserVerificationScreen(verificationInteractor); + UserExistsPresenter existsInteractor = new UserExistsPresenter(testDB, verificationScreen, new verificationMethodFactory()); + UserRegistrationUI testUI = new UserRegistrationUI(existsInteractor); + testUI.getUserCredentials(); + } @Override public void actionPerformed(ActionEvent e) { @@ -91,6 +103,7 @@ public void actionPerformed(ActionEvent e) { String password = passwordText.getText(); String email = emailText.getText(); + // Makes sure that the credentials entered are of the correct format, may use regex to correct this if(username.equals("")|| password.equals("")|| email.equals("")){ missingCredentials(); }else{ @@ -99,7 +112,9 @@ public void actionPerformed(ActionEvent e) { verifyUser.register(username, password, email); } } - + /** + * The frame that shows up when the credentials entered are not of the right format + * **/ public void missingCredentials(){ JFrame credentialsMissing = new JFrame(); credentialsMissing.setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE); diff --git a/src/main/java/screens/user_registration_screen/UserVerificationScreen.java b/src/main/java/screens/user_registration_screen/UserVerificationScreen.java index 52ec4ad6..d5f5bfc9 100644 --- a/src/main/java/screens/user_registration_screen/UserVerificationScreen.java +++ b/src/main/java/screens/user_registration_screen/UserVerificationScreen.java @@ -1,20 +1,28 @@ package screens.user_registration_screen; - -import use_cases.user_registration_use_cases.UserExistsOutputBoundary; -import use_cases.user_registration_use_cases.UserVerificationInputBoundary; +import interface_adapters.user_registration_interface_adapters.UserExistsOutputView; +import interface_adapters.user_registration_interface_adapters.UserVerificationPresenter; import javax.swing.*; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; - -public class UserVerificationScreen implements UserExistsOutputBoundary, ActionListener { +/** + * This is the class that is responsible for retrieving the verification code form the user, or presenting if + * verification is not possible + * */ +public class UserVerificationScreen implements UserExistsOutputView, ActionListener { private final JTextField verText = new JTextField(20); - private final UserVerificationInputBoundary verificationInputBoundary; + private final UserVerificationPresenter verificationInputBoundary; + private int code; + private String username; + private String password; + private String email; - public UserVerificationScreen(UserVerificationInputBoundary verificationInputBoundary) { + public UserVerificationScreen(UserVerificationPresenter verificationInputBoundary){ this.verificationInputBoundary = verificationInputBoundary; } - + /** + * This method asks for the code from the user + * */ @Override public void getVerificationCredentials() { JFrame verificationFrame = new JFrame(); @@ -37,7 +45,9 @@ public void getVerificationCredentials() { verificationPanel.add(verifyButton); verificationFrame.setVisible(true); } - + /** + * This method presents that verification is not possible, because the user exists in the database + * */ @Override public void presentUserExistsMessage() { JFrame userExistsFrame = new JFrame(); @@ -52,12 +62,33 @@ public void presentUserExistsMessage() { userExistsPanel.add(accountExists); userExistsFrame.setVisible(true); } + /** + * Retrieves code from the input boundary, to set the code onto the other input boundary in the constructor + * @param code verification code + * */ + @Override + public void getCode(int code) { + this.code = code; + } + + /** + * Retrieves user credentials from the input boundary, in order to set the credentials onto the other input + * boundary in the constructor + * */ + @Override + public void getUserCredentials(String username, String password, String email) { + this.username = username; + this.password = password; + this.email = email; + } @Override public void actionPerformed(ActionEvent e) { // Need if statements to check if code is an integer int code = Integer.parseInt(verText.getText()); - verificationInputBoundary.verify("Email", code); + verificationInputBoundary.setCode(this.code); + verificationInputBoundary.setCredentials(username, password, email); + verificationInputBoundary.verify(code); } } diff --git a/src/main/java/use_cases/emoji_manager/ChatFrame.java b/src/main/java/use_cases/emoji_manager/ChatFrame.java index cb1bc49e..5ba9a84f 100644 --- a/src/main/java/use_cases/emoji_manager/ChatFrame.java +++ b/src/main/java/use_cases/emoji_manager/ChatFrame.java @@ -1,7 +1,7 @@ package use_cases.emoji_manager; +import emoji_manager.msg.Sender; import main.java.emoji_manager.msg.MsgType; -import main.java.emoji_manager.msg.Sender; import main.java.emoji_manager.model.FontAndText; import main.java.emoji_manager.model.EmoInfo; diff --git a/src/main/java/use_cases/user_login_use_cases/Loginable.java b/src/main/java/use_cases/user_login_use_cases/Loginable.java index f0eb5ca9..d461da81 100644 --- a/src/main/java/use_cases/user_login_use_cases/Loginable.java +++ b/src/main/java/use_cases/user_login_use_cases/Loginable.java @@ -1,6 +1,8 @@ package use_cases.user_login_use_cases; - +/** + * TODO: delete this layer + * **/ public interface Loginable { void login(); diff --git a/src/main/java/use_cases/user_login_use_cases/UserLoginInputBoundary.java b/src/main/java/use_cases/user_login_use_cases/UserLoginInputBoundary.java index d0ff589b..01462de4 100644 --- a/src/main/java/use_cases/user_login_use_cases/UserLoginInputBoundary.java +++ b/src/main/java/use_cases/user_login_use_cases/UserLoginInputBoundary.java @@ -1,7 +1,10 @@ package use_cases.user_login_use_cases; public interface UserLoginInputBoundary { - void tryLogin(); + /** Use case that is responsible for logging in the user*/ + void login(String username, String password); + + /** Returns a presenter object that communicates with the view, about next steps**/ + UserLoginOutputBoundary getChatsPresenter(); - void setLoginCredentials(String username, String password); } diff --git a/src/main/java/use_cases/user_login_use_cases/UserLoginInteractor.java b/src/main/java/use_cases/user_login_use_cases/UserLoginInteractor.java deleted file mode 100644 index b9746916..00000000 --- a/src/main/java/use_cases/user_login_use_cases/UserLoginInteractor.java +++ /dev/null @@ -1,37 +0,0 @@ -package use_cases.user_login_use_cases; - -import data_access.Database; -import entities.user_entities.User; - -public class UserLoginInteractor implements UserLoginInputBoundary { - private String username; - private String password; - private User user; - Database database; - public UserLoginInteractor(Database database){ - this.database = database; - } - - @Override - public void tryLogin() { - try{ - //TODO: issues here with serialization - user = database.getUser(username); - if(user.PasswordMatch(this.password)){ - user.login(); - }else{ - System.out.println("the password or username is incorrect"); - } - }catch(NullPointerException e){ - //TODO: implement login output boundary - System.out.println("An account with these credentials do not exist"); - } - - } - - @Override - public void setLoginCredentials(String username, String password) { - this.username = username; - this.password = password; - } -} diff --git a/src/main/java/use_cases/user_login_use_cases/UserLoginInteractor2.java b/src/main/java/use_cases/user_login_use_cases/UserLoginInteractor2.java new file mode 100644 index 00000000..ab8783a8 --- /dev/null +++ b/src/main/java/use_cases/user_login_use_cases/UserLoginInteractor2.java @@ -0,0 +1,48 @@ +package use_cases.user_login_use_cases; + +import data_access.Database; +import entities.chat.Chat; +import entities.user_entities.User; + +import java.util.ArrayList; +import java.util.List; + +public class UserLoginInteractor2 implements UserLoginInputBoundary { + private final UserLoginOutputBoundary chatPresenter; + private final Database database; + + private final List chatsStrings = new ArrayList<>(); + + public UserLoginInteractor2(Database database, UserLoginOutputBoundary chatPresenter){ + this.database = database; + this.chatPresenter = chatPresenter; + } + /** + * @param username Username of the user + * @param password password that the user entered + * **/ + @Override + public void login(String username, String password) { + try { + User user = database.getUser(username); + this.chatPresenter.setUsername(username); + this.chatPresenter.setPasswordNotMatched(!user.PasswordMatch(password)); + this.chatPresenter.setUserNotExists(false); + List chats = user.getChats(); + for(Chat chat: chats){ + this.chatsStrings.add(chat.getName()); + } + this.chatPresenter.setChats(this.chatsStrings); + }catch(NullPointerException e){ + //Null pointer exception returns when the user is not in the database + this.chatPresenter.setUserNotExists(true); + this.chatPresenter.setChats(this.chatsStrings); + } + + } + + @Override + public UserLoginOutputBoundary getChatsPresenter() { + return this.chatPresenter; + } +} diff --git a/src/main/java/use_cases/user_login_use_cases/UserLoginOutputBoundary.java b/src/main/java/use_cases/user_login_use_cases/UserLoginOutputBoundary.java new file mode 100644 index 00000000..3c4da906 --- /dev/null +++ b/src/main/java/use_cases/user_login_use_cases/UserLoginOutputBoundary.java @@ -0,0 +1,18 @@ +package use_cases.user_login_use_cases; + +import java.util.List; +/** + * Objects that implement this interface are presenters that communicate with the view + * and the login interactor in order to implement login + * **/ +public interface UserLoginOutputBoundary { + void setUsername(String username); + void setChats(List chats); + void setUserNotExists(boolean notExists); + void setPasswordNotMatched(boolean notMatched); + + String getUsername(); + List getChats(); + boolean isNotExists(); + boolean isNotMatched(); +} diff --git a/src/main/java/use_cases/user_login_use_cases/UserVerificationOutputBoundary.java b/src/main/java/use_cases/user_login_use_cases/UserVerificationOutputBoundary.java deleted file mode 100644 index 66c08c43..00000000 --- a/src/main/java/use_cases/user_login_use_cases/UserVerificationOutputBoundary.java +++ /dev/null @@ -1,5 +0,0 @@ -package use_cases.user_login_use_cases; - -public interface UserVerificationOutputBoundary { - void getLoginCredentials(); -} diff --git a/src/main/java/use_cases/user_registration_use_cases/EmailDelivery.java b/src/main/java/use_cases/user_registration_use_cases/EmailDelivery.java index 99000de5..8451ec3b 100644 --- a/src/main/java/use_cases/user_registration_use_cases/EmailDelivery.java +++ b/src/main/java/use_cases/user_registration_use_cases/EmailDelivery.java @@ -4,12 +4,15 @@ import javax.mail.*; import javax.mail.internet.InternetAddress; import javax.mail.internet.MimeMessage; - +/** + * This is the class that implements Email verification*/ public class EmailDelivery implements ISendVerificationCode { + /** + * The method that implements email verification + * @param email Email address + * @param code Verification Code + * */ public void sendVerificationCode(String email, int code){ - /*TODO: When this is implemented, the verification code will be sent to the email specified by String email*/ - System.out.println("Verification code sent to " + email); - //email address we will send the code to String to = email; @@ -42,7 +45,6 @@ protected PasswordAuthentication getPasswordAuthentication() { message.setText("The verification code for your account is " + code + ". If this was not you, you can safely " + "ignore this email"); Transport.send(message); - System.out.println("success"); } catch (MessagingException e) { throw new RuntimeException(e); } diff --git a/src/main/java/use_cases/user_registration_use_cases/ISendVerificationCode.java b/src/main/java/use_cases/user_registration_use_cases/ISendVerificationCode.java index 3e417944..f8a5d145 100644 --- a/src/main/java/use_cases/user_registration_use_cases/ISendVerificationCode.java +++ b/src/main/java/use_cases/user_registration_use_cases/ISendVerificationCode.java @@ -1,5 +1,7 @@ package use_cases.user_registration_use_cases; -//This is an output boundary object for the user registration use case. +/** + * Interface that has a method which represents the sending of the verification code to the user + * */ public interface ISendVerificationCode { void sendVerificationCode(String email, int code); } diff --git a/src/main/java/use_cases/user_registration_use_cases/PhoneDelivery.java b/src/main/java/use_cases/user_registration_use_cases/PhoneDelivery.java index 007f1bfa..78a583dd 100644 --- a/src/main/java/use_cases/user_registration_use_cases/PhoneDelivery.java +++ b/src/main/java/use_cases/user_registration_use_cases/PhoneDelivery.java @@ -1,8 +1,12 @@ package use_cases.user_registration_use_cases; -import use_cases.user_registration_use_cases.ISendVerificationCode; - +/** + * Class that represents Phone verification. Currently unimplemented + * */ public class PhoneDelivery implements ISendVerificationCode { + /** + * The function that is supposed to implement phone verification. Currently unimplemented + * */ public void sendVerificationCode(String phoneNumber, int code){ /*TODO: When this is implemented properly, the verification code will be sent to phone number specified by * String phoneNumber*/ diff --git a/src/main/java/use_cases/user_registration_use_cases/UserCreator.java b/src/main/java/use_cases/user_registration_use_cases/UserCreator.java index a18204dd..437fd4b4 100644 --- a/src/main/java/use_cases/user_registration_use_cases/UserCreator.java +++ b/src/main/java/use_cases/user_registration_use_cases/UserCreator.java @@ -1,5 +1,8 @@ package use_cases.user_registration_use_cases; +/** + * Interface that has a method which represents the creation of a user + * */ public interface UserCreator { void createUser(String username, String password, String email, String type); } diff --git a/src/main/java/use_cases/user_registration_use_cases/UserExists.java b/src/main/java/use_cases/user_registration_use_cases/UserExists.java index 16c744d6..68e4c874 100644 --- a/src/main/java/use_cases/user_registration_use_cases/UserExists.java +++ b/src/main/java/use_cases/user_registration_use_cases/UserExists.java @@ -1,6 +1,15 @@ package use_cases.user_registration_use_cases; public interface UserExists { + /** + * Method that checks if a user exists in the database + * @param email Email address of the user + * @param username Username of the user + * */ boolean UserExists(String username, String email); + /** + * Method that checks if a user exists in the database + * @param username Username of the user + * */ boolean UserExists(String username); } diff --git a/src/main/java/use_cases/user_registration_use_cases/UserExistsInputBoundary.java b/src/main/java/use_cases/user_registration_use_cases/UserExistsInputBoundary.java deleted file mode 100644 index 3584c812..00000000 --- a/src/main/java/use_cases/user_registration_use_cases/UserExistsInputBoundary.java +++ /dev/null @@ -1,7 +0,0 @@ -package use_cases.user_registration_use_cases; - -public interface UserExistsInputBoundary { - - void register(String username, String password, String email); - void setCodeDeliveryMethod(String type); -} diff --git a/src/main/java/use_cases/user_registration_use_cases/UserExistsInteractor.java b/src/main/java/use_cases/user_registration_use_cases/UserExistsInteractor.java deleted file mode 100644 index 826dd3eb..00000000 --- a/src/main/java/use_cases/user_registration_use_cases/UserExistsInteractor.java +++ /dev/null @@ -1,39 +0,0 @@ -package use_cases.user_registration_use_cases; - -import data_access.Database; -import screens.user_registration_screen.UserVerificationScreen; - -import java.util.Random; - -public class UserExistsInteractor implements UserExistsInputBoundary{ - private final int code; - //May need to refactor this using facade design pattern since this class has too many responsibilities. - Database database; - UserVerificationInputBoundary verificationInputBoundary; - UserExistsOutputBoundary existsOutputBoundary; - - private ISendVerificationCode codeMailMan; - - public UserExistsInteractor(Database database){ - this.database = database; - this.verificationInputBoundary = new UserVerificationInteractor(database); - this.code = new Random().nextInt(1321512); - verificationInputBoundary.setCode(code); - this.existsOutputBoundary = new UserVerificationScreen(verificationInputBoundary); - } - @Override - public void register(String username, String password, String email) { - if(!database.UserExists(username, email)){ - verificationInputBoundary.setCredentials(username, password, email); - existsOutputBoundary.getVerificationCredentials(); - codeMailMan.sendVerificationCode(email, code); - }else{ - existsOutputBoundary.presentUserExistsMessage(); - } - } - - @Override - public void setCodeDeliveryMethod(String type) { - this.codeMailMan = new verificationMethodFactory().getVerificationMethod(type); - } -} diff --git a/src/main/java/use_cases/user_registration_use_cases/UserExistsOutputBoundary.java b/src/main/java/use_cases/user_registration_use_cases/UserExistsOutputBoundary.java deleted file mode 100644 index a14f9fe6..00000000 --- a/src/main/java/use_cases/user_registration_use_cases/UserExistsOutputBoundary.java +++ /dev/null @@ -1,6 +0,0 @@ -package use_cases.user_registration_use_cases; - -public interface UserExistsOutputBoundary { - void getVerificationCredentials(); - void presentUserExistsMessage(); -} diff --git a/src/main/java/use_cases/user_registration_use_cases/UserVerificationInputBoundary.java b/src/main/java/use_cases/user_registration_use_cases/UserVerificationInputBoundary.java deleted file mode 100644 index 1f2019e6..00000000 --- a/src/main/java/use_cases/user_registration_use_cases/UserVerificationInputBoundary.java +++ /dev/null @@ -1,7 +0,0 @@ -package use_cases.user_registration_use_cases; - -public interface UserVerificationInputBoundary { - void setCode(int code); - void setCredentials(String username, String password, String email); - void verify(String type, int code); -} diff --git a/src/main/java/use_cases/user_registration_use_cases/UserVerificationInteractor.java b/src/main/java/use_cases/user_registration_use_cases/UserVerificationInteractor.java deleted file mode 100644 index b0cf9d22..00000000 --- a/src/main/java/use_cases/user_registration_use_cases/UserVerificationInteractor.java +++ /dev/null @@ -1,49 +0,0 @@ -package use_cases.user_registration_use_cases; - -import data_access.Database; -import screens.login_screen.UserLoginUI; -import use_cases.user_login_use_cases.UserLoginInputBoundary; -import use_cases.user_login_use_cases.UserLoginInteractor; - -import java.util.Random; - -public class UserVerificationInteractor implements UserVerificationInputBoundary{ - private final Database database; - private String username; - private String password; - private String email; - - private final UserVerificationOutputBoundary verificationOutputBoundary; - - private int code ; - - public UserVerificationInteractor(Database database){ - this.database = database; - UserLoginInputBoundary loginInteractor = new UserLoginInteractor(this.database); - verificationOutputBoundary = new UserLoginUI(loginInteractor); - } - @Override - public void verify(String type, int code) { - System.out.println(this.code); - if(code == this.code){ - database.createUser(this.username, this.password, this.email, "Basic"); - System.out.println("verified"); - verificationOutputBoundary.getLoginCredentials(); - }else{ - System.out.println("failure"); - verificationOutputBoundary.cannotVerify(); - } - - } - - @Override - public void setCode(int code) { - this.code = code; - } - - public void setCredentials(String username, String password, String email){ - this.username = username; - this.password = password; - this.email = email; - } -} diff --git a/src/main/java/use_cases/user_registration_use_cases/UserVerificationOutputBoundary.java b/src/main/java/use_cases/user_registration_use_cases/UserVerificationOutputBoundary.java deleted file mode 100644 index c0062767..00000000 --- a/src/main/java/use_cases/user_registration_use_cases/UserVerificationOutputBoundary.java +++ /dev/null @@ -1,6 +0,0 @@ -package use_cases.user_registration_use_cases; - -public interface UserVerificationOutputBoundary { - void getLoginCredentials(); - void cannotVerify(); -} diff --git a/src/main/java/use_cases/user_registration_use_cases/VerificationCodeDeliveryManager.java b/src/main/java/use_cases/user_registration_use_cases/VerificationCodeDeliveryManager.java new file mode 100644 index 00000000..37aaedff --- /dev/null +++ b/src/main/java/use_cases/user_registration_use_cases/VerificationCodeDeliveryManager.java @@ -0,0 +1,37 @@ +package use_cases.user_registration_use_cases; + +import java.util.Random; +/** + * This class is responsible for managing aspects related to verification, such as creating the verification code + * and sending the code to the user + * */ +public class VerificationCodeDeliveryManager { + private final int code = new Random().nextInt(134134); + private final createMailMan mailManFactory; + private ISendVerificationCode mailMan; + public VerificationCodeDeliveryManager(createMailMan mailManFactory){ + this.mailManFactory = mailManFactory; + //By default, the type will be email. + this.setMailMan("Email"); + } + /** + * Sets the verification stream + * @param type String that represents how the code is delivered + * */ + public void setMailMan(String type){ + this.mailMan = mailManFactory.getVerificationMethod(type); + } + /** + * Sends the verification code + * @param email Represents the email + * */ + public void deliverCode(String email){ + this.mailMan.sendVerificationCode(email, this.code); + } + /** + * returns the verification code + * */ + public int getVerCode(){ + return this.code; + } +} diff --git a/src/main/java/use_cases/user_registration_use_cases/createMailMan.java b/src/main/java/use_cases/user_registration_use_cases/createMailMan.java new file mode 100644 index 00000000..8a1f71dd --- /dev/null +++ b/src/main/java/use_cases/user_registration_use_cases/createMailMan.java @@ -0,0 +1,6 @@ +package use_cases.user_registration_use_cases; +/** + * Interface that has a method which represents the creation of objects that can send verification code*/ +public interface createMailMan { + ISendVerificationCode getVerificationMethod(String type); +} diff --git a/src/main/java/use_cases/user_registration_use_cases/verificationMethodFactory.java b/src/main/java/use_cases/user_registration_use_cases/verificationMethodFactory.java index 1d67a98c..aea3ad31 100644 --- a/src/main/java/use_cases/user_registration_use_cases/verificationMethodFactory.java +++ b/src/main/java/use_cases/user_registration_use_cases/verificationMethodFactory.java @@ -1,6 +1,6 @@ package use_cases.user_registration_use_cases; -public class verificationMethodFactory { +public class verificationMethodFactory implements createMailMan { public ISendVerificationCode getVerificationMethod(String type){ return new EmailDelivery(); } diff --git a/src/test/java/UserDatabaseTest.java b/src/test/java/UserDatabaseTest.java index 09f087cf..55cac0f1 100644 --- a/src/test/java/UserDatabaseTest.java +++ b/src/test/java/UserDatabaseTest.java @@ -9,28 +9,28 @@ public class UserDatabaseTest { @Test public void addingFilesRightEmailAndUser(){ - File accounts = new File("TestUserDatabase2.csv"); + File accounts = new File("TestUserDatabase123.csv"); UserDatabase accountDatabase = new UserDatabase(accounts); accountDatabase.createUser("MadhavGopakumar", "123", "madhavgopan2000@gmail.com", "Basic"); Assertions.assertTrue(accountDatabase.UserExists("MadhavGopakumar", "madhavgopan2000@gmail.com")); } @Test public void addingMultipleFiles(){ - File accounts = new File("TestUserDatabase2.csv"); + File accounts = new File("TestUserDatabase123.csv"); UserDatabase accountDatabase = new UserDatabase(accounts); accountDatabase.createUser("MeenakshiGopakumar", "123", "meena@gmail.com", "Basic"); Assertions.assertTrue(accountDatabase.UserExists("MeenakshiGopakumar", "meena@gmail.com")); } @Test public void rightEmailWrongUser(){ - File accounts = new File("TestUserDatabase2.csv"); + File accounts = new File("TestUserDatabase123.csv"); UserDatabase accountDatabase = new UserDatabase(accounts); accountDatabase.createUser("MadhavGopakumar", "123", "madhavgopan2000@gmail.com", "Basic"); Assertions.assertTrue(accountDatabase.UserExists("MadG", "madhavgopan2000@gmail.com")); } @Test public void rightUserWrongEmail(){ - File accounts = new File("TestUserDatabase2.csv"); + File accounts = new File("TestUserDatabase123.csv"); UserDatabase accountDatabase = new UserDatabase(accounts); Assertions.assertTrue(accountDatabase.UserExists("MeenakshiGopakumar", "ma")); } diff --git a/src/test/java/test_user_login/TestUserLoginInteractor.java b/src/test/java/test_user_login/TestUserLoginInteractor.java new file mode 100644 index 00000000..34499f82 --- /dev/null +++ b/src/test/java/test_user_login/TestUserLoginInteractor.java @@ -0,0 +1,88 @@ +package test_user_login; + +import data_access.UserDatabase; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; +import use_cases.user_login_use_cases.UserLoginInteractor2; +import use_cases.user_login_use_cases.UserLoginOutputBoundary; + +import java.io.File; +import java.util.List; + +public class TestUserLoginInteractor { + private final UserDatabase database = new UserDatabase(new File("testAccounts")); + private static class testUserChatsPresenter implements UserLoginOutputBoundary{ + public int x; + private boolean notExists; + private boolean notMatched; + + @Override + public void setUsername(String username) { + x += 1; + } + + @Override + public void setChats(List chats) { + x += 3; + } + + @Override + public void setUserNotExists(boolean notExists) { + this.notExists = notExists; + } + + @Override + public void setPasswordNotMatched(boolean notMatched) { + this.notMatched = notMatched; + } + + @Override + public String getUsername() { + return null; + } + + @Override + public List getChats() { + return null; + } + + @Override + public boolean isNotExists() { + return this.notExists; + } + + @Override + public boolean isNotMatched() { + return this.notMatched; + } + } + + @Test + public void testUserNotExists(){ + testUserChatsPresenter chatsPresenter = new testUserChatsPresenter(); + UserLoginInteractor2 userInteractor = new UserLoginInteractor2(database, chatsPresenter); + userInteractor.login("Madhavi", "123"); + Assertions.assertTrue(chatsPresenter.isNotExists()); + } + + @Test + public void testUserPasswordWrong(){ + testUserChatsPresenter chatsPresenter = new testUserChatsPresenter(); + UserLoginInteractor2 userInteractor = new UserLoginInteractor2(database, chatsPresenter); + database.createUser("Madhav", "123", "madhavgopan2000@gmail.com", "Basic"); + userInteractor.login("Madhav", "1234"); + Assertions.assertFalse(chatsPresenter.isNotExists()); + Assertions.assertTrue(chatsPresenter.isNotMatched()); + } + @Test + public void testUserPasswordRightUserExists(){ + testUserChatsPresenter chatsPresenter = new testUserChatsPresenter(); + UserLoginInteractor2 userInteractor = new UserLoginInteractor2(database, chatsPresenter); + userInteractor.login("Madhav", "123"); + Assertions.assertFalse(chatsPresenter.isNotExists()); + Assertions.assertFalse(chatsPresenter.isNotMatched()); + //To make sure that setting chats and username is done right. + Assertions.assertEquals(chatsPresenter.x, 4); + } + +} diff --git a/src/test/java/test_user_login/TestUserLoginPresenter.java b/src/test/java/test_user_login/TestUserLoginPresenter.java new file mode 100644 index 00000000..bf149dff --- /dev/null +++ b/src/test/java/test_user_login/TestUserLoginPresenter.java @@ -0,0 +1,4 @@ +package test_user_login; + +public class TestUserLoginPresenter { +} diff --git a/src/test/java/test_user_registration/TestUserExistsInteractor.java b/src/test/java/test_user_registration/TestUserExistsInteractor.java new file mode 100644 index 00000000..3c60bfc0 --- /dev/null +++ b/src/test/java/test_user_registration/TestUserExistsInteractor.java @@ -0,0 +1,128 @@ +package test_user_registration; + +import data_access.Database; +import entities.user_entities.User; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; +import use_cases.user_registration_use_cases.ISendVerificationCode; +import interface_adapters.user_registration_interface_adapters.UserExistsPresenter; +import interface_adapters.user_registration_interface_adapters.UserExistsOutputView; +import use_cases.user_registration_use_cases.createMailMan; + +public class TestUserExistsInteractor { + //Objects used for testing + // The below anonymous database is created to test cases where the user does not exist. + Database userDontExist = new Database() { + @Override + public User getUser(String username) { + return null; + } + + @Override + public void createUser(String username, String password, String email, String type) { + + } + + @Override + public boolean UserExists(String username, String email) { + return false; + } + @Override + public boolean UserExists(String username) { + return false; + } + }; + //The below anonymous database for testing cases where the user exists + Database userExists = new Database() { + @Override + public User getUser(String username) { + return null; + } + + @Override + public void createUser(String username, String password, String email, String type) { + + } + + @Override + public boolean UserExists(String username, String email) { + return true; + } + + @Override + public boolean UserExists(String username) { + return true; + } + }; + //This output boundary used in test cases + private static class TestOutputBoundary implements UserExistsOutputView { + public int x = 0; + @Override + public void getVerificationCredentials() { + this.x += 1; + } + + @Override + public void presentUserExistsMessage() { + this.x += 3; + } + + @Override + public void getCode(int code) { + this.x += 5; + } + + @Override + public void getUserCredentials(String username, String password, String email) { + this.x += 7; + } + } + TestOutputBoundary userExistsOutputBoundary = new TestOutputBoundary(); + //The verification streams, and verification Stream factory used for testing + ISendVerificationCode verStream1 = (email, code) -> { + + }; + ISendVerificationCode verStream2 = (email, code) -> { + + }; + private class TestCreateMailMan implements createMailMan{ + public int x; + @Override + public ISendVerificationCode getVerificationMethod(String type) { + if(type.equals("0")){ + x = 100; + return verStream1; + }else{ + x = 200; + return verStream2; + } + } + } + TestCreateMailMan mailManFactory = new TestCreateMailMan(); + + //In the first test, the user exists in the database, and we will set verStream1 as the verification method + @Test + public void userExistsInDatabase1(){ + UserExistsPresenter uInteractor = new UserExistsPresenter(userExists, + userExistsOutputBoundary, mailManFactory); + uInteractor.setCodeDeliveryMethod("0"); + uInteractor.register("a", "b", "c"); + //The quantity below should be 103 + Assertions.assertEquals(userExistsOutputBoundary.x + mailManFactory.x, 103); + + } + //In this test, the user does not exist in the database, and we will set verStream2 as the verification method + @Test + public void userExistsInDatabase2(){ + TestOutputBoundary userExists2 = new TestOutputBoundary(); + TestCreateMailMan createMailMan2 = new TestCreateMailMan(); + UserExistsPresenter uInteractor2 = new UserExistsPresenter(userDontExist, userExists2, createMailMan2); + uInteractor2.setCodeDeliveryMethod("1"); + uInteractor2.register("a", "b", "c"); + //The quantity below should be 213 + Assertions.assertEquals(userExists2.x + createMailMan2.x, 213); + + } + + //No other combinations of the method calls, could arrive at those values, so the above tests passing suffices +} diff --git a/src/test/java/test_user_registration/TestUserVerificationInteractor.java b/src/test/java/test_user_registration/TestUserVerificationInteractor.java new file mode 100644 index 00000000..f2c38f34 --- /dev/null +++ b/src/test/java/test_user_registration/TestUserVerificationInteractor.java @@ -0,0 +1,68 @@ +package test_user_registration; + +import data_access.Database; +import entities.user_entities.User; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; +import interface_adapters.user_registration_interface_adapters.UserVerificationPresenter; +import interface_adapters.user_registration_interface_adapters.UserVerificationOutputView; + +public class TestUserVerificationInteractor { + private class testDatabase implements Database{ + public int x; + @Override + public User getUser(String username) { + return null; + } + + @Override + public void createUser(String username, String password, String email, String type) { + x += 1; + } + + @Override + public boolean UserExists(String username, String email) { + return false; + } + + @Override + public boolean UserExists(String username) { + return false; + } + } + private class testUserVerificationOutputBdy implements UserVerificationOutputView { + public int x; + @Override + public void getLoginCredentials() { + x += 20; + } + + @Override + public void cannotVerify() { + x+= 30; + } + } + //objects used for test + testDatabase testDB = new testDatabase(); + testUserVerificationOutputBdy userVerificationOutputBdy = new testUserVerificationOutputBdy(); + //The below test is to see if the verify function works in the case that the code is not right + @Test + public void testCodeNotRight(){ + UserVerificationPresenter testInteractor = new UserVerificationPresenter(testDB, userVerificationOutputBdy); + + testInteractor.setCode(123); + testInteractor.setCredentials("a", "b", "c"); + testInteractor.verify(135); + Assertions.assertEquals(testDB.x + userVerificationOutputBdy.x, 30); + } + //The below test is to see if the verify function works in the case that the code is right + @Test + public void testCodeRight(){ + UserVerificationPresenter testInteractor = new UserVerificationPresenter(testDB, userVerificationOutputBdy); + + testInteractor.setCode(123); + testInteractor.setCredentials("a", "b", "c"); + testInteractor.verify(123); + Assertions.assertEquals(testDB.x + userVerificationOutputBdy.x, 21); + } +}