src_fm_fc_ms_ff
stringlengths 43
86.8k
| target
stringlengths 20
276k
|
|---|---|
CreditRepository { @NonNull public Observable<Option<List<CreditDraft>>> getAllCreditDrafts() { return store.getAll(); } @Inject CreditRepository(@NonNull final ReactiveStore<String, CreditDraft> store,
@NonNull final CreditService creditService,
@NonNull final CreditDraftMapper creditDraftMapper); @NonNull Observable<Option<List<CreditDraft>>> getAllCreditDrafts(); @NonNull Completable fetchCreditDrafts(); } | @Test public void getAllCreditDraftsReturnsStoreObservable() { Observable<Option<List<CreditDraft>>> storeObservable = Observable.empty(); new ArrangeBuilder().withObservableFromStore(storeObservable); assertThat(repository.getAllCreditDrafts()).isEqualTo(storeObservable); } |
CreditRepository { @NonNull public Completable fetchCreditDrafts() { return creditService.getCreditDrafts() .subscribeOn(Schedulers.io()) .observeOn(Schedulers.computation()) .flatMapObservable(Observable::fromIterable) .map(creditDraftMapper) .toList() .doOnSuccess(store::replaceAll) .toCompletable(); } @Inject CreditRepository(@NonNull final ReactiveStore<String, CreditDraft> store,
@NonNull final CreditService creditService,
@NonNull final CreditDraftMapper creditDraftMapper); @NonNull Observable<Option<List<CreditDraft>>> getAllCreditDrafts(); @NonNull Completable fetchCreditDrafts(); } | @Test public void fetchCreditDraftsEmitsErrorWhenNetworkServiceErrors() { Throwable throwable = Mockito.mock(Throwable.class); new ArrangeBuilder().withErrorInCreditDraftsFromService(throwable); repository.fetchCreditDrafts().test().assertError(throwable); }
@Test public void creditDraftRawItemsFromServiceAreMapped() throws Exception { List<CreditDraftRaw> rawList = createRawList(); new ArrangeBuilder().withCreditDraftsFromService(rawList) .withMappedCredit(Mockito.mock(CreditDraft.class)); repository.fetchCreditDrafts().subscribe(); Mockito.verify(mapper).apply(rawList.get(0)); Mockito.verify(mapper).apply(rawList.get(1)); Mockito.verify(mapper).apply(rawList.get(2)); }
@Test public void creditDraftsAreStoredInStoreViaReplaceAll() throws Exception { CreditDraft safe = Mockito.mock(CreditDraft.class); new ArrangeBuilder().withCreditDraftsFromService(Collections.singletonList(Mockito.mock(CreditDraftRaw.class))) .withMappedCredit(safe); repository.fetchCreditDrafts().subscribe(); Mockito.verify(store).replaceAll(Collections.singletonList(safe)); } |
CreditRepaymentInfoMapper { @NonNull @SuppressWarnings("ConstantConditions") static CreditRepaymentInfo processRaw(@NonNull final CreditRepaymentInfoRaw raw) { assertEssentialParams(raw); return CreditRepaymentInfo.builder() .disbursedDate(raw.disbursedDate()) .nextPaymentDate(raw.nextPaymentDate()) .nextPayment(raw.nextPayment()) .totalPaid(raw.totalPaid()) .build(); } } | @Test public void map() { CreditRepaymentInfoRaw raw = CreditDataTestUtils.creditRepaymentInfoRawTestBuilder().build(); CreditRepaymentInfo mapped = CreditRepaymentInfoMapper.processRaw(raw); assertThat(mapped.disbursedDate()).isEqualTo(raw.disbursedDate()); assertThat(mapped.nextPaymentDate()).isEqualTo(raw.nextPaymentDate()); assertThat(mapped.nextPayment()).isEqualTo(raw.nextPayment()); assertThat(mapped.totalPaid()).isEqualTo(raw.totalPaid()); }
@Test public void exceptionThrownWhenEssentialParamsMissing() { thrown.expect(EssentialParamMissingException.class); thrown.expectMessage("disbursedDate nextPaymentDate"); CreditRepaymentInfoRaw raw = CreditDataTestUtils.creditRepaymentInfoRawTestBuilder() .disbursedDate(null) .nextPaymentDate(null) .build(); CreditRepaymentInfoMapper.processRaw(raw); } |
RetrieveCreditDraftList implements RetrieveInteractor<Void, List<CreditDraft>> { @NonNull @Override public Observable<List<CreditDraft>> getBehaviorStream(@NonNull final Option<Void> params) { return creditRepository.getAllCreditDrafts() .flatMapSingle(this::fetchWhenNoneAndThenDrafts) .compose(UnwrapOptionTransformer.create()); } @Inject RetrieveCreditDraftList(@NonNull final CreditRepository creditRepository); @NonNull @Override Observable<List<CreditDraft>> getBehaviorStream(@NonNull final Option<Void> params); } | @Test public void draftsFromRepoAreUnwrappedAndPassedOn() { List<CreditDraft> testDraftList = createTestDraftList(); interactor.getBehaviorStream(Option.none()).subscribe(ts); arrangeBuilder.emitDraftListFromRepo(Option.ofObj(testDraftList)); ts.assertNotTerminated(); ts.assertValue(testDraftList); }
@Test public void whenRepoIsEmptyFetchAndNoEmissions() { arrangeBuilder.emitDraftListFromRepo(Option.none()) .withSuccessfulFetch(); interactor.getBehaviorStream(Option.none()).subscribe(ts); verify(creditRepository).fetchCreditDrafts(); ts.assertNoValues(); ts.assertNotTerminated(); }
@Test public void propagateFetchError() { Throwable throwable = Mockito.mock(Throwable.class); arrangeBuilder.emitDraftListFromRepo(Option.none()) .withFetchError(throwable); interactor.getBehaviorStream(Option.none()).subscribe(ts); verify(creditRepository).fetchCreditDrafts(); ts.assertNoValues(); ts.assertError(throwable); } |
MemoryReactiveStore implements ReactiveStore<Key, Value> { public void storeSingular(@NonNull final Value model) { final Key key = extractKeyFromModel.call(model); cache.putSingular(model); getOrCreateSubjectForKey(key).onNext(ofObj(model)); final Option<List<Value>> allValues = cache.getAll().map(Option::ofObj).blockingGet(none()); allSubject.onNext(allValues); } MemoryReactiveStore(@NonNull final Func1<Value, Key> extractKeyFromModel,
@NonNull final Store.MemoryStore<Key, Value> cache); void storeSingular(@NonNull final Value model); void storeAll(@NonNull final List<Value> modelList); void replaceAll(@NonNull final List<Value> modelList); @NonNull Observable<Option<Value>> getSingular(@NonNull final Key key); @NonNull Observable<Option<List<Value>>> getAll(); } | @Test public void objectIsStoredInCache() { TestObject model = new TestObject("ID1"); new ArrangeBuilder().withCachedObjectList(Collections.singletonList(model)); reactiveStore.storeSingular(model); Mockito.verify(cache).putSingular(model); } |
MemoryReactiveStore implements ReactiveStore<Key, Value> { public void storeAll(@NonNull final List<Value> modelList) { cache.putAll(modelList); allSubject.onNext(ofObj(modelList)); publishInEachKey(); } MemoryReactiveStore(@NonNull final Func1<Value, Key> extractKeyFromModel,
@NonNull final Store.MemoryStore<Key, Value> cache); void storeSingular(@NonNull final Value model); void storeAll(@NonNull final List<Value> modelList); void replaceAll(@NonNull final List<Value> modelList); @NonNull Observable<Option<Value>> getSingular(@NonNull final Key key); @NonNull Observable<Option<List<Value>>> getAll(); } | @Test public void objectListIsStoredInCache() { List<TestObject> list = createTestObjectList(); reactiveStore.storeAll(list); Mockito.verify(cache).putAll(list); } |
MemoryReactiveStore implements ReactiveStore<Key, Value> { public void replaceAll(@NonNull final List<Value> modelList) { cache.clear(); storeAll(modelList); } MemoryReactiveStore(@NonNull final Func1<Value, Key> extractKeyFromModel,
@NonNull final Store.MemoryStore<Key, Value> cache); void storeSingular(@NonNull final Value model); void storeAll(@NonNull final List<Value> modelList); void replaceAll(@NonNull final List<Value> modelList); @NonNull Observable<Option<Value>> getSingular(@NonNull final Key key); @NonNull Observable<Option<List<Value>>> getAll(); } | @Test public void cacheIsClearedInReplaceAll() { List<TestObject> list = createTestObjectList(); reactiveStore.replaceAll(list); Mockito.verify(cache).clear(); } |
Cache implements MemoryStore<Key, Value> { @Override @NonNull public Maybe<Value> getSingular(@NonNull final Key key) { return Maybe.fromCallable(() -> cache.containsKey(key)) .filter(isPresent -> isPresent) .map(__ -> cache.get(key)) .filter(this::notExpired) .map(CacheEntry::cachedObject) .subscribeOn(Schedulers.computation()); } Cache(@NonNull final Function<Value, Key> extractKeyFromModel,
@NonNull final TimestampProvider timestampProvider); Cache(@NonNull final Function<Value, Key> extractKeyFromModel,
@NonNull final TimestampProvider timestampProvider,
final long timeoutMs); private Cache(@NonNull final Function<Value, Key> extractKeyFromModel,
@NonNull final TimestampProvider timestampProvider,
@NonNull final Option<Long> timeoutMs); @Override void putSingular(@NonNull Value value); @Override void putAll(@NonNull List<Value> values); @Override @NonNull Maybe<Value> getSingular(@NonNull final Key key); @Override @NonNull Maybe<List<Value>> getAll(); @Override void clear(); } | @Test public void getSingularCompletesWithNoEmissionsWhenCacheIsEmpty() { cache.getSingular("KEY").test().assertNoValues(); } |
Cache implements MemoryStore<Key, Value> { @Override @NonNull public Maybe<List<Value>> getAll() { return Observable.fromIterable(cache.values()) .filter(this::notExpired) .map(CacheEntry::cachedObject) .toList() .filter(ListUtils::isNotEmpty) .subscribeOn(Schedulers.computation()); } Cache(@NonNull final Function<Value, Key> extractKeyFromModel,
@NonNull final TimestampProvider timestampProvider); Cache(@NonNull final Function<Value, Key> extractKeyFromModel,
@NonNull final TimestampProvider timestampProvider,
final long timeoutMs); private Cache(@NonNull final Function<Value, Key> extractKeyFromModel,
@NonNull final TimestampProvider timestampProvider,
@NonNull final Option<Long> timeoutMs); @Override void putSingular(@NonNull Value value); @Override void putAll(@NonNull List<Value> values); @Override @NonNull Maybe<Value> getSingular(@NonNull final Key key); @Override @NonNull Maybe<List<Value>> getAll(); @Override void clear(); } | @Test public void getAllCompletesWithNoEmissionsWhenCacheIsEmpty() { cache.getAll().test().assertNoValues(); } |
UnwrapOptionTransformer implements ObservableTransformer<Option<T>, T> { @Override public ObservableSource<T> apply(final Observable<Option<T>> upstream) { return upstream.filter(Option::isSome) .map(OptionUnsafe::getUnsafe); } @Override ObservableSource<T> apply(final Observable<Option<T>> upstream); static UnwrapOptionTransformer<T> create(); } | @Test public void transformerFiltersOutNone() { Observable<Option<Object>> source = Observable.just(Option.none()); TestObserver<Object> ts = new TestObserver<>(); transformer.apply(source).subscribe(ts); ts.assertNoValues(); }
@Test public void transformerUnwrapsSome() { Object object = new Object(); Observable<Option<Object>> source = Observable.just(Option.ofObj(object)); TestObserver<Object> ts = new TestObserver<>(); transformer.apply(source).subscribe(ts); ts.assertValue(object); } |
Preconditions { public static <T> T checkNotNull(final T reference) { if (reference == null) { throw new NullPointerException(); } return reference; } private Preconditions(); @NonNull static T get(@Nullable final T reference); static T checkNotNull(final T reference); static T checkNotNull(final T reference, @NonNull final String errorMessage); } | @Test public void checkNotNull_doesNotThrowException_whenNonNull() { Preconditions.checkNotNull(new Object()); }
@Test public void checkNotNull_throwsNullPointerException_whenNull() { thrown.expect(NullPointerException.class); Preconditions.checkNotNull(null); }
@Test public void checkNotNullWithMessage_doesNotThrowException_whenNonNull() { Preconditions.checkNotNull(new Object(), "Unused message"); }
@Test public void checkNotNullWithMessage_throwsNullPointerExceptionWithMessage_whenNull() { final String message = "message"; thrown.expect(NullPointerException.class); thrown.expectMessage(message); Preconditions.checkNotNull(null, message); } |
Preconditions { @NonNull public static <T> T get(@Nullable final T reference) { if (reference == null) { throw new NullPointerException("Assertion for a nonnull object failed."); } return reference; } private Preconditions(); @NonNull static T get(@Nullable final T reference); static T checkNotNull(final T reference); static T checkNotNull(final T reference, @NonNull final String errorMessage); } | @Test public void get_returnsParameter_whenNonNull() { Object obj = new Object(); assertThat(Preconditions.get(obj)).isEqualTo(obj); }
@Test public void get_throwsNullPointerException_whenNull() { thrown.expect(NullPointerException.class); Preconditions.get(null); } |
StringUtils { @SuppressWarnings("unchecked") @NonNull public String applySubstitutionsToString(@NonNull final String string, @NonNull final Pair<String, String>... substitutions) { String primaryString = string; for (final Pair<String, String> substitution : substitutions) { primaryString = primaryString.replace("{{" + substitution.first + "}}", substitution.second); } return primaryString; } @Inject StringUtils(); @SuppressWarnings("unchecked") @NonNull String applySubstitutionsToString(@NonNull final String string, @NonNull final Pair<String, String>... substitutions); } | @Test public void parametersAreReplacedCorrectly() { String param1Name = "firstName"; String param1Value = "Georgy"; String param2Name = "lastName"; String param2Value = "Georgiev"; String string = "He is {{firstName}} {{lastName}}"; String formattedString = stringUtils.applySubstitutionsToString(string, Pair.create(param1Name, param1Value), Pair.create(param2Name, param2Value)); assertThat(formattedString).isEqualTo("He is Georgy Georgiev"); }
@Test public void notFoundParametersAreIgnored() { String param1Name = "wrongParamName"; String param1Value = "Somebody"; String string = "He is {{firstName}}"; String formattedString = stringUtils.applySubstitutionsToString(string, Pair.create(param1Name, param1Value)); assertThat(formattedString).isEqualTo(string); } |
ListUtils { @NonNull public static <T> List<T> union(@NonNull final List<T> list1, @NonNull final List<T> list2) { return new ArrayList<T>() {{ addAll(list1); addAll(list2); }}; } @NonNull static List<T> union(@NonNull final List<T> list1, @NonNull final List<T> list2); static boolean isNotEmpty(@NonNull final List<T> list); } | @Test public void unionResultsInSecondListAppendedToFirstListRespectingTheOrder() { final List<Object> list1 = new ArrayList<Object>() {{ add(mockObject1); add(mockObject2); add(mockObject3); add(mockObject4); }}; final List<Object> list2 = new ArrayList<Object>() {{ add(mockObject5); add(mockObject6); }}; final List<Object> result = ListUtils.union(list1, list2); Assertions.assertThat(result).containsExactly(mockObject1, mockObject2, mockObject3, mockObject4, mockObject5, mockObject6); }
@Test public void unionDoesNotRemoveDuplicates() { final List<Object> list1 = new ArrayList<Object>() {{ add(mockObject5); add(mockObject6); }}; final List<Object> list2 = new ArrayList<Object>() {{ add(mockObject5); add(mockObject6); }}; final List<Object> result = ListUtils.union(list1, list2); Assertions.assertThat(result).containsExactly(mockObject5, mockObject6, mockObject5, mockObject6); } |
ODFValidatorService implements Validate { public ServiceDescription describe() { ServiceDescription.Builder mds = new ServiceDescription.Builder(NAME, Validate.class.getCanonicalName()); mds.description("A validator for ODF file, based on the ODF Toolkit project ODF Validator."); mds.author("Andrew Jackson <[email protected]>"); try { mds.furtherInfo(new URI("http: } catch (URISyntaxException e) { } mds.classname(this.getClass().getCanonicalName()); return mds.build(); } ServiceDescription describe(); ValidateResult validate(DigitalObject dob, URI format, List<Parameter> parameters); static final String NAME; } | @Test public void testDescribe() { ServiceDescription desc = ids.describe(); System.out.println("Recieved service description: " + desc.toXmlFormatted() ); assertTrue("The ServiceDescription should not be NULL.", desc != null ); } |
ODFValidatorService implements Validate { public ValidateResult validate(DigitalObject dob, URI format, List<Parameter> parameters) { return ODFValidatorWrapper.validateODF(dob,format); } ServiceDescription describe(); ValidateResult validate(DigitalObject dob, URI format, List<Parameter> parameters); static final String NAME; } | @Test public void testValidate() throws MalformedURLException, URISyntaxException { testValidateThis(new DigitalObject.Builder( Content.byValue(new File("tests/test-files/documents/test_odt/v11/test_file_v11.odt") ) ).build() , new URI("planets:fmt/ext/odf"), true); testValidateThis(new DigitalObject.Builder( Content.byReference(new File("PC/odf-toolkit/src/test/resources/HelloWorld.doc") ) ).build() , new URI("planets:fmt/ext/odf"), true); testValidateThis(new DigitalObject.Builder( Content.byReference(new File("PC/odf-toolkit/src/test/resources/HelloWorld.sxw") ) ).build() , new URI("planets:fmt/ext/odf"), false); testValidateThis(null, new URI("http: testValidateThis(new DigitalObject.Builder( Content.byReference(new URL("http: true); } |
ToolSpec { String toXMlFormatted() throws JAXBException, UnsupportedEncodingException { Marshaller m = jc.createMarshaller(); m.setProperty( Marshaller.JAXB_FORMATTED_OUTPUT, Boolean.TRUE ); ByteArrayOutputStream bos = new ByteArrayOutputStream(); m.marshal(this, bos); return bos.toString("UTF-8"); } String getTool(); void setTool(String tool); Version getVersion(); void setVersion(Version version); Install getInstall(); void setInstall(Install install); List<Var> getEnv(); void setEnv(List<Var> env); List<Var> getVar(); void setVar(List<Var> var); List<Convert> getConvert(); void setConvert(List<Convert> convert); List<Validate> getValidate(); void setValidate(List<Validate> validate); static ToolSpec fromInputStream( InputStream input ); } | @Test public void testToXMlFormatted() { fail("Not yet implemented"); } |
ToolSpec { public static ToolSpec fromInputStream( InputStream input ) throws FileNotFoundException, JAXBException { Unmarshaller u = jc.createUnmarshaller(); return (ToolSpec) u.unmarshal(new StreamSource(input)); } String getTool(); void setTool(String tool); Version getVersion(); void setVersion(Version version); Install getInstall(); void setInstall(Install install); List<Var> getEnv(); void setEnv(List<Var> env); List<Var> getVar(); void setVar(List<Var> var); List<Convert> getConvert(); void setConvert(List<Convert> convert); List<Validate> getValidate(); void setValidate(List<Validate> validate); static ToolSpec fromInputStream( InputStream input ); } | @Test public void testFromInputstream() throws FileNotFoundException, JAXBException { ToolSpec kakadu = ToolSpec.fromInputStream( ToolSpec.class.getResourceAsStream("/toolspecs/kakadu.ptspec")); System.out.println("Tools "+kakadu.getTool()); ToolSpec jhove2 = ToolSpec.fromInputStream( ToolSpec.class.getResourceAsStream("/toolspecs/jhove2.ptspec")); System.out.println("Tools "+jhove2.getTool()); ToolSpec isobuster = ToolSpec.fromInputStream( ToolSpec.class.getResourceAsStream("/toolspecs/isobuster.ptspec")); System.out.println("Tools "+isobuster.getTool()); } |
PlanetsCommand { public static void main(String[] args) { java.util.logging.Logger.getAnonymousLogger().setLevel(java.util.logging.Level.FINEST); java.util.logging.Logger.getLogger( com.sun.xml.ws.util.Constants.LoggingDomain).setLevel(java.util.logging.Level.FINEST); URL wsdl; try { wsdl = new URL( args[0] ); } catch (MalformedURLException e) { e.printStackTrace(); return; } PlanetsServiceExplorer pse = new PlanetsServiceExplorer( wsdl ); System.out.println(".describe(): "+pse.getServiceDescription()); Service service = Service.create(wsdl, pse.getQName()); PlanetsService ps = (PlanetsService) service.getPort(pse.getServiceClass()); SOAPBinding binding = (SOAPBinding)((BindingProvider)ps).getBinding(); System.out.println("Logging MTOM="+binding.isMTOMEnabled()); ((BindingProvider)ps).getRequestContext().put( JAXWSProperties.MTOM_THRESHOLOD_VALUE, 8192); ((BindingProvider)ps).getRequestContext().put( JAXWSProperties.HTTP_CLIENT_STREAMING_CHUNK_SIZE, 8192); System.out.println("Logging MTOM="+binding.isMTOMEnabled()); binding.setMTOMEnabled(true); System.out.println("Logging MTOM="+binding.isMTOMEnabled()); if( pse.getQName().equals( Migrate.QNAME ) ) { System.out.println("Is a Migrate service. "); Migrate s = MigrateWrapper.createWrapper(wsdl); DigitalObject dobIn = new DigitalObject.Builder(Content.byReference( new File(args[1]))).build(); MigrateResult result = s.migrate(dobIn, URI.create(args[2]), URI.create(args[3]), null); System.out.println("ServiceReport: "+result.getReport()); DigitalObjectUtils.toFile( result.getDigitalObject(), new File("output" ) ); } else if( pse.getQName().equals( Identify.QNAME ) ) { System.out.println("Is an Identify service. "); Identify s = new IdentifyWrapper(wsdl); DigitalObject dobIn = new DigitalObject.Builder(Content.byReference( new File(args[1]))).build(); IdentifyResult result = s.identify(dobIn, null); System.out.println("ServiceReport: "+result.getReport()); } } static void main(String[] args); } | @Test public void testMain() { String[] testbedTest = { "http: "tests/test-files/images/bitmap/test_png/png_small/2274192346_4a0a03c5d6.png", "planets:fmt/ext/png", "planets:fmt/ext/jpg"}; PlanetsCommand.main(testbedTest); System.out.println("---- TEST -------------------------------------------------------------------------------------"); String[] dialogikaTest = { "http: "tests/test-files/documents/test_word_6.0/SETUP.DOC", "planets:fmt/ext/doc", "planets:fmt/ext/docx"}; PlanetsCommand.main(dialogikaTest); } |
PivotalTrackerUtil { public String pivotalTrackerAdd( String url, String projectId, String token, String name, String storyType, String description) { PivotalTrackerAPI pivotalTrackerTarget = webAPIResolver.getWebAPI(url, PivotalTrackerAPI.class); PivotalTrackerResponse bugData = pivotalTrackerTarget.addBug( token, projectId, MapBuilder.<String, String>newHashMap() .with("name", name) .with("story_type", storyType) .with("description", description) .build()); log.info("Bug Report url = " + bugData.url); return bugData.url; } PivotalTrackerUtil(WebAPIResolver resolver); String pivotalTrackerAdd(
String url,
String projectId,
String token,
String name,
String storyType,
String description); } | @Test public void testPivotalTracker() { PivotalTrackerUtil pivotalTrackerUtil = new PivotalTrackerUtil(new MyWebAPIResolver()); final String pivotalTrackerData = pivotalTrackerUtil.pivotalTrackerAdd( "https: "2016043", "ff33d6e6e138d66834a52be6bf19f6f1", "Best Awesome Bug", "bug", "The most awesome ever test of adding bug"); Assert.assertEquals("https: } |
HashCodeUtil { public static int hash(int seed, boolean bool) { return firstTerm(seed) + (bool ? 1 : 0); } static int hash(int seed, boolean bool); static int hash(int seed, char c); static int hash(int seed, int x); static int hash(int seed, long x); static int hash(int seed, float x); static int hash(int seed, double x); static int hash(int seed, Object object); static final int SEED; } | @Test public void testHash_int_char() throws Exception { int hashResult = HashCodeUtil.hash(HashCodeUtil.SEED, 'a'); assert hashResult == HASH_CODE_A; assert hashResult != HASH_CODE_HYPHEN; hashResult = HashCodeUtil.hash(HashCodeUtil.SEED, '-'); assert hashResult != HASH_CODE_A; assert hashResult == HASH_CODE_HYPHEN; hashResult = HashCodeUtil.hash(4444, 'a'); assert hashResult != HASH_CODE_A; assert hashResult != HASH_CODE_HYPHEN; }
@Test public void testHash_int_int() throws Exception { int hashResult = HashCodeUtil.hash(HashCodeUtil.SEED, Integer.MIN_VALUE); assert hashResult == HASH_CODE_INT_MIN; assert hashResult != HASH_CODE_INT_MAX; hashResult = HashCodeUtil.hash(HashCodeUtil.SEED, Integer.MAX_VALUE); assert hashResult != HASH_CODE_INT_MIN; assert hashResult == HASH_CODE_INT_MAX; hashResult = HashCodeUtil.hash(4444, Integer.MIN_VALUE); assert hashResult != HASH_CODE_INT_MIN; assert hashResult != HASH_CODE_INT_MAX; }
@Test public void testHash_int_long() throws Exception { int hashResult = HashCodeUtil.hash(HashCodeUtil.SEED, Long.MIN_VALUE); assert hashResult == HASH_CODE_LONG_MIN; assert hashResult == HASH_CODE_LONG_MAX; hashResult = HashCodeUtil.hash(HashCodeUtil.SEED, Long.MAX_VALUE); assert hashResult == HASH_CODE_LONG_MIN; assert hashResult == HASH_CODE_LONG_MAX; hashResult = HashCodeUtil.hash(4444, Long.MIN_VALUE); assert hashResult != HASH_CODE_LONG_MIN; assert hashResult != HASH_CODE_LONG_MAX; }
@Test public void testHash_int_double() throws Exception { int hashResult = HashCodeUtil.hash(HashCodeUtil.SEED, Double.MIN_VALUE); assert hashResult == HASH_CODE_DBL_MIN; assert hashResult != HASH_CODE_DBL_MAX; hashResult = HashCodeUtil.hash(HashCodeUtil.SEED, Double.MAX_VALUE); assert hashResult != HASH_CODE_DBL_MIN; assert hashResult == HASH_CODE_DBL_MAX; hashResult = HashCodeUtil.hash(4444, Double.MIN_VALUE); assert hashResult != HASH_CODE_DBL_MIN; assert hashResult != HASH_CODE_DBL_MAX; }
@Test public void testHash_int_float() throws Exception { int hashResult = HashCodeUtil.hash(HashCodeUtil.SEED, Float.MIN_VALUE); assert hashResult == HASH_CODE_FLOAT_MIN; assert hashResult != HASH_CODE_FLOAT_MAX; hashResult = HashCodeUtil.hash(HashCodeUtil.SEED, Float.MAX_VALUE); assert hashResult != HASH_CODE_FLOAT_MIN; assert hashResult == HASH_CODE_FLOAT_MAX; hashResult = HashCodeUtil.hash(4444, Float.MIN_VALUE); assert hashResult != HASH_CODE_FLOAT_MIN; assert hashResult != HASH_CODE_FLOAT_MAX; }
@Test public void testHash_int_boolean() throws Exception { int hashResult = HashCodeUtil.hash(HashCodeUtil.SEED, true); assert hashResult == HASH_CODE_TRUE; assert hashResult != HASH_CODE_FALSE; hashResult = HashCodeUtil.hash(HashCodeUtil.SEED, false); assert hashResult != HASH_CODE_TRUE; assert hashResult == HASH_CODE_FALSE; hashResult = HashCodeUtil.hash(4444, true); assert hashResult != HASH_CODE_TRUE; assert hashResult != HASH_CODE_FALSE; } |
Pair implements Serializable { public K getObject1() { return key; } Pair(K key, V value); K getKey(); void setKey(K key); V getValue(); void setValue(V value); K getObject1(); V getObject2(); @Override int hashCode(); @SuppressWarnings("rawtypes") @Override boolean equals(Object obj); @Override String toString(); } | @Test public void testObject1() throws Exception { final Pair<String, String> pair1 = new Pair("A", "D"); assertTrue(pair1.getObject1() instanceof String); assertTrue("A".equalsIgnoreCase(pair1.getObject1())); } |
Pair implements Serializable { public V getObject2() { return value; } Pair(K key, V value); K getKey(); void setKey(K key); V getValue(); void setValue(V value); K getObject1(); V getObject2(); @Override int hashCode(); @SuppressWarnings("rawtypes") @Override boolean equals(Object obj); @Override String toString(); } | @Test public void testObject2() throws Exception { final Pair<String, String> pair1 = new Pair("A", "D"); assertTrue(pair1.getObject2() instanceof String); assertTrue("D".equalsIgnoreCase(pair1.getObject2())); } |
Pair implements Serializable { @Override public String toString() { StringBuilder builder = new StringBuilder(); builder.append(key); builder.append(':'); builder.append(value); return builder.toString(); } Pair(K key, V value); K getKey(); void setKey(K key); V getValue(); void setValue(V value); K getObject1(); V getObject2(); @Override int hashCode(); @SuppressWarnings("rawtypes") @Override boolean equals(Object obj); @Override String toString(); } | @Test public void testToString() throws Exception { final Pair<String, String> pair = new Pair("Key", "Value"); assertEquals("Key:Value", pair.toString()); } |
TimeEvaluator { public int evaluate(Date reference, boolean usePastDow) { Calendar referenceCal = Calendar.getInstance(); referenceCal.setTimeZone(reportRequestorTimeZone); referenceCal.setTime(reference); Integer year = time.getYear(); if (year != null) { if (year >= -499 && year <= -1) { referenceCal.add(Calendar.YEAR, year); log.debug("year time in the past " + referenceCal.getTime() + ". year value was " + year); } else if (year > 1000 && year < 1900) { referenceCal.add(Calendar.YEAR, (year - 1000)); log.debug("year time in the future " + referenceCal.getTime() + ". year value was " + year); } else if (year >= 1900) { referenceCal.set(Calendar.YEAR, year); } else { log.warn("Invalid year value " + year); } } Integer month = time.getMonth(); if (month != null) { if (month >= 0) { if (month > FUTURE_PLACEHOLDER) { referenceCal.add(Calendar.MONTH, (month - FUTURE_PLACEHOLDER)); log.debug("month time in the future " + referenceCal.getTime() + ". month value was " + month); } else { referenceCal.set(Calendar.MONTH, month - 1); } } else { referenceCal.add(Calendar.MONTH, month); log.debug("month time in the past " + referenceCal.getTime() + ". month value was " + month); } } Integer dayofmonth = time.getDayOfMonth(); if (dayofmonth != null) { log.debug("dayofmonth"); if (dayofmonth >= 0) { if (dayofmonth > FUTURE_PLACEHOLDER) { referenceCal.add(Calendar.DAY_OF_MONTH, (dayofmonth - FUTURE_PLACEHOLDER)); log.debug("dayofmonth time in the future " + referenceCal.getTime() + ". dayofmonth value was " + dayofmonth); } else { if (dayofmonth == 31) { int actualDayofmonth = referenceCal.getActualMaximum(Calendar.DAY_OF_MONTH); referenceCal.set(Calendar.DAY_OF_MONTH, actualDayofmonth); log.debug("dayofmonth time " + referenceCal.getTime() + ". dayofmonth value was " + dayofmonth); } else { referenceCal.set(Calendar.DAY_OF_MONTH, dayofmonth); } } } else { referenceCal.add(Calendar.DAY_OF_MONTH, dayofmonth); log.debug("dayofmonth time in the past " + referenceCal.getTime()); } } Integer dayofweek = time.getDayOfWeek(); if (dayofweek != null) { if (dayofweek >= 0) { if (dayofweek > FUTURE_PLACEHOLDER) { int dowNow = referenceCal.get(Calendar.DAY_OF_WEEK); int correctionFactor = dowNow - (dayofweek - FUTURE_PLACEHOLDER); if (correctionFactor == 0) { referenceCal.add(Calendar.DATE, 7); } else if (correctionFactor > 0) { referenceCal.add(Calendar.DATE, 1 * (7 - correctionFactor)); } else { referenceCal.add(Calendar.DATE, -1 * correctionFactor); } log.debug("dayofweek time in the future " + referenceCal.getTime() + ". dayofweek value was " + dayofweek); } else { int refDow = referenceCal.get(Calendar.DAY_OF_WEEK); if (usePastDow) { if (dayofweek > refDow) { referenceCal.add(Calendar.WEEK_OF_YEAR, -1); referenceCal.getTime(); } } else { if (dayofweek < refDow) { referenceCal.add(Calendar.WEEK_OF_YEAR, 1); referenceCal.getTime(); } } referenceCal.set(Calendar.DAY_OF_WEEK, dayofweek); } } else { int dowNow = referenceCal.get(Calendar.DAY_OF_WEEK); int correctionFactor = dowNow + dayofweek; if (correctionFactor > 0) { referenceCal.add(Calendar.DATE, -1 * correctionFactor); } else { referenceCal.add(Calendar.DATE, -1 * (7 + correctionFactor)); } log.debug( "dayofweek time in the past " + referenceCal.getTime() + ". dayofweek value was " + dayofweek); } } Integer hour = time.getHour(); if (hour != null) { if (hour >= 0) { if (hour > FUTURE_PLACEHOLDER) { referenceCal.add(Calendar.HOUR_OF_DAY, (hour - FUTURE_PLACEHOLDER)); log.debug("hour time in the future " + referenceCal.getTime() + ". hour value was " + hour); } else { referenceCal.set(Calendar.HOUR_OF_DAY, hour); } } else { referenceCal.add(Calendar.HOUR_OF_DAY, hour); log.debug("hour time in the past " + referenceCal.getTime() + ". hour value was " + hour); } } Integer minute = time.getMinute(); if (minute != null) { if (minute >= 0) { if (minute > FUTURE_PLACEHOLDER) { referenceCal.add(Calendar.MINUTE, (minute - FUTURE_PLACEHOLDER)); log.debug("minute time in the future " + referenceCal.getTime() + ". minute value was " + minute); } else { referenceCal.set(Calendar.MINUTE, minute); } } else { referenceCal.add(Calendar.MINUTE, minute); log.debug("minute time in the past " + referenceCal.getTime() + ". minute value was " + minute); } } return (int) (referenceCal.getTimeInMillis() / 1000); } TimeEvaluator(IVariableTime time, TimeZone reportRequestorTimeZone); int evaluate(Date reference, boolean usePastDow); long getTime(Date stime, long baseTime); static final int FUTURE_PLACEHOLDER; } | @Test public void testEvaluate() throws Exception { final VariableTime vt = new VariableTime(30, 4, 3, 4, 12, 1972); TimeEvaluator timeEvaluator = new TimeEvaluator(vt, TimeZone.getTimeZone("EST")); Date now = new Date(); int result1 = timeEvaluator.evaluate(now, true); int result2 = timeEvaluator.evaluate(now, false); assertTrue(result1 > 0); assertTrue(result2 > 0); } |
TimeEvaluator { public long getTime(Date stime, long baseTime) { if (log.isDebugEnabled()) { log.debug("stime=" + stime); log.debug("reportRequestorTimeZone=" + reportRequestorTimeZone); log.debug("baseTime=" + baseTime); } Calendar newTime = Calendar.getInstance(); newTime.setTimeZone(reportRequestorTimeZone); newTime.setTimeInMillis(baseTime); if (stime == null) { newTime.set(Calendar.SECOND, 0); newTime.set(Calendar.MILLISECOND, 0); } else { newTime.add(Calendar.MINUTE, -1); newTime.set(Calendar.SECOND, 59); newTime.set(Calendar.MILLISECOND, 999); } Integer year = time.getYear(); if (year != null) { if (year >= -499 && year <= -1) { newTime.add(Calendar.YEAR, year); log.debug("year time in the past " + newTime.getTime() + ". year value was " + year); } else if (year > 1000 && year < 1900) { newTime.add(Calendar.YEAR, (year - 1000)); log.debug("year time in the future " + newTime.getTime() + ". year value was " + year); } else if (year >= 1900) { newTime.set(Calendar.YEAR, year); } else { log.warn("Invalid year value " + year); } } Integer month = time.getMonth(); if (month != null) { if (month >= 0) { if (month > FUTURE_PLACEHOLDER) { newTime.add(Calendar.MONTH, (month - FUTURE_PLACEHOLDER)); log.debug("month time in the future " + newTime.getTime() + ". month value was " + month); } else { newTime.set(Calendar.MONTH, month - 1); } } else { newTime.add(Calendar.MONTH, month); log.debug("month time in the past " + newTime.getTime() + ". month value was " + month); } } Integer dayofmonth = time.getDayOfMonth(); if (dayofmonth != null) { log.debug("dayofmonth"); if (dayofmonth >= 0) { if (dayofmonth > FUTURE_PLACEHOLDER) { newTime.add(Calendar.DAY_OF_MONTH, (dayofmonth - FUTURE_PLACEHOLDER)); log.debug("dayofmonth time in the future " + newTime.getTime() + ". dayofmonth value was " + dayofmonth); } else { if (dayofmonth == 31) { int actualDayofmonth = newTime.getActualMaximum(Calendar.DAY_OF_MONTH); newTime.set(Calendar.DAY_OF_MONTH, actualDayofmonth); log.debug("dayofmonth time " + newTime.getTime() + ". dayofmonth value was " + dayofmonth); } else { newTime.set(Calendar.DAY_OF_MONTH, dayofmonth); } } } else { newTime.add(Calendar.DAY_OF_MONTH, dayofmonth); log.debug("dayofmonth time in the past " + newTime.getTime()); } } Integer dayofweek = time.getDayOfWeek(); if (dayofweek != null) { if (dayofweek >= 0) { if (dayofweek > FUTURE_PLACEHOLDER) { int dowNow = newTime.get(Calendar.DAY_OF_WEEK); int correctionFactor = dowNow - (dayofweek - FUTURE_PLACEHOLDER); if (correctionFactor == 0) { newTime.add(Calendar.DATE, 7); } else if (correctionFactor > 0) { newTime.add(Calendar.DATE, 1 * (7 - correctionFactor)); } else { newTime.add(Calendar.DATE, -1 * correctionFactor); } log.debug( "dayofweek time in the future " + newTime.getTime() + ". dayofweek value was " + dayofweek); } else { int today = newTime.get(Calendar.DAY_OF_WEEK); int thisweek = newTime.get(Calendar.WEEK_OF_YEAR); int startday = -1; int startweek = -1; if (stime != null) { Calendar startTime = Calendar.getInstance(); startTime.setTimeZone(reportRequestorTimeZone); startTime.setTime(stime); startday = startTime.get(Calendar.DAY_OF_WEEK); startweek = startTime.get(Calendar.WEEK_OF_YEAR); } if ((dayofweek > today) && (startday == -1)) { newTime.add(Calendar.WEEK_OF_YEAR, -1); newTime.getTime(); } if ((dayofweek < startday) && (startday != -1)) { if (thisweek == startweek) { newTime.add(Calendar.WEEK_OF_YEAR, 1); } newTime.getTime(); } newTime.set(Calendar.DAY_OF_WEEK, dayofweek); } } else { int dowNow = newTime.get(Calendar.DAY_OF_WEEK); int correctionFactor = dowNow + dayofweek; if (correctionFactor > 0) { newTime.add(Calendar.DATE, -1 * correctionFactor); } else { newTime.add(Calendar.DATE, -1 * (7 + correctionFactor)); } log.debug("dayofweek time in the past " + newTime.getTime() + ". dayofweek value was " + dayofweek); } } Integer hour = time.getHour(); if (hour != null) { if (hour >= 0) { if (hour > FUTURE_PLACEHOLDER) { newTime.add(Calendar.HOUR_OF_DAY, (hour - FUTURE_PLACEHOLDER)); log.debug("hour time in the future " + newTime.getTime() + ". hour value was " + hour); } else { newTime.set(Calendar.HOUR_OF_DAY, hour); } } else { newTime.add(Calendar.HOUR_OF_DAY, hour); log.debug("hour time in the past " + newTime.getTime() + ". hour value was " + hour); } } Integer minute = time.getMinute(); if (minute != null) { if (minute >= 0) { if (minute > FUTURE_PLACEHOLDER) { newTime.add(Calendar.MINUTE, (minute - FUTURE_PLACEHOLDER)); log.debug("minute time in the future " + newTime.getTime() + ". minute value was " + minute); } else { newTime.set(Calendar.MINUTE, minute); } } else { newTime.add(Calendar.MINUTE, minute); log.debug("minute time in the past " + newTime.getTime() + ". minute value was " + minute); } } long millis = newTime.getTimeInMillis(); int result = ((int) (millis / 1000)); return (result); } TimeEvaluator(IVariableTime time, TimeZone reportRequestorTimeZone); int evaluate(Date reference, boolean usePastDow); long getTime(Date stime, long baseTime); static final int FUTURE_PLACEHOLDER; } | @Test public void testGetTime() throws Exception { final VariableTime vt = new VariableTime(30, 4, 3, 4, 12, 1972); TimeEvaluator timeEvaluator = new TimeEvaluator(vt, TimeZone.getTimeZone("EST")); Date now = new Date(); long result = timeEvaluator.getTime(now, 10000); System.out.println("result = " + result); assertTrue(result != 0); } |
ManagedMessageListenerImpl implements ManagedMessageListener { @Override public void onErrorMessage(Message message, Context context) { logger.error("Error message received {}", message.getMessageHeader(ERROR_HEADER)); handleMessage(message, context, true); } ManagedMessageListenerImpl(
Context context,
MessageListener messageListener,
ManagedInputQueue managedQueue,
int threadOrdinal); @Override void onMessage(Message message, Context context); @Override void onErrorMessage(Message message, Context context); QueueExecutionState getQueueExecutionState(); } | @Test public void testHandleErrorMessage_CurrentMicroserviceIsInTheMiddleOfRoute() { Message message = mock(Message.class); when(message.getContextValue(ContextImpl.MS_API_ROUTING_PLAN_HEADER)).thenReturn( "microservice1,microservice2,microservice3"); when(message.getUnderlyingMessageObject()).thenReturn(Mockito.mock(Object.class)); HashMap<String, String> messageHeaders = new HashMap(); messageHeaders.put(MessagingConstants.FAILED_HEADER, "true"); messageHeaders.put( MessagingConstants.ERROR_HEADER, "[{\"microservice_uri\":\"microservice-uri\",\"timestamp\":1456417079688,\"error_code\":503,\"error_message\":unexpected error}]"); when(message.getMessageHeaders()).thenReturn(messageHeaders); HashMap<String, String> messageContext = new HashMap(); messageContext.put(ContextImpl.MS_API_ROUTING_PLAN_HEADER, "microservice1,microservice2,microservice3"); when(message.getMessageContext()).thenReturn(messageContext); when(context.getMicroServiceBaseURI()).thenReturn("microservice2"); ResourceManager resourceManager = mock(ResourceManager.class); ManagedDependency managedResource = mock(ManagedDependency.class); MessageSender messageSender = Mockito.mock(MessageSender.class); when(managedResource.getMessageSender()).thenReturn(messageSender); when(resourceManager.getManagedResourceByName(eq("microservice3"))).thenReturn(managedResource); when(context.getDependencyManager()).thenReturn(resourceManager); managedMessageListener.onErrorMessage(message, context); verify(messageListener, Mockito.never()).onErrorMessage(eq(message), eq(context)); verify(messageSender).sendMessage(any(Class.class), anyObject(), eq(messageHeaders), eq(messageContext)); }
@Test public void testHandleErrorMessage_CurrentMicroserviceIsTheLastOneInRoute() { Message message = mock(Message.class); when(message.getContextValue(ContextImpl.MS_API_ROUTING_PLAN_HEADER)).thenReturn( "microservice1,microservice2,microservice3"); when(context.getMicroServiceBaseURI()).thenReturn("microservice3"); managedMessageListener.onErrorMessage(message, context); verify(messageListener).onErrorMessage(eq(message), eq(context)); }
@Test public void testHandleErrorMessage_CurrentMicroserviceIsTheFirstOneInRoute() { Message message = mock(Message.class); when(message.getContextValue(ContextImpl.MS_API_ROUTING_PLAN_HEADER)).thenReturn( "microservice1,microservice2,microservice3"); when(message.getUnderlyingMessageObject()).thenReturn(Mockito.mock(Object.class)); HashMap<String, String> messageHeaders = new HashMap(); messageHeaders.put(MessagingConstants.FAILED_HEADER, "true"); messageHeaders.put( MessagingConstants.ERROR_HEADER, "[{\"microservice_uri\":\"microservice-uri\",\"timestamp\":1456417079688,\"error_code\":500,\"error_message\":null}]"); when(message.getMessageHeaders()).thenReturn(messageHeaders); HashMap<String, String> messageContext = new HashMap(); messageContext.put(ContextImpl.MS_API_ROUTING_PLAN_HEADER, "microservice1,microservice2,microservice3"); when(message.getMessageContext()).thenReturn(messageContext); when(context.getMicroServiceBaseURI()).thenReturn("microservice1"); ResourceManager resourceManager = mock(ResourceManager.class); ManagedDependency managedResource = mock(ManagedDependency.class); MessageSender messageSender = Mockito.mock(MessageSender.class); when(managedResource.getMessageSender()).thenReturn(messageSender); when(resourceManager.getManagedResourceByName(eq("microservice3"))).thenReturn(managedResource); when(context.getDependencyManager()).thenReturn(resourceManager); managedMessageListener.onErrorMessage(message, context); verify(messageListener, Mockito.never()).onErrorMessage(eq(message), eq(context)); verify(messageSender).sendMessage(any(Class.class), anyObject(), eq(messageHeaders), eq(messageContext)); } |
VariableTime implements IVariableTime { public VariableTime( Integer minute, Integer hour, Integer dayOfWeek, Integer dayOfMonth, Integer month, Integer year) { this.minute = minute; this.hour = hour; this.dayOfWeek = dayOfWeek; this.dayOfMonth = dayOfMonth; this.month = month; this.year = year; } VariableTime(
Integer minute,
Integer hour,
Integer dayOfWeek,
Integer dayOfMonth,
Integer month,
Integer year); Integer getDayOfMonth(); Integer getDayOfWeek(); Integer getYear(); Integer getMonth(); Integer getHour(); Integer getMinute(); } | @Test public void testVariableTime() { final VariableTime vt = new VariableTime(20, 4, 3, 4, 12, 1972); assertTrue(vt.getMinute() == 20); assertTrue(vt.getHour() == 4); assertTrue(vt.getDayOfWeek() == 3); assertTrue(vt.getDayOfMonth() == 4); assertTrue(vt.getMonth() == 12); assertTrue(vt.getYear() == 1972); } |
CronSchedules { public static String generateDailySchedule() { return random.nextInt(60) + " " + random.nextInt(60) + " " + random.nextInt(24) + " * * ? *"; } private CronSchedules(); static String generateDailySchedule(); static String generateDailySchedule(int startHour, int endHour); } | @Test public void testGenerateDefaultDailySchedule() throws Exception { String cron = CronSchedules.generateDailySchedule(); testCommon(cron); String otherCron = CronSchedules.generateDailySchedule(); assertNotEquals(otherCron, cron); }
@Test public void testGenerateDailyScheduleInBounds() throws Exception { int startHour = 10; int endHour = 12; List<Integer> expectedHours = Arrays.asList(10, 11); String cron = CronSchedules.generateDailySchedule(startHour, endHour); testCommon(cron); testBounds(cron, expectedHours); String otherCron = CronSchedules.generateDailySchedule(); assertNotEquals(otherCron, cron); }
@Test public void testGenerateDailyScheduleInDifferentDaysBounds() throws Exception { int startHour = 22; int endHour = 5; List<Integer> expectedHours = Arrays.asList(22, 23, 0, 1, 2, 3, 4); String cron = CronSchedules.generateDailySchedule(startHour, endHour); testCommon(cron); testBounds(cron, expectedHours); String otherCron = CronSchedules.generateDailySchedule(); assertNotEquals(otherCron, cron); }
@Test(expected = IllegalArgumentException.class) public void testStartHourEqualsEndHour() throws Exception { CronSchedules.generateDailySchedule(5, 5); }
@Test(expected = IllegalArgumentException.class) public void testIncorrectStartHour() throws Exception { CronSchedules.generateDailySchedule(25, 3); }
@Test(expected = IllegalArgumentException.class) public void testIncorrectEndHour() throws Exception { CronSchedules.generateDailySchedule(8, -1); } |
PrettyDuration { public static String prettyDuration(long milliseconds) { long minutes = TimeUnit.MILLISECONDS.toMinutes(milliseconds); milliseconds -= TimeUnit.MINUTES.toMillis(minutes); long seconds = TimeUnit.MILLISECONDS.toSeconds(milliseconds); milliseconds -= TimeUnit.SECONDS.toMillis(seconds); StringBuilder sb = new StringBuilder(); sb.append(minutes); sb.append("m "); sb.append(seconds); sb.append("s "); sb.append(milliseconds); sb.append("ms"); return (sb.toString()); } static String prettyDuration(long milliseconds); } | @Test public void testPrettyDuration() throws Exception { assertEquals("0m 1s 0ms", PrettyDuration.prettyDuration(1000)); } |
MurmurHash { public static int hash32(final byte[] data, int length, int seed) { final int m = 0x5bd1e995; final int r = 24; int h = seed ^ length; int length4 = length / 4; for (int i = 0; i < length4; i++) { final int i4 = i * 4; int k = (data[i4 + 0] & 0xff) + ((data[i4 + 1] & 0xff) << 8) + ((data[i4 + 2] & 0xff) << 16) + ((data[i4 + 3] & 0xff) << 24); k *= m; k ^= k >>> r; k *= m; h *= m; h ^= k; } switch (length % 4) { case 3: h ^= (data[(length & ~3) + 2] & 0xff) << 16; case 2: h ^= (data[(length & ~3) + 1] & 0xff) << 8; case 1: h ^= (data[length & ~3] & 0xff); h *= m; default: } h ^= h >>> 13; h *= m; h ^= h >>> 15; return h; } private MurmurHash(); static int hash32(final byte[] data, int length, int seed); static int hash32(final byte[] data, int length); static int hash32(final String text); static int hash32(final String text, int from, int length); static long hash64(final byte[] data, int length, int seed); static long hash64(final byte[] data, int length); static long hash64(final String text); static long hash64(final String text, int from, int length); static long hash64(String first, String... rest); } | @Test public void testHash32ByteArrayIntInt() { for (int i = 0; i < input.length; i++) { int hash = MurmurHash.hash32(input[i], input[i].length, 0x71b4954d); if (hash != results32_seed[i]) { fail(String.format( "Unexpected hash32 result for example %d: 0x%08x instead of 0x%08x", i, hash, results32_seed[i])); } } }
@Test public void testHash32ByteArrayInt() { for (int i = 0; i < input.length; i++) { int hash = MurmurHash.hash32(input[i], input[i].length); if (hash != results32_standard[i]) { fail(String.format( "Unexpected hash32 result for example %d: 0x%08x instead of 0x%08x", i, hash, results32_standard[i])); } } }
@Test public void testHash32String() { int hash = MurmurHash.hash32(text); assertTrue(hash == 0xb3bf597e); }
@Test public void testHash32StringIntInt() { int hash = MurmurHash.hash32(text, 2, text.length() - 4); assertTrue(hash == 0x4d666d90); } |
MessageSenderImpl implements MessageSender { @Override public void streamMessage(MessageWriter messageWriter, Map<String, String> messageHeaders) { streamMessage(messageWriter, messageHeaders, null, null, null); } MessageSenderImpl(
RuntimeMessageSender runtimeMessageSender,
SerializationManager serializationManager,
ResourceProvider resourceProvider,
Context context); @Override void streamMessage(MessageWriter messageWriter, Map<String, String> messageHeaders); @Override void streamMessage(MessageWriter messageWriter, Map<String, String> messageHeaders, String messageGroup); @Override void streamMessage(
MessageWriter messageWriter,
Map<String, String> messageHeaders,
Map<String, String> messageContext); @Override void streamMessage(
MessageWriter messageWriter,
Map<String, String> messageHeaders,
Map<String, String> messageContext,
String messageGroup); @Override void streamMessage(
MessageWriter messageWriter,
Map<String, String> messageHeaders,
Map<String, String> messageContext,
MessageRoutingPlan messageRoutingPlan); @Override void streamMessage(
MessageWriter messageWriter,
Map<String, String> messageHeaders,
Map<String, String> messageContext,
MessageRoutingPlan messageRoutingPlan,
String messageGroup); @Override void sendMessage(Class<T> format, T objectForSerialization, Map<String, String> messageHeaders); @Override void sendMessage(
Class<T> format,
T objectForSerialization,
Map<String, String> messageHeaders,
String messageGroup); @Override void sendMessage(
Class<T> format,
T objectForSerialization,
Map<String, String> messageHeaders,
Map<String, String> messageContext); @Override void sendMessage(
Class<T> format,
T objectForSerialization,
Map<String, String> messageHeaders,
Map<String, String> messageContext,
String messageGroup); @Override void sendMessage(
Class<T> format,
final T objectForSerialization,
Map<String, String> messageHeaders,
Map<String, String> messageContext,
MessageRoutingPlan messageRoutingPlan); @Override void sendMessage(
Class<T> format,
final T objectForSerialization,
Map<String, String> messageHeaders,
Map<String, String> messageContext,
MessageRoutingPlan messageRoutingPlan,
String messageGroup); } | @Test public void testStreamMessage_validateRoutingPlanHeader() { final MessageRoutingPlan routingPlan = MessageRoutingPlan.builder() .withRoute("microservice1", "microservice1.queue.output", "blob=store", "runId", true) .withRoute("microservice2", "microservice2.queue.output", "blob=store", "runId", true) .withRoute("microservice3", "microservice3.queue.output", "blob=store", "runId", true) .withRoute("microservice4", "microservice4.queue.output", "blob=store", "runId", true) .withRoute("microservice5", "microservice5.queue.output", "blob=store", "runId", true) .build(); Mockito.when(resourceProvider.getServiceRegistryApi()).thenReturn(serviceRegistryApi); Mockito.when(resourceProvider.getQueueConfigurationClass()).thenReturn(QueueConfiguration.class); Mockito .when(serviceRegistryApi.getQueueConfiguration(eq(QueueConfiguration.class), anyString(), eq(context))) .thenReturn(mock(QueueConfiguration.class)); MessageWriter messageWriter = mock(MessageWriter.class); String messageGroup = "message-group"; Map<String, String> messageHeaders = mock(Map.class); Map<String, String> messageContext = mock(Map.class); messageSender.streamMessage(messageWriter, messageHeaders, messageContext, routingPlan, messageGroup); ArgumentCaptor<Map> actualMessageHeadersCaptor = ArgumentCaptor.forClass(Map.class); Mockito .verify(runtimeMessageSender) .streamMessage(eq(messageWriter), actualMessageHeadersCaptor.capture(), eq(messageGroup)); Map<String, String> actualMessageHeaders = actualMessageHeadersCaptor.getValue(); assertEquals( "Unexpected route properties in message headers", "blobstoreKeyHeaderName,runId,logInDebug,true,destinationQueueURI,microservice1.queue.output,blobstoreNameSpace,blob=store", actualMessageHeaders.get("__contextHeader__MS_API_OUTPUT_QUEUE_NAME_microservice1")); assertEquals( "Unexpected route properties in message headers", "blobstoreKeyHeaderName,runId,logInDebug,true,destinationQueueURI,microservice2.queue.output,blobstoreNameSpace,blob=store", actualMessageHeaders.get("__contextHeader__MS_API_OUTPUT_QUEUE_NAME_microservice2")); assertEquals( "Unexpected route properties in message headers", "blobstoreKeyHeaderName,runId,logInDebug,true,destinationQueueURI,microservice3.queue.output,blobstoreNameSpace,blob=store", actualMessageHeaders.get("__contextHeader__MS_API_OUTPUT_QUEUE_NAME_microservice3")); assertEquals( "Unexpected route properties in message headers", "blobstoreKeyHeaderName,runId,logInDebug,true,destinationQueueURI,microservice4.queue.output,blobstoreNameSpace,blob=store", actualMessageHeaders.get("__contextHeader__MS_API_OUTPUT_QUEUE_NAME_microservice4")); assertEquals( "Unexpected route properties in message headers", "blobstoreKeyHeaderName,runId,logInDebug,true,destinationQueueURI,microservice5.queue.output,blobstoreNameSpace,blob=store", actualMessageHeaders.get("__contextHeader__MS_API_OUTPUT_QUEUE_NAME_microservice5")); assertEquals( "Unexpected routing plan in message headers", "microservice1,microservice2,microservice3,microservice4,microservice5", actualMessageHeaders.get("__contextHeader__MS_API_ROUTING_PLAN")); }
@Test public void testStreamMessage_validateRoutingPlanHeaderWhenNoRoutingPlanProvided() { final MessageRoutingPlan routingPlan = null; Mockito.when(resourceProvider.getServiceRegistryApi()).thenReturn(serviceRegistryApi); Mockito.when(resourceProvider.getQueueConfigurationClass()).thenReturn(QueueConfiguration.class); Mockito .when(serviceRegistryApi.getQueueConfiguration(eq(QueueConfiguration.class), anyString(), eq(context))) .thenReturn(mock(QueueConfiguration.class)); MessageWriter messageWriter = mock(MessageWriter.class); String messageGroup = "message-group"; Map<String, String> messageHeaders = mock(Map.class); Map<String, String> messageContext = mock(Map.class); messageSender.streamMessage(messageWriter, messageHeaders, messageContext, routingPlan, messageGroup); ArgumentCaptor<Map> actualMessageHeadersCaptor = ArgumentCaptor.forClass(Map.class); Mockito .verify(runtimeMessageSender) .streamMessage(eq(messageWriter), actualMessageHeadersCaptor.capture(), eq(messageGroup)); Map<String, String> actualMessageHeaders = actualMessageHeadersCaptor.getValue(); assertTrue("Expected empty message headers", actualMessageHeaders.size() == 0); } |
MurmurHash { public static long hash64(final byte[] data, int length, int seed) { final long m = 0xc6a4a7935bd1e995L; final int r = 47; long h = (seed & 0xffffffffL) ^ (length * m); int length8 = length / 8; for (int i = 0; i < length8; i++) { final int i8 = i * 8; long k = ((long) data[i8 + 0] & 0xff) + (((long) data[i8 + 1] & 0xff) << 8) + (((long) data[i8 + 2] & 0xff) << 16) + (((long) data[i8 + 3] & 0xff) << 24) + (((long) data[i8 + 4] & 0xff) << 32) + (((long) data[i8 + 5] & 0xff) << 40) + (((long) data[i8 + 6] & 0xff) << 48) + (((long) data[i8 + 7] & 0xff) << 56); k *= m; k ^= k >>> r; k *= m; h ^= k; h *= m; } switch (length % 8) { case 7: h ^= (long) (data[(length & ~7) + 6] & 0xff) << 48; case 6: h ^= (long) (data[(length & ~7) + 5] & 0xff) << 40; case 5: h ^= (long) (data[(length & ~7) + 4] & 0xff) << 32; case 4: h ^= (long) (data[(length & ~7) + 3] & 0xff) << 24; case 3: h ^= (long) (data[(length & ~7) + 2] & 0xff) << 16; case 2: h ^= (long) (data[(length & ~7) + 1] & 0xff) << 8; case 1: h ^= (long) (data[length & ~7] & 0xff); h *= m; default: } h ^= h >>> r; h *= m; h ^= h >>> r; return h; } private MurmurHash(); static int hash32(final byte[] data, int length, int seed); static int hash32(final byte[] data, int length); static int hash32(final String text); static int hash32(final String text, int from, int length); static long hash64(final byte[] data, int length, int seed); static long hash64(final byte[] data, int length); static long hash64(final String text); static long hash64(final String text, int from, int length); static long hash64(String first, String... rest); } | @Test public void testHash64ByteArrayIntInt() { for (int i = 0; i < input.length; i++) { long hash = MurmurHash.hash64(input[i], input[i].length, 0x344d1f5c); assertTrue( String.format( "Unexpected hash64 result for example %d: 0x%016x instead of 0x%016x", i, hash, results64_seed[i]), hash == results64_seed[i]); } }
@Test public void testHash64ByteArrayInt() { for (int i = 0; i < input.length; i++) { long hash = MurmurHash.hash64(input[i], input[i].length); assertTrue( String.format( "Unexpected hash64 result for example %d: 0x%016x instead of 0x%016x", i, hash, results64_standard[i]), hash == results64_standard[i]); } }
@Test public void testHash64String() { long hash = MurmurHash.hash64(text); assertTrue(hash == 0x0920e0c1b7eeb261l); }
@Test public void testHash64StringIntInt() { long hash = MurmurHash.hash64(text, 2, text.length() - 4); assertTrue(hash == 0xa8b33145194985a2l); } |
SqlBuilder { public String getSqlString() { return command + (command.equals(DELETE) ? "" : selection) + FROM + tableName + getWhereClauseString() + getQuerySuffixString(); } SqlBuilder(String tableName); SqlBuilder(String tableName, String command); static String getSortOrderString(SqlQueryOrder.SortOrder sortOrder); SqlBuilder addCaseInsensitiveLikeCondition(String fieldName, String fieldValue); SqlBuilder addInCondition(String fieldName, Collection<String> values); SqlBuilder addMultipleOrConditionOfKeyValuePairs(
String keyColumnName,
String valueColumnName,
Map<String, String> keyValuePairs); SqlBuilder addCondition(String condition); SqlBuilder addQueryParam(Object param); SqlBuilder addQueryParams(Collection<Object> params); String getSqlString(); SqlBuilder setSelection(String selection); SqlBuilder addQuerySuffix(String querySuffix); SqlBuilder addQuerySuffixWithParam(String suffix, Object param); @NoJavadoc // TODO add JavaDoc SqlBuilder addOrderByClause(SqlQueryOrder sqlQueryOrder); List<Object> getQueryParams(); @Override String toString(); String build(); static final int MAX_ITEMS_FOR_IN_CLAUSE; static final String SELECT; static final String DELETE; } | @Test public void testSimpleQuery() { SqlBuilder builder = new SqlBuilder("table"); Assert.assertEquals("wrong query", "select * from table", builder.getSqlString()); } |
PersistentMessagingServer implements Connection { @Override public void pause() { queues.values().forEach(Queue::pause); } PersistentMessagingServer(MessagePersister persister); @Override void createQueue(
String queueName,
int memoryBufferMaxMessages,
int secondsToSleepBetweenMessageRetries,
int maxRetries); @Override void sendMessage(String queueName, InputStream messageBody, Map<String, String> headers); @Override void sendMessage(String queueName, Consumer<OutputStream> writer, Map<String, String> headers); @Override void subscribe(String queueName, String consumerName, Consumer<Message> messageConsumer); @Override void unsubscribe(String queueName, String consumerName); @Override void pause(); @Override void pause(String queueName); @Override void start(); @Override void start(String queueName); } | @Test public void testPause() throws InterruptedException { Connection connection = createConnectionWithQueue(1000, 2, 1); AtomicInteger count = createSomeMessyQueues(connection); Thread.sleep(55L); connection.pause(); int countRightAfterPause = count.get(); System.out.println(countRightAfterPause); Thread.sleep(100L); System.out.println(count.get()); int countNow = count.get(); Assert.assertTrue("Messages should be drained from the queue", countNow > countRightAfterPause); Thread.sleep(100L); Assert.assertEquals("Messages should stopped being consumed as the queue is paused now", countNow, count.get()); Assert.assertTrue(countNow > 0 && countNow < 10000); } |
PersistentMessagingServer implements Connection { @Override public void unsubscribe(String queueName, String consumerName) { getQueue(queueName).removeConsumer(consumerName); } PersistentMessagingServer(MessagePersister persister); @Override void createQueue(
String queueName,
int memoryBufferMaxMessages,
int secondsToSleepBetweenMessageRetries,
int maxRetries); @Override void sendMessage(String queueName, InputStream messageBody, Map<String, String> headers); @Override void sendMessage(String queueName, Consumer<OutputStream> writer, Map<String, String> headers); @Override void subscribe(String queueName, String consumerName, Consumer<Message> messageConsumer); @Override void unsubscribe(String queueName, String consumerName); @Override void pause(); @Override void pause(String queueName); @Override void start(); @Override void start(String queueName); } | @Test public void testUnsubscribe() throws InterruptedException { Connection connection = createConnectionWithQueue(1000, 2, 1); AtomicInteger count = createSomeMessyQueues(connection); Thread.sleep(55L); IntStream.range(0,30).forEach((i) -> connection.unsubscribe("q1", "Saruman" + i)); int countRightAfterPause = count.get(); System.out.println(countRightAfterPause); Thread.sleep(100L); System.out.println(count.get()); int countNow = count.get(); Assert.assertTrue("Messages should be drained from the queue until finished un-subscribing", countNow > countRightAfterPause); Thread.sleep(100L); Assert.assertEquals("Messages should stopped being consumed as the queue is has no subscribersnow", countNow, count.get()); Assert.assertTrue(countNow > 0 && countNow < 10000); } |
Task { @Override public String toString() { return "Task{" + "id=" + id + ", name='" + name + '\'' + ", executionTime=" + executionTime + ", payload='" + payload + '\'' + '}'; } Task(
String id,
String name,
long executionTime,
String payload); private Task(); final String getId(); final String getName(); final long getExecutionTime(); void setExecutionTime(long executionTime); final String getPayload(); @Override String toString(); @Override boolean equals(Object o); @Override int hashCode(); } | @Test public void serializeDeserializeTaskTest() throws Exception { Task task = new Task(UUID.randomUUID().toString(), "task", System.currentTimeMillis(), "payload"); Object serializedTask = PostgresUtil.objectToJsonBParameter(task, null); Task deserializedTask = PostgresUtil.fromJsonB(((PGobject) serializedTask).getValue(), Task.class); Assert.assertEquals(task, deserializedTask); }
@Test public void serializeDeserializeOneOffTaskTest() throws Exception { String id = UUID.randomUUID().toString(); OneOffTask task = new OneOffTask(id, "task", System.currentTimeMillis(), "payload", "consumer"); Object serializedTask = PostgresUtil.objectToJsonBParameter(task, null); Task deserializedTask = PostgresUtil.fromJsonB(((PGobject) serializedTask).getValue(), Task.class); Assert.assertEquals(task, deserializedTask); }
@Test public void serializeDeserializeRecurringTaskTest() throws Exception { String id = UUID.randomUUID().toString(); Task task = new RecurringTask(id, "task", System.currentTimeMillis(), "payload", "function", 5); Object serializedTask = PostgresUtil.objectToJsonBParameter(task, null); Task deserializedTask = PostgresUtil.fromJsonB(((PGobject) serializedTask).getValue(), Task.class); Assert.assertEquals(task, deserializedTask); } |
DeployedApplication { public DeployedApplication create(DeployedApplicationBuilder builder) { setExecutionEvent(builder.build()); return this; } DeployedApplication(Collection<DeployedApplicationEvent> event); DeployedApplication(); UUID getId(); String getName(); String getAppTemplateName(); String getAppTemplateVersion(); Map<String, DeployedDataService> getDeployedDataServices(); Map<String, DeployedAppService> getDeployedAppServices(); Map<String, Map<String, Set<String>>> getAppServiceToDataServiceMappings(); Collection<DeployedDataService> getBoundServices(String appServiceName); String getEntryPointService(); DeployedApplicationState getState(); Date getStateDate(); Date getDeployedOn(); String getStateMessage(); String getEntryPointURL(); DeployedDataServicesPolicy getDataServicesPolicy(String name, String type); Collection<DeployedDataServicesPolicy> getDataServicesPolicies(); DeployedApplication stop(); DeployedApplication stop(String message); DeployedApplication create(DeployedApplicationBuilder builder); @NoJavadoc DeployedApplication markDataServiceAsCreating(String bindName); DeployedApplication markDataServiceAsCreated(String bindName); @NoJavadoc DeployedApplication markDataServiceAsCreated(String bindName, String message); @NoJavadoc DeployedApplication markDataServiceAsRemoving(String bindName); DeployedApplication markDataServiceAsRemoved(String bindName); DeployedApplication markDataServiceAsErrorRemoving(String bindName, String message); DeployedApplication markDataServiceAsErrorUnBinding(String bindName, String message); @NoJavadoc DeployedApplication markDataServiceAsUnbound(String bindName); @NoJavadoc DeployedApplication markDataServiceAsBinding(String bindName); DeployedApplication markDataServiceAsErrorBinding(String bindName, String message); DeployedApplication markDataServiceAsErrorCreating(String bindName, String message); DeployedApplication markPolicyAsError(String policyName, String policyType, String message); @NoJavadoc DeployedApplication markPolicyAsActivating(String policyName, String policyType); DeployedApplication markPolicyAsActive(String policyName, String policyType); DeployedApplication markDataServiceAsBound(String bindName, DataServiceBoundEvent.BindingInfo bindingInfo); @NoJavadoc DeployedApplication markAppServiceAsDeploying(String appServiceName); DeployedApplication markAppServiceAsError(String appServiceName, String message); DeployedApplication markAppServiceAsStopped(String appServiceName); DeployedApplication markAppServiceAsErrorStopping(String appServiceName, String message); DeployedApplication markAppServiceAsDeployed(String appServiceName, String publicURL); Collection<DeployedApplicationEvent> rollEvent(DeployedApplicationEvent event); DeployedApplicationEvent getExecutionEvent(); void setExecutionEvent(DeployedApplicationEvent executionEvent); } | @Test public void testCreate() { DeployedApplicationBuilder builder = getBuilder(); DeployedApplication app = new DeployedApplication(); app.create(builder); app.markAsClean(); app.getDeployedAppServices().values() .forEach(deployedAppService -> Assert.assertEquals(DeployedAppServiceState.pending, deployedAppService.getState())); Assert.assertEquals("myAppInstance", app.getName()); Assert.assertEquals(DeployedApplicationState.deploying, app.getState()); roll(app.markDataServiceAsCreating("db1BindName")); roll(app.markDataServiceAsCreated("db1BindName")); roll(app.markDataServiceAsBinding("db1BindName")); roll(app.markDataServiceAsBound("db1BindName", new DataServiceBoundEvent.BindingInfo( Collections.emptyMap(), Collections.emptyList()))); roll(app.markDataServiceAsCreating("db2BindName")); roll(app.markDataServiceAsCreated("db2BindName")); roll(app.markDataServiceAsBinding("db2BindName")); roll(app.markDataServiceAsBound("db2BindName", new DataServiceBoundEvent.BindingInfo( Collections.emptyMap(), Collections.emptyList()))); app.getDeployedAppServices().values() .forEach(deployedAppService -> Assert.assertEquals(DeployedAppServiceState.queued, deployedAppService.getState())); roll(app.markAppServiceAsDeploying("svc1")); roll(app.markAppServiceAsDeployed("svc1", "http: roll(app.markAppServiceAsDeploying("svc2")); roll(app.markAppServiceAsDeployed("svc2", null)); Assert.assertEquals(DeployedApplicationState.running, app.getState()); Assert.assertEquals("http: } |
DockerArtifactRegistryImpl implements ArtifactRegistryApi { @Override public Collection<String> listVersions(String artifactId) { try { if (!artifactId.contains("/")) { artifactId = "library/" + artifactId; } final String registryUrl = this.url + "/v2/repositories/" + artifactId + "/tags/"; log.info("fetching tags from {}", registryUrl); final Map res = webAPIResolver .getWebTarget(registryUrl) .request(MediaType.APPLICATION_JSON_TYPE) .buildGet() .invoke(Map.class); return ((List<Map>) res.get("results")) .stream() .map(o -> (String) o.get("name")) .collect(Collectors.toList()); } catch (Exception ex) { log.warn("oh well.. couldn't fetch from registry" + ex.getMessage(), ex); return Collections.singleton("latest"); } } DockerArtifactRegistryImpl(WebAPIResolver webAPIResolver, String url, String username, String password); @Override Collection<String> listVersions(String artifactId); } | @Test public void testMe() { new ResteasyJackson2Provider(); final DockerArtifactRegistryImpl dockerArtifactRegistry = new DockerArtifactRegistryImpl(new TestResolver(), "https: final Collection<String> mysql = dockerArtifactRegistry.listVersions("mysql"); mysql.forEach(System.out::println); Assert.assertTrue(mysql.contains("latest")); } |
ApplicationCopyEventRepositoryImpl implements ApplicationCopyEventRepository, ServiceLifecycle { @Override public List<ApplicationCopyEvent> listOrderedEvents(UUID copyId) { return nqs.getList(SQL_SELECT_EVENTS_BY_APP_COPY_ID, this::convertRow, Collections.singletonList(copyId)); } ApplicationCopyEventRepositoryImpl(DataSource dataSource); ApplicationCopyEventRepositoryImpl(); @Override UUID subscribe(Consumer<ApplicationCopyEvent> consumer); @Override void unSubscribe(UUID subscriberId); @Override List<ApplicationCopyEvent> listOrderedEvents(UUID copyId); @Override Map<UUID, List<ApplicationCopyEvent>> listByAppInstanceId(UUID appInstanceId); @Override ApplicationCopyEvent store(ApplicationCopyEvent appCopyEvent); @Override Collection<ApplicationCopyEvent> store(Collection<ApplicationCopyEvent> appCopyEvents); @Override void init(Context context); @Override void shutDown(); } | @Test public void testNonExistentCopyId() { UUID copyId = UUID.randomUUID(); Collection<ApplicationCopyEvent> events = appCopyEventRepo.listOrderedEvents(copyId); Assert.assertEquals(0, events.size()); } |
ApplicationCopyEventRepositoryImpl implements ApplicationCopyEventRepository, ServiceLifecycle { @Override public Map<UUID, List<ApplicationCopyEvent>> listByAppInstanceId(UUID appInstanceId) { return nqs.getMapOfList( SQL_SELECT_EVENTS_BY_APP_INSTANCE_ID, new UuidNativeQueryConverter("appCopyId"), this::convertRow, Collections.singletonList(appInstanceId) ); } ApplicationCopyEventRepositoryImpl(DataSource dataSource); ApplicationCopyEventRepositoryImpl(); @Override UUID subscribe(Consumer<ApplicationCopyEvent> consumer); @Override void unSubscribe(UUID subscriberId); @Override List<ApplicationCopyEvent> listOrderedEvents(UUID copyId); @Override Map<UUID, List<ApplicationCopyEvent>> listByAppInstanceId(UUID appInstanceId); @Override ApplicationCopyEvent store(ApplicationCopyEvent appCopyEvent); @Override Collection<ApplicationCopyEvent> store(Collection<ApplicationCopyEvent> appCopyEvents); @Override void init(Context context); @Override void shutDown(); } | @Test public void testNonExistentInstanceId() { UUID instId = UUID.randomUUID(); Map<UUID, List<ApplicationCopyEvent>> events = appCopyEventRepo.listByAppInstanceId(instId); Assert.assertEquals(0, events.keySet().size()); } |
PsbAppServiceIdGenerator { public static Map<String, String> generatePsbAppServiceIdsByAppSvcName( final String appInstanceName, final Set<String> appServiceNames, int psbMaxAppIdLength) { Map<String, String> psbAppServiceIds = new HashMap<>(appServiceNames.size()); String timeSuffix = String.valueOf(System.currentTimeMillis()); if (timeSuffix.length() > 11) { timeSuffix = timeSuffix.substring(timeSuffix.length() - 11); } int charactersLeftToUse = psbMaxAppIdLength - timeSuffix.length() - 1; final String encodedAppInstanceName = encodeName(appInstanceName); final int appInstanceNameLength = encodedAppInstanceName.length(); for (String currAppServiceName : appServiceNames) { final String encodedAppServiceName = encodeName(currAppServiceName); if (appInstanceNameLength + encodedAppServiceName.length() > charactersLeftToUse) { if (appServiceNames.size() == 1) { final String singleServicePsbAppId = encodedAppInstanceName + "-" + encodedAppServiceName; String appNameAndSvcName = singleServicePsbAppId .substring( 0, Math.min( singleServicePsbAppId.length(), psbMaxAppIdLength - timeSuffix.length())); psbAppServiceIds.put( currAppServiceName, appNameAndSvcName + timeSuffix); } else { StringBuilder appInstanceNamePrefix = new StringBuilder( encodedAppInstanceName .substring( 0, Math.min( encodedAppInstanceName.length(), charactersLeftToUse / 2 + charactersLeftToUse % 2) )); if (appInstanceNamePrefix.charAt(appInstanceNamePrefix.length() - 1) != '-') { appInstanceNamePrefix.append('-'); } String psbAppServiceIdAttempt = appInstanceNamePrefix.append( encodedAppServiceName .substring( 0, Math.min( charactersLeftToUse / 2, encodedAppServiceName.length()))).toString(); int duplicateIdx = 1; while (psbAppServiceIds.containsValue(psbAppServiceIdAttempt + timeSuffix)) { psbAppServiceIdAttempt = psbAppServiceIdAttempt .substring(0, psbAppServiceIdAttempt.length() - String.valueOf(duplicateIdx).length()) + String.valueOf(duplicateIdx); duplicateIdx++; } psbAppServiceIds.put(currAppServiceName, psbAppServiceIdAttempt + timeSuffix); } } else { psbAppServiceIds.put( currAppServiceName, encodedAppInstanceName + "-" + encodedAppServiceName + timeSuffix); } } return psbAppServiceIds; } private PsbAppServiceIdGenerator(); static Map<String, String> generatePsbAppServiceIdsByAppSvcName(
final String appInstanceName,
final Set<String> appServiceNames,
int psbMaxAppIdLength); } | @Test public void testItNowBye() { Map<String, String> ret = PsbAppServiceIdGenerator.generatePsbAppServiceIdsByAppSvcName( "cool app", new HashSet<>( Arrays.asList("svc a", "svc b", "svc c")), 12 + 11 ); ret.values().forEach(s -> Assert.assertTrue(s + " too long", s.length() <= 12 + 11)); Assert.assertEquals("cool-a-svc-a", ret.get("svc a").substring(0, "cool-a-svc-a".length())); Assert.assertEquals("cool-a-svc-b", ret.get("svc b").substring(0, "cool-a-svc-b".length())); Assert.assertEquals("cool-a-svc-c", ret.get("svc c").substring(0, "cool-a-svc-c".length())); ret = PsbAppServiceIdGenerator.generatePsbAppServiceIdsByAppSvcName( "cool app", new HashSet<>( Arrays.asList("svc long test name a", "svc long test name b")), 12 + 11 ); ret.values().forEach(s -> Assert.assertTrue(s + " too long", s.length() <= 12 + 11)); System.out.println(ret); Assert.assertEquals("cool-a-svc-l", ret.get("svc long test name a").substring(0, "cool-a-svc-l".length())); Assert.assertEquals("cool-a-svc-1", ret.get("svc long test name b").substring(0, "cool-a-svc-1".length())); } |
SiteRepositoryImpl implements SiteRepository, ServiceLifecycle { @Override public Site load() { final Site site = new Site(siteName); populateSite(site); return site; } SiteRepositoryImpl(); SiteRepositoryImpl(
String siteName,
DataSource dataSource,
SerializationWriter<DbSite> writer,
SerializationReader<DbSite> reader,
ArtifactRegistryFactory artifactRegistryFactory,
WebAPIResolver resolver); @Override void init(Context context); @Override void shutDown(); @Override Site load(); @Override void persist(Site site); } | @Test public void testEmptyCreated() { final Site empty = siteRepository.load(); Assert.assertTrue(empty.getCopyRepositories().isEmpty()); Assert.assertTrue(empty.getDsbList().isEmpty()); Assert.assertTrue(empty.getPsbs().isEmpty()); Assert.assertEquals("my-site", empty.getName()); }
@Test public void testAdd() { persistSite(); Site newSite = siteRepository.load(); assertSiteEquals(newSite); } |
ErrorsMessageHeaderWriter implements SerializationWriter<ErrorsMessageHeader> { @Override public void writeObject(ErrorsMessageHeader errorsMessageHeader, OutputStream outputStream) throws ErrorMessageHeaderSerializationException { ObjectMapper mapper = new ObjectMapper(); try { mapper.writeValue(outputStream, errorsMessageHeader); } catch (Exception e) { String message = "Could not serialize a List of " + ErrorMessageHeader.class.getName() + " object. Cause: " + e.getMessage(); throw new ErrorMessageHeaderSerializationException(message, e); } } @Override void writeObject(ErrorsMessageHeader errorsMessageHeader, OutputStream outputStream); } | @Test public void testWriteListErrorMessageHeader() { List<ErrorMessageHeader> errorMessageHeaders = new ArrayList<>(); errorMessageHeaders.add(new ErrorMessageHeader( "microservice-1-uri", 1456485443905L, 404, "Service 1 unavailable")); errorMessageHeaders.add(new ErrorMessageHeader( "microservice-2-uri", 1456485443906L, 405, "Service 2 unavailable")); errorMessageHeaders.add(new ErrorMessageHeader( "microservice-3-uri", 1456485443907L, 406, "Service 3 unavailable")); errorMessageHeaders.add(new ErrorMessageHeader( "microservice-4-uri", 1456485443908L, 407, "Service 4 unavailable")); ErrorsMessageHeader errorsMessageHeader = new ErrorsMessageHeader(errorMessageHeaders); ByteArrayOutputStream outputStream = new ByteArrayOutputStream(); new ErrorsMessageHeaderWriter().writeObject(errorsMessageHeader, outputStream); String jsonResult = outputStream.toString(); JsonFluentAssert actualJson = JsonFluentAssert.assertThatJson(jsonResult); InputStream expectedJson = getClass().getClassLoader().getResourceAsStream("errors/serialization/errorsmessageheader.json"); String expectedJSON = null; try { expectedJSON = ReadFile.getFileContents(expectedJson).toString(); } catch (IOException e) { e.printStackTrace(); } actualJson.hasSameStructureAs(expectedJSON); actualJson.isEqualTo(expectedJSON); }
@Test public void testException() { ErrorsMessageHeaderWriter writer = new ErrorsMessageHeaderWriter(); try { writer.writeObject(null, null); } catch (ErrorMessageHeaderSerializationException e) { String message = e.getMessage(); Assert.assertTrue(message.startsWith("Could not serialize ")); } } |
ErrorMessageHeaderReader implements SerializationReader<ErrorMessageHeader> { @NoJavadoc @Override public ErrorMessageHeader readObject(InputStream inputStream) throws ErrorMessageHeaderSerializationException { ObjectMapper mapper = new ObjectMapper(); try { return mapper.readValue(inputStream, ErrorMessageHeader.class); } catch (Exception e) { String message = "Could not deserialize input into a " + ErrorMessageHeader.class.getName() + " object. Cause: " + e.getMessage(); throw new ErrorMessageHeaderSerializationException(message, e); } } @NoJavadoc @Override ErrorMessageHeader readObject(InputStream inputStream); @NoJavadoc @Override ErrorMessageHeader readObject(Reader reader); @NoJavadoc ErrorMessageHeader readObject(String content); } | @Test public void testReadMessageHeaderFromStream() { InputStream inputJsonStream = getClass().getClassLoader().getResourceAsStream("errors/serialization/errormessageheader.json"); ErrorMessageHeader actualErrorMessageHeader = new ErrorMessageHeaderReader().readObject(inputJsonStream); ErrorMessageHeader expectedErrorMessageHeader = new ErrorMessageHeader("microservice-1-uri", 1456485443905L, 404, "Service unavailable"); Assert.assertEquals("Unexpected error message header", expectedErrorMessageHeader, actualErrorMessageHeader); }
@Test public void testReadErrorMessageHeaderFromString() { InputStream inputJsonStream = getClass().getClassLoader().getResourceAsStream("errors/serialization/errormessageheader.json"); String inputJson = null; try { inputJson = ReadFile.getFileContents(inputJsonStream).toString(); } catch (IOException e) { e.printStackTrace(); } ErrorMessageHeader actualErrorMessageHeader = new ErrorMessageHeaderReader().readObject(inputJson); ErrorMessageHeader expectedErrorMessageHeader = new ErrorMessageHeader("microservice-1-uri", 1456485443905L, 404, "Service unavailable"); Assert.assertEquals("Unexpected error message header", expectedErrorMessageHeader, actualErrorMessageHeader); }
@Test public void testException() { InputStream inputStream = null; ErrorMessageHeaderReader reader = new ErrorMessageHeaderReader(); try { reader.readObject(inputStream); } catch (ErrorMessageHeaderSerializationException e) { String message = e.getMessage(); Assert.assertTrue(message.startsWith("Could not deserialize ")); } }
@Test public void testExceptionWithNullContent() { String content = null; ErrorMessageHeaderReader reader = new ErrorMessageHeaderReader(); try { reader.readObject(content); } catch (ErrorMessageHeaderSerializationException e) { String message = e.getMessage(); Assert.assertTrue(message.startsWith("Could not deserialize ")); } } |
ErrorMessageHeaderWriter implements SerializationWriter<ErrorMessageHeader> { @Override public void writeObject(ErrorMessageHeader errorMessageHeader, OutputStream outputStream) throws ErrorMessageHeaderSerializationException { ObjectMapper mapper = new ObjectMapper(); try { mapper.writeValue(outputStream, errorMessageHeader); } catch (Exception e) { String message = "Could not serialize a " + ErrorMessageHeader.class.getName() + " object. Cause: " + e.getMessage(); throw new ErrorMessageHeaderSerializationException(message, e); } } @Override void writeObject(ErrorMessageHeader errorMessageHeader, OutputStream outputStream); } | @Test public void testWriteErrorMessageHeader() { ErrorMessageHeader errorMessageHeader = new ErrorMessageHeader("microservice-1-uri", 1456485443905L, 404, "Service unavailable"); ByteArrayOutputStream outputStream = new ByteArrayOutputStream(); new ErrorMessageHeaderWriter().writeObject(errorMessageHeader, outputStream); String jsonResult = outputStream.toString(); JsonFluentAssert actualJson = JsonFluentAssert.assertThatJson(jsonResult); InputStream expectedJson = getClass().getClassLoader().getResourceAsStream("errors/serialization/errormessageheader.json"); String expectedJSON = null; try { expectedJSON = ReadFile.getFileContents(expectedJson).toString(); } catch (IOException e) { e.printStackTrace(); } actualJson.hasSameStructureAs(expectedJSON); actualJson.isEqualTo(expectedJSON); }
@Test public void testException() { ErrorMessageHeaderWriter writer = new ErrorMessageHeaderWriter(); try { writer.writeObject(null, null); } catch (ErrorMessageHeaderSerializationException e) { String message = e.getMessage(); Assert.assertTrue(message.startsWith("Could not serialize ")); } } |
JiraQueryUtil { public UIJiraLoginResponse queryJira(String url, String userName, String password) { JiraAPI jiraTarget = webAPIResolver.getWebAPI(url, JiraAPI.class); JiraSession session = jiraTarget.autenticate( MapBuilder.<String, String>newHashMap() .with("username", userName) .with("password", password) .build()) .session; if (!"JSESSIONID".equals(session.name)) { throw new InternalServerErrorException("jira session not identified by JSESSIONID but by " + session.name); } return new UIJiraLoginResponse( jiraTarget.listProjects(session.value).stream() .map(o -> new UIJiraLoginResponseProjects(o.id, o.name)) .collect(Collectors.toList()), jiraTarget.listIssueTypes(session.value).stream() .map(o -> new UIJiraLoginResponseProjects(o.id, o.name)) .collect(Collectors.toList()) ); } JiraQueryUtil(WebAPIResolver resolver); UIJiraLoginResponse queryJira(String url, String userName, String password); } | @Test public void testJiraQuery() { JiraQueryUtil jiraQueryUtil = new JiraQueryUtil(new MyWebAPIResolver()); final UIJiraLoginResponse jiraData = jiraQueryUtil.queryJira("http: Assert.assertEquals(1, jiraData.getIssueTypes().size()); Assert.assertEquals("iId", jiraData.getIssueTypes().iterator().next().getId()); Assert.assertEquals("iName", jiraData.getIssueTypes().iterator().next().getName()); Assert.assertEquals(1, jiraData.getProjects().size()); Assert.assertEquals("pId", jiraData.getProjects().iterator().next().getId()); Assert.assertEquals("pName", jiraData.getProjects().iterator().next().getName()); }
@Test public void testInvalidSession() { JiraQueryUtil jiraQueryUtil = new JiraQueryUtil(new MyWebAPIResolver(false)); try { jiraQueryUtil.queryJira("http: Assert.fail("Should have failed"); } catch (InternalServerErrorException ex) { } } |
ErrorsMessageHeaderReader implements SerializationReader<ErrorsMessageHeader> { @Override public ErrorsMessageHeader readObject(InputStream inputStream) throws ErrorMessageHeaderSerializationException { ObjectMapper mapper = new ObjectMapper(); try { return mapper.readValue(inputStream, ErrorsMessageHeader.class); } catch (Exception e) { String message = "Could not deserialize input into a List of " + ErrorMessageHeader.class.getName() + " object. Cause: " + e.getMessage(); throw new ErrorMessageHeaderSerializationException(message, e); } } @Override ErrorsMessageHeader readObject(InputStream inputStream); @Override ErrorsMessageHeader readObject(Reader reader); @NoJavadoc ErrorsMessageHeader readObject(String content); } | @Test public void testReadErrorsMessageHeaderFromStream() { InputStream inputJsonStream = getClass().getClassLoader().getResourceAsStream("errors/serialization/errorsmessageheader.json"); ErrorsMessageHeader actualErrorsMessageHeader = new ErrorsMessageHeaderReader().readObject(inputJsonStream); ArrayList<ErrorMessageHeader> expectedErrorMessageHeaders = new ArrayList<>(); expectedErrorMessageHeaders.add(new ErrorMessageHeader( "microservice-1-uri", 1456485443905L, 404, "Service 1 unavailable")); expectedErrorMessageHeaders.add(new ErrorMessageHeader( "microservice-2-uri", 1456485443906L, 405, "Service 2 unavailable")); expectedErrorMessageHeaders.add(new ErrorMessageHeader( "microservice-3-uri", 1456485443907L, 406, "Service 3 unavailable")); expectedErrorMessageHeaders.add(new ErrorMessageHeader( "microservice-4-uri", 1456485443908L, 407, "Service 4 unavailable")); ErrorsMessageHeader expectedErrorsMessageHeader = new ErrorsMessageHeader(expectedErrorMessageHeaders); Assert.assertTrue( "Unexpected error message header", expectedErrorsMessageHeader .getErrorMessageHeaders() .containsAll(actualErrorsMessageHeader.getErrorMessageHeaders())); }
@Test public void testReadErrorsMessageHeaderFromString() { InputStream inputJsonStream = getClass().getClassLoader().getResourceAsStream("errors/serialization/errorsmessageheader.json"); String inputJson = null; try { inputJson = ReadFile.getFileContents(inputJsonStream).toString(); } catch (IOException e) { e.printStackTrace(); } ErrorsMessageHeader actualErrorsMessageHeader = new ErrorsMessageHeaderReader().readObject(inputJson); List<ErrorMessageHeader> expectedErrorMessageHeaders = new ArrayList<>(); expectedErrorMessageHeaders.add(new ErrorMessageHeader( "microservice-1-uri", 1456485443905L, 404, "Service 1 unavailable")); expectedErrorMessageHeaders.add(new ErrorMessageHeader( "microservice-2-uri", 1456485443906L, 405, "Service 2 unavailable")); expectedErrorMessageHeaders.add(new ErrorMessageHeader( "microservice-3-uri", 1456485443907L, 406, "Service 3 unavailable")); expectedErrorMessageHeaders.add(new ErrorMessageHeader( "microservice-4-uri", 1456485443908L, 407, "Service 4 unavailable")); ErrorsMessageHeader expectedErrorsMessageHeader = new ErrorsMessageHeader(expectedErrorMessageHeaders); Assert.assertTrue( "Unexpected error message header", expectedErrorsMessageHeader .getErrorMessageHeaders() .containsAll(actualErrorsMessageHeader.getErrorMessageHeaders())); }
@Test public void testExceptionWithNullInputStream() { InputStream inputStream = null; ErrorsMessageHeaderReader reader = new ErrorsMessageHeaderReader(); try { reader.readObject(inputStream); } catch (ErrorMessageHeaderSerializationException e) { String message = e.getMessage(); Assert.assertTrue(message.startsWith("Could not deserialize ")); } }
@Test public void testExceptionWithNullContent() { String content = null; ErrorsMessageHeaderReader reader = new ErrorsMessageHeaderReader(); try { reader.readObject(content); } catch (ErrorMessageHeaderSerializationException e) { String message = e.getMessage(); Assert.assertTrue(message.startsWith("Could not deserialize ")); } } |
PathUtilities { static boolean isValid(String path) { Objects.requireNonNull(path, "Path can't be null"); if ("/".equals(path)) { return true; } if (path.startsWith("/")) { path = path.substring(1); } for (String part : split(path)) { if (!isPathNameValid(part)) { return false; } } return true; } } | @Test public void testPathsWithValidCharacters() { assertTrue(PathUtilities.isValid("level1")); assertTrue(PathUtilities.isValid("level-1")); assertTrue(PathUtilities.isValid("level-1/level-2/level3")); assertTrue(PathUtilities.isValid("1/2/a")); }
@Test public void testThatPathWithOnlyHyphenIsInvalid() { assertFalse(PathUtilities.isValid("level1/-/level3")); assertFalse(PathUtilities.isValid("-")); }
@Test public void testThatPathWithSpaceIsInvalid() { assertFalse(PathUtilities.isValid("level 1")); }
@Test public void testThatPathWithNoneAlphaNumericOrHyphenIsInvalid() { assertFalse(PathUtilities.isValid("apple_level")); assertFalse(PathUtilities.isValid("category%23/apple")); }
@Test public void testThatPathStartingWithSeparatorIsValid() { assertTrue(PathUtilities.isValid("/apple/ball")); }
@Test public void testRootPathIsValid() { assertTrue(PathUtilities.isValid("/")); } |
InfluxDBJvmTagParser { public static Map<String, String> parse(String jvmTags) throws IllegalArgumentException { if (jvmTags == null || jvmTags.isEmpty()) { return Collections.EMPTY_MAP; } String[] tagValuePairs = jvmTags.split(","); Map<String, String> result = new HashMap<>(); for (String tagValuePair : tagValuePairs) { String[] tagValueSplit = tagValuePair.split("="); if (tagValueSplit.length != 2) { throw new IllegalArgumentException("jvmTags is in an invalid format. " + "Multiple Tag/Value pairs must be delimited by ','. " + "A tag/value pair must be separated with an '='. jvmTag input was '" + jvmTags + "'"); } String tagName = tagValueSplit[0]; if (tagName.isEmpty()) { throw new IllegalArgumentException("A tag name is empty. jvmTag input was '" + jvmTags + "'"); } String value = tagValueSplit[1]; if (value.isEmpty()) { throw new IllegalArgumentException("The tag value for tag name '" + tagName + "' is empty. Full jvmTag input was '" + jvmTags + "'"); } result.put(tagName, value); } return result; } static Map<String, String> parse(String jvmTags); } | @Test public void testNullInput() { Assert.assertEquals(Collections.EMPTY_MAP, new InfluxDBJvmTagParser().parse(null)); }
@Test(expected = IllegalArgumentException.class) public void testNoEqualsSign() { InfluxDBJvmTagParser.parse("iDontContainAnEqualsSign"); }
@Test(expected = IllegalArgumentException.class) public void testLeadsWithEqualsSign() { InfluxDBJvmTagParser.parse("=iLeadWithAnEqualsSign"); }
@Test(expected = IllegalArgumentException.class) public void testMultipleEqualsSignsWithNoDelimeter() { InfluxDBJvmTagParser.parse("tag1=value1 tag2=value2"); }
@Test(expected = IllegalArgumentException.class) public void testMultipleEqualsSignsWithIncorrectDelimeter() { InfluxDBJvmTagParser.parse("tag1=value1;tag2=value2"); }
@Test() public void testSingleTag() { Map<String, String> result = InfluxDBJvmTagParser.parse("tag1=value1"); Assert.assertEquals(1, result.size()); Assert.assertEquals("value1", result.get("tag1")); }
@Test() public void testMultipleTags() { Map<String, String> result = InfluxDBJvmTagParser.parse("tag1=value1,tag2=value2,tag3=value3"); Assert.assertEquals(3, result.size()); Assert.assertEquals("value1", result.get("tag1")); Assert.assertEquals("value2", result.get("tag2")); Assert.assertEquals("value3", result.get("tag3")); } |
JMSMessage implements Message { @Override public void readMessage(final MessageReader messageReader) { if (blobStoreAPI != null) { BlobStoreLink blobStoreLink; SerializationReader<BlobStoreLink> reader = serializationManager.getReader(BlobStoreLink.class); try (InputStream inputStream = getInputStream(false)) { blobStoreLink = reader.readObject(inputStream); } catch (IOException e) { throw new IllegalStateException(e); } if (blobStoreAPI.isExists(blobStoreLink.getNamespace(), blobStoreLink.getKey())) { blobStoreAPI.readBlob(blobStoreLink.getNamespace(), blobStoreLink.getKey(), in -> { if (gzip) { try (GZIPInputStream gzipInputStream = new GZIPInputStream(in)) { messageReader.read(gzipInputStream); } catch (IOException e) { throw new IllegalStateException(e); } } else { messageReader.read(in); } }); } else { throw new IllegalStateException( "Failed reading message with id (id doesn't exist)" + blobStoreLink.getNamespace() + ':' + blobStoreLink.getKey()); } } else { try (InputStream jmsBytesMessageInputStream = getInputStream(gzip)) { messageReader.read(jmsBytesMessageInputStream); } catch (IOException e) { throw new IllegalStateException(e); } } } JMSMessage(
SerializationManager serializationManager,
javax.jms.Message msg,
BlobStoreAPI blobStoreAPI,
boolean logMessageWhileReading,
boolean gzip); @Override String getMessageHeader(String headerName); @Override Map<String, String> getMessageHeaders(); @Override String getContextValue(String key); @Override Map<String, String> getMessageContext(); @Override void readMessage(final MessageReader messageReader); @Override Object getUnderlyingMessageObject(); @Override T readObject(Class<T> format); } | @Test public void testThatWeGetGZipStream() throws Exception { try (ByteArrayOutputStream bstream = new ByteArrayOutputStream()) { try (GZIPOutputStream out = new GZIPOutputStream(bstream)) { out.write("{\"a\":1}".getBytes("UTF-8")); out.finish(); JMSMessage jmsMsg = new JMSMessage( new SerializationManagerImpl(), new TestMessage(bstream.toByteArray()), null, false, true); jmsMsg.readMessage(in -> assertTrue(in instanceof GZIPInputStream)); } } }
@Test public void testThatWeGetLoggingStream() throws Exception { try (ByteArrayOutputStream bstream = new ByteArrayOutputStream()) { try (GZIPOutputStream out = new GZIPOutputStream(bstream)) { out.write("{\"a\":1}".getBytes("UTF-8")); out.finish(); JMSMessage jmsMsg = new JMSMessage( new SerializationManagerImpl(), new TestMessage(bstream.toByteArray()), null, true, true); jmsMsg.readMessage(in -> assertTrue(in instanceof LoggingInputStream)); } } }
@Test public void testThatWeGetNormalStream() throws Exception { Message msg = new TestMessage("{\"a\":1}".getBytes("UTF-8")); JMSMessage jmsMsg = new JMSMessage(new SerializationManagerImpl(), msg, null, true, false); jmsMsg.readMessage(in -> assertFalse(in instanceof GZIPInputStream)); } |
SavedImageRepositoryImpl extends AbstractHubRepositoryImpl implements SavedImageRepository, ServiceLifecycle { @Override public Collection<DBSavedImage> list() { return nqs.getList(SQL_SELECT, this::convertRow); } SavedImageRepositoryImpl(); SavedImageRepositoryImpl(DataSource dataSource); @Override void init(Context context); @Override void pause(); @Override void resume(); @Override void shutDown(); @Override DBSavedImage get(UUID savedImageId); @Override Collection<DBSavedImage> findByAppTemplateId(UUID appTemplateId); @Override void add(DBSavedImage savedImage); @Override Collection<DBSavedImage> list(); @Override void updateImageState(UUID savedImageId, DBSavedImage.DBSavedImageState state); } | @Test public void testCreate() throws DuplicateResourceException { UUID id = UUID.randomUUID(); final DBSavedImage newImage = createAndVerify(id, "my Image"); final Collection<DBSavedImage> list = savedImageRepository.list(); Assert.assertEquals("Must be exactly one template", 1, list.size()); final DBSavedImage fromList = list.iterator().next(); Assert.assertNotNull(fromList); assertEquals(newImage, fromList); } |
SchemaBootstrapScript { @NoJavadoc public Reader getScriptReader() throws IOException { StringReader reader; if (scriptContent != null) { reader = new StringReader(scriptContent.toString()); } else { InputStream resourceAsStream = Objects.requireNonNull( this.getClass().getClassLoader().getResourceAsStream(resourceLocation), "Invalid resource path provided for sql file, resource could not be located: " + resourceLocation); reader = new StringReader(IOUtils.toString(resourceAsStream)); } return reader; } SchemaBootstrapScript(String resourceLocation, String description, int schemaVersion); SchemaBootstrapScript(StringBuilder scriptContent, String description, int schemaVersion); String getDescription(); int getSchemaVersion(); @NoJavadoc Reader getScriptReader(); } | @Test public void testGetScriptReaderFromFile() throws Exception { schemaBootstrapScript = new SchemaBootstrapScript("test.sql", "test", 1); final Reader reader = schemaBootstrapScript.getScriptReader(); final List<String> lines = IOUtils.readLines(reader); assertTrue(reader instanceof StringReader); assertTrue(lines.equals(Arrays.asList(EXPECTED.split("\n")))); }
@Test public void testGetScriptReaderFromStringBuilder() throws Exception { final StringBuilder stringBuilder = new StringBuilder(EXPECTED); schemaBootstrapScript = new SchemaBootstrapScript(stringBuilder, "test", 1); final Reader reader = schemaBootstrapScript.getScriptReader(); assertTrue(reader instanceof StringReader); assertEquals(EXPECTED, IOUtils.toString(reader)); } |
Timer { public Collection<String> list() { return jobs.keySet(); } Timer(String name, MetricsRegistry registry); void add(String name, Runnable runnable, int seconds, Date nextRun); void add(String name, Runnable runnable, int seconds); void remove(String name); Collection<String> list(); void pause(); void resume(); void stop(); void start(); } | @Test public void testThatTimerSupportsAddingTasks() { Assert.assertTrue(timer.list().contains(TASK1)); Assert.assertTrue(timer.list().contains(TASK2)); } |
Timer { public void start() { executor.execute(this::process); } Timer(String name, MetricsRegistry registry); void add(String name, Runnable runnable, int seconds, Date nextRun); void add(String name, Runnable runnable, int seconds); void remove(String name); Collection<String> list(); void pause(); void resume(); void stop(); void start(); } | @Test public void testThatTasksRunCorrectNumberOfTimes() throws Exception { timer.start(); Thread.sleep(5 * 1000); Assert.assertEquals(3, sensing.get(TASK1).size()); Assert.assertEquals(2, sensing.get(TASK2).size()); }
@Test public void testThatMetricsIsUpdated() throws Exception { timer.start(); Thread.sleep(5 * 1000); Assert.assertEquals(2, registry.getRegistry().getTimers().size()); } |
RabbitMQMessageReceiver extends QueueReceiverImpl<RabbitMQQueueConfiguration> { void handleDelivery( QueueingConsumer queueingConsumer, Channel channel, BlobStoreAPI blobStoreAPI, Logger log, ManagedMessageListener listener, Context context, SerializationManager serializationManager, boolean shouldGzip, boolean shouldLogMessageContent, List<String> deadLetterQueues, Map<String, RabbitMQQueueConfiguration> deadLetterQueueConfigurations) { try { QueueingConsumer.Delivery delivery = null; RabbitMQMessage message = null; try { delivery = queueingConsumer.nextDelivery(); message = new RabbitMQMessage(serializationManager, delivery, blobStoreAPI, shouldGzip, shouldLogMessageContent); if (message.isFailed()) { listener.onErrorMessage(message, context); return; } listener.onMessage(message, context); channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false); } catch (NullPointerException e) { if (delivery == null) { log.warn("Unable to process message. Will wait for redelivery.", e); return; } log.warn("Unable to process message. Message will be rejected.", e); channel.basicNack(delivery.getEnvelope().getDeliveryTag(), false, false); message.addErrorMessageHeader( context.getMicroServiceBaseURI(), System.currentTimeMillis(), 500, e.getMessage()); message.setFailed(true); listener.onErrorMessage(message, context); } catch (Exception e) { if (message == null) { log.warn("Unable to process message. Will wait for redelivery.", e); return; } message.addErrorMessageHeader( context.getMicroServiceBaseURI(), System.currentTimeMillis(), 500, e.getMessage()); if (delivery == null) { log.warn("Unable to process message. Will wait for redelivery.", e); return; } List<RabbitMQMessage.XDeath> deaths = message.getXDeaths(); if (!delivery.getEnvelope().isRedeliver() && deaths.isEmpty()) { log.warn("Unable to process message. Message will be immediately re-queued.", e); channel.basicNack(delivery.getEnvelope().getDeliveryTag(), false, true); return; } if (deadLetterQueues.isEmpty()) { log.warn("Unable to process message. Message will be rejected.", e); channel.basicNack(delivery.getEnvelope().getDeliveryTag(), false, false); message.setFailed(true); listener.onErrorMessage(message, context); return; } if (deaths.isEmpty()) { RabbitMQQueueConfiguration queue = deadLetterQueueConfigurations.get(deadLetterQueues.get(0)); String exchange = queue.getExchangeName(); String routingKey = queue.getQueueName(); log.warn("Unable to process message. Message will be routed to dead letter queue '" + routingKey + "' bound to exchange '" + exchange + "'.", e); channel.basicPublish(exchange, routingKey, message.getProperties(), delivery.getBody()); channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false); return; } String lastDeadLetterQueue = deaths.get(0).getQueue(); Iterator<String> deadLetterQueuesIter = deadLetterQueues.iterator(); while (deadLetterQueuesIter.hasNext()) { RabbitMQQueueConfiguration conf = deadLetterQueueConfigurations.get(deadLetterQueuesIter.next()); if (lastDeadLetterQueue.equals(conf.getQueueName())) { if (deadLetterQueuesIter.hasNext()) { conf = deadLetterQueueConfigurations.get(deadLetterQueuesIter.next()); String exchange = conf.getExchangeName(); String routingKey = conf.getQueueName(); log.warn("Unable to process message. Message will be routed to dead letter queue '" + routingKey + "' bound to exchange '" + exchange + "'.", e); channel.basicPublish(exchange, routingKey, message.getProperties(), delivery.getBody()); channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false); return; } } } log.warn( "Unable to process message and no retry dead letter queues are left. Message will be rejected.", e); channel.basicNack(delivery.getEnvelope().getDeliveryTag(), false, false); message.setFailed(true); listener.onErrorMessage(message, context); context.getHealthCheckManager().flagAsUnhealthy("Error processing message " + e.getMessage()); } } catch (IOException e) { log.error("Error processing RabbitMQ message.", e); } } RabbitMQMessageReceiver(
RabbitMQMessagingProviderConfiguration messagingProviderConfiguration,
RabbitMQQueueConfiguration queueConfiguration,
Map<String, RabbitMQQueueConfiguration> deadLetterQueueConfigurations,
InputQueueConfiguration inputQueueConfiguration,
ManagedMessageListener messageListener,
Context context,
String consumerName); RabbitMQQueueConfiguration getQueueConfiguration(); @Override void init(); @Override void start(); @Override void pause(); @Override void cleanUp(); } | @Test public void testNonRetryableNullPointerException() throws IOException { final MessageListener messageListener = new MessageListener() { @Override public void onMessage(Message message, Context context) { throw new NullPointerException(); } @Override public void onErrorMessage(Message message, Context context) { } }; ManagedMessageListener managedMessageListener = spy(new ManagedMessageListenerImpl(context, messageListener, managedInputQueue, 0)); RabbitMQMessageReceiver receiver = new RabbitMQMessageReceiver(rabbitMQMessagingProviderConfiguration, rabbitMQQueueConfiguration, deadLetterQueueConfigurations, inputQueueConfiguration, managedMessageListener, context, "consumer1"); Channel channel = Mockito.mock(Channel.class); QueueingConsumer queueingConsumer = new QueueingConsumer(channel); queueingConsumer.handleDelivery( "consumer.tag", new Envelope(0, false, "test.exchange", "test.queue.name"), new AMQP.BasicProperties(), new byte[0]); BlobStoreAPI blobStoreAPI = Mockito.mock(BlobStoreAPI.class); receiver.handleDelivery( queueingConsumer, channel, blobStoreAPI, log, managedMessageListener, context, null, false, false, inputQueueConfiguration.getDeadLetterQueues(), deadLetterQueueConfigurations); verify(channel).basicNack(0, false, false); ArgumentCaptor<Message> messageArgumentCaptor = ArgumentCaptor.forClass(Message.class); verify(managedMessageListener).onErrorMessage(messageArgumentCaptor.capture(), eq(context)); Message message = messageArgumentCaptor.getValue(); Assert.assertEquals( "Expected failed message", "true", message.getMessageHeader(MessagingConstants.FAILED_HEADER)); Assert.assertNotNull("Expected error message", message.getMessageHeader(MessagingConstants.ERROR_HEADER)); }
@Test public void testRequeue() throws IOException { final MessageListener messageListener = new MessageListener() { @Override public void onMessage(Message message, Context context) { throw new IllegalStateException(); } @Override public void onErrorMessage(Message message, Context context) { } }; ManagedMessageListener managedMessageListener = spy(new ManagedMessageListenerImpl(context, messageListener, managedInputQueue, 0)); RabbitMQMessageReceiver receiver = new RabbitMQMessageReceiver(rabbitMQMessagingProviderConfiguration, rabbitMQQueueConfiguration, deadLetterQueueConfigurations, inputQueueConfiguration, managedMessageListener, context, "consumer1"); Channel channel = Mockito.mock(Channel.class); QueueingConsumer queueingConsumer = new QueueingConsumer(channel); queueingConsumer.handleDelivery( "consumer.tag", new Envelope(0, false, "test.exchange", "test.queue.name"), new AMQP.BasicProperties(), new byte[0]); BlobStoreAPI blobStoreAPI = Mockito.mock(BlobStoreAPI.class); receiver.handleDelivery( queueingConsumer, channel, blobStoreAPI, log, managedMessageListener, context, null, false, false, inputQueueConfiguration.getDeadLetterQueues(), deadLetterQueueConfigurations); verify(channel).basicNack(0, false, true); }
@Test public void testNonRetryableNoDeadLetterQueuesInServiceConfig() throws IOException { final MessageListener messageListener = new MessageListener() { @Override public void onMessage(Message message, Context context) { throw new IllegalStateException(); } @Override public void onErrorMessage(Message message, Context context) { } }; InputQueueConfiguration inputQueueConfiguration = new InputQueueConfiguration("test.queue.uri", 1, false, null); ManagedMessageListener managedMessageListener = spy(new ManagedMessageListenerImpl(context, messageListener, managedInputQueue, 0)); RabbitMQMessageReceiver receiver = new RabbitMQMessageReceiver(rabbitMQMessagingProviderConfiguration, rabbitMQQueueConfiguration, deadLetterQueueConfigurations, inputQueueConfiguration, managedMessageListener, context, "consumer1"); Channel channel = Mockito.mock(Channel.class); AMQP.BasicProperties basicProperties = new AMQP.BasicProperties(); QueueingConsumer queueingConsumer = new QueueingConsumer(channel); queueingConsumer.handleDelivery( "consumer.tag", new Envelope(0, true, "test.exchange", "test.queue.name"), basicProperties, new byte[0]); BlobStoreAPI blobStoreAPI = Mockito.mock(BlobStoreAPI.class); receiver.handleDelivery( queueingConsumer, channel, blobStoreAPI, log, managedMessageListener, context, null, false, false, inputQueueConfiguration.getDeadLetterQueues(), deadLetterQueueConfigurations); verify(channel).basicNack(0, false, false); ArgumentCaptor<Message> messageArgumentCaptor = ArgumentCaptor.forClass(Message.class); verify(managedMessageListener).onErrorMessage(messageArgumentCaptor.capture(), eq(context)); Message message = messageArgumentCaptor.getValue(); Assert.assertEquals( "Expected failed message", "true", message.getMessageHeader(MessagingConstants.FAILED_HEADER)); Assert.assertNotNull("Expected error message", message.getMessageHeader(MessagingConstants.ERROR_HEADER)); }
@Test public void testFirstRetry() throws IOException { final MessageListener messageListener = new MessageListener() { @Override public void onMessage(Message message, Context context) { throw new IllegalStateException(); } @Override public void onErrorMessage(Message message, Context context) { } }; ManagedMessageListener managedMessageListener = spy(new ManagedMessageListenerImpl(context, messageListener, managedInputQueue, 0)); RabbitMQMessageReceiver receiver = new RabbitMQMessageReceiver(rabbitMQMessagingProviderConfiguration, rabbitMQQueueConfiguration, deadLetterQueueConfigurations, inputQueueConfiguration, managedMessageListener, context, "consumer1"); Channel channel = Mockito.mock(Channel.class); AMQP.BasicProperties basicProperties = new AMQP.BasicProperties(); QueueingConsumer queueingConsumer = new QueueingConsumer(channel); queueingConsumer.handleDelivery( "consumer.tag", new Envelope(0, true, "test.exchange", "test.queue.name"), basicProperties, new byte[0]); BlobStoreAPI blobStoreAPI = Mockito.mock(BlobStoreAPI.class); receiver.handleDelivery( queueingConsumer, channel, blobStoreAPI, log, managedMessageListener, context, null, false, false, inputQueueConfiguration.getDeadLetterQueues(), deadLetterQueueConfigurations); ArgumentCaptor<AMQP.BasicProperties> propertiesCaptor = ArgumentCaptor.forClass(AMQP.BasicProperties.class); verify(channel).basicPublish(eq("test.dle"), eq("test.dlq1.name"), propertiesCaptor.capture(), eq(new byte[0])); AMQP.BasicProperties actualProperties = propertiesCaptor.getValue(); Assert.assertTrue( "Expected ERROR header not found", actualProperties.getHeaders().containsKey(MessagingConstants.ERROR_HEADER)); verify(channel).basicAck(0, false); verify(managedMessageListener, Mockito.never()).onErrorMessage(any(Message.class), eq(context)); }
@Test public void testSecondRetry() throws IOException { final MessageListener messageListener = new MessageListener() { @Override public void onMessage(Message message, Context context) { throw new IllegalStateException(); } @Override public void onErrorMessage(Message message, Context context) { throw new IllegalStateException(); } }; ManagedMessageListener managedMessageListener = spy(new ManagedMessageListenerImpl(context, messageListener, managedInputQueue, 0)); RabbitMQMessageReceiver receiver = new RabbitMQMessageReceiver(rabbitMQMessagingProviderConfiguration, rabbitMQQueueConfiguration, deadLetterQueueConfigurations, inputQueueConfiguration, managedMessageListener, context, "consumer1"); Channel channel = Mockito.mock(Channel.class); AMQP.BasicProperties.Builder basicPropertiesBuilder = new AMQP.BasicProperties.Builder(); Map<String, Object> xDeath = new HashMap<>(); xDeath.put("reason", "expired"); xDeath.put("count", 1L); xDeath.put("exchange", "test.dle"); xDeath.put("time", new Date(System.currentTimeMillis())); xDeath.put("routing-keys", Arrays.asList("test.dlq1.name")); xDeath.put("queue", "test.dlq1.name"); List<Object> xDeaths = new ArrayList<>(); xDeaths.add(xDeath); Map<String, Object> headers = new HashMap<>(); headers.put("x-death", xDeaths); basicPropertiesBuilder.headers(headers); AMQP.BasicProperties basicProperties = basicPropertiesBuilder.build(); QueueingConsumer queueingConsumer = new QueueingConsumer(channel); queueingConsumer.handleDelivery( "consumer.tag", new Envelope(0, true, "test.exchange", "test.queue.name"), basicProperties, new byte[0]); BlobStoreAPI blobStoreAPI = Mockito.mock(BlobStoreAPI.class); receiver.handleDelivery( queueingConsumer, channel, blobStoreAPI, log, managedMessageListener, context, null, false, false, inputQueueConfiguration.getDeadLetterQueues(), deadLetterQueueConfigurations); ArgumentCaptor<AMQP.BasicProperties> propertiesCaptor = ArgumentCaptor.forClass(AMQP.BasicProperties.class); verify(channel).basicPublish(eq("test.dle"), eq("test.dlq2.name"), propertiesCaptor.capture(), eq(new byte[0])); AMQP.BasicProperties actualProperties = propertiesCaptor.getValue(); Assert.assertTrue( "Expected ERROR header not found", actualProperties.getHeaders().containsKey(MessagingConstants.ERROR_HEADER)); verify(channel).basicAck(0, false); verify(managedMessageListener, Mockito.never()).onErrorMessage(any(Message.class), eq(context)); }
@Test public void testFinalRetry() throws IOException { final MessageListener messageListener = new MessageListener() { @Override public void onMessage(Message message, Context context) { throw new IllegalStateException(); } @Override public void onErrorMessage(Message message, Context context) { } }; ManagedMessageListener managedMessageListener = spy(new ManagedMessageListenerImpl(context, messageListener, managedInputQueue, 0)); RabbitMQMessageReceiver receiver = new RabbitMQMessageReceiver(rabbitMQMessagingProviderConfiguration, rabbitMQQueueConfiguration, deadLetterQueueConfigurations, inputQueueConfiguration, managedMessageListener, context, "consumer1"); Channel channel = Mockito.mock(Channel.class); AMQP.BasicProperties.Builder basicPropertiesBuilder = new AMQP.BasicProperties.Builder(); List<Object> xDeaths = new ArrayList<>(); Map<String, Object> xDeath = new HashMap<>(); xDeath.put("reason", "expired"); xDeath.put("count", 1L); xDeath.put("exchange", "test.dle"); xDeath.put("time", new Date(System.currentTimeMillis())); xDeath.put("routing-keys", Arrays.asList("test.dlq2.name")); xDeath.put("queue", "test.dlq2.name"); xDeaths.add(xDeath); xDeath = new HashMap<>(); xDeath.put("reason", "expired"); xDeath.put("count", 1L); xDeath.put("exchange", "test.dle"); xDeath.put("time", new Date(System.currentTimeMillis())); xDeath.put("routing-keys", Arrays.asList("test.dlq1.name")); xDeath.put("queue", "test.dlq1.name"); xDeaths.add(xDeath); Map<String, Object> headers = new HashMap<>(); headers.put("x-death", xDeaths); basicPropertiesBuilder.headers(headers); AMQP.BasicProperties basicProperties = basicPropertiesBuilder.build(); QueueingConsumer queueingConsumer = new QueueingConsumer(channel); queueingConsumer.handleDelivery( "consumer.tag", new Envelope(0, true, "test.exchange", "test.queue.name"), basicProperties, new byte[0]); BlobStoreAPI blobStoreAPI = Mockito.mock(BlobStoreAPI.class); receiver.handleDelivery( queueingConsumer, channel, blobStoreAPI, log, managedMessageListener, context, null, false, false, inputQueueConfiguration.getDeadLetterQueues(), deadLetterQueueConfigurations); verify(channel).basicNack(0, false, false); ArgumentCaptor<Message> messageArgumentCaptor = ArgumentCaptor.forClass(Message.class); verify(managedMessageListener).onErrorMessage(messageArgumentCaptor.capture(), eq(context)); Message message = messageArgumentCaptor.getValue(); Assert.assertEquals( "Expected failed message", "true", message.getMessageHeader(MessagingConstants.FAILED_HEADER)); Assert.assertNotNull("Expected error message", message.getMessageHeader(MessagingConstants.ERROR_HEADER)); } |
MicroServiceStateResource extends MicroServiceResource implements MicroServiceStateAPI { @Override public ServiceState getServiceState() { Context context = getMicroServiceApplication().getMicroServiceContext(); List<ServiceState.InputQueueState> inputQueues = new ArrayList<>(); ResourceManager<InputQueueDescriptor, InputQueueConfiguration, ManagedInputQueue> queuesManager = context.getQueuesManager(); List<ManagedInputQueue> managedQueuesStats = queuesManager.getManagedResources(); if (!managedQueuesStats.isEmpty()) { for (ManagedInputQueue currManagedQueue : managedQueuesStats) { List<ServiceState.InputQueueReceiver> receivers = new ArrayList<>(); if (!currManagedQueue.getReceivers().isEmpty()) { for (QueueReceiver currReceiver : currManagedQueue.getReceivers()) { QueueExecutionState currState = ((QueueReceiverImpl) currReceiver).getMessageListener().getQueueExecutionState(); QueueExecutionState.ReceiverRunningState state = currState.getState(); Date lastExecutionTime = null; Date currExecutionStartTime = null; Map<String, String> properties = null; switch (state) { case RUNNING: currExecutionStartTime = new Date(currState.getExecutionStartTime()); Map<String, String> headers = currState.getHeaders(); if (!headers.isEmpty()) { properties = new HashMap<>(headers); } break; case IDLE: Long executionEndTime = currState.getExecutionEndTime(); if (executionEndTime != null) { lastExecutionTime = new Date(executionEndTime); } break; default: break; } receivers.add(new ServiceState.InputQueueReceiver( currState.getState().name(), currState.getInitializedDate(), lastExecutionTime, currExecutionStartTime, properties)); } } inputQueues.add(new ServiceState.InputQueueState(currManagedQueue.getQueueName(), receivers)); } } final StaticObjectMetric<RestCallInfo> restCallInfoStaticObjectMetric = context.getMetricsRegistry().getStaticObjectMetric(RestCallInfo.class); final long currentTimeMillis = System.currentTimeMillis(); return new ServiceState( context.getMicroServiceName(), ServiceState.ServiceStateEnum.valueOf(context.getServiceState().name()), context.getLogger().getName(), inputQueues, restCallInfoStaticObjectMetric.list() .stream() .map((i) -> new ServiceState.RestRequestState( i.getMethod(), i.getUrl(), currentTimeMillis - i.getStartTime().getTime())) .collect(Collectors.toList()) ); } @Override ServiceState getServiceState(); } | @Test public void getServiceState() throws URISyntaxException, IOException { final MockHttpResponse response = get(MicroServiceStateAPI.BASE_URI, MediaType.APPLICATION_JSON_TYPE); assertEquals(HttpStatus.SC_OK, response.getStatus()); final Map<String, ?> json = json(response); assertEquals("Mock Micro Service", json.get("name")); assertEquals("RUNNING", json.get("state")); } |
RabbitMQMessage implements Message { @Override public void readMessage(final MessageReader messageReader) { if (blobstoreApi != null) { BlobStoreLink blobStoreLink = MessagingSerializationHelper.readObject( serializationManager, BlobStoreLink.class, delivery.getBody()); if (blobstoreApi.isExists(blobStoreLink.getNamespace(), blobStoreLink.getKey())) { blobstoreApi.readBlob(blobStoreLink.getNamespace(), blobStoreLink.getKey(), in -> { if (gzip) { try (GZIPInputStream gzipInputStream = new GZIPInputStream(in)) { messageReader.read(gzipInputStream); } catch (IOException e) { throw new IllegalStateException(e); } } else { messageReader.read(in); } }); } else { throw new IllegalStateException( "Failed reading message with id (id doesn't exist)" + blobStoreLink.getNamespace() + ':' + blobStoreLink.getKey()); } } else { byte[] body = delivery.getBody(); try (InputStream stream = getInputStream(body)) { messageReader.read(stream); } catch (IOException e) { throw new IllegalStateException(e); } } } RabbitMQMessage(
SerializationManager serializationManager, QueueingConsumer.Delivery delivery,
BlobStoreAPI blobstoreApi, boolean gzip,
boolean logMessageWhileReading); @Override String getMessageHeader(String headerName); void addErrorMessageHeader(String microserviceURI, long timestamp, int errorCode, String errorMessage); void setFailed(boolean failed); boolean isFailed(); @Override Map<String, String> getMessageHeaders(); @Override Map<String, String> getMessageContext(); @Override String getContextValue(String key); @Override void readMessage(final MessageReader messageReader); @Override Object getUnderlyingMessageObject(); @Override T readObject(Class<T> format); List<XDeath> getXDeaths(); @NoJavadoc static String getNamespace(String blobstoreNamespace, String exchange, String queue); @NoJavadoc AMQP.BasicProperties getProperties(); } | @Test public void testThatWeGetGZipStreamForCompressedData() throws Exception { try (ByteArrayOutputStream s = new ByteArrayOutputStream()) { try (GZIPOutputStream out = new GZIPOutputStream(s)) { out.write(data); out.finish(); QueueingConsumer.Delivery delivery = new QueueingConsumer.Delivery(null, null, s.toByteArray()); RabbitMQMessage mqMsg = new RabbitMQMessage(new SerializationManagerImpl(), delivery, null, true, false); mqMsg.readMessage(in -> assertTrue(in instanceof GZIPInputStream)); } } }
@Test public void testThatWeGetNormalStreamForUncompressedData() throws Exception { QueueingConsumer.Delivery delivery = new QueueingConsumer.Delivery(null, null, data); RabbitMQMessage mqMsg = new RabbitMQMessage(new SerializationManagerImpl(), delivery, null, false, false); mqMsg.readMessage(in -> assertFalse(in instanceof GZIPInputStream)); }
@Test public void testThatWeGetLoggingStreamForUncompressedData() throws Exception { QueueingConsumer.Delivery delivery = new QueueingConsumer.Delivery(null, null, data); RabbitMQMessage mqMsg = new RabbitMQMessage(new SerializationManagerImpl(), delivery, null, false, true); mqMsg.readMessage(in -> assertTrue(in instanceof LoggingInputStream)); }
@Test public void testThatWeGetLoggingStreamForCompressedData() throws Exception { try (ByteArrayOutputStream s = new ByteArrayOutputStream()) { try (GZIPOutputStream out = new GZIPOutputStream(s)) { out.write(data); out.finish(); QueueingConsumer.Delivery delivery = new QueueingConsumer.Delivery(null, null, s.toByteArray()); RabbitMQMessage mqMsg = new RabbitMQMessage(new SerializationManagerImpl(), delivery, null, true, true); mqMsg.readMessage(in -> assertTrue(in instanceof LoggingInputStream)); } } } |
TempFileSystemBlobStore implements BlobStore { @Override public void moveNameSpace(final String oldNamespace, final String key, final String newNamespace) throws ObjectKeyFormatException, DuplicateObjectKeyException, IllegalStoreStateException { isKeyAcceptable(key); isKeyAcceptable(oldNamespace); isKeyAcceptable(newNamespace); try { File[] files = folder.listFiles(getHeadersFilenameFilter(oldNamespace, key)); ren(files, HEADERS_PREFIX + oldNamespace + "." + key, HEADERS_PREFIX + newNamespace + "." + key + "."); files = folder.listFiles(getFilenameFilter(oldNamespace, key)); ren(files, BLOB_PREFIX + oldNamespace + "." + key, BLOB_PREFIX + newNamespace + "." + key + "."); } catch (IOException e) { throw new IllegalStoreStateException("IOException happened", e); } } TempFileSystemBlobStore(); void create(String namespace, String key, Map<String, String> headers, final InputStream blob); @Override void create(String namespace, String key, Map<String, String> headers, BlobWriter blobWriter); @Override void update(String namespace, String key, Map<String, String> headers, InputStream blob); @Override void update(String namespace, String key, Map<String, String> headers, BlobWriter blobWriter); @Override void moveNameSpace(final String oldNamespace, final String key, final String newNamespace); void ren(File[] files, String target, String replacement); @Override void readBlob(final String namespace, final String key, BlobReader reader); @Override void readBlob(final String namespace, final String key, final OutputStream out); @Override Map<String, String> readHeaders(final String namespace, final String key); @Override void delete(int expirySeconds); @Override void delete(final String namespace, final String key); FilenameFilter getHeadersFilenameFilter(String namespace, String key); FilenameFilter getFilenameFilter(String namespace, String key); @Override boolean isExists(final String namespace, final String key); @Override Collection<BlobStoreLink> list(); } | @Test public void testMoveNamespace() throws Exception { HashMap<String, String> headers = new HashMap<>(); headers.put("filename", "brain_slug.png"); headers.put("retention", "1000"); File bsImage = new File(TestTempFileSystemBlobStore.class.getClassLoader().getResource("brain_slug.png").getFile()); BlobStore bs = new TempFileSystemBlobStore(); String key = UUID.randomUUID().toString(); String originalNameSpace = "ashish"; bs.update(originalNameSpace, key, headers, new FileInputStream(bsImage)); Map<String, String> storedHeaders = bs.readHeaders(originalNameSpace, key); assertEquals( "'filename' property doesn't exists or not equals to stored metadata ", "brain_slug.png", storedHeaders.get("filename")); Assert.assertTrue(bs.isExists(originalNameSpace, key)); ByteArrayOutputStream originalByteArrayOutputStream = new ByteArrayOutputStream(); bs.readBlob(originalNameSpace, key, originalByteArrayOutputStream); assertEquals( "Stored file in blob store is not the same as received from blob store", originalByteArrayOutputStream.toByteArray().length, bsImage.length()); String newNamespace = "chen"; bs.moveNameSpace(originalNameSpace, key, newNamespace); Assert.assertTrue(bs.isExists(newNamespace, key)); Assert.assertTrue(bs.isExists(newNamespace, key)); ByteArrayOutputStream newByteArrayOutputStream = new ByteArrayOutputStream(); bs.readBlob(newNamespace, key, newByteArrayOutputStream); assertEquals( "Stored file in blob store is not the same as received from blob store", newByteArrayOutputStream.toByteArray().length, bsImage.length()); Assert.assertFalse(bs.isExists(originalNameSpace, key)); bs.delete(newNamespace, key); } |
TempFileSystemBlobStore implements BlobStore { @Override public void update(String namespace, String key, Map<String, String> headers, InputStream blob) throws ObjectKeyFormatException, IllegalStoreStateException { try { delete(namespace, key); create(namespace, key, headers, blob); } catch (DuplicateObjectKeyException e) { log.error( "Duplicate keys happened. most likely something wrong with implementation. " + "This should never happens.", e); } } TempFileSystemBlobStore(); void create(String namespace, String key, Map<String, String> headers, final InputStream blob); @Override void create(String namespace, String key, Map<String, String> headers, BlobWriter blobWriter); @Override void update(String namespace, String key, Map<String, String> headers, InputStream blob); @Override void update(String namespace, String key, Map<String, String> headers, BlobWriter blobWriter); @Override void moveNameSpace(final String oldNamespace, final String key, final String newNamespace); void ren(File[] files, String target, String replacement); @Override void readBlob(final String namespace, final String key, BlobReader reader); @Override void readBlob(final String namespace, final String key, final OutputStream out); @Override Map<String, String> readHeaders(final String namespace, final String key); @Override void delete(int expirySeconds); @Override void delete(final String namespace, final String key); FilenameFilter getHeadersFilenameFilter(String namespace, String key); FilenameFilter getFilenameFilter(String namespace, String key); @Override boolean isExists(final String namespace, final String key); @Override Collection<BlobStoreLink> list(); } | @Test public void testIllegalKey() { BlobStore bs = new TempFileSystemBlobStore(); InputStream inputStream = null; try { bs.update(".", "!", null, inputStream); assertTrue("illegal key passed as valid", false); } catch (ObjectKeyFormatException e) { assertTrue(true); } catch (IllegalStoreStateException e) { assertTrue("IllegalStoreStateException should not be thrown", false); } } |
ReadFile { public static String getFileContentsFromResource(String resourceLocation) throws IOException { ClassLoader classLoader = Thread.currentThread().getContextClassLoader(); return getFileContentsFromResource(resourceLocation, classLoader); } static String getFileContentsFromResource(String resourceLocation); static String getFileContentsFromResource(String resourceLocation, ClassLoader classLoader); static StringBuilder getFileContentsFromResourceAsStringBuilder(
String resourceLocation,
ClassLoader classLoader); static String getFileContents(File file); static StringBuilder getFileContents(InputStream inputStream); static StringBuilder getFileContents(Reader reader); } | @Test(expected = FileNotFoundException.class) public void getFileContentsFromResourceTest() throws IOException { final String result = ReadFile.getFileContentsFromResource(TESTFILE); assertNotNull(result); assertTrue(result.contains("wheezles")); ReadFile.getFileContentsFromResource(BADFILE); assertFalse(true); }
@Test(expected = FileNotFoundException.class) public void getFileContentsFromResourceWithClassloaderTest() throws IOException { final String result = ReadFile.getFileContentsFromResource(TESTFILE, Thread.currentThread().getContextClassLoader()); assertNotNull(result); assertTrue(result.contains("wheezles")); ReadFile.getFileContentsFromResource(BADFILE, Thread.currentThread().getContextClassLoader()); assertFalse(true); } |
MicroServiceMetricsResource extends MicroServiceResource implements MicroServiceMetricsAPI { @Override public Response getMetricsOutput() { StreamingOutput stream = outputStream -> mapper .writerWithDefaultPrettyPrinter() .writeValue(outputStream, getMicroServiceApplication().getMicroServiceContext().getMetricsRegistry()); return Response .ok(stream, MediaType.APPLICATION_JSON_TYPE) .header("Cache-Control", "must-revalidate,no-cache,no-store") .build(); } MicroServiceMetricsResource(); @Override Response getMetricsOutput(); @Override Map<String, List> getDsMetrics(@PathParam("ds") String ds); } | @Test @SuppressWarnings("unchecked") public void getMetricsOutput() throws URISyntaxException, IOException { final MockHttpResponse response = get(MicroServiceMetricsAPI.BASE_URI, MediaType.APPLICATION_JSON_TYPE); assertEquals(HttpStatus.SC_OK, response.getStatus()); final Map<String, ?> json = json(response); System.out.println(json); assertEquals("mock-api", json.get("name")); final Map<String, ?> metrics = (Map<String, ?>) json.get("metrics"); assertEquals("3.0.0", metrics.get("version")); } |
ReadFile { public static StringBuilder getFileContentsFromResourceAsStringBuilder( String resourceLocation, ClassLoader classLoader) throws IOException { InputStream inputStream = classLoader.getResourceAsStream(resourceLocation); if (inputStream == null) { throw new FileNotFoundException("Could not find resource file at path '" + resourceLocation + "'"); } return getFileContents(inputStream); } static String getFileContentsFromResource(String resourceLocation); static String getFileContentsFromResource(String resourceLocation, ClassLoader classLoader); static StringBuilder getFileContentsFromResourceAsStringBuilder(
String resourceLocation,
ClassLoader classLoader); static String getFileContents(File file); static StringBuilder getFileContents(InputStream inputStream); static StringBuilder getFileContents(Reader reader); } | @Test public void getFileContentsFromResourceAsStringBuilderTest() throws IOException { final StringBuilder sb = ReadFile.getFileContentsFromResourceAsStringBuilder( TESTFILE, Thread.currentThread().getContextClassLoader()); assertFalse(sb.length() == 0); } |
CountingReader extends Reader { @Override public boolean ready() throws IOException { return delegate.ready(); } CountingReader(Reader delegate); @Override int read(CharBuffer target); @Override int read(); @Override int read(char[] cbuf, int off, int len); @Override long skip(long n); @Override boolean ready(); @Override boolean markSupported(); @Override void mark(int readAheadLimit); @Override void reset(); @Override void close(); int getCharCount(); } | @Test public void ready() throws IOException { when(delegate.ready()).thenReturn(true); assertTrue(cut.ready()); verify(delegate).ready(); } |
CountingReader extends Reader { @Override public boolean markSupported() { return false; } CountingReader(Reader delegate); @Override int read(CharBuffer target); @Override int read(); @Override int read(char[] cbuf, int off, int len); @Override long skip(long n); @Override boolean ready(); @Override boolean markSupported(); @Override void mark(int readAheadLimit); @Override void reset(); @Override void close(); int getCharCount(); } | @Test public void markSupported() { assertFalse(cut.markSupported()); } |
CountingReader extends Reader { @Override public void mark(int readAheadLimit) throws IOException { throw new IOException("mark() not supported"); } CountingReader(Reader delegate); @Override int read(CharBuffer target); @Override int read(); @Override int read(char[] cbuf, int off, int len); @Override long skip(long n); @Override boolean ready(); @Override boolean markSupported(); @Override void mark(int readAheadLimit); @Override void reset(); @Override void close(); int getCharCount(); } | @Test(expected = IOException.class) public void mark() throws IOException { cut.mark(1000); } |
CountingReader extends Reader { @Override public void reset() throws IOException { throw new IOException("reset() not supported"); } CountingReader(Reader delegate); @Override int read(CharBuffer target); @Override int read(); @Override int read(char[] cbuf, int off, int len); @Override long skip(long n); @Override boolean ready(); @Override boolean markSupported(); @Override void mark(int readAheadLimit); @Override void reset(); @Override void close(); int getCharCount(); } | @Test(expected = IOException.class) public void reset() throws IOException { cut.reset(); } |
CountingReader extends Reader { @Override public void close() throws IOException { delegate.close(); } CountingReader(Reader delegate); @Override int read(CharBuffer target); @Override int read(); @Override int read(char[] cbuf, int off, int len); @Override long skip(long n); @Override boolean ready(); @Override boolean markSupported(); @Override void mark(int readAheadLimit); @Override void reset(); @Override void close(); int getCharCount(); } | @Test public void close() throws IOException { cut.close(); verify(delegate).close(); } |
CountingReader extends Reader { public int getCharCount() { return charCount; } CountingReader(Reader delegate); @Override int read(CharBuffer target); @Override int read(); @Override int read(char[] cbuf, int off, int len); @Override long skip(long n); @Override boolean ready(); @Override boolean markSupported(); @Override void mark(int readAheadLimit); @Override void reset(); @Override void close(); int getCharCount(); } | @Test public void getCharCountWithNoCharactersRead() { assertEquals(0, cut.getCharCount()); } |
PrefixReader extends Reader { @Override public int read(CharBuffer target) throws IOException { int len = target.remaining(); int remainingInPrefix = prefix.length - prefixLocation; if (remainingInPrefix >= len) { target.put(prefix, prefixLocation, len); prefixLocation += len; return len; } if (remainingInPrefix > 0) { target.put(prefix, prefixLocation, remainingInPrefix); prefixLocation = prefix.length; } int readFromDelegate = delegate.read(target); if (remainingInPrefix > 0 && readFromDelegate < 0) { return remainingInPrefix; } return remainingInPrefix + readFromDelegate; } PrefixReader(char[] prefix, Reader delegate); PrefixReader(Object lock, char[] prefix, Reader delegate); @Override int read(CharBuffer target); @Override int read(); @Override int read(char[] cbuf, int off, int len); @Override long skip(long n); @Override boolean ready(); @Override boolean markSupported(); @Override void mark(int readAheadLimit); @Override void reset(); @Override void close(); } | @Test public void read() throws Exception { assertEquals('p', cut.read()); assertEquals('r', cut.read()); assertEquals('e', cut.read()); assertEquals('f', cut.read()); assertEquals('i', cut.read()); assertEquals('x', cut.read()); assertEquals('s', cut.read()); assertEquals('o', cut.read()); assertEquals('m', cut.read()); assertEquals('e', cut.read()); assertEquals('S', cut.read()); assertEquals('t', cut.read()); assertEquals('r', cut.read()); assertEquals('i', cut.read()); assertEquals('n', cut.read()); assertEquals('g', cut.read()); assertEquals(-1, cut.read()); }
@Test public void readWithLockConstructor() throws IOException { final Object lock = new Object(); final PrefixReader cut = new PrefixReader(lock, prefix, delegate); assertEquals('p', cut.read()); assertEquals('r', cut.read()); assertEquals('e', cut.read()); }
@Test public void readWithLargeCharBuffer() throws IOException { final CharBuffer buffer = CharBuffer.allocate(20); assertEquals(DEFAULT_TOTAL, cut.read(buffer)); buffer.flip(); assertEquals(DEFAULT_COMBINED, buffer.toString()); }
@Test public void readWithLargeCharArray() throws IOException { final char[] buffer = new char[20]; final int read = cut.read(buffer); assertEquals(DEFAULT_TOTAL, read); assertEquals(DEFAULT_COMBINED, String.valueOf(buffer, 0, read)); }
@Test public void readWithLargeCharBufferAndEmptyDelegate() throws IOException { final PrefixReader cut = new PrefixReader(prefix, new StringReader("")); final CharBuffer buffer = CharBuffer.allocate(20); assertEquals(DEFAULT_PREFIX.length(), cut.read(buffer)); buffer.flip(); assertEquals(DEFAULT_PREFIX, buffer.toString()); }
@Test public void readWithLargeCharArrayAndEmptyDelegate() throws IOException { final PrefixReader cut = new PrefixReader(prefix, new StringReader("")); final char[] buffer = new char[20]; int read; assertEquals(DEFAULT_PREFIX.length(), read = cut.read(buffer)); assertEquals(DEFAULT_PREFIX, String.valueOf(buffer, 0, read)); }
@Test public void readWithSmallCharBuffer() throws IOException { final int capacity = 3; final CharBuffer buffer = CharBuffer.allocate(capacity); assertEquals(capacity, cut.read(buffer)); buffer.flip(); assertEquals("pre", buffer.toString()); }
@Test public void readWithSmallCharArray() throws IOException { final int capacity = 3; final char[] buffer = new char[capacity]; final int read = cut.read(buffer); assertEquals(capacity, read); assertEquals("pre", String.valueOf(buffer, 0, read)); }
@Test public void readWithExactCharBuffer() throws IOException { final int capacity = DEFAULT_PREFIX.length(); final CharBuffer buffer = CharBuffer.allocate(capacity); assertEquals(capacity, cut.read(buffer)); buffer.clear(); assertEquals(capacity, cut.read(buffer)); assertEquals("someSt", buffer.flip().toString()); }
@Test public void readWithExactCharArray() throws IOException { final int capacity = DEFAULT_PREFIX.length(); final char[] buffer = new char[capacity]; int read; assertEquals(capacity, read = cut.read(buffer)); assertEquals(capacity, read = cut.read(buffer)); assertEquals("someSt", String.valueOf(buffer, 0, read)); }
@Test public void readWithExactCharBufferAndEmptyDelegate() throws IOException { final PrefixReader cut = new PrefixReader(prefix, new StringReader("")); final int capacity = DEFAULT_PREFIX.length(); final CharBuffer buffer = CharBuffer.allocate(capacity); assertEquals(capacity, cut.read(buffer)); buffer.clear(); assertEquals(-1, cut.read(buffer)); }
@Test public void readWithExactCharArrayAndEmptyDelegate() throws IOException { final PrefixReader cut = new PrefixReader(prefix, new StringReader("")); final int capacity = DEFAULT_PREFIX.length(); final char[] buffer = new char[capacity]; assertEquals(capacity, cut.read(buffer)); assertEquals(-1, cut.read(buffer)); } |
MicroServiceConfigurationResource extends MicroServiceResource implements MicroServiceConfigurationAPI { @Override public ServiceConfiguration getServiceConfiguration() { Context context = getMicroServiceApplication().getMicroServiceContext(); LoggerConfig loggerConfig = getLoggerConfig(context); List<ResourceConfig> inputQueues = getResourceConfigs(context.getQueuesManager().getManagedResources()); List<ResourceConfig> datasources = getResourceConfigs(context.getDatasourceManager().getManagedResources()); List<ResourceConfig> destinations = getResourceConfigs(context.getDestinationManager().getManagedResources()); List<ResourceConfig> blobStores = getResourceConfigs(context.getBlobStoreManager().getManagedResources()); List<ResourceConfig> serviceDependencies = getDependencyConfigs(context.getDependencyManager().getManagedResources()); List<ResourceConfig> externalResources = new ArrayList<>(); for (ResourceManager currExternalResourceManager : context.getExternalResourceManagers()) { externalResources.addAll(getResourceConfigs(currExternalResourceManager.getManagedResources())); } List<ParamConfig> paramsConfig = getParamConfigs(context); return new ServiceConfiguration( context.getMicroServiceName(), context.getServiceDescription(), context.getMicroServiceBaseURI(), loggerConfig, inputQueues, datasources, destinations, blobStores, serviceDependencies, externalResources, paramsConfig ); } @Override ServiceConfiguration getServiceConfiguration(); @Override Response setLogLevel(); } | @Test @SuppressWarnings("unchecked") public void getServiceConfiguration() throws URISyntaxException, IOException { final MockHttpResponse response = get(MicroServiceConfigurationAPI.BASE_URI, MediaType.APPLICATION_JSON_TYPE); assertEquals(HttpStatus.SC_OK, response.getStatus()); final Map<String, ?> json = json(response); assertEquals("Mock Micro Service", json.get("name")); assertEquals(VERSION_NOT_AVAILABLE, json.get("version")); final List<Map<String, ?>> parameters = (List<Map<String, ?>>) json.get("parameters"); assertEquals("Expected 2 parameters, boo-timeout and health-check-period-in-seconds", 3, parameters.size()); } |
PrefixReader extends Reader { @Override public boolean markSupported() { return false; } PrefixReader(char[] prefix, Reader delegate); PrefixReader(Object lock, char[] prefix, Reader delegate); @Override int read(CharBuffer target); @Override int read(); @Override int read(char[] cbuf, int off, int len); @Override long skip(long n); @Override boolean ready(); @Override boolean markSupported(); @Override void mark(int readAheadLimit); @Override void reset(); @Override void close(); } | @Test public void markSupported() throws IOException { assertFalse(cut.markSupported()); } |
ManagedMessageListenerImpl implements ManagedMessageListener { private void handleMessage(Message message, Context context, boolean isError) { ContextThreadLocal.setContext(context); Thread currentThread = Thread.currentThread(); String origThreadName = currentThread.getName(); MessageLoggingContext messageLoggingContext = buildMessageLoggingContext(message); Map<String, String> messageHeaderValuesForLogging = messageLoggingContext.getMessageHeaderValuesForLogging(); if (logger.isDebugEnabled()) { logger.debug("currentThread {}", currentThread); logger.debug("origThreadName {}", origThreadName); messageHeaderValuesForLogging.values().forEach(logger::debug); } try (CounterMetric autoCounter = activeJobs.inc(); StopWatch stopWatch = messageProcessingTimer.getStopWatch( new MapMetricState(messageHeaderValuesForLogging))) { queueExecutionState.setExecutionState(messageHeaderValuesForLogging); currentThread.setName(messageLoggingContext.getThreadName()); if (logger.isDebugEnabled()) { logger.debug("Executing message listener"); } if (isError) { handleErrorMessage(message, context); } else { messageListener.onMessage(message, context); } if (logger.isDebugEnabled()) { logger.debug("Done executing message listener"); } } catch (Exception ex) { logger.warn("Error while processing message. {}", ex.getMessage()); errorCounter.inc(); throw ex; } finally { try { queueExecutionState.clearExecutionState(); } finally { currentThread.setName(origThreadName); } } } ManagedMessageListenerImpl(
Context context,
MessageListener messageListener,
ManagedInputQueue managedQueue,
int threadOrdinal); @Override void onMessage(Message message, Context context); @Override void onErrorMessage(Message message, Context context); QueueExecutionState getQueueExecutionState(); } | @Test public void testHandleMessage() { Message message = mock(Message.class); managedMessageListener.onMessage(message, context); verify(messageListener).onMessage(eq(message), eq(context)); } |
PrefixReader extends Reader { @Override public void mark(int readAheadLimit) throws IOException { throw new IOException("mark() not supported"); } PrefixReader(char[] prefix, Reader delegate); PrefixReader(Object lock, char[] prefix, Reader delegate); @Override int read(CharBuffer target); @Override int read(); @Override int read(char[] cbuf, int off, int len); @Override long skip(long n); @Override boolean ready(); @Override boolean markSupported(); @Override void mark(int readAheadLimit); @Override void reset(); @Override void close(); } | @Test(expected = IOException.class) public void mark() throws Exception { cut.mark(0); } |
PrefixReader extends Reader { @Override public void reset() throws IOException { throw new IOException("reset() not supported"); } PrefixReader(char[] prefix, Reader delegate); PrefixReader(Object lock, char[] prefix, Reader delegate); @Override int read(CharBuffer target); @Override int read(); @Override int read(char[] cbuf, int off, int len); @Override long skip(long n); @Override boolean ready(); @Override boolean markSupported(); @Override void mark(int readAheadLimit); @Override void reset(); @Override void close(); } | @Test(expected = IOException.class) public void reset() throws Exception { cut.reset(); } |
PrefixReader extends Reader { @Override public void close() throws IOException { delegate.close(); } PrefixReader(char[] prefix, Reader delegate); PrefixReader(Object lock, char[] prefix, Reader delegate); @Override int read(CharBuffer target); @Override int read(); @Override int read(char[] cbuf, int off, int len); @Override long skip(long n); @Override boolean ready(); @Override boolean markSupported(); @Override void mark(int readAheadLimit); @Override void reset(); @Override void close(); } | @Test public void close() throws Exception { final Reader mockDelegate = Mockito.mock(Reader.class); final PrefixReader cut = new PrefixReader(prefix, mockDelegate); cut.close(); verify(mockDelegate).close(); } |
PrefixReader extends Reader { @Override public boolean ready() throws IOException { return delegate.ready(); } PrefixReader(char[] prefix, Reader delegate); PrefixReader(Object lock, char[] prefix, Reader delegate); @Override int read(CharBuffer target); @Override int read(); @Override int read(char[] cbuf, int off, int len); @Override long skip(long n); @Override boolean ready(); @Override boolean markSupported(); @Override void mark(int readAheadLimit); @Override void reset(); @Override void close(); } | @Test public void ready() throws Exception { final Reader mockDelegate = Mockito.mock(Reader.class); final PrefixReader cut = new PrefixReader(prefix, mockDelegate); cut.ready(); verify(mockDelegate).ready(); } |
EscapingReader extends Reader { @Override public int read() throws IOException { int fromDelegate = delegate.read(); if (fromDelegate < 0) { return fromDelegate; } char c = (char) fromDelegate; while (invalidCharsPattern.matcher(String.valueOf(c)).find()) { fromDelegate = delegate.read(); if (fromDelegate < 0) { return fromDelegate; } c = (char) fromDelegate; } return fromDelegate; } EscapingReader(Reader delegate); EscapingReader(Object lock, Reader delegate); @Override int read(); @Override int read(char[] cbuf, int off, int len); @Override long skip(long n); @Override boolean ready(); @Override boolean markSupported(); @Override void mark(int readAheadLimit); @Override void reset(); @Override void close(); } | @Test public void read() throws IOException { when(mockDelegate.read()).thenReturn((int) 'y', (int) 'a', (int) 'y', -1); assertEquals((int) 'y', cut.read()); assertEquals((int) 'a', cut.read()); assertEquals((int) 'y', cut.read()); assertEquals(-1, cut.read()); }
@Test public void readWithLock() throws IOException { when(mockDelegate.read()).thenReturn((int) 'y', (int) 'a', (int) 'y', -1); final Object lock = new Object(); cut = new EscapingReader(lock, mockDelegate); assertEquals((int) 'y', cut.read()); assertEquals((int) 'a', cut.read()); assertEquals((int) 'y', cut.read()); assertEquals(-1, cut.read()); }
@Test public void readWithIllegalAtEnd() throws IOException { when(mockDelegate.read()).thenReturn((int) 'y', 0x00, -1); assertEquals((int) 'y', cut.read()); assertEquals(-1, cut.read()); }
@Test public void readWithIllegalNotAtEnd() throws IOException { when(mockDelegate.read()).thenReturn((int) 'y', 0x00, (int) 'y', -1); assertEquals((int) 'y', cut.read()); assertEquals((int) 'y', cut.read()); assertEquals(-1, cut.read()); }
@Test public void readWithCharArrayAndDelegateEOF() throws IOException { when(mockDelegate.read((char[]) Mockito.anyVararg(), Mockito.anyInt(), Mockito.anyInt())).thenReturn(-1); final char[] buffer = new char[10]; assertEquals(-1, cut.read(buffer)); }
@Test public void readWithCharArrayAndLegalText() throws IOException { cut = new EscapingReader(new StringReader("legal")); final char[] buffer = new char[10]; assertEquals(5, cut.read(buffer)); assertEquals("legal", String.valueOf(buffer, 0, 5)); }
@Test public void readWithCharArrayAndIllegalText() throws IOException { cut = new EscapingReader(new StringReader("bad\0char")); final char[] buffer = new char[10]; assertEquals(7, cut.read(buffer)); assertEquals("badchar", String.valueOf(buffer, 0, 7)); }
@Test public void readWithCharBufferAndLegalText() throws IOException { cut = new EscapingReader(new StringReader("legal")); final CharBuffer buffer = CharBuffer.allocate(10); assertEquals(5, cut.read(buffer)); buffer.flip(); assertEquals("legal", buffer.toString()); }
@Test public void readWithCharBufferAndIllegalText() throws IOException { cut = new EscapingReader(new StringReader("bad\0char")); final CharBuffer buffer = CharBuffer.allocate(10); assertEquals(7, cut.read(buffer)); buffer.flip(); assertEquals("badchar", buffer.toString()); } |
EscapingReader extends Reader { @Override public long skip(long n) throws IOException { return delegate.skip(n); } EscapingReader(Reader delegate); EscapingReader(Object lock, Reader delegate); @Override int read(); @Override int read(char[] cbuf, int off, int len); @Override long skip(long n); @Override boolean ready(); @Override boolean markSupported(); @Override void mark(int readAheadLimit); @Override void reset(); @Override void close(); } | @Test public void skip() throws IOException { cut.skip(999); verify(mockDelegate).skip(Mockito.anyLong()); } |
EscapingReader extends Reader { @Override public boolean ready() throws IOException { return delegate.ready(); } EscapingReader(Reader delegate); EscapingReader(Object lock, Reader delegate); @Override int read(); @Override int read(char[] cbuf, int off, int len); @Override long skip(long n); @Override boolean ready(); @Override boolean markSupported(); @Override void mark(int readAheadLimit); @Override void reset(); @Override void close(); } | @Test public void ready() throws IOException { cut.ready(); verify(mockDelegate).ready(); } |
EscapingReader extends Reader { @Override public boolean markSupported() { return false; } EscapingReader(Reader delegate); EscapingReader(Object lock, Reader delegate); @Override int read(); @Override int read(char[] cbuf, int off, int len); @Override long skip(long n); @Override boolean ready(); @Override boolean markSupported(); @Override void mark(int readAheadLimit); @Override void reset(); @Override void close(); } | @Test public void markSupported() throws IOException { assertFalse(cut.markSupported()); } |
EscapingReader extends Reader { @Override public void mark(int readAheadLimit) throws IOException { throw new IOException("mark() not supported"); } EscapingReader(Reader delegate); EscapingReader(Object lock, Reader delegate); @Override int read(); @Override int read(char[] cbuf, int off, int len); @Override long skip(long n); @Override boolean ready(); @Override boolean markSupported(); @Override void mark(int readAheadLimit); @Override void reset(); @Override void close(); } | @Test(expected = IOException.class) public void mark() throws IOException { cut.mark(0); } |
EscapingReader extends Reader { @Override public void reset() throws IOException { throw new IOException("reset() not supported"); } EscapingReader(Reader delegate); EscapingReader(Object lock, Reader delegate); @Override int read(); @Override int read(char[] cbuf, int off, int len); @Override long skip(long n); @Override boolean ready(); @Override boolean markSupported(); @Override void mark(int readAheadLimit); @Override void reset(); @Override void close(); } | @Test(expected = IOException.class) public void reset() throws IOException { cut.reset(); } |
EscapingReader extends Reader { @Override public void close() throws IOException { delegate.close(); } EscapingReader(Reader delegate); EscapingReader(Object lock, Reader delegate); @Override int read(); @Override int read(char[] cbuf, int off, int len); @Override long skip(long n); @Override boolean ready(); @Override boolean markSupported(); @Override void mark(int readAheadLimit); @Override void reset(); @Override void close(); } | @Test public void close() throws IOException { cut.close(); verify(mockDelegate).close(); } |
PortfolioServiceImpl implements PortfolioService { @Override public void buy(int amount, JsonObject quote, Handler<AsyncResult<Portfolio>> resultHandler) { if (amount <= 0) { resultHandler.handle(Future.failedFuture("Cannot buy " + quote.getString("name") + " - the amount must be " + "greater than 0")); return; } if (quote.getInteger("shares") < amount) { resultHandler.handle(Future.failedFuture("Cannot buy " + amount + " - not enough " + "stocks on the market (" + quote.getInteger("shares") + ")")); return; } double price = amount * quote.getDouble("ask"); String name = quote.getString("name"); if (portfolio.getCash() >= price) { portfolio.setCash(portfolio.getCash() - price); int current = portfolio.getAmount(name); int newAmount = current + amount; portfolio.getShares().put(name, newAmount); sendActionOnTheEventBus("BUY", amount, quote, newAmount); resultHandler.handle(Future.succeededFuture(portfolio)); } else { resultHandler.handle(Future.failedFuture("Cannot buy " + amount + " of " + name + " - " + "not enough money, " + "need " + price + ", has " + portfolio.getCash())); } } PortfolioServiceImpl(Vertx vertx, ServiceDiscovery discovery, double initialCash); @Override void getPortfolio(Handler<AsyncResult<Portfolio>> resultHandler); @Override void evaluate(Handler<AsyncResult<Double>> resultHandler); @Override void buy(int amount, JsonObject quote, Handler<AsyncResult<Portfolio>> resultHandler); @Override void sell(int amount, JsonObject quote, Handler<AsyncResult<Portfolio>> resultHandler); } | @Test public void testBuyStocks(TestContext tc) { Async async = tc.async(); service.buy(10, quote("A", 10, 20, 100), ar -> { tc.assertTrue(ar.succeeded()); Portfolio portfolio = ar.result(); tc.assertEquals(portfolio.getAmount("A"), 10); tc.assertEquals(portfolio.getAmount("B"), 0); tc.assertEquals(portfolio.getCash(), original.getCash() - 10 * 10); async.complete(); }); }
@Test public void testThatYouCannotBuyIfYouRunOutOfMoney(TestContext tc) { Async async = tc.async(); service.buy(10000, quote("A", 10, 20, 100000), ar -> { tc.assertTrue(ar.failed()); tc.assertTrue(ar.cause().getMessage().contains("not enough money")); async.complete(); }); }
@Test public void testThatYouCannotBuyIfThereIsNotEnoughShare(TestContext tc) { Async async = tc.async(); service.buy(100, quote("A", 10, 20, 10), ar -> { tc.assertTrue(ar.failed()); tc.assertTrue(ar.cause().getMessage().contains("not enough stocks")); async.complete(); }); }
@Test public void testYouCannotBuyANegativeAmount(TestContext tc) { Async async = tc.async(); service.buy(-1, quote("A", 10, 20, 100), ar -> { tc.assertTrue(ar.failed()); async.complete(); }); } |
PortfolioServiceImpl implements PortfolioService { @Override public void sell(int amount, JsonObject quote, Handler<AsyncResult<Portfolio>> resultHandler) { if (amount <= 0) { resultHandler.handle(Future.failedFuture("Cannot sell " + quote.getString("name") + " - the amount must be " + "greater than 0")); return; } double price = amount * quote.getDouble("bid"); String name = quote.getString("name"); int current = portfolio.getAmount(name); if (current >= amount) { int newAmount = current - amount; if (newAmount == 0) { portfolio.getShares().remove(name); } else { portfolio.getShares().put(name, newAmount); } portfolio.setCash(portfolio.getCash() + price); sendActionOnTheEventBus("SELL", amount, quote, newAmount); resultHandler.handle(Future.succeededFuture(portfolio)); } else { resultHandler.handle(Future.failedFuture("Cannot sell " + amount + " of " + name + " - " + "not enough stocks " + "in portfolio")); } } PortfolioServiceImpl(Vertx vertx, ServiceDiscovery discovery, double initialCash); @Override void getPortfolio(Handler<AsyncResult<Portfolio>> resultHandler); @Override void evaluate(Handler<AsyncResult<Double>> resultHandler); @Override void buy(int amount, JsonObject quote, Handler<AsyncResult<Portfolio>> resultHandler); @Override void sell(int amount, JsonObject quote, Handler<AsyncResult<Portfolio>> resultHandler); } | @Test public void testYouCannotSellANegativeAmount(TestContext tc) { Async async = tc.async(); service.sell(-1, quote("A", 10, 20, 100), ar -> { tc.assertTrue(ar.failed()); async.complete(); }); } |
BCCryptoHelper implements ICryptoHelper { @Nonnull public KeyStore createNewKeyStore (@Nonnull final IKeyStoreType aKeyStoreType) throws GeneralSecurityException { try { return aKeyStoreType.getKeyStore (m_sSecurityProviderName); } catch (final Exception ex) { return aKeyStoreType.getKeyStore (); } } BCCryptoHelper(); @Nonnull @Nonempty String getSecurityProviderName(); @Nonnull BCCryptoHelper setSecurityProviderName(@Nonnull @Nonempty final String sSecurityProviderName); @Nonnull KeyStore createNewKeyStore(@Nonnull final IKeyStoreType aKeyStoreType); @Nonnull KeyStore loadKeyStore(@Nonnull final IKeyStoreType aKeyStoreType,
@Nullable @WillNotClose final InputStream aIS,
@Nonnull final char [] aPassword); boolean isEncrypted(@Nonnull final MimeBodyPart aPart); boolean isSigned(@Nonnull final MimeBodyPart aPart); boolean isCompressed(@Nonnull final String sContentType); @Nonnull MIC calculateMIC(@Nonnull final MimeBodyPart aPart,
@Nonnull final ECryptoAlgorithmSign eDigestAlgorithm,
final boolean bIncludeHeaders); @Nonnull MimeBodyPart decrypt(@Nonnull final MimeBodyPart aPart,
@Nonnull final X509Certificate aX509Cert,
@Nonnull final PrivateKey aPrivateKey,
final boolean bForceDecrypt,
@Nonnull final AS2ResourceHelper aResHelper); @Nonnull MimeBodyPart encrypt(@Nonnull final MimeBodyPart aPart,
@Nonnull final X509Certificate aX509Cert,
@Nonnull final ECryptoAlgorithmCrypt eAlgorithm,
@Nonnull final EContentTransferEncoding eCTE); @Nonnull MimeBodyPart sign(@Nonnull final MimeBodyPart aPart,
@Nonnull final X509Certificate aX509Cert,
@Nonnull final PrivateKey aPrivateKey,
@Nonnull final ECryptoAlgorithmSign eAlgorithm,
final boolean bIncludeCertificateInSignedContent,
final boolean bUseOldRFC3851MicAlgs,
@Nonnull final EContentTransferEncoding eCTE); @Nonnull MimeBodyPart verify(@Nonnull final MimeBodyPart aPart,
@Nullable final X509Certificate aX509Cert,
final boolean bUseCertificateInBodyPart,
final boolean bForceVerify,
@Nullable final Consumer <X509Certificate> aEffectiveCertificateConsumer,
@Nonnull final AS2ResourceHelper aResHelper); } | @Test public void testCreateKeyStores () throws GeneralSecurityException { final BCCryptoHelper x = new BCCryptoHelper (); for (final EKeyStoreType e : EKeyStoreType.values ()) { assertNotNull (x.createNewKeyStore (e)); } } |
BCCryptoHelper implements ICryptoHelper { @Nonnull public MimeBodyPart encrypt (@Nonnull final MimeBodyPart aPart, @Nonnull final X509Certificate aX509Cert, @Nonnull final ECryptoAlgorithmCrypt eAlgorithm, @Nonnull final EContentTransferEncoding eCTE) throws GeneralSecurityException, SMIMEException, CMSException { ValueEnforcer.notNull (aPart, "MimeBodyPart"); ValueEnforcer.notNull (aX509Cert, "X509Cert"); ValueEnforcer.notNull (eAlgorithm, "Algorithm"); ValueEnforcer.notNull (eCTE, "ContentTransferEncoding"); if (LOGGER.isDebugEnabled ()) LOGGER.debug ("BCCryptoHelper.encrypt; X509 subject=" + aX509Cert.getSubjectX500Principal ().getName () + "; algorithm=" + eAlgorithm + "; CTE=" + eCTE); aX509Cert.checkValidity (); final ASN1ObjectIdentifier aEncAlg = eAlgorithm.getOID (); final SMIMEEnvelopedGenerator aGen = new SMIMEEnvelopedGenerator (); aGen.addRecipientInfoGenerator (new JceKeyTransRecipientInfoGenerator (aX509Cert).setProvider (m_sSecurityProviderName)); aGen.setContentTransferEncoding (eCTE.getID ()); final OutputEncryptor aEncryptor = new JceCMSContentEncryptorBuilder (aEncAlg).setProvider (m_sSecurityProviderName).build (); final MimeBodyPart aEncryptedPart = aGen.generate (aPart, aEncryptor); return aEncryptedPart; } BCCryptoHelper(); @Nonnull @Nonempty String getSecurityProviderName(); @Nonnull BCCryptoHelper setSecurityProviderName(@Nonnull @Nonempty final String sSecurityProviderName); @Nonnull KeyStore createNewKeyStore(@Nonnull final IKeyStoreType aKeyStoreType); @Nonnull KeyStore loadKeyStore(@Nonnull final IKeyStoreType aKeyStoreType,
@Nullable @WillNotClose final InputStream aIS,
@Nonnull final char [] aPassword); boolean isEncrypted(@Nonnull final MimeBodyPart aPart); boolean isSigned(@Nonnull final MimeBodyPart aPart); boolean isCompressed(@Nonnull final String sContentType); @Nonnull MIC calculateMIC(@Nonnull final MimeBodyPart aPart,
@Nonnull final ECryptoAlgorithmSign eDigestAlgorithm,
final boolean bIncludeHeaders); @Nonnull MimeBodyPart decrypt(@Nonnull final MimeBodyPart aPart,
@Nonnull final X509Certificate aX509Cert,
@Nonnull final PrivateKey aPrivateKey,
final boolean bForceDecrypt,
@Nonnull final AS2ResourceHelper aResHelper); @Nonnull MimeBodyPart encrypt(@Nonnull final MimeBodyPart aPart,
@Nonnull final X509Certificate aX509Cert,
@Nonnull final ECryptoAlgorithmCrypt eAlgorithm,
@Nonnull final EContentTransferEncoding eCTE); @Nonnull MimeBodyPart sign(@Nonnull final MimeBodyPart aPart,
@Nonnull final X509Certificate aX509Cert,
@Nonnull final PrivateKey aPrivateKey,
@Nonnull final ECryptoAlgorithmSign eAlgorithm,
final boolean bIncludeCertificateInSignedContent,
final boolean bUseOldRFC3851MicAlgs,
@Nonnull final EContentTransferEncoding eCTE); @Nonnull MimeBodyPart verify(@Nonnull final MimeBodyPart aPart,
@Nullable final X509Certificate aX509Cert,
final boolean bUseCertificateInBodyPart,
final boolean bForceVerify,
@Nullable final Consumer <X509Certificate> aEffectiveCertificateConsumer,
@Nonnull final AS2ResourceHelper aResHelper); } | @Test public void testEncryptCTE_QuotedPrintable () throws Exception { final MimeBodyPart aPart = new MimeBodyPart (); aPart.setText ("Hello world"); final MimeBodyPart aEncrypted = AS2Helper.getCryptoHelper () .encrypt (aPart, CERT_ENCRYPT, ECryptoAlgorithmCrypt.CRYPT_3DES, EContentTransferEncoding.QUOTED_PRINTABLE); final NonBlockingByteArrayOutputStream aBAOS = new NonBlockingByteArrayOutputStream (); aEncrypted.writeTo (aBAOS); final String sExpectedStart = "Content-Type: application/pkcs7-mime; name=\"smime.p7m\"; smime-type=enveloped-data\r\n" + "Content-Transfer-Encoding: quoted-printable\r\n" + "Content-Disposition: attachment; filename=\"smime.p7m\"\r\n" + "Content-Description: S/MIME Encrypted Message\r\n" + "\r\n" + "0=80=06=09*=86H=86=F7\r\n" + "=01=07=03=A0=800=80=02=01=001=82=01=E00=82=01=DC=02=01=000=81=C30=81=BA1#0!=\r\n" + "=06=09*=86H=86=F7\r\n" + "[email protected]=0B0=09=06=03U=04=06=13=02DE1=0F0\r\n" + "=06=03U=04=08=0C=06Berlin1=0F0\r\n" + "=06=03U=04=07=0C=06Berlin1\"0 =06=03U=04\r\n" + "=0C=19mendelson-e-commerce GmbH1!0=1F=06=03U=04=0B=0C=18Do not use in produ=\r\n" + "ction1=1D0=1B=06=03U=04=03=0C=14mendelson test key 4=02=04Z*[=C80\r\n" + "=06=09*=86H=86=F7\r\n"; final String sReal = aBAOS.getAsString (StandardCharsets.ISO_8859_1); assertTrue (sReal.startsWith (sExpectedStart)); }
@Test public void testEncryptWithAllAlgorithms () throws Exception { final MimeBodyPart aPart = new MimeBodyPart (); aPart.setText ("Hello world"); for (final ECryptoAlgorithmCrypt eAlgo : ECryptoAlgorithmCrypt.values ()) { final MimeBodyPart aEncrypted = AS2Helper.getCryptoHelper ().encrypt (aPart, CERT_ENCRYPT, eAlgo, EContentTransferEncoding.BASE64); assertNotNull (aEncrypted); assertArrayEquals (new String [] { "application/pkcs7-mime; name=\"smime.p7m\"; smime-type=enveloped-data" }, aEncrypted.getHeader (CHttpHeader.CONTENT_TYPE)); assertArrayEquals (new String [] { "attachment; filename=\"smime.p7m\"" }, aEncrypted.getHeader (CHttpHeader.CONTENT_DISPOSITION)); } }
@Test public void testEncryptWithAllCTEs () throws Exception { final MimeBodyPart aPart = new MimeBodyPart (); aPart.setText ("Hello world"); for (final EContentTransferEncoding eCTE : EContentTransferEncoding.values ()) { final MimeBodyPart aEncrypted = AS2Helper.getCryptoHelper () .encrypt (aPart, CERT_ENCRYPT, ECryptoAlgorithmCrypt.CRYPT_AES256_GCM, eCTE); assertNotNull (aEncrypted); assertArrayEquals (new String [] { "application/pkcs7-mime; name=\"smime.p7m\"; smime-type=enveloped-data" }, aEncrypted.getHeader (CHttpHeader.CONTENT_TYPE)); assertArrayEquals (new String [] { "attachment; filename=\"smime.p7m\"" }, aEncrypted.getHeader (CHttpHeader.CONTENT_DISPOSITION)); } }
@Test public void testEncryptCTE_Base64 () throws Exception { final MimeBodyPart aPart = new MimeBodyPart (); aPart.setText ("Hello world"); final MimeBodyPart aEncrypted = AS2Helper.getCryptoHelper () .encrypt (aPart, CERT_ENCRYPT, ECryptoAlgorithmCrypt.CRYPT_3DES, EContentTransferEncoding.BASE64); final NonBlockingByteArrayOutputStream aBAOS = new NonBlockingByteArrayOutputStream (); aEncrypted.writeTo (aBAOS); final String sExpectedStart = "Content-Type: application/pkcs7-mime; name=\"smime.p7m\"; smime-type=enveloped-data\r\n" + "Content-Transfer-Encoding: base64\r\n" + "Content-Disposition: attachment; filename=\"smime.p7m\"\r\n" + "Content-Description: S/MIME Encrypted Message\r\n" + "\r\n" + "MIAGCSqGSIb3DQEHA6CAMIACAQAxggHgMIIB3AIBADCBwzCBujEjMCEGCSqGSIb3DQEJARYUc2Vy\r\n" + "dmljZUBtZW5kZWxzb24uZGUxCzAJBgNVBAYTAkRFMQ8wDQYDVQQIDAZCZXJsaW4xDzANBgNVBAcM\r\n" + "BkJlcmxpbjEiMCAGA1UECgwZbWVuZGVsc29uLWUtY29tbWVyY2UgR21iSDEhMB8GA1UECwwYRG8g\r\n" + "bm90IHVzZSBpbiBwcm9kdWN0aW9uMR0wGwYDVQQDDBRtZW5kZWxzb24gdGVzdCBrZXkgNAIEWipb\r\n"; final String sReal = aBAOS.getAsString (StandardCharsets.ISO_8859_1); assertTrue (sReal.startsWith (sExpectedStart)); }
@Test public void testEncryptCTE_Binary () throws Exception { final MimeBodyPart aPart = new MimeBodyPart (); aPart.setText ("Hello world"); final MimeBodyPart aEncrypted = AS2Helper.getCryptoHelper () .encrypt (aPart, CERT_ENCRYPT, ECryptoAlgorithmCrypt.CRYPT_3DES, EContentTransferEncoding.BINARY); final NonBlockingByteArrayOutputStream aBAOS = new NonBlockingByteArrayOutputStream (); aEncrypted.writeTo (aBAOS); final String sExpectedStart = "Content-Type: application/pkcs7-mime; name=\"smime.p7m\"; smime-type=enveloped-data\r\n" + "Content-Transfer-Encoding: binary\r\n" + "Content-Disposition: attachment; filename=\"smime.p7m\"\r\n" + "Content-Description: S/MIME Encrypted Message\r\n" + "\r\n"; final String sReal = aBAOS.getAsString (StandardCharsets.ISO_8859_1); assertTrue (sReal.startsWith (sExpectedStart)); } |
MIC implements Serializable { @Nullable public static MIC parse (@Nullable final String sMIC) { if (StringHelper.hasNoText (sMIC)) return null; final StringTokenizer st = new StringTokenizer (sMIC, ", \t\r\n"); final String sMICBytes = st.nextToken (); final byte [] aMICBytes = Base64.safeDecode (sMICBytes); if (aMICBytes == null) throw new IllegalArgumentException ("Failed to base64 decode '" + sMICBytes + "'"); if (!st.hasMoreTokens ()) throw new IllegalArgumentException ("Separator after Base64 bytes is missing"); final String sAlgorithm = st.nextToken (); final ECryptoAlgorithmSign eDigestAlgorithm = ECryptoAlgorithmSign.getFromIDOrNull (sAlgorithm); if (eDigestAlgorithm == null) throw new IllegalArgumentException ("Failed to parse digest algorithm '" + sAlgorithm + "'"); return new MIC (aMICBytes, eDigestAlgorithm); } MIC(@Nonnull final byte [] aMICBytes, @Nonnull final ECryptoAlgorithmSign eDigestAlgorithm); @Nonnull byte [] micBytes(); @Nonnull ECryptoAlgorithmSign getDigestAlgorithm(); @Nonnull @Nonempty String getAsAS2String(); @Override boolean equals(final Object o); @Override int hashCode(); @Override String toString(); @Nullable static MIC parse(@Nullable final String sMIC); } | @Test public void testParseEmpty () { assertNull (MIC.parse (null)); assertNull (MIC.parse ("")); }
@Test (expected = IllegalArgumentException.class) public void testParseInvalidNoSep () { MIC.parse ("VGVzdA=="); }
@Test (expected = IllegalArgumentException.class) public void testParseInvalidNoAlg () { MIC.parse ("VGVzdA==, "); }
@Test (expected = IllegalArgumentException.class) public void testParseInvalidInvalidAlg () { MIC.parse ("VGVzdA==, blub"); } |
HTTPHelper { public static int readChunkLen (@Nonnull @WillNotClose final InputStream aIS) throws IOException { int nRes = 0; boolean bHeadersStarted = false; for (;;) { int ch = aIS.read (); if (ch < 0) throw new EOFException (); if (ch == '\n') break; if (ch >= 'a' && ch <= 'f') ch -= ('a' - 10); else if (ch >= 'A' && ch <= 'F') ch -= ('A' - 10); else if (ch >= '0' && ch <= '9') ch -= '0'; else if (ch == ';') bHeadersStarted = true; else continue; if (!bHeadersStarted) nRes = (nRes * 16) + ch; } return nRes; } private HTTPHelper(); @Nonnull @ReturnsMutableCopy static ICommonsList <String> getAllHTTPHeaderLines(@Nonnull final InternetHeaders aHeaders); @Nullable static IHTTPIncomingDumper getHTTPIncomingDumper(); @Nonnull static ISupplier <? extends IHTTPIncomingDumper> getHTTPIncomingDumperFactory(); static void setHTTPIncomingDumperFactory(@Nonnull final ISupplier <? extends IHTTPIncomingDumper> aHttpDumperFactory); @Nonnull static DataSource readHttpRequest(@Nonnull final IAS2InputStreamProvider aISP,
@Nonnull final IAS2HttpResponseHandler aResponseHandler,
@Nonnull final IMessage aMsg,
@Nullable final IHTTPIncomingDumper aIncomingDumper); static void sendSimpleHTTPResponse(@Nonnull final IAS2HttpResponseHandler aResponseHandler,
@Nonnegative final int nResponseCode); static int readChunkLen(@Nonnull @WillNotClose final InputStream aIS); static void readTillNexLine(@Nonnull @WillNotClose final InputStream aIS); static final String MA_HTTP_REQ_TYPE; static final String MA_HTTP_REQ_URL; static final String MA_HTTP_REQ_VERSION; } | @Test (expected = EOFException.class) public void testReadChunkLenEOS () throws Exception { final InputStream noNewLine = new StringInputStream ("1", StandardCharsets.UTF_8); HTTPHelper.readChunkLen (noNewLine); fail ("An EOFException should have been thrown"); }
@Test public void testReadChunkLenWithHeader () throws Exception { final NonBlockingByteArrayInputStream noNewLine = new NonBlockingByteArrayInputStream ("1A;name=value\r\n".getBytes (StandardCharsets.UTF_8)); final int res = HTTPHelper.readChunkLen (noNewLine); assertEquals ("Chunk size with header", 26, res); }
@Test public void testReadChunkLenNoHeader () throws Exception { final NonBlockingByteArrayInputStream noNewLine = new NonBlockingByteArrayInputStream ("1f\n".getBytes (StandardCharsets.UTF_8)); final int res = HTTPHelper.readChunkLen (noNewLine); assertEquals ("Chunk size with header", 31, res); }
@Test public void testReadChunkLenEmpty () throws Exception { final NonBlockingByteArrayInputStream noNewLine = new NonBlockingByteArrayInputStream ("\n".getBytes (StandardCharsets.UTF_8)); final int res = HTTPHelper.readChunkLen (noNewLine); assertEquals ("Chunk size with header", 0, res); } |
HTTPHelper { @Nonnull public static DataSource readHttpRequest (@Nonnull final IAS2InputStreamProvider aISP, @Nonnull final IAS2HttpResponseHandler aResponseHandler, @Nonnull final IMessage aMsg, @Nullable final IHTTPIncomingDumper aIncomingDumper) throws IOException, MessagingException { final InputStream aIS = aISP.getInputStream (); final String [] aRequest = _readRequestInfo (aIS); aMsg.attrs ().putIn (MA_HTTP_REQ_TYPE, aRequest[0]); aMsg.attrs ().putIn (MA_HTTP_REQ_URL, aRequest[1]); aMsg.attrs ().putIn (MA_HTTP_REQ_VERSION, aRequest[2]); final InternetHeaders aHeaders = new InternetHeaders (aIS); final Enumeration <Header> aEnum = aHeaders.getAllHeaders (); while (aEnum.hasMoreElements ()) { final Header aHeader = aEnum.nextElement (); aMsg.headers ().addHeader (aHeader.getName (), aHeader.getValue ()); } final String sReceivedContentType = AS2HttpHelper.getCleanContentType (aMsg.getHeader (CHttpHeader.CONTENT_TYPE)); byte [] aBytePayLoad = null; final DataSource aPayload; final String sContentLength = aMsg.getHeader (CHttpHeader.CONTENT_LENGTH); if (sContentLength == null) { final InputStream aRealIS; final String sTransferEncoding = aMsg.getHeader (CHttpHeader.TRANSFER_ENCODING); if (sTransferEncoding != null) { if (AS2Helper.getWithoutSpaces (sTransferEncoding).equalsIgnoreCase ("chunked")) { @WillNotClose final TempSharedFileInputStream aSharedIS = TempSharedFileInputStream.getTempSharedFileInputStream (new ChunkedInputStream (aIS), aMsg.getMessageID ()); aRealIS = aSharedIS; aMsg.setTempSharedFileInputStream (aSharedIS); } else { sendSimpleHTTPResponse (aResponseHandler, CHttp.HTTP_LENGTH_REQUIRED); throw new IOException ("Transfer-Encoding unimplemented: " + sTransferEncoding); } } else { sendSimpleHTTPResponse (aResponseHandler, CHttp.HTTP_LENGTH_REQUIRED); throw new IOException ("Content-Length missing"); } aPayload = new InputStreamDataSource (aRealIS, aMsg.getAS2From () == null ? "" : aMsg.getAS2From (), sReceivedContentType, true); } else { final long nContentLength = StringParser.parseLong (sContentLength, -1); if (nContentLength < 0 || nContentLength > Integer.MAX_VALUE) { sendSimpleHTTPResponse (aResponseHandler, CHttp.HTTP_LENGTH_REQUIRED); throw new IOException ("Content-Length '" + sContentLength + "' is invalid. Only values between 0 and " + Integer.MAX_VALUE + " are allowed."); } aBytePayLoad = new byte [(int) nContentLength]; try (final DataInputStream aDataIS = new DataInputStream (aIS)) { aDataIS.readFully (aBytePayLoad); } aPayload = new ByteArrayDataSource (aBytePayLoad, sReceivedContentType, null); } if (aIncomingDumper != null) aIncomingDumper.dumpIncomingRequest (getAllHTTPHeaderLines (aHeaders), aBytePayLoad != null ? aBytePayLoad : "Payload body was not read yet, and therefore it cannot be dumped (yet) - sorry".getBytes (StandardCharsets.ISO_8859_1), aMsg); return aPayload; } private HTTPHelper(); @Nonnull @ReturnsMutableCopy static ICommonsList <String> getAllHTTPHeaderLines(@Nonnull final InternetHeaders aHeaders); @Nullable static IHTTPIncomingDumper getHTTPIncomingDumper(); @Nonnull static ISupplier <? extends IHTTPIncomingDumper> getHTTPIncomingDumperFactory(); static void setHTTPIncomingDumperFactory(@Nonnull final ISupplier <? extends IHTTPIncomingDumper> aHttpDumperFactory); @Nonnull static DataSource readHttpRequest(@Nonnull final IAS2InputStreamProvider aISP,
@Nonnull final IAS2HttpResponseHandler aResponseHandler,
@Nonnull final IMessage aMsg,
@Nullable final IHTTPIncomingDumper aIncomingDumper); static void sendSimpleHTTPResponse(@Nonnull final IAS2HttpResponseHandler aResponseHandler,
@Nonnegative final int nResponseCode); static int readChunkLen(@Nonnull @WillNotClose final InputStream aIS); static void readTillNexLine(@Nonnull @WillNotClose final InputStream aIS); static final String MA_HTTP_REQ_TYPE; static final String MA_HTTP_REQ_URL; static final String MA_HTTP_REQ_VERSION; } | @Test public void testReadHttpRequestRegularMessage () throws Exception { NonBlockingByteArrayInputStream is = new NonBlockingByteArrayInputStream (m_sRegularMessage.getBytes (StandardCharsets.UTF_8)); AS2Message aMsg = new AS2Message (); IAS2InputStreamProvider mockStreamProvider = new MockAS2InputStreamProvider (is); final DataSource resRegular = HTTPHelper.readHttpRequest (mockStreamProvider, MOCK_RH, aMsg, INCOMING_DUMPER); is = new NonBlockingByteArrayInputStream (m_sRegularMessage.getBytes (StandardCharsets.UTF_8)); aMsg = new AS2Message (); mockStreamProvider = new MockAS2InputStreamProvider (is); final DataSource resStream = HTTPHelper.readHttpRequest (mockStreamProvider, MOCK_RH, aMsg, INCOMING_DUMPER); assertTrue ("Compare regular and stream read", _compareLineByLine (resRegular.getInputStream (), resStream.getInputStream ())); }
@Test public void testReadHttpRequestStreamMessage () throws Exception { NonBlockingByteArrayInputStream is = new NonBlockingByteArrayInputStream (m_sChunkedMessage.getBytes (StandardCharsets.UTF_8)); AS2Message aMsg = new AS2Message (); IAS2InputStreamProvider mockStreamProvider = new MockAS2InputStreamProvider (is); final DataSource resRegular = HTTPHelper.readHttpRequest (mockStreamProvider, MOCK_RH, aMsg, INCOMING_DUMPER); is = new NonBlockingByteArrayInputStream (m_sChunkedMessage.getBytes (StandardCharsets.UTF_8)); aMsg = new AS2Message (); mockStreamProvider = new MockAS2InputStreamProvider (is); final DataSource resStream = HTTPHelper.readHttpRequest (mockStreamProvider, MOCK_RH, aMsg, INCOMING_DUMPER); assertTrue ("Compare regular and stream read", _compareLineByLine (resRegular.getInputStream (), resStream.getInputStream ())); }
@Test (expected = IOException.class) public void testNoLengthMessageRegular () throws Exception { final NonBlockingByteArrayInputStream is = new NonBlockingByteArrayInputStream (m_sNoLengthMessage.getBytes (StandardCharsets.UTF_8)); final AS2Message aMsg = new AS2Message (); final IAS2InputStreamProvider mockStreamProvider = new MockAS2InputStreamProvider (is); HTTPHelper.readHttpRequest (mockStreamProvider, MOCK_RH, aMsg, INCOMING_DUMPER); }
@Test (expected = IOException.class) public void testNoLengthMessageStream () throws Exception { final NonBlockingByteArrayInputStream is = new NonBlockingByteArrayInputStream (m_sNoLengthMessage.getBytes (StandardCharsets.UTF_8)); final AS2Message aMsg = new AS2Message (); final IAS2InputStreamProvider mockStreamProvider = new MockAS2InputStreamProvider (is); HTTPHelper.readHttpRequest (mockStreamProvider, MOCK_RH, aMsg, INCOMING_DUMPER); }
@Test (expected = IOException.class) public void testBadTRansferEncodingMessageRegular () throws Exception { final NonBlockingByteArrayInputStream is = new NonBlockingByteArrayInputStream (m_sBadTransferEncodingMessage.getBytes (StandardCharsets.UTF_8)); final AS2Message aMsg = new AS2Message (); final IAS2InputStreamProvider mockStreamProvider = new MockAS2InputStreamProvider (is); HTTPHelper.readHttpRequest (mockStreamProvider, MOCK_RH, aMsg, INCOMING_DUMPER); }
@Test (expected = IOException.class) public void testBadTRansferEncodingMessageStream () throws Exception { final NonBlockingByteArrayInputStream is = new NonBlockingByteArrayInputStream (m_sBadTransferEncodingMessage.getBytes (StandardCharsets.UTF_8)); final AS2Message aMsg = new AS2Message (); final IAS2InputStreamProvider mockStreamProvider = new MockAS2InputStreamProvider (is); HTTPHelper.readHttpRequest (mockStreamProvider, MOCK_RH, aMsg, INCOMING_DUMPER); } |
BCCryptoHelper implements ICryptoHelper { @Nonnull public MimeBodyPart sign (@Nonnull final MimeBodyPart aPart, @Nonnull final X509Certificate aX509Cert, @Nonnull final PrivateKey aPrivateKey, @Nonnull final ECryptoAlgorithmSign eAlgorithm, final boolean bIncludeCertificateInSignedContent, final boolean bUseOldRFC3851MicAlgs, @Nonnull final EContentTransferEncoding eCTE) throws GeneralSecurityException, SMIMEException, MessagingException, OperatorCreationException { ValueEnforcer.notNull (aPart, "MimeBodyPart"); ValueEnforcer.notNull (aX509Cert, "X509Cert"); ValueEnforcer.notNull (aPrivateKey, "PrivateKey"); ValueEnforcer.notNull (eAlgorithm, "Algorithm"); ValueEnforcer.notNull (eCTE, "ContentTransferEncoding"); if (LOGGER.isDebugEnabled ()) LOGGER.debug ("BCCryptoHelper.sign; X509 subject=" + aX509Cert.getSubjectX500Principal ().getName () + "; algorithm=" + eAlgorithm + "; includeCertificateInSignedContent=" + bIncludeCertificateInSignedContent + "; CTE=" + eCTE); aX509Cert.checkValidity (); final ICommonsList <X509Certificate> aCertList = new CommonsArrayList <> (aX509Cert); final JcaCertStore aCertStore = new JcaCertStore (aCertList); final ASN1EncodableVector aSignedAttrs = new ASN1EncodableVector (); final SMIMECapabilityVector aCapabilities = new SMIMECapabilityVector (); aCapabilities.addCapability (eAlgorithm.getOID ()); aSignedAttrs.add (new SMIMECapabilitiesAttribute (aCapabilities)); final SMIMESignedGenerator aSGen = new SMIMESignedGenerator (bUseOldRFC3851MicAlgs ? SMIMESignedGenerator.RFC3851_MICALGS : SMIMESignedGenerator.RFC5751_MICALGS); aSGen.setContentTransferEncoding (eCTE.getID ()); aSGen.addSignerInfoGenerator (new JcaSimpleSignerInfoGeneratorBuilder ().setProvider (m_sSecurityProviderName) .setSignedAttributeGenerator (new AttributeTable (aSignedAttrs)) .build (eAlgorithm.getSignAlgorithmName (), aPrivateKey, aX509Cert)); if (bIncludeCertificateInSignedContent) { aSGen.addCertificates (aCertStore); } final MimeMultipart aSignedData = aSGen.generate (aPart); final MimeBodyPart aSignedPart = new MimeBodyPart (); aSignedPart.setContent (aSignedData); aSignedPart.setHeader (CHttpHeader.CONTENT_TYPE, aSignedData.getContentType ()); return aSignedPart; } BCCryptoHelper(); @Nonnull @Nonempty String getSecurityProviderName(); @Nonnull BCCryptoHelper setSecurityProviderName(@Nonnull @Nonempty final String sSecurityProviderName); @Nonnull KeyStore createNewKeyStore(@Nonnull final IKeyStoreType aKeyStoreType); @Nonnull KeyStore loadKeyStore(@Nonnull final IKeyStoreType aKeyStoreType,
@Nullable @WillNotClose final InputStream aIS,
@Nonnull final char [] aPassword); boolean isEncrypted(@Nonnull final MimeBodyPart aPart); boolean isSigned(@Nonnull final MimeBodyPart aPart); boolean isCompressed(@Nonnull final String sContentType); @Nonnull MIC calculateMIC(@Nonnull final MimeBodyPart aPart,
@Nonnull final ECryptoAlgorithmSign eDigestAlgorithm,
final boolean bIncludeHeaders); @Nonnull MimeBodyPart decrypt(@Nonnull final MimeBodyPart aPart,
@Nonnull final X509Certificate aX509Cert,
@Nonnull final PrivateKey aPrivateKey,
final boolean bForceDecrypt,
@Nonnull final AS2ResourceHelper aResHelper); @Nonnull MimeBodyPart encrypt(@Nonnull final MimeBodyPart aPart,
@Nonnull final X509Certificate aX509Cert,
@Nonnull final ECryptoAlgorithmCrypt eAlgorithm,
@Nonnull final EContentTransferEncoding eCTE); @Nonnull MimeBodyPart sign(@Nonnull final MimeBodyPart aPart,
@Nonnull final X509Certificate aX509Cert,
@Nonnull final PrivateKey aPrivateKey,
@Nonnull final ECryptoAlgorithmSign eAlgorithm,
final boolean bIncludeCertificateInSignedContent,
final boolean bUseOldRFC3851MicAlgs,
@Nonnull final EContentTransferEncoding eCTE); @Nonnull MimeBodyPart verify(@Nonnull final MimeBodyPart aPart,
@Nullable final X509Certificate aX509Cert,
final boolean bUseCertificateInBodyPart,
final boolean bForceVerify,
@Nullable final Consumer <X509Certificate> aEffectiveCertificateConsumer,
@Nonnull final AS2ResourceHelper aResHelper); } | @SuppressWarnings ("deprecation") @Test public void testSignWithAllAlgorithms () throws Exception { final MimeBodyPart aPart = new MimeBodyPart (); aPart.setText ("Hello world"); for (int nIncludeCert = 0; nIncludeCert < 2; ++nIncludeCert) for (final ECryptoAlgorithmSign eAlgo : ECryptoAlgorithmSign.values ()) if (eAlgo != ECryptoAlgorithmSign.DIGEST_RSA_MD5 && eAlgo != ECryptoAlgorithmSign.DIGEST_RSA_SHA1) { final MimeBodyPart aSigned = AS2Helper.getCryptoHelper () .sign (aPart, (X509Certificate) PKE.getCertificate (), PKE.getPrivateKey (), eAlgo, nIncludeCert == 1, eAlgo.isRFC3851Algorithm (), EContentTransferEncoding.BASE64); assertNotNull (aSigned); final String [] aContentTypes = aSigned.getHeader (CHttpHeader.CONTENT_TYPE); assertNotNull (aContentTypes); assertEquals (1, aContentTypes.length); final String sContentType = aContentTypes[0]; final String sExpectedStart = "multipart/signed; protocol=\"application/pkcs7-signature\"; micalg=" + eAlgo.getID () + "; \r\n\tboundary=\"----=_Part"; assertTrue (sContentType + " does not start with " + sExpectedStart, sContentType.startsWith (sExpectedStart)); } }
@Test public void testSignWithAllCTEs () throws Exception { final MimeBodyPart aPart = new MimeBodyPart (); aPart.setText ("Hello world"); for (final EContentTransferEncoding eCTE : EContentTransferEncoding.values ()) { final MimeBodyPart aSigned = AS2Helper.getCryptoHelper () .sign (aPart, (X509Certificate) PKE.getCertificate (), PKE.getPrivateKey (), ECryptoAlgorithmSign.DIGEST_SHA_512, true, false, eCTE); assertNotNull (aSigned); final String [] aContentTypes = aSigned.getHeader (CHttpHeader.CONTENT_TYPE); assertNotNull (aContentTypes); assertEquals (1, aContentTypes.length); final String sContentType = aContentTypes[0]; final String sExpectedStart = "multipart/signed; protocol=\"application/pkcs7-signature\"; micalg=sha-512; \r\n\tboundary=\"----=_Part"; assertTrue (sContentType + " does not start with " + sExpectedStart, sContentType.startsWith (sExpectedStart)); } }
@Test public void testSign_Base64 () throws Exception { final MimeBodyPart aPart = new MimeBodyPart (); aPart.setText ("Hello world", StandardCharsets.ISO_8859_1.name ()); final MimeBodyPart aSigned = AS2Helper.getCryptoHelper () .sign (aPart, (X509Certificate) PKE.getCertificate (), PKE.getPrivateKey (), ECryptoAlgorithmSign.DIGEST_SHA_256, false, false, EContentTransferEncoding.BASE64); assertNotNull (aSigned); final String sBoundary = AS2HttpHelper.parseContentType (aSigned.getContentType ()).getParameter ("boundary"); assertNotNull (sBoundary); final NonBlockingByteArrayOutputStream aBAOS = new NonBlockingByteArrayOutputStream (); aSigned.writeTo (aBAOS); final String sExpectedStart = "Content-Type: multipart/signed; protocol=\"application/pkcs7-signature\"; micalg=sha-256; \r\n" + "\tboundary=\"" + sBoundary + "\"\r\n" + "\r\n" + "--" + sBoundary + "\r\n" + "Content-Type: text/plain; charset=ISO-8859-1\r\n" + "Content-Transfer-Encoding: 7bit\r\n" + "\r\n" + "Hello world\r\n" + "--" + sBoundary + "\r\n" + "Content-Type: application/pkcs7-signature; name=smime.p7s; smime-type=signed-data\r\n" + "Content-Transfer-Encoding: base64\r\n" + "Content-Disposition: attachment; filename=\"smime.p7s\"\r\n" + "Content-Description: S/MIME Cryptographic Signature\r\n" + "\r\n" + "MIAGCSqGSIb3DQEHAqCAMIACAQExDzANBglghkgBZQMEAgEFADCABgkqhkiG9w0BBwEAADGCAqgw\r\n" + "ggKkAgEBMIHDMIG6MSMwIQYJKoZIhvcNAQkBFhRzZXJ2aWNlQG1lbmRlbHNvbi5kZTELMAkGA1UE\r\n" + "BhMCREUxDzANBgNVBAgMBkJlcmxpbjEPMA0GA1UEBwwGQmVybGluMSIwIAYDVQQKDBltZW5kZWxz\r\n" + "b24tZS1jb21tZXJjZSBHbWJIMSEwHwYDVQQLDBhEbyBub3QgdXNlIGluIHByb2R1Y3Rpb24xHTAb\r\n" + "BgNVBAMMFG1lbmRlbHNvbiB0ZXN0IGtleSAzAgRaKlscMA0GCWCGSAFlAwQCAQUAoIG2MBgGCSqG\r\n"; final String sExpectedEnd = "\r\n" + "--" + sBoundary + "--\r\n"; final String sReal = aBAOS.getAsString (StandardCharsets.ISO_8859_1); assertTrue (sReal.startsWith (sExpectedStart)); assertTrue (sReal.endsWith (sExpectedEnd)); }
@Test public void testSign_Binary () throws Exception { final MimeBodyPart aPart = new MimeBodyPart (); aPart.setText ("Hello world", StandardCharsets.ISO_8859_1.name ()); final MimeBodyPart aSigned = AS2Helper.getCryptoHelper () .sign (aPart, (X509Certificate) PKE.getCertificate (), PKE.getPrivateKey (), ECryptoAlgorithmSign.DIGEST_SHA_256, false, false, EContentTransferEncoding.BINARY); assertNotNull (aSigned); final String sBoundary = AS2HttpHelper.parseContentType (aSigned.getContentType ()).getParameter ("boundary"); assertNotNull (sBoundary); final NonBlockingByteArrayOutputStream aBAOS = new NonBlockingByteArrayOutputStream (); aSigned.writeTo (aBAOS); final String sExpectedStart = "Content-Type: multipart/signed; protocol=\"application/pkcs7-signature\"; micalg=sha-256; \r\n" + "\tboundary=\"" + sBoundary + "\"\r\n" + "\r\n" + "--" + sBoundary + "\r\n" + "Content-Type: text/plain; charset=ISO-8859-1\r\n" + "Content-Transfer-Encoding: 7bit\r\n" + "\r\n" + "Hello world\r\n" + "--" + sBoundary + "\r\n" + "Content-Type: application/pkcs7-signature; name=smime.p7s; smime-type=signed-data\r\n" + "Content-Transfer-Encoding: binary\r\n" + "Content-Disposition: attachment; filename=\"smime.p7s\"\r\n" + "Content-Description: S/MIME Cryptographic Signature\r\n" + "\r\n"; final String sExpectedEnd = "\r\n" + "--" + sBoundary + "--\r\n"; final String sReal = aBAOS.getAsString (StandardCharsets.ISO_8859_1); assertTrue (sReal.startsWith (sExpectedStart)); assertTrue (sReal.endsWith (sExpectedEnd)); }
@Test public void testSign_QuotedPrintable () throws Exception { final MimeBodyPart aPart = new MimeBodyPart (); aPart.setText ("Hello world", StandardCharsets.ISO_8859_1.name ()); final MimeBodyPart aSigned = AS2Helper.getCryptoHelper () .sign (aPart, (X509Certificate) PKE.getCertificate (), PKE.getPrivateKey (), ECryptoAlgorithmSign.DIGEST_SHA_256, false, false, EContentTransferEncoding.QUOTED_PRINTABLE); assertNotNull (aSigned); final String sBoundary = AS2HttpHelper.parseContentType (aSigned.getContentType ()).getParameter ("boundary"); assertNotNull (sBoundary); final NonBlockingByteArrayOutputStream aBAOS = new NonBlockingByteArrayOutputStream (); aSigned.writeTo (aBAOS); final String sExpectedStart = "Content-Type: multipart/signed; protocol=\"application/pkcs7-signature\"; micalg=sha-256; \r\n" + "\tboundary=\"" + sBoundary + "\"\r\n" + "\r\n" + "--" + sBoundary + "\r\n" + "Content-Type: text/plain; charset=ISO-8859-1\r\n" + "Content-Transfer-Encoding: 7bit\r\n" + "\r\n" + "Hello world\r\n" + "--" + sBoundary + "\r\n" + "Content-Type: application/pkcs7-signature; name=smime.p7s; smime-type=signed-data\r\n" + "Content-Transfer-Encoding: quoted-printable\r\n" + "Content-Disposition: attachment; filename=\"smime.p7s\"\r\n" + "Content-Description: S/MIME Cryptographic Signature\r\n" + "\r\n" + "0=80=06=09*=86H=86=F7\r\n" + "=01=07=02=A0=800=80=02=01=011=0F0\r\n" + "=06=09`=86H=01e=03=04=02=01=05=000=80=06=09*=86H=86=F7\r\n" + "=01=07=01=00=001=82=02=A80=82=02=A4=02=01=010=81=C30=81=BA1#0!=06=09*=86H=\r\n" + "=86=F7\r\n" + "[email protected]=0B0=09=06=03U=04=06=13=02DE1=0F0\r\n" + "=06=03U=04=08=0C=06Berlin1=0F0\r\n" + "=06=03U=04=07=0C=06Berlin1\"0 =06=03U=04\r\n" + "=0C=19mendelson-e-commerce GmbH1!0=1F=06=03U=04=0B=0C=18Do not use in produ=\r\n" + "ction1=1D0=1B=06=03U=04=03=0C=14mendelson test key 3=02=04Z*[=1C0\r\n" + "=06=09`=86H=01e=03=04=02=01=05=00=A0=81=B60=18=06=09*=86H=86=F7\r\n" + "=01=09=031=0B=06=09*=86H=86=F7\r\n" + "=01=07=010=1C=06=09*=86H=86=F7\r\n" + "=01=09=051=0F=17\r\n"; final String sExpectedEnd = "\r\n" + "--" + sBoundary + "--\r\n"; final String sReal = aBAOS.getAsString (StandardCharsets.ISO_8859_1); assertTrue (sReal.startsWith (sExpectedStart)); assertTrue (sReal.endsWith (sExpectedEnd)); } |
ChunkedInputStream extends FilterInputStream { @Override public final int read () throws IOException { if (m_nLeft < 0) return -1; if (m_nLeft == 0) { if (m_bAfterFirstChunk) { HTTPHelper.readTillNexLine (m_aIS); } else { m_bAfterFirstChunk = true; } m_nLeft = HTTPHelper.readChunkLen (m_aIS); if (LOGGER.isDebugEnabled ()) LOGGER.debug ("Read chunk size: " + m_nLeft); if (m_nLeft <= 0) { m_nLeft = -1; return -1; } } m_nLeft--; return super.read (); } ChunkedInputStream(@Nonnull final InputStream aIS); @Override final int read(); @Override final int read(@Nonnull final byte [] aBuf, final int nOffset, final int nLength); } | @Test (expected = EOFException.class) @SuppressFBWarnings ("RR_NOT_CHECKED") public void readBufferFromEmpty () throws Exception { final InputStream empty = new NonBlockingByteArrayInputStream ("".getBytes ()); final byte [] buf = new byte [17]; try (final ChunkedInputStream cIS = new ChunkedInputStream (empty)) { cIS.read (buf, 0, buf.length); fail ("An EOFException should have been thrown"); } }
@Test public void readPastEOS () throws Exception { try (final InputStream empty = new NonBlockingByteArrayInputStream ("3\n123\r\n0\r\n".getBytes ()); final ChunkedInputStream cIS = new ChunkedInputStream (empty)) { final byte [] buf = new byte [17]; int ret = cIS.read (buf, 0, buf.length); assertEquals ("read correct num of bytes", 3, ret); assertEquals ("read the chunk", new String (buf, 0, ret), "123"); ret = cIS.read (buf, 0, buf.length); assertEquals ("read past EOS", -1, ret); } }
@Test (expected = EOFException.class) public void readByteFromEmpty () throws Exception { try (final InputStream empty = new NonBlockingByteArrayInputStream (ArrayHelper.EMPTY_BYTE_ARRAY); final ChunkedInputStream cIS = new ChunkedInputStream (empty)) { cIS.read (); fail ("An EOFException should have been thrown"); } }
@Test public void readOneChunkBuffer () throws Exception { try (final InputStream empty = new NonBlockingByteArrayInputStream ("3\n123".getBytes ()); final ChunkedInputStream cIS = new ChunkedInputStream (empty)) { final byte [] buf = new byte [3]; final int ret = cIS.read (buf, 0, buf.length); assertEquals ("Read one chunk: 3 chars read", 3, ret); assertEquals ("Read one Chunk: corect data returned", "123", new String (buf, StandardCharsets.ISO_8859_1)); } }
@Test public void readOneChunkBytes () throws Exception { try (final InputStream empty = new NonBlockingByteArrayInputStream ("3\n123".getBytes ()); final ChunkedInputStream cIS = new ChunkedInputStream (empty)) { int ret = cIS.read (); assertEquals ("Read first char", '1', ret); ret = cIS.read (); assertEquals ("Read second char", '2', ret); ret = cIS.read (); assertEquals ("Read third char", '3', ret); } }
@Test public void readTwoChunkBuffer () throws Exception { try (final InputStream empty = new NonBlockingByteArrayInputStream ("2\r\n12\r\n1\na\r\n0\r\n".getBytes ()); final ChunkedInputStream cIS = new ChunkedInputStream (empty)) { final byte [] buf = new byte [3]; final int ret = cIS.read (buf, 0, buf.length); assertEquals ("Read two chunk: 3 chars read", 3, ret); assertEquals ("Read one Chunk: corect data returned", "12a", new String (buf)); } }
@Test public void readTwoChunkBufferMultipleReads () throws Exception { try (final InputStream empty = new NonBlockingByteArrayInputStream ("2\r\n12\r\n1\na\r\n0\r\n".getBytes ()); final ChunkedInputStream cIS = new ChunkedInputStream (empty)) { final byte [] buf = new byte [3]; int ret = cIS.read (buf, 0, 1); assertEquals ("Read two chunk-1: 1 chars read", 1, ret); assertEquals ("Read one Chunk-1: correct data returned", '1', buf[0]); ret = cIS.read (buf, 0, 1); assertEquals ("Read two chunk-1: 1 chars read", 1, ret); assertEquals ("Read one Chunk-1: correct data returned", '2', buf[0]); ret = cIS.read (buf, 0, 1); assertEquals ("Read two chunk-1: 1 chars read", 1, ret); assertEquals ("Read one Chunk-1: correct data returned", 'a', buf[0]); } }
@Test public void readTwoChunkByteMultipleReads () throws Exception { try (final InputStream empty = new NonBlockingByteArrayInputStream ("2\r\n12\r\n1\na\r\n0\r\n".getBytes ()); final ChunkedInputStream cIS = new ChunkedInputStream (empty)) { int ret = cIS.read (); assertEquals ("Read one Chunk-1: correct data returned", '1', ret); ret = cIS.read (); assertEquals ("Read one Chunk-1: correct data returned", '2', ret); ret = cIS.read (); assertEquals ("Read one Chunk-1: correct data returned", 'a', ret); } } |
TempSharedFileInputStream extends SharedFileInputStream { @Nonnull public static TempSharedFileInputStream getTempSharedFileInputStream (@Nonnull @WillClose final InputStream aIS, @Nonnull final String sName) throws IOException { final File aDest = storeContentToTempFile (aIS, sName); return new TempSharedFileInputStream (aDest); } private TempSharedFileInputStream(@Nonnull final File aFile); @Override void close(); void closeAll(); @Nonnull static TempSharedFileInputStream getTempSharedFileInputStream(@Nonnull @WillClose final InputStream aIS,
@Nonnull final String sName); } | @Test public void testGetTempSharedFileInputStream () throws Exception { final String inData = "123456"; try (final InputStream is = new NonBlockingByteArrayInputStream (inData.getBytes ()); final SharedFileInputStream sis = TempSharedFileInputStream.getTempSharedFileInputStream (is, "myName"); final NonBlockingByteArrayOutputStream baos = new NonBlockingByteArrayOutputStream ()) { StreamHelper.copyInputStreamToOutputStream (sis, baos); final String res = baos.getAsString (StandardCharsets.ISO_8859_1); assertEquals ("read the data", inData, res); sis.close (); } } |
TempSharedFileInputStream extends SharedFileInputStream { @Nonnull protected static File storeContentToTempFile (@Nonnull @WillClose final InputStream aIS, @Nonnull final String sName) throws IOException { final String sSuffix = FilenameHelper.getAsSecureValidASCIIFilename (StringHelper.hasText (sName) ? sName : "tmp"); final File aDestFile = File.createTempFile ("AS2TempSharedFileIS", sSuffix); try (final FileOutputStream aOS = new FileOutputStream (aDestFile)) { final MutableLong aCount = new MutableLong (0); StreamHelper.copyInputStreamToOutputStream (aIS, aOS, aCount); if (LOGGER.isInfoEnabled ()) { if (aCount.longValue () > 1024) LOGGER.info (aCount.longValue () + " bytes copied to " + aDestFile.getAbsolutePath ()); } } return aDestFile; } private TempSharedFileInputStream(@Nonnull final File aFile); @Override void close(); void closeAll(); @Nonnull static TempSharedFileInputStream getTempSharedFileInputStream(@Nonnull @WillClose final InputStream aIS,
@Nonnull final String sName); } | @Test public void testStoreContentToTempFile () throws Exception { final String inData = "123456"; final String name = "xxy"; try (final InputStream is = new NonBlockingByteArrayInputStream (inData.getBytes (StandardCharsets.ISO_8859_1))) { final File file = TempSharedFileInputStream.storeContentToTempFile (is, name); assertTrue ("Temp file exists", file.exists ()); assertTrue ("Temp file name includes given name", file.getName ().indexOf (name) > 0); FileOperations.deleteFileIfExisting (file); } } |
TempSharedFileInputStream extends SharedFileInputStream { @Override protected void finalize () throws Throwable { try { closeAll (); } catch (final Exception ex) { LOGGER.error ("Exception in finalize()", ex); } super.finalize (); } private TempSharedFileInputStream(@Nonnull final File aFile); @Override void close(); void closeAll(); @Nonnull static TempSharedFileInputStream getTempSharedFileInputStream(@Nonnull @WillClose final InputStream aIS,
@Nonnull final String sName); } | @Test public void testFinalize () throws Exception { for (int i = 0; i < 10000; i++) { final String sSrcData = "123456"; try (final InputStream is = new NonBlockingByteArrayInputStream (sSrcData.getBytes (StandardCharsets.ISO_8859_1)); final TempSharedFileInputStream aSharedIS = TempSharedFileInputStream.getTempSharedFileInputStream (is, "myName")) { final int t = aSharedIS.read (); assertEquals (t, sSrcData.charAt (0)); aSharedIS.closeAll (); } } } |
AS2IOHelper { @Nullable public static String getFilenameFromMessageID (@Nonnull final String sMessageID) { String s = StringHelper.removeAll (sMessageID, '<'); s = StringHelper.removeAll (s, '>'); return FilenameHelper.getAsSecureValidASCIIFilename (s); } private AS2IOHelper(); @Nonnull static FileOperationManager getFileOperationManager(); @Nonnull static File getDirectoryFile(@Nonnull final String sDirectory); @Nonnull @Nonempty static String getTransferRate(final long nBytes, @Nonnull final StopWatch aSW); @Nonnull static File getUniqueFile(@Nonnull final File aDir, @Nullable final String sFilename); static void handleError(@Nonnull final File aFile, @Nonnull final String sErrorDirectory); @Nonnull static File moveFile(@Nonnull final File aSrc,
@Nonnull final File aDestFile,
final boolean bOverwrite,
final boolean bRename); @Nullable static String getFilenameFromMessageID(@Nonnull final String sMessageID); @Nullable static String getSafeFileAndFolderName(@Nullable final String s); @Nonnull @ReturnsMutableCopy static byte [] getAllAsciiBytes(@Nonnull final String sString); @Nonnull static OutputStream getContentTransferEncodingAwareOutputStream(@Nonnull final OutputStream aOS,
@Nullable final String sEncoding); @Nonnull static InputStream getContentTransferEncodingAwareInputStream(@Nonnull final InputStream aIS,
@Nullable final String sEncoding); } | @Test public void testGetFilenameFromMessageID () { assertNull (AS2IOHelper.getFilenameFromMessageID ("")); assertNull (AS2IOHelper.getFilenameFromMessageID ("<<<<>>>>")); assertEquals ("a", AS2IOHelper.getFilenameFromMessageID ("a")); assertEquals ("a", AS2IOHelper.getFilenameFromMessageID ("<a>")); assertEquals ("a", AS2IOHelper.getFilenameFromMessageID ("<<<<<a>>>>>")); assertEquals ("[email protected]", AS2IOHelper.getFilenameFromMessageID ("<<<<<[email protected]>>>>>")); } |
AS2IOHelper { @Nullable public static String getSafeFileAndFolderName (@Nullable final String s) { if (StringHelper.hasNoText (s)) return s; final File aBase = new File (FilenameHelper.getPathUsingUnixSeparator (s)); final StringBuilder aSB = new StringBuilder (); File f = aBase; while (f != null) { final String sName = f.getName (); if (sName.length () == 0) { aSB.insert (0, FilenameHelper.getPathUsingUnixSeparator (f.getPath ())); } else { final String sSecuredName = FilenameHelper.getAsSecureValidASCIIFilename (sName); aSB.insert (0, StringHelper.getNotNull (sSecuredName, "") + FilenameHelper.UNIX_SEPARATOR); } f = f.getParentFile (); } return aSB.deleteCharAt (aSB.length () - 1).toString (); } private AS2IOHelper(); @Nonnull static FileOperationManager getFileOperationManager(); @Nonnull static File getDirectoryFile(@Nonnull final String sDirectory); @Nonnull @Nonempty static String getTransferRate(final long nBytes, @Nonnull final StopWatch aSW); @Nonnull static File getUniqueFile(@Nonnull final File aDir, @Nullable final String sFilename); static void handleError(@Nonnull final File aFile, @Nonnull final String sErrorDirectory); @Nonnull static File moveFile(@Nonnull final File aSrc,
@Nonnull final File aDestFile,
final boolean bOverwrite,
final boolean bRename); @Nullable static String getFilenameFromMessageID(@Nonnull final String sMessageID); @Nullable static String getSafeFileAndFolderName(@Nullable final String s); @Nonnull @ReturnsMutableCopy static byte [] getAllAsciiBytes(@Nonnull final String sString); @Nonnull static OutputStream getContentTransferEncodingAwareOutputStream(@Nonnull final OutputStream aOS,
@Nullable final String sEncoding); @Nonnull static InputStream getContentTransferEncodingAwareInputStream(@Nonnull final InputStream aIS,
@Nullable final String sEncoding); } | @Test public void testgetSafeFileAndFolderName () { assertNull (AS2IOHelper.getSafeFileAndFolderName (null)); assertEquals ("", AS2IOHelper.getSafeFileAndFolderName ("")); assertEquals ("abc", AS2IOHelper.getSafeFileAndFolderName ("abc")); assertEquals ("abc/def", AS2IOHelper.getSafeFileAndFolderName ("abc/def")); assertEquals ("abc/def", AS2IOHelper.getSafeFileAndFolderName ("abc\\def")); assertEquals ("abc/def/blub", AS2IOHelper.getSafeFileAndFolderName ("abc/def\\blub")); assertEquals ("abc_/d_ef/g_hi", AS2IOHelper.getSafeFileAndFolderName ("abc</d|ef\\g*hi")); assertEquals ("/abc", AS2IOHelper.getSafeFileAndFolderName ("/abc")); assertEquals ("/abc", AS2IOHelper.getSafeFileAndFolderName ("\\abc")); assertEquals ("abc", AS2IOHelper.getSafeFileAndFolderName ("abc/")); assertEquals ("abc", AS2IOHelper.getSafeFileAndFolderName ("abc\\")); assertEquals ("/abc", AS2IOHelper.getSafeFileAndFolderName ("/abc/")); assertEquals ("/abc", AS2IOHelper.getSafeFileAndFolderName ("/abc\\")); assertEquals ("/abc", AS2IOHelper.getSafeFileAndFolderName ("\\abc/")); assertEquals ("/abc", AS2IOHelper.getSafeFileAndFolderName ("\\abc\\")); assertEquals ("z:/abc", AS2IOHelper.getSafeFileAndFolderName ("z:\\abc\\")); assertEquals ("z:/abc/test.txt", AS2IOHelper.getSafeFileAndFolderName ("z:\\abc/test.txt")); assertEquals ("z:/a_bc/tes_t.txt", AS2IOHelper.getSafeFileAndFolderName ("z:\\a*bc/tesät.txt")); assertEquals ("z:/com1", AS2IOHelper.getSafeFileAndFolderName ("z:\\com1")); assertEquals ("z:/_com2", AS2IOHelper.getSafeFileAndFolderName ("z:\\com2")); } |
AS2HttpHelper { @Nullable public static ContentType parseContentType (@Nullable final String sContentType) { if (StringHelper.hasText (sContentType)) { final String sRealContentType = RFC2616Codec.isMaybeEncoded (sContentType) ? new RFC2616Codec ().getDecodedAsString (sContentType) : sContentType; try { return new ContentType (sRealContentType); } catch (final ParseException ex) { if (LOGGER.isDebugEnabled ()) LOGGER.debug ("Error parsing Content-Type '" + sContentType + "'", ex); } } return null; } private AS2HttpHelper(); @Nullable static ContentType parseContentType(@Nullable final String sContentType); @Nullable static String getCleanContentType(@Nullable final String sContentType); @Nonnull static InternetHeaders getAsInternetHeaders(@Nonnull final HttpHeaderMap aHeaders); } | @Test public void testParseContentType () { assertNull (AS2HttpHelper.parseContentType (null)); assertNull (AS2HttpHelper.parseContentType ("")); assertNull (AS2HttpHelper.parseContentType (" ")); assertNull (AS2HttpHelper.parseContentType ("abc")); assertNull (AS2HttpHelper.parseContentType ("abc/")); assertNotNull (AS2HttpHelper.parseContentType ("abc/def")); assertNotNull (AS2HttpHelper.parseContentType ("abc/def; a=b")); assertNotNull (AS2HttpHelper.parseContentType (" abc/def ; a = b ")); assertNotNull (AS2HttpHelper.parseContentType ("abc/def; a=b; c=d")); assertNotNull (AS2HttpHelper.parseContentType (" abc/def ; a = b ; c = d ")); } |
AS2HttpHelper { @Nullable public static String getCleanContentType (@Nullable final String sContentType) { final ContentType aCT = parseContentType (sContentType); return aCT != null ? aCT.toString () : null; } private AS2HttpHelper(); @Nullable static ContentType parseContentType(@Nullable final String sContentType); @Nullable static String getCleanContentType(@Nullable final String sContentType); @Nonnull static InternetHeaders getAsInternetHeaders(@Nonnull final HttpHeaderMap aHeaders); } | @Test public void testGetCleanContentType () { assertNull (AS2HttpHelper.getCleanContentType (null)); assertNull (AS2HttpHelper.getCleanContentType ("")); assertNull (AS2HttpHelper.getCleanContentType (" ")); assertNull (AS2HttpHelper.getCleanContentType ("abc")); assertNull (AS2HttpHelper.getCleanContentType ("abc/")); assertEquals ("abc/def", AS2HttpHelper.getCleanContentType ("abc/def")); assertEquals ("abc/def; a=b", AS2HttpHelper.getCleanContentType ("abc/def; a=b")); assertEquals ("abc/def; a=b", AS2HttpHelper.getCleanContentType (" abc/def ; a = b ")); assertEquals ("abc/def; a=b; c=d", AS2HttpHelper.getCleanContentType ("abc/def; a=b; c=d")); assertEquals ("abc/def; a=b; c=d", AS2HttpHelper.getCleanContentType (" abc/def ; a = b ; c = d ")); } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.