More fixes on removing unneccessary ids

src/test/java/rocks/zipcode/io/web/rest/CohortResourceIntTest.java

 @SpringBootTest(classes = ZipConnectApp.class)
 public class CohortResourceIntTest {
 
-    private static final Double DEFAULT_COHORT_ID = 1D;
-    private static final Double UPDATED_COHORT_ID = 2D;
-
     private static final String DEFAULT_GRAD_DATE = "AAAAAAAAAA";
     private static final String UPDATED_GRAD_DATE = "BBBBBBBBBB";
 
      */
     public static Cohort createEntity(EntityManager em) {
         Cohort cohort = new Cohort()
-            .cohortId(DEFAULT_COHORT_ID)
             .gradDate(DEFAULT_GRAD_DATE);
         return cohort;
     }
         List<Cohort> cohortList = cohortRepository.findAll();
         assertThat(cohortList).hasSize(databaseSizeBeforeCreate + 1);
         Cohort testCohort = cohortList.get(cohortList.size() - 1);
-        assertThat(testCohort.getCohortId()).isEqualTo(DEFAULT_COHORT_ID);
         assertThat(testCohort.getGradDate()).isEqualTo(DEFAULT_GRAD_DATE);
     }
 
             .andExpect(status().isOk())
             .andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
             .andExpect(jsonPath("$.[*].id").value(hasItem(cohort.getId().intValue())))
-            .andExpect(jsonPath("$.[*].cohortId").value(hasItem(DEFAULT_COHORT_ID.doubleValue())))
             .andExpect(jsonPath("$.[*].gradDate").value(hasItem(DEFAULT_GRAD_DATE.toString())));
     }
     
             .andExpect(status().isOk())
             .andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
             .andExpect(jsonPath("$.id").value(cohort.getId().intValue()))
-            .andExpect(jsonPath("$.cohortId").value(DEFAULT_COHORT_ID.doubleValue()))
             .andExpect(jsonPath("$.gradDate").value(DEFAULT_GRAD_DATE.toString()));
     }
 
         // Disconnect from session so that the updates on updatedCohort are not directly saved in db
         em.detach(updatedCohort);
         updatedCohort
-            .cohortId(UPDATED_COHORT_ID)
             .gradDate(UPDATED_GRAD_DATE);
 
         restCohortMockMvc.perform(put("/api/cohorts")
         List<Cohort> cohortList = cohortRepository.findAll();
         assertThat(cohortList).hasSize(databaseSizeBeforeUpdate);
         Cohort testCohort = cohortList.get(cohortList.size() - 1);
-        assertThat(testCohort.getCohortId()).isEqualTo(UPDATED_COHORT_ID);
         assertThat(testCohort.getGradDate()).isEqualTo(UPDATED_GRAD_DATE);
     }
 

