method2testcases
stringlengths 118
3.08k
|
|---|
### Question:
VitamServerFactory { public static VitamServer newVitamServerByJettyConf(final String jettyConfigFile) throws VitamApplicationServerException { try { ParametersChecker.checkParameter("jetty config file", jettyConfigFile); return new BasicVitamServer(jettyConfigFile); } catch (final IllegalArgumentException e) { LOGGER.error( "Jetty server can not run with this jetty config file : " + jettyConfigFile + " " + e.getMessage(), e); throw new VitamApplicationServerException( "Jetty server can not run with this jetty config file : " + jettyConfigFile); } } private VitamServerFactory(); static VitamServer newVitamServerOnDefaultPort(); static void setDefaultPort(int port); static int getDefaultPort(); static VitamServer newVitamServer(int port); static VitamServer newVitamServerWithoutConnector(int port); static VitamServer newVitamServerByJettyConf(final String jettyConfigFile); }### Answer:
@Test public final void testNewVitamServerFromJettyConfig() { try { final VitamServer server = VitamServerFactory.newVitamServerByJettyConf(JETTY_CONFIG_TEST); final Server jettyServer = server.getServer(); jettyServer.start(); Assert.assertTrue(jettyServer.isStarted()); if (jettyServer != null && jettyServer.isStarted()) { jettyServer.stop(); } Assert.assertTrue(jettyServer.isStopped()); } catch (final Exception e) { LOGGER.error(e.getMessage(), e); } }
@Test public final void testNewVitamServerFromNotJettyConfig() { VitamServer server = null; try { server = VitamServerFactory.newVitamServerByJettyConf(null); } catch (final Exception e) { LOGGER.error(e.getMessage(), e); Assert.assertTrue(server == null); } }
|
### Question:
DbConfigurationImpl extends DefaultVitamApplicationConfiguration implements DbConfiguration { @Override public List<MongoDbNode> getMongoDbNodes() { return mongoDbNodes; } DbConfigurationImpl(); DbConfigurationImpl(List<MongoDbNode> mongoDbNodes, String dbName, boolean dbAuthentication,
String dbUserName, String dbPassword); DbConfigurationImpl(List<MongoDbNode> mongoDbNodes, String dbName); @Override List<MongoDbNode> getMongoDbNodes(); @Override String getDbName(); @Override String getDbUserName(); @Override String getDbPassword(); @Override boolean isDbAuthentication(); DbConfigurationImpl setMongoDbNodes(List<MongoDbNode> mongoDbNodes); DbConfigurationImpl setDbName(String dbName); DbConfigurationImpl setDbUserName(String userName); DbConfigurationImpl setDbPassword(String password); DbConfigurationImpl setDbAuthentication(boolean authentication); }### Answer:
@Test public void testEmpty() { final DbConfigurationImpl dbConfiguration0 = new DbConfigurationImpl(); final List<MongoDbNode> nodes = dbConfiguration0.getMongoDbNodes(); assertNull(nodes); }
|
### Question:
HttpHeaderHelper { public static void checkVitamHeaders(HttpHeaders headers) { ParametersChecker.checkParameter("Headers cannot be null", headers); final MultivaluedMap<String, String> requestHeaders = headers.getRequestHeaders(); checkVitamHeadersMap(requestHeaders); } private HttpHeaderHelper(); static List<String> getHeaderValues(HttpHeaders headers, VitamHttpHeader name); static List<String> getHeaderValues(HttpHeaders headers, String name); static boolean hasValuesFor(HttpHeaders headers, VitamHttpHeader vitamHeader); static void checkVitamHeaders(HttpHeaders headers); static void checkVitamHeadersMap(MultivaluedMap<String, String> requestHeaders); static void validateHeaderValue(HttpHeaders headers, MultivaluedHashMap<String, String> wantedHeaders); }### Answer:
@Test(expected = IllegalArgumentException.class) public void checkVitamHeadersNullTest() { HttpHeaderHelper.checkVitamHeaders(null); }
@Test public void checkAllVitamHeadersRegexValidTest() { final MultivaluedMap<String, String> map = new MultivaluedHashMap<>(); map.put(VitamHttpHeader.METHOD_OVERRIDE.getName(), Collections.singletonList("get")); map.put(VitamHttpHeader.STRATEGY_ID.getName(), Collections.singletonList("an id")); map.put(VitamHttpHeader.TENANT_ID.getName(), Collections.singletonList("an id")); Mockito.when(httpHeadersMock.getRequestHeaders()).thenReturn(map); HttpHeaderHelper.checkVitamHeaders(httpHeadersMock); }
@Test public void checkVitamHeadersTest() { final MultivaluedMap<String, String> map = new MultivaluedHashMap<>(); map.put(VitamHttpHeader.METHOD_OVERRIDE.getName(), Collections.singletonList("get")); map.put(VitamHttpHeader.STRATEGY_ID.getName(), Collections.singletonList("get")); map.put(VitamHttpHeader.TENANT_ID.getName(), Collections.singletonList("get")); Mockito.when(httpHeadersMock.getRequestHeaders()).thenReturn(map); HttpHeaderHelper.checkVitamHeaders(httpHeadersMock); }
|
### Question:
HttpHeaderHelper { public static List<String> getHeaderValues(HttpHeaders headers, VitamHttpHeader name) { ParametersChecker.checkParameter("Name cannot be null", name); return getHeaderValues(headers, name.getName()); } private HttpHeaderHelper(); static List<String> getHeaderValues(HttpHeaders headers, VitamHttpHeader name); static List<String> getHeaderValues(HttpHeaders headers, String name); static boolean hasValuesFor(HttpHeaders headers, VitamHttpHeader vitamHeader); static void checkVitamHeaders(HttpHeaders headers); static void checkVitamHeadersMap(MultivaluedMap<String, String> requestHeaders); static void validateHeaderValue(HttpHeaders headers, MultivaluedHashMap<String, String> wantedHeaders); }### Answer:
@Test public void getHeaderValuesTest() { Mockito.when(httpHeadersMock.getRequestHeader(VitamHttpHeader.METHOD_OVERRIDE.getName())).thenReturn(Collections .singletonList("get")); final List<String> values = HttpHeaderHelper.getHeaderValues(httpHeadersMock, VitamHttpHeader.METHOD_OVERRIDE); assertNotNull(values); assertEquals(1, values.size()); assertEquals("get", values.get(0)); }
@Test(expected = IllegalArgumentException.class) public void getHeaderValuesStringNullTest() { HttpHeaderHelper.getHeaderValues(httpHeadersMock, (String) null); }
@Test(expected = IllegalArgumentException.class) public void getHeaderValuesEnumNullTest() { HttpHeaderHelper.getHeaderValues(httpHeadersMock, (VitamHttpHeader) null); }
@Test(expected = IllegalArgumentException.class) public void getHeaderValuesHeaderNullTest() { HttpHeaderHelper.getHeaderValues(null, VitamHttpHeader.STRATEGY_ID); }
|
### Question:
HttpHeaderHelper { public static boolean hasValuesFor(HttpHeaders headers, VitamHttpHeader vitamHeader) { ParametersChecker.checkParameter("Header name cannot be null", vitamHeader); ParametersChecker.checkParameter("Headers cannot be null", headers); final List<String> values = headers.getRequestHeader(vitamHeader.getName()); return values != null && !values.isEmpty(); } private HttpHeaderHelper(); static List<String> getHeaderValues(HttpHeaders headers, VitamHttpHeader name); static List<String> getHeaderValues(HttpHeaders headers, String name); static boolean hasValuesFor(HttpHeaders headers, VitamHttpHeader vitamHeader); static void checkVitamHeaders(HttpHeaders headers); static void checkVitamHeadersMap(MultivaluedMap<String, String> requestHeaders); static void validateHeaderValue(HttpHeaders headers, MultivaluedHashMap<String, String> wantedHeaders); }### Answer:
@Test(expected = IllegalArgumentException.class) public void hasValueForVitamHeaderNullTest() { HttpHeaderHelper.hasValuesFor(null, null); }
@Test public void hasValueForTest() { Mockito.when(httpHeadersMock.getRequestHeader(VitamHttpHeader.METHOD_OVERRIDE.getName())).thenReturn( Collections.singletonList("get")); HttpHeaderHelper.hasValuesFor(httpHeadersMock, VitamHttpHeader.METHOD_OVERRIDE); }
|
### Question:
VitamServerLifeCycle implements Listener { @Override public void lifeCycleStarted(LifeCycle event) { VitamThreadPoolExecutor.getDefaultExecutor().execute(() -> processLifeCycle.startProcess()); } VitamServerLifeCycle(ProcessLifeCycle processLifeCycle); @Override void lifeCycleStarting(LifeCycle event); @Override void lifeCycleStarted(LifeCycle event); @Override void lifeCycleFailure(LifeCycle event, Throwable cause); @Override void lifeCycleStopping(LifeCycle event); @Override void lifeCycleStopped(LifeCycle event); }### Answer:
@Test public void whenLifeCycleStartedThenProcessLifeCycleStartProcess() throws InterruptedException { ProcessLifeCycle plc = mock(ProcessLifeCycle.class); final Semaphore semaphore = new Semaphore(0); doAnswer(o -> { semaphore.release(); return o; }).when(plc).startProcess(); new VitamServerLifeCycle(plc).lifeCycleStarted(mock(LifeCycle.class)); semaphore.tryAcquire(1, TimeUnit.SECONDS); verify(plc).startProcess(); }
|
### Question:
VitamServerLifeCycle implements Listener { @Override public void lifeCycleStopping(LifeCycle event) { processLifeCycle.stopProcess(); } VitamServerLifeCycle(ProcessLifeCycle processLifeCycle); @Override void lifeCycleStarting(LifeCycle event); @Override void lifeCycleStarted(LifeCycle event); @Override void lifeCycleFailure(LifeCycle event, Throwable cause); @Override void lifeCycleStopping(LifeCycle event); @Override void lifeCycleStopped(LifeCycle event); }### Answer:
@Test public void whenLifeCycleStoppingThenProcessLifeCycleStopProcess() { ProcessLifeCycle plc = mock(ProcessLifeCycle.class); new VitamServerLifeCycle(plc).lifeCycleStopping(mock(LifeCycle.class)); verify(plc).stopProcess(); }
|
### Question:
SedaVersion { public SedaVersion() { binaryDataObjectVersions = new ArrayList<String>(); physicalDataObjectVersions = new ArrayList<String>(); } SedaVersion(); List<String> getVersionForType(String type); List<String> getVersionForOtherType(String type); void setBinaryDataObjectVersions(String[] binaryDataObjectVersions); void setPhysicalDataObjectVersions(String[] physicalDataObjectVersions); boolean isSupportedVesion(final String version); }### Answer:
@Test public void testSedaVersion() { final SedaVersion sedaVersion = new SedaVersion(); sedaVersion.setBinaryDataObjectVersions(new String[] {"TEST1","TEST2"}); sedaVersion.setPhysicalDataObjectVersions(new String[] {"TEST3","TEST4"}); assertNotNull(sedaVersion.getVersionForType("BinaryDataObject")); assertNotNull(sedaVersion.getVersionForType("PhysicalDataObject")); assertEquals(0, sedaVersion.getVersionForType("Bleah").size()); assertEquals("TEST1", sedaVersion.getVersionForType("BinaryDataObject").get(0)); assertEquals("TEST4", sedaVersion.getVersionForType("PhysicalDataObject").get(1)); }
|
### Question:
X509KeystoreFileRealm extends AbstractX509Realm { @Override public Class<X509AuthenticationToken> getAuthenticationTokenClass() { return X509AuthenticationToken.class; } X509KeystoreFileRealm(); @Override boolean supports(AuthenticationToken token); @Override Class<X509AuthenticationToken> getAuthenticationTokenClass(); Map<String, String> getCertificateDnRoleMapping(); void setCertificateDnRoleMapping(Map<String, String> certificateDnRoleMapping); }### Answer:
@Test public void testGettersAndSetters() { realm.getAuthenticationTokenClass(); assertEquals("src/test/resources/tls/server/granted_certs.jks", realm.getGrantedKeyStoreName()); assertEquals("azerty12", realm.getGrantedKeyStorePassphrase()); assertEquals("src/test/resources/tls/server/truststore.jks", realm.getTrustedKeyStoreName()); assertEquals("azerty10", realm.getTrustedKeyStorePassphrase()); }
|
### Question:
X509KeystoreFileRealm extends AbstractX509Realm { @Override protected AuthenticationInfo doGetAuthenticationInfo(AuthenticationToken token) { return doGetX509AuthenticationInfo((X509AuthenticationToken) token); } X509KeystoreFileRealm(); @Override boolean supports(AuthenticationToken token); @Override Class<X509AuthenticationToken> getAuthenticationTokenClass(); Map<String, String> getCertificateDnRoleMapping(); void setCertificateDnRoleMapping(Map<String, String> certificateDnRoleMapping); }### Answer:
@Test public void givenRealmWhenKeyStoreNotFoundThenReturnNull() { realm.setGrantedKeyStoreName("XXX.jks"); realm.setGrantedKeyStorePassphrase("gazerty"); final X509Certificate[] clientCertChain = new X509Certificate[] {cert}; final X509AuthenticationToken token = new X509AuthenticationToken(clientCertChain, "XXX"); assertNull(realm.doGetAuthenticationInfo(token)); }
@Test public void givenRealmWhenP12NotGrantedThenReturnNull() throws KeyStoreException, NoSuchAlgorithmException, CertificateException, IOException { final InputStream inStream = new FileInputStream("src/test/resources/tls/client/client_notgranted.p12"); final KeyStore ks = KeyStore.getInstance("PKCS12"); ks.load(inStream, "vitam2016".toCharArray()); final String alias = ks.aliases().nextElement(); final X509Certificate certificate = (X509Certificate) ks.getCertificate(alias); final X509Certificate[] clientCertChain = new X509Certificate[] {certificate}; final X509AuthenticationToken token = new X509AuthenticationToken(clientCertChain, "XXX"); final X509AuthenticationInfo info = (X509AuthenticationInfo) realm.doGetAuthenticationInfo(token); assertNull(info); }
|
### Question:
X509AuthenticationFilter extends AuthenticatingFilter { @Override protected boolean onAccessDenied(ServletRequest request, ServletResponse response) throws Exception { if (!executeLogin(request, response)) { ((HttpServletResponse) response).sendError(403, "Access Denied . Need a valid TLS client certificate"); return false; } return true; } void setUseHeader(boolean useHeader); }### Answer:
@Test public void givenFilterAccessDenied() throws Exception { when(request.getAttribute("javax.servlet.request.X509Certificate")).thenReturn(new X509Certificate[] {cert}); Subject subjectUnderTest = mock(Subject.class); Mockito.doNothing().when(subjectUnderTest).login(any()); setSubject(subjectUnderTest); final X509AuthenticationFilter filter = new X509AuthenticationFilter(); filter.onAccessDenied(request, response); }
|
### Question:
X509AuthenticationFilter extends AuthenticatingFilter { @Override protected AuthenticationToken createToken(ServletRequest request, ServletResponse response) { X509Certificate[] clientCertChain = CertUtils.extractCert(request, useHeader); if (clientCertChain == null || clientCertChain.length < 1) { throw new ShiroException("Request do not contain any X509Certificate "); } return new X509AuthenticationToken(clientCertChain, getHost(request)); } void setUseHeader(boolean useHeader); }### Answer:
@Test public void givenFilterCreateToken() throws Exception { when(request.getAttribute("javax.servlet.request.X509Certificate")).thenReturn(new X509Certificate[] {cert}); final X509AuthenticationFilter filter = new X509AuthenticationFilter(); filter.createToken(request, response); }
@Test(expected = Exception.class) public void givenFilterCreateTokenWhenClientCertChainNullThenThrowException() throws Exception { final X509AuthenticationFilter filter = new X509AuthenticationFilter(); filter.createToken(requestNull, response); }
|
### Question:
TimestampGenerator { public byte[] generateToken(byte[] hash, DigestType digestType, BigInteger nonce) throws TimeStampException { final TimeStampRequestGenerator reqGen = new TimeStampRequestGenerator(); reqGen.setCertReq(true); final TimeStampRequest request = reqGen.generate(digestToOid(digestType), hash, nonce); try { TimeStampResponse timeStampResponse = timeStampSignature.sign(request); timeStampResponse.validate(request); return timeStampResponse.getEncoded(); } catch (OperatorCreationException | TSPException | CertificateEncodingException | IOException e) { throw new TimeStampException("unable to generate timestamp token", e); } } TimestampGenerator(TimeStampSignature timeStampSignature); byte[] generateToken(byte[] hash, DigestType digestType, BigInteger nonce); }### Answer:
@Test public void should_generate_a_time_stamp_request() throws TimeStampException, TSPException, CertificateEncodingException, OperatorCreationException { byte[] hash = new byte[20]; final TimeStampResponse timeStampResponse = mock(TimeStampResponse.class); final ArgumentCaptor<TimeStampRequest> timeStampRequestArgumentCaptor = ArgumentCaptor.forClass(TimeStampRequest.class); given(timeStampSignature.sign(timeStampRequestArgumentCaptor.capture())).willReturn(timeStampResponse); timestampGenerator.generateToken(hash, DigestType.SHA1, BigInteger.TEN); final TimeStampRequest capture = timeStampRequestArgumentCaptor.getValue(); assertThat(capture.getNonce()).isEqualTo(BigInteger.TEN); assertThat(capture.getMessageImprintDigest()).isEqualTo(hash); }
|
### Question:
JunitHelper extends ExternalResource { public static final void testPrivateConstructor(Class<?> clasz) { Constructor<?> c; try { c = clasz.getDeclaredConstructor(); c.setAccessible(true); c.newInstance(); } catch (NoSuchMethodException | SecurityException | InstantiationException | IllegalAccessException | IllegalArgumentException | InvocationTargetException | UnsupportedOperationException e) { SysErrLogger.FAKE_LOGGER.ignoreLog(e); } } private JunitHelper(); static final JunitHelper getInstance(); final synchronized int findAvailablePort(); final synchronized int findAvailablePort(String environmentVariable); final synchronized void releasePort(int port); final boolean isListeningOn(int port); final boolean isListeningOn(String host, int port); static final long consumeInputStream(InputStream inputStream); static final long consumeInputStreamPerByte(InputStream inputStream); static final void awaitFullGc(); static final void setJettyPortSystemProperty(String environmentVariable, int port); static final void unsetJettyPortSystemProperty(); static final void testPrivateConstructor(Class<?> clasz); static final int MIN_PORT; static final String PARAMETER_JETTY_SERVER_PORT_ADMIN; }### Answer:
@Test public void testPrivateConstructor() { JunitHelper.testPrivateConstructor(JunitHelper.class); JunitHelper.testPrivateConstructor(ToNotAllocate.class); }
|
### Question:
FakeInputStream extends InputStream { @Override public int read() { if (limit <= 0) { return -1; } limit--; read++; return getValue(); } FakeInputStream(long limit); FakeInputStream(long limit, boolean block); FakeInputStream(long limit, boolean block, boolean useRandom); @Override int read(); @Override int available(); @Override void close(); @Override int read(byte[] b, int off, int len); @Override int read(byte[] b); long readCount(); }### Answer:
@Test public void testRead() { int len = 100; try (FakeInputStream fakeInputStream = new FakeInputStream(len, true)) { assertEquals(len, JunitHelper.consumeInputStreamPerByte(fakeInputStream)); } try (FakeInputStream fakeInputStream = new FakeInputStream(len, false)) { assertEquals(len, JunitHelper.consumeInputStreamPerByte(fakeInputStream)); } len = 1000000; try (FakeInputStream fakeInputStream = new FakeInputStream(len, true)) { assertEquals(len, JunitHelper.consumeInputStreamPerByte(fakeInputStream)); } try (FakeInputStream fakeInputStream = new FakeInputStream(len, false)) { assertEquals(len, JunitHelper.consumeInputStreamPerByte(fakeInputStream)); } }
|
### Question:
FakeInputStream extends InputStream { @Override public int available() { if (limit > Integer.MAX_VALUE) { return Integer.MAX_VALUE; } return (int) limit; } FakeInputStream(long limit); FakeInputStream(long limit, boolean block); FakeInputStream(long limit, boolean block, boolean useRandom); @Override int read(); @Override int available(); @Override void close(); @Override int read(byte[] b, int off, int len); @Override int read(byte[] b); long readCount(); }### Answer:
@Test public void testAvailable() { final int len = 100; try (FakeInputStream fakeInputStream = new FakeInputStream(len, true)) { assertEquals(len, fakeInputStream.available()); fakeInputStream.read(); assertEquals(len - 1, fakeInputStream.available()); assertEquals(1, fakeInputStream.readCount()); } try (FakeInputStream fakeInputStream = new FakeInputStream(len, false)) { assertEquals(len, fakeInputStream.available()); fakeInputStream.read(); assertEquals(len - 1, fakeInputStream.available()); assertEquals(1, fakeInputStream.readCount()); } }
|
### Question:
StringUtils { public static final byte[] getBytesFromArraysToString(final String bytesString) { ParametersChecker.checkParameter("Should not be null or empty", bytesString); final String[] strings = bytesString.replace("[", "").replace("]", "").split(", "); final byte[] result = new byte[strings.length]; try { for (int i = 0; i < result.length; i++) { result[i] = (byte) (Integer.parseInt(strings[i]) & 0xFF); } } catch (final NumberFormatException e) { throw new IllegalArgumentException(e); } return result; } private StringUtils(); static String checkSanityString(String value); static void checkSanityString(String ...strings); static final byte[] getRandom(final int length); static final byte[] getBytesFromArraysToString(final String bytesString); static final String getClassName(Object object); static final String substringBetween(String source, String start, String end); static final String substringBeforeLast(String source, String separator); static String getStringFromInputStream(InputStream is); static final Pattern HTML_PATTERN; static final Pattern UNPRINTABLE_PATTERN; static final List<String> RULES; }### Answer:
@Test public void testException() { try { StringUtils.getBytesFromArraysToString((String) null); fail(ResourcesPublicUtilTest.EXPECTING_EXCEPTION_ILLEGAL_ARGUMENT_EXCEPTION); } catch (final IllegalArgumentException e) { } try { StringUtils.getBytesFromArraysToString(""); fail(ResourcesPublicUtilTest.EXPECTING_EXCEPTION_ILLEGAL_ARGUMENT_EXCEPTION); } catch (final IllegalArgumentException e) { } try { StringUtils.getBytesFromArraysToString("[ 7, a6 ]"); fail(ResourcesPublicUtilTest.EXPECTING_EXCEPTION_ILLEGAL_ARGUMENT_EXCEPTION); } catch (final IllegalArgumentException e) { } }
|
### Question:
AbstractJsonType { public ObjectNode generateJson() { String value; try { value = JsonHandler.writeAsString(this); return (ObjectNode) JsonHandler.getFromString(value); } catch (final InvalidParseOperationException e) { LOGGER.warn("Cannot parse the Object", e); } return JsonHandler.createObjectNode(); } ObjectNode generateJson(); String generateJsonString(); void writeJsonToFile(File file); static AbstractJsonType readJsonFile(File file); static AbstractJsonType readJsonString(String data); }### Answer:
@Test public final void testGenerateJson() throws InvalidParseOperationException, FileNotFoundException { final TestClass tc = new TestClass().setA("val"); tc.generateJson(); final File file = ResourcesPublicUtilTest.getInstance().getJsonTest2JsonFile(); if (file == null) { LOGGER.error(ResourcesPublicUtilTest.CANNOT_FIND_RESOURCES_TEST_FILE); } Assume.assumeTrue(ResourcesPublicUtilTest.CANNOT_FIND_RESOURCES_TEST_FILE, file != null); final TestClass tc2 = (TestClass) AbstractJsonType.readJsonFile(file); assertEquals(tc2.getA(), tc.getA()); AbstractJsonType.readJsonString(tc.generateJsonString()); File file2; try { file2 = File.createTempFile("test", "test", file.getParentFile()); tc2.writeJsonToFile(file2); final TestClass tc3 = (TestClass) AbstractJsonType.readJsonFile(file2); assertEquals(tc2.getA(), tc3.getA()); } catch (final IOException e) { } }
|
### Question:
Step { public void defaultLifecycleLog(LifecycleState lifecycleLog) { actions.forEach(action -> { boolean distributed = distribution.getKind().isDistributed(); if (distributed) { action.getActionDefinition().defaultLifecycleLog(lifecycleLog); } else { action.getActionDefinition().defaultLifecycleLog(DISABLED); } }); } Step(); @JsonCreator Step(
@JsonProperty("id") String id,
@JsonProperty("workerGroupId") String workerGroupId,
@JsonProperty("stepName") String stepName,
@JsonProperty("behavior") ProcessBehavior behavior,
@JsonProperty("distribution") Distribution distribution,
@JsonProperty("actions") List<Action> actions); String getId(); void setId(String id); List<Action> getActions(); Step setActions(List<Action> actions); String getWorkerGroupId(); Step setWorkerGroupId(String workerGroupId); String getStepName(); Step setStepName(String stepName); Distribution getDistribution(); Step setDistribution(Distribution distribution); ProcessBehavior getBehavior(); Step setBehavior(ProcessBehavior behavior); ItemStatus getStepResponses(); Step setStepResponses(ItemStatus stepResponses); @JsonIgnore boolean shallStop(); @JsonIgnore boolean isBlocking(); @JsonIgnore boolean isFinally(); PauseOrCancelAction getPauseOrCancelAction(); Step setPauseOrCancelAction(PauseOrCancelAction pauseOrCancelAction); void defaultLifecycleLog(LifecycleState lifecycleLog); }### Answer:
@Test public void should_not_log_id_we_distribute_only_one_element() { Distribution distribution = new Distribution(); distribution.setKind(DistributionKind.REF); Action action = new Action(); action.setActionDefinition( new ActionDefinition("actionKey", ProcessBehavior.NOBLOCKING, null, new ArrayList<>(), new ArrayList<>())); ArrayList<Action> actions = new ArrayList<>(); actions.add(action); Step step = new Step(null, "workerId", "stepName", ProcessBehavior.NOBLOCKING, distribution, actions); step.defaultLifecycleLog(LifecycleState.TEMPORARY); boolean lifecycleEnabled = action.getActionDefinition().lifecycleEnabled(); assertThat(lifecycleEnabled).isFalse(); }
|
### Question:
RequestResponseOK extends RequestResponse<T> { public RequestResponseOK<T> addAllResults(List<T> resultList) { ParametersChecker.checkParameter("Result list is a mandatory parameter", resultList); results.addAll(resultList); hits.setSize(hits.getSize() + resultList.size()); hits.setTotal(hits.getSize()); return this; } RequestResponseOK(); RequestResponseOK(JsonNode query); RequestResponseOK<T> addResult(T result); RequestResponseOK<T> addAllResults(List<T> resultList); RequestResponseOK<T> addFacetResult(FacetResult facetResult); RequestResponseOK<T> addAllFacetResults(List<FacetResult> facetResultList); DatabaseCursor getHits(); RequestResponseOK<T> setHits(DatabaseCursor hits); RequestResponseOK<T> setHits(long total, int offset, int limit); RequestResponseOK<T> setHits(long total, int offset, int limit, int size, String scrollId); RequestResponseOK<T> setHits(long total, int offset, int limit, int size); RequestResponseOK<T> setTotal(long total); RequestResponseOK<T> setScrollId(String scrollId); List<FacetResult> getFacetResults(); List<T> getResults(); JsonNode getQuery(); @JsonIgnore T getFirstResult(); RequestResponseOK<T> setQuery(JsonNode query); @JsonIgnore boolean isEmpty(); static RequestResponseOK<JsonNode> getFromJsonNode(JsonNode node); static RequestResponseOK<T> getFromJsonNode(JsonNode node, Class<T> clazz); @JsonIgnore List<JsonNode> getResultsAsJsonNodes(); RequestResponseOK<T> setHttpCode(int httpCode); @Override Response toResponse(); static final String TAG_RESULTS; static final String TAG_FACET_RESULTS; static final String TAG_CONTEXT; }### Answer:
@Test(expected = IllegalArgumentException.class) public final void testRequestResponseOKAddNull() { final RequestResponseOK requestResponseOK = new RequestResponseOK(); requestResponseOK.addAllResults(null); }
|
### Question:
ObjectEntryReader implements CloseableIterator<ObjectEntry> { @Override public boolean hasNext() { if (!iterator.hasNext()) { throw new RuntimeException("Premature EOF"); } String nextEntry = iterator.peek(); return !EMPTY_ENTRY.equals(nextEntry); } ObjectEntryReader(InputStream inputStream); @Override boolean hasNext(); @Override ObjectEntry next(); @Override void close(); }### Answer:
@Test public void testEmptyWithEof() throws IOException { ByteArrayOutputStream innerStream = new ByteArrayOutputStream(); try (ObjectEntryWriter writer = new ObjectEntryWriter(innerStream)) { writer.writeEof(); } try (ObjectEntryReader reader = new ObjectEntryReader(innerStream.toInputStream())) { assertThat(reader.hasNext()).isFalse(); } }
|
### Question:
ObjectEntryWriter implements AutoCloseable { public void writeEof() throws IOException { ensureNotClosed(); ensureNotEof(); if (!isEmpty) { writer.append("\n"); } isEmpty = false; writer.write(EMPTY_ENTRY); isEofWritten = true; } ObjectEntryWriter(OutputStream ouputStream); void write(ObjectEntry objectEntry); void writeEof(); @Override void close(); }### Answer:
@Test public void testEmptyWithEof() throws IOException { ByteArrayOutputStream innerStream = new ByteArrayOutputStream(); try(ObjectEntryWriter writer = new ObjectEntryWriter(innerStream)) { writer.writeEof(); } assertThat(innerStream.toInputStream()).hasContent("{}"); }
|
### Question:
ObjectEntryWriter implements AutoCloseable { public void write(ObjectEntry objectEntry) throws IOException { ParametersChecker.checkParameter(""); ensureNotClosed(); ensureNotEof(); if (!isEmpty) { writer.append("\n"); } isEmpty = false; writer.write(JsonHandler.unprettyPrint(objectEntry)); } ObjectEntryWriter(OutputStream ouputStream); void write(ObjectEntry objectEntry); void writeEof(); @Override void close(); }### Answer:
@Test public void testEntriesWithoutEof() throws IOException { ByteArrayOutputStream innerStream = new ByteArrayOutputStream(); try(ObjectEntryWriter writer = new ObjectEntryWriter(innerStream)) { writer.write(new ObjectEntry("file1", 10L)); writer.write(new ObjectEntry("file2", 20L)); } assertThat(innerStream.toInputStream()).hasContent( "{\"objectId\":\"file1\",\"size\":10}\n" + "{\"objectId\":\"file2\",\"size\":20}"); }
|
### Question:
ObjectGroupResponse { @JsonIgnore public Optional<VersionsModel> getFirstVersionsModel(String qualifier) { Optional<QualifiersModel> modelOptional = getQualifiersModel(qualifier); if (modelOptional.isPresent()) { return modelOptional .get() .getVersions() .stream() .min(comparing(VersionsModel::getDataVersion)); } return empty(); } StorageRacineModel getStorage(); void setStorage(StorageRacineModel storage); List<QualifiersModel> getQualifiers(); void setQualifiers(List<QualifiersModel> qualifiers); String getId(); void setId(String id); int getTenant(); void setTenant(int tenant); FileInfoModel getFileInfo(); void setFileInfo(FileInfoModel fileInfo); List<String> getUp(); void setUp(List<String> up); List<String> getUs(); void setUs(List<String> us); int getNbc(); void setNbc(int nbc); List<String> getOps(); void setOps(List<String> ops); String getOriginatingAgency(); void setOriginatingAgency(String originatingAgency); List<String> getOriginatingAgencies(); void setOriginatingAgencies(List<String> originatingAgencies); String getVersion(); void setVersion(String version); String getType(); void setType(String type); String getOpi(); void setOpi(String opi); @JsonIgnore Optional<VersionsModel> getLastVersionsModel(String qualifier); @JsonIgnore Optional<VersionsModel> getFirstVersionsModel(String qualifier); }### Answer:
@Test public void shouldGetBinaryMasterVersion1Model() { FormatIdentificationModel formatIdentification = objectGroupModel.getFirstVersionsModel("BinaryMaster").get().getFormatIdentification(); assertThat(formatIdentification.getFormatId()).isEqualTo("fmt/354"); }
|
### Question:
ObjectGroupResponse { @JsonIgnore public Optional<VersionsModel> getLastVersionsModel(String qualifier) { Optional<QualifiersModel> first = getQualifiersModel(qualifier); if (first.isPresent()) { return first .get() .getVersions() .stream() .max(comparing(VersionsModel::getDataVersion)); } return empty(); } StorageRacineModel getStorage(); void setStorage(StorageRacineModel storage); List<QualifiersModel> getQualifiers(); void setQualifiers(List<QualifiersModel> qualifiers); String getId(); void setId(String id); int getTenant(); void setTenant(int tenant); FileInfoModel getFileInfo(); void setFileInfo(FileInfoModel fileInfo); List<String> getUp(); void setUp(List<String> up); List<String> getUs(); void setUs(List<String> us); int getNbc(); void setNbc(int nbc); List<String> getOps(); void setOps(List<String> ops); String getOriginatingAgency(); void setOriginatingAgency(String originatingAgency); List<String> getOriginatingAgencies(); void setOriginatingAgencies(List<String> originatingAgencies); String getVersion(); void setVersion(String version); String getType(); void setType(String type); String getOpi(); void setOpi(String opi); @JsonIgnore Optional<VersionsModel> getLastVersionsModel(String qualifier); @JsonIgnore Optional<VersionsModel> getFirstVersionsModel(String qualifier); }### Answer:
@Test public void shouldGetDisseminationLastVersion() { FormatIdentificationModel formatIdentification = objectGroupModel.getLastVersionsModel("Dissemination").get().getFormatIdentification(); assertThat(formatIdentification.getFormatId()).isEqualTo("fmt/355"); }
|
### Question:
RuleCategoryActionDeletion { public void setClassificationAudience(String unused) { this.classificationAudience = Optional.empty(); } @JsonIgnore Optional<List<RuleAction>> getRules(); void setRules(List<RuleAction> rules); @JsonGetter @JsonProperty("Rules") List<RuleAction> getRulesForDeserializer(); @JsonIgnore Optional<String> getFinalAction(); void setFinalAction(String unused); @JsonGetter @JsonProperty("FinalAction") String getFinalActionForDeserializer(); @JsonIgnore Optional<String> getClassificationAudience(); void setClassificationAudience(String unused); @JsonGetter @JsonProperty("ClassificationAudience") String getClassificationAudienceForDeserializer(); @JsonIgnore Optional<String> getClassificationReassessingDate(); void setClassificationReassessingDate(String unused); @JsonGetter @JsonProperty("ClassificationReassessingDate") String getClassificationReassessingDateForDeserializer(); @JsonIgnore Optional<Boolean> getNeedReassessingAuthorization(); void setNeedReassessingAuthorization(Boolean unused); @JsonGetter @JsonProperty("NeedReassessingAuthorization") Boolean getNeedReassessingAuthorizationForDeserializer(); @JsonIgnore Optional<Boolean> getPreventInheritance(); void setPreventInheritance(Boolean unused); @JsonGetter @JsonProperty("PreventInheritance") Boolean getPreventInheritanceForDeserializer(); @JsonIgnore Optional<Set<String>> getPreventRulesId(); void setPreventRulesId(Set<String> unused); @JsonGetter @JsonProperty("PreventRulesId") Set<String> getPreventRulesIdForDeserializer(); @JsonIgnore boolean isEmpty(); }### Answer:
@Test public void should_properly_deserialize_RuleActionDeletion() throws Exception { RuleCategoryActionDeletion actionDeletion = new RuleCategoryActionDeletion(); actionDeletion.setClassificationAudience(null); String actionDeletionAsString = new String(JsonHandler.fromPojoToBytes(actionDeletion)); assertThat(actionDeletionAsString).isEqualTo("{\n \"ClassificationAudience\" : \""+UNUSED_VALUE+"\"\n}"); }
|
### Question:
BaseXx { public static final String getBase16(byte[] bytes) { ParametersChecker.checkParameter(ARGUMENT_NULL_NOT_ALLOWED, bytes); return BASE16.encode(bytes); } private BaseXx(); static final String getBase16(byte[] bytes); static final String getBase32(byte[] bytes); static final String getBase64UrlWithoutPadding(byte[] bytes); static final String getBase64UrlWithPadding(byte[] bytes); static final String getBase64(byte[] bytes); static final byte[] getFromBase16(String base16); static final byte[] getFromBase32(String base32); static final byte[] getFromBase64UrlWithoutPadding(String base64); static final byte[] getFromBase64UrlPadding(String base64Padding); static final byte[] getFromBase64(String base64Padding); }### Answer:
@Test(expected = IllegalArgumentException.class) public void testBase16() throws IOException { BaseXx.getBase16(null); fail(ResourcesPublicUtilTest.EXPECTING_EXCEPTION_ILLEGAL_ARGUMENT_EXCEPTION); }
|
### Question:
BaseXx { public static final String getBase32(byte[] bytes) { ParametersChecker.checkParameter(ARGUMENT_NULL_NOT_ALLOWED, bytes); return BASE32.encode(bytes); } private BaseXx(); static final String getBase16(byte[] bytes); static final String getBase32(byte[] bytes); static final String getBase64UrlWithoutPadding(byte[] bytes); static final String getBase64UrlWithPadding(byte[] bytes); static final String getBase64(byte[] bytes); static final byte[] getFromBase16(String base16); static final byte[] getFromBase32(String base32); static final byte[] getFromBase64UrlWithoutPadding(String base64); static final byte[] getFromBase64UrlPadding(String base64Padding); static final byte[] getFromBase64(String base64Padding); }### Answer:
@Test(expected = IllegalArgumentException.class) public void testBase32() throws FileNotFoundException { BaseXx.getBase32(null); fail(ResourcesPublicUtilTest.EXPECTING_EXCEPTION_ILLEGAL_ARGUMENT_EXCEPTION); }
|
### Question:
BaseXx { public static final String getBase64UrlWithoutPadding(byte[] bytes) { ParametersChecker.checkParameter(ARGUMENT_NULL_NOT_ALLOWED, bytes); return BASE64_URL_WITHOUT_PADDING.encode(bytes); } private BaseXx(); static final String getBase16(byte[] bytes); static final String getBase32(byte[] bytes); static final String getBase64UrlWithoutPadding(byte[] bytes); static final String getBase64UrlWithPadding(byte[] bytes); static final String getBase64(byte[] bytes); static final byte[] getFromBase16(String base16); static final byte[] getFromBase32(String base32); static final byte[] getFromBase64UrlWithoutPadding(String base64); static final byte[] getFromBase64UrlPadding(String base64Padding); static final byte[] getFromBase64(String base64Padding); }### Answer:
@Test(expected = IllegalArgumentException.class) public void testBase64() throws IOException { BaseXx.getBase64UrlWithoutPadding(null); fail(ResourcesPublicUtilTest.EXPECTING_EXCEPTION_ILLEGAL_ARGUMENT_EXCEPTION); }
|
### Question:
BaseXx { public static final String getBase64UrlWithPadding(byte[] bytes) { ParametersChecker.checkParameter(ARGUMENT_NULL_NOT_ALLOWED, bytes); return BASE64_URL_WITH_PADDING.encode(bytes); } private BaseXx(); static final String getBase16(byte[] bytes); static final String getBase32(byte[] bytes); static final String getBase64UrlWithoutPadding(byte[] bytes); static final String getBase64UrlWithPadding(byte[] bytes); static final String getBase64(byte[] bytes); static final byte[] getFromBase16(String base16); static final byte[] getFromBase32(String base32); static final byte[] getFromBase64UrlWithoutPadding(String base64); static final byte[] getFromBase64UrlPadding(String base64Padding); static final byte[] getFromBase64(String base64Padding); }### Answer:
@Test(expected = IllegalArgumentException.class) public void testBase64UrlPadding() throws IOException { BaseXx.getBase64UrlWithPadding(null); fail(ResourcesPublicUtilTest.EXPECTING_EXCEPTION_ILLEGAL_ARGUMENT_EXCEPTION); }
|
### Question:
BaseXx { public static final byte[] getFromBase16(String base16) { ParametersChecker.checkParameter(ARGUMENT_NULL_NOT_ALLOWED, base16); return BASE16.decode(base16); } private BaseXx(); static final String getBase16(byte[] bytes); static final String getBase32(byte[] bytes); static final String getBase64UrlWithoutPadding(byte[] bytes); static final String getBase64UrlWithPadding(byte[] bytes); static final String getBase64(byte[] bytes); static final byte[] getFromBase16(String base16); static final byte[] getFromBase32(String base32); static final byte[] getFromBase64UrlWithoutPadding(String base64); static final byte[] getFromBase64UrlPadding(String base64Padding); static final byte[] getFromBase64(String base64Padding); }### Answer:
@Test(expected = IllegalArgumentException.class) public void testFromBase16() throws IOException { BaseXx.getFromBase16(null); fail(ResourcesPublicUtilTest.EXPECTING_EXCEPTION_ILLEGAL_ARGUMENT_EXCEPTION); }
|
### Question:
BaseXx { public static final byte[] getFromBase32(String base32) { ParametersChecker.checkParameter(ARGUMENT_NULL_NOT_ALLOWED, base32); return BASE32.decode(base32); } private BaseXx(); static final String getBase16(byte[] bytes); static final String getBase32(byte[] bytes); static final String getBase64UrlWithoutPadding(byte[] bytes); static final String getBase64UrlWithPadding(byte[] bytes); static final String getBase64(byte[] bytes); static final byte[] getFromBase16(String base16); static final byte[] getFromBase32(String base32); static final byte[] getFromBase64UrlWithoutPadding(String base64); static final byte[] getFromBase64UrlPadding(String base64Padding); static final byte[] getFromBase64(String base64Padding); }### Answer:
@Test(expected = IllegalArgumentException.class) public void testFromBase32() throws FileNotFoundException { BaseXx.getFromBase32(null); fail(ResourcesPublicUtilTest.EXPECTING_EXCEPTION_ILLEGAL_ARGUMENT_EXCEPTION); }
|
### Question:
BaseXx { public static final byte[] getFromBase64UrlWithoutPadding(String base64) { ParametersChecker.checkParameter(ARGUMENT_NULL_NOT_ALLOWED, base64); return BASE64_URL_WITHOUT_PADDING.decode(base64); } private BaseXx(); static final String getBase16(byte[] bytes); static final String getBase32(byte[] bytes); static final String getBase64UrlWithoutPadding(byte[] bytes); static final String getBase64UrlWithPadding(byte[] bytes); static final String getBase64(byte[] bytes); static final byte[] getFromBase16(String base16); static final byte[] getFromBase32(String base32); static final byte[] getFromBase64UrlWithoutPadding(String base64); static final byte[] getFromBase64UrlPadding(String base64Padding); static final byte[] getFromBase64(String base64Padding); }### Answer:
@Test(expected = IllegalArgumentException.class) public void testFromBase64() throws IOException { BaseXx.getFromBase64UrlWithoutPadding(null); fail(ResourcesPublicUtilTest.EXPECTING_EXCEPTION_ILLEGAL_ARGUMENT_EXCEPTION); }
|
### Question:
BaseXx { public static final byte[] getFromBase64UrlPadding(String base64Padding) { ParametersChecker.checkParameter(ARGUMENT_NULL_NOT_ALLOWED, base64Padding); return BASE64_URL_WITH_PADDING.decode(base64Padding); } private BaseXx(); static final String getBase16(byte[] bytes); static final String getBase32(byte[] bytes); static final String getBase64UrlWithoutPadding(byte[] bytes); static final String getBase64UrlWithPadding(byte[] bytes); static final String getBase64(byte[] bytes); static final byte[] getFromBase16(String base16); static final byte[] getFromBase32(String base32); static final byte[] getFromBase64UrlWithoutPadding(String base64); static final byte[] getFromBase64UrlPadding(String base64Padding); static final byte[] getFromBase64(String base64Padding); }### Answer:
@Test(expected = IllegalArgumentException.class) public void testFromBase64Padding() throws IOException { BaseXx.getFromBase64UrlPadding(null); fail(ResourcesPublicUtilTest.EXPECTING_EXCEPTION_ILLEGAL_ARGUMENT_EXCEPTION); }
|
### Question:
SysErrLogger { public void syserr(String message) { System.err.println("ERROR " + message); } private SysErrLogger(); void ignoreLog(Throwable throwable); void syserr(String message); void syserr(); void syserr(String message, Throwable e); static final SysErrLogger FAKE_LOGGER; }### Answer:
@Test public void testSyserr() { SysErrLogger.FAKE_LOGGER.ignoreLog(new Exception("Fake exception")); assertTrue(buf.length() == 0); SysErrLogger.FAKE_LOGGER.syserr(NOT_EMPTY); assertTrue(buf.length() > 0); buf.setLength(0); SysErrLogger.FAKE_LOGGER.syserr(); assertTrue(buf.length() > 0); buf.setLength(0); SysErrLogger.FAKE_LOGGER.syserr(NOT_EMPTY, new Exception("Fake exception")); assertTrue(buf.length() > NOT_EMPTY.length() + 5); buf.setLength(0); }
|
### Question:
ReferentialFormatFileImpl implements ReferentialFile<FileFormat>, VitamAutoCloseable { public List<FileFormatModel> checkFile(InputStream xmlPronom) throws ReferentialException { ParametersChecker.checkParameter("Pronom file is a mandatory parameter", xmlPronom); File xmlPronomFile = null; try { xmlPronomFile = PropertiesUtils.fileFromTmpFolder( VitamThreadUtils.getVitamSession().getRequestId() + ".xml"); FileUtils.copyInputStreamToFile(xmlPronom, xmlPronomFile); return PronomParser.getPronom(xmlPronomFile); } catch (IOException e) { throw new ReferentialException(e); } finally { StreamUtils.closeSilently(xmlPronom); FileUtils.deleteQuietly(xmlPronomFile); } } ReferentialFormatFileImpl(MongoDbAccessAdminImpl dbConfiguration, VitamCounterService vitamCounterService); @VisibleForTesting ReferentialFormatFileImpl(MongoDbAccessAdminImpl dbConfiguration,
FunctionalBackupService backupService, LogbookOperationsClient logbookOperationsClient); @Override void importFile(InputStream xmlPronom, String filename); List<FileFormatModel> checkFile(InputStream xmlPronom); @Override FileFormat findDocumentById(String id); @Override RequestResponseOK<FileFormat> findDocuments(JsonNode select); @Override void close(); static final String FILE_FORMAT_REPORT; }### Answer:
@Test @RunWithCustomExecutor public void testFormatXML() throws FileNotFoundException, ReferentialException { formatFile.checkFile(new FileInputStream(PropertiesUtils.findFile(FILE_TO_TEST_OK))); }
@Test(expected = ReferentialException.class) @RunWithCustomExecutor public void testFormatXMLKO() throws FileNotFoundException, ReferentialException { formatFile.checkFile(new FileInputStream(PropertiesUtils.findFile(FILE_TO_TEST_KO))); }
|
### Question:
VitamLoggerFactory { public static void setDefaultFactory(final VitamLoggerFactory defaultFactory) { if (defaultFactory == null) { throw new IllegalArgumentException("defaultFactory must not be null"); } VitamLoggerFactory.defaultFactory = defaultFactory; } VitamLoggerFactory(final VitamLogLevel level); static VitamLoggerFactory getDefaultFactory(); static void setDefaultFactory(final VitamLoggerFactory defaultFactory); static VitamLogger getInstance(final Class<?> clazz); static VitamLogger getInstance(final String name); static VitamLogLevel getLogLevel(); static void setLogLevel(final VitamLogLevel level); }### Answer:
@Test(expected = IllegalArgumentException.class) public void shouldNotAllowNullDefaultFactory() { VitamLoggerFactory.setDefaultFactory(null); }
|
### Question:
FormattingTuple { static final Object[] trimmedCopy(final Object[] argArray) { if (argArray == null || argArray.length == 0) { throw new IllegalStateException("non-sensical empty or null argument array"); } final int trimemdLen = argArray.length - 1; final Object[] trimmed = new Object[trimemdLen]; System.arraycopy(argArray, 0, trimmed, 0, trimemdLen); return trimmed; } FormattingTuple(final String message); FormattingTuple(final String message, final Object[] argArray,
final Throwable throwable); final String getMessage(); final Object[] getArgArray(); final Throwable getThrowable(); }### Answer:
@Test public void testError() { final Object[] objectArray0 = new Object[0]; try { FormattingTuple.trimmedCopy(objectArray0); fail("Expecting exception: IllegalStateException"); } catch (final IllegalStateException e) { } try { FormattingTuple.trimmedCopy((Object[]) null); fail("Expecting exception: IllegalStateException"); } catch (final IllegalStateException e) { } }
|
### Question:
VitamCodeHelper { public static boolean isAlphanumericCode(String code) { char c; for (int i = 0; i < code.length(); i++) { c = code.charAt(i); if ((c < 0x30 || c > 0x39) && (c < 0x41 || c > 0x5a)) { return false; } } return true; } private VitamCodeHelper(); static boolean isAlphanumericCode(String code); static VitamCode getFrom(String code); static VitamCode getFrom(ServiceName service, DomainName domain, String item); static String getMessage(ServiceName service, DomainName domain, String item); static String getMessageFromVitamCode(VitamCode vitamCode); static String getMessage(String vitamCode); static String getParametrizedMessageFromVitamCode(VitamCode vitamCode, Object... params); static String getParametrizedMessageFromCode(String vitamCode, Object... params); static String getParametrizedMessage(ServiceName service, DomainName domain, String item, Object... params); static List<VitamCode> getFromDomain(DomainName domain); static List<VitamCode> getFromService(ServiceName service); static String getCode(VitamCode vitamCode); static String getLogMessage(VitamCode vitamCode, Object... params); static VitamError toVitamError(VitamCode vitamCode, String description); }### Answer:
@Test public void isAlphanumericCodeTest() { assertFalse(VitamCodeHelper.isAlphanumericCode("ee")); assertFalse(VitamCodeHelper.isAlphanumericCode("0-")); assertFalse(VitamCodeHelper.isAlphanumericCode("A*")); assertTrue(VitamCodeHelper.isAlphanumericCode("00")); assertTrue(VitamCodeHelper.isAlphanumericCode("0F")); assertTrue(VitamCodeHelper.isAlphanumericCode("ZO")); }
|
### Question:
VitamCodeHelper { public static String getMessageFromVitamCode(VitamCode vitamCode) { ParametersChecker.checkParameter(INVALID_ARGUMENT_TO_RETRIEVE_ERROR_MESSAGE, vitamCode); return getMessage(vitamCode.getService(), vitamCode.getDomain(), vitamCode.getItem()); } private VitamCodeHelper(); static boolean isAlphanumericCode(String code); static VitamCode getFrom(String code); static VitamCode getFrom(ServiceName service, DomainName domain, String item); static String getMessage(ServiceName service, DomainName domain, String item); static String getMessageFromVitamCode(VitamCode vitamCode); static String getMessage(String vitamCode); static String getParametrizedMessageFromVitamCode(VitamCode vitamCode, Object... params); static String getParametrizedMessageFromCode(String vitamCode, Object... params); static String getParametrizedMessage(ServiceName service, DomainName domain, String item, Object... params); static List<VitamCode> getFromDomain(DomainName domain); static List<VitamCode> getFromService(ServiceName service); static String getCode(VitamCode vitamCode); static String getLogMessage(VitamCode vitamCode, Object... params); static VitamError toVitamError(VitamCode vitamCode, String description); }### Answer:
@Test(expected = IllegalArgumentException.class) public void getMessageFromVitamCodeNullParameterTest() { VitamCodeHelper.getMessageFromVitamCode(null); }
@Test public void getMessageFromVitamCodeTest() { final VitamCode code = VitamCodeHelper.getFrom("000000"); final String message = VitamCodeHelper.getMessageFromVitamCode(code); assertNotNull(message); assertEquals(VitamCode.TEST.getMessage(), message); }
|
### Question:
VitamCodeHelper { public static String getParametrizedMessageFromVitamCode(VitamCode vitamCode, Object... params) { ParametersChecker.checkParameter(INVALID_ARGUMENT_TO_RETRIEVE_ERROR_MESSAGE, vitamCode, params); return String.format(vitamCode.getMessage(), params); } private VitamCodeHelper(); static boolean isAlphanumericCode(String code); static VitamCode getFrom(String code); static VitamCode getFrom(ServiceName service, DomainName domain, String item); static String getMessage(ServiceName service, DomainName domain, String item); static String getMessageFromVitamCode(VitamCode vitamCode); static String getMessage(String vitamCode); static String getParametrizedMessageFromVitamCode(VitamCode vitamCode, Object... params); static String getParametrizedMessageFromCode(String vitamCode, Object... params); static String getParametrizedMessage(ServiceName service, DomainName domain, String item, Object... params); static List<VitamCode> getFromDomain(DomainName domain); static List<VitamCode> getFromService(ServiceName service); static String getCode(VitamCode vitamCode); static String getLogMessage(VitamCode vitamCode, Object... params); static VitamError toVitamError(VitamCode vitamCode, String description); }### Answer:
@Test public void getTranslatedMessageFromVitamCodeWrongParametersTest() { try { VitamCodeHelper.getParametrizedMessageFromVitamCode(null, null); fail("Must thrown an IllegalArgumentException"); } catch (final IllegalArgumentException exc) { } try { VitamCodeHelper.getParametrizedMessageFromVitamCode(VitamCode.TEST, null); fail("Must thrown an IllegalArgumentException"); } catch (final IllegalArgumentException exc) { } }
|
### Question:
VitamCodeHelper { public static List<VitamCode> getFromDomain(DomainName domain) { ParametersChecker.checkParameter("Invalid argument to retrieve Vitam code", domain); final List<VitamCode> codes = new ArrayList<>(); for (final VitamCode vitamCode : VitamCode.values()) { if (vitamCode.getDomain().equals(domain)) { codes.add(vitamCode); } } return codes; } private VitamCodeHelper(); static boolean isAlphanumericCode(String code); static VitamCode getFrom(String code); static VitamCode getFrom(ServiceName service, DomainName domain, String item); static String getMessage(ServiceName service, DomainName domain, String item); static String getMessageFromVitamCode(VitamCode vitamCode); static String getMessage(String vitamCode); static String getParametrizedMessageFromVitamCode(VitamCode vitamCode, Object... params); static String getParametrizedMessageFromCode(String vitamCode, Object... params); static String getParametrizedMessage(ServiceName service, DomainName domain, String item, Object... params); static List<VitamCode> getFromDomain(DomainName domain); static List<VitamCode> getFromService(ServiceName service); static String getCode(VitamCode vitamCode); static String getLogMessage(VitamCode vitamCode, Object... params); static VitamError toVitamError(VitamCode vitamCode, String description); }### Answer:
@Test(expected = IllegalArgumentException.class) public void getFromDomainIllegalExceptionTest() { VitamCodeHelper.getFromDomain(null); }
@Test public void getFromDomainTest() { final List<VitamCode> codes = VitamCodeHelper.getFromDomain(DomainName.TEST); assertNotNull(codes); assertEquals(1, codes.size()); assertEquals(VitamCode.TEST, codes.get(0)); }
|
### Question:
VitamCodeHelper { public static List<VitamCode> getFromService(ServiceName service) { ParametersChecker.checkParameter("Invalid argument to retrieve Vitam code", service); final List<VitamCode> codes = new ArrayList<>(); for (final VitamCode vitamCode : VitamCode.values()) { if (vitamCode.getService().equals(service)) { codes.add(vitamCode); } } return codes; } private VitamCodeHelper(); static boolean isAlphanumericCode(String code); static VitamCode getFrom(String code); static VitamCode getFrom(ServiceName service, DomainName domain, String item); static String getMessage(ServiceName service, DomainName domain, String item); static String getMessageFromVitamCode(VitamCode vitamCode); static String getMessage(String vitamCode); static String getParametrizedMessageFromVitamCode(VitamCode vitamCode, Object... params); static String getParametrizedMessageFromCode(String vitamCode, Object... params); static String getParametrizedMessage(ServiceName service, DomainName domain, String item, Object... params); static List<VitamCode> getFromDomain(DomainName domain); static List<VitamCode> getFromService(ServiceName service); static String getCode(VitamCode vitamCode); static String getLogMessage(VitamCode vitamCode, Object... params); static VitamError toVitamError(VitamCode vitamCode, String description); }### Answer:
@Test(expected = IllegalArgumentException.class) public void getFromServiceIllegalExceptionTest() { VitamCodeHelper.getFromService(null); }
@Test public void getFromServiceTest() { final List<VitamCode> codes = VitamCodeHelper.getFromService(ServiceName.VITAM); assertNotNull(codes); assertEquals(VitamCode.TEST, codes.get(0)); }
|
### Question:
VitamCodeHelper { public static String getLogMessage(VitamCode vitamCode, Object... params) { ParametersChecker.checkParameter(INVALID_ARGUMENT_TO_RETRIEVE_ERROR_MESSAGE, vitamCode); return String.format("[%s] %s", getCode(vitamCode), getParametrizedMessageFromVitamCode(vitamCode, params)); } private VitamCodeHelper(); static boolean isAlphanumericCode(String code); static VitamCode getFrom(String code); static VitamCode getFrom(ServiceName service, DomainName domain, String item); static String getMessage(ServiceName service, DomainName domain, String item); static String getMessageFromVitamCode(VitamCode vitamCode); static String getMessage(String vitamCode); static String getParametrizedMessageFromVitamCode(VitamCode vitamCode, Object... params); static String getParametrizedMessageFromCode(String vitamCode, Object... params); static String getParametrizedMessage(ServiceName service, DomainName domain, String item, Object... params); static List<VitamCode> getFromDomain(DomainName domain); static List<VitamCode> getFromService(ServiceName service); static String getCode(VitamCode vitamCode); static String getLogMessage(VitamCode vitamCode, Object... params); static VitamError toVitamError(VitamCode vitamCode, String description); }### Answer:
@Test(expected = IllegalArgumentException.class) public void getLogMessageIllegalExceptionTest() { VitamCodeHelper.getLogMessage(null); }
@Test public void getLogMessageTest() { final String message = VitamCodeHelper.getLogMessage(VitamCode.TEST, "test"); assertNotNull(message); assertEquals(String.format("[%s] %s", VitamCodeHelper.getCode(VitamCode.TEST), String.format(VitamCode.TEST .getMessage(), "test")), message); }
|
### Question:
VitamCodeHelper { public static String getCode(VitamCode vitamCode) { return new StringBuilder() .append(vitamCode.getService().getCode()) .append(vitamCode.getDomain().getCode()) .append(vitamCode.getItem()).toString(); } private VitamCodeHelper(); static boolean isAlphanumericCode(String code); static VitamCode getFrom(String code); static VitamCode getFrom(ServiceName service, DomainName domain, String item); static String getMessage(ServiceName service, DomainName domain, String item); static String getMessageFromVitamCode(VitamCode vitamCode); static String getMessage(String vitamCode); static String getParametrizedMessageFromVitamCode(VitamCode vitamCode, Object... params); static String getParametrizedMessageFromCode(String vitamCode, Object... params); static String getParametrizedMessage(ServiceName service, DomainName domain, String item, Object... params); static List<VitamCode> getFromDomain(DomainName domain); static List<VitamCode> getFromService(ServiceName service); static String getCode(VitamCode vitamCode); static String getLogMessage(VitamCode vitamCode, Object... params); static VitamError toVitamError(VitamCode vitamCode, String description); }### Answer:
@Test public void getCodeTest() { final String code = VitamCodeHelper.getCode(VitamCode.TEST); assertNotNull(code); assertEquals("000000", code); }
|
### Question:
ParametersChecker { public static void checkValue(String name, long variable, long minValue) { if (variable < minValue) { throw new IllegalArgumentException("Parameter " + name + " is less than " + minValue); } } private ParametersChecker(); static void checkParameter(String errorMessage, String... parameters); static void checkParameterDefault(String errorMessage, String... parameters); static boolean isNotEmpty(String... parameters); static void checkParameterDefault(String errorMessage, Object... parameters); static void checkParameterNullOnly(String errorMessage, String... parameters); static void checkParameter(String errorMessage, Object... parameters); static void checkDateParam(String errorMessage, String date); static void checkValue(String name, long variable, long minValue); static void checkNullOrEmptyParameter(T key, String value,
Set<T> mandatories); static void checkNullOrEmptyParameters(Map<T, String> parameters,
Set<T> mandatories); @SuppressWarnings({"rawtypes", "unchecked"}) static void checkNullOrEmptyParameters(T parameters); }### Answer:
@Test public final void testCheckValue() { try { ParametersChecker.checkValue("test", 1, 2); fail(ResourcesPublicUtilTest.SHOULD_RAIZED_ILLEGAL_ARGUMENT_EXCEPTION); } catch (final IllegalArgumentException e) { } ParametersChecker.checkValue("test", 1, 1); ParametersChecker.checkValue("test", 1, 0); }
|
### Question:
LocalDateUtil { public static LocalDateTime fromDate(Date date) { if (date == null) { return now(); } return LocalDateTime.ofInstant(date.toInstant(), ZoneOffset.UTC); } private LocalDateUtil(); static final String getString(LocalDateTime localDateTime); static final String getStringFormatted(LocalDateTime localDateTime); static String getString(Date date); static LocalDateTime now(); static Date getDate(String date); static LocalDateTime fromMillis(long millis); static long getMillis(LocalDateTime ldt); static LocalDateTime fromDate(Date date); static LocalDateTime fromDate(FileTime fileTime); static Date getDate(LocalDateTime ldt); static String getFormattedDate(Date date); static String getFormattedDate(LocalDateTime date); static String getFormattedSimpleDate(Date date); static String getFormattedSimpleDate(LocalDate date); static Date getSimpleFormattedDate(final String date); static LocalDate getLocalDateFromSimpleFormattedDate(String date); static String getFormattedDateForMongo(String date); static String transformIsoOffsetDateToIsoOffsetDateTime(String date); static String getFormattedDateForMongo(LocalDateTime date); static LocalDateTime parseMongoFormattedDate(String str); static String getFormattedDateForEsIndexes(LocalDateTime date); static DateTimeFormatter getDateTimeFormatterForFileNames(); static final String LONG_SECOND_DATE_FORMAT; }### Answer:
@Test public void checkConversionFileTime() throws IOException { final File file = ResourcesPublicUtilTest.getInstance().getGuidTestPropertiesFile(); if (file == null) { LOGGER.error(ResourcesPublicUtilTest.CANNOT_FIND_RESOURCES_TEST_FILE); } Assume.assumeTrue(ResourcesPublicUtilTest.CANNOT_FIND_RESOURCES_TEST_FILE, file != null); assertNotNull(LocalDateUtil.fromDate(Files.getLastModifiedTime(file.toPath()))); }
|
### Question:
PropertiesUtils { public static File fileFromTmpFolder(String subpath) { try { String canonicalPath = new File(VitamConfiguration.getVitamTmpFolder()).getCanonicalPath(); File file = new File(VitamConfiguration.getVitamTmpFolder(), subpath); String fileCanonicalPath = file.getCanonicalPath(); if (!fileCanonicalPath.startsWith(canonicalPath)) { throw new VitamRuntimeException(String.format("invalid path with subpath: %s", subpath)); } return file; } catch (IOException e) { throw new VitamRuntimeException(e); } } private PropertiesUtils(); static InputStream getConfigAsStream(String resourcesFile); static InputStream getResourceAsStream(String resourcesFile); static File getResourceFile(String resourcesFile); static Path getResourcePath(String resourcesFile); static Stream<String> getResourceListing(Class clazz, String path); static File findFile(String filename); static File fileFromConfigFolder(String subpath); static File fileFromDataFolder(String subpath); static File fileFromTmpFolder(String subpath); static Properties readProperties(File propertiesFile); static C readYaml(File yamlFile, Class<C> clasz); static C readYaml(File yamlFile, TypeReference<C> typeReference); static C readYaml(InputStream yamlInputStream, Class<C> clasz); static C readYaml(Path yamlPath, Class<C> clasz); static void writeYaml(File destination, Object config); static String getResourceAsString(String resourcesFile); }### Answer:
@Test public void should_validate_file() throws Exception { assertThatThrownBy(() -> PropertiesUtils.fileFromTmpFolder("../test")) .isInstanceOf(VitamRuntimeException.class) .hasMessageContaining("invalid path"); assertThatCode(() -> PropertiesUtils.fileFromTmpFolder("./test")).doesNotThrowAnyException(); assertThatCode(() -> PropertiesUtils.fileFromTmpFolder("/test")).doesNotThrowAnyException(); assertThatCode(() -> PropertiesUtils.fileFromTmpFolder("test")).doesNotThrowAnyException(); }
|
### Question:
PropertiesUtils { public static Path getResourcePath(String resourcesFile) throws FileNotFoundException { return getResourceFile(resourcesFile).toPath(); } private PropertiesUtils(); static InputStream getConfigAsStream(String resourcesFile); static InputStream getResourceAsStream(String resourcesFile); static File getResourceFile(String resourcesFile); static Path getResourcePath(String resourcesFile); static Stream<String> getResourceListing(Class clazz, String path); static File findFile(String filename); static File fileFromConfigFolder(String subpath); static File fileFromDataFolder(String subpath); static File fileFromTmpFolder(String subpath); static Properties readProperties(File propertiesFile); static C readYaml(File yamlFile, Class<C> clasz); static C readYaml(File yamlFile, TypeReference<C> typeReference); static C readYaml(InputStream yamlInputStream, Class<C> clasz); static C readYaml(Path yamlPath, Class<C> clasz); static void writeYaml(File destination, Object config); static String getResourceAsString(String resourcesFile); }### Answer:
@Test(expected = FileNotFoundException.class) public void testReadResourcesPathFileNotFound() throws IOException { PropertiesUtils.getResourcePath("vesR[l}EQ2v6"); fail(ResourcesPublicUtilTest.EXPECTING_EXCEPTION_FILE_NOT_FOUND_EXCEPTION); }
|
### Question:
PropertiesUtils { public static File findFile(String filename) throws FileNotFoundException { File file = new File(filename); try { if (!file.exists()) { file = fileFromConfigFolder(filename); if (!file.exists()) { file = getResourceFile(filename); } } } catch (final FileNotFoundException e) { SysErrLogger.FAKE_LOGGER.ignoreLog(e); throw new FileNotFoundException("File not found: " + filename); } if (!file.exists()) { throw new FileNotFoundException("File not found: " + filename); } return file; } private PropertiesUtils(); static InputStream getConfigAsStream(String resourcesFile); static InputStream getResourceAsStream(String resourcesFile); static File getResourceFile(String resourcesFile); static Path getResourcePath(String resourcesFile); static Stream<String> getResourceListing(Class clazz, String path); static File findFile(String filename); static File fileFromConfigFolder(String subpath); static File fileFromDataFolder(String subpath); static File fileFromTmpFolder(String subpath); static Properties readProperties(File propertiesFile); static C readYaml(File yamlFile, Class<C> clasz); static C readYaml(File yamlFile, TypeReference<C> typeReference); static C readYaml(InputStream yamlInputStream, Class<C> clasz); static C readYaml(Path yamlPath, Class<C> clasz); static void writeYaml(File destination, Object config); static String getResourceAsString(String resourcesFile); }### Answer:
@Test(expected = FileNotFoundException.class) public void testGetFileNotFound() throws FileNotFoundException { PropertiesUtils.findFile("notfoundfilename"); fail(ResourcesPublicUtilTest.EXPECTING_EXCEPTION_FILE_NOT_FOUND_EXCEPTION); }
|
### Question:
PropertiesUtils { public static Properties readProperties(File propertiesFile) throws IOException { if (propertiesFile == null) { throw new FileNotFoundException(FILE_NOT_FOUND_IN_RESOURCES + propertiesFile); } final Properties properties = new Properties(); try (InputStream inputStream = new FileInputStream(propertiesFile)) { properties.load(inputStream); } return properties; } private PropertiesUtils(); static InputStream getConfigAsStream(String resourcesFile); static InputStream getResourceAsStream(String resourcesFile); static File getResourceFile(String resourcesFile); static Path getResourcePath(String resourcesFile); static Stream<String> getResourceListing(Class clazz, String path); static File findFile(String filename); static File fileFromConfigFolder(String subpath); static File fileFromDataFolder(String subpath); static File fileFromTmpFolder(String subpath); static Properties readProperties(File propertiesFile); static C readYaml(File yamlFile, Class<C> clasz); static C readYaml(File yamlFile, TypeReference<C> typeReference); static C readYaml(InputStream yamlInputStream, Class<C> clasz); static C readYaml(Path yamlPath, Class<C> clasz); static void writeYaml(File destination, Object config); static String getResourceAsString(String resourcesFile); }### Answer:
@Test(expected = FileNotFoundException.class) public void testReadPropertiesFileNotFound() throws IOException { final File file0 = new File(""); PropertiesUtils.readProperties(file0); fail(ResourcesPublicUtilTest.EXPECTING_EXCEPTION_FILE_NOT_FOUND_EXCEPTION); }
@Test(expected = FileNotFoundException.class) public void testReadPropertiesFileNotFoundNull() throws IOException { PropertiesUtils.readProperties((File) null); fail(ResourcesPublicUtilTest.EXPECTING_EXCEPTION_FILE_NOT_FOUND_EXCEPTION); }
@Test(expected = FileNotFoundException.class) public void testReadResourcesPropertiesFileNotFoundNull() throws IOException { PropertiesUtils.readProperties(null); fail(ResourcesPublicUtilTest.EXPECTING_EXCEPTION_FILE_NOT_FOUND_EXCEPTION); }
|
### Question:
PropertiesUtils { public static InputStream getResourceAsStream(String resourcesFile) throws FileNotFoundException { if (resourcesFile == null) { throw new FileNotFoundException(FILE_NOT_FOUND_IN_RESOURCES); } InputStream stream = null; try { stream = Thread.currentThread().getContextClassLoader().getResourceAsStream(resourcesFile); } catch (final SecurityException e) { SysErrLogger.FAKE_LOGGER.ignoreLog(e); } if (stream == null) { try { stream = PropertiesUtils.class.getClassLoader().getResourceAsStream(resourcesFile); } catch (final SecurityException e) { SysErrLogger.FAKE_LOGGER.ignoreLog(e); } } if (stream == null) { throw new FileNotFoundException(FILE_NOT_FOUND_IN_RESOURCES + resourcesFile); } return stream; } private PropertiesUtils(); static InputStream getConfigAsStream(String resourcesFile); static InputStream getResourceAsStream(String resourcesFile); static File getResourceFile(String resourcesFile); static Path getResourcePath(String resourcesFile); static Stream<String> getResourceListing(Class clazz, String path); static File findFile(String filename); static File fileFromConfigFolder(String subpath); static File fileFromDataFolder(String subpath); static File fileFromTmpFolder(String subpath); static Properties readProperties(File propertiesFile); static C readYaml(File yamlFile, Class<C> clasz); static C readYaml(File yamlFile, TypeReference<C> typeReference); static C readYaml(InputStream yamlInputStream, Class<C> clasz); static C readYaml(Path yamlPath, Class<C> clasz); static void writeYaml(File destination, Object config); static String getResourceAsString(String resourcesFile); }### Answer:
@Test(expected = FileNotFoundException.class) public void testGetResourcesStreamNotFoundNull() throws FileNotFoundException { PropertiesUtils.getResourceAsStream(null); fail(ResourcesPublicUtilTest.EXPECTING_EXCEPTION_FILE_NOT_FOUND_EXCEPTION); }
|
### Question:
WorkerParametersFactory { static DefaultWorkerParameters newWorkerParameters(Set<WorkerParameterName> mandatoryFieldsToAdd) { return new DefaultWorkerParameters(initMandatoriesParameters(mandatoryFieldsToAdd)); } private WorkerParametersFactory(); static DefaultWorkerParameters newWorkerParameters(); static DefaultWorkerParameters newWorkerParameters(String processId, String stepUniqId, String containerName,
String currentStep, List<String> objectNameList, String urlMetadata,
String urlWorkspace); }### Answer:
@Test public void constructorTest() { final WorkerParameters parameters = WorkerParametersFactory.newWorkerParameters(); assertNotNull(parameters); assertEquals(5, parameters.getMandatoriesParameters().size()); assertEquals(0, parameters.getMapParameters().size()); final WorkerParameters parameters2 = WorkerParametersFactory.newWorkerParameters("processId", "stepUniqId", "containerName", "currentStep", Lists.newArrayList("objectName"), "urlMetadata", "urlWorkspace"); assertNotNull(parameters2); assertEquals(7, parameters2.getMapParameters().size()); }
|
### Question:
FakeDriverImpl extends AbstractDriver { @Override public Connection connect(String offerId) throws StorageDriverException { if (offerId.contains("fail")) { throw new StorageDriverException(getName(), "Intentionaly thrown", false); } return new FakeConnectionImpl(offerId); } @Override Connection connect(String offerId); @Override boolean isStorageOfferAvailable(String offerId); @Override String getName(); @Override int getMajorVersion(); @Override int getMinorVersion(); }### Answer:
@Test(expected = StorageDriverException.class) public void givenIncorrectPropertiesThenRaiseAnException() throws Exception { final Properties props = new Properties(); props.setProperty("fail", "fail"); StorageOffer offer = new StorageOffer(); offer.setId("fail"); driver.connect(offer.getId()); }
|
### Question:
FakeDriverImpl extends AbstractDriver { @Override public String getName() { return "Fake driver"; } @Override Connection connect(String offerId); @Override boolean isStorageOfferAvailable(String offerId); @Override String getName(); @Override int getMajorVersion(); @Override int getMinorVersion(); }### Answer:
@Test public void getNameOK() throws Exception { assertEquals(DRIVER_NAME, driver.getName()); }
|
### Question:
FakeDriverImpl extends AbstractDriver { @Override public boolean isStorageOfferAvailable(String offerId) throws StorageDriverException { if (offerId.contains("fail")) { throw new StorageDriverException(getName(), "Intentionaly thrown", false); } return true; } @Override Connection connect(String offerId); @Override boolean isStorageOfferAvailable(String offerId); @Override String getName(); @Override int getMajorVersion(); @Override int getMinorVersion(); }### Answer:
@Test public void isStorageOfferAvailableOK() throws Exception { final StorageOffer offer = new StorageOffer(); offer.setParameters(new HashMap<>()); offer.getParameters().put("s", "s"); offer.setId("FakeOffer"); assertEquals(true, driver.isStorageOfferAvailable(offer.getId())); }
@Test(expected = StorageDriverException.class) public void isStorageOfferAvailableKO() throws Exception { final StorageOffer offer = new StorageOffer(); offer.setId("fail"); assertEquals(true, driver.isStorageOfferAvailable(offer.getId())); }
|
### Question:
FakeDriverImpl extends AbstractDriver { @Override public int getMajorVersion() { return 1; } @Override Connection connect(String offerId); @Override boolean isStorageOfferAvailable(String offerId); @Override String getName(); @Override int getMajorVersion(); @Override int getMinorVersion(); }### Answer:
@Test public void getMajorVersionOK() throws Exception { assertEquals(1, driver.getMajorVersion()); }
|
### Question:
FakeDriverImpl extends AbstractDriver { @Override public int getMinorVersion() { return 0; } @Override Connection connect(String offerId); @Override boolean isStorageOfferAvailable(String offerId); @Override String getName(); @Override int getMajorVersion(); @Override int getMinorVersion(); }### Answer:
@Test public void getMinorVersionOK() throws Exception { assertEquals(0, driver.getMinorVersion()); }
|
### Question:
FormatIdentifierMock implements FormatIdentifier { @Override public List<FormatIdentifierResponse> analysePath(Path pathToFile) { try { if (isProbableZip(pathToFile) && isProbableSipFile(pathToFile)) { String formatLitteral = "Zip File"; String mimeType = "application/zip"; String formatId = "x-fmt/263"; String ns = "pronom"; return Collections.singletonList(new FormatIdentifierResponse(formatLitteral, mimeType, formatId, ns)); } } catch (IOException e) { SysErrLogger.FAKE_LOGGER.ignoreLog(e); } String formatLitteral = "Plain Text File"; String mimeType = "text/plain"; String formatId = "x-fmt/111"; String ns = "pronom"; return Collections.singletonList(new FormatIdentifierResponse(formatLitteral, mimeType, formatId, ns)); } @Override List<FormatIdentifierResponse> analysePath(Path pathToFile); @Override FormatIdentifierInfo status(); static final String ZIP; }### Answer:
@Test public void testIdentifyFormatMock() throws Exception { final FormatIdentifierMock mock = new FormatIdentifierMock(); final List<FormatIdentifierResponse> responses = mock.analysePath(Paths.get("pathToFile")); assertNotNull(responses); assertEquals(responses.size(), 1); final FormatIdentifierResponse response = responses.get(0); assertEquals("Plain Text File", response.getFormatLiteral()); assertEquals("text/plain", response.getMimetype()); assertEquals("x-fmt/111", response.getPuid()); assertEquals("pronom", response.getMatchedNamespace()); }
|
### Question:
FormatIdentifierMock implements FormatIdentifier { @Override public FormatIdentifierInfo status() { return new FormatIdentifierInfo("1.0", "FormatIdentifierMock"); } @Override List<FormatIdentifierResponse> analysePath(Path pathToFile); @Override FormatIdentifierInfo status(); static final String ZIP; }### Answer:
@Test public void testStatusFormatMock() throws Exception { final FormatIdentifierMock mock = new FormatIdentifierMock(); final FormatIdentifierInfo response = mock.status(); assertNotNull(response); assertEquals("1.0", response.getVersion()); assertEquals("FormatIdentifierMock", response.getSoftwareName()); }
|
### Question:
FormatIdentifierSiegfried implements FormatIdentifier { @Override public FormatIdentifierInfo status() throws FormatIdentifierTechnicalException, FormatIdentifierNotFoundException { if (LOGGER.isDebugEnabled()) { LOGGER.debug("Check Siegfried status"); } try (SiegfriedClient siegfriedClient = siegfriedClientFactory.getClient()) { final RequestResponse<JsonNode> response = siegfriedClient.status(versionPath); final String version = response.toJsonNode().get("$results").get(0).get("siegfried").asText(); return new FormatIdentifierInfo(version, "Siegfried"); } } FormatIdentifierSiegfried(Map<String, Object> configurationProperties); @VisibleForTesting FormatIdentifierSiegfried(SiegfriedClientFactory siegfriedClientFactory, Path versionPath); @Override FormatIdentifierInfo status(); @Override List<FormatIdentifierResponse> analysePath(Path path); static final String PRONOM_NAMESPACE; static final String UNKNOW_NAMESPACE; }### Answer:
@Test public void testSiegfriedStatus() throws Exception { reset(siegfriedClientRest); when(siegfriedClientRest.status(VERSION_PATH)).thenReturn(new RequestResponseOK().addResult(JSON_NODE_VERSION)); final FormatIdentifierInfo infos = siegfried.status(); assertNotNull(infos); assertEquals("1.6.4", infos.getVersion()); assertEquals("Siegfried", infos.getSoftwareName()); }
@Test(expected = FormatIdentifierNotFoundException.class) public void testSiegfriedStatusNotFound() throws Exception { reset(siegfriedClientRest); when(siegfriedClientRest.status(VERSION_PATH)).thenThrow(FormatIdentifierNotFoundException.class); siegfried.status(); }
@Test(expected = FormatIdentifierTechnicalException.class) public void testSiegfriedStatusInternalError() throws Exception { reset(siegfriedClientRest); when(siegfriedClientRest.status(VERSION_PATH)).thenThrow(FormatIdentifierTechnicalException.class); siegfried.status(); }
|
### Question:
SiegfriedClientMock extends AbstractMockClient implements SiegfriedClient { @Override public RequestResponse<JsonNode> status(Path filePath) throws FormatIdentifierTechnicalException, FormatIdentifierNotFoundException { return new RequestResponseOK().addResult(getVersionJson()); } @Override RequestResponse<JsonNode> status(Path filePath); @Override RequestResponse<JsonNode> analysePath(Path filePath); }### Answer:
@Test public void statusTest() { SiegfriedClientFactory.changeMode(null); final SiegfriedClient client = SiegfriedClientFactory.getInstance().getClient(); assertNotNull(client); Boolean catchException = false; RequestResponse<JsonNode> response = null; try { response = client.status(Paths.get("version")); } catch (final Exception lce) { catchException = true; } assertFalse(catchException); assertNotNull(response); assertEquals("mock-1.0", response.toJsonNode().get("$results").get(0).get("siegfried").asText()); }
|
### Question:
SiegfriedClientMock extends AbstractMockClient implements SiegfriedClient { @Override public RequestResponse<JsonNode> analysePath(Path filePath) throws FormatIdentifierTechnicalException, FormatIdentifierNotFoundException { return new RequestResponseOK().addResult(getFormatJson(filePath)); } @Override RequestResponse<JsonNode> status(Path filePath); @Override RequestResponse<JsonNode> analysePath(Path filePath); }### Answer:
@Test public void analysePathTest() { SiegfriedClientFactory.changeMode(null); final SiegfriedClient client = SiegfriedClientFactory.getInstance().getClient(); assertNotNull(client); Boolean catchException = false; RequestResponse<JsonNode> response = null; try { response = client.analysePath(Paths.get("identify")); } catch (final Exception lce) { catchException = true; } assertFalse(catchException); assertNotNull(response); assertEquals(1, response.toJsonNode().get("$results").get(0).get("files").size()); }
|
### Question:
SiegfriedClientRest extends DefaultClient implements SiegfriedClient { @Override public RequestResponse<JsonNode> status(Path filePath) throws FormatIdentifierTechnicalException, FormatIdentifierNotFoundException { return analysePath(filePath); } SiegfriedClientRest(SiegfriedClientFactory factory); @Override RequestResponse<JsonNode> analysePath(Path filePath); @Override RequestResponse<JsonNode> status(Path filePath); }### Answer:
@Test public void statusExecutionWithResponse() throws Exception { when(mock.get()) .thenReturn(Response.status(Response.Status.OK).entity(JSON_NODE_VERSION).build()); RequestResponse<JsonNode> jsonNodeRequestResponse = client.status(Paths.get("Path")); assertTrue(jsonNodeRequestResponse.toJsonNode().has("$results")); assertEquals("1.6.4", jsonNodeRequestResponse.toJsonNode().get("$results").get(0).get("siegfried").asText()); }
@Test(expected = FormatIdentifierNotFoundException.class) public void statusExecutionNotFound() throws Exception { when(mock.get()).thenReturn(Response.status(Response.Status.NOT_FOUND).build()); client.status(Paths.get("Path")); }
@Test(expected = FormatIdentifierTechnicalException.class) public void statusExecutionInternalError() throws Exception { when(mock.get()).thenReturn(Response.status(Response.Status.INTERNAL_SERVER_ERROR).build()); client.status(Paths.get("Path")); }
|
### Question:
VitamClientFactory implements VitamClientFactoryInterface<T> { protected VitamClientFactory(ClientConfiguration configuration, String resourcePath) { this(configuration, resourcePath, true); } protected VitamClientFactory(ClientConfiguration configuration, String resourcePath); protected VitamClientFactory(ClientConfiguration configuration, String resourcePath,
boolean chunkedMode); protected VitamClientFactory(ClientConfiguration configuration, String resourcePath, Client client); void setGzipEncoded(boolean allowGzipEncoded); void setGzipdecoded(boolean allowGzipDecoded); @Override void changeResourcePath(String resourcePath); @Override void changeServerPort(int port); @Override VitamClientType getVitamClientType(); @Override VitamClientFactory<T> setVitamClientType(VitamClientType vitamClientType); @Override void resume(Client client, boolean chunk); @Override Client getHttpClient(); @Override Client getHttpClient(boolean useChunkedMode); @Override String getResourcePath(); @Override String getServiceUrl(); @Override String toString(); @Override final ClientConfiguration getClientConfiguration(); @Override final Map<VitamRestEasyConfiguration, Object> getDefaultConfigCient(); @Override final Map<VitamRestEasyConfiguration, Object> getDefaultConfigCient(boolean chunkedMode); @Override synchronized void shutdown(); @VisibleForTesting static void resetConnections(); }### Answer:
@Test public void vitamClientFactoryTest() { final Client client = mock(Client.class); final ClientFactoryTest cft = new ClientFactoryTest(CONFIGURATION, RESOURCE_PATH, client); assertEquals("/" + RESOURCE_PATH, cft.getResourcePath()); assertEquals(client, cft.getHttpClient(false)); assertEquals(cft.getHttpClient(), cft.getHttpClient(false)); assertTrue(cft.toString().contains(RESOURCE_PATH)); assertEquals(VitamClientType.PRODUCTION, cft.getVitamClientType()); try (BasicClient vitamClient = cft.getClient()) { assertEquals(((DefaultClient) vitamClient).getClientFactory().getClientConfiguration(), cft.getClientConfiguration()); assertTrue(vitamClient.toString().contains(cft.toString())); } }
|
### Question:
UpdateByIdSchemaValidator implements DslValidator { @Override public void validate(JsonNode dsl) throws ValidationException { Validator.validate(schema, "DSL", dsl); } UpdateByIdSchemaValidator(); @Override void validate(JsonNode dsl); }### Answer:
@Test public void testUpdateByIdValidator() throws InvalidParseOperationException, IOException, ValidationException { DslValidator dslValidator = new UpdateByIdSchemaValidator(); JsonNode updateByIdQuery = JsonHandler.getFromFile(PropertiesUtils.findFile("update_by_id_complete.json")); dslValidator.validate(updateByIdQuery); }
|
### Question:
GetByIdSchemaValidator implements DslValidator { @Override public void validate(JsonNode dsl) throws ValidationException { Validator.validate(schema, "DSL", dsl); } GetByIdSchemaValidator(); @Override void validate(JsonNode dsl); }### Answer:
@Test public void testGetByIdValidator() throws InvalidParseOperationException, IOException, ValidationException { DslValidator dslValidator = new GetByIdSchemaValidator(); JsonNode getByIdQuery = JsonHandler.getFromFile(PropertiesUtils.findFile("get_by_id_complete.json")); dslValidator.validate(getByIdQuery); }
|
### Question:
SelectSingleSchemaValidator implements DslValidator { @Override public void validate(JsonNode dsl) throws ValidationException { Validator.validate(schema, "DSL", dsl); } SelectSingleSchemaValidator(); @Override void validate(JsonNode dsl); }### Answer:
@Test public void testValidatorSelectSingle() throws InvalidParseOperationException, IOException, ValidationException { DslValidator dslValidator = new SelectSingleSchemaValidator(); JsonNode selectSingleQuery = JsonHandler.getFromFile(PropertiesUtils.findFile("select_single_complete.json")); dslValidator.validate(selectSingleQuery); }
@Test public void testValidatorSelectSingleWithMultipleQueryException() throws InvalidParseOperationException, IOException, ValidationException { DslValidator dslValidator = new SelectSingleSchemaValidator(); JsonNode selectMultipleQuery = JsonHandler.getFromFile(PropertiesUtils.findFile("select_multiple_complete.json")); assertThatThrownBy(() -> dslValidator.validate(selectMultipleQuery)) .hasMessageContaining("Dsl query is not valid"); }
|
### Question:
ReclassificationQuerySchemaValidator implements DslValidator { @Override public void validate(JsonNode dsl) throws ValidationException { Validator.validate(schema, "DSL", dsl); } ReclassificationQuerySchemaValidator(); @Override void validate(JsonNode dsl); }### Answer:
@Test public void testUpdateByIdValidator() throws InvalidParseOperationException, IOException, ValidationException { DslValidator dslValidator = new ReclassificationQuerySchemaValidator(); JsonNode updateByIdQuery = JsonHandler.getFromFile(PropertiesUtils.findFile("reclassification_query_complete.json")); dslValidator.validate(updateByIdQuery); }
|
### Question:
UpdateMultipleSchemaValidator implements DslValidator { public UpdateMultipleSchemaValidator() throws IOException { LOGGER.debug("Loading schema {} from {}", DslSchema.MASS_UPDATE.name(), DslSchema.MASS_UPDATE.getFilename()); try (final InputStream schemaSource = PropertiesUtils.getResourceAsStream(DslSchema.MASS_UPDATE.getFilename())) { schema = Schema.getSchema().loadTypes(schemaSource).build(); } } UpdateMultipleSchemaValidator(); @Override void validate(JsonNode dsl); }### Answer:
@Test public void testUpdateMultipleSchemaValidator() throws InvalidParseOperationException, IOException, ValidationException { DslValidator dslValidator = new UpdateMultipleSchemaValidator(); JsonNode updateQuery = JsonHandler.getFromFile(PropertiesUtils.findFile("update_multiple_complete.json")); dslValidator.validate(updateQuery); }
|
### Question:
EndpointAdminOnlyAuthorizationFilter implements ContainerRequestFilter { @Override public void filter(ContainerRequestContext requestContext) throws IOException { int tenantId = VitamThreadUtils.getVitamSession().getTenantId(); if (isAdminOnly && tenantId != VitamConfiguration.getAdminTenant()) { final VitamError vitamError = generateVitamError(); requestContext.abortWith( Response.status(vitamError.getHttpCode()).entity(vitamError).type(MediaType.APPLICATION_JSON_TYPE) .build()); } } EndpointAdminOnlyAuthorizationFilter(boolean isAdminOnly); @Override void filter(ContainerRequestContext requestContext); }### Answer:
@Test public void testAccessDeniedToAPIAdmin() throws Exception { VitamThreadUtils.getVitamSession().setTenantId(0); VitamConfiguration.setAdminTenant(1); ContainerRequestContext containerRequestContext = spy(ContainerRequestContext.class); EndpointAdminOnlyAuthorizationFilter instance = new EndpointAdminOnlyAuthorizationFilter(true); instance.filter(containerRequestContext); verify(containerRequestContext, only()).abortWith(any()); }
@Test public void testAccessGrantedToAPIAdmin() throws Exception { VitamThreadUtils.getVitamSession().setTenantId(1); VitamConfiguration.setAdminTenant(1); ContainerRequestContext containerRequestContext = spy(ContainerRequestContext.class); EndpointAdminOnlyAuthorizationFilter instance = new EndpointAdminOnlyAuthorizationFilter(true); instance.filter(containerRequestContext); verify(containerRequestContext, never()).abortWith(any()); }
@Test public void testAccessGrantedToNotAPIAdmin() throws Exception { VitamThreadUtils.getVitamSession().setTenantId(0); VitamConfiguration.setAdminTenant(1); ContainerRequestContext containerRequestContext = spy(ContainerRequestContext.class); EndpointAdminOnlyAuthorizationFilter instance = new EndpointAdminOnlyAuthorizationFilter(false); instance.filter(containerRequestContext); verify(containerRequestContext, never()).abortWith(any()); }
|
### Question:
BasicAuthenticationFilter implements DynamicFeature { @Override public void configure(ResourceInfo resourceInfo, FeatureContext featureContext) { VitamAuthentication authentication = resourceInfo.getResourceMethod().getAnnotation(VitamAuthentication.class); if (authentication == null) { LOGGER.debug(String .format("Ignore @%s non annotated method %s for the class %s", VitamAuthentication.class.getName(), resourceInfo.getResourceMethod().getName(), resourceInfo.getResourceClass().getName())); return; } LOGGER .debug(String.format( "Registering VitamAuthentication filters with '%s' authentication level for %s annotated method %s.%s", authentication.authentLevel(), VitamAuthentication.class.getName(), resourceInfo.getResourceClass().getName(), resourceInfo.getResourceMethod().getName())); featureContext .register(new EndpointAuthenticationFilter(authentication.authentLevel(), configuration), Priorities.AUTHORIZATION + 10); } BasicAuthenticationFilter(DefaultVitamApplicationConfiguration configuration); @Override void configure(ResourceInfo resourceInfo, FeatureContext featureContext); }### Answer:
@Test public void checkEndpointAuthenticationFilterRegistration() throws Exception { when(resourceInfo.getResourceMethod()) .thenReturn(BasicAuthenticationFilterTest.class.getMethod("basedVitamAuthenticationMethod")); BasicAuthenticationFilter instance = new BasicAuthenticationFilter(configuration); instance.configure(resourceInfo, featureContext); verify(featureContext) .register(endpointAuthenticationFilter.capture(), eq(Priorities.AUTHORIZATION + 10)); verifyNoMoreInteractions(featureContext); Assert.assertEquals(AUTHENTICATION_LEVEL, endpointAuthenticationFilter.getValue().getAuthentLevel()); }
@Test public void checkEndpointAuthenticationFilterRegistrationUnusedVitamAuthentication() throws Exception { when(resourceInfo.getResourceMethod()) .thenReturn(this.getClass().getMethod("UnusedVitamAuthenticationMethod")); BasicAuthenticationFilter instance = new BasicAuthenticationFilter(configuration); instance.configure(resourceInfo, featureContext); verify(featureContext, never()).register(any(), anyInt()); }
|
### Question:
Query { public void clean() { currentQuery.removeAll(); currentObject = currentQuery; currentTokenQUERY = null; ready = false; } protected Query(); void clean(); final Query setExactDepthLimit(final int exactdepth); final Query setRelativeDepthLimit(final int relativedepth); final Query setDepthLimit(final int relativedepth); ObjectNode getCurrentQuery(); JsonNode getNode(String key); JsonNode getCurrentObject(); QUERY getQUERY(); boolean isReady(); Query setExtraInfo(int val); int getExtraInfo(); final boolean isFullText(); final Query setFullText(boolean isFullText); final int getParserExactdepth(); final Query setParserExactdepth(int exactdepth); final int getParserRelativeDepth(); final Query setParserRelativeDepth(int relativedepth); @Override String toString(); static final String DATE; }### Answer:
@Test public void testClean() throws InvalidCreateOperationException { final BooleanQuery bq = new BooleanQuery(QUERY.AND); final MltQuery mq = new MltQuery(QUERY.MLT, "var", "val"); final InQuery iq = new InQuery(QUERY.IN, "var", true); bq.clean(); assertEquals(0, bq.getCurrentObject().size()); mq.clean(); assertEquals(0, mq.getCurrentObject().size()); iq.clean(); assertEquals(0, iq.getCurrentObject().size()); }
|
### Question:
Select extends RequestSingle { public final Select addOrderByAscFilter(final String... variableNames) throws InvalidParseOperationException { selectAddOrderByAscFilter(variableNames); return this; } final Select resetLimitFilter(); final Select resetOrderByFilter(); final Select resetUsedProjection(); @Override final Select reset(); final Select setLimitFilter(final long offset, final long limit); final Select setLimitFilter(final JsonNode filterContent); final Select parseLimitFilter(final String filter); final Select addOrderByAscFilter(final String... variableNames); final Select addOrderByDescFilter(final String... variableNames); final Select addOrderByFilter(final JsonNode filterContent); final Select parseOrderByFilter(final String filter); @Override final Select setFilter(final JsonNode filterContent); final Select addUsedProjection(final String... variableNames); final Select addUnusedProjection(final String... variableNames); final Select addProjection(final JsonNode projectionContent); final Select parseProjection(final String projection); final Select setProjection(final JsonNode projectionContent); final ObjectNode getFinalSelect(); final ObjectNode getFinalSelectById(); @Override String toString(); }### Answer:
@Test public void testAddOrderByAscFilter() { final Select select = new Select(); try { select.addOrderByAscFilter("var1", "var2"); assertEquals(2, select.getFilter().get(SELECTFILTER.ORDERBY.exactToken()).size()); select.addOrderByAscFilter("var3").addOrderByAscFilter("var4"); assertEquals(4, select.getFilter().get(SELECTFILTER.ORDERBY.exactToken()).size()); select.addOrderByDescFilter("var1", "var2"); assertEquals(4, select.getFilter().get(SELECTFILTER.ORDERBY.exactToken()).size()); select.addOrderByDescFilter("var3").addOrderByDescFilter("var4"); } catch (final InvalidParseOperationException e) { e.printStackTrace(); fail(e.getMessage()); } assertEquals(4, select.getFilter().get(SELECTFILTER.ORDERBY.exactToken()).size()); select.resetOrderByFilter(); assertFalse(select.getFilter().has(SELECTFILTER.ORDERBY.exactToken())); }
|
### Question:
Update extends RequestSingle { public final Update addActions(final Action... action) throws InvalidCreateOperationException { for (final Action act : action) { if (!act.isReady()) { throw new InvalidCreateOperationException( "Action is not ready to be added: " + act.getCurrentAction()); } actions.add(act); } return this; } final Update resetActions(); @Override final Update reset(); final Update setMult(final boolean mult); final Update setMult(final JsonNode filterContent); @Override final Update setFilter(final JsonNode filterContent); final Update addActions(final Action... action); final ObjectNode getFinalUpdateById(); final ObjectNode getFinalUpdate(); @Override final List<Action> getActions(); @Override String toString(); }### Answer:
@Test public void testAddActions() { final Update update = new Update(); assertTrue(update.actions.isEmpty()); try { update.addActions(new AddAction("varname", 1).add(true)); update.addActions(new IncAction("varname2", 2)); update.addActions(new PullAction("varname3", true).add("val")); update.addActions(new PopAction("varname4")); update.addActions(new PushAction("varname5", "val").add(1.0)); update.addActions(new RenameAction("varname6", "varname7")); update.addActions(new SetAction("varname8", "val").add("varname9", 1)); update.addActions(new UnsetAction("varname10", "varname11").add("varname12")); assertEquals(8, update.actions.size()); update.resetActions(); assertEquals(0, update.actions.size()); } catch (final InvalidCreateOperationException e) { e.printStackTrace(); fail(e.getMessage()); } }
|
### Question:
Update extends RequestSingle { public final ObjectNode getFinalUpdate() { final ObjectNode node = getFinal(); if (actions != null && !actions.isEmpty()) { final ArrayNode array = JsonHandler.createArrayNode(); for (final Action action : actions) { array.add(action.getCurrentAction()); } node.set(GLOBAL.ACTION.exactToken(), array); } else { node.putArray(GLOBAL.ACTION.exactToken()); } return node; } final Update resetActions(); @Override final Update reset(); final Update setMult(final boolean mult); final Update setMult(final JsonNode filterContent); @Override final Update setFilter(final JsonNode filterContent); final Update addActions(final Action... action); final ObjectNode getFinalUpdateById(); final ObjectNode getFinalUpdate(); @Override final List<Action> getActions(); @Override String toString(); }### Answer:
@Test public void testGetFinalUpdate() { final Update update = new Update(); assertNull(update.query); try { update.setQuery(new PathQuery("path3")); assertTrue(update.query.getCurrentQuery().fields().hasNext()); update.addActions(new IncAction("mavar")); final ObjectNode node = update.getFinalUpdate(); assertEquals(3, node.size()); } catch (final InvalidCreateOperationException e) { e.printStackTrace(); fail(e.getMessage()); } }
|
### Question:
Update extends RequestSingle { public final ObjectNode getFinalUpdateById() { final ObjectNode node = getFinalUpdate(); node.remove(GLOBAL.QUERY.exactToken()); node.remove(GLOBAL.FILTER.exactToken()); node.remove(GLOBAL.PROJECTION.exactToken()); return node; } final Update resetActions(); @Override final Update reset(); final Update setMult(final boolean mult); final Update setMult(final JsonNode filterContent); @Override final Update setFilter(final JsonNode filterContent); final Update addActions(final Action... action); final ObjectNode getFinalUpdateById(); final ObjectNode getFinalUpdate(); @Override final List<Action> getActions(); @Override String toString(); }### Answer:
@Test public void testGetFinalUpdateById() { final Update update = new Update(); assertNull(update.query); try { update.setQuery(new PathQuery("path3")); assertTrue(update.query.getCurrentQuery().fields().hasNext()); update.addActions(new IncAction("mavar")); final ObjectNode node = update.getFinalUpdateById(); assertEquals(1, node.size()); } catch (final InvalidCreateOperationException e) { e.printStackTrace(); fail(e.getMessage()); } }
|
### Question:
InsertMultiQuery extends RequestMultiple { public final InsertMultiQuery setMult(final boolean mult) { if (filter == null) { filter = JsonHandler.createObjectNode(); } filter.put(MULTIFILTER.MULT.exactToken(), mult); return this; } final InsertMultiQuery resetData(); @Override final InsertMultiQuery reset(); final InsertMultiQuery setMult(final boolean mult); final InsertMultiQuery setMult(final JsonNode filterContent); @Override final InsertMultiQuery setFilter(final JsonNode filterContent); final InsertMultiQuery addData(final ObjectNode... data); final InsertMultiQuery setData(final JsonNode dataContent); final InsertMultiQuery parseData(final String data); final ObjectNode getFinalInsert(); @Override final ObjectNode getData(); @Override String toString(); }### Answer:
@Test public void testSetMult() { final InsertMultiQuery insert = new InsertMultiQuery(); assertTrue(insert.getFilter().size() == 0); insert.setMult(true); assertTrue(insert.getFilter().size() == 1); insert.setMult(false); assertTrue(insert.getFilter().size() == 1); assertTrue(insert.getFilter().has(MULTIFILTER.MULT.exactToken())); insert.resetFilter(); assertTrue(insert.getFilter().size() == 0); }
|
### Question:
InsertMultiQuery extends RequestMultiple { public final InsertMultiQuery addData(final ObjectNode... data) { if (this.data == null) { this.data = JsonHandler.createObjectNode(); } for (final ObjectNode act : data) { if (!act.isMissingNode()) { this.data.setAll(act); } } return this; } final InsertMultiQuery resetData(); @Override final InsertMultiQuery reset(); final InsertMultiQuery setMult(final boolean mult); final InsertMultiQuery setMult(final JsonNode filterContent); @Override final InsertMultiQuery setFilter(final JsonNode filterContent); final InsertMultiQuery addData(final ObjectNode... data); final InsertMultiQuery setData(final JsonNode dataContent); final InsertMultiQuery parseData(final String data); final ObjectNode getFinalInsert(); @Override final ObjectNode getData(); @Override String toString(); }### Answer:
@Test public void testAddData() { final InsertMultiQuery insert = new InsertMultiQuery(); assertNull(insert.data); insert.addData(JsonHandler.createObjectNode().put("var1", 1)); insert.addData(JsonHandler.createObjectNode().put("var2", "val")); assertEquals(2, insert.data.size()); insert.resetData(); assertEquals(0, insert.data.size()); }
|
### Question:
InsertMultiQuery extends RequestMultiple { public final ObjectNode getFinalInsert() { final ObjectNode node = getFinal(); if (data != null && data.size() > 0) { node.set(GLOBAL.DATA.exactToken(), data); } else { node.putObject(GLOBAL.DATA.exactToken()); } return node; } final InsertMultiQuery resetData(); @Override final InsertMultiQuery reset(); final InsertMultiQuery setMult(final boolean mult); final InsertMultiQuery setMult(final JsonNode filterContent); @Override final InsertMultiQuery setFilter(final JsonNode filterContent); final InsertMultiQuery addData(final ObjectNode... data); final InsertMultiQuery setData(final JsonNode dataContent); final InsertMultiQuery parseData(final String data); final ObjectNode getFinalInsert(); @Override final ObjectNode getData(); @Override String toString(); }### Answer:
@Test public void testGetFinalInsert() { final InsertMultiQuery insert = new InsertMultiQuery(); assertTrue(insert.queries.isEmpty()); try { insert.addQueries(new PathQuery("path3")); assertEquals(1, insert.queries.size()); insert.setMult(true); insert.addData(JsonHandler.createObjectNode().put("var1", 1)); final ObjectNode node = insert.getFinalInsert(); assertEquals(4, node.size()); } catch (final InvalidCreateOperationException e) { e.printStackTrace(); fail(e.getMessage()); } }
|
### Question:
InsertMultiQuery extends RequestMultiple { public final InsertMultiQuery setData(final JsonNode dataContent) throws InvalidParseOperationException { if (data == null) { data = JsonHandler.createObjectNode(); } data.setAll((ObjectNode) dataContent); return this; } final InsertMultiQuery resetData(); @Override final InsertMultiQuery reset(); final InsertMultiQuery setMult(final boolean mult); final InsertMultiQuery setMult(final JsonNode filterContent); @Override final InsertMultiQuery setFilter(final JsonNode filterContent); final InsertMultiQuery addData(final ObjectNode... data); final InsertMultiQuery setData(final JsonNode dataContent); final InsertMultiQuery parseData(final String data); final ObjectNode getFinalInsert(); @Override final ObjectNode getData(); @Override String toString(); }### Answer:
@Test public void testSetData() throws InvalidParseOperationException { final InsertMultiQuery insert = new InsertMultiQuery(); assertNull(insert.data); assertEquals(JsonHandler.createObjectNode(), insert.getData()); insert.resetData(); assertNull(insert.data); insert.reset(); assertNull(insert.data); final JsonNode data1 = JsonHandler.createObjectNode().put("var1", 1); final JsonNode data2 = JsonHandler.createObjectNode().put("var2", 2); insert.setData(data1); assertEquals(1, insert.data.size()); assertEquals(JsonHandler.createObjectNode().put("var1", 1), insert.getData()); insert.setData(data2); assertEquals(2, insert.data.size()); insert.reset(); assertEquals(0, insert.data.size()); }
|
### Question:
InsertMultiQuery extends RequestMultiple { public final InsertMultiQuery parseData(final String data) throws InvalidParseOperationException { GlobalDatas.sanityValueCheck(data); final JsonNode dataContent = JsonHandler.getFromString(data); return setData(dataContent); } final InsertMultiQuery resetData(); @Override final InsertMultiQuery reset(); final InsertMultiQuery setMult(final boolean mult); final InsertMultiQuery setMult(final JsonNode filterContent); @Override final InsertMultiQuery setFilter(final JsonNode filterContent); final InsertMultiQuery addData(final ObjectNode... data); final InsertMultiQuery setData(final JsonNode dataContent); final InsertMultiQuery parseData(final String data); final ObjectNode getFinalInsert(); @Override final ObjectNode getData(); @Override String toString(); }### Answer:
@Test public void testParseData() throws InvalidParseOperationException { final InsertMultiQuery insert = new InsertMultiQuery(); insert.setMult(true); insert.resetFilter(); final String data = "{'var1':1}"; insert.parseData(data); final String res = "INSERT: Requests: \n\tFilter: {}\n\tRoots: []\n\tData: {\"var1\":1}"; assertEquals(res, insert.toString()); }
|
### Question:
DeleteMultiQuery extends RequestMultiple { public final DeleteMultiQuery setMult(final boolean mult) { if (filter == null) { filter = JsonHandler.createObjectNode(); } filter.put(MULTIFILTER.MULT.exactToken(), mult); return this; } final DeleteMultiQuery setMult(final boolean mult); final DeleteMultiQuery setMult(final JsonNode filterContent); @Override final DeleteMultiQuery setFilter(final JsonNode filterContent); final ObjectNode getFinalDelete(); @Override String toString(); }### Answer:
@Test public void testSetMult() { final DeleteMultiQuery delete = new DeleteMultiQuery(); assertTrue(delete.getFilter().size() == 0); delete.setMult(true); assertTrue(delete.getFilter().size() == 1); delete.setMult(false); assertTrue(delete.getFilter().size() == 1); assertTrue(delete.getFilter().has(MULTIFILTER.MULT.exactToken())); delete.resetFilter(); assertTrue(delete.getFilter().size() == 0); }
|
### Question:
DeleteMultiQuery extends RequestMultiple { public final ObjectNode getFinalDelete() { return getFinal(); } final DeleteMultiQuery setMult(final boolean mult); final DeleteMultiQuery setMult(final JsonNode filterContent); @Override final DeleteMultiQuery setFilter(final JsonNode filterContent); final ObjectNode getFinalDelete(); @Override String toString(); }### Answer:
@Test public void testGetFinalDelete() { final DeleteMultiQuery delete = new DeleteMultiQuery(); assertTrue(delete.queries.isEmpty()); try { delete.addQueries(new PathQuery("path3")); assertEquals(1, delete.queries.size()); delete.setMult(true); final ObjectNode node = delete.getFinalDelete(); assertEquals(3, node.size()); } catch (final InvalidCreateOperationException e) { e.printStackTrace(); fail(e.getMessage()); } }
|
### Question:
DeleteMultiQuery extends RequestMultiple { @Override public String toString() { final StringBuilder builder = new StringBuilder(); builder.append("DELETE: ").append(super.toString()); return builder.toString(); } final DeleteMultiQuery setMult(final boolean mult); final DeleteMultiQuery setMult(final JsonNode filterContent); @Override final DeleteMultiQuery setFilter(final JsonNode filterContent); final ObjectNode getFinalDelete(); @Override String toString(); }### Answer:
@Test public void testToString() throws InvalidCreateOperationException { final DeleteMultiQuery delete = new DeleteMultiQuery(); delete.addQueries(new ExistsQuery(QUERY.EXISTS, "var1")); delete.setMult(true); delete.resetFilter(); final String s = "DELETE: Requests: \n{\"$exists\":\"var1\"}\n\tFilter: {}\n\tRoots: []"; assertEquals(s, delete.toString()); }
|
### Question:
UpdateMultiQuery extends RequestMultiple { public final UpdateMultiQuery setMult(final boolean mult) { if (filter == null) { filter = JsonHandler.createObjectNode(); } filter.put(MULTIFILTER.MULT.exactToken(), mult); return this; } final UpdateMultiQuery resetActions(); @Override final UpdateMultiQuery reset(); final UpdateMultiQuery setMult(final boolean mult); final UpdateMultiQuery setMult(final JsonNode filterContent); @Override final UpdateMultiQuery setFilter(final JsonNode filterContent); final UpdateMultiQuery addActions(final Action... action); final ObjectNode getFinalUpdateById(); final ObjectNode getFinalUpdate(); @Override final List<Action> getActions(); @Override String toString(); }### Answer:
@Test public void testSetMult() { final UpdateMultiQuery update = new UpdateMultiQuery(); assertTrue(update.getFilter().size() == 0); update.setMult(true); assertTrue(update.getFilter().size() == 1); update.setMult(false); assertTrue(update.getFilter().size() == 1); assertTrue(update.getFilter().has(MULTIFILTER.MULT.exactToken())); update.resetFilter(); assertTrue(update.getFilter().size() == 0); }
|
### Question:
UpdateMultiQuery extends RequestMultiple { public final UpdateMultiQuery addActions(final Action... action) throws InvalidCreateOperationException { for (final Action act : action) { if (!act.isReady()) { throw new InvalidCreateOperationException( "Action is not ready to be added: " + act.getCurrentAction()); } actions.add(act); } return this; } final UpdateMultiQuery resetActions(); @Override final UpdateMultiQuery reset(); final UpdateMultiQuery setMult(final boolean mult); final UpdateMultiQuery setMult(final JsonNode filterContent); @Override final UpdateMultiQuery setFilter(final JsonNode filterContent); final UpdateMultiQuery addActions(final Action... action); final ObjectNode getFinalUpdateById(); final ObjectNode getFinalUpdate(); @Override final List<Action> getActions(); @Override String toString(); }### Answer:
@Test public void testAddActions() { final UpdateMultiQuery update = new UpdateMultiQuery(); assertTrue(update.actions.isEmpty()); try { update.addActions(new AddAction("varname", 1).add(true)); update.addActions(new IncAction("varname2", 2)); update.addActions(new PullAction("varname3", true).add("val")); update.addActions(new PopAction("varname4")); update.addActions(new PushAction("varname5", "val").add(1.0)); update.addActions(new RenameAction("varname6", "varname7")); update.addActions(new SetAction("varname8", "val").add("varname9", 1)); update.addActions(new UnsetAction("varname10", "varname11").add("varname12")); assertEquals(8, update.actions.size()); update.resetActions(); assertEquals(0, update.actions.size()); } catch (final InvalidCreateOperationException e) { e.printStackTrace(); fail(e.getMessage()); } }
|
### Question:
UpdateMultiQuery extends RequestMultiple { public final ObjectNode getFinalUpdateById() { final ObjectNode node = getFinalUpdate(); node.remove(GLOBAL.QUERY.exactToken()); node.remove(GLOBAL.ROOTS.exactToken()); node.remove(GLOBAL.FILTER.exactToken()); node.remove(GLOBAL.PROJECTION.exactToken()); return node; } final UpdateMultiQuery resetActions(); @Override final UpdateMultiQuery reset(); final UpdateMultiQuery setMult(final boolean mult); final UpdateMultiQuery setMult(final JsonNode filterContent); @Override final UpdateMultiQuery setFilter(final JsonNode filterContent); final UpdateMultiQuery addActions(final Action... action); final ObjectNode getFinalUpdateById(); final ObjectNode getFinalUpdate(); @Override final List<Action> getActions(); @Override String toString(); }### Answer:
@Test public void testGetFinalUpdateById() throws Exception { final UpdateMultiQuery update = new UpdateMultiQuery(); assertTrue(update.queries.isEmpty()); update.addQueries(new PathQuery("path3")); assertEquals(1, update.queries.size()); update.setMult(true); update.addActions(new IncAction("mavar")); final ObjectNode node = update.getFinalUpdateById(); assertEquals(1, node.size()); }
|
### Question:
VitamDocumentCodec implements CollectibleCodec<T> { public VitamDocumentCodec(Class<T> clazz) { try { documentCodec = new DocumentCodec(); clasz = clazz; constructor = clazz.getConstructor(Document.class); } catch (final Exception ex) { throw new IllegalArgumentException(ex); } } VitamDocumentCodec(Class<T> clazz); @Override void encode(BsonWriter writer, T value, EncoderContext encoderContext); @Override T generateIdIfAbsentFromDocument(T document); @Override boolean documentHasId(T document); @Override BsonValue getDocumentId(T document); @Override Class<T> getEncoderClass(); @Override T decode(BsonReader reader, DecoderContext decoderContext); }### Answer:
@Test public final void testVitamDocumentCodec() { try { new VitamDocumentCodec<>(Document.class); fail("should failed"); } catch (final IllegalArgumentException e) { } final VitamDocumentCodec<PseudoClass> vitamDocumentCodec = new VitamDocumentCodec<>(PseudoClass.class); final PseudoClass document = new PseudoClass(); assertTrue(vitamDocumentCodec.documentHasId(document)); assertNotNull(vitamDocumentCodec.getDocumentId(document)); assertNotNull(vitamDocumentCodec.generateIdIfAbsentFromDocument(document)); assertEquals(PseudoClass.class, vitamDocumentCodec.getEncoderClass()); document.remove("_id"); assertFalse(vitamDocumentCodec.documentHasId(document)); try { vitamDocumentCodec.getDocumentId(document); fail("should failed"); } catch (final IllegalStateException e) { } assertNotNull(vitamDocumentCodec.generateIdIfAbsentFromDocument(document)); assertTrue(vitamDocumentCodec.documentHasId(document)); assertNotNull(vitamDocumentCodec.getDocumentId(document)); }
|
### Question:
QueryToMongodb { protected static Iterable<Bson> getCommands(final List<Query> queries) { return new Iterable<Bson>() { @Override public Iterator<Bson> iterator() { return new Iterator<Bson>() { private int rank = 0; @Override public Bson next() { try { return getCommand(queries.get(rank++)); } catch (final InvalidParseOperationException e) { LOGGER.error("Bad request", e); return null; } } @Override public boolean hasNext() { return rank < queries.size(); } }; } }; } private QueryToMongodb(); static Bson getRoots(final String field, final Collection<String> roots); static Bson getFullCommand(final Bson command, final Bson roots); static Bson getCommand(final Query query); }### Answer:
@Test public void testGetCommands() { try { final SelectMultiQuery select = createSelect(); final Bson bsonRoot = QueryToMongodb.getRoots("_up", select.getRoots()); final List<Query> list = select.getQueries(); for (int i = 0; i < list.size(); i++) { System.out.println(i + " = " + list.get(i).toString()); final Bson bsonQuery = QueryToMongodb.getCommand(list.get(i)); final Bson pseudoRequest = QueryToMongodb.getFullCommand(bsonQuery, bsonRoot); System.out.println(i + " = " + MongoDbHelper.bsonToString(pseudoRequest, false)); } } catch (final Exception e) { e.printStackTrace(); fail(e.getMessage()); } }
|
### Question:
QueryToMongodb { public static Bson getRoots(final String field, final Collection<String> roots) { if (roots.size() == 1) { return eq(field, roots.iterator().next()); } final String[] values = new String[roots.size()]; int i = 0; for (final String node : roots) { values[i++] = node; } return in(field, values); } private QueryToMongodb(); static Bson getRoots(final String field, final Collection<String> roots); static Bson getFullCommand(final Bson command, final Bson roots); static Bson getCommand(final Query query); }### Answer:
@Test public void testGetMultiRoots() throws InvalidParseOperationException { final SelectParserMultiple request = new SelectParserMultiple(); request.parse(multiRootsJson); final SelectMultiQuery select = request.getRequest(); final Bson bsonRoot = QueryToMongodb.getRoots("_up", select.getRoots()); assertEquals("{\"_up\": {\"$in\": [\"id0\", \"id1\"]}}", MongoDbHelper.bsonToString(bsonRoot, false)); }
|
### Question:
MongoDbHelper { public static String bsonToString(Bson bson, boolean indent) { if (bson == null) { return ""; } if (indent) { return bson.toBsonDocument(BsonDocument.class, MongoClient.getDefaultCodecRegistry()).toJson(jwsIndented); } else { return bson.toBsonDocument(BsonDocument.class, MongoClient.getDefaultCodecRegistry()).toJson(jws); } } private MongoDbHelper(); static String bsonToString(Bson bson, boolean indent); }### Answer:
@Test public void testBsonToStringFn() { final Bson bson = BsonDocument.parse(test); assertEquals(test, MongoDbHelper.bsonToString(bson, false)); assertEquals("{\n \"data\": 1\n}", MongoDbHelper.bsonToString(bson, true)); }
|
### Question:
RequestToElasticsearch extends RequestToAbstract { public static RequestToElasticsearch getRequestToElasticsearch(AbstractParser<?> requestParser) throws VitamException { if (requestParser instanceof SelectParserMultiple || requestParser instanceof SelectParserSingle) { return new SelectToElasticsearch(requestParser); } else { throw new VitamException("Only Select Request is allowed on Indexation"); } } RequestToElasticsearch(AbstractParser<?> requestParser); static RequestToElasticsearch getRequestToElasticsearch(AbstractParser<?> requestParser); QueryBuilder getInitialRoots(final String field); QueryBuilder getRequest(QueryBuilder roots, QueryBuilder query); QueryBuilder getNthQueries(final int nth, VarNameAdapter adapter, DynamicParserTokens parserTokens); }### Answer:
@Test public void testGetRequestToElasticsearch() { try { final SelectParserMultiple request1 = new SelectParserMultiple(); request1.parse(exampleSelectElasticsearch); assertNotNull(request1); assertTrue(RequestToElasticsearch.getRequestToElasticsearch(request1) instanceof SelectToElasticsearch); } catch (final Exception e) { e.printStackTrace(); fail(e.getMessage()); } }
@Test(expected = VitamException.class) public void shouldRaiseException_whenRequestIsNotAllowed() throws InvalidCreateOperationException, VitamException { final DeleteParserMultiple request1 = new DeleteParserMultiple(); RequestToElasticsearch.getRequestToElasticsearch(request1); }
@Test public void testGetNestedRequestToElasticsearch() { try { final SelectParserMultiple request1 = new SelectParserMultiple(); request1.parse(nestedSearchQuery); assertNotNull(request1); assertTrue(RequestToElasticsearch.getRequestToElasticsearch(request1) instanceof SelectToElasticsearch); } catch (final Exception e) { e.printStackTrace(); fail(e.getMessage()); } }
|
### Question:
ElasticsearchHelper { private ElasticsearchHelper() { } private ElasticsearchHelper(); static String queryBuilderToString(final QueryBuilder query); }### Answer:
@Test public void testElasticsearchHelper() throws NoSuchMethodException, SecurityException, InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException { final Constructor<ElasticsearchHelper> constructor = ElasticsearchHelper.class.getDeclaredConstructor(); assertTrue(Modifier.isPrivate(constructor.getModifiers())); constructor.setAccessible(true); final ElasticsearchHelper helper = constructor.newInstance(); assertNotNull(helper); assertEquals(QUERY.toString(), ElasticsearchHelper.queryBuilderToString(QUERY)); }
|
### Question:
OffsetRepository { public void createOrUpdateOffset(int tenant, String strategy, String collection, long offset) { Bson offsetFilter = and( eq("_tenant", tenant), eq("strategy", strategy), eq("collection", collection) ); Bson offsetUpdate = Updates.set("offset", offset); UpdateOptions updateOptions = new UpdateOptions(); updateOptions.upsert(true); offerCollection.updateOne(offsetFilter, offsetUpdate, updateOptions); } @VisibleForTesting OffsetRepository(MongoDbAccess mongoDbAccess, String collectionName); OffsetRepository(MongoDbAccess mongoDbAccess); void createOrUpdateOffset(int tenant, String strategy, String collection, long offset); long findOffsetBy(int tenant, String strategy, String collection); static final String COLLECTION_NAME; }### Answer:
@Test public void should_insert_if_not_exist() { offsetRepository.createOrUpdateOffset(1, "default", "Unit", 1); assertThat(mongoCollection.countDocuments()).isEqualTo(1); assertThat(mongoCollection.find()) .extracting("offset", "collection", "strategy", "_tenant") .contains(Tuple.tuple(1L, "Unit", "default", 1)); }
@Test public void should_update_document_if_already_present() { offsetRepository.createOrUpdateOffset(1, "default", "Unit", 1); offsetRepository.createOrUpdateOffset(1, "default", "Unit", 15); assertThat(mongoCollection.countDocuments()).isEqualTo(1); assertThat(mongoCollection.find()) .extracting("offset", "collection", "strategy", "_tenant") .contains(Tuple.tuple(15L, "Unit", "default", 1)); }
|
### Question:
OffsetRepository { public long findOffsetBy(int tenant, String strategy, String collection) { Bson offsetFilter = and( eq("_tenant", tenant), eq("strategy", strategy), eq("collection", collection) ); FindIterable<Document> documents = offerCollection.find(offsetFilter); Document first = documents.first(); if (first == null) { return 0L; } return first.get("offset", Long.class); } @VisibleForTesting OffsetRepository(MongoDbAccess mongoDbAccess, String collectionName); OffsetRepository(MongoDbAccess mongoDbAccess); void createOrUpdateOffset(int tenant, String strategy, String collection, long offset); long findOffsetBy(int tenant, String strategy, String collection); static final String COLLECTION_NAME; }### Answer:
@Test public void should_select_offset_if_not_present() { Long offset = offsetRepository.findOffsetBy(1, "default", "Unit"); assertThat(offset).isEqualTo(0); }
|
### Question:
VitamElasticsearchRepository implements VitamRepository { @Override public Optional<Document> findByIdentifier(String identifier) throws DatabaseException { ParametersChecker.checkParameter(ALL_PARAMS_REQUIRED); String index = indexName; try { return handleSearch(index, termQuery(IDENTIFIER, identifier)); } catch (IOException e) { throw new DatabaseException("Search by identifier exception", e); } } VitamElasticsearchRepository(RestHighLevelClient client, String indexName, boolean indexByTenant); @Override void save(Document document); @Override VitamRepositoryStatus saveOrUpdate(Document document); @Override void save(List<Document> documents); void save(ElasticsearchCollections elasticsearchCollections, List<Document> documents); @Override void saveOrUpdate(List<Document> documents); @Override void update(List<WriteModel<Document>> updates); @Override FindIterable<Document> findDocuments(Collection<String> ids, Bson projection); @Override void remove(String id, Integer tenant); @Override long remove(Bson query); @Override void removeByNameAndTenant(String name, Integer tenant); @Override long purge(Integer tenant); static long handlePurge(RestHighLevelClient client, String index, QueryBuilder qb); @Override long purge(); @Override Optional<Document> getByID(String id, Integer tenant); @Override Optional<Document> findByIdentifierAndTenant(String identifier, Integer tenant); SearchResponse search(String index, QueryBuilder qb); @Override Optional<Document> findByIdentifier(String identifier); @Override FindIterable<Document> findByFieldsDocuments(Map<String, String> fields, int mongoBatchSize,
Integer tenant); @Override FindIterable<Document> findDocuments(int mongoBatchSize, Integer tenant); @Override FindIterable<Document> findDocuments(int mongoBatchSize); @Override FindIterable<Document> findDocuments(Bson query, int mongoBatchSize); @Override void delete(List<String> ids, int tenant); static final String IDENTIFIER; }### Answer:
@Test public void testFindByIdentifierFoundEmpty() throws DatabaseException { Optional<Document> response = repository.findByIdentifier("FakeIdentifier"); assertThat(response).isEmpty(); }
|
### Question:
VitamElasticsearchRepository implements VitamRepository { @Override public void removeByNameAndTenant(String name, Integer tenant) throws DatabaseException { throw new DatabaseException("removeByNameAndTenant not implemented for Elasticsearch repository"); } VitamElasticsearchRepository(RestHighLevelClient client, String indexName, boolean indexByTenant); @Override void save(Document document); @Override VitamRepositoryStatus saveOrUpdate(Document document); @Override void save(List<Document> documents); void save(ElasticsearchCollections elasticsearchCollections, List<Document> documents); @Override void saveOrUpdate(List<Document> documents); @Override void update(List<WriteModel<Document>> updates); @Override FindIterable<Document> findDocuments(Collection<String> ids, Bson projection); @Override void remove(String id, Integer tenant); @Override long remove(Bson query); @Override void removeByNameAndTenant(String name, Integer tenant); @Override long purge(Integer tenant); static long handlePurge(RestHighLevelClient client, String index, QueryBuilder qb); @Override long purge(); @Override Optional<Document> getByID(String id, Integer tenant); @Override Optional<Document> findByIdentifierAndTenant(String identifier, Integer tenant); SearchResponse search(String index, QueryBuilder qb); @Override Optional<Document> findByIdentifier(String identifier); @Override FindIterable<Document> findByFieldsDocuments(Map<String, String> fields, int mongoBatchSize,
Integer tenant); @Override FindIterable<Document> findDocuments(int mongoBatchSize, Integer tenant); @Override FindIterable<Document> findDocuments(int mongoBatchSize); @Override FindIterable<Document> findDocuments(Bson query, int mongoBatchSize); @Override void delete(List<String> ids, int tenant); static final String IDENTIFIER; }### Answer:
@Test(expected = DatabaseException.class) public void testRemoveByNameAndTenantNotImplemented() throws DatabaseException { repository.removeByNameAndTenant("FakeName", 0); }
|
### Question:
VitamMongoRepository implements VitamRepository { @Override public void remove(String id, Integer tenant) throws DatabaseException { ParametersChecker.checkParameter(ALL_PARAMS_REQUIRED, id); DeleteResult delete = collection.deleteOne(new BasicDBObject(ID, id)); long count = delete.getDeletedCount(); if (count == 0) { LOGGER.error(String.format("Document %s is not deleted", id)); throw new DatabaseException(String.format("Document %s is not deleted", id)); } } VitamMongoRepository(MongoCollection<Document> collection); @Override void save(Document document); @Override VitamRepositoryStatus saveOrUpdate(Document document); @Override void save(List<Document> documents); @Override void saveOrUpdate(List<Document> documents); @Override void update(List<WriteModel<Document>> queries); @Override void remove(String id, Integer tenant); @Override long remove(Bson query); @Override void removeByNameAndTenant(String name, Integer tenant); @Override long purge(Integer tenant); @Override long purge(); @Override Optional<Document> getByID(String id, Integer tenant); @Override Optional<Document> findByIdentifierAndTenant(String identifier, Integer tenant); @Override Optional<Document> findByIdentifier(String identifier); @Override FindIterable<Document> findByFieldsDocuments(Map<String, String> fields, int mongoBatchSize,
Integer tenant); @Override FindIterable<Document> findDocuments(Collection<String> ids, Bson projection); @Override FindIterable<Document> findDocuments(int mongoBatchSize, Integer tenant); @Override FindIterable<Document> findDocuments(int mongoBatchSize); @Override FindIterable<Document> findDocuments(Bson query, int mongoBatchSize); @Override void delete(List<String> ids, int tenant); static final String NAME; }### Answer:
@Test(expected = DatabaseException.class) public void testRemoveNotExists() throws DatabaseException { String id = GUIDFactory.newGUID().toString(); Integer tenant = 0; repository.remove(id, tenant); }
|
### Question:
ScrollSpliterator extends AbstractSpliterator<T> { @Override public long estimateSize() { if (requestResponse == null) { executeQuery(); } return hits.getTotal(); } ScrollSpliterator(SelectMultiQuery query, Function<SelectMultiQuery, RequestResponse<T>> repository,
int scrollTimeout, int limit); @Override boolean tryAdvance(Consumer<? super T> action); @Override long estimateSize(); }### Answer:
@Test public void should_invoke_function_two_times_when_try_to_advance() { Function function = mock(Function.class); RequestResponseOK<Long> requestResponseOK1 = new RequestResponseOK<>(); requestResponseOK1.addResult(1L); requestResponseOK1.addResult(2L); requestResponseOK1.addResult(3L); requestResponseOK1.setHits(4, 0, 3, 3); RequestResponseOK<Long> requestResponseOK2 = new RequestResponseOK<>(); requestResponseOK2.addResult(4L); requestResponseOK2.setHits(4, 0, 3, 1); given(function.apply(any(SelectMultiQuery.class))).willReturn(requestResponseOK1).willReturn(requestResponseOK2); SelectMultiQuery query = new SelectMultiQuery(); Spliterator<Long> longSpliterator = new ScrollSpliterator<>(query, function, 3, 4); AtomicInteger counter = new AtomicInteger(0); longSpliterator.forEachRemaining(item -> counter.incrementAndGet()); assertThat(longSpliterator.estimateSize()).isEqualTo(4); assertThat(counter.get()).isEqualTo(4); verify(function, times(2)).apply(query); }
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.