@Test(groups = "slow")
  public void testAccountPaymentsWithRefund() throws Exception {
    final Account accountJson = createAccountWithPMBundleAndSubscriptionAndWaitForFirstInvoice();

    // Verify payments
    final InvoicePayments objFromJson =
        killBillClient.getInvoicePaymentsForAccount(accountJson.getAccountId());
    Assert.assertEquals(objFromJson.size(), 1);
  }
  @Test(groups = "slow", description = "Verify no PII data is required")
  public void testEmptyAccount() throws Exception {
    final Account emptyAccount = new Account();

    final Account account = killBillClient.createAccount(emptyAccount, createdBy, reason, comment);
    Assert.assertNotNull(account.getExternalKey());
    Assert.assertNull(account.getName());
    Assert.assertNull(account.getEmail());
  }
  @Test(groups = "slow", description = "Can retrieve the account balance")
  public void testAccountWithBalance() throws Exception {
    final Account accountJson = createAccountNoPMBundleAndSubscriptionAndWaitForFirstInvoice();

    final Account accountWithBalance =
        killBillClient.getAccount(accountJson.getAccountId(), true, false);
    final BigDecimal accountBalance = accountWithBalance.getAccountBalance();
    Assert.assertTrue(accountBalance.compareTo(BigDecimal.ZERO) > 0);
  }
  @Test(groups = "slow", description = "Add custom fields to account")
  public void testCustomFields() throws Exception {
    final Account accountJson = createAccount();
    assertNotNull(accountJson);

    final Collection<CustomField> customFields = new LinkedList<CustomField>();
    customFields.add(
        new CustomField(null, accountJson.getAccountId(), ObjectType.ACCOUNT, "1", "value1", null));
    customFields.add(
        new CustomField(null, accountJson.getAccountId(), ObjectType.ACCOUNT, "2", "value2", null));
    customFields.add(
        new CustomField(null, accountJson.getAccountId(), ObjectType.ACCOUNT, "3", "value3", null));

    killBillClient.createAccountCustomFields(
        accountJson.getAccountId(), customFields, createdBy, reason, comment);

    final List<CustomField> accountCustomFields =
        killBillClient.getAccountCustomFields(accountJson.getAccountId());
    assertEquals(accountCustomFields.size(), 3);

    // Delete all custom fields for account
    killBillClient.deleteAccountCustomFields(
        accountJson.getAccountId(), createdBy, reason, comment);

    final List<CustomField> remainingCustomFields =
        killBillClient.getAccountCustomFields(accountJson.getAccountId());
    assertEquals(remainingCustomFields.size(), 0);
  }
  @Test(groups = "slow", description = "Add tags to account")
  public void testTags() throws Exception {
    final Account input = createAccount();
    // Use tag definition for AUTO_PAY_OFF
    final UUID autoPayOffId = new UUID(0, 1);

    // Add a tag
    killBillClient.createAccountTag(input.getAccountId(), autoPayOffId, createdBy, reason, comment);

    // Retrieves all tags
    final List<Tag> tags1 = killBillClient.getAccountTags(input.getAccountId(), AuditLevel.FULL);
    Assert.assertEquals(tags1.size(), 1);
    Assert.assertEquals(tags1.get(0).getTagDefinitionId(), autoPayOffId);

    // Verify adding the same tag a second time doesn't do anything
    killBillClient.createAccountTag(input.getAccountId(), autoPayOffId, createdBy, reason, comment);

    // Retrieves all tags again
    killBillClient.createAccountTag(input.getAccountId(), autoPayOffId, createdBy, reason, comment);
    final List<Tag> tags2 = killBillClient.getAccountTags(input.getAccountId(), AuditLevel.FULL);
    Assert.assertEquals(tags2, tags1);

    // Verify audit logs
    Assert.assertEquals(tags2.get(0).getAuditLogs().size(), 1);
    final AuditLog auditLogJson = tags2.get(0).getAuditLogs().get(0);
    Assert.assertEquals(auditLogJson.getChangeType(), "INSERT");
    Assert.assertEquals(auditLogJson.getChangedBy(), createdBy);
    Assert.assertEquals(auditLogJson.getReasonCode(), reason);
    Assert.assertEquals(auditLogJson.getComments(), comment);
    Assert.assertNotNull(auditLogJson.getChangeDate());
    Assert.assertNotNull(auditLogJson.getUserToken());
  }
  @Test(groups = "slow", description = "Verify external key is unique")
  public void testUniqueExternalKey() throws Exception {
    // Verify the external key is not mandatory
    final Account inputWithNoExternalKey =
        getAccount(UUID.randomUUID().toString(), null, UUID.randomUUID().toString());
    Assert.assertNull(inputWithNoExternalKey.getExternalKey());

    final Account account =
        killBillClient.createAccount(inputWithNoExternalKey, createdBy, reason, comment);
    Assert.assertNotNull(account.getExternalKey());

    final Account inputWithSameExternalKey =
        getAccount(
            UUID.randomUUID().toString(), account.getExternalKey(), UUID.randomUUID().toString());
    try {
      killBillClient.createAccount(inputWithSameExternalKey, createdBy, reason, comment);
      Assert.fail();
    } catch (final KillBillClientException e) {
      Assert.assertEquals(
          e.getBillingException().getCode(), (Integer) ErrorCode.ACCOUNT_ALREADY_EXISTS.getCode());
    }
  }
  @Test(groups = "slow", description = "refresh payment methods")
  public void testRefreshPaymentMethods() throws Exception {
    Account account = createAccountWithDefaultPaymentMethod("someExternalKey");

    final PaymentMethods paymentMethodsBeforeRefreshing =
        killBillClient.getPaymentMethodsForAccount(account.getAccountId());
    assertEquals(paymentMethodsBeforeRefreshing.size(), 1);
    assertEquals(paymentMethodsBeforeRefreshing.get(0).getExternalKey(), "someExternalKey");

    // WITH NAME OF AN EXISTING PLUGIN
    killBillClient.refreshPaymentMethods(
        account.getAccountId(),
        PLUGIN_NAME,
        ImmutableMap.<String, String>of(),
        createdBy,
        reason,
        comment);

    final PaymentMethods paymentMethodsAfterExistingPluginCall =
        killBillClient.getPaymentMethodsForAccount(account.getAccountId());

    assertEquals(paymentMethodsAfterExistingPluginCall.size(), 1);
    assertEquals(paymentMethodsAfterExistingPluginCall.get(0).getExternalKey(), "someExternalKey");

    // WITHOUT PLUGIN NAME
    killBillClient.refreshPaymentMethods(
        account.getAccountId(), ImmutableMap.<String, String>of(), createdBy, reason, comment);

    final PaymentMethods paymentMethodsAfterNoPluginNameCall =
        killBillClient.getPaymentMethodsForAccount(account.getAccountId());
    assertEquals(paymentMethodsAfterNoPluginNameCall.size(), 1);
    assertEquals(paymentMethodsAfterNoPluginNameCall.get(0).getExternalKey(), "someExternalKey");

    // WITH WRONG PLUGIN NAME
    try {
      killBillClient.refreshPaymentMethods(
          account.getAccountId(),
          "GreatestPluginEver",
          ImmutableMap.<String, String>of(),
          createdBy,
          reason,
          comment);
      Assert.fail();
    } catch (KillBillClientException e) {
      Assert.assertEquals(
          e.getBillingException().getCode(),
          (Integer) ErrorCode.PAYMENT_NO_SUCH_PAYMENT_PLUGIN.getCode());
    }
  }
  @Test(groups = "slow", description = "Can create, retrieve, search and update accounts")
  public void testAccountOk() throws Exception {
    final Account input = createAccount();

    // Retrieves by external key
    final Account retrievedAccount = killBillClient.getAccount(input.getExternalKey());
    Assert.assertTrue(retrievedAccount.equals(input));

    // Try search endpoint
    searchAccount(input, retrievedAccount);

    // Update Account
    final Account newInput =
        new Account(
            input.getAccountId(),
            "zozo",
            4,
            input.getExternalKey(),
            "*****@*****.**",
            18,
            "USD",
            null,
            "UTC",
            "bl1",
            "bh2",
            "",
            "",
            "ca",
            "San Francisco",
            "usa",
            "en",
            "415-255-2991",
            false,
            false,
            null,
            null);
    final Account updatedAccount =
        killBillClient.updateAccount(newInput, createdBy, reason, comment);
    Assert.assertTrue(updatedAccount.equals(newInput));

    // Try search endpoint
    searchAccount(input, null);
  }
  private void searchAccount(final Account input, @Nullable final Account output) throws Exception {
    // Search by id
    if (output != null) {
      doSearchAccount(input.getAccountId().toString(), output);
    }

    // Search by name
    doSearchAccount(input.getName(), output);

    // Search by email
    doSearchAccount(input.getEmail(), output);

    // Search by company name
    doSearchAccount(input.getCompany(), output);

    // Search by external key.
    // Note: we will always find a match since we don't update it
    final List<Account> accountsByExternalKey =
        killBillClient.searchAccounts(input.getExternalKey());
    Assert.assertEquals(accountsByExternalKey.size(), 1);
    Assert.assertEquals(accountsByExternalKey.get(0).getAccountId(), input.getAccountId());
    Assert.assertEquals(accountsByExternalKey.get(0).getExternalKey(), input.getExternalKey());
  }
