@Test
public void testFetchResponse() throws IOException {
RuleKey ruleKey = new RuleKey("00000000000000000000000000000000");
RuleKey ruleKey2 = new RuleKey("90000000000000000000008000000005");
final String data = "data";
ImmutableMap<String, String> metadata = ImmutableMap.of("metaKey", "metaValue");
HttpArtifactCacheBinaryProtocol.FetchResponse fetchResponse =
new HttpArtifactCacheBinaryProtocol.FetchResponse(
ImmutableSet.of(ruleKey, ruleKey2),
metadata,
new ByteSource() {
@Override
public InputStream openStream() throws IOException {
return new ByteArrayInputStream(data.getBytes(Charsets.UTF_8));
}
});
assertThat(fetchResponse.getContentLength(), Matchers.is(110L));
ByteArrayOutputStream fetchResponseOutputStream = new ByteArrayOutputStream();
fetchResponse.write(fetchResponseOutputStream);
ByteArrayInputStream fetchResponseInputStream =
new ByteArrayInputStream(fetchResponseOutputStream.toByteArray());
ByteArrayOutputStream fetchResponsePayload = new ByteArrayOutputStream();
FetchResponseReadResult responseReadResult =
HttpArtifactCacheBinaryProtocol.readFetchResponse(
new DataInputStream(fetchResponseInputStream), fetchResponsePayload);
assertThat(responseReadResult.getRuleKeys(), Matchers.containsInAnyOrder(ruleKey, ruleKey2));
assertThat(responseReadResult.getMetadata(), Matchers.equalTo(metadata));
assertThat(fetchResponsePayload.toByteArray(), Matchers.equalTo(data.getBytes(Charsets.UTF_8)));
}
@Test
public void testReadFetchResponse() throws IOException {
final String base64EncodedData =
"AAAALgAAAAEAIDAwMDAwMDAwMDEwMDAwMDAwMDAwMDA4MDAwMDAwMDAwAAAAANcwdr5kYXRh";
final RuleKey ruleKey = new RuleKey("00000000010000000000008000000000");
final String data = "data";
byte[] expectedData;
try (ByteArrayOutputStream out = new ByteArrayOutputStream();
DataOutputStream dataOut = new DataOutputStream(out)) {
byte[] metadata =
HttpArtifactCacheBinaryProtocol.createMetadataHeader(
ImmutableSet.of(ruleKey),
ImmutableMap.<String, String>of(),
ByteSource.wrap(data.getBytes(Charsets.UTF_8)));
dataOut.writeInt(metadata.length);
dataOut.write(metadata);
dataOut.write(data.getBytes(Charsets.UTF_8));
expectedData = out.toByteArray();
}
assertThat(expectedData, Matchers.equalTo(BaseEncoding.base64().decode(base64EncodedData)));
try (ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
DataInputStream inputStream = new DataInputStream(new ByteArrayInputStream(expectedData))) {
FetchResponseReadResult result =
HttpArtifactCacheBinaryProtocol.readFetchResponse(inputStream, outputStream);
assertThat(result.getRuleKeys(), Matchers.contains(ruleKey));
assertThat(outputStream.toByteArray(), Matchers.equalTo(data.getBytes(Charsets.UTF_8)));
assertThat(result.getActualHashCode(), Matchers.equalTo(HashCode.fromString("d73076be")));
assertThat(result.getExpectedHashCode(), Matchers.equalTo(HashCode.fromString("d73076be")));
assertThat(result.getMetadata(), Matchers.anEmptyMap());
assertThat(result.getResponseSizeBytes(), Matchers.equalTo(4L));
}
}