text: package org.jhipster.health.web.rest;
  
  import org.jhipster.health.TwentyOnePointsApp;
  import org.jhipster.health.domain.Authority;
  import org.jhipster.health.domain.User;
  import org.jhipster.health.repository.UserRepository;
  import org.jhipster.health.repository.search.UserSearchRepository;
  import org.jhipster.health.security.AuthoritiesConstants;
  import org.jhipster.health.service.MailService;
  import org.jhipster.health.service.UserService;
  import org.jhipster.health.service.dto.UserDTO;
  import org.jhipster.health.service.mapper.UserMapper;
  import org.jhipster.health.web.rest.errors.ExceptionTranslator;
  import org.jhipster.health.web.rest.vm.ManagedUserVM;
  import org.apache.commons.lang3.RandomStringUtils;
  import org.junit.Before;
  import org.junit.Test;
  import org.junit.runner.RunWith;
  import org.springframework.beans.factory.annotation.Autowired;
  import org.springframework.boot.test.context.SpringBootTest;
  import org.springframework.cache.CacheManager;
  import org.springframework.data.web.PageableHandlerMethodArgumentResolver;
  import org.springframework.http.MediaType;
  import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
  import org.springframework.test.context.junit4.SpringRunner;
  import org.springframework.test.web.servlet.MockMvc;
  import org.springframework.test.web.servlet.setup.MockMvcBuilders;
  import org.springframework.transaction.annotation.Transactional;
  
  import javax.persistence.EntityManager;
  import java.time.Instant;
  import java.util.*;
  
  import static org.assertj.core.api.Assertions.assertThat;
  import static org.hamcrest.Matchers.hasItems;
  import static org.hamcrest.Matchers.hasItem;
  import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
  import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;
  
  /**
   * Test class for the UserResource REST controller.
   *
   * @see UserResource
   */
  @RunWith(SpringRunner.class)
  @SpringBootTest(classes = TwentyOnePointsApp.class)
  public class UserResourceIntTest {
  
      private static final String DEFAULT_LOGIN = "johndoe";
      private static final String UPDATED_LOGIN = "jhipster";
  
      private static final Long DEFAULT_ID = 1L;
  
      private static final String DEFAULT_PASSWORD = "passjohndoe";
      private static final String UPDATED_PASSWORD = "passjhipster";
  
      private static final String DEFAULT_EMAIL = "johndoe@localhost";
      private static final String UPDATED_EMAIL = "jhipster@localhost";
  
      private static final String DEFAULT_FIRSTNAME = "john";
      private static final String UPDATED_FIRSTNAME = "jhipsterFirstName";
  
      private static final String DEFAULT_LASTNAME = "doe";
      private static final String UPDATED_LASTNAME = "jhipsterLastName";
  
      private static final String DEFAULT_IMAGEURL = "http://placehold.it/50x50";
      private static final String UPDATED_IMAGEURL = "http://placehold.it/40x40";
  
      private static final String DEFAULT_LANGKEY = "en";
      private static final String UPDATED_LANGKEY = "fr";
  
      @Autowired
      private UserRepository userRepository;
  
      /**
       * This repository is mocked in the org.jhipster.health.repository.search test package.
       *
       * @see org.jhipster.health.repository.search.UserSearchRepositoryMockConfiguration
       */
      @Autowired
      private UserSearchRepository mockUserSearchRepository;
  
      @Autowired
      private MailService mailService;
  
      @Autowired
      private UserService userService;
  
      @Autowired
      private UserMapper userMapper;
  
      @Autowired
      private MappingJackson2HttpMessageConverter jacksonMessageConverter;
  
      @Autowired
      private PageableHandlerMethodArgumentResolver pageableArgumentResolver;
  
      @Autowired
      private ExceptionTranslator exceptionTranslator;
  
      @Autowired
      private EntityManager em;
  
      @Autowired
      private CacheManager cacheManager;
  
      private MockMvc restUserMockMvc;
  
      private User user;
  
      @Before
      public void setup() {
          cacheManager.getCache(UserRepository.USERS_BY_LOGIN_CACHE).clear();
          cacheManager.getCache(UserRepository.USERS_BY_EMAIL_CACHE).clear();
          UserResource userResource = new UserResource(userService, userRepository, mailService, mockUserSearchRepository);
  
          this.restUserMockMvc = MockMvcBuilders.standaloneSetup(userResource)
              .setCustomArgumentResolvers(pageableArgumentResolver)
              .setControllerAdvice(exceptionTranslator)
              .setMessageConverters(jacksonMessageConverter)
              .build();
      }
  
      /**
       * Create a User.
       *
       * This is a static method, as tests for other entities might also need it,
       * if they test an entity which has a required relationship to the User entity.
       */
      public static User createEntity(EntityManager em) {
          User user = new User();
          user.setLogin(DEFAULT_LOGIN + RandomStringUtils.randomAlphabetic(5));
          user.setPassword(RandomStringUtils.random(60));
          user.setActivated(true);
          user.setEmail(RandomStringUtils.randomAlphabetic(5) + DEFAULT_EMAIL);
          user.setFirstName(DEFAULT_FIRSTNAME);
          user.setLastName(DEFAULT_LASTNAME);
          user.setImageUrl(DEFAULT_IMAGEURL);
          user.setLangKey(DEFAULT_LANGKEY);
          return user;
      }
  
      @Before
      public void initTest() {
          user = createEntity(em);
          user.setLogin(DEFAULT_LOGIN);
          user.setEmail(DEFAULT_EMAIL);
      }
  
      @Test
      @Transactional
      public void createUser() throws Exception {
          int databaseSizeBeforeCreate = userRepository.findAll().size();
  
          // Create the User
          ManagedUserVM managedUserVM = new ManagedUserVM();
          managedUserVM.setLogin(DEFAULT_LOGIN);
          managedUserVM.setPassword(DEFAULT_PASSWORD);
          managedUserVM.setFirstName(DEFAULT_FIRSTNAME);
          managedUserVM.setLastName(DEFAULT_LASTNAME);
          managedUserVM.setEmail(DEFAULT_EMAIL);
          managedUserVM.setActivated(true);
          managedUserVM.setImageUrl(DEFAULT_IMAGEURL);
          managedUserVM.setLangKey(DEFAULT_LANGKEY);
          managedUserVM.setAuthorities(Collections.singleton(AuthoritiesConstants.USER));
  
          restUserMockMvc.perform(post("/api/users")
              .contentType(TestUtil.APPLICATION_JSON_UTF8)
              .content(TestUtil.convertObjectToJsonBytes(managedUserVM)))
              .andExpect(status().isCreated());
  
          // Validate the User in the database
          List<User> userList = userRepository.findAll();
          assertThat(userList).hasSize(databaseSizeBeforeCreate + 1);
          User testUser = userList.get(userList.size() - 1);
          assertThat(testUser.getLogin()).isEqualTo(DEFAULT_LOGIN);
          assertThat(testUser.getFirstName()).isEqualTo(DEFAULT_FIRSTNAME);
          assertThat(testUser.getLastName()).isEqualTo(DEFAULT_LASTNAME);
          assertThat(testUser.getEmail()).isEqualTo(DEFAULT_EMAIL);
          assertThat(testUser.getImageUrl()).isEqualTo(DEFAULT_IMAGEURL);
          assertThat(testUser.getLangKey()).isEqualTo(DEFAULT_LANGKEY);
      }
  
      @Test
      @Transactional
      public void createUserWithExistingId() throws Exception {
          int databaseSizeBeforeCreate = userRepository.findAll().size();
  
          ManagedUserVM managedUserVM = new ManagedUserVM();
          managedUserVM.setId(1L);
          managedUserVM.setLogin(DEFAULT_LOGIN);
          managedUserVM.setPassword(DEFAULT_PASSWORD);
          managedUserVM.setFirstName(DEFAULT_FIRSTNAME);
          managedUserVM.setLastName(DEFAULT_LASTNAME);
          managedUserVM.setEmail(DEFAULT_EMAIL);
          managedUserVM.setActivated(true);
          managedUserVM.setImageUrl(DEFAULT_IMAGEURL);
          managedUserVM.setLangKey(DEFAULT_LANGKEY);
          managedUserVM.setAuthorities(Collections.singleton(AuthoritiesConstants.USER));
  
          // An entity with an existing ID cannot be created, so this API call must fail
          restUserMockMvc.perform(post("/api/users")
              .contentType(TestUtil.APPLICATION_JSON_UTF8)
              .content(TestUtil.convertObjectToJsonBytes(managedUserVM)))
              .andExpect(status().isBadRequest());
  
          // Validate the User in the database
          List<User> userList = userRepository.findAll();
          assertThat(userList).hasSize(databaseSizeBeforeCreate);
      }
  
      @Test
      @Transactional
      public void createUserWithExistingLogin() throws Exception {
          // Initialize the database
          userRepository.saveAndFlush(user);
          mockUserSearchRepository.save(user);
          int databaseSizeBeforeCreate = userRepository.findAll().size();
  
          ManagedUserVM managedUserVM = new ManagedUserVM();
          managedUserVM.setLogin(DEFAULT_LOGIN);// this login should already be used
          managedUserVM.setPassword(DEFAULT_PASSWORD);
          managedUserVM.setFirstName(DEFAULT_FIRSTNAME);
          managedUserVM.setLastName(DEFAULT_LASTNAME);
          managedUserVM.setEmail("anothermail@localhost");
          managedUserVM.setActivated(true);
          managedUserVM.setImageUrl(DEFAULT_IMAGEURL);
          managedUserVM.setLangKey(DEFAULT_LANGKEY);
          managedUserVM.setAuthorities(Collections.singleton(AuthoritiesConstants.USER));
  
          // Create the User
          restUserMockMvc.perform(post("/api/users")
              .contentType(TestUtil.APPLICATION_JSON_UTF8)
              .content(TestUtil.convertObjectToJsonBytes(managedUserVM)))
              .andExpect(status().isBadRequest());
  
          // Validate the User in the database
          List<User> userList = userRepository.findAll();
          assertThat(userList).hasSize(databaseSizeBeforeCreate);
      }
  
      @Test
      @Transactional
      public void createUserWithExistingEmail() throws Exception {
          // Initialize the database
          userRepository.saveAndFlush(user);
          mockUserSearchRepository.save(user);
          int databaseSizeBeforeCreate = userRepository.findAll().size();
  
          ManagedUserVM managedUserVM = new ManagedUserVM();
          managedUserVM.setLogin("anotherlogin");
          managedUserVM.setPassword(DEFAULT_PASSWORD);
          managedUserVM.setFirstName(DEFAULT_FIRSTNAME);
          managedUserVM.setLastName(DEFAULT_LASTNAME);
          managedUserVM.setEmail(DEFAULT_EMAIL);// this email should already be used
          managedUserVM.setActivated(true);
          managedUserVM.setImageUrl(DEFAULT_IMAGEURL);
          managedUserVM.setLangKey(DEFAULT_LANGKEY);
          managedUserVM.setAuthorities(Collections.singleton(AuthoritiesConstants.USER));
  
          // Create the User
          restUserMockMvc.perform(post("/api/users")
              .contentType(TestUtil.APPLICATION_JSON_UTF8)
              .content(TestUtil.convertObjectToJsonBytes(managedUserVM)))
              .andExpect(status().isBadRequest());
  
          // Validate the User in the database
          List<User> userList = userRepository.findAll();
          assertThat(userList).hasSize(databaseSizeBeforeCreate);
      }
  
      @Test
      @Transactional
      public void getAllUsers() throws Exception {
          // Initialize the database
          userRepository.saveAndFlush(user);
          mockUserSearchRepository.save(user);
  
          // Get all the users
          restUserMockMvc.perform(get("/api/users?sort=id,desc")
              .accept(MediaType.APPLICATION_JSON))
              .andExpect(status().isOk())
              .andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
              .andExpect(jsonPath("$.[*].login").value(hasItem(DEFAULT_LOGIN)))
              .andExpect(jsonPath("$.[*].firstName").value(hasItem(DEFAULT_FIRSTNAME)))
              .andExpect(jsonPath("$.[*].lastName").value(hasItem(DEFAULT_LASTNAME)))
              .andExpect(jsonPath("$.[*].email").value(hasItem(DEFAULT_EMAIL)))
              .andExpect(jsonPath("$.[*].imageUrl").value(hasItem(DEFAULT_IMAGEURL)))
              .andExpect(jsonPath("$.[*].langKey").value(hasItem(DEFAULT_LANGKEY)));
      }
  
      @Test
      @Transactional
      public void getUser() throws Exception {
          // Initialize the database
          userRepository.saveAndFlush(user);
          mockUserSearchRepository.save(user);
  
          assertThat(cacheManager.getCache(UserRepository.USERS_BY_LOGIN_CACHE).get(user.getLogin())).isNull();
  
          // Get the user
          restUserMockMvc.perform(get("/api/users/{login}", user.getLogin()))
              .andExpect(status().isOk())
              .andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
              .andExpect(jsonPath("$.login").value(user.getLogin()))
              .andExpect(jsonPath("$.firstName").value(DEFAULT_FIRSTNAME))
              .andExpect(jsonPath("$.lastName").value(DEFAULT_LASTNAME))
              .andExpect(jsonPath("$.email").value(DEFAULT_EMAIL))
              .andExpect(jsonPath("$.imageUrl").value(DEFAULT_IMAGEURL))
              .andExpect(jsonPath("$.langKey").value(DEFAULT_LANGKEY));
  
          assertThat(cacheManager.getCache(UserRepository.USERS_BY_LOGIN_CACHE).get(user.getLogin())).isNotNull();
      }
  
      @Test
      @Transactional
      public void getNonExistingUser() throws Exception {
          restUserMockMvc.perform(get("/api/users/unknown"))
              .andExpect(status().isNotFound());
      }
  
      @Test
      @Transactional
      public void updateUser() throws Exception {
          // Initialize the database
          userRepository.saveAndFlush(user);
          mockUserSearchRepository.save(user);
          int databaseSizeBeforeUpdate = userRepository.findAll().size();
  
          // Update the user
          User updatedUser = userRepository.findById(user.getId()).get();
  
          ManagedUserVM managedUserVM = new ManagedUserVM();
          managedUserVM.setId(updatedUser.getId());
          managedUserVM.setLogin(updatedUser.getLogin());
          managedUserVM.setPassword(UPDATED_PASSWORD);
          managedUserVM.setFirstName(UPDATED_FIRSTNAME);
          managedUserVM.setLastName(UPDATED_LASTNAME);
          managedUserVM.setEmail(UPDATED_EMAIL);
          managedUserVM.setActivated(updatedUser.getActivated());
          managedUserVM.setImageUrl(UPDATED_IMAGEURL);
          managedUserVM.setLangKey(UPDATED_LANGKEY);
          managedUserVM.setCreatedBy(updatedUser.getCreatedBy());
          managedUserVM.setCreatedDate(updatedUser.getCreatedDate());
          managedUserVM.setLastModifiedBy(updatedUser.getLastModifiedBy());
          managedUserVM.setLastModifiedDate(updatedUser.getLastModifiedDate());
          managedUserVM.setAuthorities(Collections.singleton(AuthoritiesConstants.USER));
  
          restUserMockMvc.perform(put("/api/users")
              .contentType(TestUtil.APPLICATION_JSON_UTF8)
              .content(TestUtil.convertObjectToJsonBytes(managedUserVM)))
              .andExpect(status().isOk());
  
          // Validate the User in the database
          List<User> userList = userRepository.findAll();
          assertThat(userList).hasSize(databaseSizeBeforeUpdate);
          User testUser = userList.get(userList.size() - 1);
          assertThat(testUser.getFirstName()).isEqualTo(UPDATED_FIRSTNAME);
          assertThat(testUser.getLastName()).isEqualTo(UPDATED_LASTNAME);
          assertThat(testUser.getEmail()).isEqualTo(UPDATED_EMAIL);
          assertThat(testUser.getImageUrl()).isEqualTo(UPDATED_IMAGEURL);
          assertThat(testUser.getLangKey()).isEqualTo(UPDATED_LANGKEY);
      }
  
      @Test
      @Transactional
      public void updateUserLogin() throws Exception {
          // Initialize the database
          userRepository.saveAndFlush(user);
          mockUserSearchRepository.save(user);
          int databaseSizeBeforeUpdate = userRepository.findAll().size();
  
          // Update the user
          User updatedUser = userRepository.findById(user.getId()).get();
  
          ManagedUserVM managedUserVM = new ManagedUserVM();
          managedUserVM.setId(updatedUser.getId());
          managedUserVM.setLogin(UPDATED_LOGIN);
          managedUserVM.setPassword(UPDATED_PASSWORD);
          managedUserVM.setFirstName(UPDATED_FIRSTNAME);
          managedUserVM.setLastName(UPDATED_LASTNAME);
          managedUserVM.setEmail(UPDATED_EMAIL);
          managedUserVM.setActivated(updatedUser.getActivated());
          managedUserVM.setImageUrl(UPDATED_IMAGEURL);
          managedUserVM.setLangKey(UPDATED_LANGKEY);
          managedUserVM.setCreatedBy(updatedUser.getCreatedBy());
          managedUserVM.setCreatedDate(updatedUser.getCreatedDate());
          managedUserVM.setLastModifiedBy(updatedUser.getLastModifiedBy());
          managedUserVM.setLastModifiedDate(updatedUser.getLastModifiedDate());
          managedUserVM.setAuthorities(Collections.singleton(AuthoritiesConstants.USER));
  
          restUserMockMvc.perform(put("/api/users")
              .contentType(TestUtil.APPLICATION_JSON_UTF8)
              .content(TestUtil.convertObjectToJsonBytes(managedUserVM)))
              .andExpect(status().isOk());
  
          // Validate the User in the database
          List<User> userList = userRepository.findAll();
          assertThat(userList).hasSize(databaseSizeBeforeUpdate);
          User testUser = userList.get(userList.size() - 1);
          assertThat(testUser.getLogin()).isEqualTo(UPDATED_LOGIN);
          assertThat(testUser.getFirstName()).isEqualTo(UPDATED_FIRSTNAME);
          assertThat(testUser.getLastName()).isEqualTo(UPDATED_LASTNAME);
          assertThat(testUser.getEmail()).isEqualTo(UPDATED_EMAIL);
          assertThat(testUser.getImageUrl()).isEqualTo(UPDATED_IMAGEURL);
          assertThat(testUser.getLangKey()).isEqualTo(UPDATED_LANGKEY);
      }
  
      @Test
      @Transactional
      public void updateUserExistingEmail() throws Exception {
          // Initialize the database with 2 users
          userRepository.saveAndFlush(user);
          mockUserSearchRepository.save(user);
  
          User anotherUser = new User();
          anotherUser.setLogin("jhipster");
          anotherUser.setPassword(RandomStringUtils.random(60));
          anotherUser.setActivated(true);
          anotherUser.setEmail("jhipster@localhost");
          anotherUser.setFirstName("java");
          anotherUser.setLastName("hipster");
          anotherUser.setImageUrl("");
          anotherUser.setLangKey("en");
          userRepository.saveAndFlush(anotherUser);
          mockUserSearchRepository.save(anotherUser);
  
          // Update the user
          User updatedUser = userRepository.findById(user.getId()).get();
  
          ManagedUserVM managedUserVM = new ManagedUserVM();
          managedUserVM.setId(updatedUser.getId());
          managedUserVM.setLogin(updatedUser.getLogin());
          managedUserVM.setPassword(updatedUser.getPassword());
          managedUserVM.setFirstName(updatedUser.getFirstName());
          managedUserVM.setLastName(updatedUser.getLastName());
          managedUserVM.setEmail("jhipster@localhost");// this email should already be used by anotherUser
          managedUserVM.setActivated(updatedUser.getActivated());
          managedUserVM.setImageUrl(updatedUser.getImageUrl());
          managedUserVM.setLangKey(updatedUser.getLangKey());
          managedUserVM.setCreatedBy(updatedUser.getCreatedBy());
          managedUserVM.setCreatedDate(updatedUser.getCreatedDate());
          managedUserVM.setLastModifiedBy(updatedUser.getLastModifiedBy());
          managedUserVM.setLastModifiedDate(updatedUser.getLastModifiedDate());
          managedUserVM.setAuthorities(Collections.singleton(AuthoritiesConstants.USER));
  
          restUserMockMvc.perform(put("/api/users")
              .contentType(TestUtil.APPLICATION_JSON_UTF8)
              .content(TestUtil.convertObjectToJsonBytes(managedUserVM)))
              .andExpect(status().isBadRequest());
      }
  
      @Test
      @Transactional
      public void updateUserExistingLogin() throws Exception {
          // Initialize the database
          userRepository.saveAndFlush(user);
          mockUserSearchRepository.save(user);
  
          User anotherUser = new User();
          anotherUser.setLogin("jhipster");
          anotherUser.setPassword(RandomStringUtils.random(60));
          anotherUser.setActivated(true);
          anotherUser.setEmail("jhipster@localhost");
          anotherUser.setFirstName("java");
          anotherUser.setLastName("hipster");
          anotherUser.setImageUrl("");
          anotherUser.setLangKey("en");
          userRepository.saveAndFlush(anotherUser);
          mockUserSearchRepository.save(anotherUser);
  
          // Update the user
          User updatedUser = userRepository.findById(user.getId()).get();
  
          ManagedUserVM managedUserVM = new ManagedUserVM();
          managedUserVM.setId(updatedUser.getId());
          managedUserVM.setLogin("jhipster");// this login should already be used by anotherUser
          managedUserVM.setPassword(updatedUser.getPassword());
          managedUserVM.setFirstName(updatedUser.getFirstName());
          managedUserVM.setLastName(updatedUser.getLastName());
          managedUserVM.setEmail(updatedUser.getEmail());
          managedUserVM.setActivated(updatedUser.getActivated());
          managedUserVM.setImageUrl(updatedUser.getImageUrl());
          managedUserVM.setLangKey(updatedUser.getLangKey());
          managedUserVM.setCreatedBy(updatedUser.getCreatedBy());
          managedUserVM.setCreatedDate(updatedUser.getCreatedDate());
          managedUserVM.setLastModifiedBy(updatedUser.getLastModifiedBy());
          managedUserVM.setLastModifiedDate(updatedUser.getLastModifiedDate());
          managedUserVM.setAuthorities(Collections.singleton(AuthoritiesConstants.USER));
  
          restUserMockMvc.perform(put("/api/users")
              .contentType(TestUtil.APPLICATION_JSON_UTF8)
              .content(TestUtil.convertObjectToJsonBytes(managedUserVM)))
              .andExpect(status().isBadRequest());
      }
  
      @Test
      @Transactional
      public void deleteUser() throws Exception {
          // Initialize the database
          userRepository.saveAndFlush(user);
          mockUserSearchRepository.save(user);
          int databaseSizeBeforeDelete = userRepository.findAll().size();
  
          // Delete the user
          restUserMockMvc.perform(delete("/api/users/{login}", user.getLogin())
              .accept(TestUtil.APPLICATION_JSON_UTF8))
              .andExpect(status().isOk());
  
          assertThat(cacheManager.getCache(UserRepository.USERS_BY_LOGIN_CACHE).get(user.getLogin())).isNull();
  
          // Validate the database is empty
          List<User> userList = userRepository.findAll();
          assertThat(userList).hasSize(databaseSizeBeforeDelete - 1);
      }
  
      @Test
      @Transactional
      public void getAllAuthorities() throws Exception {
          restUserMockMvc.perform(get("/api/users/authorities")
              .accept(TestUtil.APPLICATION_JSON_UTF8)
              .contentType(TestUtil.APPLICATION_JSON_UTF8))
              .andExpect(status().isOk())
              .andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
              .andExpect(jsonPath("$").isArray())
              .andExpect(jsonPath("$").value(hasItems(AuthoritiesConstants.USER, AuthoritiesConstants.ADMIN)));
      }
  
      @Test
      @Transactional
      public void testUserEquals() throws Exception {
          TestUtil.equalsVerifier(User.class);
          User user1 = new User();
          user1.setId(1L);
          User user2 = new User();
          user2.setId(user1.getId());
          assertThat(user1).isEqualTo(user2);
          user2.setId(2L);
          assertThat(user1).isNotEqualTo(user2);
          user1.setId(null);
          assertThat(user1).isNotEqualTo(user2);
      }
  
      @Test
      public void testUserFromId() {
          assertThat(userMapper.userFromId(DEFAULT_ID).getId()).isEqualTo(DEFAULT_ID);
          assertThat(userMapper.userFromId(null)).isNull();
      }
  
      @Test
      public void testUserDTOtoUser() {
          UserDTO userDTO = new UserDTO();
          userDTO.setId(DEFAULT_ID);
          userDTO.setLogin(DEFAULT_LOGIN);
          userDTO.setFirstName(DEFAULT_FIRSTNAME);
          userDTO.setLastName(DEFAULT_LASTNAME);
          userDTO.setEmail(DEFAULT_EMAIL);
          userDTO.setActivated(true);
          userDTO.setImageUrl(DEFAULT_IMAGEURL);
          userDTO.setLangKey(DEFAULT_LANGKEY);
          userDTO.setCreatedBy(DEFAULT_LOGIN);
          userDTO.setLastModifiedBy(DEFAULT_LOGIN);
          userDTO.setAuthorities(Collections.singleton(AuthoritiesConstants.USER));
  
          User user = userMapper.userDTOToUser(userDTO);
          assertThat(user.getId()).isEqualTo(DEFAULT_ID);
          assertThat(user.getLogin()).isEqualTo(DEFAULT_LOGIN);
          assertThat(user.getFirstName()).isEqualTo(DEFAULT_FIRSTNAME);
          assertThat(user.getLastName()).isEqualTo(DEFAULT_LASTNAME);
          assertThat(user.getEmail()).isEqualTo(DEFAULT_EMAIL);
          assertThat(user.getActivated()).isEqualTo(true);
          assertThat(user.getImageUrl()).isEqualTo(DEFAULT_IMAGEURL);
          assertThat(user.getLangKey()).isEqualTo(DEFAULT_LANGKEY);
          assertThat(user.getCreatedBy()).isNull();
          assertThat(user.getCreatedDate()).isNotNull();
          assertThat(user.getLastModifiedBy()).isNull();
          assertThat(user.getLastModifiedDate()).isNotNull();
          assertThat(user.getAuthorities()).extracting("name").containsExactly(AuthoritiesConstants.USER);
      }
  
      @Test
      public void testUserToUserDTO() {
          user.setId(DEFAULT_ID);
          user.setCreatedBy(DEFAULT_LOGIN);
          user.setCreatedDate(Instant.now());
          user.setLastModifiedBy(DEFAULT_LOGIN);
          user.setLastModifiedDate(Instant.now());
          Set<Authority> authorities = new HashSet<>();
          Authority authority = new Authority();
          authority.setName(AuthoritiesConstants.USER);
          authorities.add(authority);
          user.setAuthorities(authorities);
  
          UserDTO userDTO = userMapper.userToUserDTO(user);
  
          assertThat(userDTO.getId()).isEqualTo(DEFAULT_ID);
          assertThat(userDTO.getLogin()).isEqualTo(DEFAULT_LOGIN);
          assertThat(userDTO.getFirstName()).isEqualTo(DEFAULT_FIRSTNAME);
          assertThat(userDTO.getLastName()).isEqualTo(DEFAULT_LASTNAME);
          assertThat(userDTO.getEmail()).isEqualTo(DEFAULT_EMAIL);
          assertThat(userDTO.isActivated()).isEqualTo(true);
          assertThat(userDTO.getImageUrl()).isEqualTo(DEFAULT_IMAGEURL);
          assertThat(userDTO.getLangKey()).isEqualTo(DEFAULT_LANGKEY);
          assertThat(userDTO.getCreatedBy()).isEqualTo(DEFAULT_LOGIN);
          assertThat(userDTO.getCreatedDate()).isEqualTo(user.getCreatedDate());
          assertThat(userDTO.getLastModifiedBy()).isEqualTo(DEFAULT_LOGIN);
          assertThat(userDTO.getLastModifiedDate()).isEqualTo(user.getLastModifiedDate());
          assertThat(userDTO.getAuthorities()).containsExactly(AuthoritiesConstants.USER);
          assertThat(userDTO.toString()).isNotNull();
      }
  
      @Test
      public void testAuthorityEquals() {
          Authority authorityA = new Authority();
          assertThat(authorityA).isEqualTo(authorityA);
          assertThat(authorityA).isNotEqualTo(null);
          assertThat(authorityA).isNotEqualTo(new Object());
          assertThat(authorityA.hashCode()).isEqualTo(0);
          assertThat(authorityA.toString()).isNotNull();
  
          Authority authorityB = new Authority();
          assertThat(authorityA).isEqualTo(authorityB);
  
          authorityB.setName(AuthoritiesConstants.ADMIN);
          assertThat(authorityA).isNotEqualTo(authorityB);
  
          authorityA.setName(AuthoritiesConstants.USER);
          assertThat(authorityA).isNotEqualTo(authorityB);
  
          authorityB.setName(AuthoritiesConstants.USER);
          assertThat(authorityA).isEqualTo(authorityB);
          assertThat(authorityA.hashCode()).isEqualTo(authorityB.hashCode());
      }
  }
  