示例#10
0
  @Test(groups = "slow")
  public void testFailedPaymentWithPerTenantRetryConfig() throws Exception {
    // Create the tenant
    final String apiKeyTenant1 = "tenantSuperTuned";
    final String apiSecretTenant1 = "2367$$ffr79";
    loginTenant(apiKeyTenant1, apiSecretTenant1);
    final Tenant tenant1 = new Tenant();
    tenant1.setApiKey(apiKeyTenant1);
    tenant1.setApiSecret(apiSecretTenant1);
    killBillClient.createTenant(tenant1, createdBy, reason, comment);

    // Configure our plugin to fail
    mockPaymentProviderPlugin.makeAllInvoicesFailWithError(true);

    // Upload the config
    final ObjectMapper mapper = new ObjectMapper();
    final HashMap<String, String> perTenantProperties = new HashMap<String, String>();
    perTenantProperties.put("org.killbill.payment.retry.days", "1,1,1");
    final String perTenantConfig = mapper.writeValueAsString(perTenantProperties);

    final TenantKey tenantKey =
        killBillClient.postConfigurationPropertiesForTenant(perTenantConfig, basicRequestOptions());

    final Account accountJson = createAccountWithPMBundleAndSubscriptionAndWaitForFirstInvoice();

    final Payments payments = killBillClient.getPaymentsForAccount(accountJson.getAccountId());
    Assert.assertEquals(payments.size(), 1);
    Assert.assertEquals(payments.get(0).getTransactions().size(), 1);

    //
    // Because we have specified a retry interval of one day we should see the new attempt after
    // moving clock 1 day (and not 8 days which is default)
    //

    //
    // Now unregister special per tenant config and we the first retry occurs one day after (and
    // still fails), it now sets a retry date of 8 days
    //
    killBillClient.unregisterConfigurationForTenant(basicRequestOptions());
    // org.killbill.tenant.broadcast.rate has been set to 1s
    crappyWaitForLackOfProperSynchonization(2000);

    clock.addDays(1);

    Awaitility.await()
        .atMost(4, TimeUnit.SECONDS)
        .pollInterval(Duration.ONE_SECOND)
        .until(
            new Callable<Boolean>() {
              @Override
              public Boolean call() throws Exception {

                return killBillClient
                        .getPaymentsForAccount(accountJson.getAccountId())
                        .get(0)
                        .getTransactions()
                        .size()
                    == 2;
              }
            });
    final Payments payments2 = killBillClient.getPaymentsForAccount(accountJson.getAccountId());
    Assert.assertEquals(payments2.size(), 1);
    Assert.assertEquals(payments2.get(0).getTransactions().size(), 2);
    Assert.assertEquals(
        payments2.get(0).getTransactions().get(0).getStatus(),
        TransactionStatus.PAYMENT_FAILURE.name());
    Assert.assertEquals(
        payments2.get(0).getTransactions().get(1).getStatus(),
        TransactionStatus.PAYMENT_FAILURE.name());

    clock.addDays(1);
    crappyWaitForLackOfProperSynchonization(3000);

    // No retry with default config
    final Payments payments3 = killBillClient.getPaymentsForAccount(accountJson.getAccountId());
    Assert.assertEquals(payments3.size(), 1);
    Assert.assertEquals(payments3.get(0).getTransactions().size(), 2);

    mockPaymentProviderPlugin.makeAllInvoicesFailWithError(false);
    clock.addDays(7);

    Awaitility.await()
        .atMost(4, TimeUnit.SECONDS)
        .pollInterval(Duration.ONE_SECOND)
        .until(
            new Callable<Boolean>() {
              @Override
              public Boolean call() throws Exception {
                return killBillClient
                        .getPaymentsForAccount(accountJson.getAccountId())
                        .get(0)
                        .getTransactions()
                        .size()
                    == 3;
              }
            });
    final Payments payments4 = killBillClient.getPaymentsForAccount(accountJson.getAccountId());
    Assert.assertEquals(payments4.size(), 1);
    Assert.assertEquals(payments4.get(0).getTransactions().size(), 3);
    Assert.assertEquals(
        payments4.get(0).getTransactions().get(0).getStatus(),
        TransactionStatus.PAYMENT_FAILURE.name());
    Assert.assertEquals(
        payments4.get(0).getTransactions().get(1).getStatus(),
        TransactionStatus.PAYMENT_FAILURE.name());
    Assert.assertEquals(
        payments4.get(0).getTransactions().get(2).getStatus(), TransactionStatus.SUCCESS.name());
  }
  @Test(groups = "slow", description = "Can CRUD payment methods")
  public void testAccountPaymentMethods() throws Exception {
    final Account accountJson = createAccount();
    assertNotNull(accountJson);

    final PaymentMethodPluginDetail info = new PaymentMethodPluginDetail();
    info.setProperties(getPaymentMethodCCProperties());
    PaymentMethod paymentMethodJson =
        new PaymentMethod(
            null,
            UUID.randomUUID().toString(),
            accountJson.getAccountId(),
            true,
            PLUGIN_NAME,
            info);
    final PaymentMethod paymentMethodCC =
        killBillClient.createPaymentMethod(paymentMethodJson, createdBy, reason, comment);
    assertTrue(paymentMethodCC.getIsDefault());

    //
    // Add another payment method
    //
    final PaymentMethodPluginDetail info2 = new PaymentMethodPluginDetail();
    info2.setProperties(getPaymentMethodPaypalProperties());
    paymentMethodJson =
        new PaymentMethod(
            null,
            UUID.randomUUID().toString(),
            accountJson.getAccountId(),
            false,
            PLUGIN_NAME,
            info2);
    final PaymentMethod paymentMethodPP =
        killBillClient.createPaymentMethod(paymentMethodJson, createdBy, reason, comment);
    assertFalse(paymentMethodPP.getIsDefault());

    //
    // FETCH ALL PAYMENT METHODS
    //
    List<PaymentMethod> paymentMethods =
        killBillClient.getPaymentMethodsForAccount(accountJson.getAccountId());
    assertEquals(paymentMethods.size(), 2);

    //
    // CHANGE DEFAULT
    //
    assertTrue(
        killBillClient.getPaymentMethod(paymentMethodCC.getPaymentMethodId()).getIsDefault());
    assertFalse(
        killBillClient.getPaymentMethod(paymentMethodPP.getPaymentMethodId()).getIsDefault());
    killBillClient.updateDefaultPaymentMethod(
        accountJson.getAccountId(),
        paymentMethodPP.getPaymentMethodId(),
        createdBy,
        reason,
        comment);
    assertTrue(
        killBillClient.getPaymentMethod(paymentMethodPP.getPaymentMethodId()).getIsDefault());
    assertFalse(
        killBillClient.getPaymentMethod(paymentMethodCC.getPaymentMethodId()).getIsDefault());

    //
    // DELETE NON DEFAULT PM
    //
    killBillClient.deletePaymentMethod(
        paymentMethodCC.getPaymentMethodId(), false, createdBy, reason, comment);

    //
    // FETCH ALL PAYMENT METHODS
    //
    paymentMethods = killBillClient.getPaymentMethodsForAccount(accountJson.getAccountId());
    assertEquals(paymentMethods.size(), 1);

    //
    // DELETE DEFAULT PAYMENT METHOD (without special flag first)
    //
    try {
      killBillClient.deletePaymentMethod(
          paymentMethodPP.getPaymentMethodId(), false, createdBy, reason, comment);
      fail();
    } catch (final KillBillClientException e) {
    }

    //
    // RETRY TO DELETE DEFAULT PAYMENT METHOD (with special flag this time)
    //
    killBillClient.deletePaymentMethod(
        paymentMethodPP.getPaymentMethodId(), true, createdBy, reason, comment);

    // CHECK ACCOUNT IS NOW AUTO_PAY_OFF
    final List<Tag> tagsJson = killBillClient.getAccountTags(accountJson.getAccountId());
    Assert.assertEquals(tagsJson.size(), 1);
    final Tag tagJson = tagsJson.get(0);
    Assert.assertEquals(tagJson.getTagDefinitionName(), "AUTO_PAY_OFF");
    Assert.assertEquals(tagJson.getTagDefinitionId(), new UUID(0, 1));

    // FETCH ACCOUNT AGAIN AND CHECK THERE IS NO DEFAULT PAYMENT METHOD SET
    final Account updatedAccount = killBillClient.getAccount(accountJson.getAccountId());
    Assert.assertEquals(updatedAccount.getAccountId(), accountJson.getAccountId());
    Assert.assertNull(updatedAccount.getPaymentMethodId());

    //
    // FINALLY TRY TO REMOVE AUTO_PAY_OFF WITH NO DEFAULT PAYMENT METHOD ON ACCOUNT
    //
    try {
      killBillClient.deleteAccountTag(
          accountJson.getAccountId(), new UUID(0, 1), createdBy, reason, comment);
    } catch (final KillBillClientException e) {
    }
  }