method2testcases
stringlengths 118
3.08k
|
|---|
### Question:
SelectParserSingle extends RequestParserSingle { @Override public void parseQueryOnly(final String query) throws InvalidParseOperationException { super.parseQueryOnly(query); projectionParse(JsonHandler.createObjectNode()); } SelectParserSingle(); SelectParserSingle(VarNameAdapter adapter); @Override void parse(final JsonNode request); @Override void parseQueryOnly(final String query); void projectionParse(final JsonNode rootNode); void addProjection(final ObjectNode slice, final ObjectNode allFields); @Override Select getRequest(); }### Answer:
@Test public void testParseQueryOnly() throws InvalidParseOperationException { final SelectParserSingle request = new SelectParserSingle(); final String ex = "{}"; request.parseQueryOnly(ex); assertNotNull(request); }
|
### Question:
SelectParserSingle extends RequestParserSingle { private void internalParseSelect() throws InvalidParseOperationException { projectionParse(rootNode.get(GLOBAL.PROJECTION.exactToken())); } SelectParserSingle(); SelectParserSingle(VarNameAdapter adapter); @Override void parse(final JsonNode request); @Override void parseQueryOnly(final String query); void projectionParse(final JsonNode rootNode); void addProjection(final ObjectNode slice, final ObjectNode allFields); @Override Select getRequest(); }### Answer:
@Test public void testInternalParseSelect() throws InvalidParseOperationException { final SelectParserSingle request = new SelectParserSingle(); final String s = "[ { $path : [ 'id1', 'id2'] }, {$mult : false }, {} ]"; request.parse(JsonHandler.getFromString(s)); assertNotNull(request); }
|
### Question:
UpdateParserMultiple extends RequestParserMultiple { @Override public UpdateMultiQuery getRequest() { return (UpdateMultiQuery) request; } UpdateParserMultiple(); UpdateParserMultiple(VarNameAdapter adapter); @Override void parse(final JsonNode request); @Override String toString(); @Override UpdateMultiQuery getRequest(); }### Answer:
@Test public void testFilterParse() { final UpdateParserMultiple request = new UpdateParserMultiple(); final UpdateMultiQuery update = new UpdateMultiQuery(); try { request.filterParse(update.getFilter()); assertNull("Hint should be null", request.getRequest().getFilter().get(SELECTFILTER.HINT.exactToken())); assertNull("Limit should be null", request.getRequest().getFilter() .get(SELECTFILTER.LIMIT.exactToken())); assertNull("Offset should be null", request.getRequest().getFilter() .get(SELECTFILTER.OFFSET.exactToken())); assertNull("OrderBy should be null", request.getRequest().getFilter() .get(SELECTFILTER.ORDERBY.exactToken())); assertNull("Mult should be null", request.getRequest().getFilter().get(MULTIFILTER.MULT.exactToken())); update.addHintFilter(FILTERARGS.CACHE.exactToken()); request.filterParse(update.getFilter()); assertEquals("Hint should be True", FILTERARGS.CACHE.exactToken(), request.getRequest().getFilter().get(SELECTFILTER.HINT.exactToken()) .get(0).asText()); update.resetHintFilter(); request.filterParse(update.getFilter()); assertNull("Hint should be null", request.getRequest().getFilter().get(SELECTFILTER.HINT.exactToken())); update.setMult(false); request.filterParse(update.getFilter()); assertEquals(false, request.getRequest().getFilter().get(MULTIFILTER.MULT.exactToken()) .asBoolean()); update.setMult(true); request.filterParse(update.getFilter()); assertEquals(true, request.getRequest().getFilter().get(MULTIFILTER.MULT.exactToken()) .asBoolean()); } catch (final InvalidParseOperationException e) { e.printStackTrace(); fail(e.getMessage()); } }
|
### Question:
SelectParserMultiple extends RequestParserMultiple { @Override public void parseQueryOnly(final String query) throws InvalidParseOperationException { super.parseQueryOnly(query); projectionParse(JsonHandler.createObjectNode()); } SelectParserMultiple(); SelectParserMultiple(VarNameAdapter adapter); @Override void parse(final JsonNode request); @Override void parseQueryOnly(final String query); static final FACET getFacetCommand(final JsonNode facet); @Override SelectMultiQuery getRequest(); }### Answer:
@Test public void testParseQueryOnly() throws InvalidParseOperationException { final SelectParserMultiple request = new SelectParserMultiple(); final String ex = "{}"; request.parseQueryOnly(ex); assertNotNull(request); }
|
### Question:
SelectParserMultiple extends RequestParserMultiple { private void internalParseSelect() throws InvalidParseOperationException { projectionParse(rootNode.get(GLOBAL.PROJECTION.exactToken())); facetsParse(rootNode.get(GLOBAL.FACETS.exactToken())); thresholdParse(rootNode.get(GLOBAL.THRESOLD.exactToken())); } SelectParserMultiple(); SelectParserMultiple(VarNameAdapter adapter); @Override void parse(final JsonNode request); @Override void parseQueryOnly(final String query); static final FACET getFacetCommand(final JsonNode facet); @Override SelectMultiQuery getRequest(); }### Answer:
@Test public void testInternalParseSelect() throws InvalidParseOperationException { final SelectParserMultiple request = new SelectParserMultiple(); final String s = "[ [ 'id0' ], { $path : [ 'id1', 'id2'] }, {$mult : false }, {} ]"; request.parse(JsonHandler.getFromString(s)); assertNotNull(request); }
|
### Question:
InsertParserMultiple extends RequestParserMultiple { @Override public InsertMultiQuery getRequest() { return (InsertMultiQuery) request; } InsertParserMultiple(); InsertParserMultiple(VarNameAdapter adapter); @Override void parse(final JsonNode request); @Override String toString(); @Override InsertMultiQuery getRequest(); }### Answer:
@Test public void testFilterParse() { final InsertParserMultiple request = new InsertParserMultiple(); final InsertMultiQuery insert = new InsertMultiQuery(); try { request.filterParse(insert.getFilter()); assertNull("Hint should be null", request.getRequest().getFilter().get(SELECTFILTER.HINT.exactToken())); assertNull("Limit should be null", request.getRequest().getFilter() .get(SELECTFILTER.LIMIT.exactToken())); assertNull("Offset should be null", request.getRequest().getFilter() .get(SELECTFILTER.OFFSET.exactToken())); assertNull("OrderBy should be null", request.getRequest().getFilter() .get(SELECTFILTER.ORDERBY.exactToken())); assertNull("Mult should be null", request.getRequest().getFilter().get(MULTIFILTER.MULT.exactToken())); insert.addHintFilter(FILTERARGS.CACHE.exactToken()); request.filterParse(insert.getFilter()); assertEquals("Hint should be True", FILTERARGS.CACHE.exactToken(), request.getRequest().getFilter().get(SELECTFILTER.HINT.exactToken()) .get(0).asText()); insert.resetHintFilter(); request.filterParse(insert.getFilter()); assertNull("Hint should be null", request.getRequest().getFilter().get(SELECTFILTER.HINT.exactToken())); insert.setMult(false); request.filterParse(insert.getFilter()); assertEquals(false, request.getRequest().getFilter().get(MULTIFILTER.MULT.exactToken()) .asBoolean()); insert.setMult(true); request.filterParse(insert.getFilter()); assertEquals(true, request.getRequest().getFilter().get(MULTIFILTER.MULT.exactToken()) .asBoolean()); } catch (final InvalidParseOperationException e) { e.printStackTrace(); fail(e.getMessage()); } }
|
### Question:
InsertParserMultiple extends RequestParserMultiple { protected void dataParse(final JsonNode rootNode) throws InvalidParseOperationException { if (rootNode == null) { throw new InvalidParseOperationException( "Parse in error for Insert: empty data"); } GlobalDatas.sanityValueCheck(rootNode.toString()); final JsonNode newRootNode = insertAdapter.getFixedVarNameJsonNode(rootNode); try { ((InsertMultiQuery) request).setData(newRootNode); } catch (final Exception e) { throw new InvalidParseOperationException( "Parse in error for Insert: " + rootNode, e); } } InsertParserMultiple(); InsertParserMultiple(VarNameAdapter adapter); @Override void parse(final JsonNode request); @Override String toString(); @Override InsertMultiQuery getRequest(); }### Answer:
@Test public void testDataParse() { final InsertParserMultiple parser = new InsertParserMultiple(); final InsertMultiQuery insert = new InsertMultiQuery(); try { parser.dataParse(insert.getData()); assertEquals("Data should be empty", 0, parser.getRequest().getData().size()); parser.dataParse(data); insert.parseData(data.toString()); assertEquals(parser.getRequest().getFinalInsert().toString(), insert.getFinalInsert().toString()); } catch (final InvalidParseOperationException e) { e.printStackTrace(); fail(e.getMessage()); } JsonNode node; try { node = JsonHandler.getFromString("{#id: \"value\"}"); } catch (final InvalidParseOperationException e) { e.printStackTrace(); fail(e.getMessage()); return; } try { parser.dataParse(node); fail("Should Failed"); } catch (final InvalidParseOperationException e) {} }
|
### Question:
InsertParserMultiple extends RequestParserMultiple { private void internalParseInsert() throws InvalidParseOperationException { dataParse(rootNode.get(GLOBAL.DATA.exactToken())); final JsonNode node = getRequest().getData(); final int nodeDepth = GlobalDatasParser.getJsonNodedepth(node); if (nodeDepth >= GlobalDatas.MAXDEPTH) { throw new InvalidParseOperationException("Node depth exception, value: " + nodeDepth); } } InsertParserMultiple(); InsertParserMultiple(VarNameAdapter adapter); @Override void parse(final JsonNode request); @Override String toString(); @Override InsertMultiQuery getRequest(); }### Answer:
@Test public void testInternalParseInsert() throws InvalidParseOperationException { final InsertParserMultiple request = new InsertParserMultiple(); final String s = "{ $roots: [ 'id0' ], $query: { $path : [ 'id1', 'id2'] }, $filter: {$mult : false }, $data: {} }"; request.parse(JsonHandler.getFromString(s)); assertNotNull(request); }
|
### Question:
DeleteParserMultiple extends RequestParserMultiple { @Override public DeleteMultiQuery getRequest() { return (DeleteMultiQuery) request; } DeleteParserMultiple(); DeleteParserMultiple(VarNameAdapter adapter); @Override void parse(final JsonNode request); @Override String toString(); @Override DeleteMultiQuery getRequest(); }### Answer:
@Test public void testFilterParse() { final DeleteParserMultiple request = new DeleteParserMultiple(); final DeleteMultiQuery delete = new DeleteMultiQuery(); try { request.filterParse(delete.getFilter()); assertNull("Hint should be null", request.getRequest().getFilter().get(SELECTFILTER.HINT.exactToken())); assertNull("Limit should be null", request.getRequest().getFilter() .get(SELECTFILTER.LIMIT.exactToken())); assertNull("Offset should be null", request.getRequest().getFilter() .get(SELECTFILTER.OFFSET.exactToken())); assertNull("OrderBy should be null", request.getRequest().getFilter() .get(SELECTFILTER.ORDERBY.exactToken())); assertNull("Mult should be null", request.getRequest().getFilter().get(MULTIFILTER.MULT.exactToken())); delete.addHintFilter(FILTERARGS.CACHE.exactToken()); request.filterParse(delete.getFilter()); assertEquals("Hint should be True", FILTERARGS.CACHE.exactToken(), request.getRequest().getFilter().get(SELECTFILTER.HINT.exactToken()) .get(0).asText()); delete.resetHintFilter(); request.filterParse(delete.getFilter()); assertNull("Hint should be null", request.getRequest().getFilter().get(SELECTFILTER.HINT.exactToken())); delete.setMult(false); request.filterParse(delete.getFilter()); assertEquals(false, request.getRequest().getFilter().get(MULTIFILTER.MULT.exactToken()) .asBoolean()); delete.setMult(true); request.filterParse(delete.getFilter()); assertEquals(true, request.getRequest().getFilter().get(MULTIFILTER.MULT.exactToken()) .asBoolean()); } catch (final InvalidParseOperationException e) { e.printStackTrace(); fail(e.getMessage()); } }
|
### Question:
EmptyMongoCursor implements MongoCursor<TResult> { public EmptyMongoCursor() { super(); } EmptyMongoCursor(); @Override void close(); @Override boolean hasNext(); @Override TResult next(); @Override TResult tryNext(); @Override ServerCursor getServerCursor(); @Override ServerAddress getServerAddress(); }### Answer:
@Test public void testEmptyMongoCursor() { MongoCursor<Integer> cursor = new EmptyMongoCursor<Integer>(); assertFalse(cursor.hasNext()); assertNull(cursor.next()); assertNull(cursor.getServerAddress()); assertNull(cursor.getServerCursor()); cursor.close(); }
|
### Question:
ElasticsearchUtil { public static String transferJsonToMapping(InputStream is) throws IOException{ final String mapping; try (BufferedReader buffer = new BufferedReader(new InputStreamReader(is))) { mapping = buffer.lines().collect(Collectors.joining("\n")); } return mapping; } static String transferJsonToMapping(InputStream is); }### Answer:
@Test public void test() throws IOException { String mappingTrans = ElasticsearchUtil.transferJsonToMapping(PropertyUtils.class.getResourceAsStream(FILE_JSON)); System.out.println(mappingTrans); System.out.println(mapping); assertEquals(mapping, mappingTrans); }
|
### Question:
ElasticsearchNode { public ElasticsearchNode() { } ElasticsearchNode(); ElasticsearchNode(String hostName, int httpPort); String getHostName(); int getHttpPort(); ElasticsearchNode setHostName(String hostName); ElasticsearchNode setHttpPort(int httpPort); }### Answer:
@Test public void testElasticsearchNode() { final ElasticsearchNode node1 = new ElasticsearchNode(HOST, PORT); assertEquals(HOST, node1.getHostName()); assertEquals(PORT, node1.getHttpPort()); final ElasticsearchNode node2 = new ElasticsearchNode(); assertEquals(HOST, node2.setHostName(HOST).getHostName()); assertEquals(PORT, node2.setHttpPort(PORT).getHttpPort()); }
|
### Question:
StoredInfoResult { public String getId() { return id; } String getStrategy(); StoredInfoResult setStrategy(String strategy); int getNbCopy(); StoredInfoResult setNbCopy(int nbCopy); List<String> getOfferIds(); StoredInfoResult setOfferIds(List<String> offerIds); String getId(); StoredInfoResult setId(String id); String getInfo(); StoredInfoResult setInfo(String info); String getObjectGroupId(); StoredInfoResult setObjectGroupId(String objectGroupId); List<String> getUnitIds(); StoredInfoResult setUnitIds(List<String> unitIds); String getCreationTime(); StoredInfoResult setCreationTime(String creationTime); String getLastAccessTime(); StoredInfoResult setLastAccessTime(String lastAccessTime); String getLastCheckedTime(); StoredInfoResult setLastCheckedTime(String lastCheckedTime); String getLastModifiedTime(); StoredInfoResult setLastModifiedTime(String lastModifiedTime); String getDigestType(); StoredInfoResult setDigestType(String digestType); String getDigest(); StoredInfoResult setDigest(String digest); @Override String toString(); }### Answer:
@Test public void testGetId() throws Exception { storedInfoResult.setId("id"); assertEquals("id", storedInfoResult.getId()); }
|
### Question:
FileStorageProvider implements StorageStrategyProvider, StorageOfferProvider { @Override public StorageStrategy getStorageStrategy(String idStrategy) throws StorageTechnicalException { if (storageStrategies == null) { try { loadReferential(ReferentialType.STRATEGY); } catch (IOException | InvalidParseOperationException exc) { throw new StorageTechnicalException(exc); } } if (storageStrategies.containsKey(idStrategy)) { return storageStrategies.get(idStrategy); } else { throw new StorageTechnicalException("Storage strategy '" + idStrategy + "' invalid"); } } FileStorageProvider(); @Override StorageStrategy getStorageStrategy(String idStrategy); @Override StorageOffer getStorageOffer(String idOffer); @Override StorageOffer getStorageOffer(String idOffer, boolean includeDisabled); @Override Map<String, StorageStrategy> getStorageStrategies(); }### Answer:
@Test public void testGetStorageStrategy() throws Exception { final FileStorageProvider fsProvider = new FileStorageProvider(); final StorageStrategy strategy = fsProvider.getStorageStrategy(VitamConfiguration.getDefaultStrategy()); assertEquals(VitamConfiguration.getDefaultStrategy(), strategy.getId()); final List<OfferReference> offerReferences = strategy.getOffers(); assertNotNull(offerReferences); assertEquals(2, offerReferences.size()); final OfferReference offerReference = offerReferences.get(0); assertEquals("default", offerReference.getId()); }
@Test(expected = StorageException.class) public void testGetStorageStrategy_ForceIoException() throws Exception { final File strategy = PropertiesUtils.findFile("static-strategy.json"); assertNotNull(strategy); strategy.setReadable(false); final FileStorageProvider fsProvider = new FileStorageProvider(); try { fsProvider.getStorageStrategy(null); fail("Expecting storage exception"); } finally { strategy.setReadable(true); } }
|
### Question:
FileStorageProvider implements StorageStrategyProvider, StorageOfferProvider { @Override public Map<String, StorageStrategy> getStorageStrategies() throws StorageTechnicalException { return storageStrategies; } FileStorageProvider(); @Override StorageStrategy getStorageStrategy(String idStrategy); @Override StorageOffer getStorageOffer(String idOffer); @Override StorageOffer getStorageOffer(String idOffer, boolean includeDisabled); @Override Map<String, StorageStrategy> getStorageStrategies(); }### Answer:
@Test public void testGetStorageStrategies() throws Exception { final FileStorageProvider fsProvider = new FileStorageProvider(); Map<String, StorageStrategy> strategies = fsProvider.getStorageStrategies(); assertNotNull(strategies); assertEquals(1, strategies.size()); assertTrue(strategies.containsKey(VitamConfiguration.getDefaultStrategy())); }
|
### Question:
FileStorageProvider implements StorageStrategyProvider, StorageOfferProvider { @Override public StorageOffer getStorageOffer(String idOffer) throws StorageException { return getFilteredStorageOffer(idOffer, false); } FileStorageProvider(); @Override StorageStrategy getStorageStrategy(String idStrategy); @Override StorageOffer getStorageOffer(String idOffer); @Override StorageOffer getStorageOffer(String idOffer, boolean includeDisabled); @Override Map<String, StorageStrategy> getStorageStrategies(); }### Answer:
@Test public void testGetStorageOffer() throws Exception { final FileStorageProvider fsProvider = new FileStorageProvider(); final StorageOffer offer = fsProvider.getStorageOffer(VitamConfiguration.getDefaultStrategy()); assertNotNull(offer); assertEquals("default", offer.getId()); assertEquals("http: assertNotNull(offer.getParameters()); assertEquals("bob", offer.getParameters().get("user")); assertTrue(offer.isEnabled()); }
@Test(expected = StorageException.class) public void testGetStorageOffer_ForceIoException() throws Exception { final File offer = PropertiesUtils.findFile("static-offer.json"); assertNotNull(offer); offer.setReadable(false); final FileStorageProvider fsProvider = new FileStorageProvider(); try { fsProvider.getStorageOffer(null); fail("Expecting storage exception"); } finally { offer.setReadable(true); } }
|
### Question:
StorageStrategyProviderFactory { public static StorageStrategyProvider getDefaultProvider() { return FS_REFERENTIAL; } private StorageStrategyProviderFactory(); static StorageStrategyProvider getDefaultProvider(); }### Answer:
@Test public void testGetProvider() throws Exception { assertNotNull(StorageStrategyProviderFactory.getDefaultProvider()); assertTrue(StorageOfferProviderFactory.getDefaultProvider() instanceof FileStorageProvider); }
|
### Question:
StorageOfferProviderFactory { public static StorageOfferProvider getDefaultProvider() { return FS_REFERENTIAL; } private StorageOfferProviderFactory(); static StorageOfferProvider getDefaultProvider(); }### Answer:
@Test public void testGetDefaultProvider() throws Exception { assertNotNull(StorageOfferProviderFactory.getDefaultProvider()); assertTrue(StorageOfferProviderFactory.getDefaultProvider() instanceof FileStorageProvider); }
@Test public void testGetProvider() throws Exception { StorageOfferProvider provider = StorageOfferProviderFactory.getDefaultProvider(); assertNotNull(provider); assertTrue(provider instanceof FileStorageProvider); StorageOffer disabledOffer = provider.getStorageOffer("inactiveOffer", true); assertFalse(disabledOffer.isEnabled()); assertTrue(disabledOffer.getId().equals("inactiveOffer")); try { provider.getStorageOffer("inactiveOffer", false); fail("Expecting storage exception"); }catch(StorageNotFoundException ex){ } }
|
### Question:
ObjectEntryLargeFileWriter implements LargeFileWriter<ObjectEntry> { @Override public void writeEntry(ObjectEntry entry) throws IOException { objectEntryWriter.write(entry); } ObjectEntryLargeFileWriter(File file); @Override void writeEntry(ObjectEntry entry); @Override void close(); }### Answer:
@Test public void testSingleEntry() throws IOException { File file = tempFolder.newFile(); try (ObjectEntryLargeFileWriter writer = new ObjectEntryLargeFileWriter(file)) { writer.writeEntry(new ObjectEntry().setObjectId("obj1").setSize(1L)); } assertThat(file).hasContent("" + "{\"objectId\":\"obj1\",\"size\":1}\n" + "{}"); }
@Test public void testMultiEntries() throws IOException { File file = tempFolder.newFile(); try (ObjectEntryLargeFileWriter writer = new ObjectEntryLargeFileWriter(file)) { writer.writeEntry(new ObjectEntry().setObjectId("obj1").setSize(1L)); writer.writeEntry(new ObjectEntry().setObjectId("obj2").setSize(2L)); } assertThat(file).hasContent("" + "{\"objectId\":\"obj1\",\"size\":1}\n" + "{\"objectId\":\"obj2\",\"size\":2}\n" + "{}"); }
|
### Question:
OfferDiffService { public boolean isRunning() { OfferDiffProcess offerDiffProcess = lastOfferDiffProcess.get(); return offerDiffProcess != null && offerDiffProcess.isRunning(); } OfferDiffService(StorageDistribution distribution); boolean startOfferDiff(String offer1, String offer2, DataCategory dataCategory); boolean isRunning(); OfferDiffStatus getLastOfferDiffStatus(); }### Answer:
@Test @RunWithCustomExecutor public void isRunningShouldReturnFalseWhenNoProcessStarted() { OfferDiffService instance = new OfferDiffService(distribution); boolean isRunning = instance.isRunning(); assertThat(isRunning).isFalse(); }
|
### Question:
OfferDiffService { public OfferDiffStatus getLastOfferDiffStatus() { OfferDiffProcess offerDiffProcess = lastOfferDiffProcess.get(); if (offerDiffProcess == null) { return null; } else { return offerDiffProcess.getOfferDiffStatus(); } } OfferDiffService(StorageDistribution distribution); boolean startOfferDiff(String offer1, String offer2, DataCategory dataCategory); boolean isRunning(); OfferDiffStatus getLastOfferDiffStatus(); }### Answer:
@Test @RunWithCustomExecutor public void getLastDiffStatusShouldNullWhenNoProcessStarted() { OfferDiffService instance = spy(new OfferDiffService(distribution)); OfferDiffStatus status = instance.getLastOfferDiffStatus(); assertThat(status).isNull(); }
|
### Question:
OfferDiffService { void runDiffAsync(OfferDiffProcess offerDiffProcess) { int tenantId = VitamThreadUtils.getVitamSession().getTenantId(); String requestId = VitamThreadUtils.getVitamSession().getRequestId(); VitamThreadPoolExecutor.getDefaultExecutor().execute( () -> { try { VitamThreadUtils.getVitamSession().setTenantId(tenantId); VitamThreadUtils.getVitamSession().setRequestId(requestId); offerDiffProcess.run(); } catch (Exception e) { LOGGER.error("An error occurred during offer diff process execution", e); } } ); } OfferDiffService(StorageDistribution distribution); boolean startOfferDiff(String offer1, String offer2, DataCategory dataCategory); boolean isRunning(); OfferDiffStatus getLastOfferDiffStatus(); }### Answer:
@Test @RunWithCustomExecutor public void runDiffAsyncShouldStartDiff() throws Exception { CountDownLatch countDownLatch = new CountDownLatch(1); OfferDiffProcess offerDiffProcess = mock(OfferDiffProcess.class); doAnswer((args) -> { countDownLatch.countDown(); return null; }).when(offerDiffProcess).run(); OfferDiffService instance = new OfferDiffService(distribution); instance.runDiffAsync(offerDiffProcess); countDownLatch.await(1, TimeUnit.MINUTES); verify(offerDiffProcess).run(); }
|
### Question:
StorageLogAppender implements VitamAutoCloseable { public void append(StorageLogStructure parameters) throws IOException { writer.append(JsonHandler.unprettyPrint(parameters.getMapParameters())); writer.append(lineSeparator); writer.flush(); } StorageLogAppender(Path filePath); void append(StorageLogStructure parameters); @Override void close(); }### Answer:
@Test() public void appendTest() throws IOException { StorageLogbookParameters params1 = buildStorageParameters("params1"); StorageLogbookParameters params2 = buildStorageParameters("params2"); StorageLogbookParameters params3 = buildStorageParameters("params3"); Path filePath = folder.getRoot().toPath().resolve(GUIDFactory.newGUID().toString()); try (StorageLogAppender instance = new StorageLogAppender(filePath)) { instance.append(params1); instance.append(params2); instance.append(params3); } assertThat(filePath).exists(); assertThat(Files.readAllBytes(filePath)) .isEqualTo("{\"objectIdentifier\":\"params1\"}\n{\"objectIdentifier\":\"params2\"}\n{\"objectIdentifier\":\"params3\"}\n".getBytes()); }
|
### Question:
StorageLogbookParameters implements StorageLogStructure { static StorageLogbookParameters buildCreateLogParameters( Map<StorageLogbookParameterName, String> mapParameters) { checkMandatoryParameters(mapParameters, mandatoryParametersForCreate); return new StorageLogbookParameters(mapParameters); } private StorageLogbookParameters(Map<StorageLogbookParameterName, String> mapParameters); static StorageLogbookParameters createLogParameters(String objectIdentifier,
String dataCategory, String digest, String digestAlgorithm, String size, String agentIdentifiers,
String agentIdentifierRequester,
StorageLogbookOutcome outcome); static StorageLogbookParameters buildDeleteLogParameters(
Map<StorageLogbookParameterName, String> mapParameters); @JsonIgnore LocalDateTime getEventDateTime(); @JsonIgnore StorageLogbookParameters setStatus(StorageLogbookOutcome outcome); @JsonIgnore StorageLogbookOutcome getStatus(); @JsonIgnore Map<StorageLogbookParameterName, String> getMapParameters(); }### Answer:
@Test(expected = IllegalArgumentException.class) public void getEmptyParametersTest() { StorageLogbookParameters.buildCreateLogParameters(new HashMap<>()); }
|
### Question:
TimeoutStopwatch { public long getRemainingDelayInMilliseconds() { return Math.max(0L, totalTimeoutInMilliseconds - stopWatch.getTime()); } TimeoutStopwatch(long totalTimeoutInMilliseconds); long getRemainingDelayInMilliseconds(); }### Answer:
@Test public void TestDecreasingTimeout() throws Exception { TimeoutStopwatch timeoutStopwatch = new TimeoutStopwatch(1000); long remaining1 = timeoutStopwatch.getRemainingDelayInMilliseconds(); Thread.sleep(100); long remaining2 = timeoutStopwatch.getRemainingDelayInMilliseconds(); assertThat(remaining1).isBetween(0L, 5000L); assertThat(remaining2).isBetween(0L, 5000L); assertThat(remaining2).isLessThanOrEqualTo(remaining1 - 100L); }
|
### Question:
FileDriverMapper implements DriverMapper { public static FileDriverMapper getInstance() throws StorageDriverMapperException { if (configuration == null) { throw new StorageDriverMapperException(VitamCodeHelper.getLogMessage(VitamCode.STORAGE_DRIVER_MAPPING_INITIALIZE)); } return INSTANCE; } private FileDriverMapper(); static FileDriverMapper getInstance(); @Override List<String> getOffersFor(String driverName); @Override void addOfferTo(String offerId, String driverName); @Override void addOffersTo(List<String> offersIdsToAdd, String driverName); @Override void removeOfferTo(String offerId, String driverName); @Override void removeOffersTo(List<String> offersIdsToRemove, String driverName); }### Answer:
@Test public void configurationOkTest() { FileDriverMapper fileDriverMapper = null; try { fileDriverMapper = FileDriverMapper.getInstance(); } catch (final VitamException exc) { fail("should not raise an exception !"); } assertNotNull(fileDriverMapper); }
|
### Question:
DriverManagerConfiguration { public String getDriverLocation() { return driverLocation; } DriverManagerConfiguration(); DriverManagerConfiguration(String driverLocation); String getDriverLocation(); void setDriverLocation(String driverLocation); }### Answer:
@Test public void constructorTest() { final DriverManagerConfiguration conf = new DriverManagerConfiguration(DRIVER_LOCATION); assertNotNull(conf); assertEquals(DRIVER_LOCATION, conf.getDriverLocation()); }
|
### Question:
DriverManager { public static Driver getDriverFor(String offerId) throws StorageDriverNotFoundException { for (String driverName : drivers.keySet()) { final Driver driver = drivers.get(driverName); if (driver.hasOffer(offerId)) { return driver; } } LOGGER.error("No suitable driver for offer ID : " + offerId); throw new StorageDriverNotFoundException("No suitable driver for offer ID : " + offerId); } private DriverManager(); static Driver addDriver(Driver driver); static void changeDriverMapper(DriverMapper newMapper); static void addOfferToDriver(String name, String offerId); static void addOffersToDriver(String name, List<String> offerIds); static void removeOffer(String offerId); static Driver getDriverFor(String offerId); }### Answer:
@Test(expected = StorageDriverNotFoundException.class) public void getUnexistingDriver() throws Exception { DriverManager.getDriverFor("test"); }
|
### Question:
DriverManager { public static void changeDriverMapper(DriverMapper newMapper) { ParametersChecker.checkParameter("The mapper cannot be null", newMapper); mapper = Optional.of(newMapper); } private DriverManager(); static Driver addDriver(Driver driver); static void changeDriverMapper(DriverMapper newMapper); static void addOfferToDriver(String name, String offerId); static void addOffersToDriver(String name, List<String> offerIds); static void removeOffer(String offerId); static Driver getDriverFor(String offerId); }### Answer:
@Test(expected = IllegalArgumentException.class) public void changeDriverMapperNullTest() throws Exception { DriverManager.changeDriverMapper(null); }
@Test public void changeDriverMapperTest() { DriverManager.changeDriverMapper(new FakeDriverMapper()); }
|
### Question:
OfferSyncService implements AutoCloseable { public boolean isRunning() { OfferSyncProcess offerSyncProcess = lastOfferSyncService.get(); return offerSyncProcess != null && offerSyncProcess.isRunning(); } OfferSyncService(StorageDistribution distribution, StorageConfiguration storageConfiguration); @VisibleForTesting OfferSyncService(
RestoreOfferBackupService restoreOfferBackupService,
StorageDistribution distribution, int bulkSize, int offerSyncThreadPoolSize, int offerSyncNumberOfRetries,
int offerSyncFirstAttemptWaitingTime, int offerSyncWaitingTime); boolean startSynchronization(String sourceOffer, String targetOffer, String strategyId,
List<OfferPartialSyncItem> items); boolean startSynchronization(String sourceOffer, String targetOffer, String strategyId,
DataCategory dataCategory, Long offset); boolean isRunning(); OfferSyncStatus getLastSynchronizationStatus(); @VisibleForTesting ExecutorService getExecutor(); @Override void close(); }### Answer:
@Test @RunWithCustomExecutor public void isRunningShouldReturnFalseWhenNoProcessStarted() { OfferSyncService instance = spy(new OfferSyncService(restoreOfferBackupService, distribution, 1000, 16, 1, 1, 1)); boolean isRunning = instance.isRunning(); assertThat(isRunning).isFalse(); }
|
### Question:
OfferSyncService implements AutoCloseable { public OfferSyncStatus getLastSynchronizationStatus() { OfferSyncProcess offerSyncProcess = lastOfferSyncService.get(); if (offerSyncProcess == null) { return null; } else { return offerSyncProcess.getOfferSyncStatus(); } } OfferSyncService(StorageDistribution distribution, StorageConfiguration storageConfiguration); @VisibleForTesting OfferSyncService(
RestoreOfferBackupService restoreOfferBackupService,
StorageDistribution distribution, int bulkSize, int offerSyncThreadPoolSize, int offerSyncNumberOfRetries,
int offerSyncFirstAttemptWaitingTime, int offerSyncWaitingTime); boolean startSynchronization(String sourceOffer, String targetOffer, String strategyId,
List<OfferPartialSyncItem> items); boolean startSynchronization(String sourceOffer, String targetOffer, String strategyId,
DataCategory dataCategory, Long offset); boolean isRunning(); OfferSyncStatus getLastSynchronizationStatus(); @VisibleForTesting ExecutorService getExecutor(); @Override void close(); }### Answer:
@Test @RunWithCustomExecutor public void getLastSynchronizationStatusShouldNullWhenNoProcessStarted() throws Exception { try (OfferSyncService instance = spy(new OfferSyncService(restoreOfferBackupService, distribution, 1000, 16, 1, 1, 1))) { OfferSyncStatus status = instance.getLastSynchronizationStatus(); assertThat(status).isNull(); } }
|
### Question:
OfferLogHelper { public static Iterator<OfferLog> getListing(StorageClientFactory storageClientFactory, String strategy, DataCategory dataCategory, Long offset, Order order, int chunkSize, Integer limit) { int actualChunkSize = limit == null ? chunkSize : Math.min(chunkSize, limit); Iterator<OfferLog> offerLogIterator = new StorageClientOfferLogIterator( storageClientFactory, strategy, order, dataCategory, actualChunkSize, offset); if (limit != null) { offerLogIterator = IteratorUtils.boundedIterator(offerLogIterator, limit); } return offerLogIterator; } static Iterator<OfferLog> getListing(StorageClientFactory storageClientFactory, String strategy,
DataCategory dataCategory, Long offset, Order order, int chunkSize, Integer limit); }### Answer:
@Test public void testOffsetAndLimitV2OfferLogs() throws Exception { List<Integer> filesOffsets = Arrays.asList(10, 20, 30, 40, 50, 60, 70, 80, 90, 100); givenOfferLogOffsets(filesOffsets); Iterator<OfferLog> offerLogIterator = OfferLogHelper.getListing(storageClientFactory, VitamConfiguration.getDefaultStrategy(), DataCategory.UNIT, 20L, Order.ASC, 5, 7); assertThat(offerLogIterator) .extracting(OfferLog::getFileName) .containsExactly("file20", "file30", "file40", "file50", "file60", "file70", "file80"); verify(storageClient, times(2)) .getOfferLogs(eq(VitamConfiguration.getDefaultStrategy()), eq(DataCategory.UNIT), anyLong(), anyInt(), eq(Order.ASC)); }
|
### Question:
StorageDriverException extends Exception { public String getDriverInfo() { return driverInfo; } StorageDriverException(String driverInfos, String message, boolean shouldRetry); StorageDriverException(String driverInfos, String message, boolean shouldRetry, Throwable cause); StorageDriverException(String driverInfos, boolean shouldRetry, Throwable cause); String getDriverInfo(); boolean isShouldRetry(); }### Answer:
@Test public void testGetDriverInfo() throws Exception { StorageDriverException exc = new StorageDriverException("drivername", "message", true); exc = new StorageDriverException("drivername", true, exc); exc = new StorageDriverException("drivername","message", true, exc); assertEquals("drivername", exc.getDriverInfo()); }
|
### Question:
StoragePutRequest extends StorageObjectRequest { public String getDigestAlgorithm() { return digestAlgorithm; } StoragePutRequest(Integer tenantId, String type, String guid, String digestAlgorithm,
InputStream dataStream); String getDigestAlgorithm(); InputStream getDataStream(); long getSize(); void setSize(long size); @Override String toString(); }### Answer:
@Test public void testGetDigestAlgorithm() throws Exception { assertEquals("digest", storagePutRequest.getDigestAlgorithm()); }
|
### Question:
StoragePutRequest extends StorageObjectRequest { public InputStream getDataStream() { return dataStream; } StoragePutRequest(Integer tenantId, String type, String guid, String digestAlgorithm,
InputStream dataStream); String getDigestAlgorithm(); InputStream getDataStream(); long getSize(); void setSize(long size); @Override String toString(); }### Answer:
@Test public void testGetDataStream() throws Exception { assertEquals(BYTES, storagePutRequest.getDataStream()); }
|
### Question:
StorageGetResult extends StorageObjectResult { public Response getObject() { return object; } StorageGetResult(Integer tenantId, String type, String guid, Response object); Response getObject(); }### Answer:
@Test public void testGetResultStream() { assertEquals(BYTES, storageGetResult.getObject().getEntity()); }
|
### Question:
StorageRequest { public Integer getTenantId() { return tenantId; } StorageRequest(Integer tenantId, String type); Integer getTenantId(); String getType(); @Override String toString(); }### Answer:
@Test public void testGetTenantId() throws Exception { assertEquals(TENANT_ID, storageRequest.getTenantId()); }
|
### Question:
StorageRequest { public String getType() { return type; } StorageRequest(Integer tenantId, String type); Integer getTenantId(); String getType(); @Override String toString(); }### Answer:
@Test public void testGetType() throws Exception { assertEquals("object", storageRequest.getType()); }
|
### Question:
StorageCapacityResult extends StorageResult { public long getUsableSpace() { return usableSpace; } StorageCapacityResult(); StorageCapacityResult(Integer tenantId, long usableSpace); long getUsableSpace(); }### Answer:
@Test public void testGetUsableSpace() { assertEquals(1000, storageCapacityResult.getUsableSpace()); }
|
### Question:
StorageObjectResult extends StorageResult { public String getGuid() { return guid; } StorageObjectResult(Integer tenantId, String type, String guid); String getGuid(); }### Answer:
@Test public void testGetGuid() throws Exception { assertEquals("guid", storageObjectResult.getGuid()); }
|
### Question:
StorageRemoveResult extends StorageObjectResult { public boolean isObjectDeleted() { return objectDeleted; } StorageRemoveResult(Integer tenantId, String type, String guid,
boolean objectDeleted); boolean isObjectDeleted(); }### Answer:
@Test public void testIsObjectDeleted() throws Exception { assertTrue(storageRemoveResult.isObjectDeleted()); }
|
### Question:
StorageObjectRequest extends StorageRequest { public String getGuid() { return guid; } StorageObjectRequest(Integer tenantId, String type, String guid); StorageObjectRequest(Integer tenantId,String guid); String getGuid(); @Override String toString(); }### Answer:
@Test public void testGetGuid() throws Exception { assertEquals("guid", storageObjectRequest.getGuid()); }
|
### Question:
StoragePutResult extends StorageObjectResult { public String getDistantObjectId() { return distantObjectId; } StoragePutResult(Integer tenantId, String type, String guid, String distantObjectId, String digestHashBase16,
long objectSize); String getDistantObjectId(); String getDigestHashBase16(); long getObjectSize(); @Override String toString(); }### Answer:
@Test public void testGetSetDistantObjectId() { assertEquals("doi", storagePutResult.getDistantObjectId()); }
|
### Question:
StoragePutResult extends StorageObjectResult { public String getDigestHashBase16() { return digestHashBase16; } StoragePutResult(Integer tenantId, String type, String guid, String distantObjectId, String digestHashBase16,
long objectSize); String getDistantObjectId(); String getDigestHashBase16(); long getObjectSize(); @Override String toString(); }### Answer:
@Test public void testGetDigestHashBase16() { assertEquals("dhb16", storagePutResult.getDigestHashBase16()); }
|
### Question:
StoragePutResult extends StorageObjectResult { public long getObjectSize() { return objectSize; } StoragePutResult(Integer tenantId, String type, String guid, String distantObjectId, String digestHashBase16,
long objectSize); String getDistantObjectId(); String getDigestHashBase16(); long getObjectSize(); @Override String toString(); }### Answer:
@Test public void testGetSize() { assertEquals(10, storagePutResult.getObjectSize()); }
|
### Question:
StorageResult { public Integer getTenantId() { return tenantId; } StorageResult(Integer tenantId, String type); Integer getTenantId(); String getType(); }### Answer:
@Test public void testGetTenantId() throws Exception { assertEquals(TENANT_ID, storageResult.getTenantId()); }
|
### Question:
StorageResult { public String getType() { return type; } StorageResult(Integer tenantId, String type); Integer getTenantId(); String getType(); }### Answer:
@Test public void testGetType() throws Exception { assertEquals("object", storageResult.getType()); }
|
### Question:
TarFileDigestVerifier { public void finalizeChecks() throws ObjectReferentialException { for (String containerName : this.entriesToCheckByContainerName.keySet()) { Collection<EntryToCheck> entriesToCheck = entriesToCheckByContainerName.get(containerName); if (!entriesToCheck.isEmpty()) { processBulk(containerName, entriesToCheck); } } } TarFileDigestVerifier(
ObjectReferentialRepository objectReferentialRepository, int bulkSize); void addDigestToCheck(String tarEntryName, String digestValue); void finalizeChecks(); }### Answer:
@Test public void testNoEntries() throws Exception { TarFileDigestVerifier tarFileDigestVerifier = new TarFileDigestVerifier(objectReferentialRepository, 10); tarFileDigestVerifier.finalizeChecks(); verifyNoMoreInteractions(objectReferentialRepository); }
|
### Question:
ArchiveReferentialRepository { public void insert(TapeArchiveReferentialEntity tapeArchiveReferentialEntity) throws ArchiveReferentialException { try { collection.insertOne(toBson(tapeArchiveReferentialEntity)); } catch (MongoException ex) { throw new ArchiveReferentialException( "Could not insert or update archive referential for id " + tapeArchiveReferentialEntity.getArchiveId(), ex); } } ArchiveReferentialRepository(MongoCollection<Document> collection); void insert(TapeArchiveReferentialEntity tapeArchiveReferentialEntity); Optional<TapeArchiveReferentialEntity> find(String archiveId); void updateLocationToReadyOnDisk(String archiveId, long size, String digest); void updateLocationToOnTape(String archiveId,
TapeLibraryOnTapeArchiveStorageLocation onTapeTarStorageLocation); }### Answer:
@Test public void insertExistingTar() throws Exception { TapeArchiveReferentialEntity tapeArchiveReferentialEntity = new TapeArchiveReferentialEntity( "tarId1", new TapeLibraryBuildingOnDiskArchiveStorageLocation(), 10L, "digest1", "date1" ); archiveReferentialRepository.insert(tapeArchiveReferentialEntity); assertThatThrownBy(() -> archiveReferentialRepository.insert(tapeArchiveReferentialEntity)) .isInstanceOf(ArchiveReferentialException.class); }
|
### Question:
ArchiveReferentialRepository { public Optional<TapeArchiveReferentialEntity> find(String archiveId) throws ArchiveReferentialException { Document document; try { document = collection.find( Filters.eq(TapeArchiveReferentialEntity.ID, archiveId)) .first(); } catch (MongoException ex) { throw new ArchiveReferentialException("Could not find storage location by id " + archiveId, ex); } if (document == null) { return Optional.empty(); } try { return Optional.of(fromBson(document, TapeArchiveReferentialEntity.class)); } catch (InvalidParseOperationException e) { throw new IllegalStateException("Could not parse document from DB " + BsonHelper.stringify(document), e); } } ArchiveReferentialRepository(MongoCollection<Document> collection); void insert(TapeArchiveReferentialEntity tapeArchiveReferentialEntity); Optional<TapeArchiveReferentialEntity> find(String archiveId); void updateLocationToReadyOnDisk(String archiveId, long size, String digest); void updateLocationToOnTape(String archiveId,
TapeLibraryOnTapeArchiveStorageLocation onTapeTarStorageLocation); }### Answer:
@Test public void findNonExisting() throws Exception { Optional<TapeArchiveReferentialEntity> tarReferentialEntity = archiveReferentialRepository.find("tarId1"); assertThat(tarReferentialEntity.isPresent()).isFalse(); }
|
### Question:
ArchiveReferentialRepository { public void updateLocationToReadyOnDisk(String archiveId, long size, String digest) throws ArchiveReferentialException { try { UpdateResult updateResult = collection.updateOne( Filters.eq(TapeArchiveReferentialEntity.ID, archiveId), Updates.combine( Updates.set(TapeArchiveReferentialEntity.LOCATION, toBson(new TapeLibraryReadyOnDiskArchiveStorageLocation())), Updates.set(TapeArchiveReferentialEntity.SIZE, size), Updates.set(TapeArchiveReferentialEntity.DIGEST, digest), Updates.set(TapeArchiveReferentialEntity.LAST_UPDATE_DATE, LocalDateUtil.now().toString()) ), new UpdateOptions().upsert(false) ); if (updateResult.getMatchedCount() != 1) { throw new ArchiveReferentialException("Could not update storage location for " + archiveId + ". No such archiveId"); } } catch (MongoException ex) { throw new ArchiveReferentialException("Could not update storage location for " + archiveId, ex); } } ArchiveReferentialRepository(MongoCollection<Document> collection); void insert(TapeArchiveReferentialEntity tapeArchiveReferentialEntity); Optional<TapeArchiveReferentialEntity> find(String archiveId); void updateLocationToReadyOnDisk(String archiveId, long size, String digest); void updateLocationToOnTape(String archiveId,
TapeLibraryOnTapeArchiveStorageLocation onTapeTarStorageLocation); }### Answer:
@Test public void updateLocationToReadyOnDiskNonExisting() throws Exception { assertThatThrownBy(() -> archiveReferentialRepository.updateLocationToReadyOnDisk("tarId1", 10L, "digest1")) .isInstanceOf(ArchiveReferentialException.class); }
|
### Question:
ArchiveReferentialRepository { public void updateLocationToOnTape(String archiveId, TapeLibraryOnTapeArchiveStorageLocation onTapeTarStorageLocation) throws ArchiveReferentialException { try { UpdateResult updateResult = collection.updateOne( Filters.eq(TapeArchiveReferentialEntity.ID, archiveId), Updates.combine( Updates.set(TapeArchiveReferentialEntity.LOCATION, toBson(onTapeTarStorageLocation)), Updates.set(TapeArchiveReferentialEntity.LAST_UPDATE_DATE, LocalDateUtil.now().toString()) ), new UpdateOptions().upsert(false) ); if (updateResult.getMatchedCount() != 1) { throw new ArchiveReferentialException("Could not update storage location for " + archiveId + ". No such archiveId"); } } catch (MongoException ex) { throw new ArchiveReferentialException("Could not update storage location for " + archiveId, ex); } } ArchiveReferentialRepository(MongoCollection<Document> collection); void insert(TapeArchiveReferentialEntity tapeArchiveReferentialEntity); Optional<TapeArchiveReferentialEntity> find(String archiveId); void updateLocationToReadyOnDisk(String archiveId, long size, String digest); void updateLocationToOnTape(String archiveId,
TapeLibraryOnTapeArchiveStorageLocation onTapeTarStorageLocation); }### Answer:
@Test public void updateLocationToOnTapeNonExisting() throws Exception { assertThatThrownBy( () -> archiveReferentialRepository.updateLocationToOnTape("tarId1", new TapeLibraryOnTapeArchiveStorageLocation("tapeCode", 12))) .isInstanceOf(ArchiveReferentialException.class); }
|
### Question:
BucketTopologyHelper { public String getFileBucketFromContainerName(String containerName) { int tenant = parseTenantFromContainerName(containerName); DataCategory dataCategory = parseDataCategoryFromContainerName(containerName); return this.containerToFileBucketMap.get(ImmutablePair.of(tenant, dataCategory)); } BucketTopologyHelper(TapeLibraryTopologyConfiguration configuration); static String getFileBucketId(String bucket, String fileBucket); String getFileBucketFromContainerName(String containerName); String getBucketFromFileBucket(String fileBucket); Set<String> listFileBuckets(); Set<String> listContainerNames(String fileBucketId); Integer getTarBufferingTimeoutInMinutes(String bucketId); static final String DEFAULT; static final String BACKUP_BUCKET; static final String BACKUP_FILE_BUCKET; }### Answer:
@Test public void getFileBucketFromContainerName() throws Exception { BucketTopologyHelper bucketTopologyHelper = loadTopology("topology-test.conf"); assertThat(bucketTopologyHelper.getFileBucketFromContainerName("0_unit")).isEqualTo("test-metadata"); assertThat(bucketTopologyHelper.getFileBucketFromContainerName("1_object")).isEqualTo("admin-objects"); assertThat(bucketTopologyHelper.getFileBucketFromContainerName("2_report")).isEqualTo("prod-default"); }
@Test public void getFileBucketFromContainerNameWithExplicitFileBucketConf() throws Exception { BucketTopologyHelper bucketTopologyHelper = loadTopology("topology-test-explicit-file-buckets.conf"); assertThat(bucketTopologyHelper.getFileBucketFromContainerName("0_unit")).isEqualTo("test-metadata"); assertThat(bucketTopologyHelper.getFileBucketFromContainerName("1_object")).isEqualTo("admin-objects"); assertThat(bucketTopologyHelper.getFileBucketFromContainerName("2_report")).isEqualTo("prod-default"); }
|
### Question:
BucketTopologyHelper { public String getBucketFromFileBucket(String fileBucket) { if (BACKUP_FILE_BUCKET.equals(fileBucket)) { return BACKUP_BUCKET; } return this.fileBucketToBucketMap.get(fileBucket); } BucketTopologyHelper(TapeLibraryTopologyConfiguration configuration); static String getFileBucketId(String bucket, String fileBucket); String getFileBucketFromContainerName(String containerName); String getBucketFromFileBucket(String fileBucket); Set<String> listFileBuckets(); Set<String> listContainerNames(String fileBucketId); Integer getTarBufferingTimeoutInMinutes(String bucketId); static final String DEFAULT; static final String BACKUP_BUCKET; static final String BACKUP_FILE_BUCKET; }### Answer:
@Test public void getBucketFromFileBucket() throws Exception { BucketTopologyHelper bucketTopologyHelper = loadTopology("topology-test.conf"); assertThat(bucketTopologyHelper.getBucketFromFileBucket("test-metadata")).isEqualTo("test"); assertThat(bucketTopologyHelper.getBucketFromFileBucket("admin-objects")).isEqualTo("admin"); assertThat(bucketTopologyHelper.getBucketFromFileBucket("prod-default")).isEqualTo("prod"); }
|
### Question:
BucketTopologyHelper { public Set<String> listFileBuckets() { return new HashSet<>(this.containerToFileBucketMap.values()); } BucketTopologyHelper(TapeLibraryTopologyConfiguration configuration); static String getFileBucketId(String bucket, String fileBucket); String getFileBucketFromContainerName(String containerName); String getBucketFromFileBucket(String fileBucket); Set<String> listFileBuckets(); Set<String> listContainerNames(String fileBucketId); Integer getTarBufferingTimeoutInMinutes(String bucketId); static final String DEFAULT; static final String BACKUP_BUCKET; static final String BACKUP_FILE_BUCKET; }### Answer:
@Test public void listFileBuckets() throws Exception { BucketTopologyHelper bucketTopologyHelper = loadTopology("topology-test.conf"); assertThat(bucketTopologyHelper.listFileBuckets()).containsExactlyInAnyOrder( "test-metadata", "test-objects", "test-default", "admin-metadata", "admin-objects", "admin-default", "prod-metadata", "prod-objects", "prod-default"); }
|
### Question:
BucketTopologyHelper { public Set<String> listContainerNames(String fileBucketId) { return this.containerToFileBucketMap.entrySet().stream() .filter(entry -> entry.getValue().equals(fileBucketId)) .map(entry -> ContainerUtils .buildContainerName(entry.getKey().getRight(), entry.getKey().getLeft().toString())) .collect(Collectors.toSet()); } BucketTopologyHelper(TapeLibraryTopologyConfiguration configuration); static String getFileBucketId(String bucket, String fileBucket); String getFileBucketFromContainerName(String containerName); String getBucketFromFileBucket(String fileBucket); Set<String> listFileBuckets(); Set<String> listContainerNames(String fileBucketId); Integer getTarBufferingTimeoutInMinutes(String bucketId); static final String DEFAULT; static final String BACKUP_BUCKET; static final String BACKUP_FILE_BUCKET; }### Answer:
@Test public void listContainerNames() throws Exception { BucketTopologyHelper bucketTopologyHelper = loadTopology("topology-test.conf"); assertThat(bucketTopologyHelper.listContainerNames("admin-metadata")).containsExactlyInAnyOrder( "1_unit", "1_objectGroup"); assertThat(bucketTopologyHelper.listContainerNames("prod-default")).isEqualTo( Streams.concat( Arrays.stream(DataCategory.values()) .filter( dataCategory -> !Arrays.asList(DataCategory.UNIT, DataCategory.OBJECTGROUP, DataCategory.OBJECT) .contains(dataCategory)) .map(dataCategory -> "2_" + dataCategory.getFolder()), Arrays.stream(DataCategory.values()) .filter( dataCategory -> !Arrays.asList(DataCategory.UNIT, DataCategory.OBJECTGROUP, DataCategory.OBJECT) .contains(dataCategory)) .map(dataCategory -> "3_" + dataCategory.getFolder()) ).collect(Collectors.toSet()) ); }
|
### Question:
BucketTopologyHelper { public Integer getTarBufferingTimeoutInMinutes(String bucketId) { return tarBufferingTimeoutInMinutesByBucketId.get(bucketId); } BucketTopologyHelper(TapeLibraryTopologyConfiguration configuration); static String getFileBucketId(String bucket, String fileBucket); String getFileBucketFromContainerName(String containerName); String getBucketFromFileBucket(String fileBucket); Set<String> listFileBuckets(); Set<String> listContainerNames(String fileBucketId); Integer getTarBufferingTimeoutInMinutes(String bucketId); static final String DEFAULT; static final String BACKUP_BUCKET; static final String BACKUP_FILE_BUCKET; }### Answer:
@Test public void getTarBufferingTimeoutInMinutes() throws Exception { BucketTopologyHelper bucketTopologyHelper = loadTopology("topology-test.conf"); assertThat(bucketTopologyHelper.getTarBufferingTimeoutInMinutes("test")).isEqualTo(1); assertThat(bucketTopologyHelper.getTarBufferingTimeoutInMinutes("admin")).isEqualTo(10); assertThat(bucketTopologyHelper.getTarBufferingTimeoutInMinutes("prod")).isEqualTo(60); }
|
### Question:
TapeLibraryContentAddressableStorage implements ContentAddressableStorage { @Override public void createContainer(String containerName) { } TapeLibraryContentAddressableStorage(
BasicFileStorage basicFileStorage,
ObjectReferentialRepository objectReferentialRepository,
ArchiveReferentialRepository archiveReferentialRepository,
ReadRequestReferentialRepository readRequestReferentialRepository,
FileBucketTarCreatorManager fileBucketTarCreatorManager,
QueueRepository readWriteQueue, TapeCatalogService tapeCatalogService,
String outputTarStorageFolder,
ArchiveOutputRetentionPolicy archiveOutputRetentionPolicy); @Override void createContainer(String containerName); @Override boolean isExistingContainer(String containerName); @Override String putObject(String containerName, String objectName, InputStream stream, DigestType digestType,
Long size); @Override ObjectContent getObject(String containerName, String objectName); @Override String createReadOrderRequest(String containerName, List<String> objectsIds); @Override void removeReadOrderRequest(String readRequestID); @Override void deleteObject(String containerName, String objectName); @Override boolean isExistingObject(String containerName, String objectName); @Override String getObjectDigest(String containerName, String objectName, DigestType algo, boolean noCache); @Override ContainerInformation getContainerInformation(String containerName); @Override MetadatasObject getObjectMetadata(String containerName, String objectName, boolean noCache); @Override void listContainer(String containerName, ObjectListingListener objectListingListener); @Override void close(); }### Answer:
@Test public void createContainer() { tapeLibraryContentAddressableStorage.createContainer("container"); Mockito.verifyNoMoreInteractions(basicFileStorage, objectReferentialRepository, archiveReferentialRepository, fileBucketTarCreatorManager, readWriteQueueRepository, tapeCatalogService); }
|
### Question:
TapeLibraryContentAddressableStorage implements ContentAddressableStorage { @Override public boolean isExistingContainer(String containerName) { return true; } TapeLibraryContentAddressableStorage(
BasicFileStorage basicFileStorage,
ObjectReferentialRepository objectReferentialRepository,
ArchiveReferentialRepository archiveReferentialRepository,
ReadRequestReferentialRepository readRequestReferentialRepository,
FileBucketTarCreatorManager fileBucketTarCreatorManager,
QueueRepository readWriteQueue, TapeCatalogService tapeCatalogService,
String outputTarStorageFolder,
ArchiveOutputRetentionPolicy archiveOutputRetentionPolicy); @Override void createContainer(String containerName); @Override boolean isExistingContainer(String containerName); @Override String putObject(String containerName, String objectName, InputStream stream, DigestType digestType,
Long size); @Override ObjectContent getObject(String containerName, String objectName); @Override String createReadOrderRequest(String containerName, List<String> objectsIds); @Override void removeReadOrderRequest(String readRequestID); @Override void deleteObject(String containerName, String objectName); @Override boolean isExistingObject(String containerName, String objectName); @Override String getObjectDigest(String containerName, String objectName, DigestType algo, boolean noCache); @Override ContainerInformation getContainerInformation(String containerName); @Override MetadatasObject getObjectMetadata(String containerName, String objectName, boolean noCache); @Override void listContainer(String containerName, ObjectListingListener objectListingListener); @Override void close(); }### Answer:
@Test public void isExistingContainer() { boolean existingContainer = tapeLibraryContentAddressableStorage.isExistingContainer("container"); assertThat(existingContainer).isTrue(); Mockito.verifyNoMoreInteractions(basicFileStorage, objectReferentialRepository, archiveReferentialRepository, fileBucketTarCreatorManager, readWriteQueueRepository, tapeCatalogService); }
|
### Question:
TapeLibraryContentAddressableStorage implements ContentAddressableStorage { @Override public ContainerInformation getContainerInformation(String containerName) { LOGGER.debug(String.format("Get information of container %s", containerName)); ParametersChecker.checkParameter(ErrorMessage.CONTAINER_NAME_IS_A_MANDATORY_PARAMETER.getMessage(), containerName); final ContainerInformation containerInformation = new ContainerInformation(); containerInformation.setUsableSpace(-1); return containerInformation; } TapeLibraryContentAddressableStorage(
BasicFileStorage basicFileStorage,
ObjectReferentialRepository objectReferentialRepository,
ArchiveReferentialRepository archiveReferentialRepository,
ReadRequestReferentialRepository readRequestReferentialRepository,
FileBucketTarCreatorManager fileBucketTarCreatorManager,
QueueRepository readWriteQueue, TapeCatalogService tapeCatalogService,
String outputTarStorageFolder,
ArchiveOutputRetentionPolicy archiveOutputRetentionPolicy); @Override void createContainer(String containerName); @Override boolean isExistingContainer(String containerName); @Override String putObject(String containerName, String objectName, InputStream stream, DigestType digestType,
Long size); @Override ObjectContent getObject(String containerName, String objectName); @Override String createReadOrderRequest(String containerName, List<String> objectsIds); @Override void removeReadOrderRequest(String readRequestID); @Override void deleteObject(String containerName, String objectName); @Override boolean isExistingObject(String containerName, String objectName); @Override String getObjectDigest(String containerName, String objectName, DigestType algo, boolean noCache); @Override ContainerInformation getContainerInformation(String containerName); @Override MetadatasObject getObjectMetadata(String containerName, String objectName, boolean noCache); @Override void listContainer(String containerName, ObjectListingListener objectListingListener); @Override void close(); }### Answer:
@Test public void getContainerInformation() { ContainerInformation containerInformation = tapeLibraryContentAddressableStorage.getContainerInformation("container"); assertThat(containerInformation.getUsableSpace()) .isEqualTo(-1); }
|
### Question:
TapeLibraryContentAddressableStorage implements ContentAddressableStorage { @Override public void listContainer(String containerName, ObjectListingListener objectListingListener) throws ContentAddressableStorageNotFoundException, ContentAddressableStorageServerException, IOException { LOGGER.debug(String.format("Listing of object in container %s", containerName)); throw new UnsupportedOperationException("To be implemented"); } TapeLibraryContentAddressableStorage(
BasicFileStorage basicFileStorage,
ObjectReferentialRepository objectReferentialRepository,
ArchiveReferentialRepository archiveReferentialRepository,
ReadRequestReferentialRepository readRequestReferentialRepository,
FileBucketTarCreatorManager fileBucketTarCreatorManager,
QueueRepository readWriteQueue, TapeCatalogService tapeCatalogService,
String outputTarStorageFolder,
ArchiveOutputRetentionPolicy archiveOutputRetentionPolicy); @Override void createContainer(String containerName); @Override boolean isExistingContainer(String containerName); @Override String putObject(String containerName, String objectName, InputStream stream, DigestType digestType,
Long size); @Override ObjectContent getObject(String containerName, String objectName); @Override String createReadOrderRequest(String containerName, List<String> objectsIds); @Override void removeReadOrderRequest(String readRequestID); @Override void deleteObject(String containerName, String objectName); @Override boolean isExistingObject(String containerName, String objectName); @Override String getObjectDigest(String containerName, String objectName, DigestType algo, boolean noCache); @Override ContainerInformation getContainerInformation(String containerName); @Override MetadatasObject getObjectMetadata(String containerName, String objectName, boolean noCache); @Override void listContainer(String containerName, ObjectListingListener objectListingListener); @Override void close(); }### Answer:
@Test public void listContainer() { ObjectListingListener objectListingListener = mock(ObjectListingListener.class); assertThatThrownBy(() -> { tapeLibraryContentAddressableStorage.listContainer("container", objectListingListener); }) .isInstanceOf(UnsupportedOperationException.class); }
|
### Question:
ObjectReferentialRepository { public Optional<TapeObjectReferentialEntity> find(String containerName, String objectName) throws ObjectReferentialException { Document document; try { document = collection.find( Filters.eq(TapeObjectReferentialEntity.ID, toBson(new TapeLibraryObjectReferentialId(containerName, objectName)))) .first(); } catch (MongoException ex) { throw new ObjectReferentialException("Could not find storage location by id " + containerName + "/" + objectName, ex); } if (document == null) { return Optional.empty(); } try { return Optional.of(fromBson(document, TapeObjectReferentialEntity.class)); } catch (InvalidParseOperationException e) { throw new IllegalStateException("Could not parse document from DB " + BsonHelper.stringify(document), e); } } ObjectReferentialRepository(MongoCollection<Document> collection); void insertOrUpdate(TapeObjectReferentialEntity tapeObjectReferentialEntity); Optional<TapeObjectReferentialEntity> find(String containerName, String objectName); List<TapeObjectReferentialEntity> bulkFind(String containerName, Set<String> objectNames); void updateStorageLocation(String containerName, String objectName, String storageId,
TapeLibraryTarObjectStorageLocation tapeLibraryTarStorageLocation); boolean delete(TapeLibraryObjectReferentialId tapeLibraryObjectReferentialId); }### Answer:
@Test public void findNonExisting() throws Exception { Optional<TapeObjectReferentialEntity> tapeObjectReferentialEntity = objectReferentialRepository.find("container", "objectName1"); assertThat(tapeObjectReferentialEntity.isPresent()).isFalse(); }
|
### Question:
ObjectReferentialRepository { public List<TapeObjectReferentialEntity> bulkFind(String containerName, Set<String> objectNames) throws ObjectReferentialException { try (MongoCursor<Document> iterator = collection.find( Filters.in(TapeObjectReferentialEntity.ID, objectNames.stream() .map(objectName -> toBson(new TapeLibraryObjectReferentialId(containerName, objectName))) .collect(Collectors.toList()))).iterator()) { List<TapeObjectReferentialEntity> result = new ArrayList<>(); while (iterator.hasNext()) { Document document = iterator.next(); try { result.add(fromBson(document, TapeObjectReferentialEntity.class)); } catch (InvalidParseOperationException e) { throw new IllegalStateException("Could not parse documents from DB " + BsonHelper.stringify(document), e); } } return result; } catch (MongoException ex) { throw new ObjectReferentialException("Could not find storage location by ids " + objectNames + " in container " + containerName, ex); } } ObjectReferentialRepository(MongoCollection<Document> collection); void insertOrUpdate(TapeObjectReferentialEntity tapeObjectReferentialEntity); Optional<TapeObjectReferentialEntity> find(String containerName, String objectName); List<TapeObjectReferentialEntity> bulkFind(String containerName, Set<String> objectNames); void updateStorageLocation(String containerName, String objectName, String storageId,
TapeLibraryTarObjectStorageLocation tapeLibraryTarStorageLocation); boolean delete(TapeLibraryObjectReferentialId tapeLibraryObjectReferentialId); }### Answer:
@Test public void bulkFindNotExisting() throws ObjectReferentialException { List<TapeObjectReferentialEntity> tapeObjectReferentialEntities = objectReferentialRepository.bulkFind("container", ImmutableSet.of("objectName1", "objectName2", "objectName3")); assertThat(tapeObjectReferentialEntities).isEmpty(); }
|
### Question:
ObjectReferentialRepository { public void updateStorageLocation(String containerName, String objectName, String storageId, TapeLibraryTarObjectStorageLocation tapeLibraryTarStorageLocation) throws ObjectReferentialException { try { collection.updateOne( Filters.and( Filters.eq(TapeObjectReferentialEntity.ID, toBson(new TapeLibraryObjectReferentialId(containerName, objectName))), Filters.eq(TapeObjectReferentialEntity.STORAGE_ID, storageId) ), Updates.combine( Updates.set(TapeObjectReferentialEntity.LOCATION, toBson(tapeLibraryTarStorageLocation)), Updates.set(TapeObjectReferentialEntity.LAST_UPDATE_DATE, LocalDateUtil.now().toString()) ), new UpdateOptions().upsert(false) ); } catch (MongoException ex) { throw new ObjectReferentialException("Could not update storage location for " + containerName + "/" + objectName, ex); } } ObjectReferentialRepository(MongoCollection<Document> collection); void insertOrUpdate(TapeObjectReferentialEntity tapeObjectReferentialEntity); Optional<TapeObjectReferentialEntity> find(String containerName, String objectName); List<TapeObjectReferentialEntity> bulkFind(String containerName, Set<String> objectNames); void updateStorageLocation(String containerName, String objectName, String storageId,
TapeLibraryTarObjectStorageLocation tapeLibraryTarStorageLocation); boolean delete(TapeLibraryObjectReferentialId tapeLibraryObjectReferentialId); }### Answer:
@Test public void updateStorageLocationUnknownObject() throws Exception { objectReferentialRepository.updateStorageLocation( "container", "objectName1", "ANOTHER_STORAGE_ID", new TapeLibraryTarObjectStorageLocation( Arrays.asList( new TarEntryDescription("tarId1", "entry1", 1000L, 3L, "digest1-1"), new TarEntryDescription("tarId2", "entry2", 2000L, 7L, "digest1-2") ) ) ); }
|
### Question:
ObjectReferentialRepository { public boolean delete(TapeLibraryObjectReferentialId tapeLibraryObjectReferentialId) throws ObjectReferentialException { try { DeleteResult deleteResult = collection.deleteOne( Filters.eq(TapeObjectReferentialEntity.ID, toBson(tapeLibraryObjectReferentialId))); return (deleteResult.getDeletedCount() > 0L); } catch (MongoException ex) { throw new ObjectReferentialException( "Could not delete tar referential for id " + tapeLibraryObjectReferentialId.getContainerName() + "/" + tapeLibraryObjectReferentialId.getObjectName(), ex); } } ObjectReferentialRepository(MongoCollection<Document> collection); void insertOrUpdate(TapeObjectReferentialEntity tapeObjectReferentialEntity); Optional<TapeObjectReferentialEntity> find(String containerName, String objectName); List<TapeObjectReferentialEntity> bulkFind(String containerName, Set<String> objectNames); void updateStorageLocation(String containerName, String objectName, String storageId,
TapeLibraryTarObjectStorageLocation tapeLibraryTarStorageLocation); boolean delete(TapeLibraryObjectReferentialId tapeLibraryObjectReferentialId); }### Answer:
@Test public void deleteNonExistingObject() throws Exception { boolean deleted = objectReferentialRepository.delete(new TapeLibraryObjectReferentialId("container", "objectName1")); assertThat(deleted).isFalse(); }
|
### Question:
BasicFileStorage { public InputStream readFile(String containerName, String storageId) throws IOException { Path filePath = getFilePath(containerName, storageId); return Files.newInputStream(filePath, StandardOpenOption.READ); } BasicFileStorage(String basePath); String writeFile(String containerName, String objectName, InputStream inputStream, long size); InputStream readFile(String containerName, String storageId); void deleteFile(String containerName, String storageId); Stream<String> listStorageIdsByContainerName(String containerName); }### Answer:
@Test public void testReadFile() throws Exception { BasicFileStorage basicFileStorage = new BasicFileStorage(temporaryFolder.getRoot().getAbsolutePath()); byte[] data = "data".getBytes(); String storageId = basicFileStorage.writeFile(CONTAINER, OBJ_1, new ByteArrayInputStream(data), data.length); try (InputStream inputStream = basicFileStorage.readFile(CONTAINER, storageId)) { assertThat(inputStream).hasSameContentAs(new ByteArrayInputStream(data)); } }
|
### Question:
BasicFileStorage { public void deleteFile(String containerName, String storageId) { Path filePath = getFilePath(containerName, storageId); FileUtils.deleteQuietly(filePath.toFile()); } BasicFileStorage(String basePath); String writeFile(String containerName, String objectName, InputStream inputStream, long size); InputStream readFile(String containerName, String storageId); void deleteFile(String containerName, String storageId); Stream<String> listStorageIdsByContainerName(String containerName); }### Answer:
@Test public void testDeleteFile() throws Exception { BasicFileStorage basicFileStorage = new BasicFileStorage(temporaryFolder.getRoot().getAbsolutePath()); byte[] data = "data".getBytes(); String storageId = basicFileStorage.writeFile(CONTAINER, OBJ_1, new ByteArrayInputStream(data), data.length); basicFileStorage.deleteFile(CONTAINER, storageId); assertThatThrownBy( () -> basicFileStorage.readFile(CONTAINER, storageId) ).isInstanceOf(IOException.class); }
|
### Question:
BasicFileStorage { public Stream<String> listStorageIdsByContainerName(String containerName) throws IOException { Path containerPath = getContainerPath(basePath, containerName); if (!Files.exists(containerPath)) { return Stream.empty(); } return Files.list(containerPath) .map(path -> path.toFile().getName()); } BasicFileStorage(String basePath); String writeFile(String containerName, String objectName, InputStream inputStream, long size); InputStream readFile(String containerName, String storageId); void deleteFile(String containerName, String storageId); Stream<String> listStorageIdsByContainerName(String containerName); }### Answer:
@Test public void testFileListingEmpty() throws Exception { BasicFileStorage basicFileStorage = new BasicFileStorage(temporaryFolder.getRoot().getAbsolutePath()); Stream<String> storageIds = basicFileStorage.listStorageIdsByContainerName(CONTAINER); assertThat(IteratorUtils.toList(storageIds.iterator())) .isEmpty(); }
|
### Question:
WriteOrderCreator extends QueueProcessor<WriteOrder> { @Override protected void processMessage(WriteOrder message) throws QueueProcessingException { try { sendMessageToQueue(message); } catch (Exception ex) { throw new QueueProcessingException(QueueProcessingException.RetryPolicy.RETRY, "Could not process message " + JsonHandler.unprettyPrint(message), ex); } } WriteOrderCreator(ArchiveReferentialRepository archiveReferentialRepository,
QueueRepository readWriteQueue); void sendMessageToQueue(WriteOrder message); }### Answer:
@Test public void processMessage() throws Exception { WriteOrder message = new WriteOrder() .setArchiveId("tarId") .setBucket("bucket") .setFilePath("file_bucket") .setSize(1000L) .setDigest("digest"); CountDownLatch countDownLatch = new CountDownLatch(1); doAnswer((args) -> { countDownLatch.countDown(); return null; }).when(readWriteQueue).addIfAbsent(any(), any()); writeOrderCreator.startListener(); writeOrderCreator.addToQueue(message); assertThat(countDownLatch.await(1, TimeUnit.MINUTES)).isTrue(); verify(archiveReferentialRepository).updateLocationToReadyOnDisk("tarId", 1000L, "digest"); verifyNoMoreInteractions(archiveReferentialRepository); verify(readWriteQueue).addIfAbsent(anyList(), eq(message)); verifyNoMoreInteractions(readWriteQueue); }
|
### Question:
TapeDriveWorkerManager implements TapeDriveOrderConsumer, TapeDriveOrderProducer { public void enqueue(QueueMessageEntity entity) throws QueueException { this.readWriteQueue.add(entity); } TapeDriveWorkerManager(
QueueRepository readWriteQueue,
ArchiveReferentialRepository archiveReferentialRepository,
ReadRequestReferentialRepository readRequestReferentialRepository,
TapeLibraryPool tapeLibraryPool,
Map<Integer, TapeCatalog> driveTape, String inputTarPath, boolean forceOverrideNonEmptyCartridges,
ArchiveOutputRetentionPolicy archiveOutputRetentionPolicy); void startWorkers(); void enqueue(QueueMessageEntity entity); void shutdown(); void shutdown(long timeout, TimeUnit timeUnit); @Override QueueRepository getQueue(); @Override Optional<? extends ReadWriteOrder> consume(TapeDriveWorker driveWorker); @Override synchronized Optional<? extends ReadWriteOrder> produce(TapeDriveWorker driveWorker); }### Answer:
@Test(expected = QueueException.class) public void enqueue_ko() throws QueueException { QueueMessageEntity queueMessageEntity = mock(QueueMessageEntity.class); doThrow(new QueueException("")).when(queueRepository).add(any()); tapeDriveWorkerManager.enqueue(queueMessageEntity); }
|
### Question:
LocalFileUtils { public static String getCreationDateFromArchiveId(String archiveId) { Matcher matcher = ARCHIVE_ID_FILENAME_PATTERN.matcher(archiveId); if (!matcher.matches()) { throw new IllegalArgumentException("Invalid archiveId '" + archiveId + "'"); } return matcher.group("CreationDate"); } private LocalFileUtils(); static String createStorageId(String objectName); static String storageIdToObjectName(String storageId); static String createTarEntryName(String containerName, String storageId, int entryIndex); static String getContainerNameFromTarEntryName(String tarEntryName); static String getStorageIdFromTarEntryName(String tarEntryName); static int getEntryIndexFromTarEntryName(String tarEntryName); static String createTarId(LocalDateTime now); static String archiveFileNameRelativeToInputArchiveStorageFolder(String fileBucket, String archiveId); static String getCreationDateFromArchiveId(String archiveId); static String archiveFileNamePathToArchiveId(String tarFileName); static Path fileBuckedInputFilePath(String inputTarStorageFolder, String fileBucketId); static final String TAR_EXTENSION; static final String ZIP_EXTENSION; static final String TMP_EXTENSION; static final String INPUT_TAR_TMP_FOLDER; }### Answer:
@Test public void test_tar_and_zip_naming() { String tarId = "20190701165216262-a8e7c997-3c44-4119-b169-5d2000015697.tar"; String backupId = "20190701165216263-mongod-shard12.zip"; String date = LocalFileUtils.getCreationDateFromArchiveId(tarId); Assertions.assertThat(tarId).contains(date); date = LocalFileUtils.getCreationDateFromArchiveId(backupId); Assertions.assertThat(backupId).contains(date); }
|
### Question:
TapeLibraryStatusParser { public TapeLibraryState parse(String output) { ParametersChecker.checkParameter("Output param is required", output); final TapeLibraryState tapeLibraryState = new TapeLibraryState(StatusCode.OK); for (String s : output.split("\\|")) { if (s.trim().startsWith(STORAGE_ELEMENT)) { TapeSlot tapeSlot = new TapeSlot(); tapeLibraryState.addToSlots(tapeSlot); extractSlotIndexAndType(s, tapeSlot); if (s.contains(EMPTY)) { continue; } TapeCartridge cartridge = new TapeCartridge(); tapeSlot.setTape(cartridge); extractSlotVolumeTag(s, cartridge); } else if (s.trim().startsWith(DATA_TRANSFER_ELEMENT)) { TapeDrive tapeDrive = new TapeDrive(); tapeLibraryState.addToDrives(tapeDrive); extractDriveIndex(s, tapeDrive); if (s.contains(EMPTY)) { continue; } TapeCartridge cartridge = new TapeCartridge(); tapeDrive.setTape(cartridge); extractCartridgeSlotIndex(s, cartridge); extractDriveVolumeTag(s, cartridge); } else if (s.trim().startsWith(STORAGE_CHANGER)) { extractHeader(tapeLibraryState, s); } } return tapeLibraryState; } TapeLibraryState parse(String output); }### Answer:
@Test public void testParseTapeLibraryStatus() throws Exception { String statusOutPut = PropertiesUtils.getResourceAsString("output/tape-robot-stats.txt"); final TapeLibraryStatusParser tapeLibraryStatusParser = new TapeLibraryStatusParser(); final TapeLibraryState tapeLibraryState = tapeLibraryStatusParser.parse(statusOutPut); Assertions.assertThat(tapeLibraryState).isNotNull(); String expected = "result/tape-robot-stats.json"; JsonNode initialJson = JsonHandler.getFromInputStream(PropertiesUtils.getResourceAsStream(expected)); JsonAssert.assertJsonEquals(JsonHandler.toJsonNode(tapeLibraryState), initialJson); }
|
### Question:
ProcessExecutor { public Output execute(String commandPath, boolean asSudo, long timeoutInMilliseconds, List<String> args) { return execute(commandPath, asSudo, false, timeoutInMilliseconds, args); } static ProcessExecutor getInstance(); Output execute(String commandPath, boolean asSudo, long timeoutInMilliseconds, List<String> args); Output execute(String commandPath, boolean asSudo, boolean redirectStreamToFile, long timeoutInMilliseconds,
List<String> args); static final String SUDO; }### Answer:
@Test public void testExecute() throws IOException { String file = "/tmp/" + GUIDFactory.newGUID().getId() + ".test"; Output out = ProcessExecutor.getInstance().execute("/bin/touch", false, 100l, Lists.newArrayList(file)); Assertions.assertThat(out).isNotNull(); Assertions.assertThat(out.getExitCode()).isEqualTo(0); File actual = new File(file); Assertions.assertThat(actual).exists(); OutputStreamWriter writer = new OutputStreamWriter(Files.newOutputStream(actual.toPath())); for (int i = 0; i < 10_000; i++) { writer.write( "18:42:22.476 [main] DEBUG fr.gouv.vitam.storage.offers.tape.impl.robot.MtxTapeLibraryService - Execute script : /bin/mtx,timeout: 1000, args : [-f, /dev/sg0, status]\n"); } System.err.println("============================"); out = ProcessExecutor.getInstance().execute("/bin/cat", false, true, 30000l, Lists.newArrayList(file)); Assertions.assertThat(out.getStdout()) .contains("fr.gouv.vitam.storage.offers.tape.impl.robot.MtxTapeLibraryService"); actual.deleteOnExit(); }
|
### Question:
TapeRobotManager implements TapeRobotService { @Override public TapeLoadUnloadService getLoadUnloadService() { return tapeLoadUnloadService; } TapeRobotManager(TapeRobotConf tapeRobotConf); @VisibleForTesting TapeRobotManager(TapeRobotConf tapeRobotConf, TapeLoadUnloadService tapeLoadUnloadService); @Override TapeRobotConf getTapeRobotConf(); @Override TapeLoadUnloadService getLoadUnloadService(); }### Answer:
@Test public void testConstructorOneOK() { TapeRobotManager tapeRobotManager = new TapeRobotManager(mock(TapeRobotConf.class), mock(TapeLoadUnloadService.class)); Assertions.assertThat(tapeRobotManager.getLoadUnloadService()).isNotNull(); }
@Test public void testConstructorTwoOK() { TapeRobotManager tapeRobotManager = new TapeRobotManager(mock(TapeRobotConf.class)); Assertions.assertThat(tapeRobotManager.getLoadUnloadService()).isNotNull(); }
|
### Question:
MtTapeLibraryService implements TapeDriveCommandService { @Override public ProcessExecutor getExecutor() { return processExecutor; } MtTapeLibraryService(TapeDriveConf tapeDriveConf, ProcessExecutor processExecutor); @Override TapeDriveSpec status(); @Override TapeResponse move(Integer position, boolean isBackward); @Override TapeResponse rewind(); @Override TapeResponse goToEnd(); @Override TapeResponse eject(); @Override ProcessExecutor getExecutor(); static final String F; static final String STATUS; static final String FSF; static final String BSFM; static final String REWIND; static final String EOD; static final String OFFLINE; }### Answer:
@Test public void test_get_executor() { MtTapeLibraryService mtTapeLibraryService = new MtTapeLibraryService(tapeDriveConf, processExecutor); assertThat(mtTapeLibraryService.getExecutor()).isNotNull(); }
|
### Question:
TapeCatalogServiceImpl implements TapeCatalogService { @Override public boolean replace(TapeCatalog tapeCatalog) throws TapeCatalogException { return tapeCatalogRepository.replaceTape(tapeCatalog); } TapeCatalogServiceImpl(TapeCatalogRepository tapeCatalogRepository); @Override void create(TapeCatalog tapeCatalog); @Override boolean replace(TapeCatalog tapeCatalog); @Override boolean update(String tapeId, Map<String, Object> criteria); @Override Map<Integer, TapeCatalog> init(String tapeLibraryIdentifier, TapeLibrarySpec libraryState); @Override TapeCatalog findById(String tapeId); @Override List<TapeCatalog> find(List<QueryCriteria> criteria); @Override void add(QueueMessageEntity queue); @Override void addIfAbsent(List<QueryCriteria> criteria, QueueMessageEntity queueMessageEntity); @Override long remove(String queueId); @Override long complete(String queueId); @Override long markError(String queueMessageId); @Override long markReady(String queueId); @Override long initializeOnBootstrap(); @Override Optional<T> receive(QueueMessageType messageType); @Override Optional<T> receive(QueueMessageType messageType, boolean usePriority); @Override Optional<T> receive(Bson inQuery, QueueMessageType messageType); @Override Optional<T> receive(Bson inQuery, QueueMessageType messageType, boolean usePriority); @Override Optional<T> receive(Bson inQuery, Bson inUpdate, QueueMessageType messageType); @Override Optional<T> receive(Bson inQuery, Bson inUpdate, QueueMessageType messageType, boolean usePriority); }### Answer:
@Test public void test_replace_tape_ok() throws TapeCatalogException { when(tapeCatalogRepository.replaceTape(any())).thenReturn(true); tapeCatalogService.replace(mock(TapeCatalog.class)); verify(tapeCatalogRepository, times(1)).replaceTape(any()); }
@Test(expected = TapeCatalogException.class) public void test_replace_tape_ko() throws TapeCatalogException { doThrow(new TapeCatalogException("")).when(tapeCatalogRepository).replaceTape(any()); tapeCatalogService.replace(mock(TapeCatalog.class)); }
|
### Question:
DdTapeLibraryService implements TapeReadWriteService { @Override public ProcessExecutor getExecutor() { return processExecutor; } DdTapeLibraryService(TapeDriveConf tapeDriveConf, ProcessExecutor processExecutor,
String inputDirectory, String outputDirectory); @Override TapeResponse writeToTape(String inputPath); @Override TapeResponse readFromTape(String outputPath); @Override ProcessExecutor getExecutor(); @Override String getOutputDirectory(); @Override String getInputDirectory(); static final String IF; static final String OF; }### Answer:
@Test public void test_get_executor() { DdTapeLibraryService ddTapeLibraryService = new DdTapeLibraryService(tapeDriveConf, processExecutor, "fakepath", "fakepath"); assertThat(ddTapeLibraryService.getExecutor()).isNotNull(); }
|
### Question:
DriverImpl extends AbstractDriver { public static DriverImpl getInstance() { return DRIVER_IMPL; } DriverImpl(); static DriverImpl getInstance(); @Override Connection connect(String offerId); @Override String getName(); @Override int getMajorVersion(); @Override int getMinorVersion(); }### Answer:
@Test() public void isStorageOfferAvailableOK() throws Exception { assertEquals(false, DriverImpl.getInstance().isStorageOfferAvailable(null)); }
|
### Question:
PerformanceService { List<Path> listSipDirectory() throws IOException { List<Path> paths = new ArrayList<>(); Files.walkFileTree(sipDirectory, new SimpleFileVisitor<Path>() { @Override public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException { if (file.toString().toLowerCase().endsWith("zip")) { paths.add(sipDirectory.relativize(file)); } return FileVisitResult.CONTINUE; } }); return paths; } PerformanceService(Path sipDirectory, Path performanceReportDirectory); PerformanceService(IngestExternalClientFactory ingestClientFactory,
AdminExternalClientFactory adminClientFactory, Path sipDirectory,
Path performanceReportDirectory, UserInterfaceTransactionManager userInterfaceTransactionManager); }### Answer:
@Test public void should_list_file_in_sip_directory() throws IOException { Path sipDirectory = generateThreeZipFileSipWithSubDirectory(); Path reportDirectory = temporaryFolder.newFolder().toPath(); PerformanceService performanceService = new PerformanceService(ingestClientFactory, adminClientFactory, sipDirectory, reportDirectory, UserInterfaceTransactionManager.getInstance()); List<Path> files = performanceService.listSipDirectory(); assertThat(files).hasSize(3); }
|
### Question:
PerformanceService { List<Path> listReportDirectory() throws IOException { return listDirectory(performanceReportDirectory); } PerformanceService(Path sipDirectory, Path performanceReportDirectory); PerformanceService(IngestExternalClientFactory ingestClientFactory,
AdminExternalClientFactory adminClientFactory, Path sipDirectory,
Path performanceReportDirectory, UserInterfaceTransactionManager userInterfaceTransactionManager); }### Answer:
@Test public void should_list_file_in_report_directory() throws IOException { Path reportDirectory = generateFileReport(); PerformanceService performanceService = new PerformanceService(ingestClientFactory, adminClientFactory, null, reportDirectory, UserInterfaceTransactionManager.getInstance()); List<Path> files = performanceService.listReportDirectory(); assertThat(files).hasSize(2); }
|
### Question:
PerformanceService { InputStream readReport(String reportName) throws IOException { return Files.newInputStream(performanceReportDirectory.resolve(reportName)); } PerformanceService(Path sipDirectory, Path performanceReportDirectory); PerformanceService(IngestExternalClientFactory ingestClientFactory,
AdminExternalClientFactory adminClientFactory, Path sipDirectory,
Path performanceReportDirectory, UserInterfaceTransactionManager userInterfaceTransactionManager); }### Answer:
@Test public void should_read_generated_report() throws IOException { Path reportDirectory = temporaryFolder.newFolder().toPath(); String reportName = "1.txt"; Files.write(reportDirectory.resolve(reportName), "test".getBytes()); PerformanceService performanceService = new PerformanceService(ingestClientFactory, adminClientFactory, null, reportDirectory, UserInterfaceTransactionManager.getInstance()); InputStream inputStream = performanceService.readReport(reportName); assertThat(inputStream).hasSameContentAs(new ByteArrayInputStream("test".getBytes())); }
|
### Question:
StorageCRUDUtils { public boolean deleteFile(DataCategory dataCategory, String uid, String strategyId, String offerId) throws StorageServerClientException { return storageClient.delete(strategyId, dataCategory, uid, Collections.singletonList(offerId)); } StorageCRUDUtils(); @VisibleForTesting StorageCRUDUtils(StorageClient storageClient); RequestResponse<StorageStrategy> getStrategies(); boolean deleteFile(DataCategory dataCategory, String uid, String strategyId, String offerId); void storeInOffer(DataCategory dataCategory, String uid, String strategyId, String offerId, Long size, InputStream stream); }### Answer:
@Test public void should_deleteObject() throws Exception { ArrayList<String> offers = new ArrayList<>(); offers.add("offer-fs-1.service.consul"); given(storageClient .getInformation(VitamConfiguration.getDefaultStrategy(), DataCategory.OBJECT, "aeeaaaaaacew2hcbaafoialcsdnwzyyaaaaq.json", offers, true)) .willReturn( JsonHandler.getFromString(information)); given(storageClient.getOffers(VitamConfiguration.getDefaultStrategy())).willReturn(offers); storageCRUDUtils = new StorageCRUDUtils(storageClient); boolean result = storageCRUDUtils.deleteFile(DataCategory.OBJECT, VitamConfiguration.getDefaultStrategy(), "aeeaaaaaacew2hcbaafoialcsdnwzyyaaaaq.json","offer-fs-1.service.consul"); assertThat(result).isFalse(); }
|
### Question:
LogbookOperationsClientRest extends DefaultClient implements LogbookOperationsClient { @Override public RequestResponseOK traceabilityLfcUnit() throws LogbookClientServerException, InvalidParseOperationException { return traceabilityLFC("/lifecycles/units/traceability"); } LogbookOperationsClientRest(LogbookOperationsClientFactory factory); @Override void create(LogbookOperationParameters parameters); @Override void update(LogbookOperationParameters parameters); @Override JsonNode selectOperation(JsonNode select); @Override JsonNode selectOperationSliced(JsonNode select); @Override JsonNode selectOperationById(String processId); @Override void createDelegate(LogbookOperationParameters parameters); @Override void updateDelegate(LogbookOperationParameters parameters); @Override void bulkCreate(String eventIdProc, Iterable<LogbookOperationParameters> queue); @Override void commitCreateDelegate(String eventIdProc); @Override void bulkUpdate(String eventIdProc, Iterable<LogbookOperationParameters> queue); @Override void commitUpdateDelegate(String eventIdProc); @Override RequestResponseOK traceability(); @Override RequestResponseOK traceabilityLfcUnit(); @Override RequestResponseOK traceabilityLfcObjectGroup(); @Override LifecycleTraceabilityStatus checkLifecycleTraceabilityWorkflowStatus(String operationId); @Override JsonNode reindex(IndexParameters indexParam); @Override JsonNode switchIndexes(SwitchIndexParameters switchIndexParam); @Override void traceabilityAudit(int tenant, AuditLogbookOptions options); @Override LogbookCheckResult checkLogbookCoherence(); @Override void close(); }### Answer:
@Test public void traceabilityLfcUnit() throws Exception { VitamThreadUtils.getVitamSession().setTenantId(0); when(mock.post()) .thenReturn(Response.status(Status.OK).entity( new RequestResponseOK<String>().addResult("guid1")).build()); client.traceabilityLfcObjectGroup(); }
|
### Question:
LogbookOperationsClientRest extends DefaultClient implements LogbookOperationsClient { @Override public RequestResponseOK traceabilityLfcObjectGroup() throws LogbookClientServerException, InvalidParseOperationException { return traceabilityLFC("/lifecycles/objectgroups/traceability"); } LogbookOperationsClientRest(LogbookOperationsClientFactory factory); @Override void create(LogbookOperationParameters parameters); @Override void update(LogbookOperationParameters parameters); @Override JsonNode selectOperation(JsonNode select); @Override JsonNode selectOperationSliced(JsonNode select); @Override JsonNode selectOperationById(String processId); @Override void createDelegate(LogbookOperationParameters parameters); @Override void updateDelegate(LogbookOperationParameters parameters); @Override void bulkCreate(String eventIdProc, Iterable<LogbookOperationParameters> queue); @Override void commitCreateDelegate(String eventIdProc); @Override void bulkUpdate(String eventIdProc, Iterable<LogbookOperationParameters> queue); @Override void commitUpdateDelegate(String eventIdProc); @Override RequestResponseOK traceability(); @Override RequestResponseOK traceabilityLfcUnit(); @Override RequestResponseOK traceabilityLfcObjectGroup(); @Override LifecycleTraceabilityStatus checkLifecycleTraceabilityWorkflowStatus(String operationId); @Override JsonNode reindex(IndexParameters indexParam); @Override JsonNode switchIndexes(SwitchIndexParameters switchIndexParam); @Override void traceabilityAudit(int tenant, AuditLogbookOptions options); @Override LogbookCheckResult checkLogbookCoherence(); @Override void close(); }### Answer:
@Test public void traceabilityLfcObjectGroup() throws Exception { VitamThreadUtils.getVitamSession().setTenantId(0); when(mock.post()) .thenReturn(Response.status(Status.OK).entity( new RequestResponseOK<String>().addResult("guid1")).build()); client.traceabilityLfcObjectGroup(); }
|
### Question:
LogbookOperationsClientRest extends DefaultClient implements LogbookOperationsClient { @Override public JsonNode reindex(IndexParameters indexParam) throws InvalidParseOperationException, LogbookClientServerException { try (Response response = make(post().withPath("/reindex").withBody(indexParam, "The options are mandatory").withJson())) { check(response); return response.readEntity(JsonNode.class); } catch (LogbookClientNotFoundException | VitamClientInternalException | LogbookClientBadRequestException | LogbookClientAlreadyExistsException e) { throw new LogbookClientServerException(ErrorMessage.INTERNAL_SERVER_ERROR.getMessage(), e); } } LogbookOperationsClientRest(LogbookOperationsClientFactory factory); @Override void create(LogbookOperationParameters parameters); @Override void update(LogbookOperationParameters parameters); @Override JsonNode selectOperation(JsonNode select); @Override JsonNode selectOperationSliced(JsonNode select); @Override JsonNode selectOperationById(String processId); @Override void createDelegate(LogbookOperationParameters parameters); @Override void updateDelegate(LogbookOperationParameters parameters); @Override void bulkCreate(String eventIdProc, Iterable<LogbookOperationParameters> queue); @Override void commitCreateDelegate(String eventIdProc); @Override void bulkUpdate(String eventIdProc, Iterable<LogbookOperationParameters> queue); @Override void commitUpdateDelegate(String eventIdProc); @Override RequestResponseOK traceability(); @Override RequestResponseOK traceabilityLfcUnit(); @Override RequestResponseOK traceabilityLfcObjectGroup(); @Override LifecycleTraceabilityStatus checkLifecycleTraceabilityWorkflowStatus(String operationId); @Override JsonNode reindex(IndexParameters indexParam); @Override JsonNode switchIndexes(SwitchIndexParameters switchIndexParam); @Override void traceabilityAudit(int tenant, AuditLogbookOptions options); @Override LogbookCheckResult checkLogbookCoherence(); @Override void close(); }### Answer:
@Test @RunWithCustomExecutor public void launchReindexationTest() throws InvalidParseOperationException, LogbookClientServerException { when(mock.post()).thenReturn(Response.status(Status.CREATED).entity(JsonHandler.createObjectNode()) .build()); JsonNode resp = client.reindex(new IndexParameters()); assertNotNull(resp); }
|
### Question:
LogbookOperationsClientRest extends DefaultClient implements LogbookOperationsClient { @Override public JsonNode switchIndexes(SwitchIndexParameters switchIndexParam) throws InvalidParseOperationException, LogbookClientServerException { try (Response response = make(post().withPath("/alias").withBody(switchIndexParam, "The options are mandatory").withJson())) { check(response); return response.readEntity(JsonNode.class); } catch (LogbookClientNotFoundException | LogbookClientAlreadyExistsException | LogbookClientBadRequestException | VitamClientInternalException e) { throw new LogbookClientServerException(ErrorMessage.INTERNAL_SERVER_ERROR.getMessage(), e); } } LogbookOperationsClientRest(LogbookOperationsClientFactory factory); @Override void create(LogbookOperationParameters parameters); @Override void update(LogbookOperationParameters parameters); @Override JsonNode selectOperation(JsonNode select); @Override JsonNode selectOperationSliced(JsonNode select); @Override JsonNode selectOperationById(String processId); @Override void createDelegate(LogbookOperationParameters parameters); @Override void updateDelegate(LogbookOperationParameters parameters); @Override void bulkCreate(String eventIdProc, Iterable<LogbookOperationParameters> queue); @Override void commitCreateDelegate(String eventIdProc); @Override void bulkUpdate(String eventIdProc, Iterable<LogbookOperationParameters> queue); @Override void commitUpdateDelegate(String eventIdProc); @Override RequestResponseOK traceability(); @Override RequestResponseOK traceabilityLfcUnit(); @Override RequestResponseOK traceabilityLfcObjectGroup(); @Override LifecycleTraceabilityStatus checkLifecycleTraceabilityWorkflowStatus(String operationId); @Override JsonNode reindex(IndexParameters indexParam); @Override JsonNode switchIndexes(SwitchIndexParameters switchIndexParam); @Override void traceabilityAudit(int tenant, AuditLogbookOptions options); @Override LogbookCheckResult checkLogbookCoherence(); @Override void close(); }### Answer:
@Test @RunWithCustomExecutor public void switchIndexesTest() throws InvalidParseOperationException, LogbookClientServerException { when(mock.post()).thenReturn(Response.status(Status.OK).entity(JsonHandler.createObjectNode()) .build()); JsonNode resp = client.switchIndexes(new SwitchIndexParameters()); assertNotNull(resp); }
|
### Question:
LogbookOperationsClientRest extends DefaultClient implements LogbookOperationsClient { @Override public void traceabilityAudit(int tenant, AuditLogbookOptions options) throws LogbookClientServerException { try (Response response = make(post().withPath("/auditTraceability").withHeader(X_TENANT_ID, tenant).withBody(options).withJson())) { check(response); } catch (LogbookClientNotFoundException | VitamClientInternalException | LogbookClientBadRequestException | LogbookClientAlreadyExistsException e) { throw new LogbookClientServerException(ErrorMessage.INTERNAL_SERVER_ERROR.getMessage(), e); } } LogbookOperationsClientRest(LogbookOperationsClientFactory factory); @Override void create(LogbookOperationParameters parameters); @Override void update(LogbookOperationParameters parameters); @Override JsonNode selectOperation(JsonNode select); @Override JsonNode selectOperationSliced(JsonNode select); @Override JsonNode selectOperationById(String processId); @Override void createDelegate(LogbookOperationParameters parameters); @Override void updateDelegate(LogbookOperationParameters parameters); @Override void bulkCreate(String eventIdProc, Iterable<LogbookOperationParameters> queue); @Override void commitCreateDelegate(String eventIdProc); @Override void bulkUpdate(String eventIdProc, Iterable<LogbookOperationParameters> queue); @Override void commitUpdateDelegate(String eventIdProc); @Override RequestResponseOK traceability(); @Override RequestResponseOK traceabilityLfcUnit(); @Override RequestResponseOK traceabilityLfcObjectGroup(); @Override LifecycleTraceabilityStatus checkLifecycleTraceabilityWorkflowStatus(String operationId); @Override JsonNode reindex(IndexParameters indexParam); @Override JsonNode switchIndexes(SwitchIndexParameters switchIndexParam); @Override void traceabilityAudit(int tenant, AuditLogbookOptions options); @Override LogbookCheckResult checkLogbookCoherence(); @Override void close(); }### Answer:
@Test @RunWithCustomExecutor public void traceabilityAuditTest() throws InvalidParseOperationException, LogbookClientServerException { when(mock.post()).thenReturn(Response.status(Status.OK).entity(JsonHandler.createObjectNode()) .build()); client.traceabilityAudit(0, new AuditLogbookOptions()); }
|
### Question:
LogbookOperationsClientRest extends DefaultClient implements LogbookOperationsClient { @Override public void close() { super.close(); helper.clear(); } LogbookOperationsClientRest(LogbookOperationsClientFactory factory); @Override void create(LogbookOperationParameters parameters); @Override void update(LogbookOperationParameters parameters); @Override JsonNode selectOperation(JsonNode select); @Override JsonNode selectOperationSliced(JsonNode select); @Override JsonNode selectOperationById(String processId); @Override void createDelegate(LogbookOperationParameters parameters); @Override void updateDelegate(LogbookOperationParameters parameters); @Override void bulkCreate(String eventIdProc, Iterable<LogbookOperationParameters> queue); @Override void commitCreateDelegate(String eventIdProc); @Override void bulkUpdate(String eventIdProc, Iterable<LogbookOperationParameters> queue); @Override void commitUpdateDelegate(String eventIdProc); @Override RequestResponseOK traceability(); @Override RequestResponseOK traceabilityLfcUnit(); @Override RequestResponseOK traceabilityLfcObjectGroup(); @Override LifecycleTraceabilityStatus checkLifecycleTraceabilityWorkflowStatus(String operationId); @Override JsonNode reindex(IndexParameters indexParam); @Override JsonNode switchIndexes(SwitchIndexParameters switchIndexParam); @Override void traceabilityAudit(int tenant, AuditLogbookOptions options); @Override LogbookCheckResult checkLogbookCoherence(); @Override void close(); }### Answer:
@Test public void closeExecution() throws Exception { client.close(); }
|
### Question:
LogbookOperationsClientMock extends AbstractMockClient implements LogbookOperationsClient { @Override public void bulkUpdate(String eventIdProc, Iterable<LogbookOperationParameters> queue) throws LogbookClientBadRequestException { if (queue != null) { final Iterator<LogbookOperationParameters> iterator = queue.iterator(); while (iterator.hasNext()) { logInformation(UPDATE, iterator.next()); } } else { LOGGER.error(eventIdProc + " " + ErrorMessage.LOGBOOK_MISSING_MANDATORY_PARAMETER.getMessage()); throw new LogbookClientBadRequestException( ErrorMessage.LOGBOOK_MISSING_MANDATORY_PARAMETER.getMessage()); } } @Override void create(LogbookOperationParameters parameters); @Override void update(LogbookOperationParameters parameters); @Override JsonNode selectOperation(JsonNode select); @Override JsonNode selectOperationSliced(JsonNode select); @Override JsonNode selectOperationById(String id); @Override RequestResponseOK traceability(); @Override void createDelegate(LogbookOperationParameters parameters); @Override void updateDelegate(LogbookOperationParameters parameters); @Override void bulkCreate(String eventIdProc, Iterable<LogbookOperationParameters> queue); @Override void bulkUpdate(String eventIdProc, Iterable<LogbookOperationParameters> queue); @Override void commitCreateDelegate(String eventIdProc); @Override void commitUpdateDelegate(String eventIdProc); @Override void close(); @Override RequestResponseOK traceabilityLfcUnit(); @Override RequestResponseOK traceabilityLfcObjectGroup(); @Override JsonNode reindex(IndexParameters indexParam); @Override JsonNode switchIndexes(SwitchIndexParameters switchIndexParam); @Override void traceabilityAudit(int tenant, AuditLogbookOptions options); @Override LogbookCheckResult checkLogbookCoherence(); @Override LifecycleTraceabilityStatus checkLifecycleTraceabilityWorkflowStatus(String operationId); }### Answer:
@Test(expected = LogbookClientBadRequestException.class) public void bulkUpdateEmptyQueueTest() throws Exception { LogbookOperationsClientFactory.changeMode(null); final LogbookOperationsClient client = LogbookOperationsClientFactory.getInstance().getClient(); client.bulkUpdate(LogbookParameterName.eventIdentifierProcess.name(), null); }
|
### Question:
LogbookOperationsClientMock extends AbstractMockClient implements LogbookOperationsClient { @Override public void close() { super.close(); helper.clear(); } @Override void create(LogbookOperationParameters parameters); @Override void update(LogbookOperationParameters parameters); @Override JsonNode selectOperation(JsonNode select); @Override JsonNode selectOperationSliced(JsonNode select); @Override JsonNode selectOperationById(String id); @Override RequestResponseOK traceability(); @Override void createDelegate(LogbookOperationParameters parameters); @Override void updateDelegate(LogbookOperationParameters parameters); @Override void bulkCreate(String eventIdProc, Iterable<LogbookOperationParameters> queue); @Override void bulkUpdate(String eventIdProc, Iterable<LogbookOperationParameters> queue); @Override void commitCreateDelegate(String eventIdProc); @Override void commitUpdateDelegate(String eventIdProc); @Override void close(); @Override RequestResponseOK traceabilityLfcUnit(); @Override RequestResponseOK traceabilityLfcObjectGroup(); @Override JsonNode reindex(IndexParameters indexParam); @Override JsonNode switchIndexes(SwitchIndexParameters switchIndexParam); @Override void traceabilityAudit(int tenant, AuditLogbookOptions options); @Override LogbookCheckResult checkLogbookCoherence(); @Override LifecycleTraceabilityStatus checkLifecycleTraceabilityWorkflowStatus(String operationId); }### Answer:
@Test public void closeExecution() { LogbookOperationsClientFactory.changeMode(null); final LogbookOperationsClient client = LogbookOperationsClientFactory.getInstance().getClient(); client.close(); }
|
### Question:
LogbookOperationsClientMock extends AbstractMockClient implements LogbookOperationsClient { @Override public RequestResponseOK traceability() throws InvalidParseOperationException { LOGGER.debug("calling traceability "); final List<String> resultAsJson = new ArrayList<>(); resultAsJson.add(GUID_EXAMPLE); return new RequestResponseOK().addAllResults(resultAsJson); } @Override void create(LogbookOperationParameters parameters); @Override void update(LogbookOperationParameters parameters); @Override JsonNode selectOperation(JsonNode select); @Override JsonNode selectOperationSliced(JsonNode select); @Override JsonNode selectOperationById(String id); @Override RequestResponseOK traceability(); @Override void createDelegate(LogbookOperationParameters parameters); @Override void updateDelegate(LogbookOperationParameters parameters); @Override void bulkCreate(String eventIdProc, Iterable<LogbookOperationParameters> queue); @Override void bulkUpdate(String eventIdProc, Iterable<LogbookOperationParameters> queue); @Override void commitCreateDelegate(String eventIdProc); @Override void commitUpdateDelegate(String eventIdProc); @Override void close(); @Override RequestResponseOK traceabilityLfcUnit(); @Override RequestResponseOK traceabilityLfcObjectGroup(); @Override JsonNode reindex(IndexParameters indexParam); @Override JsonNode switchIndexes(SwitchIndexParameters switchIndexParam); @Override void traceabilityAudit(int tenant, AuditLogbookOptions options); @Override LogbookCheckResult checkLogbookCoherence(); @Override LifecycleTraceabilityStatus checkLifecycleTraceabilityWorkflowStatus(String operationId); }### Answer:
@Test public void traceabilityTest() throws Exception { final LogbookOperationsClient client = LogbookOperationsClientFactory.getInstance().getClient(); RequestResponse response = client.traceability(); assertNotNull(response); assertTrue(response instanceof RequestResponseOK); }
|
### Question:
LogbookOperationsClientMock extends AbstractMockClient implements LogbookOperationsClient { @Override public RequestResponseOK traceabilityLfcObjectGroup() { LOGGER.debug("calling traceability LFC ObjectGroup"); final List<String> resultAsJson = new ArrayList<>(); resultAsJson.add(GUID_EXAMPLE); return new RequestResponseOK().addAllResults(resultAsJson); } @Override void create(LogbookOperationParameters parameters); @Override void update(LogbookOperationParameters parameters); @Override JsonNode selectOperation(JsonNode select); @Override JsonNode selectOperationSliced(JsonNode select); @Override JsonNode selectOperationById(String id); @Override RequestResponseOK traceability(); @Override void createDelegate(LogbookOperationParameters parameters); @Override void updateDelegate(LogbookOperationParameters parameters); @Override void bulkCreate(String eventIdProc, Iterable<LogbookOperationParameters> queue); @Override void bulkUpdate(String eventIdProc, Iterable<LogbookOperationParameters> queue); @Override void commitCreateDelegate(String eventIdProc); @Override void commitUpdateDelegate(String eventIdProc); @Override void close(); @Override RequestResponseOK traceabilityLfcUnit(); @Override RequestResponseOK traceabilityLfcObjectGroup(); @Override JsonNode reindex(IndexParameters indexParam); @Override JsonNode switchIndexes(SwitchIndexParameters switchIndexParam); @Override void traceabilityAudit(int tenant, AuditLogbookOptions options); @Override LogbookCheckResult checkLogbookCoherence(); @Override LifecycleTraceabilityStatus checkLifecycleTraceabilityWorkflowStatus(String operationId); }### Answer:
@Test public void traceabilityTestObjectGroupLFC() throws Exception { final LogbookOperationsClient client = LogbookOperationsClientFactory.getInstance().getClient(); RequestResponse response = client.traceabilityLfcObjectGroup(); assertNotNull(response); assertTrue(response instanceof RequestResponseOK); }
|
### Question:
LogbookOperationsClientMock extends AbstractMockClient implements LogbookOperationsClient { @Override public RequestResponseOK traceabilityLfcUnit() { LOGGER.debug("calling traceability LFC unit"); final List<String> resultAsJson = new ArrayList<>(); resultAsJson.add(GUID_EXAMPLE); return new RequestResponseOK().addAllResults(resultAsJson); } @Override void create(LogbookOperationParameters parameters); @Override void update(LogbookOperationParameters parameters); @Override JsonNode selectOperation(JsonNode select); @Override JsonNode selectOperationSliced(JsonNode select); @Override JsonNode selectOperationById(String id); @Override RequestResponseOK traceability(); @Override void createDelegate(LogbookOperationParameters parameters); @Override void updateDelegate(LogbookOperationParameters parameters); @Override void bulkCreate(String eventIdProc, Iterable<LogbookOperationParameters> queue); @Override void bulkUpdate(String eventIdProc, Iterable<LogbookOperationParameters> queue); @Override void commitCreateDelegate(String eventIdProc); @Override void commitUpdateDelegate(String eventIdProc); @Override void close(); @Override RequestResponseOK traceabilityLfcUnit(); @Override RequestResponseOK traceabilityLfcObjectGroup(); @Override JsonNode reindex(IndexParameters indexParam); @Override JsonNode switchIndexes(SwitchIndexParameters switchIndexParam); @Override void traceabilityAudit(int tenant, AuditLogbookOptions options); @Override LogbookCheckResult checkLogbookCoherence(); @Override LifecycleTraceabilityStatus checkLifecycleTraceabilityWorkflowStatus(String operationId); }### Answer:
@Test public void traceabilityTestUnitLFC() throws Exception { final LogbookOperationsClient client = LogbookOperationsClientFactory.getInstance().getClient(); RequestResponse response = client.traceabilityLfcUnit(); assertNotNull(response); assertTrue(response instanceof RequestResponseOK); }
|
### Question:
LogbookOperationsClientMock extends AbstractMockClient implements LogbookOperationsClient { @Override public JsonNode reindex(IndexParameters indexParam) throws InvalidParseOperationException, LogbookClientServerException { return ClientMockResultHelper.getReindexationInfo().toJsonNode(); } @Override void create(LogbookOperationParameters parameters); @Override void update(LogbookOperationParameters parameters); @Override JsonNode selectOperation(JsonNode select); @Override JsonNode selectOperationSliced(JsonNode select); @Override JsonNode selectOperationById(String id); @Override RequestResponseOK traceability(); @Override void createDelegate(LogbookOperationParameters parameters); @Override void updateDelegate(LogbookOperationParameters parameters); @Override void bulkCreate(String eventIdProc, Iterable<LogbookOperationParameters> queue); @Override void bulkUpdate(String eventIdProc, Iterable<LogbookOperationParameters> queue); @Override void commitCreateDelegate(String eventIdProc); @Override void commitUpdateDelegate(String eventIdProc); @Override void close(); @Override RequestResponseOK traceabilityLfcUnit(); @Override RequestResponseOK traceabilityLfcObjectGroup(); @Override JsonNode reindex(IndexParameters indexParam); @Override JsonNode switchIndexes(SwitchIndexParameters switchIndexParam); @Override void traceabilityAudit(int tenant, AuditLogbookOptions options); @Override LogbookCheckResult checkLogbookCoherence(); @Override LifecycleTraceabilityStatus checkLifecycleTraceabilityWorkflowStatus(String operationId); }### Answer:
@Test public void launchReindexationTest() throws LogbookClientServerException, InvalidParseOperationException { final LogbookOperationsClient client = LogbookOperationsClientFactory.getInstance().getClient(); assertNotNull(client.reindex(new IndexParameters())); }
|
### Question:
LogbookOperationsClientMock extends AbstractMockClient implements LogbookOperationsClient { @Override public JsonNode switchIndexes(SwitchIndexParameters switchIndexParam) throws InvalidParseOperationException, LogbookClientServerException { return ClientMockResultHelper.getSwitchIndexesInfo().toJsonNode(); } @Override void create(LogbookOperationParameters parameters); @Override void update(LogbookOperationParameters parameters); @Override JsonNode selectOperation(JsonNode select); @Override JsonNode selectOperationSliced(JsonNode select); @Override JsonNode selectOperationById(String id); @Override RequestResponseOK traceability(); @Override void createDelegate(LogbookOperationParameters parameters); @Override void updateDelegate(LogbookOperationParameters parameters); @Override void bulkCreate(String eventIdProc, Iterable<LogbookOperationParameters> queue); @Override void bulkUpdate(String eventIdProc, Iterable<LogbookOperationParameters> queue); @Override void commitCreateDelegate(String eventIdProc); @Override void commitUpdateDelegate(String eventIdProc); @Override void close(); @Override RequestResponseOK traceabilityLfcUnit(); @Override RequestResponseOK traceabilityLfcObjectGroup(); @Override JsonNode reindex(IndexParameters indexParam); @Override JsonNode switchIndexes(SwitchIndexParameters switchIndexParam); @Override void traceabilityAudit(int tenant, AuditLogbookOptions options); @Override LogbookCheckResult checkLogbookCoherence(); @Override LifecycleTraceabilityStatus checkLifecycleTraceabilityWorkflowStatus(String operationId); }### Answer:
@Test public void switchIndexesTest() throws LogbookClientServerException, InvalidParseOperationException { final LogbookOperationsClient client = LogbookOperationsClientFactory.getInstance().getClient(); assertNotNull(client.switchIndexes(new SwitchIndexParameters())); }
|
### Question:
LogbookOperationsClientMock extends AbstractMockClient implements LogbookOperationsClient { @Override public void traceabilityAudit(int tenant, AuditLogbookOptions options) { LOGGER.info("audit traceability"); } @Override void create(LogbookOperationParameters parameters); @Override void update(LogbookOperationParameters parameters); @Override JsonNode selectOperation(JsonNode select); @Override JsonNode selectOperationSliced(JsonNode select); @Override JsonNode selectOperationById(String id); @Override RequestResponseOK traceability(); @Override void createDelegate(LogbookOperationParameters parameters); @Override void updateDelegate(LogbookOperationParameters parameters); @Override void bulkCreate(String eventIdProc, Iterable<LogbookOperationParameters> queue); @Override void bulkUpdate(String eventIdProc, Iterable<LogbookOperationParameters> queue); @Override void commitCreateDelegate(String eventIdProc); @Override void commitUpdateDelegate(String eventIdProc); @Override void close(); @Override RequestResponseOK traceabilityLfcUnit(); @Override RequestResponseOK traceabilityLfcObjectGroup(); @Override JsonNode reindex(IndexParameters indexParam); @Override JsonNode switchIndexes(SwitchIndexParameters switchIndexParam); @Override void traceabilityAudit(int tenant, AuditLogbookOptions options); @Override LogbookCheckResult checkLogbookCoherence(); @Override LifecycleTraceabilityStatus checkLifecycleTraceabilityWorkflowStatus(String operationId); }### Answer:
@Test public void traceabilityAuditTest() throws LogbookClientServerException, InvalidParseOperationException { final LogbookOperationsClient client = LogbookOperationsClientFactory.getInstance().getClient(); client.traceabilityAudit(0, new AuditLogbookOptions()); }
|
### Question:
LogbookClientException extends VitamException { public LogbookClientException(String message) { super(message); } LogbookClientException(String message); LogbookClientException(Throwable cause); LogbookClientException(String messsage, Throwable cause); }### Answer:
@Test public final void testLogbookClientException() { assertEquals(null, new LogbookClientException((String) null).getMessage()); assertEquals("test", new LogbookClientException("test").getMessage()); assertNotNull(new LogbookClientException(new Exception()).getCause()); assertNotNull(new LogbookClientException("test", new Exception()).getCause()); }
|
### Question:
MessageLogbookEngineHelper { public String getLabelOp(String stepOrHandler, StatusCode code, Object... args) { return VitamLogbookMessages.getFromFullCodeKey(getOutcomeDetail(stepOrHandler, code), args); } MessageLogbookEngineHelper(LogbookTypeProcess logbookTypeProcess); String getLabelOp(String stepOrHandler, StatusCode code, Object... args); String getLabelOp(String stepOrHandler, String transaction, StatusCode code, Object... args); String getOutcomeDetail(String stepOrHandler, StatusCode code); String getOutcomeDetail(String stepOrHandler, String transaction, StatusCode code); }### Answer:
@Test public void testMessages() { MessageLogbookEngineHelper messageLogbookEngineHelper = new MessageLogbookEngineHelper(LogbookTypeProcess.HOLDINGSCHEME); String label = messageLogbookEngineHelper.getLabelOp(LogbookTypeProcess.HOLDINGSCHEME.name(), StatusCode.STARTED); assertEquals("HOLDING SCHEME started", label); label = messageLogbookEngineHelper.getLabelOp(STP_STEP, StatusCode.STARTED); assertEquals("HOLDING SCHEME step started", label); label = messageLogbookEngineHelper.getLabelOp(STP_STEP, TRANSACTION, StatusCode.STARTED); assertEquals("HOLDING SCHEME step TRANSACTION started", label); messageLogbookEngineHelper = new MessageLogbookEngineHelper(LogbookTypeProcess.FILINGSCHEME); label = messageLogbookEngineHelper.getLabelOp(STP_STEP, StatusCode.STARTED); assertEquals("step started", label); label = messageLogbookEngineHelper.getLabelOp(STP_STEP, TRANSACTION, StatusCode.STARTED); assertEquals("step TRANSACTION started", label); }
|
### Question:
LogbookOperationsImpl implements LogbookOperations { @Override public void create(LogbookOperationParameters parameters) throws LogbookAlreadyExistsException, LogbookDatabaseException { mongoDbAccess.createLogbookOperation(parameters); backupOperation(parameters); } 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 = LogbookDatabaseException.class) public void givenCreateOperationWhenErrorInMongoThenThrowLogbookException() throws Exception { reset(mongoDbAccess); doThrow(LogbookDatabaseException.class).when(mongoDbAccess).createLogbookOperation(any()); logbookOperationsImpl.create(logbookParameters); }
@Test(expected = LogbookAlreadyExistsException.class) public void givenCreateOperationWhenOperationAlreadyExistsThenThrowLogbookException() throws Exception { reset(mongoDbAccess); doThrow(LogbookAlreadyExistsException.class).when(mongoDbAccess).createLogbookOperation(any()); logbookOperationsImpl.create(logbookParameters); }
|
### Question:
LogbookOperationsImpl implements LogbookOperations { @Override public void update(LogbookOperationParameters parameters) throws LogbookNotFoundException, LogbookDatabaseException { mongoDbAccess.updateLogbookOperation(parameters); backupOperation(parameters); } 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 = LogbookDatabaseException.class) public void givenUpdateOperationWhenErrorInMongoThenThrowLogbookException() throws Exception { reset(mongoDbAccess); doThrow(LogbookDatabaseException.class).when(mongoDbAccess).updateLogbookOperation(any()); logbookOperationsImpl.update(logbookParameters); }
@Test(expected = LogbookNotFoundException.class) public void givenUpdateOperationWhenOperationNotExistsThenThrowLogbookException() throws Exception { reset(mongoDbAccess); doThrow(LogbookNotFoundException.class).when(mongoDbAccess).updateLogbookOperation(any()); logbookOperationsImpl.update(logbookParameters); }
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.