hostsharing/hs.hsadmin.ng
1
0
Fork 0
Code Activity

Model customers.

Browse Source
This commit is contained in:
Michael Hierweck
2019-04-17 16:45:43 +02:00
parent bd5bb859d9
commit 7f0dfebaa4
160 changed files with 3911 additions and 5068 deletions
Download Patch File Download Diff File Expand all files Collapse all files

31
src/test/java/org/hostsharing/hsadminng/web/rest/AssetResourceIntTest.java
View File

@@ -1,15 +1,17 @@
package org.hostsharing.hsadminng.web.rest;
import org.hostsharing.hsadminng.HsadminNgApp;
import org.hostsharing.hsadminng.domain.Asset;
import org.hostsharing.hsadminng.domain.Membership;
import org.hostsharing.hsadminng.domain.enumeration.AssetAction;
import org.hostsharing.hsadminng.repository.AssetRepository;
import org.hostsharing.hsadminng.service.AssetQueryService;
import org.hostsharing.hsadminng.service.AssetService;
import org.hostsharing.hsadminng.service.dto.AssetDTO;
import org.hostsharing.hsadminng.service.mapper.AssetMapper;
import org.hostsharing.hsadminng.web.rest.errors.ExceptionTranslator;
import org.hostsharing.hsadminng.service.dto.AssetCriteria;
import org.hostsharing.hsadminng.service.AssetQueryService;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -31,11 +33,14 @@ import java.time.LocalDate;
import java.time.ZoneId;
import java.util.List;
import static org.hostsharing.hsadminng.web.rest.TestUtil.createFormattingConversionService;
import static org.assertj.core.api.Assertions.assertThat;
import static org.hamcrest.Matchers.hasItem;
import static org.hostsharing.hsadminng.web.rest.TestUtil.createFormattingConversionService;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;
import org.hostsharing.hsadminng.domain.enumeration.AssetAction;
/**
* Test class for the AssetResource REST controller.
*
@@ -116,7 +121,7 @@ public class AssetResourceIntTest {
Membership membership = MembershipResourceIntTest.createEntity(em);
em.persist(membership);
em.flush();
asset.setMember(membership);
asset.setMembership(membership);
return asset;
}
@@ -443,20 +448,20 @@ public class AssetResourceIntTest {
@Test
@Transactional
public void getAllAssetsByMemberIsEqualToSomething() throws Exception {
public void getAllAssetsByMembershipIsEqualToSomething() throws Exception {
// Initialize the database
Membership member = MembershipResourceIntTest.createEntity(em);
em.persist(member);
Membership membership = MembershipResourceIntTest.createEntity(em);
em.persist(membership);
em.flush();
asset.setMember(member);
asset.setMembership(membership);
assetRepository.saveAndFlush(asset);
Long memberId = member.getId();
Long membershipId = membership.getId();
// Get all the assetList where member equals to memberId
defaultAssetShouldBeFound("memberId.equals=" + memberId);
// Get all the assetList where membership equals to membershipId
defaultAssetShouldBeFound("membershipId.equals=" + membershipId);
// Get all the assetList where member equals to memberId + 1
defaultAssetShouldNotBeFound("memberId.equals=" + (memberId + 1));
// Get all the assetList where membership equals to membershipId + 1
defaultAssetShouldNotBeFound("membershipId.equals=" + (membershipId + 1));
}
/**

536
src/test/java/org/hostsharing/hsadminng/web/rest/ContactResourceIntTest.java
View File

@@ -1,536 +0,0 @@
package org.hostsharing.hsadminng.web.rest;
import org.hostsharing.hsadminng.HsadminNgApp;
import org.hostsharing.hsadminng.domain.Contact;
import org.hostsharing.hsadminng.domain.CustomerContact;
import org.hostsharing.hsadminng.repository.ContactRepository;
import org.hostsharing.hsadminng.service.ContactService;
import org.hostsharing.hsadminng.service.dto.ContactDTO;
import org.hostsharing.hsadminng.service.mapper.ContactMapper;
import org.hostsharing.hsadminng.web.rest.errors.ExceptionTranslator;
import org.hostsharing.hsadminng.service.dto.ContactCriteria;
import org.hostsharing.hsadminng.service.ContactQueryService;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.MockitoAnnotations;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
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 org.springframework.validation.Validator;
import javax.persistence.EntityManager;
import java.util.List;
import static org.hostsharing.hsadminng.web.rest.TestUtil.createFormattingConversionService;
import static org.assertj.core.api.Assertions.assertThat;
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 ContactResource REST controller.
*
* @see ContactResource
*/
@RunWith(SpringRunner.class)
@SpringBootTest(classes = HsadminNgApp.class)
public class ContactResourceIntTest {
private static final String DEFAULT_FIRST_NAME = "AAAAAAAAAA";
private static final String UPDATED_FIRST_NAME = "BBBBBBBBBB";
private static final String DEFAULT_LAST_NAME = "AAAAAAAAAA";
private static final String UPDATED_LAST_NAME = "BBBBBBBBBB";
private static final String DEFAULT_EMAIL = "AAAAAAAAAA";
private static final String UPDATED_EMAIL = "BBBBBBBBBB";
@Autowired
private ContactRepository contactRepository;
@Autowired
private ContactMapper contactMapper;
@Autowired
private ContactService contactService;
@Autowired
private ContactQueryService contactQueryService;
@Autowired
private MappingJackson2HttpMessageConverter jacksonMessageConverter;
@Autowired
private PageableHandlerMethodArgumentResolver pageableArgumentResolver;
@Autowired
private ExceptionTranslator exceptionTranslator;
@Autowired
private EntityManager em;
@Autowired
private Validator validator;
private MockMvc restContactMockMvc;
private Contact contact;
@Before
public void setup() {
MockitoAnnotations.initMocks(this);
final ContactResource contactResource = new ContactResource(contactService, contactQueryService);
this.restContactMockMvc = MockMvcBuilders.standaloneSetup(contactResource)
.setCustomArgumentResolvers(pageableArgumentResolver)
.setControllerAdvice(exceptionTranslator)
.setConversionService(createFormattingConversionService())
.setMessageConverters(jacksonMessageConverter)
.setValidator(validator).build();
}
/**
* Create an entity for this test.
*
* This is a static method, as tests for other entities might also need it,
* if they test an entity which requires the current entity.
*/
public static Contact createEntity(EntityManager em) {
Contact contact = new Contact()
.firstName(DEFAULT_FIRST_NAME)
.lastName(DEFAULT_LAST_NAME)
.email(DEFAULT_EMAIL);
return contact;
}
@Before
public void initTest() {
contact = createEntity(em);
}
@Test
@Transactional
public void createContact() throws Exception {
int databaseSizeBeforeCreate = contactRepository.findAll().size();
// Create the Contact
ContactDTO contactDTO = contactMapper.toDto(contact);
restContactMockMvc.perform(post("/api/contacts")
.contentType(TestUtil.APPLICATION_JSON_UTF8)
.content(TestUtil.convertObjectToJsonBytes(contactDTO)))
.andExpect(status().isCreated());
// Validate the Contact in the database
List<Contact> contactList = contactRepository.findAll();
assertThat(contactList).hasSize(databaseSizeBeforeCreate + 1);
Contact testContact = contactList.get(contactList.size() - 1);
assertThat(testContact.getFirstName()).isEqualTo(DEFAULT_FIRST_NAME);
assertThat(testContact.getLastName()).isEqualTo(DEFAULT_LAST_NAME);
assertThat(testContact.getEmail()).isEqualTo(DEFAULT_EMAIL);
}
@Test
@Transactional
public void createContactWithExistingId() throws Exception {
int databaseSizeBeforeCreate = contactRepository.findAll().size();
// Create the Contact with an existing ID
contact.setId(1L);
ContactDTO contactDTO = contactMapper.toDto(contact);
// An entity with an existing ID cannot be created, so this API call must fail
restContactMockMvc.perform(post("/api/contacts")
.contentType(TestUtil.APPLICATION_JSON_UTF8)
.content(TestUtil.convertObjectToJsonBytes(contactDTO)))
.andExpect(status().isBadRequest());
// Validate the Contact in the database
List<Contact> contactList = contactRepository.findAll();
assertThat(contactList).hasSize(databaseSizeBeforeCreate);
}
@Test
@Transactional
public void checkFirstNameIsRequired() throws Exception {
int databaseSizeBeforeTest = contactRepository.findAll().size();
// set the field null
contact.setFirstName(null);
// Create the Contact, which fails.
ContactDTO contactDTO = contactMapper.toDto(contact);
restContactMockMvc.perform(post("/api/contacts")
.contentType(TestUtil.APPLICATION_JSON_UTF8)
.content(TestUtil.convertObjectToJsonBytes(contactDTO)))
.andExpect(status().isBadRequest());
List<Contact> contactList = contactRepository.findAll();
assertThat(contactList).hasSize(databaseSizeBeforeTest);
}
@Test
@Transactional
public void checkLastNameIsRequired() throws Exception {
int databaseSizeBeforeTest = contactRepository.findAll().size();
// set the field null
contact.setLastName(null);
// Create the Contact, which fails.
ContactDTO contactDTO = contactMapper.toDto(contact);
restContactMockMvc.perform(post("/api/contacts")
.contentType(TestUtil.APPLICATION_JSON_UTF8)
.content(TestUtil.convertObjectToJsonBytes(contactDTO)))
.andExpect(status().isBadRequest());
List<Contact> contactList = contactRepository.findAll();
assertThat(contactList).hasSize(databaseSizeBeforeTest);
}
@Test
@Transactional
public void checkEmailIsRequired() throws Exception {
int databaseSizeBeforeTest = contactRepository.findAll().size();
// set the field null
contact.setEmail(null);
// Create the Contact, which fails.
ContactDTO contactDTO = contactMapper.toDto(contact);
restContactMockMvc.perform(post("/api/contacts")
.contentType(TestUtil.APPLICATION_JSON_UTF8)
.content(TestUtil.convertObjectToJsonBytes(contactDTO)))
.andExpect(status().isBadRequest());
List<Contact> contactList = contactRepository.findAll();
assertThat(contactList).hasSize(databaseSizeBeforeTest);
}
@Test
@Transactional
public void getAllContacts() throws Exception {
// Initialize the database
contactRepository.saveAndFlush(contact);
// Get all the contactList
restContactMockMvc.perform(get("/api/contacts?sort=id,desc"))
.andExpect(status().isOk())
.andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
.andExpect(jsonPath("$.[*].id").value(hasItem(contact.getId().intValue())))
.andExpect(jsonPath("$.[*].firstName").value(hasItem(DEFAULT_FIRST_NAME.toString())))
.andExpect(jsonPath("$.[*].lastName").value(hasItem(DEFAULT_LAST_NAME.toString())))
.andExpect(jsonPath("$.[*].email").value(hasItem(DEFAULT_EMAIL.toString())));
}
@Test
@Transactional
public void getContact() throws Exception {
// Initialize the database
contactRepository.saveAndFlush(contact);
// Get the contact
restContactMockMvc.perform(get("/api/contacts/{id}", contact.getId()))
.andExpect(status().isOk())
.andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
.andExpect(jsonPath("$.id").value(contact.getId().intValue()))
.andExpect(jsonPath("$.firstName").value(DEFAULT_FIRST_NAME.toString()))
.andExpect(jsonPath("$.lastName").value(DEFAULT_LAST_NAME.toString()))
.andExpect(jsonPath("$.email").value(DEFAULT_EMAIL.toString()));
}
@Test
@Transactional
public void getAllContactsByFirstNameIsEqualToSomething() throws Exception {
// Initialize the database
contactRepository.saveAndFlush(contact);
// Get all the contactList where firstName equals to DEFAULT_FIRST_NAME
defaultContactShouldBeFound("firstName.equals=" + DEFAULT_FIRST_NAME);
// Get all the contactList where firstName equals to UPDATED_FIRST_NAME
defaultContactShouldNotBeFound("firstName.equals=" + UPDATED_FIRST_NAME);
}
@Test
@Transactional
public void getAllContactsByFirstNameIsInShouldWork() throws Exception {
// Initialize the database
contactRepository.saveAndFlush(contact);
// Get all the contactList where firstName in DEFAULT_FIRST_NAME or UPDATED_FIRST_NAME
defaultContactShouldBeFound("firstName.in=" + DEFAULT_FIRST_NAME + "," + UPDATED_FIRST_NAME);
// Get all the contactList where firstName equals to UPDATED_FIRST_NAME
defaultContactShouldNotBeFound("firstName.in=" + UPDATED_FIRST_NAME);
}
@Test
@Transactional
public void getAllContactsByFirstNameIsNullOrNotNull() throws Exception {
// Initialize the database
contactRepository.saveAndFlush(contact);
// Get all the contactList where firstName is not null
defaultContactShouldBeFound("firstName.specified=true");
// Get all the contactList where firstName is null
defaultContactShouldNotBeFound("firstName.specified=false");
}
@Test
@Transactional
public void getAllContactsByLastNameIsEqualToSomething() throws Exception {
// Initialize the database
contactRepository.saveAndFlush(contact);
// Get all the contactList where lastName equals to DEFAULT_LAST_NAME
defaultContactShouldBeFound("lastName.equals=" + DEFAULT_LAST_NAME);
// Get all the contactList where lastName equals to UPDATED_LAST_NAME
defaultContactShouldNotBeFound("lastName.equals=" + UPDATED_LAST_NAME);
}
@Test
@Transactional
public void getAllContactsByLastNameIsInShouldWork() throws Exception {
// Initialize the database
contactRepository.saveAndFlush(contact);
// Get all the contactList where lastName in DEFAULT_LAST_NAME or UPDATED_LAST_NAME
defaultContactShouldBeFound("lastName.in=" + DEFAULT_LAST_NAME + "," + UPDATED_LAST_NAME);
// Get all the contactList where lastName equals to UPDATED_LAST_NAME
defaultContactShouldNotBeFound("lastName.in=" + UPDATED_LAST_NAME);
}
@Test
@Transactional
public void getAllContactsByLastNameIsNullOrNotNull() throws Exception {
// Initialize the database
contactRepository.saveAndFlush(contact);
// Get all the contactList where lastName is not null
defaultContactShouldBeFound("lastName.specified=true");
// Get all the contactList where lastName is null
defaultContactShouldNotBeFound("lastName.specified=false");
}
@Test
@Transactional
public void getAllContactsByEmailIsEqualToSomething() throws Exception {
// Initialize the database
contactRepository.saveAndFlush(contact);
// Get all the contactList where email equals to DEFAULT_EMAIL
defaultContactShouldBeFound("email.equals=" + DEFAULT_EMAIL);
// Get all the contactList where email equals to UPDATED_EMAIL
defaultContactShouldNotBeFound("email.equals=" + UPDATED_EMAIL);
}
@Test
@Transactional
public void getAllContactsByEmailIsInShouldWork() throws Exception {
// Initialize the database
contactRepository.saveAndFlush(contact);
// Get all the contactList where email in DEFAULT_EMAIL or UPDATED_EMAIL
defaultContactShouldBeFound("email.in=" + DEFAULT_EMAIL + "," + UPDATED_EMAIL);
// Get all the contactList where email equals to UPDATED_EMAIL
defaultContactShouldNotBeFound("email.in=" + UPDATED_EMAIL);
}
@Test
@Transactional
public void getAllContactsByEmailIsNullOrNotNull() throws Exception {
// Initialize the database
contactRepository.saveAndFlush(contact);
// Get all the contactList where email is not null
defaultContactShouldBeFound("email.specified=true");
// Get all the contactList where email is null
defaultContactShouldNotBeFound("email.specified=false");
}
@Test
@Transactional
public void getAllContactsByRoleIsEqualToSomething() throws Exception {
// Initialize the database
CustomerContact role = CustomerContactResourceIntTest.createEntity(em);
em.persist(role);
em.flush();
contact.addRole(role);
contactRepository.saveAndFlush(contact);
Long roleId = role.getId();
// Get all the contactList where role equals to roleId
defaultContactShouldBeFound("roleId.equals=" + roleId);
// Get all the contactList where role equals to roleId + 1
defaultContactShouldNotBeFound("roleId.equals=" + (roleId + 1));
}
/**
* Executes the search, and checks that the default entity is returned
*/
private void defaultContactShouldBeFound(String filter) throws Exception {
restContactMockMvc.perform(get("/api/contacts?sort=id,desc&" + filter))
.andExpect(status().isOk())
.andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
.andExpect(jsonPath("$.[*].id").value(hasItem(contact.getId().intValue())))
.andExpect(jsonPath("$.[*].firstName").value(hasItem(DEFAULT_FIRST_NAME)))
.andExpect(jsonPath("$.[*].lastName").value(hasItem(DEFAULT_LAST_NAME)))
.andExpect(jsonPath("$.[*].email").value(hasItem(DEFAULT_EMAIL)));
// Check, that the count call also returns 1
restContactMockMvc.perform(get("/api/contacts/count?sort=id,desc&" + filter))
.andExpect(status().isOk())
.andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
.andExpect(content().string("1"));
}
/**
* Executes the search, and checks that the default entity is not returned
*/
private void defaultContactShouldNotBeFound(String filter) throws Exception {
restContactMockMvc.perform(get("/api/contacts?sort=id,desc&" + filter))
.andExpect(status().isOk())
.andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
.andExpect(jsonPath("$").isArray())
.andExpect(jsonPath("$").isEmpty());
// Check, that the count call also returns 0
restContactMockMvc.perform(get("/api/contacts/count?sort=id,desc&" + filter))
.andExpect(status().isOk())
.andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
.andExpect(content().string("0"));
}
@Test
@Transactional
public void getNonExistingContact() throws Exception {
// Get the contact
restContactMockMvc.perform(get("/api/contacts/{id}", Long.MAX_VALUE))
.andExpect(status().isNotFound());
}
@Test
@Transactional
public void updateContact() throws Exception {
// Initialize the database
contactRepository.saveAndFlush(contact);
int databaseSizeBeforeUpdate = contactRepository.findAll().size();
// Update the contact
Contact updatedContact = contactRepository.findById(contact.getId()).get();
// Disconnect from session so that the updates on updatedContact are not directly saved in db
em.detach(updatedContact);
updatedContact
.firstName(UPDATED_FIRST_NAME)
.lastName(UPDATED_LAST_NAME)
.email(UPDATED_EMAIL);
ContactDTO contactDTO = contactMapper.toDto(updatedContact);
restContactMockMvc.perform(put("/api/contacts")
.contentType(TestUtil.APPLICATION_JSON_UTF8)
.content(TestUtil.convertObjectToJsonBytes(contactDTO)))
.andExpect(status().isOk());
// Validate the Contact in the database
List<Contact> contactList = contactRepository.findAll();
assertThat(contactList).hasSize(databaseSizeBeforeUpdate);
Contact testContact = contactList.get(contactList.size() - 1);
assertThat(testContact.getFirstName()).isEqualTo(UPDATED_FIRST_NAME);
assertThat(testContact.getLastName()).isEqualTo(UPDATED_LAST_NAME);
assertThat(testContact.getEmail()).isEqualTo(UPDATED_EMAIL);
}
@Test
@Transactional
public void updateNonExistingContact() throws Exception {
int databaseSizeBeforeUpdate = contactRepository.findAll().size();
// Create the Contact
ContactDTO contactDTO = contactMapper.toDto(contact);
// If the entity doesn't have an ID, it will throw BadRequestAlertException
restContactMockMvc.perform(put("/api/contacts")
.contentType(TestUtil.APPLICATION_JSON_UTF8)
.content(TestUtil.convertObjectToJsonBytes(contactDTO)))
.andExpect(status().isBadRequest());
// Validate the Contact in the database
List<Contact> contactList = contactRepository.findAll();
assertThat(contactList).hasSize(databaseSizeBeforeUpdate);
}
@Test
@Transactional
public void deleteContact() throws Exception {
// Initialize the database
contactRepository.saveAndFlush(contact);
int databaseSizeBeforeDelete = contactRepository.findAll().size();
// Delete the contact
restContactMockMvc.perform(delete("/api/contacts/{id}", contact.getId())
.accept(TestUtil.APPLICATION_JSON_UTF8))
.andExpect(status().isOk());
// Validate the database is empty
List<Contact> contactList = contactRepository.findAll();
assertThat(contactList).hasSize(databaseSizeBeforeDelete - 1);
}
@Test
@Transactional
public void equalsVerifier() throws Exception {
TestUtil.equalsVerifier(Contact.class);
Contact contact1 = new Contact();
contact1.setId(1L);
Contact contact2 = new Contact();
contact2.setId(contact1.getId());
assertThat(contact1).isEqualTo(contact2);
contact2.setId(2L);
assertThat(contact1).isNotEqualTo(contact2);
contact1.setId(null);
assertThat(contact1).isNotEqualTo(contact2);
}
@Test
@Transactional
public void dtoEqualsVerifier() throws Exception {
TestUtil.equalsVerifier(ContactDTO.class);
ContactDTO contactDTO1 = new ContactDTO();
contactDTO1.setId(1L);
ContactDTO contactDTO2 = new ContactDTO();
assertThat(contactDTO1).isNotEqualTo(contactDTO2);
contactDTO2.setId(contactDTO1.getId());
assertThat(contactDTO1).isEqualTo(contactDTO2);
contactDTO2.setId(2L);
assertThat(contactDTO1).isNotEqualTo(contactDTO2);
contactDTO1.setId(null);
assertThat(contactDTO1).isNotEqualTo(contactDTO2);
}
@Test
@Transactional
public void testEntityFromId() {
assertThat(contactMapper.fromId(42L).getId()).isEqualTo(42);
assertThat(contactMapper.fromId(null)).isNull();
}
}

