method2testcases
stringlengths 118
3.08k
|
|---|
### Question:
LogbookOperationsImpl implements LogbookOperations { @Override public List<LogbookOperation> select(JsonNode select) throws LogbookDatabaseException, LogbookNotFoundException, InvalidParseOperationException, VitamDBException { return select(select, false); } LogbookOperationsImpl(LogbookDbAccess mongoDbAccess); @VisibleForTesting LogbookOperationsImpl(LogbookDbAccess mongoDbAccess, WorkspaceClientFactory workspaceClientFactory,
StorageClientFactory storageClientFactory, IndexationHelper indexationHelper); @Override void create(LogbookOperationParameters parameters); @Override void update(LogbookOperationParameters parameters); @Override List<LogbookOperation> select(JsonNode select); @Override RequestResponse<LogbookOperation> selectOperations(JsonNode select); @Override RequestResponse<LogbookOperation> selectOperations(JsonNode select, boolean sliced); @Override List<LogbookOperation> select(JsonNode select, boolean sliced); @Override LogbookOperation getById(String idProcess); @Override final void createBulkLogbookOperation(final LogbookOperationParameters[] operationArray); @Override final void updateBulkLogbookOperation(final LogbookOperationParameters[] operationArray); @Override MongoCursor<LogbookOperation> selectOperationsByLastPersistenceDateInterval(LocalDateTime startDate,
LocalDateTime endDate); @Override LogbookOperation findFirstTraceabilityOperationOKAfterDate(final LocalDateTime date); @Override LogbookOperation findLastTraceabilityOperationOK(); @Override IndexationResult reindex(IndexParameters indexParameters); @Override void switchIndex(String alias, String newIndexName); }### Answer:
@Test(expected = LogbookNotFoundException.class) public void givenSelectOperationWhenErrorInMongoThenThrowLogbookException() throws Exception { reset(mongoDbAccess); doThrow(LogbookDatabaseException.class).when(mongoDbAccess) .getLogbookOperations(JsonHandler.createObjectNode(), true); logbookOperationsImpl.select(null); }
@Test(expected = LogbookNotFoundException.class) public void givenSelectOperationWhenOperationNotExistsThenThrowLogbookException() throws Exception { reset(mongoDbAccess); doThrow(LogbookNotFoundException.class).when(mongoDbAccess) .getLogbookOperations(JsonHandler.createObjectNode(), true); logbookOperationsImpl.select(null); }
|
### Question:
LogbookOperationsImpl implements LogbookOperations { @Override public LogbookOperation getById(String idProcess) throws LogbookDatabaseException, LogbookNotFoundException { return mongoDbAccess.getLogbookOperation(idProcess); } LogbookOperationsImpl(LogbookDbAccess mongoDbAccess); @VisibleForTesting LogbookOperationsImpl(LogbookDbAccess mongoDbAccess, WorkspaceClientFactory workspaceClientFactory,
StorageClientFactory storageClientFactory, IndexationHelper indexationHelper); @Override void create(LogbookOperationParameters parameters); @Override void update(LogbookOperationParameters parameters); @Override List<LogbookOperation> select(JsonNode select); @Override RequestResponse<LogbookOperation> selectOperations(JsonNode select); @Override RequestResponse<LogbookOperation> selectOperations(JsonNode select, boolean sliced); @Override List<LogbookOperation> select(JsonNode select, boolean sliced); @Override LogbookOperation getById(String idProcess); @Override final void createBulkLogbookOperation(final LogbookOperationParameters[] operationArray); @Override final void updateBulkLogbookOperation(final LogbookOperationParameters[] operationArray); @Override MongoCursor<LogbookOperation> selectOperationsByLastPersistenceDateInterval(LocalDateTime startDate,
LocalDateTime endDate); @Override LogbookOperation findFirstTraceabilityOperationOKAfterDate(final LocalDateTime date); @Override LogbookOperation findLastTraceabilityOperationOK(); @Override IndexationResult reindex(IndexParameters indexParameters); @Override void switchIndex(String alias, String newIndexName); }### Answer:
@Test public void getByIdTest() throws Exception { reset(mongoDbAccess); GUID guid = GUIDFactory.newEventGUID(0); ObjectNode data = JsonHandler.createObjectNode().put("_id", guid.getId()); doReturn(new LogbookOperation(data)).when(mongoDbAccess).getLogbookOperation(guid.getId()); LogbookOperation lo = logbookOperationsImpl.getById(guid.getId()); assertNotNull(lo); }
|
### Question:
LogbookOperationsImpl implements LogbookOperations { @Override public final void createBulkLogbookOperation(final LogbookOperationParameters[] operationArray) throws LogbookDatabaseException, LogbookAlreadyExistsException { mongoDbAccess.createBulkLogbookOperation(operationArray); backupBulkOperation(operationArray); } LogbookOperationsImpl(LogbookDbAccess mongoDbAccess); @VisibleForTesting LogbookOperationsImpl(LogbookDbAccess mongoDbAccess, WorkspaceClientFactory workspaceClientFactory,
StorageClientFactory storageClientFactory, IndexationHelper indexationHelper); @Override void create(LogbookOperationParameters parameters); @Override void update(LogbookOperationParameters parameters); @Override List<LogbookOperation> select(JsonNode select); @Override RequestResponse<LogbookOperation> selectOperations(JsonNode select); @Override RequestResponse<LogbookOperation> selectOperations(JsonNode select, boolean sliced); @Override List<LogbookOperation> select(JsonNode select, boolean sliced); @Override LogbookOperation getById(String idProcess); @Override final void createBulkLogbookOperation(final LogbookOperationParameters[] operationArray); @Override final void updateBulkLogbookOperation(final LogbookOperationParameters[] operationArray); @Override MongoCursor<LogbookOperation> selectOperationsByLastPersistenceDateInterval(LocalDateTime startDate,
LocalDateTime endDate); @Override LogbookOperation findFirstTraceabilityOperationOKAfterDate(final LocalDateTime date); @Override LogbookOperation findLastTraceabilityOperationOK(); @Override IndexationResult reindex(IndexParameters indexParameters); @Override void switchIndex(String alias, String newIndexName); }### Answer:
@RunWithCustomExecutor @Test public void createBulkLogbookOperationTest() throws Exception { VitamThreadUtils.getVitamSession().setTenantId(0); reset(mongoDbAccess); when(mongoDbAccess.getLogbookOperation(any())).thenReturn(new LogbookOperation(logbookParameters)); LogbookOperationParameters[] param = new LogbookOperationParameters[2]; param[0] = LogbookParameterHelper.newLogbookOperationParameters(); param[1] = LogbookParameterHelper.newLogbookOperationParameters(); logbookOperationsImpl.createBulkLogbookOperation(param); }
|
### Question:
LogbookOperationsImpl implements LogbookOperations { @Override public final void updateBulkLogbookOperation(final LogbookOperationParameters[] operationArray) throws LogbookDatabaseException, LogbookNotFoundException { mongoDbAccess.updateBulkLogbookOperation(operationArray); backupBulkOperation(operationArray); } LogbookOperationsImpl(LogbookDbAccess mongoDbAccess); @VisibleForTesting LogbookOperationsImpl(LogbookDbAccess mongoDbAccess, WorkspaceClientFactory workspaceClientFactory,
StorageClientFactory storageClientFactory, IndexationHelper indexationHelper); @Override void create(LogbookOperationParameters parameters); @Override void update(LogbookOperationParameters parameters); @Override List<LogbookOperation> select(JsonNode select); @Override RequestResponse<LogbookOperation> selectOperations(JsonNode select); @Override RequestResponse<LogbookOperation> selectOperations(JsonNode select, boolean sliced); @Override List<LogbookOperation> select(JsonNode select, boolean sliced); @Override LogbookOperation getById(String idProcess); @Override final void createBulkLogbookOperation(final LogbookOperationParameters[] operationArray); @Override final void updateBulkLogbookOperation(final LogbookOperationParameters[] operationArray); @Override MongoCursor<LogbookOperation> selectOperationsByLastPersistenceDateInterval(LocalDateTime startDate,
LocalDateTime endDate); @Override LogbookOperation findFirstTraceabilityOperationOKAfterDate(final LocalDateTime date); @Override LogbookOperation findLastTraceabilityOperationOK(); @Override IndexationResult reindex(IndexParameters indexParameters); @Override void switchIndex(String alias, String newIndexName); }### Answer:
@RunWithCustomExecutor @Test public void updateBulkLogbookOperationTest() throws Exception { VitamThreadUtils.getVitamSession().setTenantId(0); reset(mongoDbAccess); when(mongoDbAccess.getLogbookOperation(any())).thenReturn(new LogbookOperation(logbookParameters)); LogbookOperationParameters[] param = new LogbookOperationParameters[2]; param[0] = LogbookParameterHelper.newLogbookOperationParameters(); param[1] = LogbookParameterHelper.newLogbookOperationParameters(); logbookOperationsImpl.updateBulkLogbookOperation(param); }
|
### Question:
LogbookOperationsImpl implements LogbookOperations { @Override public RequestResponse<LogbookOperation> selectOperations(JsonNode select) throws LogbookDatabaseException, LogbookNotFoundException, VitamDBException { return selectOperations(select, false); } LogbookOperationsImpl(LogbookDbAccess mongoDbAccess); @VisibleForTesting LogbookOperationsImpl(LogbookDbAccess mongoDbAccess, WorkspaceClientFactory workspaceClientFactory,
StorageClientFactory storageClientFactory, IndexationHelper indexationHelper); @Override void create(LogbookOperationParameters parameters); @Override void update(LogbookOperationParameters parameters); @Override List<LogbookOperation> select(JsonNode select); @Override RequestResponse<LogbookOperation> selectOperations(JsonNode select); @Override RequestResponse<LogbookOperation> selectOperations(JsonNode select, boolean sliced); @Override List<LogbookOperation> select(JsonNode select, boolean sliced); @Override LogbookOperation getById(String idProcess); @Override final void createBulkLogbookOperation(final LogbookOperationParameters[] operationArray); @Override final void updateBulkLogbookOperation(final LogbookOperationParameters[] operationArray); @Override MongoCursor<LogbookOperation> selectOperationsByLastPersistenceDateInterval(LocalDateTime startDate,
LocalDateTime endDate); @Override LogbookOperation findFirstTraceabilityOperationOKAfterDate(final LocalDateTime date); @Override LogbookOperation findLastTraceabilityOperationOK(); @Override IndexationResult reindex(IndexParameters indexParameters); @Override void switchIndex(String alias, String newIndexName); }### Answer:
@Test public void selectOperationsTest() throws Exception { reset(mongoDbAccess); doReturn(createFakeMongoCursor()).when(mongoDbAccess).getLogbookOperations(any(), anyBoolean()); Select select = new Select(); RequestResponse<LogbookOperation> response = logbookOperationsImpl.selectOperations(select.getFinalSelect()); assertNotNull(response); assertEquals(1, response.toJsonNode().get("$hits").get("total").asLong()); }
|
### Question:
LogbookOperationsImpl implements LogbookOperations { @Override public void switchIndex(String alias, String newIndexName) throws DatabaseException { try { indexationHelper.switchIndex(alias, newIndexName, LogbookCollections.OPERATION.getEsClient()); } catch (DatabaseException exc) { LOGGER.error("Cannot switch alias {} to index {}", alias, newIndexName, exc); throw exc; } } LogbookOperationsImpl(LogbookDbAccess mongoDbAccess); @VisibleForTesting LogbookOperationsImpl(LogbookDbAccess mongoDbAccess, WorkspaceClientFactory workspaceClientFactory,
StorageClientFactory storageClientFactory, IndexationHelper indexationHelper); @Override void create(LogbookOperationParameters parameters); @Override void update(LogbookOperationParameters parameters); @Override List<LogbookOperation> select(JsonNode select); @Override RequestResponse<LogbookOperation> selectOperations(JsonNode select); @Override RequestResponse<LogbookOperation> selectOperations(JsonNode select, boolean sliced); @Override List<LogbookOperation> select(JsonNode select, boolean sliced); @Override LogbookOperation getById(String idProcess); @Override final void createBulkLogbookOperation(final LogbookOperationParameters[] operationArray); @Override final void updateBulkLogbookOperation(final LogbookOperationParameters[] operationArray); @Override MongoCursor<LogbookOperation> selectOperationsByLastPersistenceDateInterval(LocalDateTime startDate,
LocalDateTime endDate); @Override LogbookOperation findFirstTraceabilityOperationOKAfterDate(final LocalDateTime date); @Override LogbookOperation findLastTraceabilityOperationOK(); @Override IndexationResult reindex(IndexParameters indexParameters); @Override void switchIndex(String alias, String newIndexName); }### Answer:
@Test(expected = DatabaseException.class) public void switchIndexKOTest() throws Exception { doThrow(new DatabaseException("erreur")).when(indexationHelper).switchIndex(anyString(), anyString(), any()); logbookOperationsImpl.switchIndex("alias", "index_name"); }
@Test public void switchIndexOKTest() throws Exception { doNothing().when(indexationHelper).switchIndex(anyString(), anyString(), any()); logbookOperationsImpl.switchIndex("alias", "index_name"); }
|
### Question:
AlertLogbookOperationsDecorator extends LogbookOperationsDecorator { @Override public void create(LogbookOperationParameters parameters) throws LogbookAlreadyExistsException, LogbookDatabaseException { logbookOperations.create(parameters); createAlertIfNecessary(parameters); } AlertLogbookOperationsDecorator(LogbookOperations logbookOperations, List<LogbookEvent> alertEvents); @VisibleForTesting AlertLogbookOperationsDecorator(LogbookOperations logbookOperations, List<LogbookEvent> alertEvents, AlertService alertService); @Override void create(LogbookOperationParameters parameters); @Override void update(LogbookOperationParameters parameters); @Override RequestResponse<LogbookOperation> selectOperations(JsonNode select); @Override RequestResponse<LogbookOperation> selectOperations(JsonNode select, boolean sliced); @Override void createBulkLogbookOperation(LogbookOperationParameters[] operationArray); @Override void updateBulkLogbookOperation(LogbookOperationParameters[] operationArray); }### Answer:
@RunWithCustomExecutor @Test public void testCreate() throws Exception { VitamThreadUtils.getVitamSession().setTenantId(0); alertLogbookOperationsDecorator.create(logbookParameters); verify(alertService).createAlert(Mockito.eq(VitamLogLevel.INFO), Mockito.anyString()); }
|
### Question:
AlertLogbookOperationsDecorator extends LogbookOperationsDecorator { @Override public void update(LogbookOperationParameters parameters) throws LogbookNotFoundException, LogbookDatabaseException { logbookOperations.update(parameters); createAlertIfNecessary(parameters); } AlertLogbookOperationsDecorator(LogbookOperations logbookOperations, List<LogbookEvent> alertEvents); @VisibleForTesting AlertLogbookOperationsDecorator(LogbookOperations logbookOperations, List<LogbookEvent> alertEvents, AlertService alertService); @Override void create(LogbookOperationParameters parameters); @Override void update(LogbookOperationParameters parameters); @Override RequestResponse<LogbookOperation> selectOperations(JsonNode select); @Override RequestResponse<LogbookOperation> selectOperations(JsonNode select, boolean sliced); @Override void createBulkLogbookOperation(LogbookOperationParameters[] operationArray); @Override void updateBulkLogbookOperation(LogbookOperationParameters[] operationArray); }### Answer:
@RunWithCustomExecutor @Test public void testUpdate() throws Exception { VitamThreadUtils.getVitamSession().setTenantId(0); alertLogbookOperationsDecorator.update(logbookParameters); verify(alertService).createAlert(Mockito.eq(VitamLogLevel.INFO), Mockito.anyString()); }
|
### Question:
AlertLogbookOperationsDecorator extends LogbookOperationsDecorator { @Override public void createBulkLogbookOperation(LogbookOperationParameters[] operationArray) throws LogbookDatabaseException, LogbookAlreadyExistsException { logbookOperations.createBulkLogbookOperation(operationArray); createAlertIfNecessary(operationArray); } AlertLogbookOperationsDecorator(LogbookOperations logbookOperations, List<LogbookEvent> alertEvents); @VisibleForTesting AlertLogbookOperationsDecorator(LogbookOperations logbookOperations, List<LogbookEvent> alertEvents, AlertService alertService); @Override void create(LogbookOperationParameters parameters); @Override void update(LogbookOperationParameters parameters); @Override RequestResponse<LogbookOperation> selectOperations(JsonNode select); @Override RequestResponse<LogbookOperation> selectOperations(JsonNode select, boolean sliced); @Override void createBulkLogbookOperation(LogbookOperationParameters[] operationArray); @Override void updateBulkLogbookOperation(LogbookOperationParameters[] operationArray); }### Answer:
@RunWithCustomExecutor @Test public void testCreateBulkLogbookOperation() throws Exception { VitamThreadUtils.getVitamSession().setTenantId(0); LogbookOperationParameters[] operationArray = {logbookParameters}; alertLogbookOperationsDecorator.createBulkLogbookOperation(operationArray); verify(alertService).createAlert(Mockito.eq(VitamLogLevel.INFO), Mockito.anyString()); }
|
### Question:
AlertLogbookOperationsDecorator extends LogbookOperationsDecorator { @Override public void updateBulkLogbookOperation(LogbookOperationParameters[] operationArray) throws LogbookDatabaseException, LogbookNotFoundException { logbookOperations.updateBulkLogbookOperation(operationArray); createAlertIfNecessary(operationArray); } AlertLogbookOperationsDecorator(LogbookOperations logbookOperations, List<LogbookEvent> alertEvents); @VisibleForTesting AlertLogbookOperationsDecorator(LogbookOperations logbookOperations, List<LogbookEvent> alertEvents, AlertService alertService); @Override void create(LogbookOperationParameters parameters); @Override void update(LogbookOperationParameters parameters); @Override RequestResponse<LogbookOperation> selectOperations(JsonNode select); @Override RequestResponse<LogbookOperation> selectOperations(JsonNode select, boolean sliced); @Override void createBulkLogbookOperation(LogbookOperationParameters[] operationArray); @Override void updateBulkLogbookOperation(LogbookOperationParameters[] operationArray); }### Answer:
@RunWithCustomExecutor @Test public void testUpdateBulkLogbookOperation() throws Exception { VitamThreadUtils.getVitamSession().setTenantId(0); LogbookOperationParameters[] operationArray = {logbookParameters}; alertLogbookOperationsDecorator.updateBulkLogbookOperation(operationArray); verify(alertService).createAlert(Mockito.eq(VitamLogLevel.INFO), Mockito.anyString()); }
|
### Question:
LogbookOperationsDecorator implements LogbookOperations { @Override public void create(LogbookOperationParameters parameters) throws LogbookAlreadyExistsException, LogbookDatabaseException { logbookOperations.create(parameters); } LogbookOperationsDecorator(LogbookOperations logbookOperations); @Override void create(LogbookOperationParameters parameters); @Override void update(LogbookOperationParameters parameters); @Override List<LogbookOperation> select(JsonNode select); @Override List<LogbookOperation> select(JsonNode select, boolean sliced); @Override LogbookOperation getById(String IdProcess); @Override void createBulkLogbookOperation(LogbookOperationParameters[] operationArray); @Override void updateBulkLogbookOperation(LogbookOperationParameters[] operationArray); @Override MongoCursor<LogbookOperation> selectOperationsByLastPersistenceDateInterval(LocalDateTime startDate,
LocalDateTime endDate); @Override LogbookOperation findFirstTraceabilityOperationOKAfterDate(LocalDateTime date); @Override LogbookOperation findLastTraceabilityOperationOK(); @Override IndexationResult reindex(IndexParameters indexParameters); @Override void switchIndex(String alias, String newIndexName); }### Answer:
@RunWithCustomExecutor @Test public final void testCreate() throws Exception { VitamThreadUtils.getVitamSession().setTenantId(0); final TestClass tc = new TestClass(logbookOperationsImpl); tc.create(logbookParameters); verify(logbookOperationsImpl).create(logbookParameters); verify(mongoDbAccess).createLogbookOperation(logbookParameters); }
|
### Question:
LogbookOperationsDecorator implements LogbookOperations { @Override public void update(LogbookOperationParameters parameters) throws LogbookNotFoundException, LogbookDatabaseException { logbookOperations.update(parameters); } LogbookOperationsDecorator(LogbookOperations logbookOperations); @Override void create(LogbookOperationParameters parameters); @Override void update(LogbookOperationParameters parameters); @Override List<LogbookOperation> select(JsonNode select); @Override List<LogbookOperation> select(JsonNode select, boolean sliced); @Override LogbookOperation getById(String IdProcess); @Override void createBulkLogbookOperation(LogbookOperationParameters[] operationArray); @Override void updateBulkLogbookOperation(LogbookOperationParameters[] operationArray); @Override MongoCursor<LogbookOperation> selectOperationsByLastPersistenceDateInterval(LocalDateTime startDate,
LocalDateTime endDate); @Override LogbookOperation findFirstTraceabilityOperationOKAfterDate(LocalDateTime date); @Override LogbookOperation findLastTraceabilityOperationOK(); @Override IndexationResult reindex(IndexParameters indexParameters); @Override void switchIndex(String alias, String newIndexName); }### Answer:
@RunWithCustomExecutor @Test public final void testUpdate() throws Exception { VitamThreadUtils.getVitamSession().setTenantId(0); final TestClass tc = new TestClass(logbookOperationsImpl); tc.update(logbookParameters); verify(logbookOperationsImpl).update(logbookParameters); verify(mongoDbAccess).updateLogbookOperation(logbookParameters); }
|
### Question:
LogbookOperationsDecorator implements LogbookOperations { @Override public void updateBulkLogbookOperation(LogbookOperationParameters[] operationArray) throws LogbookDatabaseException, LogbookNotFoundException { logbookOperations.updateBulkLogbookOperation(operationArray); } LogbookOperationsDecorator(LogbookOperations logbookOperations); @Override void create(LogbookOperationParameters parameters); @Override void update(LogbookOperationParameters parameters); @Override List<LogbookOperation> select(JsonNode select); @Override List<LogbookOperation> select(JsonNode select, boolean sliced); @Override LogbookOperation getById(String IdProcess); @Override void createBulkLogbookOperation(LogbookOperationParameters[] operationArray); @Override void updateBulkLogbookOperation(LogbookOperationParameters[] operationArray); @Override MongoCursor<LogbookOperation> selectOperationsByLastPersistenceDateInterval(LocalDateTime startDate,
LocalDateTime endDate); @Override LogbookOperation findFirstTraceabilityOperationOKAfterDate(LocalDateTime date); @Override LogbookOperation findLastTraceabilityOperationOK(); @Override IndexationResult reindex(IndexParameters indexParameters); @Override void switchIndex(String alias, String newIndexName); }### Answer:
@RunWithCustomExecutor @Test public final void testUpdateBulkLogbookOperation() throws Exception { VitamThreadUtils.getVitamSession().setTenantId(0); final TestClass tc = new TestClass(logbookOperationsImpl); tc.updateBulkLogbookOperation(operationArray); verify(mongoDbAccess).updateBulkLogbookOperation(operationArray); }
|
### Question:
LogbookOperationsDecorator implements LogbookOperations { @Override public void createBulkLogbookOperation(LogbookOperationParameters[] operationArray) throws LogbookDatabaseException, LogbookAlreadyExistsException { logbookOperations.createBulkLogbookOperation(operationArray); } LogbookOperationsDecorator(LogbookOperations logbookOperations); @Override void create(LogbookOperationParameters parameters); @Override void update(LogbookOperationParameters parameters); @Override List<LogbookOperation> select(JsonNode select); @Override List<LogbookOperation> select(JsonNode select, boolean sliced); @Override LogbookOperation getById(String IdProcess); @Override void createBulkLogbookOperation(LogbookOperationParameters[] operationArray); @Override void updateBulkLogbookOperation(LogbookOperationParameters[] operationArray); @Override MongoCursor<LogbookOperation> selectOperationsByLastPersistenceDateInterval(LocalDateTime startDate,
LocalDateTime endDate); @Override LogbookOperation findFirstTraceabilityOperationOKAfterDate(LocalDateTime date); @Override LogbookOperation findLastTraceabilityOperationOK(); @Override IndexationResult reindex(IndexParameters indexParameters); @Override void switchIndex(String alias, String newIndexName); }### Answer:
@RunWithCustomExecutor @Test public final void testCreateBulkLogbookOperation() throws Exception { VitamThreadUtils.getVitamSession().setTenantId(0); final TestClass tc = new TestClass(logbookOperationsImpl); tc.createBulkLogbookOperation(operationArray); verify(mongoDbAccess).createBulkLogbookOperation(operationArray); }
|
### Question:
LogbookVarNameAdapter extends VarNameAdapter { @Override public String getVariableName(String name) { if(name.equals(ParserTokens.PROJECTIONARGS.LAST_PERSISTED_DATE.exactToken())) return LogbookDocument.LAST_PERSISTED_DATE; if(name.equals(ParserTokens.PROJECTIONARGS.ID.exactToken())) return LogbookDocument.ID; return null; } LogbookVarNameAdapter(); @Override boolean metadataAdapter(); @Override String getVariableName(String name); }### Answer:
@Test public void givenLogbookVarNameAdapterWhenGetVariableNameThenReturnCorrect() { assertEquals(null, logbookNameAdapter.getVariableName("notValid")); assertEquals("_id", logbookNameAdapter.getVariableName("#id")); assertEquals("_lastPersistedDate", logbookNameAdapter.getVariableName("#lastPersistedDate")); }
|
### Question:
IngestExternalClientMock extends AbstractMockClient implements IngestExternalClient { @Override public RequestResponse<Void> ingestLocal(VitamContext vitamContext, LocalFile localFile, String contextId, String action) throws IngestExternalException { RequestResponseOK r = new RequestResponseOK<>(); r.setHttpCode(Status.ACCEPTED.getStatusCode()); r.addHeader(FAKE_X_REQUEST_ID, X_REQUEST_ID); return r; } @Override RequestResponse<Void> ingest(VitamContext vitamContext, InputStream stream,
String contextId,
String action); @Override RequestResponse<Void> ingest(VitamContext vitamContext, InputStream stream,
IngestRequestParameters ingestRequestParameters); @Override Response downloadObjectAsync(VitamContext vitamContext, String objectId,
IngestCollection type); @Override RequestResponse<Void> ingestLocal(VitamContext vitamContext, LocalFile localFile, String contextId,
String action); @Override RequestResponse<Void> ingestLocal(VitamContext vitamContext, LocalFile localFile,
IngestRequestParameters ingestRequestParameters); static final String ID; }### Answer:
@Test public void givenNonEmptyLocalFileThenUploadWithSuccess() throws IngestExternalException, XMLStreamException { IngestExternalClientFactory.changeMode((SecureClientConfiguration)null); final IngestExternalClient client = IngestExternalClientFactory.getInstance().getClient(); assertNotNull(client); RequestResponse<Void> requestResponse = client.ingestLocal(new VitamContext(TENANT_ID), new LocalFile("path"), CONTEXT_ID, EXECUTION_MODE); assertEquals(requestResponse.getHttpCode(), 202); }
|
### Question:
IngestExternalClientMock extends AbstractMockClient implements IngestExternalClient { @Override public Response downloadObjectAsync(VitamContext vitamContext, String objectId, IngestCollection type) throws VitamClientException { return ClientMockResultHelper.getObjectStream(); } @Override RequestResponse<Void> ingest(VitamContext vitamContext, InputStream stream,
String contextId,
String action); @Override RequestResponse<Void> ingest(VitamContext vitamContext, InputStream stream,
IngestRequestParameters ingestRequestParameters); @Override Response downloadObjectAsync(VitamContext vitamContext, String objectId,
IngestCollection type); @Override RequestResponse<Void> ingestLocal(VitamContext vitamContext, LocalFile localFile, String contextId,
String action); @Override RequestResponse<Void> ingestLocal(VitamContext vitamContext, LocalFile localFile,
IngestRequestParameters ingestRequestParameters); static final String ID; }### Answer:
@Test public void givenNonEmptyStreamWhenDownloadSuccess() throws VitamClientException { IngestExternalClientFactory.changeMode((SecureClientConfiguration)null); final IngestExternalClient client = IngestExternalClientFactory.getInstance().getClient(); assertNotNull(client); final InputStream firstStream = StreamUtils.toInputStream("test"); final InputStream responseStream = client.downloadObjectAsync(new VitamContext(TENANT_ID), "1", IngestCollection.MANIFESTS).readEntity(InputStream.class); assertNotNull(responseStream); try { assertTrue(IOUtils.contentEquals(responseStream, firstStream)); } catch (final IOException e) { e.printStackTrace(); fail(); } }
|
### Question:
IngestExternalClientRest extends DefaultClient implements IngestExternalClient { @Override public RequestResponse<Void> ingest(VitamContext vitamContext, InputStream stream, String contextId, String action) throws IngestExternalException { return ingest(vitamContext, stream, new IngestRequestParameters(contextId, action)); } IngestExternalClientRest(IngestExternalClientFactory factory); @Override RequestResponse<Void> ingest(VitamContext vitamContext, InputStream stream,
String contextId,
String action); @Override RequestResponse<Void> ingest(VitamContext vitamContext, InputStream stream,
IngestRequestParameters ingestRequestParameters); Response downloadObjectAsync(VitamContext vitamContext, String objectId,
IngestCollection type); @Override RequestResponse<Void> ingestLocal(VitamContext vitamContext, LocalFile localFile, String contextId,
String action); @Override RequestResponse<Void> ingestLocal(VitamContext vitamContext, LocalFile localFile,
IngestRequestParameters ingestRequestParameters); }### Answer:
@Test public void givenErrorWhenUploadThenReturnBadRequestErrorWithBody() throws Exception { final MultivaluedHashMap<String, Object> headers = new MultivaluedHashMap<>(); headers.add(GlobalDataRest.X_REQUEST_ID, FAKE_X_REQUEST_ID); ObjectNode objectNode = JsonHandler.createObjectNode(); objectNode.put(GlobalDataRest.X_REQUEST_ID, FAKE_X_REQUEST_ID); when(mock.post()) .thenReturn(Response.accepted().header(GlobalDataRest.X_REQUEST_ID, FAKE_X_REQUEST_ID).build()); try (final InputStream streamToUpload = IOUtils.toInputStream(MOCK_INPUTSTREAM_CONTENT, CharsetUtils.UTF_8)) { RequestResponse<Void> resp = client.ingest(new VitamContext(TENANT_ID), streamToUpload, CONTEXT_ID, EXECUTION_MODE); assertEquals(resp.getHttpCode(), Status.ACCEPTED.getStatusCode()); } }
|
### Question:
IngestExternalClientRest extends DefaultClient implements IngestExternalClient { @Override public RequestResponse<Void> ingestLocal(VitamContext vitamContext, LocalFile localFile, String contextId, String action) throws IngestExternalException { return ingestLocal(vitamContext, localFile, new IngestRequestParameters(contextId, action)); } IngestExternalClientRest(IngestExternalClientFactory factory); @Override RequestResponse<Void> ingest(VitamContext vitamContext, InputStream stream,
String contextId,
String action); @Override RequestResponse<Void> ingest(VitamContext vitamContext, InputStream stream,
IngestRequestParameters ingestRequestParameters); Response downloadObjectAsync(VitamContext vitamContext, String objectId,
IngestCollection type); @Override RequestResponse<Void> ingestLocal(VitamContext vitamContext, LocalFile localFile, String contextId,
String action); @Override RequestResponse<Void> ingestLocal(VitamContext vitamContext, LocalFile localFile,
IngestRequestParameters ingestRequestParameters); }### Answer:
@Test public void givenUploadLocalFileThenReturnOK() throws Exception { final MultivaluedHashMap<String, Object> headers = new MultivaluedHashMap<>(); headers.add(GlobalDataRest.X_REQUEST_ID, FAKE_X_REQUEST_ID); ObjectNode objectNode = JsonHandler.createObjectNode(); objectNode.put(GlobalDataRest.X_REQUEST_ID, FAKE_X_REQUEST_ID); when(mock.post()) .thenReturn(Response.accepted().header(GlobalDataRest.X_REQUEST_ID, FAKE_X_REQUEST_ID).build()); RequestResponse<Void> resp = client.ingestLocal(new VitamContext(TENANT_ID), new LocalFile("path"), CONTEXT_ID, EXECUTION_MODE); assertEquals(resp.getHttpCode(), Status.ACCEPTED.getStatusCode()); }
|
### Question:
JavaExecuteScript { public static ExecutionOutput executeCommand(String cmd, String arg, long timeoutScanDelay) throws JavaExecuteScriptException { String scriptPath; try { scriptPath = PropertiesUtils.findFile(cmd).getPath(); } catch (final FileNotFoundException e) { LOGGER.error(cmd + " does not exit"); throw new JavaExecuteScriptException(e); } return exec(scriptPath, arg, timeoutScanDelay); } static ExecutionOutput executeCommand(String cmd, String arg, long timeoutScanDelay); }### Answer:
@Test public void givenExecuteScanClamAVWhenVirusFoundButNotCorrectedThenReturn2() throws Exception { assertEquals(1, JavaExecuteScript.executeCommand(SCRIPT_SCAN_CLAMAV, PropertiesUtils.getResourceFile(FIXED_VIRUS_FILE).getPath(), timeoutScanDelay).getExitCode()); assertEquals(2, JavaExecuteScript.executeCommand(SCRIPT_SCAN_CLAMAV, PropertiesUtils.getResourceFile(UNFIXED_VIRUS_FILE).getPath(), timeoutScanDelay).getExitCode()); assertEquals(0, JavaExecuteScript.executeCommand(SCRIPT_SCAN_CLAMAV, PropertiesUtils.getResourceFile(NO_VIRUS_FILE).getPath(), timeoutScanDelay).getExitCode()); }
|
### Question:
IngestInternalClientRest extends DefaultClient implements IngestInternalClient { @Override public Optional<WorkFlow> getWorkflowDetails(String workflowIdentifier) throws VitamClientException { Response response = null; try { response = make(get() .withPath(WORKFLOWS_URI + "/" + workflowIdentifier) .withJsonAccept() ); check(response); return Optional.of(response.readEntity(WorkFlow.class)); } catch (InvalidParseOperationException | NotAcceptableClientException | IngestInternalClientServerException | WorkspaceClientServerException e) { throw new VitamClientException("Internal Error Server : " + response.readEntity(String.class)); } catch (IngestInternalClientNotFoundException e) { return Optional.empty(); } finally { if (response != null) { response.close(); } } } IngestInternalClientRest(IngestInternalClientFactory factory); @Override void uploadInitialLogbook(Iterable<LogbookOperationParameters> logbookParametersList); @Override void upload(InputStream inputStream, MediaType archiveMimeType, WorkFlow workflow, String actionAfterInit); @Override void initWorkflow(WorkFlow workFlow); @Override void uploadFinalLogbook(Iterable<LogbookOperationParameters> logbookParametersList); @Override Response downloadObjectAsync(String objectId, IngestCollection type); @Override void storeATR(GUID guid, InputStream input); @Override RequestResponse<ItemStatus> updateOperationActionProcess(String actionId, String operationId); @Override ItemStatus getOperationProcessStatus(String id); @Override RequestResponse<ItemStatus> getOperationProcessExecutionDetails(String id); @Override RequestResponse<ItemStatus> cancelOperationProcessExecution(String id); @Override RequestResponse<ProcessDetail> listOperationsDetails(ProcessQuery query); @Override RequestResponse<WorkFlow> getWorkflowDefinitions(); @Override Optional<WorkFlow> getWorkflowDetails(String workflowIdentifier); }### Answer:
@Test public void givenNotFoundWhenGetWorkFlowDetailThenReturnOptionalEmpty() throws Exception { when(mock.get()).thenReturn(Response.status(Status.NOT_FOUND).build()); Optional<WorkFlow> requestReponse = client.getWorkflowDetails("FAKE_WORKFLOW"); assertEquals(Boolean.FALSE, requestReponse.isPresent()); }
|
### Question:
GriffinService { public RequestResponse<GriffinModel> findGriffin(JsonNode queryDsl) throws ReferentialException, BadRequestException, InvalidParseOperationException { DbRequestResult documents = mongoDbAccess.findDocuments(queryDsl, GRIFFIN); return documents.getRequestResponseOK(queryDsl, Griffin.class, GriffinModel.class); } @VisibleForTesting GriffinService(MongoDbAccessReferential mongoDbAccess, FunctionalBackupService functionalBackupService, LogbookOperationsClientFactory logbookOperationsClientFactory, VitamCollection preservationScenarioCollection); GriffinService(MongoDbAccessAdminImpl mongoAccess, FunctionalBackupService functionalBackupService); RequestResponse<GriffinModel> importGriffin(@NotNull List<GriffinModel> griffinsFromRequest); RequestResponse<GriffinModel> findGriffin(JsonNode queryDsl); }### Answer:
@Test @RunWithCustomExecutor public void shouldGetGriffinById() throws Exception { DbRequestResult dbRequestResult = new DbRequestResult(); when(mongoDbAccess.findDocuments(any(), eq(GRIFFIN))).thenReturn(dbRequestResult); RequestResponse<GriffinModel> griffin = griffinService.findGriffin(getFromString("{}")); assertThat(griffin).isNotNull(); }
|
### Question:
PreservationScenarioService { public RequestResponse<PreservationScenarioModel> findPreservationScenario(JsonNode queryDsl) throws ReferentialException, BadRequestException, InvalidParseOperationException { DbRequestResult documents = mongoDbAccess.findDocuments(queryDsl, PRESERVATION_SCENARIO); return documents.getRequestResponseOK(queryDsl, PreservationScenario.class, PreservationScenarioModel.class); } PreservationScenarioService(MongoDbAccessReferential mongoDbAccess,
FunctionalBackupService functionalBackupService,
LogbookOperationsClientFactory logbookOperationsClientFactory); PreservationScenarioService(MongoDbAccessAdminImpl mongoAccess,
FunctionalBackupService functionalBackupService); RequestResponse<PreservationScenarioModel> importScenarios(
@NotNull List<PreservationScenarioModel> listToImport); RequestResponse<PreservationScenarioModel> findPreservationScenario(JsonNode queryDsl); }### Answer:
@Test @RunWithCustomExecutor public void shouldGetScenarioById() throws Exception { when(mongoDbAccess.findDocuments(any(), eq(PRESERVATION_SCENARIO))).thenReturn(dbRequestResult); when(dbRequestResult.getRequestResponseOK(any(), any(), any())) .thenReturn(new RequestResponseOK<>()); RequestResponse<PreservationScenarioModel> preservationScenario = preservationScenarioService.findPreservationScenario(getFromString("{}")); assertThat(preservationScenario).isNotNull(); }
|
### Question:
AgenciesManager { public void logStarted(String eventType) throws VitamException { final LogbookOperationParameters logbookParameters = LogbookParameterHelper .newLogbookOperationParameters(eip, eventType, eip, LogbookTypeProcess.MASTERDATA, StatusCode.STARTED, VitamLogbookMessages.getCodeOp(eventType, StatusCode.STARTED), eip); logbookClient.create(logbookParameters); } AgenciesManager(LogbookOperationsClient logbookClient, GUID eip); @VisibleForTesting AgenciesManager(LogbookOperationsClient logBookclient, GUID eip, boolean warning); void logStarted(String eventType); void logFinish(String fileName); void logEventSuccess(String eventType); void logEventWarning(String eventType); void logError(String errorsDetails, String subEvenType); void setEvDetData(ObjectNode evDetData); static final VitamLogger LOGGER; }### Answer:
@Test @RunWithCustomExecutor public void should_logbookStarted() throws Exception { VitamThreadUtils.getVitamSession().setTenantId(TENANT_ID); ArgumentCaptor<LogbookOperationParameters> captor = ArgumentCaptor.forClass(LogbookOperationParameters.class); AgenciesManager manager = new AgenciesManager(logbookOperationsClient, newOperationLogbookGUID(TENANT_ID), false); manager.logStarted(AGENCIES_IMPORT_EVENT); verify(logbookOperationsClient).create(captor.capture()); LogbookOperationParameters log = captor.getValue(); assertThat(log.getParameterValue(eventType)).isEqualTo(AGENCIES_IMPORT_EVENT); assertThat(log.getParameterValue(eventTypeProcess)).isEqualTo("MASTERDATA"); assertThat(log.getParameterValue(outcome)).isEqualTo("STARTED"); }
|
### Question:
ReplacePatternUtils { public String replaceUnderscoreBySharp(String textToReplace) { LOGGER.debug("textToReplace" + textToReplace); String replacedString = replaceStringWithPattern(textToReplace, underscorePattern, SHARP_REPLACEMENT); LOGGER.debug("replacedString" + replacedString); return replacedString.replaceAll("_nbc", "#nbc"); } ReplacePatternUtils(List<String> whiteList); String replaceUnderscoreBySharp(String textToReplace); String replaceSharpByUnderscore(String textToReplace); }### Answer:
@Test public void should_replace_underscore_character() throws Exception { JsonNode fromInputStream = JsonHandler.getFromInputStream(PropertiesUtils.getResourceAsStream(UNDERSCORE_JSON)); List<String> whiteList = new ArrayList<>(Arrays.asList("tenant","sp","v", "storage")); ReplacePatternUtils replacePatternUtils = new ReplacePatternUtils(whiteList); String bodyWithoutUnderscore = replacePatternUtils.replaceUnderscoreBySharp(JsonHandler.unprettyPrint(fromInputStream)); assertThat(bodyWithoutUnderscore).contains("#tenant").contains("#v").contains("#storage.#nbc"); assertThat(bodyWithoutUnderscore).contains("_tenantx").contains("test._tenant"); }
|
### Question:
ReplacePatternUtils { public String replaceSharpByUnderscore(String textToReplace) { LOGGER.debug("textToReplace" + textToReplace); String replacedString = replaceStringWithPattern(textToReplace, sharpPattern, UNDERSCORE_REPLACEMENT); LOGGER.debug("replacedString" + replacedString); return replacedString.replaceAll("#nbc", "_nbc"); } ReplacePatternUtils(List<String> whiteList); String replaceUnderscoreBySharp(String textToReplace); String replaceSharpByUnderscore(String textToReplace); }### Answer:
@Test public void should_replace_sharp_character() throws Exception { JsonNode fromInputStream = JsonHandler.getFromInputStream(PropertiesUtils.getResourceAsStream(SHARP_JSON)); List<String> whiteList = new ArrayList<>(Arrays.asList("tenant","sp","v", "storage")); ReplacePatternUtils replacePatternUtils = new ReplacePatternUtils(whiteList); String bodyWithoutSharp = replacePatternUtils.replaceSharpByUnderscore(JsonHandler.unprettyPrint(fromInputStream)); assertThat(bodyWithoutSharp).contains("_tenant").contains("_v").contains("_storage._nbc"); assertThat(bodyWithoutSharp).contains("#tenantx").contains("test.#tenant"); }
|
### Question:
JsonTransformer { public static JsonNode transformResultObjects(JsonNode searchResult) { ParametersChecker.checkParameter("Result cannot be empty", searchResult); final ObjectNode resultNode = JsonHandler.createObjectNode(); long nbObjects = 0; final JsonNode result = searchResult.get("$results").get(0); final ArrayNode arrayNode = JsonHandler.createArrayNode(); if (result != null) { final JsonNode qualifiers = result.get("#qualifiers"); final List<JsonNode> versions = qualifiers.findValues("versions"); final Map<String, Integer> usages = new HashMap<>(); for (final JsonNode version : versions) { for (final JsonNode object : version) { arrayNode.add(getDataObject(usages, object)); nbObjects++; } } } resultNode.put("nbObjects", nbObjects); resultNode.set("versions", arrayNode); return resultNode; } private JsonTransformer(); static JsonNode transformResultObjects(JsonNode searchResult); static ObjectNode buildAllParentsRef(String unitId, JsonNode allParents); static ByteArrayOutputStream buildLogbookStatCsvFile(JsonNode logbookOperation); }### Answer:
@Test public void testTransformerObjectGroupSuccess() throws Exception { final JsonNode sampleObjectGroup = JsonHandler.getFromFile(PropertiesUtils.findFile("sample_objectGroup_document.json")); assertNotNull(JsonTransformer.transformResultObjects(sampleObjectGroup)); }
@Test public void testTransformerObjectGroupPhysicalSuccess() throws Exception { final JsonNode sampleObjectGroup = JsonHandler.getFromFile(PropertiesUtils.findFile("sample_objectGroup_physical.json")); assertNotNull(JsonTransformer.transformResultObjects(sampleObjectGroup)); }
@Test(expected = IllegalArgumentException.class) public void testTransformerNullThrowsException() throws Exception { JsonTransformer.transformResultObjects(null); }
|
### Question:
PreservationResource { @POST @Path("/importGriffins") @Consumes(MediaType.APPLICATION_JSON) @Produces(MediaType.APPLICATION_JSON) public Response importGriffin(List<GriffinModel> griffinModelList, @Context UriInfo uri) { try { RequestResponse<GriffinModel> requestResponse = griffinService.importGriffin(griffinModelList); return status(Status.CREATED).entity(requestResponse).build(); } catch (Exception e) { LOGGER.error(e); return buildErrorResponse(VitamCode.PRESERVATION_VALIDATION_ERROR, e.getMessage()); } } PreservationResource(PreservationScenarioService preservationScenarioService, GriffinService griffinService); @POST @Path("/importGriffins") @Consumes(MediaType.APPLICATION_JSON) @Produces(MediaType.APPLICATION_JSON) Response importGriffin(List<GriffinModel> griffinModelList, @Context UriInfo uri); @POST @Path("/importPreservationScenarios") @Consumes(MediaType.APPLICATION_JSON) @Produces(MediaType.APPLICATION_JSON) Response importPreservationScenario(List<PreservationScenarioModel> preservationScenarioModel,
@Context UriInfo uri); @GET @Path("/griffin") @Consumes(MediaType.APPLICATION_JSON) @Produces(MediaType.APPLICATION_JSON) Response findGriffin(JsonNode queryDsl); @GET @Path("/preservationScenario") @Consumes(MediaType.APPLICATION_JSON) @Produces(MediaType.APPLICATION_JSON) Response findPreservation(JsonNode queryDsl); }### Answer:
@Test public void shouldImportGriffin() { Response griffinResponse = preservationResource.importGriffin(new ArrayList<>(), mock(UriInfo.class)); assertThat(griffinResponse.getStatus()).isEqualTo(201); }
|
### Question:
PreservationResource { @GET @Path("/griffin") @Consumes(MediaType.APPLICATION_JSON) @Produces(MediaType.APPLICATION_JSON) public Response findGriffin(JsonNode queryDsl) { try { RequestResponse<GriffinModel> requestResponse = griffinService.findGriffin(queryDsl); return Response.status(Status.OK).entity(requestResponse).build(); } catch (InvalidParseOperationException | BadRequestException e) { LOGGER.error("Unexpected server error {}", e); return buildErrorResponse(VitamCode.PRESERVATION_VALIDATION_ERROR, e.getMessage()); } catch (ReferentialException e) { LOGGER.error(e); return buildErrorResponse(VitamCode.GLOBAL_INTERNAL_SERVER_ERROR, e.getMessage()); } } PreservationResource(PreservationScenarioService preservationScenarioService, GriffinService griffinService); @POST @Path("/importGriffins") @Consumes(MediaType.APPLICATION_JSON) @Produces(MediaType.APPLICATION_JSON) Response importGriffin(List<GriffinModel> griffinModelList, @Context UriInfo uri); @POST @Path("/importPreservationScenarios") @Consumes(MediaType.APPLICATION_JSON) @Produces(MediaType.APPLICATION_JSON) Response importPreservationScenario(List<PreservationScenarioModel> preservationScenarioModel,
@Context UriInfo uri); @GET @Path("/griffin") @Consumes(MediaType.APPLICATION_JSON) @Produces(MediaType.APPLICATION_JSON) Response findGriffin(JsonNode queryDsl); @GET @Path("/preservationScenario") @Consumes(MediaType.APPLICATION_JSON) @Produces(MediaType.APPLICATION_JSON) Response findPreservation(JsonNode queryDsl); }### Answer:
@Test public void shouldFindGriffin() throws Exception { Response griffinResponse = preservationResource.findGriffin(getFromString("{}")); assertThat(griffinResponse.getStatus()).isEqualTo(200); }
|
### Question:
PreservationResource { @GET @Path("/preservationScenario") @Consumes(MediaType.APPLICATION_JSON) @Produces(MediaType.APPLICATION_JSON) public Response findPreservation(JsonNode queryDsl) { try { RequestResponse<PreservationScenarioModel> requestResponse = preservationScenarioService.findPreservationScenario(queryDsl); return Response.status(Status.OK).entity(requestResponse).build(); } catch (InvalidParseOperationException | BadRequestException e) { LOGGER.error("Unexpected server error {}", e); return buildErrorResponse(VitamCode.PRESERVATION_VALIDATION_ERROR, e.getMessage()); } catch (ReferentialException e) { LOGGER.error(e); return buildErrorResponse(VitamCode.GLOBAL_INTERNAL_SERVER_ERROR, e.getMessage()); } } PreservationResource(PreservationScenarioService preservationScenarioService, GriffinService griffinService); @POST @Path("/importGriffins") @Consumes(MediaType.APPLICATION_JSON) @Produces(MediaType.APPLICATION_JSON) Response importGriffin(List<GriffinModel> griffinModelList, @Context UriInfo uri); @POST @Path("/importPreservationScenarios") @Consumes(MediaType.APPLICATION_JSON) @Produces(MediaType.APPLICATION_JSON) Response importPreservationScenario(List<PreservationScenarioModel> preservationScenarioModel,
@Context UriInfo uri); @GET @Path("/griffin") @Consumes(MediaType.APPLICATION_JSON) @Produces(MediaType.APPLICATION_JSON) Response findGriffin(JsonNode queryDsl); @GET @Path("/preservationScenario") @Consumes(MediaType.APPLICATION_JSON) @Produces(MediaType.APPLICATION_JSON) Response findPreservation(JsonNode queryDsl); }### Answer:
@Test public void shouldFindScenario() throws Exception { Response griffinResponse = preservationResource.findPreservation(getFromString("{}")); assertThat(griffinResponse.getStatus()).isEqualTo(200); }
|
### Question:
HelloWorldPlugin extends ActionHandler { public ItemStatus execute(WorkerParameters workerParameters, HandlerIO handlerIO) { LOGGER.warn("==========================================================="); LOGGER.warn("================= HELLO_WORLD_PLUGIN ........ =========== "); LOGGER.warn("==========================================================="); ObjectNode infoNode = JsonHandler.createObjectNode(); infoNode.put("var_name", (String) handlerIO.getInput(0)); ItemStatus itemStatus = new ItemStatus(HELLO_WORLD_PLUGIN); String unpretty = JsonHandler.unprettyPrint(infoNode); itemStatus.setEvDetailData(unpretty); itemStatus.setMasterData(LogbookParameterName.eventDetailData.name(), unpretty); return new ItemStatus(HELLO_WORLD_PLUGIN).setItemsStatus(HELLO_WORLD_PLUGIN, itemStatus.increment(StatusCode.OK)); } ItemStatus execute(WorkerParameters workerParameters, HandlerIO handlerIO); }### Answer:
@Test public void testExecuteThenOK() { HelloWorldPlugin helloWorldPlugin = new HelloWorldPlugin(); WorkerParameters parameters = WorkerParametersFactory.newWorkerParameters(); HandlerIO handlerIO = mock(HandlerIO.class); doReturn("HelloWorldPluginTest").when(handlerIO).getInput(0); ItemStatus itemStatus = helloWorldPlugin.execute(parameters, handlerIO); assertTrue(itemStatus != null); assertTrue(itemStatus.getEvDetailData().contains("var_name")); assertTrue(itemStatus.getEvDetailData().contains("HelloWorldPluginTest")); }
|
### Question:
PersonalCertificateService { public void deletePersonalCertificateIfPresent(byte[] certificate) throws PersonalCertificateException { ParsedCertificate parsedCertificate = ParsedCertificate.parseCertificate(certificate); personalRepository.deletePersonalCertificate(parsedCertificate.getCertificateHash()); } PersonalCertificateService(LogbookOperationsClientFactory logbookOperationsClientFactory,
PersonalRepository personalRepository); void createPersonalCertificateIfNotPresent(byte[] certificate); void deletePersonalCertificateIfPresent(byte[] certificate); void checkPersonalCertificateExistence(byte[] certificate, String permission); }### Answer:
@Test public void should_delete_certificate() throws Exception { InputStream stream = getClass().getResourceAsStream(CERTIFICATE_FILE); byte[] certificate = toByteArray(stream); personalCertificateService.deletePersonalCertificateIfPresent(certificate); verify(personalRepository).deletePersonalCertificate( CERTIFICATE_HASH); verifyNoMoreInteractions(logbookOperationsClientFactory, personalRepository); }
|
### Question:
IdentityService { public Optional<IdentityModel> findIdentity(byte[] certificate) throws CertificateException, InvalidParseOperationException { X509Certificate x509Certificate = X509PKIUtil.parseX509Certificate(certificate); Optional<IdentityModel> identityModelOptional = identityRepository .findIdentity(x509Certificate.getSubjectDN().getName(), String.valueOf(x509Certificate.getSerialNumber())); if (identityModelOptional.isPresent()) { X509PKIUtil.parseX509Certificate(identityModelOptional.get().getCertificate()); } return identityModelOptional; } IdentityService(IdentityRepository identityRepository); void createIdentity(IdentityInsertModel identityInsertModel); Optional<IdentityModel> linkContextToIdentity(IdentityInsertModel identityInsertModel); Optional<IdentityModel> findIdentity(byte[] certificate); boolean contextIsUsed(String contextId); }### Answer:
@Test public void should_read_certificate() throws Exception { InputStream stream = getClass().getResourceAsStream("/certificate.pem"); byte[] certBinary = toByteArray(stream); IdentityModel identityModel = new IdentityModel(); identityModel.setCertificate(certBinary); doReturn(Optional.of(identityModel)).when(identityRepository).findIdentity(any(), any()); identityService.findIdentity(certBinary); then(identityRepository).should().findIdentity( "[email protected], CN=Thawte Personal Basic CA, OU=Certification Services Division, O=Thawte Consulting, L=Cape Town, ST=Western Cape, C=ZA", String.valueOf(BigInteger.ZERO)); }
|
### Question:
IdentityService { public boolean contextIsUsed(String contextId) { return identityRepository.contextIsUsed(contextId); } IdentityService(IdentityRepository identityRepository); void createIdentity(IdentityInsertModel identityInsertModel); Optional<IdentityModel> linkContextToIdentity(IdentityInsertModel identityInsertModel); Optional<IdentityModel> findIdentity(byte[] certificate); boolean contextIsUsed(String contextId); }### Answer:
@Test public void shouldFindContextIsUsed() { final String CONTEXT_ID = "contextId"; given(identityRepository.contextIsUsed(CONTEXT_ID)).willReturn(true); assertTrue(identityService.contextIsUsed(CONTEXT_ID)); }
|
### Question:
PermissionService { public IsPersonalCertificateRequiredModel isPersonalCertificateRequiredForPermission( String permission) { if (personalCertificatePermissionConfig.getPermissionsRequiringPersonalCertificate() != null && personalCertificatePermissionConfig.getPermissionsRequiringPersonalCertificate().contains(permission)) { LOGGER.debug("Required personal certificate for permission {}", permission); return new IsPersonalCertificateRequiredModel( IsPersonalCertificateRequiredModel.Response.REQUIRED_PERSONAL_CERTIFICATE); } if (personalCertificatePermissionConfig.getPermissionsWithoutPersonalCertificate() != null && personalCertificatePermissionConfig.getPermissionsWithoutPersonalCertificate().contains(permission)) { LOGGER.debug("Non required personal certificate for permission {}", permission); return new IsPersonalCertificateRequiredModel( IsPersonalCertificateRequiredModel.Response.IGNORED_PERSONAL_CERTIFICATE); } LOGGER.error("Unknown permission {}", permission); return new IsPersonalCertificateRequiredModel( IsPersonalCertificateRequiredModel.Response.ERROR_UNKNOWN_PERMISSION); } PermissionService(
PersonalCertificatePermissionConfig personalCertificatePermissionConfig); IsPersonalCertificateRequiredModel isPersonalCertificateRequiredForPermission(
String permission); }### Answer:
@Test public void isPersonalCertificateRequiredForPermission() throws Exception { PersonalCertificatePermissionConfig config = new PersonalCertificatePermissionConfig(); config.setPermissionsRequiringPersonalCertificate(Sets.newHashSet(PERM_1, PERM_2)); config.setPermissionsWithoutPersonalCertificate(Sets.newHashSet(PERM_3)); PermissionService instance = new PermissionService(config); assertThat(instance.isPersonalCertificateRequiredForPermission(PERM_1).getResponse()).isEqualTo( IsPersonalCertificateRequiredModel.Response.REQUIRED_PERSONAL_CERTIFICATE); assertThat(instance.isPersonalCertificateRequiredForPermission(PERM_3).getResponse()).isEqualTo( IsPersonalCertificateRequiredModel.Response.IGNORED_PERSONAL_CERTIFICATE); assertThat(instance.isPersonalCertificateRequiredForPermission(PERM_4).getResponse()).isEqualTo( IsPersonalCertificateRequiredModel.Response.ERROR_UNKNOWN_PERMISSION); }
|
### Question:
AdminIdentityResource { @POST @Consumes(MediaType.APPLICATION_JSON) public Response createIdentity(IdentityInsertModel identityInsertModel, @Context UriInfo uri) throws InvalidParseOperationException, CertificateException { ParametersChecker.checkParameter("Certificate cannot be null", (Object) identityInsertModel.getCertificate()); identityService.createIdentity(identityInsertModel); return Response.created(uri.getRequestUri().normalize()).build(); } AdminIdentityResource(IdentityService identityService); @POST @Consumes(MediaType.APPLICATION_JSON) Response createIdentity(IdentityInsertModel identityInsertModel, @Context UriInfo uri); @PUT @Produces(MediaType.APPLICATION_JSON) @Consumes(MediaType.APPLICATION_JSON) IdentityModel linkContextToIdentity(IdentityInsertModel identityInsertModel, @Context UriInfo uri); }### Answer:
@Test public void should_create_identity() throws Exception { byte[] bytes = new byte[] {1, 2}; IdentityInsertModel identityModel = new IdentityInsertModel(); identityModel.setContextId("contextId"); identityModel.setCertificate(bytes); Response response = identityResource.createIdentity(identityModel, uriInfo); assertThat(response.getStatusInfo()).isEqualTo(Response.Status.CREATED); }
|
### Question:
AdminIdentityResource { @PUT @Produces(MediaType.APPLICATION_JSON) @Consumes(MediaType.APPLICATION_JSON) public IdentityModel linkContextToIdentity(IdentityInsertModel identityInsertModel, @Context UriInfo uri) throws InvalidParseOperationException, CertificateException { ParametersChecker.checkParameter("ContextId cannot be null", identityInsertModel.getContextId()); ParametersChecker.checkParameter("Certificate cannot be null", (Object) identityInsertModel.getCertificate()); return identityService.linkContextToIdentity(identityInsertModel).orElseThrow(NotFoundException::new); } AdminIdentityResource(IdentityService identityService); @POST @Consumes(MediaType.APPLICATION_JSON) Response createIdentity(IdentityInsertModel identityInsertModel, @Context UriInfo uri); @PUT @Produces(MediaType.APPLICATION_JSON) @Consumes(MediaType.APPLICATION_JSON) IdentityModel linkContextToIdentity(IdentityInsertModel identityInsertModel, @Context UriInfo uri); }### Answer:
@Test public void should_return_not_found_when_certificate_is_missing() throws Exception { byte[] bytes = new byte[] {1, 2}; IdentityInsertModel identityModel = new IdentityInsertModel(); identityModel.setContextId("contextId"); identityModel.setCertificate(bytes); given(identityService.linkContextToIdentity(identityModel)).willReturn(Optional.empty()); assertThatThrownBy(() -> identityResource.linkContextToIdentity(identityModel, uriInfo)) .isInstanceOf(NotFoundException.class); }
@Test public void should_link_context_to_identity() throws Exception { byte[] bytes = new byte[] {1, 2}; IdentityInsertModel identityInsertModel = new IdentityInsertModel(); identityInsertModel.setContextId("contextId"); identityInsertModel.setCertificate(bytes); IdentityModel identityModel = new IdentityModel(); given(identityService.linkContextToIdentity(identityInsertModel)).willReturn(Optional.of(identityModel)); IdentityModel result = identityResource.linkContextToIdentity(identityInsertModel, uriInfo); then(identityService).should().linkContextToIdentity(identityInsertModel); assertThat(result).isEqualTo(identityModel); }
|
### Question:
IdentityResource { @GET @Consumes(MediaType.APPLICATION_OCTET_STREAM) @Produces(MediaType.APPLICATION_JSON) public IdentityModel findIdentityByCertificate(byte[] certificate) throws InvalidParseOperationException, CertificateException { return identityService.findIdentity(certificate).orElseThrow(NotFoundException::new); } IdentityResource(IdentityService identityService); @GET @Consumes(MediaType.APPLICATION_OCTET_STREAM) @Produces(MediaType.APPLICATION_JSON) IdentityModel findIdentityByCertificate(byte[] certificate); @GET @Path("context/{contextId}") @Produces(MediaType.APPLICATION_JSON) Response contextIsUsed(@PathParam("contextId") String contextId); }### Answer:
@Test public void should_read_certificate() throws Exception { byte[] bytes = new byte[] {1, 2}; IdentityModel identityModel = new IdentityModel(); identityModel.setContextId("contextId"); given(identityService.findIdentity(bytes)).willReturn(of(identityModel)); IdentityModel result = identityResource.findIdentityByCertificate(bytes); assertThat(result).isEqualTo(identityModel); }
@Test public void should_return_not_found_exception_when_certificate_is_missing() throws Exception { byte[] bytes = new byte[] {1, 2}; IdentityModel identityModel = new IdentityModel(); identityModel.setContextId("contextId"); given(identityService.findIdentity(bytes)).willReturn(Optional.empty()); assertThatThrownBy(() -> identityResource.findIdentityByCertificate(bytes)) .isInstanceOf(NotFoundException.class); }
|
### Question:
IdentityResource { @GET @Path("context/{contextId}") @Produces(MediaType.APPLICATION_JSON) public Response contextIsUsed(@PathParam("contextId") String contextId) { return Response.ok().entity(identityService.contextIsUsed(contextId)).build(); } IdentityResource(IdentityService identityService); @GET @Consumes(MediaType.APPLICATION_OCTET_STREAM) @Produces(MediaType.APPLICATION_JSON) IdentityModel findIdentityByCertificate(byte[] certificate); @GET @Path("context/{contextId}") @Produces(MediaType.APPLICATION_JSON) Response contextIsUsed(@PathParam("contextId") String contextId); }### Answer:
@Test public void shouldFindContextIsUsed() { final String CONTEXT_ID = "contextId"; IdentityModel identityModel = new IdentityModel(); identityModel.setContextId(CONTEXT_ID); given(identityService.contextIsUsed(CONTEXT_ID)).willReturn(true); Response response = identityResource.contextIsUsed(CONTEXT_ID); assertThat(response.getStatus()).isEqualTo(Response.Status.OK.getStatusCode()); }
|
### Question:
PersonalCertificateResource { @Path("/personal-certificate-check/{permission}") @GET @Consumes(MediaType.APPLICATION_OCTET_STREAM) public void checkPersonalCertificate(byte[] certificate, @PathParam("permission") String permission) throws LogbookClientServerException, LogbookClientAlreadyExistsException, LogbookClientBadRequestException, InvalidParseOperationException, PersonalCertificateException { ParametersChecker.checkParameter("Permission cannot be null", permission); personalCertificateService.checkPersonalCertificateExistence(certificate, permission); } PersonalCertificateResource(
PermissionService permissionService,
PersonalCertificateService personalCertificateService); @Path("/personal-certificate-check/{permission}") @GET @Consumes(MediaType.APPLICATION_OCTET_STREAM) void checkPersonalCertificate(byte[] certificate,
@PathParam("permission") String permission); @GET @Path("/permission-check/{permission}") @Produces(MediaType.APPLICATION_JSON) IsPersonalCertificateRequiredModel isPersonalCertificateRequiredForPermission(
@PathParam("permission") String permission); }### Answer:
@Test public void should_check_personal_certificate() throws Exception { byte[] bytes = new byte[] {1, 2}; doThrow(PersonalCertificateException.class).when(personalCertificateService) .checkPersonalCertificateExistence(bytes, PERMISSION); assertThatThrownBy(() -> personalCertificateResource.checkPersonalCertificate(bytes, PERMISSION)) .isInstanceOf(PersonalCertificateException.class); }
|
### Question:
PersonalCertificateResource { @GET @Path("/permission-check/{permission}") @Produces(MediaType.APPLICATION_JSON) public IsPersonalCertificateRequiredModel isPersonalCertificateRequiredForPermission( @PathParam("permission") String permission) { ParametersChecker.checkParameter("Permission cannot be null", permission); return permissionService.isPersonalCertificateRequiredForPermission(permission); } PersonalCertificateResource(
PermissionService permissionService,
PersonalCertificateService personalCertificateService); @Path("/personal-certificate-check/{permission}") @GET @Consumes(MediaType.APPLICATION_OCTET_STREAM) void checkPersonalCertificate(byte[] certificate,
@PathParam("permission") String permission); @GET @Path("/permission-check/{permission}") @Produces(MediaType.APPLICATION_JSON) IsPersonalCertificateRequiredModel isPersonalCertificateRequiredForPermission(
@PathParam("permission") String permission); }### Answer:
@Test public void isPersonalCertificateRequiredForPermission() throws Exception { IsPersonalCertificateRequiredModel response = mock(IsPersonalCertificateRequiredModel.class); when(permissionService.isPersonalCertificateRequiredForPermission(PERMISSION)) .thenReturn(response); assertThat(personalCertificateResource.isPersonalCertificateRequiredForPermission(PERMISSION)) .isEqualTo(response); }
|
### Question:
AdminPersonalCertificateResource { @POST @Consumes(MediaType.APPLICATION_OCTET_STREAM) public void createIfNotPresent(byte[] certificate) throws PersonalCertificateException, InvalidParseOperationException { ParametersChecker.checkParameter("Certificate cannot be null", certificate); personalCertificateService.createPersonalCertificateIfNotPresent(certificate); } AdminPersonalCertificateResource(
PersonalCertificateService personalCertificateService); @POST @Consumes(MediaType.APPLICATION_OCTET_STREAM) void createIfNotPresent(byte[] certificate); @DELETE @Consumes(MediaType.APPLICATION_OCTET_STREAM) void delete(byte[] certificate); }### Answer:
@Test public void should_create_certificate() throws Exception { InputStream stream = getClass().getResourceAsStream("/certificate.pem"); byte[] certificate = toByteArray(stream); adminPersonalCertificateResource.createIfNotPresent(certificate); verify(personalCertificateService, only()).createPersonalCertificateIfNotPresent(certificate); }
|
### Question:
IllegalArgumentExceptionMapper implements ExceptionMapper<IllegalArgumentException> { @Override public Response toResponse(IllegalArgumentException exception) { LOGGER.error(exception); return Response.status(Response.Status.BAD_REQUEST).entity(exception.getMessage()).build(); } @Override Response toResponse(IllegalArgumentException exception); }### Answer:
@Test public void should_convert_exception_to_response() throws Exception { String message = "certificate is empty"; IllegalArgumentException illegalArgumentException = new IllegalArgumentException(message); Response response = illegalArgumentExceptionMapper.toResponse(illegalArgumentException); assertThat(response.getStatusInfo()).isEqualTo(BAD_REQUEST); assertThat(response.getEntity()).isEqualTo(message); }
|
### Question:
CertificateExceptionMapper implements ExceptionMapper<CertificateException> { @Override public Response toResponse(CertificateException exception) { LOGGER.error(exception); return Response.status(Response.Status.BAD_REQUEST).entity(exception.getMessage()).build(); } @Override Response toResponse(CertificateException exception); }### Answer:
@Test public void should_convert_exception_to_response() throws Exception { String message = "invalid certificate"; CertificateException certificateException = new CertificateException(message); Response response = certificateExceptionMapper.toResponse(certificateException); assertThat(response.getStatusInfo()).isEqualTo(BAD_REQUEST); assertThat(response.getEntity()).isEqualTo(message); }
|
### Question:
PersonalCertificateExceptionMapper implements ExceptionMapper<PersonalCertificateException> { @Override public Response toResponse(PersonalCertificateException exception) { LOGGER.error(exception); return Response.status(Response.Status.UNAUTHORIZED).build(); } @Override Response toResponse(PersonalCertificateException exception); }### Answer:
@Test public void should_convert_exception_to_response() throws Exception { String message = "invalid certificate"; PersonalCertificateException personalCertificateException = new PersonalCertificateException(message); Response response = certificateExceptionMapper.toResponse(personalCertificateException); assertThat(response.getStatusInfo()).isEqualTo(UNAUTHORIZED); }
|
### Question:
IdentityRepository implements CertificateCRLCheckStateUpdater<IdentityModel> { public Optional<IdentityModel> findIdentity(String subjectDN, String serialNumber) throws InvalidParseOperationException { FindIterable<Document> models = identityCollection.find(filterBySubjectDNAndSerialNumber(subjectDN, serialNumber)); Document first = models.first(); if (first == null) { return Optional.empty(); } return Optional.of(JsonHandler.getFromString(BsonHelper.stringify(first), IdentityModel.class)); } @VisibleForTesting IdentityRepository(MongoDbAccess mongoDbAccess, String collectionName); IdentityRepository(MongoDbAccess mongoDbAccess); void createIdentity(IdentityModel identityModel); Optional<IdentityModel> findIdentity(String subjectDN, String serialNumber); void linkContextToIdentity(String subjectDN, String contextId, String serialNumber); boolean contextIsUsed(String contextId); @Override FindIterable<Document> findCertificate(String issuerDN, CertificateStatus certificateStatus); @Override void updateCertificateState(List<String> certificatesToUpdate, CertificateStatus certificateStatus); @Override Class<IdentityModel> getEntityModelType(); static final String CERTIFICATE_COLLECTION; }### Answer:
@Test public void should_return_empty_when_identity_is_missing() throws InvalidParseOperationException { Optional<IdentityModel> result = identityRepository.findIdentity("invalid_dn", String.valueOf(BigInteger.ZERO)); assertThat(result).isEmpty(); }
|
### Question:
PersonalRepository implements CertificateCRLCheckStateUpdater<PersonalCertificateModel> { public void createPersonalCertificate(PersonalCertificateModel personalCertificateModel) throws InvalidParseOperationException { String json = JsonHandler.writeAsString(personalCertificateModel); personnalCollection.insertOne(Document.parse(json)); } @VisibleForTesting PersonalRepository(MongoDbAccess mongoDbAccess, String collectionName); PersonalRepository(MongoDbAccess mongoDbAccess); void createPersonalCertificate(PersonalCertificateModel personalCertificateModel); Optional<PersonalCertificateModel> findPersonalCertificateByHash(String hash); void deletePersonalCertificate(String hash); @Override FindIterable<Document> findCertificate(String issuerDN, CertificateStatus certificateStatus); @Override void updateCertificateState(List<String> certificatesToUpdate, CertificateStatus certificateStatus); @Override Class<PersonalCertificateModel> getEntityModelType(); static final String PERSONAL_COLLECTION; }### Answer:
@Test public void should_store_certificate() throws InvalidParseOperationException { GUID id = GUIDFactory.newGUID(); PersonalCertificateModel personalCertificateModel = new PersonalCertificateModel(); personalCertificateModel.setIssuerDN("issuerDN"); personalCertificateModel.setSubjectDN("distinguishedName"); personalCertificateModel.setSerialNumber(String.valueOf(BigInteger.TEN)); personalCertificateModel.setId(id.toString()); personalCertificateModel.setCertificateHash( CERTIFICATE_HASH); personalRepository.createPersonalCertificate(personalCertificateModel); Document document = certificateCollection.find(eq("_id", id.toString())).first(); assertThat(document) .isNotNull() .containsEntry("IssuerDN", "issuerDN") .containsEntry("SubjectDN", "distinguishedName") .containsEntry("SerialNumber", String.valueOf(10)) .containsEntry("Hash", CERTIFICATE_HASH); }
|
### Question:
PersonalRepository implements CertificateCRLCheckStateUpdater<PersonalCertificateModel> { public Optional<PersonalCertificateModel> findPersonalCertificateByHash(String hash) throws InvalidParseOperationException { FindIterable<Document> models = personnalCollection.find( and( eq(PersonalCertificateModel.TAG_HASH, hash), eq(PersonalCertificateModel.STATUS_TAG, CertificateStatus.VALID.name()))); Document first = models.first(); if (first == null) { return Optional.empty(); } return Optional.of(JsonHandler.getFromString(BsonHelper.stringify(first), PersonalCertificateModel.class)); } @VisibleForTesting PersonalRepository(MongoDbAccess mongoDbAccess, String collectionName); PersonalRepository(MongoDbAccess mongoDbAccess); void createPersonalCertificate(PersonalCertificateModel personalCertificateModel); Optional<PersonalCertificateModel> findPersonalCertificateByHash(String hash); void deletePersonalCertificate(String hash); @Override FindIterable<Document> findCertificate(String issuerDN, CertificateStatus certificateStatus); @Override void updateCertificateState(List<String> certificatesToUpdate, CertificateStatus certificateStatus); @Override Class<PersonalCertificateModel> getEntityModelType(); static final String PERSONAL_COLLECTION; }### Answer:
@Test public void should_return_empty_when_identity_is_missing() throws InvalidParseOperationException { Optional<PersonalCertificateModel> result = personalRepository.findPersonalCertificateByHash("invalid_dn"); assertThat(result).isEmpty(); }
|
### Question:
PersonalCertificatePermissionConfigLoader { public static PersonalCertificatePermissionConfig loadPersonalCertificatePermissionConfig(String configFile) throws IOException { final PersonalCertificatePermissionConfig config; try (final InputStream personalCertificatePermissionIS = PropertiesUtils.getConfigAsStream( configFile)) { config = PropertiesUtils.readYaml( personalCertificatePermissionIS, PersonalCertificatePermissionConfig.class); } if (config.getPermissionsRequiringPersonalCertificate() == null) config.setPermissionsRequiringPersonalCertificate(Collections.EMPTY_SET); if (config.getPermissionsWithoutPersonalCertificate() == null) config.setPermissionsWithoutPersonalCertificate(Collections.EMPTY_SET); validateConfiguration(config); return config; } static PersonalCertificatePermissionConfig loadPersonalCertificatePermissionConfig(String configFile); }### Answer:
@Test public void testLoadPersonalCertificatePermissionConfig() throws Exception { String configFile = PropertiesUtils.getResourceFile("personal-certificate-permissions-test.conf").getAbsolutePath(); PersonalCertificatePermissionConfig conf = PersonalCertificatePermissionConfigLoader.loadPersonalCertificatePermissionConfig(configFile); assertThat(conf.getPermissionsRequiringPersonalCertificate()) .containsExactlyInAnyOrder("contexts:read", "contexts:id:update"); assertThat(conf.getPermissionsWithoutPersonalCertificate()).containsExactlyInAnyOrder("ingests:create"); }
@Test public void testLoadPersonalCertificatePermissionConfigWithEmptySet() throws Exception { String configFile = PropertiesUtils.getResourceFile("personal-certificate-permissions-testEmptySet.conf").getAbsolutePath(); PersonalCertificatePermissionConfig conf = PersonalCertificatePermissionConfigLoader.loadPersonalCertificatePermissionConfig(configFile); assertThat(conf.getPermissionsRequiringPersonalCertificate()) .isEmpty(); assertThat(conf.getPermissionsWithoutPersonalCertificate()) .containsExactlyInAnyOrder("contexts:read", "contexts:id:update", "ingests:create"); }
|
### Question:
WorkspaceProcessDataManagement implements ProcessDataManagement { @Override public boolean createProcessContainer() throws ProcessingStorageWorkspaceException { if (isProcessContainerExist()) { return false; } try (WorkspaceClient client = workspaceClientFactory.getClient()) { client.createContainer(PROCESS_CONTAINER); return true; } catch (ContentAddressableStorageServerException exc) { LOGGER.error(exc); throw new ProcessingStorageWorkspaceException(exc); } } private WorkspaceProcessDataManagement(); @VisibleForTesting WorkspaceProcessDataManagement(WorkspaceClientFactory workspaceClientFactory); static ProcessDataManagement getInstance(); @Override boolean createProcessContainer(); @Override boolean isProcessContainerExist(); @Override boolean createFolder(String folderName); @Override boolean isFolderExist(String folderName); @Override boolean removeFolder(String folderName); @Override void persistProcessWorkflow(String folderName, ProcessWorkflow processWorkflow); @Override void persistDistributorIndex(String folderName, String fileName, DistributorIndex distributorIndex); @Override Optional<DistributorIndex> getDistributorIndex(String folderName, String fileName); @Override ProcessWorkflow getProcessWorkflow(String folderName, String asyncId); @Override void removeProcessWorkflow(String folderName, String asyncId); @Override Map<String, ProcessWorkflow> getProcessWorkflowFor(Integer tenantId, String folderName); }### Answer:
@Test public void createContainerTestOK() throws Exception { doNothing().when(workspaceClient).createContainer(anyString()); assertTrue(processDataManagement.createProcessContainer()); }
@Test public void createContainerTestAlreadyExists() throws Exception { doReturn(true).when(workspaceClient).isExistingContainer(anyString()); assertFalse(processDataManagement.createProcessContainer()); }
@Test(expected = ProcessingStorageWorkspaceException.class) public void createContainerTestException() throws Exception { doThrow(new ContentAddressableStorageServerException("fail")).when(workspaceClient) .createContainer(anyString()); processDataManagement.createProcessContainer(); }
|
### Question:
WorkspaceProcessDataManagement implements ProcessDataManagement { @Override public boolean isProcessContainerExist() throws ProcessingStorageWorkspaceException { try (WorkspaceClient client = workspaceClientFactory.getClient()) { return client.isExistingContainer(PROCESS_CONTAINER); } catch (ContentAddressableStorageServerException exc) { throw new ProcessingStorageWorkspaceException(exc); } } private WorkspaceProcessDataManagement(); @VisibleForTesting WorkspaceProcessDataManagement(WorkspaceClientFactory workspaceClientFactory); static ProcessDataManagement getInstance(); @Override boolean createProcessContainer(); @Override boolean isProcessContainerExist(); @Override boolean createFolder(String folderName); @Override boolean isFolderExist(String folderName); @Override boolean removeFolder(String folderName); @Override void persistProcessWorkflow(String folderName, ProcessWorkflow processWorkflow); @Override void persistDistributorIndex(String folderName, String fileName, DistributorIndex distributorIndex); @Override Optional<DistributorIndex> getDistributorIndex(String folderName, String fileName); @Override ProcessWorkflow getProcessWorkflow(String folderName, String asyncId); @Override void removeProcessWorkflow(String folderName, String asyncId); @Override Map<String, ProcessWorkflow> getProcessWorkflowFor(Integer tenantId, String folderName); }### Answer:
@Test(expected = ProcessingStorageWorkspaceException.class) public void isProcessContainerExistTestException() throws Exception { doThrow(new ContentAddressableStorageServerException("fail")).when(workspaceClient).isExistingContainer (anyString()); processDataManagement.isProcessContainerExist(); }
|
### Question:
WorkspaceProcessDataManagement implements ProcessDataManagement { @Override public boolean createFolder(String folderName) throws ProcessingStorageWorkspaceException { if (isFolderExist(folderName)) { return false; } try (WorkspaceClient client = workspaceClientFactory.getClient()) { client.createFolder(PROCESS_CONTAINER, folderName); return true; } catch (ContentAddressableStorageServerException exc) { throw new ProcessingStorageWorkspaceException(exc); } catch (ContentAddressableStorageAlreadyExistException e) { LOGGER.warn(e); return false; } } private WorkspaceProcessDataManagement(); @VisibleForTesting WorkspaceProcessDataManagement(WorkspaceClientFactory workspaceClientFactory); static ProcessDataManagement getInstance(); @Override boolean createProcessContainer(); @Override boolean isProcessContainerExist(); @Override boolean createFolder(String folderName); @Override boolean isFolderExist(String folderName); @Override boolean removeFolder(String folderName); @Override void persistProcessWorkflow(String folderName, ProcessWorkflow processWorkflow); @Override void persistDistributorIndex(String folderName, String fileName, DistributorIndex distributorIndex); @Override Optional<DistributorIndex> getDistributorIndex(String folderName, String fileName); @Override ProcessWorkflow getProcessWorkflow(String folderName, String asyncId); @Override void removeProcessWorkflow(String folderName, String asyncId); @Override Map<String, ProcessWorkflow> getProcessWorkflowFor(Integer tenantId, String folderName); }### Answer:
@Test public void createFolderTestOK() throws Exception { doNothing().when(workspaceClient).createFolder(anyString(), anyString()); assertTrue(processDataManagement.createFolder("folder")); }
@Test public void createFolderTestAlreadyExists() throws Exception { doReturn(true).when(workspaceClient).isExistingFolder(anyString(), anyString()); assertFalse(processDataManagement.createFolder("folder")); }
@Test(expected = ProcessingStorageWorkspaceException.class) public void createFolderTestException() throws Exception { doThrow(new ContentAddressableStorageServerException("fail")).when(workspaceClient).createFolder(anyString(), anyString()); processDataManagement.createFolder("folder"); }
|
### Question:
WorkspaceProcessDataManagement implements ProcessDataManagement { @Override public boolean isFolderExist(String folderName) throws ProcessingStorageWorkspaceException { try (WorkspaceClient client = workspaceClientFactory.getClient()) { return client.isExistingFolder(PROCESS_CONTAINER, folderName); } catch (ContentAddressableStorageServerException exc) { throw new ProcessingStorageWorkspaceException(exc); } } private WorkspaceProcessDataManagement(); @VisibleForTesting WorkspaceProcessDataManagement(WorkspaceClientFactory workspaceClientFactory); static ProcessDataManagement getInstance(); @Override boolean createProcessContainer(); @Override boolean isProcessContainerExist(); @Override boolean createFolder(String folderName); @Override boolean isFolderExist(String folderName); @Override boolean removeFolder(String folderName); @Override void persistProcessWorkflow(String folderName, ProcessWorkflow processWorkflow); @Override void persistDistributorIndex(String folderName, String fileName, DistributorIndex distributorIndex); @Override Optional<DistributorIndex> getDistributorIndex(String folderName, String fileName); @Override ProcessWorkflow getProcessWorkflow(String folderName, String asyncId); @Override void removeProcessWorkflow(String folderName, String asyncId); @Override Map<String, ProcessWorkflow> getProcessWorkflowFor(Integer tenantId, String folderName); }### Answer:
@Test(expected = ProcessingStorageWorkspaceException.class) public void isFolderExistsTestException() throws Exception { doThrow(new ContentAddressableStorageServerException("fail")).when(workspaceClient).isExistingFolder (anyString(), anyString()); processDataManagement.isFolderExist("folder"); }
|
### Question:
WorkspaceProcessDataManagement implements ProcessDataManagement { @Override public void removeProcessWorkflow(String folderName, String asyncId) throws ProcessingStorageWorkspaceException { try (WorkspaceClient client = workspaceClientFactory.getClient()) { client.deleteObject(PROCESS_CONTAINER, getPathToObjectFromFolder(folderName, asyncId)); } catch (ContentAddressableStorageServerException | ContentAddressableStorageNotFoundException exc) { throw new ProcessingStorageWorkspaceException(exc); } } private WorkspaceProcessDataManagement(); @VisibleForTesting WorkspaceProcessDataManagement(WorkspaceClientFactory workspaceClientFactory); static ProcessDataManagement getInstance(); @Override boolean createProcessContainer(); @Override boolean isProcessContainerExist(); @Override boolean createFolder(String folderName); @Override boolean isFolderExist(String folderName); @Override boolean removeFolder(String folderName); @Override void persistProcessWorkflow(String folderName, ProcessWorkflow processWorkflow); @Override void persistDistributorIndex(String folderName, String fileName, DistributorIndex distributorIndex); @Override Optional<DistributorIndex> getDistributorIndex(String folderName, String fileName); @Override ProcessWorkflow getProcessWorkflow(String folderName, String asyncId); @Override void removeProcessWorkflow(String folderName, String asyncId); @Override Map<String, ProcessWorkflow> getProcessWorkflowFor(Integer tenantId, String folderName); }### Answer:
@Test public void removeProcessWorkflowTestOK() throws Exception { doNothing().when(workspaceClient).deleteObject(anyString(), anyString()); processDataManagement.removeProcessWorkflow("folder", "asyncId"); }
@Test(expected = ProcessingStorageWorkspaceException.class) public void removeProcessWorkflowTestException() throws Exception { doThrow(new ContentAddressableStorageServerException("fail")).when(workspaceClient).deleteObject(anyString(), anyString()); processDataManagement.removeProcessWorkflow("folder", "asyncId"); }
|
### Question:
WorkerManager implements IWorkerManager { @Override public void registerWorker(String familyId, String workerId, WorkerBean workerInformation) throws ProcessingBadRequestException, IOException { ParametersChecker.checkParameter("All arguments are required", familyId, workerId, workerInformation); if (!workerInformation.getFamily().equals(familyId)) { throw new ProcessingBadRequestException("Cannot register a worker of another family!"); } else { workerInformation.setWorkerId(workerId); } registerWorker(workerInformation); } WorkerManager(); WorkerManager(WorkerClientFactory workerClientFactory); @Override synchronized void marshallToDB(); @Override void registerWorker(String familyId, String workerId, WorkerBean workerInformation); @Override void registerWorker(WorkerBean workerBean); @Override void unregisterWorker(String workerFamily, String worker); @Override boolean checkStatusWorker(String serverHost, int serverPort); @Override WorkerFamilyManager findWorkerBy(String workerFamily); @Override File getWorkerDbFile(); static final int QUEUE_SIZE; }### Answer:
@Test public void register_existing_worker_ok() throws Exception { final String familyId = "DefaultWorker1"; final String workerId = "NewWorkerId1" + GUIDFactory.newGUID().getId(); workerManager.registerWorker(familyId, workerId, WORKER_DESCRIPTION); workerManager.registerWorker(familyId, workerId, WORKER_DESCRIPTION); }
@Test(expected = ProcessingBadRequestException.class) public void register_unmatched_family_then_throw_exception() throws Exception { final String familyId = "NewFamilyId"; final String workerId = "NewWorkerId4" + GUIDFactory.newGUID().getId(); workerManager.registerWorker(familyId, workerId, JsonHandler.getFromString( "{\"name\":\"worker_name\",\"status\":\"ok\", \"family\" : \"fakeValue\", \"configuration\" : {\"serverHost\" : \"localhost\", \"serverPort\" : \"12345\" }}", WorkerBean.class)); }
|
### Question:
WorkerManager implements IWorkerManager { @Override public void unregisterWorker(String workerFamily, String worker) throws WorkerFamilyNotFoundException, IOException { final WorkerFamilyManager workerManager = workersFamily.get(workerFamily); if (workerManager == null) { throw new WorkerFamilyNotFoundException("Worker : " + worker + " not found in the family :" + workerFamily); } workerManager.unregisterWorker(worker); marshallToDB(); } WorkerManager(); WorkerManager(WorkerClientFactory workerClientFactory); @Override synchronized void marshallToDB(); @Override void registerWorker(String familyId, String workerId, WorkerBean workerInformation); @Override void registerWorker(WorkerBean workerBean); @Override void unregisterWorker(String workerFamily, String worker); @Override boolean checkStatusWorker(String serverHost, int serverPort); @Override WorkerFamilyManager findWorkerBy(String workerFamily); @Override File getWorkerDbFile(); static final int QUEUE_SIZE; }### Answer:
@Test(expected = WorkerFamilyNotFoundException.class) public void unregister_non_existing_family_worker_ko() throws Exception { final String familyId = "NewFamilyId" + GUIDFactory.newGUID().getId(); final String workerId = "NewWorkerId1"; workerManager.unregisterWorker(familyId, workerId); }
|
### Question:
ProcessDistributorImpl implements ProcessDistributor { @VisibleForTesting Integer findBulkSize(Distribution distribution) { return firstNonNull(distribution.getBulkSize(), VitamConfiguration.getWorkerBulkSize()); } ProcessDistributorImpl(IWorkerManager workerManager, ServerConfiguration serverConfiguration); @VisibleForTesting ProcessDistributorImpl(IWorkerManager workerManager, ServerConfiguration serverConfiguration,
ProcessDataManagement processDataManagement, WorkspaceClientFactory workspaceClientFactory,
MetaDataClientFactory metaDataClientFactory, WorkerClientFactory workerClientFactory); @Override ItemStatus distribute(WorkerParameters workParams, Step step, String operationId,
PauseRecover pauseRecover); @Override ProcessDataManagement getProcessDataManagement(); }### Answer:
@Test public void should_take_step_bulk_size_in_priority() { ProcessStep step = getStep(DistributionKind.LIST_IN_FILE, "", 5); Integer bulkSize = processDistributor.findBulkSize(step.getDistribution()); assertThat(bulkSize).isEqualTo(5); }
@Test public void should_take_bulk_size_from_configuration_if_null_in_step() { ProcessStep step = getStep(DistributionKind.LIST_IN_FILE, "", null); Integer bulkSize = processDistributor.findBulkSize(step.getDistribution()); assertThat(bulkSize).isEqualTo(1); }
|
### Question:
ProcessMonitoringImpl implements ProcessMonitoring { public static ProcessMonitoringImpl getInstance() { return INSTANCE; } private ProcessMonitoringImpl(); static ProcessMonitoringImpl getInstance(); @Override ProcessWorkflow findOneProcessWorkflow(String operationId, Integer tenantId); }### Answer:
@Test public void processMonitoringGetInstanceOK() { final ProcessMonitoringImpl processMonitoring = ProcessMonitoringImpl.getInstance(); assertNotNull(processMonitoring); final ProcessMonitoringImpl processMonitoring2 = ProcessMonitoringImpl.getInstance(); assertTrue(processMonitoring.equals(processMonitoring2)); }
|
### Question:
ProcessPopulator { private static void populate(final Map<String, WorkFlow> poolWorkflows, InputStream workflowFile, boolean update) { LOGGER.debug("Populating workflow using file " + workflowFile); Optional<WorkFlow> workflow = populate(workflowFile); if (workflow.isPresent()) { String wfId = workflow.get().getId(); LOGGER.debug("Parsed workflow with id " + wfId); if (update) { poolWorkflows.put(wfId, workflow.get()); } else { poolWorkflows.putIfAbsent(wfId, workflow.get()); } } } private ProcessPopulator(); static void loadWorkflow(final Map<String, WorkFlow> poolWorkflows); static void reloadWorkflow(final Map<String, WorkFlow> poolWorkflows, Long fromDate); static Optional<WorkFlow> populate(InputStream workflowFileStream); @VisibleForTesting static Optional<WorkFlow> populate(String workflowFile); }### Answer:
@Test public void testPopulator() { Optional<WorkFlow> res = ProcessPopulator.populate("workflowJSONv1.json"); Assertions.assertThat(res).isNotNull(); }
@Test public void testPopulatorNotFound() throws WorkflowNotFoundException { Optional<WorkFlow> res = ProcessPopulator.populate("not_found"); Assertions.assertThat(res).isEmpty(); }
|
### Question:
StateMachine implements IEventsState, IEventsProcessEngine { @Override synchronized public void pause() throws StateNotAllowedException { this.processWorkflow.getState().eval(ProcessState.PAUSE); this.doPause(RECOVER_FROM_API_PAUSE); } StateMachine(ProcessWorkflow processWorkflow, ProcessEngine processEngine); @VisibleForTesting StateMachine(ProcessWorkflow processWorkflow, ProcessEngine processEngine,
ProcessDataManagement dataManagement,
WorkspaceClientFactory workspaceClientFactory, LogbookOperationsClientFactory logbookOperationsClientFactory); @Override synchronized void resume(WorkerParameters workerParameters); @Override synchronized void next(WorkerParameters workerParameters); @Override synchronized void replay(WorkerParameters workerParameters); @Override synchronized void pause(); @Override void shutdown(); @Override synchronized void cancel(); @Override boolean isDone(); @Override int getTenant(); @Override String getWorkflowId(); @Override String getContextId(); @Override Map<String, String> getWorkflowParameters(); @Override boolean isStepByStep(); @Override LogbookTypeProcess getLogbookTypeProcess(); @Override synchronized void onUpdate(StatusCode statusCode); @Override StatusCode getCurrentProcessWorkflowStatus(); @Override synchronized void onUpdate(String messageIdentifier, String originatingAgency); @Override synchronized void onError(Throwable throwable); @Override synchronized void onProcessEngineCancel(WorkerParameters workerParameters); @Override synchronized void onProcessEngineCompleteStep(ItemStatus itemStatus, WorkerParameters workerParameters); boolean isCompleted(); @Override boolean isRecover(); }### Answer:
@Test(expected = StateNotAllowedException.class) @RunWithCustomExecutor public void test_pause_on_completed_state_ko() throws StateNotAllowedException { StateMachine stateMachine = mock(StateMachine.class); ProcessState state = ProcessState.COMPLETED; doAnswer(o -> { state.eval(ProcessState.PAUSE); return null; }).when(stateMachine).pause(); stateMachine.pause(); }
|
### Question:
StateMachine implements IEventsState, IEventsProcessEngine { @Override synchronized public void cancel() throws StateNotAllowedException { this.processWorkflow.getState().eval(ProcessState.COMPLETED); doCancel(); } StateMachine(ProcessWorkflow processWorkflow, ProcessEngine processEngine); @VisibleForTesting StateMachine(ProcessWorkflow processWorkflow, ProcessEngine processEngine,
ProcessDataManagement dataManagement,
WorkspaceClientFactory workspaceClientFactory, LogbookOperationsClientFactory logbookOperationsClientFactory); @Override synchronized void resume(WorkerParameters workerParameters); @Override synchronized void next(WorkerParameters workerParameters); @Override synchronized void replay(WorkerParameters workerParameters); @Override synchronized void pause(); @Override void shutdown(); @Override synchronized void cancel(); @Override boolean isDone(); @Override int getTenant(); @Override String getWorkflowId(); @Override String getContextId(); @Override Map<String, String> getWorkflowParameters(); @Override boolean isStepByStep(); @Override LogbookTypeProcess getLogbookTypeProcess(); @Override synchronized void onUpdate(StatusCode statusCode); @Override StatusCode getCurrentProcessWorkflowStatus(); @Override synchronized void onUpdate(String messageIdentifier, String originatingAgency); @Override synchronized void onError(Throwable throwable); @Override synchronized void onProcessEngineCancel(WorkerParameters workerParameters); @Override synchronized void onProcessEngineCompleteStep(ItemStatus itemStatus, WorkerParameters workerParameters); boolean isCompleted(); @Override boolean isRecover(); }### Answer:
@Test(expected = StateNotAllowedException.class) @RunWithCustomExecutor public void test_cancel_on_completed_state_ko() throws StateNotAllowedException { StateMachine stateMachine = mock(StateMachine.class); ProcessState state = ProcessState.COMPLETED; doAnswer(o -> { state.eval(ProcessState.COMPLETED); return null; }).when(stateMachine).cancel(); stateMachine.cancel(); }
|
### Question:
ProcessStep extends Step { @Override public boolean equals(Object object) { if (object instanceof ProcessStep) { final ProcessStep processStep = (ProcessStep) object; return getId().equals(processStep.getId()) && getStepName().equals(processStep.getStepName()) && getWorkerGroupId().equals(processStep.getWorkerGroupId()); } else { return false; } } @VisibleForTesting ProcessStep(Step step, AtomicLong elementToProcess, AtomicLong elementProcessed, String id); ProcessStep(Step step, AtomicLong elementToProcess, AtomicLong elementProcessed); @VisibleForTesting ProcessStep(Step step, String id, String containerName, String workflowId, int position,
AtomicLong elementToProcess,
AtomicLong elementProcessed); ProcessStep(Step step, String containerName, String workflowId, int position,
AtomicLong elementToProcess,
AtomicLong elementProcessed); ProcessStep(); @JsonIgnore boolean isBlockingKO(); AtomicLong getElementProcessed(); ProcessStep setElementProcessed(AtomicLong elementProcessed); AtomicLong getElementToProcess(); ProcessStep setElementToProcess(AtomicLong elementToProcess); StatusCode getStepStatusCode(); ProcessStep setStepStatusCode(StatusCode stepStatusCode); @Override boolean equals(Object object); @Override int hashCode(); @Override String toString(); void setLastStep(boolean lastStep); boolean getLastStep(); }### Answer:
@Test public void equalsTest() { final Step step = new Step(); step.setStepName("1"); final ProcessStep processStep = new ProcessStep(step, "25", "containerName", "workflowId", 0, new AtomicLong(1), new AtomicLong(0)); assertEquals(processStep, new ProcessStep(step, "25", "containerName", "workflowId", 0, new AtomicLong(1), new AtomicLong(0))); assertNotEquals(processStep, new Object()); assertNotEquals(processStep, new ProcessStep(step, "24", "containerName", "workflowId", 2, new AtomicLong(1), new AtomicLong(0))); }
|
### Question:
ServerConfiguration extends DefaultVitamApplicationConfiguration { public ServerConfiguration setUrlWorkspace(String urlWorkspace) { ParametersChecker.checkParameter("urlWorkspace is a mandatory parameter", urlWorkspace); this.urlWorkspace = urlWorkspace; return this; } String getUrlMetadata(); ServerConfiguration setUrlMetadata(String urlMetadata); String getUrlWorkspace(); ServerConfiguration setUrlWorkspace(String urlWorkspace); Integer getWorkflowRefreshPeriod(); void setWorkflowRefreshPeriod(Integer workflowRefreshPeriod); Integer getProcessingCleanerPeriod(); void setProcessingCleanerPeriod(Integer processingCleanerPeriod); Integer getMaxDistributionInMemoryBufferSize(); ServerConfiguration setMaxDistributionInMemoryBufferSize(Integer maxDistributionInMemoryBufferSize); Integer getMaxDistributionOnDiskBufferSize(); ServerConfiguration setMaxDistributionOnDiskBufferSize(Integer maxDistributionOnDiskBufferSize); }### Answer:
@Test(expected = IllegalArgumentException.class) public void testSetUrlWorkspaceNull() { new ServerConfiguration().setUrlWorkspace(null); }
|
### Question:
ServerConfiguration extends DefaultVitamApplicationConfiguration { public ServerConfiguration setUrlMetadata(String urlMetadata) { ParametersChecker.checkParameter("urlMetadata is a mandatory parameter", urlMetadata); this.urlMetadata = urlMetadata; return this; } String getUrlMetadata(); ServerConfiguration setUrlMetadata(String urlMetadata); String getUrlWorkspace(); ServerConfiguration setUrlWorkspace(String urlWorkspace); Integer getWorkflowRefreshPeriod(); void setWorkflowRefreshPeriod(Integer workflowRefreshPeriod); Integer getProcessingCleanerPeriod(); void setProcessingCleanerPeriod(Integer processingCleanerPeriod); Integer getMaxDistributionInMemoryBufferSize(); ServerConfiguration setMaxDistributionInMemoryBufferSize(Integer maxDistributionInMemoryBufferSize); Integer getMaxDistributionOnDiskBufferSize(); ServerConfiguration setMaxDistributionOnDiskBufferSize(Integer maxDistributionOnDiskBufferSize); }### Answer:
@Test(expected = IllegalArgumentException.class) public void testSetUrlMetadataNull() { new ServerConfiguration().setUrlMetadata(null); }
|
### Question:
WorkerResource extends ApplicationStatusResource { @Path("tasks/{id_async}") @PUT @Produces(MediaType.APPLICATION_JSON) @Consumes(MediaType.APPLICATION_JSON) public Response modifyStep(@PathParam("id_async") String idAsync) { final Status status = Status.NOT_IMPLEMENTED; return Response.status(status).entity(getErrorEntity(status)).build(); } WorkerResource(PluginLoader pluginLoader); WorkerResource(PluginLoader pluginLoader, Worker worker); @Path("tasks") @GET @Produces(MediaType.APPLICATION_JSON) @Consumes(MediaType.APPLICATION_JSON) Response getStepsList(); @Path("tasks") @POST @Produces(MediaType.APPLICATION_JSON) @Consumes(MediaType.APPLICATION_JSON) Response submitStep(@Context HttpHeaders headers, JsonNode descriptionStepJson); @Path("tasks/{id_async}") @GET @Produces(MediaType.APPLICATION_JSON) Response getStepStatus(@PathParam("id_async") String idAsync); @Path("tasks/{id_async}") @PUT @Produces(MediaType.APPLICATION_JSON) @Consumes(MediaType.APPLICATION_JSON) Response modifyStep(@PathParam("id_async") String idAsync); final WorkerFactory WORKER_FACTORY; }### Answer:
@Test public final void testModifyStep() { given().contentType(ContentType.JSON).body("").when() .put(WORKER_STEP_URI + "/idAsync").then() .statusCode(Status.NOT_IMPLEMENTED.getStatusCode()); }
|
### Question:
SedaUtilsFactory { @Deprecated public static SedaUtils create(HandlerIO handlerIO) { ParametersChecker.checkParameter("HandlerIO must not be null", handlerIO); return sedaUtilsFactory.createSedaUtils(handlerIO); } private SedaUtilsFactory(); static SedaUtilsFactory getInstance(); SedaUtils createSedaUtils(HandlerIO handlerIO); @Deprecated static SedaUtils create(HandlerIO handlerIO); }### Answer:
@Test public void givenSedaUtilsFactoryWhenCallingCreateWithoutParamsThenReturnClient() { assertTrue(SedaUtilsFactory.create(mock(HandlerIO.class)) instanceof SedaUtils); }
|
### Question:
PluginProperties { @JsonCreator public PluginProperties(@JsonProperty("className") String className, @JsonProperty("propertiesFile") String propertiesFile) { ParametersChecker.checkParameter("className is a mandatory parameter", className); this.className = className; this.propertiesFile = propertiesFile; } @JsonCreator PluginProperties(@JsonProperty("className") String className,
@JsonProperty("propertiesFile") String propertiesFile); String getClassName(); void setClassName(String className); String getPropertiesFile(); void setPropertiesFile(String propertiesFile); String getJarName(); void setJarName(String jarName); }### Answer:
@Test public void testPluginProperties() { PluginProperties pluginProp = new PluginProperties("name", "propertiesFile"); assertEquals("name", pluginProp.getClassName()); assertEquals("propertiesFile", pluginProp.getPropertiesFile()); pluginProp.setClassName("newName"); pluginProp.setPropertiesFile("newFIle"); assertEquals("newName", pluginProp.getClassName()); assertEquals("newFIle", pluginProp.getPropertiesFile()); }
|
### Question:
WorkerClientFactory extends VitamClientFactory<WorkerClient> { public static final void changeMode(WorkerClientConfiguration configuration) { getInstance(configuration).initialisation(configuration, getInstance(configuration).getResourcePath()); } private WorkerClientFactory(WorkerClientConfiguration configuration); static WorkerClientFactory getInstance(WorkerClientConfiguration configuration); @Override WorkerClient getClient(); static final WorkerClientConfiguration changeConfigurationFile(String configurationPath); static final void changeMode(WorkerClientConfiguration configuration); static final String RESOURCE_PATH; }### Answer:
@Test(expected = IllegalArgumentException.class) public void testWithWrongInitServerParameters() { WorkerClientFactory.changeMode(new WorkerClientConfiguration()); }
|
### Question:
WorkerClientMock extends AbstractMockClient implements WorkerClient { @Override public ItemStatus submitStep(DescriptionStep data) throws WorkerNotFoundClientException, WorkerServerClientException { final ItemStatus mockResponse = new ItemStatus("StepId"); final ItemStatus itemStatus = new ItemStatus("ItemId"); itemStatus.setMessage("message"); final StatusCode status = StatusCode.OK; itemStatus.increment(status); mockResponse.setItemsStatus("ItemId", itemStatus); return mockResponse; } @Override ItemStatus submitStep(DescriptionStep data); }### Answer:
@Test public void createSteps() throws WorkerNotFoundClientException, WorkerServerClientException { WorkerClientFactory.changeMode(null); final WorkerClient client = WorkerClientFactory.getInstance(null) .getClient(); final Step step = new Step(); final DefaultWorkerParameters workParams = WorkerParametersFactory.newWorkerParameters(); final DescriptionStep descriptionStep = new DescriptionStep(step, workParams); final String requestId = "requestId"; final ItemStatus result = client.submitStep(descriptionStep); assertNotNull(result); assertEquals(result.getItemsStatus().size(), 1); }
|
### Question:
EliminationActionFinalizationHandler extends ActionHandler { @Override public ItemStatus execute(WorkerParameters param, HandlerIO handler) throws ProcessingException { try { eliminationActionReportService.cleanupReport(param.getContainerName()); purgeReportService.cleanupReport(param.getContainerName()); LOGGER.info("Elimination action finalization succeeded"); return buildItemStatus(ELIMINATION_ACTION_FINALIZATION, StatusCode.OK, null); } catch (ProcessingStatusException e) { LOGGER.error( String.format("Elimination action finalization failed with status [%s]", e.getStatusCode()), e); return buildItemStatus(ELIMINATION_ACTION_FINALIZATION, e.getStatusCode(), e.getEventDetails()); } } EliminationActionFinalizationHandler(); @VisibleForTesting EliminationActionFinalizationHandler(
EliminationActionReportService eliminationActionReportService,
PurgeReportService purgeReportService); @Override ItemStatus execute(WorkerParameters param, HandlerIO handler); @Override void checkMandatoryIOParameter(HandlerIO handler); static String getId(); }### Answer:
@Test @RunWithCustomExecutor public void testExecute_OK() throws Exception { ItemStatus itemStatus = instance.execute(params, handler); assertThat(itemStatus.getGlobalStatus()).isEqualTo(StatusCode.OK); verify(eliminationActionReportService).cleanupReport(any()); verify(purgeReportService).cleanupReport(any()); }
|
### Question:
EliminationAnalysisUnitIndexationPlugin extends ActionHandler { @Override public ItemStatus execute(WorkerParameters param, HandlerIO handler) throws ProcessingException { try { EliminationAnalysisResult eliminationAnalysisResult = getUnitEliminationAnalysisResult(param); String unitId = param.getObjectName(); indexUnit(unitId, eliminationAnalysisResult); LOGGER.info("Elimination analysis unit indexation succeeded"); return buildItemStatus(ELIMINATION_ANALYSIS_UNIT_INDEXATION, StatusCode.OK, null); } catch (ProcessingStatusException e) { LOGGER.error("Elimination analysis unit indexation failed with status [" + e.getStatusCode() + "]", e); return buildItemStatus(ELIMINATION_ANALYSIS_UNIT_INDEXATION, e.getStatusCode(), e.getEventDetails()); } } EliminationAnalysisUnitIndexationPlugin(); @VisibleForTesting EliminationAnalysisUnitIndexationPlugin(
MetaDataClientFactory metaDataClientFactory); @Override ItemStatus execute(WorkerParameters param, HandlerIO handler); @Override void checkMandatoryIOParameter(HandlerIO handler); static String getId(); }### Answer:
@Test @RunWithCustomExecutor public void testIndexUnitOK() throws Exception { instance.execute(parameters, handlerIO); ArgumentCaptor<JsonNode> updateDsl = ArgumentCaptor.forClass(JsonNode.class); verify(metaDataClient).updateUnitById(updateDsl.capture(), eq("unit1")); String update = JsonHandler.unprettyPrint(updateDsl.getValue()); assertThat(update).contains("{\"$push\":{\"#elimination\""); assertThat(update).contains("\"OperationId\":\"opId\""); }
@Test @RunWithCustomExecutor public void testIndexUnitOnMetadataExceptionThenFatal() throws Exception { doThrow(MetaDataExecutionException.class).when(metaDataClient).updateUnitById(any(), any()); ItemStatus itemStatus = instance.execute(parameters, handlerIO); assertThat(itemStatus.getGlobalStatus()).isEqualTo(StatusCode.FATAL); }
|
### Question:
EvidenceAuditException extends VitamException { public EvidenceAuditException(EvidenceStatus status, String message) { super(message); this.status = status; } EvidenceAuditException(EvidenceStatus status, String message); EvidenceAuditException(EvidenceStatus status, String message, Throwable cause); EvidenceStatus getStatus(); }### Answer:
@Test public final void testEvidenceAuditException() { assertEquals("", new EvidenceAuditException(EvidenceStatus.KO,"").getMessage()); assertEquals("test", new EvidenceAuditException(EvidenceStatus.KO,"test").getMessage()); }
|
### Question:
EvidenceAuditPrepare extends ActionHandler { @Override public ItemStatus execute(WorkerParameters param, HandlerIO handlerIO) throws ProcessingException { ItemStatus itemStatus = new ItemStatus(EVIDENCE_AUDIT_LIST_OBJECT); JsonNode options = handlerIO.getJsonFromWorkspace("evidenceOptions"); boolean correctiveAudit = options.get("correctiveOption").booleanValue(); if (!correctiveAudit) { return handleEvidenceAudit(handlerIO, itemStatus); } String operationId = options.get(OPERATION).textValue(); return handleRectificationAudit(handlerIO, itemStatus, operationId); } EvidenceAuditPrepare(); @VisibleForTesting EvidenceAuditPrepare(MetaDataClientFactory metaDataClientFactory, StorageClientFactory storageClientFactory); @Override ItemStatus execute(WorkerParameters param, HandlerIO handlerIO); }### Answer:
@Test public void should_prepare_evidence_audit() throws Exception { WorkerParameters defaultWorkerParameters = mock(WorkerParameters.class); when(defaultWorkerParameters.getObjectName()).thenReturn("test"); JsonNode query = JsonHandler.getFromString(EvidenceAuditPrepareTest.query); when(handlerIO.getJsonFromWorkspace(anyString())).thenReturn(query); given(metaDataClient.selectUnits(JsonHandler.getFromString(query2))).willReturn( JsonHandler.getFromInputStream(getClass().getResourceAsStream("/evidenceAudit/selectResult.json"))); given(handlerIO.getNewLocalFile("aeaqaaaaaaebta56aaoc4alcdk4hlcqaaaaq")).willReturn(tempFolder.newFile()); given(handlerIO.getNewLocalFile("aeaqaaaaaaebta56aam5ualcdnzc4wiaaabq")).willReturn(tempFolder.newFile()); given(handlerIO.getJsonFromWorkspace("evidenceOptions")) .willReturn(JsonHandler.createObjectNode().put("correctiveOption", false)); ItemStatus execute = evidenceAuditPrepare.execute(defaultWorkerParameters, handlerIO); Assertions.assertThat(execute.getGlobalStatus()).isEqualTo(StatusCode.OK); }
|
### Question:
EvidenceAuditExtractFromZip extends ActionHandler { @Override public ItemStatus execute(WorkerParameters param, HandlerIO handlerIO) throws ProcessingException { ItemStatus itemStatus = new ItemStatus(EVIDENCE_AUDIT_EXTRACT_ZIP_FILE); String secureDataFileName = param.getObjectName(); File file = null; try { file = evidenceService.downloadAndExtractDataFromStorage(secureDataFileName, "data.txt", "zip",true); handlerIO.transferFileToWorkspace("zip" + File.separator + secureDataFileName, file, true, false); itemStatus.increment(StatusCode.OK); return new ItemStatus(EVIDENCE_AUDIT_EXTRACT_ZIP_FILE) .setItemsStatus(EVIDENCE_AUDIT_EXTRACT_ZIP_FILE, itemStatus); } catch (EvidenceAuditException e) { LOGGER.error(e); return itemStatus.increment(StatusCode.FATAL); } } @VisibleForTesting EvidenceAuditExtractFromZip(EvidenceService evidenceService); EvidenceAuditExtractFromZip(); @Override ItemStatus execute(WorkerParameters param, HandlerIO handlerIO); }### Answer:
@Test public void should_extract_from_zip() throws Exception { WorkerParameters defaultWorkerParameters = mock(WorkerParameters.class); when(defaultWorkerParameters.getObjectName()) .thenReturn("evidenceAudit/0_LogbookLifecycles_20180220_111512.zip"); ItemStatus execute = evidenceAuditExtractFromZip.execute(defaultWorkerParameters, handlerIO); assertThat(execute.getGlobalStatus()).isEqualTo(StatusCode.OK); }
|
### Question:
EvidenceAuditFinalize extends ActionHandler { @Override public ItemStatus execute(WorkerParameters param, HandlerIO handlerIO) throws ProcessingException { ItemStatus itemStatus = new ItemStatus(EVIDENCE_AUDIT_FINALIZE); try { String containerName = param.getContainerName(); evidenceAuditReportService.storeReportToOffers(containerName); evidenceAuditReportService.cleanupReport(containerName); itemStatus.increment(StatusCode.OK); return new ItemStatus(EVIDENCE_AUDIT_FINALIZE).setItemsStatus(EVIDENCE_AUDIT_FINALIZE, itemStatus); } catch (ProcessingStatusException e) { LOGGER.error(e); itemStatus.increment(e.getStatusCode()); return new ItemStatus(EVIDENCE_AUDIT_FINALIZE).setItemsStatus(EVIDENCE_AUDIT_FINALIZE, itemStatus); } } @VisibleForTesting EvidenceAuditFinalize(EvidenceAuditReportService evidenceAuditReportService); EvidenceAuditFinalize(); @Override ItemStatus execute(WorkerParameters param, HandlerIO handlerIO); }### Answer:
@RunWithCustomExecutor @Test public void shouldFinalizeAudit() throws Exception { VitamThreadUtils.getVitamSession().setTenantId(0); String containerName = GUIDFactory.newGUID().getId(); VitamThreadUtils.getVitamSession().setRequestId(containerName); doReturn(containerName).when(defaultWorkerParameters).getContainerName(); ItemStatus itemStatus = evidenceAuditFinalize.execute(defaultWorkerParameters, handlerIO); assertThat(itemStatus.getGlobalStatus()).isEqualTo(StatusCode.OK); verify(evidenceAuditReportService).storeReportToOffers(containerName); verify(evidenceAuditReportService).cleanupReport(containerName); }
|
### Question:
TransferReplyFinalizationPlugin extends ActionHandler { @Override public ItemStatus execute(WorkerParameters param, HandlerIO handler) throws ProcessingException { try { transferReplyReportService.cleanupReport(param.getContainerName()); purgeReportService.cleanupReport(param.getContainerName()); LOGGER.info("Transfer reply finalization succeeded"); return buildItemStatus(TRANSFER_REPLY_FINALIZATION, StatusCode.OK, null); } catch (ProcessingStatusException e) { LOGGER.error( String.format("Transfer reply finalization failed with status [%s]", e.getStatusCode()), e); return buildItemStatus(TRANSFER_REPLY_FINALIZATION, e.getStatusCode(), e.getEventDetails()); } } TransferReplyFinalizationPlugin(); @VisibleForTesting TransferReplyFinalizationPlugin(
TransferReplyReportService TransferReplyReportService,
PurgeReportService purgeReportService); @Override ItemStatus execute(WorkerParameters param, HandlerIO handler); @Override void checkMandatoryIOParameter(HandlerIO handler); static String getId(); }### Answer:
@Test @RunWithCustomExecutor public void should_transfer_reply_finalization_ok() throws Exception { ItemStatus itemStatus = instance.execute(params, handler); assertThat(itemStatus.getGlobalStatus()).isEqualTo(StatusCode.OK); verify(eliminationActionReportService).cleanupReport(any()); verify(purgeReportService).cleanupReport(any()); }
|
### Question:
SortedLevelJsonLineWriter implements AutoCloseable { public void exportToWorkspace(String filename, boolean ascending) throws IOException, ProcessingException { for (JsonLineWriter value : this.writersByLevel.values()) { value.close(); } File combinedSortedJsonLineFile = handler.getNewLocalFile(GUIDFactory.newGUID().toString()); try { try (OutputStream outputStream = new FileOutputStream(combinedSortedJsonLineFile); JsonLineWriter writer = new JsonLineWriter(outputStream)) { List<Integer> levels = this.filesByLevel.keySet().stream() .sorted(ascending ? Comparator.naturalOrder() : Comparator.reverseOrder()) .collect(Collectors.toList()); for (Integer level : levels) { File fileLevel = this.filesByLevel.get(level); try (InputStream is = new FileInputStream(fileLevel); JsonLineGenericIterator<JsonLineModel> lineGenericIterator = new JsonLineGenericIterator<>( is, TYPE_REFERENCE)) { while (lineGenericIterator.hasNext()) { writer.addEntry(lineGenericIterator.next()); } } } } handler.transferFileToWorkspace(filename, combinedSortedJsonLineFile, true, false); } finally { for (File file : filesByLevel.values()) { FileUtils.deleteQuietly(file); } } } SortedLevelJsonLineWriter(HandlerIO handler); void addEntry(JsonLineModel line); void exportToWorkspace(String filename, boolean ascending); @Override void close(); }### Answer:
@Test public void testEmpty() throws Exception { instance.exportToWorkspace(EXPORT_FILE, true); ArgumentCaptor<File> fileArgumentCaptor = ArgumentCaptor.forClass(File.class); verify(handler).transferFileToWorkspace(eq(EXPORT_FILE), fileArgumentCaptor.capture(), eq(true), eq(false)); assertThat(fileArgumentCaptor.getValue().length()).isEqualTo(0); }
|
### Question:
SortedLevelJsonLineWriter implements AutoCloseable { public void addEntry(JsonLineModel line) throws IOException { if (line.getDistribGroup() == null) { throw new IllegalArgumentException("Null distribution group " + JsonHandler.unprettyPrint(line)); } if (!filesByLevel.containsKey(line.getDistribGroup())) { if (filesByLevel.size() >= MAX_LEVELS) { throw new IllegalStateException("Too many levels " + MAX_LEVELS); } File newLocalFile = handler.getNewLocalFile(GUIDFactory.newGUID().toString()); filesByLevel.put(line.getDistribGroup(), newLocalFile); writersByLevel.put(line.getDistribGroup(), new JsonLineWriter(new FileOutputStream(newLocalFile))); } JsonLineWriter jsonLineWriter = writersByLevel.get(line.getDistribGroup()); jsonLineWriter.addEntry(line); } SortedLevelJsonLineWriter(HandlerIO handler); void addEntry(JsonLineModel line); void exportToWorkspace(String filename, boolean ascending); @Override void close(); }### Answer:
@Test public void testTooManyLevelThenException() throws Exception { for (int i = 1; i <= 100; i++) { instance.addEntry(new JsonLineModel("id" + i, i, JsonHandler.createObjectNode())); } assertThatThrownBy(() -> instance.addEntry(new JsonLineModel("id101", 101, JsonHandler.createObjectNode()))) .isInstanceOf(IllegalStateException.class); }
|
### Question:
JokeServiceStubClient { @HystrixCommand(groupKey = "joke-svc-broker", commandKey = "joke-svc-cmd", threadPoolKey = "joke-svc-pool") public String tellAJoke() { try { Thread.sleep(3000); } catch (InterruptedException e) { e.printStackTrace(); } return ""; } @HystrixCommand(groupKey = "joke-svc-broker", commandKey = "joke-svc-cmd", threadPoolKey = "joke-svc-pool") String tellAJoke(); }### Answer:
@Test public void testHystrixCommandTimeout() { assertThatExceptionOfType(HystrixRuntimeException.class).isThrownBy(() -> client.tellAJoke()); }
|
### Question:
BaseCouchbaseRepository implements CouchbaseRepository<T> { @Override public Single<AsyncBucket> asyncBucket() { return couchbaseAsyncBucketFactory.getAsyncBucketInstance(); } BaseCouchbaseRepository(); BaseCouchbaseRepository(ObjectMapper objectMapper); @Override Single<AsyncBucket> asyncBucket(); @Override Single<T> convert(String json); }### Answer:
@Test public void testAsyncBucket() { BaseCouchbaseRepository<TestPojo> baseCouchbaseRepository = new BaseCouchbaseRepository<>(); baseCouchbaseRepository.couchbaseAsyncBucketFactory = mockBucketFactory; TestSubscriber<AsyncBucket> subscriber = new TestSubscriber<>(); baseCouchbaseRepository.asyncBucket() .subscribe(subscriber); subscriber.assertCompleted(); subscriber.assertNoErrors(); subscriber.assertValueCount(1); subscriber.assertValue(mockBucket); }
@Test public void testAsyncBucketError() { when(mockBucketFactory.getAsyncBucketInstance()).thenReturn(Single.error(new RuntimeException("test"))); BaseCouchbaseRepository<TestPojo> baseCouchbaseRepository = new BaseCouchbaseRepository<>(); baseCouchbaseRepository.couchbaseAsyncBucketFactory = mockBucketFactory; TestSubscriber<AsyncBucket> subscriber = new TestSubscriber<>(); baseCouchbaseRepository.asyncBucket() .subscribe(subscriber); subscriber.assertError(RuntimeException.class); }
|
### Question:
BaseCouchbaseRepository implements CouchbaseRepository<T> { @Override public Single<T> convert(String json) { try { return Single.just(objectMapper.readValue(json, getGenericClass())); } catch (IOException e) { return Single.error(e); } } BaseCouchbaseRepository(); BaseCouchbaseRepository(ObjectMapper objectMapper); @Override Single<AsyncBucket> asyncBucket(); @Override Single<T> convert(String json); }### Answer:
@Test public void testConvert() { TestRepository testRepository = new TestRepository(mockBucketFactory); TestSubscriber<TestPojo> subscriber = new TestSubscriber<>(); testRepository.convert("{\"key\":\"value\"}") .subscribe(subscriber); subscriber.assertCompleted(); subscriber.assertNoErrors(); subscriber.assertValueCount(1); TestPojo testPojo = subscriber.getOnNextEvents().get(0); assertThat(testPojo.key).isEqualTo("value"); }
|
### Question:
ThymeleafConfig { static YamlPropertiesFactoryBean yamlPropertiesFactory(String path, List<String> names) throws IOException { YamlPropertiesFactoryBean factory = new YamlPropertiesFactoryBean(); FileSystemResource[] resources = Files.find(Paths.get(path, "properties"), MAX_DEPTH, (p, attr) -> { String filename = getFilename(cleanPath(p.toFile().getAbsolutePath())); return isYaml(filename) && isGlobalOrMatchesTemplatesNames(filename, names); }) .map(Path::toFile) .peek(f -> log.debug("Found resource: {}.", f.getAbsolutePath())) .map(FileSystemResource::new) .toArray(size -> new FileSystemResource[size]); factory.setResources(resources); return factory; } static final int MAX_DEPTH; }### Answer:
@Test public void testYamlPropertiesFactory() throws URISyntaxException, IOException { File test = new File(getClass().getResource("/").toURI()); String projectDir = test.getParentFile().getParentFile().getParent(); String resources = new File(projectDir, "src/test/resources").getAbsolutePath(); YamlPropertiesFactoryBean propertiesFactory = ThymeleafConfig.yamlPropertiesFactory(resources, singletonList("nginx")); Properties props = propertiesFactory.getObject(); assertThat(props.getProperty("app.name"), is("test")); }
|
### Question:
Consumer { public Map<String, Map<String, Integer>> getAnalytics() { return unmodifiableMap(analytics); } Map<String, Map<String, Integer>> getAnalytics(); @KafkaListener(id = "ufo", topics = "ufo", containerFactory = "ufoContainerFactory") void listen(List<Sighting> sightings); @EventListener(condition = "event.listenerId.startsWith('ufo-')") ConsumerCompletedEvent eventHandler(ListenerContainerIdleEvent event); }### Answer:
@Test public void testGetAnalytics() { List<Sighting> sightings = IntStream.range(1, 13) .mapToObj(this::stubSighting) .collect(toList()); Consumer consumer = new Consumer(); consumer.listen(sightings); Map<String, Map<String, Integer>> analytics = consumer.getAnalytics(); assertThat(analytics.get("state"), is(notNullValue())); assertThat(analytics.get("state").size(), is(1)); assertThat(analytics.get("shape"), is(notNullValue())); assertThat(analytics.get("shape").size(), is(1)); assertThat(analytics.get("year"), is(notNullValue())); assertThat(analytics.get("year").size(), is(1)); assertThat(analytics.get("month"), is(notNullValue())); assertThat(analytics.get("month").size(), is(12)); }
|
### Question:
Producer implements CommandLineRunner { Flux<Sighting> getSightings() { YearMonth from = producerProperties.getFromYearMonth(); YearMonth to = producerProperties.getToYearMonth(); int months = (int) from.until(to, MONTHS) + 1; int numBatches = (int) Math.ceil((double) months / BATCH_SIZE); return Flux.range(1, numBatches - 1) .zipWith(Flux.intervalMillis(producerProperties.getDelayMillis()), (i, delay) -> i) .scanWith(new TupleSupplier(true, from, to), (t, i) -> new TupleSupplier(false, t.getT1(), to).get()) .groupBy(t -> t.getT1().getYear()) .flatMap(g -> g .publishOn(Schedulers.parallel()) .flatMap(t -> crawler.getSightings(t.getT1(), t.getT2())), CONCURRENCY); } @Override void run(String... args); }### Answer:
@Test public void testGetSightings() { Producer producer = new Producer(null, producerProperties(), this.crawler); List<Sighting> sightings = producer.getSightings() .collectList() .block(); assertThat(sightings, hasSize(31)); }
|
### Question:
CrawlerImpl implements Crawler { @Override public Flux<Sighting> getSightings(YearMonth from, YearMonth to) { int months = (int) from.until(to, ChronoUnit.MONTHS) + 1; return Flux.range(0, months) .map(from::plusMonths) .flatMap(this::getSightings); } @Override Flux<Sighting> getSightings(YearMonth from, YearMonth to); @Override Flux<Sighting> getSightings(YearMonth yearMonth); }### Answer:
@Test public void testGetIncidents() { YearMonth from = YearMonth.of(2017, 01); YearMonth to = YearMonth.of(2017, 02); StepVerifier.create(new CrawlerImpl().getSightings(from, to)) .expectNextMatches(s -> { LocalDateTime eventDateTime = s.getEventDateTime(); return eventDateTime.getYear() == 2017 && (eventDateTime.getMonth().equals(Month.JANUARY) || eventDateTime.getMonth().equals(Month.FEBRUARY)); }) .thenCancel() .verify(Duration.ofSeconds(5)); }
|
### Question:
UserController { @RequestMapping(value = "/findUserDetailsByUsername", method = GET) ResponseEntity<Resource<UserDetails>> findUserDetailsByUsername(@RequestParam("username") String username) { UserDetails userDetails = authorityRepository.loadUserByUsername(username); Resource<UserDetails> userDetailsResource = new Resource<>(userDetails); return new ResponseEntity<>(userDetailsResource, OK); } }### Answer:
@Test public void testFindUserDetailsByUsername() throws Exception { mockMvc.perform(get("/users/search/findUserDetailsByUsername").param("username", testUser.getEmail().get()) .accept(HAL_JSON)).andDo(new ResultHandler() { @Override public void handle(MvcResult findResult) throws Exception { String body = findResult.getResponse().getContentAsString(); UserIdAwareUserDetails userDetails = OBJECT_MAPPER.readValue(body, UserIdAwareUserDetails.class); assertEquals(authority.getRole().name(), userDetails.getAuthorities().iterator().next().getAuthority()); } }); }
|
### Question:
ReleaseSymbolType extends SymbolType implements Rule, Translation { @Override public String toTarget(Translator translator, Symbol symbol) { Release release; try { release = new Release(symbol.getProperty(OptionType.RELEASE.name())); } catch (Exception e) { return "<strong>Malformed release: " + e.getMessage() + "</strong>"; } String href = symbol.getProperty(OptionType.HREF.name()); TagGroup html = new TagGroup(); addTitle(html, release, href); if (release.exists()) { addFilesHtml(html, release); release.saveInfo(); } else html.add("The release directory could not be found."); return html.html(); } ReleaseSymbolType(); @Override Maybe<Symbol> parse(Symbol current, Parser parser); @Override String toTarget(Translator translator, Symbol symbol); }### Answer:
@Test public void translatesToContent() { Symbol symbol = new Symbol(releaseSymbolType); symbol.putProperty(ReleaseSymbolType.OptionType.RELEASE.name(), "20121220"); String html = releaseSymbolType.toTarget(null, symbol); assertTrue(html.contains("<h3>release \n" + "\t<a href=\"\">20121220</a>\n" + "</h3>")); assertTrue(html.contains("<a href=\"/fitnesse-standalone.jar?responder=releaseDownload&release=20121220\">")); }
|
### Question:
DownloadResponder implements Responder { public Response makeResponse(FitNesseContext fitNesseContext, Request request) throws Exception { releaseName = (String) request.getInput("release"); release = new Release(releaseName); filename = request.getResource(); if (!release.exists()) return new ErrorResponder("There is no release named " + releaseName ).makeResponse(fitNesseContext, request); ReleaseFile releaseFile = release.getFile(filename); if (releaseFile == null) return new ErrorResponder( "The " + releaseName + " doesn't have a file named " + filename ).makeResponse(fitNesseContext, request); InputStreamResponse response = new InputStreamResponse(); response.setContentType(FileResponder.getContentType(filename)); InputStream input = releaseFile.getDownloadStream(); response.setBody(input, (int) releaseFile.getByteCount()); release.saveInfo(); return response; } Response makeResponse(FitNesseContext fitNesseContext, Request request); String getReleaseName(); String getFilename(); }### Answer:
@Test public void testMimeType() throws Exception { ReleaseTest.prepareReleaseWithFiles(); FileUtil.createFile("releases/xyz/file3.jar", "jar file"); FileUtil.createFile("releases/xyz/file4.zip", "zip file"); MockRequest request = new MockRequest(); request.addInput("release", "xyz"); request.setResource("file3.jar"); Response response = responder.makeResponse(context, request); assertEquals("application/x-java-archive", response.getContentType()); request.setResource("file4.zip"); response = responder.makeResponse(context, request); assertEquals("application/zip", response.getContentType()); }
|
### Question:
Release { public boolean exists() { return releaseDir.exists(); } Release(String name); String getName(); boolean exists(); int fileCount(); void saveInfo(); List<ReleaseFile> getFiles(); ReleaseFile getFile(String filename); boolean isCorrupted(); static final String ENDL; }### Answer:
@Test public void testCreationNoDirectory() throws Exception { Release release = new Release("xyz"); assertFalse(release.exists()); }
|
### Question:
Release { public void saveInfo() { FileWriter writer = null; try { writer = new FileWriter(infoFile); for (Iterator iterator = getFiles().iterator(); iterator.hasNext();) writer.write(iterator.next().toString() + "\n"); writer.flush(); writer.close(); writer = null; } catch (IOException e) { e.printStackTrace(); } finally{ if (writer != null) { try { writer.close(); } catch (Exception e2) { } } } } Release(String name); String getName(); boolean exists(); int fileCount(); void saveInfo(); List<ReleaseFile> getFiles(); ReleaseFile getFile(String filename); boolean isCorrupted(); static final String ENDL; }### Answer:
@Test public void testReleaseInfo() throws Exception { Release release = prepareReleaseWithFiles(); release.saveInfo(); String info = FileUtil.getFileContent("releases/xyz/.releaseInfo"); assertSubString("file1", info); assertSubString("file2", info); }
|
### Question:
CamelExchangeBus implements ExchangeBus { @Override public ExchangeDispatcher createDispatcher(final ServiceReference reference) { if (_logger.isDebugEnabled()) { _logger.debug("Creating Camel dispatcher for " + reference.getName()); } String endpoint = "direct:" + reference.getName(); RouteBuilder rb = new CamelExchangeBusRouteBuilder(endpoint, reference); try { if (_camelContext.getRoute(endpoint) != null) { _camelContext.removeRoute(endpoint); if (_logger.isInfoEnabled()) { BusLogger.ROOT_LOGGER.removeRoute(endpoint); } } _camelContext.addRoutes(rb); if (_logger.isDebugEnabled()) { _logger.debug("Created route for " + endpoint + ", definition is: " + ModelHelper.dumpModelAsXml(rb.getRouteCollection())); } } catch (Exception ex) { throw BusMessages.MESSAGES.failedToCreateRoute(reference.getName(), ex); } ExchangeDispatcher dispatcher = new ExchangeDispatcher(_camelContext, reference); _dispatchers.put(reference.getName(), dispatcher); return dispatcher; } CamelExchangeBus(SwitchYardCamelContext context); @Override void init(ServiceDomain domain); @Override synchronized void start(); @Override synchronized void stop(); @Override Dispatcher getDispatcher(ServiceReference reference); @Override ExchangeDispatcher createDispatcher(final ServiceReference reference); }### Answer:
@Test public void testCreateDispatcher() throws Exception { ServiceReference inOnly = new ServiceReferenceImpl( new QName("inOnly"), new InOnlyService(), _domain, null); assertNotNull(_provider.createDispatcher(inOnly)); ServiceReference inOut = new ServiceReferenceImpl( new QName("inOut"), new InOutService(), _domain, null); assertNotNull(_provider.createDispatcher(inOut)); }
|
### Question:
DefaultMessage implements Message { @Override public void removeAttachment(final String name) { _attachments.remove(name); } DefaultMessage(); DefaultMessage setTransformerRegistry(TransformerRegistry transformerRegistry); @Override DefaultMessage addAttachment(final String name, final DataSource attachment); @Override DataSource getAttachment(final String name); @Override void removeAttachment(final String name); @Override Map<String, DataSource> getAttachmentMap(); @Override Object getContent(); @Override Context getContext(); @Override T getContent(final Class<T> type); @Override DefaultMessage setContent(final Object content); @Override Message copy(); boolean isSent(); void send(); }### Answer:
@Test public void testRemoveAttachment() throws Exception { _message.addAttachment("attach1", new DummyDS("attach1", "text/xml")); Assert.assertNotNull(_message.getAttachment("attach1")); _message.removeAttachment("attach1"); Assert.assertNull(_message.getAttachment("attach1")); }
|
### Question:
DefaultMessage implements Message { @Override public Map<String, DataSource> getAttachmentMap() { return new HashMap<String, DataSource>(_attachments); } DefaultMessage(); DefaultMessage setTransformerRegistry(TransformerRegistry transformerRegistry); @Override DefaultMessage addAttachment(final String name, final DataSource attachment); @Override DataSource getAttachment(final String name); @Override void removeAttachment(final String name); @Override Map<String, DataSource> getAttachmentMap(); @Override Object getContent(); @Override Context getContext(); @Override T getContent(final Class<T> type); @Override DefaultMessage setContent(final Object content); @Override Message copy(); boolean isSent(); void send(); }### Answer:
@Test public void testGetAttachmentMap() throws Exception { _message.addAttachment("attach1", new DummyDS("attach1", "text/xml")); _message.addAttachment("attach2", new DummyDS("attach1", "text/xml")); Map<String, DataSource> attachments = _message.getAttachmentMap(); Assert.assertTrue(attachments.containsKey("attach1")); Assert.assertTrue(attachments.containsKey("attach2")); attachments.remove("attach1"); Assert.assertNotNull(_message.getAttachment("attach1")); }
|
### Question:
ServiceImpl implements Service { @Override public void unregister() { _domain.getServiceRegistry().unregisterService(this); _domain.getEventPublisher().publish(new ServiceUnregistrationEvent(this)); } ServiceImpl(QName name,
ServiceInterface serviceInterface,
DomainImpl domain,
ExchangeHandler providerHandler); ServiceImpl(QName name,
ServiceInterface serviceInterface,
DomainImpl domain,
ExchangeHandler providerHandler,
ServiceMetadata metadata); @Override ServiceInterface getInterface(); @Override QName getName(); @Override ServiceDomain getDomain(); @Override void unregister(); @Override ExchangeHandler getProviderHandler(); @Override String toString(); @Override ServiceMetadata getServiceMetadata(); }### Answer:
@Test public void testUnregister() { Service service = _domain.registerService(new QName("TestService"), new InOnlyService(), new MockHandler()); Assert.assertEquals(1, _domain.getServiceRegistry().getServices().size()); service.unregister(); Assert.assertEquals(0, _domain.getServiceRegistry().getServices().size()); }
|
### Question:
DefaultHandlerChain implements HandlerChain { @Override public synchronized boolean replace(String handlerName, ExchangeHandler handler) { for (int i = 0; i < _chain.size(); i++) { if (_chain.get(i).getName().equals(handlerName)) { _chain.remove(i); _chain.add(i, new HandlerRef(handlerName, handler)); return true; } } return false; } DefaultHandlerChain(); private DefaultHandlerChain(List<HandlerRef> handlers); static DefaultHandlerChain fromList(List<ExchangeHandler> handlers); @Override synchronized void addFirst(String handlerName,
ExchangeHandler handler); @Override synchronized void addLast(String handlerName,
ExchangeHandler handler); @Override synchronized boolean replace(String handlerName, ExchangeHandler handler); @Override synchronized ExchangeHandler remove(String handlerName); @Override void handle(Exchange exchange); @Override void handleFault(Exchange exchange); @Override void handleMessage(Exchange exchange); @Override List<ExchangeHandler> getHandlers(); DefaultHandlerChain copy(); @Override String toString(); }### Answer:
@Test public void testReplace() { MockHandler m1 = new MockHandler(); MockHandler m2 = new MockHandler(); MockHandler m3 = new MockHandler(); MockHandler m4 = new MockHandler(); _chain.addFirst("1", m1); Assert.assertFalse(_chain.replace("5", m2)); Assert.assertTrue(_chain.replace("1", m2)); Assert.assertTrue(_chain.getHandlers().contains(m2)); Assert.assertFalse(_chain.getHandlers().contains(m1)); _chain.remove("1"); Assert.assertEquals(0, _chain.getHandlers().size()); _chain.addFirst("1", m1); _chain.addFirst("2", m2); _chain.addFirst("3", m3); _chain.replace("2", m4); Assert.assertEquals(m4, _chain.getHandlers().get(1)); }
|
### Question:
DomainImpl implements SecureServiceDomain { @Override public EventPublisher getEventPublisher() { return _eventManager; } protected DomainImpl(QName name); DomainImpl(QName name,
ServiceRegistry serviceRegistry,
ExchangeBus exchangeBus,
TransformerRegistry transformerRegistry,
ValidatorRegistry validatorRegistry,
EventManager eventManager,
ServiceDomainSecurity serviceDomainSecurity); @Override Service registerService(QName serviceName, ServiceInterface contract,
ExchangeHandler handler); @Override Service registerService(QName serviceName,
ServiceInterface contract, ExchangeHandler handler, ServiceMetadata metadata); @Override ServiceReference registerServiceReference(QName serviceName,
ServiceInterface contract); @Override ServiceReference registerServiceReference(QName serviceName,
ServiceInterface contract, ExchangeHandler handler); @Override ServiceReference registerServiceReference(QName serviceName,
ServiceInterface contract, ExchangeHandler handler, ServiceMetadata metadata); @Override ServiceReference getServiceReference(QName serviceName); @Override QName getName(); @Override TransformerRegistry getTransformerRegistry(); @Override ValidatorRegistry getValidatorRegistry(); @Override List<Service> getServices(); @Override List<Service> getServices(QName serviceName); ServiceRegistry getServiceRegistry(); ExchangeBus getBus(); @Override void init(); @Override void destroy(); @Override ServiceDomain addEventObserver(EventObserver observer, Class<? extends EventObject> eventType); @Override EventPublisher getEventPublisher(); @Override Map<String, Object> getProperties(); @Override Object getProperty(String name); @Override ServiceDomain setProperty(String name, Object value); @Override ServiceSecurity getServiceSecurity(String name); @Override ServiceDomainSecurity getServiceDomainSecurity(); @Override String toString(); }### Answer:
@Test public void testGetEventPublisher() { Assert.assertNotNull(_domain.getEventPublisher()); }
|
### Question:
BaseValidatorRegistry implements ValidatorRegistry { @Override public Validator<?> getValidator(QName name) { Validator<?> validator = _validators.get(name); if (validator == null) { validator = _fallbackValidators.get(name); if (validator == null && QNameUtil.isJavaMessageType(name)) { validator = getJavaFallbackValidator(name); if (validator != null && _log.isDebugEnabled()) { _log.debug("Selecting fallback validator: name '" + validator.getName() + "'. Type: " + validator.getClass().getName()); } else if (_log.isDebugEnabled()) { _log.debug("No compatible validator registered: name '" + name + "'"); } } } else if (_log.isDebugEnabled()) { _log.debug("Selecting validator: name '" + validator.getName() + "'. Type: " + validator.getClass().getName()); } return validator == NULL_VALIDATOR ? null : validator; } BaseValidatorRegistry(); BaseValidatorRegistry(Set<Validator<?>> validators); @Override BaseValidatorRegistry addValidator(Validator<?> validator); @Override ValidatorRegistry addValidator(Validator<?> validator, QName name); @Override Validator<?> getValidator(QName name); @Override boolean hasValidator(QName name); @Override boolean removeValidator(Validator<?> validator); void setEventPublisher(EventPublisher eventPublisher); }### Answer:
@Test public void testNullValidator() { final QName name = new QName("notfound"); Validator<?> validator = _registry.getValidator(name); Assert.assertTrue(validator == null); }
|
### Question:
ContextProperty implements Property { @Override public boolean equals(Object obj) { if (this == obj) { return true; } if (!(obj instanceof ContextProperty)) { return false; } ContextProperty comp = (ContextProperty)obj; return _name.equals(comp.getName()) && _scope.equals(comp.getScope()) && (_value == null ? comp.getValue() == null : _value.equals(comp.getValue())); } private ContextProperty(); ContextProperty(String name, Scope scope, Object value); @Override String getName(); @Override Scope getScope(); @Override Object getValue(); void setValue(Object value); @Override Set<String> getLabels(); @Override Property addLabels(String... labels); @Override Property addLabels(Set<String> labels); @Override Property removeLabels(String... labels); @Override boolean hasLabel(String label); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testEquals() { ContextProperty prop1 = new ContextProperty("foo", Scope.MESSAGE, "bar"); ContextProperty prop2 = new ContextProperty("foo", Scope.MESSAGE, "bar"); Assert.assertTrue(prop1.equals(prop2)); }
@Test public void testNotEquals() { ContextProperty propRef = new ContextProperty("foo", Scope.MESSAGE, "bar"); ContextProperty propDiffName = new ContextProperty("oops", Scope.MESSAGE, "bar"); ContextProperty propDiffValue = new ContextProperty("foo", Scope.MESSAGE, "nope"); Assert.assertFalse(propRef.equals(propDiffName)); Assert.assertFalse(propRef.equals(propDiffValue)); }
|
### Question:
ExchangeImpl implements Exchange { @Override public ExchangePhase getPhase() { return _phase; } ExchangeImpl(ServiceDomain domain, Dispatcher dispatcher); ExchangeImpl(ServiceDomain domain, Dispatcher dispatch, ExchangeHandler replyHandler); @Override Context getContext(); @Override Context getContext(Message message); @Override Message getMessage(); @Override synchronized void send(Message message); @Override synchronized void sendFault(Message message); @Override ExchangeState getState(); Dispatcher getDispatcher(); @Override ExchangeHandler getReplyHandler(); @Override ExchangePattern getPattern(); @Override ExchangeSecurity getSecurity(); @Override Message createMessage(); @Override ExchangePhase getPhase(); @Override ExchangeContract getContract(); @Override ServiceReference getConsumer(); @Override Service getProvider(); @Override ExchangeImpl consumer(ServiceReference consumer, ServiceOperation operation); @Override ExchangeImpl provider(Service provider, ServiceOperation operation); }### Answer:
@Test public void testPhaseIsNullOnNewExchange() { Exchange exchange = new ExchangeImpl(_domain, _dispatch); Assert.assertNull(exchange.getPhase()); }
|
### Question:
ExchangeImpl implements Exchange { @Override public Message getMessage() { return _message; } ExchangeImpl(ServiceDomain domain, Dispatcher dispatcher); ExchangeImpl(ServiceDomain domain, Dispatcher dispatch, ExchangeHandler replyHandler); @Override Context getContext(); @Override Context getContext(Message message); @Override Message getMessage(); @Override synchronized void send(Message message); @Override synchronized void sendFault(Message message); @Override ExchangeState getState(); Dispatcher getDispatcher(); @Override ExchangeHandler getReplyHandler(); @Override ExchangePattern getPattern(); @Override ExchangeSecurity getSecurity(); @Override Message createMessage(); @Override ExchangePhase getPhase(); @Override ExchangeContract getContract(); @Override ServiceReference getConsumer(); @Override Service getProvider(); @Override ExchangeImpl consumer(ServiceReference consumer, ServiceOperation operation); @Override ExchangeImpl provider(Service provider, ServiceOperation operation); }### Answer:
@Test public void testGetMessage() throws Exception { final QName serviceName = new QName("bleh"); final String inMsgContent = "in message"; final String outMsgContent = "out message"; ExchangeHandler provider = new BaseHandler() { public void handleMessage(Exchange exchange) { Assert.assertEquals( exchange.getMessage().getContent(), inMsgContent); Message outMsg = exchange.createMessage(); outMsg.setContent(outMsgContent); try { exchange.send(outMsg); } catch (Exception ex) { Assert.fail(ex.toString()); } } }; ExchangeHandler consumer = new BaseHandler() { public void handleMessage(Exchange exchange) { Assert.assertEquals( exchange.getMessage().getContent(), outMsgContent); } }; ServiceReference service = _domain.createInOutService(serviceName, provider); Exchange exchange = service.createExchange(consumer); Message inMsg = exchange.createMessage(); inMsg.setContent(inMsgContent); exchange.send(inMsg); }
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.