@Test public void testWriteItems() throws Exception { List<String> items = Collections.singletonList("foo"); writer.write(items); verify(repository).save("foo"); } }
/** * Mainly used to create a new entity * however, can also be used to save something without using the * update() method. * @param model * @return saved entity model */ public M save(M model) { return this.repo.save(model); }
public void store(Serializable key, Object value) { crudRepository.save(value); }
private ContractEventFilter saveContractEventFilter(ContractEventFilter contractEventFilter) { return eventFilterRepository.save(contractEventFilter); }
public void storeAll(Map map) { crudRepository.save(map.values()); }
@SuppressWarnings("unchecked") public void populate(AlbumRepository repository) { Object entity = getEntityFromResource(sourceData); if (entity instanceof Collection) { for (Album album : (Collection<Album>) entity) { if (album != null) { repository.save(album); } } } else { repository.save((Album) entity); } }
/** * Persists the given {@link Object} using a suitable repository. * * @param object must not be {@literal null}. * @param repositories must not be {@literal null}. */ private void persist(Object object, Repositories repositories) { CrudRepository<Object, Serializable> repository = repositories.getRepositoryFor(object.getClass()); LOG.debug(String.format("Persisting %s using repository %s", object, repository)); repository.save(object); } }
@Override public <T> T invokeSave(T entity) { return customSaveMethod ? super.invokeSave(entity) : repository.save(entity); }
public <T, ID> void doOperation(OperationMode operationMode, CrudRepository<T, ID> repo, T object, ID id) { switch (operationMode) { case UPDATE: case INSERT: repo.save(object); break; case DELETE: if (repo.existsById(id)) { repo.deleteById(id); } break; default: throw new IllegalArgumentException(operationMode + " is not supported"); } }
public M update(M model) { M updated = this.repo.findOne(model.getId()); updated = copy(model, updated); return this.repo.save(updated); }
@Test public void test_multiple_inserts() { //Given there is no entities in database List<String> ids = Arrays.asList("testInsert1", "testInsert2"); List<T> initialList = ids.stream() .map(this::build) .collect(Collectors.toList()); //When we insert multiple entities dao.save(initialList); //Then count is equal to number we inserted assertThat("Count should be equal to the amount inserted", countEntities(), is(equalTo(initialList.size()))); }
@Test public void test_delete_by_id() { //Given db has some ids List<String> ids = Arrays.asList("deleteId1", "deleteId2", "deleteId3", "deleteId4"); ids.forEach(id -> dao.save(build(id))); //When an entity is deleted by id dao.delete(ids.get(0)); //Then the count is decremented assertThat(countEntities(), is(equalTo(ids.size() - 1))); }
public default void update(T entity) { if (getRepository().exists(getId(entity))) { getRepository().save(entity); } else { throw new GenericServiceException("Can't update Rating because it doesn't exist in DB: " + entity); } }
@Test public void test_exists() { //Given there is some entity in database List<String> ids = Arrays.asList("testInsert1", "testInsert2"); ids.forEach(id -> dao.save(build(id))); //When we request each object by id //Then objects are found ids.forEach(id -> assertThat("Each element should exist in DAO", dao.exists(id), is(true))); }
@Test public void test_delete_by_entity() { //Given db has some ids List<String> ids = Arrays.asList("deleteId1", "deleteId2", "deleteId3", "deleteId4"); ids.forEach(id -> dao.save(build(id))); //When an entity is deleted by entity dao.delete(dao.findOne(ids.get(0))); //Then the count is decremented assertThat(countEntities(), is(equalTo(ids.size() - 1))); }
@Test public void test_insert() { //Given there is no entity in database //When an entity is inserted dao.save(build("testInsert")); //Then count is equal to one assertThat(countEntities(), is(equalTo(1))); }
@Test public void test_delete_in_mass() { //Given db has some ids List<String> ids = Arrays.asList("deleteId1", "deleteId2", "deleteId3", "deleteId4"); ids.forEach(id -> dao.save(build(id))); //When we request the deletion giving two existing ids Iterable<T> entities = dao.findAll(ids.subList(0, 2)); dao.delete(entities); //Then the count is decremented assertThat(countEntities(), is(equalTo(ids.size() - 2))); }
@Test public void test_find_one_returns_null_on_non_existing_id() { //Given an object is inserted String entityId = "someEntityId"; T original = build(entityId); dao.save(original); //When we load a non existing id T other = dao.findOne(entityId + "-fail"); //then the object returned is null assertThat(other, is(nullValue())); }
@Test public void test_delete_all() { //Given db has some ids List<String> ids = Arrays.asList("deleteId1", "deleteId2", "deleteId3", "deleteId4"); ids.forEach(id -> dao.save(build(id))); //When all are deleted dao.deleteAll(); //Then the returned count is null assertThat(countEntities(), is(equalTo(0))); }
@Test public void test_find_one_preserve_equality() { //Given an object is inserted String entityId = "someEntityId"; T original = build(entityId); dao.save(original); //When we re load it T reloaded = dao.findOne(entityId); //Then it is found assertNotNull(reloaded); //And all attributes are equals to the one inserted compareReloaded(original, reloaded); }