method2testcases
stringlengths 118
3.08k
|
|---|
### Question:
ValueAlreadyExistsException extends DataConstraintViolationException { @Override public String getMessage() { return "entityTypeId:" + entityTypeId + " attributeName:" + attributeName + " value:" + value; } ValueAlreadyExistsException(
@Nullable @CheckForNull String entityTypeId,
@Nullable @CheckForNull String attributeName,
String value,
@Nullable @CheckForNull Throwable cause); @Override String getMessage(); }### Answer:
@Test void testGetMessage() { ValueAlreadyExistsException ex = new ValueAlreadyExistsException( "MyEntityType", "myAttributeName", "myValue", mock(Throwable.class)); assertEquals( "entityTypeId:MyEntityType attributeName:myAttributeName value:myValue", ex.getMessage()); }
|
### Question:
InvalidValueTypeException extends DataConstraintViolationException { @Override public String getMessage() { return "value:" + value + " type:" + type; } InvalidValueTypeException(
String value, String type, @Nullable @CheckForNull Throwable cause); @Override String getMessage(); }### Answer:
@Test void testGetMessage() { InvalidValueTypeException ex = new InvalidValueTypeException("value", "type", mock(Throwable.class)); assertEquals("value:value type:type", ex.getMessage()); }
|
### Question:
ExceptionUtils { static Optional<String> getErrorCode(Throwable throwable) { Optional<String> errorCode; if (throwable instanceof ErrorCoded) { errorCode = Optional.of(((ErrorCoded) throwable).getErrorCode()); } else { errorCode = Optional.empty(); } return errorCode; } private ExceptionUtils(); }### Answer:
@Test void testGetErrorCode() { String myErrorCode = "MyErrorCode"; CodedRuntimeException e = mock(CodedRuntimeException.class); when(e.getErrorCode()).thenReturn(myErrorCode); assertEquals(of(myErrorCode), getErrorCode(e)); }
@Test void testGetErrorCodeNotExists() { Exception e = mock(Exception.class); assertEquals(empty(), getErrorCode(e)); }
|
### Question:
TemplateExpressionEvaluator implements ExpressionEvaluator { TemplateExpressionEvaluator(Attribute attribute, EntityType entityType) { this.attribute = requireNonNull(attribute); this.entityType = requireNonNull(entityType); } TemplateExpressionEvaluator(Attribute attribute, EntityType entityType); @Override Object evaluate(Entity entity); static Template getTemplate(Attribute attribute); }### Answer:
@Test void testTemplateExpressionEvaluator() { assertThrows(NullPointerException.class, () -> new TemplateExpressionEvaluator(null, null)); }
|
### Question:
ExceptionUtils { static boolean hasErrors(Throwable throwable) { return throwable instanceof Errors || throwable instanceof MethodArgumentNotValidException; } private ExceptionUtils(); }### Answer:
@Test void testHasErrorsTrueBindException() { assertTrue(ExceptionUtils.hasErrors(mock(BindException.class))); }
@Test void testHasErrorsTrueMethodArgumentNotValidException() { assertTrue(ExceptionUtils.hasErrors(mock(MethodArgumentNotValidException.class))); }
@Test void testHasErrorsFalse() { assertFalse(ExceptionUtils.hasErrors(mock(Throwable.class))); }
|
### Question:
DefaultEntityCollection implements EntityCollection { @Override public boolean isLazy() { return false; } DefaultEntityCollection(Iterable<Entity> entities, Iterable<String> attrNames); @Override Iterator<Entity> iterator(); @Override Iterable<String> getAttributeNames(); @Override boolean isLazy(); }### Answer:
@SuppressWarnings("unchecked") @Test void isLazy() { Iterable<Entity> entities = mock(Iterable.class); Iterable<String> attrNames = mock(Iterable.class); assertFalse(new DefaultEntityCollection(entities, attrNames).isLazy()); }
|
### Question:
EntityReference implements Entity { public EntityReference(EntityType entityType, Object id) { this.entityType = requireNonNull(entityType); this.id = requireNonNull(validateIdType(id)); } EntityReference(EntityType entityType, Object id); @Override EntityType getEntityType(); @Override Iterable<String> getAttributeNames(); @Override Object getIdValue(); @Override void setIdValue(Object id); @Override Object getLabelValue(); @Override Object get(String attributeName); @Override String getString(String attributeName); @Override Integer getInt(String attributeName); @Override Long getLong(String attributeName); @Override Boolean getBoolean(String attributeName); @Override Double getDouble(String attributeName); @Override Instant getInstant(String attributeName); @Override LocalDate getLocalDate(String attributeName); @Override Entity getEntity(String attributeName); @SuppressWarnings("unchecked") @Override E getEntity(String attributeName, Class<E> clazz); @SuppressWarnings("unchecked") @Override Iterable<Entity> getEntities(String attributeName); @SuppressWarnings("unchecked") @Override Iterable<E> getEntities(String attributeName, Class<E> clazz); @Override void set(String attributeName, Object value); @Override void set(Entity values); }### Answer:
@Test void testEntityReference() { assertThrows(NullPointerException.class, () -> new EntityReference(null, null)); }
|
### Question:
EntityReference implements Entity { @Override public EntityType getEntityType() { return entityType; } EntityReference(EntityType entityType, Object id); @Override EntityType getEntityType(); @Override Iterable<String> getAttributeNames(); @Override Object getIdValue(); @Override void setIdValue(Object id); @Override Object getLabelValue(); @Override Object get(String attributeName); @Override String getString(String attributeName); @Override Integer getInt(String attributeName); @Override Long getLong(String attributeName); @Override Boolean getBoolean(String attributeName); @Override Double getDouble(String attributeName); @Override Instant getInstant(String attributeName); @Override LocalDate getLocalDate(String attributeName); @Override Entity getEntity(String attributeName); @SuppressWarnings("unchecked") @Override E getEntity(String attributeName, Class<E> clazz); @SuppressWarnings("unchecked") @Override Iterable<Entity> getEntities(String attributeName); @SuppressWarnings("unchecked") @Override Iterable<E> getEntities(String attributeName, Class<E> clazz); @Override void set(String attributeName, Object value); @Override void set(Entity values); }### Answer:
@Test void testGetEntityType() { assertEquals(entityType, entityReference.getEntityType()); }
|
### Question:
EntityReference implements Entity { @Override public Iterable<String> getAttributeNames() { return EntityTypeUtils.getAttributeNames(entityType.getAtomicAttributes()); } EntityReference(EntityType entityType, Object id); @Override EntityType getEntityType(); @Override Iterable<String> getAttributeNames(); @Override Object getIdValue(); @Override void setIdValue(Object id); @Override Object getLabelValue(); @Override Object get(String attributeName); @Override String getString(String attributeName); @Override Integer getInt(String attributeName); @Override Long getLong(String attributeName); @Override Boolean getBoolean(String attributeName); @Override Double getDouble(String attributeName); @Override Instant getInstant(String attributeName); @Override LocalDate getLocalDate(String attributeName); @Override Entity getEntity(String attributeName); @SuppressWarnings("unchecked") @Override E getEntity(String attributeName, Class<E> clazz); @SuppressWarnings("unchecked") @Override Iterable<Entity> getEntities(String attributeName); @SuppressWarnings("unchecked") @Override Iterable<E> getEntities(String attributeName, Class<E> clazz); @Override void set(String attributeName, Object value); @Override void set(Entity values); }### Answer:
@Test void testGetAttributeNames() { assertEquals( asList(ID_ATTR_NAME, LABEL_ATTR_NAME), newArrayList(entityReference.getAttributeNames())); }
|
### Question:
EntityReference implements Entity { @Override public Object getIdValue() { return id; } EntityReference(EntityType entityType, Object id); @Override EntityType getEntityType(); @Override Iterable<String> getAttributeNames(); @Override Object getIdValue(); @Override void setIdValue(Object id); @Override Object getLabelValue(); @Override Object get(String attributeName); @Override String getString(String attributeName); @Override Integer getInt(String attributeName); @Override Long getLong(String attributeName); @Override Boolean getBoolean(String attributeName); @Override Double getDouble(String attributeName); @Override Instant getInstant(String attributeName); @Override LocalDate getLocalDate(String attributeName); @Override Entity getEntity(String attributeName); @SuppressWarnings("unchecked") @Override E getEntity(String attributeName, Class<E> clazz); @SuppressWarnings("unchecked") @Override Iterable<Entity> getEntities(String attributeName); @SuppressWarnings("unchecked") @Override Iterable<E> getEntities(String attributeName, Class<E> clazz); @Override void set(String attributeName, Object value); @Override void set(Entity values); }### Answer:
@Test void testGetIdValue() { assertEquals("entityId", entityReference.getIdValue()); }
|
### Question:
EntityReference implements Entity { @Override public void setIdValue(Object id) { setIdValue(entityType.getIdAttribute().getName(), id); } EntityReference(EntityType entityType, Object id); @Override EntityType getEntityType(); @Override Iterable<String> getAttributeNames(); @Override Object getIdValue(); @Override void setIdValue(Object id); @Override Object getLabelValue(); @Override Object get(String attributeName); @Override String getString(String attributeName); @Override Integer getInt(String attributeName); @Override Long getLong(String attributeName); @Override Boolean getBoolean(String attributeName); @Override Double getDouble(String attributeName); @Override Instant getInstant(String attributeName); @Override LocalDate getLocalDate(String attributeName); @Override Entity getEntity(String attributeName); @SuppressWarnings("unchecked") @Override E getEntity(String attributeName, Class<E> clazz); @SuppressWarnings("unchecked") @Override Iterable<Entity> getEntities(String attributeName); @SuppressWarnings("unchecked") @Override Iterable<E> getEntities(String attributeName, Class<E> clazz); @Override void set(String attributeName, Object value); @Override void set(Entity values); }### Answer:
@Test void testSetIdValue() { entityReference.setIdValue("newEntityId"); assertEquals("newEntityId", entityReference.getIdValue()); }
@Test void testSetIdValueStringWrongType() { assertThrows(MolgenisDataException.class, () -> entityReference.setIdValue(123)); }
@Test void testSetIdValueIntegerWrongType() { when(idAttribute.getDataType()).thenReturn(AttributeType.INT); assertThrows(MolgenisDataException.class, () -> entityReference.setIdValue(34359738368L)); }
@Test void testSetIdValueLongWrongType() { when(idAttribute.getDataType()).thenReturn(AttributeType.LONG); assertThrows(MolgenisDataException.class, () -> entityReference.setIdValue("123")); }
|
### Question:
EntityReference implements Entity { @Override public Object getLabelValue() { Attribute labelAttribute = entityType.getLabelAttribute(); return getIdValue(labelAttribute.getName()); } EntityReference(EntityType entityType, Object id); @Override EntityType getEntityType(); @Override Iterable<String> getAttributeNames(); @Override Object getIdValue(); @Override void setIdValue(Object id); @Override Object getLabelValue(); @Override Object get(String attributeName); @Override String getString(String attributeName); @Override Integer getInt(String attributeName); @Override Long getLong(String attributeName); @Override Boolean getBoolean(String attributeName); @Override Double getDouble(String attributeName); @Override Instant getInstant(String attributeName); @Override LocalDate getLocalDate(String attributeName); @Override Entity getEntity(String attributeName); @SuppressWarnings("unchecked") @Override E getEntity(String attributeName, Class<E> clazz); @SuppressWarnings("unchecked") @Override Iterable<Entity> getEntities(String attributeName); @SuppressWarnings("unchecked") @Override Iterable<E> getEntities(String attributeName, Class<E> clazz); @Override void set(String attributeName, Object value); @Override void set(Entity values); }### Answer:
@Test void testGetLabelValue() { Attribute labelAttribute = when(mock(Attribute.class).getName()).thenReturn(LABEL_ATTR_NAME).getMock(); when(entityType.getLabelAttribute()).thenReturn(labelAttribute); assertThrows(UnsupportedOperationException.class, () -> entityReference.getLabelValue()); }
@Test void testGetLabelValueLabelAttributeIsIdAttribute() { when(entityType.getLabelAttribute()).thenReturn(idAttribute); assertEquals("entityId", entityReference.getLabelValue()); }
|
### Question:
EntityReference implements Entity { @Override public Object get(String attributeName) { return getIdValue(attributeName); } EntityReference(EntityType entityType, Object id); @Override EntityType getEntityType(); @Override Iterable<String> getAttributeNames(); @Override Object getIdValue(); @Override void setIdValue(Object id); @Override Object getLabelValue(); @Override Object get(String attributeName); @Override String getString(String attributeName); @Override Integer getInt(String attributeName); @Override Long getLong(String attributeName); @Override Boolean getBoolean(String attributeName); @Override Double getDouble(String attributeName); @Override Instant getInstant(String attributeName); @Override LocalDate getLocalDate(String attributeName); @Override Entity getEntity(String attributeName); @SuppressWarnings("unchecked") @Override E getEntity(String attributeName, Class<E> clazz); @SuppressWarnings("unchecked") @Override Iterable<Entity> getEntities(String attributeName); @SuppressWarnings("unchecked") @Override Iterable<E> getEntities(String attributeName, Class<E> clazz); @Override void set(String attributeName, Object value); @Override void set(Entity values); }### Answer:
@Test void testGet() { assertThrows(UnsupportedOperationException.class, () -> entityReference.get(LABEL_ATTR_NAME)); }
@Test void testGetIdAttribute() { assertEquals("entityId", entityReference.get(ID_ATTR_NAME)); }
@Test void testGetStringIdAttribute() { assertEquals("entityId", entityReference.get(ID_ATTR_NAME)); }
|
### Question:
EntityReference implements Entity { @Override public String getString(String attributeName) { return (String) getIdValue(attributeName); } EntityReference(EntityType entityType, Object id); @Override EntityType getEntityType(); @Override Iterable<String> getAttributeNames(); @Override Object getIdValue(); @Override void setIdValue(Object id); @Override Object getLabelValue(); @Override Object get(String attributeName); @Override String getString(String attributeName); @Override Integer getInt(String attributeName); @Override Long getLong(String attributeName); @Override Boolean getBoolean(String attributeName); @Override Double getDouble(String attributeName); @Override Instant getInstant(String attributeName); @Override LocalDate getLocalDate(String attributeName); @Override Entity getEntity(String attributeName); @SuppressWarnings("unchecked") @Override E getEntity(String attributeName, Class<E> clazz); @SuppressWarnings("unchecked") @Override Iterable<Entity> getEntities(String attributeName); @SuppressWarnings("unchecked") @Override Iterable<E> getEntities(String attributeName, Class<E> clazz); @Override void set(String attributeName, Object value); @Override void set(Entity values); }### Answer:
@Test void testGetString() { assertThrows( UnsupportedOperationException.class, () -> entityReference.getString(LABEL_ATTR_NAME)); }
|
### Question:
EntityReference implements Entity { @Override public Integer getInt(String attributeName) { return (Integer) getIdValue(attributeName); } EntityReference(EntityType entityType, Object id); @Override EntityType getEntityType(); @Override Iterable<String> getAttributeNames(); @Override Object getIdValue(); @Override void setIdValue(Object id); @Override Object getLabelValue(); @Override Object get(String attributeName); @Override String getString(String attributeName); @Override Integer getInt(String attributeName); @Override Long getLong(String attributeName); @Override Boolean getBoolean(String attributeName); @Override Double getDouble(String attributeName); @Override Instant getInstant(String attributeName); @Override LocalDate getLocalDate(String attributeName); @Override Entity getEntity(String attributeName); @SuppressWarnings("unchecked") @Override E getEntity(String attributeName, Class<E> clazz); @SuppressWarnings("unchecked") @Override Iterable<Entity> getEntities(String attributeName); @SuppressWarnings("unchecked") @Override Iterable<E> getEntities(String attributeName, Class<E> clazz); @Override void set(String attributeName, Object value); @Override void set(Entity values); }### Answer:
@Test void testGetInt() { assertThrows(UnsupportedOperationException.class, () -> entityReference.getInt("someAttr")); }
@Test void testGetIntIdAttribute() { when(idAttribute.getDataType()).thenReturn(AttributeType.INT); EntityReference entityReference = new EntityReference(entityType, 123); assertEquals(valueOf(123), entityReference.getInt(ID_ATTR_NAME)); }
|
### Question:
EntityReference implements Entity { @Override public Long getLong(String attributeName) { return (Long) getIdValue(attributeName); } EntityReference(EntityType entityType, Object id); @Override EntityType getEntityType(); @Override Iterable<String> getAttributeNames(); @Override Object getIdValue(); @Override void setIdValue(Object id); @Override Object getLabelValue(); @Override Object get(String attributeName); @Override String getString(String attributeName); @Override Integer getInt(String attributeName); @Override Long getLong(String attributeName); @Override Boolean getBoolean(String attributeName); @Override Double getDouble(String attributeName); @Override Instant getInstant(String attributeName); @Override LocalDate getLocalDate(String attributeName); @Override Entity getEntity(String attributeName); @SuppressWarnings("unchecked") @Override E getEntity(String attributeName, Class<E> clazz); @SuppressWarnings("unchecked") @Override Iterable<Entity> getEntities(String attributeName); @SuppressWarnings("unchecked") @Override Iterable<E> getEntities(String attributeName, Class<E> clazz); @Override void set(String attributeName, Object value); @Override void set(Entity values); }### Answer:
@Test void testGetLong() { assertThrows(UnsupportedOperationException.class, () -> entityReference.getLong("someAttr")); }
@Test void testGetLongIdAttribute() { when(idAttribute.getDataType()).thenReturn(AttributeType.LONG); EntityReference entityReference = new EntityReference(entityType, 123L); assertEquals(Long.valueOf(123L), entityReference.getLong(ID_ATTR_NAME)); }
|
### Question:
EntityReference implements Entity { @Override public Boolean getBoolean(String attributeName) { return (Boolean) getIdValue(attributeName); } EntityReference(EntityType entityType, Object id); @Override EntityType getEntityType(); @Override Iterable<String> getAttributeNames(); @Override Object getIdValue(); @Override void setIdValue(Object id); @Override Object getLabelValue(); @Override Object get(String attributeName); @Override String getString(String attributeName); @Override Integer getInt(String attributeName); @Override Long getLong(String attributeName); @Override Boolean getBoolean(String attributeName); @Override Double getDouble(String attributeName); @Override Instant getInstant(String attributeName); @Override LocalDate getLocalDate(String attributeName); @Override Entity getEntity(String attributeName); @SuppressWarnings("unchecked") @Override E getEntity(String attributeName, Class<E> clazz); @SuppressWarnings("unchecked") @Override Iterable<Entity> getEntities(String attributeName); @SuppressWarnings("unchecked") @Override Iterable<E> getEntities(String attributeName, Class<E> clazz); @Override void set(String attributeName, Object value); @Override void set(Entity values); }### Answer:
@Test void testGetBoolean() { assertThrows(UnsupportedOperationException.class, () -> entityReference.getBoolean("someAttr")); }
|
### Question:
EntityReference implements Entity { @Override public Double getDouble(String attributeName) { return (Double) getIdValue(attributeName); } EntityReference(EntityType entityType, Object id); @Override EntityType getEntityType(); @Override Iterable<String> getAttributeNames(); @Override Object getIdValue(); @Override void setIdValue(Object id); @Override Object getLabelValue(); @Override Object get(String attributeName); @Override String getString(String attributeName); @Override Integer getInt(String attributeName); @Override Long getLong(String attributeName); @Override Boolean getBoolean(String attributeName); @Override Double getDouble(String attributeName); @Override Instant getInstant(String attributeName); @Override LocalDate getLocalDate(String attributeName); @Override Entity getEntity(String attributeName); @SuppressWarnings("unchecked") @Override E getEntity(String attributeName, Class<E> clazz); @SuppressWarnings("unchecked") @Override Iterable<Entity> getEntities(String attributeName); @SuppressWarnings("unchecked") @Override Iterable<E> getEntities(String attributeName, Class<E> clazz); @Override void set(String attributeName, Object value); @Override void set(Entity values); }### Answer:
@Test void testGetDouble() { assertThrows(UnsupportedOperationException.class, () -> entityReference.getDouble("someAttr")); }
|
### Question:
EntityReference implements Entity { @Override public Instant getInstant(String attributeName) { return (Instant) getIdValue(attributeName); } EntityReference(EntityType entityType, Object id); @Override EntityType getEntityType(); @Override Iterable<String> getAttributeNames(); @Override Object getIdValue(); @Override void setIdValue(Object id); @Override Object getLabelValue(); @Override Object get(String attributeName); @Override String getString(String attributeName); @Override Integer getInt(String attributeName); @Override Long getLong(String attributeName); @Override Boolean getBoolean(String attributeName); @Override Double getDouble(String attributeName); @Override Instant getInstant(String attributeName); @Override LocalDate getLocalDate(String attributeName); @Override Entity getEntity(String attributeName); @SuppressWarnings("unchecked") @Override E getEntity(String attributeName, Class<E> clazz); @SuppressWarnings("unchecked") @Override Iterable<Entity> getEntities(String attributeName); @SuppressWarnings("unchecked") @Override Iterable<E> getEntities(String attributeName, Class<E> clazz); @Override void set(String attributeName, Object value); @Override void set(Entity values); }### Answer:
@Test void testGetInstant() { assertThrows(UnsupportedOperationException.class, () -> entityReference.getInstant("someAttr")); }
|
### Question:
EntityReference implements Entity { @Override public LocalDate getLocalDate(String attributeName) { return (LocalDate) getIdValue(attributeName); } EntityReference(EntityType entityType, Object id); @Override EntityType getEntityType(); @Override Iterable<String> getAttributeNames(); @Override Object getIdValue(); @Override void setIdValue(Object id); @Override Object getLabelValue(); @Override Object get(String attributeName); @Override String getString(String attributeName); @Override Integer getInt(String attributeName); @Override Long getLong(String attributeName); @Override Boolean getBoolean(String attributeName); @Override Double getDouble(String attributeName); @Override Instant getInstant(String attributeName); @Override LocalDate getLocalDate(String attributeName); @Override Entity getEntity(String attributeName); @SuppressWarnings("unchecked") @Override E getEntity(String attributeName, Class<E> clazz); @SuppressWarnings("unchecked") @Override Iterable<Entity> getEntities(String attributeName); @SuppressWarnings("unchecked") @Override Iterable<E> getEntities(String attributeName, Class<E> clazz); @Override void set(String attributeName, Object value); @Override void set(Entity values); }### Answer:
@Test void testGetLocalDate() { assertThrows( UnsupportedOperationException.class, () -> entityReference.getLocalDate("someAttr")); }
|
### Question:
EntityReference implements Entity { @Override public Entity getEntity(String attributeName) { return (Entity) getIdValue(attributeName); } EntityReference(EntityType entityType, Object id); @Override EntityType getEntityType(); @Override Iterable<String> getAttributeNames(); @Override Object getIdValue(); @Override void setIdValue(Object id); @Override Object getLabelValue(); @Override Object get(String attributeName); @Override String getString(String attributeName); @Override Integer getInt(String attributeName); @Override Long getLong(String attributeName); @Override Boolean getBoolean(String attributeName); @Override Double getDouble(String attributeName); @Override Instant getInstant(String attributeName); @Override LocalDate getLocalDate(String attributeName); @Override Entity getEntity(String attributeName); @SuppressWarnings("unchecked") @Override E getEntity(String attributeName, Class<E> clazz); @SuppressWarnings("unchecked") @Override Iterable<Entity> getEntities(String attributeName); @SuppressWarnings("unchecked") @Override Iterable<E> getEntities(String attributeName, Class<E> clazz); @Override void set(String attributeName, Object value); @Override void set(Entity values); }### Answer:
@Test void testGetEntity() { assertThrows(UnsupportedOperationException.class, () -> entityReference.getEntity("someAttr")); }
@Test void testGetEntityClass() { assertThrows( UnsupportedOperationException.class, () -> entityReference.getEntity("someAttr", Entity.class)); }
|
### Question:
EntityReference implements Entity { @SuppressWarnings("unchecked") @Override public Iterable<Entity> getEntities(String attributeName) { return (Iterable<Entity>) getIdValue(attributeName); } EntityReference(EntityType entityType, Object id); @Override EntityType getEntityType(); @Override Iterable<String> getAttributeNames(); @Override Object getIdValue(); @Override void setIdValue(Object id); @Override Object getLabelValue(); @Override Object get(String attributeName); @Override String getString(String attributeName); @Override Integer getInt(String attributeName); @Override Long getLong(String attributeName); @Override Boolean getBoolean(String attributeName); @Override Double getDouble(String attributeName); @Override Instant getInstant(String attributeName); @Override LocalDate getLocalDate(String attributeName); @Override Entity getEntity(String attributeName); @SuppressWarnings("unchecked") @Override E getEntity(String attributeName, Class<E> clazz); @SuppressWarnings("unchecked") @Override Iterable<Entity> getEntities(String attributeName); @SuppressWarnings("unchecked") @Override Iterable<E> getEntities(String attributeName, Class<E> clazz); @Override void set(String attributeName, Object value); @Override void set(Entity values); }### Answer:
@Test void testGetEntities() { assertThrows( UnsupportedOperationException.class, () -> entityReference.getEntities("someAttr")); }
@Test void testGetEntitiesClass() { assertThrows( UnsupportedOperationException.class, () -> entityReference.getEntities("someAttr", Entity.class)); }
|
### Question:
EntityReference implements Entity { @Override public void set(String attributeName, Object value) { setIdValue(attributeName, value); } EntityReference(EntityType entityType, Object id); @Override EntityType getEntityType(); @Override Iterable<String> getAttributeNames(); @Override Object getIdValue(); @Override void setIdValue(Object id); @Override Object getLabelValue(); @Override Object get(String attributeName); @Override String getString(String attributeName); @Override Integer getInt(String attributeName); @Override Long getLong(String attributeName); @Override Boolean getBoolean(String attributeName); @Override Double getDouble(String attributeName); @Override Instant getInstant(String attributeName); @Override LocalDate getLocalDate(String attributeName); @Override Entity getEntity(String attributeName); @SuppressWarnings("unchecked") @Override E getEntity(String attributeName, Class<E> clazz); @SuppressWarnings("unchecked") @Override Iterable<Entity> getEntities(String attributeName); @SuppressWarnings("unchecked") @Override Iterable<E> getEntities(String attributeName, Class<E> clazz); @Override void set(String attributeName, Object value); @Override void set(Entity values); }### Answer:
@Test void testSet() { assertThrows( UnsupportedOperationException.class, () -> entityReference.set("someAttr", "value")); }
|
### Question:
LazyEntity implements Entity { public LazyEntity(EntityType entityType, DataService dataService, Object id) { this.entityType = requireNonNull(entityType); this.dataService = requireNonNull(dataService); this.id = requireNonNull(id); } LazyEntity(EntityType entityType, DataService dataService, Object id); @Override Object getIdValue(); @Override void setIdValue(Object id); EntityType getEntityType(); @Override Iterable<String> getAttributeNames(); @Override Object getLabelValue(); @Override Object get(String attributeName); @Override String getString(String attributeName); @Override Integer getInt(String attributeName); @Override Long getLong(String attributeName); @Override Boolean getBoolean(String attributeName); @Override Double getDouble(String attributeName); @Override Instant getInstant(String attributeName); @Override LocalDate getLocalDate(String attributeName); @Override Entity getEntity(String attributeName); @Override E getEntity(String attributeName, Class<E> clazz); @Override Iterable<Entity> getEntities(String attributeName); @Override Iterable<E> getEntities(String attributeName, Class<E> clazz); @Override void set(String attributeName, Object value); @Override void set(Entity values); @Override String toString(); }### Answer:
@Test void LazyEntity() { assertThrows(NullPointerException.class, () -> new LazyEntity(null, null, null)); }
|
### Question:
LazyEntity implements Entity { @Override public Object get(String attributeName) { Attribute idAttr = entityType.getIdAttribute(); if (attributeName.equals(idAttr.getName())) { return id; } return getLazyLoadedEntity().get(attributeName); } LazyEntity(EntityType entityType, DataService dataService, Object id); @Override Object getIdValue(); @Override void setIdValue(Object id); EntityType getEntityType(); @Override Iterable<String> getAttributeNames(); @Override Object getLabelValue(); @Override Object get(String attributeName); @Override String getString(String attributeName); @Override Integer getInt(String attributeName); @Override Long getLong(String attributeName); @Override Boolean getBoolean(String attributeName); @Override Double getDouble(String attributeName); @Override Instant getInstant(String attributeName); @Override LocalDate getLocalDate(String attributeName); @Override Entity getEntity(String attributeName); @Override E getEntity(String attributeName, Class<E> clazz); @Override Iterable<Entity> getEntities(String attributeName); @Override Iterable<E> getEntities(String attributeName, Class<E> clazz); @Override void set(String attributeName, Object value); @Override void set(Entity values); @Override String toString(); }### Answer:
@Test void get() { String attrName = "attr"; Object value = mock(Object.class); when(entity.get(attrName)).thenReturn(value); assertEquals(lazyEntity.get(attrName), value); assertEquals(lazyEntity.get(attrName), value); verify(dataService, times(1)).findOneById(ENTITY_NAME, id); }
@Test void getIdAttr() { assertEquals(lazyEntity.get(ID_ATTR_NAME), id); }
|
### Question:
ExceptionUtils { static Optional<Errors> getErrors(Throwable throwable) { Optional<Errors> errors; if (throwable instanceof Errors) { errors = Optional.of((Errors) throwable); } else if (throwable instanceof MethodArgumentNotValidException) { errors = Optional.of(((MethodArgumentNotValidException) throwable).getBindingResult()); } else { errors = Optional.empty(); } return errors; } private ExceptionUtils(); }### Answer:
@Test void testGetErrorsBindException() { BindException bindException = mock(BindException.class); assertEquals(of(bindException), getErrors(bindException)); }
@Test void testGetErrorsMethodArgumentNotValidException() { MethodArgumentNotValidException methodArgumentNotValidException = mock(MethodArgumentNotValidException.class); BindingResult bindingResult = mock(BindingResult.class); when(methodArgumentNotValidException.getBindingResult()).thenReturn(bindingResult); assertEquals(of(bindingResult), getErrors(methodArgumentNotValidException)); }
@Test void testGetErrorsEmpty() { assertEquals(empty(), getErrors(mock(Throwable.class))); }
|
### Question:
LazyEntity implements Entity { @Override public Iterable<String> getAttributeNames() { return EntityTypeUtils.getAttributeNames(entityType.getAtomicAttributes()); } LazyEntity(EntityType entityType, DataService dataService, Object id); @Override Object getIdValue(); @Override void setIdValue(Object id); EntityType getEntityType(); @Override Iterable<String> getAttributeNames(); @Override Object getLabelValue(); @Override Object get(String attributeName); @Override String getString(String attributeName); @Override Integer getInt(String attributeName); @Override Long getLong(String attributeName); @Override Boolean getBoolean(String attributeName); @Override Double getDouble(String attributeName); @Override Instant getInstant(String attributeName); @Override LocalDate getLocalDate(String attributeName); @Override Entity getEntity(String attributeName); @Override E getEntity(String attributeName, Class<E> clazz); @Override Iterable<Entity> getEntities(String attributeName); @Override Iterable<E> getEntities(String attributeName, Class<E> clazz); @Override void set(String attributeName, Object value); @Override void set(Entity values); @Override String toString(); }### Answer:
@Test void getAttributeNames() { Entity entity = new DynamicEntity(entityType); Attribute attr0 = when(mock(Attribute.class).getName()).thenReturn("attr0").getMock(); Attribute attr1 = when(mock(Attribute.class).getName()).thenReturn("attr1").getMock(); when(entityType.getAtomicAttributes()).thenReturn(Arrays.asList(attr0, attr1)); assertEquals(asList("attr0", "attr1"), newArrayList(entity.getAttributeNames())); }
|
### Question:
LazyEntity implements Entity { @Override public Boolean getBoolean(String attributeName) { return getLazyLoadedEntity().getBoolean(attributeName); } LazyEntity(EntityType entityType, DataService dataService, Object id); @Override Object getIdValue(); @Override void setIdValue(Object id); EntityType getEntityType(); @Override Iterable<String> getAttributeNames(); @Override Object getLabelValue(); @Override Object get(String attributeName); @Override String getString(String attributeName); @Override Integer getInt(String attributeName); @Override Long getLong(String attributeName); @Override Boolean getBoolean(String attributeName); @Override Double getDouble(String attributeName); @Override Instant getInstant(String attributeName); @Override LocalDate getLocalDate(String attributeName); @Override Entity getEntity(String attributeName); @Override E getEntity(String attributeName, Class<E> clazz); @Override Iterable<Entity> getEntities(String attributeName); @Override Iterable<E> getEntities(String attributeName, Class<E> clazz); @Override void set(String attributeName, Object value); @Override void set(Entity values); @Override String toString(); }### Answer:
@Test void getBoolean() { String attrName = "attr"; Boolean value = Boolean.TRUE; when(entity.getBoolean(attrName)).thenReturn(value); assertEquals(lazyEntity.getBoolean(attrName), value); assertEquals(lazyEntity.getBoolean(attrName), value); verify(dataService, times(1)).findOneById(ENTITY_NAME, id); }
|
### Question:
LazyEntity implements Entity { @Override public Double getDouble(String attributeName) { return getLazyLoadedEntity().getDouble(attributeName); } LazyEntity(EntityType entityType, DataService dataService, Object id); @Override Object getIdValue(); @Override void setIdValue(Object id); EntityType getEntityType(); @Override Iterable<String> getAttributeNames(); @Override Object getLabelValue(); @Override Object get(String attributeName); @Override String getString(String attributeName); @Override Integer getInt(String attributeName); @Override Long getLong(String attributeName); @Override Boolean getBoolean(String attributeName); @Override Double getDouble(String attributeName); @Override Instant getInstant(String attributeName); @Override LocalDate getLocalDate(String attributeName); @Override Entity getEntity(String attributeName); @Override E getEntity(String attributeName, Class<E> clazz); @Override Iterable<Entity> getEntities(String attributeName); @Override Iterable<E> getEntities(String attributeName, Class<E> clazz); @Override void set(String attributeName, Object value); @Override void set(Entity values); @Override String toString(); }### Answer:
@Test void getDouble() { String attrName = "attr"; Double value = 0d; when(entity.getDouble(attrName)).thenReturn(value); assertEquals(lazyEntity.getDouble(attrName), value); assertEquals(lazyEntity.getDouble(attrName), value); verify(dataService, times(1)).findOneById(ENTITY_NAME, id); }
|
### Question:
LazyEntity implements Entity { @Override public Iterable<Entity> getEntities(String attributeName) { return getLazyLoadedEntity().getEntities(attributeName); } LazyEntity(EntityType entityType, DataService dataService, Object id); @Override Object getIdValue(); @Override void setIdValue(Object id); EntityType getEntityType(); @Override Iterable<String> getAttributeNames(); @Override Object getLabelValue(); @Override Object get(String attributeName); @Override String getString(String attributeName); @Override Integer getInt(String attributeName); @Override Long getLong(String attributeName); @Override Boolean getBoolean(String attributeName); @Override Double getDouble(String attributeName); @Override Instant getInstant(String attributeName); @Override LocalDate getLocalDate(String attributeName); @Override Entity getEntity(String attributeName); @Override E getEntity(String attributeName, Class<E> clazz); @Override Iterable<Entity> getEntities(String attributeName); @Override Iterable<E> getEntities(String attributeName, Class<E> clazz); @Override void set(String attributeName, Object value); @Override void set(Entity values); @Override String toString(); }### Answer:
@Test void getEntitiesString() { String attrName = "attr"; @SuppressWarnings("unchecked") Iterable<Entity> entities = mock(Iterable.class); when(entity.getEntities(attrName)).thenReturn(entities); assertEquals(lazyEntity.getEntities(attrName), entities); assertEquals(lazyEntity.getEntities(attrName), entities); verify(dataService, times(1)).findOneById(ENTITY_NAME, id); }
@Test void getEntitiesStringClassE() { String attrName = "attr"; @SuppressWarnings("unchecked") Iterable<Entity> entities = mock(Iterable.class); when(entity.getEntities(attrName, Entity.class)).thenReturn(entities); assertEquals(lazyEntity.getEntities(attrName, Entity.class), entities); assertEquals(lazyEntity.getEntities(attrName, Entity.class), entities); verify(dataService, times(1)).findOneById(ENTITY_NAME, id); }
|
### Question:
LazyEntity implements Entity { @Override public Entity getEntity(String attributeName) { return getLazyLoadedEntity().getEntity(attributeName); } LazyEntity(EntityType entityType, DataService dataService, Object id); @Override Object getIdValue(); @Override void setIdValue(Object id); EntityType getEntityType(); @Override Iterable<String> getAttributeNames(); @Override Object getLabelValue(); @Override Object get(String attributeName); @Override String getString(String attributeName); @Override Integer getInt(String attributeName); @Override Long getLong(String attributeName); @Override Boolean getBoolean(String attributeName); @Override Double getDouble(String attributeName); @Override Instant getInstant(String attributeName); @Override LocalDate getLocalDate(String attributeName); @Override Entity getEntity(String attributeName); @Override E getEntity(String attributeName, Class<E> clazz); @Override Iterable<Entity> getEntities(String attributeName); @Override Iterable<E> getEntities(String attributeName, Class<E> clazz); @Override void set(String attributeName, Object value); @Override void set(Entity values); @Override String toString(); }### Answer:
@Test void getEntityString() { String attrName = "attr"; Entity value = mock(Entity.class); when(entity.getEntity(attrName)).thenReturn(value); assertEquals(lazyEntity.getEntity(attrName), value); assertEquals(lazyEntity.getEntity(attrName), value); verify(dataService, times(1)).findOneById(ENTITY_NAME, id); }
@Test void getEntityStringClassE() { String attrName = "attr"; Entity value = mock(Entity.class); when(entity.getEntity(attrName, Entity.class)).thenReturn(value); assertEquals(lazyEntity.getEntity(attrName, Entity.class), value); assertEquals(lazyEntity.getEntity(attrName, Entity.class), value); verify(dataService, times(1)).findOneById(ENTITY_NAME, id); }
|
### Question:
LazyEntity implements Entity { public EntityType getEntityType() { return entityType; } LazyEntity(EntityType entityType, DataService dataService, Object id); @Override Object getIdValue(); @Override void setIdValue(Object id); EntityType getEntityType(); @Override Iterable<String> getAttributeNames(); @Override Object getLabelValue(); @Override Object get(String attributeName); @Override String getString(String attributeName); @Override Integer getInt(String attributeName); @Override Long getLong(String attributeName); @Override Boolean getBoolean(String attributeName); @Override Double getDouble(String attributeName); @Override Instant getInstant(String attributeName); @Override LocalDate getLocalDate(String attributeName); @Override Entity getEntity(String attributeName); @Override E getEntity(String attributeName, Class<E> clazz); @Override Iterable<Entity> getEntities(String attributeName); @Override Iterable<E> getEntities(String attributeName, Class<E> clazz); @Override void set(String attributeName, Object value); @Override void set(Entity values); @Override String toString(); }### Answer:
@Test void getEntityType() { assertEquals(lazyEntity.getEntityType(), entityType); }
|
### Question:
LazyEntity implements Entity { @Override public Object getIdValue() { return id; } LazyEntity(EntityType entityType, DataService dataService, Object id); @Override Object getIdValue(); @Override void setIdValue(Object id); EntityType getEntityType(); @Override Iterable<String> getAttributeNames(); @Override Object getLabelValue(); @Override Object get(String attributeName); @Override String getString(String attributeName); @Override Integer getInt(String attributeName); @Override Long getLong(String attributeName); @Override Boolean getBoolean(String attributeName); @Override Double getDouble(String attributeName); @Override Instant getInstant(String attributeName); @Override LocalDate getLocalDate(String attributeName); @Override Entity getEntity(String attributeName); @Override E getEntity(String attributeName, Class<E> clazz); @Override Iterable<Entity> getEntities(String attributeName); @Override Iterable<E> getEntities(String attributeName, Class<E> clazz); @Override void set(String attributeName, Object value); @Override void set(Entity values); @Override String toString(); }### Answer:
@Test void getIdValue() { assertEquals(lazyEntity.getIdValue(), id); }
|
### Question:
LazyEntity implements Entity { @Override public Integer getInt(String attributeName) { Attribute idAttr = entityType.getIdAttribute(); if (attributeName.equals(idAttr.getName())) { return (Integer) id; } return getLazyLoadedEntity().getInt(attributeName); } LazyEntity(EntityType entityType, DataService dataService, Object id); @Override Object getIdValue(); @Override void setIdValue(Object id); EntityType getEntityType(); @Override Iterable<String> getAttributeNames(); @Override Object getLabelValue(); @Override Object get(String attributeName); @Override String getString(String attributeName); @Override Integer getInt(String attributeName); @Override Long getLong(String attributeName); @Override Boolean getBoolean(String attributeName); @Override Double getDouble(String attributeName); @Override Instant getInstant(String attributeName); @Override LocalDate getLocalDate(String attributeName); @Override Entity getEntity(String attributeName); @Override E getEntity(String attributeName, Class<E> clazz); @Override Iterable<Entity> getEntities(String attributeName); @Override Iterable<E> getEntities(String attributeName, Class<E> clazz); @Override void set(String attributeName, Object value); @Override void set(Entity values); @Override String toString(); }### Answer:
@Test void getInt() { String attrName = "attr"; Integer value = 0; when(entity.getInt(attrName)).thenReturn(value); assertEquals(lazyEntity.getInt(attrName), value); assertEquals(lazyEntity.getInt(attrName), value); verify(dataService, times(1)).findOneById(ENTITY_NAME, id); }
@Test void getIntIdAttr() { assertEquals(lazyEntity.getInt(ID_ATTR_NAME), id); }
|
### Question:
LazyEntity implements Entity { @Override public Object getLabelValue() { Attribute idAttr = entityType.getIdAttribute(); Attribute labelAttr = entityType.getLabelAttribute(); if (idAttr.equals(labelAttr)) { return id; } else { return getLazyLoadedEntity().getLabelValue(); } } LazyEntity(EntityType entityType, DataService dataService, Object id); @Override Object getIdValue(); @Override void setIdValue(Object id); EntityType getEntityType(); @Override Iterable<String> getAttributeNames(); @Override Object getLabelValue(); @Override Object get(String attributeName); @Override String getString(String attributeName); @Override Integer getInt(String attributeName); @Override Long getLong(String attributeName); @Override Boolean getBoolean(String attributeName); @Override Double getDouble(String attributeName); @Override Instant getInstant(String attributeName); @Override LocalDate getLocalDate(String attributeName); @Override Entity getEntity(String attributeName); @Override E getEntity(String attributeName, Class<E> clazz); @Override Iterable<Entity> getEntities(String attributeName); @Override Iterable<E> getEntities(String attributeName, Class<E> clazz); @Override void set(String attributeName, Object value); @Override void set(Entity values); @Override String toString(); }### Answer:
@Test void getLabelValue() { String value = "label"; when(entity.getLabelValue()).thenReturn(value); assertEquals(lazyEntity.getLabelValue(), value); assertEquals(lazyEntity.getLabelValue(), value); verify(dataService, times(1)).findOneById(ENTITY_NAME, id); }
|
### Question:
LazyEntity implements Entity { @Override public Long getLong(String attributeName) { return getLazyLoadedEntity().getLong(attributeName); } LazyEntity(EntityType entityType, DataService dataService, Object id); @Override Object getIdValue(); @Override void setIdValue(Object id); EntityType getEntityType(); @Override Iterable<String> getAttributeNames(); @Override Object getLabelValue(); @Override Object get(String attributeName); @Override String getString(String attributeName); @Override Integer getInt(String attributeName); @Override Long getLong(String attributeName); @Override Boolean getBoolean(String attributeName); @Override Double getDouble(String attributeName); @Override Instant getInstant(String attributeName); @Override LocalDate getLocalDate(String attributeName); @Override Entity getEntity(String attributeName); @Override E getEntity(String attributeName, Class<E> clazz); @Override Iterable<Entity> getEntities(String attributeName); @Override Iterable<E> getEntities(String attributeName, Class<E> clazz); @Override void set(String attributeName, Object value); @Override void set(Entity values); @Override String toString(); }### Answer:
@Test void getLong() { String attrName = "attr"; Long value = 0L; when(entity.getLong(attrName)).thenReturn(value); assertEquals(lazyEntity.getLong(attrName), value); assertEquals(lazyEntity.getLong(attrName), value); verify(dataService, times(1)).findOneById(ENTITY_NAME, id); }
|
### Question:
LazyEntity implements Entity { @Override public String getString(String attributeName) { Attribute idAttr = entityType.getIdAttribute(); if (attributeName.equals(idAttr.getName())) { return (String) id; } return getLazyLoadedEntity().getString(attributeName); } LazyEntity(EntityType entityType, DataService dataService, Object id); @Override Object getIdValue(); @Override void setIdValue(Object id); EntityType getEntityType(); @Override Iterable<String> getAttributeNames(); @Override Object getLabelValue(); @Override Object get(String attributeName); @Override String getString(String attributeName); @Override Integer getInt(String attributeName); @Override Long getLong(String attributeName); @Override Boolean getBoolean(String attributeName); @Override Double getDouble(String attributeName); @Override Instant getInstant(String attributeName); @Override LocalDate getLocalDate(String attributeName); @Override Entity getEntity(String attributeName); @Override E getEntity(String attributeName, Class<E> clazz); @Override Iterable<Entity> getEntities(String attributeName); @Override Iterable<E> getEntities(String attributeName, Class<E> clazz); @Override void set(String attributeName, Object value); @Override void set(Entity values); @Override String toString(); }### Answer:
@Test void getString() { String attrName = "attr"; String value = "str"; when(entity.getString(attrName)).thenReturn(value); assertEquals(lazyEntity.getString(attrName), value); assertEquals(lazyEntity.getString(attrName), value); verify(dataService, times(1)).findOneById(ENTITY_NAME, id); }
@Test void getStringIdAttr() { String strId = "1"; when(dataService.findOneById(ENTITY_NAME, strId)).thenReturn(entity); lazyEntity = new LazyEntity(entityType, dataService, strId); assertEquals(lazyEntity.getString(ID_ATTR_NAME), strId); }
|
### Question:
LazyEntity implements Entity { @Override public LocalDate getLocalDate(String attributeName) { return getLazyLoadedEntity().getLocalDate(attributeName); } LazyEntity(EntityType entityType, DataService dataService, Object id); @Override Object getIdValue(); @Override void setIdValue(Object id); EntityType getEntityType(); @Override Iterable<String> getAttributeNames(); @Override Object getLabelValue(); @Override Object get(String attributeName); @Override String getString(String attributeName); @Override Integer getInt(String attributeName); @Override Long getLong(String attributeName); @Override Boolean getBoolean(String attributeName); @Override Double getDouble(String attributeName); @Override Instant getInstant(String attributeName); @Override LocalDate getLocalDate(String attributeName); @Override Entity getEntity(String attributeName); @Override E getEntity(String attributeName, Class<E> clazz); @Override Iterable<Entity> getEntities(String attributeName); @Override Iterable<E> getEntities(String attributeName, Class<E> clazz); @Override void set(String attributeName, Object value); @Override void set(Entity values); @Override String toString(); }### Answer:
@Test void getLocalDate() { String attrName = "attr"; LocalDate value = LocalDate.now(); when(entity.getLocalDate(attrName)).thenReturn(value); assertEquals(lazyEntity.getLocalDate(attrName), value); assertEquals(lazyEntity.getLocalDate(attrName), value); verify(dataService, times(1)).findOneById(ENTITY_NAME, id); }
|
### Question:
LazyEntity implements Entity { @Override public Instant getInstant(String attributeName) { return getLazyLoadedEntity().getInstant(attributeName); } LazyEntity(EntityType entityType, DataService dataService, Object id); @Override Object getIdValue(); @Override void setIdValue(Object id); EntityType getEntityType(); @Override Iterable<String> getAttributeNames(); @Override Object getLabelValue(); @Override Object get(String attributeName); @Override String getString(String attributeName); @Override Integer getInt(String attributeName); @Override Long getLong(String attributeName); @Override Boolean getBoolean(String attributeName); @Override Double getDouble(String attributeName); @Override Instant getInstant(String attributeName); @Override LocalDate getLocalDate(String attributeName); @Override Entity getEntity(String attributeName); @Override E getEntity(String attributeName, Class<E> clazz); @Override Iterable<Entity> getEntities(String attributeName); @Override Iterable<E> getEntities(String attributeName, Class<E> clazz); @Override void set(String attributeName, Object value); @Override void set(Entity values); @Override String toString(); }### Answer:
@Test void getInstant() { String attrName = "attr"; Instant value = Instant.now(); when(entity.getInstant(attrName)).thenReturn(value); assertEquals(lazyEntity.getInstant(attrName), value); assertEquals(lazyEntity.getInstant(attrName), value); verify(dataService, times(1)).findOneById(ENTITY_NAME, id); }
|
### Question:
LazyEntity implements Entity { @Override public void set(String attributeName, Object value) { getLazyLoadedEntity().set(attributeName, value); } LazyEntity(EntityType entityType, DataService dataService, Object id); @Override Object getIdValue(); @Override void setIdValue(Object id); EntityType getEntityType(); @Override Iterable<String> getAttributeNames(); @Override Object getLabelValue(); @Override Object get(String attributeName); @Override String getString(String attributeName); @Override Integer getInt(String attributeName); @Override Long getLong(String attributeName); @Override Boolean getBoolean(String attributeName); @Override Double getDouble(String attributeName); @Override Instant getInstant(String attributeName); @Override LocalDate getLocalDate(String attributeName); @Override Entity getEntity(String attributeName); @Override E getEntity(String attributeName, Class<E> clazz); @Override Iterable<Entity> getEntities(String attributeName); @Override Iterable<E> getEntities(String attributeName, Class<E> clazz); @Override void set(String attributeName, Object value); @Override void set(Entity values); @Override String toString(); }### Answer:
@Test void setStringObject() { String attrName = "attr"; Object value = mock(Object.class); lazyEntity.set(attrName, value); lazyEntity.set(attrName, value); verify(dataService, times(1)).findOneById(ENTITY_NAME, id); verify(entity, times(2)).set(attrName, value); }
@Test void setEntity() { Entity value = mock(Entity.class); lazyEntity.set(value); lazyEntity.set(value); verify(dataService, times(1)).findOneById(ENTITY_NAME, id); verify(entity, times(2)).set(value); }
|
### Question:
MapOfStringsExpressionEvaluator implements ExpressionEvaluator { @Override public Object evaluate(Entity entity) { Entity result = new DynamicEntity(targetAttribute.getRefEntity()); for (Entry<String, ExpressionEvaluator> entry : evaluators.entrySet()) { result.set(entry.getKey(), entry.getValue().evaluate(entity)); } return result; } MapOfStringsExpressionEvaluator(Attribute attribute, EntityType entityType); @Override Object evaluate(Entity entity); }### Answer:
@Test void testEvaluate() { Attribute amd = when(mock(Attribute.class).getName()).thenReturn("#CHROM").getMock(); when(amd.getDataType()).thenReturn(XREF); when(amd.hasRefEntity()).thenReturn(true); when(amd.getRefEntity()).thenReturn(refEmd); when(amd.getExpression()).thenReturn("{'Chromosome':String, 'Position':Int}"); when(amd.getEntityType()).thenReturn(mock(EntityType.class)); when(amd.getDataType()).thenReturn(XREF); ExpressionEvaluator evaluator = new MapOfStringsExpressionEvaluator(amd, emd); Entity expected = new DynamicEntity(refEmd); expected.set("Chromosome", "12"); expected.set("Position", "1"); Entity actual = (Entity) evaluator.evaluate(entity); assertTrue(EntityUtils.equals(actual, expected)); }
|
### Question:
RepositoryCopier { public RepositoryCopier(MetaDataService metaDataService, AttributeFactory attrFactory) { this.metaDataService = requireNonNull(metaDataService); this.attrFactory = requireNonNull(attrFactory); } RepositoryCopier(MetaDataService metaDataService, AttributeFactory attrFactory); @Transactional Repository<Entity> copyRepository(
Repository<Entity> repository, String entityTypeId, Package pack, String entityTypeLabel); }### Answer:
@Test void testRepositoryCopier() { assertThrows(NullPointerException.class, () -> new RepositoryCopier(null, null)); }
|
### Question:
ExceptionUtils { static Optional<Throwable> getErrorCodedCause(Throwable throwable) { for (Throwable cause = throwable; cause != null; cause = cause.getCause()) { if (cause instanceof ErrorCoded) { return Optional.of(cause); } } return Optional.empty(); } private ExceptionUtils(); }### Answer:
@Test void testGetErrorCodedThrowable() { Throwable throwable = mock(CodedRuntimeException.class); assertEquals(of(throwable), getErrorCodedCause(throwable)); }
@Test void testGetErrorCodedThrowableCause() { Throwable throwableCauseCause = mock(CodedRuntimeException.class); Throwable throwableCause = mock(Throwable.class); Throwable throwable = mock(Throwable.class); when(throwable.getCause()).thenReturn(throwableCause); when(throwableCause.getCause()).thenReturn(throwableCauseCause); assertEquals(of(throwableCauseCause), getErrorCodedCause(throwable)); }
@Test void testGetErrorCodedCauseEmpty() { Throwable throwable = mock(Throwable.class); assertEquals(empty(), getErrorCodedCause(throwable)); }
|
### Question:
BatchingQueryResult extends BatchingIterable<E> { @Override protected List<E> getBatch(int offset, int batchSize) { Query<E> batchQuery; if (offset != query.getOffset() || batchSize != query.getPageSize()) { batchQuery = new QueryImpl<>(query).setOffset(offset).setPageSize(batchSize); } else { batchQuery = query; } return getBatch(batchQuery); } BatchingQueryResult(int batchSize, Query<E> query); }### Answer:
@Test void getBatch() { final int batchSize = 2; BatchingQueryResult<Entity> bqr = new DummyBatchingQueryResult(batchSize); assertEquals(4, size(bqr)); }
|
### Question:
PartialEntity implements Entity { @Override public Object get(String attributeName) { if (fetch.hasField(attributeName)) { return decoratedEntity.get(attributeName); } else { return entityManager.getReference(getEntityType(), getIdValue()).get(attributeName); } } PartialEntity(Entity decoratedEntity, Fetch fetch, EntityManager entityManager); EntityType getEntityType(); @Override Iterable<String> getAttributeNames(); @Override Object getIdValue(); @Override void setIdValue(Object id); @Override Object getLabelValue(); @Override Object get(String attributeName); @Override String getString(String attributeName); @Override Integer getInt(String attributeName); @Override Long getLong(String attributeName); @Override Boolean getBoolean(String attributeName); @Override Double getDouble(String attributeName); @Override Instant getInstant(String attributeName); @Override LocalDate getLocalDate(String attributeName); @Override Entity getEntity(String attributeName); @Override E getEntity(String attributeName, Class<E> clazz); @Override Iterable<Entity> getEntities(String attributeName); @Override Iterable<E> getEntities(String attributeName, Class<E> clazz); @Override void set(String attributeName, Object value); @Override void set(Entity values); }### Answer:
@Test void get() { partialEntity.get("id"); verify(decoratedEntity, times(1)).get("id"); verifyZeroInteractions(entityManager); }
@Test void getNotInFetch() { partialEntity.get("label"); verify(entityManager, times(1)).getReference(meta, "id"); }
|
### Question:
PartialEntity implements Entity { @Override public Boolean getBoolean(String attributeName) { if (fetch.hasField(attributeName)) { return decoratedEntity.getBoolean(attributeName); } else { return entityManager.getReference(getEntityType(), getIdValue()).getBoolean(attributeName); } } PartialEntity(Entity decoratedEntity, Fetch fetch, EntityManager entityManager); EntityType getEntityType(); @Override Iterable<String> getAttributeNames(); @Override Object getIdValue(); @Override void setIdValue(Object id); @Override Object getLabelValue(); @Override Object get(String attributeName); @Override String getString(String attributeName); @Override Integer getInt(String attributeName); @Override Long getLong(String attributeName); @Override Boolean getBoolean(String attributeName); @Override Double getDouble(String attributeName); @Override Instant getInstant(String attributeName); @Override LocalDate getLocalDate(String attributeName); @Override Entity getEntity(String attributeName); @Override E getEntity(String attributeName, Class<E> clazz); @Override Iterable<Entity> getEntities(String attributeName); @Override Iterable<E> getEntities(String attributeName, Class<E> clazz); @Override void set(String attributeName, Object value); @Override void set(Entity values); }### Answer:
@Test void getBoolean() { partialEntity.getBoolean("id"); verify(decoratedEntity, times(1)).getBoolean("id"); verifyZeroInteractions(entityManager); }
@Test void getBooleanNotInFetch() { partialEntity.getBoolean("label"); verify(entityManager, times(1)).getReference(meta, "id"); }
|
### Question:
PartialEntity implements Entity { @Override public LocalDate getLocalDate(String attributeName) { if (fetch.hasField(attributeName)) { return decoratedEntity.getLocalDate(attributeName); } else { return entityManager.getReference(getEntityType(), getIdValue()).getLocalDate(attributeName); } } PartialEntity(Entity decoratedEntity, Fetch fetch, EntityManager entityManager); EntityType getEntityType(); @Override Iterable<String> getAttributeNames(); @Override Object getIdValue(); @Override void setIdValue(Object id); @Override Object getLabelValue(); @Override Object get(String attributeName); @Override String getString(String attributeName); @Override Integer getInt(String attributeName); @Override Long getLong(String attributeName); @Override Boolean getBoolean(String attributeName); @Override Double getDouble(String attributeName); @Override Instant getInstant(String attributeName); @Override LocalDate getLocalDate(String attributeName); @Override Entity getEntity(String attributeName); @Override E getEntity(String attributeName, Class<E> clazz); @Override Iterable<Entity> getEntities(String attributeName); @Override Iterable<E> getEntities(String attributeName, Class<E> clazz); @Override void set(String attributeName, Object value); @Override void set(Entity values); }### Answer:
@Test void getDateNotInFetch() { partialEntity.getLocalDate("label"); verify(entityManager, times(1)).getReference(meta, "id"); }
@Test void getTimestamp() { partialEntity.getLocalDate("id"); verify(decoratedEntity, times(1)).getLocalDate("id"); verifyZeroInteractions(entityManager); }
@Test void getTimestampNotInFetch() { partialEntity.getLocalDate("label"); verify(entityManager, times(1)).getReference(meta, "id"); }
|
### Question:
PartialEntity implements Entity { @Override public Double getDouble(String attributeName) { if (fetch.hasField(attributeName)) { return decoratedEntity.getDouble(attributeName); } else { return entityManager.getReference(getEntityType(), getIdValue()).getDouble(attributeName); } } PartialEntity(Entity decoratedEntity, Fetch fetch, EntityManager entityManager); EntityType getEntityType(); @Override Iterable<String> getAttributeNames(); @Override Object getIdValue(); @Override void setIdValue(Object id); @Override Object getLabelValue(); @Override Object get(String attributeName); @Override String getString(String attributeName); @Override Integer getInt(String attributeName); @Override Long getLong(String attributeName); @Override Boolean getBoolean(String attributeName); @Override Double getDouble(String attributeName); @Override Instant getInstant(String attributeName); @Override LocalDate getLocalDate(String attributeName); @Override Entity getEntity(String attributeName); @Override E getEntity(String attributeName, Class<E> clazz); @Override Iterable<Entity> getEntities(String attributeName); @Override Iterable<E> getEntities(String attributeName, Class<E> clazz); @Override void set(String attributeName, Object value); @Override void set(Entity values); }### Answer:
@Test void getDouble() { partialEntity.getDouble("id"); verify(decoratedEntity, times(1)).getDouble("id"); verifyZeroInteractions(entityManager); }
@Test void getDoubleNotInFetch() { partialEntity.getDouble("label"); verify(entityManager, times(1)).getReference(meta, "id"); }
|
### Question:
PartialEntity implements Entity { @Override public Iterable<Entity> getEntities(String attributeName) { if (fetch.hasField(attributeName)) { return decoratedEntity.getEntities(attributeName); } else { return entityManager.getReference(getEntityType(), getIdValue()).getEntities(attributeName); } } PartialEntity(Entity decoratedEntity, Fetch fetch, EntityManager entityManager); EntityType getEntityType(); @Override Iterable<String> getAttributeNames(); @Override Object getIdValue(); @Override void setIdValue(Object id); @Override Object getLabelValue(); @Override Object get(String attributeName); @Override String getString(String attributeName); @Override Integer getInt(String attributeName); @Override Long getLong(String attributeName); @Override Boolean getBoolean(String attributeName); @Override Double getDouble(String attributeName); @Override Instant getInstant(String attributeName); @Override LocalDate getLocalDate(String attributeName); @Override Entity getEntity(String attributeName); @Override E getEntity(String attributeName, Class<E> clazz); @Override Iterable<Entity> getEntities(String attributeName); @Override Iterable<E> getEntities(String attributeName, Class<E> clazz); @Override void set(String attributeName, Object value); @Override void set(Entity values); }### Answer:
@Test void getEntitiesString() { partialEntity.getEntities("id"); verify(decoratedEntity, times(1)).getEntities("id"); verifyZeroInteractions(entityManager); }
@Test void getEntitiesStringNotInFetch() { partialEntity.getEntities("label"); verify(entityManager, times(1)).getReference(meta, "id"); }
@Test void getEntitiesStringClassE() { partialEntity.getEntities("id", Entity.class); verify(decoratedEntity, times(1)).getEntities("id", Entity.class); verifyZeroInteractions(entityManager); }
@Test void getEntitiesStringClassENotInFetch() { partialEntity.getEntities("label", Entity.class); verify(entityManager, times(1)).getReference(meta, "id"); }
|
### Question:
PartialEntity implements Entity { @Override public Entity getEntity(String attributeName) { if (fetch.hasField(attributeName)) { return decoratedEntity.getEntity(attributeName); } else { return entityManager.getReference(getEntityType(), getIdValue()).getEntity(attributeName); } } PartialEntity(Entity decoratedEntity, Fetch fetch, EntityManager entityManager); EntityType getEntityType(); @Override Iterable<String> getAttributeNames(); @Override Object getIdValue(); @Override void setIdValue(Object id); @Override Object getLabelValue(); @Override Object get(String attributeName); @Override String getString(String attributeName); @Override Integer getInt(String attributeName); @Override Long getLong(String attributeName); @Override Boolean getBoolean(String attributeName); @Override Double getDouble(String attributeName); @Override Instant getInstant(String attributeName); @Override LocalDate getLocalDate(String attributeName); @Override Entity getEntity(String attributeName); @Override E getEntity(String attributeName, Class<E> clazz); @Override Iterable<Entity> getEntities(String attributeName); @Override Iterable<E> getEntities(String attributeName, Class<E> clazz); @Override void set(String attributeName, Object value); @Override void set(Entity values); }### Answer:
@Test void getEntityString() { partialEntity.getEntity("id"); verify(decoratedEntity, times(1)).getEntity("id"); verifyZeroInteractions(entityManager); }
@Test void getEntityStringNotInFetch() { partialEntity.getEntity("label"); verify(entityManager, times(1)).getReference(meta, "id"); }
@Test void getEntityStringClassE() { partialEntity.getEntity("id", Entity.class); verify(decoratedEntity, times(1)).getEntity("id", Entity.class); verifyZeroInteractions(entityManager); }
@Test void getEntityStringClassENotInFetch() { partialEntity.getEntity("label", Entity.class); verify(entityManager, times(1)).getReference(meta, "id"); }
|
### Question:
PartialEntity implements Entity { @Override public Integer getInt(String attributeName) { if (fetch.hasField(attributeName)) { return decoratedEntity.getInt(attributeName); } else { return entityManager.getReference(getEntityType(), getIdValue()).getInt(attributeName); } } PartialEntity(Entity decoratedEntity, Fetch fetch, EntityManager entityManager); EntityType getEntityType(); @Override Iterable<String> getAttributeNames(); @Override Object getIdValue(); @Override void setIdValue(Object id); @Override Object getLabelValue(); @Override Object get(String attributeName); @Override String getString(String attributeName); @Override Integer getInt(String attributeName); @Override Long getLong(String attributeName); @Override Boolean getBoolean(String attributeName); @Override Double getDouble(String attributeName); @Override Instant getInstant(String attributeName); @Override LocalDate getLocalDate(String attributeName); @Override Entity getEntity(String attributeName); @Override E getEntity(String attributeName, Class<E> clazz); @Override Iterable<Entity> getEntities(String attributeName); @Override Iterable<E> getEntities(String attributeName, Class<E> clazz); @Override void set(String attributeName, Object value); @Override void set(Entity values); }### Answer:
@Test void getInt() { partialEntity.getInt("id"); verify(decoratedEntity, times(1)).getInt("id"); verifyZeroInteractions(entityManager); }
@Test void getIntNotInFetch() { partialEntity.getInt("label"); verify(entityManager, times(1)).getReference(meta, "id"); }
|
### Question:
PartialEntity implements Entity { @Override public Long getLong(String attributeName) { if (fetch.hasField(attributeName)) { return decoratedEntity.getLong(attributeName); } else { return entityManager.getReference(getEntityType(), getIdValue()).getLong(attributeName); } } PartialEntity(Entity decoratedEntity, Fetch fetch, EntityManager entityManager); EntityType getEntityType(); @Override Iterable<String> getAttributeNames(); @Override Object getIdValue(); @Override void setIdValue(Object id); @Override Object getLabelValue(); @Override Object get(String attributeName); @Override String getString(String attributeName); @Override Integer getInt(String attributeName); @Override Long getLong(String attributeName); @Override Boolean getBoolean(String attributeName); @Override Double getDouble(String attributeName); @Override Instant getInstant(String attributeName); @Override LocalDate getLocalDate(String attributeName); @Override Entity getEntity(String attributeName); @Override E getEntity(String attributeName, Class<E> clazz); @Override Iterable<Entity> getEntities(String attributeName); @Override Iterable<E> getEntities(String attributeName, Class<E> clazz); @Override void set(String attributeName, Object value); @Override void set(Entity values); }### Answer:
@Test void getLong() { partialEntity.getLong("id"); verify(decoratedEntity, times(1)).getLong("id"); verifyZeroInteractions(entityManager); }
@Test void getLongNotInFetch() { partialEntity.getLong("label"); verify(entityManager, times(1)).getReference(meta, "id"); }
|
### Question:
PartialEntity implements Entity { @Override public String getString(String attributeName) { if (fetch.hasField(attributeName)) { return decoratedEntity.getString(attributeName); } else { return entityManager.getReference(getEntityType(), getIdValue()).getString(attributeName); } } PartialEntity(Entity decoratedEntity, Fetch fetch, EntityManager entityManager); EntityType getEntityType(); @Override Iterable<String> getAttributeNames(); @Override Object getIdValue(); @Override void setIdValue(Object id); @Override Object getLabelValue(); @Override Object get(String attributeName); @Override String getString(String attributeName); @Override Integer getInt(String attributeName); @Override Long getLong(String attributeName); @Override Boolean getBoolean(String attributeName); @Override Double getDouble(String attributeName); @Override Instant getInstant(String attributeName); @Override LocalDate getLocalDate(String attributeName); @Override Entity getEntity(String attributeName); @Override E getEntity(String attributeName, Class<E> clazz); @Override Iterable<Entity> getEntities(String attributeName); @Override Iterable<E> getEntities(String attributeName, Class<E> clazz); @Override void set(String attributeName, Object value); @Override void set(Entity values); }### Answer:
@Test void getString() { partialEntity.getString("id"); verify(decoratedEntity, times(1)).getString("id"); verifyZeroInteractions(entityManager); }
@Test void getStringNotInFetch() { partialEntity.getString("label"); verify(entityManager, times(1)).getReference(meta, "id"); }
|
### Question:
PartialEntity implements Entity { @Override public Instant getInstant(String attributeName) { if (fetch.hasField(attributeName)) { return decoratedEntity.getInstant(attributeName); } else { return entityManager.getReference(getEntityType(), getIdValue()).getInstant(attributeName); } } PartialEntity(Entity decoratedEntity, Fetch fetch, EntityManager entityManager); EntityType getEntityType(); @Override Iterable<String> getAttributeNames(); @Override Object getIdValue(); @Override void setIdValue(Object id); @Override Object getLabelValue(); @Override Object get(String attributeName); @Override String getString(String attributeName); @Override Integer getInt(String attributeName); @Override Long getLong(String attributeName); @Override Boolean getBoolean(String attributeName); @Override Double getDouble(String attributeName); @Override Instant getInstant(String attributeName); @Override LocalDate getLocalDate(String attributeName); @Override Entity getEntity(String attributeName); @Override E getEntity(String attributeName, Class<E> clazz); @Override Iterable<Entity> getEntities(String attributeName); @Override Iterable<E> getEntities(String attributeName, Class<E> clazz); @Override void set(String attributeName, Object value); @Override void set(Entity values); }### Answer:
@Test void getUtilDate() { partialEntity.getInstant("id"); verify(decoratedEntity, times(1)).getInstant("id"); verifyZeroInteractions(entityManager); }
@Test void getUtilDateNotInFetch() { partialEntity.getInstant("label"); verify(entityManager, times(1)).getReference(meta, "id"); }
|
### Question:
PartialEntity implements Entity { @Override public void set(String attributeName, Object value) { decoratedEntity.set(attributeName, value); } PartialEntity(Entity decoratedEntity, Fetch fetch, EntityManager entityManager); EntityType getEntityType(); @Override Iterable<String> getAttributeNames(); @Override Object getIdValue(); @Override void setIdValue(Object id); @Override Object getLabelValue(); @Override Object get(String attributeName); @Override String getString(String attributeName); @Override Integer getInt(String attributeName); @Override Long getLong(String attributeName); @Override Boolean getBoolean(String attributeName); @Override Double getDouble(String attributeName); @Override Instant getInstant(String attributeName); @Override LocalDate getLocalDate(String attributeName); @Override Entity getEntity(String attributeName); @Override E getEntity(String attributeName, Class<E> clazz); @Override Iterable<Entity> getEntities(String attributeName); @Override Iterable<E> getEntities(String attributeName, Class<E> clazz); @Override void set(String attributeName, Object value); @Override void set(Entity values); }### Answer:
@Test void setStringObject() { Object obj = mock(Object.class); partialEntity.set("test", obj); verify(decoratedEntity, times(1)).set("test", obj); verifyZeroInteractions(entityManager); }
@Test void setEntity() { Entity e = mock(Entity.class); partialEntity.set(e); verify(decoratedEntity, times(1)).set(e); verifyZeroInteractions(entityManager); }
|
### Question:
PartialEntity implements Entity { @Override public Iterable<String> getAttributeNames() { return decoratedEntity.getAttributeNames(); } PartialEntity(Entity decoratedEntity, Fetch fetch, EntityManager entityManager); EntityType getEntityType(); @Override Iterable<String> getAttributeNames(); @Override Object getIdValue(); @Override void setIdValue(Object id); @Override Object getLabelValue(); @Override Object get(String attributeName); @Override String getString(String attributeName); @Override Integer getInt(String attributeName); @Override Long getLong(String attributeName); @Override Boolean getBoolean(String attributeName); @Override Double getDouble(String attributeName); @Override Instant getInstant(String attributeName); @Override LocalDate getLocalDate(String attributeName); @Override Entity getEntity(String attributeName); @Override E getEntity(String attributeName, Class<E> clazz); @Override Iterable<Entity> getEntities(String attributeName); @Override Iterable<E> getEntities(String attributeName, Class<E> clazz); @Override void set(String attributeName, Object value); @Override void set(Entity values); }### Answer:
@Test void getAttributeNames() { partialEntity.getAttributeNames(); verify(decoratedEntity, times(1)).getAttributeNames(); verifyZeroInteractions(entityManager); }
|
### Question:
PartialEntity implements Entity { public EntityType getEntityType() { return decoratedEntity.getEntityType(); } PartialEntity(Entity decoratedEntity, Fetch fetch, EntityManager entityManager); EntityType getEntityType(); @Override Iterable<String> getAttributeNames(); @Override Object getIdValue(); @Override void setIdValue(Object id); @Override Object getLabelValue(); @Override Object get(String attributeName); @Override String getString(String attributeName); @Override Integer getInt(String attributeName); @Override Long getLong(String attributeName); @Override Boolean getBoolean(String attributeName); @Override Double getDouble(String attributeName); @Override Instant getInstant(String attributeName); @Override LocalDate getLocalDate(String attributeName); @Override Entity getEntity(String attributeName); @Override E getEntity(String attributeName, Class<E> clazz); @Override Iterable<Entity> getEntities(String attributeName); @Override Iterable<E> getEntities(String attributeName, Class<E> clazz); @Override void set(String attributeName, Object value); @Override void set(Entity values); }### Answer:
@Test void getEntityType() { partialEntity.getEntityType(); verify(decoratedEntity, times(1)).getEntityType(); verifyZeroInteractions(entityManager); }
|
### Question:
PartialEntity implements Entity { @Override public Object getIdValue() { return decoratedEntity.getIdValue(); } PartialEntity(Entity decoratedEntity, Fetch fetch, EntityManager entityManager); EntityType getEntityType(); @Override Iterable<String> getAttributeNames(); @Override Object getIdValue(); @Override void setIdValue(Object id); @Override Object getLabelValue(); @Override Object get(String attributeName); @Override String getString(String attributeName); @Override Integer getInt(String attributeName); @Override Long getLong(String attributeName); @Override Boolean getBoolean(String attributeName); @Override Double getDouble(String attributeName); @Override Instant getInstant(String attributeName); @Override LocalDate getLocalDate(String attributeName); @Override Entity getEntity(String attributeName); @Override E getEntity(String attributeName, Class<E> clazz); @Override Iterable<Entity> getEntities(String attributeName); @Override Iterable<E> getEntities(String attributeName, Class<E> clazz); @Override void set(String attributeName, Object value); @Override void set(Entity values); }### Answer:
@Test void getIdValue() { partialEntity.getIdValue(); verify(decoratedEntity, times(1)).getIdValue(); verifyZeroInteractions(entityManager); }
|
### Question:
PartialEntity implements Entity { @Override public Object getLabelValue() { return decoratedEntity.getLabelValue(); } PartialEntity(Entity decoratedEntity, Fetch fetch, EntityManager entityManager); EntityType getEntityType(); @Override Iterable<String> getAttributeNames(); @Override Object getIdValue(); @Override void setIdValue(Object id); @Override Object getLabelValue(); @Override Object get(String attributeName); @Override String getString(String attributeName); @Override Integer getInt(String attributeName); @Override Long getLong(String attributeName); @Override Boolean getBoolean(String attributeName); @Override Double getDouble(String attributeName); @Override Instant getInstant(String attributeName); @Override LocalDate getLocalDate(String attributeName); @Override Entity getEntity(String attributeName); @Override E getEntity(String attributeName, Class<E> clazz); @Override Iterable<Entity> getEntities(String attributeName); @Override Iterable<E> getEntities(String attributeName, Class<E> clazz); @Override void set(String attributeName, Object value); @Override void set(Entity values); }### Answer:
@Test void getLabelValue() { partialEntity.getLabelValue(); verify(decoratedEntity, times(1)).getLabelValue(); verifyZeroInteractions(entityManager); }
|
### Question:
ExpressionEvaluatorFactory { static ExpressionEvaluator createExpressionEvaluator(Attribute attribute, EntityType entityType) { ExpressionEvaluator expressionEvaluator; Object expressionJson = new Gson().fromJson(attribute.getExpression(), Object.class); if (expressionJson instanceof String) { expressionEvaluator = new StringExpressionEvaluator(attribute, entityType); } else { switch (attribute.getDataType()) { case BOOL: case CATEGORICAL: case CATEGORICAL_MREF: case COMPOUND: case DATE: case DATE_TIME: case DECIMAL: case FILE: case INT: case LONG: case MREF: case ONE_TO_MANY: case XREF: expressionEvaluator = new MapOfStringsExpressionEvaluator(attribute, entityType); break; case EMAIL: case ENUM: case HTML: case HYPERLINK: case SCRIPT: case STRING: case TEXT: expressionEvaluator = new TemplateExpressionEvaluator(attribute, entityType); break; default: throw new UnexpectedEnumException(attribute.getDataType()); } } return expressionEvaluator; } private ExpressionEvaluatorFactory(); }### Answer:
@Test void testCreateExpressionEvaluatorStringExpressionEvaluator() { Attribute attribute = when(mock(Attribute.class).getName()).thenReturn("attr").getMock(); Attribute otherAttribute = when(mock(Attribute.class).getName()).thenReturn("otherAttr").getMock(); when(attribute.getExpression()).thenReturn("otherAttr"); EntityType entityType = mock(EntityType.class); when(entityType.getAttribute("attr")).thenReturn(attribute); when(entityType.getAttribute("otherAttr")).thenReturn(otherAttribute); assertTrue( ExpressionEvaluatorFactory.createExpressionEvaluator(attribute, entityType) instanceof StringExpressionEvaluator); }
@Test void testCreateExpressionEvaluatorTemplateExpressionEvaluator() { Attribute attribute = when(mock(Attribute.class).getDataType()).thenReturn(STRING).getMock(); EntityType entityType = mock(EntityType.class); assertTrue( ExpressionEvaluatorFactory.createExpressionEvaluator(attribute, entityType) instanceof TemplateExpressionEvaluator); }
|
### Question:
AbstractRepository implements Repository<Entity> { @Override public void add(Entity entity) { throw new UnsupportedOperationException(); } @Override String getName(); @Override Set<Operator> getQueryOperators(); Query<Entity> query(); @Override long count(); @Override void close(); @Override long count(Query<Entity> q); @Override Stream<Entity> findAll(Query<Entity> q); @Override Entity findOne(Query<Entity> q); @Override Entity findOneById(Object id); @Override Entity findOneById(Object id, Fetch fetch); @Override Stream<Entity> findAll(Stream<Object> ids); @Override Stream<Entity> findAll(Stream<Object> ids, Fetch fetch); @Override AggregateResult aggregate(AggregateQuery aggregateQuery); @Override void update(Entity entity); @Override void update(Stream<Entity> entities); @Override void delete(Entity entity); @Override void delete(Stream<Entity> entities); @Override void deleteById(Object id); @Override void deleteAll(Stream<Object> ids); @Override void deleteAll(); @Override void add(Entity entity); @Override Integer add(Stream<Entity> entities); @Override void forEachBatched(Fetch fetch, Consumer<List<Entity>> consumer, int batchSize); }### Answer:
@Test void addStream() { assertThrows(UnsupportedOperationException.class, () -> abstractRepository.add(Stream.empty())); }
|
### Question:
AbstractRepository implements Repository<Entity> { @Override public void delete(Entity entity) { throw new UnsupportedOperationException(); } @Override String getName(); @Override Set<Operator> getQueryOperators(); Query<Entity> query(); @Override long count(); @Override void close(); @Override long count(Query<Entity> q); @Override Stream<Entity> findAll(Query<Entity> q); @Override Entity findOne(Query<Entity> q); @Override Entity findOneById(Object id); @Override Entity findOneById(Object id, Fetch fetch); @Override Stream<Entity> findAll(Stream<Object> ids); @Override Stream<Entity> findAll(Stream<Object> ids, Fetch fetch); @Override AggregateResult aggregate(AggregateQuery aggregateQuery); @Override void update(Entity entity); @Override void update(Stream<Entity> entities); @Override void delete(Entity entity); @Override void delete(Stream<Entity> entities); @Override void deleteById(Object id); @Override void deleteAll(Stream<Object> ids); @Override void deleteAll(); @Override void add(Entity entity); @Override Integer add(Stream<Entity> entities); @Override void forEachBatched(Fetch fetch, Consumer<List<Entity>> consumer, int batchSize); }### Answer:
@Test void deleteStream() { assertThrows( UnsupportedOperationException.class, () -> abstractRepository.delete(Stream.empty())); }
|
### Question:
AbstractRepository implements Repository<Entity> { @Override public void update(Entity entity) { throw new UnsupportedOperationException(); } @Override String getName(); @Override Set<Operator> getQueryOperators(); Query<Entity> query(); @Override long count(); @Override void close(); @Override long count(Query<Entity> q); @Override Stream<Entity> findAll(Query<Entity> q); @Override Entity findOne(Query<Entity> q); @Override Entity findOneById(Object id); @Override Entity findOneById(Object id, Fetch fetch); @Override Stream<Entity> findAll(Stream<Object> ids); @Override Stream<Entity> findAll(Stream<Object> ids, Fetch fetch); @Override AggregateResult aggregate(AggregateQuery aggregateQuery); @Override void update(Entity entity); @Override void update(Stream<Entity> entities); @Override void delete(Entity entity); @Override void delete(Stream<Entity> entities); @Override void deleteById(Object id); @Override void deleteAll(Stream<Object> ids); @Override void deleteAll(); @Override void add(Entity entity); @Override Integer add(Stream<Entity> entities); @Override void forEachBatched(Fetch fetch, Consumer<List<Entity>> consumer, int batchSize); }### Answer:
@Test void updateStream() { assertThrows( UnsupportedOperationException.class, () -> abstractRepository.update(Stream.empty())); }
|
### Question:
AbstractRepository implements Repository<Entity> { @Override public Entity findOneById(Object id) { return findOneById(id, null); } @Override String getName(); @Override Set<Operator> getQueryOperators(); Query<Entity> query(); @Override long count(); @Override void close(); @Override long count(Query<Entity> q); @Override Stream<Entity> findAll(Query<Entity> q); @Override Entity findOne(Query<Entity> q); @Override Entity findOneById(Object id); @Override Entity findOneById(Object id, Fetch fetch); @Override Stream<Entity> findAll(Stream<Object> ids); @Override Stream<Entity> findAll(Stream<Object> ids, Fetch fetch); @Override AggregateResult aggregate(AggregateQuery aggregateQuery); @Override void update(Entity entity); @Override void update(Stream<Entity> entities); @Override void delete(Entity entity); @Override void delete(Stream<Entity> entities); @Override void deleteById(Object id); @Override void deleteAll(Stream<Object> ids); @Override void deleteAll(); @Override void add(Entity entity); @Override Integer add(Stream<Entity> entities); @Override void forEachBatched(Fetch fetch, Consumer<List<Entity>> consumer, int batchSize); }### Answer:
@Test void findOneObjectFetch() { assertThrows( UnsupportedOperationException.class, () -> abstractRepository.findOneById(0, new Fetch())); }
|
### Question:
EntityReferenceCreatorImpl implements EntityReferenceCreator { public EntityReferenceCreatorImpl( DataService dataService, EntityFactoryRegistry entityFactoryRegistry) { this.dataService = requireNonNull(dataService); this.entityFactoryRegistry = requireNonNull(entityFactoryRegistry); } EntityReferenceCreatorImpl(
DataService dataService, EntityFactoryRegistry entityFactoryRegistry); @Override Entity getReference(EntityType entityType, Object id); @Override Iterable<Entity> getReferences(EntityType entityType, Iterable<?> ids); }### Answer:
@Test void EntityReferenceCreatorImpl() { assertThrows(NullPointerException.class, () -> new EntityReferenceCreatorImpl(null, null)); }
|
### Question:
EntityReferenceCreatorImpl implements EntityReferenceCreator { @Override public Entity getReference(EntityType entityType, Object id) { Entity lazyEntity = new LazyEntity(entityType, dataService, id); EntityFactory<? extends Entity, ?> entityFactory = entityFactoryRegistry.getEntityFactory(entityType); if (entityFactory != null) { lazyEntity = entityFactory.create(lazyEntity); } return lazyEntity; } EntityReferenceCreatorImpl(
DataService dataService, EntityFactoryRegistry entityFactoryRegistry); @Override Entity getReference(EntityType entityType, Object id); @Override Iterable<Entity> getReferences(EntityType entityType, Iterable<?> ids); }### Answer:
@Test void getReference() { String entityTypeId = "entity"; EntityType entityType = when(mock(EntityType.class).getId()).thenReturn(entityTypeId).getMock(); Attribute idAttr = when(mock(Attribute.class).getName()).thenReturn("id").getMock(); Attribute lblAttr = when(mock(Attribute.class).getName()).thenReturn("label").getMock(); when(entityType.getIdAttribute()).thenReturn(idAttr); when(entityType.getLabelAttribute()).thenReturn(lblAttr); String label = "label"; Integer id = 0; Entity entity = when(mock(Entity.class).getLabelValue()).thenReturn(label).getMock(); when(dataService.findOneById(entityTypeId, id)).thenReturn(entity); Entity entityReference = entityManagerImpl.getReference(entityType, id); assertEquals(id, entityReference.getIdValue()); verifyNoMoreInteractions(dataService); assertEquals(entityReference.getLabelValue(), label); verify(dataService, times(1)).findOneById(entityTypeId, id); }
|
### Question:
MetricsController { @GetMapping(path = "prometheus", produces = CONTENT_TYPE_004) @ResponseStatus(HttpStatus.OK) @PreAuthorize("hasAnyRole('METRICS')") @ApiResponses({ @ApiResponse( code = 200, message = "Tab separated metrics values in a format fit for prometheus to consume"), @ApiResponse(code = 403, message = "Current user does not have ROLE_METRICS"), @ApiResponse( code = 401, message = "User is not authenticated and anonymous user does not have ROLE_METRICS") }) @ApiOperation( value = "Get recorded metrics for prometheus.", response = String.class, produces = CONTENT_TYPE_004) public String prometheus() { return meterRegistry.scrape(); } MetricsController(PrometheusMeterRegistry meterRegistry); @GetMapping(path = "prometheus", produces = CONTENT_TYPE_004) @ResponseStatus(HttpStatus.OK) @PreAuthorize("hasAnyRole('METRICS')") @ApiResponses({ @ApiResponse( code = 200, message = "Tab separated metrics values in a format fit for prometheus to consume"), @ApiResponse(code = 403, message = "Current user does not have ROLE_METRICS"), @ApiResponse( code = 401, message = "User is not authenticated and anonymous user does not have ROLE_METRICS") }) @ApiOperation( value = "Get recorded metrics for prometheus.", response = String.class, produces = CONTENT_TYPE_004) String prometheus(); }### Answer:
@Test void testPrometheus() { when(meterRegistry.scrape()).thenReturn("scraped"); String actual = metricsController.prometheus(); assertEquals("scraped", actual); }
|
### Question:
LanguageFactory extends AbstractSystemEntityFactory<Language, LanguageMetadata, String> { public Language create(String code, String name, boolean active) { Language language = super.create(code); language.setName(name); language.setActive(active); return language; } LanguageFactory(LanguageMetadata languageMetadata, EntityPopulator entityPopulator); Language create(String code, String name, boolean active); }### Answer:
@Override @Test public void testCreate() { super.testCreate(factory, Language.class); }
|
### Question:
LanguageRepositoryDecorator extends AbstractRepositoryDecorator<Language> { @Override public void add(Language language) { validateLanguage(language); delegate().add(language); } LanguageRepositoryDecorator(Repository<Language> delegateRepository); @Override void delete(Language language); @Override void delete(Stream<Language> entities); @Override void deleteById(Object id); @Override void deleteAll(Stream<Object> ids); @Override void deleteAll(); @Override void add(Language language); @Override Integer add(Stream<Language> languageStream); }### Answer:
@Test void testAddExistingLanguage() { Language language = getMockLanguage(LANGUAGE_CODE_NL); languageRepositoryDecorator.add(language); verify(delegateRepository).add(language); }
@Test void testAddUnknownLanguage() { Language language = getMockLanguage("unknownLanguage"); assertThrows( LanguageModificationException.class, () -> languageRepositoryDecorator.add(language)); }
@SuppressWarnings({"unchecked", "ResultOfMethodCallIgnored"}) @Test void testAddStreamExistingLanguages() { Language language0 = getMockLanguage(LANGUAGE_CODE_EN); Language language1 = getMockLanguage(LANGUAGE_CODE_NL); doAnswer( invocation -> { ((Stream<Language>) invocation.getArguments()[0]).collect(toList()); return 2; }) .when(delegateRepository) .add(any(Stream.class)); assertEquals(valueOf(2), languageRepositoryDecorator.add(of(language0, language1))); }
@SuppressWarnings({"unchecked", "ResultOfMethodCallIgnored"}) @Test void testAddStreamUnknownLanguage() { Language language = getMockLanguage("unknownLanguage"); doAnswer( invocation -> { ((Stream<Language>) invocation.getArguments()[0]).collect(toList()); return 1; }) .when(delegateRepository) .add(any(Stream.class)); assertThrows( LanguageModificationException.class, () -> languageRepositoryDecorator.add(Stream.of(language))); }
|
### Question:
LanguageRepositoryDecorator extends AbstractRepositoryDecorator<Language> { @Override public void delete(Language language) { throw new LanguageModificationException(); } LanguageRepositoryDecorator(Repository<Language> delegateRepository); @Override void delete(Language language); @Override void delete(Stream<Language> entities); @Override void deleteById(Object id); @Override void deleteAll(Stream<Object> ids); @Override void deleteAll(); @Override void add(Language language); @Override Integer add(Stream<Language> languageStream); }### Answer:
@Test void testDelete() { assertThrows( LanguageModificationException.class, () -> languageRepositoryDecorator.delete(mock(Language.class))); }
@Test void testDeleteStream() { assertThrows( LanguageModificationException.class, () -> languageRepositoryDecorator.delete(Stream.of(mock(Language.class)))); }
|
### Question:
LanguageRepositoryDecorator extends AbstractRepositoryDecorator<Language> { @Override public void deleteById(Object id) { Language entity = findOneById(id); if (entity != null) delete(entity); } LanguageRepositoryDecorator(Repository<Language> delegateRepository); @Override void delete(Language language); @Override void delete(Stream<Language> entities); @Override void deleteById(Object id); @Override void deleteAll(Stream<Object> ids); @Override void deleteAll(); @Override void add(Language language); @Override Integer add(Stream<Language> languageStream); }### Answer:
@Test void testDeleteById() { Language language = mock(Language.class); when(delegateRepository.findOneById(LANGUAGE_CODE_NL)).thenReturn(language); assertThrows( LanguageModificationException.class, () -> languageRepositoryDecorator.deleteById(LANGUAGE_CODE_NL)); }
|
### Question:
LocalizationService implements MessageResolution { @Override @RunAsSystem public String resolveCodeWithoutArguments(String code, Locale locale) { return Optional.ofNullable( dataService.query(L10N_STRING, L10nString.class).eq(MSGID, code).findOne()) .map(l10nString -> l10nString.getString(locale)) .orElse(null); } LocalizationService(DataService dataService, L10nStringFactory l10nStringFactory); @Override @RunAsSystem String resolveCodeWithoutArguments(String code, Locale locale); @RunAsSystem Map<String, String> getMessages(String namespace, Locale locale); List<String> getAllMessageIds(); Stream<L10nString> getExistingMessages(String namespace, Set<String> messageIds); @Transactional void addMissingMessageIds(String namespace, Set<String> messageIDs); @Transactional void deleteNamespace(String namespace); void store(Collection<L10nString> toUpdate, Collection<L10nString> toAdd); }### Answer:
@Test void testGetMessage() { doReturn("string 1 - nl").when(enPlusNl).getString(DUTCH); @SuppressWarnings("unchecked") Query<L10nString> query = mock(Query.class, RETURNS_SELF); when(dataService.query(L10N_STRING, L10nString.class)).thenReturn(query); when(query.eq(MSGID, "EN_PLUS_NL").findOne()).thenReturn(enPlusNl); assertEquals( "string 1 - nl", localizationService.resolveCodeWithoutArguments("EN_PLUS_NL", DUTCH)); }
|
### Question:
LocalizationService implements MessageResolution { @RunAsSystem public Map<String, String> getMessages(String namespace, Locale locale) { return getL10nStrings(namespace).stream() .filter(e -> e.getString(locale) != null) .collect(toMap(L10nString::getMessageID, e -> e.getString(locale))); } LocalizationService(DataService dataService, L10nStringFactory l10nStringFactory); @Override @RunAsSystem String resolveCodeWithoutArguments(String code, Locale locale); @RunAsSystem Map<String, String> getMessages(String namespace, Locale locale); List<String> getAllMessageIds(); Stream<L10nString> getExistingMessages(String namespace, Set<String> messageIds); @Transactional void addMissingMessageIds(String namespace, Set<String> messageIDs); @Transactional void deleteNamespace(String namespace); void store(Collection<L10nString> toUpdate, Collection<L10nString> toAdd); }### Answer:
@Test void testGetMessages() { @SuppressWarnings("unchecked") Query<L10nString> query = mock(Query.class, RETURNS_SELF); when(dataService.query(L10N_STRING, L10nString.class)).thenReturn(query); when(query.eq(NAMESPACE, "test").findAll()).thenReturn(Stream.of(enPlusNl, nlOnly)); when(enPlusNl.getMessageID()).thenReturn("EN_PLUS_NL"); doReturn("string 1 - nl").when(enPlusNl).getString(DUTCH); when(nlOnly.getMessageID()).thenReturn("NL_ONLY"); doReturn("string 2 - nl").when(nlOnly).getString(DUTCH); assertEquals( of("EN_PLUS_NL", "string 1 - nl", "NL_ONLY", "string 2 - nl"), localizationService.getMessages("test", DUTCH)); }
|
### Question:
LocalizationService implements MessageResolution { @Transactional public void deleteNamespace(String namespace) { List<L10nString> namespaceEntities = getL10nStrings(namespace); dataService.delete(L10N_STRING, namespaceEntities.stream()); } LocalizationService(DataService dataService, L10nStringFactory l10nStringFactory); @Override @RunAsSystem String resolveCodeWithoutArguments(String code, Locale locale); @RunAsSystem Map<String, String> getMessages(String namespace, Locale locale); List<String> getAllMessageIds(); Stream<L10nString> getExistingMessages(String namespace, Set<String> messageIds); @Transactional void addMissingMessageIds(String namespace, Set<String> messageIDs); @Transactional void deleteNamespace(String namespace); void store(Collection<L10nString> toUpdate, Collection<L10nString> toAdd); }### Answer:
@Test void testDeleteNamespace() { @SuppressWarnings("unchecked") Query<L10nString> query = mock(Query.class, RETURNS_SELF); when(dataService.query(L10N_STRING, L10nString.class)).thenReturn(query); when(query.eq(NAMESPACE, "test").findAll()).thenReturn(Stream.of(enPlusNl, nlOnly)); localizationService.deleteNamespace("test"); verify(dataService).delete(eq(L10N_STRING), deleteCaptor.capture()); assertEquals(newArrayList(enPlusNl, nlOnly), deleteCaptor.getValue().collect(toList())); }
|
### Question:
LocalizationService implements MessageResolution { public void store(Collection<L10nString> toUpdate, Collection<L10nString> toAdd) { dataService.update(L10N_STRING, toUpdate.stream()); dataService.add(L10N_STRING, toAdd.stream()); } LocalizationService(DataService dataService, L10nStringFactory l10nStringFactory); @Override @RunAsSystem String resolveCodeWithoutArguments(String code, Locale locale); @RunAsSystem Map<String, String> getMessages(String namespace, Locale locale); List<String> getAllMessageIds(); Stream<L10nString> getExistingMessages(String namespace, Set<String> messageIds); @Transactional void addMissingMessageIds(String namespace, Set<String> messageIDs); @Transactional void deleteNamespace(String namespace); void store(Collection<L10nString> toUpdate, Collection<L10nString> toAdd); }### Answer:
@Test void testStore() { List<L10nString> toAdd = singletonList(newString1); List<L10nString> toUpdate = singletonList(enPlusNl); localizationService.store(toUpdate, toAdd); verify(dataService).add(eq(L10N_STRING), addCaptor.capture()); verify(dataService).update(eq(L10N_STRING), updateCaptor.capture()); assertEquals(toAdd, addCaptor.getValue().collect(toList())); assertEquals(toUpdate, updateCaptor.getValue().collect(toList())); }
|
### Question:
LocalizationService implements MessageResolution { public List<String> getAllMessageIds() { return dataService .findAll(L10N_STRING, L10nString.class) .map(L10nString::getMessageID) .collect(toList()); } LocalizationService(DataService dataService, L10nStringFactory l10nStringFactory); @Override @RunAsSystem String resolveCodeWithoutArguments(String code, Locale locale); @RunAsSystem Map<String, String> getMessages(String namespace, Locale locale); List<String> getAllMessageIds(); Stream<L10nString> getExistingMessages(String namespace, Set<String> messageIds); @Transactional void addMissingMessageIds(String namespace, Set<String> messageIDs); @Transactional void deleteNamespace(String namespace); void store(Collection<L10nString> toUpdate, Collection<L10nString> toAdd); }### Answer:
@Test void testGetAllMessageIds() { when(dataService.findAll(L10N_STRING, L10nString.class)) .thenReturn(Stream.of(enPlusNl, nlOnly)); when(enPlusNl.getMessageID()).thenReturn("A"); when(nlOnly.getMessageID()).thenReturn("B"); assertEquals(asList("A", "B"), localizationService.getAllMessageIds()); }
|
### Question:
I18nUtils { public static boolean isI18n(String name) { return name.matches(".+-[a-z]{2,3}$"); } private I18nUtils(); static boolean isI18n(String name); static String getLanguageCode(String name); }### Answer:
@Test void isI18n() { assertTrue(I18nUtils.isI18n("test-nl")); assertTrue(I18nUtils.isI18n("test-xxx")); assertFalse(I18nUtils.isI18n("test")); assertFalse(I18nUtils.isI18n("test-NL")); assertFalse(I18nUtils.isI18n("test-nlnl")); assertFalse(I18nUtils.isI18n("test-")); assertFalse(I18nUtils.isI18n("test-n1")); assertFalse(I18nUtils.isI18n("-nl")); }
|
### Question:
I18nUtils { public static String getLanguageCode(String name) { if (!isI18n(name)) return null; return name.substring(name.indexOf('-') + 1, name.length()); } private I18nUtils(); static boolean isI18n(String name); static String getLanguageCode(String name); }### Answer:
@Test void getLanguageCode() { assertEquals("nl", I18nUtils.getLanguageCode("test-nl")); assertEquals("xxx", I18nUtils.getLanguageCode("test-xxx")); assertNull(I18nUtils.getLanguageCode("test")); }
|
### Question:
JobsController extends PluginController { @PostMapping("/cancel/{jobExecutionType}/{jobExecutionId}") @ResponseStatus(NO_CONTENT) public void cancel( @PathVariable("jobExecutionType") String jobExecutionType, @PathVariable("jobExecutionId") String jobExecutionId) { jobsService.cancel(jobExecutionType, jobExecutionId); } JobsController(
JobsService jobsService,
UserAccountService userAccountService,
DataService dataService,
JobExecutionMetaData jobMetaDataMetaData,
JobScheduler jobScheduler,
MenuReaderService menuReaderService,
UserPermissionEvaluator userPermissionEvaluator); @GetMapping String init(Model model); @GetMapping("/viewJob") String viewJob(
Model model,
@RequestParam(name = "jobHref") String jobHref,
@RequestParam(name = "refreshTimeoutMillis", defaultValue = "10000")
Integer refreshTimeoutMillis); @Transactional(readOnly = true) @GetMapping(value = "/latest", produces = MediaType.APPLICATION_JSON_VALUE) @ResponseBody List<Entity> findLastJobs(); @PostMapping("/cancel/{jobExecutionType}/{jobExecutionId}") @ResponseStatus(NO_CONTENT) void cancel(
@PathVariable("jobExecutionType") String jobExecutionType,
@PathVariable("jobExecutionId") String jobExecutionId); @PostMapping("/run/{scheduledJobId}") @ResponseStatus(NO_CONTENT) void runNow(@PathVariable("scheduledJobId") String scheduledJobId); String createJobExecutionViewHref(String jobHref, int refreshTimeoutMillis); static final String ID; static final String URI; }### Answer:
@Test void testCancel() { String jobExecutionType = "MyJobExecutionType"; String jobExecutionId = "MyJobExecutionId"; jobsController.cancel(jobExecutionType, jobExecutionId); verify(jobsService).cancel(jobExecutionType, jobExecutionId); }
|
### Question:
JobsController extends PluginController { public String createJobExecutionViewHref(String jobHref, int refreshTimeoutMillis) { String jobControllerURL = menuReaderService.findMenuItemPath(ID); return format( "%s/viewJob/?jobHref=%s&refreshTimeoutMillis=%s", jobControllerURL, jobHref, refreshTimeoutMillis); } JobsController(
JobsService jobsService,
UserAccountService userAccountService,
DataService dataService,
JobExecutionMetaData jobMetaDataMetaData,
JobScheduler jobScheduler,
MenuReaderService menuReaderService,
UserPermissionEvaluator userPermissionEvaluator); @GetMapping String init(Model model); @GetMapping("/viewJob") String viewJob(
Model model,
@RequestParam(name = "jobHref") String jobHref,
@RequestParam(name = "refreshTimeoutMillis", defaultValue = "10000")
Integer refreshTimeoutMillis); @Transactional(readOnly = true) @GetMapping(value = "/latest", produces = MediaType.APPLICATION_JSON_VALUE) @ResponseBody List<Entity> findLastJobs(); @PostMapping("/cancel/{jobExecutionType}/{jobExecutionId}") @ResponseStatus(NO_CONTENT) void cancel(
@PathVariable("jobExecutionType") String jobExecutionType,
@PathVariable("jobExecutionId") String jobExecutionId); @PostMapping("/run/{scheduledJobId}") @ResponseStatus(NO_CONTENT) void runNow(@PathVariable("scheduledJobId") String scheduledJobId); String createJobExecutionViewHref(String jobHref, int refreshTimeoutMillis); static final String ID; static final String URI; }### Answer:
@Test void testCreateJobExecutionViewHref() { when(menuReaderService.findMenuItemPath(JobsController.ID)).thenReturn("/menu/jobs"); assertEquals( "/menu/jobs/viewJob/?jobHref=/api/v2/sys_MappingJobExecution/abcde&refreshTimeoutMillis=2345", jobsController.createJobExecutionViewHref("/api/v2/sys_MappingJobExecution/abcde", 2345)); }
|
### Question:
UploadWizardPage extends AbstractWizardPage { @Override public String getTitle() { return "Upload file"; } UploadWizardPage(
ImportServiceFactory importServiceFactory,
FileRepositoryCollectionFactory fileRepositoryCollectionFactory); @Override String getTitle(); @Override String handleRequest(HttpServletRequest request, BindingResult result, Wizard wizard); }### Answer:
@Test void testGetTitle() { assertEquals("Upload file", uploadWizardPage.getTitle()); }
|
### Question:
UploadWizardPage extends AbstractWizardPage { @Override public String handleRequest(HttpServletRequest request, BindingResult result, Wizard wizard) { ImportWizardUtil.validateImportWizard(wizard); ImportWizard importWizard = (ImportWizard) wizard; String dataImportOption = request.getParameter("data-option"); try { File file = null; Part part = request.getPart("upload"); if (part != null) { file = FileUploadUtils.saveToTempFolder(part); } if (file == null) { result.addError(new ObjectError("wizard", "No file selected")); } else { importWizard.setFile(file); RepositoryCollection repositoryCollection = getFileRepositoryCollectionFactory().createFileRepositoryCollection(file); ImportService importService = getImportServiceFactory().getImportService(file, repositoryCollection); importWizard.setSupportedMetadataActions(importService.getSupportedMetadataActions()); importWizard.setSupportedDataActions(importService.getSupportedDataActions()); importWizard.setMustChangeEntityName(importService.getMustChangeEntityName()); } } catch (Exception e) { ImportWizardUtil.handleException(e, importWizard, result, LOG, dataImportOption); } return null; } UploadWizardPage(
ImportServiceFactory importServiceFactory,
FileRepositoryCollectionFactory fileRepositoryCollectionFactory); @Override String getTitle(); @Override String handleRequest(HttpServletRequest request, BindingResult result, Wizard wizard); }### Answer:
@Test void testHandleRequestNoFileSelected() { HttpServletRequest httpServletRequest = mock(HttpServletRequest.class); BindingResult bindingResult = mock(BindingResult.class); ImportWizard wizard = mock(ImportWizard.class); assertNull(uploadWizardPage.handleRequest(httpServletRequest, bindingResult, wizard)); verify(bindingResult).addError(new ObjectError("wizard", "No file selected")); }
|
### Question:
OptionsWizardPage extends AbstractWizardPage { @Override public String getTitle() { return "Options"; } OptionsWizardPage(
FileRepositoryCollectionFactory fileRepositoryCollectionFactory,
ImportServiceFactory importServiceFactory,
DataService dataService,
UserPermissionEvaluator userPermissionEvaluator); @Override String getTitle(); @SuppressWarnings("javasecurity:S2083") @Override String handleRequest(HttpServletRequest request, BindingResult result, Wizard wizard); }### Answer:
@Test void testGetTitle() { assertEquals("Options", optionsWizardPage.getTitle()); }
|
### Question:
ImportWizardUtil { static void handleException( Exception e, ImportWizard importWizard, BindingResult result, Logger logger, String dataImportOption) { File file = importWizard.getFile(); if (logger.isWarnEnabled()) { logger.warn( format( "Import of file [%s] failed for action [%s]", Optional.ofNullable(file).map(File::getName).orElse("UNKNOWN"), dataImportOption), e); } result.addError( new ObjectError("wizard", "<b>Your import failed:</b><br />" + e.getLocalizedMessage())); } private ImportWizardUtil(); }### Answer:
@Test void testHandleException() { Exception exception = when(mock(Exception.class).getLocalizedMessage()).thenReturn("message").getMock(); ImportWizard importWizard = mock(ImportWizard.class); BindingResult bindingResult = mock(BindingResult.class); Logger logger = mock(Logger.class); String dataImportOption = "dataImportOption"; ImportWizardUtil.handleException( exception, importWizard, bindingResult, logger, dataImportOption); verify(bindingResult) .addError(new ObjectError("wizard", "<b>Your import failed:</b><br />message")); }
|
### Question:
ValidationResultWizardPage extends AbstractWizardPage { @Override public String getTitle() { return "Validation"; } ValidationResultWizardPage(
ImportServiceFactory importServiceFactory,
FileRepositoryCollectionFactory fileRepositoryCollectionFactory,
ImportRunService importRunService); @Override String getTitle(); @Override String handleRequest(HttpServletRequest request, BindingResult result, Wizard wizard); }### Answer:
@Test void testGetTitle() { assertEquals("Validation", validationResultWizardPage.getTitle()); }
|
### Question:
MolgenisUiUtils { public static String getCurrentUri() { HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.currentRequestAttributes()).getRequest(); StringBuilder uri = new StringBuilder(); uri.append(request.getAttribute("javax.servlet.forward.request_uri")); if (StringUtils.isNotBlank(request.getQueryString())) { uri.append("?").append(request.getQueryString()); } return uri.toString(); } private MolgenisUiUtils(); static String getCurrentUri(); }### Answer:
@Test void getCurrentUri() { String uri = "/menu/test"; String queryString = "a=b&c=d"; MockHttpServletRequest request = new MockHttpServletRequest(); request.setAttribute("javax.servlet.forward.request_uri", uri); request.setQueryString(queryString); RequestContextHolder.setRequestAttributes(new ServletRequestAttributes(request)); String currentUri = MolgenisUiUtils.getCurrentUri(); assertNotNull(currentUri); assertEquals(uri + "?" + queryString, currentUri); request.setQueryString(null); RequestContextHolder.setRequestAttributes(new ServletRequestAttributes(request)); currentUri = MolgenisUiUtils.getCurrentUri(); assertNotNull(currentUri); assertEquals(uri, currentUri); }
|
### Question:
Menu implements MenuNode { @Override public Optional<List<String>> getPath(String id) { return id.equals(getId()) ? Optional.of(ImmutableList.of(id)) : filter(menu -> containsMenuItem(menu, id)) .filter(menu -> !((Menu) menu).getItems().isEmpty()) .flatMap(menu -> ((Menu) menu).getItems().get(0).getPath(id)) .map(this::prefixId); } abstract List<MenuNode> getItems(); @Override Optional<MenuNode> filter(Predicate<MenuNode> predicate); @Override boolean isMenu(); @Override Optional<List<String>> getPath(String id); @Override boolean contains(Predicate<MenuNode> predicate); Optional<MenuItem> firstItem(); Optional<Menu> findMenu(String menuId); static Menu create(String id, String label, List<MenuNode> items); }### Answer:
@Test void getPath() { assertEquals(of(asList("root/p1_0".split("/"))), menu.getPath("p1_0")); assertEquals(of(asList("root/p1_1".split("/"))), menu.getPath("p1_1")); assertEquals(of(asList("p1_1/p2_0".split("/"))), menu.getPath("p2_0")); assertEquals(of(asList("p1_1/p2_1".split("/"))), menu.getPath("p2_1")); assertEquals(of(asList("p2_0/p3_0".split("/"))), menu.getPath("p3_0")); assertEquals(of(asList("p2_0/p3_1".split("/"))), menu.getPath("p3_1")); assertEquals(empty(), menu.getPath("non_existing")); }
|
### Question:
BrowserDetectionFilter implements Filter { protected boolean isSupported(String userAgentHeaderValue) { UserAgent userAgent = UserAgent.parseUserAgentString(userAgentHeaderValue); return !UNSUPPORTED_BROWSERS.contains(userAgent.getBrowser()); } @Override void doFilter(ServletRequest request, ServletResponse response, FilterChain chain); @Override void destroy(); @Override void init(FilterConfig filterConfig); }### Answer:
@Test void isSupported() { BrowserDetectionFilter browserDetectionFilter = new BrowserDetectionFilter(); assertTrue(browserDetectionFilter.isSupported(IE11_USER_AGENT)); assertTrue(browserDetectionFilter.isSupported(null)); assertTrue(browserDetectionFilter.isSupported("")); assertTrue(browserDetectionFilter.isSupported("bogus")); assertFalse(browserDetectionFilter.isSupported(IE8_USER_AGENT)); assertFalse(browserDetectionFilter.isSupported(IE9_COMPATIBILTY_MODUS_USER_AGENT)); }
|
### Question:
RedirectController extends PluginController { static boolean nodeMatches(MenuNode node, String url) { return node instanceof MenuItem && itemMatches((MenuItem) node, url); } RedirectController(MenuReaderService menuReaderService); @GetMapping View redirect(@RequestParam("url") String url); static final String ID; static final String URI; }### Answer:
@Test void testNodeMatchesUrlEncoded() { assertTrue(nodeMatches(item, "https: }
@Test void testNodeMatchesEscapeEqualsCharacter() { assertTrue(nodeMatches(userManual, "https: }
@Test void testNodeMatchesWrongID() { assertFalse(nodeMatches(MenuItem.create("wrong-id", "Wrong ID"), "https: }
@Test void testNodeMatchesNotAMenuItem() { assertFalse(nodeMatches(menu, "https: }
|
### Question:
RedirectController extends PluginController { @GetMapping public View redirect(@RequestParam("url") String url) throws AccessDeniedException { if (!menuReaderService .getMenu() .filter(menu -> menu.contains(node -> nodeMatches(node, url))) .isPresent()) { throw new AccessDeniedException("URL not present in menu!"); } return new RedirectView(url, false, false, false); } RedirectController(MenuReaderService menuReaderService); @GetMapping View redirect(@RequestParam("url") String url); static final String ID; static final String URI; }### Answer:
@Test void testRedirectToUnknownSite() throws AccessDeniedException { when(menuReaderService.getMenu()).thenReturn(Optional.of(menu)); assertThrows( AccessDeniedException.class, () -> redirectController.redirect("https: }
@Test void testCorrectRedirect() throws AccessDeniedException { when(menuReaderService.getMenu()).thenReturn(Optional.of(menu)); String url = "https: RedirectView response = (RedirectView) redirectController.redirect(url); assertEquals(url, response.getUrl()); }
|
### Question:
StaticContentServiceImpl implements StaticContentService { @Transactional(readOnly = true) @Override public String getContent(String key) { StaticContent staticContent = RunAsSystemAspect.runAsSystem( () -> dataService.findOneById(STATIC_CONTENT, key, StaticContent.class)); return staticContent != null ? staticContent.getContent() : null; } StaticContentServiceImpl(
DataService dataService,
StaticContentFactory staticContentFactory,
UserPermissionEvaluator permissionService); @Override @Transactional boolean submitContent(String key, String content); @Transactional(readOnly = true) @Override boolean isCurrentUserCanEdit(String pluginId); @Transactional(readOnly = true) @Override String getContent(String key); void checkPermissions(String pluginId); }### Answer:
@Test void getContent() { when(dataService.findOneById(STATIC_CONTENT, "home", StaticContent.class)) .thenReturn(staticContent); when(staticContent.getContent()).thenReturn("<p>Welcome to Molgenis!</p>"); assertEquals("<p>Welcome to Molgenis!</p>", staticContentService.getContent("home")); }
|
### Question:
Menu implements MenuNode { @Override public boolean contains(Predicate<MenuNode> predicate) { return predicate.test(this) || getItems().stream().anyMatch(it -> it.contains(predicate)); } abstract List<MenuNode> getItems(); @Override Optional<MenuNode> filter(Predicate<MenuNode> predicate); @Override boolean isMenu(); @Override Optional<List<String>> getPath(String id); @Override boolean contains(Predicate<MenuNode> predicate); Optional<MenuItem> firstItem(); Optional<Menu> findMenu(String menuId); static Menu create(String id, String label, List<MenuNode> items); }### Answer:
@Test void contains() { assertTrue(menu.contains((node) -> node.getLabel().equals("lbl"))); assertTrue(menu.contains((node) -> node.getLabel().equals("sub lbl"))); }
|
### Question:
StaticContentServiceImpl implements StaticContentService { public void checkPermissions(String pluginId) { StaticContent staticContent = dataService.findOneById(STATIC_CONTENT, pluginId, StaticContent.class); if (staticContent == null) { if (!permissionService.hasPermission(new EntityTypeIdentity(STATIC_CONTENT), UPDATE_DATA)) { throw new EntityTypePermissionDeniedException(UPDATE_DATA, STATIC_CONTENT); } } else { if (!permissionService.hasPermission(new EntityTypeIdentity(STATIC_CONTENT), ADD_DATA)) { throw new EntityTypePermissionDeniedException(ADD_DATA, STATIC_CONTENT); } } } StaticContentServiceImpl(
DataService dataService,
StaticContentFactory staticContentFactory,
UserPermissionEvaluator permissionService); @Override @Transactional boolean submitContent(String key, String content); @Transactional(readOnly = true) @Override boolean isCurrentUserCanEdit(String pluginId); @Transactional(readOnly = true) @Override String getContent(String key); void checkPermissions(String pluginId); }### Answer:
@Test void checkPermissionsThrowsException() { Exception exception = assertThrows( EntityTypePermissionDeniedException.class, () -> this.staticContentService.checkPermissions("home")); assertThat(exception.getMessage()) .containsPattern("permission:UPDATE_DATA entityTypeId:sys_StaticContent"); }
@Test void checkPermissionsNoException() { doReturn(true) .when(permissionService) .hasPermission(new EntityTypeIdentity(STATIC_CONTENT), EntityTypePermission.UPDATE_DATA); staticContentService.checkPermissions("home"); }
|
### Question:
MenuReaderServiceImpl implements MenuReaderService { public MenuReaderServiceImpl( AppSettings appSettings, Gson gson, UserPermissionEvaluator userPermissionEvaluator) { this.appSettings = requireNonNull(appSettings); this.gson = requireNonNull(gson); this.userPermissionEvaluator = requireNonNull(userPermissionEvaluator); } MenuReaderServiceImpl(
AppSettings appSettings, Gson gson, UserPermissionEvaluator userPermissionEvaluator); @Override Optional<Menu> getMenu(); @Override @Nullable String findMenuItemPath(String menuItemId); }### Answer:
@Test void MenuReaderServiceImpl() { assertThrows(NullPointerException.class, () -> new MenuReaderServiceImpl(null, null, null)); }
|
### Question:
Wizard implements Serializable { public void addPage(WizardPage page) { pages.add(page); } void addPage(WizardPage page); List<WizardPage> getPages(); WizardPage getCurrentPage(); boolean isLastPage(); boolean isFirstPage(); void next(); void previous(); WizardButton getNextButton(); WizardButton getPreviousButton(); }### Answer:
@Test void addPage() { Wizard wizard = new Wizard(); wizard.addPage(new TestWizardPage()); assertEquals(1, wizard.getPages().size()); }
|
### Question:
Wizard implements Serializable { public WizardPage getCurrentPage() { if (pages.isEmpty()) { throw new IllegalStateException(NO_WIZARD_PAGES_DEFINED_MSG); } return pages.get(currentPageIndex); } void addPage(WizardPage page); List<WizardPage> getPages(); WizardPage getCurrentPage(); boolean isLastPage(); boolean isFirstPage(); void next(); void previous(); WizardButton getNextButton(); WizardButton getPreviousButton(); }### Answer:
@Test void getCurrentPage() { Wizard wizard = new Wizard(); WizardPage page = new TestWizardPage(); wizard.addPage(page); assertEquals(page, wizard.getCurrentPage()); }
|
### Question:
Wizard implements Serializable { public WizardButton getNextButton() { boolean lastPage = isLastPage(); String id = lastPage ? FINISH_BUTTON_ID : NEXT_BUTTON_ID; String title = lastPage ? "Finish" : "Next"; String uri = lastPage ? "/restart" : "/next"; return new WizardButton(id, title, true, uri); } void addPage(WizardPage page); List<WizardPage> getPages(); WizardPage getCurrentPage(); boolean isLastPage(); boolean isFirstPage(); void next(); void previous(); WizardButton getNextButton(); WizardButton getPreviousButton(); }### Answer:
@Test void getNextButton() { Wizard wizard = new Wizard(); wizard.addPage(new TestWizardPage()); wizard.addPage(new TestWizardPage()); WizardButton nextButton = wizard.getNextButton(); assertNotNull(nextButton); assertTrue(nextButton.isEnabled()); assertEquals("Next", nextButton.getTitle()); assertEquals("/next", nextButton.getTargetUri()); wizard.next(); nextButton = wizard.getNextButton(); assertTrue(nextButton.isEnabled()); assertEquals("Finish", nextButton.getTitle()); assertEquals("/restart", nextButton.getTargetUri()); }
|
### Question:
Wizard implements Serializable { public List<WizardPage> getPages() { return Collections.unmodifiableList(pages); } void addPage(WizardPage page); List<WizardPage> getPages(); WizardPage getCurrentPage(); boolean isLastPage(); boolean isFirstPage(); void next(); void previous(); WizardButton getNextButton(); WizardButton getPreviousButton(); }### Answer:
@Test void getPages() { Wizard wizard = new Wizard(); assertNotNull(wizard.getPages()); assertEquals(0, wizard.getPages().size()); wizard.addPage(new TestWizardPage()); assertEquals(1, wizard.getPages().size()); wizard.addPage(new TestWizardPage()); assertEquals(2, wizard.getPages().size()); }
|
### Question:
Wizard implements Serializable { public WizardButton getPreviousButton() { return new WizardButton(PREVIOUS_BUTTON_ID, "Previous", !isFirstPage(), "/previous"); } void addPage(WizardPage page); List<WizardPage> getPages(); WizardPage getCurrentPage(); boolean isLastPage(); boolean isFirstPage(); void next(); void previous(); WizardButton getNextButton(); WizardButton getPreviousButton(); }### Answer:
@Test void getPreviousButton() { Wizard wizard = new Wizard(); wizard.addPage(new TestWizardPage()); WizardButton prevButton = wizard.getPreviousButton(); assertNotNull(prevButton); assertFalse(prevButton.isEnabled()); assertEquals("Previous", prevButton.getTitle()); }
|
### Question:
Wizard implements Serializable { public boolean isFirstPage() { if (pages.isEmpty()) { throw new IllegalStateException(NO_WIZARD_PAGES_DEFINED_MSG); } return currentPageIndex == 0; } void addPage(WizardPage page); List<WizardPage> getPages(); WizardPage getCurrentPage(); boolean isLastPage(); boolean isFirstPage(); void next(); void previous(); WizardButton getNextButton(); WizardButton getPreviousButton(); }### Answer:
@Test void isFirstPage() { Wizard wizard = new Wizard(); wizard.addPage(new TestWizardPage()); wizard.addPage(new TestWizardPage()); assertTrue(wizard.isFirstPage()); wizard.next(); assertFalse(wizard.isFirstPage()); }
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.