src_fm_fc_ms_ff
stringlengths 43
86.8k
| target
stringlengths 20
276k
|
|---|---|
SubscriptionImpl implements Subscription { public SubscriptionImpl<T> onClose(Runnable e) { onClose = e; return this; } @Override void close(); @Override Subscription awaitCatchup(); Subscription awaitCatchup(long waitTimeInMillis); @Override Subscription awaitComplete(); Subscription awaitComplete(long waitTimeInMillis); @SuppressFBWarnings("NP_NONNULL_PARAM_VIOLATION") void notifyCatchup(); @SuppressFBWarnings("NP_NONNULL_PARAM_VIOLATION") void notifyComplete(); void notifyError(Throwable e); void notifyElement(@NonNull T e); SubscriptionImpl<T> onClose(Runnable e); static SubscriptionImpl<T> on(@NonNull GenericObserver<T> o); } | @Test void testOnClose() throws Exception { CountDownLatch l = new CountDownLatch(1); uut.onClose(l::countDown); uut.close(); l.await(); } |
SubscriptionImpl implements Subscription { public static <T> SubscriptionImpl<T> on(@NonNull GenericObserver<T> o) { return new SubscriptionImpl<>(o); } @Override void close(); @Override Subscription awaitCatchup(); Subscription awaitCatchup(long waitTimeInMillis); @Override Subscription awaitComplete(); Subscription awaitComplete(long waitTimeInMillis); @SuppressFBWarnings("NP_NONNULL_PARAM_VIOLATION") void notifyCatchup(); @SuppressFBWarnings("NP_NONNULL_PARAM_VIOLATION") void notifyComplete(); void notifyError(Throwable e); void notifyElement(@NonNull T e); SubscriptionImpl<T> onClose(Runnable e); static SubscriptionImpl<T> on(@NonNull GenericObserver<T> o); } | @Test void testOnNull() { Assertions.assertThrows(NullPointerException.class, () -> { SubscriptionImpl.on(null); }); }
@Test void testOn() { SubscriptionImpl<Integer> on = SubscriptionImpl.on(obs); verify(obs, never()).onNext(any()); on.notifyElement(1); verify(obs).onNext(1); verify(obs, never()).onCatchup(); on.notifyCatchup(); verify(obs).onCatchup(); verify(obs, never()).onComplete(); on.notifyComplete(); verify(obs).onComplete(); } |
ReconnectingFactSubscriptionWrapper implements Subscription { @Override public Subscription awaitComplete() throws SubscriptionCancelledException { for (;;) { assertSubscriptionStateNotClosed(); Subscription cur = currentSubscription.get(); if (cur != null) { try { cur.awaitComplete(); return this; } catch (SubscriptionCancelledException ignore) { } } else { sleep(); } } } ReconnectingFactSubscriptionWrapper(@NonNull FactStore store,
@NonNull SubscriptionRequestTO req,
@NonNull FactObserver obs); @Override void close(); @Override Subscription awaitCatchup(); @Override Subscription awaitCatchup(long waitTimeInMillis); @Override Subscription awaitComplete(); @Override Subscription awaitComplete(long waitTimeInMillis); } | @Test public void testAwaitComplete() throws Exception { observerAC.getValue().onComplete(); assertTimeout(Duration.ofMillis(1000), () -> { uut.awaitComplete(); }); }
@Test public void testAwaitCompleteLong() throws Exception { when(subscription.awaitComplete(anyLong())).thenThrow(TimeoutException.class) .then(x -> subscription); assertThrows(TimeoutException.class, () -> { uut.awaitComplete(51); }); assertTimeout(Duration.ofMillis(1000), () -> { assertThat(uut.awaitComplete(52)).isSameAs(uut); }); verify(subscription).awaitComplete(52); } |
ReconnectingFactSubscriptionWrapper implements Subscription { @Override public Subscription awaitCatchup() throws SubscriptionCancelledException { for (;;) { assertSubscriptionStateNotClosed(); Subscription cur = currentSubscription.get(); if (cur != null) { try { cur.awaitCatchup(); return this; } catch (SubscriptionCancelledException ignore) { } } else { sleep(); } } } ReconnectingFactSubscriptionWrapper(@NonNull FactStore store,
@NonNull SubscriptionRequestTO req,
@NonNull FactObserver obs); @Override void close(); @Override Subscription awaitCatchup(); @Override Subscription awaitCatchup(long waitTimeInMillis); @Override Subscription awaitComplete(); @Override Subscription awaitComplete(long waitTimeInMillis); } | @Test public void testAwaitCatchup() throws Exception { observerAC.getValue().onCatchup(); assertTimeout(Duration.ofMillis(1000), () -> { uut.awaitCatchup(); }); }
@Test public void testAwaitCatchupLong() throws Exception { when(subscription.awaitCatchup(anyLong())).thenThrow(TimeoutException.class) .then(x -> subscription); assertThrows(TimeoutException.class, () -> { uut.awaitCatchup(51); }); assertTimeout(Duration.ofMillis(1000), () -> { assertThat(uut.awaitCatchup(52)).isSameAs(uut); }); verify(subscription).awaitCatchup(52); } |
ReconnectingFactSubscriptionWrapper implements Subscription { private void assertSubscriptionStateNotClosed() { if (closed.get()) { throw new SubscriptionCancelledException("Subscription already cancelled"); } } ReconnectingFactSubscriptionWrapper(@NonNull FactStore store,
@NonNull SubscriptionRequestTO req,
@NonNull FactObserver obs); @Override void close(); @Override Subscription awaitCatchup(); @Override Subscription awaitCatchup(long waitTimeInMillis); @Override Subscription awaitComplete(); @Override Subscription awaitComplete(long waitTimeInMillis); } | @Test public void testAssertSubscriptionStateNotClosed() throws Exception { uut.close(); assertThrows(SubscriptionCancelledException.class, () -> { uut.awaitCatchup(); }); assertThrows(SubscriptionCancelledException.class, () -> { uut.awaitCatchup(1L); }); assertThrows(SubscriptionCancelledException.class, () -> { uut.awaitComplete(); }); assertThrows(SubscriptionCancelledException.class, () -> { uut.awaitComplete(1L); }); } |
CondensedQueryExecutor { public void trigger() { if (connectionStateSupplier.get()) { if (maxDelayInMillis < 1) { runTarget(); } else if (!currentlyScheduled.getAndSet(true)) { timer.schedule(new TimerTask() { @Override public void run() { currentlyScheduled.set(false); try { CondensedQueryExecutor.this.runTarget(); } catch (Throwable e) { log.debug("Scheduled query failed, closing: {}", e.getMessage()); } } }, maxDelayInMillis); } } } void trigger(); @Subscribe void onEvent(FactInsertionEvent ev); void cancel(); } | @Test void testDelayedExecution() { CondensedQueryExecutor uut = new CondensedQueryExecutor(1, callback, () -> true, mockTimer); uut.trigger(); verify(mockTimer).schedule(any(), eq(1L)); task.getValue().run(); verify(callback).run(anyBoolean()); }
@Test void testDelayedMultipleExecution() { CondensedQueryExecutor uut = new CondensedQueryExecutor(22, callback, () -> true, mockTimer); verify(mockTimer, never()).schedule(any(), anyLong()); uut.trigger(); task.getAllValues().get(0).run(); uut.trigger(); task.getAllValues().get(1).run(); verify(callback, times(2)).run(anyBoolean()); }
@Test void testDelayedCondensedExecution() { CondensedQueryExecutor uut = new CondensedQueryExecutor(104, callback, () -> true, mockTimer); verify(mockTimer, never()).schedule(any(), anyLong()); uut.trigger(); verify(mockTimer).schedule(any(), eq(104L)); uut.trigger(); uut.trigger(); uut.trigger(); uut.trigger(); verify(mockTimer).schedule(any(), eq(104L)); TimerTask taskArg = task.getValue(); taskArg.run(); verify(mockTimer).schedule(any(), eq(104L)); verifyNoMoreInteractions(mockTimer); uut.trigger(); verify(mockTimer, times(2)).schedule(any(), eq(104L)); uut.trigger(); uut.trigger(); uut.trigger(); verify(mockTimer, times(2)).schedule(any(), eq(104L)); } |
FluentSubscriptionRequest implements SubscriptionRequest { @Override public String toString() { return debugInfo; } FluentSubscriptionRequest(); @Override java.util.Optional<UUID> startingAfter(); @Override String toString(); } | @Test void testToString() { SubscriptionRequest r = SubscriptionRequest.catchup(FactSpec.ns("foo")).fromScratch(); assertSame(r.debugInfo(), r.toString()); } |
SubscriptionRequestTO implements SubscriptionRequest { public static SubscriptionRequestTO forFacts(SubscriptionRequest request) { SubscriptionRequestTO t = new SubscriptionRequestTO(request); t.idOnly(false); return t; } SubscriptionRequestTO(SubscriptionRequest request); boolean hasAnyScriptFilters(); @Override java.util.Optional<UUID> startingAfter(); static SubscriptionRequestTO forFacts(SubscriptionRequest request); static SubscriptionRequestTO forIds(SubscriptionRequest request); void addSpecs(@NonNull List<FactSpec> factSpecs); @Override List<FactSpec> specs(); String dump(); @Override String toString(); } | @Test void testDebugInfo() { SubscriptionRequest r = SubscriptionRequest.catchup(FactSpec.ns("foo")).fromScratch(); SubscriptionRequestTO uut = SubscriptionRequestTO.forFacts(r); assertEquals(r.debugInfo(), uut.debugInfo()); }
@Test void testMaxDelay() { final FactSpec s = FactSpec.ns("foo"); SubscriptionRequest r = SubscriptionRequest.catchup(s).fromScratch(); SubscriptionRequestTO uut = SubscriptionRequestTO.forFacts(r); assertEquals(0, uut.maxBatchDelayInMs()); uut.maxBatchDelayInMs(7); assertEquals(7, uut.maxBatchDelayInMs()); } |
SubscriptionRequestTO implements SubscriptionRequest { @Override public String toString() { return debugInfo; } SubscriptionRequestTO(SubscriptionRequest request); boolean hasAnyScriptFilters(); @Override java.util.Optional<UUID> startingAfter(); static SubscriptionRequestTO forFacts(SubscriptionRequest request); static SubscriptionRequestTO forIds(SubscriptionRequest request); void addSpecs(@NonNull List<FactSpec> factSpecs); @Override List<FactSpec> specs(); String dump(); @Override String toString(); } | @Test void testToString() { SubscriptionRequest r = SubscriptionRequest.catchup(FactSpec.ns("foo")).fromScratch(); String debugInfo = r.debugInfo(); SubscriptionRequestTO uut = SubscriptionRequestTO.forFacts(r); assertEquals(debugInfo, uut.toString()); } |
SubscriptionRequestTO implements SubscriptionRequest { public boolean hasAnyScriptFilters() { return specs.stream().anyMatch(s -> s.jsFilterScript() != null); } SubscriptionRequestTO(SubscriptionRequest request); boolean hasAnyScriptFilters(); @Override java.util.Optional<UUID> startingAfter(); static SubscriptionRequestTO forFacts(SubscriptionRequest request); static SubscriptionRequestTO forIds(SubscriptionRequest request); void addSpecs(@NonNull List<FactSpec> factSpecs); @Override List<FactSpec> specs(); String dump(); @Override String toString(); } | @Test void testHasAnyScriptFilters() { final FactSpec s = FactSpec.ns("foo"); SubscriptionRequest r = SubscriptionRequest.catchup(s).fromScratch(); SubscriptionRequestTO uut = SubscriptionRequestTO.forFacts(r); assertFalse(uut.hasAnyScriptFilters()); uut.addSpecs(Collections.singletonList(FactSpec.ns("buh").jsFilterScript( "function (h,e){ return true }"))); assertTrue(uut.hasAnyScriptFilters()); } |
SubscriptionRequestTO implements SubscriptionRequest { public void addSpecs(@NonNull List<FactSpec> factSpecs) { checkArgument(!factSpecs.isEmpty()); specs.addAll(factSpecs); } SubscriptionRequestTO(SubscriptionRequest request); boolean hasAnyScriptFilters(); @Override java.util.Optional<UUID> startingAfter(); static SubscriptionRequestTO forFacts(SubscriptionRequest request); static SubscriptionRequestTO forIds(SubscriptionRequest request); void addSpecs(@NonNull List<FactSpec> factSpecs); @Override List<FactSpec> specs(); String dump(); @Override String toString(); } | @Test void testAddSpecs() { final FactSpec s = FactSpec.ns("foo"); SubscriptionRequest r = SubscriptionRequest.catchup(s).fromScratch(); SubscriptionRequestTO uut = SubscriptionRequestTO.forFacts(r); assertEquals(1, uut.specs().size()); final String js = "function (h,e){ return true }"; uut.addSpecs(Collections.singletonList(FactSpec.ns("buh").jsFilterScript(js))); assertEquals(2, uut.specs().size()); assertEquals(js, uut.specs().get(1).jsFilterScript()); } |
Lz4GrpcServerCodec implements Codec { @Override public String getMessageEncoding() { return "lz4"; } @Override String getMessageEncoding(); @Override InputStream decompress(InputStream inputStream); @Override OutputStream compress(OutputStream outputStream); } | @Test void getMessageEncoding() { assertEquals("lz4", uut.getMessageEncoding()); } |
SnappyGrpcServerCodec implements Codec { @Override public String getMessageEncoding() { return "snappy"; } @Override String getMessageEncoding(); @Override InputStream decompress(InputStream inputStream); @Override OutputStream compress(OutputStream outputStream); } | @Test void getMessageEncoding() { assertEquals("snappy", uut.getMessageEncoding()); } |
BlockingStreamObserver implements StreamObserver<T> { @Override public void onCompleted() { delegate.onCompleted(); } BlockingStreamObserver(@NonNull String id, @NonNull ServerCallStreamObserver<T> delegate); @Override void onNext(T value); @Override void onError(Throwable t); @Override void onCompleted(); } | @Test void testOnCompleted() { verify(delegate, never()).onCompleted(); uut.onCompleted(); verify(delegate).onCompleted(); } |
BlockingStreamObserver implements StreamObserver<T> { @Override public void onError(Throwable t) { delegate.onError(t); } BlockingStreamObserver(@NonNull String id, @NonNull ServerCallStreamObserver<T> delegate); @Override void onNext(T value); @Override void onError(Throwable t); @Override void onCompleted(); } | @Test void testOnError() { verify(delegate, never()).onError(any()); uut.onError(new Exception()); verify(delegate).onError(any()); } |
PgConfigurationProperties implements ApplicationListener<ApplicationReadyEvent> { public int getQueueSizeForIds() { return queueSize * idOnlyFactor; } int getPageSizeForIds(); int getQueueSizeForIds(); int getFetchSizeForIds(); int getFetchSize(); @Override void onApplicationEvent(ApplicationReadyEvent event); } | @Test void testGetQueueSizeForIds() { assertEquals(100000, uut.getQueueSizeForIds()); } |
BlockingStreamObserver implements StreamObserver<T> { @Override public void onNext(T value) { if (!delegate.isCancelled()) { synchronized (lock) { if (!delegate.isReady()) { for (int i = 1; i <= RETRY_COUNT; i++) { log.debug("{} channel not ready. Slow client? Attempt: {}/{}", id, i, RETRY_COUNT); try { lock.wait(WAIT_TIME); } catch (InterruptedException meh) { } if (delegate.isReady()) { break; } if (delegate.isCancelled()) { break; } } if (!delegate.isReady() && !delegate.isCancelled()) { throw new TransportLayerException("channel not coming back."); } } if (!delegate.isCancelled()) delegate.onNext(value); } } } BlockingStreamObserver(@NonNull String id, @NonNull ServerCallStreamObserver<T> delegate); @Override void onNext(T value); @Override void onError(Throwable t); @Override void onCompleted(); } | @Test void testOnNextWhenReady() { when(delegate.isReady()).thenReturn(true); uut.onNext(new Object()); verify(delegate).onNext(any()); } |
FactStoreGrpcService extends RemoteFactStoreImplBase { @Override @Secured(FactCastRole.WRITE) public void publish(@NonNull MSG_Facts request, StreamObserver<MSG_Empty> responseObserver) { List<Fact> facts = request.getFactList() .stream() .map(converter::fromProto) .collect( Collectors.toList()); final int size = facts.size(); log.debug("publish {} fact{}", size, size > 1 ? "s" : ""); log.trace("publish {}", facts); try { log.trace("store publish {}", facts); store.publish(facts); log.trace("store publish done"); responseObserver.onNext(MSG_Empty.getDefaultInstance()); responseObserver.onCompleted(); } catch (Throwable e) { log.error("Problem while publishing: ", e); responseObserver.onError(e); } } @Override void fetchById(MSG_UUID request,
StreamObserver<MSG_OptionalFact> responseObserver); @Override @Secured(FactCastRole.WRITE) void publish(@NonNull MSG_Facts request,
StreamObserver<MSG_Empty> responseObserver); @Override void subscribe(MSG_SubscriptionRequest request,
StreamObserver<MSG_Notification> responseObserver); @Override void handshake(MSG_Empty request,
StreamObserver<MSG_ServerConfig> responseObserver); @Override void serialOf(MSG_UUID request, StreamObserver<MSG_OptionalSerial> responseObserver); @Override void enumerateNamespaces(MSG_Empty request,
StreamObserver<MSG_StringSet> responseObserver); @Override void enumerateTypes(MSG_String request,
StreamObserver<MSG_StringSet> responseObserver); @Override @Secured(FactCastRole.WRITE) void publishConditional(MSG_ConditionalPublishRequest request,
StreamObserver<MSG_ConditionalPublishResult> responseObserver); @Override @Secured(FactCastRole.WRITE) void stateFor(MSG_StateForRequest request, StreamObserver<MSG_UUID> responseObserver); @Override @Secured(FactCastRole.WRITE) void invalidate(MSG_UUID request, StreamObserver<MSG_Empty> responseObserver); @Override void currentTime(MSG_Empty request,
StreamObserver<MSG_CurrentDatabaseTime> responseObserver); } | @Test void testPublishNull() { Assertions.assertThrows(NullPointerException.class, () -> { uut.publish(null, mock(StreamObserver.class)); }); }
@Test void testPublishNone() { doNothing().when(backend).publish(acFactList.capture()); MSG_Facts r = MSG_Facts.newBuilder().build(); uut.publish(r, mock(StreamObserver.class)); verify(backend).publish(anyList()); assertTrue(acFactList.getValue().isEmpty()); }
@Test void testPublishSome() { doNothing().when(backend).publish(acFactList.capture()); Builder b = MSG_Facts.newBuilder(); Fact f1 = Fact.builder().ns("test").build("{}"); Fact f2 = Fact.builder().ns("test").build("{}"); MSG_Fact msg1 = conv.toProto(f1); MSG_Fact msg2 = conv.toProto(f2); b.addAllFact(Arrays.asList(msg1, msg2)); MSG_Facts r = b.build(); uut.publish(r, mock(StreamObserver.class)); verify(backend).publish(anyList()); List<Fact> facts = acFactList.getValue(); assertFalse(facts.isEmpty()); assertEquals(2, facts.size()); assertEquals(f1.id(), facts.get(0).id()); assertEquals(f2.id(), facts.get(1).id()); }
@Test public void testPublishThrows() throws Exception { doThrow(UnsupportedOperationException.class).when(backend).publish(anyListOf(Fact.class)); List<Fact> toPublish = Lists.newArrayList(Fact.builder().build("{}")); StreamObserver so = mock(StreamObserver.class); uut.publish(conv.toProto(toPublish), so); verify(so).onError(any(UnsupportedOperationException.class)); } |
FactStoreGrpcService extends RemoteFactStoreImplBase { @Override public void fetchById(MSG_UUID request, StreamObserver<MSG_OptionalFact> responseObserver) { try { enableResponseCompression(responseObserver); UUID fromProto = converter.fromProto(request); log.trace("fetchById {}", fromProto); Optional<Fact> fetchById = store.fetchById(fromProto); log.debug("fetchById({}) was {}found", fromProto, fetchById.map(f -> "") .orElse( "NOT ")); responseObserver.onNext(converter.toProto(fetchById)); responseObserver.onCompleted(); } catch (Throwable e) { responseObserver.onError(e); } } @Override void fetchById(MSG_UUID request,
StreamObserver<MSG_OptionalFact> responseObserver); @Override @Secured(FactCastRole.WRITE) void publish(@NonNull MSG_Facts request,
StreamObserver<MSG_Empty> responseObserver); @Override void subscribe(MSG_SubscriptionRequest request,
StreamObserver<MSG_Notification> responseObserver); @Override void handshake(MSG_Empty request,
StreamObserver<MSG_ServerConfig> responseObserver); @Override void serialOf(MSG_UUID request, StreamObserver<MSG_OptionalSerial> responseObserver); @Override void enumerateNamespaces(MSG_Empty request,
StreamObserver<MSG_StringSet> responseObserver); @Override void enumerateTypes(MSG_String request,
StreamObserver<MSG_StringSet> responseObserver); @Override @Secured(FactCastRole.WRITE) void publishConditional(MSG_ConditionalPublishRequest request,
StreamObserver<MSG_ConditionalPublishResult> responseObserver); @Override @Secured(FactCastRole.WRITE) void stateFor(MSG_StateForRequest request, StreamObserver<MSG_UUID> responseObserver); @Override @Secured(FactCastRole.WRITE) void invalidate(MSG_UUID request, StreamObserver<MSG_Empty> responseObserver); @Override void currentTime(MSG_Empty request,
StreamObserver<MSG_CurrentDatabaseTime> responseObserver); } | @Test void testFetchById() { UUID id = UUID.randomUUID(); uut.fetchById(conv.toProto(id), mock(ServerCallStreamObserver.class)); verify(backend).fetchById(eq(id)); }
@Test void testFetchByIdThrows() { UUID id = UUID.randomUUID(); when(backend.fetchById(any(UUID.class))).thenThrow(UnsupportedOperationException.class); StreamObserver so = mock(StreamObserver.class); uut.fetchById(conv.toProto(id), so); verify(so).onError(any(UnsupportedOperationException.class)); } |
FactStoreGrpcService extends RemoteFactStoreImplBase { @Override public void subscribe(MSG_SubscriptionRequest request, StreamObserver<MSG_Notification> responseObserver) { enableResponseCompression(responseObserver); SubscriptionRequestTO req = converter.fromProto(request); resetDebugInfo(req); BlockingStreamObserver<MSG_Notification> resp = new BlockingStreamObserver<>(req.toString(), (ServerCallStreamObserver) responseObserver); final boolean idOnly = req.idOnly(); store.subscribe(req, new GrpcObserverAdapter(req.toString(), resp, f -> idOnly ? converter .createNotificationFor(f.id()) : converter.createNotificationFor(f))); } @Override void fetchById(MSG_UUID request,
StreamObserver<MSG_OptionalFact> responseObserver); @Override @Secured(FactCastRole.WRITE) void publish(@NonNull MSG_Facts request,
StreamObserver<MSG_Empty> responseObserver); @Override void subscribe(MSG_SubscriptionRequest request,
StreamObserver<MSG_Notification> responseObserver); @Override void handshake(MSG_Empty request,
StreamObserver<MSG_ServerConfig> responseObserver); @Override void serialOf(MSG_UUID request, StreamObserver<MSG_OptionalSerial> responseObserver); @Override void enumerateNamespaces(MSG_Empty request,
StreamObserver<MSG_StringSet> responseObserver); @Override void enumerateTypes(MSG_String request,
StreamObserver<MSG_StringSet> responseObserver); @Override @Secured(FactCastRole.WRITE) void publishConditional(MSG_ConditionalPublishRequest request,
StreamObserver<MSG_ConditionalPublishResult> responseObserver); @Override @Secured(FactCastRole.WRITE) void stateFor(MSG_StateForRequest request, StreamObserver<MSG_UUID> responseObserver); @Override @Secured(FactCastRole.WRITE) void invalidate(MSG_UUID request, StreamObserver<MSG_Empty> responseObserver); @Override void currentTime(MSG_Empty request,
StreamObserver<MSG_CurrentDatabaseTime> responseObserver); } | @Test void testSubscribeFacts() { SubscriptionRequest req = SubscriptionRequest.catchup(FactSpec.ns("foo")).fromNowOn(); when(backend.subscribe(this.reqCaptor.capture(), any())).thenReturn(null); uut.subscribe(new ProtoConverter().toProto(SubscriptionRequestTO.forFacts(req)), mock(ServerCallStreamObserver.class)); verify(backend).subscribe(any(), any()); assertFalse(reqCaptor.getValue().idOnly()); }
@Test void testSubscribeIds() { SubscriptionRequest req = SubscriptionRequest.catchup(FactSpec.ns("foo")).fromNowOn(); when(backend.subscribe(this.reqCaptor.capture(), any())).thenReturn(null); uut.subscribe(new ProtoConverter().toProto(SubscriptionRequestTO.forIds(req)), mock(ServerCallStreamObserver.class)); verify(backend).subscribe(any(), any()); assertTrue(reqCaptor.getValue().idOnly()); } |
FactStoreGrpcService extends RemoteFactStoreImplBase { @Override public void serialOf(MSG_UUID request, StreamObserver<MSG_OptionalSerial> responseObserver) { OptionalLong serialOf = store.serialOf(converter.fromProto(request)); responseObserver.onNext(converter.toProto(serialOf)); responseObserver.onCompleted(); } @Override void fetchById(MSG_UUID request,
StreamObserver<MSG_OptionalFact> responseObserver); @Override @Secured(FactCastRole.WRITE) void publish(@NonNull MSG_Facts request,
StreamObserver<MSG_Empty> responseObserver); @Override void subscribe(MSG_SubscriptionRequest request,
StreamObserver<MSG_Notification> responseObserver); @Override void handshake(MSG_Empty request,
StreamObserver<MSG_ServerConfig> responseObserver); @Override void serialOf(MSG_UUID request, StreamObserver<MSG_OptionalSerial> responseObserver); @Override void enumerateNamespaces(MSG_Empty request,
StreamObserver<MSG_StringSet> responseObserver); @Override void enumerateTypes(MSG_String request,
StreamObserver<MSG_StringSet> responseObserver); @Override @Secured(FactCastRole.WRITE) void publishConditional(MSG_ConditionalPublishRequest request,
StreamObserver<MSG_ConditionalPublishResult> responseObserver); @Override @Secured(FactCastRole.WRITE) void stateFor(MSG_StateForRequest request, StreamObserver<MSG_UUID> responseObserver); @Override @Secured(FactCastRole.WRITE) void invalidate(MSG_UUID request, StreamObserver<MSG_Empty> responseObserver); @Override void currentTime(MSG_Empty request,
StreamObserver<MSG_CurrentDatabaseTime> responseObserver); } | @Test public void testSerialOf() throws Exception { uut = new FactStoreGrpcService(backend); StreamObserver so = mock(StreamObserver.class); assertThrows(NullPointerException.class, () -> { uut.serialOf(null, so); }); UUID id = new UUID(0, 1); OptionalLong twenty_two = OptionalLong.of(22); when(backend.serialOf(id)).thenReturn(twenty_two); uut.serialOf(conv.toProto(id), so); verify(so).onCompleted(); verify(so).onNext(conv.toProto(twenty_two)); verifyNoMoreInteractions(so); }
@Test public void testSerialOfThrows() throws Exception { uut = new FactStoreGrpcService(backend); StreamObserver so = mock(StreamObserver.class); when(backend.serialOf(any(UUID.class))).thenThrow(UnsupportedOperationException.class); assertThrows(UnsupportedOperationException.class, () -> { uut.serialOf(conv.toProto(UUID.randomUUID()), so); }); } |
FactStoreGrpcService extends RemoteFactStoreImplBase { @Override public void enumerateNamespaces(MSG_Empty request, StreamObserver<MSG_StringSet> responseObserver) { try { responseObserver.onNext(converter.toProto(store.enumerateNamespaces())); responseObserver.onCompleted(); } catch (Throwable e) { responseObserver.onError(e); } } @Override void fetchById(MSG_UUID request,
StreamObserver<MSG_OptionalFact> responseObserver); @Override @Secured(FactCastRole.WRITE) void publish(@NonNull MSG_Facts request,
StreamObserver<MSG_Empty> responseObserver); @Override void subscribe(MSG_SubscriptionRequest request,
StreamObserver<MSG_Notification> responseObserver); @Override void handshake(MSG_Empty request,
StreamObserver<MSG_ServerConfig> responseObserver); @Override void serialOf(MSG_UUID request, StreamObserver<MSG_OptionalSerial> responseObserver); @Override void enumerateNamespaces(MSG_Empty request,
StreamObserver<MSG_StringSet> responseObserver); @Override void enumerateTypes(MSG_String request,
StreamObserver<MSG_StringSet> responseObserver); @Override @Secured(FactCastRole.WRITE) void publishConditional(MSG_ConditionalPublishRequest request,
StreamObserver<MSG_ConditionalPublishResult> responseObserver); @Override @Secured(FactCastRole.WRITE) void stateFor(MSG_StateForRequest request, StreamObserver<MSG_UUID> responseObserver); @Override @Secured(FactCastRole.WRITE) void invalidate(MSG_UUID request, StreamObserver<MSG_Empty> responseObserver); @Override void currentTime(MSG_Empty request,
StreamObserver<MSG_CurrentDatabaseTime> responseObserver); } | @Test public void testEnumerateNamespaces() throws Exception { uut = new FactStoreGrpcService(backend); StreamObserver so = mock(StreamObserver.class); when(backend.enumerateNamespaces()).thenReturn(Sets.newHashSet("foo", "bar")); uut.enumerateNamespaces(conv.empty(), so); verify(so).onCompleted(); verify(so).onNext(eq(conv.toProto(Sets.newHashSet("foo", "bar")))); verifyNoMoreInteractions(so); }
@Test public void testEnumerateNamespacesThrows() throws Exception { uut = new FactStoreGrpcService(backend); StreamObserver so = mock(StreamObserver.class); when(backend.enumerateNamespaces()).thenThrow(UnsupportedOperationException.class); uut.enumerateNamespaces(conv.empty(), so); verify(so).onError(any(UnsupportedOperationException.class)); } |
FactStoreGrpcService extends RemoteFactStoreImplBase { @Override public void enumerateTypes(MSG_String request, StreamObserver<MSG_StringSet> responseObserver) { enableResponseCompression(responseObserver); try { Set<String> types = store.enumerateTypes(converter.fromProto( request)); responseObserver.onNext(converter.toProto(types)); responseObserver.onCompleted(); } catch (Throwable e) { responseObserver.onError(e); } } @Override void fetchById(MSG_UUID request,
StreamObserver<MSG_OptionalFact> responseObserver); @Override @Secured(FactCastRole.WRITE) void publish(@NonNull MSG_Facts request,
StreamObserver<MSG_Empty> responseObserver); @Override void subscribe(MSG_SubscriptionRequest request,
StreamObserver<MSG_Notification> responseObserver); @Override void handshake(MSG_Empty request,
StreamObserver<MSG_ServerConfig> responseObserver); @Override void serialOf(MSG_UUID request, StreamObserver<MSG_OptionalSerial> responseObserver); @Override void enumerateNamespaces(MSG_Empty request,
StreamObserver<MSG_StringSet> responseObserver); @Override void enumerateTypes(MSG_String request,
StreamObserver<MSG_StringSet> responseObserver); @Override @Secured(FactCastRole.WRITE) void publishConditional(MSG_ConditionalPublishRequest request,
StreamObserver<MSG_ConditionalPublishResult> responseObserver); @Override @Secured(FactCastRole.WRITE) void stateFor(MSG_StateForRequest request, StreamObserver<MSG_UUID> responseObserver); @Override @Secured(FactCastRole.WRITE) void invalidate(MSG_UUID request, StreamObserver<MSG_Empty> responseObserver); @Override void currentTime(MSG_Empty request,
StreamObserver<MSG_CurrentDatabaseTime> responseObserver); } | @Test public void testEnumerateTypes() throws Exception { uut = new FactStoreGrpcService(backend); StreamObserver so = mock(StreamObserver.class); when(backend.enumerateTypes(eq("ns"))).thenReturn(Sets.newHashSet("foo", "bar")); uut.enumerateTypes(conv.toProto("ns"), so); verify(so).onCompleted(); verify(so).onNext(eq(conv.toProto(Sets.newHashSet("foo", "bar")))); verifyNoMoreInteractions(so); }
@Test public void testEnumerateTypesThrows() throws Exception { uut = new FactStoreGrpcService(backend); StreamObserver so = mock(StreamObserver.class); when(backend.enumerateTypes(eq("ns"))).thenThrow(UnsupportedOperationException.class); uut.enumerateTypes(conv.toProto("ns"), so); verify(so).onError(any(UnsupportedOperationException.class)); } |
FactStoreGrpcService extends RemoteFactStoreImplBase { @Override public void handshake(MSG_Empty request, StreamObserver<MSG_ServerConfig> responseObserver) { ServerConfig cfg = ServerConfig.of(PROTOCOL_VERSION, collectProperties()); responseObserver.onNext(converter.toProto(cfg)); responseObserver.onCompleted(); } @Override void fetchById(MSG_UUID request,
StreamObserver<MSG_OptionalFact> responseObserver); @Override @Secured(FactCastRole.WRITE) void publish(@NonNull MSG_Facts request,
StreamObserver<MSG_Empty> responseObserver); @Override void subscribe(MSG_SubscriptionRequest request,
StreamObserver<MSG_Notification> responseObserver); @Override void handshake(MSG_Empty request,
StreamObserver<MSG_ServerConfig> responseObserver); @Override void serialOf(MSG_UUID request, StreamObserver<MSG_OptionalSerial> responseObserver); @Override void enumerateNamespaces(MSG_Empty request,
StreamObserver<MSG_StringSet> responseObserver); @Override void enumerateTypes(MSG_String request,
StreamObserver<MSG_StringSet> responseObserver); @Override @Secured(FactCastRole.WRITE) void publishConditional(MSG_ConditionalPublishRequest request,
StreamObserver<MSG_ConditionalPublishResult> responseObserver); @Override @Secured(FactCastRole.WRITE) void stateFor(MSG_StateForRequest request, StreamObserver<MSG_UUID> responseObserver); @Override @Secured(FactCastRole.WRITE) void invalidate(MSG_UUID request, StreamObserver<MSG_Empty> responseObserver); @Override void currentTime(MSG_Empty request,
StreamObserver<MSG_CurrentDatabaseTime> responseObserver); } | @Test public void testHandshake() throws Exception { StreamObserver so = mock(StreamObserver.class); uut.handshake(conv.empty(), so); verify(so).onCompleted(); verify(so).onNext(any(MSG_ServerConfig.class)); } |
FactStoreGrpcService extends RemoteFactStoreImplBase { @VisibleForTesting void retrieveImplementationVersion(HashMap<String, String> properties) { String implVersion = "UNKNOWN"; URL propertiesUrl = getProjectProperties(); Properties buildProperties = new Properties(); if (propertiesUrl != null) { try { InputStream is = propertiesUrl.openStream(); if (is != null) { buildProperties.load(is); String v = buildProperties.getProperty("version"); if (v != null) { implVersion = v; } } } catch (Exception ignore) { } } properties.put(Capabilities.FACTCAST_IMPL_VERSION.toString(), implVersion); } @Override void fetchById(MSG_UUID request,
StreamObserver<MSG_OptionalFact> responseObserver); @Override @Secured(FactCastRole.WRITE) void publish(@NonNull MSG_Facts request,
StreamObserver<MSG_Empty> responseObserver); @Override void subscribe(MSG_SubscriptionRequest request,
StreamObserver<MSG_Notification> responseObserver); @Override void handshake(MSG_Empty request,
StreamObserver<MSG_ServerConfig> responseObserver); @Override void serialOf(MSG_UUID request, StreamObserver<MSG_OptionalSerial> responseObserver); @Override void enumerateNamespaces(MSG_Empty request,
StreamObserver<MSG_StringSet> responseObserver); @Override void enumerateTypes(MSG_String request,
StreamObserver<MSG_StringSet> responseObserver); @Override @Secured(FactCastRole.WRITE) void publishConditional(MSG_ConditionalPublishRequest request,
StreamObserver<MSG_ConditionalPublishResult> responseObserver); @Override @Secured(FactCastRole.WRITE) void stateFor(MSG_StateForRequest request, StreamObserver<MSG_UUID> responseObserver); @Override @Secured(FactCastRole.WRITE) void invalidate(MSG_UUID request, StreamObserver<MSG_Empty> responseObserver); @Override void currentTime(MSG_Empty request,
StreamObserver<MSG_CurrentDatabaseTime> responseObserver); } | @Test public void testRetrieveImplementationVersion() throws Exception { uut = spy(uut); when(uut.getProjectProperties()).thenReturn(this.getClass() .getResource( "/test.properties")); HashMap<String, String> map = new HashMap<>(); uut.retrieveImplementationVersion(map); assertEquals("9.9.9", map.get(Capabilities.FACTCAST_IMPL_VERSION.toString())); } |
FactStoreGrpcService extends RemoteFactStoreImplBase { @Override @Secured(FactCastRole.WRITE) public void invalidate(MSG_UUID request, StreamObserver<MSG_Empty> responseObserver) { try { UUID tokenId = converter.fromProto(request); store.invalidate(new StateToken(tokenId)); responseObserver.onNext(MSG_Empty.getDefaultInstance()); responseObserver.onCompleted(); } catch (Throwable e) { responseObserver.onError(e); } } @Override void fetchById(MSG_UUID request,
StreamObserver<MSG_OptionalFact> responseObserver); @Override @Secured(FactCastRole.WRITE) void publish(@NonNull MSG_Facts request,
StreamObserver<MSG_Empty> responseObserver); @Override void subscribe(MSG_SubscriptionRequest request,
StreamObserver<MSG_Notification> responseObserver); @Override void handshake(MSG_Empty request,
StreamObserver<MSG_ServerConfig> responseObserver); @Override void serialOf(MSG_UUID request, StreamObserver<MSG_OptionalSerial> responseObserver); @Override void enumerateNamespaces(MSG_Empty request,
StreamObserver<MSG_StringSet> responseObserver); @Override void enumerateTypes(MSG_String request,
StreamObserver<MSG_StringSet> responseObserver); @Override @Secured(FactCastRole.WRITE) void publishConditional(MSG_ConditionalPublishRequest request,
StreamObserver<MSG_ConditionalPublishResult> responseObserver); @Override @Secured(FactCastRole.WRITE) void stateFor(MSG_StateForRequest request, StreamObserver<MSG_UUID> responseObserver); @Override @Secured(FactCastRole.WRITE) void invalidate(MSG_UUID request, StreamObserver<MSG_Empty> responseObserver); @Override void currentTime(MSG_Empty request,
StreamObserver<MSG_CurrentDatabaseTime> responseObserver); } | @Test public void testInvalidate() throws Exception { { UUID id = UUID.randomUUID(); MSG_UUID req = conv.toProto(id); StreamObserver o = mock(StreamObserver.class); uut.invalidate(req, o); verify(backend).invalidate(eq(new StateToken(id))); verify(o).onNext(any()); verify(o).onCompleted(); } { doThrow(new StatusRuntimeException(Status.DATA_LOSS)).when(backend).invalidate(any()); UUID id = UUID.randomUUID(); MSG_UUID req = conv.toProto(id); StreamObserver o = mock(StreamObserver.class); uut.invalidate(req, o); verify(backend).invalidate(eq(new StateToken(id))); verify(o).onError(any()); verifyNoMoreInteractions(o); } } |
FactStoreGrpcService extends RemoteFactStoreImplBase { @Override @Secured(FactCastRole.WRITE) public void stateFor(MSG_StateForRequest request, StreamObserver<MSG_UUID> responseObserver) { try { StateForRequest req = converter.fromProto(request); StateToken token = store.stateFor(req.aggIds(), Optional.ofNullable(req.ns())); responseObserver.onNext(converter.toProto(token.uuid())); responseObserver.onCompleted(); } catch (Throwable e) { responseObserver.onError(e); } } @Override void fetchById(MSG_UUID request,
StreamObserver<MSG_OptionalFact> responseObserver); @Override @Secured(FactCastRole.WRITE) void publish(@NonNull MSG_Facts request,
StreamObserver<MSG_Empty> responseObserver); @Override void subscribe(MSG_SubscriptionRequest request,
StreamObserver<MSG_Notification> responseObserver); @Override void handshake(MSG_Empty request,
StreamObserver<MSG_ServerConfig> responseObserver); @Override void serialOf(MSG_UUID request, StreamObserver<MSG_OptionalSerial> responseObserver); @Override void enumerateNamespaces(MSG_Empty request,
StreamObserver<MSG_StringSet> responseObserver); @Override void enumerateTypes(MSG_String request,
StreamObserver<MSG_StringSet> responseObserver); @Override @Secured(FactCastRole.WRITE) void publishConditional(MSG_ConditionalPublishRequest request,
StreamObserver<MSG_ConditionalPublishResult> responseObserver); @Override @Secured(FactCastRole.WRITE) void stateFor(MSG_StateForRequest request, StreamObserver<MSG_UUID> responseObserver); @Override @Secured(FactCastRole.WRITE) void invalidate(MSG_UUID request, StreamObserver<MSG_Empty> responseObserver); @Override void currentTime(MSG_Empty request,
StreamObserver<MSG_CurrentDatabaseTime> responseObserver); } | @Test public void testStateFor() throws Exception { { UUID id = UUID.randomUUID(); StateForRequest sfr = new StateForRequest(Lists.newArrayList(id), "foo"); MSG_StateForRequest req = conv.toProto(sfr); StreamObserver o = mock(StreamObserver.class); UUID token = UUID.randomUUID(); when(backend.stateFor(any(), any())).thenReturn(new StateToken(token)); uut.stateFor(req, o); verify(backend).stateFor(eq(Lists.newArrayList(id)), eq(Optional.of("foo"))); verify(o).onNext(eq(conv.toProto(token))); verify(o).onCompleted(); } { doThrow(new StatusRuntimeException(Status.DATA_LOSS)).when(backend) .stateFor(any(), any()); UUID id = UUID.randomUUID(); StateForRequest sfr = new StateForRequest(Lists.newArrayList(id), "foo"); MSG_StateForRequest req = conv.toProto(sfr); StreamObserver o = mock(StreamObserver.class); uut.stateFor(req, o); verify(o).onError(any()); verifyNoMoreInteractions(o); } } |
FactStoreGrpcService extends RemoteFactStoreImplBase { @Override @Secured(FactCastRole.WRITE) public void publishConditional(MSG_ConditionalPublishRequest request, StreamObserver<MSG_ConditionalPublishResult> responseObserver) { try { ConditionalPublishRequest req = converter.fromProto(request); boolean result = store.publishIfUnchanged(req.facts(), req.token()); responseObserver.onNext(converter.toProto(result)); responseObserver.onCompleted(); } catch (Throwable e) { responseObserver.onError(e); } } @Override void fetchById(MSG_UUID request,
StreamObserver<MSG_OptionalFact> responseObserver); @Override @Secured(FactCastRole.WRITE) void publish(@NonNull MSG_Facts request,
StreamObserver<MSG_Empty> responseObserver); @Override void subscribe(MSG_SubscriptionRequest request,
StreamObserver<MSG_Notification> responseObserver); @Override void handshake(MSG_Empty request,
StreamObserver<MSG_ServerConfig> responseObserver); @Override void serialOf(MSG_UUID request, StreamObserver<MSG_OptionalSerial> responseObserver); @Override void enumerateNamespaces(MSG_Empty request,
StreamObserver<MSG_StringSet> responseObserver); @Override void enumerateTypes(MSG_String request,
StreamObserver<MSG_StringSet> responseObserver); @Override @Secured(FactCastRole.WRITE) void publishConditional(MSG_ConditionalPublishRequest request,
StreamObserver<MSG_ConditionalPublishResult> responseObserver); @Override @Secured(FactCastRole.WRITE) void stateFor(MSG_StateForRequest request, StreamObserver<MSG_UUID> responseObserver); @Override @Secured(FactCastRole.WRITE) void invalidate(MSG_UUID request, StreamObserver<MSG_Empty> responseObserver); @Override void currentTime(MSG_Empty request,
StreamObserver<MSG_CurrentDatabaseTime> responseObserver); } | @Test public void testPublishConditional() throws Exception { { UUID id = UUID.randomUUID(); ConditionalPublishRequest sfr = new ConditionalPublishRequest(Lists.newArrayList(), id); MSG_ConditionalPublishRequest req = conv.toProto(sfr); StreamObserver o = mock(StreamObserver.class); when(backend.publishIfUnchanged(any(), any())).thenReturn(true); uut.publishConditional(req, o); verify(backend).publishIfUnchanged(eq(Lists.newArrayList()), eq(Optional.of( new StateToken(id)))); verify(o).onNext(eq(conv.toProto(true))); verify(o).onCompleted(); } { doThrow(new StatusRuntimeException(Status.DATA_LOSS)).when(backend) .publishIfUnchanged(any(), any()); UUID id = UUID.randomUUID(); ConditionalPublishRequest sfr = new ConditionalPublishRequest(Lists.newArrayList(), id); MSG_ConditionalPublishRequest req = conv.toProto(sfr); StreamObserver o = mock(StreamObserver.class); uut.publishConditional(req, o); verify(o).onError(any()); verifyNoMoreInteractions(o); } } |
PgListener implements InitializingBean, DisposableBean { private void listen() { log.trace("Starting instance Listener"); CountDownLatch l = new CountDownLatch(1); listenerThread = new Thread(() -> { while (running.get()) { postEvent("scheduled-poll"); try (PgConnection pc = pgConnectionSupplier.get()) { while (running.get()) { try (PreparedStatement ps = pc.prepareStatement(PgConstants.LISTEN_SQL)) { log.trace("Running LISTEN command"); ps.execute(); } if (pgConnectionTester.test(pc)) { log.trace("Waiting for notifications for {}ms", blockingWaitTimeInMillis); l.countDown(); PGNotification[] notifications = pc.getNotifications( blockingWaitTimeInMillis); if ((notifications != null) && (notifications.length > 0)) { final String name = notifications[0].getName(); log.trace("notifying consumers for '{}'", name); postEvent(name); } else { log.trace("No notifications yet. Looping."); } } else { throw new SQLException("Connection is failing test"); } } } catch (SQLException e) { log.warn("While waiting for Notifications", e); sleep(); } } }, "PG Instance Listener"); listenerThread.setDaemon(true); listenerThread.setUncaughtExceptionHandler( (t, e) -> log.error("thread " + t + " encountered an unhandled exception", e)); listenerThread.start(); try { l.await(15, TimeUnit.SECONDS); } catch (InterruptedException ignored) { } } @Override void afterPropertiesSet(); @Override void destroy(); } | @Test void testListen() throws Exception { Mockito.when(ds.get()).thenReturn(conn); Mockito.when(conn.prepareStatement(anyString())).thenReturn(ps); PgListener l = new PgListener(ds, bus, tester); l.afterPropertiesSet(); sleep(100); verify(bus).post(any(FactInsertionEvent.class)); verifyNoMoreInteractions(bus); verify(conn, atLeastOnce()).prepareStatement(PgConstants.LISTEN_SQL); verify(ps, atLeastOnce()).execute(); l.destroy(); } |
GrpcCompressionInterceptor implements ServerInterceptor { @Override public <ReqT, RespT> Listener<ReqT> interceptCall(ServerCall<ReqT, RespT> call, Metadata headers, ServerCallHandler<ReqT, RespT> next) { codecs.selectFrom(headers.get(GRPC_ACCEPT_ENCODING)).ifPresent(c -> { call.setCompression(c); call.setMessageCompression(false); }); return next.startCall(call, headers); } @Override Listener<ReqT> interceptCall(ServerCall<ReqT, RespT> call,
Metadata headers, ServerCallHandler<ReqT, RespT> next); final Metadata.Key<String> GRPC_ACCEPT_ENCODING; } | @Test void interceptCallWithoutCompression() { ServerCall call = mock(ServerCall.class); Metadata metadata = mock(Metadata.class); ServerCallHandler next = mock(ServerCallHandler.class); uut.interceptCall(call, metadata, next); verify(next).startCall(call, metadata); verifyNoMoreInteractions(call); verifyNoMoreInteractions(next); }
@Test void interceptCallGZip() { ServerCall call = mock(ServerCall.class); Metadata metadata = mock(Metadata.class); when(metadata.get(uut.GRPC_ACCEPT_ENCODING)).thenReturn("gzip"); ServerCallHandler next = mock(ServerCallHandler.class); uut.interceptCall(call, metadata, next); verify(next).startCall(call, metadata); verify(call).setCompression("gzip"); verify(call).setMessageCompression(false); } |
GrpcObserverAdapter implements FactObserver { @Override public void onComplete() { log.info("{} onComplete – sending complete notification", id); observer.onNext(converter.createCompleteNotification()); tryComplete(); } @Override void onComplete(); @Override void onError(Throwable e); @Override void onCatchup(); @Override void onNext(Fact element); } | @Test void testOnComplete() { GrpcObserverAdapter uut = new GrpcObserverAdapter("foo", observer, projection); uut.onComplete(); verify(observer).onCompleted(); }
@Test void testOnCompleteWithException() { GrpcObserverAdapter uut = new GrpcObserverAdapter("foo", observer, projection); doThrow(UnsupportedOperationException.class).when(observer).onCompleted(); uut.onComplete(); verify(observer).onCompleted(); } |
GrpcObserverAdapter implements FactObserver { @Override public void onCatchup() { log.info("{} onCatchup – sending catchup notification", id); observer.onNext(converter.createCatchupNotification()); } @Override void onComplete(); @Override void onError(Throwable e); @Override void onCatchup(); @Override void onNext(Fact element); } | @Test void testOnCatchup() { GrpcObserverAdapter uut = new GrpcObserverAdapter("foo", observer, projection); doNothing().when(observer).onNext(msg.capture()); verify(observer, never()).onNext(any()); uut.onCatchup(); verify(observer).onNext(any()); assertEquals(MSG_Notification.Type.Catchup, msg.getValue().getType()); } |
GrpcObserverAdapter implements FactObserver { @Override public void onError(Throwable e) { log.warn("{} onError – sending Error notification {}", id, e.getMessage()); observer.onError(e); tryComplete(); } @Override void onComplete(); @Override void onError(Throwable e); @Override void onCatchup(); @Override void onNext(Fact element); } | @Test void testOnError() { GrpcObserverAdapter uut = new GrpcObserverAdapter("foo", observer, projection); verify(observer, never()).onNext(any()); uut.onError(new Exception()); verify(observer).onError(any()); } |
GrpcObserverAdapter implements FactObserver { @Override public void onNext(Fact element) { observer.onNext(projection.apply(element)); } @Override void onComplete(); @Override void onError(Throwable e); @Override void onCatchup(); @Override void onNext(Fact element); } | @Test void testOnNext() { ProtoConverter conv = new ProtoConverter(); GrpcObserverAdapter uut = new GrpcObserverAdapter("foo", observer, conv::createNotificationFor); doNothing().when(observer).onNext(msg.capture()); verify(observer, never()).onNext(any()); Fact f = Fact.builder().ns("test").build("{}"); uut.onNext(f); verify(observer).onNext(any()); assertEquals(MSG_Notification.Type.Fact, msg.getValue().getType()); assertEquals(f.id(), conv.fromProto(msg.getValue().getFact()).id()); } |
PgListener implements InitializingBean, DisposableBean { @Override public void destroy() { this.running.set(false); if (listenerThread != null) { listenerThread.interrupt(); } } @Override void afterPropertiesSet(); @Override void destroy(); } | @Test void testStopWithoutStarting() { PgListener l = new PgListener(ds, bus, tester); l.destroy(); verifyNoMoreInteractions(conn); } |
PgConnectionSupplier { @VisibleForTesting Properties buildPgConnectionProperties(org.apache.tomcat.jdbc.pool.DataSource ds) { Properties dbp = new Properties(); final PoolConfiguration poolProperties = ds.getPoolProperties(); if (poolProperties != null) { setProperty(dbp, "user", poolProperties.getUsername()); setProperty(dbp, "password", poolProperties.getPassword()); final String connectionProperties = poolProperties.getConnectionProperties(); if (connectionProperties != null) { try { @SuppressWarnings("UnstableApiUsage") Map<String, String> singleConnectionProperties = Splitter.on(";") .omitEmptyStrings() .withKeyValueSeparator("=") .split(connectionProperties); setProperty(dbp, "socketTimeout", singleConnectionProperties.get( "socketTimeout")); setProperty(dbp, "connectTimeout", singleConnectionProperties.get( "connectTimeout")); setProperty(dbp, "loginTimeout", singleConnectionProperties.get( "loginTimeout")); } catch (IllegalArgumentException e) { throw new IllegalArgumentException("illegal connectionProperties: " + connectionProperties); } } } return dbp; } PgConnectionSupplier(DataSource dataSource); PgConnection get(); } | @Test void test_noRelevantPropertySet() { setupConnectionProperties("sockettimeout=30"); uut.buildPgConnectionProperties(ds); }
@Test void test_propertySyntaxBroken() { Assertions.assertThrows(IllegalArgumentException.class, () -> { setupConnectionProperties("sockettimeout:30"); uut.buildPgConnectionProperties(ds); }); }
@Test void test_nullProperties() { setupConnectionProperties(null); uut.buildPgConnectionProperties(ds); }
@Test void test_invalidConnectionProperties() { Assertions.assertThrows(IllegalArgumentException.class, () -> { setupConnectionProperties("socketTimeout=30;connectTimeout=20,loginTimeout=10;"); uut.buildPgConnectionProperties(ds); failBecauseExceptionWasNotThrown(IllegalArgumentException.class); }); } |
RdsDataSourceFactoryBeanPostProcessor implements BeanPostProcessor { @Override @NonNull public Object postProcessAfterInitialization(@NonNull Object bean, @NonNull String beanName) throws BeansException { return bean; } @Override @NonNull Object postProcessBeforeInitialization(@NonNull Object bean, @NonNull String beanName); @Override @NonNull Object postProcessAfterInitialization(@NonNull Object bean, @NonNull String beanName); } | @Test public void shouldReturnFromAfterInitSameBeanAsPassed() throws Exception { UUID instance = UUID.randomUUID(); Object afterInit = uut.postProcessAfterInitialization(instance, "foo"); assertThat(afterInit).isSameAs(instance); } |
RdsDataSourceFactoryBeanPostProcessor implements BeanPostProcessor { @Override @NonNull public Object postProcessBeforeInitialization(@NonNull Object bean, @NonNull String beanName) throws BeansException { if (bean instanceof AmazonRdsDataSourceFactoryBean) { ((AmazonRdsDataSourceFactoryBean) bean).setDataSourceFactory( tomcatJdbcDataSourceFactory()); } return bean; } @Override @NonNull Object postProcessBeforeInitialization(@NonNull Object bean, @NonNull String beanName); @Override @NonNull Object postProcessAfterInitialization(@NonNull Object bean, @NonNull String beanName); } | @Test public void shouldReturnFromBeforeSameBeanAsPassed() throws Exception { UUID instance = UUID.randomUUID(); Object beforeInit = uut.postProcessBeforeInitialization(instance, "foo"); assertThat(beforeInit).isSameAs(instance); }
@Test public void shouldReplaceJdbcCP() throws Exception { AmazonRdsDataSourceFactoryBean instance = mock(AmazonRdsDataSourceFactoryBean.class); when(env.getProperty(any(), any(), anyBoolean())).thenReturn(true); AmazonRdsDataSourceFactoryBean afterInit = (AmazonRdsDataSourceFactoryBean) uut .postProcessBeforeInitialization(instance, "foo"); assertThat(afterInit).isSameAs(instance); verify(instance).setDataSourceFactory(any()); } |
PgConfigurationProperties implements ApplicationListener<ApplicationReadyEvent> { public int getFetchSizeForIds() { return getQueueSizeForIds() / queueFetchRatio; } int getPageSizeForIds(); int getQueueSizeForIds(); int getFetchSizeForIds(); int getFetchSize(); @Override void onApplicationEvent(ApplicationReadyEvent event); } | @Test void testGetFetchSizeForIds() { assertEquals(25000, uut.getFetchSizeForIds()); } |
InMemFact extends DefaultFact { @Override public String toString() { return FactCastJson.writeValueAsPrettyString(this); } InMemFact(long ser, Fact toCopyFrom); @Override String toString(); } | @Test public void testToString() throws Exception { Fact f = Fact.of("{\"ns\":\"someNs\",\"id\":\"" + UUID.randomUUID() + "\"}", "{}"); InMemFact f1 = new InMemFact(32, f); Fact d = FactCastJson.readValue(DefaultFact.class, f1.toString()); Fact fact = Fact.of(d.jsonHeader(), d.jsonPayload()); InMemFact f2 = new InMemFact(fact.serial(), fact); assertNotSame(f1, f2); assertEquals(f1, f2); } |
FactRenderer { public String render(Fact f) { return "Fact: id=" + f.id() + CR + TAB + "header: " + renderJson(f.jsonHeader()).replaceAll( CR, CR + TAB + TAB) + CR + TAB + "payload: " + renderJson(f.jsonPayload()).replaceAll(CR, CR + TAB + TAB) + CR + CR; } String render(Fact f); } | @Test void testRender() throws Exception { FactRenderer uut = new FactRenderer(new Options()); assertEquals("Fact: id=00000000-0000-0000-0000-000000000000\n" + " header: {\"id\":\"00000000-0000-0000-0000-000000000000\",\"ns\":\"ns\",\"type\":\"type\",\"aggIds\":[\"00000000-0000-0000-0000-000000000001\"],\"meta\":{\"foo\":\"bar\"}}\n" + " payload: {\"some\":\"json\"}\n" + "\n", uut.render(f)); }
@Test void testRenderPretty() throws Exception { Options options = new Options() { @Override public boolean pretty() { return true; } }; FactRenderer uut = new FactRenderer(options); assertEquals( "Fact: id=00000000-0000-0000-0000-000000000000\n" + " header: {\n" + " \"id\" : \"00000000-0000-0000-0000-000000000000\",\n" + " \"ns\" : \"ns\",\n" + " \"type\" : \"type\",\n" + " \"aggIds\" : [ \"00000000-0000-0000-0000-000000000001\" ],\n" + " \"meta\" : {\n" + " \"foo\" : \"bar\"\n" + " }\n" + " }\n" + " payload: {\n" + " \"some\" : \"json\"\n" + " }\n" + "\n" + "", uut.render(f)); } |
Catchup implements Command { @Override public void runWith(FactCast fc, Options opt) { ConsoleFactObserver obs = new ConsoleFactObserver(opt); SpecBuilder catchup = SubscriptionRequest.catchup(FactSpec.ns(ns)); if (from == null) fc.subscribeEphemeral(catchup.fromScratch(), obs); else fc.subscribeEphemeral(catchup.from(from), obs); obs.awaitTermination(); } @Override void runWith(FactCast fc, Options opt); } | @Test void testCatchup() { String ns = "foo"; UUID startId = new UUID(0, 1); Catchup cmd = new Catchup(ns, startId); fc = spy(FactCast.from(fs)); Options opt = new Options(); when(fs.subscribe(any(), any(ConsoleFactObserver.class))).thenAnswer(invocation -> { Object[] args = invocation.getArguments(); GenericObserver<?> o = (GenericObserver<?>) args[1]; o.onCatchup(); o.onComplete(); SubscriptionRequest r = (SubscriptionRequest) args[0]; List<FactSpec> specs = new ArrayList<>(r.specs()); assertEquals(startId, r.startingAfter().get()); assertEquals(ns, specs.iterator().next().ns()); return null; }); cmd.runWith(fc, opt); verify(fc).subscribeEphemeral(any(SubscriptionRequest.class), any(ConsoleFactObserver.class)); } |
ProtoConverter { @NonNull public MSG_UUID toProto(@NonNull UUID id) { return MSG_UUID.newBuilder() .setLsb(id.getLeastSignificantBits()) .setMsb(id.getMostSignificantBits()) .build(); } MSG_Notification createCatchupNotification(); MSG_Notification createCompleteNotification(); MSG_Notification createNotificationFor(@NonNull Fact t); MSG_Notification createNotificationFor(@NonNull UUID id); @NonNull MSG_UUID toProto(@NonNull UUID id); SubscriptionRequestTO fromProto(@NonNull MSG_SubscriptionRequest request); MSG_SubscriptionRequest toProto(SubscriptionRequestTO request); UUID fromProto(MSG_UUID request); Fact fromProto(MSG_Fact protoFact); MSG_Fact toProto(Fact factMark); MSG_OptionalFact toProto(Optional<Fact> optFact); Optional<Fact> fromProto(@NonNull MSG_OptionalFact message); @NonNull OptionalLong fromProto(@NonNull MSG_OptionalSerial serialOf); @NonNull ProtocolVersion fromProto(@NonNull MSG_ServerProtocolVersion msg); @NonNull Map<String, String> fromProto(@NonNull MSG_ServerProperties msg); @NonNull ServerConfig fromProto(@NonNull MSG_ServerConfig msg); @NonNull MSG_ServerProtocolVersion toProto(@NonNull ProtocolVersion v); @NonNull MSG_ServerConfig toProto(@NonNull ServerConfig cfg); @NonNull MSG_ServerProperties toProto(@NonNull Map<String, String> property); MSG_Empty empty(); MSG_OptionalSerial toProto(OptionalLong serialOf); Set<String> fromProto(MSG_StringSet set); MSG_StringSet toProto(Set<String> set); MSG_String toProto(String ns); String fromProto(MSG_String request); @NonNull MSG_Facts toProto(@NonNull List<? extends Fact> toPublish); StateForRequest fromProto(MSG_StateForRequest request); ConditionalPublishRequest fromProto(@NonNull MSG_ConditionalPublishRequest request); @NonNull List<? extends Fact> fromProto(@NonNull MSG_Facts facts); MSG_ConditionalPublishResult toProto(boolean result); MSG_StateForRequest toProto(@NonNull StateForRequest req); MSG_ConditionalPublishRequest toProto(@NonNull ConditionalPublishRequest req); long fromProto(@NonNull MSG_CurrentDatabaseTime resp); MSG_CurrentDatabaseTime toProto(long currentTime); } | @Test void testToProtoUUIDNull() { Assertions.assertThrows(NullPointerException.class, () -> { uut.toProto((UUID) null); }); }
@Test void testToProtoFactNull() { Assertions.assertThrows(NullPointerException.class, () -> { uut.toProto((Fact) null); }); }
@Test void testToProtoFacts_empty() { MSG_Facts proto = uut.toProto(new ArrayList<Fact>()); assertTrue(proto.getFactList().isEmpty()); }
@Test void testToProtoFacts_nullArg() { assertThrows(NullPointerException.class, () -> { uut.toProto((List<Fact>) null); }); }
@Test void testToProtoSubscriptionRequestNull() { Assertions.assertThrows(NullPointerException.class, () -> { uut.toProto((SubscriptionRequestTO) null); }); }
@Test void testToProtoOptionalLongPresent() { MSG_OptionalSerial msg = uut.toProto(OptionalLong.of(133)); assertTrue(msg.getPresent()); assertEquals(133, msg.getSerial()); }
@Test public void testToProtoBoolean() throws Exception { assertFalse(uut.toProto(false).getSuccess()); assertTrue(uut.toProto(true).getSuccess()); }
@Test public void testToProtoStateForRequest() throws Exception { assertThrows(NullPointerException.class, () -> { uut.toProto((StateForRequest) null); }); StateForRequest req = new StateForRequest(Lists.emptyList(), null); MSG_StateForRequest msg = uut.toProto(req); assertThat(msg.getNsPresent()).isFalse(); assertThat(msg.getAggIdsList()).isEmpty(); req = new StateForRequest(Lists.emptyList(), "foo"); msg = uut.toProto(req); assertThat(msg.getNsPresent()).isTrue(); assertThat(msg.getNs()).isEqualTo("foo"); assertThat(msg.getAggIdsList()).isEmpty(); UUID u1 = new UUID(0, 1); UUID u2 = new UUID(0, 2); List<UUID> ids = Arrays.asList(u1, u2); req = new StateForRequest(ids, "foo"); msg = uut.toProto(req); assertThat(msg.getNsPresent()).isTrue(); assertThat(msg.getNs()).isEqualTo("foo"); assertThat(msg.getAggIdsList()).isNotEmpty(); assertThat(msg.getAggIdsList().size()).isEqualTo(2); assertThat(msg.getAggIdsList().get(0)).isEqualTo(uut.toProto(u1)); assertThat(msg.getAggIdsList().get(1)).isEqualTo(uut.toProto(u2)); }
@Test public void testToProtoConditionalPublishRequest() throws Exception { assertThrows(NullPointerException.class, () -> { uut.toProto((ConditionalPublishRequest) null); }); { UUID id = UUID.randomUUID(); Fact f2 = new TestFact(); Fact f1 = new TestFact(); ConditionalPublishRequest req = new ConditionalPublishRequest(Lists.newArrayList(f1, f2), id); MSG_ConditionalPublishRequest msg = uut.toProto(req); assertThat(msg.getTokenPresent()).isTrue(); assertThat(msg.getToken()).isEqualTo(uut.toProto(id)); assertThat(msg.getFacts().getFactList().get(0)).isEqualTo(uut.toProto(f1)); assertThat(msg.getFacts().getFactList().get(1)).isEqualTo(uut.toProto(f2)); assertThat(msg.getFacts().getFactList().size()).isEqualTo(2); } { Fact f2 = new TestFact(); Fact f1 = new TestFact(); ConditionalPublishRequest req = new ConditionalPublishRequest(Lists.newArrayList(f1, f2), null); MSG_ConditionalPublishRequest msg = uut.toProto(req); assertThat(msg.getTokenPresent()).isFalse(); assertThat(msg.getFacts().getFactList().get(0)).isEqualTo(uut.toProto(f1)); assertThat(msg.getFacts().getFactList().get(1)).isEqualTo(uut.toProto(f2)); assertThat(msg.getFacts().getFactList().size()).isEqualTo(2); } } |
ProtoConverter { public SubscriptionRequestTO fromProto(@NonNull MSG_SubscriptionRequest request) { return FactCastJson.readValue(SubscriptionRequestTO.class, request.getJson()); } MSG_Notification createCatchupNotification(); MSG_Notification createCompleteNotification(); MSG_Notification createNotificationFor(@NonNull Fact t); MSG_Notification createNotificationFor(@NonNull UUID id); @NonNull MSG_UUID toProto(@NonNull UUID id); SubscriptionRequestTO fromProto(@NonNull MSG_SubscriptionRequest request); MSG_SubscriptionRequest toProto(SubscriptionRequestTO request); UUID fromProto(MSG_UUID request); Fact fromProto(MSG_Fact protoFact); MSG_Fact toProto(Fact factMark); MSG_OptionalFact toProto(Optional<Fact> optFact); Optional<Fact> fromProto(@NonNull MSG_OptionalFact message); @NonNull OptionalLong fromProto(@NonNull MSG_OptionalSerial serialOf); @NonNull ProtocolVersion fromProto(@NonNull MSG_ServerProtocolVersion msg); @NonNull Map<String, String> fromProto(@NonNull MSG_ServerProperties msg); @NonNull ServerConfig fromProto(@NonNull MSG_ServerConfig msg); @NonNull MSG_ServerProtocolVersion toProto(@NonNull ProtocolVersion v); @NonNull MSG_ServerConfig toProto(@NonNull ServerConfig cfg); @NonNull MSG_ServerProperties toProto(@NonNull Map<String, String> property); MSG_Empty empty(); MSG_OptionalSerial toProto(OptionalLong serialOf); Set<String> fromProto(MSG_StringSet set); MSG_StringSet toProto(Set<String> set); MSG_String toProto(String ns); String fromProto(MSG_String request); @NonNull MSG_Facts toProto(@NonNull List<? extends Fact> toPublish); StateForRequest fromProto(MSG_StateForRequest request); ConditionalPublishRequest fromProto(@NonNull MSG_ConditionalPublishRequest request); @NonNull List<? extends Fact> fromProto(@NonNull MSG_Facts facts); MSG_ConditionalPublishResult toProto(boolean result); MSG_StateForRequest toProto(@NonNull StateForRequest req); MSG_ConditionalPublishRequest toProto(@NonNull ConditionalPublishRequest req); long fromProto(@NonNull MSG_CurrentDatabaseTime resp); MSG_CurrentDatabaseTime toProto(long currentTime); } | @Test void testFromProtoOptionalNull() { Assertions.assertThrows(NullPointerException.class, () -> { uut.fromProto((MSG_OptionalFact) null); }); }
@Test void testFromProtoMSG_SubscriptionRequestNull() { Assertions.assertThrows(NullPointerException.class, () -> { uut.fromProto((MSG_SubscriptionRequest) null); }); }
@Test public void testFromProtoMSG_OptionalSerial() throws Exception { assertThrows(NullPointerException.class, () -> { uut.fromProto((MSG_OptionalSerial) null); }); assertFalse(uut.fromProto(MSG_OptionalSerial.newBuilder() .setPresent(false) .setSerial(4) .build()).isPresent()); assertFalse(uut.fromProto(MSG_OptionalSerial.newBuilder().setPresent(false).build()) .isPresent()); @NonNull OptionalLong optSerial = uut.fromProto(MSG_OptionalSerial.newBuilder() .setPresent(true) .setSerial(4) .build()); assertTrue(optSerial.isPresent()); assertEquals(4, optSerial.getAsLong()); }
@Test public void testFromProtoMSG_ServerProtocolVersion() throws Exception { assertThrows(NullPointerException.class, () -> { uut.fromProto((MSG_ServerProtocolVersion) null); }); assertEquals(ProtocolVersion.of(1, 2, 3), uut.fromProto(MSG_ServerProtocolVersion.newBuilder() .setMajor(1) .setMinor(2) .setPatch(3) .build())); }
@Test public void testFromProtoMSG_ServerProperties() throws Exception { assertThrows(NullPointerException.class, () -> { uut.fromProto((MSG_ServerProperties) null); }); assertEquals(Maps.newHashMap("foo", "bar"), uut.fromProto(MSG_ServerProperties.newBuilder().putProperty("foo", "bar").build())); }
@Test public void testFromProtoMSG_StateForRequest_nsSet() throws Exception { MSG_StateForRequest request = MSG_StateForRequest.newBuilder() .setNs("foo") .setNsPresent(true) .addAggIds(MSG_UUID.newBuilder().setLsb(1).setMsb(2).build()) .build(); StateForRequest req = uut.fromProto(request); assertEquals("foo", req.ns()); assertNotNull(req.aggIds()); assertEquals(1, req.aggIds().size()); assertEquals(new UUID(2, 1), req.aggIds().get(0)); }
@Test public void testFromProtoMSG_StateForRequest_nsNotSet() throws Exception { MSG_StateForRequest request = MSG_StateForRequest.newBuilder() .setNs("foo") .setNsPresent(false) .addAggIds(MSG_UUID.newBuilder().setLsb(1).setMsb(2).build()) .build(); StateForRequest req = uut.fromProto(request); assertThat(req.ns()).isNull(); assertNotNull(req.aggIds()); assertEquals(1, req.aggIds().size()); assertEquals(new UUID(2, 1), req.aggIds().get(0)); }
@Test public void testFromProtoMSG_StateForRequest_emptyAggIds() throws Exception { MSG_StateForRequest request = MSG_StateForRequest.newBuilder().setNsPresent(false).build(); StateForRequest req = uut.fromProto(request); assertNotNull(req.aggIds()); assertEquals(0, req.aggIds().size()); }
@Test public void testFromProtoMSG_Facts() throws Exception { assertThrows(NullPointerException.class, () -> { uut.fromProto((MSG_Facts) null); }); }
@Test public void testFromProtoMSG_CurrentDatabaseTimeNull() throws Exception { assertThrows(NullPointerException.class, () -> { MSG_CurrentDatabaseTime t = null; uut.fromProto(t); }); } |
ProtoConverter { public MSG_Notification createCatchupNotification() { return MSG_Notification.newBuilder().setType(MSG_Notification.Type.Catchup).build(); } MSG_Notification createCatchupNotification(); MSG_Notification createCompleteNotification(); MSG_Notification createNotificationFor(@NonNull Fact t); MSG_Notification createNotificationFor(@NonNull UUID id); @NonNull MSG_UUID toProto(@NonNull UUID id); SubscriptionRequestTO fromProto(@NonNull MSG_SubscriptionRequest request); MSG_SubscriptionRequest toProto(SubscriptionRequestTO request); UUID fromProto(MSG_UUID request); Fact fromProto(MSG_Fact protoFact); MSG_Fact toProto(Fact factMark); MSG_OptionalFact toProto(Optional<Fact> optFact); Optional<Fact> fromProto(@NonNull MSG_OptionalFact message); @NonNull OptionalLong fromProto(@NonNull MSG_OptionalSerial serialOf); @NonNull ProtocolVersion fromProto(@NonNull MSG_ServerProtocolVersion msg); @NonNull Map<String, String> fromProto(@NonNull MSG_ServerProperties msg); @NonNull ServerConfig fromProto(@NonNull MSG_ServerConfig msg); @NonNull MSG_ServerProtocolVersion toProto(@NonNull ProtocolVersion v); @NonNull MSG_ServerConfig toProto(@NonNull ServerConfig cfg); @NonNull MSG_ServerProperties toProto(@NonNull Map<String, String> property); MSG_Empty empty(); MSG_OptionalSerial toProto(OptionalLong serialOf); Set<String> fromProto(MSG_StringSet set); MSG_StringSet toProto(Set<String> set); MSG_String toProto(String ns); String fromProto(MSG_String request); @NonNull MSG_Facts toProto(@NonNull List<? extends Fact> toPublish); StateForRequest fromProto(MSG_StateForRequest request); ConditionalPublishRequest fromProto(@NonNull MSG_ConditionalPublishRequest request); @NonNull List<? extends Fact> fromProto(@NonNull MSG_Facts facts); MSG_ConditionalPublishResult toProto(boolean result); MSG_StateForRequest toProto(@NonNull StateForRequest req); MSG_ConditionalPublishRequest toProto(@NonNull ConditionalPublishRequest req); long fromProto(@NonNull MSG_CurrentDatabaseTime resp); MSG_CurrentDatabaseTime toProto(long currentTime); } | @Test void testCreateCatchupNotification() { MSG_Notification n = uut.createCatchupNotification(); assertNotNull(n); assertEquals(MSG_Notification.Type.Catchup, n.getType()); } |
PgConfigurationProperties implements ApplicationListener<ApplicationReadyEvent> { public int getFetchSize() { return getQueueSize() / queueFetchRatio; } int getPageSizeForIds(); int getQueueSizeForIds(); int getFetchSizeForIds(); int getFetchSize(); @Override void onApplicationEvent(ApplicationReadyEvent event); } | @Test void testGetFetchSize() { assertEquals(250, uut.getFetchSize()); } |
ProtoConverter { public MSG_Notification createCompleteNotification() { return MSG_Notification.newBuilder().setType(MSG_Notification.Type.Complete).build(); } MSG_Notification createCatchupNotification(); MSG_Notification createCompleteNotification(); MSG_Notification createNotificationFor(@NonNull Fact t); MSG_Notification createNotificationFor(@NonNull UUID id); @NonNull MSG_UUID toProto(@NonNull UUID id); SubscriptionRequestTO fromProto(@NonNull MSG_SubscriptionRequest request); MSG_SubscriptionRequest toProto(SubscriptionRequestTO request); UUID fromProto(MSG_UUID request); Fact fromProto(MSG_Fact protoFact); MSG_Fact toProto(Fact factMark); MSG_OptionalFact toProto(Optional<Fact> optFact); Optional<Fact> fromProto(@NonNull MSG_OptionalFact message); @NonNull OptionalLong fromProto(@NonNull MSG_OptionalSerial serialOf); @NonNull ProtocolVersion fromProto(@NonNull MSG_ServerProtocolVersion msg); @NonNull Map<String, String> fromProto(@NonNull MSG_ServerProperties msg); @NonNull ServerConfig fromProto(@NonNull MSG_ServerConfig msg); @NonNull MSG_ServerProtocolVersion toProto(@NonNull ProtocolVersion v); @NonNull MSG_ServerConfig toProto(@NonNull ServerConfig cfg); @NonNull MSG_ServerProperties toProto(@NonNull Map<String, String> property); MSG_Empty empty(); MSG_OptionalSerial toProto(OptionalLong serialOf); Set<String> fromProto(MSG_StringSet set); MSG_StringSet toProto(Set<String> set); MSG_String toProto(String ns); String fromProto(MSG_String request); @NonNull MSG_Facts toProto(@NonNull List<? extends Fact> toPublish); StateForRequest fromProto(MSG_StateForRequest request); ConditionalPublishRequest fromProto(@NonNull MSG_ConditionalPublishRequest request); @NonNull List<? extends Fact> fromProto(@NonNull MSG_Facts facts); MSG_ConditionalPublishResult toProto(boolean result); MSG_StateForRequest toProto(@NonNull StateForRequest req); MSG_ConditionalPublishRequest toProto(@NonNull ConditionalPublishRequest req); long fromProto(@NonNull MSG_CurrentDatabaseTime resp); MSG_CurrentDatabaseTime toProto(long currentTime); } | @Test void testCreateCompleteNotification() { MSG_Notification n = uut.createCompleteNotification(); assertNotNull(n); assertEquals(MSG_Notification.Type.Complete, n.getType()); } |
ProtoConverter { public MSG_Notification createNotificationFor(@NonNull Fact t) { MSG_Notification.Builder builder = MSG_Notification.newBuilder() .setType(MSG_Notification.Type.Fact); builder.setFact(toProto(t)); return builder.build(); } MSG_Notification createCatchupNotification(); MSG_Notification createCompleteNotification(); MSG_Notification createNotificationFor(@NonNull Fact t); MSG_Notification createNotificationFor(@NonNull UUID id); @NonNull MSG_UUID toProto(@NonNull UUID id); SubscriptionRequestTO fromProto(@NonNull MSG_SubscriptionRequest request); MSG_SubscriptionRequest toProto(SubscriptionRequestTO request); UUID fromProto(MSG_UUID request); Fact fromProto(MSG_Fact protoFact); MSG_Fact toProto(Fact factMark); MSG_OptionalFact toProto(Optional<Fact> optFact); Optional<Fact> fromProto(@NonNull MSG_OptionalFact message); @NonNull OptionalLong fromProto(@NonNull MSG_OptionalSerial serialOf); @NonNull ProtocolVersion fromProto(@NonNull MSG_ServerProtocolVersion msg); @NonNull Map<String, String> fromProto(@NonNull MSG_ServerProperties msg); @NonNull ServerConfig fromProto(@NonNull MSG_ServerConfig msg); @NonNull MSG_ServerProtocolVersion toProto(@NonNull ProtocolVersion v); @NonNull MSG_ServerConfig toProto(@NonNull ServerConfig cfg); @NonNull MSG_ServerProperties toProto(@NonNull Map<String, String> property); MSG_Empty empty(); MSG_OptionalSerial toProto(OptionalLong serialOf); Set<String> fromProto(MSG_StringSet set); MSG_StringSet toProto(Set<String> set); MSG_String toProto(String ns); String fromProto(MSG_String request); @NonNull MSG_Facts toProto(@NonNull List<? extends Fact> toPublish); StateForRequest fromProto(MSG_StateForRequest request); ConditionalPublishRequest fromProto(@NonNull MSG_ConditionalPublishRequest request); @NonNull List<? extends Fact> fromProto(@NonNull MSG_Facts facts); MSG_ConditionalPublishResult toProto(boolean result); MSG_StateForRequest toProto(@NonNull StateForRequest req); MSG_ConditionalPublishRequest toProto(@NonNull ConditionalPublishRequest req); long fromProto(@NonNull MSG_CurrentDatabaseTime resp); MSG_CurrentDatabaseTime toProto(long currentTime); } | @Test void testCreateNotificationForFactNull() { Assertions.assertThrows(NullPointerException.class, () -> { uut.createNotificationFor((Fact) null); }); }
@Test void testCreateNotificationForIdNull() { Assertions.assertThrows(NullPointerException.class, () -> { uut.createNotificationFor((UUID) null); }); } |
ProtoConverter { public MSG_Empty empty() { return EMPTY; } MSG_Notification createCatchupNotification(); MSG_Notification createCompleteNotification(); MSG_Notification createNotificationFor(@NonNull Fact t); MSG_Notification createNotificationFor(@NonNull UUID id); @NonNull MSG_UUID toProto(@NonNull UUID id); SubscriptionRequestTO fromProto(@NonNull MSG_SubscriptionRequest request); MSG_SubscriptionRequest toProto(SubscriptionRequestTO request); UUID fromProto(MSG_UUID request); Fact fromProto(MSG_Fact protoFact); MSG_Fact toProto(Fact factMark); MSG_OptionalFact toProto(Optional<Fact> optFact); Optional<Fact> fromProto(@NonNull MSG_OptionalFact message); @NonNull OptionalLong fromProto(@NonNull MSG_OptionalSerial serialOf); @NonNull ProtocolVersion fromProto(@NonNull MSG_ServerProtocolVersion msg); @NonNull Map<String, String> fromProto(@NonNull MSG_ServerProperties msg); @NonNull ServerConfig fromProto(@NonNull MSG_ServerConfig msg); @NonNull MSG_ServerProtocolVersion toProto(@NonNull ProtocolVersion v); @NonNull MSG_ServerConfig toProto(@NonNull ServerConfig cfg); @NonNull MSG_ServerProperties toProto(@NonNull Map<String, String> property); MSG_Empty empty(); MSG_OptionalSerial toProto(OptionalLong serialOf); Set<String> fromProto(MSG_StringSet set); MSG_StringSet toProto(Set<String> set); MSG_String toProto(String ns); String fromProto(MSG_String request); @NonNull MSG_Facts toProto(@NonNull List<? extends Fact> toPublish); StateForRequest fromProto(MSG_StateForRequest request); ConditionalPublishRequest fromProto(@NonNull MSG_ConditionalPublishRequest request); @NonNull List<? extends Fact> fromProto(@NonNull MSG_Facts facts); MSG_ConditionalPublishResult toProto(boolean result); MSG_StateForRequest toProto(@NonNull StateForRequest req); MSG_ConditionalPublishRequest toProto(@NonNull ConditionalPublishRequest req); long fromProto(@NonNull MSG_CurrentDatabaseTime resp); MSG_CurrentDatabaseTime toProto(long currentTime); } | @Test void testEmpty() { assertEquals(MSG_Empty.newBuilder().build(), uut.empty()); } |
PgQueryBuilder { public PgQueryBuilder(@NonNull SubscriptionRequestTO request) { this.req = request; selectIdOnly = request.idOnly() && !request.hasAnyScriptFilters(); } PgQueryBuilder(@NonNull SubscriptionRequestTO request); PreparedStatementSetter createStatementSetter(@NonNull AtomicLong serial); String createSQL(); String catchupSQL(long clientId); } | @Test public void testPGQueryBuilder() throws Exception { assertThrows(NullPointerException.class, () -> { new PgQueryBuilder(null); }); PgQueryBuilder uut = new PgQueryBuilder(mock(SubscriptionRequestTO.class)); assertThrows(NullPointerException.class, () -> { uut.createStatementSetter(null); }); } |
ProtocolVersion { public boolean isCompatibleTo(ProtocolVersion other) { return (major == other.major) && (minor <= other.minor); } boolean isCompatibleTo(ProtocolVersion other); @Override String toString(); } | @Test void testIsCompatibleTo() { assertTrue(ProtocolVersion.of(1, 0, 0).isCompatibleTo(ProtocolVersion.of(1, 0, 0))); assertTrue(ProtocolVersion.of(1, 0, 0).isCompatibleTo(ProtocolVersion.of(1, 0, 1))); assertTrue(ProtocolVersion.of(1, 0, 0).isCompatibleTo(ProtocolVersion.of(1, 1, 0))); assertFalse(ProtocolVersion.of(1, 1, 0).isCompatibleTo(ProtocolVersion.of(1, 0, 0))); assertFalse(ProtocolVersion.of(1, 1, 0).isCompatibleTo(ProtocolVersion.of(2, 0, 0))); } |
ProtocolVersion { @Override public String toString() { StringJoiner joiner = new StringJoiner("."); joiner.add(String.valueOf(major)).add(String.valueOf(minor)).add(String.valueOf(patch)); return joiner.toString(); } boolean isCompatibleTo(ProtocolVersion other); @Override String toString(); } | @Test void testToString() { assertEquals("3.1.2", ProtocolVersion.of(3, 1, 2).toString()); } |
PgSynchronizedQuery { @SuppressWarnings("SameReturnValue") public synchronized void run(boolean useIndex) { long latest = latestFetcher.retrieveLatestSer(); transactionTemplate.execute(status -> { if (!useIndex) jdbcTemplate.execute("SET LOCAL enable_bitmapscan=0;"); jdbcTemplate.query(sql, setter, rowHandler); return null; }); serialToContinueFrom.set(Math.max(latest, serialToContinueFrom.get())); } PgSynchronizedQuery(@NonNull JdbcTemplate jdbcTemplate, @NonNull String sql,
@NonNull PreparedStatementSetter setter, @NonNull RowCallbackHandler rowHandler,
AtomicLong serialToContinueFrom, PgLatestSerialFetcher fetcher); @SuppressWarnings("SameReturnValue") synchronized void run(boolean useIndex); } | @Test public void testRunWithIndex() throws Exception { uut = new PgSynchronizedQuery(jdbcTemplate, sql, setter, rowHandler, serialToContinueFrom, fetcher); uut.run(true); verify(jdbcTemplate, never()).execute(startsWith("SET LOCAL enable_bitmapscan")); }
@Test public void testRunWithoutIndex() throws Exception { uut = new PgSynchronizedQuery(jdbcTemplate, sql, setter, rowHandler, serialToContinueFrom, fetcher); uut.run(false); verify(jdbcTemplate).execute(startsWith("SET LOCAL enable_bitmapscan")); } |
SnappyGrpcClientCodec implements Codec { @Override public String getMessageEncoding() { return "snappy"; } @Override String getMessageEncoding(); @Override OutputStream compress(OutputStream os); @Override InputStream decompress(InputStream is); } | @Test void getMessageEncoding() { assertEquals("snappy", uut.getMessageEncoding()); } |
Lz4GrpcClientCodec implements Codec { @Override public String getMessageEncoding() { return "lz4"; } @Override String getMessageEncoding(); @Override InputStream decompress(InputStream inputStream); @Override OutputStream compress(OutputStream outputStream); } | @Test void getMessageEncoding() { assertEquals("lz4", uut.getMessageEncoding()); } |
ClientStreamObserver implements StreamObserver<FactStoreProto.MSG_Notification> { @Override public void onNext(MSG_Notification f) { log.trace("observer got msg: {}", f); switch (f.getType()) { case Catchup: log.debug("received onCatchup signal"); subscription.notifyCatchup(); break; case Complete: log.debug("received onComplete signal"); subscription.notifyComplete(); break; case Fact: subscription.notifyElement(converter.fromProto(f.getFact())); break; case Id: subscription.notifyElement(new IdOnlyFact(converter.fromProto(f.getId()))); break; default: subscription.notifyError(new RuntimeException( "Unrecognized notification type. THIS IS A BUG!")); break; } } @Override void onNext(MSG_Notification f); @Override void onError(Throwable t); @Override void onCompleted(); } | @Test void testOnNext() { Fact f = Fact.of("{\"ns\":\"ns\",\"id\":\"" + UUID.randomUUID() + "\"}", "{}"); MSG_Notification n = converter.createNotificationFor(f); uut.onNext(n); verify(factObserver).onNext(eq(f)); }
@Test void testOnNextFailsOnUnknownMessage() { assertThrows(IllegalArgumentException.class, () -> { MSG_Notification n = MSG_Notification.newBuilder().setType(Type.UNRECOGNIZED).build(); uut.onNext(n); }); }
@Test void testOnNextId() { MSG_Notification n = converter.createNotificationFor(UUID.randomUUID()); uut.onNext(n); verify(factObserver).onNext(any(IdOnlyFact.class)); }
@Test void testOnCatchup() { uut.onNext(converter.createCatchupNotification()); verify(factObserver).onCatchup(); }
@Test void testFailOnUnknownType() { uut.onNext(MSG_Notification.newBuilder().setTypeValue(999).build()); verify(subscription).notifyError(any(RuntimeException.class)); }
@Test void testOnComplete() { uut.onNext(converter.createCompleteNotification()); verify(factObserver).onComplete(); } |
ClientStreamObserver implements StreamObserver<FactStoreProto.MSG_Notification> { @Override public void onCompleted() { subscription.notifyComplete(); } @Override void onNext(MSG_Notification f); @Override void onError(Throwable t); @Override void onCompleted(); } | @Test void testOnTransportComplete() { uut.onCompleted(); verify(factObserver).onComplete(); } |
ClientStreamObserver implements StreamObserver<FactStoreProto.MSG_Notification> { @Override public void onError(Throwable t) { subscription.notifyError(t); } @Override void onNext(MSG_Notification f); @Override void onError(Throwable t); @Override void onCompleted(); } | @Test void testOnError() { uut.onError(new IOException()); verify(factObserver).onError(any()); } |
GrpcFactStore implements FactStore, SmartInitializingSingleton { @Override public Optional<Fact> fetchById(UUID id) { log.trace("fetching {} from remote store", id); MSG_OptionalFact fetchById; try { fetchById = blockingStub.fetchById(converter.toProto(id)); } catch (StatusRuntimeException e) { throw wrapRetryable(e); } if (!fetchById.getPresent()) { return Optional.empty(); } else { return converter.fromProto(fetchById); } } @SuppressWarnings("OptionalUsedAsFieldOrParameterType") @Autowired @Generated GrpcFactStore(FactCastGrpcChannelFactory channelFactory,
@Value("${grpc.client.factstore.credentials:#{null}}") Optional<String> credentials); @Generated @VisibleForTesting GrpcFactStore(Channel channel,
Optional<String> credentials); private GrpcFactStore(RemoteFactStoreBlockingStub newBlockingStub, RemoteFactStoreStub newStub,
Optional<String> credentials); @Override Optional<Fact> fetchById(UUID id); @Override void publish(@NonNull List<? extends Fact> factsToPublish); @Override Subscription subscribe(@NonNull SubscriptionRequestTO req,
@NonNull FactObserver observer); @Override OptionalLong serialOf(@NonNull UUID l); synchronized void initialize(); @Override synchronized void afterSingletonsInstantiated(); @Override Set<String> enumerateNamespaces(); @Override Set<String> enumerateTypes(String ns); @Override boolean publishIfUnchanged(@NonNull List<? extends Fact> factsToPublish,
@NonNull Optional<StateToken> token); @Override void invalidate(@NonNull StateToken token); @Override StateToken stateFor(@NonNull Collection<UUID> forAggIds, @NonNull Optional<String> ns); @Override long currentTime(); } | @Test void testFetchByIdNotFound() { UUID id = UUID.randomUUID(); when(blockingStub.fetchById(eq(conv.toProto(id)))).thenReturn(conv.toProto(Optional .empty())); Optional<Fact> fetchById = uut.fetchById(id); assertFalse(fetchById.isPresent()); }
@Test void testFetchByIdFound() { UUID id = UUID.randomUUID(); when(blockingStub.fetchById(eq(conv.toProto(id)))) .thenReturn(conv.toProto(Optional.of(Fact.builder().ns("test").build("{}")))); Optional<Fact> fetchById = uut.fetchById(id); assertTrue(fetchById.isPresent()); }
@Test void testFetchByIdPropagatesRetryableExceptionOnUnavailableStatus() { when(blockingStub.fetchById(any())).thenThrow(new StatusRuntimeException( Status.UNAVAILABLE)); assertThrows(RetryableException.class, () -> uut.fetchById(UUID.randomUUID())); } |
GrpcFactStore implements FactStore, SmartInitializingSingleton { @Override public void publish(@NonNull List<? extends Fact> factsToPublish) { log.trace("publishing {} facts to remote store", factsToPublish.size()); List<MSG_Fact> mf = factsToPublish.stream() .map(converter::toProto) .collect(Collectors .toList()); MSG_Facts mfs = MSG_Facts.newBuilder().addAllFact(mf).build(); try { MSG_Empty msgEmpty = blockingStub.publish(mfs); } catch (StatusRuntimeException e) { throw wrapRetryable(e); } } @SuppressWarnings("OptionalUsedAsFieldOrParameterType") @Autowired @Generated GrpcFactStore(FactCastGrpcChannelFactory channelFactory,
@Value("${grpc.client.factstore.credentials:#{null}}") Optional<String> credentials); @Generated @VisibleForTesting GrpcFactStore(Channel channel,
Optional<String> credentials); private GrpcFactStore(RemoteFactStoreBlockingStub newBlockingStub, RemoteFactStoreStub newStub,
Optional<String> credentials); @Override Optional<Fact> fetchById(UUID id); @Override void publish(@NonNull List<? extends Fact> factsToPublish); @Override Subscription subscribe(@NonNull SubscriptionRequestTO req,
@NonNull FactObserver observer); @Override OptionalLong serialOf(@NonNull UUID l); synchronized void initialize(); @Override synchronized void afterSingletonsInstantiated(); @Override Set<String> enumerateNamespaces(); @Override Set<String> enumerateTypes(String ns); @Override boolean publishIfUnchanged(@NonNull List<? extends Fact> factsToPublish,
@NonNull Optional<StateToken> token); @Override void invalidate(@NonNull StateToken token); @Override StateToken stateFor(@NonNull Collection<UUID> forAggIds, @NonNull Optional<String> ns); @Override long currentTime(); } | @Test void testPublish() { when(blockingStub.publish(factsCap.capture())).thenReturn(MSG_Empty.newBuilder().build()); final TestFact fact = new TestFact(); uut.publish(Collections.singletonList(fact)); verify(blockingStub).publish(any()); final MSG_Facts pfacts = factsCap.getValue(); Fact published = conv.fromProto(pfacts.getFact(0)); assertEquals(fact.id(), published.id()); }
@Test void testPublishNullParameter() { assertThrows(NullPointerException.class, () -> uut.publish(null)); }
@Test void testPublishPropagatesException() { when(blockingStub.publish(any())).thenThrow(new SomeException()); assertThrows(SomeException.class, () -> uut.publish(Collections.singletonList(Fact.builder() .build("{}")))); }
@Test void testPublishPropagatesRetryableExceptionOnUnavailableStatus() { when(blockingStub.publish(any())).thenThrow(new StatusRuntimeException(Status.UNAVAILABLE)); assertThrows(RetryableException.class, () -> uut.publish(Collections.singletonList(Fact .builder() .build("{}")))); } |
GrpcFactStore implements FactStore, SmartInitializingSingleton { @VisibleForTesting void configureCompression(String codecListFromServer) { codecs.selectFrom(codecListFromServer).ifPresent(c -> { log.info("configuring Codec " + c); this.blockingStub = blockingStub.withCompression(c); this.stub = stub.withCompression(c); }); } @SuppressWarnings("OptionalUsedAsFieldOrParameterType") @Autowired @Generated GrpcFactStore(FactCastGrpcChannelFactory channelFactory,
@Value("${grpc.client.factstore.credentials:#{null}}") Optional<String> credentials); @Generated @VisibleForTesting GrpcFactStore(Channel channel,
Optional<String> credentials); private GrpcFactStore(RemoteFactStoreBlockingStub newBlockingStub, RemoteFactStoreStub newStub,
Optional<String> credentials); @Override Optional<Fact> fetchById(UUID id); @Override void publish(@NonNull List<? extends Fact> factsToPublish); @Override Subscription subscribe(@NonNull SubscriptionRequestTO req,
@NonNull FactObserver observer); @Override OptionalLong serialOf(@NonNull UUID l); synchronized void initialize(); @Override synchronized void afterSingletonsInstantiated(); @Override Set<String> enumerateNamespaces(); @Override Set<String> enumerateTypes(String ns); @Override boolean publishIfUnchanged(@NonNull List<? extends Fact> factsToPublish,
@NonNull Optional<StateToken> token); @Override void invalidate(@NonNull StateToken token); @Override StateToken stateFor(@NonNull Collection<UUID> forAggIds, @NonNull Optional<String> ns); @Override long currentTime(); } | @Test void configureCompressionChooseGzipIfAvail() { uut.configureCompression(" gzip,lz3,lz4, lz99"); verify(stub).withCompression("gzip"); }
@Test void configureCompressionSkipCompression() { uut.configureCompression("zip,lz3,lz4, lz99"); verifyNoMoreInteractions(stub); } |
GrpcFactStore implements FactStore, SmartInitializingSingleton { @VisibleForTesting void cancel(final ClientCall<MSG_SubscriptionRequest, MSG_Notification> call) { call.cancel("Client is no longer interested", null); } @SuppressWarnings("OptionalUsedAsFieldOrParameterType") @Autowired @Generated GrpcFactStore(FactCastGrpcChannelFactory channelFactory,
@Value("${grpc.client.factstore.credentials:#{null}}") Optional<String> credentials); @Generated @VisibleForTesting GrpcFactStore(Channel channel,
Optional<String> credentials); private GrpcFactStore(RemoteFactStoreBlockingStub newBlockingStub, RemoteFactStoreStub newStub,
Optional<String> credentials); @Override Optional<Fact> fetchById(UUID id); @Override void publish(@NonNull List<? extends Fact> factsToPublish); @Override Subscription subscribe(@NonNull SubscriptionRequestTO req,
@NonNull FactObserver observer); @Override OptionalLong serialOf(@NonNull UUID l); synchronized void initialize(); @Override synchronized void afterSingletonsInstantiated(); @Override Set<String> enumerateNamespaces(); @Override Set<String> enumerateTypes(String ns); @Override boolean publishIfUnchanged(@NonNull List<? extends Fact> factsToPublish,
@NonNull Optional<StateToken> token); @Override void invalidate(@NonNull StateToken token); @Override StateToken stateFor(@NonNull Collection<UUID> forAggIds, @NonNull Optional<String> ns); @Override long currentTime(); } | @SuppressWarnings("unchecked") @Test void testCancelNotRetryableExceptionOnUnavailableStatus() { ClientCall<MSG_SubscriptionRequest, MSG_Notification> call = mock(ClientCall.class); doThrow(new StatusRuntimeException(Status.UNAVAILABLE)).when(call).cancel(any(), any()); assertThrows(StatusRuntimeException.class, () -> uut.cancel(call)); }
@Test void testCancelIsPropagated() throws Exception { ClientCall call = mock(ClientCall.class); uut.cancel(call); verify(call).cancel(any(), any()); }
@Test void testCancelIsNotRetryable() throws Exception { ClientCall call = mock(ClientCall.class); doThrow(StatusRuntimeException.class).when(call).cancel(any(), any()); try { uut.cancel(call); fail(); } catch (Throwable e) { assertTrue(e instanceof StatusRuntimeException); assertFalse(e instanceof RetryableException); } } |
PgFactStream { void connect(@NonNull SubscriptionRequestTO request) { this.request = request; log.debug("{} connecting subscription {}", request, request.dump()); postQueryMatcher = new PgPostQueryMatcher(request); PgQueryBuilder q = new PgQueryBuilder(request); initializeSerialToStartAfter(); String sql = q.createSQL(); PreparedStatementSetter setter = q.createStatementSetter(serial); RowCallbackHandler rsHandler = new FactRowCallbackHandler(subscription, postQueryMatcher); PgSynchronizedQuery query = new PgSynchronizedQuery(jdbcTemplate, sql, setter, rsHandler, serial, fetcher); catchupAndFollow(request, subscription, query); } synchronized void close(); } | @Test public void testConnectNullParameter() throws Exception { assertThrows(NullPointerException.class, () -> { uut.connect(null); }); } |
GrpcFactStore implements FactStore, SmartInitializingSingleton { @Override public OptionalLong serialOf(@NonNull UUID l) { MSG_UUID protoMessage = converter.toProto(l); MSG_OptionalSerial responseMessage; try { responseMessage = blockingStub.serialOf(protoMessage); } catch (StatusRuntimeException e) { throw wrapRetryable(e); } return converter.fromProto(responseMessage); } @SuppressWarnings("OptionalUsedAsFieldOrParameterType") @Autowired @Generated GrpcFactStore(FactCastGrpcChannelFactory channelFactory,
@Value("${grpc.client.factstore.credentials:#{null}}") Optional<String> credentials); @Generated @VisibleForTesting GrpcFactStore(Channel channel,
Optional<String> credentials); private GrpcFactStore(RemoteFactStoreBlockingStub newBlockingStub, RemoteFactStoreStub newStub,
Optional<String> credentials); @Override Optional<Fact> fetchById(UUID id); @Override void publish(@NonNull List<? extends Fact> factsToPublish); @Override Subscription subscribe(@NonNull SubscriptionRequestTO req,
@NonNull FactObserver observer); @Override OptionalLong serialOf(@NonNull UUID l); synchronized void initialize(); @Override synchronized void afterSingletonsInstantiated(); @Override Set<String> enumerateNamespaces(); @Override Set<String> enumerateTypes(String ns); @Override boolean publishIfUnchanged(@NonNull List<? extends Fact> factsToPublish,
@NonNull Optional<StateToken> token); @Override void invalidate(@NonNull StateToken token); @Override StateToken stateFor(@NonNull Collection<UUID> forAggIds, @NonNull Optional<String> ns); @Override long currentTime(); } | @Test void testSerialOfPropagatesRetryableExceptionOnUnavailableStatus() { when(blockingStub.serialOf(any())).thenThrow(new StatusRuntimeException( Status.UNAVAILABLE)); assertThrows(RetryableException.class, () -> uut.serialOf(mock(UUID.class))); }
@Test void testSerialOf() { OptionalLong seven = OptionalLong.of(7); when(blockingStub.serialOf(any())).thenReturn(conv.toProto(seven)); OptionalLong response = uut.serialOf(mock(UUID.class)); assertEquals(seven, response); assertNotSame(seven, response); }
@Test void testSerialOfNullParameters() throws Exception { expectNPE(() -> uut.serialOf(null)); } |
GrpcFactStore implements FactStore, SmartInitializingSingleton { public synchronized void initialize() { if (!initialized.getAndSet(true)) { log.debug("Invoking handshake"); Map<String, String> serverProperties; ProtocolVersion serverProtocolVersion; try { ServerConfig cfg = converter.fromProto(blockingStub.handshake(converter.empty())); serverProtocolVersion = cfg.version(); serverProperties = cfg.properties(); } catch (StatusRuntimeException e) { throw wrapRetryable(e); } logProtocolVersion(serverProtocolVersion); logServerVersion(serverProperties); configureCompression(serverProperties.get(Capabilities.CODECS.toString())); } } @SuppressWarnings("OptionalUsedAsFieldOrParameterType") @Autowired @Generated GrpcFactStore(FactCastGrpcChannelFactory channelFactory,
@Value("${grpc.client.factstore.credentials:#{null}}") Optional<String> credentials); @Generated @VisibleForTesting GrpcFactStore(Channel channel,
Optional<String> credentials); private GrpcFactStore(RemoteFactStoreBlockingStub newBlockingStub, RemoteFactStoreStub newStub,
Optional<String> credentials); @Override Optional<Fact> fetchById(UUID id); @Override void publish(@NonNull List<? extends Fact> factsToPublish); @Override Subscription subscribe(@NonNull SubscriptionRequestTO req,
@NonNull FactObserver observer); @Override OptionalLong serialOf(@NonNull UUID l); synchronized void initialize(); @Override synchronized void afterSingletonsInstantiated(); @Override Set<String> enumerateNamespaces(); @Override Set<String> enumerateTypes(String ns); @Override boolean publishIfUnchanged(@NonNull List<? extends Fact> factsToPublish,
@NonNull Optional<StateToken> token); @Override void invalidate(@NonNull StateToken token); @Override StateToken stateFor(@NonNull Collection<UUID> forAggIds, @NonNull Optional<String> ns); @Override long currentTime(); } | @Test void testInitializePropagatesRetryableExceptionOnUnavailableStatus() { when(blockingStub.handshake(any())).thenThrow(new StatusRuntimeException( Status.UNAVAILABLE)); assertThrows(RetryableException.class, () -> uut.initialize()); }
@Test void testCompatibleProtocolVersion() { when(blockingStub.handshake(any())) .thenReturn(conv.toProto(ServerConfig.of(ProtocolVersion.of(1, 1, 0), new HashMap<>()))); uut.initialize(); }
@Test void testIncompatibleProtocolVersion() { when(blockingStub.handshake(any())) .thenReturn(conv.toProto(ServerConfig.of(ProtocolVersion.of(99, 0, 0), new HashMap<>()))); Assertions.assertThrows(IncompatibleProtocolVersions.class, () -> uut.initialize()); }
@Test void testInitializationExecutesOnlyOnce() { when(blockingStub.handshake(any())) .thenReturn(conv.toProto(ServerConfig.of(ProtocolVersion.of(1, 1, 0), new HashMap<>()))); uut.initialize(); uut.initialize(); verify(blockingStub, times(1)).handshake(any()); } |
GrpcFactStore implements FactStore, SmartInitializingSingleton { @Override public Set<String> enumerateTypes(String ns) { MSG_String ns_message = converter.toProto(ns); MSG_StringSet resp; try { resp = blockingStub.enumerateTypes(ns_message); } catch (StatusRuntimeException e) { throw wrapRetryable(e); } return converter.fromProto(resp); } @SuppressWarnings("OptionalUsedAsFieldOrParameterType") @Autowired @Generated GrpcFactStore(FactCastGrpcChannelFactory channelFactory,
@Value("${grpc.client.factstore.credentials:#{null}}") Optional<String> credentials); @Generated @VisibleForTesting GrpcFactStore(Channel channel,
Optional<String> credentials); private GrpcFactStore(RemoteFactStoreBlockingStub newBlockingStub, RemoteFactStoreStub newStub,
Optional<String> credentials); @Override Optional<Fact> fetchById(UUID id); @Override void publish(@NonNull List<? extends Fact> factsToPublish); @Override Subscription subscribe(@NonNull SubscriptionRequestTO req,
@NonNull FactObserver observer); @Override OptionalLong serialOf(@NonNull UUID l); synchronized void initialize(); @Override synchronized void afterSingletonsInstantiated(); @Override Set<String> enumerateNamespaces(); @Override Set<String> enumerateTypes(String ns); @Override boolean publishIfUnchanged(@NonNull List<? extends Fact> factsToPublish,
@NonNull Optional<StateToken> token); @Override void invalidate(@NonNull StateToken token); @Override StateToken stateFor(@NonNull Collection<UUID> forAggIds, @NonNull Optional<String> ns); @Override long currentTime(); } | @Test void testEnumerateTypesPropagatesRetryableExceptionOnUnavailableStatus() { when(blockingStub.enumerateTypes(any())).thenThrow(new StatusRuntimeException( Status.UNAVAILABLE)); assertThrows(RetryableException.class, () -> uut.enumerateTypes("ns")); }
@Test void testEnumerateTypes() { HashSet<String> types = Sets.newHashSet("foo", "bar"); when(blockingStub.enumerateTypes(any())).thenReturn(conv.toProto(types)); Set<String> enumerateTypes = uut.enumerateTypes("ns"); assertEquals(types, enumerateTypes); assertNotSame(types, enumerateTypes); } |
PgPostQueryMatcher implements Predicate<Fact> { PgPostQueryMatcher(@NonNull SubscriptionRequest req) { canBeSkipped = req.specs().stream().noneMatch(s -> s.jsFilterScript() != null); if (canBeSkipped) { log.trace("{} post query filtering has been disabled", req); } else { this.matchers.addAll(req.specs() .stream() .map(FactSpecMatcher::new) .collect(Collectors.toList())); } } PgPostQueryMatcher(@NonNull SubscriptionRequest req); @Override boolean test(Fact input); } | @Test public void testPGPostQueryMatcher() throws Exception { assertThrows(NullPointerException.class, () -> { new PgPostQueryMatcher(null); }); } |
GrpcFactStore implements FactStore, SmartInitializingSingleton { @VisibleForTesting static RuntimeException wrapRetryable(StatusRuntimeException e) { if (e.getStatus().getCode() == Code.UNAVAILABLE) { return new RetryableException(e); } else { return e; } } @SuppressWarnings("OptionalUsedAsFieldOrParameterType") @Autowired @Generated GrpcFactStore(FactCastGrpcChannelFactory channelFactory,
@Value("${grpc.client.factstore.credentials:#{null}}") Optional<String> credentials); @Generated @VisibleForTesting GrpcFactStore(Channel channel,
Optional<String> credentials); private GrpcFactStore(RemoteFactStoreBlockingStub newBlockingStub, RemoteFactStoreStub newStub,
Optional<String> credentials); @Override Optional<Fact> fetchById(UUID id); @Override void publish(@NonNull List<? extends Fact> factsToPublish); @Override Subscription subscribe(@NonNull SubscriptionRequestTO req,
@NonNull FactObserver observer); @Override OptionalLong serialOf(@NonNull UUID l); synchronized void initialize(); @Override synchronized void afterSingletonsInstantiated(); @Override Set<String> enumerateNamespaces(); @Override Set<String> enumerateTypes(String ns); @Override boolean publishIfUnchanged(@NonNull List<? extends Fact> factsToPublish,
@NonNull Optional<StateToken> token); @Override void invalidate(@NonNull StateToken token); @Override StateToken stateFor(@NonNull Collection<UUID> forAggIds, @NonNull Optional<String> ns); @Override long currentTime(); } | @Test void testWrapRetryable_nonRetryable() throws Exception { StatusRuntimeException cause = new StatusRuntimeException(Status.DEADLINE_EXCEEDED); RuntimeException e = GrpcFactStore.wrapRetryable(cause); assertTrue(e instanceof StatusRuntimeException); assertSame(e, cause); }
@Test void testWrapRetryable() throws Exception { StatusRuntimeException cause = new StatusRuntimeException(Status.UNAVAILABLE); RuntimeException e = GrpcFactStore.wrapRetryable(cause); assertTrue(e instanceof RetryableException); assertSame(e.getCause(), cause); } |
GrpcFactStore implements FactStore, SmartInitializingSingleton { @Override public void invalidate(@NonNull StateToken token) { MSG_UUID msg = converter.toProto(token.uuid()); try { MSG_Empty msgEmpty = blockingStub.invalidate(msg); } catch (StatusRuntimeException e) { throw wrapRetryable(e); } } @SuppressWarnings("OptionalUsedAsFieldOrParameterType") @Autowired @Generated GrpcFactStore(FactCastGrpcChannelFactory channelFactory,
@Value("${grpc.client.factstore.credentials:#{null}}") Optional<String> credentials); @Generated @VisibleForTesting GrpcFactStore(Channel channel,
Optional<String> credentials); private GrpcFactStore(RemoteFactStoreBlockingStub newBlockingStub, RemoteFactStoreStub newStub,
Optional<String> credentials); @Override Optional<Fact> fetchById(UUID id); @Override void publish(@NonNull List<? extends Fact> factsToPublish); @Override Subscription subscribe(@NonNull SubscriptionRequestTO req,
@NonNull FactObserver observer); @Override OptionalLong serialOf(@NonNull UUID l); synchronized void initialize(); @Override synchronized void afterSingletonsInstantiated(); @Override Set<String> enumerateNamespaces(); @Override Set<String> enumerateTypes(String ns); @Override boolean publishIfUnchanged(@NonNull List<? extends Fact> factsToPublish,
@NonNull Optional<StateToken> token); @Override void invalidate(@NonNull StateToken token); @Override StateToken stateFor(@NonNull Collection<UUID> forAggIds, @NonNull Optional<String> ns); @Override long currentTime(); } | @Test void testInvalidate() throws Exception { assertThrows(NullPointerException.class, () -> uut.invalidate(null)); { UUID id = new UUID(0, 1); StateToken token = new StateToken(id); uut.invalidate(token); verify(blockingStub).invalidate(eq(conv.toProto(id))); } { when(blockingStub.invalidate(any())).thenThrow( new StatusRuntimeException( Status.UNAVAILABLE)); UUID id = new UUID(0, 1); StateToken token = new StateToken(id); try { uut.invalidate(token); fail(); } catch (RetryableException expected) { } } } |
GrpcFactStore implements FactStore, SmartInitializingSingleton { @Override public StateToken stateFor(@NonNull Collection<UUID> forAggIds, @NonNull Optional<String> ns) { StateForRequest req = new StateForRequest(Lists.newArrayList(forAggIds), ns.orElse(null)); MSG_StateForRequest msg = converter.toProto(req); try { MSG_UUID result = blockingStub.stateFor(msg); return new StateToken(converter.fromProto(result)); } catch (StatusRuntimeException e) { throw wrapRetryable(e); } } @SuppressWarnings("OptionalUsedAsFieldOrParameterType") @Autowired @Generated GrpcFactStore(FactCastGrpcChannelFactory channelFactory,
@Value("${grpc.client.factstore.credentials:#{null}}") Optional<String> credentials); @Generated @VisibleForTesting GrpcFactStore(Channel channel,
Optional<String> credentials); private GrpcFactStore(RemoteFactStoreBlockingStub newBlockingStub, RemoteFactStoreStub newStub,
Optional<String> credentials); @Override Optional<Fact> fetchById(UUID id); @Override void publish(@NonNull List<? extends Fact> factsToPublish); @Override Subscription subscribe(@NonNull SubscriptionRequestTO req,
@NonNull FactObserver observer); @Override OptionalLong serialOf(@NonNull UUID l); synchronized void initialize(); @Override synchronized void afterSingletonsInstantiated(); @Override Set<String> enumerateNamespaces(); @Override Set<String> enumerateTypes(String ns); @Override boolean publishIfUnchanged(@NonNull List<? extends Fact> factsToPublish,
@NonNull Optional<StateToken> token); @Override void invalidate(@NonNull StateToken token); @Override StateToken stateFor(@NonNull Collection<UUID> forAggIds, @NonNull Optional<String> ns); @Override long currentTime(); } | @Test void testStateFor() throws Exception { assertThrows(NullPointerException.class, () -> uut.stateFor(Lists.emptyList(), null)); assertThrows(NullPointerException.class, () -> uut.stateFor(null, null)); assertThrows(NullPointerException.class, () -> uut.stateFor(null, Optional.of("foo"))); { UUID id = new UUID(0, 1); StateForRequest req = new StateForRequest(Lists.emptyList(), "foo"); when(blockingStub.stateFor(any())).thenReturn(conv.toProto(id)); StateToken stateFor = uut.stateFor(Lists.emptyList(), Optional.of("foo")); verify(blockingStub).stateFor(conv.toProto(req)); } { StateForRequest req = new StateForRequest(Lists.emptyList(), "foo"); when(blockingStub.stateFor(any())).thenThrow( new StatusRuntimeException( Status.UNAVAILABLE)); try { uut.stateFor(Lists.emptyList(), Optional.of("foo")); fail(); } catch (RetryableException expected) { } } } |
GrpcFactStore implements FactStore, SmartInitializingSingleton { @Override public boolean publishIfUnchanged(@NonNull List<? extends Fact> factsToPublish, @NonNull Optional<StateToken> token) { ConditionalPublishRequest req = new ConditionalPublishRequest(factsToPublish, token.map( StateToken::uuid).orElse(null)); MSG_ConditionalPublishRequest msg = converter.toProto(req); try { MSG_ConditionalPublishResult r = blockingStub.publishConditional(msg); return r.getSuccess(); } catch (StatusRuntimeException e) { throw wrapRetryable(e); } } @SuppressWarnings("OptionalUsedAsFieldOrParameterType") @Autowired @Generated GrpcFactStore(FactCastGrpcChannelFactory channelFactory,
@Value("${grpc.client.factstore.credentials:#{null}}") Optional<String> credentials); @Generated @VisibleForTesting GrpcFactStore(Channel channel,
Optional<String> credentials); private GrpcFactStore(RemoteFactStoreBlockingStub newBlockingStub, RemoteFactStoreStub newStub,
Optional<String> credentials); @Override Optional<Fact> fetchById(UUID id); @Override void publish(@NonNull List<? extends Fact> factsToPublish); @Override Subscription subscribe(@NonNull SubscriptionRequestTO req,
@NonNull FactObserver observer); @Override OptionalLong serialOf(@NonNull UUID l); synchronized void initialize(); @Override synchronized void afterSingletonsInstantiated(); @Override Set<String> enumerateNamespaces(); @Override Set<String> enumerateTypes(String ns); @Override boolean publishIfUnchanged(@NonNull List<? extends Fact> factsToPublish,
@NonNull Optional<StateToken> token); @Override void invalidate(@NonNull StateToken token); @Override StateToken stateFor(@NonNull Collection<UUID> forAggIds, @NonNull Optional<String> ns); @Override long currentTime(); } | @Test void testPublishIfUnchanged() throws Exception { assertThrows(NullPointerException.class, () -> uut.publishIfUnchanged(Lists.emptyList(), null)); assertThrows(NullPointerException.class, () -> uut.publishIfUnchanged(null, null)); assertThrows(NullPointerException.class, () -> uut.publishIfUnchanged(null, Optional .empty())); { UUID id = new UUID(0, 1); ConditionalPublishRequest req = new ConditionalPublishRequest(Lists.emptyList(), id); when(blockingStub.publishConditional(any())).thenReturn(conv.toProto(true)); boolean publishIfUnchanged = uut.publishIfUnchanged(Lists.emptyList(), Optional.of( new StateToken(id))); assertThat(publishIfUnchanged).isTrue(); verify(blockingStub).publishConditional(conv.toProto(req)); } { UUID id = new UUID(0, 1); ConditionalPublishRequest req = new ConditionalPublishRequest(Lists.emptyList(), id); when(blockingStub.publishConditional(any())).thenThrow( new StatusRuntimeException( Status.UNAVAILABLE)); try { uut.publishIfUnchanged(Lists.emptyList(), Optional.of( new StateToken(id))); fail(); } catch (RetryableException expected) { } } } |
JadxCLIArgs { public boolean isReplaceConsts() { return replaceConsts; } boolean processArgs(String[] args); boolean overrideProvided(String[] args); JadxArgs toJadxArgs(); List<String> getFiles(); String getOutDir(); String getOutDirSrc(); String getOutDirRes(); boolean isSkipResources(); boolean isSkipSources(); int getThreadsCount(); boolean isFallbackMode(); boolean isShowInconsistentCode(); boolean isUseImports(); boolean isDebugInfo(); boolean isInlineAnonymousClasses(); boolean isDeobfuscationOn(); int getDeobfuscationMinLength(); int getDeobfuscationMaxLength(); boolean isDeobfuscationForceSave(); boolean isDeobfuscationUseSourceNameAsAlias(); boolean isDeobfuscationParseKotlinMetadata(); boolean isEscapeUnicode(); boolean isCfgOutput(); boolean isRawCfgOutput(); boolean isReplaceConsts(); boolean isRespectBytecodeAccessModifiers(); boolean isExportAsGradleProject(); boolean isRenameCaseSensitive(); boolean isRenameValid(); boolean isRenamePrintable(); boolean isFsCaseSensitive(); static String enumValuesString(Enum<?>[] values); } | @Test public void testInvertedBooleanOption() { assertThat(parse("--no-replace-consts").isReplaceConsts(), is(false)); assertThat(parse("").isReplaceConsts(), is(true)); } |
CertificateManager { public String generateSignature() { StringBuilder builder = new StringBuilder(); append(builder, NLS.str("certificate.serialSigType"), x509cert.getSigAlgName()); append(builder, NLS.str("certificate.serialSigOID"), x509cert.getSigAlgOID()); return builder.toString(); } CertificateManager(Certificate cert); static String decode(InputStream in); String generateHeader(); String generateSignature(); String generateFingerprint(); String generatePublicKey(); String generateTextForX509(); String generateText(); static String getThumbPrint(X509Certificate cert, String type); static String hexify(byte[] bytes); } | @Test public void decodeRSAKeySignature() { String string = certificateManagerRSA.generateSignature(); assertTrue(string.contains("SHA256withRSA")); assertTrue(string.contains("1.2.840.113549.1.1.11")); }
@Test public void decodeDSAKeySignature() { String string = certificateManagerDSA.generateSignature(); assertTrue(string.contains("SHA1withDSA")); assertTrue(string.contains("1.2.840.10040.4.3")); } |
CertificateManager { public String generateFingerprint() { StringBuilder builder = new StringBuilder(); try { append(builder, NLS.str("certificate.serialMD5"), getThumbPrint(x509cert, "MD5")); append(builder, NLS.str("certificate.serialSHA1"), getThumbPrint(x509cert, "SHA-1")); append(builder, NLS.str("certificate.serialSHA256"), getThumbPrint(x509cert, "SHA-256")); } catch (Exception e) { LOG.error("Failed to parse fingerprint", e); } return builder.toString(); } CertificateManager(Certificate cert); static String decode(InputStream in); String generateHeader(); String generateSignature(); String generateFingerprint(); String generatePublicKey(); String generateTextForX509(); String generateText(); static String getThumbPrint(X509Certificate cert, String type); static String hexify(byte[] bytes); } | @Test public void decodeRSAFingerprint() { String string = certificateManagerRSA.generateFingerprint(); assertTrue(string.contains("61 18 0A 71 3F C9 55 16 4E 04 E3 C5 45 08 D9 11")); assertTrue(string.contains("A0 6E A6 06 DB 2C 6F 3A 16 56 7F 75 97 7B AE 85 C2 13 09 37")); assertTrue(string.contains("12 53 E8 BB C8 AA 27 A8 49 9B F8 0D 6E 68 CE 32 35 50 DE 55 A7 E7 8C 29 51 00 96 D7 56 F4 54 44")); }
@Test public void decodeDSAFingerprint() { String string = certificateManagerDSA.generateFingerprint(); assertTrue(string.contains("D9 06 A6 2D 1F 79 8C 9D A6 EF 40 C7 2E C2 EA 0B")); assertTrue(string.contains("18 E9 9C D4 A1 40 8F 63 FA EC 2E 62 A0 F2 AE B7 3F C3 C2 04")); assertTrue(string.contains("74 F9 48 64 EE AC 92 26 53 2C 7A 0E 55 BE 5E D8 2F A7 D9 A9 99 F5 D5 21 2C 51 21 C4 31 AD 73 40")); } |
CertificateManager { public String generatePublicKey() { PublicKey publicKey = x509cert.getPublicKey(); if (publicKey instanceof RSAPublicKey) { return generateRSAPublicKey(); } if (publicKey instanceof DSAPublicKey) { return generateDSAPublicKey(); } return ""; } CertificateManager(Certificate cert); static String decode(InputStream in); String generateHeader(); String generateSignature(); String generateFingerprint(); String generatePublicKey(); String generateTextForX509(); String generateText(); static String getThumbPrint(X509Certificate cert, String type); static String hexify(byte[] bytes); } | @Test public void decodeRSAPubKey() { String string = certificateManagerRSA.generatePublicKey(); assertTrue(string.contains("RSA")); assertTrue(string.contains("65537")); assertTrue(string.contains("1681953129031804462554643735709908030601939275292568895111488068832920121318010916" + "889038430576806710152191447376363866950356097752126932858298006033288814768019331823126004318941179" + "4465899645633586173494259691101582064441956032924396850221679489313043628562082670183392670094163371" + "8586841184804093747497905514737738452134274762361473284344272721776230189352829291523087538543142199" + "8761760403746876947208990209024335828599173964217021197086277312193991177728010193707324300633538463" + "6193260583579409760790138329893534549366882523130765297472656435892831796545149793228897111760122091" + "442123535919361963075454640516520743")); }
@Test public void decodeDSAPubKey() { String string = certificateManagerDSA.generatePublicKey(); assertTrue(string.contains("DSA")); assertTrue(string.contains("193233676050581546825633012823454532222793121048898990016982096262547255815113" + "7546996381246109049596383861577383286736433045701055397423798599190480095839416942148507037843474" + "67923797088055637932532829952742936211625049432875384559446523443782422268975073691469424116922209" + "22477368782490423187845815262510366")); } |
StringRef implements CharSequence { public static StringRef subString(String str, int from, int to) { return new StringRef(str, from, to - from); } private StringRef(String str, int from, int length); static StringRef subString(String str, int from, int to); static StringRef subString(String str, int from); static StringRef fromStr(String str); @Override int length(); @Override char charAt(int index); @Override CharSequence subSequence(int start, int end); StringRef trim(); int indexOf(String str); int indexOf(String str, boolean caseInsensitive); int indexOf(String str, int from, boolean caseInsensitive); int indexOf(String str, int from); static List<StringRef> split(String str, String splitBy); int hashCode(); boolean equals(Object other); @NotNull @Override String toString(); } | @Test public void testSubstring() { checkStr(subString("a", 0), "a"); checkStr(subString("a", 1), ""); checkStr(subString("a", 0, 0), ""); checkStr(subString("a", 0, 1), "a"); checkStr(subString("abc", 1, 2), "b"); checkStr(subString("abc", 2), "c"); checkStr(subString("abc", 2, 3), "c"); } |
StringRef implements CharSequence { public StringRef trim() { int start = offset; int end = start + length; String str = refStr; while ((start < end) && (str.charAt(start) <= ' ')) { start++; } while ((start < end) && (str.charAt(end - 1) <= ' ')) { end--; } if ((start > offset) || (end < offset + length)) { return subString(str, start, end); } return this; } private StringRef(String str, int from, int length); static StringRef subString(String str, int from, int to); static StringRef subString(String str, int from); static StringRef fromStr(String str); @Override int length(); @Override char charAt(int index); @Override CharSequence subSequence(int start, int end); StringRef trim(); int indexOf(String str); int indexOf(String str, boolean caseInsensitive); int indexOf(String str, int from, boolean caseInsensitive); int indexOf(String str, int from); static List<StringRef> split(String str, String splitBy); int hashCode(); boolean equals(Object other); @NotNull @Override String toString(); } | @Test public void testTrim() { checkTrim(fromStr("a"), "a"); checkTrim(fromStr(" a "), "a"); checkTrim(fromStr("\ta"), "a"); checkTrim(subString("a b c", 1), "b c"); checkTrim(subString("a b\tc", 1, 4), "b"); checkTrim(subString("a b\tc", 2, 3), "b"); } |
StringRef implements CharSequence { public static List<StringRef> split(String str, String splitBy) { int len = str.length(); int targetLen = splitBy.length(); if (len == 0 || targetLen == 0) { return Collections.emptyList(); } int pos = -targetLen; List<StringRef> list = new ArrayList<>(); while (true) { int start = pos + targetLen; pos = indexOf(str, 0, len, splitBy, 0, targetLen, start, false); if (pos == -1) { if (start != len) { list.add(subString(str, start, len)); } break; } else { list.add(subString(str, start, pos)); } } return list; } private StringRef(String str, int from, int length); static StringRef subString(String str, int from, int to); static StringRef subString(String str, int from); static StringRef fromStr(String str); @Override int length(); @Override char charAt(int index); @Override CharSequence subSequence(int start, int end); StringRef trim(); int indexOf(String str); int indexOf(String str, boolean caseInsensitive); int indexOf(String str, int from, boolean caseInsensitive); int indexOf(String str, int from); static List<StringRef> split(String str, String splitBy); int hashCode(); boolean equals(Object other); @NotNull @Override String toString(); } | @Test public void testSplit() { checkSplit("abc", "b", "a", "c"); checkSplit("abc", "a", "", "bc"); checkSplit("abc", "c", "ab"); checkSplit("abc", "d", "abc"); checkSplit("abbbc", "b", "a", "", "", "c"); checkSplit("abbbc", "bb", "a", "bc"); checkSplit("abbbc", "bbb", "a", "c"); checkSplit("abbbc", "bbc", "ab"); checkSplit("abbbc", "bbbc", "a"); } |
VersionComparator { public static int compare(String str1, String str2) { String[] s1 = str1.split("\\."); int l1 = s1.length; String[] s2 = str2.split("\\."); int l2 = s2.length; int i = 0; while (i < l1 && i < l2) { if (!s1[i].equals(s2[i])) { break; } i++; } if (i < l1 && i < l2) { return Integer.valueOf(s1[i]).compareTo(Integer.valueOf(s2[i])); } boolean checkFirst = l1 > l2; boolean zeroTail = isZeroTail(checkFirst ? s1 : s2, i); if (zeroTail) { return 0; } return checkFirst ? 1 : -1; } private VersionComparator(); static int checkAndCompare(String str1, String str2); static int compare(String str1, String str2); } | @Test public void testCompare() { checkCompare("", "", 0); checkCompare("1", "1", 0); checkCompare("1", "2", -1); checkCompare("1.1", "1.1", 0); checkCompare("0.5", "0.5", 0); checkCompare("0.5", "0.5.0", 0); checkCompare("0.5", "0.5.00", 0); checkCompare("0.5", "0.5.0.0", 0); checkCompare("0.5", "0.5.0.1", -1); checkCompare("0.5.0", "0.5.0", 0); checkCompare("0.5.0", "0.5.1", -1); checkCompare("0.5", "0.5.1", -1); checkCompare("0.4.8", "0.5", -1); checkCompare("0.4.8", "0.5.0", -1); checkCompare("0.4.8", "0.6", -1); } |
JadxCLIArgs { public boolean isEscapeUnicode() { return escapeUnicode; } boolean processArgs(String[] args); boolean overrideProvided(String[] args); JadxArgs toJadxArgs(); List<String> getFiles(); String getOutDir(); String getOutDirSrc(); String getOutDirRes(); boolean isSkipResources(); boolean isSkipSources(); int getThreadsCount(); boolean isFallbackMode(); boolean isShowInconsistentCode(); boolean isUseImports(); boolean isDebugInfo(); boolean isInlineAnonymousClasses(); boolean isDeobfuscationOn(); int getDeobfuscationMinLength(); int getDeobfuscationMaxLength(); boolean isDeobfuscationForceSave(); boolean isDeobfuscationUseSourceNameAsAlias(); boolean isDeobfuscationParseKotlinMetadata(); boolean isEscapeUnicode(); boolean isCfgOutput(); boolean isRawCfgOutput(); boolean isReplaceConsts(); boolean isRespectBytecodeAccessModifiers(); boolean isExportAsGradleProject(); boolean isRenameCaseSensitive(); boolean isRenameValid(); boolean isRenamePrintable(); boolean isFsCaseSensitive(); static String enumValuesString(Enum<?>[] values); } | @Test public void testEscapeUnicodeOption() { assertThat(parse("--escape-unicode").isEscapeUnicode(), is(true)); assertThat(parse("").isEscapeUnicode(), is(false)); } |
TypeCompare { public TypeCompareEnum compareTypes(ClassNode first, ClassNode second) { return compareObjects(first.getType(), second.getType()); } TypeCompare(RootNode root); TypeCompareEnum compareTypes(ClassNode first, ClassNode second); TypeCompareEnum compareTypes(ArgType first, ArgType second); Comparator<ArgType> getComparator(); Comparator<ArgType> getReversedComparator(); } | @Test public void compareTypes() { firstIsNarrow(INT, UNKNOWN); firstIsNarrow(array(UNKNOWN), UNKNOWN); firstIsNarrow(array(UNKNOWN), NARROW); } |
TypeUtils { @Nullable public ArgType replaceTypeVariablesUsingMap(ArgType replaceType, Map<ArgType, ArgType> replaceMap) { if (replaceMap.isEmpty()) { return null; } if (replaceType.isGenericType()) { return replaceMap.get(replaceType); } if (replaceType.isArray()) { ArgType replaced = replaceTypeVariablesUsingMap(replaceType.getArrayElement(), replaceMap); if (replaced == null) { return null; } return ArgType.array(replaced); } ArgType wildcardType = replaceType.getWildcardType(); if (wildcardType != null && wildcardType.containsTypeVariable()) { ArgType newWildcardType = replaceTypeVariablesUsingMap(wildcardType, replaceMap); if (newWildcardType == null) { return null; } return ArgType.wildcard(newWildcardType, replaceType.getWildcardBound()); } List<ArgType> genericTypes = replaceType.getGenericTypes(); if (replaceType.isGeneric() && notEmpty(genericTypes)) { List<ArgType> newTypes = Utils.collectionMap(genericTypes, t -> { ArgType type = replaceTypeVariablesUsingMap(t, replaceMap); return type == null ? t : type; }); return ArgType.generic(replaceType, newTypes); } return null; } TypeUtils(RootNode rootNode); List<ArgType> getClassGenerics(ArgType type); ArgType expandTypeVariables(ClassNode cls, ArgType type); ArgType expandTypeVariables(MethodNode mth, ArgType type); Set<ArgType> getKnownTypeVarsAtMethod(MethodNode mth); @Nullable ArgType replaceClassGenerics(ArgType instanceType, ArgType typeWithGeneric); Map<ArgType, ArgType> getTypeVariablesMapping(ArgType clsType); @Nullable ArgType replaceMethodGenerics(BaseInvokeNode invokeInsn, IMethodDetails details, ArgType typeWithGeneric); @Nullable ArgType replaceTypeVariablesUsingMap(ArgType replaceType, Map<ArgType, ArgType> replaceMap); } | @Test void replaceTypeVariablesUsingMap() { ArgType typeVar = genericType("T"); ArgType listCls = object("java.util.List"); Map<ArgType, ArgType> typeMap = Collections.singletonMap(typeVar, STRING); replaceTypeVar(typeVar, typeMap, STRING); replaceTypeVar(generic(listCls, typeVar), typeMap, generic(listCls, STRING)); replaceTypeVar(array(typeVar), typeMap, array(STRING)); } |
AccessInfo { public AccessInfo changeVisibility(int flag) { int currentVisFlags = accFlags & VISIBILITY_FLAGS; if (currentVisFlags == flag) { return this; } int unsetAllVisFlags = accFlags & ~VISIBILITY_FLAGS; return new AccessInfo(unsetAllVisFlags | flag, type); } AccessInfo(int accessFlags, AFType type); boolean containsFlag(int flag); AccessInfo remove(int flag); AccessInfo add(int flag); AccessInfo changeVisibility(int flag); AccessInfo getVisibility(); boolean isPublic(); boolean isProtected(); boolean isPrivate(); boolean isPackagePrivate(); boolean isAbstract(); boolean isInterface(); boolean isAnnotation(); boolean isNative(); boolean isStatic(); boolean isFinal(); boolean isConstructor(); boolean isEnum(); boolean isSynthetic(); boolean isBridge(); boolean isVarArgs(); boolean isSynchronized(); boolean isTransient(); boolean isVolatile(); AFType getType(); String makeString(); String visibilityName(); int rawValue(); @Override String toString(); static final int VISIBILITY_FLAGS; } | @Test public void changeVisibility() { AccessInfo accessInfo = new AccessInfo(AccessFlags.PROTECTED | AccessFlags.STATIC, AFType.METHOD); AccessInfo result = accessInfo.changeVisibility(AccessFlags.PUBLIC); assertThat(result.isPublic(), is(true)); assertThat(result.isPrivate(), is(false)); assertThat(result.isProtected(), is(false)); assertThat(result.isStatic(), is(true)); }
@Test public void changeVisibilityNoOp() { AccessInfo accessInfo = new AccessInfo(AccessFlags.PUBLIC, AFType.METHOD); AccessInfo result = accessInfo.changeVisibility(AccessFlags.PUBLIC); assertSame(accessInfo, result); } |
NameMapper { public static boolean isValidIdentifier(String str) { return notEmpty(str) && !isReserved(str) && VALID_JAVA_IDENTIFIER.matcher(str).matches(); } private NameMapper(); static boolean isReserved(String str); static boolean isValidIdentifier(String str); static boolean isValidFullIdentifier(String str); static boolean isValidAndPrintable(String str); static boolean isValidIdentifierStart(int codePoint); static boolean isValidIdentifierPart(int codePoint); static boolean isPrintableChar(int c); static boolean isAllCharsPrintable(String str); static String removeInvalidCharsMiddle(String name); static String removeInvalidChars(String name, String prefix); } | @Test public void validIdentifiers() { assertThat(isValidIdentifier("ACls"), is(true)); }
@Test public void notValidIdentifiers() { assertThat(isValidIdentifier("1cls"), is(false)); assertThat(isValidIdentifier("-cls"), is(false)); assertThat(isValidIdentifier("A-cls"), is(false)); } |
NameMapper { public static String removeInvalidCharsMiddle(String name) { if (isValidIdentifier(name) && isAllCharsPrintable(name)) { return name; } int len = name.length(); StringBuilder sb = new StringBuilder(len); for (int i = 0; i < len; i++) { int codePoint = name.codePointAt(i); if (isPrintableChar(codePoint) && isValidIdentifierPart(codePoint)) { sb.append((char) codePoint); } } return sb.toString(); } private NameMapper(); static boolean isReserved(String str); static boolean isValidIdentifier(String str); static boolean isValidFullIdentifier(String str); static boolean isValidAndPrintable(String str); static boolean isValidIdentifierStart(int codePoint); static boolean isValidIdentifierPart(int codePoint); static boolean isPrintableChar(int c); static boolean isAllCharsPrintable(String str); static String removeInvalidCharsMiddle(String name); static String removeInvalidChars(String name, String prefix); } | @Test public void testRemoveInvalidCharsMiddle() { assertThat(removeInvalidCharsMiddle("1cls"), is("1cls")); assertThat(removeInvalidCharsMiddle("-cls"), is("cls")); assertThat(removeInvalidCharsMiddle("A-cls"), is("Acls")); } |
NameMapper { public static String removeInvalidChars(String name, String prefix) { String result = removeInvalidCharsMiddle(name); if (!result.isEmpty()) { int codePoint = result.codePointAt(0); if (!isValidIdentifierStart(codePoint)) { return prefix + result; } } return result; } private NameMapper(); static boolean isReserved(String str); static boolean isValidIdentifier(String str); static boolean isValidFullIdentifier(String str); static boolean isValidAndPrintable(String str); static boolean isValidIdentifierStart(int codePoint); static boolean isValidIdentifierPart(int codePoint); static boolean isPrintableChar(int c); static boolean isAllCharsPrintable(String str); static String removeInvalidCharsMiddle(String name); static String removeInvalidChars(String name, String prefix); } | @Test public void testRemoveInvalidChars() { assertThat(removeInvalidChars("1cls", "C"), is("C1cls")); assertThat(removeInvalidChars("-cls", "C"), is("cls")); assertThat(removeInvalidChars("A-cls", "C"), is("Acls")); } |
JadxCLIArgs { public boolean isSkipSources() { return skipSources; } boolean processArgs(String[] args); boolean overrideProvided(String[] args); JadxArgs toJadxArgs(); List<String> getFiles(); String getOutDir(); String getOutDirSrc(); String getOutDirRes(); boolean isSkipResources(); boolean isSkipSources(); int getThreadsCount(); boolean isFallbackMode(); boolean isShowInconsistentCode(); boolean isUseImports(); boolean isDebugInfo(); boolean isInlineAnonymousClasses(); boolean isDeobfuscationOn(); int getDeobfuscationMinLength(); int getDeobfuscationMaxLength(); boolean isDeobfuscationForceSave(); boolean isDeobfuscationUseSourceNameAsAlias(); boolean isDeobfuscationParseKotlinMetadata(); boolean isEscapeUnicode(); boolean isCfgOutput(); boolean isRawCfgOutput(); boolean isReplaceConsts(); boolean isRespectBytecodeAccessModifiers(); boolean isExportAsGradleProject(); boolean isRenameCaseSensitive(); boolean isRenameValid(); boolean isRenamePrintable(); boolean isFsCaseSensitive(); static String enumValuesString(Enum<?>[] values); } | @Test public void testSrcOption() { assertThat(parse("--no-src").isSkipSources(), is(true)); assertThat(parse("-s").isSkipSources(), is(true)); assertThat(parse("").isSkipSources(), is(false)); } |
JSources extends JNode { List<JPackage> getHierarchyPackages(List<JavaPackage> packages) { Map<String, JPackage> pkgMap = new HashMap<>(); for (JavaPackage pkg : packages) { addPackage(pkgMap, new JPackage(pkg, wrapper)); } boolean repeat; do { repeat = false; for (JPackage pkg : pkgMap.values()) { List<JPackage> innerPackages = pkg.getInnerPackages(); if (innerPackages.size() == 1 && pkg.getClasses().isEmpty()) { JPackage innerPkg = innerPackages.get(0); pkg.setInnerPackages(innerPkg.getInnerPackages()); pkg.setClasses(innerPkg.getClasses()); String innerName = '.' + innerPkg.getName(); pkg.updateBothNames(pkg.getFullName() + innerName, pkg.getName() + innerName, wrapper); innerPkg.setInnerPackages(Collections.emptyList()); innerPkg.setClasses(Collections.emptyList()); repeat = true; break; } } } while (repeat); pkgMap.values().removeIf(pkg -> pkg.getInnerPackages().isEmpty() && pkg.getClasses().isEmpty()); Set<JPackage> innerPackages = Collections.newSetFromMap(new IdentityHashMap<>()); for (JPackage pkg : pkgMap.values()) { innerPackages.addAll(pkg.getInnerPackages()); } List<JPackage> rootPkgs = new ArrayList<>(); for (JPackage pkg : pkgMap.values()) { if (!innerPackages.contains(pkg)) { rootPkgs.add(pkg); } } Collections.sort(rootPkgs); return rootPkgs; } JSources(JRoot jRoot, JadxWrapper wrapper); final void update(); @Override Icon getIcon(); @Override JClass getJParent(); @Override String makeString(); } | @Test public void testHierarchyPackages() { String pkgName = "a.b.c.d.e"; List<JavaPackage> packages = Collections.singletonList(newPkg(pkgName)); List<JPackage> out = sources.getHierarchyPackages(packages); assertThat(out, hasSize(1)); JPackage jPkg = out.get(0); assertThat(jPkg.getName(), is(pkgName)); assertThat(jPkg.getClasses(), hasSize(1)); }
@Test public void testHierarchyPackages2() { List<JavaPackage> packages = asList( newPkg("a.b"), newPkg("a.c"), newPkg("a.d")); List<JPackage> out = sources.getHierarchyPackages(packages); assertThat(out, hasSize(1)); JPackage jPkg = out.get(0); assertThat(jPkg.getName(), is("a")); assertThat(jPkg.getClasses(), hasSize(0)); assertThat(jPkg.getInnerPackages(), hasSize(3)); }
@Test public void testHierarchyPackages3() { List<JavaPackage> packages = asList( newPkg("a.b.p1"), newPkg("a.b.p2"), newPkg("a.b.p3")); List<JPackage> out = sources.getHierarchyPackages(packages); assertThat(out, hasSize(1)); JPackage jPkg = out.get(0); assertThat(jPkg.getName(), is("a.b")); assertThat(jPkg.getClasses(), hasSize(0)); assertThat(jPkg.getInnerPackages(), hasSize(3)); }
@Test public void testHierarchyPackages4() { List<JavaPackage> packages = asList( newPkg("a.p1"), newPkg("a.b.c.p2"), newPkg("a.b.c.p3"), newPkg("d.e"), newPkg("d.f.a")); List<JPackage> out = sources.getHierarchyPackages(packages); assertThat(out, hasSize(2)); assertThat(out.get(0).getName(), is("a")); assertThat(out.get(0).getInnerPackages(), hasSize(2)); assertThat(out.get(1).getName(), is("d")); assertThat(out.get(1).getInnerPackages(), hasSize(2)); } |
CertificateManager { public static String decode(InputStream in) { StringBuilder strBuild = new StringBuilder(); Collection<? extends Certificate> certificates = readCertificates(in); if (certificates != null) { for (Certificate cert : certificates) { CertificateManager certificateManager = new CertificateManager(cert); strBuild.append(certificateManager.generateText()); } } return strBuild.toString(); } CertificateManager(Certificate cert); static String decode(InputStream in); String generateHeader(); String generateSignature(); String generateFingerprint(); String generatePublicKey(); String generateTextForX509(); String generateText(); static String getThumbPrint(X509Certificate cert, String type); static String hexify(byte[] bytes); } | @Test public void decodeNotCertificateFile() throws IOException { try (InputStream in = new FileInputStream(emptyPath)) { String result = CertificateManager.decode(in); assertEquals("", result); } } |
CertificateManager { public String generateHeader() { StringBuilder builder = new StringBuilder(); append(builder, NLS.str("certificate.cert_type"), x509cert.getType()); append(builder, NLS.str("certificate.serialSigVer"), ((Integer) x509cert.getVersion()).toString()); append(builder, NLS.str("certificate.serialNumber"), "0x" + x509cert.getSerialNumber().toString(16)); Principal subjectDN = x509cert.getSubjectDN(); append(builder, NLS.str("certificate.cert_subject"), subjectDN.getName()); append(builder, NLS.str("certificate.serialValidFrom"), x509cert.getNotBefore().toString()); append(builder, NLS.str("certificate.serialValidUntil"), x509cert.getNotAfter().toString()); return builder.toString(); } CertificateManager(Certificate cert); static String decode(InputStream in); String generateHeader(); String generateSignature(); String generateFingerprint(); String generatePublicKey(); String generateTextForX509(); String generateText(); static String getThumbPrint(X509Certificate cert, String type); static String hexify(byte[] bytes); } | @Test public void decodeRSAKeyHeader() { String string = certificateManagerRSA.generateHeader(); assertTrue(string.contains("X.509")); assertTrue(string.contains("0x4bd68052")); assertTrue(string.contains("CN=test cert, OU=test unit, O=OOO TestOrg, L=St.Peterburg, ST=Russia, C=123456")); }
@Test public void decodeDSAKeyHeader() { String string = certificateManagerDSA.generateHeader(); assertTrue(string.contains("X.509")); assertTrue(string.contains("0x16420ba2")); assertTrue(string.contains("O=\"UJMRFVV CN=EDCVBGT C=TG\"")); } |
CatalogService { public CompletableFuture<String> addProductToCatalog(AddProductToCatalogCommand command) { LOG.debug("Processing AddProductToCatalogCommand command: {}", command); return this.commandGateway.send(command); } CatalogService(CommandGateway commandGateway); CompletableFuture<String> addProductToCatalog(AddProductToCatalogCommand command); } | @Test public void testApi() throws Exception { when(commandGateway.send(any())) .thenAnswer(i -> { AddProductToCatalogCommand command = i.getArgumentAt(0, AddProductToCatalogCommand.class); assertEquals(id, command.getId()); CompletableFuture<String> response = new CompletableFuture<String>(); response.complete(command.getId()); return response; }); CompletableFuture<String> response = service.addProductToCatalog(command); verify(commandGateway, times(1)).send(any()); verifyNoMoreInteractions(commandGateway); assertEquals(id, response.get().toString()); } |
CatalogApiController { @PostMapping("/add") public CompletableFuture<String> addProductToCatalog(@RequestBody Map<String, String> request) { AddProductToCatalogCommand command = new AddProductToCatalogCommand(request.get("id"), request.get("name")); LOG.info("Executing command: {}", command); return catalogService.addProductToCatalog(command); } CatalogApiController(CatalogService commandGateway); @PostMapping("/add") CompletableFuture<String> addProductToCatalog(@RequestBody Map<String, String> request); } | @Test public void checkControllerCallsServiceCorrectly() throws ExecutionException, InterruptedException { assertNotNull(request); assertNotNull(request.containsKey("id")); assertNotNull(request.containsKey("name")); when(commandGateway.addProductToCatalog(any(AddProductToCatalogCommand.class))) .thenAnswer(i -> { AddProductToCatalogCommand command = i.getArgumentAt(0, AddProductToCatalogCommand.class); CompletableFuture<String> response = new CompletableFuture<String>(); response.complete(command.getId()); return response; }); CompletableFuture<String> answer = controller.addProductToCatalog(request); verify(commandGateway, times(1)).addProductToCatalog(any(AddProductToCatalogCommand.class)); verifyNoMoreInteractions(commandGateway); assertEquals(id, answer.get().toString()); } |
EventProcessor { @EventHandler public void on(ProductAddedEvent productAddedEvent) { repo.save(new Product(productAddedEvent.getId(), productAddedEvent.getName())); LOG.info("A product was added! Id={} Name={}", productAddedEvent.getId(), productAddedEvent.getName()); } EventProcessor(ProductRepository repository); @EventHandler // Mark this method as an Axon Event Handler void on(ProductAddedEvent productAddedEvent); } | @Test public void testOn(){ List<Product> products = new ArrayList<>(); when(repo.save(any(Product.class))) .thenAnswer(i -> { Product prod = i.getArgumentAt(0, Product.class); products.add(prod); return prod; }); processor.on(event); verify(repo, times(1)).save(any(Product.class)); verifyNoMoreInteractions(repo); Assert.assertEquals(products.get(0).getId(), uuid); Assert.assertEquals(products.get(0).getName(), name); } |
DriftMethodInvocation extends AbstractFuture<Object> { static <A extends Address> DriftMethodInvocation<A> createDriftMethodInvocation( MethodInvoker invoker, MethodMetadata metadata, Map<String, String> headers, List<Object> parameters, RetryPolicy retryPolicy, AddressSelector<A> addressSelector, Optional<String> addressSelectionContext, MethodInvocationStat stat, Ticker ticker) { DriftMethodInvocation<A> invocation = new DriftMethodInvocation<>( invoker, metadata, headers, parameters, retryPolicy, addressSelector, addressSelectionContext, stat, ticker); invocation.nextAttempt(true); return invocation; } private DriftMethodInvocation(
MethodInvoker invoker,
MethodMetadata metadata,
Map<String, String> headers,
List<Object> parameters,
RetryPolicy retryPolicy,
AddressSelector<A> addressSelector,
Optional<String> addressSelectionContext,
MethodInvocationStat stat,
Ticker ticker); } | @Test(timeOut = 60000) public void testFirstTrySuccess() throws Exception { TestingMethodInvocationStat stat = new TestingMethodInvocationStat(); DriftMethodInvocation<?> methodInvocation = createDriftMethodInvocation(RetryPolicy.NO_RETRY_POLICY, stat, () -> immediateFuture(SUCCESS)); assertEquals(methodInvocation.get(), SUCCESS); stat.assertSuccess(0); } |
ThriftEnumMetadata { public ThriftEnumMetadata( String enumName, Class<T> enumClass) throws RuntimeException { this.enumName = requireNonNull(enumName, "enumName must not be null"); this.enumClass = requireNonNull(enumClass, "enumClass must not be null"); Method enumValueMethod = null; for (Method method : enumClass.getMethods()) { if (method.isAnnotationPresent(ThriftEnumValue.class)) { checkArgument( Modifier.isPublic(method.getModifiers()), "Enum class %s @ThriftEnumValue method is not public: %s", enumClass.getName(), method); checkArgument( !Modifier.isStatic(method.getModifiers()), "Enum class %s @ThriftEnumValue method is static: %s", enumClass.getName(), method); checkArgument( method.getTypeParameters().length == 0, "Enum class %s @ThriftEnumValue method has parameters: %s", enumClass.getName(), method); Class<?> returnType = method.getReturnType(); checkArgument( returnType == int.class || returnType == Integer.class, "Enum class %s @ThriftEnumValue method does not return int or Integer: %s", enumClass.getName(), method); checkArgument( enumValueMethod == null, "Enum class %s has multiple methods annotated with @ThriftEnumValue", enumClass.getName()); enumValueMethod = method; } } checkArgument( enumValueMethod != null, "Enum class %s must have a method annotated with @ThriftEnumValue", enumClass.getName()); Set<Integer> values = new HashSet<>(); ImmutableMap.Builder<T, ImmutableList<String>> elementDocs = ImmutableMap.builder(); ImmutableMap.Builder<Integer, T> byEnumValue = ImmutableMap.builder(); ImmutableMap.Builder<T, Integer> byEnumConstant = ImmutableMap.builder(); Optional<T> unknownEnumConstant = Optional.empty(); for (T enumConstant : enumClass.getEnumConstants()) { Integer value; try { value = (Integer) enumValueMethod.invoke(enumConstant); } catch (Exception e) { throw new RuntimeException(format("Enum class %s element %s get value method threw an exception", enumClass.getName(), enumConstant), e); } checkArgument(value != null, "Enum class %s element %s returned null for enum value", enumClass.getName(), enumConstant); checkArgument(values.add(value), "Enum class %s returned duplicate enum values: %s", enumClass.getName(), value); byEnumValue.put(value, enumConstant); byEnumConstant.put(enumConstant, value); if (isThriftEnumUnknownValue(enumClass, enumConstant)) { checkArgument(!unknownEnumConstant.isPresent(), "Enum class %s has multiple constants annotated with @ThriftEnumUnknownValue", enumClass.getName()); unknownEnumConstant = Optional.of(enumConstant); } elementDocs.put(enumConstant, ThriftCatalog.getThriftDocumentation(enumConstant)); } this.byEnumValue = byEnumValue.build(); this.byEnumConstant = byEnumConstant.build(); this.unknownEnumConstant = unknownEnumConstant; this.elementDocs = elementDocs.build(); this.documentation = ThriftCatalog.getThriftDocumentation(enumClass); } ThriftEnumMetadata(
String enumName,
Class<T> enumClass); String getEnumName(); Class<T> getEnumClass(); Map<Integer, T> getByEnumValue(); Map<T, Integer> getByEnumConstant(); Optional<T> getUnknownEnumConstant(); ImmutableList<String> getDocumentation(); Map<T, ImmutableList<String>> getElementsDocumentation(); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); } | @Test(expectedExceptions = IllegalArgumentException.class, expectedExceptionsMessageRegExp = "Enum class .*DuplicateValues returned duplicate enum values: 42") public void testDuplicateValues() { thriftEnumMetadata(DuplicateValues.class); }
@Test(expectedExceptions = IllegalArgumentException.class, expectedExceptionsMessageRegExp = "Enum class .*MultipleUnknownValues has multiple constants annotated with @ThriftEnumUnknownValue") public void testMultipleUnknownValues() { thriftEnumMetadata(MultipleUnknownValues.class); }
@Test(expectedExceptions = IllegalArgumentException.class, expectedExceptionsMessageRegExp = "Enum class .*MissingEnumAnnotation is not annotated with @ThriftEnum") public void testMissingEnumAnnotation() { thriftEnumMetadata(MissingEnumAnnotation.class); }
@Test(expectedExceptions = IllegalArgumentException.class, expectedExceptionsMessageRegExp = "Enum class .*MissingValueMethod must have a method annotated with @ThriftEnumValue") public void testMissingValueMethod() { thriftEnumMetadata(MissingValueMethod.class); }
@Test(expectedExceptions = IllegalArgumentException.class, expectedExceptionsMessageRegExp = "Enum class .*MultipleValueMethods has multiple methods annotated with @ThriftEnumValue") public void testMultipleValueMethods() { thriftEnumMetadata(MultipleValueMethods.class); } |
ReflectionHelper { public static List<String> extractParameterNames(Executable methodOrConstructor) { return PARAMETER_NAMES.getUnchecked(methodOrConstructor); } private ReflectionHelper(); static boolean isArray(Type type); static boolean isOptional(Type type); static Class<?> getArrayOfType(Type componentType); static Type getMapKeyType(Type type); static Type getMapValueType(Type type); static Type getIterableType(Type type); static Type getOptionalType(Type type); static Type getFutureReturnType(Type type); static Set<T> getEffectiveClassAnnotations(Class<?> type, Class<T> annotation); static Iterable<Method> getAllDeclaredMethods(Class<?> type); static Iterable<Field> getAllDeclaredFields(Class<?> type); static Collection<Method> findAnnotatedMethods(Class<?> type, Class<? extends Annotation> annotation); @SuppressWarnings("PMD.EmptyCatchBlock") static Method findAnnotatedMethod(Class<?> configClass, Class<? extends Annotation> annotation, String methodName, Class<?>... paramTypes); static Collection<Field> findAnnotatedFields(Class<?> type, Class<? extends Annotation> annotation); static List<String> extractParameterNames(Executable methodOrConstructor); static String extractFieldName(Method method); static String extractFieldName(String methodName); static Type resolveFieldType(Type structType, Type genericType); static Type[] resolveFieldTypes(Type structType, Type[] genericTypes); } | @Test public void testExtractParameterNamesNoAnnotations() throws Exception { assertEquals( extractParameterNames(getClass().getDeclaredMethod("noAnnotations", String.class, String.class, String.class)), ImmutableList.of("a", "b", "c")); }
@Test public void testExtractParameterNamesThriftFieldAnnotation() throws Exception { assertEquals( extractParameterNames(getClass().getDeclaredMethod("thriftFieldAnnotation", String.class, String.class, String.class)), ImmutableList.of("a", "b", "c")); }
@Test public void testExtractParameterNamesMixedThriftFieldAnnotation() throws Exception { assertEquals( extractParameterNames(getClass().getDeclaredMethod("mixedThriftFieldAnnotation", String.class, String.class, String.class)), ImmutableList.of("a", "b", "c")); } |
ThriftUnionMetadataBuilder extends AbstractThriftMetadataBuilder { @Override public ThriftStructMetadata build() { metadataErrors.throwIfHasErrors(); ThriftMethodInjection builderMethodInjection = buildBuilderConstructorInjections(); ThriftConstructorInjection constructorInjection = buildConstructorInjection(); Iterable<ThriftFieldMetadata> fieldsMetadata = buildFieldInjections(); List<ThriftMethodInjection> methodInjections = buildMethodInjections(); return new ThriftStructMetadata( structName, extractStructIdlAnnotations(), structType, builderType, MetadataType.UNION, Optional.ofNullable(builderMethodInjection), ImmutableList.copyOf(documentation), ImmutableList.copyOf(fieldsMetadata), Optional.ofNullable(constructorInjection), methodInjections); } ThriftUnionMetadataBuilder(ThriftCatalog catalog, Type structType); @Override ThriftStructMetadata build(); } | @Test public void testNonFinalUnionOk() { ThriftUnionMetadataBuilder builder = new ThriftUnionMetadataBuilder(new ThriftCatalog(), NotFinalUnion.class); builder.build(); } |
ThriftStructMetadataBuilder extends AbstractThriftMetadataBuilder { @Override public ThriftStructMetadata build() { metadataErrors.throwIfHasErrors(); ThriftMethodInjection builderMethodInjection = buildBuilderConstructorInjections(); ThriftConstructorInjection constructorInjections = buildConstructorInjection(); Iterable<ThriftFieldMetadata> fieldsMetadata = buildFieldInjections(); List<ThriftMethodInjection> methodInjections = buildMethodInjections(); return new ThriftStructMetadata( structName, extractStructIdlAnnotations(), structType, builderType, MetadataType.STRUCT, Optional.ofNullable(builderMethodInjection), ImmutableList.copyOf(documentation), ImmutableList.copyOf(fieldsMetadata), Optional.of(constructorInjections), methodInjections); } ThriftStructMetadataBuilder(ThriftCatalog catalog, Type structType); @Override ThriftStructMetadata build(); } | @Test public void testGenericBuilder() { Type structType = new TypeToken<GenericStruct<String>>() {}.getType(); ThriftStructMetadataBuilder builder = new ThriftStructMetadataBuilder(new ThriftCatalog(), structType); builder.build(); }
@Test(expectedExceptions = MetadataErrorException.class) public void testGenericBuilderForNonGenericStruct() { Type structType = new TypeToken<NonGenericStruct>() {}.getType(); ThriftStructMetadataBuilder builder = new ThriftStructMetadataBuilder(new ThriftCatalog(), structType); builder.build(); }
@Test public void testMergeableRequiredness() { ThriftStructMetadata metadata = new ThriftStructMetadataBuilder(new ThriftCatalog(), MergeableRequiredness.class).build(); assertThat(metadata.getField(1).getRequiredness()) .as("requiredness of field 'foo'") .isEqualTo(Requiredness.OPTIONAL); }
@Test public void testNonFinalStructsOk() { ThriftStructMetadataBuilder builder = new ThriftStructMetadataBuilder(new ThriftCatalog(), NotFinalStruct.class); builder.build(); } |
RetryPolicy { public ExceptionClassification classifyException(Throwable throwable, boolean idempotent) { if (throwable instanceof ConnectionFailedException) { return new ExceptionClassification(Optional.of(TRUE), DOWN); } if (idempotent && throwable instanceof RequestTimeoutException) { return new ExceptionClassification(Optional.of(TRUE), NORMAL); } if (throwable instanceof MessageTooLargeException) { return new ExceptionClassification(Optional.of(FALSE), NORMAL); } if (throwable instanceof InterruptedException || throwable instanceof InterruptedIOException) { return new ExceptionClassification(Optional.of(FALSE), NORMAL); } ExceptionClassification result = exceptionClassifier.classifyException(unwrapUserException(throwable)); if (result.isRetry().isPresent()) { return result; } if (throwable instanceof DriftApplicationException) { Optional<Boolean> retryable = ((DriftApplicationException) throwable).isRetryable(); if (retryable.isPresent()) { return new ExceptionClassification(retryable, NORMAL); } } if (idempotent && throwable instanceof TTransportException) { return new ExceptionClassification(Optional.of(TRUE), NORMAL); } return result; } RetryPolicy(DriftClientConfig config, ExceptionClassifier exceptionClassifier); RetryPolicy(int maxRetries,
Duration minBackoffDelay,
Duration maxBackoffDelay,
double backoffScaleFactor,
Duration maxRetryTime,
ExceptionClassifier exceptionClassifier); int getMaxRetries(); Duration getBackoffDelay(int invocationAttempts); Duration getMaxRetryTime(); ExceptionClassification classifyException(Throwable throwable, boolean idempotent); @Override String toString(); static final RetryPolicy NO_RETRY_POLICY; } | @Test public void testRetryUserException() { ExceptionClassification overloaded = new ExceptionClassification(Optional.of(true), OVERLOADED); RetryPolicy policy = new RetryPolicy(new DriftClientConfig(), classifier -> { if (classifier instanceof TestingUserException) { return overloaded; } return NORMAL_EXCEPTION; }); assertSame(policy.classifyException(new DriftApplicationException(new TestingUserException(), Optional.empty()), true), overloaded); assertSame(policy.classifyException(new TestingUserException(), true), overloaded); } |
ThriftCatalog { public <T extends Enum<T>> ThriftEnumMetadata<?> getThriftEnumMetadata(Class<?> enumClass) { checkArgument(enumClass.isEnum(), "Class %s is not an enum", enumClass.getName()); ThriftEnumMetadata<?> enumMetadata = enums.get(enumClass); if (enumMetadata == null) { enumMetadata = thriftEnumMetadata((Class<T>) enumClass); ThriftEnumMetadata<?> current = enums.putIfAbsent(enumClass, enumMetadata); if (current != null) { enumMetadata = current; } } return enumMetadata; } ThriftCatalog(); ThriftCatalog(Monitor monitor); void addThriftType(ThriftType thriftType); void addDefaultCoercions(Class<?> coercionsClass); TypeCoercion getDefaultCoercion(Type type); ThriftType getThriftType(Type javaType); ThriftType getThriftTypeFromCache(Type javaType); ThriftTypeReference getFieldThriftTypeReference(FieldMetadata fieldMetadata); ThriftTypeReference getCollectionElementThriftTypeReference(Type javaType); ThriftTypeReference getMapKeyThriftTypeReference(Type javaType); ThriftTypeReference getMapValueThriftTypeReference(Type javaType); ThriftTypeReference getOptionalThriftTypeReference(Type javaType); boolean isSupportedStructFieldType(Type javaType); ThriftProtocolType getThriftProtocolType(Type javaType); static boolean isStructType(Type javaType); boolean isSupportedArrayComponentType(Class<?> componentType); ThriftEnumMetadata<?> getThriftEnumMetadata(Class<?> enumClass); ThriftStructMetadata getThriftStructMetadata(Type structType); @SuppressWarnings("PMD.EmptyCatchBlock") static ImmutableList<String> getThriftDocumentation(Class<?> objectClass); @SuppressWarnings("PMD.EmptyCatchBlock") static ImmutableList<String> getThriftDocumentation(Method method); @SuppressWarnings("PMD.EmptyCatchBlock") static ImmutableList<String> getThriftDocumentation(Field field); @SuppressWarnings("PMD.EmptyCatchBlock") static ImmutableList<String> getThriftDocumentation(Enum<T> enumConstant); @SuppressWarnings("PMD.EmptyCatchBlock") static Integer getMethodOrder(Method method); } | @Test(expectedExceptions = IllegalArgumentException.class, expectedExceptionsMessageRegExp = "Class .*NotEnum is not an enum") public void testEnumMetadataForNonEnum() { new ThriftCatalog().getThriftEnumMetadata(NotEnum.class); } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.