diff --git a/engine/schema/src/main/java/com/cloud/user/UserVO.java b/engine/schema/src/main/java/com/cloud/user/UserVO.java index 6e355e102e6c..d74aa7ed41b8 100644 --- a/engine/schema/src/main/java/com/cloud/user/UserVO.java +++ b/engine/schema/src/main/java/com/cloud/user/UserVO.java @@ -123,8 +123,8 @@ public UserVO() { } public UserVO(long id) { + this(); this.id = id; - this.uuid = UUID.randomUUID().toString(); } public UserVO(long accountId, String username, String password, String firstName, String lastName, String email, String timezone, String uuid, Source source) { diff --git a/engine/schema/src/main/java/com/cloud/user/dao/AccountDao.java b/engine/schema/src/main/java/com/cloud/user/dao/AccountDao.java index dae5f3a34677..67b70571cb4c 100644 --- a/engine/schema/src/main/java/com/cloud/user/dao/AccountDao.java +++ b/engine/schema/src/main/java/com/cloud/user/dao/AccountDao.java @@ -21,13 +21,11 @@ import com.cloud.user.Account; import com.cloud.user.AccountVO; -import com.cloud.user.User; import com.cloud.utils.Pair; import com.cloud.utils.db.Filter; import com.cloud.utils.db.GenericDao; public interface AccountDao extends GenericDao { - Pair findUserAccountByApiKey(String apiKey); List findAccountsLike(String accountName); diff --git a/engine/schema/src/main/java/com/cloud/user/dao/AccountDaoImpl.java b/engine/schema/src/main/java/com/cloud/user/dao/AccountDaoImpl.java index f5f95d5da1ff..48b29fac45eb 100644 --- a/engine/schema/src/main/java/com/cloud/user/dao/AccountDaoImpl.java +++ b/engine/schema/src/main/java/com/cloud/user/dao/AccountDaoImpl.java @@ -16,8 +16,6 @@ // under the License. package com.cloud.user.dao; -import java.sql.PreparedStatement; -import java.sql.ResultSet; import java.util.Date; import java.util.List; @@ -27,10 +25,7 @@ import com.cloud.user.Account; import com.cloud.user.Account.State; import com.cloud.user.AccountVO; -import com.cloud.user.User; -import com.cloud.user.UserVO; import com.cloud.utils.Pair; -import com.cloud.utils.crypt.DBEncryptionUtil; import com.cloud.utils.db.Filter; import com.cloud.utils.db.GenericDaoBase; import com.cloud.utils.db.GenericSearchBuilder; @@ -38,13 +33,9 @@ import com.cloud.utils.db.SearchCriteria; import com.cloud.utils.db.SearchCriteria.Func; import com.cloud.utils.db.SearchCriteria.Op; -import com.cloud.utils.db.TransactionLegacy; @Component public class AccountDaoImpl extends GenericDaoBase implements AccountDao { - private static final String FIND_USER_ACCOUNT_BY_API_KEY = "SELECT u.id, u.username, u.account_id, u.secret_key, u.state, u.api_key_access, " - + "a.id, a.account_name, a.type, a.role_id, a.domain_id, a.state, a.api_key_access " + "FROM `cloud`.`user` u, `cloud`.`account` a " - + "WHERE u.account_id = a.id AND u.api_key = ? and u.removed IS NULL"; protected final SearchBuilder AllFieldsSearch; protected final SearchBuilder AccountTypeSearch; @@ -132,51 +123,6 @@ public List findCleanupsForDisabledAccounts() { return listBy(sc); } - @Override - public Pair findUserAccountByApiKey(String apiKey) { - TransactionLegacy txn = TransactionLegacy.currentTxn(); - PreparedStatement pstmt = null; - Pair userAcctPair = null; - try { - String sql = FIND_USER_ACCOUNT_BY_API_KEY; - pstmt = txn.prepareAutoCloseStatement(sql); - pstmt.setString(1, apiKey); - ResultSet rs = pstmt.executeQuery(); - // TODO: make sure we don't have more than 1 result? ApiKey had better be unique - if (rs.next()) { - User u = new UserVO(rs.getLong(1)); - u.setUsername(rs.getString(2)); - u.setAccountId(rs.getLong(3)); - u.setSecretKey(DBEncryptionUtil.decrypt(rs.getString(4))); - u.setState(State.getValueOf(rs.getString(5))); - boolean apiKeyAccess = rs.getBoolean(6); - if (rs.wasNull()) { - u.setApiKeyAccess(null); - } else { - u.setApiKeyAccess(apiKeyAccess); - } - - AccountVO a = new AccountVO(rs.getLong(7)); - a.setAccountName(rs.getString(8)); - a.setType(Account.Type.getFromValue(rs.getInt(9))); - a.setRoleId(rs.getLong(10)); - a.setDomainId(rs.getLong(11)); - a.setState(State.getValueOf(rs.getString(12))); - apiKeyAccess = rs.getBoolean(13); - if (rs.wasNull()) { - a.setApiKeyAccess(null); - } else { - a.setApiKeyAccess(apiKeyAccess); - } - - userAcctPair = new Pair(u, a); - } - } catch (Exception e) { - logger.warn("Exception finding user/acct by api key: " + apiKey, e); - } - return userAcctPair; - } - @Override public List findAccountsLike(String accountName) { return findAccountsLike(accountName, null).first(); @@ -341,11 +287,9 @@ public long getDomainIdForGivenAccountId(long id) { domain_id = account_vo.getDomainId(); } catch (Exception e) { - logger.warn("getDomainIdForGivenAccountId: Exception :" + e.getMessage()); - } - finally { - return domain_id; + logger.warn("Can not get DomainId for the given AccountId; exception message : {}", e.getMessage()); } + return domain_id; } @Override diff --git a/server/src/main/java/com/cloud/user/AccountManagerImpl.java b/server/src/main/java/com/cloud/user/AccountManagerImpl.java index d4c23e8d62be..1f6e8d5b49ee 100644 --- a/server/src/main/java/com/cloud/user/AccountManagerImpl.java +++ b/server/src/main/java/com/cloud/user/AccountManagerImpl.java @@ -85,7 +85,6 @@ import org.apache.commons.codec.binary.Base64; import org.apache.commons.collections.CollectionUtils; import org.apache.commons.lang3.BooleanUtils; -import org.apache.commons.lang3.StringUtils; import org.jetbrains.annotations.NotNull; import org.springframework.beans.factory.NoSuchBeanDefinitionException; @@ -176,6 +175,7 @@ import com.cloud.utils.NumbersUtil; import com.cloud.utils.Pair; import com.cloud.utils.Ternary; +import com.cloud.utils.StringUtils; import com.cloud.utils.component.ComponentContext; import com.cloud.utils.component.Manager; import com.cloud.utils.component.ManagerBase; @@ -223,7 +223,7 @@ public class AccountManagerImpl extends ManagerBase implements AccountManager, M @Inject private InstanceGroupDao _vmGroupDao; @Inject - private UserAccountDao _userAccountDao; + private UserAccountDao userAccountDao; @Inject private VolumeDao _volumeDao; @Inject @@ -585,11 +585,7 @@ public boolean isAdmin(Long accountId) { if (acct == null) { return false; //account is deleted or does not exist } - if ((isRootAdmin(accountId)) || (isDomainAdmin(accountId)) || (isResourceDomainAdmin(accountId))) { - return true; - } else if (acct.getType() == Account.Type.READ_ONLY_ADMIN) { - return true; - } + return (isRootAdmin(accountId)) || (isDomainAdmin(accountId)) || (isResourceDomainAdmin(accountId)) || (acct.getType() == Account.Type.READ_ONLY_ADMIN); } return false; @@ -644,10 +640,7 @@ public boolean isDomainAdmin(Long accountId) { @Override public boolean isNormalUser(long accountId) { AccountVO acct = _accountDao.findById(accountId); - if (acct != null && acct.getType() == Account.Type.NORMAL) { - return true; - } - return false; + return acct != null && acct.getType() == Account.Type.NORMAL; } @Override @@ -678,10 +671,7 @@ public boolean isInternalAccount(long accountId) { if (account == null) { return false; //account is deleted or does not exist } - if (isRootAdmin(accountId) || (account.getType() == Account.Type.ADMIN)) { - return true; - } - return false; + return isRootAdmin(accountId) || (account.getType() == Account.Type.ADMIN); } @Override @@ -712,7 +702,7 @@ public void checkAccess(Account caller, AccessType accessType, boolean sameOwner for (ControlledEntity entity : entities) { if (ownerId == null) { ownerId = entity.getAccountId(); - } else if (ownerId.longValue() != entity.getAccountId()) { + } else if (! ownerId.equals(entity.getAccountId())) { throw new PermissionDeniedException("Entity " + entity + " and entity " + prevEntity + " belong to different accounts"); } prevEntity = entity; @@ -738,7 +728,7 @@ public void checkAccess(Account caller, AccessType accessType, boolean sameOwner domainId = account != null ? account.getDomainId() : -1; } if (entity.getAccountId() != -1 && domainId != -1 && !(entity instanceof VirtualMachineTemplate) - && !(entity instanceof Network && accessType != null && (accessType == AccessType.UseEntry || accessType == AccessType.OperateEntry)) + && !(entity instanceof Network && (accessType == AccessType.UseEntry || accessType == AccessType.OperateEntry)) && !(entity instanceof AffinityGroup) && !(entity instanceof VirtualRouter)) { List toBeChecked = domains.get(entity.getDomainId()); // for templates, we don't have to do cross domains check @@ -821,7 +811,7 @@ private Long getZoneIdForAccount(Account account) { // Currently just for resource domain admin List dcList = _dcDao.findZonesByDomainId(account.getDomainId()); - if (dcList != null && dcList.size() != 0) { + if (CollectionUtils.isNotEmpty(dcList)) { return dcList.get(0).getId(); } else { throw new CloudRuntimeException("Failed to find any private zone for Resource domain admin."); @@ -836,23 +826,23 @@ public void updateLoginAttempts(final Long id, final int attempts, final boolean @Override public void doInTransactionWithoutResult(TransactionStatus status) { UserAccountVO user = null; - user = _userAccountDao.lockRow(id, true); + user = userAccountDao.lockRow(id, true); user.setLoginAttempts(attempts); if (toDisable) { user.setState(State.DISABLED.toString()); } - _userAccountDao.update(id, user); + userAccountDao.update(id, user); } }); } catch (Exception e) { - logger.error("Failed to update login attempts for user {}", () -> _userAccountDao.findById(id)); + logger.error("Failed to update login attempts for user {}", () -> userAccountDao.findById(id)); } } private boolean doSetUserStatus(long userId, State state) { UserVO userForUpdate = _userDao.createForUpdate(); userForUpdate.setState(state); - return _userDao.update(Long.valueOf(userId), userForUpdate); + return _userDao.update(userId, userForUpdate); } @Override @@ -861,7 +851,7 @@ public boolean enableAccount(long accountId) { AccountVO acctForUpdate = _accountDao.createForUpdate(); acctForUpdate.setState(State.ENABLED); acctForUpdate.setNeedsCleanup(false); - success = _accountDao.update(Long.valueOf(accountId), acctForUpdate); + success = _accountDao.update(accountId, acctForUpdate); return success; } @@ -874,7 +864,7 @@ protected boolean lockAccount(long accountId) { } else if (account.getState().equals(State.ENABLED)) { AccountVO acctForUpdate = _accountDao.createForUpdate(); acctForUpdate.setState(State.LOCKED); - success = _accountDao.update(Long.valueOf(accountId), acctForUpdate); + success = _accountDao.update(accountId, acctForUpdate); } else { if (logger.isInfoEnabled()) { logger.info("Attempting to lock a non-enabled account {}, current state is {}, locking failed.", account, account.getState()); @@ -988,7 +978,7 @@ protected boolean cleanupAccount(AccountVO account, long callerUserId, Account c } // Destroy VM Snapshots - List vmSnapshots = _vmSnapshotDao.listByAccountId(Long.valueOf(accountId)); + List vmSnapshots = _vmSnapshotDao.listByAccountId(accountId); for (VMSnapshot vmSnapshot : vmSnapshots) { try { _vmSnapshotMgr.deleteVMSnapshot(vmSnapshot.getId()); @@ -1010,8 +1000,7 @@ protected boolean cleanupAccount(AccountVO account, long callerUserId, Account c try { _vmMgr.destroyVm(vm.getId(), false); } catch (Exception e) { - e.printStackTrace(); - logger.warn("Failed destroying instance {} as part of account deletion.", vm); + logger.warn("Failed destroying instance {} as part of account deletion.", vm, e); } } // no need to catch exception at this place as expunging vm @@ -1069,7 +1058,7 @@ protected boolean cleanupAccount(AccountVO account, long callerUserId, Account c logger.debug("Deleting networks for account {}", account); List networks = _networkDao.listByOwner(accountId); if (networks != null) { - Collections.sort(networks, new Comparator<>() { + networks.sort(new Comparator<>() { @Override public int compare(NetworkVO network1, NetworkVO network2) { if (network1.getGuestType() != network2.getGuestType() && Network.GuestType.Isolated.equals(network2.getGuestType())) { @@ -1237,7 +1226,7 @@ public boolean disableAccount(long accountId) throws ConcurrentOperationExceptio } else { AccountVO acctForUpdate = _accountDao.createForUpdate(); acctForUpdate.setState(State.DISABLED); - success = _accountDao.update(Long.valueOf(accountId), acctForUpdate); + success = _accountDao.update(accountId, acctForUpdate); if (success) { boolean disableAccountResult = false; @@ -1331,11 +1320,11 @@ public UserAccount createUserAccount(final String userName, final String passwor // Check permissions checkAccess(getCurrentCallingAccount(), domain); - if (!userAllowMultipleAccounts.valueInDomain(domainId) && !_userAccountDao.validateUsernameInDomain(userName, domainId)) { + if (!userAllowMultipleAccounts.valueInDomain(domainId) && !userAccountDao.validateUsernameInDomain(userName, domainId)) { throw new InvalidParameterValueException(String.format("The user %s already exists in domain %s", userName, domain)); } - if (networkDomain != null && networkDomain.length() > 0) { + if (StringUtils.isNotEmpty(networkDomain)) { if (!NetUtils.verifyDomainName(networkDomain)) { throw new InvalidParameterValueException( "Invalid network domain. Total length shouldn't exceed 190 chars. Each domain label must be between 1 and 63 characters long, can contain ASCII letters 'a' through 'z', the digits '0' through '9', " @@ -1387,7 +1376,7 @@ public Pair doInTransaction(TransactionStatus status) { CallContext.current().putContextParameter(User.class, userId); // check success - return _userAccountDao.findById(userId); + return userAccountDao.findById(userId); } /* @@ -1525,7 +1514,7 @@ public UserVO createUser(String userName, String password, String firstName, Str throw new PermissionDeniedException(String.format("Account: %s is a system account, can't add a user to it", account)); } - if (!userAllowMultipleAccounts.valueInDomain(domainId) && !_userAccountDao.validateUsernameInDomain(userName, domainId)) { + if (!userAllowMultipleAccounts.valueInDomain(domainId) && !userAccountDao.validateUsernameInDomain(userName, domainId)) { throw new CloudRuntimeException("The user " + userName + " already exists in domain " + domainId); } List duplicatedUsers = _userDao.findUsersByName(userName); @@ -1579,7 +1568,7 @@ public UserAccount updateUser(UpdateUserCmd updateUserCmd) { user.setUser2faEnabled(true); } _userDao.update(user.getId(), user); - return _userAccountDao.findById(user.getId()); + return userAccountDao.findById(user.getId()); } @Override @@ -1861,10 +1850,9 @@ protected void validateAndUpdateApiAndSecretKeyIfNeeded(UpdateUserCmd updateUser if (isApiKeyBlank && isSecretKeyBlank) { return; } - Pair apiKeyOwner = _accountDao.findUserAccountByApiKey(apiKey); + UserAccount apiKeyOwner = userAccountDao.getUserByApiKey(apiKey); if (apiKeyOwner != null) { - User userThatHasTheProvidedApiKey = apiKeyOwner.first(); - if (userThatHasTheProvidedApiKey.getId() != user.getId()) { + if (apiKeyOwner.getId() != user.getId()) { throw new InvalidParameterValueException(String.format("The API key [%s] already exists in the system. Please provide a unique key.", apiKey)); } } @@ -1952,7 +1940,7 @@ public UserAccount disableUser(long userId) { CallContext.current().putContextParameter(User.class, user.getUuid()); // user successfully disabled - return _userAccountDao.findById(userId); + return userAccountDao.findById(userId); } else { throw new CloudRuntimeException(String.format("Unable to disable user %s", user)); } @@ -2006,7 +1994,7 @@ public Boolean doInTransaction(TransactionStatus status) { CallContext.current().putContextParameter(User.class, user.getUuid()); - return _userAccountDao.findById(userId); + return userAccountDao.findById(userId); } else { throw new CloudRuntimeException(String.format("Unable to enable user %s", user)); } @@ -2047,7 +2035,7 @@ public UserAccount lockUser(long userId) { boolean success; if (user.getState().equals(State.LOCKED)) { // already locked...no-op - return _userAccountDao.findById(userId); + return userAccountDao.findById(userId); } else if (user.getState().equals(State.ENABLED)) { success = doSetUserStatus(user.getId(), State.LOCKED); @@ -2074,7 +2062,7 @@ public UserAccount lockUser(long userId) { CallContext.current().putContextParameter(User.class, user.getUuid()); - return _userAccountDao.findById(userId); + return userAccountDao.findById(userId); } else { throw new CloudRuntimeException(String.format("Unable to lock user %s", user)); } @@ -2602,7 +2590,7 @@ public Account finalizeOwner(Account caller, String accountName, Long domainId, return owner; } else if (!isAdmin(caller.getId()) && accountName != null && domainId != null) { - if (!accountName.equals(caller.getAccountName()) || domainId.longValue() != caller.getDomainId()) { + if (!accountName.equals(caller.getAccountName()) || domainId != caller.getDomainId()) { throw new PermissionDeniedException("Can't create/list resources for account " + accountName + " in domain " + domainId + ", permission denied"); } else { return caller; @@ -2627,12 +2615,12 @@ public Account getActiveAccountByName(String accountName, Long domainId) { @Override public UserAccount getActiveUserAccount(String username, Long domainId) { - return _userAccountDao.getUserAccount(username, domainId); + return userAccountDao.getUserAccount(username, domainId); } @Override public List getActiveUserAccountByEmail(String email, Long domainId) { - List userAccountByEmail = _userAccountDao.getUserAccountByEmail(email, domainId); + List userAccountByEmail = userAccountDao.getUserAccountByEmail(email, domainId); List userAccounts = userAccountByEmail.stream() .map(userAccountVO -> (UserAccount) userAccountVO) .collect(Collectors.toList()); @@ -2676,7 +2664,7 @@ public User getActiveUserByRegistrationToken(String registrationToken) { public void markUserRegistered(long userId) { UserVO userForUpdate = _userDao.createForUpdate(); userForUpdate.setRegistered(true); - _userDao.update(Long.valueOf(userId), userForUpdate); + _userDao.update(userId, userForUpdate); } @Override @@ -2731,7 +2719,7 @@ public AccountVO doInTransaction(TransactionStatus status) { throw new CloudRuntimeException(String.format("Failed to create account name %s in domain id=%s", accountName, _domainMgr.getDomain(domainId))); } - Long accountId = account.getId(); + long accountId = account.getId(); if (details != null) { _accountDetailsDao.persist(accountId, details); @@ -2780,7 +2768,7 @@ protected UserVO createUser(long accountId, String userName, String password, St @Override public void logoutUser(long userId) { - UserAccount userAcct = _userAccountDao.findById(userId); + UserAccount userAcct = userAccountDao.findById(userId); if (userAcct != null) { ActionEventUtils.onActionEvent(userId, userAcct.getAccountId(), userAcct.getDomainId(), EventTypes.EVENT_USER_LOGOUT, "user has logged out", userId, ApiCommandResourceType.User.toString()); } // else log some kind of error event? This likely means the user doesn't exist, or has been deleted... @@ -2822,11 +2810,11 @@ public UserAccount authenticateUser(final String username, final String password final Boolean ApiSourceCidrChecksEnabled = ApiServiceConfiguration.ApiSourceCidrChecksEnabled.value(); if (ApiSourceCidrChecksEnabled) { - logger.debug("CIDRs from which account '" + account.toString() + "' is allowed to perform API calls: " + accessAllowedCidrs); + logger.debug("CIDRs from which account '{}' is allowed to perform API calls: {}", account.toString(), accessAllowedCidrs); // Block when is not in the list of allowed IPs if (!NetUtils.isIpInCidrList(loginIpAddress, accessAllowedCidrs.split(","))) { - logger.warn("Request by account '" + account.toString() + "' was denied since " + loginIpAddress.toString().replace("/", "") + " does not match " + accessAllowedCidrs); + logger.warn("Request by account '{}' was denied since {} does not match {}", account.toString(), loginIpAddress.toString().replace("/", ""), accessAllowedCidrs); throw new CloudAuthenticationException("Failed to authenticate user '" + username + "' in domain '" + domain.getPath() + "' from ip " + loginIpAddress.toString().replace("/", "") + "; please provide valid credentials"); } @@ -2858,6 +2846,7 @@ public UserAccount authenticateUser(final String username, final String password try { Thread.sleep(waitTimeDurationInMs); } catch (final InterruptedException e) { + // ignored } } @@ -2869,7 +2858,7 @@ private UserAccount getUserAccount(String username, String password, Long domain if (logger.isDebugEnabled()) { logger.debug("Attempting to log in user: " + username + " in domain " + domainId); } - UserAccount userAccount = _userAccountDao.getUserAccount(username, domainId); + UserAccount userAccount = userAccountDao.getUserAccount(username, domainId); boolean authenticated = false; HashSet actionsOnFailedAuthenticaion = new HashSet<>(); @@ -2899,11 +2888,7 @@ private UserAccount getUserAccount(String username, String password, Long domain if (authenticated) { Domain domain = _domainMgr.getDomain(domainId); - String domainName = null; - if (domain != null) { - domainName = domain.getName(); - } - userAccount = _userAccountDao.getUserAccount(username, domainId); + userAccount = userAccountDao.getUserAccount(username, domainId); if (!userAccount.getState().equalsIgnoreCase(Account.State.ENABLED.toString()) || !userAccount.getAccountState().equalsIgnoreCase(Account.State.ENABLED.toString())) { if (logger.isInfoEnabled()) { @@ -2963,11 +2948,9 @@ private UserAccount getUserAccountForSSO(String username, Long domainId, Map parameterNames = new ArrayList<>(); - for (Object paramNameObj : requestParameters.keySet()) { - parameterNames.add((String)paramNameObj); // put the name in a list that we'll sort later - } + // put the name in a list that we'll sort later + List parameterNames = new ArrayList<>(requestParameters.keySet()); Collections.sort(parameterNames); @@ -2999,7 +2982,7 @@ private UserAccount getUserAccountForSSO(String username, Long domainId, Map findUserByApiKey(String apiKey) { - return _accountDao.findUserAccountByApiKey(apiKey); + UserAccount userAccount = userAccountDao.getUserByApiKey(apiKey); + if (userAccount != null) { + User user = _userDao.getUser(userAccount.getId()); + Account account = _accountDao.findById(userAccount.getAccountId()); + return new Pair<>(user, account); + } else { + return null; + } } @Override @@ -3184,14 +3174,14 @@ private String createUserApiKey(long userId) { UserVO updatedUser = _userDao.createForUpdate(); String encodedKey; - Pair userAcct; + UserAccount userAcct; int retryLimit = 10; do { // FIXME: what algorithm should we use for API keys? KeyGenerator generator = KeyGenerator.getInstance("HmacSHA1"); SecretKey key = generator.generateKey(); encodedKey = Base64.encodeBase64URLSafeString(key.getEncoded()); - userAcct = _accountDao.findUserAccountByApiKey(encodedKey); + userAcct = userAccountDao.getUserByApiKey(encodedKey); retryLimit--; } while ((userAcct != null) && (retryLimit >= 0)); @@ -3202,7 +3192,7 @@ private String createUserApiKey(long userId) { _userDao.update(userId, updatedUser); return encodedKey; } catch (NoSuchAlgorithmException ex) { - logger.error("error generating secret key for user {}", _userAccountDao.findById(userId), ex); + logger.error("error generating secret key for user {}", userAccountDao.findById(userId), ex); } return null; } @@ -3229,7 +3219,7 @@ private String createUserSecretKey(long userId) { _userDao.update(userId, updatedUser); return encodedKey; } catch (NoSuchAlgorithmException ex) { - logger.error("error generating secret key for user {}", _userAccountDao.findById(userId), ex); + logger.error("error generating secret key for user {}", userAccountDao.findById(userId), ex); } return null; } @@ -3440,12 +3430,12 @@ public void buildACLViewSearchCriteria(SearchCriteria listAclGroupsByAccount(Long accountId) { - if (_querySelectors == null || _querySelectors.size() == 0) { + if (CollectionUtils.isEmpty(_querySelectors)) { return new ArrayList<>(); } @@ -3500,7 +3490,7 @@ public Long finalyzeAccountId(final String accountName, final Long domainId, fin @Override public UserAccount getUserAccountById(Long userId) { - UserAccount userAccount = _userAccountDao.findById(userId); + UserAccount userAccount = userAccountDao.findById(userId); Map details = _userDetailsDao.listDetailsKeyPairs(userId); userAccount.setDetails(details); @@ -3674,7 +3664,7 @@ public UserTwoFactorAuthenticationSetupResponse setupUserTwoFactorAuthentication } protected UserTwoFactorAuthenticationSetupResponse enableTwoFactorAuthentication(Long userId, String providerName) { - UserAccountVO userAccount = _userAccountDao.findById(userId); + UserAccountVO userAccount = userAccountDao.findById(userId); UserVO userVO = _userDao.findById(userId); Long domainId = userAccount.getDomainId(); if (Boolean.FALSE.equals(enableUserTwoFactorAuthentication.valueIn(domainId)) && Boolean.FALSE.equals(mandateUserTwoFactorAuthentication.valueIn(domainId))) { @@ -3766,11 +3756,11 @@ public UserAccount clearUserTwoFactorAuthenticationInSetupStateOnLogin(UserAccou if (userDetailVO != null) { _userDetailsDao.remove(userDetailVO.getId()); } - UserAccountVO userAccountVO = _userAccountDao.findById(user.getId()); + UserAccountVO userAccountVO = userAccountDao.findById(user.getId()); userAccountVO.setUser2faEnabled(false); userAccountVO.setUser2faProvider(null); userAccountVO.setKeyFor2fa(null); - _userAccountDao.update(user.getId(), userAccountVO); + userAccountDao.update(user.getId(), userAccountVO); return userAccountVO; }); } diff --git a/server/src/test/java/com/cloud/user/AccountManagetImplTestBase.java b/server/src/test/java/com/cloud/user/AccountManagentImplTestBase.java similarity index 98% rename from server/src/test/java/com/cloud/user/AccountManagetImplTestBase.java rename to server/src/test/java/com/cloud/user/AccountManagentImplTestBase.java index 98f152088ed2..71878143f240 100644 --- a/server/src/test/java/com/cloud/user/AccountManagetImplTestBase.java +++ b/server/src/test/java/com/cloud/user/AccountManagentImplTestBase.java @@ -84,7 +84,7 @@ import java.util.Map; @RunWith(MockitoJUnitRunner.class) -public class AccountManagetImplTestBase { +public class AccountManagentImplTestBase { @Mock AccountDao _accountDao; @@ -99,7 +99,7 @@ public class AccountManagetImplTestBase { @Mock InstanceGroupDao _vmGroupDao; @Mock - UserAccountDao userAccountDaoMock; + UserAccountDao userAccountDao; @Mock VolumeDao _volumeDao; @Mock @@ -210,9 +210,6 @@ public class AccountManagetImplTestBase { @Mock RoutedIpv4Manager routedIpv4Manager; - @Mock - Account accountMock; - @Before public void setup() { accountManagerImpl.setUserAuthenticators(Arrays.asList(userAuthenticator)); @@ -228,7 +225,6 @@ public void cleanup() { @Test public void test() { - return; } public static Map getInheritedFields(Class type) { diff --git a/server/src/test/java/com/cloud/user/AccountManagerImplTest.java b/server/src/test/java/com/cloud/user/AccountManagerImplTest.java index 2aeb43469d19..6f5fbb0fdc12 100644 --- a/server/src/test/java/com/cloud/user/AccountManagerImplTest.java +++ b/server/src/test/java/com/cloud/user/AccountManagerImplTest.java @@ -47,13 +47,11 @@ import org.junit.Assert; import org.junit.Before; import org.junit.Test; -import org.junit.runner.RunWith; import org.mockito.ArgumentCaptor; import org.mockito.InOrder; import org.mockito.Mock; import org.mockito.MockedStatic; import org.mockito.Mockito; -import org.mockito.junit.MockitoJUnitRunner; import org.springframework.beans.factory.NoSuchBeanDefinitionException; import com.cloud.acl.DomainChecker; @@ -76,8 +74,7 @@ import com.cloud.vm.VMInstanceVO; import com.cloud.vm.snapshot.VMSnapshotVO; -@RunWith(MockitoJUnitRunner.class) -public class AccountManagerImplTest extends AccountManagetImplTestBase { +public class AccountManagerImplTest extends AccountManagentImplTestBase { @Mock private UserVmManagerImpl _vmMgr; @@ -100,11 +97,11 @@ public class AccountManagerImplTest extends AccountManagetImplTestBase { @Mock private UpdateAccountCmd UpdateAccountCmdMock; - private long userVoIdMock = 111l; + private final long userVoIdMock = 111L; @Mock private UserVO userVoMock; - private long accountMockId = 100l; + private final long accountMockId = 100L; @Mock private Account accountMock; @@ -154,7 +151,7 @@ public void beforeTest() { @Test public void disableAccountNotexisting() throws ConcurrentOperationException, ResourceUnavailableException { - Mockito.when(_accountDao.findById(42l)).thenReturn(null); + Mockito.when(_accountDao.findById(42L)).thenReturn(null); Assert.assertTrue(accountManagerImpl.disableAccount(42)); } @@ -162,7 +159,7 @@ public void disableAccountNotexisting() throws ConcurrentOperationException, Res public void disableAccountDisabled() throws ConcurrentOperationException, ResourceUnavailableException { AccountVO disabledAccount = new AccountVO(); disabledAccount.setState(State.DISABLED); - Mockito.when(_accountDao.findById(42l)).thenReturn(disabledAccount); + Mockito.when(_accountDao.findById(42L)).thenReturn(disabledAccount); Assert.assertTrue(accountManagerImpl.disableAccount(42)); } @@ -170,22 +167,22 @@ public void disableAccountDisabled() throws ConcurrentOperationException, Resour public void disableAccount() throws ConcurrentOperationException, ResourceUnavailableException { AccountVO account = new AccountVO(); account.setState(State.ENABLED); - Mockito.when(_accountDao.findById(42l)).thenReturn(account); + Mockito.when(_accountDao.findById(42L)).thenReturn(account); Mockito.when(_accountDao.createForUpdate()).thenReturn(new AccountVO()); - Mockito.when(_accountDao.update(Mockito.eq(42l), Mockito.any(AccountVO.class))).thenReturn(true); - Mockito.when(_vmDao.listByAccountId(42l)).thenReturn(Arrays.asList(Mockito.mock(VMInstanceVO.class))); + Mockito.when(_accountDao.update(Mockito.eq(42L), Mockito.any(AccountVO.class))).thenReturn(true); + Mockito.when(_vmDao.listByAccountId(42L)).thenReturn(Arrays.asList(Mockito.mock(VMInstanceVO.class))); Assert.assertTrue(accountManagerImpl.disableAccount(42)); - Mockito.verify(_accountDao, Mockito.atLeastOnce()).update(Mockito.eq(42l), Mockito.any(AccountVO.class)); + Mockito.verify(_accountDao, Mockito.atLeastOnce()).update(Mockito.eq(42L), Mockito.any(AccountVO.class)); } @Test public void deleteUserAccount() { AccountVO account = new AccountVO(); - account.setId(42l); + account.setId(42L); DomainVO domain = new DomainVO(); - Mockito.when(_accountDao.findById(42l)).thenReturn(account); + Mockito.when(_accountDao.findById(42L)).thenReturn(account); Mockito.doNothing().when(accountManagerImpl).checkAccess(Mockito.any(Account.class), Mockito.isNull(), Mockito.anyBoolean(), Mockito.any(Account.class)); - Mockito.when(_accountDao.remove(42l)).thenReturn(true); + Mockito.when(_accountDao.remove(42L)).thenReturn(true); Mockito.when(_configMgr.releaseAccountSpecificVirtualRanges(account)).thenReturn(true); Mockito.lenient().when(_domainMgr.getDomain(Mockito.anyLong())).thenReturn(domain); Mockito.lenient().when(securityChecker.checkAccess(Mockito.any(Account.class), Mockito.any(Domain.class))).thenReturn(true); @@ -194,7 +191,7 @@ public void deleteUserAccount() { List sshkeyList = new ArrayList(); SSHKeyPairVO sshkey = new SSHKeyPairVO(); - sshkey.setId(1l); + sshkey.setId(1L); sshkeyList.add(sshkey); Mockito.when(_sshKeyPairDao.listKeyPairs(Mockito.anyLong(), Mockito.anyLong())).thenReturn(sshkeyList); Mockito.when(_sshKeyPairDao.remove(Mockito.anyLong())).thenReturn(true); @@ -202,30 +199,30 @@ public void deleteUserAccount() { Mockito.doNothing().when(accountManagerImpl).deleteWebhooksForAccount(Mockito.anyLong()); Mockito.doNothing().when(accountManagerImpl).verifyCallerPrivilegeForUserOrAccountOperations((Account) any()); - Assert.assertTrue(accountManagerImpl.deleteUserAccount(42l)); + Assert.assertTrue(accountManagerImpl.deleteUserAccount(42L)); // assert that this was a clean delete - Mockito.verify(_accountDao, Mockito.never()).markForCleanup(Mockito.eq(42l)); + Mockito.verify(_accountDao, Mockito.never()).markForCleanup(Mockito.eq(42L)); } @Test public void deleteUserAccountCleanup() { AccountVO account = new AccountVO(); - account.setId(42l); + account.setId(42L); DomainVO domain = new DomainVO(); - Mockito.when(_accountDao.findById(42l)).thenReturn(account); + Mockito.when(_accountDao.findById(42L)).thenReturn(account); Mockito.doNothing().when(accountManagerImpl).checkAccess(Mockito.any(Account.class), Mockito.isNull(), Mockito.anyBoolean(), Mockito.any(Account.class)); - Mockito.when(_accountDao.remove(42l)).thenReturn(true); + Mockito.when(_accountDao.remove(42L)).thenReturn(true); Mockito.when(_configMgr.releaseAccountSpecificVirtualRanges(account)).thenReturn(true); - Mockito.when(_userVmDao.listByAccountId(42l)).thenReturn(Arrays.asList(Mockito.mock(UserVmVO.class))); + Mockito.when(_userVmDao.listByAccountId(42L)).thenReturn(Arrays.asList(Mockito.mock(UserVmVO.class))); Mockito.when(_vmMgr.expunge(Mockito.any(UserVmVO.class))).thenReturn(false); Mockito.lenient().when(_domainMgr.getDomain(Mockito.anyLong())).thenReturn(domain); Mockito.lenient().when(securityChecker.checkAccess(Mockito.any(Account.class), Mockito.any(Domain.class))).thenReturn(true); Mockito.doNothing().when(accountManagerImpl).deleteWebhooksForAccount(Mockito.anyLong()); Mockito.doNothing().when(accountManagerImpl).verifyCallerPrivilegeForUserOrAccountOperations((Account) any()); - Assert.assertTrue(accountManagerImpl.deleteUserAccount(42l)); + Assert.assertTrue(accountManagerImpl.deleteUserAccount(42L)); // assert that this was NOT a clean delete - Mockito.verify(_accountDao, Mockito.atLeastOnce()).markForCleanup(Mockito.eq(42l)); + Mockito.verify(_accountDao, Mockito.atLeastOnce()).markForCleanup(Mockito.eq(42L)); } @Test (expected = InvalidParameterValueException.class) @@ -308,7 +305,7 @@ public void testAuthenticateUser() throws UnknownHostException { UserAccountVO userAccountVO = new UserAccountVO(); userAccountVO.setSource(User.Source.UNKNOWN); userAccountVO.setState(Account.State.DISABLED.toString()); - Mockito.when(userAccountDaoMock.getUserAccount("test", 1L)).thenReturn(userAccountVO); + Mockito.when(userAccountDao.getUserAccount("test", 1L)).thenReturn(userAccountVO); Mockito.when(userAuthenticator.authenticate("test", "fail", 1L, new HashMap<>())).thenReturn(failureAuthenticationPair); Mockito.lenient().when(userAuthenticator.authenticate("test", null, 1L, new HashMap<>())).thenReturn(successAuthenticationPair); Mockito.lenient().when(userAuthenticator.authenticate("test", "", 1L, new HashMap<>())).thenReturn(successAuthenticationPair); @@ -337,7 +334,7 @@ public void testgetUserCmd() { CallContext.register(callingUser, callingAccount); // Calling account is user account i.e normal account Mockito.when(_listkeyscmd.getID()).thenReturn(1L); Mockito.when(accountManagerImpl.getActiveUser(1L)).thenReturn(userVoMock); - Mockito.when(userAccountDaoMock.findById(1L)).thenReturn(userAccountVO); + Mockito.when(userAccountDao.findById(1L)).thenReturn(userAccountVO); Mockito.when(userAccountVO.getAccountId()).thenReturn(1L); Mockito.lenient().when(accountManagerImpl.getAccount(Mockito.anyLong())).thenReturn(accountMock); // Queried account - admin account @@ -355,7 +352,7 @@ public void testGetUserKeysCmdDomainAdminRootAdminUser() { CallContext.register(callingUser, callingAccount); Mockito.when(_listkeyscmd.getID()).thenReturn(2L); Mockito.when(accountManagerImpl.getActiveUser(2L)).thenReturn(userVoMock); - Mockito.when(userAccountDaoMock.findById(2L)).thenReturn(userAccountVO); + Mockito.when(userAccountDao.findById(2L)).thenReturn(userAccountVO); Mockito.when(userAccountVO.getAccountId()).thenReturn(2L); Mockito.when(userDetailsDaoMock.listDetailsKeyPairs(Mockito.anyLong())).thenReturn(null); @@ -442,14 +439,14 @@ private void prepareMockAndExecuteUpdateUserTest(int numberOfExpectedCallsForSet Mockito.doNothing().when(accountManagerImpl).validateUserPasswordAndUpdateIfNeeded(Mockito.anyString(), Mockito.eq(userVoMock), Mockito.anyString(), Mockito.eq(false)); Mockito.doReturn(true).when(userDaoMock).update(Mockito.anyLong(), Mockito.eq(userVoMock)); - Mockito.doReturn(Mockito.mock(UserAccountVO.class)).when(userAccountDaoMock).findById(Mockito.anyLong()); + Mockito.doReturn(Mockito.mock(UserAccountVO.class)).when(userAccountDao).findById(Mockito.anyLong()); Mockito.doNothing().when(accountManagerImpl).checkAccess(nullable(User.class), nullable(Account.class)); accountManagerImpl.updateUser(UpdateUserCmdMock); Mockito.lenient().doNothing().when(accountManagerImpl).checkRoleEscalation(accountMock, accountMock); - InOrder inOrder = Mockito.inOrder(userVoMock, accountManagerImpl, userDaoMock, userAccountDaoMock); + InOrder inOrder = Mockito.inOrder(userVoMock, accountManagerImpl, userDaoMock, userAccountDao); inOrder.verify(accountManagerImpl).retrieveAndValidateUser(UpdateUserCmdMock); inOrder.verify(accountManagerImpl).retrieveAndValidateAccount(userVoMock); @@ -464,7 +461,7 @@ private void prepareMockAndExecuteUpdateUserTest(int numberOfExpectedCallsForSet inOrder.verify(userVoMock, Mockito.times(numberOfExpectedCallsForSetEmailAndSetTimeZone)).setTimezone(Mockito.anyString()); inOrder.verify(userDaoMock).update(Mockito.anyLong(), Mockito.eq(userVoMock)); - inOrder.verify(userAccountDaoMock).findById(Mockito.anyLong()); + inOrder.verify(userAccountDao).findById(Mockito.anyLong()); } @Test(expected = InvalidParameterValueException.class) @@ -487,7 +484,7 @@ public void retrieveAndValidateUserTestUserIsFound() { public void validateAndUpdatApiAndSecretKeyIfNeededTestNoKeys() { accountManagerImpl.validateAndUpdateApiAndSecretKeyIfNeeded(UpdateUserCmdMock, userVoMock); - Mockito.verify(_accountDao, Mockito.times(0)).findUserAccountByApiKey(Mockito.anyString()); + Mockito.verify(userAccountDao, Mockito.times(0)).getUserByApiKey(Mockito.anyString()); } @Test(expected = InvalidParameterValueException.class) @@ -513,10 +510,9 @@ public void validateAndUpdatApiAndSecretKeyIfNeededTestApiKeyAlreadyUsedBySomeon Mockito.doReturn(1L).when(userVoMock).getId(); User otherUserMock = Mockito.mock(User.class); - Mockito.doReturn(2L).when(otherUserMock).getId(); - Pair pairUserAccountMock = new Pair(otherUserMock, Mockito.mock(Account.class)); - Mockito.doReturn(pairUserAccountMock).when(_accountDao).findUserAccountByApiKey(apiKey); + UserAccount UserAccountMock = Mockito.mock(UserAccount.class); + Mockito.doReturn(UserAccountMock).when(userAccountDao).getUserByApiKey(apiKey); accountManagerImpl.validateAndUpdateApiAndSecretKeyIfNeeded(UpdateUserCmdMock, userVoMock); } @@ -529,17 +525,13 @@ public void validateAndUpdatApiAndSecretKeyIfNeededTest() { String secretKey = "secretKey"; Mockito.doReturn(secretKey).when(UpdateUserCmdMock).getSecretKey(); - Mockito.doReturn(1L).when(userVoMock).getId(); - User otherUserMock = Mockito.mock(User.class); - Mockito.doReturn(1L).when(otherUserMock).getId(); - Pair pairUserAccountMock = new Pair(otherUserMock, Mockito.mock(Account.class)); - Mockito.doReturn(pairUserAccountMock).when(_accountDao).findUserAccountByApiKey(apiKey); + Mockito.doReturn(null).when(userAccountDao).getUserByApiKey(apiKey); accountManagerImpl.validateAndUpdateApiAndSecretKeyIfNeeded(UpdateUserCmdMock, userVoMock); - Mockito.verify(_accountDao).findUserAccountByApiKey(apiKey); + Mockito.verify(userAccountDao).getUserByApiKey(apiKey); Mockito.verify(userVoMock).setApiKey(apiKey); Mockito.verify(userVoMock).setSecretKey(secretKey); } @@ -693,18 +685,18 @@ public void validateAndUpdateUsernameIfNeededTestBlankUsername() { @Test(expected = InvalidParameterValueException.class) public void validateAndUpdateUsernameIfNeededTestDuplicatedUserSameDomainThisUser() { - long domanIdCurrentUser = 22l; + long domanIdCurrentUser = 22L; String userName = "username"; Mockito.doReturn(userName).when(UpdateUserCmdMock).getUsername(); Mockito.lenient().doReturn(userName).when(userVoMock).getUsername(); Mockito.doReturn(domanIdCurrentUser).when(accountMock).getDomainId(); - long userVoDuplicatedMockId = 67l; + long userVoDuplicatedMockId = 67L; UserVO userVoDuplicatedMock = Mockito.mock(UserVO.class); Mockito.doReturn(userVoDuplicatedMockId).when(userVoDuplicatedMock).getId(); - long accountIdUserDuplicated = 98l; + long accountIdUserDuplicated = 98L; Mockito.doReturn(accountIdUserDuplicated).when(userVoDuplicatedMock).getAccountId(); @@ -728,24 +720,24 @@ public void validateAndUpdateUsernameIfNeededTestDuplicatedUserSameDomainThisUse @Test public void validateAndUpdateUsernameIfNeededTestDuplicatedUserButInDifferentDomains() { - long domanIdCurrentUser = 22l; + long domanIdCurrentUser = 22L; String userName = "username"; Mockito.doReturn(userName).when(UpdateUserCmdMock).getUsername(); Mockito.lenient().doReturn(userName).when(userVoMock).getUsername(); Mockito.doReturn(domanIdCurrentUser).when(accountMock).getDomainId(); - long userVoDuplicatedMockId = 67l; + long userVoDuplicatedMockId = 67L; UserVO userVoDuplicatedMock = Mockito.mock(UserVO.class); Mockito.lenient().doReturn(userName).when(userVoDuplicatedMock).getUsername(); Mockito.doReturn(userVoDuplicatedMockId).when(userVoDuplicatedMock).getId(); - long accountIdUserDuplicated = 98l; + long accountIdUserDuplicated = 98L; Mockito.doReturn(accountIdUserDuplicated).when(userVoDuplicatedMock).getAccountId(); Account accountUserDuplicatedMock = Mockito.mock(AccountVO.class); Mockito.lenient().doReturn(accountIdUserDuplicated).when(accountUserDuplicatedMock).getId(); - Mockito.doReturn(45l).when(accountUserDuplicatedMock).getDomainId(); + Mockito.doReturn(45L).when(accountUserDuplicatedMock).getDomainId(); List usersWithSameUserName = new ArrayList<>(); usersWithSameUserName.add(userVoMock); @@ -763,7 +755,7 @@ public void validateAndUpdateUsernameIfNeededTestDuplicatedUserButInDifferentDom @Test public void validateAndUpdateUsernameIfNeededTestNoDuplicatedUserNames() { - long domanIdCurrentUser = 22l; + long domanIdCurrentUser = 22L; String userName = "username"; Mockito.doReturn(userName).when(UpdateUserCmdMock).getUsername(); @@ -961,7 +953,7 @@ public void validateCurrentPasswordTestUserNotAuthenticatedWithProvidedCurrentPa @Test public void validateCurrentPasswordTestUserAuthenticatedWithProvidedCurrentPasswordViaFirstAuthenticator() { AccountVO accountVoMock = Mockito.mock(AccountVO.class); - long domainId = 14l; + long domainId = 14L; Mockito.doReturn(domainId).when(accountVoMock).getDomainId(); Mockito.doReturn(accountVoMock).when(_accountDao).findById(accountMockId); @@ -990,7 +982,7 @@ public void validateCurrentPasswordTestUserAuthenticatedWithProvidedCurrentPassw @Test public void validateCurrentPasswordTestUserAuthenticatedWithProvidedCurrentPasswordViaSecondAuthenticator() { AccountVO accountVoMock = Mockito.mock(AccountVO.class); - long domainId = 14l; + long domainId = 14L; Mockito.doReturn(domainId).when(accountVoMock).getDomainId(); Mockito.doReturn(accountVoMock).when(_accountDao).findById(accountMockId); @@ -1051,7 +1043,7 @@ public void testEnableUserTwoFactorAuthenticationWhenDomainlevelSettingisDisable UserAccountVO userAccount = Mockito.mock(UserAccountVO.class); UserVO userVO = Mockito.mock(UserVO.class); - Mockito.when(userAccountDaoMock.findById(userId)).thenReturn(userAccount); + Mockito.when(userAccountDao.findById(userId)).thenReturn(userAccount); Mockito.when(userDaoMock.findById(userId)).thenReturn(userVO); Mockito.when(userAccount.getDomainId()).thenReturn(1L); @@ -1070,7 +1062,7 @@ public void testEnableUserTwoFactorAuthenticationWhenProviderNameIsNullExpectedD UserAccountVO userAccount = Mockito.mock(UserAccountVO.class); UserVO userVO = Mockito.mock(UserVO.class); - Mockito.when(userAccountDaoMock.findById(userId)).thenReturn(userAccount); + Mockito.when(userAccountDao.findById(userId)).thenReturn(userAccount); Mockito.when(userDaoMock.findById(userId)).thenReturn(userVO); Mockito.when(userAccount.getDomainId()).thenReturn(1L); @@ -1099,7 +1091,7 @@ public void testEnableUserTwoFactorAuthentication() { UserAccountVO userAccount = Mockito.mock(UserAccountVO.class); UserVO userVO = Mockito.mock(UserVO.class); - Mockito.when(userAccountDaoMock.findById(userId)).thenReturn(userAccount); + Mockito.when(userAccountDao.findById(userId)).thenReturn(userAccount); Mockito.when(userDaoMock.findById(userId)).thenReturn(userVO); Mockito.when(userAccount.getDomainId()).thenReturn(1L); @@ -1205,7 +1197,7 @@ public void testEnable2FAcode() { Mockito.when(callingUser.getId()).thenReturn(1L); CallContext.register(callingUser, callingAccount); // Calling account is user account i.e normal account Mockito.lenient().when(_accountService.getActiveAccountById(1L)).thenReturn(accountMock); - Mockito.when(userAccountDaoMock.findById(1L)).thenReturn(userAccountVO); + Mockito.when(userAccountDao.findById(1L)).thenReturn(userAccountVO); Mockito.when(userDaoMock.findById(1L)).thenReturn(userVoMock); Mockito.when(userAccountVO.getDomainId()).thenReturn(1L); Mockito.when(enableUserTwoFactorAuthenticationMock.valueIn(1L)).thenReturn(true); @@ -1231,7 +1223,7 @@ public void testGetActiveUserAccountByEmail() { List userAccountVOList = new ArrayList<>(); UserAccountVO userAccountVO = new UserAccountVO(); userAccountVOList.add(userAccountVO); - Mockito.when(userAccountDaoMock.getUserAccountByEmail(email, domainId)).thenReturn(userAccountVOList); + Mockito.when(userAccountDao.getUserAccountByEmail(email, domainId)).thenReturn(userAccountVOList); List userAccounts = accountManagerImpl.getActiveUserAccountByEmail(email, domainId); Assert.assertEquals(userAccountVOList.size(), userAccounts.size()); Assert.assertEquals(userAccountVOList.get(0), userAccounts.get(0)); @@ -1406,7 +1398,7 @@ public void testClearUser2FA_When2FADisabled_NoChanges() { Mockito.when(user.getUser2faProvider()).thenReturn(null); UserAccount result = accountManagerImpl.clearUserTwoFactorAuthenticationInSetupStateOnLogin(user); Assert.assertSame(user, result); - Mockito.verifyNoInteractions(userDetailsDaoMock, userAccountDaoMock); + Mockito.verifyNoInteractions(userDetailsDaoMock, userAccountDao); } @Test @@ -1420,7 +1412,7 @@ public void testClearUser2FA_When2FAInVerifiedState_NoChanges() { UserAccount result = accountManagerImpl.clearUserTwoFactorAuthenticationInSetupStateOnLogin(user); Assert.assertSame(user, result); Mockito.verify(userDetailsDaoMock).findDetail(1L, UserDetailVO.Setup2FADetail); - Mockito.verifyNoMoreInteractions(userDetailsDaoMock, userAccountDaoMock); + Mockito.verifyNoMoreInteractions(userDetailsDaoMock, userAccountDao); } @Test @@ -1433,16 +1425,16 @@ public void testClearUser2FA_When2FAInSetupState_Disable2FA() { UserAccountVO userAccountVO = new UserAccountVO(); userAccountVO.setId(1L); Mockito.when(userDetailsDaoMock.findDetail(1L, UserDetailVO.Setup2FADetail)).thenReturn(userDetail); - Mockito.when(userAccountDaoMock.findById(1L)).thenReturn(userAccountVO); + Mockito.when(userAccountDao.findById(any())).thenReturn(userAccountVO); UserAccount result = accountManagerImpl.clearUserTwoFactorAuthenticationInSetupStateOnLogin(user); Assert.assertNotNull(result); Assert.assertFalse(result.isUser2faEnabled()); Assert.assertNull(result.getUser2faProvider()); Mockito.verify(userDetailsDaoMock).findDetail(1L, UserDetailVO.Setup2FADetail); Mockito.verify(userDetailsDaoMock).remove(Mockito.anyLong()); - Mockito.verify(userAccountDaoMock).findById(1L); + Mockito.verify(userAccountDao).findById(1L); ArgumentCaptor captor = ArgumentCaptor.forClass(UserAccountVO.class); - Mockito.verify(userAccountDaoMock).update(Mockito.eq(1L), captor.capture()); + Mockito.verify(userAccountDao).update(Mockito.eq(1L), captor.capture()); UserAccountVO updatedUser = captor.getValue(); Assert.assertFalse(updatedUser.isUser2faEnabled()); Assert.assertNull(updatedUser.getUser2faProvider()); diff --git a/server/src/test/java/com/cloud/user/AccountManagerImplVolumeDeleteEventTest.java b/server/src/test/java/com/cloud/user/AccountManagerImplVolumeDeleteEventTest.java index 6d69890c9a5d..3f13d9dd0247 100644 --- a/server/src/test/java/com/cloud/user/AccountManagerImplVolumeDeleteEventTest.java +++ b/server/src/test/java/com/cloud/user/AccountManagerImplVolumeDeleteEventTest.java @@ -63,7 +63,7 @@ import static org.mockito.Mockito.when; @RunWith(MockitoJUnitRunner.class) -public class AccountManagerImplVolumeDeleteEventTest extends AccountManagetImplTestBase { +public class AccountManagerImplVolumeDeleteEventTest extends AccountManagentImplTestBase { private static final Long ACCOUNT_ID = 1l; private static final String VOLUME_UUID = "vol-111111";