use of com.quorum.tessera.enclave.EncodedPayload in project tessera by ConsenSys.
the class AsyncBatchPayloadPublisherTest method publishPayloadStripsAndPublishes.
@Test
public void publishPayloadStripsAndPublishes() throws InterruptedException {
final Executor realExecutor = Executors.newSingleThreadExecutor();
when(executorFactory.createCachedThreadPool()).thenReturn(realExecutor);
asyncPublisher = new AsyncBatchPayloadPublisher(executorFactory, countDownLatchFactory, publisher);
final PublicKey recipient = PublicKey.from("RECIPIENT".getBytes());
final PublicKey otherRecipient = PublicKey.from("OTHERRECIPIENT".getBytes());
final List<PublicKey> recipients = List.of(recipient, otherRecipient);
final EncodedPayload payload = EncodedPayload.Builder.create().withSenderKey(mock(PublicKey.class)).withRecipientKeys(recipients).withRecipientBoxes(List.of("box1".getBytes(), "box2".getBytes())).build();
doAnswer(invocation -> {
// sleep main thread so publish threads can work
Thread.sleep(200);
return null;
}).when(countDownLatch).await();
asyncPublisher.publishPayload(payload, recipients);
verify(executorFactory, times(2)).createCachedThreadPool();
verify(countDownLatchFactory).create(2);
verify(publisher).publishPayload(any(), eq(recipient));
verify(publisher).publishPayload(any(), eq(otherRecipient));
verify(countDownLatch, times(2)).countDown();
verify(countDownLatch).await();
}
use of com.quorum.tessera.enclave.EncodedPayload in project tessera by ConsenSys.
the class AsyncBatchPayloadPublisherTest method publishPayloadCancelsCountDownLatchIfOneTaskFails.
@Test
public void publishPayloadCancelsCountDownLatchIfOneTaskFails() throws InterruptedException {
final Executor realExecutor = Executors.newCachedThreadPool();
when(executorFactory.createCachedThreadPool()).thenReturn(realExecutor);
asyncPublisher = new AsyncBatchPayloadPublisher(executorFactory, countDownLatchFactory, publisher);
final PublicKey recipient = PublicKey.from("RECIPIENT".getBytes());
final PublicKey otherRecipient = PublicKey.from("OTHERRECIPIENT".getBytes());
final List<PublicKey> recipients = List.of(recipient, otherRecipient);
final EncodedPayload payload = EncodedPayload.Builder.create().withSenderKey(mock(PublicKey.class)).withRecipientKeys(recipients).withRecipientBoxes(List.of("box1".getBytes(), "box2".getBytes())).build();
final PublishPayloadException cause = new PublishPayloadException("some exception");
doThrow(cause).doNothing().when(publisher).publishPayload(any(EncodedPayload.class), any(PublicKey.class));
doAnswer(invocation -> {
// sleep main thread so publish threads can work
Thread.sleep(200);
return null;
}).when(countDownLatch).await();
asyncPublisher.publishPayload(payload, recipients);
verify(executorFactory, times(2)).createCachedThreadPool();
verify(countDownLatchFactory).create(2);
verify(publisher).publishPayload(any(), eq(recipient));
verify(publisher).publishPayload(any(), eq(otherRecipient));
verify(countDownLatch).countDown();
verify(countDownLatch).cancelWithException(cause);
verify(countDownLatch).await();
}
use of com.quorum.tessera.enclave.EncodedPayload in project tessera by ConsenSys.
the class AsyncBatchPayloadPublisherTest method publishPayloadWrapsInterruptedException.
@Test
public void publishPayloadWrapsInterruptedException() throws InterruptedException {
EncodedPayload payload = mock(EncodedPayload.class);
PublicKey recipient = PublicKey.from("RECIPIENT".getBytes());
PublicKey otherRecipient = PublicKey.from("OTHERRECIPIENT".getBytes());
List<PublicKey> recipients = List.of(recipient, otherRecipient);
InterruptedException cause = new InterruptedException("some exception");
doThrow(cause).when(countDownLatch).await();
Throwable ex = catchThrowable(() -> asyncPublisher.publishPayload(payload, recipients));
assertThat(ex).isExactlyInstanceOf(BatchPublishPayloadException.class);
assertThat(ex).hasCause(cause);
verify(executorFactory).createCachedThreadPool();
verify(executor, times(2)).execute(any(Runnable.class));
verify(countDownLatchFactory).create(2);
verify(countDownLatch).await();
}
use of com.quorum.tessera.enclave.EncodedPayload in project tessera by ConsenSys.
the class RestPayloadPublisherTest method publishMandatoryRecipientsToNodesThatDoNotSupport.
@Test
public void publishMandatoryRecipientsToNodesThatDoNotSupport() {
String targetUrl = "http://someplace.com";
EncodedPayload encodedPayload = mock(EncodedPayload.class);
when(encodedPayload.getPrivacyMode()).thenReturn(PrivacyMode.MANDATORY_RECIPIENTS);
byte[] payloadData = "Some Data".getBytes();
when(payloadEncoder.encode(encodedPayload)).thenReturn(payloadData);
PublicKey recipientKey = mock(PublicKey.class);
NodeInfo nodeInfo = mock(NodeInfo.class);
when(nodeInfo.supportedApiVersions()).thenReturn(Set.of("v2", "2.1", "3.0"));
Recipient recipient = mock(Recipient.class);
when(recipient.getKey()).thenReturn(recipientKey);
when(recipient.getUrl()).thenReturn(targetUrl);
when(nodeInfo.getRecipients()).thenReturn(Set.of(recipient));
when(discovery.getRemoteNodeInfo(recipientKey)).thenReturn(nodeInfo);
assertThatExceptionOfType(MandatoryRecipientsNotSupportedException.class).isThrownBy(() -> payloadPublisher.publishPayload(encodedPayload, recipientKey)).withMessageContaining("Transactions with mandatory recipients are not currently supported on recipient");
verify(discovery).getRemoteNodeInfo(eq(recipientKey));
payloadEncoderFactoryFunction.verify(() -> PayloadEncoder.create(any(EncodedPayloadCodec.class)));
}
use of com.quorum.tessera.enclave.EncodedPayload in project tessera by ConsenSys.
the class RestPayloadPublisherTest method publish.
@Test
public void publish() {
final String targetUrl = "nodeUrl";
final EncodedPayload encodedPayload = mock(EncodedPayload.class);
final PublicKey publicKey = mock(PublicKey.class);
for (Response.Status expectedResponseStatus : Response.Status.values()) {
for (PrivacyMode privacyMode : PrivacyMode.values()) {
when(encodedPayload.getPrivacyMode()).thenReturn(privacyMode);
final NodeInfo nodeInfo = mock(NodeInfo.class);
when(nodeInfo.supportedApiVersions()).thenReturn(Set.of(EnhancedPrivacyVersion.API_VERSION_2, "2.1", "3.0", "4.0"));
when(nodeInfo.getUrl()).thenReturn(targetUrl);
when(discovery.getRemoteNodeInfo(publicKey)).thenReturn(nodeInfo);
final byte[] payloadData = "Payload".getBytes();
when(payloadEncoder.encode(encodedPayload)).thenReturn(payloadData);
WebTarget webTarget = mock(WebTarget.class);
when(client.target(targetUrl)).thenReturn(webTarget);
when(webTarget.path("/push")).thenReturn(webTarget);
Invocation.Builder invocationBuilder = mock(Invocation.Builder.class);
Response response = Response.status(expectedResponseStatus).build();
when(invocationBuilder.post(Entity.entity(payloadData, MediaType.APPLICATION_OCTET_STREAM_TYPE))).thenReturn(response);
when(webTarget.request()).thenReturn(invocationBuilder);
if (expectedResponseStatus == Response.Status.OK || expectedResponseStatus == Response.Status.CREATED) {
payloadPublisher.publishPayload(encodedPayload, publicKey);
} else {
PublishPayloadException publishPayloadException = Assertions.catchThrowableOfType(() -> payloadPublisher.publishPayload(encodedPayload, publicKey), PublishPayloadException.class);
assertThat(publishPayloadException).hasMessage(String.format("Unable to push payload to recipient url %s", targetUrl));
}
}
}
int iterations = Response.Status.values().length * PrivacyMode.values().length;
verify(client, times(iterations)).target(targetUrl);
verify(discovery, times(iterations)).getRemoteNodeInfo(publicKey);
verify(payloadEncoder, times(iterations)).encode(encodedPayload);
payloadEncoderFactoryFunction.verify(times(iterations), () -> PayloadEncoder.create(any(EncodedPayloadCodec.class)));
}
Aggregations