method2testcases
stringlengths 118
6.63k
|
|---|
### Question:
MinikubeExtension { public Map<String, String> getDockerEnv() throws IOException, InterruptedException { return getDockerEnv(""); } MinikubeExtension(Project project, CommandExecutorFactory commandExecutorFactory); String getMinikube(); void setMinikube(String minikube); Property<String> getMinikubeProvider(); Map<String, String> getDockerEnv(); Map<String, String> getDockerEnv(String profile); }### Answer:
@Test public void testGetDockerEnvWithDefaultProfile() throws IOException, InterruptedException { expectedCommand.add("--profile="); when(commandExecutorMock.run(expectedCommand)).thenReturn(dockerEnvOutput); Assert.assertEquals(expectedMap, minikube.getDockerEnv()); verify(commandExecutorMock).run(expectedCommand); }
@Test public void testGetDockerEnvWithTestProfile() throws IOException, InterruptedException { String profile = "testProfile"; expectedCommand.add("--profile=".concat(profile)); when(commandExecutorMock.run(expectedCommand)).thenReturn(dockerEnvOutput); Assert.assertEquals(expectedMap, minikube.getDockerEnv(profile)); verify(commandExecutorMock).run(expectedCommand); }
@Test public void testGetSameDockerEnvWithTwoDefaultProfiles() throws IOException, InterruptedException { String profile = ""; expectedCommand.add("--profile=".concat(profile)); when(commandExecutorMock.run(expectedCommand)).thenReturn(dockerEnvOutput); Assert.assertEquals(minikube.getDockerEnv(), minikube.getDockerEnv(profile)); verify(commandExecutorMock, times(2)).run(expectedCommand); }
@Test public void testGetDockerEnvWithNullProfile() throws IOException, InterruptedException { try { minikube.getDockerEnv(null); Assert.fail("getDockerEnv() should not permit null values"); } catch (NullPointerException ex) { Assert.assertNotNull(ex.getMessage()); Assert.assertEquals("Minikube profile must not be null", ex.getMessage()); } } |
### Question:
DefaultedURL { @Override public boolean equals(Object o) { if (o instanceof DefaultedURL) { return url.equals(((DefaultedURL) o).getUrl()); } return false; } DefaultedURL(); boolean isDefault(); void setUrl(URL url); String getDomain(); URL getUrl(); @Override String toString(); @Override boolean equals(Object o); }### Answer:
@Test public void testEquals_true() throws MalformedURLException { DefaultedURL defaultedURL = new DefaultedURL(); DefaultedURL customURL = new DefaultedURL(); assertTrue(defaultedURL.equals(customURL)); } |
### Question:
GatewaysManager { public Gateway select(int nClosest) { Connection.TransportType transportType = getUsePluggableTransports(context) ? OBFS4 : OPENVPN; if (presortedList.size() > 0) { return getGatewayFromPresortedList(nClosest, transportType); } return getGatewayFromTimezoneCalculation(nClosest, transportType); } GatewaysManager(Context context); Gateway select(int nClosest); int getPosition(VpnProfile profile); boolean isEmpty(); int size(); @Override String toString(); }### Answer:
@Test public void TestSelectN_selectFirstObfs4Connection_returnThirdGateway() { Provider provider = getProvider(null, null, null, null, null, null, "ptdemo_two_openvpn_one_pt_gateways.json", null); MockHelper.mockProviderObserver(provider); mockStatic(PreferenceHelper.class); when(PreferenceHelper.getUsePluggableTransports(any(Context.class))).thenReturn(true); GatewaysManager gatewaysManager = new GatewaysManager(mockContext); assertEquals("37.12.247.10", gatewaysManager.select(0).getRemoteIP()); }
@Test public void testSelectN_selectFromPresortedGateways_returnsGatewaysInPresortedOrder() { Provider provider = getProvider(null, null, null, null, null, null, "ptdemo_three_mixed_gateways.json", "ptdemo_three_mixed_gateways.geoip.json"); MockHelper.mockProviderObserver(provider); mockStatic(PreferenceHelper.class); when(PreferenceHelper.getUsePluggableTransports(any(Context.class))).thenReturn(false); GatewaysManager gatewaysManager = new GatewaysManager(mockContext); assertEquals("manila.bitmask.net", gatewaysManager.select(0).getHost()); assertEquals("moscow.bitmask.net", gatewaysManager.select(1).getHost()); assertEquals("pt.demo.bitmask.net", gatewaysManager.select(2).getHost()); }
@Test public void testSelectN_selectObfs4FromPresortedGateways_returnsObfs4GatewaysInPresortedOrder() { Provider provider = getProvider(null, null, null, null, null, null, "ptdemo_three_mixed_gateways.json", "ptdemo_three_mixed_gateways.geoip.json"); MockHelper.mockProviderObserver(provider); mockStatic(PreferenceHelper.class); when(PreferenceHelper.getUsePluggableTransports(any(Context.class))).thenReturn(true); GatewaysManager gatewaysManager = new GatewaysManager(mockContext); assertEquals("moscow.bitmask.net", gatewaysManager.select(0).getHost()); assertEquals("pt.demo.bitmask.net", gatewaysManager.select(1).getHost()); assertNull(gatewaysManager.select(2)); } |
### Question:
GatewaysManager { public int size() { return gateways.size(); } GatewaysManager(Context context); Gateway select(int nClosest); int getPosition(VpnProfile profile); boolean isEmpty(); int size(); @Override String toString(); }### Answer:
@Test public void testGatewayManagerFromCurrentProvider_noProvider_noGateways() { MockHelper.mockProviderObserver(null); GatewaysManager gatewaysManager = new GatewaysManager(mockContext); assertEquals(0, gatewaysManager.size()); }
@Test public void testGatewayManagerFromCurrentProvider_misconfiguredProvider_noGateways() throws IOException, NullPointerException { Provider provider = getProvider(null, null, null, null, null, null, "ptdemo_misconfigured_gateway.json", null); MockHelper.mockProviderObserver(provider); GatewaysManager gatewaysManager = new GatewaysManager(mockContext); assertEquals(0, gatewaysManager.size()); }
@Test public void testGatewayManagerFromCurrentProvider_threeGateways() { Provider provider = getProvider(null, null, null, null,null, null, "ptdemo_three_mixed_gateways.json", null); MockHelper.mockProviderObserver(provider); GatewaysManager gatewaysManager = new GatewaysManager(mockContext); assertEquals(3, gatewaysManager.size()); } |
### Question:
GatewaySelector { public Gateway select() { return closestGateway(); } GatewaySelector(List<Gateway> gateways); Gateway select(); Gateway select(int nClosest); }### Answer:
@Test @UseDataProvider("dataProviderTimezones") public void testSelect(int timezone, String expected) { when(ConfigHelper.getCurrentTimezone()).thenReturn(timezone); gatewaySelector = new GatewaySelector(gatewayList); assertEquals(expected, gatewaySelector.select().getName()); }
@Test @UseDataProvider("dataProviderSameDistanceTimezones") public void testSelectSameTimezoneDistance(int timezone, String expected1, String expected2) { when(ConfigHelper.getCurrentTimezone()).thenReturn(timezone); gatewaySelector = new GatewaySelector(gatewayList); assertTrue(gatewaySelector.select().getName().equals(expected1) || gatewaySelector.select().getName().equals(expected2)); }
@Test @UseDataProvider("dataProviderSameDistanceTimezones") public void testNClostest_SameTimezoneDistance_chooseGatewayWithSameDistance(int timezone, String expected1, String expected2) { when(ConfigHelper.getCurrentTimezone()).thenReturn(timezone); gatewaySelector = new GatewaySelector(gatewayList); ArrayList<String> gateways = new ArrayList<>(); gateways.add(gatewaySelector.select(0).getName()); gateways.add(gatewaySelector.select(1).getName()); assertTrue(gateways.contains(expected1) && gateways.contains(expected2)); }
@Test public void testNClostest_OneTimezonePerSet_choseSecondClosestTimezone() { when(ConfigHelper.getCurrentTimezone()).thenReturn(-4); gatewaySelector = new GatewaySelector(gatewayList); assertTrue("Frankfurt".equals(gatewaySelector.select(1).getName())); } |
### Question:
Provider implements Parcelable { @Override public boolean equals(Object o) { if (o instanceof Provider) { Provider p = (Provider) o; return p.getDomain().equals(getDomain()) && definition.toString().equals(p.getDefinition().toString()) && eipServiceJson.toString().equals(p.getEipServiceJsonString()) && geoIpJson.toString().equals(p.getGeoIpJsonString()) && providerIp.equals(p.getProviderIp()) && providerApiIp.equals(p.getProviderApiIp()) && apiUrl.equals(p.getApiUrl()) && geoipUrl.equals(p.getGeoipUrl()) && certificatePin.equals(p.getCertificatePin()) && certificatePinEncoding.equals(p.getCertificatePinEncoding()) && caCert.equals(p.getCaCert()) && apiVersion.equals(p.getApiVersion()) && privateKey.equals(p.getPrivateKey()) && vpnCertificate.equals(p.getVpnCertificate()) && allowAnonymous == p.allowsAnonymous() && allowRegistered == p.allowsRegistered(); } else return false; } Provider(); Provider(String mainUrl); Provider(String mainUrl, String geoipUrl); Provider(String mainUrl, String providerIp, String providerApiIp); Provider(String mainUrl, String geoipUrl, String providerIp, String providerApiIp); Provider(String mainUrl, String geoipUrl, String providerIp, String providerApiIp, String caCert, String definition); private Provider(Parcel in); boolean isConfigured(); boolean supportsPluggableTransports(); String getIpForHostname(String host); String getProviderApiIp(); void setProviderApiIp(String providerApiIp); void setProviderIp(String providerIp); String getProviderIp(); void setMainUrl(URL url); void setMainUrl(String url); boolean define(JSONObject providerJson); JSONObject getDefinition(); String getDefinitionString(); String getDomain(); String getMainUrlString(); DefaultedURL getMainUrl(); DefaultedURL getGeoipUrl(); void setGeoipUrl(String url); String getApiUrlString(); String getApiVersion(); boolean hasDefinition(); boolean hasGeoIpJson(); String getCaCert(); String getName(); @Override int describeContents(); @Override void writeToParcel(Parcel parcel, int i); @Override boolean equals(Object o); JSONObject toJson(); @Override int hashCode(); @Override String toString(); void setCaCert(String cert); boolean allowsAnonymous(); boolean allowsRegistered(); void setLastEipServiceUpdate(long timestamp); boolean shouldUpdateEipServiceJson(); void setLastGeoIpUpdate(long timestamp); boolean shouldUpdateGeoIpJson(); boolean setEipServiceJson(JSONObject eipServiceJson); boolean setGeoIpJson(JSONObject geoIpJson); JSONObject getEipServiceJson(); JSONObject getGeoIpJson(); String getGeoIpJsonString(); String getEipServiceJsonString(); boolean isDefault(); String getPrivateKey(); void setPrivateKey(String privateKey); boolean hasPrivateKey(); String getVpnCertificate(); void setVpnCertificate(String vpnCertificate); boolean hasVpnCertificate(); String getCertificatePin(); String getCertificatePinEncoding(); String getCaCertFingerprint(); void reset(); final static String API_URL; static final Parcelable.Creator<Provider> CREATOR; }### Answer:
@Test public void testEquals_sameFields_returnsTrue() throws Exception { Provider p1 = TestSetupHelper.getConfiguredProvider(); Provider p2 = TestSetupHelper.getConfiguredProvider(); assertTrue("Providers should be same:", p1.equals(p2)); } |
### Question:
Provider implements Parcelable { public void setMainUrl(URL url) { mainUrl.setUrl(url); } Provider(); Provider(String mainUrl); Provider(String mainUrl, String geoipUrl); Provider(String mainUrl, String providerIp, String providerApiIp); Provider(String mainUrl, String geoipUrl, String providerIp, String providerApiIp); Provider(String mainUrl, String geoipUrl, String providerIp, String providerApiIp, String caCert, String definition); private Provider(Parcel in); boolean isConfigured(); boolean supportsPluggableTransports(); String getIpForHostname(String host); String getProviderApiIp(); void setProviderApiIp(String providerApiIp); void setProviderIp(String providerIp); String getProviderIp(); void setMainUrl(URL url); void setMainUrl(String url); boolean define(JSONObject providerJson); JSONObject getDefinition(); String getDefinitionString(); String getDomain(); String getMainUrlString(); DefaultedURL getMainUrl(); DefaultedURL getGeoipUrl(); void setGeoipUrl(String url); String getApiUrlString(); String getApiVersion(); boolean hasDefinition(); boolean hasGeoIpJson(); String getCaCert(); String getName(); @Override int describeContents(); @Override void writeToParcel(Parcel parcel, int i); @Override boolean equals(Object o); JSONObject toJson(); @Override int hashCode(); @Override String toString(); void setCaCert(String cert); boolean allowsAnonymous(); boolean allowsRegistered(); void setLastEipServiceUpdate(long timestamp); boolean shouldUpdateEipServiceJson(); void setLastGeoIpUpdate(long timestamp); boolean shouldUpdateGeoIpJson(); boolean setEipServiceJson(JSONObject eipServiceJson); boolean setGeoIpJson(JSONObject geoIpJson); JSONObject getEipServiceJson(); JSONObject getGeoIpJson(); String getGeoIpJsonString(); String getEipServiceJsonString(); boolean isDefault(); String getPrivateKey(); void setPrivateKey(String privateKey); boolean hasPrivateKey(); String getVpnCertificate(); void setVpnCertificate(String vpnCertificate); boolean hasVpnCertificate(); String getCertificatePin(); String getCertificatePinEncoding(); String getCaCertFingerprint(); void reset(); final static String API_URL; static final Parcelable.Creator<Provider> CREATOR; }### Answer:
@Test public void testEqualsThroughSetContains_differentFields_returnsFalse() throws Exception { Provider p1 = TestSetupHelper.getConfiguredProvider(); Provider p2 = TestSetupHelper.getConfiguredProvider(); p2.setMainUrl("http: Provider p3 = new Provider("https: Set<Provider> defaultProviders = new HashSet<>(); defaultProviders.add(p1); defaultProviders.add(p2); assertTrue(defaultProviders.contains(p1)); assertTrue(defaultProviders.contains(p2)); assertFalse(defaultProviders.contains(p3)); } |
### Question:
Provider implements Parcelable { public boolean supportsPluggableTransports() { try { JSONArray gatewayJsons = eipServiceJson.getJSONArray(GATEWAYS); for (int i = 0; i < gatewayJsons.length(); i++) { JSONArray transports = gatewayJsons.getJSONObject(i). getJSONObject(CAPABILITIES). getJSONArray(TRANSPORT); for (int j = 0; j < transports.length(); j++) { if (OBFS4.toString().equals(transports.getJSONObject(j).getString(TYPE))) { return true; } } } } catch (Exception e) { } return false; } Provider(); Provider(String mainUrl); Provider(String mainUrl, String geoipUrl); Provider(String mainUrl, String providerIp, String providerApiIp); Provider(String mainUrl, String geoipUrl, String providerIp, String providerApiIp); Provider(String mainUrl, String geoipUrl, String providerIp, String providerApiIp, String caCert, String definition); private Provider(Parcel in); boolean isConfigured(); boolean supportsPluggableTransports(); String getIpForHostname(String host); String getProviderApiIp(); void setProviderApiIp(String providerApiIp); void setProviderIp(String providerIp); String getProviderIp(); void setMainUrl(URL url); void setMainUrl(String url); boolean define(JSONObject providerJson); JSONObject getDefinition(); String getDefinitionString(); String getDomain(); String getMainUrlString(); DefaultedURL getMainUrl(); DefaultedURL getGeoipUrl(); void setGeoipUrl(String url); String getApiUrlString(); String getApiVersion(); boolean hasDefinition(); boolean hasGeoIpJson(); String getCaCert(); String getName(); @Override int describeContents(); @Override void writeToParcel(Parcel parcel, int i); @Override boolean equals(Object o); JSONObject toJson(); @Override int hashCode(); @Override String toString(); void setCaCert(String cert); boolean allowsAnonymous(); boolean allowsRegistered(); void setLastEipServiceUpdate(long timestamp); boolean shouldUpdateEipServiceJson(); void setLastGeoIpUpdate(long timestamp); boolean shouldUpdateGeoIpJson(); boolean setEipServiceJson(JSONObject eipServiceJson); boolean setGeoIpJson(JSONObject geoIpJson); JSONObject getEipServiceJson(); JSONObject getGeoIpJson(); String getGeoIpJsonString(); String getEipServiceJsonString(); boolean isDefault(); String getPrivateKey(); void setPrivateKey(String privateKey); boolean hasPrivateKey(); String getVpnCertificate(); void setVpnCertificate(String vpnCertificate); boolean hasVpnCertificate(); String getCertificatePin(); String getCertificatePinEncoding(); String getCaCertFingerprint(); void reset(); final static String API_URL; static final Parcelable.Creator<Provider> CREATOR; }### Answer:
@Test public void testIsPluggableTransportsSupported_Obfs4_returnsTrue() throws Exception { Provider p1 = TestSetupHelper.getProvider( "https: null, null, null, null, null, "ptdemo.bitmask.eip-service.json", null); assertTrue(p1.supportsPluggableTransports()); }
@Test public void testIsPluggableTransportsSupported_noObfs4_returnsFalse() throws Exception { Provider p1 = TestSetupHelper.getProvider( null, null, null, null, null, null, "eip-service-two-gateways.json", null); assertFalse(p1.supportsPluggableTransports()); } |
### Question:
CeSymmMain { public static List<String> parseInputStructures(String filename) throws FileNotFoundException { File file = new File(filename); Scanner s = new Scanner(file); List<String> structures = new ArrayList<String>(); while (s.hasNext()) { String name = s.next(); if (name.startsWith("#")) { s.nextLine(); } else { structures.add(name); } } s.close(); return structures; } static void main(String[] args); static List<String> parseInputStructures(String filename); }### Answer:
@Test public void testParseInput() throws FileNotFoundException { URL url = CeSymmMainTest.class.getResource("/cesymmtest.txt"); String filename = url.getFile(); List<String> names = CeSymmMain.parseInputStructures(filename); assertEquals(6,names.size()); int i = 0; assertEquals("d1ijqa1",names.get(i++)); assertEquals("1G6S",names.get(i++)); assertEquals("1MER.A",names.get(i++)); assertEquals("d1h70a_",names.get(i++)); assertEquals("2YMS_A:,C:,B:,D:",names.get(i++)); assertEquals("1HIV",names.get(i++)); } |
### Question:
PrincipalAutoSuggestion { public List<Principal> autoSuggestion(final String name) { if (name.length() >= 3) { String lowerCaseName = name.toLowerCase(); ListRolesRequest listRolesRequest = new ListRolesRequest(); listRolesRequest.withMaxItems(1000); ListRolesResult result = client.listRoles(listRolesRequest); List<Principal> tmp = result.getRoles().stream() .filter(p -> p.getRoleName().toLowerCase().contains(lowerCaseName)) .map(p -> new Principal(PrincipalType.ROLE, p.getRoleName())).collect(Collectors.toList()); return tmp.subList(0, Math.min(5, tmp.size())); } return new ArrayList<>(); } PrincipalAutoSuggestion(AmazonIdentityManagement client); static PrincipalAutoSuggestion fromCredentials(AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration); List<Principal> autoSuggestion(final String name); }### Answer:
@Test public void testAutoSuggestion() throws Exception { ListRolesRequest request = new ListRolesRequest().withMaxItems(1000); Role role1 = new Role().withRoleName("foobar1"); Role role2 = new Role().withRoleName("afoobar"); Role role3 = new Role().withRoleName("foooobar"); ListRolesResult mockResult = new ListRolesResult(); mockResult.withRoles(role1, role2, role3); when(mockClient.listRoles(request)).thenReturn(mockResult); List<Principal> list = partiallyMockedPrincipalAutoSuggestion.autoSuggestion("foobar"); assertEquals(list.size(), 2); assertEquals(list.get(0).name, "foobar1"); assertEquals(list.get(1).name, "afoobar"); verify(mockClient, times(1)).listRoles(request); }
@Test public void testAutoSuggestionShortName() throws Exception { ListRolesRequest request = new ListRolesRequest().withMaxItems(1000); List<Principal> list = partiallyMockedPrincipalAutoSuggestion.autoSuggestion("fo"); assertTrue(list.isEmpty()); verify(mockClient, never()).listRoles(request); }
@Test public void testAutoSuggestionCaseInsensitive() throws Exception { ListRolesRequest request = new ListRolesRequest().withMaxItems(1000); Role lowercase = new Role().withRoleName("foobar"); Role uppercase = new Role().withRoleName("FOOBAR"); Role mixedCase = new Role().withRoleName("FooBar"); ListRolesResult mockResult = new ListRolesResult(); mockResult.withRoles(lowercase, uppercase, mixedCase); when(mockClient.listRoles(request)).thenReturn(mockResult); List<Principal> list = partiallyMockedPrincipalAutoSuggestion.autoSuggestion("fOOb"); assertEquals(list.size(), 3); assertEquals(list.get(0).name, "foobar"); assertEquals(list.get(1).name, "FOOBAR"); assertEquals(list.get(2).name, "FooBar"); } |
### Question:
DefaultSimpleSecretsGroup implements SimpleSecretsGroup { @Override public List<StringSecretEntry> getAllStringSecrets() { return secretsGroup.getLatestActiveVersionOfAllSecrets() .stream() .filter(secretEntry -> secretEntry.secretValue.encoding == Encoding.UTF8) .map(StringSecretEntry::of) .collect(Collectors.toList()); } DefaultSimpleSecretsGroup(final SecretsGroup secretsGroup); DefaultSimpleSecretsGroup(final SecretsGroupIdentifier groupIdentifier); DefaultSimpleSecretsGroup(final SecretsGroupIdentifier groupIdentifier, final RoleARN role); DefaultSimpleSecretsGroup(final SecretsGroupIdentifier groupIdentifier, final AWSCredentialsProvider credentialsProvider); @Override Optional<String> getStringSecret(final SecretIdentifier secretIdentifier); @Override Optional<String> getStringSecret(String secretIdentifier); @Override Optional<String> getStringSecret(final SecretIdentifier secretIdentifier, long version); @Override Optional<String> getStringSecret(String secretIdentifier, long version); @Override List<StringSecretEntry> getAllStringSecrets(); @Override Optional<byte[]> getBinarySecret(final SecretIdentifier secretIdentifier); @Override Optional<byte[]> getBinarySecret(String secretIdentifier); @Override Optional<byte[]> getBinarySecret(final SecretIdentifier secretIdentifier, final long version); @Override Optional<byte[]> getBinarySecret(String secretIdentifier, long version); @Override List<ByteSecretEntry> getAllBinarySecrets(); }### Answer:
@Test public void getAllStringSecrets() { List<StringSecretEntry> secrets = simpleSecretsGroup.getAllStringSecrets(); StringSecretEntry one = new StringSecretEntry(stringSecretIdentifier2, 1l, stringSecretValue2.asString()); StringSecretEntry two = new StringSecretEntry(stringSecretIdentifier3, 1l, stringSecretValue3.asString()); assertThat(secrets, is(Arrays.asList(one, two))); } |
### Question:
DefaultSimpleSecretsGroup implements SimpleSecretsGroup { @Override public List<ByteSecretEntry> getAllBinarySecrets() { return secretsGroup.getLatestActiveVersionOfAllSecrets() .stream() .filter(secretEntry -> secretEntry.secretValue.encoding == Encoding.BINARY) .map(ByteSecretEntry::of) .collect(Collectors.toList()); } DefaultSimpleSecretsGroup(final SecretsGroup secretsGroup); DefaultSimpleSecretsGroup(final SecretsGroupIdentifier groupIdentifier); DefaultSimpleSecretsGroup(final SecretsGroupIdentifier groupIdentifier, final RoleARN role); DefaultSimpleSecretsGroup(final SecretsGroupIdentifier groupIdentifier, final AWSCredentialsProvider credentialsProvider); @Override Optional<String> getStringSecret(final SecretIdentifier secretIdentifier); @Override Optional<String> getStringSecret(String secretIdentifier); @Override Optional<String> getStringSecret(final SecretIdentifier secretIdentifier, long version); @Override Optional<String> getStringSecret(String secretIdentifier, long version); @Override List<StringSecretEntry> getAllStringSecrets(); @Override Optional<byte[]> getBinarySecret(final SecretIdentifier secretIdentifier); @Override Optional<byte[]> getBinarySecret(String secretIdentifier); @Override Optional<byte[]> getBinarySecret(final SecretIdentifier secretIdentifier, final long version); @Override Optional<byte[]> getBinarySecret(String secretIdentifier, long version); @Override List<ByteSecretEntry> getAllBinarySecrets(); }### Answer:
@Test public void getAllByteSecrets() { List<ByteSecretEntry> secrets = simpleSecretsGroup.getAllBinarySecrets(); ByteSecretEntry one = new ByteSecretEntry(binarySecretIdentifier2, 1l, binarySecretValue2.asByteArray()); ByteSecretEntry two = new ByteSecretEntry(binarySecretIdentifier3, 1l, binarySecretValue3.asByteArray()); assertThat(secrets, is(Arrays.asList(one, two))); } |
### Question:
DefaultSimpleSecretsGroup implements SimpleSecretsGroup { @Override public Optional<String> getStringSecret(final SecretIdentifier secretIdentifier) { return asString(secretsGroup.getLatestActiveVersion(secretIdentifier)); } DefaultSimpleSecretsGroup(final SecretsGroup secretsGroup); DefaultSimpleSecretsGroup(final SecretsGroupIdentifier groupIdentifier); DefaultSimpleSecretsGroup(final SecretsGroupIdentifier groupIdentifier, final RoleARN role); DefaultSimpleSecretsGroup(final SecretsGroupIdentifier groupIdentifier, final AWSCredentialsProvider credentialsProvider); @Override Optional<String> getStringSecret(final SecretIdentifier secretIdentifier); @Override Optional<String> getStringSecret(String secretIdentifier); @Override Optional<String> getStringSecret(final SecretIdentifier secretIdentifier, long version); @Override Optional<String> getStringSecret(String secretIdentifier, long version); @Override List<StringSecretEntry> getAllStringSecrets(); @Override Optional<byte[]> getBinarySecret(final SecretIdentifier secretIdentifier); @Override Optional<byte[]> getBinarySecret(String secretIdentifier); @Override Optional<byte[]> getBinarySecret(final SecretIdentifier secretIdentifier, final long version); @Override Optional<byte[]> getBinarySecret(String secretIdentifier, long version); @Override List<ByteSecretEntry> getAllBinarySecrets(); }### Answer:
@Test public void getStringSecret() { Optional<String> result = simpleSecretsGroup.getStringSecret(stringSecretIdentifier); assertThat(result, is(Optional.of(value1))); }
@Test public void versioned_getStringSecret() { Optional<String> result = simpleSecretsGroup.getStringSecret(stringSecretIdentifier, version); assertThat(result, is(Optional.of(value2))); }
@Test public void not_present_getStringSecret() { Optional<String> result = simpleSecretsGroup.getStringSecret(notPresent); assertThat(result, is(Optional.empty())); }
@Test public void not_present_versioned_getStringSecret() { Optional<String> result = simpleSecretsGroup.getStringSecret(notPresent, version); assertThat(result, is(Optional.empty())); }
@Test(expectedExceptions = EncodingException.class) public void getStringSecret_on_binary_secret() { simpleSecretsGroup.getStringSecret(binarySecretIdentifier); } |
### Question:
DefaultSimpleSecretsGroup implements SimpleSecretsGroup { @Override public Optional<byte[]> getBinarySecret(final SecretIdentifier secretIdentifier) { return asBinary(secretsGroup.getLatestActiveVersion(secretIdentifier)); } DefaultSimpleSecretsGroup(final SecretsGroup secretsGroup); DefaultSimpleSecretsGroup(final SecretsGroupIdentifier groupIdentifier); DefaultSimpleSecretsGroup(final SecretsGroupIdentifier groupIdentifier, final RoleARN role); DefaultSimpleSecretsGroup(final SecretsGroupIdentifier groupIdentifier, final AWSCredentialsProvider credentialsProvider); @Override Optional<String> getStringSecret(final SecretIdentifier secretIdentifier); @Override Optional<String> getStringSecret(String secretIdentifier); @Override Optional<String> getStringSecret(final SecretIdentifier secretIdentifier, long version); @Override Optional<String> getStringSecret(String secretIdentifier, long version); @Override List<StringSecretEntry> getAllStringSecrets(); @Override Optional<byte[]> getBinarySecret(final SecretIdentifier secretIdentifier); @Override Optional<byte[]> getBinarySecret(String secretIdentifier); @Override Optional<byte[]> getBinarySecret(final SecretIdentifier secretIdentifier, final long version); @Override Optional<byte[]> getBinarySecret(String secretIdentifier, long version); @Override List<ByteSecretEntry> getAllBinarySecrets(); }### Answer:
@Test public void getBinarySecret() { Optional<byte[]> result = simpleSecretsGroup.getBinarySecret(binarySecretIdentifier); assertThat(result, is(Optional.of(value3))); }
@Test public void versioned_getBinarySecret() { Optional<byte[]> result = simpleSecretsGroup.getBinarySecret(binarySecretIdentifier, version); assertThat(result, is(Optional.of(value4))); }
@Test public void not_present_getBinarySecret() { Optional<byte[]> result = simpleSecretsGroup.getBinarySecret(notPresent); assertThat(result, is(Optional.empty())); }
@Test public void not_present_versioned_getBinarySecret() { Optional<byte[]> result = simpleSecretsGroup.getBinarySecret(notPresent, version); assertThat(result, is(Optional.empty())); }
@Test(expectedExceptions = EncodingException.class) public void getBinarySecret_on_string_secret() { simpleSecretsGroup.getBinarySecret(stringSecretIdentifier); } |
### Question:
IAMPolicyManager { public void detachReadOnly(SecretsGroupIdentifier group, Principal principal) { detachPrincipal(group,principal, AccessLevel.READONLY); } IAMPolicyManager(AmazonIdentityManagement client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration); static IAMPolicyManager fromCredentials(AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration); static String getAccount(AWSCredentialsProvider awsCredentialsProvider, ClientConfiguration clientConfiguration); String getAccount(); boolean adminPolicyExists(SecretsGroupIdentifier group); boolean readOnlyPolicyExists(SecretsGroupIdentifier group); String getAdminPolicyArn(SecretsGroupIdentifier group); String getReadOnlyArn(SecretsGroupIdentifier group); void attachAdmin(SecretsGroupIdentifier group, Principal principal); void attachReadOnly(SecretsGroupIdentifier group, Principal principal); void detachAllPrincipals(SecretsGroupIdentifier group); void detachAdmin(SecretsGroupIdentifier group, Principal principal); void detachReadOnly(SecretsGroupIdentifier group, Principal principal); void attachPrincipalToPolicy(SecretsGroupIdentifier group, Principal principal, AccessLevel accessLevel); List<Principal> listAttachedAdmin(SecretsGroupIdentifier group); List<Principal> listAttachedReadOnly(SecretsGroupIdentifier group); Set<SecretsGroupIdentifier> getSecretsGroupIdentifiers(); String createAdminPolicy(final SecretsGroupIdentifier group, final KMSEncryptor kmsEncryptor, final Store store); String createReadOnlyPolicy(SecretsGroupIdentifier group, KMSEncryptor kmsEncryptor, Store store); void deleteAdminPolicy(SecretsGroupIdentifier group); void deleteReadonlyPolicy(SecretsGroupIdentifier group); static final String PATH_PREFIX; }### Answer:
@Test public void testDetachReadonlyRole() throws Exception { Principal principal = new Principal(PrincipalType.ROLE, "awesome-service"); partiallyMockedPolicyManager.detachReadOnly(group, principal); DetachRolePolicyRequest request = new DetachRolePolicyRequest() .withPolicyArn(READONLY_POLICY_ARN) .withRoleName(principal.name); verify(mockClient, times(1)).detachRolePolicy(request); } |
### Question:
IAMPolicyManager { public void detachAllPrincipals(SecretsGroupIdentifier group) { try { List<Principal> admins = listAttachedAdmin(group); admins.forEach(p -> detachAdmin(group, p)); } catch (DoesNotExistException e) { } try { List<Principal> readonly = listAttachedReadOnly(group); readonly.forEach(p -> detachReadOnly(group, p)); } catch (DoesNotExistException e) { } } IAMPolicyManager(AmazonIdentityManagement client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration); static IAMPolicyManager fromCredentials(AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration); static String getAccount(AWSCredentialsProvider awsCredentialsProvider, ClientConfiguration clientConfiguration); String getAccount(); boolean adminPolicyExists(SecretsGroupIdentifier group); boolean readOnlyPolicyExists(SecretsGroupIdentifier group); String getAdminPolicyArn(SecretsGroupIdentifier group); String getReadOnlyArn(SecretsGroupIdentifier group); void attachAdmin(SecretsGroupIdentifier group, Principal principal); void attachReadOnly(SecretsGroupIdentifier group, Principal principal); void detachAllPrincipals(SecretsGroupIdentifier group); void detachAdmin(SecretsGroupIdentifier group, Principal principal); void detachReadOnly(SecretsGroupIdentifier group, Principal principal); void attachPrincipalToPolicy(SecretsGroupIdentifier group, Principal principal, AccessLevel accessLevel); List<Principal> listAttachedAdmin(SecretsGroupIdentifier group); List<Principal> listAttachedReadOnly(SecretsGroupIdentifier group); Set<SecretsGroupIdentifier> getSecretsGroupIdentifiers(); String createAdminPolicy(final SecretsGroupIdentifier group, final KMSEncryptor kmsEncryptor, final Store store); String createReadOnlyPolicy(SecretsGroupIdentifier group, KMSEncryptor kmsEncryptor, Store store); void deleteAdminPolicy(SecretsGroupIdentifier group); void deleteReadonlyPolicy(SecretsGroupIdentifier group); static final String PATH_PREFIX; }### Answer:
@Test public void testDetachAllPrincipals() throws Exception { } |
### Question:
IAMPolicyManager { public List<Principal> listAttachedAdmin(SecretsGroupIdentifier group) { return listEntities(group, AccessLevel.ADMIN); } IAMPolicyManager(AmazonIdentityManagement client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration); static IAMPolicyManager fromCredentials(AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration); static String getAccount(AWSCredentialsProvider awsCredentialsProvider, ClientConfiguration clientConfiguration); String getAccount(); boolean adminPolicyExists(SecretsGroupIdentifier group); boolean readOnlyPolicyExists(SecretsGroupIdentifier group); String getAdminPolicyArn(SecretsGroupIdentifier group); String getReadOnlyArn(SecretsGroupIdentifier group); void attachAdmin(SecretsGroupIdentifier group, Principal principal); void attachReadOnly(SecretsGroupIdentifier group, Principal principal); void detachAllPrincipals(SecretsGroupIdentifier group); void detachAdmin(SecretsGroupIdentifier group, Principal principal); void detachReadOnly(SecretsGroupIdentifier group, Principal principal); void attachPrincipalToPolicy(SecretsGroupIdentifier group, Principal principal, AccessLevel accessLevel); List<Principal> listAttachedAdmin(SecretsGroupIdentifier group); List<Principal> listAttachedReadOnly(SecretsGroupIdentifier group); Set<SecretsGroupIdentifier> getSecretsGroupIdentifiers(); String createAdminPolicy(final SecretsGroupIdentifier group, final KMSEncryptor kmsEncryptor, final Store store); String createReadOnlyPolicy(SecretsGroupIdentifier group, KMSEncryptor kmsEncryptor, Store store); void deleteAdminPolicy(SecretsGroupIdentifier group); void deleteReadonlyPolicy(SecretsGroupIdentifier group); static final String PATH_PREFIX; }### Answer:
@Test public void testListAttachedAdminNoneAttached() throws Exception { ListEntitiesForPolicyRequest request = new ListEntitiesForPolicyRequest() .withPolicyArn(ADMIN_POLICY_ARN); ListEntitiesForPolicyResult result = new ListEntitiesForPolicyResult(); when(mockClient.listEntitiesForPolicy(request)).thenReturn(result); List<Principal> list = partiallyMockedPolicyManager.listAttachedAdmin(group); assertTrue(list.isEmpty()); }
@Test public void testListAttachedAdmin() throws Exception { ListEntitiesForPolicyRequest request = new ListEntitiesForPolicyRequest() .withPolicyArn(ADMIN_POLICY_ARN); PolicyGroup policyGroup = new PolicyGroup().withGroupName("awesome-group"); PolicyRole policyRole = new PolicyRole().withRoleName("awesome-service"); PolicyUser policyUser = new PolicyUser().withUserName("bob"); ListEntitiesForPolicyResult result = new ListEntitiesForPolicyResult() .withPolicyGroups(policyGroup) .withPolicyUsers(policyUser) .withPolicyRoles(policyRole); when(mockClient.listEntitiesForPolicy(request)).thenReturn(result); List<Principal> list = partiallyMockedPolicyManager.listAttachedAdmin(group); assertEquals(list.size(), 3); assertEquals(list.get(0), new Principal(PrincipalType.GROUP, "awesome-group")); assertEquals(list.get(1), new Principal(PrincipalType.USER, "bob")); assertEquals(list.get(2), new Principal(PrincipalType.ROLE, "awesome-service")); } |
### Question:
IAMPolicyManager { public List<Principal> listAttachedReadOnly(SecretsGroupIdentifier group) { return listEntities(group, AccessLevel.READONLY); } IAMPolicyManager(AmazonIdentityManagement client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration); static IAMPolicyManager fromCredentials(AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration); static String getAccount(AWSCredentialsProvider awsCredentialsProvider, ClientConfiguration clientConfiguration); String getAccount(); boolean adminPolicyExists(SecretsGroupIdentifier group); boolean readOnlyPolicyExists(SecretsGroupIdentifier group); String getAdminPolicyArn(SecretsGroupIdentifier group); String getReadOnlyArn(SecretsGroupIdentifier group); void attachAdmin(SecretsGroupIdentifier group, Principal principal); void attachReadOnly(SecretsGroupIdentifier group, Principal principal); void detachAllPrincipals(SecretsGroupIdentifier group); void detachAdmin(SecretsGroupIdentifier group, Principal principal); void detachReadOnly(SecretsGroupIdentifier group, Principal principal); void attachPrincipalToPolicy(SecretsGroupIdentifier group, Principal principal, AccessLevel accessLevel); List<Principal> listAttachedAdmin(SecretsGroupIdentifier group); List<Principal> listAttachedReadOnly(SecretsGroupIdentifier group); Set<SecretsGroupIdentifier> getSecretsGroupIdentifiers(); String createAdminPolicy(final SecretsGroupIdentifier group, final KMSEncryptor kmsEncryptor, final Store store); String createReadOnlyPolicy(SecretsGroupIdentifier group, KMSEncryptor kmsEncryptor, Store store); void deleteAdminPolicy(SecretsGroupIdentifier group); void deleteReadonlyPolicy(SecretsGroupIdentifier group); static final String PATH_PREFIX; }### Answer:
@Test public void testListAttachedReadOnly() throws Exception { ListEntitiesForPolicyRequest request = new ListEntitiesForPolicyRequest() .withPolicyArn(READONLY_POLICY_ARN); PolicyGroup policyGroup = new PolicyGroup().withGroupName("awesome-group"); PolicyRole policyRole = new PolicyRole().withRoleName("awesome-service"); PolicyUser policyUser = new PolicyUser().withUserName("alice"); ListEntitiesForPolicyResult result = new ListEntitiesForPolicyResult() .withPolicyGroups(policyGroup) .withPolicyUsers(policyUser) .withPolicyRoles(policyRole); when(mockClient.listEntitiesForPolicy(request)).thenReturn(result); List<Principal> list = partiallyMockedPolicyManager.listAttachedReadOnly(group); assertEquals(list.size(), 3); assertEquals(list.get(0), new Principal(PrincipalType.GROUP, "awesome-group")); assertEquals(list.get(1), new Principal(PrincipalType.USER, "alice")); assertEquals(list.get(2), new Principal(PrincipalType.ROLE, "awesome-service")); } |
### Question:
IAMPolicyManager { public Set<SecretsGroupIdentifier> getSecretsGroupIdentifiers() { ListPoliciesRequest request = new ListPoliciesRequest(); request.setMaxItems(1000); request.setPathPrefix(PATH_PREFIX); ListPoliciesResult result = client.listPolicies(request); return result.getPolicies().stream() .map(p -> IAMPolicyName.fromString(p.getPolicyName()).group).distinct().collect(Collectors.toSet()); } IAMPolicyManager(AmazonIdentityManagement client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration); static IAMPolicyManager fromCredentials(AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration); static String getAccount(AWSCredentialsProvider awsCredentialsProvider, ClientConfiguration clientConfiguration); String getAccount(); boolean adminPolicyExists(SecretsGroupIdentifier group); boolean readOnlyPolicyExists(SecretsGroupIdentifier group); String getAdminPolicyArn(SecretsGroupIdentifier group); String getReadOnlyArn(SecretsGroupIdentifier group); void attachAdmin(SecretsGroupIdentifier group, Principal principal); void attachReadOnly(SecretsGroupIdentifier group, Principal principal); void detachAllPrincipals(SecretsGroupIdentifier group); void detachAdmin(SecretsGroupIdentifier group, Principal principal); void detachReadOnly(SecretsGroupIdentifier group, Principal principal); void attachPrincipalToPolicy(SecretsGroupIdentifier group, Principal principal, AccessLevel accessLevel); List<Principal> listAttachedAdmin(SecretsGroupIdentifier group); List<Principal> listAttachedReadOnly(SecretsGroupIdentifier group); Set<SecretsGroupIdentifier> getSecretsGroupIdentifiers(); String createAdminPolicy(final SecretsGroupIdentifier group, final KMSEncryptor kmsEncryptor, final Store store); String createReadOnlyPolicy(SecretsGroupIdentifier group, KMSEncryptor kmsEncryptor, Store store); void deleteAdminPolicy(SecretsGroupIdentifier group); void deleteReadonlyPolicy(SecretsGroupIdentifier group); static final String PATH_PREFIX; }### Answer:
@Test public void testGetSecretsGroupIdentifiersNoGroups() throws Exception { ListPoliciesRequest request = new ListPoliciesRequest().withMaxItems(1000).withPathPrefix("/strongbox/"); when(mockClient.listPolicies(request)).thenReturn(new ListPoliciesResult()); Set<SecretsGroupIdentifier> identifiers = partiallyMockedPolicyManager.getSecretsGroupIdentifiers(); assertTrue(identifiers.isEmpty()); }
@Test public void testGetSecretsGroupIdentifiers() throws Exception { ListPoliciesRequest request = new ListPoliciesRequest().withMaxItems(1000).withPathPrefix("/strongbox/"); Policy policyUS1 = new Policy().withPolicyName("strongbox_us-west-1_test-group1_admin"); Policy policyUS2 = new Policy().withPolicyName("strongbox_us-west-1_test-group2_admin"); Policy policyEU1 = new Policy().withPolicyName("strongbox_eu-west-1_test-group1_admin"); Policy policyEU1readonly = new Policy().withPolicyName("strongbox_eu-west-1_test-group1_readonly"); ListPoliciesResult result = new ListPoliciesResult() .withPolicies(policyUS1, policyUS2, policyEU1, policyEU1readonly); when(mockClient.listPolicies(request)).thenReturn(new ListPoliciesResult() .withPolicies(policyUS1, policyUS2, policyEU1, policyEU1readonly)); Set<SecretsGroupIdentifier> identifiers = partiallyMockedPolicyManager.getSecretsGroupIdentifiers(); assertEquals(identifiers.size(), 3); assertTrue(identifiers.contains(new SecretsGroupIdentifier(Region.US_WEST_1, "test.group1"))); assertTrue(identifiers.contains(new SecretsGroupIdentifier(Region.US_WEST_1, "test.group2"))); assertTrue(identifiers.contains(new SecretsGroupIdentifier(Region.EU_WEST_1, "test.group1"))); verify(mockClient, times(1)).listPolicies(request); } |
### Question:
IAMPolicyManager { public String createAdminPolicy(final SecretsGroupIdentifier group, final KMSEncryptor kmsEncryptor, final Store store) { String adminPolicy = "{\n" + " \"Version\": \"2012-10-17\",\n" + " \"Statement\": [\n" + kmsEncryptor.awsAdminPolicy().get() + ",\n" + storeAdminPolicyString(store) + ",\n" + listAllPolicies() + ",\n" + getPolicyInfo(group) + ",\n" + managePolicies(group) + "\n ]\n" + "}"; return createPolicy(group, AccessLevel.ADMIN, adminPolicy); } IAMPolicyManager(AmazonIdentityManagement client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration); static IAMPolicyManager fromCredentials(AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration); static String getAccount(AWSCredentialsProvider awsCredentialsProvider, ClientConfiguration clientConfiguration); String getAccount(); boolean adminPolicyExists(SecretsGroupIdentifier group); boolean readOnlyPolicyExists(SecretsGroupIdentifier group); String getAdminPolicyArn(SecretsGroupIdentifier group); String getReadOnlyArn(SecretsGroupIdentifier group); void attachAdmin(SecretsGroupIdentifier group, Principal principal); void attachReadOnly(SecretsGroupIdentifier group, Principal principal); void detachAllPrincipals(SecretsGroupIdentifier group); void detachAdmin(SecretsGroupIdentifier group, Principal principal); void detachReadOnly(SecretsGroupIdentifier group, Principal principal); void attachPrincipalToPolicy(SecretsGroupIdentifier group, Principal principal, AccessLevel accessLevel); List<Principal> listAttachedAdmin(SecretsGroupIdentifier group); List<Principal> listAttachedReadOnly(SecretsGroupIdentifier group); Set<SecretsGroupIdentifier> getSecretsGroupIdentifiers(); String createAdminPolicy(final SecretsGroupIdentifier group, final KMSEncryptor kmsEncryptor, final Store store); String createReadOnlyPolicy(SecretsGroupIdentifier group, KMSEncryptor kmsEncryptor, Store store); void deleteAdminPolicy(SecretsGroupIdentifier group); void deleteReadonlyPolicy(SecretsGroupIdentifier group); static final String PATH_PREFIX; }### Answer:
@Test public void testCreateAdminPolicy() throws Exception { String policyDocument = new String(Files.readAllBytes(Paths.get(TEST_DATA_DIR, "test_admin_policy"))); CreatePolicyRequest request = constructCreatePolicyRequest("admin", policyDocument); CreatePolicyResult result = new CreatePolicyResult().withPolicy(new Policy().withArn(ADMIN_POLICY_ARN)); when(mockClient.createPolicy(request)).thenReturn(result); DescribeKeyRequest keyRequest = new DescribeKeyRequest().withKeyId(KMS_ALIAS_ARN); when(mockKMSClient.describeKey(keyRequest)).thenReturn(constructDescribeKeyResult()); String policyArn = partiallyMockedPolicyManager.createAdminPolicy(group, kmsEncryptor, partiallyMockedStore); verify(mockClient, times(1)).createPolicy(request); verify(mockKMSClient, times(1)).describeKey(keyRequest); assertEquals(policyArn, ADMIN_POLICY_ARN); } |
### Question:
IAMPolicyManager { public String createReadOnlyPolicy(SecretsGroupIdentifier group, KMSEncryptor kmsEncryptor, Store store) { String readOnlyPolicy = "{\n" + " \"Version\": \"2012-10-17\",\n" + " \"Statement\": [\n" + storeReadOnlyPolicyString(store) + ",\n" + kmsEncryptor.awsReadOnlyPolicy().get() + "\n ]\n" + "}"; return createPolicy(group, AccessLevel.READONLY, readOnlyPolicy); } IAMPolicyManager(AmazonIdentityManagement client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration); static IAMPolicyManager fromCredentials(AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration); static String getAccount(AWSCredentialsProvider awsCredentialsProvider, ClientConfiguration clientConfiguration); String getAccount(); boolean adminPolicyExists(SecretsGroupIdentifier group); boolean readOnlyPolicyExists(SecretsGroupIdentifier group); String getAdminPolicyArn(SecretsGroupIdentifier group); String getReadOnlyArn(SecretsGroupIdentifier group); void attachAdmin(SecretsGroupIdentifier group, Principal principal); void attachReadOnly(SecretsGroupIdentifier group, Principal principal); void detachAllPrincipals(SecretsGroupIdentifier group); void detachAdmin(SecretsGroupIdentifier group, Principal principal); void detachReadOnly(SecretsGroupIdentifier group, Principal principal); void attachPrincipalToPolicy(SecretsGroupIdentifier group, Principal principal, AccessLevel accessLevel); List<Principal> listAttachedAdmin(SecretsGroupIdentifier group); List<Principal> listAttachedReadOnly(SecretsGroupIdentifier group); Set<SecretsGroupIdentifier> getSecretsGroupIdentifiers(); String createAdminPolicy(final SecretsGroupIdentifier group, final KMSEncryptor kmsEncryptor, final Store store); String createReadOnlyPolicy(SecretsGroupIdentifier group, KMSEncryptor kmsEncryptor, Store store); void deleteAdminPolicy(SecretsGroupIdentifier group); void deleteReadonlyPolicy(SecretsGroupIdentifier group); static final String PATH_PREFIX; }### Answer:
@Test public void testCreateReadOnlyPolicy() throws Exception { String policyDocument = new String(Files.readAllBytes(Paths.get(TEST_DATA_DIR, "test_readonly_policy"))); CreatePolicyRequest request = constructCreatePolicyRequest("readonly", policyDocument); CreatePolicyResult result = new CreatePolicyResult().withPolicy(new Policy().withArn(READONLY_POLICY_ARN)); when(mockClient.createPolicy(request)).thenReturn(result); DescribeKeyRequest keyRequest = new DescribeKeyRequest().withKeyId(KMS_ALIAS_ARN); when(mockKMSClient.describeKey(keyRequest)).thenReturn(constructDescribeKeyResult()); String policyArn = partiallyMockedPolicyManager.createReadOnlyPolicy(group, kmsEncryptor, partiallyMockedStore); verify(mockClient, times(1)).createPolicy(request); verify(mockKMSClient, times(1)).describeKey(keyRequest); assertEquals(policyArn, READONLY_POLICY_ARN); } |
### Question:
IAMPolicyManager { public void deleteAdminPolicy(SecretsGroupIdentifier group) { deletePolicy(group, AccessLevel.ADMIN); } IAMPolicyManager(AmazonIdentityManagement client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration); static IAMPolicyManager fromCredentials(AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration); static String getAccount(AWSCredentialsProvider awsCredentialsProvider, ClientConfiguration clientConfiguration); String getAccount(); boolean adminPolicyExists(SecretsGroupIdentifier group); boolean readOnlyPolicyExists(SecretsGroupIdentifier group); String getAdminPolicyArn(SecretsGroupIdentifier group); String getReadOnlyArn(SecretsGroupIdentifier group); void attachAdmin(SecretsGroupIdentifier group, Principal principal); void attachReadOnly(SecretsGroupIdentifier group, Principal principal); void detachAllPrincipals(SecretsGroupIdentifier group); void detachAdmin(SecretsGroupIdentifier group, Principal principal); void detachReadOnly(SecretsGroupIdentifier group, Principal principal); void attachPrincipalToPolicy(SecretsGroupIdentifier group, Principal principal, AccessLevel accessLevel); List<Principal> listAttachedAdmin(SecretsGroupIdentifier group); List<Principal> listAttachedReadOnly(SecretsGroupIdentifier group); Set<SecretsGroupIdentifier> getSecretsGroupIdentifiers(); String createAdminPolicy(final SecretsGroupIdentifier group, final KMSEncryptor kmsEncryptor, final Store store); String createReadOnlyPolicy(SecretsGroupIdentifier group, KMSEncryptor kmsEncryptor, Store store); void deleteAdminPolicy(SecretsGroupIdentifier group); void deleteReadonlyPolicy(SecretsGroupIdentifier group); static final String PATH_PREFIX; }### Answer:
@Test public void testDeleteAdminPolicy() throws Exception { DeletePolicyRequest request = new DeletePolicyRequest().withPolicyArn(ADMIN_POLICY_ARN); partiallyMockedPolicyManager.deleteAdminPolicy(group); verify(mockClient, times(1)).deletePolicy(request); } |
### Question:
IAMPolicyManager { public void deleteReadonlyPolicy(SecretsGroupIdentifier group) { deletePolicy(group, AccessLevel.READONLY); } IAMPolicyManager(AmazonIdentityManagement client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration); static IAMPolicyManager fromCredentials(AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration); static String getAccount(AWSCredentialsProvider awsCredentialsProvider, ClientConfiguration clientConfiguration); String getAccount(); boolean adminPolicyExists(SecretsGroupIdentifier group); boolean readOnlyPolicyExists(SecretsGroupIdentifier group); String getAdminPolicyArn(SecretsGroupIdentifier group); String getReadOnlyArn(SecretsGroupIdentifier group); void attachAdmin(SecretsGroupIdentifier group, Principal principal); void attachReadOnly(SecretsGroupIdentifier group, Principal principal); void detachAllPrincipals(SecretsGroupIdentifier group); void detachAdmin(SecretsGroupIdentifier group, Principal principal); void detachReadOnly(SecretsGroupIdentifier group, Principal principal); void attachPrincipalToPolicy(SecretsGroupIdentifier group, Principal principal, AccessLevel accessLevel); List<Principal> listAttachedAdmin(SecretsGroupIdentifier group); List<Principal> listAttachedReadOnly(SecretsGroupIdentifier group); Set<SecretsGroupIdentifier> getSecretsGroupIdentifiers(); String createAdminPolicy(final SecretsGroupIdentifier group, final KMSEncryptor kmsEncryptor, final Store store); String createReadOnlyPolicy(SecretsGroupIdentifier group, KMSEncryptor kmsEncryptor, Store store); void deleteAdminPolicy(SecretsGroupIdentifier group); void deleteReadonlyPolicy(SecretsGroupIdentifier group); static final String PATH_PREFIX; }### Answer:
@Test public void testDeleteReadonlyPolicy() throws Exception { DeletePolicyRequest request = new DeletePolicyRequest().withPolicyArn(READONLY_POLICY_ARN); partiallyMockedPolicyManager.deleteReadonlyPolicy(group); verify(mockClient, times(1)).deletePolicy(request); } |
### Question:
RegionLocalResourceName { @Override public String toString() { return String.format("%s_%s_%s", PREFIX, group.region.getName(), AWSResourceNameSerialization.encodeSecretsGroupName(group.name)); } RegionLocalResourceName(SecretsGroupIdentifier group); @Override String toString(); static RegionLocalResourceName fromString(String wrappedAWSResourceName); @Override boolean equals(final Object obj); final SecretsGroupIdentifier group; }### Answer:
@Test public void testToString() throws Exception { assertEquals(resourceName.toString(), resourceAsString); } |
### Question:
RegionLocalResourceName { public static RegionLocalResourceName fromString(String wrappedAWSResourceName) { String[] parts = wrappedAWSResourceName.split(AWSResourceNameSerialization.GLOBAL_STRING_DELIMITER); if (!parts[0].equals(PREFIX)) { throw new InvalidResourceName( wrappedAWSResourceName, "Regional local resource name should start with " + PREFIX); } if (parts.length != 3) { throw new InvalidResourceName( wrappedAWSResourceName, "Regional local resource name should have exactly 3 parts"); } Region region = Region.fromName(parts[1]); String name = AWSResourceNameSerialization.decodeSecretsGroupName(parts[2]); SecretsGroupIdentifier group = new SecretsGroupIdentifier(region, name); return new RegionLocalResourceName(group); } RegionLocalResourceName(SecretsGroupIdentifier group); @Override String toString(); static RegionLocalResourceName fromString(String wrappedAWSResourceName); @Override boolean equals(final Object obj); final SecretsGroupIdentifier group; }### Answer:
@Test public void testFromString() throws Exception { assertEquals(RegionLocalResourceName.fromString(resourceAsString).group, resourceName.group); assertEquals(RegionLocalResourceName.fromString(resourceAsString).toString(), resourceAsString); }
@Test(expectedExceptions = InvalidResourceName.class) public void testFromStringInvalidPrefix() throws Exception { RegionLocalResourceName.fromString("sm_us-west-1_test-group"); }
@Test(expectedExceptions = InvalidResourceName.class) public void testFromStringMissingRegion() throws Exception { RegionLocalResourceName.fromString("strongbox_test-group"); } |
### Question:
RegionLocalResourceName { @Override public boolean equals(final Object obj) { if(obj instanceof RegionLocalResourceName){ final RegionLocalResourceName other = (RegionLocalResourceName) obj; return Objects.equal(group, other.group); } else{ return false; } } RegionLocalResourceName(SecretsGroupIdentifier group); @Override String toString(); static RegionLocalResourceName fromString(String wrappedAWSResourceName); @Override boolean equals(final Object obj); final SecretsGroupIdentifier group; }### Answer:
@Test public void testEquals() { assertTrue(resourceName.equals(resourceName)); assertTrue(resourceName.equals(new RegionLocalResourceName(new SecretsGroupIdentifier(Region.US_WEST_1, "test.group")))); assertFalse(resourceName.equals(new RegionLocalResourceName(new SecretsGroupIdentifier(Region.EU_WEST_1, "test.group")))); assertFalse(resourceName.equals(new RegionLocalResourceName(new SecretsGroupIdentifier(Region.US_WEST_1, "test.group2")))); assertFalse(resourceName.equals(resourceAsString)); } |
### Question:
SessionCache { String resolveFileName() { return String.format("%s--%s.json", profile.name, roleToAssume.toArn().replace(':', '_').replace('/', '-')); } SessionCache(final ProfileIdentifier profile, final RoleARN roleToAssume); Optional<BasicSessionCredentials> load(); void save(final AssumedRoleUser assumedRoleUser, final BasicSessionCredentials credentials, final ZonedDateTime expiration); }### Answer:
@Test public void resolve_filename() { ProfileIdentifier profile = new ProfileIdentifier("my-profile"); RoleARN arn = new RoleARN("arn:aws:iam::12345678910:role/my-role"); SessionCache sessionCache = new SessionCache(profile, arn); assertThat(sessionCache.resolveFileName(), is("my-profile--arn_aws_iam__12345678910_role-my-role.json")); } |
### Question:
AWSCLIConfigFile { public Config getConfig() { try (BufferedReader bufferedReader = new BufferedReader(new FileReader(file))) { return getConfig(bufferedReader); } catch (Exception e) { throw new RuntimeException(String.format("Failed to load config from '%s': %s", file.getAbsolutePath(), e.getMessage()), e); } } AWSCLIConfigFile(final File file); Config getConfig(); static Optional<File> getCredentialProfilesFile(); static Optional<File> getConfigFile(); }### Answer:
@Test public void single_section_single_property() { AWSCLIConfigFile configFile = new AWSCLIConfigFile(new File("")); AWSCLIConfigFile.Config config = configFile.getConfig(asBufferedReader("[default]\nkey=value\n")); assertSectionAndPropertyExists(config, "default", new AWSCLIConfigFile.Property("key", "value")); }
@Test public void multiple_sections_multiple_properties() { AWSCLIConfigFile configFile = new AWSCLIConfigFile(new File("")); AWSCLIConfigFile.Config config = configFile.getConfig(asBufferedReader("[default]\nkey=value\n[my section]\nkey2=value2\nkey3=value3")); assertSectionAndPropertyExists(config, "default", new AWSCLIConfigFile.Property("key", "value")); assertSectionAndPropertyExists(config, "my section", new AWSCLIConfigFile.Property("key2", "value2")); assertSectionAndPropertyExists(config, "my section", new AWSCLIConfigFile.Property("key3", "value3")); }
@Test public void surrounding_spaces_in_section_name() { AWSCLIConfigFile configFile = new AWSCLIConfigFile(new File("")); AWSCLIConfigFile.Config config = configFile.getConfig(asBufferedReader("[ default ]\nkey=value\n")); assertSectionAndPropertyExists(config, "default", new AWSCLIConfigFile.Property("key", "value")); }
@Test public void surrounding_spaces_in_property() { AWSCLIConfigFile configFile = new AWSCLIConfigFile(new File("")); AWSCLIConfigFile.Config config = configFile.getConfig(asBufferedReader("[default]\n key = value \n")); assertSectionAndPropertyExists(config, "default", new AWSCLIConfigFile.Property("key", "value")); }
@Test public void when_there_are_duplicate_properties_use_the_last() { AWSCLIConfigFile configFile = new AWSCLIConfigFile(new File("")); AWSCLIConfigFile.Config config = configFile.getConfig(asBufferedReader("[default]\nkey=value\n[default]\nkey=value2\n")); assertSectionAndPropertyExists(config, "default", new AWSCLIConfigFile.Property("key", "value2")); } |
### Question:
KMSEncryptor implements Encryptor, ManagedResource { @Override public String encrypt(String plaintext, EncryptionContext context) { return crypto.encryptString(getProvider(), plaintext, context.toMap()).getResult(); } KMSEncryptor(KMSManager kmsManager, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier, AwsCrypto awsCrypto, EncryptionStrength encryptionStrength); static KMSEncryptor fromCredentials(AWSCredentialsProvider awsCredentials,
ClientConfiguration clientConfiguration,
SecretsGroupIdentifier groupIdentifier,
EncryptionStrength encryptionStrength); @Override String encrypt(String plaintext, EncryptionContext context); @Override String decrypt(String ciphertext, EncryptionContext context); @Override byte[] encrypt(byte[] plaintext, EncryptionContext context); @Override byte[] decrypt(byte[] ciphertext, EncryptionContext context); byte[] generateRandom(Integer numberOfBytes); @Override String create(); String create(boolean allowExistingPendingDeletedOrDisabledKey); @Override void delete(); @Override Optional<String> awsAdminPolicy(); @Override Optional<String> awsReadOnlyPolicy(); @Override String getArn(); @Override boolean exists(); boolean exists(boolean allowExistingPendingDeletedOrDisabledKey); int pendingDeletionWindowInDays(); }### Answer:
@Test public void testEncrypt() throws Exception { String plaintext = "jsonblob"; EncryptionContext mockContext = mock(EncryptionContext.class); CryptoResult mockCryptoResult = mock(CryptoResult.class); Map<String, String> contextMap = new HashMap<>(); when(mockContext.toMap()).thenReturn(contextMap); when(mockCryptoResult.getResult()).thenReturn(encryptedPayload); when(mockAwsCrypto.encryptString(mockProvider, plaintext, contextMap)).thenReturn( mockCryptoResult); assertEquals(kmsEncryptor.encrypt(plaintext, mockContext), encryptedPayload); } |
### Question:
KMSEncryptor implements Encryptor, ManagedResource { @Override public String create() { return kmsManager.create(); } KMSEncryptor(KMSManager kmsManager, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier, AwsCrypto awsCrypto, EncryptionStrength encryptionStrength); static KMSEncryptor fromCredentials(AWSCredentialsProvider awsCredentials,
ClientConfiguration clientConfiguration,
SecretsGroupIdentifier groupIdentifier,
EncryptionStrength encryptionStrength); @Override String encrypt(String plaintext, EncryptionContext context); @Override String decrypt(String ciphertext, EncryptionContext context); @Override byte[] encrypt(byte[] plaintext, EncryptionContext context); @Override byte[] decrypt(byte[] ciphertext, EncryptionContext context); byte[] generateRandom(Integer numberOfBytes); @Override String create(); String create(boolean allowExistingPendingDeletedOrDisabledKey); @Override void delete(); @Override Optional<String> awsAdminPolicy(); @Override Optional<String> awsReadOnlyPolicy(); @Override String getArn(); @Override boolean exists(); boolean exists(boolean allowExistingPendingDeletedOrDisabledKey); int pendingDeletionWindowInDays(); }### Answer:
@Test public void testCreate() throws Exception { when(mockKmsManager.create()).thenReturn(KMS_ARN); assertEquals(kmsEncryptor.create(), KMS_ARN); verify(mockKmsManager, times(1)).create(); } |
### Question:
KMSEncryptor implements Encryptor, ManagedResource { @Override public void delete() { kmsManager.delete(); } KMSEncryptor(KMSManager kmsManager, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier, AwsCrypto awsCrypto, EncryptionStrength encryptionStrength); static KMSEncryptor fromCredentials(AWSCredentialsProvider awsCredentials,
ClientConfiguration clientConfiguration,
SecretsGroupIdentifier groupIdentifier,
EncryptionStrength encryptionStrength); @Override String encrypt(String plaintext, EncryptionContext context); @Override String decrypt(String ciphertext, EncryptionContext context); @Override byte[] encrypt(byte[] plaintext, EncryptionContext context); @Override byte[] decrypt(byte[] ciphertext, EncryptionContext context); byte[] generateRandom(Integer numberOfBytes); @Override String create(); String create(boolean allowExistingPendingDeletedOrDisabledKey); @Override void delete(); @Override Optional<String> awsAdminPolicy(); @Override Optional<String> awsReadOnlyPolicy(); @Override String getArn(); @Override boolean exists(); boolean exists(boolean allowExistingPendingDeletedOrDisabledKey); int pendingDeletionWindowInDays(); }### Answer:
@Test public void testDelete() throws Exception { kmsEncryptor.delete(); verify(mockKmsManager, times(1)).delete(); } |
### Question:
KMSEncryptor implements Encryptor, ManagedResource { @Override public Optional<String> awsAdminPolicy() { return kmsManager.awsAdminPolicy(); } KMSEncryptor(KMSManager kmsManager, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier, AwsCrypto awsCrypto, EncryptionStrength encryptionStrength); static KMSEncryptor fromCredentials(AWSCredentialsProvider awsCredentials,
ClientConfiguration clientConfiguration,
SecretsGroupIdentifier groupIdentifier,
EncryptionStrength encryptionStrength); @Override String encrypt(String plaintext, EncryptionContext context); @Override String decrypt(String ciphertext, EncryptionContext context); @Override byte[] encrypt(byte[] plaintext, EncryptionContext context); @Override byte[] decrypt(byte[] ciphertext, EncryptionContext context); byte[] generateRandom(Integer numberOfBytes); @Override String create(); String create(boolean allowExistingPendingDeletedOrDisabledKey); @Override void delete(); @Override Optional<String> awsAdminPolicy(); @Override Optional<String> awsReadOnlyPolicy(); @Override String getArn(); @Override boolean exists(); boolean exists(boolean allowExistingPendingDeletedOrDisabledKey); int pendingDeletionWindowInDays(); }### Answer:
@Test public void testAwsAdminPolicy() throws Exception { String adminPolicy = "Admin policy"; when(mockKmsManager.awsAdminPolicy()).thenReturn(Optional.of(adminPolicy)); assertEquals(kmsEncryptor.awsAdminPolicy().get(),adminPolicy); verify(mockKmsManager, times(1)).awsAdminPolicy(); } |
### Question:
KMSEncryptor implements Encryptor, ManagedResource { @Override public Optional<String> awsReadOnlyPolicy() { return kmsManager.awsReadOnlyPolicy(); } KMSEncryptor(KMSManager kmsManager, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier, AwsCrypto awsCrypto, EncryptionStrength encryptionStrength); static KMSEncryptor fromCredentials(AWSCredentialsProvider awsCredentials,
ClientConfiguration clientConfiguration,
SecretsGroupIdentifier groupIdentifier,
EncryptionStrength encryptionStrength); @Override String encrypt(String plaintext, EncryptionContext context); @Override String decrypt(String ciphertext, EncryptionContext context); @Override byte[] encrypt(byte[] plaintext, EncryptionContext context); @Override byte[] decrypt(byte[] ciphertext, EncryptionContext context); byte[] generateRandom(Integer numberOfBytes); @Override String create(); String create(boolean allowExistingPendingDeletedOrDisabledKey); @Override void delete(); @Override Optional<String> awsAdminPolicy(); @Override Optional<String> awsReadOnlyPolicy(); @Override String getArn(); @Override boolean exists(); boolean exists(boolean allowExistingPendingDeletedOrDisabledKey); int pendingDeletionWindowInDays(); }### Answer:
@Test public void testAwsReadOnlyPolicy() throws Exception { String readonlyPolicy = "Readonly policy"; when(mockKmsManager.awsReadOnlyPolicy()).thenReturn(Optional.of(readonlyPolicy)); assertEquals(kmsEncryptor.awsReadOnlyPolicy().get(), readonlyPolicy); verify(mockKmsManager, times(1)).awsReadOnlyPolicy(); } |
### Question:
KMSEncryptor implements Encryptor, ManagedResource { @Override public String getArn() { return kmsManager.getArn(); } KMSEncryptor(KMSManager kmsManager, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier, AwsCrypto awsCrypto, EncryptionStrength encryptionStrength); static KMSEncryptor fromCredentials(AWSCredentialsProvider awsCredentials,
ClientConfiguration clientConfiguration,
SecretsGroupIdentifier groupIdentifier,
EncryptionStrength encryptionStrength); @Override String encrypt(String plaintext, EncryptionContext context); @Override String decrypt(String ciphertext, EncryptionContext context); @Override byte[] encrypt(byte[] plaintext, EncryptionContext context); @Override byte[] decrypt(byte[] ciphertext, EncryptionContext context); byte[] generateRandom(Integer numberOfBytes); @Override String create(); String create(boolean allowExistingPendingDeletedOrDisabledKey); @Override void delete(); @Override Optional<String> awsAdminPolicy(); @Override Optional<String> awsReadOnlyPolicy(); @Override String getArn(); @Override boolean exists(); boolean exists(boolean allowExistingPendingDeletedOrDisabledKey); int pendingDeletionWindowInDays(); }### Answer:
@Test public void testGetArn() throws Exception { when(mockKmsManager.getArn()).thenReturn(KMS_ARN); assertEquals(kmsEncryptor.getArn(), KMS_ARN); verify(mockKmsManager, times(1)).getArn(); } |
### Question:
KMSEncryptor implements Encryptor, ManagedResource { @Override public boolean exists() { return kmsManager.exists(); } KMSEncryptor(KMSManager kmsManager, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier, AwsCrypto awsCrypto, EncryptionStrength encryptionStrength); static KMSEncryptor fromCredentials(AWSCredentialsProvider awsCredentials,
ClientConfiguration clientConfiguration,
SecretsGroupIdentifier groupIdentifier,
EncryptionStrength encryptionStrength); @Override String encrypt(String plaintext, EncryptionContext context); @Override String decrypt(String ciphertext, EncryptionContext context); @Override byte[] encrypt(byte[] plaintext, EncryptionContext context); @Override byte[] decrypt(byte[] ciphertext, EncryptionContext context); byte[] generateRandom(Integer numberOfBytes); @Override String create(); String create(boolean allowExistingPendingDeletedOrDisabledKey); @Override void delete(); @Override Optional<String> awsAdminPolicy(); @Override Optional<String> awsReadOnlyPolicy(); @Override String getArn(); @Override boolean exists(); boolean exists(boolean allowExistingPendingDeletedOrDisabledKey); int pendingDeletionWindowInDays(); }### Answer:
@Test public void testExists() throws Exception { when(mockKmsManager.exists()).thenReturn(true); assertTrue(kmsEncryptor.exists()); verify(mockKmsManager, times(1)).exists(); } |
### Question:
DefaultEncryptionContext implements EncryptionContext { @Override public Map<String, String> toMap() { ImmutableMap.Builder<String, String> builder = ImmutableMap.builder(); builder.put("0", Padding.padWithSpaces(groupIdentifier.region.getName(), 14)); builder.put("1", Padding.padWithSpaces(groupIdentifier.name, 64)); builder.put("2", Padding.padWithSpaces(secretIdentifier.name, 128)); builder.put("3", Padding.padWithZeros(secretVersion)); builder.put("4", Padding.singleDigit(state.asByte())); builder.put("5", Padding.isPresent(notBefore)); builder.put("6", Padding.asOptionalString(notBefore)); builder.put("7", Padding.isPresent(notAfter)); builder.put("8", Padding.asOptionalString(notAfter)); return builder.build(); } DefaultEncryptionContext(SecretsGroupIdentifier groupIdentifier,
SecretIdentifier secretIdentifier,
long secretVersion,
State state,
Optional<ZonedDateTime> notBefore,
Optional<ZonedDateTime> notAfter); @Override Map<String, String> toMap(); final SecretsGroupIdentifier groupIdentifier; final SecretIdentifier secretIdentifier; final Long secretVersion; final State state; final Optional<ZonedDateTime> notBefore; final Optional<ZonedDateTime> notAfter; }### Answer:
@Test public void testToMap() { DefaultEncryptionContext context = new DefaultEncryptionContext( new SecretsGroupIdentifier(Region.US_WEST_1, "test.group"), new SecretIdentifier("secret1"), Long.parseUnsignedLong("8446744073709551615"), State.ENABLED, Optional.of(ZonedDateTime.of(2016,1,2,3,4,0,0, ZoneId.of("UTC"))), Optional.empty() ); Map<String, String> map = context.toMap(); assertEquals(map.get("0"), "us-west-1 "); assertEquals(map.get("0").length(), 14); assertEquals(map.get("1"), "test.group "); assertEquals(map.get("1").length(), 64); assertEquals(map.get("2"), "secret1 "); assertEquals(map.get("2").length(), 128); assertEquals(map.get("3"), "08446744073709551615"); assertEquals(map.get("3").length(), 20); assertEquals(map.get("4"), "2"); assertEquals(map.get("4").length(), 1); assertEquals(map.get("5"), "1"); assertEquals(map.get("5").length(), 1); assertEquals(map.get("6"), "00000000001451703840"); assertEquals(map.get("6").length(), 20); assertEquals(map.get("7"), "0"); assertEquals(map.get("7").length(), 1); assertEquals(map.get("8"), "00000000000000000000"); assertEquals(map.get("8").length(), 20); } |
### Question:
IAMPolicyManager { public String getAdminPolicyArn(SecretsGroupIdentifier group) { return getArn(group, AccessLevel.ADMIN); } IAMPolicyManager(AmazonIdentityManagement client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration); static IAMPolicyManager fromCredentials(AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration); static String getAccount(AWSCredentialsProvider awsCredentialsProvider, ClientConfiguration clientConfiguration); String getAccount(); boolean adminPolicyExists(SecretsGroupIdentifier group); boolean readOnlyPolicyExists(SecretsGroupIdentifier group); String getAdminPolicyArn(SecretsGroupIdentifier group); String getReadOnlyArn(SecretsGroupIdentifier group); void attachAdmin(SecretsGroupIdentifier group, Principal principal); void attachReadOnly(SecretsGroupIdentifier group, Principal principal); void detachAllPrincipals(SecretsGroupIdentifier group); void detachAdmin(SecretsGroupIdentifier group, Principal principal); void detachReadOnly(SecretsGroupIdentifier group, Principal principal); void attachPrincipalToPolicy(SecretsGroupIdentifier group, Principal principal, AccessLevel accessLevel); List<Principal> listAttachedAdmin(SecretsGroupIdentifier group); List<Principal> listAttachedReadOnly(SecretsGroupIdentifier group); Set<SecretsGroupIdentifier> getSecretsGroupIdentifiers(); String createAdminPolicy(final SecretsGroupIdentifier group, final KMSEncryptor kmsEncryptor, final Store store); String createReadOnlyPolicy(SecretsGroupIdentifier group, KMSEncryptor kmsEncryptor, Store store); void deleteAdminPolicy(SecretsGroupIdentifier group); void deleteReadonlyPolicy(SecretsGroupIdentifier group); static final String PATH_PREFIX; }### Answer:
@Test public void testGetAdminPolicyArn() throws Exception { String arn = partiallyMockedPolicyManager.getAdminPolicyArn(group); assertEquals(arn, ADMIN_POLICY_ARN); } |
### Question:
KMSManager implements ManagedResource { public String create(boolean allowExistingPendingDeletedOrDisabledKey) { String arn; Optional<KeyMetadata> current = describeKey(); if (current.isPresent()) { if (!allowExistingPendingDeletedOrDisabledKey) { throw new com.schibsted.security.strongbox.sdk.exceptions.AlreadyExistsException(String.format( "KMS key already exists for group=%s,region=%s, and override not set", group.name, group.region.getName())); } arn = current.get().getArn(); KMSKeyState state = KMSKeyState.fromString(current.get().getKeyState()); switch (state) { case PENDING_DELETION: CancelKeyDeletionRequest request = new CancelKeyDeletionRequest(); request.withKeyId(arn); kms.cancelKeyDeletion(request); case DISABLED: EnableKeyRequest enableKeyRequest = new EnableKeyRequest(); enableKeyRequest.withKeyId(arn); kms.enableKey(enableKeyRequest); break; default: throw new com.schibsted.security.strongbox.sdk.exceptions.AlreadyExistsException(String.format( "KMS key already exists for group=%s,region=%s", group.name, group.region.getName())); } } else { CreateKeyRequest keyRequest = new CreateKeyRequest(); keyRequest.setDescription("This key is automatically managed by Strongbox"); CreateKeyResult result = kms.createKey(keyRequest); arn = result.getKeyMetadata().getArn(); CreateAliasRequest createAliasRequest = new CreateAliasRequest(); createAliasRequest.setAliasName(aliasKeyName); createAliasRequest.setTargetKeyId(arn); kms.createAlias(createAliasRequest); EnableKeyRotationRequest enableKeyRotationRequest = new EnableKeyRotationRequest(); enableKeyRotationRequest.setKeyId(arn); kms.enableKeyRotation(enableKeyRotationRequest); } waitForKeyState(KMSKeyState.ENABLED); return arn; } KMSManager(AWSKMS client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier); static KMSManager fromCredentials(AWSCredentialsProvider awsCredentials,
ClientConfiguration clientConfiguration,
SecretsGroupIdentifier groupIdentifier); String create(boolean allowExistingPendingDeletedOrDisabledKey); @Override String create(); byte[] generateRandom(Integer numberOfBytes); @Override void delete(); @Override Optional<String> awsAdminPolicy(); @Override Optional<String> awsReadOnlyPolicy(); @Override String getArn(); @Override boolean exists(); boolean exists(boolean allowExistingPendingDeletedOrDisabledKey); String getAliasArn(); int pendingDeletionWindowInDays(); }### Answer:
@Test public void testCreate() throws Exception { CreateKeyRequest createKeyRequest = new CreateKeyRequest().withDescription( "This key is automatically managed by Strongbox"); CreateKeyResult createKeyResult = new CreateKeyResult().withKeyMetadata(new KeyMetadata().withArn(KMS_ARN)); CreateAliasRequest createAliasRequest = new CreateAliasRequest().withAliasName(ALIAS_KEY_NAME).withTargetKeyId(KMS_ARN); when(mockKMSClient.describeKey(describeKeyRequest)) .thenThrow(NotFoundException.class) .thenThrow(NotFoundException.class) .thenReturn(enabledKeyResult()); when(mockKMSClient.createKey(createKeyRequest)).thenReturn(createKeyResult); String arn = kmsManager.create(); assertEquals(arn, KMS_ARN); verify(mockKMSClient, times(3)).describeKey(describeKeyRequest); verify(mockKMSClient, times(1)).createAlias(createAliasRequest); verify(mockKMSClient, times(1)).createKey(createKeyRequest); } |
### Question:
KMSManager implements ManagedResource { @Override public void delete() { deleteAndGetSchedule(); waitForKeyState(KMSKeyState.PENDING_DELETION); } KMSManager(AWSKMS client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier); static KMSManager fromCredentials(AWSCredentialsProvider awsCredentials,
ClientConfiguration clientConfiguration,
SecretsGroupIdentifier groupIdentifier); String create(boolean allowExistingPendingDeletedOrDisabledKey); @Override String create(); byte[] generateRandom(Integer numberOfBytes); @Override void delete(); @Override Optional<String> awsAdminPolicy(); @Override Optional<String> awsReadOnlyPolicy(); @Override String getArn(); @Override boolean exists(); boolean exists(boolean allowExistingPendingDeletedOrDisabledKey); String getAliasArn(); int pendingDeletionWindowInDays(); }### Answer:
@Test public void testDelete() throws Exception { ScheduleKeyDeletionRequest deleteRequest = new ScheduleKeyDeletionRequest() .withKeyId(KMS_ARN) .withPendingWindowInDays(7); ScheduleKeyDeletionResult deleteResult = new ScheduleKeyDeletionResult(). withDeletionDate(new Date()); when(mockKMSClient.scheduleKeyDeletion(deleteRequest)).thenReturn(deleteResult); when(mockKMSClient.describeKey(describeKeyRequest)) .thenReturn(enabledKeyResult()) .thenReturn(enabledKeyResult()) .thenReturn(constructDescribeKeyResult(KeyState.PendingDeletion)); kmsManager.delete(); verify(mockKMSClient, times(3)).describeKey(describeKeyRequest); verify(mockKMSClient, times(1)).scheduleKeyDeletion(deleteRequest); } |
### Question:
KMSManager implements ManagedResource { @Override public boolean exists() { return exists(false); } KMSManager(AWSKMS client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration, SecretsGroupIdentifier groupIdentifier); static KMSManager fromCredentials(AWSCredentialsProvider awsCredentials,
ClientConfiguration clientConfiguration,
SecretsGroupIdentifier groupIdentifier); String create(boolean allowExistingPendingDeletedOrDisabledKey); @Override String create(); byte[] generateRandom(Integer numberOfBytes); @Override void delete(); @Override Optional<String> awsAdminPolicy(); @Override Optional<String> awsReadOnlyPolicy(); @Override String getArn(); @Override boolean exists(); boolean exists(boolean allowExistingPendingDeletedOrDisabledKey); String getAliasArn(); int pendingDeletionWindowInDays(); }### Answer:
@Test public void testExists() throws Exception { when(mockKMSClient.describeKey(describeKeyRequest)).thenReturn(enabledKeyResult()); assertTrue(kmsManager.exists()); } |
### Question:
EncryptionPayload implements BestEffortShred { public String toJsonBlob() { try { return objectMapper.writeValueAsString(this); } catch (JsonProcessingException e) { throw new SerializationException("Failed to serialize to JSON blob", e); } } @JsonCreator EncryptionPayload(@JsonProperty("value") SecretValue value,
@JsonProperty("userdata") Optional<UserData> userData,
@JsonProperty("created") ZonedDateTime created,
Optional<UserAlias> createdBy,
@JsonProperty("modified") ZonedDateTime modified,
Optional<UserAlias> modifiedBy,
@JsonProperty("comment") Optional<Comment> comment); static byte[] computeSHA(State state, Optional<ZonedDateTime> notBefore, Optional<ZonedDateTime> notAfter); static boolean verifyDataIntegrity(State state, Optional<ZonedDateTime> notBefore, Optional<ZonedDateTime> notAfter, byte[] sha); byte[] toByteArray(); static EncryptionPayload fromByteArray(byte[] payload); String toJsonBlob(); static EncryptionPayload fromJsonBlob(String jsonBlob); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); @Override void bestEffortShred(); final SecretValue value; final Optional<UserData> userData; final ZonedDateTime created; final ZonedDateTime modified; final Optional<UserAlias> createdBy; final Optional<UserAlias> modifiedBy; final Optional<Comment> comment; }### Answer:
@Test(enabled = false) public void testSerialize() { String serialized = encryptionPayload.toJsonBlob(); assertThat(serialized, is(blob)); } |
### Question:
EncryptionPayload implements BestEffortShred { public static EncryptionPayload fromJsonBlob(String jsonBlob) { try { return objectMapper.readValue(jsonBlob, EncryptionPayload.class); } catch (IOException e) { throw new ParseException("Failed to deserialize JSON blob", e); } } @JsonCreator EncryptionPayload(@JsonProperty("value") SecretValue value,
@JsonProperty("userdata") Optional<UserData> userData,
@JsonProperty("created") ZonedDateTime created,
Optional<UserAlias> createdBy,
@JsonProperty("modified") ZonedDateTime modified,
Optional<UserAlias> modifiedBy,
@JsonProperty("comment") Optional<Comment> comment); static byte[] computeSHA(State state, Optional<ZonedDateTime> notBefore, Optional<ZonedDateTime> notAfter); static boolean verifyDataIntegrity(State state, Optional<ZonedDateTime> notBefore, Optional<ZonedDateTime> notAfter, byte[] sha); byte[] toByteArray(); static EncryptionPayload fromByteArray(byte[] payload); String toJsonBlob(); static EncryptionPayload fromJsonBlob(String jsonBlob); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); @Override void bestEffortShred(); final SecretValue value; final Optional<UserData> userData; final ZonedDateTime created; final ZonedDateTime modified; final Optional<UserAlias> createdBy; final Optional<UserAlias> modifiedBy; final Optional<Comment> comment; }### Answer:
@Test(enabled = false) public void testDeserialize() { EncryptionPayload deserialized = EncryptionPayload.fromJsonBlob(blob); assertThat(deserialized, is(encryptionPayload)); }
@Test(expectedExceptions = ParseException.class) public void testDeserializeInvalidJson() { EncryptionPayload deserialized = EncryptionPayload.fromJsonBlob("{!@#$%^"); } |
### Question:
EncryptionPayload implements BestEffortShred { public static EncryptionPayload fromByteArray(byte[] payload) { ByteBuffer byteBuffer = ByteBuffer.wrap(payload); byte version = byteBuffer.get(); if (version != (byte)1) { throw new IllegalStateException(String.format("Expected version 1, got %d", version)); } ZonedDateTime created = FormattedTimestamp.fromEpoch(byteBuffer.getLong()); ZonedDateTime modified = FormattedTimestamp.fromEpoch(byteBuffer.getLong()); Optional<UserAlias> createdBy = readOptionalString(byteBuffer).map(UserAlias::new); Optional<UserAlias> modifiedBy = readOptionalString(byteBuffer).map(UserAlias::new); Encoding encoding = Encoding.fromByte(byteBuffer.get()); SecretType secretType = SecretType.fromByte(byteBuffer.get()); SecretValue value = new SecretValue(readArray(byteBuffer), encoding, secretType); Optional<UserData> userData = readUserData(byteBuffer); Optional<Comment> comment = readComment(byteBuffer); return new EncryptionPayload(value, userData, created, createdBy, modified, modifiedBy, comment); } @JsonCreator EncryptionPayload(@JsonProperty("value") SecretValue value,
@JsonProperty("userdata") Optional<UserData> userData,
@JsonProperty("created") ZonedDateTime created,
Optional<UserAlias> createdBy,
@JsonProperty("modified") ZonedDateTime modified,
Optional<UserAlias> modifiedBy,
@JsonProperty("comment") Optional<Comment> comment); static byte[] computeSHA(State state, Optional<ZonedDateTime> notBefore, Optional<ZonedDateTime> notAfter); static boolean verifyDataIntegrity(State state, Optional<ZonedDateTime> notBefore, Optional<ZonedDateTime> notAfter, byte[] sha); byte[] toByteArray(); static EncryptionPayload fromByteArray(byte[] payload); String toJsonBlob(); static EncryptionPayload fromJsonBlob(String jsonBlob); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); @Override void bestEffortShred(); final SecretValue value; final Optional<UserData> userData; final ZonedDateTime created; final ZonedDateTime modified; final Optional<UserAlias> createdBy; final Optional<UserAlias> modifiedBy; final Optional<Comment> comment; }### Answer:
@Test void deserializeBinary() { EncryptionPayload deserializedPayload = EncryptionPayload.fromByteArray(binaryBlob); assertThat(deserializedPayload, is(encryptionPayload)); } |
### Question:
EncryptionPayload implements BestEffortShred { @Override public String toString() { return MoreObjects.toStringHelper(this) .add("value", value) .add("userdata", userData) .add("created", created) .add("modified", modified) .add("comment", comment) .toString(); } @JsonCreator EncryptionPayload(@JsonProperty("value") SecretValue value,
@JsonProperty("userdata") Optional<UserData> userData,
@JsonProperty("created") ZonedDateTime created,
Optional<UserAlias> createdBy,
@JsonProperty("modified") ZonedDateTime modified,
Optional<UserAlias> modifiedBy,
@JsonProperty("comment") Optional<Comment> comment); static byte[] computeSHA(State state, Optional<ZonedDateTime> notBefore, Optional<ZonedDateTime> notAfter); static boolean verifyDataIntegrity(State state, Optional<ZonedDateTime> notBefore, Optional<ZonedDateTime> notAfter, byte[] sha); byte[] toByteArray(); static EncryptionPayload fromByteArray(byte[] payload); String toJsonBlob(); static EncryptionPayload fromJsonBlob(String jsonBlob); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); @Override void bestEffortShred(); final SecretValue value; final Optional<UserData> userData; final ZonedDateTime created; final ZonedDateTime modified; final Optional<UserAlias> createdBy; final Optional<UserAlias> modifiedBy; final Optional<Comment> comment; }### Answer:
@Test public void testToString() { assertEquals( encryptionPayload.toString(), "EncryptionPayload{value=SecretValue{type=opaque, secretEncoding=utf8}, userdata=Optional[UserData{}], " + "created=2016-06-01T00:00Z[UTC], modified=2017-06-01T00:00Z[UTC], " + "comment=Optional[Comment{}]}"); } |
### Question:
EncryptionPayload implements BestEffortShred { public static byte[] computeSHA(State state, Optional<ZonedDateTime> notBefore, Optional<ZonedDateTime> notAfter) { try { MessageDigest messageDigest = MessageDigest.getInstance("SHA-256"); messageDigest.update(state.asByte()); messageDigest.update(toByteArray(notBefore)); messageDigest.update(toByteArray(notAfter)); return messageDigest.digest(); } catch (NoSuchAlgorithmException e) { throw new SerializationException("Failed to get SHA for encryption payload", e); } } @JsonCreator EncryptionPayload(@JsonProperty("value") SecretValue value,
@JsonProperty("userdata") Optional<UserData> userData,
@JsonProperty("created") ZonedDateTime created,
Optional<UserAlias> createdBy,
@JsonProperty("modified") ZonedDateTime modified,
Optional<UserAlias> modifiedBy,
@JsonProperty("comment") Optional<Comment> comment); static byte[] computeSHA(State state, Optional<ZonedDateTime> notBefore, Optional<ZonedDateTime> notAfter); static boolean verifyDataIntegrity(State state, Optional<ZonedDateTime> notBefore, Optional<ZonedDateTime> notAfter, byte[] sha); byte[] toByteArray(); static EncryptionPayload fromByteArray(byte[] payload); String toJsonBlob(); static EncryptionPayload fromJsonBlob(String jsonBlob); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); @Override void bestEffortShred(); final SecretValue value; final Optional<UserData> userData; final ZonedDateTime created; final ZonedDateTime modified; final Optional<UserAlias> createdBy; final Optional<UserAlias> modifiedBy; final Optional<Comment> comment; }### Answer:
@Test public void ensureNotCommutative() { byte[] sha1 = EncryptionPayload.computeSHA(State.ENABLED, notAfter, Optional.empty()); byte[] sha2 = EncryptionPayload.computeSHA(State.ENABLED, Optional.empty(), notAfter); assertNotEquals(sha1, sha2, "Should not be able to reorder and have the same hash"); } |
### Question:
EncryptionPayload implements BestEffortShred { @Override public boolean equals(final Object obj) { if(obj instanceof EncryptionPayload){ final EncryptionPayload other = (EncryptionPayload) obj; return Objects.equal(value, other.value) && Objects.equal(userData, other.userData) && Objects.equal(created, other.created) && Objects.equal(modified, other.modified) && Objects.equal(comment, other.comment); } else { return false; } } @JsonCreator EncryptionPayload(@JsonProperty("value") SecretValue value,
@JsonProperty("userdata") Optional<UserData> userData,
@JsonProperty("created") ZonedDateTime created,
Optional<UserAlias> createdBy,
@JsonProperty("modified") ZonedDateTime modified,
Optional<UserAlias> modifiedBy,
@JsonProperty("comment") Optional<Comment> comment); static byte[] computeSHA(State state, Optional<ZonedDateTime> notBefore, Optional<ZonedDateTime> notAfter); static boolean verifyDataIntegrity(State state, Optional<ZonedDateTime> notBefore, Optional<ZonedDateTime> notAfter, byte[] sha); byte[] toByteArray(); static EncryptionPayload fromByteArray(byte[] payload); String toJsonBlob(); static EncryptionPayload fromJsonBlob(String jsonBlob); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); @Override void bestEffortShred(); final SecretValue value; final Optional<UserData> userData; final ZonedDateTime created; final ZonedDateTime modified; final Optional<UserAlias> createdBy; final Optional<UserAlias> modifiedBy; final Optional<Comment> comment; }### Answer:
@Test public void testEquals() { EncryptionPayload samePayload = new EncryptionPayload(value, userData, created, createdBy, modified, modifiedBy, comment); assertTrue(encryptionPayload.equals(samePayload)); EncryptionPayload differentPayload = new EncryptionPayload(new SecretValue("DifferentValue", SecretType.OPAQUE), userData, created, createdBy, modified, modifiedBy, comment); assertFalse(encryptionPayload.equals(differentPayload)); differentPayload = new EncryptionPayload(value, Optional.of(new UserData("different userdata".getBytes(StandardCharsets.UTF_8))), created, createdBy, modified, modifiedBy, comment); assertFalse(encryptionPayload.equals(differentPayload)); differentPayload = new EncryptionPayload(value, userData, ZonedDateTime.of(2017,12,1,0,0,0,0, ZoneId.of("UTC")), createdBy, modified, modifiedBy, comment); assertFalse(encryptionPayload.equals(differentPayload)); differentPayload = new EncryptionPayload(value, userData, created, createdBy, ZonedDateTime.of(2017,12,1,0,0,0,0, ZoneId.of("UTC")), modifiedBy, comment); assertFalse(encryptionPayload.equals(differentPayload)); differentPayload = new EncryptionPayload(value, userData, created, createdBy, modified, modifiedBy, Optional.of(new Comment("different comment"))); assertFalse(encryptionPayload.equals(differentPayload)); assertFalse(encryptionPayload.equals("some string value")); } |
### Question:
IAMPolicyManager { public String getReadOnlyArn(SecretsGroupIdentifier group) { return getArn(group, AccessLevel.READONLY); } IAMPolicyManager(AmazonIdentityManagement client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration); static IAMPolicyManager fromCredentials(AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration); static String getAccount(AWSCredentialsProvider awsCredentialsProvider, ClientConfiguration clientConfiguration); String getAccount(); boolean adminPolicyExists(SecretsGroupIdentifier group); boolean readOnlyPolicyExists(SecretsGroupIdentifier group); String getAdminPolicyArn(SecretsGroupIdentifier group); String getReadOnlyArn(SecretsGroupIdentifier group); void attachAdmin(SecretsGroupIdentifier group, Principal principal); void attachReadOnly(SecretsGroupIdentifier group, Principal principal); void detachAllPrincipals(SecretsGroupIdentifier group); void detachAdmin(SecretsGroupIdentifier group, Principal principal); void detachReadOnly(SecretsGroupIdentifier group, Principal principal); void attachPrincipalToPolicy(SecretsGroupIdentifier group, Principal principal, AccessLevel accessLevel); List<Principal> listAttachedAdmin(SecretsGroupIdentifier group); List<Principal> listAttachedReadOnly(SecretsGroupIdentifier group); Set<SecretsGroupIdentifier> getSecretsGroupIdentifiers(); String createAdminPolicy(final SecretsGroupIdentifier group, final KMSEncryptor kmsEncryptor, final Store store); String createReadOnlyPolicy(SecretsGroupIdentifier group, KMSEncryptor kmsEncryptor, Store store); void deleteAdminPolicy(SecretsGroupIdentifier group); void deleteReadonlyPolicy(SecretsGroupIdentifier group); static final String PATH_PREFIX; }### Answer:
@Test public void testGetReadOnlyArn() throws Exception { String arn = partiallyMockedPolicyManager.getReadOnlyArn(group); assertEquals(arn, READONLY_POLICY_ARN); } |
### Question:
FileEncryptionContext implements EncryptionContext { @Override public Map<String, String> toMap() { return ImmutableMap.of( "0", FILE_VERSION, "1", groupIdentifier.region.getName(), "2", groupIdentifier.name); } FileEncryptionContext(SecretsGroupIdentifier groupIdentifier); @Override Map<String, String> toMap(); final SecretsGroupIdentifier groupIdentifier; }### Answer:
@Test public void testToMap() { FileEncryptionContext context = new FileEncryptionContext( new SecretsGroupIdentifier(Region.EU_WEST_1, "test.group") ); Map<String, String> map = context.toMap(); assertEquals(map.get("0"), "1"); assertEquals(map.get("1"), "eu-west-1"); assertEquals(map.get("2"), "test.group"); } |
### Question:
GenericDynamoDB implements GenericStore<Entry, Primary>, ManagedResource, AutoCloseable { @Override public String create() { readWriteLock.writeLock().lock(); try { CreateTableResult result = client.createTable(constructCreateTableRequest()); waitForTableToBecomeActive(); return result.getTableDescription().getTableArn(); } catch (ResourceInUseException e) { throw new AlreadyExistsException(String.format("There is already a DynamoDB table called '%s'", tableName), e); } finally { readWriteLock.writeLock().unlock(); } } GenericDynamoDB(AmazonDynamoDB client, AWSCredentialsProvider awsCredentials,
ClientConfiguration clientConfiguration,
SecretsGroupIdentifier groupIdentifier, Class<Entry> clazz, Converters converters,
ReadWriteLock readWriteLock); CreateTableRequest constructCreateTableRequest(); @Override String create(); @Override void delete(); @Override Optional<String> awsAdminPolicy(); @Override Optional<String> awsReadOnlyPolicy(); @Override String getArn(); @Override boolean exists(); @Override void create(Entry entry); @Override void update(Entry entry, Entry existingEntry); @Override void delete(Primary partitionKeyValue); @Override Set<Primary> keySet(); @Override KVStream<Entry> stream(); @Override void close(); }### Answer:
@Test public void testCreateEntry() throws Exception { RawSecretEntry rawSecretEntry = constructRawEntry(SECRET_NAME); UpdateItemRequest expectedUpdateRequest = constructUpdateItemRequest(rawSecretEntry, false, Optional.empty()); dynamoDB.create(rawSecretEntry); verify(mockDynamoDBClient, times(1)).updateItem(expectedUpdateRequest); }
@Test public void testCreateEntryAlreadyExists() throws Exception { RawSecretEntry rawSecretEntry = constructRawEntry(SECRET_NAME); UpdateItemRequest expectedUpdateRequest = constructUpdateItemRequest(rawSecretEntry, false, Optional.empty()); when(mockDynamoDBClient.updateItem(expectedUpdateRequest)).thenThrow( new ConditionalCheckFailedException("")); boolean exceptionThrown = false; try { dynamoDB.create(rawSecretEntry); } catch (AlreadyExistsException e) { assertEquals(e.getMessage(), "DynamoDB store entry already exists:{1={S: secret1,}, 2={N: 1,}}"); exceptionThrown = true; } assertTrue(exceptionThrown); verify(mockDynamoDBClient, times(1)).updateItem(expectedUpdateRequest); } |
### Question:
GenericDynamoDB implements GenericStore<Entry, Primary>, ManagedResource, AutoCloseable { @Override public void update(Entry entry, Entry existingEntry) { readWriteLock.writeLock().lock(); try { Map<String, AttributeValue> keys = createKey(entry); Map<String, AttributeValueUpdate> attributes = createAttributes(entry); Map<String, ExpectedAttributeValue> expected = expectExists(existingEntry); try { executeUpdate(keys, attributes, expected); } catch (ConditionalCheckFailedException e) { throw new DoesNotExistException("Precondition to update entry in DynamoDB failed:" + keys.toString()); } } finally { readWriteLock.writeLock().unlock(); } } GenericDynamoDB(AmazonDynamoDB client, AWSCredentialsProvider awsCredentials,
ClientConfiguration clientConfiguration,
SecretsGroupIdentifier groupIdentifier, Class<Entry> clazz, Converters converters,
ReadWriteLock readWriteLock); CreateTableRequest constructCreateTableRequest(); @Override String create(); @Override void delete(); @Override Optional<String> awsAdminPolicy(); @Override Optional<String> awsReadOnlyPolicy(); @Override String getArn(); @Override boolean exists(); @Override void create(Entry entry); @Override void update(Entry entry, Entry existingEntry); @Override void delete(Primary partitionKeyValue); @Override Set<Primary> keySet(); @Override KVStream<Entry> stream(); @Override void close(); }### Answer:
@Test public void testUpdateEntry() throws Exception { RawSecretEntry rawSecretEntry = constructRawEntry(SECRET_NAME); RawSecretEntry alternativeRawSecretEntry = constructAlternativeRawSecretEntry(SECRET_NAME); UpdateItemRequest expectedUpdateRequest = constructUpdateItemRequest(rawSecretEntry, true, Optional.of(alternativeRawSecretEntry)); dynamoDB.update(rawSecretEntry, alternativeRawSecretEntry); verify(mockDynamoDBClient, times(1)).updateItem(expectedUpdateRequest); }
@Test public void testUpdateEntryDoesNotExist() throws Exception { RawSecretEntry rawSecretEntry = constructRawEntry(SECRET_NAME); RawSecretEntry alternativeRawSecretEntry = constructAlternativeRawSecretEntry(SECRET_NAME); UpdateItemRequest expectedUpdateRequest = constructUpdateItemRequest(rawSecretEntry, true, Optional.of(alternativeRawSecretEntry)); when(mockDynamoDBClient.updateItem(expectedUpdateRequest)).thenThrow( new ConditionalCheckFailedException("")); boolean exceptionThrown = false; try { dynamoDB.update(rawSecretEntry, alternativeRawSecretEntry); } catch (DoesNotExistException e) { assertEquals(e.getMessage(), "Precondition to update entry in DynamoDB failed:{1={S: secret1,}, 2={N: 1,}}"); exceptionThrown = true; } assertTrue(exceptionThrown); verify(mockDynamoDBClient, times(1)).updateItem(expectedUpdateRequest); } |
### Question:
GenericDynamoDB implements GenericStore<Entry, Primary>, ManagedResource, AutoCloseable { @Override public Set<Primary> keySet() { readWriteLock.readLock().lock(); try { return stream() .uniquePrimaryKey() .toJavaStream() .map(this::getUnconvertedPartitionKeyValue) .collect(Collectors.toSet()); } finally { readWriteLock.readLock().unlock(); } } GenericDynamoDB(AmazonDynamoDB client, AWSCredentialsProvider awsCredentials,
ClientConfiguration clientConfiguration,
SecretsGroupIdentifier groupIdentifier, Class<Entry> clazz, Converters converters,
ReadWriteLock readWriteLock); CreateTableRequest constructCreateTableRequest(); @Override String create(); @Override void delete(); @Override Optional<String> awsAdminPolicy(); @Override Optional<String> awsReadOnlyPolicy(); @Override String getArn(); @Override boolean exists(); @Override void create(Entry entry); @Override void update(Entry entry, Entry existingEntry); @Override void delete(Primary partitionKeyValue); @Override Set<Primary> keySet(); @Override KVStream<Entry> stream(); @Override void close(); }### Answer:
@Test public void testKeySet() throws Exception { ScanRequest request = new ScanRequest().withConsistentRead(true).withTableName(tableName); ScanResult result = constructScanResult(); when(mockDynamoDBClient.scan(request)).thenReturn(result); Set<SecretIdentifier> keys = dynamoDB.keySet(); assertEquals(keys.size(), 2); assertTrue(keys.contains(new SecretIdentifier(SECRET_NAME))); assertTrue(keys.contains(new SecretIdentifier(SECRET2_NAME))); verify(mockDynamoDBClient, times(1)).scan(request); }
@Test public void testKeySetEmpty() throws Exception { ScanRequest request = new ScanRequest().withConsistentRead(true).withTableName(tableName); ScanResult result = new ScanResult().withCount(0).withItems(new ArrayList<>()); when(mockDynamoDBClient.scan(request)).thenReturn(result); Set<SecretIdentifier> keySet = dynamoDB.keySet(); assertTrue(keySet.isEmpty()); verify(mockDynamoDBClient, times(1)).scan(request); } |
### Question:
GenericDynamoDB implements GenericStore<Entry, Primary>, ManagedResource, AutoCloseable { @Override public void delete() { readWriteLock.writeLock().lock(); try { client.deleteTable(tableName); waitForTableToFinishDeleting(); } finally { readWriteLock.writeLock().unlock(); } } GenericDynamoDB(AmazonDynamoDB client, AWSCredentialsProvider awsCredentials,
ClientConfiguration clientConfiguration,
SecretsGroupIdentifier groupIdentifier, Class<Entry> clazz, Converters converters,
ReadWriteLock readWriteLock); CreateTableRequest constructCreateTableRequest(); @Override String create(); @Override void delete(); @Override Optional<String> awsAdminPolicy(); @Override Optional<String> awsReadOnlyPolicy(); @Override String getArn(); @Override boolean exists(); @Override void create(Entry entry); @Override void update(Entry entry, Entry existingEntry); @Override void delete(Primary partitionKeyValue); @Override Set<Primary> keySet(); @Override KVStream<Entry> stream(); @Override void close(); }### Answer:
@Test public void testDeleteSecret() { QueryRequest request = constructQueryRequest(SECRET_NAME); QueryResult result = constructQueryResult(false); when(mockDynamoDBClient.query(request)).thenReturn(result); dynamoDB.delete(new SecretIdentifier(SECRET_NAME)); verify(mockDynamoDBClient, times(1)).query(request); verify(mockDynamoDBClient, times(1)).deleteItem(tableName, constructKey(SECRET_NAME, 1)); verify(mockDynamoDBClient, times(1)).deleteItem(tableName, constructKey(SECRET_NAME, 2)); verify(mockDynamoDBClient, never()).deleteItem(tableName, constructKey(SECRET2_NAME, 1)); }
@Test public void testDeleteSecretMaliciousResults() { QueryRequest request = constructQueryRequest(SECRET_NAME); QueryResult maliciousResult = constructQueryResult(true); when(mockDynamoDBClient.query(request)).thenReturn(maliciousResult); boolean consideredMalicious = false; try { dynamoDB.delete(new SecretIdentifier(SECRET_NAME)); } catch (PotentiallyMaliciousDataException e) { consideredMalicious = true; } assertTrue(consideredMalicious); verify(mockDynamoDBClient, times(1)).query(request); verify(mockDynamoDBClient, never()).deleteItem(tableName, constructKey(SECRET_NAME, 1)); verify(mockDynamoDBClient, never()).deleteItem(tableName, constructKey(SECRET_NAME, 2)); verify(mockDynamoDBClient, never()).deleteItem(tableName, constructKey(SECRET2_NAME, 1)); }
@Test public void testDeleteSecretNotInTable() { QueryRequest request = constructQueryRequest(SECRET_NAME); QueryResult result = new QueryResult().withCount(0).withItems(new ArrayList<>()); when(mockDynamoDBClient.query(request)).thenReturn(result); dynamoDB.delete(new SecretIdentifier(SECRET_NAME)); verify(mockDynamoDBClient, times(1)).query(request); verify(mockDynamoDBClient, never()).deleteItem(tableName, constructKey(SECRET_NAME, 1)); } |
### Question:
IAMPolicyManager { public void attachAdmin(SecretsGroupIdentifier group, Principal principal) { attachPrincipalToPolicy(group, principal, AccessLevel.ADMIN); } IAMPolicyManager(AmazonIdentityManagement client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration); static IAMPolicyManager fromCredentials(AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration); static String getAccount(AWSCredentialsProvider awsCredentialsProvider, ClientConfiguration clientConfiguration); String getAccount(); boolean adminPolicyExists(SecretsGroupIdentifier group); boolean readOnlyPolicyExists(SecretsGroupIdentifier group); String getAdminPolicyArn(SecretsGroupIdentifier group); String getReadOnlyArn(SecretsGroupIdentifier group); void attachAdmin(SecretsGroupIdentifier group, Principal principal); void attachReadOnly(SecretsGroupIdentifier group, Principal principal); void detachAllPrincipals(SecretsGroupIdentifier group); void detachAdmin(SecretsGroupIdentifier group, Principal principal); void detachReadOnly(SecretsGroupIdentifier group, Principal principal); void attachPrincipalToPolicy(SecretsGroupIdentifier group, Principal principal, AccessLevel accessLevel); List<Principal> listAttachedAdmin(SecretsGroupIdentifier group); List<Principal> listAttachedReadOnly(SecretsGroupIdentifier group); Set<SecretsGroupIdentifier> getSecretsGroupIdentifiers(); String createAdminPolicy(final SecretsGroupIdentifier group, final KMSEncryptor kmsEncryptor, final Store store); String createReadOnlyPolicy(SecretsGroupIdentifier group, KMSEncryptor kmsEncryptor, Store store); void deleteAdminPolicy(SecretsGroupIdentifier group); void deleteReadonlyPolicy(SecretsGroupIdentifier group); static final String PATH_PREFIX; }### Answer:
@Test public void testAttachAdminUser() throws Exception { Principal principal = new Principal(PrincipalType.USER, "alice"); partiallyMockedPolicyManager.attachAdmin(group, principal); AttachUserPolicyRequest request = new AttachUserPolicyRequest() .withPolicyArn(ADMIN_POLICY_ARN) .withUserName(principal.name); verify(mockClient, times(1)).attachUserPolicy(request); }
@Test public void testAttachAdminGroup() throws Exception { Principal principal = new Principal(PrincipalType.GROUP, "awesome-team"); partiallyMockedPolicyManager.attachAdmin(group, principal); AttachGroupPolicyRequest request = new AttachGroupPolicyRequest() .withPolicyArn(ADMIN_POLICY_ARN) .withGroupName(principal.name); verify(mockClient, times(1)).attachGroupPolicy(request); } |
### Question:
FilterGenerator { public static String convertNumberToLetters(int number) { int range = 'z'-'a' + 1; StringBuilder sb = new StringBuilder(); do { int last = number % range; sb.append(Character.toChars('a' + last)); number /= range; } while (number != 0); return sb.reverse().toString(); } FilterGenerator(int startCount); FilterGenerator(); Filter process(RSEF.ParsedAttributeCondition<Entry> attributeCondition, Converters converters); Filter createTerm(RSEF.TypedTerm<T> typedTerm, Converters converters); static String getOperator(RSEF.BinaryOpType binaryOpType); static Map<A, B> merge(Map<A, B> left, Map<A, B> right); static String convertNumberToLetters(int number); public int count; }### Answer:
@Test public void test() { assertThat(FilterGenerator.convertNumberToLetters(0), is("a")); assertThat(FilterGenerator.convertNumberToLetters(1), is("b")); assertThat(FilterGenerator.convertNumberToLetters(26-1), is("z")); assertThat(FilterGenerator.convertNumberToLetters(26), is("ba")); assertThat(FilterGenerator.convertNumberToLetters(26+1), is("bb")); assertThat(FilterGenerator.convertNumberToLetters(26*26-1), is("zz")); assertThat(FilterGenerator.convertNumberToLetters(26*26), is("baa")); assertThat(FilterGenerator.convertNumberToLetters(26*26+1), is("bab")); assertThat(FilterGenerator.convertNumberToLetters(26*26*26-1), is("zzz")); } |
### Question:
IAMPolicyName { @Override public String toString() { return String.format("%s_%s_%s_%s", AWSResourceNameSerialization.GLOBAL_PREFIX, group.region.getName(), AWSResourceNameSerialization.encodeSecretsGroupName(group.name), accessLevel); } IAMPolicyName(SecretsGroupIdentifier group, AccessLevel accessLevel); @Override String toString(); static IAMPolicyName fromString(String wrappedAWSResourceName); @Override boolean equals(final Object obj); final SecretsGroupIdentifier group; final AccessLevel accessLevel; }### Answer:
@Test public void testToString() throws Exception { assertEquals(adminPolicyName.toString(), adminPolicyAsString); assertEquals(readonlyPolicyName.toString(), readonlyPolicyAsString); } |
### Question:
IAMPolicyName { public static IAMPolicyName fromString(String wrappedAWSResourceName) { String[] parts = wrappedAWSResourceName.split(AWSResourceNameSerialization.GLOBAL_STRING_DELIMITER); if (!parts[0].equals(AWSResourceNameSerialization.GLOBAL_PREFIX)) { throw new InvalidResourceName(wrappedAWSResourceName, "An IAM policy name should start with " + AWSResourceNameSerialization.GLOBAL_PREFIX); } if (parts.length != 4) { throw new InvalidResourceName(wrappedAWSResourceName, "An IAM policy name should have exactly 4 parts"); } Region region = Region.fromName(parts[1]); String name = AWSResourceNameSerialization.decodeSecretsGroupName(parts[2]); SecretsGroupIdentifier group = new SecretsGroupIdentifier(region, name); AccessLevel accessLevel = AccessLevel.fromString(parts[3]); return new IAMPolicyName(group, accessLevel); } IAMPolicyName(SecretsGroupIdentifier group, AccessLevel accessLevel); @Override String toString(); static IAMPolicyName fromString(String wrappedAWSResourceName); @Override boolean equals(final Object obj); final SecretsGroupIdentifier group; final AccessLevel accessLevel; }### Answer:
@Test public void testFromString() throws Exception { IAMPolicyName adminFromString = IAMPolicyName.fromString(adminPolicyAsString); assertEquals(adminFromString.group, group); assertEquals(adminFromString.accessLevel, AccessLevel.ADMIN); IAMPolicyName readonlyFromString = IAMPolicyName.fromString(readonlyPolicyAsString); assertEquals(readonlyFromString.group, group); assertEquals(readonlyFromString.accessLevel, AccessLevel.READONLY); }
@Test(expectedExceptions = IllegalArgumentException.class) public void testFromStringInvalidAccessLevel() throws Exception { IAMPolicyName.fromString("strongbox_us-west-1_test-group_invalid"); }
@Test(expectedExceptions = InvalidResourceName.class) public void testFromStringMissingRegion() throws Exception { IAMPolicyName.fromString("strongbox_test-group_admin"); }
@Test(expectedExceptions = InvalidResourceName.class) public void testFromStringInvalidPrefix() throws Exception { IAMPolicyName.fromString("sm_eu-west-1_test-group_admin"); } |
### Question:
IAMPolicyName { @Override public boolean equals(final Object obj) { if (obj instanceof IAMPolicyName) { final IAMPolicyName other = (IAMPolicyName) obj; return Objects.equal(group, other.group) && Objects.equal(accessLevel, other.accessLevel); } else { return false; } } IAMPolicyName(SecretsGroupIdentifier group, AccessLevel accessLevel); @Override String toString(); static IAMPolicyName fromString(String wrappedAWSResourceName); @Override boolean equals(final Object obj); final SecretsGroupIdentifier group; final AccessLevel accessLevel; }### Answer:
@Test public void testEquals() throws Exception { assertTrue(adminPolicyName.equals(new IAMPolicyName(group, AccessLevel.ADMIN))); assertTrue(readonlyPolicyName.equals(new IAMPolicyName(group, AccessLevel.READONLY))); assertFalse(adminPolicyName.equals(readonlyPolicyName)); assertFalse(adminPolicyName.equals( new IAMPolicyName(new SecretsGroupIdentifier(Region.EU_WEST_1, "test.group"), AccessLevel.ADMIN))); assertFalse(adminPolicyName.equals( new IAMPolicyName(new SecretsGroupIdentifier(Region.US_WEST_1, "test.group2"), AccessLevel.ADMIN))); } |
### Question:
UserConfig { public void addLocalFilePath(SecretsGroupIdentifier group, File path) { checkUniqueGroup(group); checkUniqueFilePath(path); localFiles.put(group, path); } UserConfig(@JsonProperty("localFiles") Map<SecretsGroupIdentifier, File> localFiles); UserConfig(); Map<SecretsGroupIdentifier, File> getMap(); Optional<File> getLocalFilePath(SecretsGroupIdentifier group); void addLocalFilePath(SecretsGroupIdentifier group, File path); void updateLocalFilePath(SecretsGroupIdentifier group, File path); void removeLocalFilePath(SecretsGroupIdentifier group); }### Answer:
@Test(expectedExceptions = AlreadyExistsException.class) public void addSamePathToConfig() { SecretsGroupIdentifier anotherGroup = new SecretsGroupIdentifier(Region.EU_CENTRAL_1, "test2.group"); userConfig.addLocalFilePath(EU_GROUP, new File("path-eu")); userConfig.addLocalFilePath(anotherGroup, new File("path-eu")); }
@Test(expectedExceptions = AlreadyExistsException.class) public void addSameGroupToConfigWithDifferentPath() { userConfig.addLocalFilePath(EU_GROUP, new File("path-eu")); userConfig.addLocalFilePath(EU_GROUP, new File("path-foobar")); } |
### Question:
FileUserConfig extends UserConfig { @Override public Optional<File> getLocalFilePath(SecretsGroupIdentifier group) { return Optional.ofNullable(localFiles.get(group)); } FileUserConfig(File configFile); @Override Optional<File> getLocalFilePath(SecretsGroupIdentifier group); @Override void addLocalFilePath(SecretsGroupIdentifier group, File path); @Override void updateLocalFilePath(SecretsGroupIdentifier group, File path); @Override void removeLocalFilePath(SecretsGroupIdentifier group); }### Answer:
@Test public void testGetLocalFilePath() throws Exception { assertEquals(fileUserConfig.getLocalFilePath(GROUP1_US), Optional.of(new File("uswest1-test-group.sm"))); assertEquals(fileUserConfig.getLocalFilePath(GROUP1_EU), Optional.of(new File("euwest1-test-group.sm"))); assertEquals(fileUserConfig.getLocalFilePath(GROUP2_EU), Optional.of(new File("euwest1-test-group2.sm"))); assertEquals(fileUserConfig.getLocalFilePath( new SecretsGroupIdentifier(Region.EU_CENTRAL_1, "test.group")), Optional.empty()); } |
### Question:
FileUserConfig extends UserConfig { @Override public void updateLocalFilePath(SecretsGroupIdentifier group, File path) { checkUniqueFilePath(path); localFiles.put(group, path); persist(); } FileUserConfig(File configFile); @Override Optional<File> getLocalFilePath(SecretsGroupIdentifier group); @Override void addLocalFilePath(SecretsGroupIdentifier group, File path); @Override void updateLocalFilePath(SecretsGroupIdentifier group, File path); @Override void removeLocalFilePath(SecretsGroupIdentifier group); }### Answer:
@Test public void testUpdateLocalFilePath() throws Exception { assertEquals(fileUserConfig.getLocalFilePath(GROUP1_US), Optional.of(new File("uswest1-test-group.sm"))); fileUserConfig.updateLocalFilePath(GROUP1_US, new File("some-other-file.sm")); assertEquals(fileUserConfig.getLocalFilePath(GROUP1_US), Optional.of(new File("some-other-file.sm"))); } |
### Question:
FileUserConfig extends UserConfig { @Override public void removeLocalFilePath(SecretsGroupIdentifier group) { localFiles.remove(group); persist(); } FileUserConfig(File configFile); @Override Optional<File> getLocalFilePath(SecretsGroupIdentifier group); @Override void addLocalFilePath(SecretsGroupIdentifier group, File path); @Override void updateLocalFilePath(SecretsGroupIdentifier group, File path); @Override void removeLocalFilePath(SecretsGroupIdentifier group); }### Answer:
@Test public void testRemoveLocalFilePath() throws Exception { fileUserConfig.removeLocalFilePath(GROUP1_EU); fileUserConfig.removeLocalFilePath(GROUP2_EU); assertEquals(fileUserConfig.getLocalFilePath(GROUP1_EU), Optional.empty()); assertEquals(fileUserConfig.getLocalFilePath(GROUP2_EU), Optional.empty()); assertEquals(fileUserConfig.getLocalFilePath(GROUP1_US), Optional.of(new File("uswest1-test-group.sm"))); } |
### Question:
AWSResourceNameSerialization { public static String decodeSecretsGroupName(String encoded) { return encoded.replace('-', '.'); } static String decodeSecretsGroupName(String encoded); static String encodeSecretsGroupName(String name); static final String GLOBAL_PREFIX; static final String GLOBAL_STRING_DELIMITER; }### Answer:
@Test public void testDecodeSecretsGroupName() { String decoded = AWSResourceNameSerialization.decodeSecretsGroupName("test-group-1"); assertEquals(decoded, "test.group.1"); } |
### Question:
AWSResourceNameSerialization { public static String encodeSecretsGroupName(String name) { return name.replace('.', '-'); } static String decodeSecretsGroupName(String encoded); static String encodeSecretsGroupName(String name); static final String GLOBAL_PREFIX; static final String GLOBAL_STRING_DELIMITER; }### Answer:
@Test public void testEncodeSecretsGroupName() { String encoded = AWSResourceNameSerialization.encodeSecretsGroupName("test.group.1"); assertEquals(encoded, "test-group-1"); assertEquals(AWSResourceNameSerialization.encodeSecretsGroupName( AWSResourceNameSerialization.decodeSecretsGroupName("test-group-1")), "test-group-1"); } |
### Question:
RawSecretEntry implements BestEffortShred { public String toJsonBlob() { try { return objectMapper.writeValueAsString(this); } catch (JsonProcessingException e) { throw new SerializationException("Failed to serialize secret entry to JSON blob", e); } } @Deprecated RawSecretEntry(); RawSecretEntry(@JsonProperty("secretIdentifier") SecretIdentifier secretIdentifier,
@JsonProperty("version") long version,
@JsonProperty("state") State state,
@JsonProperty("notBefore") Optional<ZonedDateTime> notBefore,
@JsonProperty("notAfter") Optional<ZonedDateTime> notAfter,
@JsonProperty("encryptedPayload") byte[] encryptedPayload); String toJsonBlob(); static RawSecretEntry fromJsonBlob(String jsonBlob); byte[] sha1OfEncryptionPayload(); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); @Override void bestEffortShred(); @PartitionKey(position=Config.KEY, padding = 128)
@JsonProperty("secretIdentifier")
public SecretIdentifier secretIdentifier; @SortKey(position=Config.VERSION)
@JsonProperty("version")
public Long version; @Attribute(position=Config.STATE)
@JsonProperty("state")
public State state; @Attribute(position=Config.NOT_BEFORE)
@JsonProperty("notBefore")
public Optional<ZonedDateTime> notBefore; @Attribute(position=Config.NOT_AFTER)
@JsonProperty("notAfter")
public Optional<ZonedDateTime> notAfter; @Attribute(position=Config.VALUE)
@JsonProperty("encryptedPayload")
public byte[] encryptedPayload; }### Answer:
@Test public void serialize() { String serialized = rawSecretEntry.toJsonBlob(); assertThat(serialized, is(jsonBlob)); } |
### Question:
RawSecretEntry implements BestEffortShred { public static RawSecretEntry fromJsonBlob(String jsonBlob) { try { return objectMapper.readValue(jsonBlob, RawSecretEntry.class); } catch (IOException e) { throw new ParseException("Failed to deserialize secret entry from JSON blob", e); } } @Deprecated RawSecretEntry(); RawSecretEntry(@JsonProperty("secretIdentifier") SecretIdentifier secretIdentifier,
@JsonProperty("version") long version,
@JsonProperty("state") State state,
@JsonProperty("notBefore") Optional<ZonedDateTime> notBefore,
@JsonProperty("notAfter") Optional<ZonedDateTime> notAfter,
@JsonProperty("encryptedPayload") byte[] encryptedPayload); String toJsonBlob(); static RawSecretEntry fromJsonBlob(String jsonBlob); byte[] sha1OfEncryptionPayload(); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); @Override void bestEffortShred(); @PartitionKey(position=Config.KEY, padding = 128)
@JsonProperty("secretIdentifier")
public SecretIdentifier secretIdentifier; @SortKey(position=Config.VERSION)
@JsonProperty("version")
public Long version; @Attribute(position=Config.STATE)
@JsonProperty("state")
public State state; @Attribute(position=Config.NOT_BEFORE)
@JsonProperty("notBefore")
public Optional<ZonedDateTime> notBefore; @Attribute(position=Config.NOT_AFTER)
@JsonProperty("notAfter")
public Optional<ZonedDateTime> notAfter; @Attribute(position=Config.VALUE)
@JsonProperty("encryptedPayload")
public byte[] encryptedPayload; }### Answer:
@Test public void deserialize() { RawSecretEntry deserialized = RawSecretEntry.fromJsonBlob(jsonBlob); assertThat(deserialized, is(rawSecretEntry)); }
@Test(expectedExceptions = ParseException.class) public void deserializeInvalidJson() { RawSecretEntry.fromJsonBlob("{#$%^&*"); } |
### Question:
IAMPolicyManager { public void attachReadOnly(SecretsGroupIdentifier group, Principal principal) { attachPrincipalToPolicy(group, principal, AccessLevel.READONLY); } IAMPolicyManager(AmazonIdentityManagement client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration); static IAMPolicyManager fromCredentials(AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration); static String getAccount(AWSCredentialsProvider awsCredentialsProvider, ClientConfiguration clientConfiguration); String getAccount(); boolean adminPolicyExists(SecretsGroupIdentifier group); boolean readOnlyPolicyExists(SecretsGroupIdentifier group); String getAdminPolicyArn(SecretsGroupIdentifier group); String getReadOnlyArn(SecretsGroupIdentifier group); void attachAdmin(SecretsGroupIdentifier group, Principal principal); void attachReadOnly(SecretsGroupIdentifier group, Principal principal); void detachAllPrincipals(SecretsGroupIdentifier group); void detachAdmin(SecretsGroupIdentifier group, Principal principal); void detachReadOnly(SecretsGroupIdentifier group, Principal principal); void attachPrincipalToPolicy(SecretsGroupIdentifier group, Principal principal, AccessLevel accessLevel); List<Principal> listAttachedAdmin(SecretsGroupIdentifier group); List<Principal> listAttachedReadOnly(SecretsGroupIdentifier group); Set<SecretsGroupIdentifier> getSecretsGroupIdentifiers(); String createAdminPolicy(final SecretsGroupIdentifier group, final KMSEncryptor kmsEncryptor, final Store store); String createReadOnlyPolicy(SecretsGroupIdentifier group, KMSEncryptor kmsEncryptor, Store store); void deleteAdminPolicy(SecretsGroupIdentifier group); void deleteReadonlyPolicy(SecretsGroupIdentifier group); static final String PATH_PREFIX; }### Answer:
@Test public void testAttachReadOnly() throws Exception { Principal principal = new Principal(PrincipalType.USER, "bob"); partiallyMockedPolicyManager.attachReadOnly(group, principal); AttachUserPolicyRequest request = new AttachUserPolicyRequest() .withPolicyArn(READONLY_POLICY_ARN) .withUserName(principal.name); verify(mockClient, times(1)).attachUserPolicy(request); }
@Test public void testAttachReadonlyRole() throws Exception { Principal principal = new Principal(PrincipalType.ROLE, "awesome-service"); partiallyMockedPolicyManager.attachReadOnly(group, principal); AttachRolePolicyRequest request = new AttachRolePolicyRequest() .withPolicyArn(READONLY_POLICY_ARN) .withRoleName(principal.name); verify(mockClient, times(1)).attachRolePolicy(request); } |
### Question:
RawSecretEntry implements BestEffortShred { @Override public boolean equals(final Object obj) { if(obj instanceof RawSecretEntry){ final RawSecretEntry other = (RawSecretEntry) obj; return Objects.equal(secretIdentifier, other.secretIdentifier) && Objects.equal(version, other.version) && Objects.equal(state, other.state) && Objects.equal(notBefore, other.notBefore) && Objects.equal(notAfter, other.notAfter) && Arrays.equals(encryptedPayload, other.encryptedPayload); } else { return false; } } @Deprecated RawSecretEntry(); RawSecretEntry(@JsonProperty("secretIdentifier") SecretIdentifier secretIdentifier,
@JsonProperty("version") long version,
@JsonProperty("state") State state,
@JsonProperty("notBefore") Optional<ZonedDateTime> notBefore,
@JsonProperty("notAfter") Optional<ZonedDateTime> notAfter,
@JsonProperty("encryptedPayload") byte[] encryptedPayload); String toJsonBlob(); static RawSecretEntry fromJsonBlob(String jsonBlob); byte[] sha1OfEncryptionPayload(); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); @Override void bestEffortShred(); @PartitionKey(position=Config.KEY, padding = 128)
@JsonProperty("secretIdentifier")
public SecretIdentifier secretIdentifier; @SortKey(position=Config.VERSION)
@JsonProperty("version")
public Long version; @Attribute(position=Config.STATE)
@JsonProperty("state")
public State state; @Attribute(position=Config.NOT_BEFORE)
@JsonProperty("notBefore")
public Optional<ZonedDateTime> notBefore; @Attribute(position=Config.NOT_AFTER)
@JsonProperty("notAfter")
public Optional<ZonedDateTime> notAfter; @Attribute(position=Config.VALUE)
@JsonProperty("encryptedPayload")
public byte[] encryptedPayload; }### Answer:
@Test public void equals() { assertFalse(rawSecretEntry.equals(secretIdentifier)); RawSecretEntry rawSecretEntry2 = new RawSecretEntry( secretIdentifier, version, state, Optional.empty(), Optional.empty(), secret); assertFalse(rawSecretEntry.equals(rawSecretEntry2)); RawSecretEntry rawSecretEntry3 = new RawSecretEntry( secretIdentifier, version, state, Optional.empty(), Optional.empty(), secret); assertTrue(rawSecretEntry2.equals(rawSecretEntry3)); } |
### Question:
SecretsGroupInfo { public SecretsGroupInfo(SecretsGroupSRN srn, Optional<String> encryptorArn, Optional<String> storageArn, Optional<String> adminPolicyArn, Optional<String> readOnlyPolicyArn, List<Principal> admin, List<Principal> readOnly) { this.srn = srn; this.encryptorArn = encryptorArn; this.storageArn = storageArn; this.adminPolicyArn = adminPolicyArn; this.readOnlyPolicyArn = readOnlyPolicyArn; this.admin = admin; this.readOnly = readOnly; } SecretsGroupInfo(SecretsGroupSRN srn, Optional<String> encryptorArn, Optional<String> storageArn, Optional<String> adminPolicyArn, Optional<String> readOnlyPolicyArn, List<Principal> admin, List<Principal> readOnly); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); public SecretsGroupSRN srn; public Optional<String> encryptorArn; public Optional<String> storageArn; public Optional<String> adminPolicyArn; public Optional<String> readOnlyPolicyArn; public List<Principal> admin; public List<Principal> readOnly; }### Answer:
@Test public void testSecretsGroupInfo() { List<Principal> readonlyPrincipals = getReadOnlyPrincipals(); List<Principal> adminPrincipals = getAdminPrincipals(); SecretsGroupInfo info = new SecretsGroupInfo( new SecretsGroupSRN(account, new SecretsGroupIdentifier(groupRegion, groupName)), encryptorArn, storageArn, adminArn, readonlyArn, adminPrincipals, readonlyPrincipals); assertEquals(info.srn.account, account); assertEquals(info.srn.groupIdentifier.name, groupName); assertEquals(info.srn.groupIdentifier.region, groupRegion); assertEquals(info.encryptorArn, encryptorArn); assertEquals(info.storageArn, storageArn); assertEquals(info.adminPolicyArn, adminArn); assertEquals(info.readOnlyPolicyArn, readonlyArn); assertEquals(info.admin, adminPrincipals); assertEquals(info.readOnly, readonlyPrincipals); assertEquals( info.toString(), "SecretsGroupInfo{srn=srn:aws:strongbox:us-west-1:1234:group/project/group1, " + "storageArn=Optional[arn:aws:dynamodb:eu-west-1:1234:table/strongbox_eu-west-1_project-group1], " + "encryptorArn=Optional[arn:aws:kms:eu-west-1:1234:key/d413a4de-5eb5-4eb4-b4af-373bcba5efdf], " + "adminPolicyArn=Optional[arn:aws:iam::1234:policy/strongbox/strongbox_eu-west-1_project-group1_admin], " + "readOnlyPolicyArn=Optional[arn:aws:iam::1234:policy/strongbox/strongbox_eu-west-1_project-group1_readonly], " + "admin=[alice [user], awesometeam [group]], readOnly=[bob [user], awesomeservice [role]]}" ); } |
### Question:
RoleARN extends ARN { public String getRoleName() { return this.resource; } RoleARN(final String arn); String getRoleName(); }### Answer:
@Test public void role() { RoleARN arn = new RoleARN("arn:aws:iam::12345:role/role-name"); assertThat(arn.getRoleName(), is("role-name")); } |
### Question:
SecretValue implements BestEffortShred { @Override public boolean equals(final Object obj) { if (obj instanceof SecretValue) { final SecretValue other = (SecretValue) obj; return Arrays.equals(secretValue, other.asByteArray()) && Objects.equal(type, other.type) && Objects.equal(encoding, other.encoding); } else { return false; } } SecretValue(byte[] secretValue, Encoding encoding, SecretType type); SecretValue(byte[] secretValue, SecretType type); SecretValue(String secretValue, SecretType type); byte[] asByteArray(); String asString(); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); @Override void bestEffortShred(); final SecretType type; final Encoding encoding; }### Answer:
@Test public void testEquals() { byte[] value1 = {1, 2, 3, 4}; byte[] value2 = {1, 2, 3, 4}; byte[] value3 = {1, 2, 3, 5}; SecretValue secretValue1 = new SecretValue(value1, SecretType.OPAQUE); SecretValue secretValue2 = new SecretValue(value2, SecretType.OPAQUE); SecretValue secretValue3 = new SecretValue(value3, SecretType.OPAQUE); assertTrue(secretValue1.equals(secretValue2)); assertFalse(secretValue1.equals(secretValue3)); } |
### Question:
Principal { public static Principal fromArn(String arn, String account) { String[] parts = arn.split(":"); if (parts.length != 6 || !parts[0].equals("arn") || !parts[1].equals("aws") || !parts[2].equals("iam")) { throw new InvalidResourceName(arn, "A principal ARN should start with 'arn:aws:iam' and have 6 parts"); } if (!account.equals(parts[4])) { throw new IllegalArgumentException("The account in the ARN does not match account of the Principal trying to " + "perform the action."); } String last = parts[5]; String[] elements = last.split("/"); if (elements.length != 2) { throw new InvalidResourceName( arn, "Resource name part of principal ARN should contain exactly one '/'. Only principal ARNs for" + "groups, users or roles can be used."); } String type = elements[0]; String name = elements[1]; return new Principal(PrincipalType.fromString(type), name); } Principal(PrincipalType type, String principalName); static Principal fromArn(String arn, String account); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); final PrincipalType type; final String name; }### Answer:
@Test public void testFromArn() { Principal principal; principal = Principal.fromArn("arn:aws:iam::12345:user/bob", "12345"); assertEquals(principal.type, PrincipalType.USER); assertEquals(principal.name, "bob" ); principal = Principal.fromArn("arn:aws:iam::12345:group/team-awesome", "12345"); assertEquals(principal.type, PrincipalType.GROUP); assertEquals(principal.name, "team-awesome"); principal = Principal.fromArn("arn:aws:iam::12345:role/myrole", "12345"); assertEquals(principal.type, PrincipalType.ROLE); assertEquals(principal.name, "myrole"); }
@Test(expectedExceptions = InvalidResourceName.class) public void testFromArnInvalidPrefix() { Principal principal = Principal.fromArn("arn:aws:invalid::12345:user/username", "12345"); }
@Test(expectedExceptions = InvalidResourceName.class) public void testFromArnInvalidNumberParts() { Principal principal = Principal.fromArn("arn:aws:iam::user/username", "12345"); }
@Test(expectedExceptions = IllegalArgumentException.class) public void testFromArnInvalidType() { Principal principal = Principal.fromArn("arn:aws:iam::12345:invalid-type/username", "12345"); }
@Test(expectedExceptions = InvalidResourceName.class) public void testFromArnInvalidResource() { Principal principal = Principal.fromArn("arn:aws:iam::12345:user/username/group", "12345"); }
@Test(expectedExceptions = IllegalArgumentException.class) public void testAnotherAccount() { Principal principal = Principal.fromArn("arn:aws:iam::123456:user/bob", "12345"); } |
### Question:
Principal { @Override public String toString() { return String.format("%s [%s]", name, type.toString()); } Principal(PrincipalType type, String principalName); static Principal fromArn(String arn, String account); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); final PrincipalType type; final String name; }### Answer:
@Test public void testToString() { Principal principal = Principal.fromArn("arn:aws:iam::12345:user/bob", "12345"); assertEquals(principal.toString(), "bob [user]"); } |
### Question:
Principal { @Override public boolean equals(final Object obj) { if(obj instanceof Principal){ final Principal other = (Principal) obj; return Objects.equal(name, other.name) && Objects.equal(type, other.type); } else{ return false; } } Principal(PrincipalType type, String principalName); static Principal fromArn(String arn, String account); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); final PrincipalType type; final String name; }### Answer:
@Test public void testEquals() { Principal principal1 = Principal.fromArn("arn:aws:iam::12345:user/bob", "12345"); Principal principal2 = new Principal(PrincipalType.USER, "bob"); assertTrue(principal1.equals(principal2)); } |
### Question:
SecretEntry implements BestEffortShred { public SecretEntry(EncryptionPayload encryptionPayload, RawSecretEntry rawSecretEntry) { this.secretIdentifier = rawSecretEntry.secretIdentifier; this.version = rawSecretEntry.version; this.state = rawSecretEntry.state; this.notBefore = rawSecretEntry.notBefore; this.notAfter = rawSecretEntry.notAfter; this.secretValue = encryptionPayload.value; this.userData = encryptionPayload.userData; this.created = encryptionPayload.created; this.modified = encryptionPayload.modified; this.createdBy = encryptionPayload.createdBy; this.modifiedBy = encryptionPayload.modifiedBy; this.comment = encryptionPayload.comment; } SecretEntry(EncryptionPayload encryptionPayload, RawSecretEntry rawSecretEntry); protected SecretEntry(SecretIdentifier secretIdentifier,
long version, SecretValue secretValue,
ZonedDateTime created,
ZonedDateTime modified,
Optional<UserAlias> createdBy,
Optional<UserAlias> modifiedBy,
State state,
Optional<ZonedDateTime> notBefore,
Optional<ZonedDateTime> notAfter,
Optional<Comment> comment,
Optional<UserData> userData); @Override String toString(); @Override void bestEffortShred(); final SecretIdentifier secretIdentifier; final long version; final SecretValue secretValue; final ZonedDateTime created; final ZonedDateTime modified; final Optional<UserAlias> createdBy; final Optional<UserAlias> modifiedBy; final State state; final Optional<ZonedDateTime> notBefore; final Optional<ZonedDateTime> notAfter; final Optional<Comment> comment; final Optional<UserData> userData; }### Answer:
@Test public void testSecretEntry() { EncryptionPayload payload = createPayload(true); RawSecretEntry rawEntry = createRawEntry(); SecretEntry secretEntry = new SecretEntry(payload, rawEntry); assertEquals(secretEntry.secretIdentifier.name, rawEntry.secretIdentifier.name); assertEquals(secretEntry.version, rawEntry.version.longValue()); assertEquals(secretEntry.secretValue, payload.value); assertEquals(secretEntry.created, payload.created); assertEquals(secretEntry.comment, payload.comment); assertEquals(secretEntry.userData, payload.userData); assertEquals( secretEntry.toString(), "SecretEntry{secretIdentifier=key, version=1, secretValue=SecretValue{type=opaque, secretEncoding=utf8}, " + "created=2016-06-01T00:00Z[UTC], modified=2017-06-01T00:00Z[UTC], state=enabled, notBefore=Optional[2016-06-01T13:37:42Z[UTC]], " + "notAfter=Optional.empty, comment=Optional[Comment{}], userData=Optional[UserData{}]}"); } |
### Question:
SecretsGroupIdentifier implements Comparable<SecretsGroupIdentifier> { @Override public String toString() { return String.format("%s [%s]", name, region.getName()); } SecretsGroupIdentifier(@JsonProperty("region") Region region,
@JsonProperty("name") String name); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); @Override int compareTo(SecretsGroupIdentifier o); @JsonProperty("region")
final Region region; @JsonProperty("name")
final String name; }### Answer:
@Test public void testConstructWithValidNames() { SecretsGroupIdentifier group = new SecretsGroupIdentifier(Region.US_WEST_1, "project.service.group1"); assertEquals(group.name, "project.service.group1"); assertEquals(group.region, Region.US_WEST_1); assertEquals(group.toString(), "project.service.group1 [us-west-1]"); } |
### Question:
SecretsGroupIdentifier implements Comparable<SecretsGroupIdentifier> { @Override public boolean equals(final Object obj) { if(obj instanceof SecretsGroupIdentifier){ final SecretsGroupIdentifier other = (SecretsGroupIdentifier) obj; return Objects.equal(name, other.name) && Objects.equal(region, other.region); } else { return false; } } SecretsGroupIdentifier(@JsonProperty("region") Region region,
@JsonProperty("name") String name); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); @Override int compareTo(SecretsGroupIdentifier o); @JsonProperty("region")
final Region region; @JsonProperty("name")
final String name; }### Answer:
@Test public void testEquals() throws Exception { SecretsGroupIdentifier group1 = new SecretsGroupIdentifier(Region.US_WEST_1, "project.service.group1"); SecretsGroupIdentifier group2 = new SecretsGroupIdentifier(Region.US_WEST_1, "project.service.group1"); SecretsGroupIdentifier group3 = new SecretsGroupIdentifier(Region.EU_WEST_1, "project.service.group1"); SecretsGroupIdentifier group4 = new SecretsGroupIdentifier(Region.US_WEST_1, "project.service.group2"); assertTrue(group1.equals(group2)); assertFalse(group1.equals(group3)); assertFalse(group1.equals(group4)); assertFalse(group1.equals("some string value")); } |
### Question:
SecretsGroupIdentifier implements Comparable<SecretsGroupIdentifier> { @Override public int compareTo(SecretsGroupIdentifier o) { if (region.compareTo(o.region) == 0) { return name.compareTo(o.name); } else { return region.compareTo(o.region); } } SecretsGroupIdentifier(@JsonProperty("region") Region region,
@JsonProperty("name") String name); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); @Override int compareTo(SecretsGroupIdentifier o); @JsonProperty("region")
final Region region; @JsonProperty("name")
final String name; }### Answer:
@Test public void testCompareTo() throws Exception { SecretsGroupIdentifier group1 = new SecretsGroupIdentifier(Region.US_WEST_1, "project.service.group1"); SecretsGroupIdentifier group2 = new SecretsGroupIdentifier(Region.US_WEST_1, "project.service.group1"); SecretsGroupIdentifier group3 = new SecretsGroupIdentifier(Region.EU_WEST_1, "project.service.group1"); SecretsGroupIdentifier group4 = new SecretsGroupIdentifier(Region.US_WEST_1, "project.service.group2"); assertEquals(group1.compareTo(group1), 0); assertEquals(group1.compareTo(group2), 0); assertEquals(group1.compareTo(group3), -2); assertEquals(group1.compareTo(group4), -1); assertEquals(group3.compareTo(group4), 2); } |
### Question:
SecretIdentifier { @Override public String toString() { return name; } @JsonCreator SecretIdentifier(@JsonProperty("name") String name); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); final String name; }### Answer:
@Test public void testConstructWithValidNames() { SecretIdentifier secret = new SecretIdentifier("fooBar1"); assertEquals(secret.name, "fooBar1"); assertEquals(secret.toString(), "fooBar1"); }
@Test public void testConstructWithValidUnderscoreNames() { SecretIdentifier secret = new SecretIdentifier("foo_bar_1"); assertEquals(secret.name, "foo_bar_1"); assertEquals(secret.toString(), "foo_bar_1"); } |
### Question:
SecretIdentifier { @Override public boolean equals(final Object obj) { if(obj instanceof SecretIdentifier){ final SecretIdentifier other = (SecretIdentifier) obj; return Objects.equal(name, other.name); } else { return false; } } @JsonCreator SecretIdentifier(@JsonProperty("name") String name); @Override String toString(); @Override int hashCode(); @Override boolean equals(final Object obj); final String name; }### Answer:
@Test public void testEquals() throws Exception { SecretIdentifier secret1 = new SecretIdentifier("fooBar1"); SecretIdentifier secret2 = new SecretIdentifier("fooBar1"); SecretIdentifier secret3 = new SecretIdentifier("fooBar2"); assertTrue(secret1.equals(secret2)); assertFalse(secret1.equals(secret3)); assertFalse(secret1.equals("some value")); } |
### Question:
IAMPolicyManager { public void detachAdmin(SecretsGroupIdentifier group, Principal principal) { detachPrincipal(group, principal, AccessLevel.ADMIN); } IAMPolicyManager(AmazonIdentityManagement client, AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration); static IAMPolicyManager fromCredentials(AWSCredentialsProvider awsCredentials, ClientConfiguration clientConfiguration); static String getAccount(AWSCredentialsProvider awsCredentialsProvider, ClientConfiguration clientConfiguration); String getAccount(); boolean adminPolicyExists(SecretsGroupIdentifier group); boolean readOnlyPolicyExists(SecretsGroupIdentifier group); String getAdminPolicyArn(SecretsGroupIdentifier group); String getReadOnlyArn(SecretsGroupIdentifier group); void attachAdmin(SecretsGroupIdentifier group, Principal principal); void attachReadOnly(SecretsGroupIdentifier group, Principal principal); void detachAllPrincipals(SecretsGroupIdentifier group); void detachAdmin(SecretsGroupIdentifier group, Principal principal); void detachReadOnly(SecretsGroupIdentifier group, Principal principal); void attachPrincipalToPolicy(SecretsGroupIdentifier group, Principal principal, AccessLevel accessLevel); List<Principal> listAttachedAdmin(SecretsGroupIdentifier group); List<Principal> listAttachedReadOnly(SecretsGroupIdentifier group); Set<SecretsGroupIdentifier> getSecretsGroupIdentifiers(); String createAdminPolicy(final SecretsGroupIdentifier group, final KMSEncryptor kmsEncryptor, final Store store); String createReadOnlyPolicy(SecretsGroupIdentifier group, KMSEncryptor kmsEncryptor, Store store); void deleteAdminPolicy(SecretsGroupIdentifier group); void deleteReadonlyPolicy(SecretsGroupIdentifier group); static final String PATH_PREFIX; }### Answer:
@Test public void testDetachAdminUser() throws Exception { Principal principal = new Principal(PrincipalType.USER, "alice"); partiallyMockedPolicyManager.detachAdmin(group, principal); DetachUserPolicyRequest request = new DetachUserPolicyRequest() .withPolicyArn(ADMIN_POLICY_ARN) .withUserName(principal.name); verify(mockClient, times(1)).detachUserPolicy(request); } |
### Question:
LambdaHandler implements RequestStreamHandler { @Override public void handleRequest(InputStream input, OutputStream output, Context context) throws IOException { I inputObject = deserializeEventJson(input, getInputType()); O handlerResult = handleRequest(inputObject, context); serializeOutput(output, handlerResult); } protected LambdaHandler(); @Override void handleRequest(InputStream input, OutputStream output, Context context); abstract O handleRequest(I input, Context context); }### Answer:
@Test public void handleRequest() throws Exception { String jsonInputAndExpectedOutput = "{\"value\":\"testValue\"}"; InputStream exampleInputStream = new ByteArrayInputStream(jsonInputAndExpectedOutput.getBytes(StandardCharsets.UTF_8)); OutputStream exampleOutputStream = new OutputStream() { private final StringBuilder stringBuilder = new StringBuilder(); @Override public void write(int b) { stringBuilder.append((char) b); } @Override public String toString() { return stringBuilder.toString(); } }; TestLambdaHandler lambdaHandler = new TestLambdaHandler(); lambdaHandler.handleRequest(exampleInputStream, exampleOutputStream, null); assertEquals(jsonInputAndExpectedOutput, exampleOutputStream.toString()); } |
### Question:
Handler extends LambdaHandler<AuthorizationInput, AuthorizationOutput> { @Override public AuthorizationOutput handleRequest(AuthorizationInput input, Context context) { final String authenticationToken = input.getAuthorizationToken(); final PolicyDocument policyDocument = new PolicyDocument(); PolicyStatement.Effect policyEffect = PolicyStatement.Effect.ALLOW; String principalId = null; try { User authenticatedUser = userService.getUserByToken(authenticationToken); principalId = String.valueOf(authenticatedUser.getId()); } catch (UserNotFoundException userNotFoundException) { policyEffect = PolicyStatement.Effect.DENY; LOGGER.info("User authentication failed for token " + authenticationToken); } policyDocument.withPolicyStatement(new PolicyStatement("execute-api:Invoke", policyEffect, input.getMethodArn())); return new AuthorizationOutput(principalId, policyDocument); } Handler(); @Inject void setUserService(UserService userService); @Override AuthorizationOutput handleRequest(AuthorizationInput input, Context context); }### Answer:
@Test public void testFailingToken() throws Exception { Handler testHandler = new Handler(); AuthorizationInput mockEvent = createNiceMock(AuthorizationInput.class); expect(mockEvent.getAuthorizationToken()).andReturn("INVALID_TOKEN").anyTimes(); replay(mockEvent); AuthorizationOutput authorizationOutput = testHandler.handleRequest(mockEvent, null); assertEquals(PolicyStatement.Effect.DENY, authorizationOutput.getPolicyDocument().getPolicyStatements().get(0).getEffect()); } |
### Question:
UserServiceImpl implements UserService { @Override public User registerNewUser(String username, String email) throws UserRegistrationException { checkEmailValidity(email); checkEmailUniqueness(email); checkUsernameUniqueness(username); User newUser = new User() .setId(UUID.randomUUID().toString()) .setUsername(username) .setEmail(email); userRepository.saveUser(newUser); return newUser; } @Inject UserServiceImpl(UserRepository userRepository); @Override User getUserByToken(String token); @Override User registerNewUser(String username, String email); }### Answer:
@Test public void failedUserRegistrationWithExistingUsernameTest() throws Exception { thrown.expect(AnotherUserWithSameUsernameExistsException.class); UserService userService = getUserService(); final String username = UUID.randomUUID() + "test-username"; userService.registerNewUser(username, UUID.randomUUID() + "@test.com"); userService.registerNewUser(username, UUID.randomUUID() + "@test.com"); }
@Test public void failedUserRegistrationWithExistingEMailTest() throws Exception { thrown.expect(AnotherUserWithSameEmailExistsException.class); UserService userService = getUserService(); final String email = UUID.randomUUID() + "@test.com"; userService.registerNewUser(UUID.randomUUID().toString(), email); userService.registerNewUser(UUID.randomUUID().toString(), email); }
@Test public void failedUserRegistrationWithInvalidEmailTest() throws Exception { thrown.expect(InvalidMailAddressException.class); UserService userService = getUserService(); userService.registerNewUser(UUID.randomUUID().toString(), "INVALID_EMAIL"); } |
### Question:
DataTypes { public static <T extends Number> T parseNum(String num, Class<T> cls, T def) { if (num == null) { return def; } T result = def; String toParse = num; Long multiplier = 1L; try { switch (num.charAt(num.length() - 1)) { case 'k' : case 'K' : multiplier = 1024L; toParse = num.substring(0, num.length() - 1); break; case 'm' : case 'M' : multiplier = 1024L * 1024L; toParse = num.substring(0, num.length() - 1); break; case 'g' : case 'G' : multiplier = 1024L * 1024L * 1024L; toParse = num.substring(0, num.length() - 1); break; } if(cls.equals(Integer.class)) { result = cls.cast(Integer.valueOf(toParse) * multiplier.intValue()); } else if(cls.equals(Long.class)) { result = cls.cast(Long.valueOf(toParse) * multiplier); } else if(cls.equals(Double.class)) { result = cls.cast(Double.valueOf(toParse) * multiplier.doubleValue()); } else if(cls.equals(Float.class)) { result = cls.cast(Float.valueOf(toParse) * multiplier.floatValue()); } else if(cls.equals(Byte.class)) { Integer res = Byte.valueOf(toParse) * multiplier.byteValue(); result = cls.cast(res.byteValue()); } else if(cls.equals(Short.class)) { Integer res = Short.valueOf(toParse) * multiplier.shortValue(); result = cls.cast(res.shortValue()); } } catch (Exception e) { log.log( Level.WARNING, "Error parsing value: {0} as {1}, using default: {2}", new Object[] {num,cls,def}); return def; } return result; } static T parseNum(String num, Class<T> cls, T def); static int parseSizeInt(String size, int def); static boolean parseBool(final String val); static Object decodeValueType(char typeId, String value); static String valueToString(final Object value); static char decodeTypeIdFromName(String name); static String stripNameFromTypeId(String name); static String encodeTypeIdInName(String name, Object value); static char getTypeId(Object instance); static boolean getProperty(String key, Boolean def); static void main( String[] args ); static final Map<String, Character> typesMap; }### Answer:
@Test public void testParseNum() { assertEquals( new Long( 262144L ), Long.valueOf( Integer.class.cast( DataTypes.parseNum( "256k", Integer.class, 1 ) ) ) ); assertEquals( new Long( 262144L ), Long.class.cast( DataTypes.parseNum( "256k", Long.class, 1L ) ) ); assertEquals( new Double( 670720.0D ), Double.class.cast( DataTypes.parseNum( "655k", Double.class, 1D ) ) ); assertEquals( new Double( 262144F ), Double.valueOf( Float.class.cast( DataTypes.parseNum( "256k", Float.class, 1F ) ) ) ); assertEquals( new Long( 25 ), Long.valueOf( (long) DataTypes.parseNum( "25", Short.class, Short.valueOf( "1" ) ) ) ); assertEquals( new Long( 25 ), Long.valueOf( Byte.class.cast( DataTypes.parseNum( "25", Byte.class, Byte.valueOf( "1" ) ) ) ) ); } |
### Question:
C2SDeliveryErrorProcessor { public static boolean preProcess(Packet packet, XMPPResourceConnection session, NonAuthUserRepository repo, Queue<Packet> results, Map<String, Object> settings, Message messageProcessor) { if (packet.getElemName() != tigase.server.Message.ELEM_NAME) return false; Element deliveryError = getDeliveryError(packet); if (deliveryError == null) return false; try { if (packet.getStanzaTo() != null && packet.getStanzaTo().getResource() == null && session != null) { if (packet.getElemName() != Message.ELEM_NAME) return true; List<XMPPResourceConnection> sessionsForMessageDelivery = messageProcessor.getConnectionsForMessageDelivery(session); if (sessionsForMessageDelivery.isEmpty()) return false; String delay = deliveryError.getAttributeStaticStr("stamp"); if (delay == null) return true; long time = Long.parseLong(delay); for (XMPPResourceConnection conn : sessionsForMessageDelivery) { if (conn.getCreationTime() <= time) continue; Packet result = packet.copyElementOnly(); result.setPacketFrom(packet.getPacketTo()); result.setPacketTo(conn.getConnectionId()); results.offer(result); } return true; } return false; } catch (NotAuthorizedException ex) { if (log.isLoggable(Level.FINEST)) { log.finest("NotAuthorizedException while processing undelivered message from " + "C2S, packet = " + packet); } } catch (NoConnectionIdException ex) { if (log.isLoggable(Level.FINEST)) { log.finest("NotAuthorizedException while processing undelivered message from " + "C2S, packet = " + packet); } } return false; } static void filter(Packet packet, XMPPResourceConnection session, NonAuthUserRepository repo, Queue<Packet> results, JID toIgnore); static void filterErrorElement(Element messageElem); static boolean preProcess(Packet packet, XMPPResourceConnection session, NonAuthUserRepository repo,
Queue<Packet> results, Map<String, Object> settings, Message messageProcessor); static boolean isDeliveryError(Packet packet); static Element getDeliveryError(Packet packet); static Packet makeDeliveryError(Packet packet, Long stamp); static final String ELEM_NAME; static final String XMLNS; }### Answer:
@Test public void testPreprocessingNotSupportedPackets() throws Exception { Element packetEl = null; Packet packet = null; JID from = JID.jidInstance("[email protected]/res"); JID to = JID.jidInstance("[email protected]"); packetEl = new Element("iq", new String[] { "id", "from", "to" }, new String[] { UUID.randomUUID().toString(), from.toString(), to.toString() }); packet = Packet.packetInstance(packetEl); assertFalse(C2SDeliveryErrorProcessor.preProcess(packet, null, null, null, null, messageProcessor)); packetEl = new Element("message", new String[] { "id", "from", "to" }, new String[] { UUID.randomUUID().toString(), from.toString(), to.toString() }); packet = Packet.packetInstance(packetEl); assertFalse(C2SDeliveryErrorProcessor.preProcess(packet, null, null, null, null, messageProcessor)); packetEl = new Element("message", new String[] { "id", "from", "to" }, new String[] { UUID.randomUUID().toString(), from.toString(), to.toString() }); packetEl.addChild(new Element("delivery-error", new String[] { "xmlns" }, new String[] { "http: packet = Packet.packetInstance(packetEl); assertFalse(C2SDeliveryErrorProcessor.preProcess(packet, null, null, null, null, messageProcessor)); } |
### Question:
RosterElement { public final void setName(final String name) { if(name==this.name || (name!=null && this.name!=null && name.equals(this.name))){ return ; } else { this.name = name==null?null:XMLUtils.unescape(name); this.modified = true; } } RosterElement(Element roster_el, XMPPResourceConnection session); RosterElement(JID jid, String name, String[] groups,
XMPPResourceConnection session); void addGroups(String[] groups); String[] getGroups(); JID getJid(); String getName(); String getOtherData(); Element getRosterElement(); Element getRosterItem(); @Override String toString(); SubscriptionType getSubscription(); boolean isModified(); boolean isOnline(); boolean isPresence_sent(); final void setGroups(String[] groups); final void setName(final String name); void setOnline(String resource, boolean online); void setOtherData(String other_data); void setPresence_sent(boolean presence_sent); void setSubscription(SubscriptionType subscription); boolean isPersistent(); void setPersistent(boolean persistent); double getActivity(); void setActivity(double activity); double getWeight(); void setWeight(double weight); long getLastSeen(); void setLastSeen(long lastSeen); }### Answer:
@Test public void testSetName() { RosterElement e = new RosterElement(JID.jidInstanceNS("[email protected]"), null, new String[] {}, null); assertNull(e.getName()); assertTrue(e.isModified()); e.getRosterElement(); assertFalse(e.isModified()); e.setName(null); assertFalse(e.isModified()); assertNull(e.getName()); e.setName("jeff"); assertTrue(e.isModified()); assertEquals("jeff", e.getName()); e.getRosterElement(); assertFalse(e.isModified()); e.setName("jeff"); assertFalse(e.isModified()); assertEquals("jeff", e.getName()); e.setName("bob"); assertTrue(e.isModified()); assertEquals("bob", e.getName()); e.getRosterElement(); assertFalse(e.isModified()); e.setName(null); assertTrue(e.isModified()); assertNull(e.getName()); e.getRosterElement(); assertFalse(e.isModified()); e.setName(null); assertFalse(e.isModified()); assertNull(e.getName()); } |
### Question:
DataTypes { public static int parseSizeInt(String size, int def) { return parseNum(size, Integer.class, def); } static T parseNum(String num, Class<T> cls, T def); static int parseSizeInt(String size, int def); static boolean parseBool(final String val); static Object decodeValueType(char typeId, String value); static String valueToString(final Object value); static char decodeTypeIdFromName(String name); static String stripNameFromTypeId(String name); static String encodeTypeIdInName(String name, Object value); static char getTypeId(Object instance); static boolean getProperty(String key, Boolean def); static void main( String[] args ); static final Map<String, Character> typesMap; }### Answer:
@Test public void testParseSizeInt() { System.out.println( "parseSizeInt" ); assertEquals( 1, DataTypes.parseSizeInt( "1", 1 ) ); assertEquals( 1024, DataTypes.parseSizeInt( "1k", 1 ) ); assertEquals( 1024 * 1024, DataTypes.parseSizeInt( "1m", 1 ) ); assertEquals( 1024 * 1024 * 1024, DataTypes.parseSizeInt( "1g", 1 ) ); assertEquals( 1, DataTypes.parseSizeInt( "fail", 1 ) ); } |
### Question:
OfflineMessages extends XMPPProcessor implements XMPPPostprocessorIfc, XMPPProcessorIfc { protected boolean loadOfflineMessages( Packet packet, XMPPResourceConnection conn ) { if ( ( conn == null ) || conn.isAnonymous() ){ return false; } if ( conn.getSessionData( ID ) != null ){ return false; } if (packet.getStanzaTo() != null) return false; if ( conn.getCommonSessionData(FlexibleOfflineMessageRetrieval.FLEXIBLE_OFFLINE_XMLNS) != null ){ return false; } StanzaType type = packet.getType(); if ( ( type == null ) || ( type == StanzaType.available ) ){ String priority_str = packet.getElemCDataStaticStr( tigase.server.Presence.PRESENCE_PRIORITY_PATH ); int priority = 0; if ( priority_str != null ){ try { priority = Integer.decode( priority_str ); } catch ( NumberFormatException e ) { priority = 0; } } if ( priority >= 0 ){ conn.putSessionData( ID, ID ); return true; } } return false; } @Override String id(); @Override void init(Map<String, Object> settings); @Override void postProcess( final Packet packet, final XMPPResourceConnection conn,
final NonAuthUserRepository repo, final Queue<Packet> queue,
Map<String, Object> settings ); @Override void process( final Packet packet, final XMPPResourceConnection conn,
final NonAuthUserRepository repo, final Queue<Packet> results,
final Map<String, Object> settings ); void processIq(Packet packet, XMPPResourceConnection conn, NonAuthUserRepository repo, Queue<Packet> results); Queue<Packet> restorePacketForOffLineUser( XMPPResourceConnection conn,
MsgRepositoryIfc repo ); Authorization savePacketForOffLineUser( Packet pac, MsgRepositoryIfc repo, NonAuthUserRepository userRepo); @Override Element[] supDiscoFeatures( final XMPPResourceConnection session ); @Override String[][] supElementNamePaths(); @Override String[] supNamespaces(); void publishInPubSub(final Packet packet, final XMPPResourceConnection conn, final Queue<Packet> queue,
Map<String, Object> settings); static final String[] MESSAGE_EVENT_PATH; static final String[] MESSAGE_HEADER_PATH; static final String[] MESSAGE_HINTS_NO_STORE; static final String MESSAGE_HINTS_XMLNS; static final String[] MESSAGE_RECEIVED_PATH; static final String MESSAGE_RECEIVED_XMLNS; static final String[] PUBSUB_NODE_PATH; static final String PUBSUB_NODE_KEY; }### Answer:
@Test public void testLoadOfflineMessages() throws Exception { BareJID userJid = BareJID.bareJIDInstance("[email protected]"); JID res1 = JID.jidInstance(userJid, "res1"); JID res2 = JID.jidInstance(userJid, "res2"); XMPPResourceConnection session1 = getSession(JID.jidInstance("[email protected]/" + UUID.randomUUID().toString()), res1); XMPPResourceConnection session2 = getSession(JID.jidInstance("[email protected]/" + UUID.randomUUID().toString()), res2); assertEquals(Arrays.asList(session1, session2), session1.getActiveSessions()); Element presenceEl = new Element("presence", new String[] { "from", "to" }, new String[] { res1.toString(), res2.toString() }); Packet packet = Packet.packetInstance(presenceEl); assertFalse(offlineProcessor.loadOfflineMessages(packet, session1)); presenceEl = new Element("presence", new String[] { "from" }, new String[] { res1.toString() }); packet = Packet.packetInstance(presenceEl); assertTrue(offlineProcessor.loadOfflineMessages(packet, session1)); } |
### Question:
SSLContextContainer implements SSLContextContainerIfc { public static <T> T find(Map<String, T> data, String key) { if (data.containsKey(key)) { return data.get(key); } int idx = key.indexOf("."); if (idx >= 0) { String asteriskKey = "*" + key.substring(idx); T value = data.get(asteriskKey); if (value != null) { data.put(key, value); return value; } } return null; } @Override void addCertificates(Map<String, String> params); SSLContext getSSLContext(String protocol, String hostname, boolean clientMode); static T find(Map<String, T> data, String key); @Override SSLContext getSSLContext(String protocol, String hostname, boolean clientMode, TrustManager... tms); @Override KeyStore getTrustStore(); @Override void init(Map<String, Object> params); final static String PER_DOMAIN_CERTIFICATE_KEY; }### Answer:
@Test public void testFind() { final HashMap<String, String> domains = new HashMap<String, String>(); domains.put("one.com", "one.com"); domains.put("a.two.com", "a.two.com"); domains.put("*.two.com", "*.two.com"); assertEquals("one.com", SSLContextContainer.find(domains, "one.com")); assertNull(SSLContextContainer.find(domains, "tone.com")); assertNull(SSLContextContainer.find(domains, "zero.com")); assertEquals("a.two.com", SSLContextContainer.find(domains, "a.two.com")); assertEquals("*.two.com", SSLContextContainer.find(domains, "b.two.com")); assertEquals("*.two.com", SSLContextContainer.find(domains, "b.two.com")); assertNull(SSLContextContainer.find(domains, "btwo.com")); assertEquals("*.two.com", SSLContextContainer.find(domains, ".two.com")); } |
### Question:
WebSocketHybi implements WebSocketProtocolIfc { @Override public boolean handshake(WebSocketXMPPIOService service, Map<String, String> headers, byte[] buf) throws NoSuchAlgorithmException, IOException { if (!headers.containsKey(WS_VERSION_KEY)) { return false; } StringBuilder response = new StringBuilder(RESPONSE_HEADER.length() * 2); response.append(RESPONSE_HEADER); int version = Integer.parseInt(headers.get(WS_VERSION_KEY)); String key = headers.get(WS_KEY_KEY) + GUID; MessageDigest md = MessageDigest.getInstance("SHA1"); byte[] resp = md.digest(key.getBytes()); response.append(WS_PROTOCOL_KEY).append(": "); if (headers.get(WS_PROTOCOL_KEY).contains("xmpp-framing")) { response.append("xmpp-framing"); } else { response.append("xmpp"); } response.append("\r\n"); response.append(WS_ACCEPT_KEY + ": "); response.append(Base64.encode(resp)); response.append("\r\n"); response.append("\r\n"); service.maskingKey = new byte[4]; service.writeRawData(response.toString()); return true; } @Override String getId(); @Override boolean handshake(WebSocketXMPPIOService service, Map<String, String> headers, byte[] buf); @Override ByteBuffer decodeFrame(WebSocketXMPPIOService service, ByteBuffer buf); @Override void encodeFrameAndWrite(WebSocketXMPPIOService service, ByteBuffer buf); @Override void closeConnection(WebSocketXMPPIOService service); static final String ID; }### Answer:
@Test public void testHandshakeFail() throws NoSuchAlgorithmException, IOException { final ByteBuffer tmp = ByteBuffer.allocate(2048); WebSocketXMPPIOService<Object> io = new WebSocketXMPPIOService<Object>(new WebSocketProtocolIfc[]{ new WebSocketHixie76() }) { @Override protected void writeBytes(ByteBuffer data) { tmp.put(data); } @Override public int getLocalPort() { return 80; } }; Map<String,String> params = new HashMap<String,String>(); params.put("Sec-WebSocket-Key1", "1C2J899_05 6 ! M 9 ^4"); params.put("Sec-WebSocket-Key2", "23 2ff0M_E0#.454X23"); params.put("Sec-WebSocket-Protocol", "xmpp"); byte[] bytes = new byte[10]; bytes[0] = '\r'; bytes[1] = '\n'; Assert.assertFalse("Handshake succeeded", impl.handshake(io, params, bytes)); }
@Test public void testHandshakeOK() throws NoSuchAlgorithmException, IOException { final ByteBuffer tmp = ByteBuffer.allocate(2048); WebSocketXMPPIOService<Object> io = new WebSocketXMPPIOService<Object>(new WebSocketProtocolIfc[]{ new WebSocketHixie76() }) { @Override protected void writeBytes(ByteBuffer data) { tmp.put(data); } @Override public int getLocalPort() { return 80; } }; Map<String,String> params = new HashMap<String,String>(); params.put("Sec-WebSocket-Version", "13"); params.put("Sec-WebSocket-Key", "some random data as a key"); params.put("Sec-WebSocket-Protocol", "xmpp"); byte[] bytes = new byte[10]; bytes[0] = '\r'; bytes[1] = '\n'; Assert.assertTrue("Handshake failed", impl.handshake(io, params, bytes)); } |
### Question:
WebSocketXMPPIOService extends XMPPIOService<RefObject> { protected int parseHttpHeaders(byte[] buf, Map<String, String> headers) { int i = 0; while (buf[i] != '\n') { i++; } i++; if (log.isLoggable(Level.FINEST)) { log.log(Level.FINEST, "parsing request = \n{0}", new String(buf)); } StringBuilder builder = new StringBuilder(64); String key = null; boolean skipWhitespace = false; for (; i < buf.length; i++) { switch (buf[i]) { case ':': if (key == null) { key = builder.toString().trim(); builder = new StringBuilder(64); skipWhitespace = true; } else { builder.append((char) buf[i]); } break; case '\r': headers.put(key, builder.toString().trim()); key = null; builder = new StringBuilder(64); if (buf[i + 2] == '\r') { i += 3; } else { i++; } break; case ' ': case '\t': if (!skipWhitespace) { builder.append((char) buf[i]); } break; default: skipWhitespace = false; builder.append((char) buf[i]); } } return i; } WebSocketXMPPIOService(WebSocketProtocolIfc[] enabledProtocols); @Override void stop(); void dumpHeaders(Map<String,String> headers); }### Answer:
@Test public void testHttpHeadersParsingWithSpaces() throws UnsupportedEncodingException { byte[] data = prepareHTTPRequest(headers, true); Map<String, String> parsedHeaders = new HashMap<>(); service.parseHttpHeaders(data, parsedHeaders); assertMaps(headers, parsedHeaders); }
@Test public void testHttpHeadersParsingWithoutSpaces() throws UnsupportedEncodingException { byte[] data = prepareHTTPRequest(headers, false); Map<String, String> parsedHeaders = new HashMap<>(); service.parseHttpHeaders(data, parsedHeaders); assertMaps(headers, parsedHeaders); } |
### Question:
ClusterElement { public String getMethodName() { return method_name; } ClusterElement(Element elem); ClusterElement(JID from, JID to, StanzaType type, Packet packet); static Element clusterElement(JID from, JID to, StanzaType type); static Element createClusterElement(JID from, JID to, StanzaType type,
String packet_from); static ClusterElement createClusterMethodCall(JID from, JID to, StanzaType type,
String method_name, Map<String, String> params); static ClusterElement createForNextNode(ClusterElement clel,
List<JID> cluster_nodes, JID comp_id); void addDataPacket(Packet packet); void addDataPacket(Element packet); void addDataPackets(Queue<Element> packets); void addMethodResult(String key, String val); void addVisitedNode(JID node_id); void addVisitedNodes(Set<JID> nodes); ClusterElement createMethodResponse(JID from, StanzaType type,
Map<String, String> results); ClusterElement createMethodResponse(JID from, JID to, StanzaType type,
Map<String, String> results); Map<String, String> getAllMethodParams(); Map<String, String> getAllMethodResults(); Element getClusterElement(String id); Queue<Element> getDataPackets(); JID getFirstNode(); String getMethodName(); String getMethodParam(String par_name); long getMethodParam(String par_name, long def); String getMethodResultVal(String val_name); long getMethodResultVal(String val_name, long def); Priority getPriority(); Set<JID> getVisitedNodes(); boolean isVisitedNode(JID node_id); void setPriority(Priority priority); ClusterElement nextClusterNode(JID node_id); static final String CLUSTER_CONTROL_EL_NAME; static final String CLUSTER_DATA_EL_NAME; static final String CLUSTER_EL_NAME; static final String CLUSTER_METHOD_EL_NAME; static final String CLUSTER_METHOD_PAR_EL_NAME; static final String CLUSTER_METHOD_RESULTS_EL_NAME; static final String CLUSTER_METHOD_RESULTS_VAL_EL_NAME; static final String CLUSTER_NAME_ATTR; static final String FIRST_NODE_EL_NAME; static final String NODE_ID_EL_NAME; static final String VISITED_NODES_EL_NAME; static final String XMLNS; static final String[] VISITED_NODES_PATH; static final String[] FIRST_NODE_PATH; static final String[] CLUSTER_METHOD_RESULTS_PATH; static final String[] CLUSTER_METHOD_PATH; static final String[] CLUSTER_DATA_PATH; static final String[] CLUSTER_CONTROL_PATH; }### Answer:
@Test @SuppressWarnings("deprecation") public void testGetMethodName() { SimpleParser parser = new SimpleParser(); DomBuilderHandler handler = new DomBuilderHandler(); char[] data = "<cluster to=\"sess-man@blue\" type=\"set\" id=\"cl-6627\" xmlns=\"tigase:cluster\" from=\"sess-man@green\"><control><visited-nodes><node-id>sess-man@green</node-id></visited-nodes><method-call name=\"packet-forward-sm-cmd\"/><first-node>sess-man@green</first-node></control><data><presence to=\"test2@test\" xmlns=\"jabber:client\" from=\"test1@test/test\"><status/><priority>5</priority></presence></data></cluster>".toCharArray(); parser.parse(handler, data, 0, data.length); Element elem = handler.getParsedElements().poll(); assertEquals( "packet-forward-sm-cmd", elem.findChild("/cluster/control/method-call").getAttributeStaticStr("name")); ClusterElement clElem = new ClusterElement(elem); assertEquals("packet-forward-sm-cmd", clElem.getMethodName()); } |
### Question:
ClusterConnectionSelector implements ClusterConnectionSelectorIfc { @Override public XMPPIOService<Object> selectConnection(Packet p, ClusterConnection conn) { if (conn == null) return null; int code = Math.abs(handler.hashCodeForPacket(p)); List<XMPPIOService<Object>> conns = conn.getConnections(); if (conns.size() > 0) { if (conns.size() > sysConns) { if (p.getPriority() != null && p.getPriority().ordinal() <= Priority.CLUSTER.ordinal()) { return conns.get(code % sysConns); } else { return conns.get(sysConns + (code % (conns.size() - sysConns))); } } else { return conns.get(code % conns.size()); } } return null; } @Override XMPPIOService<Object> selectConnection(Packet p, ClusterConnection conn); @Override void setClusterConnectionHandler(ClusterConnectionHandler handler); @Override void setProperties(Map<String,Object> props); }### Answer:
@Test public void testSelectConnection() throws Exception { ClusterConnection conn = new ClusterConnection("test"); ClusterConnectionSelector selector = new ClusterConnectionSelector(); selector.setClusterConnectionHandler(new ClusterConnectionHandler() { @Override public int hashCodeForPacket(Packet packet) { return packet.getStanzaFrom().hashCode(); } }); Map<String,Object> props = new HashMap<>(); props.put(CLUSTER_SYS_CONNECTIONS_PER_NODE_PROP_KEY, 1); selector.setProperties(props); Element el = new Element("iq", new String[] { "from" }, new String[] { "test1" }); Packet p = Packet.packetInstance(el); assertNull(selector.selectConnection(p, conn)); XMPPIOService<Object> serv1 = new XMPPIOService<Object>(); conn.addConn(serv1); assertEquals(serv1, selector.selectConnection(p, conn)); p.setPriority(Priority.SYSTEM); assertEquals(serv1, selector.selectConnection(p, conn)); p.setPriority(null); XMPPIOService<Object> serv2 = new XMPPIOService<Object>(); conn.addConn(serv2); assertEquals(2, conn.size()); assertEquals(serv2, selector.selectConnection(p, conn)); p.setPriority(Priority.SYSTEM); assertEquals(serv1, selector.selectConnection(p, conn)); p.setPriority(null); XMPPIOService<Object> serv3 = new XMPPIOService<Object>(); conn.addConn(serv3); assertEquals(3, conn.size()); assertNotSame(serv1, selector.selectConnection(p, conn)); p.setPriority(Priority.SYSTEM); assertEquals(serv1, selector.selectConnection(p, conn)); el = new Element("iq", new String[] { "from" }, new String[] { "test2" }); p = Packet.packetInstance(el); assertEquals(3, conn.size()); assertNotSame(serv1, selector.selectConnection(p, conn)); el = new Element("iq", new String[] { "from" }, new String[] { "test3" }); p = Packet.packetInstance(el); assertEquals(3, conn.size()); assertNotSame(serv1, selector.selectConnection(p, conn)); el = new Element("iq", new String[] { "from" }, new String[] { "test4" }); p = Packet.packetInstance(el); assertEquals(3, conn.size()); assertNotSame(serv1, selector.selectConnection(p, conn)); } |
### Question:
CustomDomainFilter { public static Set<Rule> parseRules( String rules ) throws ParseException { String[] rulesArr = rules.split( ";" ); if ( rulesArr != null ){ return parseRules( rulesArr ); } return null; } private CustomDomainFilter(); static Set<Rule> parseRules( String rules ); static Set<Rule> parseRules( String[] rules ); static boolean isAllowed( JID source, JID destination, String rules ); static boolean isAllowed( JID source, JID destination, String[] rules ); static boolean isAllowed( JID source, JID destination, Set<Rule> rules ); }### Answer:
@Test public void testParseRules() throws TigaseStringprepException, ParseException { System.out.println( "parseRules" ); Set<Rule> expResult = new TreeSet<>(); Rule rule = new Rule( 1, true, RuleType.self, null ); if ( rule != null ){ expResult.add( rule ); } rule = new Rule( 2, true, RuleType.jid, JID.jidInstance( "[email protected]" ) ); if ( rule != null ){ expResult.add( rule ); } rule = new Rule( 3, true, RuleType.jid, JID.jidInstance( "[email protected]" ) ); if ( rule != null ){ expResult.add( rule ); } rule = new Rule( 4, false, RuleType.all, null ); if ( rule != null ){ expResult.add( rule ); } Set<Rule> result = CustomDomainFilter.parseRules( rules ); assertEquals( expResult, result ); }
@Test public void testParseRulesString() throws TigaseStringprepException, ParseException { System.out.println( "parseRules" ); String rulseString = "4|deny|all;1|allow|self;3|allow|jid|[email protected];2|allow|jid|[email protected]"; Set<Rule> expResult = new TreeSet<>(); Rule rule = new Rule( 1, true, RuleType.self, null ); if ( rule != null ){ expResult.add( rule ); } rule = new Rule( 2, true, RuleType.jid, JID.jidInstance( "[email protected]" ) ); if ( rule != null ){ expResult.add( rule ); } rule = new Rule( 3, true, RuleType.jid, JID.jidInstance( "[email protected]" ) ); if ( rule != null ){ expResult.add( rule ); } rule = new Rule( 4, false, RuleType.all, null ); if ( rule != null ){ expResult.add( rule ); } Set<Rule> result = CustomDomainFilter.parseRules( rulseString ); assertEquals( expResult, result ); rulseString = "1|allow|self;2|allow|jid|[email protected];3|allow|jid|[email protected];4|deny|all;"; String resultString = new String(); for ( Rule res : result) { resultString += res.toConfigurationString(); } assertEquals( rulseString, resultString ); }
@Test(expected = ParseException.class) public void testParseRulesException() throws TigaseStringprepException, ParseException { String[] rules_fail = { "8|deny|||self,", "|||18|||deny,self::::" }; Set<Rule> result = CustomDomainFilter.parseRules( rules_fail ); } |
### Question:
CustomDomainFilter { public static boolean isAllowed( JID source, JID destination, String rules ) { try { Set<Rule> parseRules = parseRules( rules ); if ( parseRules != null ){ return isAllowed( source, destination, parseRules ); } else { return true; } } catch ( ParseException e ) { return true; } } private CustomDomainFilter(); static Set<Rule> parseRules( String rules ); static Set<Rule> parseRules( String[] rules ); static boolean isAllowed( JID source, JID destination, String rules ); static boolean isAllowed( JID source, JID destination, String[] rules ); static boolean isAllowed( JID source, JID destination, Set<Rule> rules ); }### Answer:
@Test public void testIsAllowed() throws TigaseStringprepException, ParseException { JID jid1_r1 = JID.jidInstance( "user1", "domain1", "resource1" ); JID jid1_r2 = JID.jidInstance( "user1", "domain1", "resource2" ); JID jid2_r1 = JID.jidInstance( "user2", "domain1", "resource1" ); JID jid3_r1 = JID.jidInstance( "user3", "domain1", "resource1" ); JID admin = JID.jidInstance( "admin", "test2.com" ); JID pubsub = JID.jidInstance( "pubsub", "test.com" ); boolean allowed = CustomDomainFilter.isAllowed( jid1_r1, jid1_r2, rules ); assertTrue( "should be allowed / self / permitted jid", allowed ); allowed = CustomDomainFilter.isAllowed( jid1_r1, admin, rules ); assertTrue( "should be allowed / permitted jid", allowed ); allowed = CustomDomainFilter.isAllowed( jid1_r1, pubsub, rules ); assertTrue( "should be allowed / permitted jid", allowed ); allowed = CustomDomainFilter.isAllowed( jid1_r1, jid2_r1, rules ); assertFalse( "should be denyed / permitted jid", allowed ); allowed = CustomDomainFilter.isAllowed( jid2_r1, jid2_r1, rules ); assertTrue( "should be allowed / self", allowed ); allowed = CustomDomainFilter.isAllowed( jid3_r1, jid2_r1, rules ); assertFalse( "should be denied / not permitted jids", allowed ); } |
### Question:
NodeNameUtil { public static String createNodeName(String eventName, String xmlns) { return (eventName == null ? "*" : eventName) + "|" + (xmlns == null ? "*" : xmlns); } private NodeNameUtil(); static String createNodeName(String eventName, String xmlns); static EventName parseNodeName(String nodeName); }### Answer:
@Test public void testCreateNodeName() throws Exception { assertEquals("1|2", NodeNameUtil.createNodeName("1", "2")); assertEquals("*|2", NodeNameUtil.createNodeName(null, "2")); assertEquals("*|*", NodeNameUtil.createNodeName(null, null)); assertEquals("1|*", NodeNameUtil.createNodeName("1", null)); } |
### Question:
NodeNameUtil { public static EventName parseNodeName(String nodeName) { int i = nodeName.indexOf('|'); String n = nodeName.substring(0, i); String x = nodeName.substring(i + 1); return new EventName(n.equals("*") ? null : n, x.equals("*") ? null : x); } private NodeNameUtil(); static String createNodeName(String eventName, String xmlns); static EventName parseNodeName(String nodeName); }### Answer:
@Test public void testParseNodeName() throws Exception { assertEquals(new EventName("1", "2"), NodeNameUtil.parseNodeName("1|2")); assertEquals(new EventName(null, "2"), NodeNameUtil.parseNodeName("*|2")); assertEquals(new EventName(null, null), NodeNameUtil.parseNodeName("*|*")); assertEquals(new EventName("1", null), NodeNameUtil.parseNodeName("1|*")); assertEquals(new EventName("1", ""), NodeNameUtil.parseNodeName("1|")); assertEquals(new EventName("", ""), NodeNameUtil.parseNodeName("|")); } |
### Question:
EventName { @Override public boolean equals(Object obj) { if (this == obj) return true; if (obj == null) return false; if (getClass() != obj.getClass()) return false; EventName other = (EventName) obj; if (name == null) { if (other.name != null) return false; } else if (!name.equals(other.name)) return false; if (xmlns == null) { if (other.xmlns != null) return false; } else if (!xmlns.equals(other.xmlns)) return false; return true; } EventName(String name, String xmlns); @Override boolean equals(Object obj); String getName(); String getXmlns(); @Override int hashCode(); String toEventBusNode(); @Override String toString(); }### Answer:
@Test public void testEquals() throws Exception { assertEquals(new EventName(null, null), new EventName(null, null)); assertEquals(new EventName(null, "2"), new EventName(null, "2")); assertEquals(new EventName("1", "2"), new EventName("1", "2")); assertNotEquals(new EventName(null, null), new EventName("2", "2")); assertNotEquals(new EventName(null, null), new EventName(null, "2")); assertNotEquals(new EventName(null, null), new EventName("2", null)); assertNotEquals(new EventName("1", null), new EventName("2", "2")); assertNotEquals(new EventName(null, "2"), new EventName("2", "2")); assertNotEquals(new EventName("2", "1"), new EventName("2", "2")); } |
### Question:
ImageResizer { public byte[] resize(BufferedImage originalImage) throws IOException { if (originalImage == null) { throw new IIOException("Image is null. Did ImageIO fail to decode the image?"); } BufferedImage resized = ImageUtil.resizeImage(originalImage, size, size); originalImage.flush(); byte[] resizedBytes = com.github.dozedoff.similarImage.util.ImageUtil.imageToBytes(resized); resized.flush(); return resizedBytes; } ImageResizer(int size); byte[] resize(BufferedImage originalImage); }### Answer:
@Test(expected = IIOException.class) public void testResizeNullImage() throws Exception { cut.resize((BufferedImage) null); } |
### Question:
OrmliteImageRepository implements ImageRepository { @Override public List<ImageRecord> getByHash(long hash) throws RepositoryException { try { return imageDao.queryForMatching(new ImageRecord(null, hash)); } catch (SQLException e) { throw new RepositoryException("Failed to query by hash", e); } } OrmliteImageRepository(Dao<ImageRecord, String> imageDao, Dao<IgnoreRecord, String> ignoreDao); @Override void store(ImageRecord image); @Override List<ImageRecord> getByHash(long hash); @Override ImageRecord getByPath(Path path); @Override synchronized List<ImageRecord> startsWithPath(Path directory); @Override void remove(ImageRecord image); @Override void remove(Collection<ImageRecord> images); @Override List<ImageRecord> getAll(); @Override List<ImageRecord> getAllWithoutIgnored(); @Override List<ImageRecord> getAllWithoutIgnored(Path directory); }### Answer:
@Test public void testGetByHashNotFound() throws Exception { assertThat(cut.getByHash(HASH_NEW_RECORD), hasSize(0)); }
@Test public void testGetByHashExists() throws Exception { assertThat(cut.getByHash(HASH_EXISTING_RECORD), containsInAnyOrder(imageExisting)); } |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.