431
src/test/java/org/hostsharing/hsadminng/web/rest/CustomerContactResourceIntTest.java
View File

@@ -1,431 +0,0 @@
package org.hostsharing.hsadminng.web.rest;
import org.hostsharing.hsadminng.HsadminNgApp;
import org.hostsharing.hsadminng.domain.CustomerContact;
import org.hostsharing.hsadminng.domain.Contact;
import org.hostsharing.hsadminng.domain.Customer;
import org.hostsharing.hsadminng.repository.CustomerContactRepository;
import org.hostsharing.hsadminng.service.CustomerContactService;
import org.hostsharing.hsadminng.service.dto.CustomerContactDTO;
import org.hostsharing.hsadminng.service.mapper.CustomerContactMapper;
import org.hostsharing.hsadminng.web.rest.errors.ExceptionTranslator;
import org.hostsharing.hsadminng.service.dto.CustomerContactCriteria;
import org.hostsharing.hsadminng.service.CustomerContactQueryService;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.MockitoAnnotations;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
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 org.springframework.validation.Validator;
import javax.persistence.EntityManager;
import java.util.List;
import static org.hostsharing.hsadminng.web.rest.TestUtil.createFormattingConversionService;
import static org.assertj.core.api.Assertions.assertThat;
import static org.hamcrest.Matchers.hasItem;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;
import org.hostsharing.hsadminng.domain.enumeration.CustomerContactRole;
/**
* Test class for the CustomerContactResource REST controller.
*
* @see CustomerContactResource
*/
@RunWith(SpringRunner.class)
@SpringBootTest(classes = HsadminNgApp.class)
public class CustomerContactResourceIntTest {
private static final CustomerContactRole DEFAULT_ROLE = CustomerContactRole.CONTRACTUAL;
private static final CustomerContactRole UPDATED_ROLE = CustomerContactRole.TECHNICAL;
@Autowired
private CustomerContactRepository customerContactRepository;
@Autowired
private CustomerContactMapper customerContactMapper;
@Autowired
private CustomerContactService customerContactService;
@Autowired
private CustomerContactQueryService customerContactQueryService;
@Autowired
private MappingJackson2HttpMessageConverter jacksonMessageConverter;
@Autowired
private PageableHandlerMethodArgumentResolver pageableArgumentResolver;
@Autowired
private ExceptionTranslator exceptionTranslator;
@Autowired
private EntityManager em;
@Autowired
private Validator validator;
private MockMvc restCustomerContactMockMvc;
private CustomerContact customerContact;
@Before
public void setup() {
MockitoAnnotations.initMocks(this);
final CustomerContactResource customerContactResource = new CustomerContactResource(customerContactService, customerContactQueryService);
this.restCustomerContactMockMvc = MockMvcBuilders.standaloneSetup(customerContactResource)
.setCustomArgumentResolvers(pageableArgumentResolver)
.setControllerAdvice(exceptionTranslator)
.setConversionService(createFormattingConversionService())
.setMessageConverters(jacksonMessageConverter)
.setValidator(validator).build();
}
/**
* Create an entity for this test.
*
* This is a static method, as tests for other entities might also need it,
* if they test an entity which requires the current entity.
*/
public static CustomerContact createEntity(EntityManager em) {
CustomerContact customerContact = new CustomerContact()
.role(DEFAULT_ROLE);
// Add required entity
Contact contact = ContactResourceIntTest.createEntity(em);
em.persist(contact);
em.flush();
customerContact.setContact(contact);
// Add required entity
Customer customer = CustomerResourceIntTest.createEntity(em);
em.persist(customer);
em.flush();
customerContact.setCustomer(customer);
return customerContact;
}
@Before
public void initTest() {
customerContact = createEntity(em);
}
@Test
@Transactional
public void createCustomerContact() throws Exception {
int databaseSizeBeforeCreate = customerContactRepository.findAll().size();
// Create the CustomerContact
CustomerContactDTO customerContactDTO = customerContactMapper.toDto(customerContact);
restCustomerContactMockMvc.perform(post("/api/customer-contacts")
.contentType(TestUtil.APPLICATION_JSON_UTF8)
.content(TestUtil.convertObjectToJsonBytes(customerContactDTO)))
.andExpect(status().isCreated());
// Validate the CustomerContact in the database
List<CustomerContact> customerContactList = customerContactRepository.findAll();
assertThat(customerContactList).hasSize(databaseSizeBeforeCreate + 1);
CustomerContact testCustomerContact = customerContactList.get(customerContactList.size() - 1);
assertThat(testCustomerContact.getRole()).isEqualTo(DEFAULT_ROLE);
}
@Test
@Transactional
public void createCustomerContactWithExistingId() throws Exception {
int databaseSizeBeforeCreate = customerContactRepository.findAll().size();
// Create the CustomerContact with an existing ID
customerContact.setId(1L);
CustomerContactDTO customerContactDTO = customerContactMapper.toDto(customerContact);
// An entity with an existing ID cannot be created, so this API call must fail
restCustomerContactMockMvc.perform(post("/api/customer-contacts")
.contentType(TestUtil.APPLICATION_JSON_UTF8)
.content(TestUtil.convertObjectToJsonBytes(customerContactDTO)))
.andExpect(status().isBadRequest());
// Validate the CustomerContact in the database
List<CustomerContact> customerContactList = customerContactRepository.findAll();
assertThat(customerContactList).hasSize(databaseSizeBeforeCreate);
}
@Test
@Transactional
public void checkRoleIsRequired() throws Exception {
int databaseSizeBeforeTest = customerContactRepository.findAll().size();
// set the field null
customerContact.setRole(null);
// Create the CustomerContact, which fails.
CustomerContactDTO customerContactDTO = customerContactMapper.toDto(customerContact);
restCustomerContactMockMvc.perform(post("/api/customer-contacts")
.contentType(TestUtil.APPLICATION_JSON_UTF8)
.content(TestUtil.convertObjectToJsonBytes(customerContactDTO)))
.andExpect(status().isBadRequest());
List<CustomerContact> customerContactList = customerContactRepository.findAll();
assertThat(customerContactList).hasSize(databaseSizeBeforeTest);
}
@Test
@Transactional
public void getAllCustomerContacts() throws Exception {
// Initialize the database
customerContactRepository.saveAndFlush(customerContact);
// Get all the customerContactList
restCustomerContactMockMvc.perform(get("/api/customer-contacts?sort=id,desc"))
.andExpect(status().isOk())
.andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
.andExpect(jsonPath("$.[*].id").value(hasItem(customerContact.getId().intValue())))
.andExpect(jsonPath("$.[*].role").value(hasItem(DEFAULT_ROLE.toString())));
}
@Test
@Transactional
public void getCustomerContact() throws Exception {
// Initialize the database
customerContactRepository.saveAndFlush(customerContact);
// Get the customerContact
restCustomerContactMockMvc.perform(get("/api/customer-contacts/{id}", customerContact.getId()))
.andExpect(status().isOk())
.andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
.andExpect(jsonPath("$.id").value(customerContact.getId().intValue()))
.andExpect(jsonPath("$.role").value(DEFAULT_ROLE.toString()));
}
@Test
@Transactional
public void getAllCustomerContactsByRoleIsEqualToSomething() throws Exception {
// Initialize the database
customerContactRepository.saveAndFlush(customerContact);
// Get all the customerContactList where role equals to DEFAULT_ROLE
defaultCustomerContactShouldBeFound("role.equals=" + DEFAULT_ROLE);
// Get all the customerContactList where role equals to UPDATED_ROLE
defaultCustomerContactShouldNotBeFound("role.equals=" + UPDATED_ROLE);
}
@Test
@Transactional
public void getAllCustomerContactsByRoleIsInShouldWork() throws Exception {
// Initialize the database
customerContactRepository.saveAndFlush(customerContact);
// Get all the customerContactList where role in DEFAULT_ROLE or UPDATED_ROLE
defaultCustomerContactShouldBeFound("role.in=" + DEFAULT_ROLE + "," + UPDATED_ROLE);
// Get all the customerContactList where role equals to UPDATED_ROLE
defaultCustomerContactShouldNotBeFound("role.in=" + UPDATED_ROLE);
}
@Test
@Transactional
public void getAllCustomerContactsByRoleIsNullOrNotNull() throws Exception {
// Initialize the database
customerContactRepository.saveAndFlush(customerContact);
// Get all the customerContactList where role is not null
defaultCustomerContactShouldBeFound("role.specified=true");
// Get all the customerContactList where role is null
defaultCustomerContactShouldNotBeFound("role.specified=false");
}
@Test
@Transactional
public void getAllCustomerContactsByContactIsEqualToSomething() throws Exception {
// Initialize the database
Contact contact = ContactResourceIntTest.createEntity(em);
em.persist(contact);
em.flush();
customerContact.setContact(contact);
customerContactRepository.saveAndFlush(customerContact);
Long contactId = contact.getId();
// Get all the customerContactList where contact equals to contactId
defaultCustomerContactShouldBeFound("contactId.equals=" + contactId);
// Get all the customerContactList where contact equals to contactId + 1
defaultCustomerContactShouldNotBeFound("contactId.equals=" + (contactId + 1));
}
@Test
@Transactional
public void getAllCustomerContactsByCustomerIsEqualToSomething() throws Exception {
// Initialize the database
Customer customer = CustomerResourceIntTest.createEntity(em);
em.persist(customer);
em.flush();
customerContact.setCustomer(customer);
customerContactRepository.saveAndFlush(customerContact);
Long customerId = customer.getId();
// Get all the customerContactList where customer equals to customerId
defaultCustomerContactShouldBeFound("customerId.equals=" + customerId);
// Get all the customerContactList where customer equals to customerId + 1
defaultCustomerContactShouldNotBeFound("customerId.equals=" + (customerId + 1));
}
/**
* Executes the search, and checks that the default entity is returned
*/
private void defaultCustomerContactShouldBeFound(String filter) throws Exception {
restCustomerContactMockMvc.perform(get("/api/customer-contacts?sort=id,desc&" + filter))
.andExpect(status().isOk())
.andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
.andExpect(jsonPath("$.[*].id").value(hasItem(customerContact.getId().intValue())))
.andExpect(jsonPath("$.[*].role").value(hasItem(DEFAULT_ROLE.toString())));
// Check, that the count call also returns 1
restCustomerContactMockMvc.perform(get("/api/customer-contacts/count?sort=id,desc&" + filter))
.andExpect(status().isOk())
.andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
.andExpect(content().string("1"));
}
/**
* Executes the search, and checks that the default entity is not returned
*/
private void defaultCustomerContactShouldNotBeFound(String filter) throws Exception {
restCustomerContactMockMvc.perform(get("/api/customer-contacts?sort=id,desc&" + filter))
.andExpect(status().isOk())
.andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
.andExpect(jsonPath("$").isArray())
.andExpect(jsonPath("$").isEmpty());
// Check, that the count call also returns 0
restCustomerContactMockMvc.perform(get("/api/customer-contacts/count?sort=id,desc&" + filter))
.andExpect(status().isOk())
.andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
.andExpect(content().string("0"));
}
@Test
@Transactional
public void getNonExistingCustomerContact() throws Exception {
// Get the customerContact
restCustomerContactMockMvc.perform(get("/api/customer-contacts/{id}", Long.MAX_VALUE))
.andExpect(status().isNotFound());
}
@Test
@Transactional
public void updateCustomerContact() throws Exception {
// Initialize the database
customerContactRepository.saveAndFlush(customerContact);
int databaseSizeBeforeUpdate = customerContactRepository.findAll().size();
// Update the customerContact
CustomerContact updatedCustomerContact = customerContactRepository.findById(customerContact.getId()).get();
// Disconnect from session so that the updates on updatedCustomerContact are not directly saved in db
em.detach(updatedCustomerContact);
updatedCustomerContact
.role(UPDATED_ROLE);
CustomerContactDTO customerContactDTO = customerContactMapper.toDto(updatedCustomerContact);
restCustomerContactMockMvc.perform(put("/api/customer-contacts")
.contentType(TestUtil.APPLICATION_JSON_UTF8)
.content(TestUtil.convertObjectToJsonBytes(customerContactDTO)))
.andExpect(status().isOk());
// Validate the CustomerContact in the database
List<CustomerContact> customerContactList = customerContactRepository.findAll();
assertThat(customerContactList).hasSize(databaseSizeBeforeUpdate);
CustomerContact testCustomerContact = customerContactList.get(customerContactList.size() - 1);
assertThat(testCustomerContact.getRole()).isEqualTo(UPDATED_ROLE);
}
@Test
@Transactional
public void updateNonExistingCustomerContact() throws Exception {
int databaseSizeBeforeUpdate = customerContactRepository.findAll().size();
// Create the CustomerContact
CustomerContactDTO customerContactDTO = customerContactMapper.toDto(customerContact);
// If the entity doesn't have an ID, it will throw BadRequestAlertException
restCustomerContactMockMvc.perform(put("/api/customer-contacts")
.contentType(TestUtil.APPLICATION_JSON_UTF8)
.content(TestUtil.convertObjectToJsonBytes(customerContactDTO)))
.andExpect(status().isBadRequest());
// Validate the CustomerContact in the database
List<CustomerContact> customerContactList = customerContactRepository.findAll();
assertThat(customerContactList).hasSize(databaseSizeBeforeUpdate);
}
@Test
@Transactional
public void deleteCustomerContact() throws Exception {
// Initialize the database
customerContactRepository.saveAndFlush(customerContact);
int databaseSizeBeforeDelete = customerContactRepository.findAll().size();
// Delete the customerContact
restCustomerContactMockMvc.perform(delete("/api/customer-contacts/{id}", customerContact.getId())
.accept(TestUtil.APPLICATION_JSON_UTF8))
.andExpect(status().isOk());
// Validate the database is empty
List<CustomerContact> customerContactList = customerContactRepository.findAll();
assertThat(customerContactList).hasSize(databaseSizeBeforeDelete - 1);
}
@Test
@Transactional
public void equalsVerifier() throws Exception {
TestUtil.equalsVerifier(CustomerContact.class);
CustomerContact customerContact1 = new CustomerContact();
customerContact1.setId(1L);
CustomerContact customerContact2 = new CustomerContact();
customerContact2.setId(customerContact1.getId());
assertThat(customerContact1).isEqualTo(customerContact2);
customerContact2.setId(2L);
assertThat(customerContact1).isNotEqualTo(customerContact2);
customerContact1.setId(null);
assertThat(customerContact1).isNotEqualTo(customerContact2);
}
@Test
@Transactional
public void dtoEqualsVerifier() throws Exception {
TestUtil.equalsVerifier(CustomerContactDTO.class);
CustomerContactDTO customerContactDTO1 = new CustomerContactDTO();
customerContactDTO1.setId(1L);
CustomerContactDTO customerContactDTO2 = new CustomerContactDTO();
assertThat(customerContactDTO1).isNotEqualTo(customerContactDTO2);
customerContactDTO2.setId(customerContactDTO1.getId());
assertThat(customerContactDTO1).isEqualTo(customerContactDTO2);
customerContactDTO2.setId(2L);
assertThat(customerContactDTO1).isNotEqualTo(customerContactDTO2);
customerContactDTO1.setId(null);
assertThat(customerContactDTO1).isNotEqualTo(customerContactDTO2);
}
@Test
@Transactional
public void testEntityFromId() {
assertThat(customerContactMapper.fromId(42L).getId()).isEqualTo(42);
assertThat(customerContactMapper.fromId(null)).isNull();
}
}