src/test/java/rocks/zipcode/io/web/rest/EmployerResourceIntTest.java

 @SpringBootTest(classes = ZipConnectApp.class)
 public class EmployerResourceIntTest {
 
-    private static final Long DEFAULT_EMPLOYER_ID = 1L;
-    private static final Long UPDATED_EMPLOYER_ID = 2L;
-
     private static final String DEFAULT_COMPANY_NAME = "AAAAAAAAAA";
     private static final String UPDATED_COMPANY_NAME = "BBBBBBBBBB";
 
      */
     public static Employer createEntity(EntityManager em) {
         Employer employer = new Employer()
-            .employerId(DEFAULT_EMPLOYER_ID)
             .companyName(DEFAULT_COMPANY_NAME)
             .city(DEFAULT_CITY)
             .state(DEFAULT_STATE);
         List<Employer> employerList = employerRepository.findAll();
         assertThat(employerList).hasSize(databaseSizeBeforeCreate + 1);
         Employer testEmployer = employerList.get(employerList.size() - 1);
-        assertThat(testEmployer.getEmployerId()).isEqualTo(DEFAULT_EMPLOYER_ID);
         assertThat(testEmployer.getCompanyName()).isEqualTo(DEFAULT_COMPANY_NAME);
         assertThat(testEmployer.getCity()).isEqualTo(DEFAULT_CITY);
         assertThat(testEmployer.getState()).isEqualTo(DEFAULT_STATE);
             .andExpect(status().isOk())
             .andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
             .andExpect(jsonPath("$.[*].id").value(hasItem(employer.getId().intValue())))
-            .andExpect(jsonPath("$.[*].employerId").value(hasItem(DEFAULT_EMPLOYER_ID.intValue())))
             .andExpect(jsonPath("$.[*].companyName").value(hasItem(DEFAULT_COMPANY_NAME.toString())))
             .andExpect(jsonPath("$.[*].city").value(hasItem(DEFAULT_CITY.toString())))
             .andExpect(jsonPath("$.[*].state").value(hasItem(DEFAULT_STATE.toString())));
             .andExpect(status().isOk())
             .andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
             .andExpect(jsonPath("$.id").value(employer.getId().intValue()))
-            .andExpect(jsonPath("$.employerId").value(DEFAULT_EMPLOYER_ID.intValue()))
             .andExpect(jsonPath("$.companyName").value(DEFAULT_COMPANY_NAME.toString()))
             .andExpect(jsonPath("$.city").value(DEFAULT_CITY.toString()))
             .andExpect(jsonPath("$.state").value(DEFAULT_STATE.toString()));
         // Disconnect from session so that the updates on updatedEmployer are not directly saved in db
         em.detach(updatedEmployer);
         updatedEmployer
-            .employerId(UPDATED_EMPLOYER_ID)
             .companyName(UPDATED_COMPANY_NAME)
             .city(UPDATED_CITY)
             .state(UPDATED_STATE);
         List<Employer> employerList = employerRepository.findAll();
         assertThat(employerList).hasSize(databaseSizeBeforeUpdate);
         Employer testEmployer = employerList.get(employerList.size() - 1);
-        assertThat(testEmployer.getEmployerId()).isEqualTo(UPDATED_EMPLOYER_ID);
         assertThat(testEmployer.getCompanyName()).isEqualTo(UPDATED_COMPANY_NAME);
         assertThat(testEmployer.getCity()).isEqualTo(UPDATED_CITY);
         assertThat(testEmployer.getState()).isEqualTo(UPDATED_STATE);

src/test/java/rocks/zipcode/io/web/rest/PostResourceIntTest.java

 @SpringBootTest(classes = ZipConnectApp.class)
 public class PostResourceIntTest {
 
-    private static final Long DEFAULT_POST_ID = 1L;
-    private static final Long UPDATED_POST_ID = 2L;
-
     private static final LocalDate DEFAULT_TIMESTAMP = LocalDate.ofEpochDay(0L);
     private static final LocalDate UPDATED_TIMESTAMP = LocalDate.now(ZoneId.systemDefault());
 
      */
     public static Post createEntity(EntityManager em) {
         Post post = new Post()
-            .postId(DEFAULT_POST_ID)
             .timestamp(DEFAULT_TIMESTAMP)
             .content(DEFAULT_CONTENT)
             .likes(DEFAULT_LIKES);
         List<Post> postList = postRepository.findAll();
         assertThat(postList).hasSize(databaseSizeBeforeCreate + 1);
         Post testPost = postList.get(postList.size() - 1);
-        assertThat(testPost.getPostId()).isEqualTo(DEFAULT_POST_ID);
         assertThat(testPost.getTimestamp()).isEqualTo(DEFAULT_TIMESTAMP);
         assertThat(testPost.getContent()).isEqualTo(DEFAULT_CONTENT);
         assertThat(testPost.getLikes()).isEqualTo(DEFAULT_LIKES);
             .andExpect(status().isOk())
             .andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
             .andExpect(jsonPath("$.[*].id").value(hasItem(post.getId().intValue())))
-            .andExpect(jsonPath("$.[*].postId").value(hasItem(DEFAULT_POST_ID.intValue())))
             .andExpect(jsonPath("$.[*].timestamp").value(hasItem(DEFAULT_TIMESTAMP.toString())))
             .andExpect(jsonPath("$.[*].content").value(hasItem(DEFAULT_CONTENT.toString())))
             .andExpect(jsonPath("$.[*].likes").value(hasItem(DEFAULT_LIKES.toString())));
             .andExpect(status().isOk())
             .andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
             .andExpect(jsonPath("$.id").value(post.getId().intValue()))
-            .andExpect(jsonPath("$.postId").value(DEFAULT_POST_ID.intValue()))
             .andExpect(jsonPath("$.timestamp").value(DEFAULT_TIMESTAMP.toString()))
             .andExpect(jsonPath("$.content").value(DEFAULT_CONTENT.toString()))
             .andExpect(jsonPath("$.likes").value(DEFAULT_LIKES.toString()));
         // Disconnect from session so that the updates on updatedPost are not directly saved in db
         em.detach(updatedPost);
         updatedPost
-            .postId(UPDATED_POST_ID)
             .timestamp(UPDATED_TIMESTAMP)
             .content(UPDATED_CONTENT)
             .likes(UPDATED_LIKES);
         List<Post> postList = postRepository.findAll();
         assertThat(postList).hasSize(databaseSizeBeforeUpdate);
         Post testPost = postList.get(postList.size() - 1);
-        assertThat(testPost.getPostId()).isEqualTo(UPDATED_POST_ID);
         assertThat(testPost.getTimestamp()).isEqualTo(UPDATED_TIMESTAMP);
         assertThat(testPost.getContent()).isEqualTo(UPDATED_CONTENT);
         assertThat(testPost.getLikes()).isEqualTo(UPDATED_LIKES);

src/test/java/rocks/zipcode/io/web/rest/PrivacyResourceIntTest.java

 @SpringBootTest(classes = ZipConnectApp.class)
 public class PrivacyResourceIntTest {
 
-    private static final Long DEFAULT_PRIVACY_ID = 1L;
-    private static final Long UPDATED_PRIVACY_ID = 2L;
-
     private static final Boolean DEFAULT_PUBLIC_VIEW = false;
     private static final Boolean UPDATED_PUBLIC_VIEW = true;
 
      */
     public static Privacy createEntity(EntityManager em) {
         Privacy privacy = new Privacy()
-            .privacyId(DEFAULT_PRIVACY_ID)
             .publicView(DEFAULT_PUBLIC_VIEW)
             .cohortView(DEFAULT_COHORT_VIEW)
             .employerView(DEFAULT_EMPLOYER_VIEW);
         List<Privacy> privacyList = privacyRepository.findAll();
         assertThat(privacyList).hasSize(databaseSizeBeforeCreate + 1);
         Privacy testPrivacy = privacyList.get(privacyList.size() - 1);
-        assertThat(testPrivacy.getPrivacyId()).isEqualTo(DEFAULT_PRIVACY_ID);
         assertThat(testPrivacy.isPublicView()).isEqualTo(DEFAULT_PUBLIC_VIEW);
         assertThat(testPrivacy.isCohortView()).isEqualTo(DEFAULT_COHORT_VIEW);
         assertThat(testPrivacy.isEmployerView()).isEqualTo(DEFAULT_EMPLOYER_VIEW);
             .andExpect(status().isOk())
             .andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
             .andExpect(jsonPath("$.[*].id").value(hasItem(privacy.getId().intValue())))
-            .andExpect(jsonPath("$.[*].privacyId").value(hasItem(DEFAULT_PRIVACY_ID.intValue())))
             .andExpect(jsonPath("$.[*].publicView").value(hasItem(DEFAULT_PUBLIC_VIEW.booleanValue())))
             .andExpect(jsonPath("$.[*].cohortView").value(hasItem(DEFAULT_COHORT_VIEW.booleanValue())))
             .andExpect(jsonPath("$.[*].employerView").value(hasItem(DEFAULT_EMPLOYER_VIEW.booleanValue())));
             .andExpect(status().isOk())
             .andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
             .andExpect(jsonPath("$.id").value(privacy.getId().intValue()))
-            .andExpect(jsonPath("$.privacyId").value(DEFAULT_PRIVACY_ID.intValue()))
             .andExpect(jsonPath("$.publicView").value(DEFAULT_PUBLIC_VIEW.booleanValue()))
             .andExpect(jsonPath("$.cohortView").value(DEFAULT_COHORT_VIEW.booleanValue()))
             .andExpect(jsonPath("$.employerView").value(DEFAULT_EMPLOYER_VIEW.booleanValue()));
         // Disconnect from session so that the updates on updatedPrivacy are not directly saved in db
         em.detach(updatedPrivacy);
         updatedPrivacy
-            .privacyId(UPDATED_PRIVACY_ID)
             .publicView(UPDATED_PUBLIC_VIEW)
             .cohortView(UPDATED_COHORT_VIEW)
             .employerView(UPDATED_EMPLOYER_VIEW);
         List<Privacy> privacyList = privacyRepository.findAll();
         assertThat(privacyList).hasSize(databaseSizeBeforeUpdate);
         Privacy testPrivacy = privacyList.get(privacyList.size() - 1);
-        assertThat(testPrivacy.getPrivacyId()).isEqualTo(UPDATED_PRIVACY_ID);
         assertThat(testPrivacy.isPublicView()).isEqualTo(UPDATED_PUBLIC_VIEW);
         assertThat(testPrivacy.isCohortView()).isEqualTo(UPDATED_COHORT_VIEW);
         assertThat(testPrivacy.isEmployerView()).isEqualTo(UPDATED_EMPLOYER_VIEW);

src/test/java/rocks/zipcode/io/web/rest/UserProfileResourceIntTest.java

 @SpringBootTest(classes = ZipConnectApp.class)
 public class UserProfileResourceIntTest {
 
-    private static final Long DEFAULT_PROFILE_ID = 1L;
-    private static final Long UPDATED_PROFILE_ID = 2L;
-
     private static final String DEFAULT_FIRST_NAME = "AAAAAAAAAA";
     private static final String UPDATED_FIRST_NAME = "BBBBBBBBBB";
 
      */
     public static UserProfile createEntity(EntityManager em) {
         UserProfile userProfile = new UserProfile()
-            .profileId(DEFAULT_PROFILE_ID)
             .firstName(DEFAULT_FIRST_NAME)
             .lastName(DEFAULT_LAST_NAME)
             .userStack(DEFAULT_USER_STACK);
         List<UserProfile> userProfileList = userProfileRepository.findAll();
         assertThat(userProfileList).hasSize(databaseSizeBeforeCreate + 1);
         UserProfile testUserProfile = userProfileList.get(userProfileList.size() - 1);
-        assertThat(testUserProfile.getProfileId()).isEqualTo(DEFAULT_PROFILE_ID);
         assertThat(testUserProfile.getFirstName()).isEqualTo(DEFAULT_FIRST_NAME);
         assertThat(testUserProfile.getLastName()).isEqualTo(DEFAULT_LAST_NAME);
         assertThat(testUserProfile.getUserStack()).isEqualTo(DEFAULT_USER_STACK);
             .andExpect(status().isOk())
             .andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
             .andExpect(jsonPath("$.[*].id").value(hasItem(userProfile.getId().intValue())))
-            .andExpect(jsonPath("$.[*].profileId").value(hasItem(DEFAULT_PROFILE_ID.intValue())))
             .andExpect(jsonPath("$.[*].firstName").value(hasItem(DEFAULT_FIRST_NAME.toString())))
             .andExpect(jsonPath("$.[*].lastName").value(hasItem(DEFAULT_LAST_NAME.toString())))
             .andExpect(jsonPath("$.[*].userStack").value(hasItem(DEFAULT_USER_STACK.toString())));
             .andExpect(status().isOk())
             .andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
             .andExpect(jsonPath("$.id").value(userProfile.getId().intValue()))
-            .andExpect(jsonPath("$.profileId").value(DEFAULT_PROFILE_ID.intValue()))
             .andExpect(jsonPath("$.firstName").value(DEFAULT_FIRST_NAME.toString()))
             .andExpect(jsonPath("$.lastName").value(DEFAULT_LAST_NAME.toString()))
             .andExpect(jsonPath("$.userStack").value(DEFAULT_USER_STACK.toString()));
         // Disconnect from session so that the updates on updatedUserProfile are not directly saved in db
         em.detach(updatedUserProfile);
         updatedUserProfile
-            .profileId(UPDATED_PROFILE_ID)
             .firstName(UPDATED_FIRST_NAME)
             .lastName(UPDATED_LAST_NAME)
             .userStack(UPDATED_USER_STACK);
         List<UserProfile> userProfileList = userProfileRepository.findAll();
         assertThat(userProfileList).hasSize(databaseSizeBeforeUpdate);
         UserProfile testUserProfile = userProfileList.get(userProfileList.size() - 1);
-        assertThat(testUserProfile.getProfileId()).isEqualTo(UPDATED_PROFILE_ID);
         assertThat(testUserProfile.getFirstName()).isEqualTo(UPDATED_FIRST_NAME);
         assertThat(testUserProfile.getLastName()).isEqualTo(UPDATED_LAST_NAME);
         assertThat(testUserProfile.getUserStack()).isEqualTo(UPDATED_USER_STACK);