http://git-wip-us.apache.org/repos/asf/jclouds-labs/blob/fa63f6b1/azurecompute-arm/src/test/java/org/jclouds/azurecompute/arm/features/VaultApiMockTest.java ---------------------------------------------------------------------- diff --git a/azurecompute-arm/src/test/java/org/jclouds/azurecompute/arm/features/VaultApiMockTest.java b/azurecompute-arm/src/test/java/org/jclouds/azurecompute/arm/features/VaultApiMockTest.java new file mode 100644 index 0000000..7459f48 --- /dev/null +++ b/azurecompute-arm/src/test/java/org/jclouds/azurecompute/arm/features/VaultApiMockTest.java @@ -0,0 +1,1619 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.jclouds.azurecompute.arm.features; + +import static org.testng.Assert.assertFalse; +import static org.testng.Assert.assertNotNull; +import static org.testng.Assert.assertNull; +import static org.testng.Assert.assertTrue; + +import java.io.IOException; +import java.net.URI; +import java.net.URISyntaxException; + +import java.util.List; +import java.util.Map; +import java.util.HashMap; +import java.util.Arrays; +import java.util.ArrayList; + +import org.jclouds.azurecompute.arm.domain.Certificate; +import org.jclouds.azurecompute.arm.domain.Certificate.AdministrationDetails; +import org.jclouds.azurecompute.arm.domain.Certificate.CertificateAttributes; +import org.jclouds.azurecompute.arm.domain.Certificate.CertificateBundle; +import org.jclouds.azurecompute.arm.domain.Certificate.CertificateIssuer; +import org.jclouds.azurecompute.arm.domain.Certificate.CertificateOperation; +import org.jclouds.azurecompute.arm.domain.Certificate.CertificatePolicy; +import org.jclouds.azurecompute.arm.domain.Certificate.Contact; +import org.jclouds.azurecompute.arm.domain.Certificate.Contacts; +import org.jclouds.azurecompute.arm.domain.Certificate.DeletedCertificate; +import org.jclouds.azurecompute.arm.domain.Certificate.DeletedCertificateBundle; +import org.jclouds.azurecompute.arm.domain.Certificate.IssuerBundle; +import org.jclouds.azurecompute.arm.domain.Certificate.IssuerCredentials; +import org.jclouds.azurecompute.arm.domain.Certificate.IssuerParameters; +import org.jclouds.azurecompute.arm.domain.Certificate.KeyProperties; +import org.jclouds.azurecompute.arm.domain.Certificate.OrganizationDetails; +import org.jclouds.azurecompute.arm.domain.Certificate.SecretProperties; +import org.jclouds.azurecompute.arm.domain.Certificate.X509CertificateProperties; +import org.jclouds.azurecompute.arm.domain.Key; +import org.jclouds.azurecompute.arm.domain.Key.DeletedKeyBundle; +import org.jclouds.azurecompute.arm.domain.Key.JsonWebKey; +import org.jclouds.azurecompute.arm.domain.Key.KeyAttributes; +import org.jclouds.azurecompute.arm.domain.Key.KeyBundle; +import org.jclouds.azurecompute.arm.domain.Key.KeyOperationResult; +import org.jclouds.azurecompute.arm.domain.SKU; +import org.jclouds.azurecompute.arm.domain.Secret; +import org.jclouds.azurecompute.arm.domain.Secret.DeletedSecretBundle; +import org.jclouds.azurecompute.arm.domain.Secret.SecretAttributes; +import org.jclouds.azurecompute.arm.domain.Secret.SecretBundle; +import org.jclouds.azurecompute.arm.domain.Vault; +import org.jclouds.azurecompute.arm.domain.Vault.DeletedVault; +import org.jclouds.azurecompute.arm.domain.VaultProperties; +import org.jclouds.azurecompute.arm.internal.BaseAzureComputeApiMockTest; +import org.jclouds.rest.ResourceNotFoundException; +import org.testng.SkipException; +import org.testng.annotations.BeforeMethod; +import org.testng.annotations.Test; + +import com.google.common.collect.ImmutableList; + + +@Test(groups = "unit", testName = "VaultApiMockTest", singleThreaded = true) +public class VaultApiMockTest extends BaseAzureComputeApiMockTest { + private final String subscriptionId = "SUBSCRIPTIONID"; + private final String resourceGroup = "myresourcegroup"; + private final String tenantId = "myTenantId"; + private final String identityObjId = "myIdentityObjectId"; + private final String vaultName = "kvvaultapimocktest"; + private final String apiVersion = "api-version=2016-10-01"; + private final String location = "westeurope"; + private URI vaultUri; + + private static String KEY_NAME = "myKey"; + private static String TEMP_KEY_NAME = "myTempKey"; + private static String IMPORT_KEY_NAME = "myImportKey"; + private static String RECOVERABLE_KEY_NAME = "myRecoverableKey"; + private static String SECRET_NAME = "mySecret"; + private static String RECOVERABLE_SECRET_NAME = "myRecoverableSecret"; + private static String CERTIFICATE_NAME = "myCertificate"; + private static String TEMP_CERTIFICATE_NAME = "myTempCertificate"; + private static String RECOVERABLE_CERTIFICATE_NAME = "myRecoverableCertificate"; + private static String IMPORTABLE_CERTIFICATE_NAME = "myImportableCertificate"; + private static String CERTIFICATE_ISSUER_NAME = "globalsign01"; + private String IMPORTABLE_CERTIFICATE_PEM = stringFromResource("/vaultimportablecert.txt"); + private String sampleSecret = stringFromResource("/vaultsamplesecret.txt"); + private String keyBackup = stringFromResource("/vaultkeybackup.txt"); + private String secretBackup = stringFromResource("/vaultsecretbackup.txt"); + private String[] mergeX5C = { + stringFromResource("/vaultmergex5c-1.txt"), + stringFromResource("/vaultmergex5c-2.txt"), + stringFromResource("/vaultmergex5c-3.txt") + }; + private static String cryptoText = "R29sZCUyNTIxJTJCR29sZCUyNTIxJTJCR2" + + "9sZCUyQmZyb20lMkJ0aGUlMkJBbWVyaWNhbiUyQlJpdmVyJTI1MjE"; + private static String cryptoAlgorithm = "RSA-OAEP"; + private static String hashToSign = "FvabKT6qGwpml59iHUJ72DZ4XyJcJ8bgpgFA4_8JFmM"; + private static String signatureAlgorithm = "RS256"; + private static String contentEncryptionKey = "YxzoHR65aFwD2_IOiZ5rD08jMSALA1y7b_yYW0G3hyI"; + private static String keyDecryptData = "0_S8pyjjnGRlcbDa-Lt0jYjMXpXrf9Fat3elx-fSO" + + "g3dj6mYgEEs6kt79OMD4MFmVyOt6umeWAfdDIkNVnqb5fgyWceveh9wN-37jc5CFgG2PF3XI" + + "A6RII-HF2BkBcVa9KcAX3_di4KQE70PXgHf-dlz_RgLOJILeG50wzFeBFCLsjEEPp3itmoai" + + "E6vfDidCRm5At8Vjka0G-N_afwkIijfQZLT0VaXvL39cIJE2QN3HJPZM8YPUlkFlYnY4GIRy" + + "RWSBpK_KYuVufzUGtDi6Sh8pUa67ppa7DHVZlixlmnVqI3Oeg6XUvMqbFFqVSrcNbRQDwVGL" + + "3cUtK-KB1PfKg"; + private static String keySignedData = "uO0r4P1cB-fKsDZ8cj5ahiNw8Tdsudt5zLCeEKOt29" + + "LAlPDpeGx9Q1SOFNaR7JlRYVelxsohdzvydwX8ao6MLnqlpdEj0Xt5Aadp-kN84AXW238gab" + + "S1AUyiWILCmdsBFeRU4wTRSxz2qGS_0ztHkaNln32P_9GJC72ZRlgZoVA4C_fowZolUoCWGj" + + "4V7fAzcSoiNYipWP0HkFe3xmuz-cSQg3CCAs-MclHHfMeSagLJZZQ9bpl5LIr-Ik89bNtqEq" + + "yP7Jb_fCgHajAx2lUFcRZhSIKuCfrLPMl6wzejQ2rQXX-ixEkDa73dYaPIrVW4IL3iC0Ufxn" + + "fxYffHJ7QCRw"; + private static String keyWrappedData = "1jcTlu3KJNDBYydhaH9POWOo0tAPGkpsZVizCkHpC" + + "3g_9Kg91Q3HKK-rfZynn5W5nVPM-SVFHA3JTankcXX8gx8GycwUh4pMoyil_DV35m2QjyuiT" + + "ln83OJXw-nMvRXyKdVfF7nyRcs256kW7gthAOsYUVBrfFS7DFFxsXqLNREsA8j85IqIXIm8p" + + "AB3C9uvl1I7SQhLvrwZZXXqjeCWMfseVJwWgsQFyyqH2P0f3-xnngV7cvik2k3Elrk3G_2Cu" + + "JCozIIrANg9zG9Z8DrwSNNm9YooxWkSu0ZeDLOJ0bMdhcPGGm5OvKz3oZqX-39yv5klNlCRb" + + "r0q7gqmI0x25w"; + + @BeforeMethod + public void start() throws IOException, URISyntaxException { + super.start(); + vaultUri = server.getUrl("").toURI(); + } + + public void createVault() throws InterruptedException { + server.enqueue(jsonResponse("/vaultcreate.json").setResponseCode(200)); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + Vault vault = vaultApi.createOrUpdateVault(vaultName, location, VaultProperties.builder() + .tenantId(this.tenantId) + .sku(SKU.create(location, "standard", null, "A")) + .accessPolicies(ImmutableList.of(VaultProperties.AccessPolicyEntry.create(null, this.identityObjId, this.tenantId, + VaultProperties.Permissions.create( + ImmutableList.of( // certificates + "Get", + "List", + "Update", + "Create", + "Import", + "Delete", + "ManageContacts", + "ManageIssuers", + "GetIssuers", + "ListIssuers", + "SetIssuers", + "DeleteIssuers", + "Purge", + "Recover" + ), + ImmutableList.of( // keys + "Get", + "List", + "Update", + "Create", + "Import", + "Delete", + "Recover", + "Backup", + "Restore", + "Purge", + "Encrypt", + "Decrypt", + "Sign", + "Verify", + "WrapKey", + "UnwrapKey" + ), + ImmutableList.of( // secrets + "Get", + "List", + "Set", + "Delete", + "Recover", + "Backup", + "Restore", + "Purge" + ), + ImmutableList.<String>of() + )))) + .build(), + null); + + String path = String.format( + "/subscriptions/%s/resourcegroups/%s/providers/Microsoft.KeyVault/vaults/%s?%s", + subscriptionId, resourceGroup, vaultName, apiVersion + ); + assertSent(server, "PUT", path, stringFromResource("/vaultcreaterequestbody.json")); + + assertNotNull(vault); + assertNotNull(vault.properties().vaultUri()); + assertTrue(!vault.name().isEmpty()); + } + + public void listVaults() throws InterruptedException { + server.enqueue(jsonResponse("/vaultlist.json").setResponseCode(200)); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + List<Vault> vaults = vaultApi.listVaults(); + + String path = String.format( + "/subscriptions/%s/resourcegroups/%s/providers/Microsoft.KeyVault/vaults?%s", + subscriptionId, resourceGroup, apiVersion + ); + assertSent(server, "GET", path); + + assertNotNull(vaults); + assertTrue(vaults.size() > 0); + assertTrue(!vaults.get(0).name().isEmpty()); + } + + public void listVaultsReturns404() throws InterruptedException { + server.enqueue(response404()); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + List<Vault> vaults = vaultApi.listVaults(); + + String path = String.format( + "/subscriptions/%s/resourcegroups/%s/providers/Microsoft.KeyVault/vaults?%s", + subscriptionId, resourceGroup, apiVersion + ); + assertSent(server, "GET", path); + + assertTrue(vaults.isEmpty()); + } + + public void getVault() throws InterruptedException { + server.enqueue(jsonResponse("/vaultget.json").setResponseCode(200)); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + Vault vault = vaultApi.getVault(vaultName); + + String path = String.format( + "/subscriptions/%s/resourcegroups/%s/providers/Microsoft.KeyVault/vaults/%s?%s", + subscriptionId, resourceGroup, vaultName, apiVersion + ); + assertSent(server, "GET", path); + + assertNotNull(vault); + assertTrue(!vault.name().isEmpty()); + } + + public void getVaultReturns404() throws InterruptedException { + server.enqueue(response404()); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + Vault vault = vaultApi.getVault(vaultName); + + String path = String.format( + "/subscriptions/%s/resourcegroups/%s/providers/Microsoft.KeyVault/vaults/%s?%s", + subscriptionId, resourceGroup, vaultName, apiVersion + ); + assertSent(server, "GET", path); + + assertNull(vault); + } + + public void deleteVault() throws InterruptedException { + server.enqueue(response200()); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + boolean status = vaultApi.deleteVault(vaultName); + + String path = String.format( + "/subscriptions/%s/resourcegroups/%s/providers/Microsoft.KeyVault/vaults/%s?%s", + subscriptionId, resourceGroup, vaultName, apiVersion + ); + assertSent(server, "DELETE", path); + + assertTrue(status); + } + + public void deleteVaultReturns404() throws InterruptedException { + server.enqueue(response404()); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + boolean status = vaultApi.deleteVault(vaultName); + + String path = String.format( + "/subscriptions/%s/resourcegroups/%s/providers/Microsoft.KeyVault/vaults/%s?%s", + subscriptionId, resourceGroup, vaultName, apiVersion + ); + assertSent(server, "DELETE", path); + + assertFalse(status); + } + + public void purgeDeletedVault() throws InterruptedException { + server.enqueue(response200()); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + boolean status = vaultApi.purgeVault(location, vaultName); + + String path = String.format( + "/subscriptions/%s/providers/Microsoft.KeyVault/locations/%s/deletedVaults/%s/purge?%s", + subscriptionId, location, vaultName, apiVersion + ); + assertSent(server, "POST", path); + + assertTrue(status); + } + + public void purgeDeletedVaultReturns404() throws InterruptedException { + server.enqueue(response404()); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + boolean status = vaultApi.purgeVault(location, vaultName); + + String path = String.format( + "/subscriptions/%s/providers/Microsoft.KeyVault/locations/%s/deletedVaults/%s/purge?%s", + subscriptionId, location, vaultName, apiVersion + ); + assertSent(server, "POST", path); + + assertFalse(status); + } + + public void listDeletedVaults() throws InterruptedException { + server.enqueue(jsonResponse("/vaultlistdeleted.json").setResponseCode(200)); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + List<DeletedVault> vaults = vaultApi.listDeletedVaults(); + + String path = String.format( + "/subscriptions/%s/providers/Microsoft.KeyVault/deletedVaults?%s", + subscriptionId, apiVersion + ); + assertSent(server, "GET", path); + + assertNotNull(vaults); + assertTrue(vaults.size() > 0); + } + + public void listDeletedVaultsReturns404() throws InterruptedException { + server.enqueue(response404()); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + List<DeletedVault> vaults = vaultApi.listDeletedVaults(); + + String path = String.format( + "/subscriptions/%s/providers/Microsoft.KeyVault/deletedVaults?%s", + subscriptionId, apiVersion + ); + assertSent(server, "GET", path); + + assertTrue(vaults.isEmpty()); + } + + public void getDeletedVault() throws InterruptedException { + server.enqueue(jsonResponse("/vaultgetdeleted.json").setResponseCode(200)); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + DeletedVault vault = vaultApi.getDeletedVault(location, vaultName); + + String path = String.format( + "/subscriptions/%s/providers/Microsoft.KeyVault/locations/%s/deletedVaults/%s?%s", + subscriptionId, location, vaultName, apiVersion + ); + assertSent(server, "GET", path); + + assertNotNull(vault); + assertTrue(!vault.name().isEmpty()); + assertTrue(!vault.properties().deletionDate().toString().isEmpty()); + } + + public void getDeletedVaultReturns404() throws InterruptedException { + server.enqueue(response404()); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + DeletedVault vault = vaultApi.getDeletedVault(location, vaultName); + + String path = String.format( + "/subscriptions/%s/providers/Microsoft.KeyVault/locations/%s/deletedVaults/%s?%s", + subscriptionId, location, vaultName, apiVersion + ); + assertSent(server, "GET", path); + + assertNull(vault); + } + + + // Key mock tests + public void listKeys() throws InterruptedException { + server.enqueue(jsonResponse("/vaultlistkeys.json").setResponseCode(200)); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + List<Key> keys = vaultApi.listKeys(vaultUri); + + String path = String.format("/keys?%s", apiVersion); + assertSent(server, "GET", path); + + assertNotNull(keys); + assertTrue(keys.size() > 0); + } + + public void listKeysReturns404() throws InterruptedException { + server.enqueue(response404()); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + List<Key> keys = vaultApi.listKeys(vaultUri); + + String path = String.format("/keys?%s", apiVersion); + assertSent(server, "GET", path); + + assertTrue(keys.isEmpty()); + } + + public void createKey() throws InterruptedException { + server.enqueue(jsonResponse("/vaultcreatekey.json").setResponseCode(200)); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + KeyAttributes keyAttr = KeyAttributes.create(true, null, null, null, null, null); + KeyBundle keyBundle = vaultApi.createKey(vaultUri, + KEY_NAME, + keyAttr, + null, + null, + 2048, + "RSA", + null + ); + + String path = String.format("/keys/%s/create?%s", KEY_NAME, apiVersion); + assertSent(server, "POST", path, stringFromResource("/vaultcreatekeyrequestbody.json")); + + assertNotNull(keyBundle); + assertNotNull(keyBundle.attributes().created()); + } + + public void importKey() throws InterruptedException { + server.enqueue(jsonResponse("/vaultcreatekey.json").setResponseCode(200)); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + KeyAttributes keyAttr = KeyAttributes.create(true, null, null, null, null, null); + List<String> keyOps = new ArrayList<String>(); + keyOps.add("encrypt"); + JsonWebKey keyInfo = JsonWebKey.create( + null, + "DjU54mYvHpICXHjc5-JiFqiH8NkUgOG8LL4kwt3DeBp9bP0-5hSJH8vmzwJkeGG9L79EWG4b_bfxgYdeNX7cFFagmW" + + "PRFrlxbd64VRYFawZHRJt-2cbzMVI6DL8EK4bu5Ux5qTiV44Jw19hoD9nDzCTfPzSTSGrKD3iLPdnREYaIGDVxcjB" + + "v3Tx6rrv3Z2lhHHKhEHb0RRjATcjAVKV9NZhMajJ4l9pqJ3A4IQrCBl95ux6Xm1oXP0i6aR78cjchsCpcMXdP3WMs" + + "vHgTlsZT0RZLFHrvkiNHlPiil4G2_eHkwvT__CrcbO6SmI_zCtMmypuHJqcr-Xb7GPJoa64WoQ", + "DB9nGuHplY_7Xv5a5UCs5YgxkWPtJFfbIZ1Zr-XHCCY09JIWReOGQG226OhjwixKtOK_OqmAKtMKM9OmKviJRHNbD" + + "hbTxumN3u7cL8dftjXpSryiEQlPmWyW94MneI2WNIrvh4wruQuDt8EztgOiDFxwcnUgey8iend7WmZnE7E", + "O-bSTUQ4N_UuQezgkF3TDrnBraO67leDGwRbfiE_U0ghQvqh5DA0QSPVzlWDZc9KUitvj8vxsR9o1PW9GS0an17GJ" + + "EYuetLnkShKK3NWOhBBX6d1yP9rVdH6JhgIJEy_g0Suz7TAFiFc8i7JF8u4QJ05C8bZAMhOLotqftQeVOM", + "AQAB", + null, + null, + keyOps, + null, + "RSA", + "33TqqLR3eeUmDtHS89qF3p4MP7Wfqt2Zjj3lZjLjjCGDvwr9cJNlNDiuKboODgUiT4ZdPWbOiMAfDcDzlOxA04DDnEF" + + "GAf-kDQiNSe2ZtqC7bnIc8-KSG_qOGQIVaay4Ucr6ovDkykO5Hxn7OU7sJp9TP9H0JH8zMQA6YzijYH9LsupTerrY" + + "3U6zyihVEDXXOv08vBHk50BMFJbE9iwFwnxCsU5-UZUZYw87Uu0n4LPFS9BT8tUIvAfnRXIEWCha3KbFWmdZQZlyr" + + "Fw0buUEf0YN3_Q0auBkdbDR_ES2PbgKTJdkjc_rEeM0TxvOUf7HuUNOhrtAVEN1D5uuxE1WSw", + "8K33pX90XX6PZGiv26wZm7tfvqlqWFT03nUMvOAytqdxhO2HysiPn4W58OaJd1tY4372Qpiv6enmUeI4MidCie-s-d0" + + "_B6A0xfhU5EeeaDN0xDOOl8yN-kaaVj9b4HDR3c91OAwKpDJQIeJVZtxoijxl-SRx3u7Vs_7meeSpOfE", + "7a5KnUs1pTo72A-JquJvIz4Eu794Yh3ftTk_Et-83aE_FVc6Nk-EhfnwYSNpVmM6UKdrAoy5gsCvZPxrq-eR9pEwU8M" + + "5UOlki03vWY_nqDBpJSIqwPvGHUB16zvggsPQUyQBfnN3N8XlDi12n88ltvWwEhn1LQOwMUALEfka9_s", + "InfGmkb2jNkPGuNiZ-mU0-ZrOgLza_fLL9ErZ35jUPhGFzdGxJNobklvsNoTd-E2GAU41YkJh24bncMLvJVYxHHA5iF" + + "7FBWx1SvpEyKVhhnIcuXGD7N5PbNZzEdmr9C6I7cPVkWO-sUV7zfFukexIcANmsd_oBBGKRoYzP5Tti4", + null, + null + ); + KeyBundle importedKey = vaultApi.importKey(vaultUri, IMPORT_KEY_NAME, false, keyAttr, keyInfo, null); + + String path = String.format("/keys/%s?%s", IMPORT_KEY_NAME, apiVersion); + assertSent(server, "PUT", path, stringFromResource("/vaultimportkeyrequestbody.json")); + + assertNotNull(importedKey); + assertNotNull(importedKey.attributes().created()); + } + + public void getKey() throws InterruptedException { + server.enqueue(jsonResponse("/vaultgetkey.json").setResponseCode(200)); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + KeyBundle key = vaultApi.getKey(vaultUri, KEY_NAME); + + String path = String.format("/keys/%s?%s", KEY_NAME, apiVersion); + assertSent(server, "GET", path); + + assertNotNull(key); + assertNotNull(key.attributes().created()); + } + + public void getKeyReturns404() throws InterruptedException { + server.enqueue(response404()); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + KeyBundle key = vaultApi.getKey(vaultUri, KEY_NAME); + + String path = String.format("/keys/%s?%s", KEY_NAME, apiVersion); + assertSent(server, "GET", path); + + assertNull(key); + } + + public void deleteKey() throws InterruptedException { + server.enqueue(jsonResponse("/vaultdeletekey.json").setResponseCode(200)); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + DeletedKeyBundle key = vaultApi.deleteKey(vaultUri, KEY_NAME); + + String path = String.format("/keys/%s?%s", KEY_NAME, apiVersion); + assertSent(server, "DELETE", path); + + assertNotNull(key); + assertNotNull(key.attributes().created()); + } + + public void deleteKeyReturns404() throws InterruptedException { + server.enqueue(response404()); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + DeletedKeyBundle key = vaultApi.deleteKey(vaultUri, KEY_NAME); + + String path = String.format("/keys/%s?%s", KEY_NAME, apiVersion); + assertSent(server, "DELETE", path); + + assertNull(key); + } + + public void getKeyVersions() throws InterruptedException { + server.enqueue(jsonResponse("/vaultgetkeyversions.json").setResponseCode(200)); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + List<Key> keys = vaultApi.getKeyVersions(vaultUri, KEY_NAME); + + String path = String.format("/keys/%s/versions?%s", KEY_NAME, apiVersion); + assertSent(server, "GET", path); + + assertNotNull(keys); + assertTrue(keys.size() > 0); + assertNotNull(keys.get(0).attributes().created()); + } + + public void getKeyVersionsReturns404() throws InterruptedException { + server.enqueue(response404()); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + List<Key> keys = vaultApi.getKeyVersions(vaultUri, KEY_NAME); + + String path = String.format("/keys/%s/versions?%s", KEY_NAME, apiVersion); + assertSent(server, "GET", path); + + assertTrue(keys.isEmpty()); + } + + public void updateKey() throws InterruptedException { + server.enqueue(jsonResponse("/vaultupdatekey.json").setResponseCode(200)); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + Map<String, String> tags = new HashMap<String, String>(); + tags.put("purpose", "testing"); + KeyBundle updatedKey = vaultApi.updateKey(vaultUri, KEY_NAME, null, null, null, tags); + + String path = String.format("/keys/%s?%s", KEY_NAME, apiVersion); + assertSent(server, "PATCH", path, stringFromResource("/vaultupdatekeyrequestbody.json")); + + assertNotNull(updatedKey); + assertNotNull(updatedKey.attributes().created()); + } + + public void updateKeyWithVersion() throws InterruptedException { + server.enqueue(jsonResponse("/vaultupdatekeywithversion.json").setResponseCode(200)); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + String keyVersion = "bd6566ec707e4ad89f4ab9577d9d0bef"; + Map<String, String> tags = new HashMap<String, String>(); + tags.put("purpose", "testing"); + KeyBundle updatedKey = vaultApi.updateKey(vaultUri, KEY_NAME, keyVersion, null, null, tags); + + String path = String.format("/keys/%s/%s?%s", KEY_NAME, keyVersion, apiVersion); + assertSent(server, "PATCH", path, stringFromResource("/vaultupdatekeyrequestbody.json")); + + assertNotNull(updatedKey); + assertNotNull(updatedKey.attributes().created()); + } + + public void backupKey() throws InterruptedException { + server.enqueue(jsonResponse("/vaultbackupkey.json").setResponseCode(200)); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + String keyBackup = vaultApi.backupKey(vaultUri, KEY_NAME); + + String path = String.format("/keys/%s/backup?%s", KEY_NAME, apiVersion); + assertSent(server, "POST", path); + + assertNotNull(keyBackup); + assertTrue(keyBackup.length() > 0); + } + + public void restoreKey() throws InterruptedException { + server.enqueue(jsonResponse("/vaultrestorekey.json").setResponseCode(200)); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + KeyBundle restoredKey = vaultApi.restoreKey(vaultUri, keyBackup); + + String path = String.format("/keys/restore?%s", apiVersion); + assertSent(server, "POST", path, stringFromResource("/vaultrestorekeyrequestbody.json")); + + assertNotNull(restoredKey); + assertNotNull(restoredKey.attributes().created()); + } + + public void listDeletedKeys() throws InterruptedException { + server.enqueue(jsonResponse("/vaultlistdeletedkeys.json").setResponseCode(200)); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + List<DeletedKeyBundle> keys = vaultApi.listDeletedKeys(vaultUri); + + String path = String.format("/deletedkeys?%s", apiVersion); + assertSent(server, "GET", path); + + assertNotNull(keys); + assertTrue(keys.size() > 0); + } + + public void listDeletedKeysReturns404() throws InterruptedException { + server.enqueue(response404()); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + List<DeletedKeyBundle> keys = vaultApi.listDeletedKeys(vaultUri); + + String path = String.format("/deletedkeys?%s", apiVersion); + assertSent(server, "GET", path); + + assertTrue(keys.isEmpty()); + } + + public void getDeletedKey() throws InterruptedException { + server.enqueue(jsonResponse("/vaultgetdeletedkey.json").setResponseCode(200)); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + DeletedKeyBundle key = vaultApi.getDeletedKey(vaultUri, RECOVERABLE_KEY_NAME); + + String path = String.format("/deletedkeys/%s?%s", RECOVERABLE_KEY_NAME, apiVersion); + assertSent(server, "GET", path); + + assertNotNull(key); + assertTrue(!key.deletedDate().isEmpty()); + } + + public void getDeletedKeyReturns404() throws InterruptedException { + server.enqueue(response404()); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + DeletedKeyBundle key = vaultApi.getDeletedKey(vaultUri, RECOVERABLE_KEY_NAME); + + String path = String.format("/deletedkeys/%s?%s", RECOVERABLE_KEY_NAME, apiVersion); + assertSent(server, "GET", path); + + assertNull(key); + } + + public void recoverDeletedKey() throws InterruptedException { + server.enqueue(jsonResponse("/vaultrecoverdeletedkey.json").setResponseCode(200)); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + KeyBundle key = vaultApi.recoverDeletedKey(vaultUri, RECOVERABLE_KEY_NAME); + + String path = String.format("/deletedkeys/%s/recover?%s", RECOVERABLE_KEY_NAME, apiVersion); + assertSent(server, "POST", path); + + assertNotNull(key); + assertNotNull(key.attributes().created()); + } + + public void purgeDeletedKey() throws InterruptedException { + server.enqueue(response200()); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + boolean status = vaultApi.purgeDeletedKey(vaultUri, RECOVERABLE_KEY_NAME); + + String path = String.format("/deletedkeys/%s?%s", RECOVERABLE_KEY_NAME, apiVersion); + assertSent(server, "DELETE", path); + + assertTrue(status); + } + + public void purgeDeletedKeyReturns404() throws InterruptedException { + server.enqueue(response404()); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + boolean status = vaultApi.purgeDeletedKey(vaultUri, RECOVERABLE_KEY_NAME); + + String path = String.format("/deletedkeys/%s?%s", RECOVERABLE_KEY_NAME, apiVersion); + assertSent(server, "DELETE", path); + + assertFalse(status); + } + + public void encrypt() throws InterruptedException { + server.enqueue(jsonResponse("/vaultkeyencrypt.json").setResponseCode(200)); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + KeyOperationResult encryptResult = vaultApi.encrypt(vaultUri, + KEY_NAME, + null, + cryptoAlgorithm, + cryptoText + ); + + String path = String.format("/keys/%s/encrypt?%s", KEY_NAME, apiVersion); + assertSent(server, "POST", path, stringFromResource("/vaultkeyencryptrequestbody.json")); + + assertNotNull(encryptResult); + assertTrue(!encryptResult.value().isEmpty()); + } + + public void decrypt() throws InterruptedException { + server.enqueue(jsonResponse("/vaultkeydecrypt.json").setResponseCode(200)); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + KeyOperationResult decryptResult = vaultApi.decrypt(vaultUri, + KEY_NAME, + null, + cryptoAlgorithm, + keyDecryptData + ); + + String path = String.format("/keys/%s/decrypt?%s", KEY_NAME, apiVersion); + assertSent(server, "POST", path, stringFromResource("/vaultkeydecryptrequestbody.json")); + + assertNotNull(decryptResult); + assertTrue(!decryptResult.value().isEmpty()); + } + + public void sign() throws InterruptedException { + server.enqueue(jsonResponse("/vaultkeysign.json").setResponseCode(200)); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + KeyOperationResult signResult = vaultApi.sign(vaultUri, + KEY_NAME, + null, + signatureAlgorithm, + hashToSign + ); + + String path = String.format("/keys/%s/sign?%s", KEY_NAME, apiVersion); + assertSent(server, "POST", path, stringFromResource("/vaultkeysignrequestbody.json")); + + assertNotNull(signResult); + assertTrue(!signResult.value().isEmpty()); + } + + public void verify() throws InterruptedException { + server.enqueue(jsonResponse("/vaultkeyverify.json").setResponseCode(200)); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + boolean verifyResult = vaultApi.verify(vaultUri, + KEY_NAME, + null, + signatureAlgorithm, + hashToSign, + keySignedData + ); + + String path = String.format("/keys/%s/verify?%s", KEY_NAME, apiVersion); + assertSent(server, "POST", path, stringFromResource("/vaultkeyverifyrequestbody.json")); + + assertTrue(verifyResult); + } + + public void wrap() throws InterruptedException { + server.enqueue(jsonResponse("/vaultkeywrap.json").setResponseCode(200)); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + KeyOperationResult wrapResult = vaultApi.wrap(vaultUri, + KEY_NAME, + null, + cryptoAlgorithm, + contentEncryptionKey + ); + + String path = String.format("/keys/%s/wrapkey?%s", KEY_NAME, apiVersion); + assertSent(server, "POST", path, stringFromResource("/vaultkeywraprequestbody.json")); + + assertNotNull(wrapResult); + assertTrue(!wrapResult.value().isEmpty()); + } + + public void unwrap() throws InterruptedException { + server.enqueue(jsonResponse("/vaultkeyunwrap.json").setResponseCode(200)); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + KeyOperationResult unwrapResult = vaultApi.unwrap(vaultUri, + KEY_NAME, + null, + cryptoAlgorithm, + keyWrappedData + ); + + String path = String.format("/keys/%s/unwrapkey?%s", KEY_NAME, apiVersion); + assertSent(server, "POST", path, stringFromResource("/vaultkeyunwraprequestbody.json")); + + assertNotNull(unwrapResult); + assertTrue(!unwrapResult.value().isEmpty()); + } + + // Secret mock tests + public void listSecrets() throws InterruptedException { + server.enqueue(jsonResponse("/vaultlistsecrets.json").setResponseCode(200)); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + List<Secret> secrets = vaultApi.listSecrets(vaultUri); + + String path = String.format("/secrets?%s", apiVersion); + assertSent(server, "GET", path); + + assertNotNull(secrets); + assertTrue(secrets.size() > 0); + } + + public void listSecretsReturns404() throws InterruptedException { + server.enqueue(response404()); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + List<Secret> secrets = vaultApi.listSecrets(vaultUri); + + String path = String.format("/secrets?%s", apiVersion); + assertSent(server, "GET", path); + + assertTrue(secrets.isEmpty()); + } + + public void setSecret() throws InterruptedException { + server.enqueue(jsonResponse("/vaultsetsecret.json").setResponseCode(200)); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + SecretAttributes attributes = SecretAttributes.create(true, null, null, null, null, null); + SecretBundle secretBundle = vaultApi.setSecret(vaultUri, + SECRET_NAME, + attributes, + "testSecretKey", + null, + sampleSecret + ); + + String path = String.format("/secrets/%s?%s", SECRET_NAME, apiVersion); + assertSent(server, "PUT", path, stringFromResource("/vaultsetsecretrequestbody.json")); + + assertNotNull(secretBundle); + assertTrue(!secretBundle.id().isEmpty()); + } + + public void getSecret() throws InterruptedException { + server.enqueue(jsonResponse("/vaultgetsecret.json").setResponseCode(200)); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + SecretBundle secret = vaultApi.getSecret(vaultUri, SECRET_NAME, null); + + String path = String.format("/secrets/%s?%s", SECRET_NAME, apiVersion); + assertSent(server, "GET", path); + + assertNotNull(secret); + assertNotNull(secret.attributes().created()); + } + + public void getSecretReturns404() throws InterruptedException { + server.enqueue(response404()); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + SecretBundle secret = vaultApi.getSecret(vaultUri, SECRET_NAME, null); + + String path = String.format("/secrets/%s?%s", SECRET_NAME, apiVersion); + assertSent(server, "GET", path); + + assertNull(secret); + } + + public void deleteSecret() throws InterruptedException { + server.enqueue(jsonResponse("/vaultdeletesecret.json").setResponseCode(200)); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + DeletedSecretBundle secret = vaultApi.deleteSecret(vaultUri, SECRET_NAME); + + String path = String.format("/secrets/%s?%s", SECRET_NAME, apiVersion); + assertSent(server, "DELETE", path); + + assertNotNull(secret); + assertNotNull(secret.attributes().created()); + } + + public void deleteSecretReturns404() throws InterruptedException { + server.enqueue(response404()); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + DeletedSecretBundle secret = vaultApi.deleteSecret(vaultUri, SECRET_NAME); + + String path = String.format("/secrets/%s?%s", SECRET_NAME, apiVersion); + assertSent(server, "DELETE", path); + + assertNull(secret); + } + + public void getSecretVersions() throws InterruptedException { + server.enqueue(jsonResponse("/vaultgetsecretversions.json").setResponseCode(200)); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + List<Secret> secrets = vaultApi.getSecretVersions(vaultUri, SECRET_NAME); + + String path = String.format("/secrets/%s/versions?%s", SECRET_NAME, apiVersion); + assertSent(server, "GET", path); + + assertNotNull(secrets); + assertTrue(secrets.size() > 0); + assertNotNull(secrets.get(0).attributes().created()); + } + + public void getSecretVersionsReturns404() throws InterruptedException { + server.enqueue(response404()); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + List<Secret> secrets = vaultApi.getSecretVersions(vaultUri, SECRET_NAME); + + String path = String.format("/secrets/%s/versions?%s", SECRET_NAME, apiVersion); + assertSent(server, "GET", path); + + assertTrue(secrets.isEmpty()); + } + + public void updateSecret() throws InterruptedException { + server.enqueue(jsonResponse("/vaultupdatekey.json").setResponseCode(200)); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + Map<String, String> tags = new HashMap<String, String>(); + tags.put("purpose", "testing"); + SecretBundle updatedSecret = vaultApi.updateSecret(vaultUri, SECRET_NAME, null, null, null, tags); + + String path = String.format("/secrets/%s?%s", SECRET_NAME, apiVersion); + assertSent(server, "PATCH", path, stringFromResource("/vaultupdatesecretrequestbody.json")); + + assertNotNull(updatedSecret); + assertNotNull(updatedSecret.attributes().created()); + } + + public void updateSecretWithVersion() throws InterruptedException { + server.enqueue(jsonResponse("/vaultupdatesecretwithversion.json").setResponseCode(200)); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + String secretVersion = "b936ececbc674f3bb1367ae50d28ada0"; + Map<String, String> tags = new HashMap<String, String>(); + tags.put("purpose", "testing again"); + SecretBundle updatedSecret = vaultApi.updateSecret(vaultUri, SECRET_NAME, secretVersion, null, null, tags); + + String path = String.format("/secrets/%s/%s?%s", SECRET_NAME, secretVersion, apiVersion); + assertSent(server, "PATCH", path, stringFromResource("/vaultupdatesecretwithversionrequestbody.json")); + + assertNotNull(updatedSecret); + assertNotNull(updatedSecret.attributes().created()); + } + + public void backupSecret() throws InterruptedException { + server.enqueue(jsonResponse("/vaultbackupsecret.json").setResponseCode(200)); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + String secretBackup = vaultApi.backupSecret(vaultUri, SECRET_NAME); + + String path = String.format("/secrets/%s/backup?%s", SECRET_NAME, apiVersion); + assertSent(server, "POST", path); + + assertNotNull(secretBackup); + assertTrue(secretBackup.length() > 0); + } + + public void restoreSecret() throws InterruptedException { + server.enqueue(jsonResponse("/vaultrestoresecret.json").setResponseCode(200)); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + SecretBundle restoredSecret = vaultApi.restoreSecret(vaultUri, secretBackup); + + String path = String.format("/secrets/restore?%s", apiVersion); + assertSent(server, "POST", path, stringFromResource("/vaultrestoresecretrequestbody.json")); + + assertNotNull(restoredSecret); + assertNotNull(restoredSecret.attributes().created()); + } + + public void listDeletedSecrets() throws InterruptedException { + server.enqueue(jsonResponse("/vaultlistdeletedsecrets.json").setResponseCode(200)); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + List<DeletedSecretBundle> secrets = vaultApi.listDeletedSecrets(vaultUri); + + String path = String.format("/deletedsecrets?%s", apiVersion); + assertSent(server, "GET", path); + + assertNotNull(secrets); + assertTrue(secrets.size() > 0); + } + + public void listDeletedSecretsReturns404() throws InterruptedException { + server.enqueue(response404()); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + List<DeletedSecretBundle> secrets = vaultApi.listDeletedSecrets(vaultUri); + + String path = String.format("/deletedsecrets?%s", apiVersion); + assertSent(server, "GET", path); + + assertTrue(secrets.isEmpty()); + } + + public void getDeletedSecret() throws InterruptedException { + server.enqueue(jsonResponse("/vaultgetdeletedsecret.json").setResponseCode(200)); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + DeletedSecretBundle secret = vaultApi.getDeletedSecret(vaultUri, RECOVERABLE_SECRET_NAME); + + String path = String.format("/deletedsecrets/%s?%s", RECOVERABLE_SECRET_NAME, apiVersion); + assertSent(server, "GET", path); + + assertNotNull(secret); + assertTrue(!secret.deletedDate().isEmpty()); + } + + public void getDeletedSecretReturns404() throws InterruptedException { + server.enqueue(response404()); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + DeletedSecretBundle secret = vaultApi.getDeletedSecret(vaultUri, RECOVERABLE_SECRET_NAME); + + String path = String.format("/deletedsecrets/%s?%s", RECOVERABLE_SECRET_NAME, apiVersion); + assertSent(server, "GET", path); + + assertNull(secret); + } + + public void recoverDeletedSecret() throws InterruptedException { + server.enqueue(jsonResponse("/vaultrecoverdeletedsecret.json").setResponseCode(200)); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + SecretBundle secret = vaultApi.recoverDeletedSecret(vaultUri, RECOVERABLE_SECRET_NAME); + + String path = String.format("/deletedsecrets/%s/recover?%s", RECOVERABLE_SECRET_NAME, apiVersion); + assertSent(server, "POST", path); + + assertNotNull(secret); + assertNotNull(secret.attributes().created()); + } + + public void purgeDeletedSecret() throws InterruptedException { + server.enqueue(response200()); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + boolean status = vaultApi.purgeDeletedSecret(vaultUri, RECOVERABLE_SECRET_NAME); + + String path = String.format("/deletedsecrets/%s?%s", RECOVERABLE_SECRET_NAME, apiVersion); + assertSent(server, "DELETE", path); + + assertTrue(status); + } + + public void purgeDeletedSecretReturns404() throws InterruptedException { + server.enqueue(response404()); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + boolean status = vaultApi.purgeDeletedSecret(vaultUri, RECOVERABLE_SECRET_NAME); + + String path = String.format("/deletedsecrets/%s?%s", RECOVERABLE_SECRET_NAME, apiVersion); + assertSent(server, "DELETE", path); + + assertFalse(status); + } + + public void createCertificate() throws InterruptedException { + server.enqueue(jsonResponse("/vaultcreatecertificate.json").setResponseCode(200)); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + CertificatePolicy policy = CertificatePolicy.create(null, + CERTIFICATE_NAME, + IssuerParameters.create(null, "Self"), + KeyProperties.create(false, 2048, "RSA", false), + null, + null, + X509CertificateProperties.create(null, null, null, "CN=mycertificate.foobar.com", 12) + ); + CertificateOperation certOp = vaultApi.createCertificate(vaultUri, + CERTIFICATE_NAME, + null, + policy, + null + ); + + String path = String.format("/certificates/%s/create?%s", CERTIFICATE_NAME, apiVersion); + assertSent(server, "POST", path, stringFromResource("/vaultcreatecertificaterequestbody.json")); + + assertNotNull(certOp); + assertTrue(!certOp.id().isEmpty()); + } + + public void getCertificate() throws InterruptedException { + server.enqueue(jsonResponse("/vaultgetcertificate.json").setResponseCode(200)); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + CertificateBundle cert = vaultApi.getCertificate(vaultUri, CERTIFICATE_NAME, null); + + String path = String.format("/certificates/%s?%s", CERTIFICATE_NAME, apiVersion); + assertSent(server, "GET", path); + + assertNotNull(cert); + assertTrue(!cert.id().isEmpty()); + } + + public void getCertificateReturns404() throws InterruptedException { + server.enqueue(response404()); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + CertificateBundle cert = vaultApi.getCertificate(vaultUri, CERTIFICATE_NAME, null); + + String path = String.format("/certificates/%s?%s", CERTIFICATE_NAME, apiVersion); + assertSent(server, "GET", path); + + assertNull(cert); + } + + public void deleteCertificate() throws InterruptedException { + server.enqueue(jsonResponse("/vaultdeletecertificate.json").setResponseCode(200)); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + DeletedCertificateBundle cert = vaultApi.deleteCertificate(vaultUri, CERTIFICATE_NAME); + + String path = String.format("/certificates/%s?%s", CERTIFICATE_NAME, apiVersion); + assertSent(server, "DELETE", path); + + assertNotNull(cert); + assertTrue(!cert.id().isEmpty()); + } + + public void deleteCertificateReturns404() throws InterruptedException { + server.enqueue(response404()); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + DeletedCertificateBundle cert = vaultApi.deleteCertificate(vaultUri, CERTIFICATE_NAME); + + String path = String.format("/certificates/%s?%s", CERTIFICATE_NAME, apiVersion); + assertSent(server, "DELETE", path); + + assertNull(cert); + } + + public void listCertificates() throws InterruptedException { + server.enqueue(jsonResponse("/vaultlistcertificates.json").setResponseCode(200)); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + List<Certificate> certs = vaultApi.getCertificates(vaultUri); + + String path = String.format("/certificates?%s", apiVersion); + assertSent(server, "GET", path); + + assertNotNull(certs); + assertTrue(certs.size() > 0); + } + + public void listCertificatesReturns404() throws InterruptedException { + server.enqueue(response404()); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + List<Certificate> certs = vaultApi.getCertificates(vaultUri); + + String path = String.format("/certificates?%s", apiVersion); + assertSent(server, "GET", path); + + assertTrue(certs.isEmpty()); + } + + public void listDeletedCertificates() throws InterruptedException { + server.enqueue(jsonResponse("/vaultlistdeletedcertificates.json").setResponseCode(200)); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + List<DeletedCertificate> certs = vaultApi.getDeletedCertificates(vaultUri); + + String path = String.format("/deletedcertificates?%s", apiVersion); + assertSent(server, "GET", path); + + assertNotNull(certs); + assertTrue(certs.size() > 0); + } + + public void listDeletedCertificatesReturns404() throws InterruptedException { + server.enqueue(response404()); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + List<DeletedCertificate> certs = vaultApi.getDeletedCertificates(vaultUri); + + String path = String.format("/deletedcertificates?%s", apiVersion); + assertSent(server, "GET", path); + + assertTrue(certs.isEmpty()); + } + + public void getDeletedCertificate() throws InterruptedException { + server.enqueue(jsonResponse("/vaultgetdeletedcertificate.json").setResponseCode(200)); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + DeletedCertificateBundle cert = vaultApi.getDeletedCertificate(vaultUri, RECOVERABLE_CERTIFICATE_NAME); + + String path = String.format("/deletedcertificates/%s?%s", RECOVERABLE_CERTIFICATE_NAME, apiVersion); + assertSent(server, "GET", path); + + assertNotNull(cert); + assertTrue(!cert.id().isEmpty()); + } + + public void getDeletedCertificateReturns404() throws InterruptedException { + server.enqueue(response404()); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + DeletedCertificateBundle cert = vaultApi.getDeletedCertificate(vaultUri, RECOVERABLE_CERTIFICATE_NAME); + + String path = String.format("/deletedcertificates/%s?%s", RECOVERABLE_CERTIFICATE_NAME, apiVersion); + assertSent(server, "GET", path); + + assertNull(cert); + } + + public void recoverDeletedCertificate() throws InterruptedException { + server.enqueue(jsonResponse("/vaultrecoverdeletedcertificate.json").setResponseCode(200)); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + CertificateBundle cert = vaultApi.recoverDeletedCertificate(vaultUri, RECOVERABLE_CERTIFICATE_NAME); + + String path = String.format("/deletedcertificates/%s/recover?%s", RECOVERABLE_CERTIFICATE_NAME, apiVersion); + assertSent(server, "POST", path); + + assertNotNull(cert); + assertTrue(!cert.id().isEmpty()); + } + + public void purgeDeletedCertificate() throws InterruptedException { + server.enqueue(response200()); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + boolean status = vaultApi.purgeDeletedCertificate(vaultUri, RECOVERABLE_CERTIFICATE_NAME); + + String path = String.format("/deletedcertificates/%s?%s", RECOVERABLE_CERTIFICATE_NAME, apiVersion); + assertSent(server, "DELETE", path); + + assertTrue(status); + } + + public void purgeDeletedCertificateReturns404() throws InterruptedException { + server.enqueue(response404()); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + boolean status = vaultApi.purgeDeletedCertificate(vaultUri, RECOVERABLE_CERTIFICATE_NAME); + + String path = String.format("/deletedcertificates/%s?%s", RECOVERABLE_CERTIFICATE_NAME, apiVersion); + assertSent(server, "DELETE", path); + + assertFalse(status); + } + + public void listCertificateVersions() throws InterruptedException { + server.enqueue(jsonResponse("/vaultlistcertificateversions.json").setResponseCode(200)); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + List<Certificate> certs = vaultApi.getCertificateVersions(vaultUri, CERTIFICATE_NAME); + + String path = String.format("/certificates/%s/versions?%s", CERTIFICATE_NAME, apiVersion); + assertSent(server, "GET", path); + + assertNotNull(certs); + assertTrue(certs.size() > 0); + } + + public void listCertificateVersionsReturns404() throws InterruptedException { + server.enqueue(response404()); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + List<Certificate> certs = vaultApi.getCertificateVersions(vaultUri, CERTIFICATE_NAME); + + String path = String.format("/certificates/%s/versions?%s", CERTIFICATE_NAME, apiVersion); + assertSent(server, "GET", path); + + assertTrue(certs.isEmpty()); + } + + public void updateCertificate() throws InterruptedException { + server.enqueue(jsonResponse("/vaultupdatecertificate.json").setResponseCode(200)); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + Map<String, String> tags = new HashMap<String, String>(); + tags.put("selfsigned", "true"); + CertificatePolicy policy = CertificatePolicy.create(null, + CERTIFICATE_NAME, + IssuerParameters.create(null, "Self"), + KeyProperties.create(false, 2048, "RSA", false), + null, + null, + X509CertificateProperties.create(null, null, null, "CN=mycertificate.foobar.com", 12) + ); + CertificateBundle certBundle = vaultApi.updateCertificate( + vaultUri, + CERTIFICATE_NAME, + null, + null, + policy, + tags + ); + + String path = String.format("/certificates/%s?%s", CERTIFICATE_NAME, apiVersion); + assertSent(server, "PATCH", path, stringFromResource("/vaultupdatecertificaterequestbody.json")); + + assertNotNull(certBundle); + assertTrue(!certBundle.id().isEmpty()); + } + + public void updateCertificateVersion() { + // Update the specific version of a certificate + + /* + * XXX -- update using version complains about needing policy (required input), yet + * passing in the same policy results in the error: + * + * Policy cannot be updated with a specific version of a certificate + * + * Will uncomment/fix once this issue is resolved. + * + */ + throw new SkipException("azure bug - update using version complains about needing policy"); + } + + public void importCertificate() throws InterruptedException { + server.enqueue(jsonResponse("/vaultimportcertificate.json").setResponseCode(200)); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + String certPem = IMPORTABLE_CERTIFICATE_PEM; + CertificateBundle certBundle = null; + try { + certBundle = vaultApi.importCertificate( + vaultUri, + RECOVERABLE_CERTIFICATE_NAME, + null, + CertificatePolicy.create( + null, + null, + null, + null, + null, + SecretProperties.create("application/x-pem-file"), + null + ), + null, + null, + certPem); + } catch (ResourceNotFoundException rnf) { + assertNotNull(rnf); + } + + String path = String.format("/certificates/%s/import?%s", RECOVERABLE_CERTIFICATE_NAME, apiVersion); + assertSent(server, "POST", path, stringFromResource("/vaultimportcertificaterequestbody.json")); + + assertNotNull(certBundle); + assertTrue(!certBundle.id().isEmpty()); + } + + public void mergeCertificate() throws InterruptedException { + // Merging a certificate is for when a CSR is signed by an external CA + server.enqueue(jsonResponse("/vaultmergecertificate.json").setResponseCode(200)); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + CertificateAttributes attributes = CertificateAttributes.create(null, true, null, null, null, null); + CertificateBundle certBundle = vaultApi.mergeCertificate( + vaultUri, + CERTIFICATE_NAME, + attributes, + null, + Arrays.asList(mergeX5C) + ); + + String path = String.format("/certificates/%s/pending/merge?%s", CERTIFICATE_NAME, apiVersion); + assertSent(server, "POST", path, stringFromResource("/vaultmergecertificaterequestbody.json")); + + assertNotNull(certBundle); + assertTrue(!certBundle.attributes().created().toString().isEmpty()); + } + + public void getCertificateOperation() throws InterruptedException { + server.enqueue(jsonResponse("/vaultgetcertificateoperation.json").setResponseCode(200)); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + CertificateOperation certOp = vaultApi.getCertificateOperation(vaultUri, CERTIFICATE_NAME); + + String path = String.format("/certificates/%s/pending?%s", CERTIFICATE_NAME, apiVersion); + assertSent(server, "GET", path); + + assertNotNull(certOp); + assertTrue(!certOp.id().isEmpty()); + } + + public void getCertificateOperationReturns404() throws InterruptedException { + server.enqueue(response404()); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + CertificateOperation certOp = vaultApi.getCertificateOperation(vaultUri, CERTIFICATE_NAME); + + String path = String.format("/certificates/%s/pending?%s", CERTIFICATE_NAME, apiVersion); + assertSent(server, "GET", path); + + assertNull(certOp); + } + + public void updateCertificateOperation() throws InterruptedException { + server.enqueue(jsonResponse("/vaultupdatecertificateoperation.json").setResponseCode(200)); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + CertificateOperation certOp = vaultApi.updateCertificateOperation(vaultUri, CERTIFICATE_NAME, true); + + String path = String.format("/certificates/%s/pending?%s", CERTIFICATE_NAME, apiVersion); + assertSent(server, "PATCH", path, stringFromResource("/vaultupdatecertificateoperationrequestbody.json")); + + assertNotNull(certOp); + assertTrue(!certOp.id().isEmpty()); + } + + public void deleteCertificateOperation() throws InterruptedException { + server.enqueue(jsonResponse("/vaultdeletecertificateoperation.json").setResponseCode(200)); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + CertificateOperation certOp = vaultApi.deleteCertificateOperation(vaultUri, CERTIFICATE_NAME); + + String path = String.format("/certificates/%s/pending?%s", CERTIFICATE_NAME, apiVersion); + assertSent(server, "DELETE", path); + + assertNotNull(certOp); + assertTrue(!certOp.id().isEmpty()); + } + + public void deleteCertificateOperationReturns404() throws InterruptedException { + server.enqueue(response404()); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + CertificateOperation certOp = vaultApi.deleteCertificateOperation(vaultUri, CERTIFICATE_NAME); + + String path = String.format("/certificates/%s/pending?%s", CERTIFICATE_NAME, apiVersion); + assertSent(server, "DELETE", path); + + assertNull(certOp); + } + + public void setCertificateIssuer() throws InterruptedException { + server.enqueue(jsonResponse("/vaultsetcertificateissuer.json").setResponseCode(200)); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + AdministrationDetails adminDetail = AdministrationDetails.create( + "[email protected]", + "Admin", + "Guy", + "867-5309" + ); + List<AdministrationDetails> adminDetails = new ArrayList<AdministrationDetails>(); + adminDetails.add(adminDetail); + OrganizationDetails orgDetails = OrganizationDetails.create( + adminDetails, + null + ); + IssuerBundle issuer = null; + try { + issuer = vaultApi.setCertificateIssuer( + vaultUri, + CERTIFICATE_ISSUER_NAME, + null, + IssuerCredentials.create("imauser", "This1sMyPa55wurD!"), + orgDetails, + "GlobalSign" + ); + } catch (ResourceNotFoundException rnf) { + assertNotNull(rnf); + } + + String path = String.format("/certificates/issuers/%s?%s", CERTIFICATE_ISSUER_NAME, apiVersion); + assertSent(server, "PUT", path, stringFromResource("/vaultsetcertificateissuerrequestbody.json")); + + assertNotNull(issuer); + assertTrue(!issuer.id().isEmpty()); + } + + public void listCertificateIssuers() throws InterruptedException { + server.enqueue(jsonResponse("/vaultlistcertificateissuers.json").setResponseCode(200)); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + List<CertificateIssuer> issuers = vaultApi.getCertificateIssuers(vaultUri); + + String path = String.format("/certificates/issuers?%s", apiVersion); + assertSent(server, "GET", path); + + assertNotNull(issuers); + assertTrue(issuers.size() > 0); + } + + public void listCertificateIssuersReturns404() throws InterruptedException { + server.enqueue(response404()); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + List<CertificateIssuer> issuers = vaultApi.getCertificateIssuers(vaultUri); + + String path = String.format("/certificates/issuers?%s", apiVersion); + assertSent(server, "GET", path); + + assertTrue(issuers.isEmpty()); + } + + public void getCertificateIssuer() throws InterruptedException { + server.enqueue(jsonResponse("/vaultgetcertificateissuer.json").setResponseCode(200)); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + IssuerBundle issuer = vaultApi.getCertificateIssuer(vaultUri, CERTIFICATE_ISSUER_NAME); + + String path = String.format("/certificates/issuers/%s?%s", CERTIFICATE_ISSUER_NAME, apiVersion); + assertSent(server, "GET", path); + + assertNotNull(issuer); + assertTrue(!issuer.id().isEmpty()); + } + + public void getCertificateIssuerReturns404() throws InterruptedException { + server.enqueue(response404()); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + IssuerBundle issuer = vaultApi.getCertificateIssuer(vaultUri, CERTIFICATE_ISSUER_NAME); + + String path = String.format("/certificates/issuers/%s?%s", CERTIFICATE_ISSUER_NAME, apiVersion); + assertSent(server, "GET", path); + + assertNull(issuer); + } + + public void updateCertificateIssuer() throws InterruptedException { + server.enqueue(jsonResponse("/vaultupdatecertificateissuer.json").setResponseCode(200)); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + AdministrationDetails adminDetail = AdministrationDetails.create( + "[email protected]", + "Admin", + "Guy", + "867-5309" + ); + List<AdministrationDetails> adminDetails = new ArrayList<AdministrationDetails>(); + adminDetails.add(adminDetail); + OrganizationDetails orgDetails = OrganizationDetails.create( + adminDetails, + null + ); + IssuerBundle issuer = vaultApi.updateCertificateIssuer( + vaultUri, + "globalsign01", + null, + IssuerCredentials.create("imauser", "CanHa5P455wuRd!"), + orgDetails, + "GlobalSign" + ); + + String path = String.format("/certificates/issuers/%s?%s", CERTIFICATE_ISSUER_NAME, apiVersion); + assertSent(server, "PATCH", path, stringFromResource("/vaultupdatecertificateissuerrequestbody.json")); + + assertNotNull(issuer); + assertTrue(!issuer.id().isEmpty()); + } + + public void deleteCertificateIssuer() throws InterruptedException { + server.enqueue(jsonResponse("/vaultdeletecertificateissuer.json").setResponseCode(200)); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + IssuerBundle issuer = vaultApi.deleteCertificateIssuer(vaultUri, CERTIFICATE_ISSUER_NAME); + + String path = String.format("/certificates/issuers/%s?%s", CERTIFICATE_ISSUER_NAME, apiVersion); + assertSent(server, "DELETE", path); + + assertNotNull(issuer); + assertTrue(!issuer.id().isEmpty()); + } + + public void deleteCertificateIssuerReturns404() throws InterruptedException { + server.enqueue(response404()); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + IssuerBundle issuer = vaultApi.deleteCertificateIssuer(vaultUri, CERTIFICATE_ISSUER_NAME); + + String path = String.format("/certificates/issuers/%s?%s", CERTIFICATE_ISSUER_NAME, apiVersion); + assertSent(server, "DELETE", path); + + assertNull(issuer); + } + + public void getCertificateContacts() throws InterruptedException { + server.enqueue(jsonResponse("/vaultgetcertificatecontacts.json").setResponseCode(200)); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + Contacts contacts = vaultApi.getCertificateContacts(vaultUri); + + String path = String.format("/certificates/contacts?%s", apiVersion); + assertSent(server, "GET", path); + + assertNotNull(contacts); + assertTrue(!contacts.id().isEmpty()); + assertTrue(contacts.contacts().size() > 0); + } + + public void getCertificateContactsReturns404() throws InterruptedException { + server.enqueue(response404()); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + IssuerBundle issuer = null; + try { + issuer = vaultApi.getCertificateIssuer(vaultUri, CERTIFICATE_ISSUER_NAME); + } catch (ResourceNotFoundException rnf) { + assertNotNull(rnf); + } + + String path = String.format("/certificates/issuers/%s?%s", CERTIFICATE_ISSUER_NAME, apiVersion); + assertSent(server, "GET", path); + + assertNull(issuer); + } + + public void setCertificateContacts() throws InterruptedException { + server.enqueue(jsonResponse("/vaultsetcertificatecontacts.json").setResponseCode(200)); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + List<Contact> contactsIn = new ArrayList<Contact>(); + contactsIn.add(Contact.create("[email protected]", "Foo bar", "867-5309")); + Contacts contacts = vaultApi.setCertificateContacts(vaultUri, contactsIn); + + String path = String.format("/certificates/contacts?%s", apiVersion); + assertSent(server, "PUT", path, stringFromResource("/vaultsetcertificatecontactsrequestbody.json")); + + assertNotNull(contacts); + assertTrue(!contacts.id().isEmpty()); + assertTrue(contacts.contacts().size() > 0); + } + + public void deleteCertificateContacts() throws InterruptedException { + server.enqueue(jsonResponse("/vaultdeletecertificatecontacts.json").setResponseCode(200)); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + Contacts contacts = vaultApi.deleteCertificateContacts(vaultUri); + + String path = String.format("/certificates/contacts?%s", apiVersion); + assertSent(server, "DELETE", path); + + assertNotNull(contacts); + assertTrue(!contacts.id().isEmpty()); + assertTrue(contacts.contacts().size() > 0); + } + + public void deleteCertificateContactsReturns404() throws InterruptedException { + server.enqueue(response404()); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + Contacts contacts = vaultApi.deleteCertificateContacts(vaultUri); + + String path = String.format("/certificates/contacts?%s", apiVersion); + assertSent(server, "DELETE", path); + + assertNull(contacts); + } + + public void getCertificatePolicy() throws InterruptedException { + server.enqueue(jsonResponse("/vaultgetcertificatepolicy.json").setResponseCode(200)); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + CertificatePolicy policy = vaultApi.getCertificatePolicy(vaultUri, CERTIFICATE_NAME); + + String path = String.format("/certificates/%s/policy?%s", CERTIFICATE_NAME, apiVersion); + assertSent(server, "GET", path); + + assertNotNull(policy); + assertTrue(!policy.id().isEmpty()); + } + + public void getCertificatePolicyReturns404() throws InterruptedException { + server.enqueue(response404()); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + CertificatePolicy policy = vaultApi.getCertificatePolicy(vaultUri, CERTIFICATE_NAME); + + String path = String.format("/certificates/%s/policy?%s", CERTIFICATE_NAME, apiVersion); + assertSent(server, "GET", path); + + assertNull(policy); + } + + public void updateCertificatePolicy() throws InterruptedException { + server.enqueue(jsonResponse("/vaultupdatecertificatepolicy.json").setResponseCode(200)); + final VaultApi vaultApi = api.getVaultApi(resourceGroup); + CertificatePolicy policy = vaultApi.updateCertificatePolicy( + vaultUri, + CERTIFICATE_NAME, + null, + null, + KeyProperties.create(true, 3072, "RSA", false), + null, + null, + null + ); + + String path = String.format("/certificates/%s/policy?%s", CERTIFICATE_NAME, apiVersion); + assertSent(server, "PATCH", path, stringFromResource("/vaultupdatecertificatepolicyrequestbody.json")); + + assertNotNull(policy); + assertTrue(!policy.id().isEmpty()); + } +}
http://git-wip-us.apache.org/repos/asf/jclouds-labs/blob/fa63f6b1/azurecompute-arm/src/test/java/org/jclouds/azurecompute/arm/internal/BaseAzureComputeApiLiveTest.java ---------------------------------------------------------------------- diff --git a/azurecompute-arm/src/test/java/org/jclouds/azurecompute/arm/internal/BaseAzureComputeApiLiveTest.java b/azurecompute-arm/src/test/java/org/jclouds/azurecompute/arm/internal/BaseAzureComputeApiLiveTest.java index f439315..78d5425 100644 --- a/azurecompute-arm/src/test/java/org/jclouds/azurecompute/arm/internal/BaseAzureComputeApiLiveTest.java +++ b/azurecompute-arm/src/test/java/org/jclouds/azurecompute/arm/internal/BaseAzureComputeApiLiveTest.java @@ -17,21 +17,42 @@ package org.jclouds.azurecompute.arm.internal; import static com.google.common.base.Preconditions.checkNotNull; -import static org.jclouds.azurecompute.arm.config.AzureComputeProperties.TIMEOUT_RESOURCE_DELETED; import static org.jclouds.compute.config.ComputeServiceProperties.TIMEOUT_IMAGE_AVAILABLE; import static org.jclouds.util.Predicates2.retry; import static org.testng.Assert.assertNotNull; import static org.testng.Assert.assertTrue; - +import static org.jclouds.azurecompute.arm.config.AzureComputeProperties.TIMEOUT_RESOURCE_DELETED; +import static org.jclouds.azurecompute.arm.config.AzureComputeProperties.VAULT_DELETE_STATUS; +import static org.jclouds.azurecompute.arm.config.AzureComputeProperties.VAULT_SECRET_DELETE_STATUS; +import static org.jclouds.azurecompute.arm.config.AzureComputeProperties.VAULT_SECRET_RECOVERABLE_STATUS; +import static org.jclouds.azurecompute.arm.config.AzureComputeProperties.VAULT_KEY_DELETED_STATUS; +import static org.jclouds.azurecompute.arm.config.AzureComputeProperties.VAULT_KEY_RECOVERABLE_STATUS; +import static org.jclouds.azurecompute.arm.config.AzureComputeProperties.VAULT_CERTIFICATE_DELETE_STATUS; +import static org.jclouds.azurecompute.arm.config.AzureComputeProperties.VAULT_CERTIFICATE_RECOVERABLE_STATUS; +import static org.jclouds.azurecompute.arm.config.AzureComputeProperties.VAULT_CERTIFICATE_OPERATION_STATUS; + +import java.io.IOException; import java.net.URI; import java.util.Arrays; import java.util.List; import java.util.Properties; import java.util.Random; +import com.google.common.base.Charsets; +import com.google.common.base.Throwables; +import com.google.common.io.Resources; import org.jclouds.apis.BaseApiLiveTest; import org.jclouds.azurecompute.arm.AzureComputeApi; -import org.jclouds.azurecompute.arm.compute.config.AzureComputeServiceContextModule.PublicIpAvailablePredicateFactory; +import org.jclouds.azurecompute.arm.config.Tenant; +import org.jclouds.azurecompute.arm.compute.config.AzurePredicatesModule.VaultPredicates.DeletedVaultStatusPredicateFactory; +import org.jclouds.azurecompute.arm.compute.config.AzurePredicatesModule.VaultKeyPredicates.DeletedKeyStatusPredicateFactory; +import org.jclouds.azurecompute.arm.compute.config.AzurePredicatesModule.VaultKeyPredicates.RecoverableKeyStatusPredicateFactory; +import org.jclouds.azurecompute.arm.compute.config.AzurePredicatesModule.VaultSecretPredicates.DeletedSecretStatusPredicateFactory; +import org.jclouds.azurecompute.arm.compute.config.AzurePredicatesModule.VaultSecretPredicates.RecoverableSecretStatusPredicateFactory; +import org.jclouds.azurecompute.arm.compute.config.AzurePredicatesModule.VaultCertificatePredicates.CertificateOperationStatusPredicateFactory; +import org.jclouds.azurecompute.arm.compute.config.AzurePredicatesModule.VaultCertificatePredicates.DeletedCertificateStatusPredicateFactory; +import org.jclouds.azurecompute.arm.compute.config.AzurePredicatesModule.VaultCertificatePredicates.RecoverableCertificateStatusPredicateFactory; +import org.jclouds.azurecompute.arm.compute.config.AzurePredicatesModule.PublicIpAvailablePredicateFactory; import org.jclouds.azurecompute.arm.domain.NetworkSecurityGroup; import org.jclouds.azurecompute.arm.domain.NetworkSecurityGroupProperties; import org.jclouds.azurecompute.arm.domain.NetworkSecurityRule; @@ -47,11 +68,11 @@ import com.google.common.base.Predicate; import com.google.common.base.Supplier; import com.google.common.collect.ImmutableMap; import com.google.common.collect.Lists; +import com.google.inject.name.Names; import com.google.inject.Injector; -import com.google.inject.Key; import com.google.inject.Module; +import com.google.inject.Key; import com.google.inject.TypeLiteral; -import com.google.inject.name.Names; public class BaseAzureComputeApiLiveTest extends BaseApiLiveTest<AzureComputeApi> { @@ -64,12 +85,22 @@ public class BaseAzureComputeApiLiveTest extends BaseApiLiveTest<AzureComputeApi protected Predicate<URI> resourceDeleted; protected PublicIpAvailablePredicateFactory publicIpAvailable; protected Predicate<Supplier<Provisionable>> resourceAvailable; - + protected DeletedVaultStatusPredicateFactory deletedVaultStatus; + protected DeletedKeyStatusPredicateFactory deletedKeyStatus; + protected RecoverableKeyStatusPredicateFactory recoverableKeyStatus; + protected DeletedSecretStatusPredicateFactory deletedSecretStatus; + protected RecoverableSecretStatusPredicateFactory recoverableSecretStatus; + protected DeletedCertificateStatusPredicateFactory deletedCertificateStatus; + protected RecoverableCertificateStatusPredicateFactory recoverableCertificateStatus; + protected CertificateOperationStatusPredicateFactory certificateOperationStatus; + + protected String resourceGroupName; protected String vaultResourceGroup; protected String vaultName; protected String vaultCertificateUrl; + protected String tenantId; public BaseAzureComputeApiLiveTest() { provider = "azurecompute-arm"; @@ -110,6 +141,16 @@ public class BaseAzureComputeApiLiveTest extends BaseApiLiveTest<AzureComputeApi publicIpAvailable = injector.getInstance(PublicIpAvailablePredicateFactory.class); resourceAvailable = injector.getInstance(Key.get(new TypeLiteral<Predicate<Supplier<Provisionable>>>() { })); + deletedVaultStatus = injector.getInstance(Key.get(DeletedVaultStatusPredicateFactory.class, Names.named(VAULT_DELETE_STATUS))); + deletedKeyStatus = injector.getInstance(Key.get(DeletedKeyStatusPredicateFactory.class, Names.named(VAULT_KEY_DELETED_STATUS))); + recoverableKeyStatus = injector.getInstance(Key.get(RecoverableKeyStatusPredicateFactory.class, Names.named(VAULT_KEY_RECOVERABLE_STATUS))); + deletedSecretStatus = injector.getInstance(Key.get(DeletedSecretStatusPredicateFactory.class, Names.named(VAULT_SECRET_DELETE_STATUS))); + recoverableSecretStatus = injector.getInstance(Key.get(RecoverableSecretStatusPredicateFactory.class, Names.named(VAULT_SECRET_RECOVERABLE_STATUS))); + deletedCertificateStatus = injector.getInstance(Key.get(DeletedCertificateStatusPredicateFactory.class, Names.named(VAULT_CERTIFICATE_DELETE_STATUS))); + recoverableCertificateStatus = injector.getInstance(Key.get(RecoverableCertificateStatusPredicateFactory.class, Names.named(VAULT_CERTIFICATE_RECOVERABLE_STATUS))); + certificateOperationStatus = injector.getInstance(Key.get(CertificateOperationStatusPredicateFactory.class, Names.named(VAULT_CERTIFICATE_OPERATION_STATUS))); + + tenantId = injector.getInstance(Key.get(String.class, Tenant.class)); return injector.getInstance(AzureComputeApi.class); } @@ -198,4 +239,11 @@ public class BaseAzureComputeApiLiveTest extends BaseApiLiveTest<AzureComputeApi return subscriptionId; } + protected String stringFromResource(String resourceName) { + try { + return Resources.toString(getClass().getResource(resourceName), Charsets.UTF_8); + } catch (IOException e) { + throw Throwables.propagate(e); + } + } } http://git-wip-us.apache.org/repos/asf/jclouds-labs/blob/fa63f6b1/azurecompute-arm/src/test/java/org/jclouds/azurecompute/arm/internal/BaseAzureComputeApiMockTest.java ---------------------------------------------------------------------- diff --git a/azurecompute-arm/src/test/java/org/jclouds/azurecompute/arm/internal/BaseAzureComputeApiMockTest.java b/azurecompute-arm/src/test/java/org/jclouds/azurecompute/arm/internal/BaseAzureComputeApiMockTest.java index 9d5eab0..8a0efd4 100644 --- a/azurecompute-arm/src/test/java/org/jclouds/azurecompute/arm/internal/BaseAzureComputeApiMockTest.java +++ b/azurecompute-arm/src/test/java/org/jclouds/azurecompute/arm/internal/BaseAzureComputeApiMockTest.java @@ -26,6 +26,7 @@ import static org.testng.Assert.assertEquals; import java.io.IOException; import java.net.URI; +import java.net.URISyntaxException; import java.util.Properties; import java.util.Set; @@ -71,7 +72,7 @@ public class BaseAzureComputeApiMockTest { private final JsonParser parser = new JsonParser(); @BeforeMethod - public void start() throws IOException { + public void start() throws IOException, URISyntaxException { server = new MockWebServer(); server.play(); @@ -148,10 +149,19 @@ public class BaseAzureComputeApiMockTest { "https://management.azure.com/subscriptions/SUBSCRIPTIONID/operationresults/eyJqb2JJZCI6IlJFU09VUkNFR1JPVVBERUxFVElPTkpPQi1SVEVTVC1DRU5UUkFMVVMiLCJqb2JMb2NhdGlvbiI6ImNlbnRyYWx1cyJ9?api-version=2014-04-01";); } + protected MockResponse response200WithHeader() { + return new MockResponse() + .setStatus("HTTP/1.1 200 O") + .addHeader("Location", "https://management.azure.com/subscriptions/SUBSCRIPTIONID/operationresults/eyJqb2JJZCI6IlJFU09VUkNFR1JPVVBERUxFVElPTkpPQi1SVEVTVC1DRU5UUkFMVVMiLCJqb2JMb2NhdGlvbiI6ImNlbnRyYWx1cyJ9?api-version=2014-04-01";); + } + protected String stringFromResource(String resourceName) { try { - return Resources.toString(getClass().getResource(resourceName), Charsets.UTF_8).replace(DEFAULT_ENDPOINT, - url("")); + String rsrc = Resources.toString(getClass().getResource(resourceName), Charsets.UTF_8); + if (rsrc.contains(DEFAULT_ENDPOINT)) { + rsrc = rsrc.replace(DEFAULT_ENDPOINT, url("")); + } + return rsrc; } catch (IOException e) { throw Throwables.propagate(e); } http://git-wip-us.apache.org/repos/asf/jclouds-labs/blob/fa63f6b1/azurecompute-arm/src/test/resources/getvault.json ---------------------------------------------------------------------- diff --git a/azurecompute-arm/src/test/resources/getvault.json b/azurecompute-arm/src/test/resources/getvault.json new file mode 100644 index 0000000..53bee7d --- /dev/null +++ b/azurecompute-arm/src/test/resources/getvault.json @@ -0,0 +1,60 @@ +{ + "id": "/subscriptions/012e832d-7b27-4c30-9f21-22cdd9159d12/resourceGroups/rg-vaultapilivetest-andrea/providers/Microsoft.KeyVault/vaults/vaultapilivetest-andrea", + "name": "vaultapilivetest-andrea", + "type": "Microsoft.KeyVault/vaults", + "location": "westeurope", + "tags": {}, + "properties": { + "sku": { + "family": "A", + "name": "Standard" + }, + "tenantId": "ba85e8cd-8c83-486e-a7e3-0d7666169d34", + "accessPolicies": [ + { + "tenantId": "ba85e8cd-8c83-486e-a7e3-0d7666169d34", + "objectId": "b025a8c0-d7fa-42fd-8e62-d988a3f12791", + "permissions": { + "keys": [ + "Get", + "List", + "Update", + "Create", + "Import", + "Delete", + "Recover", + "Backup", + "Restore" + ], + "secrets": [ + "Get", + "List", + "Set", + "Delete", + "Recover", + "Backup", + "Restore" + ], + "certificates": [ + "Get", + "List", + "Update", + "Create", + "Import", + "Delete", + "ManageContacts", + "ManageIssuers", + "GetIssuers", + "ListIssuers", + "SetIssuers", + "DeleteIssuers" + ] + } + } + ], + "enabledForDeployment": false, + "enabledForDiskEncryption": false, + "enabledForTemplateDeployment": false, + "vaultUri": "https://vaultapilivetest-andrea.vault.azure.net/"; + } +}