190
src/test/java/org/hostsharing/hsadminng/web/rest/CustomerResourceIntTest.java
View File

@@ -1,15 +1,18 @@
package org.hostsharing.hsadminng.web.rest;
import org.hostsharing.hsadminng.HsadminNgApp;
import org.hostsharing.hsadminng.domain.Customer;
import org.hostsharing.hsadminng.domain.CustomerContact;
import org.hostsharing.hsadminng.domain.Membership;
import org.hostsharing.hsadminng.domain.SepaMandate;
import org.hostsharing.hsadminng.repository.CustomerRepository;
import org.hostsharing.hsadminng.service.CustomerQueryService;
import org.hostsharing.hsadminng.service.CustomerService;
import org.hostsharing.hsadminng.service.dto.CustomerDTO;
import org.hostsharing.hsadminng.service.mapper.CustomerMapper;
import org.hostsharing.hsadminng.web.rest.errors.ExceptionTranslator;
import org.hostsharing.hsadminng.service.dto.CustomerCriteria;
import org.hostsharing.hsadminng.service.CustomerQueryService;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -28,9 +31,10 @@ import org.springframework.validation.Validator;
import javax.persistence.EntityManager;
import java.util.List;
import static org.hostsharing.hsadminng.web.rest.TestUtil.createFormattingConversionService;
import static org.assertj.core.api.Assertions.assertThat;
import static org.hamcrest.Matchers.hasItem;
import static org.hostsharing.hsadminng.web.rest.TestUtil.createFormattingConversionService;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;
@@ -46,24 +50,24 @@ public class CustomerResourceIntTest {
private static final Integer DEFAULT_NUMBER = 10000;
private static final Integer UPDATED_NUMBER = 10001;
private static final String DEFAULT_PREFIX = "lzv";
private static final String UPDATED_PREFIX = "zf";
private static final String DEFAULT_PREFIX = "nf";
private static final String UPDATED_PREFIX = "m2";
private static final String DEFAULT_NAME = "AAAAAAAAAA";
private static final String UPDATED_NAME = "BBBBBBBBBB";
private static final String DEFAULT_CONTRACTUAL_ADDRESS = "AAAAAAAAAA";
private static final String UPDATED_CONTRACTUAL_ADDRESS = "BBBBBBBBBB";
private static final String DEFAULT_CONTRACTUAL_SALUTATION = "AAAAAAAAAA";
private static final String UPDATED_CONTRACTUAL_SALUTATION = "BBBBBBBBBB";
private static final String DEFAULT_BILLING_ADDRESS = "AAAAAAAAAA";
private static final String UPDATED_BILLING_ADDRESS = "BBBBBBBBBB";
private static final String DEFAULT_CONTRACTUAL_ADDRESS = "AAAAAAAAAA";
private static final String UPDATED_CONTRACTUAL_ADDRESS = "BBBBBBBBBB";
private static final String DEFAULT_BILLING_SALUTATION = "AAAAAAAAAA";
private static final String UPDATED_BILLING_SALUTATION = "BBBBBBBBBB";
private static final String DEFAULT_BILLING_ADDRESS = "AAAAAAAAAA";
private static final String UPDATED_BILLING_ADDRESS = "BBBBBBBBBB";
@Autowired
private CustomerRepository customerRepository;
@@ -118,10 +122,10 @@ public class CustomerResourceIntTest {
.number(DEFAULT_NUMBER)
.prefix(DEFAULT_PREFIX)
.name(DEFAULT_NAME)
.contractualAddress(DEFAULT_CONTRACTUAL_ADDRESS)
.contractualSalutation(DEFAULT_CONTRACTUAL_SALUTATION)
.billingAddress(DEFAULT_BILLING_ADDRESS)
.billingSalutation(DEFAULT_BILLING_SALUTATION);
.contractualAddress(DEFAULT_CONTRACTUAL_ADDRESS)
.billingSalutation(DEFAULT_BILLING_SALUTATION)
.billingAddress(DEFAULT_BILLING_ADDRESS);
return customer;
}
@@ -149,10 +153,10 @@ public class CustomerResourceIntTest {
assertThat(testCustomer.getNumber()).isEqualTo(DEFAULT_NUMBER);
assertThat(testCustomer.getPrefix()).isEqualTo(DEFAULT_PREFIX);
assertThat(testCustomer.getName()).isEqualTo(DEFAULT_NAME);
assertThat(testCustomer.getContractualAddress()).isEqualTo(DEFAULT_CONTRACTUAL_ADDRESS);
assertThat(testCustomer.getContractualSalutation()).isEqualTo(DEFAULT_CONTRACTUAL_SALUTATION);
assertThat(testCustomer.getBillingAddress()).isEqualTo(DEFAULT_BILLING_ADDRESS);
assertThat(testCustomer.getContractualAddress()).isEqualTo(DEFAULT_CONTRACTUAL_ADDRESS);
assertThat(testCustomer.getBillingSalutation()).isEqualTo(DEFAULT_BILLING_SALUTATION);
assertThat(testCustomer.getBillingAddress()).isEqualTo(DEFAULT_BILLING_ADDRESS);
}
@Test
@@ -265,10 +269,10 @@ public class CustomerResourceIntTest {
.andExpect(jsonPath("$.[*].number").value(hasItem(DEFAULT_NUMBER)))
.andExpect(jsonPath("$.[*].prefix").value(hasItem(DEFAULT_PREFIX.toString())))
.andExpect(jsonPath("$.[*].name").value(hasItem(DEFAULT_NAME.toString())))
.andExpect(jsonPath("$.[*].contractualAddress").value(hasItem(DEFAULT_CONTRACTUAL_ADDRESS.toString())))
.andExpect(jsonPath("$.[*].contractualSalutation").value(hasItem(DEFAULT_CONTRACTUAL_SALUTATION.toString())))
.andExpect(jsonPath("$.[*].billingAddress").value(hasItem(DEFAULT_BILLING_ADDRESS.toString())))
.andExpect(jsonPath("$.[*].billingSalutation").value(hasItem(DEFAULT_BILLING_SALUTATION.toString())));
.andExpect(jsonPath("$.[*].contractualAddress").value(hasItem(DEFAULT_CONTRACTUAL_ADDRESS.toString())))
.andExpect(jsonPath("$.[*].billingSalutation").value(hasItem(DEFAULT_BILLING_SALUTATION.toString())))
.andExpect(jsonPath("$.[*].billingAddress").value(hasItem(DEFAULT_BILLING_ADDRESS.toString())));
}
@Test
@@ -285,10 +289,10 @@ public class CustomerResourceIntTest {
.andExpect(jsonPath("$.number").value(DEFAULT_NUMBER))
.andExpect(jsonPath("$.prefix").value(DEFAULT_PREFIX.toString()))
.andExpect(jsonPath("$.name").value(DEFAULT_NAME.toString()))
.andExpect(jsonPath("$.contractualAddress").value(DEFAULT_CONTRACTUAL_ADDRESS.toString()))
.andExpect(jsonPath("$.contractualSalutation").value(DEFAULT_CONTRACTUAL_SALUTATION.toString()))
.andExpect(jsonPath("$.billingAddress").value(DEFAULT_BILLING_ADDRESS.toString()))
.andExpect(jsonPath("$.billingSalutation").value(DEFAULT_BILLING_SALUTATION.toString()));
.andExpect(jsonPath("$.contractualAddress").value(DEFAULT_CONTRACTUAL_ADDRESS.toString()))
.andExpect(jsonPath("$.billingSalutation").value(DEFAULT_BILLING_SALUTATION.toString()))
.andExpect(jsonPath("$.billingAddress").value(DEFAULT_BILLING_ADDRESS.toString()));
}
@Test
@@ -435,45 +439,6 @@ public class CustomerResourceIntTest {
defaultCustomerShouldNotBeFound("name.specified=false");
}
@Test
@Transactional
public void getAllCustomersByContractualAddressIsEqualToSomething() throws Exception {
// Initialize the database
customerRepository.saveAndFlush(customer);
// Get all the customerList where contractualAddress equals to DEFAULT_CONTRACTUAL_ADDRESS
defaultCustomerShouldBeFound("contractualAddress.equals=" + DEFAULT_CONTRACTUAL_ADDRESS);
// Get all the customerList where contractualAddress equals to UPDATED_CONTRACTUAL_ADDRESS
defaultCustomerShouldNotBeFound("contractualAddress.equals=" + UPDATED_CONTRACTUAL_ADDRESS);
}
@Test
@Transactional
public void getAllCustomersByContractualAddressIsInShouldWork() throws Exception {
// Initialize the database
customerRepository.saveAndFlush(customer);
// Get all the customerList where contractualAddress in DEFAULT_CONTRACTUAL_ADDRESS or UPDATED_CONTRACTUAL_ADDRESS
defaultCustomerShouldBeFound("contractualAddress.in=" + DEFAULT_CONTRACTUAL_ADDRESS + "," + UPDATED_CONTRACTUAL_ADDRESS);
// Get all the customerList where contractualAddress equals to UPDATED_CONTRACTUAL_ADDRESS
defaultCustomerShouldNotBeFound("contractualAddress.in=" + UPDATED_CONTRACTUAL_ADDRESS);
}
@Test
@Transactional
public void getAllCustomersByContractualAddressIsNullOrNotNull() throws Exception {
// Initialize the database
customerRepository.saveAndFlush(customer);
// Get all the customerList where contractualAddress is not null
defaultCustomerShouldBeFound("contractualAddress.specified=true");
// Get all the customerList where contractualAddress is null
defaultCustomerShouldNotBeFound("contractualAddress.specified=false");
}
@Test
@Transactional
public void getAllCustomersByContractualSalutationIsEqualToSomething() throws Exception {
@@ -515,41 +480,41 @@ public class CustomerResourceIntTest {
@Test
@Transactional
public void getAllCustomersByBillingAddressIsEqualToSomething() throws Exception {
public void getAllCustomersByContractualAddressIsEqualToSomething() throws Exception {
// Initialize the database
customerRepository.saveAndFlush(customer);
// Get all the customerList where billingAddress equals to DEFAULT_BILLING_ADDRESS
defaultCustomerShouldBeFound("billingAddress.equals=" + DEFAULT_BILLING_ADDRESS);
// Get all the customerList where contractualAddress equals to DEFAULT_CONTRACTUAL_ADDRESS
defaultCustomerShouldBeFound("contractualAddress.equals=" + DEFAULT_CONTRACTUAL_ADDRESS);
// Get all the customerList where billingAddress equals to UPDATED_BILLING_ADDRESS
defaultCustomerShouldNotBeFound("billingAddress.equals=" + UPDATED_BILLING_ADDRESS);
// Get all the customerList where contractualAddress equals to UPDATED_CONTRACTUAL_ADDRESS
defaultCustomerShouldNotBeFound("contractualAddress.equals=" + UPDATED_CONTRACTUAL_ADDRESS);
}
@Test
@Transactional
public void getAllCustomersByBillingAddressIsInShouldWork() throws Exception {
public void getAllCustomersByContractualAddressIsInShouldWork() throws Exception {
// Initialize the database
customerRepository.saveAndFlush(customer);
// Get all the customerList where billingAddress in DEFAULT_BILLING_ADDRESS or UPDATED_BILLING_ADDRESS
defaultCustomerShouldBeFound("billingAddress.in=" + DEFAULT_BILLING_ADDRESS + "," + UPDATED_BILLING_ADDRESS);
// Get all the customerList where contractualAddress in DEFAULT_CONTRACTUAL_ADDRESS or UPDATED_CONTRACTUAL_ADDRESS
defaultCustomerShouldBeFound("contractualAddress.in=" + DEFAULT_CONTRACTUAL_ADDRESS + "," + UPDATED_CONTRACTUAL_ADDRESS);
// Get all the customerList where billingAddress equals to UPDATED_BILLING_ADDRESS
defaultCustomerShouldNotBeFound("billingAddress.in=" + UPDATED_BILLING_ADDRESS);
// Get all the customerList where contractualAddress equals to UPDATED_CONTRACTUAL_ADDRESS
defaultCustomerShouldNotBeFound("contractualAddress.in=" + UPDATED_CONTRACTUAL_ADDRESS);
}
@Test
@Transactional
public void getAllCustomersByBillingAddressIsNullOrNotNull() throws Exception {
public void getAllCustomersByContractualAddressIsNullOrNotNull() throws Exception {
// Initialize the database
customerRepository.saveAndFlush(customer);
// Get all the customerList where billingAddress is not null
defaultCustomerShouldBeFound("billingAddress.specified=true");
// Get all the customerList where contractualAddress is not null
defaultCustomerShouldBeFound("contractualAddress.specified=true");
// Get all the customerList where billingAddress is null
defaultCustomerShouldNotBeFound("billingAddress.specified=false");
// Get all the customerList where contractualAddress is null
defaultCustomerShouldNotBeFound("contractualAddress.specified=false");
}
@Test
@@ -593,22 +558,42 @@ public class CustomerResourceIntTest {
@Test
@Transactional
public void getAllCustomersByRoleIsEqualToSomething() throws Exception {
public void getAllCustomersByBillingAddressIsEqualToSomething() throws Exception {
// Initialize the database
CustomerContact role = CustomerContactResourceIntTest.createEntity(em);
em.persist(role);
em.flush();
customer.addRole(role);
customerRepository.saveAndFlush(customer);
Long roleId = role.getId();
// Get all the customerList where role equals to roleId
defaultCustomerShouldBeFound("roleId.equals=" + roleId);
// Get all the customerList where billingAddress equals to DEFAULT_BILLING_ADDRESS
defaultCustomerShouldBeFound("billingAddress.equals=" + DEFAULT_BILLING_ADDRESS);
// Get all the customerList where role equals to roleId + 1
defaultCustomerShouldNotBeFound("roleId.equals=" + (roleId + 1));
// Get all the customerList where billingAddress equals to UPDATED_BILLING_ADDRESS
defaultCustomerShouldNotBeFound("billingAddress.equals=" + UPDATED_BILLING_ADDRESS);
}
@Test
@Transactional
public void getAllCustomersByBillingAddressIsInShouldWork() throws Exception {
// Initialize the database
customerRepository.saveAndFlush(customer);
// Get all the customerList where billingAddress in DEFAULT_BILLING_ADDRESS or UPDATED_BILLING_ADDRESS
defaultCustomerShouldBeFound("billingAddress.in=" + DEFAULT_BILLING_ADDRESS + "," + UPDATED_BILLING_ADDRESS);
// Get all the customerList where billingAddress equals to UPDATED_BILLING_ADDRESS
defaultCustomerShouldNotBeFound("billingAddress.in=" + UPDATED_BILLING_ADDRESS);
}
@Test
@Transactional
public void getAllCustomersByBillingAddressIsNullOrNotNull() throws Exception {
// Initialize the database
customerRepository.saveAndFlush(customer);
// Get all the customerList where billingAddress is not null
defaultCustomerShouldBeFound("billingAddress.specified=true");
// Get all the customerList where billingAddress is null
defaultCustomerShouldNotBeFound("billingAddress.specified=false");
}
@Test
@Transactional
@@ -628,6 +613,25 @@ public class CustomerResourceIntTest {
defaultCustomerShouldNotBeFound("membershipId.equals=" + (membershipId + 1));
}
@Test
@Transactional
public void getAllCustomersBySepamandateIsEqualToSomething() throws Exception {
// Initialize the database
SepaMandate sepamandate = SepaMandateResourceIntTest.createEntity(em);
em.persist(sepamandate);
em.flush();
customer.addSepamandate(sepamandate);
customerRepository.saveAndFlush(customer);
Long sepamandateId = sepamandate.getId();
// Get all the customerList where sepamandate equals to sepamandateId
defaultCustomerShouldBeFound("sepamandateId.equals=" + sepamandateId);
// Get all the customerList where sepamandate equals to sepamandateId + 1
defaultCustomerShouldNotBeFound("sepamandateId.equals=" + (sepamandateId + 1));
}
/**
* Executes the search, and checks that the default entity is returned
*/
@@ -639,10 +643,10 @@ public class CustomerResourceIntTest {
.andExpect(jsonPath("$.[*].number").value(hasItem(DEFAULT_NUMBER)))
.andExpect(jsonPath("$.[*].prefix").value(hasItem(DEFAULT_PREFIX)))
.andExpect(jsonPath("$.[*].name").value(hasItem(DEFAULT_NAME)))
.andExpect(jsonPath("$.[*].contractualAddress").value(hasItem(DEFAULT_CONTRACTUAL_ADDRESS)))
.andExpect(jsonPath("$.[*].contractualSalutation").value(hasItem(DEFAULT_CONTRACTUAL_SALUTATION)))
.andExpect(jsonPath("$.[*].billingAddress").value(hasItem(DEFAULT_BILLING_ADDRESS)))
.andExpect(jsonPath("$.[*].billingSalutation").value(hasItem(DEFAULT_BILLING_SALUTATION)));
.andExpect(jsonPath("$.[*].contractualAddress").value(hasItem(DEFAULT_CONTRACTUAL_ADDRESS)))
.andExpect(jsonPath("$.[*].billingSalutation").value(hasItem(DEFAULT_BILLING_SALUTATION)))
.andExpect(jsonPath("$.[*].billingAddress").value(hasItem(DEFAULT_BILLING_ADDRESS)));
// Check, that the count call also returns 1
restCustomerMockMvc.perform(get("/api/customers/count?sort=id,desc&" + filter))
@@ -693,10 +697,10 @@ public class CustomerResourceIntTest {
.number(UPDATED_NUMBER)
.prefix(UPDATED_PREFIX)
.name(UPDATED_NAME)
.contractualAddress(UPDATED_CONTRACTUAL_ADDRESS)
.contractualSalutation(UPDATED_CONTRACTUAL_SALUTATION)
.billingAddress(UPDATED_BILLING_ADDRESS)
.billingSalutation(UPDATED_BILLING_SALUTATION);
.contractualAddress(UPDATED_CONTRACTUAL_ADDRESS)
.billingSalutation(UPDATED_BILLING_SALUTATION)
.billingAddress(UPDATED_BILLING_ADDRESS);
CustomerDTO customerDTO = customerMapper.toDto(updatedCustomer);
restCustomerMockMvc.perform(put("/api/customers")
@@ -711,10 +715,10 @@ public class CustomerResourceIntTest {
assertThat(testCustomer.getNumber()).isEqualTo(UPDATED_NUMBER);
assertThat(testCustomer.getPrefix()).isEqualTo(UPDATED_PREFIX);
assertThat(testCustomer.getName()).isEqualTo(UPDATED_NAME);
assertThat(testCustomer.getContractualAddress()).isEqualTo(UPDATED_CONTRACTUAL_ADDRESS);
assertThat(testCustomer.getContractualSalutation()).isEqualTo(UPDATED_CONTRACTUAL_SALUTATION);
assertThat(testCustomer.getBillingAddress()).isEqualTo(UPDATED_BILLING_ADDRESS);
assertThat(testCustomer.getContractualAddress()).isEqualTo(UPDATED_CONTRACTUAL_ADDRESS);
assertThat(testCustomer.getBillingSalutation()).isEqualTo(UPDATED_BILLING_SALUTATION);
assertThat(testCustomer.getBillingAddress()).isEqualTo(UPDATED_BILLING_ADDRESS);
}
@Test

201
src/test/java/org/hostsharing/hsadminng/web/rest/MembershipResourceIntTest.java
View File

@@ -1,16 +1,19 @@
package org.hostsharing.hsadminng.web.rest;
import org.hostsharing.hsadminng.HsadminNgApp;
import org.hostsharing.hsadminng.domain.Asset;
import org.hostsharing.hsadminng.domain.Customer;
import org.hostsharing.hsadminng.domain.Membership;
import org.hostsharing.hsadminng.domain.Share;
import org.hostsharing.hsadminng.domain.Asset;
import org.hostsharing.hsadminng.domain.Customer;
import org.hostsharing.hsadminng.repository.MembershipRepository;
import org.hostsharing.hsadminng.service.MembershipQueryService;
import org.hostsharing.hsadminng.service.MembershipService;
import org.hostsharing.hsadminng.service.dto.MembershipDTO;
import org.hostsharing.hsadminng.service.mapper.MembershipMapper;
import org.hostsharing.hsadminng.web.rest.errors.ExceptionTranslator;
import org.hostsharing.hsadminng.service.dto.MembershipCriteria;
import org.hostsharing.hsadminng.service.MembershipQueryService;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -31,9 +34,10 @@ import java.time.LocalDate;
import java.time.ZoneId;
import java.util.List;
import static org.hostsharing.hsadminng.web.rest.TestUtil.createFormattingConversionService;
import static org.assertj.core.api.Assertions.assertThat;
import static org.hamcrest.Matchers.hasItem;
import static org.hostsharing.hsadminng.web.rest.TestUtil.createFormattingConversionService;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;
@@ -46,11 +50,14 @@ import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.
@SpringBootTest(classes = HsadminNgApp.class)
public class MembershipResourceIntTest {
private static final LocalDate DEFAULT_SINCE_DATE = LocalDate.ofEpochDay(0L);
private static final LocalDate UPDATED_SINCE_DATE = LocalDate.now(ZoneId.systemDefault());
private static final LocalDate DEFAULT_FROM = LocalDate.ofEpochDay(0L);
private static final LocalDate UPDATED_FROM = LocalDate.now(ZoneId.systemDefault());
private static final LocalDate DEFAULT_UNTIL_DATE = LocalDate.ofEpochDay(0L);
private static final LocalDate UPDATED_UNTIL_DATE = LocalDate.now(ZoneId.systemDefault());
private static final LocalDate DEFAULT_TO = LocalDate.ofEpochDay(0L);
private static final LocalDate UPDATED_TO = LocalDate.now(ZoneId.systemDefault());
private static final String DEFAULT_COMMENT = "AAAAAAAAAA";
private static final String UPDATED_COMMENT = "BBBBBBBBBB";
@Autowired
private MembershipRepository membershipRepository;
@@ -103,8 +110,9 @@ public class MembershipResourceIntTest {
*/
public static Membership createEntity(EntityManager em) {
Membership membership = new Membership()
.sinceDate(DEFAULT_SINCE_DATE)
.untilDate(DEFAULT_UNTIL_DATE);
.from(DEFAULT_FROM)
.to(DEFAULT_TO)
.comment(DEFAULT_COMMENT);
// Add required entity
Customer customer = CustomerResourceIntTest.createEntity(em);
em.persist(customer);
@@ -134,8 +142,9 @@ public class MembershipResourceIntTest {
List<Membership> membershipList = membershipRepository.findAll();
assertThat(membershipList).hasSize(databaseSizeBeforeCreate + 1);
Membership testMembership = membershipList.get(membershipList.size() - 1);
assertThat(testMembership.getSinceDate()).isEqualTo(DEFAULT_SINCE_DATE);
assertThat(testMembership.getUntilDate()).isEqualTo(DEFAULT_UNTIL_DATE);
assertThat(testMembership.getFrom()).isEqualTo(DEFAULT_FROM);
assertThat(testMembership.getTo()).isEqualTo(DEFAULT_TO);
assertThat(testMembership.getComment()).isEqualTo(DEFAULT_COMMENT);
}
@Test
@@ -160,10 +169,10 @@ public class MembershipResourceIntTest {
@Test
@Transactional
public void checkSinceDateIsRequired() throws Exception {
public void checkFromIsRequired() throws Exception {
int databaseSizeBeforeTest = membershipRepository.findAll().size();
// set the field null
membership.setSinceDate(null);
membership.setFrom(null);
// Create the Membership, which fails.
MembershipDTO membershipDTO = membershipMapper.toDto(membership);
@@ -188,8 +197,9 @@ public class MembershipResourceIntTest {
.andExpect(status().isOk())
.andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
.andExpect(jsonPath("$.[*].id").value(hasItem(membership.getId().intValue())))
.andExpect(jsonPath("$.[*].sinceDate").value(hasItem(DEFAULT_SINCE_DATE.toString())))
.andExpect(jsonPath("$.[*].untilDate").value(hasItem(DEFAULT_UNTIL_DATE.toString())));
.andExpect(jsonPath("$.[*].from").value(hasItem(DEFAULT_FROM.toString())))
.andExpect(jsonPath("$.[*].to").value(hasItem(DEFAULT_TO.toString())))
.andExpect(jsonPath("$.[*].comment").value(hasItem(DEFAULT_COMMENT.toString())));
}
@Test
@@ -203,142 +213,182 @@ public class MembershipResourceIntTest {
.andExpect(status().isOk())
.andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
.andExpect(jsonPath("$.id").value(membership.getId().intValue()))
.andExpect(jsonPath("$.sinceDate").value(DEFAULT_SINCE_DATE.toString()))
.andExpect(jsonPath("$.untilDate").value(DEFAULT_UNTIL_DATE.toString()));
.andExpect(jsonPath("$.from").value(DEFAULT_FROM.toString()))
.andExpect(jsonPath("$.to").value(DEFAULT_TO.toString()))
.andExpect(jsonPath("$.comment").value(DEFAULT_COMMENT.toString()));
}
@Test
@Transactional
public void getAllMembershipsBySinceDateIsEqualToSomething() throws Exception {
public void getAllMembershipsByFromIsEqualToSomething() throws Exception {
// Initialize the database
membershipRepository.saveAndFlush(membership);
// Get all the membershipList where sinceDate equals to DEFAULT_SINCE_DATE
defaultMembershipShouldBeFound("sinceDate.equals=" + DEFAULT_SINCE_DATE);
// Get all the membershipList where from equals to DEFAULT_FROM
defaultMembershipShouldBeFound("from.equals=" + DEFAULT_FROM);
// Get all the membershipList where sinceDate equals to UPDATED_SINCE_DATE
defaultMembershipShouldNotBeFound("sinceDate.equals=" + UPDATED_SINCE_DATE);
// Get all the membershipList where from equals to UPDATED_FROM
defaultMembershipShouldNotBeFound("from.equals=" + UPDATED_FROM);
}
@Test
@Transactional
public void getAllMembershipsBySinceDateIsInShouldWork() throws Exception {
public void getAllMembershipsByFromIsInShouldWork() throws Exception {
// Initialize the database
membershipRepository.saveAndFlush(membership);
// Get all the membershipList where sinceDate in DEFAULT_SINCE_DATE or UPDATED_SINCE_DATE
defaultMembershipShouldBeFound("sinceDate.in=" + DEFAULT_SINCE_DATE + "," + UPDATED_SINCE_DATE);
// Get all the membershipList where from in DEFAULT_FROM or UPDATED_FROM
defaultMembershipShouldBeFound("from.in=" + DEFAULT_FROM + "," + UPDATED_FROM);
// Get all the membershipList where sinceDate equals to UPDATED_SINCE_DATE
defaultMembershipShouldNotBeFound("sinceDate.in=" + UPDATED_SINCE_DATE);
// Get all the membershipList where from equals to UPDATED_FROM
defaultMembershipShouldNotBeFound("from.in=" + UPDATED_FROM);
}
@Test
@Transactional
public void getAllMembershipsBySinceDateIsNullOrNotNull() throws Exception {
public void getAllMembershipsByFromIsNullOrNotNull() throws Exception {
// Initialize the database
membershipRepository.saveAndFlush(membership);
// Get all the membershipList where sinceDate is not null
defaultMembershipShouldBeFound("sinceDate.specified=true");
// Get all the membershipList where from is not null
defaultMembershipShouldBeFound("from.specified=true");
// Get all the membershipList where sinceDate is null
defaultMembershipShouldNotBeFound("sinceDate.specified=false");
// Get all the membershipList where from is null
defaultMembershipShouldNotBeFound("from.specified=false");
}
@Test
@Transactional
public void getAllMembershipsBySinceDateIsGreaterThanOrEqualToSomething() throws Exception {
public void getAllMembershipsByFromIsGreaterThanOrEqualToSomething() throws Exception {
// Initialize the database
membershipRepository.saveAndFlush(membership);
// Get all the membershipList where sinceDate greater than or equals to DEFAULT_SINCE_DATE
defaultMembershipShouldBeFound("sinceDate.greaterOrEqualThan=" + DEFAULT_SINCE_DATE);
// Get all the membershipList where from greater than or equals to DEFAULT_FROM
defaultMembershipShouldBeFound("from.greaterOrEqualThan=" + DEFAULT_FROM);
// Get all the membershipList where sinceDate greater than or equals to UPDATED_SINCE_DATE
defaultMembershipShouldNotBeFound("sinceDate.greaterOrEqualThan=" + UPDATED_SINCE_DATE);
// Get all the membershipList where from greater than or equals to UPDATED_FROM
defaultMembershipShouldNotBeFound("from.greaterOrEqualThan=" + UPDATED_FROM);
}
@Test
@Transactional
public void getAllMembershipsBySinceDateIsLessThanSomething() throws Exception {
public void getAllMembershipsByFromIsLessThanSomething() throws Exception {
// Initialize the database
membershipRepository.saveAndFlush(membership);
// Get all the membershipList where sinceDate less than or equals to DEFAULT_SINCE_DATE
defaultMembershipShouldNotBeFound("sinceDate.lessThan=" + DEFAULT_SINCE_DATE);
// Get all the membershipList where from less than or equals to DEFAULT_FROM
defaultMembershipShouldNotBeFound("from.lessThan=" + DEFAULT_FROM);
// Get all the membershipList where sinceDate less than or equals to UPDATED_SINCE_DATE
defaultMembershipShouldBeFound("sinceDate.lessThan=" + UPDATED_SINCE_DATE);
// Get all the membershipList where from less than or equals to UPDATED_FROM
defaultMembershipShouldBeFound("from.lessThan=" + UPDATED_FROM);
}
@Test
@Transactional
public void getAllMembershipsByUntilDateIsEqualToSomething() throws Exception {
public void getAllMembershipsByToIsEqualToSomething() throws Exception {
// Initialize the database
membershipRepository.saveAndFlush(membership);
// Get all the membershipList where untilDate equals to DEFAULT_UNTIL_DATE
defaultMembershipShouldBeFound("untilDate.equals=" + DEFAULT_UNTIL_DATE);
// Get all the membershipList where to equals to DEFAULT_TO
defaultMembershipShouldBeFound("to.equals=" + DEFAULT_TO);
// Get all the membershipList where untilDate equals to UPDATED_UNTIL_DATE
defaultMembershipShouldNotBeFound("untilDate.equals=" + UPDATED_UNTIL_DATE);
// Get all the membershipList where to equals to UPDATED_TO
defaultMembershipShouldNotBeFound("to.equals=" + UPDATED_TO);
}
@Test
@Transactional
public void getAllMembershipsByUntilDateIsInShouldWork() throws Exception {
public void getAllMembershipsByToIsInShouldWork() throws Exception {
// Initialize the database
membershipRepository.saveAndFlush(membership);
// Get all the membershipList where untilDate in DEFAULT_UNTIL_DATE or UPDATED_UNTIL_DATE
defaultMembershipShouldBeFound("untilDate.in=" + DEFAULT_UNTIL_DATE + "," + UPDATED_UNTIL_DATE);
// Get all the membershipList where to in DEFAULT_TO or UPDATED_TO
defaultMembershipShouldBeFound("to.in=" + DEFAULT_TO + "," + UPDATED_TO);
// Get all the membershipList where untilDate equals to UPDATED_UNTIL_DATE
defaultMembershipShouldNotBeFound("untilDate.in=" + UPDATED_UNTIL_DATE);
// Get all the membershipList where to equals to UPDATED_TO
defaultMembershipShouldNotBeFound("to.in=" + UPDATED_TO);
}
@Test
@Transactional
public void getAllMembershipsByUntilDateIsNullOrNotNull() throws Exception {
public void getAllMembershipsByToIsNullOrNotNull() throws Exception {
// Initialize the database
membershipRepository.saveAndFlush(membership);
// Get all the membershipList where untilDate is not null
defaultMembershipShouldBeFound("untilDate.specified=true");
// Get all the membershipList where to is not null
defaultMembershipShouldBeFound("to.specified=true");
// Get all the membershipList where untilDate is null
defaultMembershipShouldNotBeFound("untilDate.specified=false");
// Get all the membershipList where to is null
defaultMembershipShouldNotBeFound("to.specified=false");
}
@Test
@Transactional
public void getAllMembershipsByUntilDateIsGreaterThanOrEqualToSomething() throws Exception {
public void getAllMembershipsByToIsGreaterThanOrEqualToSomething() throws Exception {
// Initialize the database
membershipRepository.saveAndFlush(membership);
// Get all the membershipList where untilDate greater than or equals to DEFAULT_UNTIL_DATE
defaultMembershipShouldBeFound("untilDate.greaterOrEqualThan=" + DEFAULT_UNTIL_DATE);
// Get all the membershipList where to greater than or equals to DEFAULT_TO
defaultMembershipShouldBeFound("to.greaterOrEqualThan=" + DEFAULT_TO);
// Get all the membershipList where untilDate greater than or equals to UPDATED_UNTIL_DATE
defaultMembershipShouldNotBeFound("untilDate.greaterOrEqualThan=" + UPDATED_UNTIL_DATE);
// Get all the membershipList where to greater than or equals to UPDATED_TO
defaultMembershipShouldNotBeFound("to.greaterOrEqualThan=" + UPDATED_TO);
}
@Test
@Transactional
public void getAllMembershipsByUntilDateIsLessThanSomething() throws Exception {
public void getAllMembershipsByToIsLessThanSomething() throws Exception {
// Initialize the database
membershipRepository.saveAndFlush(membership);
// Get all the membershipList where untilDate less than or equals to DEFAULT_UNTIL_DATE
defaultMembershipShouldNotBeFound("untilDate.lessThan=" + DEFAULT_UNTIL_DATE);
// Get all the membershipList where to less than or equals to DEFAULT_TO
defaultMembershipShouldNotBeFound("to.lessThan=" + DEFAULT_TO);
// Get all the membershipList where untilDate less than or equals to UPDATED_UNTIL_DATE
defaultMembershipShouldBeFound("untilDate.lessThan=" + UPDATED_UNTIL_DATE);
// Get all the membershipList where to less than or equals to UPDATED_TO
defaultMembershipShouldBeFound("to.lessThan=" + UPDATED_TO);
}
@Test
@Transactional
public void getAllMembershipsByCommentIsEqualToSomething() throws Exception {
// Initialize the database
membershipRepository.saveAndFlush(membership);
// Get all the membershipList where comment equals to DEFAULT_COMMENT
defaultMembershipShouldBeFound("comment.equals=" + DEFAULT_COMMENT);
// Get all the membershipList where comment equals to UPDATED_COMMENT
defaultMembershipShouldNotBeFound("comment.equals=" + UPDATED_COMMENT);
}
@Test
@Transactional
public void getAllMembershipsByCommentIsInShouldWork() throws Exception {
// Initialize the database
membershipRepository.saveAndFlush(membership);
// Get all the membershipList where comment in DEFAULT_COMMENT or UPDATED_COMMENT
defaultMembershipShouldBeFound("comment.in=" + DEFAULT_COMMENT + "," + UPDATED_COMMENT);
// Get all the membershipList where comment equals to UPDATED_COMMENT
defaultMembershipShouldNotBeFound("comment.in=" + UPDATED_COMMENT);
}
@Test
@Transactional
public void getAllMembershipsByCommentIsNullOrNotNull() throws Exception {
// Initialize the database
membershipRepository.saveAndFlush(membership);
// Get all the membershipList where comment is not null
defaultMembershipShouldBeFound("comment.specified=true");
// Get all the membershipList where comment is null
defaultMembershipShouldNotBeFound("comment.specified=false");
}
@Test
@Transactional
public void getAllMembershipsByShareIsEqualToSomething() throws Exception {
@@ -403,8 +453,9 @@ public class MembershipResourceIntTest {
.andExpect(status().isOk())
.andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
.andExpect(jsonPath("$.[*].id").value(hasItem(membership.getId().intValue())))
.andExpect(jsonPath("$.[*].sinceDate").value(hasItem(DEFAULT_SINCE_DATE.toString())))
.andExpect(jsonPath("$.[*].untilDate").value(hasItem(DEFAULT_UNTIL_DATE.toString())));
.andExpect(jsonPath("$.[*].from").value(hasItem(DEFAULT_FROM.toString())))
.andExpect(jsonPath("$.[*].to").value(hasItem(DEFAULT_TO.toString())))
.andExpect(jsonPath("$.[*].comment").value(hasItem(DEFAULT_COMMENT)));
// Check, that the count call also returns 1
restMembershipMockMvc.perform(get("/api/memberships/count?sort=id,desc&" + filter))
@@ -452,8 +503,9 @@ public class MembershipResourceIntTest {
// Disconnect from session so that the updates on updatedMembership are not directly saved in db
em.detach(updatedMembership);
updatedMembership
.sinceDate(UPDATED_SINCE_DATE)
.untilDate(UPDATED_UNTIL_DATE);
.from(UPDATED_FROM)
.to(UPDATED_TO)
.comment(UPDATED_COMMENT);
MembershipDTO membershipDTO = membershipMapper.toDto(updatedMembership);
restMembershipMockMvc.perform(put("/api/memberships")
@@ -465,8 +517,9 @@ public class MembershipResourceIntTest {
List<Membership> membershipList = membershipRepository.findAll();
assertThat(membershipList).hasSize(databaseSizeBeforeUpdate);
Membership testMembership = membershipList.get(membershipList.size() - 1);
assertThat(testMembership.getSinceDate()).isEqualTo(UPDATED_SINCE_DATE);
assertThat(testMembership.getUntilDate()).isEqualTo(UPDATED_UNTIL_DATE);
assertThat(testMembership.getFrom()).isEqualTo(UPDATED_FROM);
assertThat(testMembership.getTo()).isEqualTo(UPDATED_TO);
assertThat(testMembership.getComment()).isEqualTo(UPDATED_COMMENT);
}
@Test

972
src/test/java/org/hostsharing/hsadminng/web/rest/SepaMandateResourceIntTest.java Normal file
View File

@@ -0,0 +1,972 @@
package org.hostsharing.hsadminng.web.rest;
import org.hostsharing.hsadminng.HsadminNgApp;
import org.hostsharing.hsadminng.domain.SepaMandate;
import org.hostsharing.hsadminng.domain.Customer;
import org.hostsharing.hsadminng.repository.SepaMandateRepository;
import org.hostsharing.hsadminng.service.SepaMandateService;
import org.hostsharing.hsadminng.service.dto.SepaMandateDTO;
import org.hostsharing.hsadminng.service.mapper.SepaMandateMapper;
import org.hostsharing.hsadminng.web.rest.errors.ExceptionTranslator;
import org.hostsharing.hsadminng.service.dto.SepaMandateCriteria;
import org.hostsharing.hsadminng.service.SepaMandateQueryService;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.MockitoAnnotations;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
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 org.springframework.validation.Validator;
import javax.persistence.EntityManager;
import java.time.LocalDate;
import java.time.ZoneId;
import java.util.List;
import static org.hostsharing.hsadminng.web.rest.TestUtil.createFormattingConversionService;
import static org.assertj.core.api.Assertions.assertThat;
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 SepaMandateResource REST controller.
*
* @see SepaMandateResource
*/
@RunWith(SpringRunner.class)
@SpringBootTest(classes = HsadminNgApp.class)
public class SepaMandateResourceIntTest {
private static final String DEFAULT_REFERENCE = "AAAAAAAAAA";
private static final String UPDATED_REFERENCE = "BBBBBBBBBB";
private static final String DEFAULT_IBAN = "AAAAAAAAAA";
private static final String UPDATED_IBAN = "BBBBBBBBBB";
private static final String DEFAULT_BIC = "AAAAAAAAAA";
private static final String UPDATED_BIC = "BBBBBBBBBB";
private static final LocalDate DEFAULT_CREATED = LocalDate.ofEpochDay(0L);
private static final LocalDate UPDATED_CREATED = LocalDate.now(ZoneId.systemDefault());
private static final LocalDate DEFAULT_VALID_FROM = LocalDate.ofEpochDay(0L);
private static final LocalDate UPDATED_VALID_FROM = LocalDate.now(ZoneId.systemDefault());
private static final LocalDate DEFAULT_VALID_TO = LocalDate.ofEpochDay(0L);
private static final LocalDate UPDATED_VALID_TO = LocalDate.now(ZoneId.systemDefault());
private static final LocalDate DEFAULT_LAST_USED = LocalDate.ofEpochDay(0L);
private static final LocalDate UPDATED_LAST_USED = LocalDate.now(ZoneId.systemDefault());
private static final LocalDate DEFAULT_CANCELLED = LocalDate.ofEpochDay(0L);
private static final LocalDate UPDATED_CANCELLED = LocalDate.now(ZoneId.systemDefault());
private static final String DEFAULT_COMMENT = "AAAAAAAAAA";
private static final String UPDATED_COMMENT = "BBBBBBBBBB";
@Autowired
private SepaMandateRepository sepaMandateRepository;
@Autowired
private SepaMandateMapper sepaMandateMapper;
@Autowired
private SepaMandateService sepaMandateService;
@Autowired
private SepaMandateQueryService sepaMandateQueryService;
@Autowired
private MappingJackson2HttpMessageConverter jacksonMessageConverter;
@Autowired
private PageableHandlerMethodArgumentResolver pageableArgumentResolver;
@Autowired
private ExceptionTranslator exceptionTranslator;
@Autowired
private EntityManager em;
@Autowired
private Validator validator;
private MockMvc restSepaMandateMockMvc;
private SepaMandate sepaMandate;
@Before
public void setup() {
MockitoAnnotations.initMocks(this);
final SepaMandateResource sepaMandateResource = new SepaMandateResource(sepaMandateService, sepaMandateQueryService);
this.restSepaMandateMockMvc = MockMvcBuilders.standaloneSetup(sepaMandateResource)
.setCustomArgumentResolvers(pageableArgumentResolver)
.setControllerAdvice(exceptionTranslator)
.setConversionService(createFormattingConversionService())
.setMessageConverters(jacksonMessageConverter)
.setValidator(validator).build();
}
/**
* Create an entity for this test.
*
* This is a static method, as tests for other entities might also need it,
* if they test an entity which requires the current entity.
*/
public static SepaMandate createEntity(EntityManager em) {
SepaMandate sepaMandate = new SepaMandate()
.reference(DEFAULT_REFERENCE)
.iban(DEFAULT_IBAN)
.bic(DEFAULT_BIC)
.created(DEFAULT_CREATED)
.validFrom(DEFAULT_VALID_FROM)
.validTo(DEFAULT_VALID_TO)
.lastUsed(DEFAULT_LAST_USED)
.cancelled(DEFAULT_CANCELLED)
.comment(DEFAULT_COMMENT);
// Add required entity
Customer customer = CustomerResourceIntTest.createEntity(em);
em.persist(customer);
em.flush();
sepaMandate.setCustomer(customer);
return sepaMandate;
}
@Before
public void initTest() {
sepaMandate = createEntity(em);
}
@Test
@Transactional
public void createSepaMandate() throws Exception {
int databaseSizeBeforeCreate = sepaMandateRepository.findAll().size();
// Create the SepaMandate
SepaMandateDTO sepaMandateDTO = sepaMandateMapper.toDto(sepaMandate);
restSepaMandateMockMvc.perform(post("/api/sepa-mandates")
.contentType(TestUtil.APPLICATION_JSON_UTF8)
.content(TestUtil.convertObjectToJsonBytes(sepaMandateDTO)))
.andExpect(status().isCreated());
// Validate the SepaMandate in the database
List<SepaMandate> sepaMandateList = sepaMandateRepository.findAll();
assertThat(sepaMandateList).hasSize(databaseSizeBeforeCreate + 1);
SepaMandate testSepaMandate = sepaMandateList.get(sepaMandateList.size() - 1);
assertThat(testSepaMandate.getReference()).isEqualTo(DEFAULT_REFERENCE);
assertThat(testSepaMandate.getIban()).isEqualTo(DEFAULT_IBAN);
assertThat(testSepaMandate.getBic()).isEqualTo(DEFAULT_BIC);
assertThat(testSepaMandate.getCreated()).isEqualTo(DEFAULT_CREATED);
assertThat(testSepaMandate.getValidFrom()).isEqualTo(DEFAULT_VALID_FROM);
assertThat(testSepaMandate.getValidTo()).isEqualTo(DEFAULT_VALID_TO);
assertThat(testSepaMandate.getLastUsed()).isEqualTo(DEFAULT_LAST_USED);
assertThat(testSepaMandate.getCancelled()).isEqualTo(DEFAULT_CANCELLED);
assertThat(testSepaMandate.getComment()).isEqualTo(DEFAULT_COMMENT);
}
@Test
@Transactional
public void createSepaMandateWithExistingId() throws Exception {
int databaseSizeBeforeCreate = sepaMandateRepository.findAll().size();
// Create the SepaMandate with an existing ID
sepaMandate.setId(1L);
SepaMandateDTO sepaMandateDTO = sepaMandateMapper.toDto(sepaMandate);
// An entity with an existing ID cannot be created, so this API call must fail
restSepaMandateMockMvc.perform(post("/api/sepa-mandates")
.contentType(TestUtil.APPLICATION_JSON_UTF8)
.content(TestUtil.convertObjectToJsonBytes(sepaMandateDTO)))
.andExpect(status().isBadRequest());
// Validate the SepaMandate in the database
List<SepaMandate> sepaMandateList = sepaMandateRepository.findAll();
assertThat(sepaMandateList).hasSize(databaseSizeBeforeCreate);
}
@Test
@Transactional
public void checkReferenceIsRequired() throws Exception {
int databaseSizeBeforeTest = sepaMandateRepository.findAll().size();
// set the field null
sepaMandate.setReference(null);
// Create the SepaMandate, which fails.
SepaMandateDTO sepaMandateDTO = sepaMandateMapper.toDto(sepaMandate);
restSepaMandateMockMvc.perform(post("/api/sepa-mandates")
.contentType(TestUtil.APPLICATION_JSON_UTF8)
.content(TestUtil.convertObjectToJsonBytes(sepaMandateDTO)))
.andExpect(status().isBadRequest());
List<SepaMandate> sepaMandateList = sepaMandateRepository.findAll();
assertThat(sepaMandateList).hasSize(databaseSizeBeforeTest);
}
@Test
@Transactional
public void checkCreatedIsRequired() throws Exception {
int databaseSizeBeforeTest = sepaMandateRepository.findAll().size();
// set the field null
sepaMandate.setCreated(null);
// Create the SepaMandate, which fails.
SepaMandateDTO sepaMandateDTO = sepaMandateMapper.toDto(sepaMandate);
restSepaMandateMockMvc.perform(post("/api/sepa-mandates")
.contentType(TestUtil.APPLICATION_JSON_UTF8)
.content(TestUtil.convertObjectToJsonBytes(sepaMandateDTO)))
.andExpect(status().isBadRequest());
List<SepaMandate> sepaMandateList = sepaMandateRepository.findAll();
assertThat(sepaMandateList).hasSize(databaseSizeBeforeTest);
}
@Test
@Transactional
public void checkValidFromIsRequired() throws Exception {
int databaseSizeBeforeTest = sepaMandateRepository.findAll().size();
// set the field null
sepaMandate.setValidFrom(null);
// Create the SepaMandate, which fails.
SepaMandateDTO sepaMandateDTO = sepaMandateMapper.toDto(sepaMandate);
restSepaMandateMockMvc.perform(post("/api/sepa-mandates")
.contentType(TestUtil.APPLICATION_JSON_UTF8)
.content(TestUtil.convertObjectToJsonBytes(sepaMandateDTO)))
.andExpect(status().isBadRequest());
List<SepaMandate> sepaMandateList = sepaMandateRepository.findAll();
assertThat(sepaMandateList).hasSize(databaseSizeBeforeTest);
}
@Test
@Transactional
public void getAllSepaMandates() throws Exception {
// Initialize the database
sepaMandateRepository.saveAndFlush(sepaMandate);
// Get all the sepaMandateList
restSepaMandateMockMvc.perform(get("/api/sepa-mandates?sort=id,desc"))
.andExpect(status().isOk())
.andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
.andExpect(jsonPath("$.[*].id").value(hasItem(sepaMandate.getId().intValue())))
.andExpect(jsonPath("$.[*].reference").value(hasItem(DEFAULT_REFERENCE.toString())))
.andExpect(jsonPath("$.[*].iban").value(hasItem(DEFAULT_IBAN.toString())))
.andExpect(jsonPath("$.[*].bic").value(hasItem(DEFAULT_BIC.toString())))
.andExpect(jsonPath("$.[*].created").value(hasItem(DEFAULT_CREATED.toString())))
.andExpect(jsonPath("$.[*].validFrom").value(hasItem(DEFAULT_VALID_FROM.toString())))
.andExpect(jsonPath("$.[*].validTo").value(hasItem(DEFAULT_VALID_TO.toString())))
.andExpect(jsonPath("$.[*].lastUsed").value(hasItem(DEFAULT_LAST_USED.toString())))
.andExpect(jsonPath("$.[*].cancelled").value(hasItem(DEFAULT_CANCELLED.toString())))
.andExpect(jsonPath("$.[*].comment").value(hasItem(DEFAULT_COMMENT.toString())));
}
@Test
@Transactional
public void getSepaMandate() throws Exception {
// Initialize the database
sepaMandateRepository.saveAndFlush(sepaMandate);
// Get the sepaMandate
restSepaMandateMockMvc.perform(get("/api/sepa-mandates/{id}", sepaMandate.getId()))
.andExpect(status().isOk())
.andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
.andExpect(jsonPath("$.id").value(sepaMandate.getId().intValue()))
.andExpect(jsonPath("$.reference").value(DEFAULT_REFERENCE.toString()))
.andExpect(jsonPath("$.iban").value(DEFAULT_IBAN.toString()))
.andExpect(jsonPath("$.bic").value(DEFAULT_BIC.toString()))
.andExpect(jsonPath("$.created").value(DEFAULT_CREATED.toString()))
.andExpect(jsonPath("$.validFrom").value(DEFAULT_VALID_FROM.toString()))
.andExpect(jsonPath("$.validTo").value(DEFAULT_VALID_TO.toString()))
.andExpect(jsonPath("$.lastUsed").value(DEFAULT_LAST_USED.toString()))
.andExpect(jsonPath("$.cancelled").value(DEFAULT_CANCELLED.toString()))
.andExpect(jsonPath("$.comment").value(DEFAULT_COMMENT.toString()));
}
@Test
@Transactional
public void getAllSepaMandatesByReferenceIsEqualToSomething() throws Exception {
// Initialize the database
sepaMandateRepository.saveAndFlush(sepaMandate);
// Get all the sepaMandateList where reference equals to DEFAULT_REFERENCE
defaultSepaMandateShouldBeFound("reference.equals=" + DEFAULT_REFERENCE);
// Get all the sepaMandateList where reference equals to UPDATED_REFERENCE
defaultSepaMandateShouldNotBeFound("reference.equals=" + UPDATED_REFERENCE);
}
@Test
@Transactional
public void getAllSepaMandatesByReferenceIsInShouldWork() throws Exception {
// Initialize the database
sepaMandateRepository.saveAndFlush(sepaMandate);
// Get all the sepaMandateList where reference in DEFAULT_REFERENCE or UPDATED_REFERENCE
defaultSepaMandateShouldBeFound("reference.in=" + DEFAULT_REFERENCE + "," + UPDATED_REFERENCE);
// Get all the sepaMandateList where reference equals to UPDATED_REFERENCE
defaultSepaMandateShouldNotBeFound("reference.in=" + UPDATED_REFERENCE);
}
@Test
@Transactional
public void getAllSepaMandatesByReferenceIsNullOrNotNull() throws Exception {
// Initialize the database
sepaMandateRepository.saveAndFlush(sepaMandate);
// Get all the sepaMandateList where reference is not null
defaultSepaMandateShouldBeFound("reference.specified=true");
// Get all the sepaMandateList where reference is null
defaultSepaMandateShouldNotBeFound("reference.specified=false");
}
@Test
@Transactional
public void getAllSepaMandatesByIbanIsEqualToSomething() throws Exception {
// Initialize the database
sepaMandateRepository.saveAndFlush(sepaMandate);
// Get all the sepaMandateList where iban equals to DEFAULT_IBAN
defaultSepaMandateShouldBeFound("iban.equals=" + DEFAULT_IBAN);
// Get all the sepaMandateList where iban equals to UPDATED_IBAN
defaultSepaMandateShouldNotBeFound("iban.equals=" + UPDATED_IBAN);
}
@Test
@Transactional
public void getAllSepaMandatesByIbanIsInShouldWork() throws Exception {
// Initialize the database
sepaMandateRepository.saveAndFlush(sepaMandate);
// Get all the sepaMandateList where iban in DEFAULT_IBAN or UPDATED_IBAN
defaultSepaMandateShouldBeFound("iban.in=" + DEFAULT_IBAN + "," + UPDATED_IBAN);
// Get all the sepaMandateList where iban equals to UPDATED_IBAN
defaultSepaMandateShouldNotBeFound("iban.in=" + UPDATED_IBAN);
}
@Test
@Transactional
public void getAllSepaMandatesByIbanIsNullOrNotNull() throws Exception {
// Initialize the database
sepaMandateRepository.saveAndFlush(sepaMandate);
// Get all the sepaMandateList where iban is not null
defaultSepaMandateShouldBeFound("iban.specified=true");
// Get all the sepaMandateList where iban is null
defaultSepaMandateShouldNotBeFound("iban.specified=false");
}
@Test
@Transactional
public void getAllSepaMandatesByBicIsEqualToSomething() throws Exception {
// Initialize the database
sepaMandateRepository.saveAndFlush(sepaMandate);
// Get all the sepaMandateList where bic equals to DEFAULT_BIC
defaultSepaMandateShouldBeFound("bic.equals=" + DEFAULT_BIC);
// Get all the sepaMandateList where bic equals to UPDATED_BIC
defaultSepaMandateShouldNotBeFound("bic.equals=" + UPDATED_BIC);
}
@Test
@Transactional
public void getAllSepaMandatesByBicIsInShouldWork() throws Exception {
// Initialize the database
sepaMandateRepository.saveAndFlush(sepaMandate);
// Get all the sepaMandateList where bic in DEFAULT_BIC or UPDATED_BIC
defaultSepaMandateShouldBeFound("bic.in=" + DEFAULT_BIC + "," + UPDATED_BIC);
// Get all the sepaMandateList where bic equals to UPDATED_BIC
defaultSepaMandateShouldNotBeFound("bic.in=" + UPDATED_BIC);
}
@Test
@Transactional
public void getAllSepaMandatesByBicIsNullOrNotNull() throws Exception {
// Initialize the database
sepaMandateRepository.saveAndFlush(sepaMandate);
// Get all the sepaMandateList where bic is not null
defaultSepaMandateShouldBeFound("bic.specified=true");
// Get all the sepaMandateList where bic is null
defaultSepaMandateShouldNotBeFound("bic.specified=false");
}
@Test
@Transactional
public void getAllSepaMandatesByCreatedIsEqualToSomething() throws Exception {
// Initialize the database
sepaMandateRepository.saveAndFlush(sepaMandate);
// Get all the sepaMandateList where created equals to DEFAULT_CREATED
defaultSepaMandateShouldBeFound("created.equals=" + DEFAULT_CREATED);
// Get all the sepaMandateList where created equals to UPDATED_CREATED
defaultSepaMandateShouldNotBeFound("created.equals=" + UPDATED_CREATED);
}
@Test
@Transactional
public void getAllSepaMandatesByCreatedIsInShouldWork() throws Exception {
// Initialize the database
sepaMandateRepository.saveAndFlush(sepaMandate);
// Get all the sepaMandateList where created in DEFAULT_CREATED or UPDATED_CREATED
defaultSepaMandateShouldBeFound("created.in=" + DEFAULT_CREATED + "," + UPDATED_CREATED);
// Get all the sepaMandateList where created equals to UPDATED_CREATED
defaultSepaMandateShouldNotBeFound("created.in=" + UPDATED_CREATED);
}
@Test
@Transactional
public void getAllSepaMandatesByCreatedIsNullOrNotNull() throws Exception {
// Initialize the database
sepaMandateRepository.saveAndFlush(sepaMandate);
// Get all the sepaMandateList where created is not null
defaultSepaMandateShouldBeFound("created.specified=true");
// Get all the sepaMandateList where created is null
defaultSepaMandateShouldNotBeFound("created.specified=false");
}
@Test
@Transactional
public void getAllSepaMandatesByCreatedIsGreaterThanOrEqualToSomething() throws Exception {
// Initialize the database
sepaMandateRepository.saveAndFlush(sepaMandate);
// Get all the sepaMandateList where created greater than or equals to DEFAULT_CREATED
defaultSepaMandateShouldBeFound("created.greaterOrEqualThan=" + DEFAULT_CREATED);
// Get all the sepaMandateList where created greater than or equals to UPDATED_CREATED
defaultSepaMandateShouldNotBeFound("created.greaterOrEqualThan=" + UPDATED_CREATED);
}
@Test
@Transactional
public void getAllSepaMandatesByCreatedIsLessThanSomething() throws Exception {
// Initialize the database
sepaMandateRepository.saveAndFlush(sepaMandate);
// Get all the sepaMandateList where created less than or equals to DEFAULT_CREATED
defaultSepaMandateShouldNotBeFound("created.lessThan=" + DEFAULT_CREATED);
// Get all the sepaMandateList where created less than or equals to UPDATED_CREATED
defaultSepaMandateShouldBeFound("created.lessThan=" + UPDATED_CREATED);
}
@Test
@Transactional
public void getAllSepaMandatesByValidFromIsEqualToSomething() throws Exception {
// Initialize the database
sepaMandateRepository.saveAndFlush(sepaMandate);
// Get all the sepaMandateList where validFrom equals to DEFAULT_VALID_FROM
defaultSepaMandateShouldBeFound("validFrom.equals=" + DEFAULT_VALID_FROM);
// Get all the sepaMandateList where validFrom equals to UPDATED_VALID_FROM
defaultSepaMandateShouldNotBeFound("validFrom.equals=" + UPDATED_VALID_FROM);
}
@Test
@Transactional
public void getAllSepaMandatesByValidFromIsInShouldWork() throws Exception {
// Initialize the database
sepaMandateRepository.saveAndFlush(sepaMandate);
// Get all the sepaMandateList where validFrom in DEFAULT_VALID_FROM or UPDATED_VALID_FROM
defaultSepaMandateShouldBeFound("validFrom.in=" + DEFAULT_VALID_FROM + "," + UPDATED_VALID_FROM);
// Get all the sepaMandateList where validFrom equals to UPDATED_VALID_FROM
defaultSepaMandateShouldNotBeFound("validFrom.in=" + UPDATED_VALID_FROM);
}
@Test
@Transactional
public void getAllSepaMandatesByValidFromIsNullOrNotNull() throws Exception {
// Initialize the database
sepaMandateRepository.saveAndFlush(sepaMandate);
// Get all the sepaMandateList where validFrom is not null
defaultSepaMandateShouldBeFound("validFrom.specified=true");
// Get all the sepaMandateList where validFrom is null
defaultSepaMandateShouldNotBeFound("validFrom.specified=false");
}
@Test
@Transactional
public void getAllSepaMandatesByValidFromIsGreaterThanOrEqualToSomething() throws Exception {
// Initialize the database
sepaMandateRepository.saveAndFlush(sepaMandate);
// Get all the sepaMandateList where validFrom greater than or equals to DEFAULT_VALID_FROM
defaultSepaMandateShouldBeFound("validFrom.greaterOrEqualThan=" + DEFAULT_VALID_FROM);
// Get all the sepaMandateList where validFrom greater than or equals to UPDATED_VALID_FROM
defaultSepaMandateShouldNotBeFound("validFrom.greaterOrEqualThan=" + UPDATED_VALID_FROM);
}
@Test
@Transactional
public void getAllSepaMandatesByValidFromIsLessThanSomething() throws Exception {
// Initialize the database
sepaMandateRepository.saveAndFlush(sepaMandate);
// Get all the sepaMandateList where validFrom less than or equals to DEFAULT_VALID_FROM
defaultSepaMandateShouldNotBeFound("validFrom.lessThan=" + DEFAULT_VALID_FROM);
// Get all the sepaMandateList where validFrom less than or equals to UPDATED_VALID_FROM
defaultSepaMandateShouldBeFound("validFrom.lessThan=" + UPDATED_VALID_FROM);
}
@Test
@Transactional
public void getAllSepaMandatesByValidToIsEqualToSomething() throws Exception {
// Initialize the database
sepaMandateRepository.saveAndFlush(sepaMandate);
// Get all the sepaMandateList where validTo equals to DEFAULT_VALID_TO
defaultSepaMandateShouldBeFound("validTo.equals=" + DEFAULT_VALID_TO);
// Get all the sepaMandateList where validTo equals to UPDATED_VALID_TO
defaultSepaMandateShouldNotBeFound("validTo.equals=" + UPDATED_VALID_TO);
}
@Test
@Transactional
public void getAllSepaMandatesByValidToIsInShouldWork() throws Exception {
// Initialize the database
sepaMandateRepository.saveAndFlush(sepaMandate);
// Get all the sepaMandateList where validTo in DEFAULT_VALID_TO or UPDATED_VALID_TO
defaultSepaMandateShouldBeFound("validTo.in=" + DEFAULT_VALID_TO + "," + UPDATED_VALID_TO);
// Get all the sepaMandateList where validTo equals to UPDATED_VALID_TO
defaultSepaMandateShouldNotBeFound("validTo.in=" + UPDATED_VALID_TO);
}
@Test
@Transactional
public void getAllSepaMandatesByValidToIsNullOrNotNull() throws Exception {
// Initialize the database
sepaMandateRepository.saveAndFlush(sepaMandate);
// Get all the sepaMandateList where validTo is not null
defaultSepaMandateShouldBeFound("validTo.specified=true");
// Get all the sepaMandateList where validTo is null
defaultSepaMandateShouldNotBeFound("validTo.specified=false");
}
@Test
@Transactional
public void getAllSepaMandatesByValidToIsGreaterThanOrEqualToSomething() throws Exception {
// Initialize the database
sepaMandateRepository.saveAndFlush(sepaMandate);
// Get all the sepaMandateList where validTo greater than or equals to DEFAULT_VALID_TO
defaultSepaMandateShouldBeFound("validTo.greaterOrEqualThan=" + DEFAULT_VALID_TO);
// Get all the sepaMandateList where validTo greater than or equals to UPDATED_VALID_TO
defaultSepaMandateShouldNotBeFound("validTo.greaterOrEqualThan=" + UPDATED_VALID_TO);
}
@Test
@Transactional
public void getAllSepaMandatesByValidToIsLessThanSomething() throws Exception {
// Initialize the database
sepaMandateRepository.saveAndFlush(sepaMandate);
// Get all the sepaMandateList where validTo less than or equals to DEFAULT_VALID_TO
defaultSepaMandateShouldNotBeFound("validTo.lessThan=" + DEFAULT_VALID_TO);
// Get all the sepaMandateList where validTo less than or equals to UPDATED_VALID_TO
defaultSepaMandateShouldBeFound("validTo.lessThan=" + UPDATED_VALID_TO);
}
@Test
@Transactional
public void getAllSepaMandatesByLastUsedIsEqualToSomething() throws Exception {
// Initialize the database
sepaMandateRepository.saveAndFlush(sepaMandate);
// Get all the sepaMandateList where lastUsed equals to DEFAULT_LAST_USED
defaultSepaMandateShouldBeFound("lastUsed.equals=" + DEFAULT_LAST_USED);
// Get all the sepaMandateList where lastUsed equals to UPDATED_LAST_USED
defaultSepaMandateShouldNotBeFound("lastUsed.equals=" + UPDATED_LAST_USED);
}
@Test
@Transactional
public void getAllSepaMandatesByLastUsedIsInShouldWork() throws Exception {
// Initialize the database
sepaMandateRepository.saveAndFlush(sepaMandate);
// Get all the sepaMandateList where lastUsed in DEFAULT_LAST_USED or UPDATED_LAST_USED
defaultSepaMandateShouldBeFound("lastUsed.in=" + DEFAULT_LAST_USED + "," + UPDATED_LAST_USED);
// Get all the sepaMandateList where lastUsed equals to UPDATED_LAST_USED
defaultSepaMandateShouldNotBeFound("lastUsed.in=" + UPDATED_LAST_USED);
}
@Test
@Transactional
public void getAllSepaMandatesByLastUsedIsNullOrNotNull() throws Exception {
// Initialize the database
sepaMandateRepository.saveAndFlush(sepaMandate);
// Get all the sepaMandateList where lastUsed is not null
defaultSepaMandateShouldBeFound("lastUsed.specified=true");
// Get all the sepaMandateList where lastUsed is null
defaultSepaMandateShouldNotBeFound("lastUsed.specified=false");
}
@Test
@Transactional
public void getAllSepaMandatesByLastUsedIsGreaterThanOrEqualToSomething() throws Exception {
// Initialize the database
sepaMandateRepository.saveAndFlush(sepaMandate);
// Get all the sepaMandateList where lastUsed greater than or equals to DEFAULT_LAST_USED
defaultSepaMandateShouldBeFound("lastUsed.greaterOrEqualThan=" + DEFAULT_LAST_USED);
// Get all the sepaMandateList where lastUsed greater than or equals to UPDATED_LAST_USED
defaultSepaMandateShouldNotBeFound("lastUsed.greaterOrEqualThan=" + UPDATED_LAST_USED);
}
@Test
@Transactional
public void getAllSepaMandatesByLastUsedIsLessThanSomething() throws Exception {
// Initialize the database
sepaMandateRepository.saveAndFlush(sepaMandate);
// Get all the sepaMandateList where lastUsed less than or equals to DEFAULT_LAST_USED
defaultSepaMandateShouldNotBeFound("lastUsed.lessThan=" + DEFAULT_LAST_USED);
// Get all the sepaMandateList where lastUsed less than or equals to UPDATED_LAST_USED
defaultSepaMandateShouldBeFound("lastUsed.lessThan=" + UPDATED_LAST_USED);
}
@Test
@Transactional
public void getAllSepaMandatesByCancelledIsEqualToSomething() throws Exception {
// Initialize the database
sepaMandateRepository.saveAndFlush(sepaMandate);
// Get all the sepaMandateList where cancelled equals to DEFAULT_CANCELLED
defaultSepaMandateShouldBeFound("cancelled.equals=" + DEFAULT_CANCELLED);
// Get all the sepaMandateList where cancelled equals to UPDATED_CANCELLED
defaultSepaMandateShouldNotBeFound("cancelled.equals=" + UPDATED_CANCELLED);
}
@Test
@Transactional
public void getAllSepaMandatesByCancelledIsInShouldWork() throws Exception {
// Initialize the database
sepaMandateRepository.saveAndFlush(sepaMandate);
// Get all the sepaMandateList where cancelled in DEFAULT_CANCELLED or UPDATED_CANCELLED
defaultSepaMandateShouldBeFound("cancelled.in=" + DEFAULT_CANCELLED + "," + UPDATED_CANCELLED);
// Get all the sepaMandateList where cancelled equals to UPDATED_CANCELLED
defaultSepaMandateShouldNotBeFound("cancelled.in=" + UPDATED_CANCELLED);
}
@Test
@Transactional
public void getAllSepaMandatesByCancelledIsNullOrNotNull() throws Exception {
// Initialize the database
sepaMandateRepository.saveAndFlush(sepaMandate);
// Get all the sepaMandateList where cancelled is not null
defaultSepaMandateShouldBeFound("cancelled.specified=true");
// Get all the sepaMandateList where cancelled is null
defaultSepaMandateShouldNotBeFound("cancelled.specified=false");
}
@Test
@Transactional
public void getAllSepaMandatesByCancelledIsGreaterThanOrEqualToSomething() throws Exception {
// Initialize the database
sepaMandateRepository.saveAndFlush(sepaMandate);
// Get all the sepaMandateList where cancelled greater than or equals to DEFAULT_CANCELLED
defaultSepaMandateShouldBeFound("cancelled.greaterOrEqualThan=" + DEFAULT_CANCELLED);
// Get all the sepaMandateList where cancelled greater than or equals to UPDATED_CANCELLED
defaultSepaMandateShouldNotBeFound("cancelled.greaterOrEqualThan=" + UPDATED_CANCELLED);
}
@Test
@Transactional
public void getAllSepaMandatesByCancelledIsLessThanSomething() throws Exception {
// Initialize the database
sepaMandateRepository.saveAndFlush(sepaMandate);
// Get all the sepaMandateList where cancelled less than or equals to DEFAULT_CANCELLED
defaultSepaMandateShouldNotBeFound("cancelled.lessThan=" + DEFAULT_CANCELLED);
// Get all the sepaMandateList where cancelled less than or equals to UPDATED_CANCELLED
defaultSepaMandateShouldBeFound("cancelled.lessThan=" + UPDATED_CANCELLED);
}
@Test
@Transactional
public void getAllSepaMandatesByCommentIsEqualToSomething() throws Exception {
// Initialize the database
sepaMandateRepository.saveAndFlush(sepaMandate);
// Get all the sepaMandateList where comment equals to DEFAULT_COMMENT
defaultSepaMandateShouldBeFound("comment.equals=" + DEFAULT_COMMENT);
// Get all the sepaMandateList where comment equals to UPDATED_COMMENT
defaultSepaMandateShouldNotBeFound("comment.equals=" + UPDATED_COMMENT);
}
@Test
@Transactional
public void getAllSepaMandatesByCommentIsInShouldWork() throws Exception {
// Initialize the database
sepaMandateRepository.saveAndFlush(sepaMandate);
// Get all the sepaMandateList where comment in DEFAULT_COMMENT or UPDATED_COMMENT
defaultSepaMandateShouldBeFound("comment.in=" + DEFAULT_COMMENT + "," + UPDATED_COMMENT);
// Get all the sepaMandateList where comment equals to UPDATED_COMMENT
defaultSepaMandateShouldNotBeFound("comment.in=" + UPDATED_COMMENT);
}
@Test
@Transactional
public void getAllSepaMandatesByCommentIsNullOrNotNull() throws Exception {
// Initialize the database
sepaMandateRepository.saveAndFlush(sepaMandate);
// Get all the sepaMandateList where comment is not null
defaultSepaMandateShouldBeFound("comment.specified=true");
// Get all the sepaMandateList where comment is null
defaultSepaMandateShouldNotBeFound("comment.specified=false");
}
@Test
@Transactional
public void getAllSepaMandatesByCustomerIsEqualToSomething() throws Exception {
// Initialize the database
Customer customer = CustomerResourceIntTest.createEntity(em);
em.persist(customer);
em.flush();
sepaMandate.setCustomer(customer);
sepaMandateRepository.saveAndFlush(sepaMandate);
Long customerId = customer.getId();
// Get all the sepaMandateList where customer equals to customerId
defaultSepaMandateShouldBeFound("customerId.equals=" + customerId);
// Get all the sepaMandateList where customer equals to customerId + 1
defaultSepaMandateShouldNotBeFound("customerId.equals=" + (customerId + 1));
}
/**
* Executes the search, and checks that the default entity is returned
*/
private void defaultSepaMandateShouldBeFound(String filter) throws Exception {
restSepaMandateMockMvc.perform(get("/api/sepa-mandates?sort=id,desc&" + filter))
.andExpect(status().isOk())
.andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
.andExpect(jsonPath("$.[*].id").value(hasItem(sepaMandate.getId().intValue())))
.andExpect(jsonPath("$.[*].reference").value(hasItem(DEFAULT_REFERENCE)))
.andExpect(jsonPath("$.[*].iban").value(hasItem(DEFAULT_IBAN)))
.andExpect(jsonPath("$.[*].bic").value(hasItem(DEFAULT_BIC)))
.andExpect(jsonPath("$.[*].created").value(hasItem(DEFAULT_CREATED.toString())))
.andExpect(jsonPath("$.[*].validFrom").value(hasItem(DEFAULT_VALID_FROM.toString())))
.andExpect(jsonPath("$.[*].validTo").value(hasItem(DEFAULT_VALID_TO.toString())))
.andExpect(jsonPath("$.[*].lastUsed").value(hasItem(DEFAULT_LAST_USED.toString())))
.andExpect(jsonPath("$.[*].cancelled").value(hasItem(DEFAULT_CANCELLED.toString())))
.andExpect(jsonPath("$.[*].comment").value(hasItem(DEFAULT_COMMENT)));
// Check, that the count call also returns 1
restSepaMandateMockMvc.perform(get("/api/sepa-mandates/count?sort=id,desc&" + filter))
.andExpect(status().isOk())
.andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
.andExpect(content().string("1"));
}
/**
* Executes the search, and checks that the default entity is not returned
*/
private void defaultSepaMandateShouldNotBeFound(String filter) throws Exception {
restSepaMandateMockMvc.perform(get("/api/sepa-mandates?sort=id,desc&" + filter))
.andExpect(status().isOk())
.andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
.andExpect(jsonPath("$").isArray())
.andExpect(jsonPath("$").isEmpty());
// Check, that the count call also returns 0
restSepaMandateMockMvc.perform(get("/api/sepa-mandates/count?sort=id,desc&" + filter))
.andExpect(status().isOk())
.andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8_VALUE))
.andExpect(content().string("0"));
}
@Test
@Transactional
public void getNonExistingSepaMandate() throws Exception {
// Get the sepaMandate
restSepaMandateMockMvc.perform(get("/api/sepa-mandates/{id}", Long.MAX_VALUE))
.andExpect(status().isNotFound());
}
@Test
@Transactional
public void updateSepaMandate() throws Exception {
// Initialize the database
sepaMandateRepository.saveAndFlush(sepaMandate);
int databaseSizeBeforeUpdate = sepaMandateRepository.findAll().size();
// Update the sepaMandate
SepaMandate updatedSepaMandate = sepaMandateRepository.findById(sepaMandate.getId()).get();
// Disconnect from session so that the updates on updatedSepaMandate are not directly saved in db
em.detach(updatedSepaMandate);
updatedSepaMandate
.reference(UPDATED_REFERENCE)
.iban(UPDATED_IBAN)
.bic(UPDATED_BIC)
.created(UPDATED_CREATED)
.validFrom(UPDATED_VALID_FROM)
.validTo(UPDATED_VALID_TO)
.lastUsed(UPDATED_LAST_USED)
.cancelled(UPDATED_CANCELLED)
.comment(UPDATED_COMMENT);
SepaMandateDTO sepaMandateDTO = sepaMandateMapper.toDto(updatedSepaMandate);
restSepaMandateMockMvc.perform(put("/api/sepa-mandates")
.contentType(TestUtil.APPLICATION_JSON_UTF8)
.content(TestUtil.convertObjectToJsonBytes(sepaMandateDTO)))
.andExpect(status().isOk());
// Validate the SepaMandate in the database
List<SepaMandate> sepaMandateList = sepaMandateRepository.findAll();
assertThat(sepaMandateList).hasSize(databaseSizeBeforeUpdate);
SepaMandate testSepaMandate = sepaMandateList.get(sepaMandateList.size() - 1);
assertThat(testSepaMandate.getReference()).isEqualTo(UPDATED_REFERENCE);
assertThat(testSepaMandate.getIban()).isEqualTo(UPDATED_IBAN);
assertThat(testSepaMandate.getBic()).isEqualTo(UPDATED_BIC);
assertThat(testSepaMandate.getCreated()).isEqualTo(UPDATED_CREATED);
assertThat(testSepaMandate.getValidFrom()).isEqualTo(UPDATED_VALID_FROM);
assertThat(testSepaMandate.getValidTo()).isEqualTo(UPDATED_VALID_TO);
assertThat(testSepaMandate.getLastUsed()).isEqualTo(UPDATED_LAST_USED);
assertThat(testSepaMandate.getCancelled()).isEqualTo(UPDATED_CANCELLED);
assertThat(testSepaMandate.getComment()).isEqualTo(UPDATED_COMMENT);
}
@Test
@Transactional
public void updateNonExistingSepaMandate() throws Exception {
int databaseSizeBeforeUpdate = sepaMandateRepository.findAll().size();
// Create the SepaMandate
SepaMandateDTO sepaMandateDTO = sepaMandateMapper.toDto(sepaMandate);
// If the entity doesn't have an ID, it will throw BadRequestAlertException
restSepaMandateMockMvc.perform(put("/api/sepa-mandates")
.contentType(TestUtil.APPLICATION_JSON_UTF8)
.content(TestUtil.convertObjectToJsonBytes(sepaMandateDTO)))
.andExpect(status().isBadRequest());
// Validate the SepaMandate in the database
List<SepaMandate> sepaMandateList = sepaMandateRepository.findAll();
assertThat(sepaMandateList).hasSize(databaseSizeBeforeUpdate);
}
@Test
@Transactional
public void deleteSepaMandate() throws Exception {
// Initialize the database
sepaMandateRepository.saveAndFlush(sepaMandate);
int databaseSizeBeforeDelete = sepaMandateRepository.findAll().size();
// Delete the sepaMandate
restSepaMandateMockMvc.perform(delete("/api/sepa-mandates/{id}", sepaMandate.getId())
.accept(TestUtil.APPLICATION_JSON_UTF8))
.andExpect(status().isOk());
// Validate the database is empty
List<SepaMandate> sepaMandateList = sepaMandateRepository.findAll();
assertThat(sepaMandateList).hasSize(databaseSizeBeforeDelete - 1);
}
@Test
@Transactional
public void equalsVerifier() throws Exception {
TestUtil.equalsVerifier(SepaMandate.class);
SepaMandate sepaMandate1 = new SepaMandate();
sepaMandate1.setId(1L);
SepaMandate sepaMandate2 = new SepaMandate();
sepaMandate2.setId(sepaMandate1.getId());
assertThat(sepaMandate1).isEqualTo(sepaMandate2);
sepaMandate2.setId(2L);
assertThat(sepaMandate1).isNotEqualTo(sepaMandate2);
sepaMandate1.setId(null);
assertThat(sepaMandate1).isNotEqualTo(sepaMandate2);
}
@Test
@Transactional
public void dtoEqualsVerifier() throws Exception {
TestUtil.equalsVerifier(SepaMandateDTO.class);
SepaMandateDTO sepaMandateDTO1 = new SepaMandateDTO();
sepaMandateDTO1.setId(1L);
SepaMandateDTO sepaMandateDTO2 = new SepaMandateDTO();
assertThat(sepaMandateDTO1).isNotEqualTo(sepaMandateDTO2);
sepaMandateDTO2.setId(sepaMandateDTO1.getId());
assertThat(sepaMandateDTO1).isEqualTo(sepaMandateDTO2);
sepaMandateDTO2.setId(2L);
assertThat(sepaMandateDTO1).isNotEqualTo(sepaMandateDTO2);
sepaMandateDTO1.setId(null);
assertThat(sepaMandateDTO1).isNotEqualTo(sepaMandateDTO2);
}
@Test
@Transactional
public void testEntityFromId() {
assertThat(sepaMandateMapper.fromId(42L).getId()).isEqualTo(42);
assertThat(sepaMandateMapper.fromId(null)).isNull();
}
}

33
src/test/java/org/hostsharing/hsadminng/web/rest/ShareResourceIntTest.java
View File

@@ -1,15 +1,17 @@
package org.hostsharing.hsadminng.web.rest;
import org.hostsharing.hsadminng.HsadminNgApp;
import org.hostsharing.hsadminng.domain.Membership;
import org.hostsharing.hsadminng.domain.Share;
import org.hostsharing.hsadminng.domain.enumeration.ShareAction;
import org.hostsharing.hsadminng.domain.Membership;
import org.hostsharing.hsadminng.repository.ShareRepository;
import org.hostsharing.hsadminng.service.ShareQueryService;
import org.hostsharing.hsadminng.service.ShareService;
import org.hostsharing.hsadminng.service.dto.ShareDTO;
import org.hostsharing.hsadminng.service.mapper.ShareMapper;
import org.hostsharing.hsadminng.web.rest.errors.ExceptionTranslator;
import org.hostsharing.hsadminng.service.dto.ShareCriteria;
import org.hostsharing.hsadminng.service.ShareQueryService;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -30,11 +32,14 @@ import java.time.LocalDate;
import java.time.ZoneId;
import java.util.List;
import static org.hostsharing.hsadminng.web.rest.TestUtil.createFormattingConversionService;
import static org.assertj.core.api.Assertions.assertThat;
import static org.hamcrest.Matchers.hasItem;
import static org.hostsharing.hsadminng.web.rest.TestUtil.createFormattingConversionService;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;
import org.hostsharing.hsadminng.domain.enumeration.ShareAction;
/**
* Test class for the ShareResource REST controller.
*
@@ -115,7 +120,7 @@ public class ShareResourceIntTest {
Membership membership = MembershipResourceIntTest.createEntity(em);
em.persist(membership);
em.flush();
share.setMember(membership);
share.setMembership(membership);
return share;
}
@@ -469,20 +474,20 @@ public class ShareResourceIntTest {
@Test
@Transactional
public void getAllSharesByMemberIsEqualToSomething() throws Exception {
public void getAllSharesByMembershipIsEqualToSomething() throws Exception {
// Initialize the database
Membership member = MembershipResourceIntTest.createEntity(em);
em.persist(member);
Membership membership = MembershipResourceIntTest.createEntity(em);
em.persist(membership);
em.flush();
share.setMember(member);
share.setMembership(membership);
shareRepository.saveAndFlush(share);
Long memberId = member.getId();
Long membershipId = membership.getId();
// Get all the shareList where member equals to memberId
defaultShareShouldBeFound("memberId.equals=" + memberId);
// Get all the shareList where membership equals to membershipId
defaultShareShouldBeFound("membershipId.equals=" + membershipId);
// Get all the shareList where member equals to memberId + 1
defaultShareShouldNotBeFound("memberId.equals=" + (memberId + 1));
// Get all the shareList where membership equals to membershipId + 1
defaultShareShouldNotBeFound("membershipId.equals=" + (membershipId + 1));
}
/**