@Test
  @Transactional
  public void updateBloodPressure() throws Exception {
    // Initialize the database
    bloodPressureRepository.saveAndFlush(bloodPressure);

    int databaseSizeBeforeUpdate = bloodPressureRepository.findAll().size();

    // Update the bloodPressure
    bloodPressure.setTimestamp(UPDATED_TIMESTAMP);
    bloodPressure.setSystolic(UPDATED_SYSTOLIC);
    bloodPressure.setDiastolic(UPDATED_DIASTOLIC);

    restBloodPressureMockMvc
        .perform(
            put("/api/bloodPressures")
                .contentType(TestUtil.APPLICATION_JSON_UTF8)
                .content(TestUtil.convertObjectToJsonBytes(bloodPressure)))
        .andExpect(status().isOk());

    // Validate the BloodPressure in the database
    List<BloodPressure> bloodPressures = bloodPressureRepository.findAll();
    assertThat(bloodPressures).hasSize(databaseSizeBeforeUpdate);
    BloodPressure testBloodPressure = bloodPressures.get(bloodPressures.size() - 1);
    assertThat(testBloodPressure.getTimestamp()).isEqualTo(UPDATED_TIMESTAMP);
    assertThat(testBloodPressure.getSystolic()).isEqualTo(UPDATED_SYSTOLIC);
    assertThat(testBloodPressure.getDiastolic()).isEqualTo(UPDATED_DIASTOLIC);
  }
  @Test
  @Transactional
  public void createJugadores() throws Exception {
    int databaseSizeBeforeCreate = jugadoresRepository.findAll().size();

    // Create the Jugadores

    restJugadoresMockMvc
        .perform(
            post("/api/jugadoress")
                .contentType(TestUtil.APPLICATION_JSON_UTF8)
                .content(TestUtil.convertObjectToJsonBytes(jugadores)))
        .andExpect(status().isCreated());

    // Validate the Jugadores in the database
    List<Jugadores> jugadoress = jugadoresRepository.findAll();
    assertThat(jugadoress).hasSize(databaseSizeBeforeCreate + 1);
    Jugadores testJugadores = jugadoress.get(jugadoress.size() - 1);
    assertThat(testJugadores.getNombreJugador()).isEqualTo(DEFAULT_NOMBRE_JUGADOR);
    assertThat(testJugadores.getFechaNacimiento()).isEqualTo(DEFAULT_FECHA_NACIMIENTO);
    assertThat(testJugadores.getNumCanastas()).isEqualTo(DEFAULT_NUM_CANASTAS);
    assertThat(testJugadores.getNumAsistencias()).isEqualTo(DEFAULT_NUM_ASISTENCIAS);
    assertThat(testJugadores.getNumRebotes()).isEqualTo(DEFAULT_NUM_REBOTES);
    assertThat(testJugadores.getPosicion()).isEqualTo(DEFAULT_POSICION);
  }
  @Test
  @Transactional
  public void updateBill_service() throws Exception {
    // Initialize the database
    bill_serviceRepository.saveAndFlush(bill_service);

    int databaseSizeBeforeUpdate = bill_serviceRepository.findAll().size();

    // Update the bill_service
    bill_service.setQuantity(UPDATED_QUANTITY);
    bill_service.setTotal(UPDATED_TOTAL);
    bill_service.setDecription(UPDATED_DECRIPTION);
    bill_service.setCreate_date(UPDATED_CREATE_DATE);

    restBill_serviceMockMvc
        .perform(
            put("/api/bill_services")
                .contentType(TestUtil.APPLICATION_JSON_UTF8)
                .content(TestUtil.convertObjectToJsonBytes(bill_service)))
        .andExpect(status().isOk());

    // Validate the Bill_service in the database
    List<Bill_service> bill_services = bill_serviceRepository.findAll();
    assertThat(bill_services).hasSize(databaseSizeBeforeUpdate);
    Bill_service testBill_service = bill_services.get(bill_services.size() - 1);
    assertThat(testBill_service.getQuantity()).isEqualTo(UPDATED_QUANTITY);
    assertThat(testBill_service.getTotal()).isEqualTo(UPDATED_TOTAL);
    assertThat(testBill_service.getDecription()).isEqualTo(UPDATED_DECRIPTION);
    assertThat(testBill_service.getCreate_date()).isEqualTo(UPDATED_CREATE_DATE);
  }
  @Test
  @Transactional
  public void createOperation() throws Exception {
    int databaseSizeBeforeCreate = operationRepository.findAll().size();

    // Create the Operation

    restOperationMockMvc
        .perform(
            post("/api/operations")
                .contentType(TestUtil.APPLICATION_JSON_UTF8)
                .content(TestUtil.convertObjectToJsonBytes(operation)))
        .andExpect(status().isCreated());

    // Validate the Operation in the database
    List<Operation> operations = operationRepository.findAll();
    assertThat(operations).hasSize(databaseSizeBeforeCreate + 1);
    Operation testOperation = operations.get(operations.size() - 1);
    assertThat(testOperation.getDate()).isEqualTo(DEFAULT_DATE);
    assertThat(testOperation.getDescription()).isEqualTo(DEFAULT_DESCRIPTION);
    assertThat(testOperation.getAmount()).isEqualTo(DEFAULT_AMOUNT);

    // Validate the Operation in ElasticSearch
    Operation operationEs = operationSearchRepository.findOne(testOperation.getId());
    assertThat(operationEs).isEqualToComparingFieldByField(testOperation);
  }
  @Test
  @Transactional
  public void updatePayment() throws Exception {
    // Initialize the database
    paymentRepository.saveAndFlush(payment);

    int databaseSizeBeforeUpdate = paymentRepository.findAll().size();

    // Update the payment
    payment.setName(UPDATED_NAME);
    payment.setImage(UPDATED_IMAGE);

    restPaymentMockMvc
        .perform(
            put("/api/payments")
                .contentType(TestUtil.APPLICATION_JSON_UTF8)
                .content(TestUtil.convertObjectToJsonBytes(payment)))
        .andExpect(status().isOk());

    // Validate the Payment in the database
    List<Payment> payments = paymentRepository.findAll();
    assertThat(payments).hasSize(databaseSizeBeforeUpdate);
    Payment testPayment = payments.get(payments.size() - 1);
    assertThat(testPayment.getName()).isEqualTo(UPDATED_NAME);
    assertThat(testPayment.getImage()).isEqualTo(UPDATED_IMAGE);
  }
  @Test
  @Transactional
  public void createOs_type() throws Exception {
    int databaseSizeBeforeCreate = os_typeRepository.findAll().size();

    // Create the Os_type

    restOs_typeMockMvc
        .perform(
            post("/api/os_types")
                .contentType(TestUtil.APPLICATION_JSON_UTF8)
                .content(TestUtil.convertObjectToJsonBytes(os_type)))
        .andExpect(status().isCreated());

    // Validate the Os_type in the database
    List<Os_type> os_types = os_typeRepository.findAll();
    assertThat(os_types).hasSize(databaseSizeBeforeCreate + 1);
    Os_type testOs_type = os_types.get(os_types.size() - 1);
    assertThat(testOs_type.getOs_type_name()).isEqualTo(DEFAULT_OS_TYPE_NAME);
    assertThat(testOs_type.getDescription()).isEqualTo(DEFAULT_DESCRIPTION);
    assertThat(testOs_type.getStatus_id()).isEqualTo(DEFAULT_STATUS_ID);
    assertThat(testOs_type.getCreated_by()).isEqualTo(DEFAULT_CREATED_BY);
    assertThat(testOs_type.getCreated_date()).isEqualTo(DEFAULT_CREATED_DATE);
    assertThat(testOs_type.getModified_by()).isEqualTo(DEFAULT_MODIFIED_BY);
    assertThat(testOs_type.getModified_date()).isEqualTo(DEFAULT_MODIFIED_DATE);
  }
  @Test
  @Transactional
  public void updateHotel() throws Exception {
    // Initialize the database
    hotelRepository.saveAndFlush(hotel);

    int databaseSizeBeforeUpdate = hotelRepository.findAll().size();

    // Update the hotel
    hotel.setName(UPDATED_NAME);
    hotel.setCode(UPDATED_CODE);

    restHotelMockMvc
        .perform(
            put("/api/hotels")
                .contentType(TestUtil.APPLICATION_JSON_UTF8)
                .content(TestUtil.convertObjectToJsonBytes(hotel)))
        .andExpect(status().isOk());

    // Validate the Hotel in the database
    List<Hotel> hotels = hotelRepository.findAll();
    assertThat(hotels).hasSize(databaseSizeBeforeUpdate);
    Hotel testHotel = hotels.get(hotels.size() - 1);
    assertThat(testHotel.getName()).isEqualTo(UPDATED_NAME);
    assertThat(testHotel.getCode()).isEqualTo(UPDATED_CODE);
  }
  @Test
  @Transactional
  public void updateCoupon() throws Exception {
    // Initialize the database
    couponRepository.saveAndFlush(coupon);

    int databaseSizeBeforeUpdate = couponRepository.findAll().size();

    // Update the coupon
    coupon.setCode(UPDATED_CODE);
    coupon.setPassword(UPDATED_PASSWORD);
    coupon.setCategory(UPDATED_CATEGORY);
    coupon.setStatus(STATUS.Unused);
    restCouponMockMvc
        .perform(
            put("/api/coupons")
                .contentType(TestUtil.APPLICATION_JSON_UTF8)
                .content(TestUtil.convertObjectToJsonBytes(coupon)))
        .andExpect(status().isOk());

    // Validate the Coupon in the database
    List<Coupon> coupons = couponRepository.findAll();
    assertThat(coupons).hasSize(databaseSizeBeforeUpdate);
    Coupon testCoupon = coupons.get(coupons.size() - 1);
    assertThat(testCoupon.getCode()).isEqualTo(UPDATED_CODE);
    assertThat(testCoupon.getPassword()).isEqualTo(UPDATED_PASSWORD);
    assertThat(testCoupon.getCategory()).isEqualTo(UPDATED_CATEGORY);
    assertThat(testCoupon.getStatus()).isEqualTo(UPDATED_STATUS);
  }
  @Test
  @Transactional
  public void createForum() throws Exception {
    int databaseSizeBeforeCreate = forumRepository.findAll().size();

    // Create the Forum
    restForumMockMvc
        .perform(
            post("/api/forums")
                .contentType(TestUtil.APPLICATION_JSON_UTF8)
                .content(TestUtil.convertObjectToJsonBytes(forum)))
        .andExpect(status().isCreated());

    // Validate the Forum in the database
    List<Forum> forums = forumRepository.findAll();
    assertThat(forums).hasSize(databaseSizeBeforeCreate + 1);
    Forum testForum = forums.get(forums.size() - 1);
    assertThat(testForum.getName()).isEqualTo(DEFAULT_NAME);
    assertThat(testForum.getDescription()).isEqualTo(DEFAULT_DESCRIPTION);
    assertThat(testForum.getDisplay()).isEqualTo(DEFAULT_DISPLAY);
    assertThat(testForum.getLft()).isEqualTo(DEFAULT_LFT);
    assertThat(testForum.getRgt()).isEqualTo(DEFAULT_RGT);
    assertThat(testForum.getPostCount()).isEqualTo(DEFAULT_POST_COUNT);
    assertThat(testForum.getTopicCount()).isEqualTo(DEFAULT_TOPIC_COUNT);
    assertThat(testForum.getLocked()).isEqualTo(DEFAULT_LOCKED);
  }
  @Test
  @Transactional
  public void updateMethod_payment() throws Exception {
    // Initialize the database
    method_paymentRepository.saveAndFlush(method_payment);

    int databaseSizeBeforeUpdate = method_paymentRepository.findAll().size();

    // Update the method_payment
    method_payment.setName(UPDATED_NAME);
    method_payment.setDecription(UPDATED_DECRIPTION);
    method_payment.setCreate_date(UPDATED_CREATE_DATE);

    restMethod_paymentMockMvc
        .perform(
            put("/api/method_payments")
                .contentType(TestUtil.APPLICATION_JSON_UTF8)
                .content(TestUtil.convertObjectToJsonBytes(method_payment)))
        .andExpect(status().isOk());

    // Validate the Method_payment in the database
    List<Method_payment> method_payments = method_paymentRepository.findAll();
    assertThat(method_payments).hasSize(databaseSizeBeforeUpdate);
    Method_payment testMethod_payment = method_payments.get(method_payments.size() - 1);
    assertThat(testMethod_payment.getName()).isEqualTo(UPDATED_NAME);
    assertThat(testMethod_payment.getDecription()).isEqualTo(UPDATED_DECRIPTION);
    assertThat(testMethod_payment.getCreate_date()).isEqualTo(UPDATED_CREATE_DATE);
  }
  @Test
  @Transactional
  public void updateSocio() throws Exception {
    // Initialize the database
    socioRepository.saveAndFlush(socio);

    int databaseSizeBeforeUpdate = socioRepository.findAll().size();

    // Update the socio
    socio.setNombre(UPDATED_NOMBRE);
    socio.setFechaNacimiento(UPDATED_FECHA_NACIMIENTO);
    socio.setEquipo(UPDATED_EQUIPO);

    restSocioMockMvc
        .perform(
            put("/api/socios")
                .contentType(TestUtil.APPLICATION_JSON_UTF8)
                .content(TestUtil.convertObjectToJsonBytes(socio)))
        .andExpect(status().isOk());

    // Validate the Socio in the database
    List<Socio> socios = socioRepository.findAll();
    assertThat(socios).hasSize(databaseSizeBeforeUpdate);
    Socio testSocio = socios.get(socios.size() - 1);
    assertThat(testSocio.getNombre()).isEqualTo(UPDATED_NOMBRE);
    assertThat(testSocio.getFechaNacimiento()).isEqualTo(UPDATED_FECHA_NACIMIENTO);
    assertThat(testSocio.getEquipo()).isEqualTo(UPDATED_EQUIPO);
  }
  @Test
  @Transactional
  public void updateBankAccount() throws Exception {
    // Initialize the database
    bankAccountRepository.saveAndFlush(bankAccount);
    int databaseSizeBeforeUpdate = bankAccountRepository.findAll().size();

    // Update the bankAccount
    BankAccount updatedBankAccount = bankAccountRepository.findOne(bankAccount.getId());
    updatedBankAccount.setName(UPDATED_NAME);
    updatedBankAccount.setBalance(UPDATED_BALANCE);

    restBankAccountMockMvc
        .perform(
            put("/api/bank-accounts")
                .contentType(TestUtil.APPLICATION_JSON_UTF8)
                .content(TestUtil.convertObjectToJsonBytes(updatedBankAccount)))
        .andExpect(status().isOk());

    // Validate the BankAccount in the database
    List<BankAccount> bankAccountList = bankAccountRepository.findAll();
    assertThat(bankAccountList).hasSize(databaseSizeBeforeUpdate);
    BankAccount testBankAccount = bankAccountList.get(bankAccountList.size() - 1);
    assertThat(testBankAccount.getName()).isEqualTo(UPDATED_NAME);
    assertThat(testBankAccount.getBalance()).isEqualTo(UPDATED_BALANCE);
  }
  @Test
  @Transactional
  public void updateAluno() throws Exception {
    // Initialize the database
    alunoRepository.saveAndFlush(aluno);

    int databaseSizeBeforeUpdate = alunoRepository.findAll().size();

    // Update the aluno
    aluno.setNome(UPDATED_NOME);
    aluno.setCpf(UPDATED_CPF);
    aluno.setEndereco(UPDATED_ENDERECO);

    restAlunoMockMvc
        .perform(
            put("/api/alunos")
                .contentType(TestUtil.APPLICATION_JSON_UTF8)
                .content(TestUtil.convertObjectToJsonBytes(aluno)))
        .andExpect(status().isOk());

    // Validate the Aluno in the database
    List<Aluno> alunos = alunoRepository.findAll();
    assertThat(alunos).hasSize(databaseSizeBeforeUpdate);
    Aluno testAluno = alunos.get(alunos.size() - 1);
    assertThat(testAluno.getNome()).isEqualTo(UPDATED_NOME);
    assertThat(testAluno.getCpf()).isEqualTo(UPDATED_CPF);
    assertThat(testAluno.getEndereco()).isEqualTo(UPDATED_ENDERECO);
  }
  @Test
  @Transactional
  public void createRegister_info() throws Exception {
    int databaseSizeBeforeCreate = register_infoRepository.findAll().size();

    // Create the Register_info

    restRegister_infoMockMvc
        .perform(
            post("/api/register_infos")
                .contentType(TestUtil.APPLICATION_JSON_UTF8)
                .content(TestUtil.convertObjectToJsonBytes(register_info)))
        .andExpect(status().isCreated());

    // Validate the Register_info in the database
    List<Register_info> register_infos = register_infoRepository.findAll();
    assertThat(register_infos).hasSize(databaseSizeBeforeCreate + 1);
    Register_info testRegister_info = register_infos.get(register_infos.size() - 1);
    assertThat(testRegister_info.getDate_checkin()).isEqualTo(DEFAULT_DATE_CHECKIN);
    assertThat(testRegister_info.getDate_checkout()).isEqualTo(DEFAULT_DATE_CHECKOUT);
    assertThat(testRegister_info.getNumber_of_adult()).isEqualTo(DEFAULT_NUMBER_OF_ADULT);
    assertThat(testRegister_info.getNumber_of_kid()).isEqualTo(DEFAULT_NUMBER_OF_KID);
    assertThat(testRegister_info.getOther_request()).isEqualTo(DEFAULT_OTHER_REQUEST);
    assertThat(testRegister_info.getDeposit_value()).isEqualTo(DEFAULT_DEPOSIT_VALUE);
    assertThat(testRegister_info.getCreate_date()).isEqualTo(DEFAULT_CREATE_DATE);
    assertThat(testRegister_info.getLast_modified_date()).isEqualTo(DEFAULT_LAST_MODIFIED_DATE);
  }
  @Test
  @Transactional
  public void updateEntry() throws Exception {
    // Initialize the database
    entryRepository.saveAndFlush(entry);

    int databaseSizeBeforeUpdate = entryRepository.findAll().size();

    // Update the entry
    entry.setDate(UPDATED_DATE);
    entry.setExercise(UPDATED_EXERCISE);
    entry.setMeals(UPDATED_MEALS);
    entry.setAlcohol(UPDATED_ALCOHOL);
    entry.setNotes(UPDATED_NOTES);

    restEntryMockMvc
        .perform(
            put("/api/entrys")
                .contentType(TestUtil.APPLICATION_JSON_UTF8)
                .content(TestUtil.convertObjectToJsonBytes(entry)))
        .andExpect(status().isOk());

    // Validate the Entry in the database
    List<Entry> entrys = entryRepository.findAll();
    assertThat(entrys).hasSize(databaseSizeBeforeUpdate);
    Entry testEntry = entrys.get(entrys.size() - 1);
    assertThat(testEntry.getDate()).isEqualTo(UPDATED_DATE);
    assertThat(testEntry.getExercise()).isEqualTo(UPDATED_EXERCISE);
    assertThat(testEntry.getMeals()).isEqualTo(UPDATED_MEALS);
    assertThat(testEntry.getAlcohol()).isEqualTo(UPDATED_ALCOHOL);
    assertThat(testEntry.getNotes()).isEqualTo(UPDATED_NOTES);
  }
  @Test
  @Transactional
  public void updatePhysiotherapist() throws Exception {
    // Initialize the database
    physiotherapistRepository.saveAndFlush(physiotherapist);

    int databaseSizeBeforeUpdate = physiotherapistRepository.findAll().size();

    // Update the physiotherapist
    physiotherapist.setFirstName(UPDATED_FIRST_NAME);
    physiotherapist.setLastName(UPDATED_LAST_NAME);
    physiotherapist.setStreet(UPDATED_STREET);
    physiotherapist.setPostalCode(UPDATED_POSTAL_CODE);
    physiotherapist.setCity(UPDATED_CITY);
    physiotherapist.setCountry(UPDATED_COUNTRY);

    restPhysiotherapistMockMvc
        .perform(
            put("/api/physiotherapists")
                .contentType(TestUtil.APPLICATION_JSON_UTF8)
                .content(TestUtil.convertObjectToJsonBytes(physiotherapist)))
        .andExpect(status().isOk());

    // Validate the Physiotherapist in the database
    List<Physiotherapist> physiotherapists = physiotherapistRepository.findAll();
    assertThat(physiotherapists).hasSize(databaseSizeBeforeUpdate);
    Physiotherapist testPhysiotherapist = physiotherapists.get(physiotherapists.size() - 1);
    assertThat(testPhysiotherapist.getFirstName()).isEqualTo(UPDATED_FIRST_NAME);
    assertThat(testPhysiotherapist.getLastName()).isEqualTo(UPDATED_LAST_NAME);
    assertThat(testPhysiotherapist.getStreet()).isEqualTo(UPDATED_STREET);
    assertThat(testPhysiotherapist.getPostalCode()).isEqualTo(UPDATED_POSTAL_CODE);
    assertThat(testPhysiotherapist.getCity()).isEqualTo(UPDATED_CITY);
    assertThat(testPhysiotherapist.getCountry()).isEqualTo(UPDATED_COUNTRY);
  }
  @Test
  @Transactional
  public void updateAccountFamily() throws Exception {
    // Initialize the database
    accountFamilyRepository.saveAndFlush(accountFamily);

    int databaseSizeBeforeUpdate = accountFamilyRepository.findAll().size();

    // Update the accountFamily
    accountFamily.setAccountFamilyCode(UPDATED_ACCOUNT_FAMILY_CODE);
    accountFamily.setAccountFamilyDesc(UPDATED_ACCOUNT_FAMILY_DESC);
    AccountFamilyDTO accountFamilyDTO =
        accountFamilyMapper.accountFamilyToAccountFamilyDTO(accountFamily);

    restAccountFamilyMockMvc
        .perform(
            put("/api/accountFamilys")
                .contentType(TestUtil.APPLICATION_JSON_UTF8)
                .content(TestUtil.convertObjectToJsonBytes(accountFamilyDTO)))
        .andExpect(status().isOk());

    // Validate the AccountFamily in the database
    List<AccountFamily> accountFamilys = accountFamilyRepository.findAll();
    assertThat(accountFamilys).hasSize(databaseSizeBeforeUpdate);
    AccountFamily testAccountFamily = accountFamilys.get(accountFamilys.size() - 1);
    assertThat(testAccountFamily.getAccountFamilyCode()).isEqualTo(UPDATED_ACCOUNT_FAMILY_CODE);
    assertThat(testAccountFamily.getAccountFamilyDesc()).isEqualTo(UPDATED_ACCOUNT_FAMILY_DESC);
  }
  @Test
  @Transactional
  public void createPhysiotherapist() throws Exception {
    int databaseSizeBeforeCreate = physiotherapistRepository.findAll().size();

    // Create the Physiotherapist

    restPhysiotherapistMockMvc
        .perform(
            post("/api/physiotherapists")
                .contentType(TestUtil.APPLICATION_JSON_UTF8)
                .content(TestUtil.convertObjectToJsonBytes(physiotherapist)))
        .andExpect(status().isCreated());

    // Validate the Physiotherapist in the database
    List<Physiotherapist> physiotherapists = physiotherapistRepository.findAll();
    assertThat(physiotherapists).hasSize(databaseSizeBeforeCreate + 1);
    Physiotherapist testPhysiotherapist = physiotherapists.get(physiotherapists.size() - 1);
    assertThat(testPhysiotherapist.getFirstName()).isEqualTo(DEFAULT_FIRST_NAME);
    assertThat(testPhysiotherapist.getLastName()).isEqualTo(DEFAULT_LAST_NAME);
    assertThat(testPhysiotherapist.getStreet()).isEqualTo(DEFAULT_STREET);
    assertThat(testPhysiotherapist.getPostalCode()).isEqualTo(DEFAULT_POSTAL_CODE);
    assertThat(testPhysiotherapist.getCity()).isEqualTo(DEFAULT_CITY);
    assertThat(testPhysiotherapist.getCountry()).isEqualTo(DEFAULT_COUNTRY);
  }
  @Test
  @Transactional
  public void updateStudent() throws Exception {
    // Initialize the database
    studentRepository.saveAndFlush(student);

    int databaseSizeBeforeUpdate = studentRepository.findAll().size();

    // Update the student
    student.setSid(UPDATED_SID);
    student.setLastName(UPDATED_LAST_NAME);
    student.setFirstName(UPDATED_FIRST_NAME);
    student.setEmail(UPDATED_EMAIL);
    student.setPhone(UPDATED_PHONE);

    restStudentMockMvc
        .perform(
            put("/api/students")
                .contentType(TestUtil.APPLICATION_JSON_UTF8)
                .content(TestUtil.convertObjectToJsonBytes(student)))
        .andExpect(status().isOk());

    // Validate the Student in the database
    List<Student> students = studentRepository.findAll();
    assertThat(students).hasSize(databaseSizeBeforeUpdate);
    Student testStudent = students.get(students.size() - 1);
    assertThat(testStudent.getSid()).isEqualTo(UPDATED_SID);
    assertThat(testStudent.getLastName()).isEqualTo(UPDATED_LAST_NAME);
    assertThat(testStudent.getFirstName()).isEqualTo(UPDATED_FIRST_NAME);
    assertThat(testStudent.getEmail()).isEqualTo(UPDATED_EMAIL);
    assertThat(testStudent.getPhone()).isEqualTo(UPDATED_PHONE);
  }
  @Test
  @Transactional
  public void updateShipOrder() throws Exception {
    // Initialize the database
    shipOrderRepository.saveAndFlush(shipOrder);

    int databaseSizeBeforeUpdate = shipOrderRepository.findAll().size();

    // Update the shipOrder
    shipOrder.setDeliveryTimeStamp(UPDATED_DELIVERY_TIME_STAMP);
    shipOrder.setFinalCosts(UPDATED_FINAL_COSTS);
    shipOrder.setReadyForShipping(UPDATED_READY_FOR_SHIPPING);

    restShipOrderMockMvc
        .perform(
            put("/api/shipOrders")
                .contentType(TestUtil.APPLICATION_JSON_UTF8)
                .content(TestUtil.convertObjectToJsonBytes(shipOrder)))
        .andExpect(status().isOk());

    // Validate the ShipOrder in the database
    List<ShipOrder> shipOrders = shipOrderRepository.findAll();
    assertThat(shipOrders).hasSize(databaseSizeBeforeUpdate);
    ShipOrder testShipOrder = shipOrders.get(shipOrders.size() - 1);
    assertThat(testShipOrder.getDeliveryTimeStamp()).isEqualTo(UPDATED_DELIVERY_TIME_STAMP);
    assertThat(testShipOrder.getFinalCosts()).isEqualTo(UPDATED_FINAL_COSTS);
    assertThat(testShipOrder.getReadyForShipping()).isEqualTo(UPDATED_READY_FOR_SHIPPING);
  }
  @Test
  @Transactional
  public void updateAuthor() throws Exception {
    // Initialize the database
    authorRepository.saveAndFlush(author);

    int databaseSizeBeforeUpdate = authorRepository.findAll().size();

    // Update the author
    author.setName(UPDATED_NAME);
    author.setSurname(UPDATED_SURNAME);
    author.setDescription(UPDATED_DESCRIPTION);
    author.setBirthDate(UPDATED_BIRTH_DATE);
    restAuthorMockMvc
        .perform(
            put("/api/authors")
                .contentType(TestUtil.APPLICATION_JSON_UTF8)
                .content(TestUtil.convertObjectToJsonBytes(author)))
        .andExpect(status().isOk());

    // Validate the Author in the database
    List<Author> authors = authorRepository.findAll();
    assertThat(authors).hasSize(databaseSizeBeforeUpdate);
    Author testAuthor = authors.get(authors.size() - 1);
    assertThat(testAuthor.getName()).isEqualTo(UPDATED_NAME);
    assertThat(testAuthor.getSurname()).isEqualTo(UPDATED_SURNAME);
    assertThat(testAuthor.getDescription()).isEqualTo(UPDATED_DESCRIPTION);
    assertThat(testAuthor.getBirthDate()).isEqualTo(UPDATED_BIRTH_DATE);
  }
  @Test
  @Transactional
  public void updateLocation() throws Exception {
    // Initialize the database
    locationRepository.saveAndFlush(location);

    int databaseSizeBeforeUpdate = locationRepository.findAll().size();

    // Update the location
    location.setAddressLine1(UPDATED_ADDRESS_LINE1);
    location.setAddressLine2(UPDATED_ADDRESS_LINE2);
    location.setAddressLine3(UPDATED_ADDRESS_LINE3);
    location.setLongitude(UPDATED_LONGITUDE);
    location.setLatitude(UPDATED_LATITUDE);
    location.setZipCode(UPDATED_ZIP_CODE);

    restLocationMockMvc
        .perform(
            put("/api/locations")
                .contentType(TestUtil.APPLICATION_JSON_UTF8)
                .content(TestUtil.convertObjectToJsonBytes(location)))
        .andExpect(status().isOk());

    // Validate the Location in the database
    List<Location> locations = locationRepository.findAll();
    assertThat(locations).hasSize(databaseSizeBeforeUpdate);
    Location testLocation = locations.get(locations.size() - 1);
    assertThat(testLocation.getAddressLine1()).isEqualTo(UPDATED_ADDRESS_LINE1);
    assertThat(testLocation.getAddressLine2()).isEqualTo(UPDATED_ADDRESS_LINE2);
    assertThat(testLocation.getAddressLine3()).isEqualTo(UPDATED_ADDRESS_LINE3);
    assertThat(testLocation.getLongitude()).isEqualTo(UPDATED_LONGITUDE);
    assertThat(testLocation.getLatitude()).isEqualTo(UPDATED_LATITUDE);
    assertThat(testLocation.getZipCode()).isEqualTo(UPDATED_ZIP_CODE);
  }
  @Test
  @Transactional
  public void updateOperation() throws Exception {
    // Initialize the database
    operationRepository.saveAndFlush(operation);
    operationSearchRepository.save(operation);
    int databaseSizeBeforeUpdate = operationRepository.findAll().size();

    // Update the operation
    Operation updatedOperation = operationRepository.findOne(operation.getId());
    updatedOperation.setDate(UPDATED_DATE);
    updatedOperation.setDescription(UPDATED_DESCRIPTION);
    updatedOperation.setAmount(UPDATED_AMOUNT);

    restOperationMockMvc
        .perform(
            put("/api/operations")
                .contentType(TestUtil.APPLICATION_JSON_UTF8)
                .content(TestUtil.convertObjectToJsonBytes(updatedOperation)))
        .andExpect(status().isOk());

    // Validate the Operation in the database
    List<Operation> operations = operationRepository.findAll();
    assertThat(operations).hasSize(databaseSizeBeforeUpdate);
    Operation testOperation = operations.get(operations.size() - 1);
    assertThat(testOperation.getDate()).isEqualTo(UPDATED_DATE);
    assertThat(testOperation.getDescription()).isEqualTo(UPDATED_DESCRIPTION);
    assertThat(testOperation.getAmount()).isEqualTo(UPDATED_AMOUNT);

    // Validate the Operation in ElasticSearch
    Operation operationEs = operationSearchRepository.findOne(testOperation.getId());
    assertThat(operationEs).isEqualToComparingFieldByField(testOperation);
  }
  @Test
  @Transactional
  public void createLocation() throws Exception {
    int databaseSizeBeforeCreate = locationRepository.findAll().size();

    // Create the Location

    restLocationMockMvc
        .perform(
            post("/api/locations")
                .contentType(TestUtil.APPLICATION_JSON_UTF8)
                .content(TestUtil.convertObjectToJsonBytes(location)))
        .andExpect(status().isCreated());

    // Validate the Location in the database
    List<Location> locations = locationRepository.findAll();
    assertThat(locations).hasSize(databaseSizeBeforeCreate + 1);
    Location testLocation = locations.get(locations.size() - 1);
    assertThat(testLocation.getAddressLine1()).isEqualTo(DEFAULT_ADDRESS_LINE1);
    assertThat(testLocation.getAddressLine2()).isEqualTo(DEFAULT_ADDRESS_LINE2);
    assertThat(testLocation.getAddressLine3()).isEqualTo(DEFAULT_ADDRESS_LINE3);
    assertThat(testLocation.getLongitude()).isEqualTo(DEFAULT_LONGITUDE);
    assertThat(testLocation.getLatitude()).isEqualTo(DEFAULT_LATITUDE);
    assertThat(testLocation.getZipCode()).isEqualTo(DEFAULT_ZIP_CODE);
  }
  @Test
  @Transactional
  public void updateJugadores() throws Exception {
    // Initialize the database
    jugadoresRepository.saveAndFlush(jugadores);

    int databaseSizeBeforeUpdate = jugadoresRepository.findAll().size();

    // Update the jugadores
    jugadores.setNombreJugador(UPDATED_NOMBRE_JUGADOR);
    jugadores.setFechaNacimiento(UPDATED_FECHA_NACIMIENTO);
    jugadores.setNumCanastas(UPDATED_NUM_CANASTAS);
    jugadores.setNumAsistencias(UPDATED_NUM_ASISTENCIAS);
    jugadores.setNumRebotes(UPDATED_NUM_REBOTES);
    jugadores.setPosicion(UPDATED_POSICION);

    restJugadoresMockMvc
        .perform(
            put("/api/jugadoress")
                .contentType(TestUtil.APPLICATION_JSON_UTF8)
                .content(TestUtil.convertObjectToJsonBytes(jugadores)))
        .andExpect(status().isOk());

    // Validate the Jugadores in the database
    List<Jugadores> jugadoress = jugadoresRepository.findAll();
    assertThat(jugadoress).hasSize(databaseSizeBeforeUpdate);
    Jugadores testJugadores = jugadoress.get(jugadoress.size() - 1);
    assertThat(testJugadores.getNombreJugador()).isEqualTo(UPDATED_NOMBRE_JUGADOR);
    assertThat(testJugadores.getFechaNacimiento()).isEqualTo(UPDATED_FECHA_NACIMIENTO);
    assertThat(testJugadores.getNumCanastas()).isEqualTo(UPDATED_NUM_CANASTAS);
    assertThat(testJugadores.getNumAsistencias()).isEqualTo(UPDATED_NUM_ASISTENCIAS);
    assertThat(testJugadores.getNumRebotes()).isEqualTo(UPDATED_NUM_REBOTES);
    assertThat(testJugadores.getPosicion()).isEqualTo(UPDATED_POSICION);
  }
  @Test
  public void updatePicture() throws Exception {
    // Initialize the database
    pictureRepository.save(picture);

    int databaseSizeBeforeUpdate = pictureRepository.findAll().size();

    // Update the picture
    picture.setTitle(UPDATED_TITLE);
    picture.setDescription(UPDATED_DESCRIPTION);
    picture.setPictureFile(ByteBuffer.wrap(UPDATED_PICTURE_FILE));

    picture.setCreated(UPDATED_CREATED);
    picture.setModified(UPDATED_MODIFIED);

    PictureDTO pictureDTO = pictureMapper.pictureToPictureDTO(picture);

    restPictureMockMvc
        .perform(
            put("/api/pictures")
                .contentType(TestUtil.APPLICATION_JSON_UTF8)
                .content(TestUtil.convertObjectToJsonBytes(pictureDTO)))
        .andExpect(status().isOk());

    // Validate the Picture in the database
    List<Picture> pictures = pictureRepository.findAll();
    assertThat(pictures).hasSize(databaseSizeBeforeUpdate);
    Picture testPicture = pictures.get(pictures.size() - 1);
    assertThat(testPicture.getTitle()).isEqualTo(UPDATED_TITLE);
    assertThat(testPicture.getDescription()).isEqualTo(UPDATED_DESCRIPTION);
    assertThat(testPicture.getPictureFile()).isEqualTo(UPDATED_PICTURE_FILE);

    assertThat(testPicture.getCreated()).isEqualTo(UPDATED_CREATED);
    assertThat(testPicture.getModified()).isEqualTo(UPDATED_MODIFIED);
  }
  @Test
  public void updateBook() throws Exception {
    // Initialize the database
    bookRepository.save(book);

    int databaseSizeBeforeUpdate = bookRepository.findAll().size();

    // Update the book
    book.setTitle(UPDATED_TITLE);
    book.setDescription(UPDATED_DESCRIPTION);
    book.setPublisher(UPDATED_PUBLISHER);
    book.setPublicationDate(UPDATED_PUBLICATION_DATE);
    book.setPrice(UPDATED_PRICE);

    restBookMockMvc
        .perform(
            put("/api/books")
                .contentType(TestUtil.APPLICATION_JSON_UTF8)
                .content(TestUtil.convertObjectToJsonBytes(book)))
        .andExpect(status().isOk());

    // Validate the Book in the database
    List<Book> books = bookRepository.findAll();
    assertThat(books).hasSize(databaseSizeBeforeUpdate);
    Book testBook = books.get(books.size() - 1);
    assertThat(testBook.getTitle()).isEqualTo(UPDATED_TITLE);
    assertThat(testBook.getDescription()).isEqualTo(UPDATED_DESCRIPTION);
    assertThat(testBook.getPublisher()).isEqualTo(UPDATED_PUBLISHER);
    assertThat(testBook.getPublicationDate()).isEqualTo(UPDATED_PUBLICATION_DATE);
    assertThat(testBook.getPrice()).isEqualTo(UPDATED_PRICE);
  }
  @Test
  public void createPicture() throws Exception {
    int databaseSizeBeforeCreate = pictureRepository.findAll().size();

    // Create the Picture
    PictureDTO pictureDTO = pictureMapper.pictureToPictureDTO(picture);

    restPictureMockMvc
        .perform(
            post("/api/pictures")
                .contentType(TestUtil.APPLICATION_JSON_UTF8)
                .content(TestUtil.convertObjectToJsonBytes(pictureDTO)))
        .andExpect(status().isCreated());

    // Validate the Picture in the database
    List<Picture> pictures = pictureRepository.findAll();
    assertThat(pictures).hasSize(databaseSizeBeforeCreate + 1);
    Picture testPicture = pictures.get(pictures.size() - 1);
    assertThat(testPicture.getTitle()).isEqualTo(DEFAULT_TITLE);
    assertThat(testPicture.getDescription()).isEqualTo(DEFAULT_DESCRIPTION);
    assertThat(testPicture.getPictureFile()).isEqualTo(DEFAULT_PICTURE_FILE);

    assertThat(testPicture.getCreated()).isEqualTo(DEFAULT_CREATED);
    assertThat(testPicture.getModified()).isEqualTo(DEFAULT_MODIFIED);
  }
  @Test
  @Transactional
  public void testRegisterAdminIsIgnored() throws Exception {
    UserDTO u =
        new UserDTO(
            "badguy", // login
            "password", // password
            "Bad", // firstName
            "Guy", // lastName
            "*****@*****.**", // e-mail
            true, // activated
            "en", // langKey
            new HashSet<>(
                Arrays.asList(
                    AuthoritiesConstants.ADMIN)) // <-- only admin should be able to do that
            );

    restMvc
        .perform(
            post("/api/register")
                .contentType(TestUtil.APPLICATION_JSON_UTF8)
                .content(TestUtil.convertObjectToJsonBytes(u)))
        .andExpect(status().isCreated());

    Optional<User> userDup = userRepository.findOneByLogin("badguy");
    assertThat(userDup.isPresent()).isTrue();
    assertThat(userDup.get().getAuthorities())
        .hasSize(1)
        .containsExactly(authorityRepository.findOne(AuthoritiesConstants.USER));
  }
  @Test
  @Transactional
  public void updateClasseType() throws Exception {
    // Initialize the database
    classeTypeRepository.saveAndFlush(classeType);

    int databaseSizeBeforeUpdate = classeTypeRepository.findAll().size();

    // Update the classeType
    classeType.setIntitule(UPDATED_INTITULE);
    classeType.setDateCreation(UPDATED_DATE_CREATION);

    restClasseTypeMockMvc
        .perform(
            put("/api/classeTypes")
                .contentType(TestUtil.APPLICATION_JSON_UTF8)
                .content(TestUtil.convertObjectToJsonBytes(classeType)))
        .andExpect(status().isOk());

    // Validate the ClasseType in the database
    List<ClasseType> classeTypes = classeTypeRepository.findAll();
    assertThat(classeTypes).hasSize(databaseSizeBeforeUpdate);
    ClasseType testClasseType = classeTypes.get(classeTypes.size() - 1);
    assertThat(testClasseType.getIntitule()).isEqualTo(UPDATED_INTITULE);
    assertThat(testClasseType.getDateCreation()).isEqualTo(UPDATED_DATE_CREATION);
  }