src_fm_fc_ms_ff
stringlengths 43
86.8k
| target
stringlengths 20
276k
|
|---|---|
EcrExtendedAuth { HttpPost createSignedRequest(RegistryAuth localCredentials, Date time) { String host = "ecr." + region + ".amazonaws.com"; logger.debug("Get ECR AuthorizationToken from %s", host); HttpPost request = new HttpPost("https: request.setHeader("host", host); request.setHeader("Content-Type", "application/x-amz-json-1.1"); request.setHeader("X-Amz-Target", "AmazonEC2ContainerRegistry_V20150921.GetAuthorizationToken"); request.setEntity(new StringEntity("{\"registryIds\":[\"" + accountId + "\"]}", StandardCharsets.UTF_8)); AwsSigner4 signer = new AwsSigner4(region, "ecr"); signer.sign(request, localCredentials, time); return request; } EcrExtendedAuth(KitLogger logger, String registry); boolean isAwsRegistry(); RegistryAuth extendedAuth(RegistryAuth localCredentials); } | @Test public void testHeaders() throws ParseException { EcrExtendedAuth eea = new EcrExtendedAuth(logger, "123456789012.dkr.ecr.eu-west-1.amazonaws.com"); RegistryAuth localCredentials = new RegistryAuth.Builder() .username("username") .password("password") .build(); Date signingTime = AwsSigner4Request.TIME_FORMAT.parse("20161217T211058Z"); HttpPost request = eea.createSignedRequest(localCredentials, signingTime); assertEquals("ecr.eu-west-1.amazonaws.com", request.getFirstHeader("host").getValue()); assertEquals("20161217T211058Z", request.getFirstHeader("X-Amz-Date").getValue()); assertEquals("AWS4-HMAC-SHA256 Credential=username/20161217/eu-west-1/ecr/aws4_request, SignedHeaders=content-type;host;x-amz-target, Signature=1bab0f5c269debe913e532011d5d192b190bb4c55d3de1bc1506eefb93e058e1", request.getFirstHeader("Authorization").getValue()); } |
EcrExtendedAuth { public RegistryAuth extendedAuth(RegistryAuth localCredentials) throws IOException { JsonObject jo = getAuthorizationToken(localCredentials); JsonArray authorizationDatas = jo.getAsJsonArray("authorizationData"); JsonObject authorizationData = authorizationDatas.get(0).getAsJsonObject(); String authorizationToken = authorizationData.get("authorizationToken").getAsString(); return new RegistryAuth.Builder().withCredentialsEncoded(authorizationToken).email("none").build(); } EcrExtendedAuth(KitLogger logger, String registry); boolean isAwsRegistry(); RegistryAuth extendedAuth(RegistryAuth localCredentials); } | @Test public void testClientClosedAndCredentialsDecoded(@Mocked final CloseableHttpClient closeableHttpClient, @Mocked final CloseableHttpResponse closeableHttpResponse, @Mocked final StatusLine statusLine) throws IOException { final HttpEntity entity = new StringEntity("{\"authorizationData\": [{" + "\"authorizationToken\": \"QVdTOnBhc3N3b3Jk\"," + "\"expiresAt\": 1448878779.809," + "\"proxyEndpoint\": \"https: new Expectations() {{ statusLine.getStatusCode(); result = 200; closeableHttpResponse.getEntity(); result = entity; }}; EcrExtendedAuth eea = new EcrExtendedAuth(logger, "123456789012.dkr.ecr.eu-west-1.amazonaws.com") { CloseableHttpClient createClient() { return closeableHttpClient; } }; RegistryAuth localCredentials = new RegistryAuth.Builder() .username("username") .password("password") .build(); RegistryAuth awsCredentials = eea.extendedAuth(localCredentials); assertEquals("AWS", awsCredentials.getUsername()); assertEquals("password", awsCredentials.getPassword()); new Verifications() {{ closeableHttpClient.close(); }}; } |
OpenShiftRegistryAuthHandler implements RegistryAuthHandler { @Override public RegistryAuth create(RegistryAuthConfig.Kind kind, String user, String registry, Function<String, String> decryptor) { Properties props = System.getProperties(); String useOpenAuthMode = registryAuthConfig.extractFromProperties(props, kind, AUTH_USE_OPENSHIFT_AUTH); if (useOpenAuthMode != null) { boolean useOpenShift = Boolean.valueOf(useOpenAuthMode); if (!useOpenShift) { return null; } log.debug("AuthConfig: OpenShift credentials"); return validateMandatoryOpenShiftLogin(parseOpenShiftConfig()); } boolean useOpenShiftAuth = Optional.ofNullable(registryAuthConfig.getConfigForHandler(getId(), AUTH_USE_OPENSHIFT_AUTH)) .map(Boolean::parseBoolean) .orElse(false); if (useOpenShiftAuth) { log.debug("AuthConfig: OpenShift credentials"); return validateMandatoryOpenShiftLogin(parseOpenShiftConfig()); } return null; } OpenShiftRegistryAuthHandler(RegistryAuthConfig registryAuthConfig, KitLogger log); @Override String getId(); @Override RegistryAuth create(RegistryAuthConfig.Kind kind, String user, String registry, Function<String, String> decryptor); static final String AUTH_USE_OPENSHIFT_AUTH; } | @Test public void testOpenShiftConfigFromPluginConfig() throws Exception { executeWithTempHomeDir(homeDir -> { createOpenShiftConfig(homeDir,"openshift_simple_config.yaml"); RegistryAuth config = handler.create(RegistryAuthConfig.Kind.PUSH, "roland", null, s -> s); verifyAuthConfig(config,"admin","token123",null); }); }
@Test public void testOpenShiftConfigFromSystemProps() throws Exception { try { System.setProperty("docker.useOpenShiftAuth", "true"); executeWithTempHomeDir(homeDir -> { createOpenShiftConfig(homeDir, "openshift_simple_config.yaml"); RegistryAuth config = handler.create(RegistryAuthConfig.Kind.PUSH, "roland", null, s->s); verifyAuthConfig(config, "admin", "token123", null); }); } finally { System.getProperties().remove("docker.useOpenShiftAuth"); } }
@Test public void testOpenShiftConfigFromSystemPropsNegative() throws Exception { try { System.setProperty("docker.useOpenShiftAuth", "false"); executeWithTempHomeDir(homeDir -> { createOpenShiftConfig(homeDir, "openshift_simple_config.yaml"); RegistryAuth config = handler.create(RegistryAuthConfig.Kind.PUSH, "roland", null, s->s); assertNull(config); }); } finally { System.getProperties().remove("docker.useOpenShiftAuth"); } }
@Test public void testOpenShiftConfigNotLoggedIn() throws Exception { executeWithTempHomeDir(homeDir -> { createOpenShiftConfig(homeDir,"openshift_nologin_config.yaml"); expectedException.expect(IllegalArgumentException.class); expectedException.expectMessage(containsString("~/.kube/config")); handler.create(RegistryAuthConfig.Kind.PUSH, "roland", null, s -> s); }); } |
FromConfigRegistryAuthHandler implements RegistryAuthHandler { @Override public RegistryAuth create(RegistryAuthConfig.Kind kind, String user, String registry, Function<String, String> decryptor) { if (registryAuthConfig.getUsername(kind) != null) { if (registryAuthConfig.getPassword(kind) == null) { throw new IllegalArgumentException("No 'password' given while using <authConfig> in configuration for mode " + kind); } log.debug("AuthConfig: credentials from plugin config"); return RegistryAuth.fromRegistryAuthConfig(registryAuthConfig, kind, decryptor); } return null; } FromConfigRegistryAuthHandler(RegistryAuthConfig registryAuthConfig, KitLogger log); @Override String getId(); @Override RegistryAuth create(RegistryAuthConfig.Kind kind, String user, String registry, Function<String, String> decryptor); } | @Test public void testFromPluginConfiguration() throws IOException { FromConfigRegistryAuthHandler handler = new FromConfigRegistryAuthHandler(setupAuthConfigFactoryWithConfigData(), log); RegistryAuth config = handler.create(RegistryAuthConfig.Kind.PUSH, null, null, s -> s); verifyAuthConfig(config, "roland", "secret", "[email protected]"); }
@Test public void testFromPluginConfigurationPull() throws IOException { FromConfigRegistryAuthHandler handler = new FromConfigRegistryAuthHandler(setupAuthConfigFactoryWithConfigDataForKind(RegistryAuthConfig.Kind.PULL), log); RegistryAuth config = handler.create(RegistryAuthConfig.Kind.PULL, null, null, s -> s); verifyAuthConfig(config, "roland", "secret", "[email protected]"); }
@Test public void testFromPluginConfigurationFailed() throws IOException { FromConfigRegistryAuthHandler handler = new FromConfigRegistryAuthHandler( new RegistryAuthConfig.Builder().addDefaultConfig(RegistryAuth.USERNAME, "admin").build(), log); expectedException.expect(IllegalArgumentException.class); expectedException.expectMessage(containsString("password")); handler.create(RegistryAuthConfig.Kind.PUSH, null, null, s -> s); } |
SystemPropertyRegistryAuthHandler implements RegistryAuthHandler { @Override public RegistryAuth create(RegistryAuthConfig.Kind kind, String user, String registry, Function<String, String> decryptor) { Properties props = System.getProperties(); String username = registryAuthConfig.extractFromProperties(props, kind, RegistryAuth.USERNAME); String password = registryAuthConfig.extractFromProperties(props, kind, RegistryAuth.PASSWORD); if (username == null) { return null; } if (password == null) { throw new IllegalArgumentException("No password provided for username " + username); } log.debug("AuthConfig: credentials from system properties"); return new RegistryAuth.Builder() .username(username) .password(password, decryptor) .email(registryAuthConfig.extractFromProperties(props, kind, RegistryAuth.EMAIL)) .auth(registryAuthConfig.extractFromProperties(props, kind, RegistryAuth.AUTH)) .build(); } SystemPropertyRegistryAuthHandler(RegistryAuthConfig registryAuthConfig, KitLogger log); @Override String getId(); @Override RegistryAuth create(RegistryAuthConfig.Kind kind, String user, String registry, Function<String, String> decryptor); } | @Test public void testEmpty() throws Exception { String userHome = System.getProperty("user.home"); try { File tempDir = Files.createTempDirectory("d-m-p").toFile(); System.setProperty("user.home", tempDir.getAbsolutePath()); assertEquals(handler.create(RegistryAuthConfig.Kind.PUSH, null, "blubberbla:1611", s->s), null); } finally { System.setProperty("user.home", userHome); } }
@Test public void testSystemProperty() throws Exception { System.setProperty("docker.push.username", "roland"); System.setProperty("docker.push.password", "secret"); System.setProperty("docker.push.email", "[email protected]"); try { RegistryAuth config = handler.create(RegistryAuthConfig.Kind.PUSH, null, null, s -> s); verifyAuthConfig(config,"roland","secret","[email protected]"); } finally { System.clearProperty("docker.push.username"); System.clearProperty("docker.push.password"); System.clearProperty("docker.push.email"); } } |
DockerAccessWithHcClient implements DockerAccess { @Override public void saveImage(String image, String filename) throws DockerAccessException { ImageName name = new ImageName(image); String url = urlBuilder.getImage(name); try { delegate.get(url, getImageResponseHandler(filename), HTTP_OK); } catch (IOException e) { throw new DockerAccessException(e, "Unable to save '%s' to '%s'", image, filename); } } DockerAccessWithHcClient(String apiVersion,
String baseUrl,
String certPath,
int maxConnections,
KitLogger log); @Override String getServerApiVersion(); @Override void buildImage(String image, File dockerArchive, BuildOptions options); @Override boolean hasImage(String name); @Override String getImageId(String name); @Override void loadImage(String image, File tarArchive); @Override void pullImage(String image, String authHeader, String registry); @Override void pushImage(String image, String authHeader, String registry, int retries); @Override void saveImage(String image, String filename); @Override void tag(String sourceImage, String targetImage, boolean force); @Override boolean removeImage(String image, boolean... forceOpt); } | @Test public void testSaveImage() throws IOException { givenAnImageName("test"); givenFilename("test.tar"); givenCompression(ArchiveCompression.none); whenSaveImage(); thenNoException(); } |
DockerFileBuilder { public DockerFileBuilder maintainer(String maintainer) { this.maintainer = maintainer; return this; } DockerFileBuilder(); File write(File destDir); String content(); DockerFileBuilder baseImage(String baseImage); DockerFileBuilder maintainer(String maintainer); DockerFileBuilder workdir(String workdir); DockerFileBuilder basedir(String dir); DockerFileBuilder cmd(Arguments cmd); DockerFileBuilder entryPoint(Arguments entryPoint); DockerFileBuilder assemblyUser(String assemblyUser); DockerFileBuilder user(String user); DockerFileBuilder healthCheck(HealthCheckConfiguration healthCheck); DockerFileBuilder add(String source, String destination); DockerFileBuilder expose(List<String> ports); DockerFileBuilder run(List<String> runCmds); DockerFileBuilder exportTargetDir(Boolean exportTargetDir); DockerFileBuilder env(Map<String, String> values); DockerFileBuilder labels(Map<String,String> values); DockerFileBuilder volumes(List<String> volumes); DockerFileBuilder optimise(); static List<String[]> extractLines(File dockerFile,
String keyword,
Function<String, String> interpolator); } | @Test public void testMaintainer() { String dockerfileContent = new DockerFileBuilder().maintainer("[email protected]").content(); assertThat(dockerfileToMap(dockerfileContent), hasEntry("MAINTAINER", "[email protected]")); } |
DockerFileBuilder { public DockerFileBuilder optimise() { this.shouldOptimise = true; return this; } DockerFileBuilder(); File write(File destDir); String content(); DockerFileBuilder baseImage(String baseImage); DockerFileBuilder maintainer(String maintainer); DockerFileBuilder workdir(String workdir); DockerFileBuilder basedir(String dir); DockerFileBuilder cmd(Arguments cmd); DockerFileBuilder entryPoint(Arguments entryPoint); DockerFileBuilder assemblyUser(String assemblyUser); DockerFileBuilder user(String user); DockerFileBuilder healthCheck(HealthCheckConfiguration healthCheck); DockerFileBuilder add(String source, String destination); DockerFileBuilder expose(List<String> ports); DockerFileBuilder run(List<String> runCmds); DockerFileBuilder exportTargetDir(Boolean exportTargetDir); DockerFileBuilder env(Map<String, String> values); DockerFileBuilder labels(Map<String,String> values); DockerFileBuilder volumes(List<String> volumes); DockerFileBuilder optimise(); static List<String[]> extractLines(File dockerFile,
String keyword,
Function<String, String> interpolator); } | @Test public void testOptimise() { String dockerfileContent = new DockerFileBuilder().optimise().run(Arrays.asList("echo something", "echo two")).content(); assertThat(dockerfileToMap(dockerfileContent), hasEntry("RUN", "echo something && echo two")); } |
DockerFileBuilder { public DockerFileBuilder user(String user) { this.user = user; return this; } DockerFileBuilder(); File write(File destDir); String content(); DockerFileBuilder baseImage(String baseImage); DockerFileBuilder maintainer(String maintainer); DockerFileBuilder workdir(String workdir); DockerFileBuilder basedir(String dir); DockerFileBuilder cmd(Arguments cmd); DockerFileBuilder entryPoint(Arguments entryPoint); DockerFileBuilder assemblyUser(String assemblyUser); DockerFileBuilder user(String user); DockerFileBuilder healthCheck(HealthCheckConfiguration healthCheck); DockerFileBuilder add(String source, String destination); DockerFileBuilder expose(List<String> ports); DockerFileBuilder run(List<String> runCmds); DockerFileBuilder exportTargetDir(Boolean exportTargetDir); DockerFileBuilder env(Map<String, String> values); DockerFileBuilder labels(Map<String,String> values); DockerFileBuilder volumes(List<String> volumes); DockerFileBuilder optimise(); static List<String[]> extractLines(File dockerFile,
String keyword,
Function<String, String> interpolator); } | @Test public void testUser() { String dockerFile = new DockerFileBuilder().assemblyUser("jboss:jboss:jboss").user("bob") .add("a","a/nested").add("b","b/deeper/nested").content(); String EXPECTED_REGEXP = "USER bob$"; Pattern pattern = Pattern.compile(EXPECTED_REGEXP); assertTrue(pattern.matcher(dockerFile).find()); } |
BuildConfiguration implements Serializable { public String validate() throws IllegalArgumentException { if (entryPoint != null) { entryPoint.validate(); } if (cmd != null) { cmd.validate(); } if (healthCheck != null) { healthCheck.validate(); } if ((dockerFile != null || contextDir != null) && dockerArchive != null) { throw new IllegalArgumentException("Both <dockerFile> (<dockerFileDir>) and <dockerArchive> are set. " + "Only one of them can be specified."); } if (healthCheck != null) { return "1.24"; } else if (args != null) { return "1.21"; } else { return null; } } BuildConfiguration(); boolean isDockerFileMode(); String getDockerFile(); String getDockerArchive(); String getContextDir(); String getFilter(); String getFrom(); Map<String, String> getFromExt(); String getRegistry(); String getMaintainer(); String getWorkdir(); AssemblyConfiguration getAssemblyConfiguration(); List<String> getPorts(); String getImagePullPolicy(); List<String> getVolumes(); List<String> getTags(); Map<String, String> getEnv(); Map<String, String> getLabels(); Arguments getCmd(); String getCleanupMode(); Boolean getNoCache(); Boolean getOptimise(); Boolean getSkip(); ArchiveCompression getCompression(); Map<String, String> getBuildOptions(); Arguments getEntryPoint(); List<String> getRunCmds(); String getUser(); HealthCheckConfiguration getHealthCheck(); Map<String, String> getArgs(); String validate(); File calculateDockerFilePath(); } | @Test public void dockerFileAndArchive() { BuildConfiguration config = new BuildConfiguration.Builder(). dockerArchive("this"). dockerFile("that").build(); try { config.validate(); } catch (IllegalArgumentException expected) { return; } fail("Should have failed."); } |
BuildConfiguration implements Serializable { public ArchiveCompression getCompression() { return compression; } BuildConfiguration(); boolean isDockerFileMode(); String getDockerFile(); String getDockerArchive(); String getContextDir(); String getFilter(); String getFrom(); Map<String, String> getFromExt(); String getRegistry(); String getMaintainer(); String getWorkdir(); AssemblyConfiguration getAssemblyConfiguration(); List<String> getPorts(); String getImagePullPolicy(); List<String> getVolumes(); List<String> getTags(); Map<String, String> getEnv(); Map<String, String> getLabels(); Arguments getCmd(); String getCleanupMode(); Boolean getNoCache(); Boolean getOptimise(); Boolean getSkip(); ArchiveCompression getCompression(); Map<String, String> getBuildOptions(); Arguments getEntryPoint(); List<String> getRunCmds(); String getUser(); HealthCheckConfiguration getHealthCheck(); Map<String, String> getArgs(); String validate(); File calculateDockerFilePath(); } | @Test public void compression() { BuildConfiguration config = new BuildConfiguration.Builder(). compression("gzip").build(); assertEquals(gzip, config.getCompression()); config = new BuildConfiguration.Builder().build(); assertEquals(none, config.getCompression()); config = new BuildConfiguration.Builder(). compression("bzip2").build(); assertEquals(bzip2, config.getCompression()); try { new BuildConfiguration.Builder(). compression("bzip").build(); fail(); } catch (Exception exp) { assertTrue(exp.getMessage().contains("bzip")); } } |
BuildConfiguration implements Serializable { boolean isValidWindowsFileName(String filename) { Pattern pattern = Pattern.compile( "# Match a valid Windows filename (unspecified file system). \n" + "^ # Anchor to start of string. \n" + "(?! # Assert filename is not: CON, PRN, \n" + " (?: # AUX, NUL, COM1, COM2, COM3, COM4, \n" + " CON|PRN|AUX|NUL| # COM5, COM6, COM7, COM8, COM9, \n" + " COM[1-9]|LPT[1-9] # LPT1, LPT2, LPT3, LPT4, LPT5, \n" + " ) # LPT6, LPT7, LPT8, and LPT9... \n" + " (?:\\.[^.]*)? # followed by optional extension \n" + " $ # and end of string \n" + ") # End negative lookahead assertion. \n" + "[^<>:\"/\\\\|?*\\x00-\\x1F]* # Zero or more valid filename chars.\n" + "[^<>:\"/\\\\|?*\\x00-\\x1F .] # Last char is not a space or dot. \n" + "$ # Anchor to end of string. ", Pattern.CASE_INSENSITIVE | Pattern.UNICODE_CASE | Pattern.COMMENTS); Matcher matcher = pattern.matcher(filename); return matcher.matches(); } BuildConfiguration(); boolean isDockerFileMode(); String getDockerFile(); String getDockerArchive(); String getContextDir(); String getFilter(); String getFrom(); Map<String, String> getFromExt(); String getRegistry(); String getMaintainer(); String getWorkdir(); AssemblyConfiguration getAssemblyConfiguration(); List<String> getPorts(); String getImagePullPolicy(); List<String> getVolumes(); List<String> getTags(); Map<String, String> getEnv(); Map<String, String> getLabels(); Arguments getCmd(); String getCleanupMode(); Boolean getNoCache(); Boolean getOptimise(); Boolean getSkip(); ArchiveCompression getCompression(); Map<String, String> getBuildOptions(); Arguments getEntryPoint(); List<String> getRunCmds(); String getUser(); HealthCheckConfiguration getHealthCheck(); Map<String, String> getArgs(); String validate(); File calculateDockerFilePath(); } | @Test public void isValidWindowsFileName() { BuildConfiguration cfg = new BuildConfiguration(); assertFalse(cfg.isValidWindowsFileName("/Dockerfile")); assertTrue(cfg.isValidWindowsFileName("Dockerfile")); assertFalse(cfg.isValidWindowsFileName("Dockerfile/")); } |
ImageName { public String getFullName() { return getFullName(null); } ImageName(String fullName); ImageName(String fullName, String givenTag); String getRepository(); String getRegistry(); String getTag(); boolean hasRegistry(); String getNameWithoutTag(); String getNameWithoutTag(String optionalRegistry); String getFullName(); String getFullName(String optionalRegistry); String getUser(); String getSimpleName(); static void validate(String image); } | @Test public void testRegistryNaming() throws Exception { assertEquals("docker.jolokia.org/jolokia/jolokia_demo:0.18", new ImageName("jolokia/jolokia_demo:0.18").getFullName("docker.jolokia.org")); assertEquals("docker.jolokia.org/jolokia/jolokia_demo:latest", new ImageName("jolokia/jolokia_demo").getFullName("docker.jolokia.org")); assertEquals("jolokia/jolokia_demo:latest", new ImageName("jolokia/jolokia_demo").getFullName(null)); assertEquals("docker.jolokia.org/jolokia/jolokia_demo:latest", new ImageName("docker.jolokia.org/jolokia/jolokia_demo").getFullName("another.registry.org")); assertEquals("docker.jolokia.org/jolokia/jolokia_demo:latest", new ImageName("docker.jolokia.org/jolokia/jolokia_demo").getFullName(null)); }
@Test public void testRegistryNamingExtended() throws Exception { assertEquals("docker.jolokia.org/org/jolokia/jolokia_demo:0.18", new ImageName("org/jolokia/jolokia_demo:0.18").getFullName("docker.jolokia.org")); assertEquals("docker.jolokia.org/org/jolokia/jolokia_demo:latest", new ImageName("org/jolokia/jolokia_demo").getFullName("docker.jolokia.org")); assertEquals("org/jolokia/jolokia_demo:latest", new ImageName("org/jolokia/jolokia_demo").getFullName(null)); assertEquals("docker.jolokia.org/org/jolokia/jolokia_demo:latest", new ImageName("docker.jolokia.org/org/jolokia/jolokia_demo").getFullName("another.registry.org")); assertEquals("docker.jolokia.org/org/jolokia/jolokia_demo:latest", new ImageName("docker.jolokia.org/org/jolokia/jolokia_demo").getFullName(null)); } |
EnricherFactory { List<Enricher<P>> createEnrichers(String... descriptorPaths) { try { EnricherEntry.initDefaultOrder(); TreeMap<EnricherEntry,Enricher<P>> enricherMap = new TreeMap<>(); for (String descriptor : descriptorPaths) { readEnricherDefinitions(enricherMap, descriptor); } ArrayList<Enricher<P>> ret = new ArrayList<>(); ret.addAll(enricherMap.values()); return ret; } finally { EnricherEntry.removeDefaultOrder(); } } EnricherFactory(ClassLoader... additionalClassLoaders); } | @Test public void testOrder() { List<Enricher<ProjectContext>> enrichers = enricherFactory.createEnrichers("enricher/test-enrichers-default", "enricher/test-enrichers"); String[] orderExpected = new String[] { "three", "two", "five", "one"}; assertEquals(enrichers.size(), 4); Iterator<Enricher<ProjectContext>> it = enrichers.iterator(); for (String val : orderExpected) { assertEquals(it.next().getName(),val); } }
@Test public void errorHandling() { try { enricherFactory.createEnrichers("enricher/error-enrichers"); fail(); } catch (IllegalStateException exp) { assertTrue(exp.getMessage().matches(".*bla\\.blub\\.NotExist.*")); } } |
KeyStoreUtil { public static KeyStore createDockerKeyStore(String certPath) throws IOException, GeneralSecurityException { PrivateKey privKey = loadPrivateKey(certPath + "/key.pem"); Certificate[] certs = loadCertificates(certPath + "/cert.pem"); KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType()); keyStore.load(null); keyStore.setKeyEntry("docker", privKey, "docker".toCharArray(), certs); addCA(keyStore, certPath + "/ca.pem"); return keyStore; } static KeyStore createDockerKeyStore(String certPath); } | @Test public void createKeyStore() throws Exception { KeyStore keyStore = KeyStoreUtil.createDockerKeyStore(getFile("certpath")); KeyStore.PrivateKeyEntry pkEntry = (KeyStore.PrivateKeyEntry) keyStore.getEntry("docker", new KeyStore.PasswordProtection("docker".toCharArray())); assertNotNull(pkEntry); assertNotNull(pkEntry.getCertificate()); assertNotNull(keyStore.getCertificate("cn=ca-test,o=internet widgits pty ltd,st=some-state,c=cr")); assertNotNull(keyStore.getCertificate("cn=ca-test-2,o=internet widgits pty ltd,st=some-state,c=cr")); } |
KeyStoreUtil { static PrivateKey loadPrivateKey(String keyPath) throws IOException, GeneralSecurityException { try (Reader reader = new FileReader(keyPath); PEMParser parser = new PEMParser(reader)) { Object readObject; while ((readObject = parser.readObject()) != null) { if (readObject instanceof PEMKeyPair) { PEMKeyPair keyPair = (PEMKeyPair) readObject; return generatePrivateKey(keyPair.getPrivateKeyInfo()); } else if (readObject instanceof PrivateKeyInfo) { return generatePrivateKey((PrivateKeyInfo) readObject); } } } throw new GeneralSecurityException("Cannot generate private key from file: " + keyPath); } static KeyStore createDockerKeyStore(String certPath); } | @Test public void loadPrivateKeyDefault() throws Exception { PrivateKey privateKey = KeyStoreUtil.loadPrivateKey(getFile("keys/pkcs1.pem")); assertNotNull(privateKey); }
@Test public void loadPrivateKeyPKCS8() throws Exception { PrivateKey privateKey = KeyStoreUtil.loadPrivateKey(getFile("keys/pkcs8.pem")); assertNotNull(privateKey); }
@Test public void loadPrivateKeyECDSA() throws Exception { PrivateKey privateKey = KeyStoreUtil.loadPrivateKey(getFile("keys/ecdsa.pem")); assertNotNull(privateKey); }
@Test public void loadInvalidPrivateKey() throws Exception { exception.expect(GeneralSecurityException.class); exception.expectMessage("Cannot generate private key"); KeyStoreUtil.loadPrivateKey(getFile("keys/invalid.pem")); } |
EcrExtendedAuth { public boolean isAwsRegistry() { return isAwsRegistry; } EcrExtendedAuth(KitLogger logger, String registry); boolean isAwsRegistry(); RegistryAuth extendedAuth(RegistryAuth localCredentials); } | @Test public void testIsNotAws() { assertFalse(new EcrExtendedAuth(logger, "jolokia").isAwsRegistry()); }
@Test public void testIsAws() { assertTrue(new EcrExtendedAuth(logger, "123456789012.dkr.ecr.eu-west-1.amazonaws.com").isAwsRegistry()); } |
ObjModel extends IndexedModel { protected static void parseInts(String str, int[] ints) { int len = str.length(); int intIndex = 0; int currentInt = -1; ints[0] = -1; ints[1] = -1; ints[2] = -1; for (int i = 0; i < len; i++) { char c = str.charAt(i); if (c >= '0' && c <= '9') { if (currentInt == -1) { currentInt = (c - '0'); } else { currentInt *= 10; currentInt += (c - '0'); } } else { if (currentInt >= 0) { ints[intIndex++] = currentInt; currentInt = -1; } else { ints[intIndex++] = -1; } } } if (currentInt >= 0) { ints[intIndex] = currentInt; } } ObjModel(@NonNull InputStream inputStream); @Override void initModelMatrix(float boundSize); } | @Test public void testParseInts() throws Exception { int[] ints = new int[4]; ObjModel.parseInts("1/2/3", ints); assertEquals(ints[0], 1); assertEquals(ints[1], 2); assertEquals(ints[2], 3); ObjModel.parseInts("111/222/333/444", ints); assertEquals(ints[0], 111); assertEquals(ints[1], 222); assertEquals(ints[2], 333); assertEquals(ints[3], 444); ObjModel.parseInts("12 assertEquals(ints[0], 12); assertEquals(ints[1], -1); assertEquals(ints[2], 34); ObjModel.parseInts("42", ints); assertEquals(ints[0], 42); assertEquals(ints[1], -1); assertEquals(ints[2], -1); } |
SignatureConfig { public void write(Writer out) throws IOException { Ini configIni = new Ini(); Section section = configIni.add(SECTION_NAME); section.put("algorithm", algorithm.toString()); section.put("provider", provider); section.put("destination", destination.toString()); if (destinationTable != null) { section.put("table", destinationTable); } if (defaultVisibility != null) { section.put("defaultVisibility", new String(defaultVisibility, VISIBILITY_CHARSET)); } configIni.store(out); } SignatureConfig(ValueSigner signer, String provider, Destination destination, String destinationTable, byte[] defaultVisibility); void write(Writer out); boolean isSignatureInSeparateTable(); ValueSigner getAlgorithm(); } | @Test public void writeTest() throws Exception { File file = writeConfigToFile(config1); Ini expectedIni = getIni("config1.ini"); Ini actualIni = new Ini(file); assertThat("writing the ini file produces the correct configuration", expectedIni, equalTo(actualIni)); file = writeConfigToFile(config2); expectedIni = getIni("config2.ini"); actualIni = new Ini(file); assertThat("writing the ini file produces the correct configuration", expectedIni, equalTo(actualIni)); file = writeConfigToFile(config3); expectedIni = getIni("config3.ini"); actualIni = new Ini(file); assertThat("writing the ini file produces the correct configuration", expectedIni, equalTo(actualIni)); } |
SignedBatchWriter implements BatchWriter { @Override public void addMutation(Mutation mutation) throws MutationsRejectedException { Mutation signedMutation = new Mutation(mutation.getRow()); for (ColumnUpdate update : mutation.getUpdates()) { if (update.isDeleted()) { if (signatureConfig.destination == Destination.COLUMN_VISIBILITY) { throw new IllegalArgumentException("cannot delete entries when the signature is stored in the column visibility"); } if (update.hasTimestamp()) { signedMutation.putDelete(update.getColumnFamily(), update.getColumnQualifier(), new ColumnVisibility(update.getColumnVisibility()), update.getTimestamp()); } else { signedMutation.putDelete(update.getColumnFamily(), update.getColumnQualifier(), new ColumnVisibility(update.getColumnVisibility())); } } else { Entry<Key,Value> signedEntry = signer.sign(new MutableEntry(mutation.getRow(), update).toEntry(), update.hasTimestamp()); Key signedKey = signedEntry.getKey(); if (update.hasTimestamp()) { signedMutation.put(signedKey.getColumnFamily(), signedKey.getColumnQualifier(), signedKey.getColumnVisibilityParsed(), signedKey.getTimestamp(), signedEntry.getValue()); } else { signedMutation.put(signedKey.getColumnFamily(), signedKey.getColumnQualifier(), signedKey.getColumnVisibilityParsed(), signedEntry.getValue()); } } } if (signatureTableWriter != null) { tableWriter.addMutation(mutation); signatureTableWriter.addMutation(signedMutation); } else { tableWriter.addMutation(signedMutation); } } SignedBatchWriter(Connector connector, String tableName, BatchWriterConfig batchConfig, SignatureConfig signatureConfig, SignatureKeyContainer keys); @Override void addMutation(Mutation mutation); @Override void addMutations(Iterable<Mutation> iterable); @Override void flush(); @Override void close(); } | @Test public void deleteExternalTest() throws Exception { when(mockConnector.createBatchWriter(TEST_TABLE, null)).thenReturn(mockWriter); when(mockConnector.createBatchWriter(SIG_TABLE, null)).thenReturn(mockSignatureWriter); BatchWriter writer = new SignedBatchWriter(mockConnector, TEST_TABLE, null, getConfig("config3.ini"), aliceKeyContainers.get(ValueSigner.ECDSA)); Mutation mutation = new Mutation("row".getBytes()); mutation.putDelete("colF".getBytes(), "colQ".getBytes()); mutation.putDelete("colF".getBytes(), "colQ".getBytes(), 0); writer.addMutation(mutation); verify(mockWriter).addMutation(captor.capture()); verify(mockSignatureWriter).addMutation(signatureCaptor.capture()); List<Mutation> mutations = captor.getAllValues(); assertThat("only a single mutation", mutations, hasSize(1)); Mutation signed = mutations.get(0); assertThat("row is unchanged", signed.getRow(), equalTo("row".getBytes())); List<ColumnUpdate> updates = signed.getUpdates(); assertThat("has 2 updates", updates, hasSize(2)); ColumnUpdate update = updates.get(0); assertThat("is delete operation", update.isDeleted(), is(true)); assertThat("column family is unchanged", update.getColumnFamily(), equalTo("colF".getBytes())); assertThat("column qualifier is unchanged", update.getColumnFamily(), equalTo("colF".getBytes())); assertThat("timestamp not set", update.hasTimestamp(), is(false)); update = updates.get(1); assertThat("is delete operation", update.isDeleted(), is(true)); assertThat("column family is unchanged", update.getColumnFamily(), equalTo("colF".getBytes())); assertThat("column qualifier is unchanged", update.getColumnFamily(), equalTo("colF".getBytes())); assertThat("timestamp is set", update.hasTimestamp(), is(true)); assertThat("timestamp is correct", update.getTimestamp(), is(0L)); mutations = signatureCaptor.getAllValues(); assertThat("only a single mutation", mutations, hasSize(1)); signed = mutations.get(0); assertThat("row is unchanged", signed.getRow(), equalTo("row".getBytes())); updates = signed.getUpdates(); assertThat("has 2 updates", updates, hasSize(2)); update = updates.get(0); assertThat("is delete operation", update.isDeleted(), is(true)); assertThat("column family is unchanged", update.getColumnFamily(), equalTo("colF".getBytes())); assertThat("column qualifier is unchanged", update.getColumnFamily(), equalTo("colF".getBytes())); assertThat("timestamp not set", update.hasTimestamp(), is(false)); update = updates.get(1); assertThat("is delete operation", update.isDeleted(), is(true)); assertThat("column family is unchanged", update.getColumnFamily(), equalTo("colF".getBytes())); assertThat("column qualifier is unchanged", update.getColumnFamily(), equalTo("colF".getBytes())); assertThat("timestamp is set", update.hasTimestamp(), is(true)); assertThat("timestamp is correct", update.getTimestamp(), is(0L)); }
@Test public void addMutationValueTest() throws Exception { when(mockConnector.createBatchWriter(TEST_TABLE, null)).thenReturn(mockWriter); BatchWriter writer = new SignedBatchWriter(mockConnector, TEST_TABLE, null, getConfig("config1.ini"), aliceKeyContainers.get(ValueSigner.RSA_PSS)); EntrySigner signer = new EntrySigner(getConfig("config1.ini"), aliceKeyContainers.get(ValueSigner.RSA_PSS)); Mutation mutation = new Mutation("row".getBytes()); mutation.put("colF".getBytes(), "colQ".getBytes(), "val1".getBytes()); mutation.put("colF".getBytes(), "colQ".getBytes(), 0, "val2".getBytes()); writer.addMutation(mutation); verify(mockWriter).addMutation(captor.capture()); verify(mockSignatureWriter, never()).addMutation(any()); List<Mutation> mutations = captor.getAllValues(); assertThat("only a single mutation", mutations, hasSize(1)); Mutation signed = mutations.get(0); assertThat("row is unchanged", signed.getRow(), equalTo("row".getBytes())); List<ColumnUpdate> updates = signed.getUpdates(); assertThat("has 2 updates", updates, hasSize(2)); ColumnUpdate update = updates.get(0); assertThat("column family is unchanged", update.getColumnFamily(), equalTo("colF".getBytes())); assertThat("column qualifier is unchanged", update.getColumnFamily(), equalTo("colF".getBytes())); assertThat("timestamp not set", update.hasTimestamp(), is(false)); assertThat("signature in value", update.getColumnFamily(), not(equalTo("val1".getBytes()))); MutableEntry verified = new MutableEntry(signer.verify(new MutableEntry("row".getBytes(), update).toEntry())); assertThat("value was correctly unwrapped", verified.value, equalTo("val1".getBytes())); update = updates.get(1); assertThat("column family is unchanged", update.getColumnFamily(), equalTo("colF".getBytes())); assertThat("column qualifier is unchanged", update.getColumnFamily(), equalTo("colF".getBytes())); assertThat("timestamp is set", update.hasTimestamp(), is(true)); assertThat("timestamp is correct", update.getTimestamp(), is(0L)); assertThat("signature in value", update.getColumnFamily(), not(equalTo("val2".getBytes()))); verified = new MutableEntry(signer.verify(new MutableEntry("row".getBytes(), update).toEntry())); assertThat("value was correctly unwrapped", verified.value, equalTo("val2".getBytes())); }
@Test public void addMutationColVisTest() throws Exception { when(mockConnector.createBatchWriter(TEST_TABLE, null)).thenReturn(mockWriter); BatchWriter writer = new SignedBatchWriter(mockConnector, TEST_TABLE, null, getConfig("config2.ini"), aliceKeyContainers.get(ValueSigner.RSA_PSS)); EntrySigner signer = new EntrySigner(getConfig("config2.ini"), aliceKeyContainers.get(ValueSigner.RSA_PSS)); Mutation mutation = new Mutation("row".getBytes()); mutation.put("colF".getBytes(), "colQ".getBytes(), "val1".getBytes()); mutation.put("colF".getBytes(), "colQ".getBytes(), 0, "val2".getBytes()); writer.addMutation(mutation); verify(mockWriter).addMutation(captor.capture()); verify(mockSignatureWriter, never()).addMutation(any()); List<Mutation> mutations = captor.getAllValues(); assertThat("only a single mutation", mutations, iterableWithSize(1)); Mutation signed = mutations.get(0); assertThat("row is unchanged", signed.getRow(), equalTo("row".getBytes())); List<ColumnUpdate> updates = signed.getUpdates(); assertThat("has 2 updates", updates, hasSize(2)); ColumnUpdate update = updates.get(0); assertThat("column family is unchanged", update.getColumnFamily(), equalTo("colF".getBytes())); assertThat("column qualifier is unchanged", update.getColumnQualifier(), equalTo("colQ".getBytes())); assertThat("colQualifier has the default visibility", new String(update.getColumnVisibility(), Utils.VISIBILITY_CHARSET), startsWith("(default)")); assertThat("timestamp not set", update.hasTimestamp(), is(false)); assertThat("value is unchanged", update.getValue(), equalTo("val1".getBytes())); MutableEntry verified = new MutableEntry(signer.verify(new MutableEntry("row".getBytes(), update).toEntry())); assertThat("value was correctly unwrapped", verified.value, equalTo("val1".getBytes())); update = updates.get(1); assertThat("column family is unchanged", update.getColumnFamily(), equalTo("colF".getBytes())); assertThat("column qualifier is unchanged", update.getColumnQualifier(), equalTo("colQ".getBytes())); assertThat("colQualifier has the default visibility", new String(update.getColumnVisibility(), Utils.VISIBILITY_CHARSET), startsWith("(default)")); assertThat("timestamp is set", update.hasTimestamp(), is(true)); assertThat("timestamp is correct", update.getTimestamp(), is(0L)); assertThat("value is unchanged", update.getValue(), equalTo("val2".getBytes())); verified = new MutableEntry(signer.verify(new MutableEntry("row".getBytes(), update).toEntry())); assertThat("value was correctly unwrapped", verified.value, equalTo("val2".getBytes())); }
@Test public void addMutationSeparateTableTest() throws Exception { when(mockConnector.createBatchWriter(TEST_TABLE, null)).thenReturn(mockWriter); when(mockConnector.createBatchWriter(SIG_TABLE, null)).thenReturn(mockSignatureWriter); BatchWriter writer = new SignedBatchWriter(mockConnector, TEST_TABLE, null, getConfig("config3.ini"), aliceKeyContainers.get(ValueSigner.ECDSA)); EntrySigner signer = new EntrySigner(getConfig("config3.ini"), aliceKeyContainers.get(ValueSigner.ECDSA)); Mutation mutation = new Mutation("row".getBytes()); mutation.put("colF".getBytes(), "colQ".getBytes(), "val1".getBytes()); mutation.put("colF".getBytes(), "colQ".getBytes(), 0, "val2".getBytes()); writer.addMutation(mutation); verify(mockWriter).addMutation(captor.capture()); verify(mockSignatureWriter).addMutation(signatureCaptor.capture()); List<Mutation> mutations = captor.getAllValues(); assertThat("only a single mutation", mutations, hasSize(1)); Mutation signed = mutations.get(0); assertThat("row is unchanged", signed.getRow(), equalTo("row".getBytes())); List<ColumnUpdate> updates = signed.getUpdates(); assertThat("has 2 updates", updates, hasSize(2)); ColumnUpdate update = updates.get(0); assertThat("column family is unchanged", update.getColumnFamily(), equalTo("colF".getBytes())); assertThat("column qualifier is unchanged", update.getColumnFamily(), equalTo("colF".getBytes())); assertThat("timestamp not set", update.hasTimestamp(), is(false)); assertThat("value is unchanged", update.getValue(), equalTo("val1".getBytes())); update = updates.get(1); assertThat("column family is unchanged", update.getColumnFamily(), equalTo("colF".getBytes())); assertThat("column qualifier is unchanged", update.getColumnFamily(), equalTo("colF".getBytes())); assertThat("timestamp is set", update.hasTimestamp(), is(true)); assertThat("timestamp is correct", update.getTimestamp(), is(0L)); assertThat("value is unchanged", update.getValue(), equalTo("val2".getBytes())); mutations = signatureCaptor.getAllValues(); assertThat("only a single mutation", mutations, hasSize(1)); signed = mutations.get(0); assertThat("row is unchanged", signed.getRow(), equalTo("row".getBytes())); updates = signed.getUpdates(); assertThat("has 2 updates", updates, hasSize(2)); update = updates.get(0); assertThat("column family is unchanged", update.getColumnFamily(), equalTo("colF".getBytes())); assertThat("column qualifier is unchanged", update.getColumnFamily(), equalTo("colF".getBytes())); assertThat("timestamp not set", update.hasTimestamp(), is(false)); assertThat("signature in value", update.getColumnFamily(), not(equalTo("val1".getBytes()))); update = updates.get(1); assertThat("column family is unchanged", update.getColumnFamily(), equalTo("colF".getBytes())); assertThat("column qualifier is unchanged", update.getColumnFamily(), equalTo("colF".getBytes())); assertThat("timestamp is set", update.hasTimestamp(), is(true)); assertThat("timestamp is correct", update.getTimestamp(), is(0L)); assertThat("signature in value", update.getColumnFamily(), not(equalTo("val2".getBytes()))); MutableEntry verified = new MutableEntry(signer.verify(new MutableEntry("row".getBytes(), captor.getAllValues().get(0).getUpdates().get(0)).toEntry(), new MutableEntry("row".getBytes(), signatureCaptor.getAllValues().get(0).getUpdates().get(0)).toEntry())); assertThat("value was correctly unwrapped", verified.value, equalTo("val1".getBytes())); }
@Test public void deleteTest() throws Exception { when(mockConnector.createBatchWriter(TEST_TABLE, null)).thenReturn(mockWriter); BatchWriter writer = new SignedBatchWriter(mockConnector, TEST_TABLE, null, getConfig("config1.ini"), aliceKeyContainers.get(ValueSigner.RSA_PSS)); Mutation mutation = new Mutation("row".getBytes()); mutation.putDelete("colF".getBytes(), "colQ".getBytes()); mutation.putDelete("colF".getBytes(), "colQ".getBytes(), 0L); writer.addMutation(mutation); verify(mockWriter).addMutation(captor.capture()); verify(mockSignatureWriter, never()).addMutation(any()); List<Mutation> mutations = captor.getAllValues(); assertThat("only a single mutation", mutations, iterableWithSize(1)); Mutation signed = mutations.get(0); assertThat("row is unchanged", signed.getRow(), equalTo("row".getBytes())); List<ColumnUpdate> updates = signed.getUpdates(); assertThat("has 2 updates", updates, hasSize(2)); ColumnUpdate update = updates.get(0); assertThat("is delete operation", update.isDeleted(), is(true)); assertThat("column family is unchanged", update.getColumnFamily(), equalTo("colF".getBytes())); assertThat("column qualifier is unchanged", update.getColumnQualifier(), equalTo("colQ".getBytes())); assertThat("timestamp is not set", update.hasTimestamp(), is(false)); update = updates.get(1); assertThat("is delete operation", update.isDeleted(), is(true)); assertThat("column family is unchanged", update.getColumnFamily(), equalTo("colF".getBytes())); assertThat("column qualifier is unchanged", update.getColumnQualifier(), equalTo("colQ".getBytes())); assertThat("timestamp is set", update.hasTimestamp(), is(true)); assertThat("timestamp is correct", update.getTimestamp(), is(0L)); }
@Test public void deleteColVisTest() throws Exception { when(mockConnector.createBatchWriter(TEST_TABLE, null)).thenReturn(mockWriter); BatchWriter writer = new SignedBatchWriter(mockConnector, TEST_TABLE, null, getConfig("config2.ini"), aliceKeyContainers.get(ValueSigner.RSA_PSS)); Mutation mutation = new Mutation("row".getBytes()); mutation.putDelete("colF1".getBytes(), "colQ".getBytes()); mutation.putDelete("colF1".getBytes(), "colQ".getBytes(), 0L); try { writer.addMutation(mutation); fail("signed deletes are not allowed"); } catch (IllegalArgumentException e) { } } |
SignedBatchWriter implements BatchWriter { @Override public void addMutations(Iterable<Mutation> iterable) throws MutationsRejectedException { for (Mutation mutation : iterable) { addMutation(mutation); } } SignedBatchWriter(Connector connector, String tableName, BatchWriterConfig batchConfig, SignatureConfig signatureConfig, SignatureKeyContainer keys); @Override void addMutation(Mutation mutation); @Override void addMutations(Iterable<Mutation> iterable); @Override void flush(); @Override void close(); } | @Test public void addMutationsTest() throws Exception { when(mockConnector.createBatchWriter(TEST_TABLE, null)).thenReturn(mockWriter); BatchWriter writer = new SignedBatchWriter(mockConnector, TEST_TABLE, null, getConfig("config1.ini"), aliceKeyContainers.get(ValueSigner.RSA_PSS)); List<Mutation> mutations = new ArrayList<>(); Mutation mutation = new Mutation("row"); mutation.put("colF", "colQ", "val"); mutations.add(mutation); writer.addMutations(mutations); verify(mockWriter, times(1)).addMutation(any()); verify(mockSignatureWriter, never()).addMutation(any()); mutations.add(mutation); writer.addMutations(mutations); verify(mockWriter, times(3)).addMutation(any()); verify(mockSignatureWriter, never()).addMutation(any()); mutations.add(mutation); writer.addMutations(mutations); verify(mockWriter, times(6)).addMutation(any()); verify(mockSignatureWriter, never()).addMutation(any()); } |
SignedBatchWriter implements BatchWriter { @Override public void flush() throws MutationsRejectedException { tableWriter.flush(); if (signatureTableWriter != null) { signatureTableWriter.flush(); } } SignedBatchWriter(Connector connector, String tableName, BatchWriterConfig batchConfig, SignatureConfig signatureConfig, SignatureKeyContainer keys); @Override void addMutation(Mutation mutation); @Override void addMutations(Iterable<Mutation> iterable); @Override void flush(); @Override void close(); } | @Test public void flushTest() throws Exception { when(mockConnector.createBatchWriter(TEST_TABLE, null)).thenReturn(mockWriter); new SignedBatchWriter(mockConnector, TEST_TABLE, null, getConfig("config1.ini"), aliceKeyContainers.get(ValueSigner.RSA_PSS)).flush(); verify(mockWriter).flush(); }
@Test public void flushExternalTest() throws Exception { when(mockConnector.createBatchWriter(TEST_TABLE, null)).thenReturn(mockWriter); when(mockConnector.createBatchWriter(SIG_TABLE, null)).thenReturn(mockSignatureWriter); new SignedBatchWriter(mockConnector, TEST_TABLE, null, getConfig("config3.ini"), aliceKeyContainers.get(ValueSigner.ECDSA)).flush(); verify(mockWriter).flush(); verify(mockSignatureWriter).flush(); } |
SignedBatchWriter implements BatchWriter { @Override public void close() throws MutationsRejectedException { tableWriter.close(); if (signatureTableWriter != null) { signatureTableWriter.close(); } } SignedBatchWriter(Connector connector, String tableName, BatchWriterConfig batchConfig, SignatureConfig signatureConfig, SignatureKeyContainer keys); @Override void addMutation(Mutation mutation); @Override void addMutations(Iterable<Mutation> iterable); @Override void flush(); @Override void close(); } | @Test public void closeTest() throws Exception { when(mockConnector.createBatchWriter(TEST_TABLE, null)).thenReturn(mockWriter); new SignedBatchWriter(mockConnector, TEST_TABLE, null, getConfig("config1.ini"), aliceKeyContainers.get(ValueSigner.RSA_PSS)).close(); verify(mockWriter).close(); }
@Test public void closeExternalTest() throws Exception { when(mockConnector.createBatchWriter(TEST_TABLE, null)).thenReturn(mockWriter); when(mockConnector.createBatchWriter(SIG_TABLE, null)).thenReturn(mockSignatureWriter); new SignedBatchWriter(mockConnector, TEST_TABLE, null, getConfig("config3.ini"), aliceKeyContainers.get(ValueSigner.ECDSA)).close(); verify(mockWriter).close(); verify(mockSignatureWriter).close(); } |
EncryptedBatchScanner implements BatchScanner { @Override public void setRanges(Collection<Range> collection) { checkArgument(collection != null && collection.size() > 0, "ranges must be non null and contain at least 1 range"); List<Range> serverSideRanges = new ArrayList<>(); clientSideRanges = new ArrayList<>(); for (Range range : collection) { if (encryptor.transformRange(range, serverSideRanges)) { clientSideRanges.add(range); } } scanner.setRanges(serverSideRanges); } EncryptedBatchScanner(Connector connector, String tableName, Authorizations authorizations, int numQueryThreads, EncryptionConfig cryptoConfig,
EncryptionKeyContainer keys); @Override void setRanges(Collection<Range> collection); @Override void fetchColumnFamily(Text col); @Override void fetchColumn(Text colFam, Text colQual); @Override void fetchColumn(IteratorSetting.Column column); @Override void clearColumns(); @Override ItemProcessingIterator<Entry<Key,Value>> iterator(); @Override void clearScanIterators(); @Override void close(); @Override Authorizations getAuthorizations(); @Override void setSamplerConfiguration(SamplerConfiguration samplerConfiguration); @Override SamplerConfiguration getSamplerConfiguration(); @Override void clearSamplerConfiguration(); @Override void setBatchTimeout(long l, TimeUnit timeUnit); @Override long getBatchTimeout(TimeUnit timeUnit); @Override void setClassLoaderContext(String s); @Override void clearClassLoaderContext(); @Override String getClassLoaderContext(); @Override void addScanIterator(IteratorSetting iteratorSetting); @Override void removeScanIterator(String s); @Override void updateScanIteratorOption(String s, String s1, String s2); @Override void setTimeout(long l, TimeUnit timeUnit); @Override long getTimeout(TimeUnit timeUnit); } | @Test public void setRangesException() throws Exception { BatchScanner scanner = new EncryptedBatchScanner(mockConnector, TEST_TABLE, authorizations, 1, getConfig("encrypt-key.ini"), KEYS); try { scanner.setRanges(null); fail("null ranges not allowed"); } catch (IllegalArgumentException e) { } try { scanner.setRanges(new ArrayList<>()); fail("empty ranges not allowed"); } catch (IllegalArgumentException e) { } } |
EncryptedBatchScanner implements BatchScanner { @Override public void fetchColumnFamily(Text col) { checkArgument(col != null, "col is null"); ColumnFilterResult search = encryptor.getColumnFamilyFilter(col); for (Column filter : search.serverSideFilters) { scanner.fetchColumnFamily(new Text(filter.getColumnFamily())); } if (search.needsClientSideFiltering) { clientSideColumnFilters.add(new Column(TextUtil.getBytes(col), null, null)); } } EncryptedBatchScanner(Connector connector, String tableName, Authorizations authorizations, int numQueryThreads, EncryptionConfig cryptoConfig,
EncryptionKeyContainer keys); @Override void setRanges(Collection<Range> collection); @Override void fetchColumnFamily(Text col); @Override void fetchColumn(Text colFam, Text colQual); @Override void fetchColumn(IteratorSetting.Column column); @Override void clearColumns(); @Override ItemProcessingIterator<Entry<Key,Value>> iterator(); @Override void clearScanIterators(); @Override void close(); @Override Authorizations getAuthorizations(); @Override void setSamplerConfiguration(SamplerConfiguration samplerConfiguration); @Override SamplerConfiguration getSamplerConfiguration(); @Override void clearSamplerConfiguration(); @Override void setBatchTimeout(long l, TimeUnit timeUnit); @Override long getBatchTimeout(TimeUnit timeUnit); @Override void setClassLoaderContext(String s); @Override void clearClassLoaderContext(); @Override String getClassLoaderContext(); @Override void addScanIterator(IteratorSetting iteratorSetting); @Override void removeScanIterator(String s); @Override void updateScanIteratorOption(String s, String s1, String s2); @Override void setTimeout(long l, TimeUnit timeUnit); @Override long getTimeout(TimeUnit timeUnit); } | @Test public void fetchColumnFamilyException() throws Exception { BatchScanner scanner = new EncryptedBatchScanner(mockConnector, TEST_TABLE, authorizations, 1, getConfig("encrypt-key.ini"), KEYS); try { scanner.fetchColumnFamily(null); fail("null column family not allowed"); } catch (IllegalArgumentException e) { } } |
EncryptedBatchScanner implements BatchScanner { @Override public void fetchColumn(Text colFam, Text colQual) { checkArgument(colFam != null, "colFam is null"); checkArgument(colQual != null, "colQual is null"); ColumnFilterResult search = encryptor.getColumnFilter(colFam, colQual); for (Column column : search.serverSideFilters) { if (column.getColumnQualifier() == null) { scanner.fetchColumnFamily(new Text(column.getColumnFamily())); } else { scanner.fetchColumn(new Text(column.getColumnFamily()), new Text(column.getColumnQualifier())); } } if (search.needsClientSideFiltering) { clientSideColumnFilters.add(new Column(TextUtil.getBytes(colFam), TextUtil.getBytes(colQual), null)); } } EncryptedBatchScanner(Connector connector, String tableName, Authorizations authorizations, int numQueryThreads, EncryptionConfig cryptoConfig,
EncryptionKeyContainer keys); @Override void setRanges(Collection<Range> collection); @Override void fetchColumnFamily(Text col); @Override void fetchColumn(Text colFam, Text colQual); @Override void fetchColumn(IteratorSetting.Column column); @Override void clearColumns(); @Override ItemProcessingIterator<Entry<Key,Value>> iterator(); @Override void clearScanIterators(); @Override void close(); @Override Authorizations getAuthorizations(); @Override void setSamplerConfiguration(SamplerConfiguration samplerConfiguration); @Override SamplerConfiguration getSamplerConfiguration(); @Override void clearSamplerConfiguration(); @Override void setBatchTimeout(long l, TimeUnit timeUnit); @Override long getBatchTimeout(TimeUnit timeUnit); @Override void setClassLoaderContext(String s); @Override void clearClassLoaderContext(); @Override String getClassLoaderContext(); @Override void addScanIterator(IteratorSetting iteratorSetting); @Override void removeScanIterator(String s); @Override void updateScanIteratorOption(String s, String s1, String s2); @Override void setTimeout(long l, TimeUnit timeUnit); @Override long getTimeout(TimeUnit timeUnit); } | @Test public void fetchColumnException() throws Exception { BatchScanner scanner = new EncryptedBatchScanner(mockConnector, TEST_TABLE, authorizations, 1, getConfig("encrypt-key.ini"), KEYS); try { scanner.fetchColumn(null); fail("null column not allowed"); } catch (IllegalArgumentException e) { } try { scanner.fetchColumn(null, new Text(Utils.EMPTY)); fail("null column family not allowed"); } catch (IllegalArgumentException e) { } try { scanner.fetchColumn(new Text(Utils.EMPTY), null); fail("null column qualifier not allowed"); } catch (IllegalArgumentException e) { } } |
EncryptedBatchScanner implements BatchScanner { @Override public void clearColumns() { scanner.clearColumns(); clientSideColumnFilters.clear(); } EncryptedBatchScanner(Connector connector, String tableName, Authorizations authorizations, int numQueryThreads, EncryptionConfig cryptoConfig,
EncryptionKeyContainer keys); @Override void setRanges(Collection<Range> collection); @Override void fetchColumnFamily(Text col); @Override void fetchColumn(Text colFam, Text colQual); @Override void fetchColumn(IteratorSetting.Column column); @Override void clearColumns(); @Override ItemProcessingIterator<Entry<Key,Value>> iterator(); @Override void clearScanIterators(); @Override void close(); @Override Authorizations getAuthorizations(); @Override void setSamplerConfiguration(SamplerConfiguration samplerConfiguration); @Override SamplerConfiguration getSamplerConfiguration(); @Override void clearSamplerConfiguration(); @Override void setBatchTimeout(long l, TimeUnit timeUnit); @Override long getBatchTimeout(TimeUnit timeUnit); @Override void setClassLoaderContext(String s); @Override void clearClassLoaderContext(); @Override String getClassLoaderContext(); @Override void addScanIterator(IteratorSetting iteratorSetting); @Override void removeScanIterator(String s); @Override void updateScanIteratorOption(String s, String s1, String s2); @Override void setTimeout(long l, TimeUnit timeUnit); @Override long getTimeout(TimeUnit timeUnit); } | @Test public void clearColumnsTest() throws Exception { when(mockConnector.createBatchScanner(TEST_TABLE, authorizations, 1)).thenReturn(mockScanner); EntryEncryptor encryptor = new EntryEncryptor(getConfig("encrypt-key.ini"), KEYS); List<Map.Entry<Key,Value>> entries = new ArrayList<>(); Map.Entry<Key,Value> entry = new SimpleImmutableEntry<>(new Key(new byte[] {1}, new byte[] {2}, new byte[] {3}, "secret".getBytes(Utils.VISIBILITY_CHARSET), 0, false, false), new Value(new byte[] {4})); Map.Entry<Key,Value> entry2 = new SimpleImmutableEntry<>(new Key(new byte[] {5}, new byte[] {6}, new byte[] {7}, "secret".getBytes(Utils.VISIBILITY_CHARSET), 0, false, false), new Value(new byte[] {8})); entries.add(encryptor.encrypt(entry)); entries.add(encryptor.encrypt(entry2)); when(mockScanner.iterator()).thenReturn(entries.iterator()).thenReturn(entries.iterator()); BatchScanner scanner = new EncryptedBatchScanner(mockConnector, TEST_TABLE, authorizations, 1, getConfig("encrypt-key.ini"), KEYS); scanner.fetchColumn(new Text(new byte[] {2}), new Text(new byte[] {2})); assertThat("has correct number of elements", scanner, iterableWithSize(0)); scanner.clearColumns(); assertThat("has correct number of elements", scanner, iterableWithSize(2)); } |
SignedScanner implements Scanner { @Override public void clearScanIterators() { valueScanner.clearScanIterators(); if (signatureScanner != null) { signatureScanner.clearScanIterators(); } } SignedScanner(Connector connector, String tableName, Authorizations authorizations, SignatureConfig signatureConfig, SignatureKeyContainer keys); @Override ItemProcessingIterator<Entry<Key,Value>> iterator(); @Override void addScanIterator(IteratorSetting cfg); @Override void clearColumns(); @Override void clearScanIterators(); @Override void close(); @Override void fetchColumn(Column column); @Override void fetchColumn(Text colFam, Text colQual); @Override void fetchColumnFamily(Text col); @Override Authorizations getAuthorizations(); @Override void setSamplerConfiguration(SamplerConfiguration samplerConfiguration); @Override SamplerConfiguration getSamplerConfiguration(); @Override void clearSamplerConfiguration(); @Override void setBatchTimeout(long l, TimeUnit timeUnit); @Override long getBatchTimeout(TimeUnit timeUnit); @Override void setClassLoaderContext(String s); @Override void clearClassLoaderContext(); @Override String getClassLoaderContext(); @Override long getTimeout(TimeUnit timeUnit); @Override void removeScanIterator(String iteratorName); @Override void updateScanIteratorOption(String iteratorName, String key, String value); @Override void setTimeout(long timeout, TimeUnit timeUnit); @Override void disableIsolation(); @Override void enableIsolation(); @Override int getBatchSize(); @Override Range getRange(); @Override long getReadaheadThreshold(); @Override @SuppressWarnings("deprecation") int getTimeOut(); @Override void setBatchSize(int size); @Override void setRange(Range range); @Override void setReadaheadThreshold(long batches); @Override @SuppressWarnings("deprecation") void setTimeOut(int timeOut); } | @Test public void clearScanIteratorsExternalTest() throws Exception { when(mockConnector.createScanner(TEST_TABLE, authorizations)).thenReturn(mockScanner); when(mockConnector.createScanner(SIG_TABLE, authorizations)).thenReturn(mockSignatureScanner); new SignedScanner(mockConnector, TEST_TABLE, authorizations, getConfig("config3.ini"), aliceKeyContainers.get(ValueSigner.RSA_PSS)).clearScanIterators(); verify(mockScanner).clearScanIterators(); verify(mockSignatureScanner).clearScanIterators(); }
@Test public void clearScanIteratorsTest() throws Exception { when(mockConnector.createScanner(TEST_TABLE, authorizations)).thenReturn(mockScanner); new SignedScanner(mockConnector, TEST_TABLE, authorizations, getConfig("config1.ini"), aliceKeyContainers.get(ValueSigner.RSA_PSS)).clearScanIterators(); verify(mockScanner).clearScanIterators(); } |
EncryptedBatchScanner implements BatchScanner { @Override public ItemProcessingIterator<Entry<Key,Value>> iterator() { return new EncryptedScannerIterator(scanner.iterator(), encryptor, clientSideRanges, clientSideColumnFilters); } EncryptedBatchScanner(Connector connector, String tableName, Authorizations authorizations, int numQueryThreads, EncryptionConfig cryptoConfig,
EncryptionKeyContainer keys); @Override void setRanges(Collection<Range> collection); @Override void fetchColumnFamily(Text col); @Override void fetchColumn(Text colFam, Text colQual); @Override void fetchColumn(IteratorSetting.Column column); @Override void clearColumns(); @Override ItemProcessingIterator<Entry<Key,Value>> iterator(); @Override void clearScanIterators(); @Override void close(); @Override Authorizations getAuthorizations(); @Override void setSamplerConfiguration(SamplerConfiguration samplerConfiguration); @Override SamplerConfiguration getSamplerConfiguration(); @Override void clearSamplerConfiguration(); @Override void setBatchTimeout(long l, TimeUnit timeUnit); @Override long getBatchTimeout(TimeUnit timeUnit); @Override void setClassLoaderContext(String s); @Override void clearClassLoaderContext(); @Override String getClassLoaderContext(); @Override void addScanIterator(IteratorSetting iteratorSetting); @Override void removeScanIterator(String s); @Override void updateScanIteratorOption(String s, String s1, String s2); @Override void setTimeout(long l, TimeUnit timeUnit); @Override long getTimeout(TimeUnit timeUnit); } | @Test public void iteratorTest() throws Exception { when(mockConnector.createBatchScanner(TEST_TABLE, authorizations, 1)).thenReturn(mockScanner); EntryEncryptor encryptor = new EntryEncryptor(getConfig("encrypt-value.ini"), KEYS); List<Map.Entry<Key,Value>> entries = new ArrayList<>(); Map.Entry<Key,Value> entry = new SimpleImmutableEntry<>(new Key(new byte[] {1}, new byte[] {2}, new byte[] {3}, "secret".getBytes(Utils.VISIBILITY_CHARSET), 0, false, false), new Value(new byte[] {4})); Map.Entry<Key,Value> entry2 = new SimpleImmutableEntry<>(new Key(new byte[] {5}, new byte[] {6}, new byte[] {7}, "secret".getBytes(Utils.VISIBILITY_CHARSET), 0, false, false), new Value(new byte[] {8})); entries.add(encryptor.encrypt(entry)); entries.add(encryptor.encrypt(entry2)); when(mockScanner.iterator()).thenReturn(entries.iterator()).thenReturn(entries.iterator()); BatchScanner scanner = new EncryptedBatchScanner(mockConnector, TEST_TABLE, authorizations, 1, getConfig("encrypt-value.ini"), KEYS); assertThat("has correct number of elements", scanner, iterableWithSize(2)); Iterator<Entry<Key,Value>> iterator = scanner.iterator(); assertThat("correct item", iterator.next(), Matchers.equalTo(entry)); assertThat("correct item", iterator.next(), Matchers.equalTo(entry2)); } |
EncryptedBatchScanner implements BatchScanner { @Override public void clearScanIterators() { scanner.clearScanIterators(); } EncryptedBatchScanner(Connector connector, String tableName, Authorizations authorizations, int numQueryThreads, EncryptionConfig cryptoConfig,
EncryptionKeyContainer keys); @Override void setRanges(Collection<Range> collection); @Override void fetchColumnFamily(Text col); @Override void fetchColumn(Text colFam, Text colQual); @Override void fetchColumn(IteratorSetting.Column column); @Override void clearColumns(); @Override ItemProcessingIterator<Entry<Key,Value>> iterator(); @Override void clearScanIterators(); @Override void close(); @Override Authorizations getAuthorizations(); @Override void setSamplerConfiguration(SamplerConfiguration samplerConfiguration); @Override SamplerConfiguration getSamplerConfiguration(); @Override void clearSamplerConfiguration(); @Override void setBatchTimeout(long l, TimeUnit timeUnit); @Override long getBatchTimeout(TimeUnit timeUnit); @Override void setClassLoaderContext(String s); @Override void clearClassLoaderContext(); @Override String getClassLoaderContext(); @Override void addScanIterator(IteratorSetting iteratorSetting); @Override void removeScanIterator(String s); @Override void updateScanIteratorOption(String s, String s1, String s2); @Override void setTimeout(long l, TimeUnit timeUnit); @Override long getTimeout(TimeUnit timeUnit); } | @Test public void clearScanIteratorsTest() throws Exception { when(mockConnector.createBatchScanner(TEST_TABLE, authorizations, 1)).thenReturn(mockScanner); new EncryptedBatchScanner(mockConnector, TEST_TABLE, authorizations, 1, getConfig("encrypt-value.ini"), KEYS).clearScanIterators(); verify(mockScanner).clearScanIterators(); } |
EncryptedBatchScanner implements BatchScanner { @Override public void close() { scanner.close(); } EncryptedBatchScanner(Connector connector, String tableName, Authorizations authorizations, int numQueryThreads, EncryptionConfig cryptoConfig,
EncryptionKeyContainer keys); @Override void setRanges(Collection<Range> collection); @Override void fetchColumnFamily(Text col); @Override void fetchColumn(Text colFam, Text colQual); @Override void fetchColumn(IteratorSetting.Column column); @Override void clearColumns(); @Override ItemProcessingIterator<Entry<Key,Value>> iterator(); @Override void clearScanIterators(); @Override void close(); @Override Authorizations getAuthorizations(); @Override void setSamplerConfiguration(SamplerConfiguration samplerConfiguration); @Override SamplerConfiguration getSamplerConfiguration(); @Override void clearSamplerConfiguration(); @Override void setBatchTimeout(long l, TimeUnit timeUnit); @Override long getBatchTimeout(TimeUnit timeUnit); @Override void setClassLoaderContext(String s); @Override void clearClassLoaderContext(); @Override String getClassLoaderContext(); @Override void addScanIterator(IteratorSetting iteratorSetting); @Override void removeScanIterator(String s); @Override void updateScanIteratorOption(String s, String s1, String s2); @Override void setTimeout(long l, TimeUnit timeUnit); @Override long getTimeout(TimeUnit timeUnit); } | @Test public void closeTest() throws Exception { when(mockConnector.createBatchScanner(TEST_TABLE, authorizations, 1)).thenReturn(mockScanner); new EncryptedBatchScanner(mockConnector, TEST_TABLE, authorizations, 1, getConfig("encrypt-value.ini"), KEYS).close(); verify(mockScanner).close(); } |
EncryptedBatchScanner implements BatchScanner { @Override public Authorizations getAuthorizations() { return scanner.getAuthorizations(); } EncryptedBatchScanner(Connector connector, String tableName, Authorizations authorizations, int numQueryThreads, EncryptionConfig cryptoConfig,
EncryptionKeyContainer keys); @Override void setRanges(Collection<Range> collection); @Override void fetchColumnFamily(Text col); @Override void fetchColumn(Text colFam, Text colQual); @Override void fetchColumn(IteratorSetting.Column column); @Override void clearColumns(); @Override ItemProcessingIterator<Entry<Key,Value>> iterator(); @Override void clearScanIterators(); @Override void close(); @Override Authorizations getAuthorizations(); @Override void setSamplerConfiguration(SamplerConfiguration samplerConfiguration); @Override SamplerConfiguration getSamplerConfiguration(); @Override void clearSamplerConfiguration(); @Override void setBatchTimeout(long l, TimeUnit timeUnit); @Override long getBatchTimeout(TimeUnit timeUnit); @Override void setClassLoaderContext(String s); @Override void clearClassLoaderContext(); @Override String getClassLoaderContext(); @Override void addScanIterator(IteratorSetting iteratorSetting); @Override void removeScanIterator(String s); @Override void updateScanIteratorOption(String s, String s1, String s2); @Override void setTimeout(long l, TimeUnit timeUnit); @Override long getTimeout(TimeUnit timeUnit); } | @Test public void getAuthorizationsTest() throws Exception { when(mockConnector.createBatchScanner(TEST_TABLE, authorizations, 1)).thenReturn(mockScanner); when(mockScanner.getAuthorizations()).thenReturn(authorizations); Authorizations auths = new EncryptedBatchScanner(mockConnector, TEST_TABLE, authorizations, 1, getConfig("encrypt-value.ini"), KEYS).getAuthorizations(); verify(mockScanner).getAuthorizations(); assertThat("correct authorizations returned", auths, equalTo(authorizations)); } |
EncryptedBatchScanner implements BatchScanner { @Override public void setSamplerConfiguration(SamplerConfiguration samplerConfiguration) { scanner.setSamplerConfiguration(samplerConfiguration); } EncryptedBatchScanner(Connector connector, String tableName, Authorizations authorizations, int numQueryThreads, EncryptionConfig cryptoConfig,
EncryptionKeyContainer keys); @Override void setRanges(Collection<Range> collection); @Override void fetchColumnFamily(Text col); @Override void fetchColumn(Text colFam, Text colQual); @Override void fetchColumn(IteratorSetting.Column column); @Override void clearColumns(); @Override ItemProcessingIterator<Entry<Key,Value>> iterator(); @Override void clearScanIterators(); @Override void close(); @Override Authorizations getAuthorizations(); @Override void setSamplerConfiguration(SamplerConfiguration samplerConfiguration); @Override SamplerConfiguration getSamplerConfiguration(); @Override void clearSamplerConfiguration(); @Override void setBatchTimeout(long l, TimeUnit timeUnit); @Override long getBatchTimeout(TimeUnit timeUnit); @Override void setClassLoaderContext(String s); @Override void clearClassLoaderContext(); @Override String getClassLoaderContext(); @Override void addScanIterator(IteratorSetting iteratorSetting); @Override void removeScanIterator(String s); @Override void updateScanIteratorOption(String s, String s1, String s2); @Override void setTimeout(long l, TimeUnit timeUnit); @Override long getTimeout(TimeUnit timeUnit); } | @Test public void setSamplerConfigurationTest() throws Exception { when(mockConnector.createBatchScanner(TEST_TABLE, authorizations, 1)).thenReturn(mockScanner); SamplerConfiguration config = new SamplerConfiguration("test"); new EncryptedBatchScanner(mockConnector, TEST_TABLE, authorizations, 1, getConfig("encrypt-value.ini"), KEYS).setSamplerConfiguration(config); verify(mockScanner).setSamplerConfiguration(config); } |
EncryptedBatchScanner implements BatchScanner { @Override public SamplerConfiguration getSamplerConfiguration() { return scanner.getSamplerConfiguration(); } EncryptedBatchScanner(Connector connector, String tableName, Authorizations authorizations, int numQueryThreads, EncryptionConfig cryptoConfig,
EncryptionKeyContainer keys); @Override void setRanges(Collection<Range> collection); @Override void fetchColumnFamily(Text col); @Override void fetchColumn(Text colFam, Text colQual); @Override void fetchColumn(IteratorSetting.Column column); @Override void clearColumns(); @Override ItemProcessingIterator<Entry<Key,Value>> iterator(); @Override void clearScanIterators(); @Override void close(); @Override Authorizations getAuthorizations(); @Override void setSamplerConfiguration(SamplerConfiguration samplerConfiguration); @Override SamplerConfiguration getSamplerConfiguration(); @Override void clearSamplerConfiguration(); @Override void setBatchTimeout(long l, TimeUnit timeUnit); @Override long getBatchTimeout(TimeUnit timeUnit); @Override void setClassLoaderContext(String s); @Override void clearClassLoaderContext(); @Override String getClassLoaderContext(); @Override void addScanIterator(IteratorSetting iteratorSetting); @Override void removeScanIterator(String s); @Override void updateScanIteratorOption(String s, String s1, String s2); @Override void setTimeout(long l, TimeUnit timeUnit); @Override long getTimeout(TimeUnit timeUnit); } | @Test public void getSamplerConfigurationTest() throws Exception { when(mockConnector.createBatchScanner(TEST_TABLE, authorizations, 1)).thenReturn(mockScanner); SamplerConfiguration config = new SamplerConfiguration("test"); when(mockScanner.getSamplerConfiguration()).thenReturn(config); SamplerConfiguration value = new EncryptedBatchScanner(mockConnector, TEST_TABLE, authorizations, 1, getConfig("encrypt-value.ini"), KEYS) .getSamplerConfiguration(); verify(mockScanner).getSamplerConfiguration(); assertThat("correct config returned", value, equalTo(config)); } |
EncryptedBatchScanner implements BatchScanner { @Override public void clearSamplerConfiguration() { scanner.clearSamplerConfiguration(); } EncryptedBatchScanner(Connector connector, String tableName, Authorizations authorizations, int numQueryThreads, EncryptionConfig cryptoConfig,
EncryptionKeyContainer keys); @Override void setRanges(Collection<Range> collection); @Override void fetchColumnFamily(Text col); @Override void fetchColumn(Text colFam, Text colQual); @Override void fetchColumn(IteratorSetting.Column column); @Override void clearColumns(); @Override ItemProcessingIterator<Entry<Key,Value>> iterator(); @Override void clearScanIterators(); @Override void close(); @Override Authorizations getAuthorizations(); @Override void setSamplerConfiguration(SamplerConfiguration samplerConfiguration); @Override SamplerConfiguration getSamplerConfiguration(); @Override void clearSamplerConfiguration(); @Override void setBatchTimeout(long l, TimeUnit timeUnit); @Override long getBatchTimeout(TimeUnit timeUnit); @Override void setClassLoaderContext(String s); @Override void clearClassLoaderContext(); @Override String getClassLoaderContext(); @Override void addScanIterator(IteratorSetting iteratorSetting); @Override void removeScanIterator(String s); @Override void updateScanIteratorOption(String s, String s1, String s2); @Override void setTimeout(long l, TimeUnit timeUnit); @Override long getTimeout(TimeUnit timeUnit); } | @Test public void clearSamplerConfigurationTest() throws Exception { when(mockConnector.createBatchScanner(TEST_TABLE, authorizations, 1)).thenReturn(mockScanner); new EncryptedBatchScanner(mockConnector, TEST_TABLE, authorizations, 1, getConfig("encrypt-value.ini"), KEYS).clearSamplerConfiguration(); verify(mockScanner).clearSamplerConfiguration(); } |
EncryptedBatchScanner implements BatchScanner { @Override public void setBatchTimeout(long l, TimeUnit timeUnit) { scanner.setBatchTimeout(l, timeUnit); } EncryptedBatchScanner(Connector connector, String tableName, Authorizations authorizations, int numQueryThreads, EncryptionConfig cryptoConfig,
EncryptionKeyContainer keys); @Override void setRanges(Collection<Range> collection); @Override void fetchColumnFamily(Text col); @Override void fetchColumn(Text colFam, Text colQual); @Override void fetchColumn(IteratorSetting.Column column); @Override void clearColumns(); @Override ItemProcessingIterator<Entry<Key,Value>> iterator(); @Override void clearScanIterators(); @Override void close(); @Override Authorizations getAuthorizations(); @Override void setSamplerConfiguration(SamplerConfiguration samplerConfiguration); @Override SamplerConfiguration getSamplerConfiguration(); @Override void clearSamplerConfiguration(); @Override void setBatchTimeout(long l, TimeUnit timeUnit); @Override long getBatchTimeout(TimeUnit timeUnit); @Override void setClassLoaderContext(String s); @Override void clearClassLoaderContext(); @Override String getClassLoaderContext(); @Override void addScanIterator(IteratorSetting iteratorSetting); @Override void removeScanIterator(String s); @Override void updateScanIteratorOption(String s, String s1, String s2); @Override void setTimeout(long l, TimeUnit timeUnit); @Override long getTimeout(TimeUnit timeUnit); } | @Test public void setBatchTimeoutTest() throws Exception { when(mockConnector.createBatchScanner(TEST_TABLE, authorizations, 1)).thenReturn(mockScanner); new EncryptedBatchScanner(mockConnector, TEST_TABLE, authorizations, 1, getConfig("encrypt-value.ini"), KEYS).setBatchTimeout(5L, TimeUnit.DAYS); verify(mockScanner).setBatchTimeout(5L, TimeUnit.DAYS); } |
EncryptedBatchScanner implements BatchScanner { @Override public long getBatchTimeout(TimeUnit timeUnit) { return scanner.getBatchTimeout(timeUnit); } EncryptedBatchScanner(Connector connector, String tableName, Authorizations authorizations, int numQueryThreads, EncryptionConfig cryptoConfig,
EncryptionKeyContainer keys); @Override void setRanges(Collection<Range> collection); @Override void fetchColumnFamily(Text col); @Override void fetchColumn(Text colFam, Text colQual); @Override void fetchColumn(IteratorSetting.Column column); @Override void clearColumns(); @Override ItemProcessingIterator<Entry<Key,Value>> iterator(); @Override void clearScanIterators(); @Override void close(); @Override Authorizations getAuthorizations(); @Override void setSamplerConfiguration(SamplerConfiguration samplerConfiguration); @Override SamplerConfiguration getSamplerConfiguration(); @Override void clearSamplerConfiguration(); @Override void setBatchTimeout(long l, TimeUnit timeUnit); @Override long getBatchTimeout(TimeUnit timeUnit); @Override void setClassLoaderContext(String s); @Override void clearClassLoaderContext(); @Override String getClassLoaderContext(); @Override void addScanIterator(IteratorSetting iteratorSetting); @Override void removeScanIterator(String s); @Override void updateScanIteratorOption(String s, String s1, String s2); @Override void setTimeout(long l, TimeUnit timeUnit); @Override long getTimeout(TimeUnit timeUnit); } | @Test public void getBatchTimeoutTest() throws Exception { when(mockConnector.createBatchScanner(TEST_TABLE, authorizations, 1)).thenReturn(mockScanner); when(mockScanner.getBatchTimeout(TimeUnit.DAYS)).thenReturn(5L); long value = new EncryptedBatchScanner(mockConnector, TEST_TABLE, authorizations, 1, getConfig("encrypt-value.ini"), KEYS).getBatchTimeout(TimeUnit.DAYS); verify(mockScanner).getBatchTimeout(TimeUnit.DAYS); assertThat("correct timeout returned", value, is(5L)); } |
EncryptedBatchScanner implements BatchScanner { @Override public void setClassLoaderContext(String s) { scanner.setClassLoaderContext(s); } EncryptedBatchScanner(Connector connector, String tableName, Authorizations authorizations, int numQueryThreads, EncryptionConfig cryptoConfig,
EncryptionKeyContainer keys); @Override void setRanges(Collection<Range> collection); @Override void fetchColumnFamily(Text col); @Override void fetchColumn(Text colFam, Text colQual); @Override void fetchColumn(IteratorSetting.Column column); @Override void clearColumns(); @Override ItemProcessingIterator<Entry<Key,Value>> iterator(); @Override void clearScanIterators(); @Override void close(); @Override Authorizations getAuthorizations(); @Override void setSamplerConfiguration(SamplerConfiguration samplerConfiguration); @Override SamplerConfiguration getSamplerConfiguration(); @Override void clearSamplerConfiguration(); @Override void setBatchTimeout(long l, TimeUnit timeUnit); @Override long getBatchTimeout(TimeUnit timeUnit); @Override void setClassLoaderContext(String s); @Override void clearClassLoaderContext(); @Override String getClassLoaderContext(); @Override void addScanIterator(IteratorSetting iteratorSetting); @Override void removeScanIterator(String s); @Override void updateScanIteratorOption(String s, String s1, String s2); @Override void setTimeout(long l, TimeUnit timeUnit); @Override long getTimeout(TimeUnit timeUnit); } | @Test public void setClassLoaderContextTest() throws Exception { when(mockConnector.createBatchScanner(TEST_TABLE, authorizations, 1)).thenReturn(mockScanner); new EncryptedBatchScanner(mockConnector, TEST_TABLE, authorizations, 1, getConfig("encrypt-value.ini"), KEYS).setClassLoaderContext("test"); verify(mockScanner).setClassLoaderContext("test"); } |
SignedScanner implements Scanner { @Override public void close() { valueScanner.close(); if (signatureScanner != null) { signatureScanner.close(); } } SignedScanner(Connector connector, String tableName, Authorizations authorizations, SignatureConfig signatureConfig, SignatureKeyContainer keys); @Override ItemProcessingIterator<Entry<Key,Value>> iterator(); @Override void addScanIterator(IteratorSetting cfg); @Override void clearColumns(); @Override void clearScanIterators(); @Override void close(); @Override void fetchColumn(Column column); @Override void fetchColumn(Text colFam, Text colQual); @Override void fetchColumnFamily(Text col); @Override Authorizations getAuthorizations(); @Override void setSamplerConfiguration(SamplerConfiguration samplerConfiguration); @Override SamplerConfiguration getSamplerConfiguration(); @Override void clearSamplerConfiguration(); @Override void setBatchTimeout(long l, TimeUnit timeUnit); @Override long getBatchTimeout(TimeUnit timeUnit); @Override void setClassLoaderContext(String s); @Override void clearClassLoaderContext(); @Override String getClassLoaderContext(); @Override long getTimeout(TimeUnit timeUnit); @Override void removeScanIterator(String iteratorName); @Override void updateScanIteratorOption(String iteratorName, String key, String value); @Override void setTimeout(long timeout, TimeUnit timeUnit); @Override void disableIsolation(); @Override void enableIsolation(); @Override int getBatchSize(); @Override Range getRange(); @Override long getReadaheadThreshold(); @Override @SuppressWarnings("deprecation") int getTimeOut(); @Override void setBatchSize(int size); @Override void setRange(Range range); @Override void setReadaheadThreshold(long batches); @Override @SuppressWarnings("deprecation") void setTimeOut(int timeOut); } | @Test public void closeTest() throws Exception { when(mockConnector.createScanner(TEST_TABLE, authorizations)).thenReturn(mockScanner); new SignedScanner(mockConnector, TEST_TABLE, authorizations, getConfig("config1.ini"), aliceKeyContainers.get(ValueSigner.RSA_PSS)).close(); verify(mockScanner).close(); }
@Test public void closeExternalTest() throws Exception { when(mockConnector.createScanner(TEST_TABLE, authorizations)).thenReturn(mockScanner); when(mockConnector.createScanner(SIG_TABLE, authorizations)).thenReturn(mockSignatureScanner); new SignedScanner(mockConnector, TEST_TABLE, authorizations, getConfig("config3.ini"), aliceKeyContainers.get(ValueSigner.RSA_PSS)).close(); verify(mockScanner).close(); verify(mockSignatureScanner).close(); } |
EncryptedBatchScanner implements BatchScanner { @Override public void clearClassLoaderContext() { scanner.clearClassLoaderContext(); } EncryptedBatchScanner(Connector connector, String tableName, Authorizations authorizations, int numQueryThreads, EncryptionConfig cryptoConfig,
EncryptionKeyContainer keys); @Override void setRanges(Collection<Range> collection); @Override void fetchColumnFamily(Text col); @Override void fetchColumn(Text colFam, Text colQual); @Override void fetchColumn(IteratorSetting.Column column); @Override void clearColumns(); @Override ItemProcessingIterator<Entry<Key,Value>> iterator(); @Override void clearScanIterators(); @Override void close(); @Override Authorizations getAuthorizations(); @Override void setSamplerConfiguration(SamplerConfiguration samplerConfiguration); @Override SamplerConfiguration getSamplerConfiguration(); @Override void clearSamplerConfiguration(); @Override void setBatchTimeout(long l, TimeUnit timeUnit); @Override long getBatchTimeout(TimeUnit timeUnit); @Override void setClassLoaderContext(String s); @Override void clearClassLoaderContext(); @Override String getClassLoaderContext(); @Override void addScanIterator(IteratorSetting iteratorSetting); @Override void removeScanIterator(String s); @Override void updateScanIteratorOption(String s, String s1, String s2); @Override void setTimeout(long l, TimeUnit timeUnit); @Override long getTimeout(TimeUnit timeUnit); } | @Test public void clearClassLoaderContextTest() throws Exception { when(mockConnector.createBatchScanner(TEST_TABLE, authorizations, 1)).thenReturn(mockScanner); new EncryptedBatchScanner(mockConnector, TEST_TABLE, authorizations, 1, getConfig("encrypt-value.ini"), KEYS).clearClassLoaderContext(); verify(mockScanner).clearClassLoaderContext(); } |
EncryptedBatchScanner implements BatchScanner { @Override public String getClassLoaderContext() { return scanner.getClassLoaderContext(); } EncryptedBatchScanner(Connector connector, String tableName, Authorizations authorizations, int numQueryThreads, EncryptionConfig cryptoConfig,
EncryptionKeyContainer keys); @Override void setRanges(Collection<Range> collection); @Override void fetchColumnFamily(Text col); @Override void fetchColumn(Text colFam, Text colQual); @Override void fetchColumn(IteratorSetting.Column column); @Override void clearColumns(); @Override ItemProcessingIterator<Entry<Key,Value>> iterator(); @Override void clearScanIterators(); @Override void close(); @Override Authorizations getAuthorizations(); @Override void setSamplerConfiguration(SamplerConfiguration samplerConfiguration); @Override SamplerConfiguration getSamplerConfiguration(); @Override void clearSamplerConfiguration(); @Override void setBatchTimeout(long l, TimeUnit timeUnit); @Override long getBatchTimeout(TimeUnit timeUnit); @Override void setClassLoaderContext(String s); @Override void clearClassLoaderContext(); @Override String getClassLoaderContext(); @Override void addScanIterator(IteratorSetting iteratorSetting); @Override void removeScanIterator(String s); @Override void updateScanIteratorOption(String s, String s1, String s2); @Override void setTimeout(long l, TimeUnit timeUnit); @Override long getTimeout(TimeUnit timeUnit); } | @Test public void getClassLoaderContextTest() throws Exception { when(mockConnector.createBatchScanner(TEST_TABLE, authorizations, 1)).thenReturn(mockScanner); when(mockScanner.getClassLoaderContext()).thenReturn("test"); String value = new EncryptedBatchScanner(mockConnector, TEST_TABLE, authorizations, 1, getConfig("encrypt-value.ini"), KEYS).getClassLoaderContext(); verify(mockScanner).getClassLoaderContext(); assertThat("correct class loader context returned", value, is("test")); } |
EncryptedBatchScanner implements BatchScanner { @Override public void addScanIterator(IteratorSetting iteratorSetting) { scanner.addScanIterator(iteratorSetting); } EncryptedBatchScanner(Connector connector, String tableName, Authorizations authorizations, int numQueryThreads, EncryptionConfig cryptoConfig,
EncryptionKeyContainer keys); @Override void setRanges(Collection<Range> collection); @Override void fetchColumnFamily(Text col); @Override void fetchColumn(Text colFam, Text colQual); @Override void fetchColumn(IteratorSetting.Column column); @Override void clearColumns(); @Override ItemProcessingIterator<Entry<Key,Value>> iterator(); @Override void clearScanIterators(); @Override void close(); @Override Authorizations getAuthorizations(); @Override void setSamplerConfiguration(SamplerConfiguration samplerConfiguration); @Override SamplerConfiguration getSamplerConfiguration(); @Override void clearSamplerConfiguration(); @Override void setBatchTimeout(long l, TimeUnit timeUnit); @Override long getBatchTimeout(TimeUnit timeUnit); @Override void setClassLoaderContext(String s); @Override void clearClassLoaderContext(); @Override String getClassLoaderContext(); @Override void addScanIterator(IteratorSetting iteratorSetting); @Override void removeScanIterator(String s); @Override void updateScanIteratorOption(String s, String s1, String s2); @Override void setTimeout(long l, TimeUnit timeUnit); @Override long getTimeout(TimeUnit timeUnit); } | @Test public void addScanIteratorTest() throws Exception { when(mockConnector.createBatchScanner(TEST_TABLE, authorizations, 1)).thenReturn(mockScanner); IteratorSetting test = new IteratorSetting(10, "test", "test2"); new EncryptedBatchScanner(mockConnector, TEST_TABLE, authorizations, 1, getConfig("encrypt-value.ini"), KEYS).addScanIterator(test); verify(mockScanner).addScanIterator(test); } |
EncryptedBatchScanner implements BatchScanner { @Override public void removeScanIterator(String s) { scanner.removeScanIterator(s); } EncryptedBatchScanner(Connector connector, String tableName, Authorizations authorizations, int numQueryThreads, EncryptionConfig cryptoConfig,
EncryptionKeyContainer keys); @Override void setRanges(Collection<Range> collection); @Override void fetchColumnFamily(Text col); @Override void fetchColumn(Text colFam, Text colQual); @Override void fetchColumn(IteratorSetting.Column column); @Override void clearColumns(); @Override ItemProcessingIterator<Entry<Key,Value>> iterator(); @Override void clearScanIterators(); @Override void close(); @Override Authorizations getAuthorizations(); @Override void setSamplerConfiguration(SamplerConfiguration samplerConfiguration); @Override SamplerConfiguration getSamplerConfiguration(); @Override void clearSamplerConfiguration(); @Override void setBatchTimeout(long l, TimeUnit timeUnit); @Override long getBatchTimeout(TimeUnit timeUnit); @Override void setClassLoaderContext(String s); @Override void clearClassLoaderContext(); @Override String getClassLoaderContext(); @Override void addScanIterator(IteratorSetting iteratorSetting); @Override void removeScanIterator(String s); @Override void updateScanIteratorOption(String s, String s1, String s2); @Override void setTimeout(long l, TimeUnit timeUnit); @Override long getTimeout(TimeUnit timeUnit); } | @Test public void removeScanIteratorTest() throws Exception { when(mockConnector.createBatchScanner(TEST_TABLE, authorizations, 1)).thenReturn(mockScanner); new EncryptedBatchScanner(mockConnector, TEST_TABLE, authorizations, 1, getConfig("encrypt-value.ini"), KEYS).removeScanIterator("test"); verify(mockScanner).removeScanIterator("test"); } |
EncryptedBatchScanner implements BatchScanner { @Override public void updateScanIteratorOption(String s, String s1, String s2) { scanner.updateScanIteratorOption(s, s1, s2); } EncryptedBatchScanner(Connector connector, String tableName, Authorizations authorizations, int numQueryThreads, EncryptionConfig cryptoConfig,
EncryptionKeyContainer keys); @Override void setRanges(Collection<Range> collection); @Override void fetchColumnFamily(Text col); @Override void fetchColumn(Text colFam, Text colQual); @Override void fetchColumn(IteratorSetting.Column column); @Override void clearColumns(); @Override ItemProcessingIterator<Entry<Key,Value>> iterator(); @Override void clearScanIterators(); @Override void close(); @Override Authorizations getAuthorizations(); @Override void setSamplerConfiguration(SamplerConfiguration samplerConfiguration); @Override SamplerConfiguration getSamplerConfiguration(); @Override void clearSamplerConfiguration(); @Override void setBatchTimeout(long l, TimeUnit timeUnit); @Override long getBatchTimeout(TimeUnit timeUnit); @Override void setClassLoaderContext(String s); @Override void clearClassLoaderContext(); @Override String getClassLoaderContext(); @Override void addScanIterator(IteratorSetting iteratorSetting); @Override void removeScanIterator(String s); @Override void updateScanIteratorOption(String s, String s1, String s2); @Override void setTimeout(long l, TimeUnit timeUnit); @Override long getTimeout(TimeUnit timeUnit); } | @Test public void updateScanIteratorOptionTest() throws Exception { when(mockConnector.createBatchScanner(TEST_TABLE, authorizations, 1)).thenReturn(mockScanner); new EncryptedBatchScanner(mockConnector, TEST_TABLE, authorizations, 1, getConfig("encrypt-value.ini"), KEYS).updateScanIteratorOption("test", "a", "b"); verify(mockScanner).updateScanIteratorOption("test", "a", "b"); } |
EncryptedBatchScanner implements BatchScanner { @Override public void setTimeout(long l, TimeUnit timeUnit) { scanner.setTimeout(l, timeUnit); } EncryptedBatchScanner(Connector connector, String tableName, Authorizations authorizations, int numQueryThreads, EncryptionConfig cryptoConfig,
EncryptionKeyContainer keys); @Override void setRanges(Collection<Range> collection); @Override void fetchColumnFamily(Text col); @Override void fetchColumn(Text colFam, Text colQual); @Override void fetchColumn(IteratorSetting.Column column); @Override void clearColumns(); @Override ItemProcessingIterator<Entry<Key,Value>> iterator(); @Override void clearScanIterators(); @Override void close(); @Override Authorizations getAuthorizations(); @Override void setSamplerConfiguration(SamplerConfiguration samplerConfiguration); @Override SamplerConfiguration getSamplerConfiguration(); @Override void clearSamplerConfiguration(); @Override void setBatchTimeout(long l, TimeUnit timeUnit); @Override long getBatchTimeout(TimeUnit timeUnit); @Override void setClassLoaderContext(String s); @Override void clearClassLoaderContext(); @Override String getClassLoaderContext(); @Override void addScanIterator(IteratorSetting iteratorSetting); @Override void removeScanIterator(String s); @Override void updateScanIteratorOption(String s, String s1, String s2); @Override void setTimeout(long l, TimeUnit timeUnit); @Override long getTimeout(TimeUnit timeUnit); } | @Test public void setTimeoutTest() throws Exception { when(mockConnector.createBatchScanner(TEST_TABLE, authorizations, 1)).thenReturn(mockScanner); new EncryptedBatchScanner(mockConnector, TEST_TABLE, authorizations, 1, getConfig("encrypt-value.ini"), KEYS).setTimeout(5L, TimeUnit.DAYS); verify(mockScanner).setTimeout(5L, TimeUnit.DAYS); } |
EncryptedBatchScanner implements BatchScanner { @Override public long getTimeout(TimeUnit timeUnit) { return scanner.getTimeout(timeUnit); } EncryptedBatchScanner(Connector connector, String tableName, Authorizations authorizations, int numQueryThreads, EncryptionConfig cryptoConfig,
EncryptionKeyContainer keys); @Override void setRanges(Collection<Range> collection); @Override void fetchColumnFamily(Text col); @Override void fetchColumn(Text colFam, Text colQual); @Override void fetchColumn(IteratorSetting.Column column); @Override void clearColumns(); @Override ItemProcessingIterator<Entry<Key,Value>> iterator(); @Override void clearScanIterators(); @Override void close(); @Override Authorizations getAuthorizations(); @Override void setSamplerConfiguration(SamplerConfiguration samplerConfiguration); @Override SamplerConfiguration getSamplerConfiguration(); @Override void clearSamplerConfiguration(); @Override void setBatchTimeout(long l, TimeUnit timeUnit); @Override long getBatchTimeout(TimeUnit timeUnit); @Override void setClassLoaderContext(String s); @Override void clearClassLoaderContext(); @Override String getClassLoaderContext(); @Override void addScanIterator(IteratorSetting iteratorSetting); @Override void removeScanIterator(String s); @Override void updateScanIteratorOption(String s, String s1, String s2); @Override void setTimeout(long l, TimeUnit timeUnit); @Override long getTimeout(TimeUnit timeUnit); } | @Test public void getTimeoutTest() throws Exception { when(mockConnector.createBatchScanner(TEST_TABLE, authorizations, 1)).thenReturn(mockScanner); when(mockScanner.getTimeout(TimeUnit.DAYS)).thenReturn(5L); Long value = new EncryptedBatchScanner(mockConnector, TEST_TABLE, authorizations, 1, getConfig("encrypt-value.ini"), KEYS).getTimeout(TimeUnit.DAYS); verify(mockScanner).getTimeout(TimeUnit.DAYS); assertThat("correct timeout returned", value, is(5L)); } |
EncryptedBatchWriter implements BatchWriter { @Override public void addMutation(Mutation mutation) throws MutationsRejectedException { for (ColumnUpdate update : mutation.getUpdates()) { MutableEntry entry = new MutableEntry(mutation.getRow(), update); if (update.isDeleted()) { if (!supportsDelete) { throw new IllegalArgumentException("cannot delete entries when there are fields encrypted using non-deterministic encryption"); } for (Key deleteKey : encryptor.getDeleteKeys(entry.toKey())) { MutableEntry encryptedKey = new MutableEntry(deleteKey); Mutation encryptedMutation = new Mutation(encryptedKey.row); if (update.hasTimestamp()) { encryptedMutation.putDelete(encryptedKey.colF, encryptedKey.colQ, new ColumnVisibility(encryptedKey.colVis), encryptedKey.timestamp); } else { encryptedMutation.putDelete(encryptedKey.colF, encryptedKey.colQ, new ColumnVisibility(encryptedKey.colVis)); } writer.addMutation(encryptedMutation); } } else { MutableEntry encryptedEntry = new MutableEntry(encryptor.encrypt(new MutableEntry(mutation.getRow(), update).toEntry())); Mutation encryptedMutation = new Mutation(encryptedEntry.row); if (update.hasTimestamp()) { encryptedMutation.put(encryptedEntry.colF, encryptedEntry.colQ, new ColumnVisibility(encryptedEntry.colVis), encryptedEntry.timestamp, encryptedEntry.value); } else { encryptedMutation.put(encryptedEntry.colF, encryptedEntry.colQ, new ColumnVisibility(encryptedEntry.colVis), encryptedEntry.value); } writer.addMutation(encryptedMutation); } } } EncryptedBatchWriter(Connector connector, String tableName, BatchWriterConfig batchConfig, EncryptionConfig cryptoConfig, EncryptionKeyContainer keys); @Override void addMutation(Mutation mutation); @Override void addMutations(Iterable<Mutation> iterable); @Override void flush(); @Override void close(); } | @Test public void addMutationTest() throws Exception { when(mockConnector.createBatchWriter(TEST_TABLE, null)).thenReturn(mockWriter); BatchWriter writer = new EncryptedBatchWriter(mockConnector, TEST_TABLE, null, getConfig("encrypt-value.ini"), KEYS); EntryEncryptor encryptor = new EntryEncryptor(getConfig("encrypt-value.ini"), KEYS); Mutation mutation = new Mutation("row".getBytes()); mutation.put("colF".getBytes(), "colQ".getBytes(), "val1".getBytes()); mutation.put("colF".getBytes(), "colQ".getBytes(), 0, "val2".getBytes()); writer.addMutation(mutation); verify(mockWriter, times(2)).addMutation(captor.capture()); List<Mutation> mutations = captor.getAllValues(); assertThat("two mutations", mutations, iterableWithSize(2)); Mutation encrypted = mutations.get(0); assertThat("row is unchanged", encrypted.getRow(), equalTo("row".getBytes())); List<ColumnUpdate> updates = encrypted.getUpdates(); assertThat("has 1 update", updates, hasSize(1)); ColumnUpdate update = updates.get(0); assertThat("column family is unchanged", update.getColumnFamily(), equalTo("colF".getBytes())); assertThat("column qualifier is unchanged", update.getColumnQualifier(), equalTo("colQ".getBytes())); assertThat("timestamp not set", update.hasTimestamp(), is(false)); assertThat("value is encrypted", update.getColumnFamily(), not(equalTo("val1".getBytes()))); MutableEntry decrypted = new MutableEntry(encryptor.decrypt(new MutableEntry("row".getBytes(), update).toEntry())); assertThat("value was encrypted correctly", decrypted.value, equalTo("val1".getBytes())); encrypted = mutations.get(1); assertThat("row is unchanged", encrypted.getRow(), equalTo("row".getBytes())); updates = encrypted.getUpdates(); assertThat("has 1 update", updates, hasSize(1)); update = updates.get(0); assertThat("column family is unchanged", update.getColumnFamily(), equalTo("colF".getBytes())); assertThat("column qualifier is unchanged", update.getColumnQualifier(), equalTo("colQ".getBytes())); assertThat("timestamp is set", update.hasTimestamp(), is(true)); assertThat("timestamp is correct", update.getTimestamp(), is(0L)); assertThat("value is encrypted", update.getColumnFamily(), not(equalTo("val2".getBytes()))); decrypted = new MutableEntry(encryptor.decrypt(new MutableEntry("row".getBytes(), update).toEntry())); assertThat("value was encrypted correctly", decrypted.value, equalTo("val2".getBytes())); }
@Test public void addMutationDeterministicTest() throws Exception { when(mockConnector.createBatchWriter(TEST_TABLE, null)).thenReturn(mockWriter); BatchWriter writer = new EncryptedBatchWriter(mockConnector, TEST_TABLE, null, getConfig("deterministic.ini"), KEYS); Mutation mutation = new Mutation("row".getBytes()); mutation.put("colF1".getBytes(), "colQ".getBytes(), "val".getBytes()); mutation.put("colF2".getBytes(), "colQ".getBytes(), 0, "val".getBytes()); mutation.put("colF1".getBytes(), "colQ".getBytes(), 0, "val2".getBytes()); writer.addMutation(mutation); verify(mockWriter, times(3)).addMutation(captor.capture()); Iterable<Mutation> mutations = captor.getAllValues(); assertThat("should have 2 mutations", mutations, iterableWithSize(3)); }
@Test public void deleteTest() throws Exception { when(mockConnector.createBatchWriter(TEST_TABLE, null)).thenReturn(mockWriter); BatchWriter writer = new EncryptedBatchWriter(mockConnector, TEST_TABLE, null, getConfig("encrypt-entry.ini"), KEYS); Mutation mutation = new Mutation("row".getBytes()); mutation.putDelete("colF1".getBytes(), "colQ".getBytes()); try { writer.addMutation(mutation); fail("encrypted deletes are not allowed on non-deterministically encrypted data"); } catch (IllegalArgumentException e) { } }
@Test public void deleteDeterministicTest() throws Exception { when(mockConnector.createBatchWriter(TEST_TABLE, null)).thenReturn(mockWriter); BatchWriter writer = new EncryptedBatchWriter(mockConnector, TEST_TABLE, null, getConfig("deterministic.ini"), KEYS); Mutation mutation = new Mutation("row".getBytes()); mutation.putDelete("colF1".getBytes(), "colQ".getBytes()); mutation.putDelete("colF2".getBytes(), "colQ".getBytes(), 0); writer.addMutation(mutation); verify(mockWriter, times(4)).addMutation(captor.capture()); Iterable<Mutation> mutations = captor.getAllValues(); assertThat("should have 4 mutations", mutations, iterableWithSize(4)); } |
EncryptedBatchWriter implements BatchWriter { @Override public void addMutations(Iterable<Mutation> iterable) throws MutationsRejectedException { for (Mutation mutation : iterable) { addMutation(mutation); } } EncryptedBatchWriter(Connector connector, String tableName, BatchWriterConfig batchConfig, EncryptionConfig cryptoConfig, EncryptionKeyContainer keys); @Override void addMutation(Mutation mutation); @Override void addMutations(Iterable<Mutation> iterable); @Override void flush(); @Override void close(); } | @Test public void addMutationsTest() throws Exception { when(mockConnector.createBatchWriter(TEST_TABLE, null)).thenReturn(mockWriter); BatchWriter writer = new EncryptedBatchWriter(mockConnector, TEST_TABLE, null, getConfig("encrypt-value.ini"), KEYS); List<Mutation> mutations = new ArrayList<>(); Mutation mutation = new Mutation("row"); mutation.put("colF", "colQ", "val"); mutations.add(mutation); writer.addMutations(mutations); verify(mockWriter, times(1)).addMutation(any()); mutations.add(mutation); writer.addMutations(mutations); verify(mockWriter, times(3)).addMutation(any()); mutations.add(mutation); writer.addMutations(mutations); verify(mockWriter, times(6)).addMutation(any()); } |
EncryptedBatchWriter implements BatchWriter { @Override public void flush() throws MutationsRejectedException { writer.flush(); } EncryptedBatchWriter(Connector connector, String tableName, BatchWriterConfig batchConfig, EncryptionConfig cryptoConfig, EncryptionKeyContainer keys); @Override void addMutation(Mutation mutation); @Override void addMutations(Iterable<Mutation> iterable); @Override void flush(); @Override void close(); } | @Test public void flushTest() throws Exception { when(mockConnector.createBatchWriter(TEST_TABLE, null)).thenReturn(mockWriter); new EncryptedBatchWriter(mockConnector, TEST_TABLE, null, getConfig("encrypt-value.ini"), KEYS).flush(); verify(mockWriter).flush(); } |
EncryptedBatchWriter implements BatchWriter { @Override public void close() throws MutationsRejectedException { writer.close(); } EncryptedBatchWriter(Connector connector, String tableName, BatchWriterConfig batchConfig, EncryptionConfig cryptoConfig, EncryptionKeyContainer keys); @Override void addMutation(Mutation mutation); @Override void addMutations(Iterable<Mutation> iterable); @Override void flush(); @Override void close(); } | @Test public void closeTest() throws Exception { when(mockConnector.createBatchWriter(TEST_TABLE, null)).thenReturn(mockWriter); new EncryptedBatchWriter(mockConnector, TEST_TABLE, null, getConfig("encrypt-value.ini"), KEYS).close(); verify(mockWriter).close(); } |
EncryptionConfig { public void write(Writer out) throws IOException { Ini configIni = new Ini(); for (FieldEncryptorConfig config : fieldEncryptorConfigs) { config.write(configIni); } configIni.store(out); } EncryptionConfig(List<FieldEncryptorConfig> fieldEncryptorConfigs); void write(Writer out); } | @Test public void writeTest() throws IOException { File iniFile = testFolder.newFile(); FileWriter out = new FileWriter(iniFile); config1.write(out); out.close(); Ini actual = new Ini(new FileReader(iniFile)); Ini expected = getIni("config1.ini"); assertThat("reading the ini produces the correct configuration", actual, is(Matchers.equalTo(expected))); }
@Test public void writeReadTest() throws IOException { File ini = testFolder.newFile(); FileWriter out = new FileWriter(ini); config1.write(out); out.close(); FileReader in = new FileReader(ini); EncryptionConfig config2 = new EncryptionConfigBuilder().readFromFile(in).build(); in.close(); assertThat("writing then reading the config should produce an equivalent configuration", config2, is(equalTo(config1))); } |
EncryptedScannerIterator implements ItemProcessingIterator<Entry<Key,Value>> { @Override public boolean hasNext() { if (next == null) { advance(); } return next != null; } EncryptedScannerIterator(Iterator<Entry<Key,Value>> iterator, EntryEncryptor encryptor, List<Range> clientSideRanges,
SortedSet<Column> clientSideColumnFilters); @Override boolean hasNext(); @Override Entry<Key,Value> next(); @Override void remove(); @Override Entry<Key,Value> unprocessed(); } | @Test public void hasNextTest() throws Exception { EntryEncryptor encryptor = new EntryEncryptor(getConfig("config.ini"), KEYS); List<Entry<Key,Value>> entries = new ArrayList<>(); Entry<Key,Value> entry = new SimpleImmutableEntry<Key,Value>(new Key(new byte[] {1}, new byte[] {2}, new byte[] {3}, "secret".getBytes(Utils.VISIBILITY_CHARSET), 0, false, false), new Value(new byte[] {4})); entries.add(encryptor.encrypt(entry)); EncryptedScannerIterator iterator = new EncryptedScannerIterator(entries.iterator(), encryptor, Collections.singletonList(new Range()), new TreeSet<Column>()); assertThat("has next item", iterator.hasNext(), is(true)); assertThat("has next item", iterator.hasNext(), is(true)); iterator.next(); assertThat("does not have a next item", iterator.hasNext(), is(false)); } |
EncryptedScannerIterator implements ItemProcessingIterator<Entry<Key,Value>> { @Override public Entry<Key,Value> next() { if (next == null) { advance(); } if (next == null) { throw new NoSuchElementException(); } Entry<Key,Value> value = next; next = null; return value; } EncryptedScannerIterator(Iterator<Entry<Key,Value>> iterator, EntryEncryptor encryptor, List<Range> clientSideRanges,
SortedSet<Column> clientSideColumnFilters); @Override boolean hasNext(); @Override Entry<Key,Value> next(); @Override void remove(); @Override Entry<Key,Value> unprocessed(); } | @Test public void nextTest() throws Exception { EntryEncryptor encryptor = new EntryEncryptor(getConfig("config.ini"), KEYS); List<Entry<Key,Value>> entries = new ArrayList<>(); Entry<Key,Value> entry = new SimpleImmutableEntry<Key,Value>(new Key(new byte[] {1}, new byte[] {2}, new byte[] {3}, "secret".getBytes(Utils.VISIBILITY_CHARSET), 0, false, false), new Value(new byte[] {4})); entries.add(encryptor.encrypt(entry)); EncryptedScannerIterator iterator = new EncryptedScannerIterator(entries.iterator(), encryptor, Collections.singletonList(new Range()), new TreeSet<Column>()); assertThat("next item is correct", iterator.next(), Matchers.equalTo(entry)); try { iterator.next(); fail("no items should be left"); } catch (NoSuchElementException e) { } } |
EncryptedScannerIterator implements ItemProcessingIterator<Entry<Key,Value>> { @Override public Entry<Key,Value> unprocessed() { if (next != null || unprocessedEntry == null) { throw new NoSuchElementException(); } return unprocessedEntry; } EncryptedScannerIterator(Iterator<Entry<Key,Value>> iterator, EntryEncryptor encryptor, List<Range> clientSideRanges,
SortedSet<Column> clientSideColumnFilters); @Override boolean hasNext(); @Override Entry<Key,Value> next(); @Override void remove(); @Override Entry<Key,Value> unprocessed(); } | @Test public void unprocessedTest() throws Exception { EntryEncryptor encryptor = new EntryEncryptor(getConfig("config.ini"), KEYS); List<Entry<Key,Value>> entries = new ArrayList<>(); Entry<Key,Value> entry = new SimpleImmutableEntry<Key,Value>(new Key(new byte[] {1}, new byte[] {2}, new byte[] {3}, "secret".getBytes(Utils.VISIBILITY_CHARSET), 0, false, false), new Value(new byte[] {4})); entries.add(encryptor.encrypt(entry)); EncryptedScannerIterator iterator = new EncryptedScannerIterator(entries.iterator(), encryptor, Collections.singletonList(new Range()), new TreeSet<Column>()); iterator.next(); assertThat("unprocessed item is correct", iterator.unprocessed(), Matchers.equalTo(entries.get(0))); } |
EncryptedScannerIterator implements ItemProcessingIterator<Entry<Key,Value>> { @Override public void remove() { throw new UnsupportedOperationException(); } EncryptedScannerIterator(Iterator<Entry<Key,Value>> iterator, EntryEncryptor encryptor, List<Range> clientSideRanges,
SortedSet<Column> clientSideColumnFilters); @Override boolean hasNext(); @Override Entry<Key,Value> next(); @Override void remove(); @Override Entry<Key,Value> unprocessed(); } | @Test public void removeException() throws Exception { EntryEncryptor encryptor = new EntryEncryptor(getConfig("config.ini"), KEYS); List<Entry<Key,Value>> entries = new ArrayList<>(); Entry<Key,Value> entry = new SimpleImmutableEntry<Key,Value>(new Key(new byte[] {1}, new byte[] {2}, new byte[] {3}, "secret".getBytes(Utils.VISIBILITY_CHARSET), 0, false, false), new Value(new byte[] {4})); entries.add(encryptor.encrypt(entry)); EncryptedScannerIterator iterator = new EncryptedScannerIterator(entries.iterator(), encryptor, Collections.singletonList(new Range()), new TreeSet<>()); try { iterator.remove(); fail("remove not supported"); } catch (UnsupportedOperationException e) { } } |
SignedScanner implements Scanner { @Override public void fetchColumn(Column column) { valueScanner.fetchColumn(column); if (signatureScanner != null) { signatureScanner.fetchColumn(column); } } SignedScanner(Connector connector, String tableName, Authorizations authorizations, SignatureConfig signatureConfig, SignatureKeyContainer keys); @Override ItemProcessingIterator<Entry<Key,Value>> iterator(); @Override void addScanIterator(IteratorSetting cfg); @Override void clearColumns(); @Override void clearScanIterators(); @Override void close(); @Override void fetchColumn(Column column); @Override void fetchColumn(Text colFam, Text colQual); @Override void fetchColumnFamily(Text col); @Override Authorizations getAuthorizations(); @Override void setSamplerConfiguration(SamplerConfiguration samplerConfiguration); @Override SamplerConfiguration getSamplerConfiguration(); @Override void clearSamplerConfiguration(); @Override void setBatchTimeout(long l, TimeUnit timeUnit); @Override long getBatchTimeout(TimeUnit timeUnit); @Override void setClassLoaderContext(String s); @Override void clearClassLoaderContext(); @Override String getClassLoaderContext(); @Override long getTimeout(TimeUnit timeUnit); @Override void removeScanIterator(String iteratorName); @Override void updateScanIteratorOption(String iteratorName, String key, String value); @Override void setTimeout(long timeout, TimeUnit timeUnit); @Override void disableIsolation(); @Override void enableIsolation(); @Override int getBatchSize(); @Override Range getRange(); @Override long getReadaheadThreshold(); @Override @SuppressWarnings("deprecation") int getTimeOut(); @Override void setBatchSize(int size); @Override void setRange(Range range); @Override void setReadaheadThreshold(long batches); @Override @SuppressWarnings("deprecation") void setTimeOut(int timeOut); } | @Test public void fetchColumnTest() throws Exception { Column column = new Column(new Text(new byte[] {1}), new Text(new byte[] {2})); when(mockConnector.createScanner(TEST_TABLE, authorizations)).thenReturn(mockScanner); new SignedScanner(mockConnector, TEST_TABLE, authorizations, getConfig("config1.ini"), aliceKeyContainers.get(ValueSigner.RSA_PSS)).fetchColumn(column); verify(mockScanner).fetchColumn(column); }
@Test public void fetchColumnExternalTest() throws Exception { Column column = new Column(new Text(new byte[] {1}), new Text(new byte[] {2})); when(mockConnector.createScanner(TEST_TABLE, authorizations)).thenReturn(mockScanner); when(mockConnector.createScanner(SIG_TABLE, authorizations)).thenReturn(mockSignatureScanner); new SignedScanner(mockConnector, TEST_TABLE, authorizations, getConfig("config3.ini"), aliceKeyContainers.get(ValueSigner.RSA_PSS)).fetchColumn(column); verify(mockScanner).fetchColumn(column); verify(mockSignatureScanner).fetchColumn(column); }
@Test public void fetchColumn2Test() throws Exception { Text colF = new Text(new byte[] {1}), colQ = new Text(new byte[] {2}); when(mockConnector.createScanner(TEST_TABLE, authorizations)).thenReturn(mockScanner); new SignedScanner(mockConnector, TEST_TABLE, authorizations, getConfig("config1.ini"), aliceKeyContainers.get(ValueSigner.RSA_PSS)).fetchColumn(colF, colQ); verify(mockScanner).fetchColumn(colF, colQ); }
@Test public void fetchColumn2ExternalTest() throws Exception { Text colF = new Text(new byte[] {1}), colQ = new Text(new byte[] {2}); when(mockConnector.createScanner(TEST_TABLE, authorizations)).thenReturn(mockScanner); when(mockConnector.createScanner(SIG_TABLE, authorizations)).thenReturn(mockSignatureScanner); new SignedScanner(mockConnector, TEST_TABLE, authorizations, getConfig("config3.ini"), aliceKeyContainers.get(ValueSigner.RSA_PSS)).fetchColumn(colF, colQ); verify(mockScanner).fetchColumn(colF, colQ); verify(mockSignatureScanner).fetchColumn(colF, colQ); } |
EntryEncryptor { public boolean canBeDeleteServerSide() { for (EntryField field : FieldEncryptorConfig.KEY_DESTINATION_FIELDS) { if (destinationMap.containsKey(field) && !destinationMap.get(field).canBeFilteredServerSide(FieldEncryptorConfig.KEY_SOURCE_FIELDS)) { return false; } } return true; } EntryEncryptor(EncryptionConfig config, EncryptionKeyContainer keys); Entry<Key,Value> encrypt(Entry<Key,Value> entry); Entry<Key,Value> decrypt(Entry<Key,Value> entry); boolean canBeDeleteServerSide(); Collection<Key> getDeleteKeys(Key key); ColumnFilterResult getColumnFamilyFilter(Text col); ColumnFilterResult getColumnFilter(Text colFam, Text colQual); boolean transformRange(Range range, Collection<Range> serverSideRanges); } | @Test public void canBeDeletedServerSideTest() throws Exception { assertThat("non-encrypted key can be updated", getEncryptor("encrypt-value.ini").canBeDeleteServerSide(), is(true)); assertThat("non-deterministically encrypted key cannot be updated", getEncryptor("encrypt-entry.ini").canBeDeleteServerSide(), is(false)); assertThat("searchable key can be updated", getEncryptor("searchable.ini").canBeDeleteServerSide(), is(true)); } |
EntryEncryptor { public Collection<Key> getDeleteKeys(Key key) { checkArgument(canBeDeleteServerSide(), "canBeDeleteServerSide is false"); checkArgument(key != null, "key is null"); MutableEntry searchKey = new MutableEntry(key); Collection<byte[]> rowValues = getDeleteValues(searchKey, EntryField.ROW); Collection<byte[]> colFValues = getDeleteValues(searchKey, EntryField.COLUMN_FAMILY); Collection<byte[]> colQValues = getDeleteValues(searchKey, EntryField.COLUMN_QUALIFIER); return rowValues .stream() .flatMap( r -> colFValues.stream().flatMap( cf -> colQValues.stream().map(cq -> new Key(r, cf, cq, key.getColumnVisibilityData().getBackingArray(), key.getTimestamp(), true, true)))) .collect(Collectors.toList()); } EntryEncryptor(EncryptionConfig config, EncryptionKeyContainer keys); Entry<Key,Value> encrypt(Entry<Key,Value> entry); Entry<Key,Value> decrypt(Entry<Key,Value> entry); boolean canBeDeleteServerSide(); Collection<Key> getDeleteKeys(Key key); ColumnFilterResult getColumnFamilyFilter(Text col); ColumnFilterResult getColumnFilter(Text colFam, Text colQual); boolean transformRange(Range range, Collection<Range> serverSideRanges); } | @Test public void getDeleteKeysTest() throws Exception { EntryEncryptor encryptor = getEncryptor("deterministic.ini"); MutableEntry searchKey = new MutableEntry(new Key(new byte[] {1}, new byte[] {2}, new byte[] {3}, "secret".getBytes(VISIBILITY_CHARSET), (long) 5, false)); Collection<Key> keys = encryptor.getDeleteKeys(searchKey.toKey()); assertThat("has correct number of delete keys", keys, hasSize(2)); for (Key deleteKey : keys) { MutableEntry key = new MutableEntry(deleteKey); assertThat("row is encrypted", key.row, not(equalTo(searchKey.row))); assertThat("colF is zeroes", key.colF, equalTo(EMPTY)); assertThat("colQ is plaintext", key.colQ, equalTo(searchKey.colQ)); assertThat("colQ is plaintext", key.colVis, equalTo(searchKey.colVis)); assertThat("colQ is plaintext", key.timestamp, equalTo(searchKey.timestamp)); assertThat("delete is true", key.delete, is(true)); } }
@Test public void getDeleteKeysExceptionTest() throws Exception { EntryEncryptor encryptor = getEncryptor("encrypt-entry.ini"); try { encryptor.getDeleteKeys(null); fail("cannot call delete keys with a null value"); } catch (IllegalArgumentException e) { } encryptor = getEncryptor("encrypt-entry.ini"); try { encryptor.getDeleteKeys(new Key()); fail("cannot call delete keys when the encryptor does not allow server side delete"); } catch (IllegalArgumentException e) { } } |
EntryEncryptor { public ColumnFilterResult getColumnFamilyFilter(Text col) { checkArgument(col != null, "col is null"); MutableEntry key = new MutableEntry(); key.colF = TextUtil.getBytes(col); return getColumnFamilyFilter(key, ImmutableSet.of(EntryField.COLUMN_FAMILY)); } EntryEncryptor(EncryptionConfig config, EncryptionKeyContainer keys); Entry<Key,Value> encrypt(Entry<Key,Value> entry); Entry<Key,Value> decrypt(Entry<Key,Value> entry); boolean canBeDeleteServerSide(); Collection<Key> getDeleteKeys(Key key); ColumnFilterResult getColumnFamilyFilter(Text col); ColumnFilterResult getColumnFilter(Text colFam, Text colQual); boolean transformRange(Range range, Collection<Range> serverSideRanges); } | @Test public void getColumnFamilyFilterTest() throws Exception { byte[] columnFamily = new byte[] {2}; ColumnFilterResult result = getEncryptor("encrypt-value.ini").getColumnFamilyFilter(new Text(columnFamily)); assertThat("unencrypted column is searchable server side", result.serverSideFilters, hasSize(1)); assertThat("unencrypted column is searchable server side", result.serverSideFilters, containsInAnyOrder(new Column(columnFamily, null, null))); assertThat("unencrypted column does not need client-side search", result.needsClientSideFiltering, is(false)); result = getEncryptor("zeroed3.ini").getColumnFamilyFilter(new Text(columnFamily)); assertThat("zeroed column is searchable server side", result.serverSideFilters, hasSize(1)); assertThat("zeroed column is searchable server side", result.serverSideFilters, containsInAnyOrder(new Column(EMPTY, null, null))); assertThat("zeroed column needs client-side search", result.needsClientSideFiltering, is(true)); result = getEncryptor("encrypt-entry.ini").getColumnFamilyFilter(new Text(columnFamily)); assertThat("non-deterministically encrypted column is not searchable server side", result.serverSideFilters, hasSize(0)); assertThat("non-deterministically encrypted column needs client-side search", result.needsClientSideFiltering, is(true)); Entry<Key,Value> entry = new SimpleImmutableEntry<>(new Key(EMPTY, columnFamily, EMPTY, EMPTY, (long) 0, false), new Value(EMPTY)); MutableEntry encrypted1 = new MutableEntry(getEncryptor("filterable.ini", new MockEncryptionKeyContainer(Pair.of("searchable_colFamily", 1), Pair.of("searchable_colQualifier", 1))).encrypt(entry)); MutableEntry encrypted2 = new MutableEntry(getEncryptor("filterable.ini", new MockEncryptionKeyContainer(Pair.of("searchable_colFamily", 2), Pair.of("searchable_colQualifier", 2))).encrypt(entry)); result = getEncryptor("filterable.ini").getColumnFamilyFilter(new Text(columnFamily)); assertThat("deterministically encrypted column is searchable server side", result.serverSideFilters, hasSize(2)); assertThat("deterministically encrypted column is searchable server side", result.serverSideFilters, containsInAnyOrder(new Column(encrypted1.colF, null, null), new Column(encrypted2.colF, null, null))); assertThat("deterministically column does not needs client-side search", result.needsClientSideFiltering, is(false)); }
@Test public void getColumnFamilyFilterExceptionTest() throws Exception { EntryEncryptor encryptor = getEncryptor("encrypt-entry.ini"); try { encryptor.getColumnFamilyFilter(null); fail("cannot call filter with a null value"); } catch (IllegalArgumentException e) { } } |
EntryEncryptor { public ColumnFilterResult getColumnFilter(Text colFam, Text colQual) { checkArgument(colFam != null, "colFam is null"); checkArgument(colQual != null, "colQual is null"); Set<EntryField> fields = ImmutableSet.of(EntryField.COLUMN_FAMILY, EntryField.COLUMN_QUALIFIER); MutableEntry key = new MutableEntry(); key.colF = TextUtil.getBytes(colFam); key.colQ = TextUtil.getBytes(colQual); ColumnFilterResult familySearch = getColumnFamilyFilter(key, fields); if (!destinationMap.containsKey(EntryField.COLUMN_QUALIFIER)) { if (!sources.contains(EntryField.COLUMN_QUALIFIER)) { return new ColumnFilterResult(familySearch.serverSideFilters.stream().map(f -> new Column(f.getColumnFamily(), key.colQ, null)) .collect(Collectors.toList()), familySearch.needsClientSideFiltering); } else { boolean serverSideOnly = destinationMap.containsKey(EntryField.COLUMN_FAMILY) && destinationMap.get(EntryField.COLUMN_FAMILY).canSearchFor(ImmutableSet.of(EntryField.COLUMN_FAMILY, EntryField.COLUMN_QUALIFIER)); return new ColumnFilterResult(familySearch.serverSideFilters.stream().map(f -> new Column(f.getColumnFamily(), EMPTY, null)) .collect(Collectors.toList()), !serverSideOnly); } } else { FieldEncryptor encryptor = destinationMap.get(EntryField.COLUMN_QUALIFIER); if (encryptor.canBeFilteredServerSide(fields)) { boolean serverSideOnly = !familySearch.needsClientSideFiltering || (!destinationMap.containsKey(EntryField.COLUMN_FAMILY) && sources.contains(EntryField.COLUMN_FAMILY) && encryptor.canSearchFor(ImmutableSet.of( EntryField.COLUMN_FAMILY, EntryField.COLUMN_QUALIFIER))); return new ColumnFilterResult(familySearch.serverSideFilters.stream() .flatMap(f -> encryptor.getServerSideFilterValues(key).stream().map(v -> new Column(f.getColumnFamily(), v, null))).collect(Collectors.toList()), !serverSideOnly); } else { boolean serverSideOnly = destinationMap.containsKey(EntryField.COLUMN_FAMILY) && destinationMap.get(EntryField.COLUMN_FAMILY).canSearchFor(ImmutableSet.of(EntryField.COLUMN_FAMILY, EntryField.COLUMN_QUALIFIER)); return new ColumnFilterResult(familySearch.serverSideFilters.stream().map(f -> new Column(f.getColumnFamily(), null, null)) .collect(Collectors.toList()), !serverSideOnly); } } } EntryEncryptor(EncryptionConfig config, EncryptionKeyContainer keys); Entry<Key,Value> encrypt(Entry<Key,Value> entry); Entry<Key,Value> decrypt(Entry<Key,Value> entry); boolean canBeDeleteServerSide(); Collection<Key> getDeleteKeys(Key key); ColumnFilterResult getColumnFamilyFilter(Text col); ColumnFilterResult getColumnFilter(Text colFam, Text colQual); boolean transformRange(Range range, Collection<Range> serverSideRanges); } | @Test public void getColumnFilterTest() throws Exception { byte[] columnFamily = new byte[] {2}; byte[] columnQualifier = new byte[] {3}; ColumnFilterResult result = getEncryptor("encrypt-value.ini").getColumnFilter(new Text(columnFamily), new Text(columnQualifier)); assertThat("unencrypted column is searchable server side", result.serverSideFilters, hasSize(1)); assertThat("unencrypted column is searchable server side", result.serverSideFilters, containsInAnyOrder(new Column(columnFamily, columnQualifier, null))); assertThat("unencrypted column does not need client-side search", result.needsClientSideFiltering, is(false)); result = getEncryptor("zeroed1.ini").getColumnFilter(new Text(columnFamily), new Text(columnQualifier)); assertThat("zeroed column is searchable server side", result.serverSideFilters, hasSize(2)); assertThat("zeroed column needs client-side search", result.needsClientSideFiltering, is(false)); result = getEncryptor("zeroed2.ini").getColumnFilter(new Text(columnFamily), new Text(columnQualifier)); assertThat("zeroed column is searchable server side", result.serverSideFilters, hasSize(2)); assertThat("zeroed column needs client-side search", result.needsClientSideFiltering, is(true)); result = getEncryptor("zeroed3.ini").getColumnFilter(new Text(columnFamily), new Text(columnQualifier)); assertThat("zeroed column is searchable server side", result.serverSideFilters, hasSize(2)); assertThat("zeroed column needs client-side search", result.needsClientSideFiltering, is(false)); result = getEncryptor("zeroed4.ini").getColumnFilter(new Text(columnFamily), new Text(columnQualifier)); assertThat("zeroed column is searchable server side", result.serverSideFilters, hasSize(2)); assertThat("zeroed column needs client-side search", result.needsClientSideFiltering, is(true)); result = getEncryptor("zeroed5.ini").getColumnFilter(new Text(columnFamily), new Text(columnQualifier)); assertThat("zeroed column is searchable server side", result.serverSideFilters, hasSize(1)); assertThat("zeroed column needs client-side search", result.needsClientSideFiltering, is(true)); result = getEncryptor("encrypt-entry.ini").getColumnFilter(new Text(columnFamily), new Text(columnQualifier)); assertThat("non-deterministically encrypted column is not searchable server side", result.serverSideFilters, hasSize(0)); assertThat("non-deterministically encrypted column needs client-side search", result.needsClientSideFiltering, is(true)); result = getEncryptor("filterable2.ini").getColumnFilter(new Text(columnFamily), new Text(columnQualifier)); assertThat("non-deterministically encrypted column is not searchable server side", result.serverSideFilters, hasSize(2)); assertThat("non-deterministically encrypted column needs client-side search", result.needsClientSideFiltering, is(false)); result = getEncryptor("filterable.ini").getColumnFilter(new Text(columnFamily), new Text(columnQualifier)); assertThat("deterministically encrypted column is searchable server side", result.serverSideFilters, hasSize(4)); assertThat("deterministically column does not needs client-side search", result.needsClientSideFiltering, is(false)); result = getEncryptor("filterable3.ini").getColumnFilter(new Text(columnFamily), new Text(columnQualifier)); assertThat("deterministically encrypted column is searchable server side", result.serverSideFilters, hasSize(2)); assertThat("deterministically column does not needs client-side search", result.needsClientSideFiltering, is(false)); result = getEncryptor("filterable4.ini").getColumnFilter(new Text(columnFamily), new Text(columnQualifier)); assertThat("deterministically encrypted column is searchable server side", result.serverSideFilters, hasSize(2)); assertThat("deterministically column does not needs client-side search", result.needsClientSideFiltering, is(true)); result = getEncryptor("filterable5.ini").getColumnFilter(new Text(columnFamily), new Text(columnQualifier)); assertThat("deterministically encrypted column is searchable server side", result.serverSideFilters, hasSize(0)); assertThat("deterministically column does not needs client-side search", result.needsClientSideFiltering, is(true)); }
@Test public void getColumnFilterExceptionTest() throws Exception { EntryEncryptor encryptor = getEncryptor("encrypt-entry.ini"); try { encryptor.getColumnFilter(null, new Text()); fail("cannot call filter with a null value"); } catch (IllegalArgumentException e) { } try { encryptor.getColumnFilter(new Text(), null); fail("cannot call filter with a null value"); } catch (IllegalArgumentException e) { } } |
EntryEncryptor { public boolean transformRange(Range range, Collection<Range> serverSideRanges) { checkArgument(range != null, "range is null"); checkArgument(serverSideRanges != null, "serverSideRanges is null"); if (destinationMap.size() == 1 && destinationMap.containsKey(EntryField.VALUE)) { serverSideRanges.add(range); return false; } if (range.isInfiniteStartKey() && range.isInfiniteStopKey()) { serverSideRanges.add(range); return false; } MutableEntry startKey = range.isInfiniteStartKey() ? new MutableEntry() : new MutableEntry(range.getStartKey()); MutableEntry endKey = range.isInfiniteStopKey() ? new MutableEntry() : new MutableEntry(range.getEndKey()); Set<EntryField> equalFields = new HashSet<>(); EntryField followingKey = null; if (!range.isInfiniteStartKey() && !range.isInfiniteStopKey()) { for (EntryField field : FieldEncryptorConfig.KEY_SOURCE_FIELDS) { byte[] start = startKey.getBytes(field); byte[] end = endKey.getBytes(field); if (Arrays.equals(start, end)) { equalFields.add(field); } else if (!range.isEndKeyInclusive() && range.getStartKey().followingKey(toPartialKey(field)).equals(range.getEndKey())) { followingKey = field; break; } } if (followingKey != null) { equalFields.add(followingKey); } } List<MutableEntry> startKeys = new ArrayList<>(), endKeys = new ArrayList<>(); startKeys.add(new MutableEntry()); endKeys.add(new MutableEntry()); PartialKey prefix = null; boolean prefixHasVariance = range.isInfiniteStartKey() || range.isInfiniteStopKey(); for (EntryField field : EntryField.values()) { if (field == EntryField.VALUE) { continue; } if (!destinationMap.containsKey(field)) { if (!sources.contains(field)) { if (range.isInfiniteStartKey()) { for (MutableEntry entry : endKeys) { entry.setBytes(field, endKey.getBytes(field)); } } else if (range.isInfiniteStopKey()) { for (MutableEntry entry : startKeys) { entry.setBytes(field, startKey.getBytes(field)); } } else { if (!equalFields.contains(field)) { prefixHasVariance = true; } Iterator<MutableEntry> startKeyIterator = startKeys.iterator(); Iterator<MutableEntry> endKeyIterator = endKeys.iterator(); while (startKeyIterator.hasNext()) { switch (field) { case TIMESTAMP: startKeyIterator.next().timestamp = startKey.timestamp; endKeyIterator.next().timestamp = endKey.timestamp; break; case DELETE: startKeyIterator.next().delete = startKey.delete; endKeyIterator.next().delete = endKey.delete; break; default: startKeyIterator.next().setBytes(field, startKey.getBytes(field)); endKeyIterator.next().setBytes(field, endKey.getBytes(field)); } } } } } else { if (prefixHasVariance || !destinationMap.get(field).canBeFilteredServerSide(equalFields)) { appendServerSideRanges(serverSideRanges, range, startKeys, endKeys, prefix); return true; } else { startKeys = getServerSideFilterKeys(startKeys, field, startKey, false); endKeys = getServerSideFilterKeys(endKeys, field, startKey, field == followingKey); } } prefix = toPartialKey(field); } Iterator<MutableEntry> startKeyIterator = startKeys.iterator(); Iterator<MutableEntry> endKeyIterator = endKeys.iterator(); while (startKeyIterator.hasNext()) { serverSideRanges.add(new Range(startKeyIterator.next().toKey(), range.isStartKeyInclusive(), endKeyIterator.next().toKey(), range.isEndKeyInclusive())); } return false; } EntryEncryptor(EncryptionConfig config, EncryptionKeyContainer keys); Entry<Key,Value> encrypt(Entry<Key,Value> entry); Entry<Key,Value> decrypt(Entry<Key,Value> entry); boolean canBeDeleteServerSide(); Collection<Key> getDeleteKeys(Key key); ColumnFilterResult getColumnFamilyFilter(Text col); ColumnFilterResult getColumnFilter(Text colFam, Text colQual); boolean transformRange(Range range, Collection<Range> serverSideRanges); } | @Test public void transformRangeTest() throws Exception { Range range = new Range("A"); Collection<Range> serverSideRanges = new ArrayList<>(); boolean result = getEncryptor("encrypt-value.ini", keys).transformRange(range, serverSideRanges); assertThat("should be filtered server side", serverSideRanges, hasSize(1)); assertThat("should be filtered server side", serverSideRanges, contains(range)); assertThat("should not be filtered client side", result, is(false)); range = new Range("A"); serverSideRanges.clear(); result = getEncryptor("encrypt-entry.ini", keys).transformRange(range, serverSideRanges); assertThat("should not be filtered server side", serverSideRanges, hasSize(1)); assertThat("should not be filtered server side", serverSideRanges, contains(new Range())); assertThat("should be filtered client side", result, is(true)); range = new Range(); serverSideRanges.clear(); result = getEncryptor("searchable.ini", keys).transformRange(range, serverSideRanges); assertThat("should be filtered server side", serverSideRanges, hasSize(1)); assertThat("should be filtered server side", serverSideRanges, contains(range)); assertThat("should not be filtered client side", result, is(false)); range = new Range(new Key(new byte[] {1}, new byte[] {2}, new byte[] {3}, "secret".getBytes(VISIBILITY_CHARSET), 0, false), new Key(new byte[] {1}, new byte[] {2}, new byte[] {3}, "secret".getBytes(VISIBILITY_CHARSET), 0, false)); serverSideRanges.clear(); result = getEncryptor("searchable.ini", keys).transformRange(range, serverSideRanges); assertThat("should be filtered server side", serverSideRanges, hasSize(8)); assertThat("should not be filtered client side", result, is(false)); range = new Range(new Key(new byte[] {1}, new byte[] {2}, new byte[] {3}, "secret".getBytes(VISIBILITY_CHARSET), 1, false), new Key(new byte[] {1}, new byte[] {2}, new byte[] {3}, "secret".getBytes(VISIBILITY_CHARSET), 0, true)); serverSideRanges.clear(); result = getEncryptor("searchable.ini", keys).transformRange(range, serverSideRanges); assertThat("should be filtered server side", serverSideRanges, hasSize(8)); assertThat("should not be filtered client side", result, is(false)); range = new Range(new Key(new byte[] {1}, new byte[] {2}, new byte[] {3}, "secret".getBytes(VISIBILITY_CHARSET), 0, false), new Key(new byte[] {1}, new byte[] {4}, new byte[] {3}, "secret".getBytes(VISIBILITY_CHARSET), 0, false)); serverSideRanges.clear(); result = getEncryptor("searchable.ini", keys).transformRange(range, serverSideRanges); assertThat("should be filtered server side", serverSideRanges, hasSize(2)); assertThat("should not be filtered client side", result, is(true)); range = new Range(new Key(new byte[] {1}, new byte[] {2}, new byte[] {3}, "secret".getBytes(VISIBILITY_CHARSET), 0, false), new Key(new byte[] {1}, new byte[] {2}, new byte[] {4}, "secret".getBytes(VISIBILITY_CHARSET), 0, false)); serverSideRanges.clear(); result = getEncryptor("searchable.ini", keys).transformRange(range, serverSideRanges); assertThat("should be filtered server side", serverSideRanges, hasSize(4)); assertThat("should not be filtered client side", result, is(true)); range = new Range(null, new Key(new byte[] {1}, new byte[] {2}, new byte[] {4}, "secret".getBytes(VISIBILITY_CHARSET), 0, false)); serverSideRanges.clear(); result = getEncryptor("searchable2.ini", keys).transformRange(range, serverSideRanges); assertThat("should be filtered server side", serverSideRanges, hasSize(1)); assertThat("should not be filtered client side", result, is(true)); range = new Range(new Key(new byte[] {1}, new byte[] {2}, new byte[] {4}, "secret".getBytes(VISIBILITY_CHARSET), 0, false), null); serverSideRanges.clear(); result = getEncryptor("searchable2.ini", keys).transformRange(range, serverSideRanges); assertThat("should be filtered server side", serverSideRanges, hasSize(1)); assertThat("should not be filtered client side", result, is(true)); range = new Range(new Key(new byte[] {1}, new byte[] {2}, new byte[] {3}, "secret".getBytes(VISIBILITY_CHARSET), 0, false), new Key(new byte[] {1}, new byte[] {2}, new byte[] {3}, "secret".getBytes(VISIBILITY_CHARSET), 0, false)); serverSideRanges.clear(); result = getEncryptor("searchable3.ini", keys).transformRange(range, serverSideRanges); assertThat("should be filtered server side", serverSideRanges, hasSize(2)); assertThat("should not be filtered client side", result, is(true)); }
@Test public void transformRangeExceptionTest() throws Exception { Range range = new Range(); Collection<Range> serverSideRanges = new ArrayList<>(); EntryEncryptor encryptor = getEncryptor("searchable.ini"); try { encryptor.transformRange(null, serverSideRanges); fail("cannot call with a null range"); } catch (IllegalArgumentException e) { } try { encryptor.transformRange(range, null); fail("cannot call with a null serverSideRanges"); } catch (IllegalArgumentException e) { } } |
FieldEncryptorConfig { void write(Ini configIni) { Section section = configIni.add(destination.toString()); section.put("cipher", valueEncryptor.toString()); section.put("provider", provider); section.put("useVisibility", encryptUsingVisibility); section.put("keyId", keyId); section.put("keyLength", Integer.toString(keyLength)); section.put("sources", StringUtils.join(sources, ',')); } FieldEncryptorConfig(ValueEncryptor valueEncryptor, String provider, boolean encryptUsingVisibility, String keyId, int keyLength,
EntryField destination, SortedSet<EntryField> sources); } | @Test public void writeTest() throws IOException { FieldEncryptorConfig config = new FieldEncryptorConfigBuilder().setValueEncryptor(ValueEncryptor.AES_CBC).setProvider("SunJCE").setKeyLength(24) .setEncryptUsingVisibility(false).setKeyId("keyId").setDestination(EntryField.COLUMN_FAMILY) .setSources(ImmutableSortedSet.of(EntryField.ROW, EntryField.COLUMN_QUALIFIER, EntryField.COLUMN_FAMILY)).build(); Ini ini = new Ini(); config.write(ini); assertThat("the configuration is properly written to an ini", ini, is(Matchers.equalTo(getIni("config1.ini")))); config = new FieldEncryptorConfigBuilder().setValueEncryptor(ValueEncryptor.AES_CBC).setProvider("BC").setKeyLength(16).setEncryptUsingVisibility(true) .setKeyId("AES_CBC").setDestination(EntryField.ROW).setSources(ImmutableSortedSet.of(EntryField.ROW)).build(); ini = new Ini(); config.write(ini); assertThat("empty fields are not included in the output ini", ini, is(Matchers.equalTo(getIni("config2.ini")))); }
@Test public void writeReadTest() { FieldEncryptorConfig config = new FieldEncryptorConfigBuilder().setValueEncryptor(ValueEncryptor.AES_CBC).setProvider("BC").setKeyLength(32) .setEncryptUsingVisibility(false).setKeyId("keyId").setDestination(EntryField.COLUMN_FAMILY) .setSources(ImmutableSortedSet.of(EntryField.ROW, EntryField.COLUMN_FAMILY, EntryField.COLUMN_QUALIFIER)).build(); Ini ini = new Ini(); config.write(ini); FieldEncryptorConfig config2 = new FieldEncryptorConfigBuilder().readFromIni(ini.values().iterator().next()).build(); assertThat("writing then reading the config should produce an equivalent configuration", config2, hasSameFieldsAs(config)); } |
FieldEncryptor { void encrypt(MutableEntry entry, MutableEntry result, ColumnVisibility columnVisibility) throws IOException { byte[] data = concatData(entry); ByteArrayOutputStream ciphertextStream = new ByteArrayOutputStream(); DataOutput ciphertextOut = new DataOutputStream(ciphertextStream); byte[] key = getKey(columnVisibility, ciphertextOut); ciphertextOut.write(encryptor.encrypt(key, data)); byte[] ciphertext = ciphertextStream.toByteArray(); result.setBytes(config.destination, ciphertext); } FieldEncryptor(FieldEncryptorConfig config, EncryptionKeyContainer keys); } | @Test public void encryptTest() throws Exception { MutableEntry original = new MutableEntry(new SimpleImmutableEntry<>(new Key(new byte[] {1}, new byte[] {2}, new byte[] {3}, "secret".getBytes(VISIBILITY_CHARSET), (long) 5, false), new Value(new byte[] {6}))); MutableEntry empty = new MutableEntry(); ColumnVisibility visibility = new ColumnVisibility("secret"); MutableEntry encrypted = new MutableEntry(); FieldEncryptor encryptor = getEncryptor("gcm.ini"); encryptor.encrypt(original, encrypted, visibility); assertThat("row was not encrypted and should not be set", encrypted.row, is(empty.row)); assertThat("colFamily was not encrypted and should not be set", encrypted.colF, is(empty.colF)); assertThat("colQualifier was not encrypted and should not be set", encrypted.colQ, is(empty.colQ)); assertThat("colVisibility was not encrypted and should not be set", encrypted.colVis, is(empty.colVis)); assertThat("timestamp was not encrypted and should not be set", encrypted.timestamp, is(empty.timestamp)); assertThat("delete was not encrypted and should not be set", encrypted.delete, is(empty.delete)); assertThat("value was encrypted and should be different", encrypted.value, is(not(original.value))); encrypted = new MutableEntry(); encryptor = getEncryptor("gcmCEABAC.ini"); encryptor.encrypt(original, encrypted, visibility); assertThat("row was not encrypted and should not be set", encrypted.row, is(empty.row)); assertThat("colFamily was not encrypted and should not be set", encrypted.colF, is(empty.colF)); assertThat("colQualifier was not encrypted and should not be set", encrypted.colQ, is(empty.colQ)); assertThat("colVisibility was not encrypted and should not be set", encrypted.colVis, is(empty.colVis)); assertThat("timestamp was not encrypted and should not be set", encrypted.timestamp, is(empty.timestamp)); assertThat("delete was not encrypted and should not be set", encrypted.delete, is(empty.delete)); assertThat("value was encrypted and should be different", encrypted.value, is(not(original.value))); encrypted = new MutableEntry(); encryptor = getEncryptor("siv.ini"); encryptor.encrypt(original, encrypted, visibility); assertThat("row was encrypted and should be different", encrypted.row, is(not(original.row))); assertThat("colFamily was not encrypted and should not be set", encrypted.colF, is(empty.colF)); assertThat("colQualifier was not encrypted and should not be set", encrypted.colQ, is(empty.colQ)); assertThat("colVisibility was not encrypted and should not be set", encrypted.colVis, is(empty.colVis)); assertThat("timestamp was not encrypted and should not be set", encrypted.timestamp, is(empty.timestamp)); assertThat("delete was not encrypted and should not be set", encrypted.delete, is(empty.delete)); assertThat("value was not encrypted and should not be set", encrypted.value, is(empty.value)); encrypted = new MutableEntry(); encryptor = getEncryptor("all.ini"); encryptor.encrypt(original, encrypted, visibility); assertThat("row was encrypted and should not be different", encrypted.row, is(not(original.row))); assertThat("colFamily was encrypted and should not be different", encrypted.colF, is(not(original.colF))); assertThat("colQualifier was encrypted and should not be different", encrypted.colQ, is(not(original.colQ))); assertThat("colVisibility was encrypted and should be different", encrypted.colVis, is(not(original.colVis))); assertThat("timestamp was encrypted and should not be different", encrypted.timestamp, is(empty.timestamp)); assertThat("delete was encrypted, but and should not be different", encrypted.delete, is(empty.delete)); assertThat("value was encrypted and should not be different", encrypted.value, is(not(original.value))); }
@Test public void encryptedFieldStructureTest() throws Exception { MutableEntry original1 = new MutableEntry(new SimpleImmutableEntry<>(new Key(new byte[] {1}, new byte[] {2}, new byte[] {3}, "secret".getBytes(VISIBILITY_CHARSET), (long) 5, false), new Value(new byte[] {6, 7, 8}))); MutableEntry original2 = new MutableEntry(new SimpleImmutableEntry<>(new Key(new byte[] {9}, new byte[] {10, 11}, new byte[] {12, 13, 14}, "abcde".getBytes(VISIBILITY_CHARSET), (long) 15, true), new Value(new byte[] {16, 17}))); ColumnVisibility visibility = new ColumnVisibility("secret"); MutableEntry encrypted = new MutableEntry(); FieldEncryptor encryptor = getEncryptor("identity1.ini"); IdentityEncryptor.replaceValueEncryptorWithIdentityFunction(encryptor); encryptor.encrypt(original1, encrypted, visibility); assertThat("encrypted structure is (key version, length, data)", encrypted.value, is(new byte[] {1, 3, 6, 7, 8})); encryptor.encrypt(original2, encrypted, visibility); assertThat("encrypted structure is (key version, length, data)", encrypted.value, is(new byte[] {1, 2, 16, 17})); encrypted = new MutableEntry(); encryptor = getEncryptor("identity2.ini"); IdentityEncryptor.replaceValueEncryptorWithIdentityFunction(encryptor); encryptor.encrypt(original1, encrypted, visibility); assertThat("encrypted structure is (key version, length, data)", encrypted.value, is(new byte[] {2, 3, 6, 7, 8})); encrypted = new MutableEntry(); encryptor = getEncryptor("identityAll.ini"); IdentityEncryptor.replaceValueEncryptorWithIdentityFunction(encryptor); encryptor.encrypt(original1, encrypted, visibility); assertThat("encrypted structure is (key version, foreach field [length, data])", encrypted.row, is(new byte[] {2, 1, 1, 1, 2, 1, 3, 6, 115, 101, 99, 114, 101, 116})); encryptor.encrypt(original2, encrypted, visibility); assertThat("encrypted structure is (key version, foreach field [length, data])", encrypted.row, is(new byte[] {2, 1, 9, 2, 10, 11, 3, 12, 13, 14, 5, 97, 98, 99, 100, 101})); } |
FieldEncryptor { boolean canBeFilteredServerSide(Collection<EntryField> availableSources) { return config.valueEncryptor.isDeterministic() && availableSources.containsAll(config.sources); } FieldEncryptor(FieldEncryptorConfig config, EncryptionKeyContainer keys); } | @Test public void canBeFilteredServerSideTest() throws Exception { assertThat("non-deterministic algorithms can't be filtered server side", getEncryptor("gcm.ini").canBeFilteredServerSide(ImmutableSet.of(EntryField.ROW)), is(false)); assertThat("Visibility can't be filtered server side", getEncryptor("gcmCEABAC.ini").canBeFilteredServerSide(ImmutableSet.of(EntryField.ROW)), is(false)); assertThat("appropriate columns must be available", getEncryptor("siv.ini").canBeFilteredServerSide(ImmutableSet.of(EntryField.COLUMN_FAMILY)), is(false)); assertThat("deterministic encryption with correct fields should work", getEncryptor("siv.ini").canBeFilteredServerSide(ImmutableSet.of(EntryField.ROW)), is(true)); } |
FieldEncryptor { boolean canSearchFor(Set<EntryField> fields) { return config.valueEncryptor.isDeterministic() && fields.equals(config.sources); } FieldEncryptor(FieldEncryptorConfig config, EncryptionKeyContainer keys); } | @Test public void canSearchForTest() throws Exception { assertThat("non-deterministic algorithms can't be searched server side", getEncryptor("gcm.ini").canSearchFor(ImmutableSet.of(EntryField.ROW)), is(false)); assertThat("Visibility can't be filtered server side", getEncryptor("gcmCEABAC.ini").canSearchFor(ImmutableSet.of(EntryField.ROW)), is(false)); assertThat("appropriate columns must be available", getEncryptor("siv.ini").canSearchFor(ImmutableSet.of(EntryField.ROW, EntryField.COLUMN_FAMILY)), is(false)); assertThat("deterministic encryption with correct fields should work", getEncryptor("siv.ini").canSearchFor(ImmutableSet.of(EntryField.ROW)), is(true)); } |
FieldEncryptor { List<byte[]> getServerSideFilterValues(MutableEntry key) { return getServerSideFilterValues(key, false); } FieldEncryptor(FieldEncryptorConfig config, EncryptionKeyContainer keys); } | @Test public void getServerSideFilterValuesTest() throws Exception { MutableEntry original = new MutableEntry(new SimpleImmutableEntry<>(new Key(new byte[] {1}, new byte[] {2}, new byte[] {3}, "secret".getBytes(VISIBILITY_CHARSET), (long) 5, false), new Value(new byte[] {6}))); ColumnVisibility visibility = new ColumnVisibility("secret"); MutableEntry encryptedV1 = new MutableEntry(); getEncryptor("siv.ini", new MockEncryptionKeyContainer(Pair.of("SIV", 1))).encrypt(original, encryptedV1, visibility); MutableEntry encryptedV2 = new MutableEntry(); getEncryptor("siv.ini", new MockEncryptionKeyContainer(Pair.of("SIV", 2))).encrypt(original, encryptedV2, visibility); List<byte[]> searchKeys = getEncryptor("siv.ini", new MockEncryptionKeyContainer(Pair.of("SIV", 2))).getServerSideFilterValues(original); assertThat("encrypted values for each version available", searchKeys, containsInAnyOrder(encryptedV1.row, encryptedV2.row)); } |
MutableEntry implements Cloneable { public Key toKey() { return new Key(row, colF, colQ, colVis, timestamp, delete, false); } MutableEntry(); MutableEntry(Key key); MutableEntry(Map.Entry<Key,Value> entry); MutableEntry(byte[] row, ColumnUpdate update); Key toKey(); Map.Entry<Key,Value> toEntry(); MutableEntry cloneEntry(); byte[] getBytes(EntryField field); void setBytes(EntryField field, byte[] bytes); public byte[] row; public long timestamp; public boolean delete; } | @Test public void toKeyTest() { MutableEntry mutableKey = new MutableEntry(key); assertThat("returned key should be the same as the original key", mutableKey.toKey(), is(equalTo(key))); } |
MutableEntry implements Cloneable { public Map.Entry<Key,Value> toEntry() { return new AbstractMap.SimpleImmutableEntry<>(toKey(), new Value(value, false)); } MutableEntry(); MutableEntry(Key key); MutableEntry(Map.Entry<Key,Value> entry); MutableEntry(byte[] row, ColumnUpdate update); Key toKey(); Map.Entry<Key,Value> toEntry(); MutableEntry cloneEntry(); byte[] getBytes(EntryField field); void setBytes(EntryField field, byte[] bytes); public byte[] row; public long timestamp; public boolean delete; } | @Test public void toEntryTest() { MutableEntry mutableEntry = new MutableEntry(entry); assertThat("returned entry should be the same as the original entry", mutableEntry.toEntry(), is(equalTo(entry))); } |
MutableEntry implements Cloneable { public byte[] getBytes(EntryField field) { switch (field) { case ROW: return row; case COLUMN_FAMILY: return colF; case COLUMN_QUALIFIER: return colQ; case COLUMN_VISIBILITY: return colVis; case VALUE: return value; default: throw new IllegalArgumentException("invalid field"); } } MutableEntry(); MutableEntry(Key key); MutableEntry(Map.Entry<Key,Value> entry); MutableEntry(byte[] row, ColumnUpdate update); Key toKey(); Map.Entry<Key,Value> toEntry(); MutableEntry cloneEntry(); byte[] getBytes(EntryField field); void setBytes(EntryField field, byte[] bytes); public byte[] row; public long timestamp; public boolean delete; } | @Test public void getBytesTest() { MutableEntry mutableEntry = new MutableEntry(entry); assertThat("correct bytes returned", mutableEntry.getBytes(EntryField.ROW), is(equalTo(row))); assertThat("correct bytes returned", mutableEntry.getBytes(EntryField.COLUMN_FAMILY), is(equalTo(colF))); assertThat("correct bytes returned", mutableEntry.getBytes(EntryField.COLUMN_QUALIFIER), is(equalTo(colQ))); assertThat("correct bytes returned", mutableEntry.getBytes(EntryField.COLUMN_VISIBILITY), is(equalTo(colVis))); assertThat("correct bytes returned", mutableEntry.getBytes(EntryField.VALUE), is(equalTo(value))); }
@Test(expected = IllegalArgumentException.class) public void getBytesException() { MutableEntry mutableEntry = new MutableEntry(entry); mutableEntry.getBytes(EntryField.TIMESTAMP); } |
MutableEntry implements Cloneable { public void setBytes(EntryField field, byte[] bytes) { switch (field) { case ROW: row = bytes; break; case COLUMN_FAMILY: colF = bytes; break; case COLUMN_QUALIFIER: colQ = bytes; break; case COLUMN_VISIBILITY: colVis = bytes; break; case VALUE: value = bytes; break; default: throw new IllegalArgumentException("invalid field"); } } MutableEntry(); MutableEntry(Key key); MutableEntry(Map.Entry<Key,Value> entry); MutableEntry(byte[] row, ColumnUpdate update); Key toKey(); Map.Entry<Key,Value> toEntry(); MutableEntry cloneEntry(); byte[] getBytes(EntryField field); void setBytes(EntryField field, byte[] bytes); public byte[] row; public long timestamp; public boolean delete; } | @Test(expected = IllegalArgumentException.class) public void setBytesException() { MutableEntry mutableEntry = new MutableEntry(entry); mutableEntry.setBytes(EntryField.TIMESTAMP, EMPTY); } |
Utils { public static byte[] xor(byte[] first, byte[] second) { checkArgument(first != null, "first is null"); checkArgument(second != null, "second is null"); checkArgument(first.length == second.length, "first and second must be the same length"); for (int i = 0; i < first.length; i++) { first[i] = (byte) (first[i] ^ second[i]); } return first; } private Utils(); static byte[] xor(byte[] first, byte[] second); static final byte[] EMPTY; static final Charset VISIBILITY_CHARSET; } | @Test public void xorTest() { byte[] first = new byte[] {0, 1, 2}; byte[] second = new byte[] {0, 1, 1}; byte[] result = Utils.xor(first, second); assertThat("the return value is the same as the first argument", result == first, is(true)); assertThat("the correct result was achieved", result, is(equalTo(new byte[] {0, 0, 3}))); }
@Test public void xorExceptionTest() { byte[] first = new byte[] {0, 1, 2}; byte[] second = new byte[] {0, 1, 2, 3}; try { Utils.xor(null, second); fail("null first variable not allowed"); } catch (IllegalArgumentException e) { } try { Utils.xor(first, null); fail("null second variable not allowed"); } catch (IllegalArgumentException e) { } try { Utils.xor(first, second); fail("arrays with unequal length not allowed"); } catch (IllegalArgumentException e) { } } |
SignedScanner implements Scanner { @Override public void fetchColumnFamily(Text col) { valueScanner.fetchColumnFamily(col); if (signatureScanner != null) { signatureScanner.fetchColumnFamily(col); } } SignedScanner(Connector connector, String tableName, Authorizations authorizations, SignatureConfig signatureConfig, SignatureKeyContainer keys); @Override ItemProcessingIterator<Entry<Key,Value>> iterator(); @Override void addScanIterator(IteratorSetting cfg); @Override void clearColumns(); @Override void clearScanIterators(); @Override void close(); @Override void fetchColumn(Column column); @Override void fetchColumn(Text colFam, Text colQual); @Override void fetchColumnFamily(Text col); @Override Authorizations getAuthorizations(); @Override void setSamplerConfiguration(SamplerConfiguration samplerConfiguration); @Override SamplerConfiguration getSamplerConfiguration(); @Override void clearSamplerConfiguration(); @Override void setBatchTimeout(long l, TimeUnit timeUnit); @Override long getBatchTimeout(TimeUnit timeUnit); @Override void setClassLoaderContext(String s); @Override void clearClassLoaderContext(); @Override String getClassLoaderContext(); @Override long getTimeout(TimeUnit timeUnit); @Override void removeScanIterator(String iteratorName); @Override void updateScanIteratorOption(String iteratorName, String key, String value); @Override void setTimeout(long timeout, TimeUnit timeUnit); @Override void disableIsolation(); @Override void enableIsolation(); @Override int getBatchSize(); @Override Range getRange(); @Override long getReadaheadThreshold(); @Override @SuppressWarnings("deprecation") int getTimeOut(); @Override void setBatchSize(int size); @Override void setRange(Range range); @Override void setReadaheadThreshold(long batches); @Override @SuppressWarnings("deprecation") void setTimeOut(int timeOut); } | @Test public void fetchColumnFamilyTest() throws Exception { Text colF = new Text(new byte[] {1}); when(mockConnector.createScanner(TEST_TABLE, authorizations)).thenReturn(mockScanner); new SignedScanner(mockConnector, TEST_TABLE, authorizations, getConfig("config1.ini"), aliceKeyContainers.get(ValueSigner.RSA_PSS)).fetchColumnFamily(colF); verify(mockScanner).fetchColumnFamily(colF); }
@Test public void fetchColumnFamilyExternalTest() throws Exception { Text colF = new Text(new byte[] {1}); when(mockConnector.createScanner(TEST_TABLE, authorizations)).thenReturn(mockScanner); when(mockConnector.createScanner(SIG_TABLE, authorizations)).thenReturn(mockSignatureScanner); new SignedScanner(mockConnector, TEST_TABLE, authorizations, getConfig("config3.ini"), aliceKeyContainers.get(ValueSigner.RSA_PSS)).fetchColumnFamily(colF); verify(mockScanner).fetchColumnFamily(colF); verify(mockSignatureScanner).fetchColumnFamily(colF); } |
SignedScanner implements Scanner { @Override public Authorizations getAuthorizations() { return valueScanner.getAuthorizations(); } SignedScanner(Connector connector, String tableName, Authorizations authorizations, SignatureConfig signatureConfig, SignatureKeyContainer keys); @Override ItemProcessingIterator<Entry<Key,Value>> iterator(); @Override void addScanIterator(IteratorSetting cfg); @Override void clearColumns(); @Override void clearScanIterators(); @Override void close(); @Override void fetchColumn(Column column); @Override void fetchColumn(Text colFam, Text colQual); @Override void fetchColumnFamily(Text col); @Override Authorizations getAuthorizations(); @Override void setSamplerConfiguration(SamplerConfiguration samplerConfiguration); @Override SamplerConfiguration getSamplerConfiguration(); @Override void clearSamplerConfiguration(); @Override void setBatchTimeout(long l, TimeUnit timeUnit); @Override long getBatchTimeout(TimeUnit timeUnit); @Override void setClassLoaderContext(String s); @Override void clearClassLoaderContext(); @Override String getClassLoaderContext(); @Override long getTimeout(TimeUnit timeUnit); @Override void removeScanIterator(String iteratorName); @Override void updateScanIteratorOption(String iteratorName, String key, String value); @Override void setTimeout(long timeout, TimeUnit timeUnit); @Override void disableIsolation(); @Override void enableIsolation(); @Override int getBatchSize(); @Override Range getRange(); @Override long getReadaheadThreshold(); @Override @SuppressWarnings("deprecation") int getTimeOut(); @Override void setBatchSize(int size); @Override void setRange(Range range); @Override void setReadaheadThreshold(long batches); @Override @SuppressWarnings("deprecation") void setTimeOut(int timeOut); } | @Test public void getAuthorizationsTest() throws Exception { when(mockConnector.createScanner(TEST_TABLE, authorizations)).thenReturn(mockScanner); when(mockScanner.getAuthorizations()).thenReturn(authorizations); Authorizations auths = new SignedScanner(mockConnector, TEST_TABLE, authorizations, getConfig("config1.ini"), aliceKeyContainers.get(ValueSigner.RSA_PSS)) .getAuthorizations(); verify(mockScanner).getAuthorizations(); assertThat("correct authorizations returned", auths, equalTo(authorizations)); } |
SignatureConfig { public ValueSigner getAlgorithm() { return this.algorithm; } SignatureConfig(ValueSigner signer, String provider, Destination destination, String destinationTable, byte[] defaultVisibility); void write(Writer out); boolean isSignatureInSeparateTable(); ValueSigner getAlgorithm(); } | @Test public void getAlgorithmTest() { assertThat("correct algorithm", config1.getAlgorithm(), Matchers.equalTo(config1.algorithm)); assertThat("correct algorithm", config2.getAlgorithm(), Matchers.equalTo(config2.algorithm)); assertThat("correct algorithm", config3.getAlgorithm(), Matchers.equalTo(config3.algorithm)); } |
SignedScanner implements Scanner { @Override public SamplerConfiguration getSamplerConfiguration() { return valueScanner.getSamplerConfiguration(); } SignedScanner(Connector connector, String tableName, Authorizations authorizations, SignatureConfig signatureConfig, SignatureKeyContainer keys); @Override ItemProcessingIterator<Entry<Key,Value>> iterator(); @Override void addScanIterator(IteratorSetting cfg); @Override void clearColumns(); @Override void clearScanIterators(); @Override void close(); @Override void fetchColumn(Column column); @Override void fetchColumn(Text colFam, Text colQual); @Override void fetchColumnFamily(Text col); @Override Authorizations getAuthorizations(); @Override void setSamplerConfiguration(SamplerConfiguration samplerConfiguration); @Override SamplerConfiguration getSamplerConfiguration(); @Override void clearSamplerConfiguration(); @Override void setBatchTimeout(long l, TimeUnit timeUnit); @Override long getBatchTimeout(TimeUnit timeUnit); @Override void setClassLoaderContext(String s); @Override void clearClassLoaderContext(); @Override String getClassLoaderContext(); @Override long getTimeout(TimeUnit timeUnit); @Override void removeScanIterator(String iteratorName); @Override void updateScanIteratorOption(String iteratorName, String key, String value); @Override void setTimeout(long timeout, TimeUnit timeUnit); @Override void disableIsolation(); @Override void enableIsolation(); @Override int getBatchSize(); @Override Range getRange(); @Override long getReadaheadThreshold(); @Override @SuppressWarnings("deprecation") int getTimeOut(); @Override void setBatchSize(int size); @Override void setRange(Range range); @Override void setReadaheadThreshold(long batches); @Override @SuppressWarnings("deprecation") void setTimeOut(int timeOut); } | @Test public void getSamplerConfigurationTest() throws Exception { when(mockConnector.createScanner(TEST_TABLE, authorizations)).thenReturn(mockScanner); SamplerConfiguration config = new SamplerConfiguration("test"); when(mockScanner.getSamplerConfiguration()).thenReturn(config); SamplerConfiguration value = new SignedScanner(mockConnector, TEST_TABLE, authorizations, getConfig("config1.ini"), aliceKeyContainers.get(ValueSigner.RSA_PSS)).getSamplerConfiguration(); verify(mockScanner).getSamplerConfiguration(); assertThat("correct config returned", value, equalTo(config)); } |
SignedScanner implements Scanner { @Override public void setSamplerConfiguration(SamplerConfiguration samplerConfiguration) { valueScanner.setSamplerConfiguration(samplerConfiguration); if (signatureScanner != null) { signatureScanner.setSamplerConfiguration(samplerConfiguration); } } SignedScanner(Connector connector, String tableName, Authorizations authorizations, SignatureConfig signatureConfig, SignatureKeyContainer keys); @Override ItemProcessingIterator<Entry<Key,Value>> iterator(); @Override void addScanIterator(IteratorSetting cfg); @Override void clearColumns(); @Override void clearScanIterators(); @Override void close(); @Override void fetchColumn(Column column); @Override void fetchColumn(Text colFam, Text colQual); @Override void fetchColumnFamily(Text col); @Override Authorizations getAuthorizations(); @Override void setSamplerConfiguration(SamplerConfiguration samplerConfiguration); @Override SamplerConfiguration getSamplerConfiguration(); @Override void clearSamplerConfiguration(); @Override void setBatchTimeout(long l, TimeUnit timeUnit); @Override long getBatchTimeout(TimeUnit timeUnit); @Override void setClassLoaderContext(String s); @Override void clearClassLoaderContext(); @Override String getClassLoaderContext(); @Override long getTimeout(TimeUnit timeUnit); @Override void removeScanIterator(String iteratorName); @Override void updateScanIteratorOption(String iteratorName, String key, String value); @Override void setTimeout(long timeout, TimeUnit timeUnit); @Override void disableIsolation(); @Override void enableIsolation(); @Override int getBatchSize(); @Override Range getRange(); @Override long getReadaheadThreshold(); @Override @SuppressWarnings("deprecation") int getTimeOut(); @Override void setBatchSize(int size); @Override void setRange(Range range); @Override void setReadaheadThreshold(long batches); @Override @SuppressWarnings("deprecation") void setTimeOut(int timeOut); } | @Test public void setSamplerConfigurationTest() throws Exception { when(mockConnector.createScanner(TEST_TABLE, authorizations)).thenReturn(mockScanner); SamplerConfiguration config = new SamplerConfiguration("test"); new SignedScanner(mockConnector, TEST_TABLE, authorizations, getConfig("config1.ini"), aliceKeyContainers.get(ValueSigner.RSA_PSS)) .setSamplerConfiguration(config); verify(mockScanner).setSamplerConfiguration(config); }
@Test public void setSamplerConfigurationExternalTest() throws Exception { when(mockConnector.createScanner(TEST_TABLE, authorizations)).thenReturn(mockScanner); when(mockConnector.createScanner(SIG_TABLE, authorizations)).thenReturn(mockSignatureScanner); SamplerConfiguration config = new SamplerConfiguration("test"); new SignedScanner(mockConnector, TEST_TABLE, authorizations, getConfig("config3.ini"), aliceKeyContainers.get(ValueSigner.RSA_PSS)) .setSamplerConfiguration(config); verify(mockScanner).setSamplerConfiguration(config); verify(mockSignatureScanner).setSamplerConfiguration(config); } |
SignedScanner implements Scanner { @Override public void clearSamplerConfiguration() { valueScanner.clearSamplerConfiguration(); if (signatureScanner != null) { signatureScanner.clearSamplerConfiguration(); } } SignedScanner(Connector connector, String tableName, Authorizations authorizations, SignatureConfig signatureConfig, SignatureKeyContainer keys); @Override ItemProcessingIterator<Entry<Key,Value>> iterator(); @Override void addScanIterator(IteratorSetting cfg); @Override void clearColumns(); @Override void clearScanIterators(); @Override void close(); @Override void fetchColumn(Column column); @Override void fetchColumn(Text colFam, Text colQual); @Override void fetchColumnFamily(Text col); @Override Authorizations getAuthorizations(); @Override void setSamplerConfiguration(SamplerConfiguration samplerConfiguration); @Override SamplerConfiguration getSamplerConfiguration(); @Override void clearSamplerConfiguration(); @Override void setBatchTimeout(long l, TimeUnit timeUnit); @Override long getBatchTimeout(TimeUnit timeUnit); @Override void setClassLoaderContext(String s); @Override void clearClassLoaderContext(); @Override String getClassLoaderContext(); @Override long getTimeout(TimeUnit timeUnit); @Override void removeScanIterator(String iteratorName); @Override void updateScanIteratorOption(String iteratorName, String key, String value); @Override void setTimeout(long timeout, TimeUnit timeUnit); @Override void disableIsolation(); @Override void enableIsolation(); @Override int getBatchSize(); @Override Range getRange(); @Override long getReadaheadThreshold(); @Override @SuppressWarnings("deprecation") int getTimeOut(); @Override void setBatchSize(int size); @Override void setRange(Range range); @Override void setReadaheadThreshold(long batches); @Override @SuppressWarnings("deprecation") void setTimeOut(int timeOut); } | @Test public void clearSamplerConfigurationTest() throws Exception { when(mockConnector.createScanner(TEST_TABLE, authorizations)).thenReturn(mockScanner); new SignedScanner(mockConnector, TEST_TABLE, authorizations, getConfig("config1.ini"), aliceKeyContainers.get(ValueSigner.RSA_PSS)) .clearSamplerConfiguration(); verify(mockScanner).clearSamplerConfiguration(); }
@Test public void clearSamplerConfigurationExternalTest() throws Exception { when(mockConnector.createScanner(TEST_TABLE, authorizations)).thenReturn(mockScanner); when(mockConnector.createScanner(SIG_TABLE, authorizations)).thenReturn(mockSignatureScanner); new SignedScanner(mockConnector, TEST_TABLE, authorizations, getConfig("config3.ini"), aliceKeyContainers.get(ValueSigner.RSA_PSS)) .clearSamplerConfiguration(); verify(mockScanner).clearSamplerConfiguration(); verify(mockSignatureScanner).clearSamplerConfiguration(); } |
SignedScanner implements Scanner { @Override public void setBatchTimeout(long l, TimeUnit timeUnit) { valueScanner.setBatchTimeout(l, timeUnit); if (signatureScanner != null) { signatureScanner.setBatchTimeout(l, timeUnit); } } SignedScanner(Connector connector, String tableName, Authorizations authorizations, SignatureConfig signatureConfig, SignatureKeyContainer keys); @Override ItemProcessingIterator<Entry<Key,Value>> iterator(); @Override void addScanIterator(IteratorSetting cfg); @Override void clearColumns(); @Override void clearScanIterators(); @Override void close(); @Override void fetchColumn(Column column); @Override void fetchColumn(Text colFam, Text colQual); @Override void fetchColumnFamily(Text col); @Override Authorizations getAuthorizations(); @Override void setSamplerConfiguration(SamplerConfiguration samplerConfiguration); @Override SamplerConfiguration getSamplerConfiguration(); @Override void clearSamplerConfiguration(); @Override void setBatchTimeout(long l, TimeUnit timeUnit); @Override long getBatchTimeout(TimeUnit timeUnit); @Override void setClassLoaderContext(String s); @Override void clearClassLoaderContext(); @Override String getClassLoaderContext(); @Override long getTimeout(TimeUnit timeUnit); @Override void removeScanIterator(String iteratorName); @Override void updateScanIteratorOption(String iteratorName, String key, String value); @Override void setTimeout(long timeout, TimeUnit timeUnit); @Override void disableIsolation(); @Override void enableIsolation(); @Override int getBatchSize(); @Override Range getRange(); @Override long getReadaheadThreshold(); @Override @SuppressWarnings("deprecation") int getTimeOut(); @Override void setBatchSize(int size); @Override void setRange(Range range); @Override void setReadaheadThreshold(long batches); @Override @SuppressWarnings("deprecation") void setTimeOut(int timeOut); } | @Test public void setBatchTimeoutTest() throws Exception { when(mockConnector.createScanner(TEST_TABLE, authorizations)).thenReturn(mockScanner); new SignedScanner(mockConnector, TEST_TABLE, authorizations, getConfig("config1.ini"), aliceKeyContainers.get(ValueSigner.RSA_PSS)).setBatchTimeout(5L, TimeUnit.DAYS); verify(mockScanner).setBatchTimeout(5L, TimeUnit.DAYS); }
@Test public void setBatchTimeoutExternalTest() throws Exception { when(mockConnector.createScanner(TEST_TABLE, authorizations)).thenReturn(mockScanner); when(mockConnector.createScanner(SIG_TABLE, authorizations)).thenReturn(mockSignatureScanner); new SignedScanner(mockConnector, TEST_TABLE, authorizations, getConfig("config3.ini"), aliceKeyContainers.get(ValueSigner.RSA_PSS)).setBatchTimeout(5L, TimeUnit.DAYS); verify(mockScanner).setBatchTimeout(5L, TimeUnit.DAYS); verify(mockSignatureScanner).setBatchTimeout(5L, TimeUnit.DAYS); } |
SignedScanner implements Scanner { @Override public long getBatchTimeout(TimeUnit timeUnit) { return valueScanner.getBatchTimeout(timeUnit); } SignedScanner(Connector connector, String tableName, Authorizations authorizations, SignatureConfig signatureConfig, SignatureKeyContainer keys); @Override ItemProcessingIterator<Entry<Key,Value>> iterator(); @Override void addScanIterator(IteratorSetting cfg); @Override void clearColumns(); @Override void clearScanIterators(); @Override void close(); @Override void fetchColumn(Column column); @Override void fetchColumn(Text colFam, Text colQual); @Override void fetchColumnFamily(Text col); @Override Authorizations getAuthorizations(); @Override void setSamplerConfiguration(SamplerConfiguration samplerConfiguration); @Override SamplerConfiguration getSamplerConfiguration(); @Override void clearSamplerConfiguration(); @Override void setBatchTimeout(long l, TimeUnit timeUnit); @Override long getBatchTimeout(TimeUnit timeUnit); @Override void setClassLoaderContext(String s); @Override void clearClassLoaderContext(); @Override String getClassLoaderContext(); @Override long getTimeout(TimeUnit timeUnit); @Override void removeScanIterator(String iteratorName); @Override void updateScanIteratorOption(String iteratorName, String key, String value); @Override void setTimeout(long timeout, TimeUnit timeUnit); @Override void disableIsolation(); @Override void enableIsolation(); @Override int getBatchSize(); @Override Range getRange(); @Override long getReadaheadThreshold(); @Override @SuppressWarnings("deprecation") int getTimeOut(); @Override void setBatchSize(int size); @Override void setRange(Range range); @Override void setReadaheadThreshold(long batches); @Override @SuppressWarnings("deprecation") void setTimeOut(int timeOut); } | @Test public void getBatchTimeoutTest() throws Exception { when(mockConnector.createScanner(TEST_TABLE, authorizations)).thenReturn(mockScanner); when(mockScanner.getBatchTimeout(TimeUnit.DAYS)).thenReturn(5L); long value = new SignedScanner(mockConnector, TEST_TABLE, authorizations, getConfig("config1.ini"), aliceKeyContainers.get(ValueSigner.RSA_PSS)) .getBatchTimeout(TimeUnit.DAYS); verify(mockScanner).getBatchTimeout(TimeUnit.DAYS); assertThat("correct timeout returned", value, is(5L)); } |
SignedScanner implements Scanner { @Override public void setClassLoaderContext(String s) { valueScanner.setClassLoaderContext(s); if (signatureScanner != null) { signatureScanner.setClassLoaderContext(s); } } SignedScanner(Connector connector, String tableName, Authorizations authorizations, SignatureConfig signatureConfig, SignatureKeyContainer keys); @Override ItemProcessingIterator<Entry<Key,Value>> iterator(); @Override void addScanIterator(IteratorSetting cfg); @Override void clearColumns(); @Override void clearScanIterators(); @Override void close(); @Override void fetchColumn(Column column); @Override void fetchColumn(Text colFam, Text colQual); @Override void fetchColumnFamily(Text col); @Override Authorizations getAuthorizations(); @Override void setSamplerConfiguration(SamplerConfiguration samplerConfiguration); @Override SamplerConfiguration getSamplerConfiguration(); @Override void clearSamplerConfiguration(); @Override void setBatchTimeout(long l, TimeUnit timeUnit); @Override long getBatchTimeout(TimeUnit timeUnit); @Override void setClassLoaderContext(String s); @Override void clearClassLoaderContext(); @Override String getClassLoaderContext(); @Override long getTimeout(TimeUnit timeUnit); @Override void removeScanIterator(String iteratorName); @Override void updateScanIteratorOption(String iteratorName, String key, String value); @Override void setTimeout(long timeout, TimeUnit timeUnit); @Override void disableIsolation(); @Override void enableIsolation(); @Override int getBatchSize(); @Override Range getRange(); @Override long getReadaheadThreshold(); @Override @SuppressWarnings("deprecation") int getTimeOut(); @Override void setBatchSize(int size); @Override void setRange(Range range); @Override void setReadaheadThreshold(long batches); @Override @SuppressWarnings("deprecation") void setTimeOut(int timeOut); } | @Test public void setClassLoaderContextTest() throws Exception { when(mockConnector.createScanner(TEST_TABLE, authorizations)).thenReturn(mockScanner); new SignedScanner(mockConnector, TEST_TABLE, authorizations, getConfig("config1.ini"), aliceKeyContainers.get(ValueSigner.RSA_PSS)) .setClassLoaderContext("test"); verify(mockScanner).setClassLoaderContext("test"); }
@Test public void setClassLoaderContextExternalTest() throws Exception { when(mockConnector.createScanner(TEST_TABLE, authorizations)).thenReturn(mockScanner); when(mockConnector.createScanner(SIG_TABLE, authorizations)).thenReturn(mockSignatureScanner); new SignedScanner(mockConnector, TEST_TABLE, authorizations, getConfig("config3.ini"), aliceKeyContainers.get(ValueSigner.RSA_PSS)) .setClassLoaderContext("test"); verify(mockScanner).setClassLoaderContext("test"); verify(mockSignatureScanner).setClassLoaderContext("test"); } |
SignatureConfig { public boolean isSignatureInSeparateTable() { return this.destination == Destination.SEPARATE_TABLE; } SignatureConfig(ValueSigner signer, String provider, Destination destination, String destinationTable, byte[] defaultVisibility); void write(Writer out); boolean isSignatureInSeparateTable(); ValueSigner getAlgorithm(); } | @Test public void isSignatureInSeparateTableTest() { assertThat("correct return value", config1.isSignatureInSeparateTable(), is(false)); assertThat("correct return value", config2.isSignatureInSeparateTable(), is(false)); assertThat("correct return value", config3.isSignatureInSeparateTable(), is(true)); } |
SignedScanner implements Scanner { @Override public void clearClassLoaderContext() { valueScanner.clearClassLoaderContext(); if (signatureScanner != null) { signatureScanner.clearClassLoaderContext(); } } SignedScanner(Connector connector, String tableName, Authorizations authorizations, SignatureConfig signatureConfig, SignatureKeyContainer keys); @Override ItemProcessingIterator<Entry<Key,Value>> iterator(); @Override void addScanIterator(IteratorSetting cfg); @Override void clearColumns(); @Override void clearScanIterators(); @Override void close(); @Override void fetchColumn(Column column); @Override void fetchColumn(Text colFam, Text colQual); @Override void fetchColumnFamily(Text col); @Override Authorizations getAuthorizations(); @Override void setSamplerConfiguration(SamplerConfiguration samplerConfiguration); @Override SamplerConfiguration getSamplerConfiguration(); @Override void clearSamplerConfiguration(); @Override void setBatchTimeout(long l, TimeUnit timeUnit); @Override long getBatchTimeout(TimeUnit timeUnit); @Override void setClassLoaderContext(String s); @Override void clearClassLoaderContext(); @Override String getClassLoaderContext(); @Override long getTimeout(TimeUnit timeUnit); @Override void removeScanIterator(String iteratorName); @Override void updateScanIteratorOption(String iteratorName, String key, String value); @Override void setTimeout(long timeout, TimeUnit timeUnit); @Override void disableIsolation(); @Override void enableIsolation(); @Override int getBatchSize(); @Override Range getRange(); @Override long getReadaheadThreshold(); @Override @SuppressWarnings("deprecation") int getTimeOut(); @Override void setBatchSize(int size); @Override void setRange(Range range); @Override void setReadaheadThreshold(long batches); @Override @SuppressWarnings("deprecation") void setTimeOut(int timeOut); } | @Test public void clearClassLoaderContextTest() throws Exception { when(mockConnector.createScanner(TEST_TABLE, authorizations)).thenReturn(mockScanner); new SignedScanner(mockConnector, TEST_TABLE, authorizations, getConfig("config1.ini"), aliceKeyContainers.get(ValueSigner.RSA_PSS)) .clearClassLoaderContext(); verify(mockScanner).clearClassLoaderContext(); }
@Test public void clearClassLoaderContextExternalTest() throws Exception { when(mockConnector.createScanner(TEST_TABLE, authorizations)).thenReturn(mockScanner); when(mockConnector.createScanner(SIG_TABLE, authorizations)).thenReturn(mockSignatureScanner); new SignedScanner(mockConnector, TEST_TABLE, authorizations, getConfig("config3.ini"), aliceKeyContainers.get(ValueSigner.RSA_PSS)) .clearClassLoaderContext(); verify(mockScanner).clearClassLoaderContext(); verify(mockSignatureScanner).clearClassLoaderContext(); } |
SignedScanner implements Scanner { @Override public String getClassLoaderContext() { return valueScanner.getClassLoaderContext(); } SignedScanner(Connector connector, String tableName, Authorizations authorizations, SignatureConfig signatureConfig, SignatureKeyContainer keys); @Override ItemProcessingIterator<Entry<Key,Value>> iterator(); @Override void addScanIterator(IteratorSetting cfg); @Override void clearColumns(); @Override void clearScanIterators(); @Override void close(); @Override void fetchColumn(Column column); @Override void fetchColumn(Text colFam, Text colQual); @Override void fetchColumnFamily(Text col); @Override Authorizations getAuthorizations(); @Override void setSamplerConfiguration(SamplerConfiguration samplerConfiguration); @Override SamplerConfiguration getSamplerConfiguration(); @Override void clearSamplerConfiguration(); @Override void setBatchTimeout(long l, TimeUnit timeUnit); @Override long getBatchTimeout(TimeUnit timeUnit); @Override void setClassLoaderContext(String s); @Override void clearClassLoaderContext(); @Override String getClassLoaderContext(); @Override long getTimeout(TimeUnit timeUnit); @Override void removeScanIterator(String iteratorName); @Override void updateScanIteratorOption(String iteratorName, String key, String value); @Override void setTimeout(long timeout, TimeUnit timeUnit); @Override void disableIsolation(); @Override void enableIsolation(); @Override int getBatchSize(); @Override Range getRange(); @Override long getReadaheadThreshold(); @Override @SuppressWarnings("deprecation") int getTimeOut(); @Override void setBatchSize(int size); @Override void setRange(Range range); @Override void setReadaheadThreshold(long batches); @Override @SuppressWarnings("deprecation") void setTimeOut(int timeOut); } | @Test public void getClassLoaderContextTest() throws Exception { when(mockConnector.createScanner(TEST_TABLE, authorizations)).thenReturn(mockScanner); when(mockScanner.getClassLoaderContext()).thenReturn("test"); String value = new SignedScanner(mockConnector, TEST_TABLE, authorizations, getConfig("config1.ini"), aliceKeyContainers.get(ValueSigner.RSA_PSS)) .getClassLoaderContext(); verify(mockScanner).getClassLoaderContext(); assertThat("correct class loader context returned", value, is("test")); } |
SignedScanner implements Scanner { @Override public long getTimeout(TimeUnit timeUnit) { return valueScanner.getTimeout(timeUnit); } SignedScanner(Connector connector, String tableName, Authorizations authorizations, SignatureConfig signatureConfig, SignatureKeyContainer keys); @Override ItemProcessingIterator<Entry<Key,Value>> iterator(); @Override void addScanIterator(IteratorSetting cfg); @Override void clearColumns(); @Override void clearScanIterators(); @Override void close(); @Override void fetchColumn(Column column); @Override void fetchColumn(Text colFam, Text colQual); @Override void fetchColumnFamily(Text col); @Override Authorizations getAuthorizations(); @Override void setSamplerConfiguration(SamplerConfiguration samplerConfiguration); @Override SamplerConfiguration getSamplerConfiguration(); @Override void clearSamplerConfiguration(); @Override void setBatchTimeout(long l, TimeUnit timeUnit); @Override long getBatchTimeout(TimeUnit timeUnit); @Override void setClassLoaderContext(String s); @Override void clearClassLoaderContext(); @Override String getClassLoaderContext(); @Override long getTimeout(TimeUnit timeUnit); @Override void removeScanIterator(String iteratorName); @Override void updateScanIteratorOption(String iteratorName, String key, String value); @Override void setTimeout(long timeout, TimeUnit timeUnit); @Override void disableIsolation(); @Override void enableIsolation(); @Override int getBatchSize(); @Override Range getRange(); @Override long getReadaheadThreshold(); @Override @SuppressWarnings("deprecation") int getTimeOut(); @Override void setBatchSize(int size); @Override void setRange(Range range); @Override void setReadaheadThreshold(long batches); @Override @SuppressWarnings("deprecation") void setTimeOut(int timeOut); } | @Test public void getTimeoutTest() throws Exception { when(mockConnector.createScanner(TEST_TABLE, authorizations)).thenReturn(mockScanner); when(mockScanner.getTimeout(TimeUnit.DAYS)).thenReturn(5L); Long value = new SignedScanner(mockConnector, TEST_TABLE, authorizations, getConfig("config1.ini"), aliceKeyContainers.get(ValueSigner.RSA_PSS)) .getTimeout(TimeUnit.DAYS); verify(mockScanner).getTimeout(TimeUnit.DAYS); assertThat("correct timeout returned", value, is(5L)); }
@Test @SuppressWarnings("deprecation") public void getTimeOutTest() throws Exception { when(mockConnector.createScanner(TEST_TABLE, authorizations)).thenReturn(mockScanner); when(mockScanner.getTimeOut()).thenReturn(5); int value = new SignedScanner(mockConnector, TEST_TABLE, authorizations, getConfig("config1.ini"), aliceKeyContainers.get(ValueSigner.RSA_PSS)) .getTimeOut(); verify(mockScanner).getTimeOut(); assertThat("correct timeout returned", value, is(5)); } |
SignedScanner implements Scanner { @Override public void removeScanIterator(String iteratorName) { valueScanner.removeScanIterator(iteratorName); if (signatureScanner != null) { signatureScanner.removeScanIterator(iteratorName); } } SignedScanner(Connector connector, String tableName, Authorizations authorizations, SignatureConfig signatureConfig, SignatureKeyContainer keys); @Override ItemProcessingIterator<Entry<Key,Value>> iterator(); @Override void addScanIterator(IteratorSetting cfg); @Override void clearColumns(); @Override void clearScanIterators(); @Override void close(); @Override void fetchColumn(Column column); @Override void fetchColumn(Text colFam, Text colQual); @Override void fetchColumnFamily(Text col); @Override Authorizations getAuthorizations(); @Override void setSamplerConfiguration(SamplerConfiguration samplerConfiguration); @Override SamplerConfiguration getSamplerConfiguration(); @Override void clearSamplerConfiguration(); @Override void setBatchTimeout(long l, TimeUnit timeUnit); @Override long getBatchTimeout(TimeUnit timeUnit); @Override void setClassLoaderContext(String s); @Override void clearClassLoaderContext(); @Override String getClassLoaderContext(); @Override long getTimeout(TimeUnit timeUnit); @Override void removeScanIterator(String iteratorName); @Override void updateScanIteratorOption(String iteratorName, String key, String value); @Override void setTimeout(long timeout, TimeUnit timeUnit); @Override void disableIsolation(); @Override void enableIsolation(); @Override int getBatchSize(); @Override Range getRange(); @Override long getReadaheadThreshold(); @Override @SuppressWarnings("deprecation") int getTimeOut(); @Override void setBatchSize(int size); @Override void setRange(Range range); @Override void setReadaheadThreshold(long batches); @Override @SuppressWarnings("deprecation") void setTimeOut(int timeOut); } | @Test public void removeScanIteratorTest() throws Exception { when(mockConnector.createScanner(TEST_TABLE, authorizations)).thenReturn(mockScanner); new SignedScanner(mockConnector, TEST_TABLE, authorizations, getConfig("config1.ini"), aliceKeyContainers.get(ValueSigner.RSA_PSS)) .removeScanIterator("test"); verify(mockScanner).removeScanIterator("test"); }
@Test public void removeScanIteratorExternalTest() throws Exception { when(mockConnector.createScanner(TEST_TABLE, authorizations)).thenReturn(mockScanner); when(mockConnector.createScanner(SIG_TABLE, authorizations)).thenReturn(mockSignatureScanner); new SignedScanner(mockConnector, TEST_TABLE, authorizations, getConfig("config3.ini"), aliceKeyContainers.get(ValueSigner.RSA_PSS)) .removeScanIterator("test"); verify(mockScanner).removeScanIterator("test"); verify(mockSignatureScanner).removeScanIterator("test"); } |
SignedScanner implements Scanner { @Override public void updateScanIteratorOption(String iteratorName, String key, String value) { valueScanner.updateScanIteratorOption(iteratorName, key, value); if (signatureScanner != null) { signatureScanner.updateScanIteratorOption(iteratorName, key, value); } } SignedScanner(Connector connector, String tableName, Authorizations authorizations, SignatureConfig signatureConfig, SignatureKeyContainer keys); @Override ItemProcessingIterator<Entry<Key,Value>> iterator(); @Override void addScanIterator(IteratorSetting cfg); @Override void clearColumns(); @Override void clearScanIterators(); @Override void close(); @Override void fetchColumn(Column column); @Override void fetchColumn(Text colFam, Text colQual); @Override void fetchColumnFamily(Text col); @Override Authorizations getAuthorizations(); @Override void setSamplerConfiguration(SamplerConfiguration samplerConfiguration); @Override SamplerConfiguration getSamplerConfiguration(); @Override void clearSamplerConfiguration(); @Override void setBatchTimeout(long l, TimeUnit timeUnit); @Override long getBatchTimeout(TimeUnit timeUnit); @Override void setClassLoaderContext(String s); @Override void clearClassLoaderContext(); @Override String getClassLoaderContext(); @Override long getTimeout(TimeUnit timeUnit); @Override void removeScanIterator(String iteratorName); @Override void updateScanIteratorOption(String iteratorName, String key, String value); @Override void setTimeout(long timeout, TimeUnit timeUnit); @Override void disableIsolation(); @Override void enableIsolation(); @Override int getBatchSize(); @Override Range getRange(); @Override long getReadaheadThreshold(); @Override @SuppressWarnings("deprecation") int getTimeOut(); @Override void setBatchSize(int size); @Override void setRange(Range range); @Override void setReadaheadThreshold(long batches); @Override @SuppressWarnings("deprecation") void setTimeOut(int timeOut); } | @Test public void updateScanIteratorOptionTest() throws Exception { when(mockConnector.createScanner(TEST_TABLE, authorizations)).thenReturn(mockScanner); new SignedScanner(mockConnector, TEST_TABLE, authorizations, getConfig("config1.ini"), aliceKeyContainers.get(ValueSigner.RSA_PSS)) .updateScanIteratorOption("test", "a", "b"); verify(mockScanner).updateScanIteratorOption("test", "a", "b"); }
@Test public void updateScanIteratorOptionExternalTest() throws Exception { when(mockConnector.createScanner(TEST_TABLE, authorizations)).thenReturn(mockScanner); when(mockConnector.createScanner(SIG_TABLE, authorizations)).thenReturn(mockSignatureScanner); new SignedScanner(mockConnector, TEST_TABLE, authorizations, getConfig("config3.ini"), aliceKeyContainers.get(ValueSigner.RSA_PSS)) .updateScanIteratorOption("test", "a", "b"); verify(mockScanner).updateScanIteratorOption("test", "a", "b"); verify(mockSignatureScanner).updateScanIteratorOption("test", "a", "b"); } |
SignedScanner implements Scanner { @Override public void setTimeout(long timeout, TimeUnit timeUnit) { valueScanner.setTimeout(timeout, timeUnit); if (signatureScanner != null) { signatureScanner.setTimeout(timeout, timeUnit); } } SignedScanner(Connector connector, String tableName, Authorizations authorizations, SignatureConfig signatureConfig, SignatureKeyContainer keys); @Override ItemProcessingIterator<Entry<Key,Value>> iterator(); @Override void addScanIterator(IteratorSetting cfg); @Override void clearColumns(); @Override void clearScanIterators(); @Override void close(); @Override void fetchColumn(Column column); @Override void fetchColumn(Text colFam, Text colQual); @Override void fetchColumnFamily(Text col); @Override Authorizations getAuthorizations(); @Override void setSamplerConfiguration(SamplerConfiguration samplerConfiguration); @Override SamplerConfiguration getSamplerConfiguration(); @Override void clearSamplerConfiguration(); @Override void setBatchTimeout(long l, TimeUnit timeUnit); @Override long getBatchTimeout(TimeUnit timeUnit); @Override void setClassLoaderContext(String s); @Override void clearClassLoaderContext(); @Override String getClassLoaderContext(); @Override long getTimeout(TimeUnit timeUnit); @Override void removeScanIterator(String iteratorName); @Override void updateScanIteratorOption(String iteratorName, String key, String value); @Override void setTimeout(long timeout, TimeUnit timeUnit); @Override void disableIsolation(); @Override void enableIsolation(); @Override int getBatchSize(); @Override Range getRange(); @Override long getReadaheadThreshold(); @Override @SuppressWarnings("deprecation") int getTimeOut(); @Override void setBatchSize(int size); @Override void setRange(Range range); @Override void setReadaheadThreshold(long batches); @Override @SuppressWarnings("deprecation") void setTimeOut(int timeOut); } | @Test public void setTimeoutTest() throws Exception { when(mockConnector.createScanner(TEST_TABLE, authorizations)).thenReturn(mockScanner); new SignedScanner(mockConnector, TEST_TABLE, authorizations, getConfig("config1.ini"), aliceKeyContainers.get(ValueSigner.RSA_PSS)).setTimeout(5L, TimeUnit.DAYS); verify(mockScanner).setTimeout(5L, TimeUnit.DAYS); }
@Test public void setTimeoutExternalTest() throws Exception { when(mockConnector.createScanner(TEST_TABLE, authorizations)).thenReturn(mockScanner); when(mockConnector.createScanner(SIG_TABLE, authorizations)).thenReturn(mockSignatureScanner); new SignedScanner(mockConnector, TEST_TABLE, authorizations, getConfig("config3.ini"), aliceKeyContainers.get(ValueSigner.RSA_PSS)).setTimeout(5L, TimeUnit.DAYS); verify(mockScanner).setTimeout(5L, TimeUnit.DAYS); verify(mockSignatureScanner).setTimeout(5L, TimeUnit.DAYS); }
@Test @SuppressWarnings("deprecation") public void setTimeOutTest() throws Exception { when(mockConnector.createScanner(TEST_TABLE, authorizations)).thenReturn(mockScanner); new SignedScanner(mockConnector, TEST_TABLE, authorizations, getConfig("config1.ini"), aliceKeyContainers.get(ValueSigner.RSA_PSS)).setTimeOut(5); verify(mockScanner).setTimeOut(5); }
@Test @SuppressWarnings("deprecation") public void setTimeOutExternalTest() throws Exception { when(mockConnector.createScanner(TEST_TABLE, authorizations)).thenReturn(mockScanner); when(mockConnector.createScanner(SIG_TABLE, authorizations)).thenReturn(mockSignatureScanner); new SignedScanner(mockConnector, TEST_TABLE, authorizations, getConfig("config3.ini"), aliceKeyContainers.get(ValueSigner.RSA_PSS)).setTimeOut(5); verify(mockScanner).setTimeOut(5); verify(mockSignatureScanner).setTimeOut(5); } |
SignedScanner implements Scanner { @Override public ItemProcessingIterator<Entry<Key,Value>> iterator() { if (signatureScanner != null) { return new SignedExternalScannerIterator(valueScanner.iterator(), signatureScanner.iterator(), verifier, true); } else { return new SignedInlineScannerIterator(valueScanner.iterator(), verifier); } } SignedScanner(Connector connector, String tableName, Authorizations authorizations, SignatureConfig signatureConfig, SignatureKeyContainer keys); @Override ItemProcessingIterator<Entry<Key,Value>> iterator(); @Override void addScanIterator(IteratorSetting cfg); @Override void clearColumns(); @Override void clearScanIterators(); @Override void close(); @Override void fetchColumn(Column column); @Override void fetchColumn(Text colFam, Text colQual); @Override void fetchColumnFamily(Text col); @Override Authorizations getAuthorizations(); @Override void setSamplerConfiguration(SamplerConfiguration samplerConfiguration); @Override SamplerConfiguration getSamplerConfiguration(); @Override void clearSamplerConfiguration(); @Override void setBatchTimeout(long l, TimeUnit timeUnit); @Override long getBatchTimeout(TimeUnit timeUnit); @Override void setClassLoaderContext(String s); @Override void clearClassLoaderContext(); @Override String getClassLoaderContext(); @Override long getTimeout(TimeUnit timeUnit); @Override void removeScanIterator(String iteratorName); @Override void updateScanIteratorOption(String iteratorName, String key, String value); @Override void setTimeout(long timeout, TimeUnit timeUnit); @Override void disableIsolation(); @Override void enableIsolation(); @Override int getBatchSize(); @Override Range getRange(); @Override long getReadaheadThreshold(); @Override @SuppressWarnings("deprecation") int getTimeOut(); @Override void setBatchSize(int size); @Override void setRange(Range range); @Override void setReadaheadThreshold(long batches); @Override @SuppressWarnings("deprecation") void setTimeOut(int timeOut); } | @Test public void iteratorTest() throws Exception { when(mockConnector.createScanner(TEST_TABLE, authorizations)).thenReturn(mockScanner); EntrySigner signer = new EntrySigner(getConfig("config1.ini"), aliceKeyContainers.get(ValueSigner.RSA_PSS)); List<Entry<Key,Value>> entries = new ArrayList<>(); Map.Entry<Key,Value> entry = new SimpleImmutableEntry<>(new Key(new byte[] {1}, new byte[] {2}, new byte[] {3}, "secret".getBytes(Utils.VISIBILITY_CHARSET), 0, false, false), new Value(new byte[] {4})); Map.Entry<Key,Value> entry2 = new SimpleImmutableEntry<>(new Key(new byte[] {5}, new byte[] {6}, new byte[] {7}, "secret".getBytes(Utils.VISIBILITY_CHARSET), 0, false, false), new Value(new byte[] {8})); entries.add(signer.sign(entry, true)); entries.add(signer.sign(entry2, true)); when(mockScanner.iterator()).thenReturn(entries.iterator()).thenReturn(entries.iterator()); Scanner scanner = new SignedScanner(mockConnector, TEST_TABLE, authorizations, getConfig("config1.ini"), aliceKeyContainers.get(ValueSigner.RSA_PSS)); assertThat("has correct number of elements", scanner, iterableWithSize(2)); Iterator<Entry<Key,Value>> iterator = scanner.iterator(); assertThat("correct item", iterator.next(), Matchers.equalTo(entry)); assertThat("correct item", iterator.next(), Matchers.equalTo(entry2)); }
@Test public void iteratorExternalTest() throws Exception { when(mockConnector.createScanner(TEST_TABLE, authorizations)).thenReturn(mockScanner); when(mockConnector.createScanner(SIG_TABLE, authorizations)).thenReturn(mockSignatureScanner); EntrySigner signer = new EntrySigner(getConfig("config3.ini"), aliceKeyContainers.get(ValueSigner.ECDSA)); List<Entry<Key,Value>> entries = new ArrayList<>(); List<Entry<Key,Value>> signedEntries = new ArrayList<>(); Map.Entry<Key,Value> entry = new SimpleImmutableEntry<>(new Key(new byte[] {1}, new byte[] {2}, new byte[] {3}, "secret".getBytes(Utils.VISIBILITY_CHARSET), 0, false, false), new Value(new byte[] {4})); Map.Entry<Key,Value> entry2 = new SimpleImmutableEntry<>(new Key(new byte[] {5}, new byte[] {6}, new byte[] {7}, "secret".getBytes(Utils.VISIBILITY_CHARSET), 0, false, false), new Value(new byte[] {8})); entries.add(entry); entries.add(entry2); signedEntries.add(signer.sign(entry, true)); signedEntries.add(signer.sign(entry2, true)); when(mockScanner.iterator()).thenReturn(entries.iterator()).thenReturn(entries.iterator()); when(mockSignatureScanner.iterator()).thenReturn(signedEntries.iterator()).thenReturn(signedEntries.iterator()); Scanner scanner = new SignedScanner(mockConnector, TEST_TABLE, authorizations, getConfig("config3.ini"), aliceKeyContainers.get(ValueSigner.ECDSA)); assertThat("has correct number of elements", scanner, iterableWithSize(2)); Iterator<Entry<Key,Value>> iterator = scanner.iterator(); assertThat("correct item", iterator.next(), Matchers.equalTo(entry)); assertThat("correct item", iterator.next(), Matchers.equalTo(entry2)); } |
SignedScanner implements Scanner { @Override public void disableIsolation() { valueScanner.disableIsolation(); if (signatureScanner != null) { signatureScanner.disableIsolation(); } } SignedScanner(Connector connector, String tableName, Authorizations authorizations, SignatureConfig signatureConfig, SignatureKeyContainer keys); @Override ItemProcessingIterator<Entry<Key,Value>> iterator(); @Override void addScanIterator(IteratorSetting cfg); @Override void clearColumns(); @Override void clearScanIterators(); @Override void close(); @Override void fetchColumn(Column column); @Override void fetchColumn(Text colFam, Text colQual); @Override void fetchColumnFamily(Text col); @Override Authorizations getAuthorizations(); @Override void setSamplerConfiguration(SamplerConfiguration samplerConfiguration); @Override SamplerConfiguration getSamplerConfiguration(); @Override void clearSamplerConfiguration(); @Override void setBatchTimeout(long l, TimeUnit timeUnit); @Override long getBatchTimeout(TimeUnit timeUnit); @Override void setClassLoaderContext(String s); @Override void clearClassLoaderContext(); @Override String getClassLoaderContext(); @Override long getTimeout(TimeUnit timeUnit); @Override void removeScanIterator(String iteratorName); @Override void updateScanIteratorOption(String iteratorName, String key, String value); @Override void setTimeout(long timeout, TimeUnit timeUnit); @Override void disableIsolation(); @Override void enableIsolation(); @Override int getBatchSize(); @Override Range getRange(); @Override long getReadaheadThreshold(); @Override @SuppressWarnings("deprecation") int getTimeOut(); @Override void setBatchSize(int size); @Override void setRange(Range range); @Override void setReadaheadThreshold(long batches); @Override @SuppressWarnings("deprecation") void setTimeOut(int timeOut); } | @Test public void disableIsolationTest() throws Exception { when(mockConnector.createScanner(TEST_TABLE, authorizations)).thenReturn(mockScanner); new SignedScanner(mockConnector, TEST_TABLE, authorizations, getConfig("config1.ini"), aliceKeyContainers.get(ValueSigner.RSA_PSS)).disableIsolation(); verify(mockScanner).disableIsolation(); }
@Test public void disableIsolationExternalTest() throws Exception { when(mockConnector.createScanner(TEST_TABLE, authorizations)).thenReturn(mockScanner); when(mockConnector.createScanner(SIG_TABLE, authorizations)).thenReturn(mockSignatureScanner); new SignedScanner(mockConnector, TEST_TABLE, authorizations, getConfig("config3.ini"), aliceKeyContainers.get(ValueSigner.RSA_PSS)).disableIsolation(); verify(mockScanner).disableIsolation(); verify(mockSignatureScanner).disableIsolation(); } |
SignedScanner implements Scanner { @Override public void enableIsolation() { valueScanner.enableIsolation(); if (signatureScanner != null) { signatureScanner.enableIsolation(); } } SignedScanner(Connector connector, String tableName, Authorizations authorizations, SignatureConfig signatureConfig, SignatureKeyContainer keys); @Override ItemProcessingIterator<Entry<Key,Value>> iterator(); @Override void addScanIterator(IteratorSetting cfg); @Override void clearColumns(); @Override void clearScanIterators(); @Override void close(); @Override void fetchColumn(Column column); @Override void fetchColumn(Text colFam, Text colQual); @Override void fetchColumnFamily(Text col); @Override Authorizations getAuthorizations(); @Override void setSamplerConfiguration(SamplerConfiguration samplerConfiguration); @Override SamplerConfiguration getSamplerConfiguration(); @Override void clearSamplerConfiguration(); @Override void setBatchTimeout(long l, TimeUnit timeUnit); @Override long getBatchTimeout(TimeUnit timeUnit); @Override void setClassLoaderContext(String s); @Override void clearClassLoaderContext(); @Override String getClassLoaderContext(); @Override long getTimeout(TimeUnit timeUnit); @Override void removeScanIterator(String iteratorName); @Override void updateScanIteratorOption(String iteratorName, String key, String value); @Override void setTimeout(long timeout, TimeUnit timeUnit); @Override void disableIsolation(); @Override void enableIsolation(); @Override int getBatchSize(); @Override Range getRange(); @Override long getReadaheadThreshold(); @Override @SuppressWarnings("deprecation") int getTimeOut(); @Override void setBatchSize(int size); @Override void setRange(Range range); @Override void setReadaheadThreshold(long batches); @Override @SuppressWarnings("deprecation") void setTimeOut(int timeOut); } | @Test public void enableIsolationTest() throws Exception { when(mockConnector.createScanner(TEST_TABLE, authorizations)).thenReturn(mockScanner); new SignedScanner(mockConnector, TEST_TABLE, authorizations, getConfig("config1.ini"), aliceKeyContainers.get(ValueSigner.RSA_PSS)).enableIsolation(); verify(mockScanner).enableIsolation(); }
@Test public void enableIsolationExternalTest() throws Exception { when(mockConnector.createScanner(TEST_TABLE, authorizations)).thenReturn(mockScanner); when(mockConnector.createScanner(SIG_TABLE, authorizations)).thenReturn(mockSignatureScanner); new SignedScanner(mockConnector, TEST_TABLE, authorizations, getConfig("config3.ini"), aliceKeyContainers.get(ValueSigner.RSA_PSS)).enableIsolation(); verify(mockScanner).enableIsolation(); verify(mockSignatureScanner).enableIsolation(); } |
SignedScanner implements Scanner { @Override public void setBatchSize(int size) { valueScanner.setBatchSize(size); if (signatureScanner != null) { signatureScanner.setBatchSize(size); } } SignedScanner(Connector connector, String tableName, Authorizations authorizations, SignatureConfig signatureConfig, SignatureKeyContainer keys); @Override ItemProcessingIterator<Entry<Key,Value>> iterator(); @Override void addScanIterator(IteratorSetting cfg); @Override void clearColumns(); @Override void clearScanIterators(); @Override void close(); @Override void fetchColumn(Column column); @Override void fetchColumn(Text colFam, Text colQual); @Override void fetchColumnFamily(Text col); @Override Authorizations getAuthorizations(); @Override void setSamplerConfiguration(SamplerConfiguration samplerConfiguration); @Override SamplerConfiguration getSamplerConfiguration(); @Override void clearSamplerConfiguration(); @Override void setBatchTimeout(long l, TimeUnit timeUnit); @Override long getBatchTimeout(TimeUnit timeUnit); @Override void setClassLoaderContext(String s); @Override void clearClassLoaderContext(); @Override String getClassLoaderContext(); @Override long getTimeout(TimeUnit timeUnit); @Override void removeScanIterator(String iteratorName); @Override void updateScanIteratorOption(String iteratorName, String key, String value); @Override void setTimeout(long timeout, TimeUnit timeUnit); @Override void disableIsolation(); @Override void enableIsolation(); @Override int getBatchSize(); @Override Range getRange(); @Override long getReadaheadThreshold(); @Override @SuppressWarnings("deprecation") int getTimeOut(); @Override void setBatchSize(int size); @Override void setRange(Range range); @Override void setReadaheadThreshold(long batches); @Override @SuppressWarnings("deprecation") void setTimeOut(int timeOut); } | @Test public void setBatchSizeTest() throws Exception { when(mockConnector.createScanner(TEST_TABLE, authorizations)).thenReturn(mockScanner); new SignedScanner(mockConnector, TEST_TABLE, authorizations, getConfig("config1.ini"), aliceKeyContainers.get(ValueSigner.RSA_PSS)).setBatchSize(5); verify(mockScanner).setBatchSize(5); }
@Test public void setBatchSizeExternalTest() throws Exception { when(mockConnector.createScanner(TEST_TABLE, authorizations)).thenReturn(mockScanner); when(mockConnector.createScanner(SIG_TABLE, authorizations)).thenReturn(mockSignatureScanner); new SignedScanner(mockConnector, TEST_TABLE, authorizations, getConfig("config3.ini"), aliceKeyContainers.get(ValueSigner.RSA_PSS)).setBatchSize(5); verify(mockScanner).setBatchSize(5); verify(mockSignatureScanner).setBatchSize(5); } |
SignedScanner implements Scanner { @Override public int getBatchSize() { return valueScanner.getBatchSize(); } SignedScanner(Connector connector, String tableName, Authorizations authorizations, SignatureConfig signatureConfig, SignatureKeyContainer keys); @Override ItemProcessingIterator<Entry<Key,Value>> iterator(); @Override void addScanIterator(IteratorSetting cfg); @Override void clearColumns(); @Override void clearScanIterators(); @Override void close(); @Override void fetchColumn(Column column); @Override void fetchColumn(Text colFam, Text colQual); @Override void fetchColumnFamily(Text col); @Override Authorizations getAuthorizations(); @Override void setSamplerConfiguration(SamplerConfiguration samplerConfiguration); @Override SamplerConfiguration getSamplerConfiguration(); @Override void clearSamplerConfiguration(); @Override void setBatchTimeout(long l, TimeUnit timeUnit); @Override long getBatchTimeout(TimeUnit timeUnit); @Override void setClassLoaderContext(String s); @Override void clearClassLoaderContext(); @Override String getClassLoaderContext(); @Override long getTimeout(TimeUnit timeUnit); @Override void removeScanIterator(String iteratorName); @Override void updateScanIteratorOption(String iteratorName, String key, String value); @Override void setTimeout(long timeout, TimeUnit timeUnit); @Override void disableIsolation(); @Override void enableIsolation(); @Override int getBatchSize(); @Override Range getRange(); @Override long getReadaheadThreshold(); @Override @SuppressWarnings("deprecation") int getTimeOut(); @Override void setBatchSize(int size); @Override void setRange(Range range); @Override void setReadaheadThreshold(long batches); @Override @SuppressWarnings("deprecation") void setTimeOut(int timeOut); } | @Test public void getBatchSizeTest() throws Exception { when(mockConnector.createScanner(TEST_TABLE, authorizations)).thenReturn(mockScanner); when(mockScanner.getBatchSize()).thenReturn(5); int value = new SignedScanner(mockConnector, TEST_TABLE, authorizations, getConfig("config1.ini"), aliceKeyContainers.get(ValueSigner.RSA_PSS)) .getBatchSize(); verify(mockScanner).getBatchSize(); assertThat("correct batch size returned", value, is(5)); } |
SignedScanner implements Scanner { @Override public void setRange(Range range) { valueScanner.setRange(range); if (signatureScanner != null) { signatureScanner.setRange(range); } } SignedScanner(Connector connector, String tableName, Authorizations authorizations, SignatureConfig signatureConfig, SignatureKeyContainer keys); @Override ItemProcessingIterator<Entry<Key,Value>> iterator(); @Override void addScanIterator(IteratorSetting cfg); @Override void clearColumns(); @Override void clearScanIterators(); @Override void close(); @Override void fetchColumn(Column column); @Override void fetchColumn(Text colFam, Text colQual); @Override void fetchColumnFamily(Text col); @Override Authorizations getAuthorizations(); @Override void setSamplerConfiguration(SamplerConfiguration samplerConfiguration); @Override SamplerConfiguration getSamplerConfiguration(); @Override void clearSamplerConfiguration(); @Override void setBatchTimeout(long l, TimeUnit timeUnit); @Override long getBatchTimeout(TimeUnit timeUnit); @Override void setClassLoaderContext(String s); @Override void clearClassLoaderContext(); @Override String getClassLoaderContext(); @Override long getTimeout(TimeUnit timeUnit); @Override void removeScanIterator(String iteratorName); @Override void updateScanIteratorOption(String iteratorName, String key, String value); @Override void setTimeout(long timeout, TimeUnit timeUnit); @Override void disableIsolation(); @Override void enableIsolation(); @Override int getBatchSize(); @Override Range getRange(); @Override long getReadaheadThreshold(); @Override @SuppressWarnings("deprecation") int getTimeOut(); @Override void setBatchSize(int size); @Override void setRange(Range range); @Override void setReadaheadThreshold(long batches); @Override @SuppressWarnings("deprecation") void setTimeOut(int timeOut); } | @Test public void setRangeTest() throws Exception { Range range = new Range("test"); when(mockConnector.createScanner(TEST_TABLE, authorizations)).thenReturn(mockScanner); new SignedScanner(mockConnector, TEST_TABLE, authorizations, getConfig("config1.ini"), aliceKeyContainers.get(ValueSigner.RSA_PSS)).setRange(range); verify(mockScanner).setRange(range); }
@Test public void setRangeExternalTest() throws Exception { Range range = new Range("test"); when(mockConnector.createScanner(TEST_TABLE, authorizations)).thenReturn(mockScanner); when(mockConnector.createScanner(SIG_TABLE, authorizations)).thenReturn(mockSignatureScanner); new SignedScanner(mockConnector, TEST_TABLE, authorizations, getConfig("config3.ini"), aliceKeyContainers.get(ValueSigner.RSA_PSS)).setRange(range); verify(mockScanner).setRange(range); verify(mockSignatureScanner).setRange(range); } |
SignedScanner implements Scanner { @Override public Range getRange() { return valueScanner.getRange(); } SignedScanner(Connector connector, String tableName, Authorizations authorizations, SignatureConfig signatureConfig, SignatureKeyContainer keys); @Override ItemProcessingIterator<Entry<Key,Value>> iterator(); @Override void addScanIterator(IteratorSetting cfg); @Override void clearColumns(); @Override void clearScanIterators(); @Override void close(); @Override void fetchColumn(Column column); @Override void fetchColumn(Text colFam, Text colQual); @Override void fetchColumnFamily(Text col); @Override Authorizations getAuthorizations(); @Override void setSamplerConfiguration(SamplerConfiguration samplerConfiguration); @Override SamplerConfiguration getSamplerConfiguration(); @Override void clearSamplerConfiguration(); @Override void setBatchTimeout(long l, TimeUnit timeUnit); @Override long getBatchTimeout(TimeUnit timeUnit); @Override void setClassLoaderContext(String s); @Override void clearClassLoaderContext(); @Override String getClassLoaderContext(); @Override long getTimeout(TimeUnit timeUnit); @Override void removeScanIterator(String iteratorName); @Override void updateScanIteratorOption(String iteratorName, String key, String value); @Override void setTimeout(long timeout, TimeUnit timeUnit); @Override void disableIsolation(); @Override void enableIsolation(); @Override int getBatchSize(); @Override Range getRange(); @Override long getReadaheadThreshold(); @Override @SuppressWarnings("deprecation") int getTimeOut(); @Override void setBatchSize(int size); @Override void setRange(Range range); @Override void setReadaheadThreshold(long batches); @Override @SuppressWarnings("deprecation") void setTimeOut(int timeOut); } | @Test public void getRangeTest() throws Exception { Range range = new Range("test"); when(mockConnector.createScanner(TEST_TABLE, authorizations)).thenReturn(mockScanner); when(mockScanner.getRange()).thenReturn(range); Range value = new SignedScanner(mockConnector, TEST_TABLE, authorizations, getConfig("config1.ini"), aliceKeyContainers.get(ValueSigner.RSA_PSS)) .getRange(); verify(mockScanner).getRange(); assertThat("correct range returned", value, equalTo(range)); } |
SignedScanner implements Scanner { @Override public void setReadaheadThreshold(long batches) { valueScanner.setReadaheadThreshold(batches); if (signatureScanner != null) { signatureScanner.setReadaheadThreshold(batches); } } SignedScanner(Connector connector, String tableName, Authorizations authorizations, SignatureConfig signatureConfig, SignatureKeyContainer keys); @Override ItemProcessingIterator<Entry<Key,Value>> iterator(); @Override void addScanIterator(IteratorSetting cfg); @Override void clearColumns(); @Override void clearScanIterators(); @Override void close(); @Override void fetchColumn(Column column); @Override void fetchColumn(Text colFam, Text colQual); @Override void fetchColumnFamily(Text col); @Override Authorizations getAuthorizations(); @Override void setSamplerConfiguration(SamplerConfiguration samplerConfiguration); @Override SamplerConfiguration getSamplerConfiguration(); @Override void clearSamplerConfiguration(); @Override void setBatchTimeout(long l, TimeUnit timeUnit); @Override long getBatchTimeout(TimeUnit timeUnit); @Override void setClassLoaderContext(String s); @Override void clearClassLoaderContext(); @Override String getClassLoaderContext(); @Override long getTimeout(TimeUnit timeUnit); @Override void removeScanIterator(String iteratorName); @Override void updateScanIteratorOption(String iteratorName, String key, String value); @Override void setTimeout(long timeout, TimeUnit timeUnit); @Override void disableIsolation(); @Override void enableIsolation(); @Override int getBatchSize(); @Override Range getRange(); @Override long getReadaheadThreshold(); @Override @SuppressWarnings("deprecation") int getTimeOut(); @Override void setBatchSize(int size); @Override void setRange(Range range); @Override void setReadaheadThreshold(long batches); @Override @SuppressWarnings("deprecation") void setTimeOut(int timeOut); } | @Test public void setReadaheadThresholdTest() throws Exception { when(mockConnector.createScanner(TEST_TABLE, authorizations)).thenReturn(mockScanner); new SignedScanner(mockConnector, TEST_TABLE, authorizations, getConfig("config1.ini"), aliceKeyContainers.get(ValueSigner.RSA_PSS)) .setReadaheadThreshold(5L); verify(mockScanner).setReadaheadThreshold(5L); }
@Test public void setReadaheadThresholdExternalTest() throws Exception { when(mockConnector.createScanner(TEST_TABLE, authorizations)).thenReturn(mockScanner); when(mockConnector.createScanner(SIG_TABLE, authorizations)).thenReturn(mockSignatureScanner); new SignedScanner(mockConnector, TEST_TABLE, authorizations, getConfig("config3.ini"), aliceKeyContainers.get(ValueSigner.RSA_PSS)) .setReadaheadThreshold(5L); verify(mockScanner).setReadaheadThreshold(5L); verify(mockSignatureScanner).setReadaheadThreshold(5L); } |
SignedScanner implements Scanner { @Override public long getReadaheadThreshold() { return valueScanner.getReadaheadThreshold(); } SignedScanner(Connector connector, String tableName, Authorizations authorizations, SignatureConfig signatureConfig, SignatureKeyContainer keys); @Override ItemProcessingIterator<Entry<Key,Value>> iterator(); @Override void addScanIterator(IteratorSetting cfg); @Override void clearColumns(); @Override void clearScanIterators(); @Override void close(); @Override void fetchColumn(Column column); @Override void fetchColumn(Text colFam, Text colQual); @Override void fetchColumnFamily(Text col); @Override Authorizations getAuthorizations(); @Override void setSamplerConfiguration(SamplerConfiguration samplerConfiguration); @Override SamplerConfiguration getSamplerConfiguration(); @Override void clearSamplerConfiguration(); @Override void setBatchTimeout(long l, TimeUnit timeUnit); @Override long getBatchTimeout(TimeUnit timeUnit); @Override void setClassLoaderContext(String s); @Override void clearClassLoaderContext(); @Override String getClassLoaderContext(); @Override long getTimeout(TimeUnit timeUnit); @Override void removeScanIterator(String iteratorName); @Override void updateScanIteratorOption(String iteratorName, String key, String value); @Override void setTimeout(long timeout, TimeUnit timeUnit); @Override void disableIsolation(); @Override void enableIsolation(); @Override int getBatchSize(); @Override Range getRange(); @Override long getReadaheadThreshold(); @Override @SuppressWarnings("deprecation") int getTimeOut(); @Override void setBatchSize(int size); @Override void setRange(Range range); @Override void setReadaheadThreshold(long batches); @Override @SuppressWarnings("deprecation") void setTimeOut(int timeOut); } | @Test public void getReadaheadThresholdTest() throws Exception { when(mockConnector.createScanner(TEST_TABLE, authorizations)).thenReturn(mockScanner); when(mockScanner.getReadaheadThreshold()).thenReturn(5L); long value = new SignedScanner(mockConnector, TEST_TABLE, authorizations, getConfig("config1.ini"), aliceKeyContainers.get(ValueSigner.RSA_PSS)) .getReadaheadThreshold(); verify(mockScanner).getReadaheadThreshold(); assertThat("correct threshold returned", value, is(5L)); } |
SignedBatchScanner implements BatchScanner { @Override public ItemProcessingIterator<Entry<Key,Value>> iterator() { if (signatureScanner != null) { return new SignedExternalScannerIterator(valueScanner.iterator(), signatureScanner.iterator(), verifier, false); } else { return new SignedInlineScannerIterator(valueScanner.iterator(), verifier); } } SignedBatchScanner(Connector connector, String tableName, Authorizations authorizations, int numQueryThreads, SignatureConfig signatureConfig,
SignatureKeyContainer keys); @Override ItemProcessingIterator<Entry<Key,Value>> iterator(); @Override void addScanIterator(IteratorSetting cfg); @Override void clearColumns(); @Override void clearScanIterators(); @Override void setRanges(Collection<Range> collection); @Override void close(); @Override void fetchColumn(Column column); @Override void fetchColumn(Text colFam, Text colQual); @Override void fetchColumnFamily(Text col); @Override Authorizations getAuthorizations(); @Override void setSamplerConfiguration(SamplerConfiguration samplerConfiguration); @Override SamplerConfiguration getSamplerConfiguration(); @Override void clearSamplerConfiguration(); @Override void setBatchTimeout(long l, TimeUnit timeUnit); @Override long getBatchTimeout(TimeUnit timeUnit); @Override void setClassLoaderContext(String s); @Override void clearClassLoaderContext(); @Override String getClassLoaderContext(); @Override long getTimeout(TimeUnit timeUnit); @Override void removeScanIterator(String iteratorName); @Override void updateScanIteratorOption(String iteratorName, String key, String value); @Override void setTimeout(long timeout, TimeUnit timeUnit); } | @Test public void iteratorTest() throws Exception { when(mockConnector.createBatchScanner(TEST_TABLE, authorizations, 1)).thenReturn(mockScanner); EntrySigner signer = new EntrySigner(getConfig("config1.ini"), aliceKeyContainers.get(ValueSigner.RSA_PSS)); List<Entry<Key,Value>> entries = new ArrayList<>(); Entry<Key,Value> entry = new SimpleImmutableEntry<>(new Key(new byte[] {1}, new byte[] {2}, new byte[] {3}, "secret".getBytes(Utils.VISIBILITY_CHARSET), 0, false, false), new Value(new byte[] {4})); Entry<Key,Value> entry2 = new SimpleImmutableEntry<>(new Key(new byte[] {5}, new byte[] {6}, new byte[] {7}, "secret".getBytes(Utils.VISIBILITY_CHARSET), 0, false, false), new Value(new byte[] {8})); entries.add(signer.sign(entry, true)); entries.add(signer.sign(entry2, true)); when(mockScanner.iterator()).thenReturn(entries.iterator()).thenReturn(entries.iterator()); BatchScanner scanner = new SignedBatchScanner(mockConnector, TEST_TABLE, authorizations, 1, getConfig("config1.ini"), aliceKeyContainers.get(ValueSigner.RSA_PSS)); assertThat("has correct number of elements", scanner, iterableWithSize(2)); Iterator<Entry<Key,Value>> iterator = scanner.iterator(); assertThat("correct item", iterator.next(), Matchers.equalTo(entry)); assertThat("correct item", iterator.next(), Matchers.equalTo(entry2)); }
@Test public void iteratorExternalTest() throws Exception { when(mockConnector.createBatchScanner(TEST_TABLE, authorizations, 1)).thenReturn(mockScanner); when(mockConnector.createBatchScanner(SIG_TABLE, authorizations, 1)).thenReturn(mockSignatureScanner); EntrySigner signer = new EntrySigner(getConfig("config3.ini"), aliceKeyContainers.get(ValueSigner.ECDSA)); List<Entry<Key,Value>> entries = new ArrayList<>(); List<Entry<Key,Value>> signedEntries = new ArrayList<>(); Entry<Key,Value> entry = new SimpleImmutableEntry<>(new Key(new byte[] {1}, new byte[] {2}, new byte[] {3}, "secret".getBytes(Utils.VISIBILITY_CHARSET), 0, false, false), new Value(new byte[] {4})); Entry<Key,Value> entry2 = new SimpleImmutableEntry<>(new Key(new byte[] {5}, new byte[] {6}, new byte[] {7}, "secret".getBytes(Utils.VISIBILITY_CHARSET), 0, false, false), new Value(new byte[] {8})); entries.add(entry); entries.add(entry2); signedEntries.add(signer.sign(entry, true)); signedEntries.add(signer.sign(entry2, true)); when(mockScanner.iterator()).thenReturn(entries.iterator()).thenReturn(entries.iterator()); when(mockSignatureScanner.iterator()).thenReturn(signedEntries.iterator()).thenReturn(signedEntries.iterator()); BatchScanner scanner = new SignedBatchScanner(mockConnector, TEST_TABLE, authorizations, 1, getConfig("config3.ini"), aliceKeyContainers.get(ValueSigner.ECDSA)); assertThat("has correct number of elements", scanner, iterableWithSize(2)); Iterator<Entry<Key,Value>> iterator = scanner.iterator(); assertThat("correct item", iterator.next(), Matchers.equalTo(entry)); assertThat("correct item", iterator.next(), Matchers.equalTo(entry2)); } |
SignedBatchScanner implements BatchScanner { @Override public void addScanIterator(IteratorSetting cfg) { valueScanner.addScanIterator(cfg); if (signatureScanner != null) { signatureScanner.addScanIterator(cfg); } } SignedBatchScanner(Connector connector, String tableName, Authorizations authorizations, int numQueryThreads, SignatureConfig signatureConfig,
SignatureKeyContainer keys); @Override ItemProcessingIterator<Entry<Key,Value>> iterator(); @Override void addScanIterator(IteratorSetting cfg); @Override void clearColumns(); @Override void clearScanIterators(); @Override void setRanges(Collection<Range> collection); @Override void close(); @Override void fetchColumn(Column column); @Override void fetchColumn(Text colFam, Text colQual); @Override void fetchColumnFamily(Text col); @Override Authorizations getAuthorizations(); @Override void setSamplerConfiguration(SamplerConfiguration samplerConfiguration); @Override SamplerConfiguration getSamplerConfiguration(); @Override void clearSamplerConfiguration(); @Override void setBatchTimeout(long l, TimeUnit timeUnit); @Override long getBatchTimeout(TimeUnit timeUnit); @Override void setClassLoaderContext(String s); @Override void clearClassLoaderContext(); @Override String getClassLoaderContext(); @Override long getTimeout(TimeUnit timeUnit); @Override void removeScanIterator(String iteratorName); @Override void updateScanIteratorOption(String iteratorName, String key, String value); @Override void setTimeout(long timeout, TimeUnit timeUnit); } | @Test public void addScanIteratorTest() throws Exception { when(mockConnector.createBatchScanner(TEST_TABLE, authorizations, 1)).thenReturn(mockScanner); IteratorSetting test = new IteratorSetting(10, "test", "test2"); new SignedBatchScanner(mockConnector, TEST_TABLE, authorizations, 1, getConfig("config1.ini"), aliceKeyContainers.get(ValueSigner.RSA_PSS)) .addScanIterator(test); verify(mockScanner).addScanIterator(test); }
@Test public void addScanIteratorExternalTest() throws Exception { when(mockConnector.createBatchScanner(TEST_TABLE, authorizations, 1)).thenReturn(mockScanner); when(mockConnector.createBatchScanner(SIG_TABLE, authorizations, 1)).thenReturn(mockSignatureScanner); IteratorSetting test = new IteratorSetting(10, "test", "test2"); new SignedBatchScanner(mockConnector, TEST_TABLE, authorizations, 1, getConfig("config3.ini"), aliceKeyContainers.get(ValueSigner.RSA_PSS)) .addScanIterator(test); verify(mockScanner).addScanIterator(test); verify(mockSignatureScanner).addScanIterator(test); } |
SignedScanner implements Scanner { @Override public void addScanIterator(IteratorSetting cfg) { valueScanner.addScanIterator(cfg); if (signatureScanner != null) { signatureScanner.addScanIterator(cfg); } } SignedScanner(Connector connector, String tableName, Authorizations authorizations, SignatureConfig signatureConfig, SignatureKeyContainer keys); @Override ItemProcessingIterator<Entry<Key,Value>> iterator(); @Override void addScanIterator(IteratorSetting cfg); @Override void clearColumns(); @Override void clearScanIterators(); @Override void close(); @Override void fetchColumn(Column column); @Override void fetchColumn(Text colFam, Text colQual); @Override void fetchColumnFamily(Text col); @Override Authorizations getAuthorizations(); @Override void setSamplerConfiguration(SamplerConfiguration samplerConfiguration); @Override SamplerConfiguration getSamplerConfiguration(); @Override void clearSamplerConfiguration(); @Override void setBatchTimeout(long l, TimeUnit timeUnit); @Override long getBatchTimeout(TimeUnit timeUnit); @Override void setClassLoaderContext(String s); @Override void clearClassLoaderContext(); @Override String getClassLoaderContext(); @Override long getTimeout(TimeUnit timeUnit); @Override void removeScanIterator(String iteratorName); @Override void updateScanIteratorOption(String iteratorName, String key, String value); @Override void setTimeout(long timeout, TimeUnit timeUnit); @Override void disableIsolation(); @Override void enableIsolation(); @Override int getBatchSize(); @Override Range getRange(); @Override long getReadaheadThreshold(); @Override @SuppressWarnings("deprecation") int getTimeOut(); @Override void setBatchSize(int size); @Override void setRange(Range range); @Override void setReadaheadThreshold(long batches); @Override @SuppressWarnings("deprecation") void setTimeOut(int timeOut); } | @Test public void addScanIteratorTest() throws Exception { when(mockConnector.createScanner(TEST_TABLE, authorizations)).thenReturn(mockScanner); IteratorSetting test = new IteratorSetting(10, "test", "test2"); new SignedScanner(mockConnector, TEST_TABLE, authorizations, getConfig("config1.ini"), aliceKeyContainers.get(ValueSigner.RSA_PSS)).addScanIterator(test); verify(mockScanner).addScanIterator(test); }
@Test public void addScanIteratorExternalTest() throws Exception { when(mockConnector.createScanner(TEST_TABLE, authorizations)).thenReturn(mockScanner); when(mockConnector.createScanner(SIG_TABLE, authorizations)).thenReturn(mockSignatureScanner); IteratorSetting test = new IteratorSetting(10, "test", "test2"); new SignedScanner(mockConnector, TEST_TABLE, authorizations, getConfig("config3.ini"), aliceKeyContainers.get(ValueSigner.RSA_PSS)).addScanIterator(test); verify(mockScanner).addScanIterator(test); verify(mockSignatureScanner).addScanIterator(test); } |
SignedBatchScanner implements BatchScanner { @Override public void clearColumns() { valueScanner.clearColumns(); if (signatureScanner != null) { signatureScanner.clearColumns(); } } SignedBatchScanner(Connector connector, String tableName, Authorizations authorizations, int numQueryThreads, SignatureConfig signatureConfig,
SignatureKeyContainer keys); @Override ItemProcessingIterator<Entry<Key,Value>> iterator(); @Override void addScanIterator(IteratorSetting cfg); @Override void clearColumns(); @Override void clearScanIterators(); @Override void setRanges(Collection<Range> collection); @Override void close(); @Override void fetchColumn(Column column); @Override void fetchColumn(Text colFam, Text colQual); @Override void fetchColumnFamily(Text col); @Override Authorizations getAuthorizations(); @Override void setSamplerConfiguration(SamplerConfiguration samplerConfiguration); @Override SamplerConfiguration getSamplerConfiguration(); @Override void clearSamplerConfiguration(); @Override void setBatchTimeout(long l, TimeUnit timeUnit); @Override long getBatchTimeout(TimeUnit timeUnit); @Override void setClassLoaderContext(String s); @Override void clearClassLoaderContext(); @Override String getClassLoaderContext(); @Override long getTimeout(TimeUnit timeUnit); @Override void removeScanIterator(String iteratorName); @Override void updateScanIteratorOption(String iteratorName, String key, String value); @Override void setTimeout(long timeout, TimeUnit timeUnit); } | @Test public void clearColumns() throws Exception { when(mockConnector.createBatchScanner(TEST_TABLE, authorizations, 1)).thenReturn(mockScanner); new SignedBatchScanner(mockConnector, TEST_TABLE, authorizations, 1, getConfig("config1.ini"), aliceKeyContainers.get(ValueSigner.RSA_PSS)).clearColumns(); verify(mockScanner).clearColumns(); }
@Test public void clearExternalColumns() throws Exception { when(mockConnector.createBatchScanner(TEST_TABLE, authorizations, 1)).thenReturn(mockScanner); when(mockConnector.createBatchScanner(SIG_TABLE, authorizations, 1)).thenReturn(mockSignatureScanner); new SignedBatchScanner(mockConnector, TEST_TABLE, authorizations, 1, getConfig("config3.ini"), aliceKeyContainers.get(ValueSigner.RSA_PSS)).clearColumns(); verify(mockScanner).clearColumns(); verify(mockSignatureScanner).clearColumns(); } |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.