diff --git a/tests/src/test/java/com/maxio/advancedbilling/controllers/subscriptiongroups/SubscriptionGroupsControllerCreateTest.java b/tests/src/test/java/com/maxio/advancedbilling/controllers/subscriptiongroups/SubscriptionGroupsControllerCreateTest.java new file mode 100644 index 00000000..5c4b2b53 --- /dev/null +++ b/tests/src/test/java/com/maxio/advancedbilling/controllers/subscriptiongroups/SubscriptionGroupsControllerCreateTest.java @@ -0,0 +1,158 @@ +package com.maxio.advancedbilling.controllers.subscriptiongroups; + +import com.maxio.advancedbilling.AdvancedBillingClient; +import com.maxio.advancedbilling.TestClient; +import com.maxio.advancedbilling.controllers.SubscriptionGroupsController; +import com.maxio.advancedbilling.exceptions.ApiException; +import com.maxio.advancedbilling.exceptions.SubscriptionGroupCreateErrorResponseException; +import com.maxio.advancedbilling.models.CreateSubscriptionGroup; +import com.maxio.advancedbilling.models.CreateSubscriptionGroupRequest; +import com.maxio.advancedbilling.models.Customer; +import com.maxio.advancedbilling.models.Product; +import com.maxio.advancedbilling.models.Subscription; +import com.maxio.advancedbilling.models.SubscriptionGroup; +import com.maxio.advancedbilling.models.SubscriptionGroupMembersArrayError; +import com.maxio.advancedbilling.models.SubscriptionGroupResponse; +import com.maxio.advancedbilling.models.SubscriptionGroupSingleError; +import com.maxio.advancedbilling.utils.TestSetup; +import com.maxio.advancedbilling.utils.TestTeardown; +import com.maxio.advancedbilling.utils.matchers.SubscriptionGroupCreateErrorResponseErrorsGetter; +import org.assertj.core.api.ThrowingConsumer; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; + +import java.io.IOException; +import java.util.List; +import java.util.stream.Stream; + +import static com.maxio.advancedbilling.models.CollectionMethod.AUTOMATIC; +import static com.maxio.advancedbilling.utils.assertions.CommonAssertions.assertUnauthorized; +import static com.maxio.advancedbilling.utils.assertions.CommonAssertions.assertUnprocessableEntity; +import static org.assertj.core.api.Assertions.assertThat; + +public class SubscriptionGroupsControllerCreateTest { + + private static final TestSetup TEST_SETUP = new TestSetup(); + private static final AdvancedBillingClient CLIENT = TestClient.createClient(); + private static final SubscriptionGroupsController SUBSCRIPTION_GROUPS_CONTROLLER = + CLIENT.getSubscriptionGroupsController(); + private static SubscriptionGroupResponse createSubscriptionGroupResponse; + private static Integer primarySubscriptionId; + private static Customer customer; + private static Product product; + private static Subscription otherSubscription; + + + @BeforeAll + static void setUp() throws IOException, ApiException { + customer = TEST_SETUP.createCustomer(); + product = TEST_SETUP.createProduct(TEST_SETUP.createProductFamily()); + otherSubscription = TEST_SETUP.createSubscription(customer, product); + } + + + @AfterAll + static void teardown() throws IOException, ApiException { + if (createSubscriptionGroupResponse != null && primarySubscriptionId != null) { + new TestTeardown().deleteSubscriptionGroup(primarySubscriptionId, + createSubscriptionGroupResponse.getSubscriptionGroup().getSubscriptionIds(), + customer.getId()); + createSubscriptionGroupResponse = null; + primarySubscriptionId = null; + } + } + + @Test + void shouldCreateSubscriptionGroup() throws IOException, ApiException { + // given + Customer customer = TEST_SETUP.createCustomer(); + Subscription subscription1 = TEST_SETUP.createSubscription(customer, product); + Subscription subscription2 = TEST_SETUP.createSubscription(customer, product); + + // when + createSubscriptionGroupResponse = SUBSCRIPTION_GROUPS_CONTROLLER + .createSubscriptionGroup(new CreateSubscriptionGroupRequest(new CreateSubscriptionGroup.Builder() + .subscriptionId(subscription1.getId()) + .memberIds(List.of(subscription2.getId())) + .build() + )); + primarySubscriptionId = subscription1.getId(); + + // then + SubscriptionGroup subscriptionGroup = createSubscriptionGroupResponse.getSubscriptionGroup(); + assertThat(subscriptionGroup.getAdditionalProperties()).isEmpty(); + assertThat(subscriptionGroup.getCustomerId()).isEqualTo(customer.getId()); + assertThat(subscriptionGroup.getCreatedAt()).isNotNull(); + assertThat(subscriptionGroup.getPaymentCollectionMethod()).isEqualTo(AUTOMATIC); + assertThat(subscriptionGroup.getSubscriptionIds()).containsOnly(subscription1.getId(), subscription2.getId()); + + assertThat(subscriptionGroup.getPaymentProfile().getAdditionalProperties()).isEmpty(); + assertThat(subscriptionGroup.getPaymentProfile().getFirstName()).isEqualTo(customer.getFirstName()); + assertThat(subscriptionGroup.getPaymentProfile().getLastName()).isEqualTo(customer.getLastName()); + assertThat(subscriptionGroup.getPaymentProfile().getMaskedCardNumber()).isEqualTo("XXXX-XXXX-XXXX-1111"); + assertThat(subscriptionGroup.getPaymentProfile().getId()).isNotNull(); + } + + @ParameterizedTest + @MethodSource("argsForShouldReturn422WhenCreatingGroupWithInvalidData") + void shouldReturn422WhenCreatingGroupWithInvalidData(CreateSubscriptionGroupRequest request, + ThrowingConsumer + assertionsConsumer) { + assertUnprocessableEntity( + SubscriptionGroupCreateErrorResponseException.class, + () -> SUBSCRIPTION_GROUPS_CONTROLLER.createSubscriptionGroup(request), + assertionsConsumer::accept + ); + } + + private static Stream argsForShouldReturn422WhenCreatingGroupWithInvalidData() { + return Stream.of( + Arguments.of( + new CreateSubscriptionGroupRequest( + null + ), + (ThrowingConsumer) error -> + assertThat(error.getErrors() + .match(new SubscriptionGroupCreateErrorResponseErrorsGetter()) + .getSubscriptionGroup()) + .isEqualTo("can't be blank") + ), + Arguments.of( + new CreateSubscriptionGroupRequest( + new CreateSubscriptionGroup.Builder() + .subscriptionId(otherSubscription.getId()) + .memberIds(List.of(123)) + .build() + ), + (ThrowingConsumer) error -> + assertThat(error.getErrors() + .match(new SubscriptionGroupCreateErrorResponseErrorsGetter()) + .getMembers()) + .containsOnly("not_found") + ), + Arguments.of( + new CreateSubscriptionGroupRequest( + new CreateSubscriptionGroup.Builder() + .subscriptionId((123)) + .memberIds(List.of()) + .build() + ), + (ThrowingConsumer) error -> + assertThat(error.getErrors() + .match(new SubscriptionGroupCreateErrorResponseErrorsGetter())) + .startsWith("Couldn't find Subscription with 'id'=123") + ) + ); + } + + @Test + void shouldNotCreateGroupWhenProvidingInvalidCredentials() { + assertUnauthorized(() -> TestClient.createInvalidCredentialsClient().getSubscriptionGroupsController() + .createSubscriptionGroup(null)); + } + +} diff --git a/tests/src/test/java/com/maxio/advancedbilling/controllers/subscriptiongroups/SubscriptionGroupsControllerListTest.java b/tests/src/test/java/com/maxio/advancedbilling/controllers/subscriptiongroups/SubscriptionGroupsControllerListTest.java new file mode 100644 index 00000000..b4ab3b34 --- /dev/null +++ b/tests/src/test/java/com/maxio/advancedbilling/controllers/subscriptiongroups/SubscriptionGroupsControllerListTest.java @@ -0,0 +1,218 @@ +package com.maxio.advancedbilling.controllers.subscriptiongroups; + +import com.maxio.advancedbilling.AdvancedBillingClient; +import com.maxio.advancedbilling.TestClient; +import com.maxio.advancedbilling.controllers.SubscriptionGroupsController; +import com.maxio.advancedbilling.exceptions.ApiException; +import com.maxio.advancedbilling.models.CreateSubscriptionGroup; +import com.maxio.advancedbilling.models.CreateSubscriptionGroupRequest; +import com.maxio.advancedbilling.models.Customer; +import com.maxio.advancedbilling.models.GroupType; +import com.maxio.advancedbilling.models.IssueServiceCredit; +import com.maxio.advancedbilling.models.IssueServiceCreditRequest; +import com.maxio.advancedbilling.models.ListSubscriptionGroupsInput; +import com.maxio.advancedbilling.models.ListSubscriptionGroupsItem; +import com.maxio.advancedbilling.models.ListSubscriptionGroupsResponse; +import com.maxio.advancedbilling.models.Product; +import com.maxio.advancedbilling.models.Subscription; +import com.maxio.advancedbilling.models.SubscriptionGroupPrepayment; +import com.maxio.advancedbilling.models.SubscriptionGroupPrepaymentMethod; +import com.maxio.advancedbilling.models.SubscriptionGroupPrepaymentRequest; +import com.maxio.advancedbilling.models.SubscriptionGroupResponse; +import com.maxio.advancedbilling.models.SubscriptionGroupsListInclude; +import com.maxio.advancedbilling.models.containers.IssueServiceCreditAmount; +import com.maxio.advancedbilling.utils.TestSetup; +import com.maxio.advancedbilling.utils.TestTeardown; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; + +import java.io.IOException; +import java.time.ZonedDateTime; +import java.util.Collections; +import java.util.List; + +import static com.maxio.advancedbilling.utils.assertions.CommonAssertions.assertUnauthorized; +import static org.assertj.core.api.Assertions.assertThat; + +public class SubscriptionGroupsControllerListTest { + + private static final TestSetup TEST_SETUP = new TestSetup(); + private static final AdvancedBillingClient CLIENT = TestClient.createClient(); + private static final SubscriptionGroupsController SUBSCRIPTION_GROUPS_CONTROLLER = + CLIENT.getSubscriptionGroupsController(); + private static SubscriptionGroupResponse createSubscriptionGroupResponse1; + private static Integer primarySubscriptionId1; + private static SubscriptionGroupResponse createSubscriptionGroupResponse2; + private static Integer primarySubscriptionId2; + private static Product product; + + @BeforeAll + static void setUp() throws IOException, ApiException { + new TestTeardown().deleteAllSubscriptionGroups(); + + Customer customer1 = TEST_SETUP.createCustomer(); + Customer customer2 = TEST_SETUP.createCustomer(); + product = TEST_SETUP.createProduct(TEST_SETUP.createProductFamily()); + + Subscription customer1Subscription1 = TEST_SETUP.createSubscription(customer1, product); + Subscription customer1Subscription2 = TEST_SETUP.createSubscription(customer1, product); + Subscription customer2Subscription1 = TEST_SETUP.createSubscription(customer2, product); + Subscription customer2Subscription2 = TEST_SETUP.createSubscription(customer2, product); + + createSubscriptionGroupResponse1 = SUBSCRIPTION_GROUPS_CONTROLLER + .createSubscriptionGroup(new CreateSubscriptionGroupRequest(new CreateSubscriptionGroup.Builder() + .subscriptionId(customer1Subscription1.getId()) + .memberIds(List.of(customer1Subscription2.getId())) + .build() + )); + primarySubscriptionId1 = customer1Subscription1.getId(); + + createSubscriptionGroupResponse2 = SUBSCRIPTION_GROUPS_CONTROLLER + .createSubscriptionGroup(new CreateSubscriptionGroupRequest(new CreateSubscriptionGroup.Builder() + .subscriptionId(customer2Subscription1.getId()) + .memberIds(List.of(customer2Subscription2.getId())) + .build() + )); + primarySubscriptionId2 = customer2Subscription1.getId(); + + // setup account balances + String groupUid = CLIENT.getSubscriptionsController().readSubscription(primarySubscriptionId1, null) + .getSubscription().getGroup().match(g -> g).getUid(); + CLIENT.getSubscriptionGroupInvoiceAccountController().issueSubscriptionGroupServiceCredit(groupUid, + new IssueServiceCreditRequest( + new IssueServiceCredit(IssueServiceCreditAmount.fromString("5"), "credit") + )); + CLIENT.getSubscriptionGroupInvoiceAccountController().createSubscriptionGroupPrepayment(groupUid, + new SubscriptionGroupPrepaymentRequest( + new SubscriptionGroupPrepayment(3, "details", "pay", SubscriptionGroupPrepaymentMethod.CHECK) + )); + } + + @AfterAll + static void teardown() throws IOException, ApiException { + if (createSubscriptionGroupResponse1 != null && primarySubscriptionId1 != null) { + new TestTeardown().deleteSubscriptionGroup(primarySubscriptionId1, + createSubscriptionGroupResponse1.getSubscriptionGroup().getSubscriptionIds(), + createSubscriptionGroupResponse1.getSubscriptionGroup().getCustomerId()); + createSubscriptionGroupResponse1 = null; + primarySubscriptionId1 = null; + } + if (createSubscriptionGroupResponse2 != null && primarySubscriptionId2 != null) { + new TestTeardown().deleteSubscriptionGroup(primarySubscriptionId2, + createSubscriptionGroupResponse2.getSubscriptionGroup().getSubscriptionIds(), + createSubscriptionGroupResponse2.getSubscriptionGroup().getCustomerId()); + createSubscriptionGroupResponse2 = null; + primarySubscriptionId2 = null; + } + } + + @Test + void shouldListSubscriptionGroups() throws IOException, ApiException { + // given - when + ListSubscriptionGroupsResponse listSubscriptionGroups = SUBSCRIPTION_GROUPS_CONTROLLER.listSubscriptionGroups( + new ListSubscriptionGroupsInput() + ); + + // then + assertThat(listSubscriptionGroups.getAdditionalProperties()).isEmpty(); + assertThat(listSubscriptionGroups.getMeta().getCurrentPage()).isEqualTo(1); + assertThat(listSubscriptionGroups.getMeta().getTotalCount()).isEqualTo(2); + + assertThat(listSubscriptionGroups.getSubscriptionGroups()).hasSize(2); + + ListSubscriptionGroupsItem group1 = listSubscriptionGroups.getSubscriptionGroups().get(0); + assertThat(group1.getAccountBalances()).isNull(); + assertThat(group1.getCancelAtEndOfPeriod()).isFalse(); + assertThat(group1.getCustomerId()).isEqualTo(createSubscriptionGroupResponse1.getSubscriptionGroup().getCustomerId()); + assertThat(group1.getNextAssessmentAt()).isAfter(ZonedDateTime.now()); + assertThat(group1.getPaymentProfileId()).isNotNull(); + assertThat(group1.getPrimarySubscriptionId()).isEqualTo(primarySubscriptionId1); + assertThat(group1.getScheme()).isEqualTo(1); + assertThat(group1.getState()).isEqualTo("active"); + assertThat(group1.getGroupType()).isEqualTo(GroupType.SINGLE_CUSTOMER); + assertThat(group1.getSubscriptionIds()) + .containsExactlyInAnyOrderElementsOf(createSubscriptionGroupResponse1.getSubscriptionGroup().getSubscriptionIds()); + assertThat(group1.getUid()).isNotNull(); + + ListSubscriptionGroupsItem group2 = listSubscriptionGroups.getSubscriptionGroups().get(1); + assertThat(group2.getAccountBalances()).isNull(); + assertThat(group2.getCancelAtEndOfPeriod()).isFalse(); + assertThat(group2.getCustomerId()).isEqualTo(createSubscriptionGroupResponse2.getSubscriptionGroup().getCustomerId()); + assertThat(group2.getNextAssessmentAt()).isAfter(ZonedDateTime.now()); + assertThat(group2.getPaymentProfileId()).isNotNull(); + assertThat(group2.getPrimarySubscriptionId()).isEqualTo(primarySubscriptionId2); + assertThat(group2.getScheme()).isEqualTo(1); + assertThat(group2.getState()).isEqualTo("active"); + assertThat(group2.getGroupType()).isEqualTo(GroupType.SINGLE_CUSTOMER); + assertThat(group2.getSubscriptionIds()) + .containsExactlyInAnyOrderElementsOf(createSubscriptionGroupResponse2.getSubscriptionGroup().getSubscriptionIds()); + assertThat(group2.getUid()).isNotNull(); + } + + @Test + void shouldListSubscriptionGroupsWithAccountBalances() throws IOException, ApiException { + // given - when + ListSubscriptionGroupsResponse listSubscriptionGroups = SUBSCRIPTION_GROUPS_CONTROLLER.listSubscriptionGroups( + new ListSubscriptionGroupsInput.Builder() + .include(Collections.singletonList(SubscriptionGroupsListInclude.ACCOUNT_BALANCES)) + .build() + ); + + // then + ListSubscriptionGroupsItem group1 = listSubscriptionGroups.getSubscriptionGroups().get(0); + ListSubscriptionGroupsItem group2 = listSubscriptionGroups.getSubscriptionGroups().get(1); + + assertThat(group1.getAccountBalances().getServiceCredits().getBalanceInCents()).isEqualTo(500); + assertThat(group1.getAccountBalances().getPrepayments().getBalanceInCents()).isEqualTo(300); + assertThat(group1.getAccountBalances().getPendingDiscounts().getBalanceInCents()).isEqualTo(0); + assertThat(group1.getAccountBalances().getOpenInvoices().getBalanceInCents()).isEqualTo(0); + + assertThat(group2.getAccountBalances().getServiceCredits().getBalanceInCents()).isEqualTo(0); + assertThat(group2.getAccountBalances().getPrepayments().getBalanceInCents()).isEqualTo(0); + assertThat(group2.getAccountBalances().getPendingDiscounts().getBalanceInCents()).isEqualTo(0); + assertThat(group2.getAccountBalances().getOpenInvoices().getBalanceInCents()).isEqualTo(0); + } + + @Test + void shouldListSubscriptionGroupsWithPaging() throws IOException, ApiException { + // given - when + ListSubscriptionGroupsResponse listSubscriptionGroups1 = SUBSCRIPTION_GROUPS_CONTROLLER.listSubscriptionGroups( + new ListSubscriptionGroupsInput.Builder() + .page(1) + .perPage(1) + .build() + ); + ListSubscriptionGroupsResponse listSubscriptionGroups2 = SUBSCRIPTION_GROUPS_CONTROLLER.listSubscriptionGroups( + new ListSubscriptionGroupsInput.Builder() + .page(2) + .perPage(1) + .build() + ); + ListSubscriptionGroupsResponse listSubscriptionGroups3 = SUBSCRIPTION_GROUPS_CONTROLLER.listSubscriptionGroups( + new ListSubscriptionGroupsInput.Builder() + .page(3) + .perPage(1) + .build() + ); + + // then + assertThat(listSubscriptionGroups1.getSubscriptionGroups()).hasSize(1); + assertThat(listSubscriptionGroups2.getSubscriptionGroups()).hasSize(1); + assertThat(listSubscriptionGroups3.getSubscriptionGroups()).isEmpty(); + + assertThat(listSubscriptionGroups1.getMeta().getCurrentPage()).isEqualTo(1); + assertThat(listSubscriptionGroups1.getMeta().getTotalCount()).isEqualTo(2); + assertThat(listSubscriptionGroups2.getMeta().getCurrentPage()).isEqualTo(2); + assertThat(listSubscriptionGroups2.getMeta().getTotalCount()).isEqualTo(2); + assertThat(listSubscriptionGroups3.getMeta().getCurrentPage()).isEqualTo(3); + assertThat(listSubscriptionGroups3.getMeta().getTotalCount()).isEqualTo(2); + } + + @Test + void shouldNotListGroupsWhenProvidingInvalidCredentials() { + assertUnauthorized(() -> TestClient.createInvalidCredentialsClient().getSubscriptionGroupsController() + .listSubscriptionGroups(new ListSubscriptionGroupsInput())); + } + +} diff --git a/tests/src/test/java/com/maxio/advancedbilling/controllers/subscriptiongroups/SubscriptionGroupsControllerReadTest.java b/tests/src/test/java/com/maxio/advancedbilling/controllers/subscriptiongroups/SubscriptionGroupsControllerReadTest.java new file mode 100644 index 00000000..da47092d --- /dev/null +++ b/tests/src/test/java/com/maxio/advancedbilling/controllers/subscriptiongroups/SubscriptionGroupsControllerReadTest.java @@ -0,0 +1,155 @@ +package com.maxio.advancedbilling.controllers.subscriptiongroups; + +import com.maxio.advancedbilling.AdvancedBillingClient; +import com.maxio.advancedbilling.TestClient; +import com.maxio.advancedbilling.controllers.SubscriptionGroupsController; +import com.maxio.advancedbilling.exceptions.ApiException; +import com.maxio.advancedbilling.models.Component; +import com.maxio.advancedbilling.models.CreateAllocation; +import com.maxio.advancedbilling.models.CreateAllocationRequest; +import com.maxio.advancedbilling.models.CreateSubscriptionGroup; +import com.maxio.advancedbilling.models.CreateSubscriptionGroupRequest; +import com.maxio.advancedbilling.models.Customer; +import com.maxio.advancedbilling.models.FullSubscriptionGroupResponse; +import com.maxio.advancedbilling.models.IssueServiceCredit; +import com.maxio.advancedbilling.models.IssueServiceCreditRequest; +import com.maxio.advancedbilling.models.Product; +import com.maxio.advancedbilling.models.Subscription; +import com.maxio.advancedbilling.models.SubscriptionGroupInclude; +import com.maxio.advancedbilling.models.SubscriptionGroupPrepayment; +import com.maxio.advancedbilling.models.SubscriptionGroupPrepaymentMethod; +import com.maxio.advancedbilling.models.SubscriptionGroupPrepaymentRequest; +import com.maxio.advancedbilling.models.SubscriptionGroupResponse; +import com.maxio.advancedbilling.models.SubscriptionState; +import com.maxio.advancedbilling.models.containers.IssueServiceCreditAmount; +import com.maxio.advancedbilling.utils.TestSetup; +import com.maxio.advancedbilling.utils.TestTeardown; +import com.maxio.advancedbilling.utils.assertions.CommonAssertions; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; + +import java.io.IOException; +import java.time.ZonedDateTime; +import java.util.Collections; +import java.util.List; + +import static com.maxio.advancedbilling.utils.assertions.CommonAssertions.assertUnauthorized; +import static org.assertj.core.api.Assertions.assertThat; + +public class SubscriptionGroupsControllerReadTest { + + private static final TestSetup TEST_SETUP = new TestSetup(); + private static final AdvancedBillingClient CLIENT = TestClient.createClient(); + private static final SubscriptionGroupsController SUBSCRIPTION_GROUPS_CONTROLLER = + CLIENT.getSubscriptionGroupsController(); + private static SubscriptionGroupResponse createSubscriptionGroupResponse; + private static Integer primarySubscriptionId; + private static Customer customer; + private static Product product; + + @BeforeAll + static void setUp() throws IOException, ApiException { + customer = TEST_SETUP.createCustomer(); + product = TEST_SETUP.createProduct(TEST_SETUP.createProductFamily()); + } + + @AfterAll + static void tearDown() throws IOException, ApiException { + if (createSubscriptionGroupResponse != null && primarySubscriptionId != null) { + new TestTeardown().deleteSubscriptionGroup(primarySubscriptionId, + createSubscriptionGroupResponse.getSubscriptionGroup().getSubscriptionIds(), + createSubscriptionGroupResponse.getSubscriptionGroup().getCustomerId()); + createSubscriptionGroupResponse = null; + primarySubscriptionId = null; + } + new TestTeardown().deleteCustomer(customer); + } + + @Test + void shouldReadSubscriptionGroup() throws IOException, ApiException { + // given + Customer customer = TEST_SETUP.createCustomer(); + Subscription subscription1 = TEST_SETUP.createSubscription(customer, product); + Subscription subscription2 = TEST_SETUP.createSubscription(customer, product); + Component component = TEST_SETUP.createQuantityBasedComponent(product.getProductFamily().getId()); + + // when + // create group + createSubscriptionGroupResponse = SUBSCRIPTION_GROUPS_CONTROLLER + .createSubscriptionGroup(new CreateSubscriptionGroupRequest(new CreateSubscriptionGroup.Builder() + .subscriptionId(subscription1.getId()) + .memberIds(List.of(subscription2.getId())) + .build() + )); + primarySubscriptionId = subscription1.getId(); + String groupUid = CLIENT.getSubscriptionsController().readSubscription(primarySubscriptionId, null) + .getSubscription().getGroup().match(g -> g).getUid(); + + // setup account balances + CLIENT.getSubscriptionGroupInvoiceAccountController().issueSubscriptionGroupServiceCredit(groupUid, + new IssueServiceCreditRequest( + new IssueServiceCredit(IssueServiceCreditAmount.fromString("5"), "credit") + )); + CLIENT.getSubscriptionGroupInvoiceAccountController().createSubscriptionGroupPrepayment(groupUid, + new SubscriptionGroupPrepaymentRequest( + new SubscriptionGroupPrepayment(3, "details", "pay", SubscriptionGroupPrepaymentMethod.CHECK) + )); + + // make some allocation to generate billing amount + CLIENT.getSubscriptionComponentsController().allocateComponent(subscription1.getId(), component.getId(), new CreateAllocationRequest( + new CreateAllocation.Builder() + .quantity(3) + .build() + )); + + // read group + FullSubscriptionGroupResponse subscriptionGroup = SUBSCRIPTION_GROUPS_CONTROLLER.readSubscriptionGroup(groupUid, null); + FullSubscriptionGroupResponse subscriptionGroupWithCurrentBalance = SUBSCRIPTION_GROUPS_CONTROLLER + .readSubscriptionGroup(groupUid, Collections.singletonList(SubscriptionGroupInclude.CURRENT_BILLING_AMOUNT_IN_CENTS)); + + // then + assertThat(subscriptionGroup.getAdditionalProperties()).isEmpty(); + + assertThat(subscriptionGroup.getAccountBalances().getOpenInvoices().getBalanceInCents()).isEqualTo(0); + assertThat(subscriptionGroup.getAccountBalances().getPrepayments().getBalanceInCents()).isEqualTo(300); + assertThat(subscriptionGroup.getAccountBalances().getPendingDiscounts().getBalanceInCents()).isEqualTo(0); + assertThat(subscriptionGroup.getAccountBalances().getServiceCredits().getBalanceInCents()).isEqualTo(500); + + assertThat(subscriptionGroup.getCancelAtEndOfPeriod()).isFalse(); + assertThat(subscriptionGroup.getCurrentBillingAmountInCents()).isNull(); + + assertThat(subscriptionGroup.getCustomerId()).isEqualTo(customer.getId()); + assertThat(subscriptionGroup.getCustomer().getFirstName()).isEqualTo(customer.getFirstName()); + assertThat(subscriptionGroup.getCustomer().getLastName()).isEqualTo(customer.getLastName()); + assertThat(subscriptionGroup.getCustomer().getOrganization()).isEqualTo(customer.getOrganization()); + assertThat(subscriptionGroup.getCustomer().getReference()).isEqualTo(customer.getReference()); + + assertThat(subscriptionGroup.getNextAssessmentAt()).isAfter(ZonedDateTime.now()); + assertThat(subscriptionGroup.getPaymentProfileId()).isNotNull(); + assertThat(subscriptionGroup.getPrimarySubscriptionId()).isEqualTo(primarySubscriptionId); + assertThat(subscriptionGroup.getScheme()).isEqualTo(1); + assertThat(subscriptionGroup.getState()).isEqualTo(SubscriptionState.ACTIVE); + assertThat(subscriptionGroup.getSubscriptionIds()).containsOnly(primarySubscriptionId, subscription2.getId()); + assertThat(subscriptionGroup.getUid()).isEqualTo(groupUid); + + assertThat(subscriptionGroupWithCurrentBalance).usingRecursiveComparison().ignoringFields("currentBillingAmountInCents") + .isEqualTo(subscriptionGroup); + assertThat(subscriptionGroupWithCurrentBalance.getCurrentBillingAmountInCents()).isEqualTo(300); + } + + @Test + void shouldNotReadGroupWhenProvidingInvalidCredentials() { + assertUnauthorized(() -> TestClient.createInvalidCredentialsClient().getSubscriptionGroupsController() + .readSubscriptionGroup("abc", null)); + } + + @Test + void shouldReturn404ForNotExistentSubscriptionGroup() { + // when - then + CommonAssertions.assertNotFound( + () -> SUBSCRIPTION_GROUPS_CONTROLLER.readSubscriptionGroup("123", null) + ); + } + +} diff --git a/tests/src/test/java/com/maxio/advancedbilling/controllers/subscriptiongroups/SubscriptionGroupsControllerSignupTest.java b/tests/src/test/java/com/maxio/advancedbilling/controllers/subscriptiongroups/SubscriptionGroupsControllerSignupTest.java new file mode 100644 index 00000000..dfe374dd --- /dev/null +++ b/tests/src/test/java/com/maxio/advancedbilling/controllers/subscriptiongroups/SubscriptionGroupsControllerSignupTest.java @@ -0,0 +1,403 @@ +package com.maxio.advancedbilling.controllers.subscriptiongroups; + +import com.maxio.advancedbilling.AdvancedBillingClient; +import com.maxio.advancedbilling.TestClient; +import com.maxio.advancedbilling.controllers.SubscriptionGroupsController; +import com.maxio.advancedbilling.exceptions.ApiException; +import com.maxio.advancedbilling.exceptions.SubscriptionGroupSignupErrorResponseException; +import com.maxio.advancedbilling.models.BankAccountHolderType; +import com.maxio.advancedbilling.models.BankAccountType; +import com.maxio.advancedbilling.models.CollectionMethod; +import com.maxio.advancedbilling.models.Component; +import com.maxio.advancedbilling.models.Coupon; +import com.maxio.advancedbilling.models.Customer; +import com.maxio.advancedbilling.models.NestedSubscriptionGroup; +import com.maxio.advancedbilling.models.PayerAttributes; +import com.maxio.advancedbilling.models.PaymentType; +import com.maxio.advancedbilling.models.Product; +import com.maxio.advancedbilling.models.ProductFamily; +import com.maxio.advancedbilling.models.SubscriptionGroupBankAccount; +import com.maxio.advancedbilling.models.SubscriptionGroupCreditCard; +import com.maxio.advancedbilling.models.SubscriptionGroupItem; +import com.maxio.advancedbilling.models.SubscriptionGroupSignup; +import com.maxio.advancedbilling.models.SubscriptionGroupSignupComponent; +import com.maxio.advancedbilling.models.SubscriptionGroupSignupItem; +import com.maxio.advancedbilling.models.SubscriptionGroupSignupRequest; +import com.maxio.advancedbilling.models.SubscriptionGroupSignupResponse; +import com.maxio.advancedbilling.models.SubscriptionGroupSubscriptionError; +import com.maxio.advancedbilling.models.containers.SubscriptionGroupCreditCardExpirationMonth; +import com.maxio.advancedbilling.models.containers.SubscriptionGroupCreditCardExpirationYear; +import com.maxio.advancedbilling.models.containers.SubscriptionGroupCreditCardFullNumber; +import com.maxio.advancedbilling.models.containers.SubscriptionGroupSignupComponentComponentId; +import com.maxio.advancedbilling.models.containers.SubscriptionGroupSignupComponentUnitBalance; +import com.maxio.advancedbilling.utils.TestSetup; +import com.maxio.advancedbilling.utils.TestTeardown; +import org.assertj.core.api.ThrowingConsumer; +import org.junit.jupiter.api.AfterAll; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeAll; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; + +import java.io.IOException; +import java.time.LocalDate; +import java.time.ZonedDateTime; +import java.util.List; +import java.util.Map; +import java.util.stream.Stream; + +import static com.maxio.advancedbilling.models.SubscriptionState.ACTIVE; +import static com.maxio.advancedbilling.utils.assertions.CommonAssertions.assertUnauthorized; +import static com.maxio.advancedbilling.utils.assertions.CommonAssertions.assertUnprocessableEntity; +import static org.apache.commons.lang3.RandomStringUtils.randomNumeric; +import static org.assertj.core.api.Assertions.assertThat; + +public class SubscriptionGroupsControllerSignupTest { + + private static final TestSetup TEST_SETUP = new TestSetup(); + private static final AdvancedBillingClient CLIENT = TestClient.createClient(); + private static final SubscriptionGroupsController SUBSCRIPTION_GROUPS_CONTROLLER = + CLIENT.getSubscriptionGroupsController(); + private static SubscriptionGroupSignupResponse groupSignup; + private static Customer customer; + private static Product product; + private static Product product2; + private static Component meteredComponent; + private static Coupon coupon; + + @BeforeAll + static void setUp() throws IOException, ApiException { + ProductFamily productFamily = TEST_SETUP.createProductFamily(); + product = TEST_SETUP.createProduct(productFamily, b -> b.priceInCents(1250)); + product2 = TEST_SETUP.createProduct(productFamily, b -> b.priceInCents(1000)); + + customer = TEST_SETUP.createCustomer(); + meteredComponent = TEST_SETUP.createMeteredComponent(productFamily, 11.5); + coupon = TEST_SETUP.createAmountCoupon(productFamily, 1250, true); + } + + @AfterEach + void cleanupSubscriptionGroup() throws IOException, ApiException { + if (groupSignup != null) { + new TestTeardown().deleteSubscriptionGroup(groupSignup); + groupSignup = null; + } + } + + @AfterAll + static void teardown() throws IOException, ApiException { + new TestTeardown().deleteCustomer(customer); + } + + @Test + void shouldSignupSubscriptionGroupUsingExistingCustomer() throws IOException, ApiException { + // given + Customer customer = TEST_SETUP.createCustomer(); + + // when + groupSignup = SUBSCRIPTION_GROUPS_CONTROLLER + .signupWithSubscriptionGroup(new SubscriptionGroupSignupRequest( + new SubscriptionGroupSignup.Builder() + .payerId(customer.getId()) + .creditCardAttributes(new SubscriptionGroupCreditCard.Builder() + .fullNumber(SubscriptionGroupCreditCardFullNumber.fromString("4111 1111 1111 1111")) + .expirationMonth(SubscriptionGroupCreditCardExpirationMonth.fromNumber(11)) + .expirationYear(SubscriptionGroupCreditCardExpirationYear.fromNumber(LocalDate.now().getYear() + 1)) + .billingAddress("1703 Edsel Road") + .billingCity("Los Angeles") + .billingState("CA") + .build()) + .subscriptions(List.of(new SubscriptionGroupSignupItem.Builder() + .productId(product.getId()) + .couponCodes(List.of(coupon.getCode())) + .primary(true) + .components(List.of(new SubscriptionGroupSignupComponent.Builder() + .componentId(SubscriptionGroupSignupComponentComponentId.fromNumber(meteredComponent.getId())) + .unitBalance(SubscriptionGroupSignupComponentUnitBalance.fromNumber(10)) + .build()) + ) + .build(), + new SubscriptionGroupSignupItem.Builder() + .productId(product2.getId()) + .components(List.of(new SubscriptionGroupSignupComponent.Builder() + .componentId(SubscriptionGroupSignupComponentComponentId.fromNumber(meteredComponent.getId())) + .unitBalance(SubscriptionGroupSignupComponentUnitBalance.fromNumber(20)) + .build()) + ) + .build() + )) + .build() + )); + + // then + assertThat(groupSignup.getCustomerId()).isEqualTo(customer.getId()); + assertSubscriptionGroup(); + } + + @Test + void shouldSignupSubscriptionGroupWithPayerAttributes() throws IOException, ApiException { + // given - when + String reference = "ref-" + randomNumeric(5); + groupSignup = SUBSCRIPTION_GROUPS_CONTROLLER + .signupWithSubscriptionGroup(new SubscriptionGroupSignupRequest( + new SubscriptionGroupSignup.Builder() + .payerAttributes(new PayerAttributes.Builder() + .firstName("John") + .lastName("Doe") + .city("New York") + .state("NY") + .country("US") + .address("Broadway") + .zip("78015") + .address2("1703 Edsel Road") + .email("payerdoe@chargify.com") + .ccEmails("washington@example.com") + .reference(reference) + .organization("Acme, Inc") + .phone("555-111-222") + .locale("es-MX") + .vatNumber("123") + .taxExempt(true) + .taxExemptReason("N") + .build()) + .bankAccountAttributes(new SubscriptionGroupBankAccount.Builder() + .bankName("Best Bank") + .bankRoutingNumber("021000089") + .bankAccountNumber("111111111111") + .bankAccountType(BankAccountType.CHECKING) + .bankAccountHolderType(BankAccountHolderType.BUSINESS) + .paymentType(PaymentType.BANK_ACCOUNT) + .build() + ) + .subscriptions(List.of(new SubscriptionGroupSignupItem.Builder() + .productId(product.getId()) + .couponCodes(List.of(coupon.getCode())) + .primary(true) + .components(List.of(new SubscriptionGroupSignupComponent.Builder() + .componentId(SubscriptionGroupSignupComponentComponentId.fromNumber(meteredComponent.getId())) + .unitBalance(SubscriptionGroupSignupComponentUnitBalance.fromNumber(10)) + .build()) + ) + .build(), + new SubscriptionGroupSignupItem.Builder() + .productId(product2.getId()) + .components(List.of(new SubscriptionGroupSignupComponent.Builder() + .componentId(SubscriptionGroupSignupComponentComponentId.fromNumber(meteredComponent.getId())) + .unitBalance(SubscriptionGroupSignupComponentUnitBalance.fromNumber(20)) + .build()) + ) + .build() + )) + .build() + )); + Customer createdCustomer = CLIENT.getCustomersController().readCustomer(groupSignup.getCustomerId()).getCustomer(); + + // then + assertThat(groupSignup.getCustomerId()).isNotNull(); + assertSubscriptionGroup(); + + assertThat(createdCustomer.getFirstName()).isEqualTo("John"); + assertThat(createdCustomer.getLastName()).isEqualTo("Doe"); + assertThat(createdCustomer.getEmail()).isEqualTo("payerdoe@chargify.com"); + assertThat(createdCustomer.getId()).isNotNull(); + assertThat(createdCustomer.getCreatedAt()).isNotNull(); + assertThat(createdCustomer.getUpdatedAt()).isNotNull(); + assertThat(createdCustomer.getCcEmails()).isEqualTo("washington@example.com"); + assertThat(createdCustomer.getOrganization()).isEqualTo("Acme, Inc"); + assertThat(createdCustomer.getReference()).isEqualTo(reference); + assertThat(createdCustomer.getAddress()).isEqualTo("Broadway"); + assertThat(createdCustomer.getAddress2()).isEqualTo("1703 Edsel Road"); + assertThat(createdCustomer.getCity()).isEqualTo("New York"); + assertThat(createdCustomer.getState()).isEqualTo("NY"); + assertThat(createdCustomer.getStateName()).isEqualTo("New York"); + assertThat(createdCustomer.getZip()).isEqualTo("78015"); + assertThat(createdCustomer.getCountry()).isEqualTo("US"); + assertThat(createdCustomer.getCountryName()).isEqualTo("United States"); + assertThat(createdCustomer.getPhone()).isEqualTo("555-111-222"); + assertThat(createdCustomer.getVerified()).isFalse(); + assertThat(createdCustomer.getPortalCustomerCreatedAt()).isNull(); + assertThat(createdCustomer.getPortalInviteLastSentAt()).isNull(); + assertThat(createdCustomer.getPortalInviteLastAcceptedAt()).isNull(); + assertThat(createdCustomer.getTaxExempt()).isTrue(); + assertThat(createdCustomer.getVatNumber()).isEqualTo("123"); + assertThat(createdCustomer.getParentId()).isNull(); + assertThat(createdCustomer.getLocale()).isEqualTo("es-MX"); + assertThat(createdCustomer.getDefaultSubscriptionGroupUid()).isNull(); + } + + @ParameterizedTest + @MethodSource("argsForShouldReturn422WhenSigningUpGroupWithInvalidData") + void shouldReturn422WhenSigningUpGroupWithInvalidData(SubscriptionGroupSignupRequest request, + ThrowingConsumer + assertionsConsumer) { + assertUnprocessableEntity( + SubscriptionGroupSignupErrorResponseException.class, + () -> SUBSCRIPTION_GROUPS_CONTROLLER.signupWithSubscriptionGroup(request), + assertionsConsumer::accept + ); + } + + private static Stream argsForShouldReturn422WhenSigningUpGroupWithInvalidData() { + return Stream.of( + Arguments.of( + new SubscriptionGroupSignupRequest( + new SubscriptionGroupSignup.Builder() + .subscriptions(List.of( + new SubscriptionGroupSignupItem.Builder() + .build() + )) + .build() + ), + (ThrowingConsumer) error -> + { + assertThat(error.getErrors().getSubscriptions()).isNull(); + assertThat(error.getErrors().getSubscriptionGroup()).containsOnly( + "One primary subscription is required.", + "One of 'payer_attributes', 'payer_id', 'payer_reference' is required."); + } + ), + Arguments.of( + new SubscriptionGroupSignupRequest( + new SubscriptionGroupSignup.Builder() + .payerId(customer.getId()) + .subscriptions(List.of( + new SubscriptionGroupSignupItem.Builder() + .primary(true) + .productId(product.getId()) + .build() + )) + .build() + ), + (ThrowingConsumer) error -> + { + assertThat(error.getErrors().getSubscriptionGroup()).isNull(); + assertThat(error.getErrors().getSubscriptions()).usingRecursiveComparison().isEqualTo( + Map.of("0", new SubscriptionGroupSubscriptionError.Builder() + .base(List.of("No payment method was on file for the $12.50 balance")) + .build()) + ); + } + ), + Arguments.of( + new SubscriptionGroupSignupRequest( + new SubscriptionGroupSignup.Builder() + .payerId(customer.getId()) + .creditCardAttributes(new SubscriptionGroupCreditCard.Builder() + .chargifyToken("abc") + .build()) + .subscriptions(List.of( + new SubscriptionGroupSignupItem.Builder() + .primary(true) + .productId(product.getId()) + .build() + )) + .build() + ), + (ThrowingConsumer) error -> + { + assertThat(error.getErrors().getSubscriptionGroup()).isNull(); + assertThat(error.getErrors().getSubscriptions()).usingRecursiveComparison().isEqualTo( + Map.of("0", new SubscriptionGroupSubscriptionError.Builder() + .paymentProfileChargifyToken(List.of("Chargify token not found")) + .build()) + ); + } + ), + Arguments.of( + new SubscriptionGroupSignupRequest( + new SubscriptionGroupSignup.Builder() + .payerId(customer.getId()) + .creditCardAttributes(new SubscriptionGroupCreditCard.Builder() + .fullNumber((SubscriptionGroupCreditCardFullNumber.fromString("4111 1111 1111 1111"))) + .expirationMonth(SubscriptionGroupCreditCardExpirationMonth.fromNumber(11)) + .expirationYear(SubscriptionGroupCreditCardExpirationYear.fromNumber(LocalDate.now().getYear() + 1)) + .build()) + .subscriptions(List.of( + new SubscriptionGroupSignupItem.Builder() + .primary(true) + .productId(123) + .build() + )) + .build() + ), + (ThrowingConsumer) error -> + { + assertThat(error.getErrors().getSubscriptionGroup()).isNull(); + assertThat(error.getErrors().getSubscriptions()).usingRecursiveComparison().isEqualTo( + Map.of("0", new SubscriptionGroupSubscriptionError.Builder() + .product(List.of("Product must be specified and be a valid product provided by the seller.")) + .productPricePointId(List.of("Product price point must belong to product.")) + .build()) + ); + } + ) + ); + } + + private void assertSubscriptionGroup() throws IOException, ApiException { + assertThat(groupSignup.getAdditionalProperties()).isEmpty(); + assertThat(groupSignup.getCancelAtEndOfPeriod()).isFalse(); + assertThat(groupSignup.getNextAssessmentAt()).isAfter(ZonedDateTime.now()); + assertThat(groupSignup.getPaymentCollectionMethod()).isEqualTo(CollectionMethod.AUTOMATIC); + assertThat(groupSignup.getPaymentProfileId()).isNotNull(); + assertThat(groupSignup.getPrimarySubscriptionId()).isNotNull(); + assertThat(groupSignup.getScheme()).isEqualTo(1); + assertThat(groupSignup.getScheme()).isEqualTo(1); + assertThat(groupSignup.getState()).isEqualTo(ACTIVE); + assertThat(groupSignup.getSubscriptionIds()).isNotEmpty(); + assertThat(groupSignup.getSubscriptionIds()).hasSize(2); + assertThat(groupSignup.getUid()).isNotNull(); + + assertThat(groupSignup.getSubscriptions()).hasSize(2); + SubscriptionGroupItem subscription1 = groupSignup.getSubscriptions().get(0); + SubscriptionGroupItem subscription2 = groupSignup.getSubscriptions().get(1); + + assertThat(subscription1.getAdditionalProperties()).isEmpty(); + assertThat(subscription1.getBalanceInCents()).isEqualTo(0); + assertThat(subscription1.getCouponCode()).isEqualTo(coupon.getCode()); + assertThat(subscription1.getCurrency()).isEqualTo("USD"); + assertThat(subscription1.getId()).isNotNull(); + assertThat(subscription1.getProductHandle()).isEqualTo(product.getHandle()); + assertThat(subscription1.getProductId()).isEqualTo(product.getId()); + assertThat(subscription1.getProductPricePointHandle()).isEqualTo(product.getProductPricePointHandle()); + assertThat(subscription1.getProductPricePointId()).isEqualTo(product.getDefaultProductPricePointId()); + assertThat(subscription1.getReference()).isNull(); + assertThat(subscription1.getTotalRevenueInCents()).isEqualTo(11500); + + assertThat(subscription2.getAdditionalProperties()).isEmpty(); + assertThat(subscription2.getBalanceInCents()).isEqualTo(0); + assertThat(subscription2.getCouponCode()).isNull(); + assertThat(subscription2.getCurrency()).isEqualTo("USD"); + assertThat(subscription2.getId()).isNotNull(); + assertThat(subscription2.getProductHandle()).isEqualTo(product2.getHandle()); + assertThat(subscription2.getProductId()).isEqualTo(product2.getId()); + assertThat(subscription2.getProductPricePointHandle()).isEqualTo(product2.getProductPricePointHandle()); + assertThat(subscription2.getProductPricePointId()).isEqualTo(product2.getDefaultProductPricePointId()); + assertThat(subscription2.getReference()).isNull(); + assertThat(subscription2.getTotalRevenueInCents()).isEqualTo(24000); + + NestedSubscriptionGroup subscription1Group = CLIENT.getSubscriptionsController().readSubscription(subscription1.getId(), null) + .getSubscription().getGroup().match(g -> g); + NestedSubscriptionGroup subscription2Group = CLIENT.getSubscriptionsController().readSubscription(subscription2.getId(), null) + .getSubscription().getGroup().match(g -> g); + + assertThat(subscription1Group.getPrimary()).isTrue(); + assertThat(subscription1Group.getPrimarySubscriptionId()).isEqualTo(subscription1.getId()); + assertThat(subscription1Group.getScheme()).isEqualTo(1); + assertThat(subscription1Group.getUid()).isEqualTo(groupSignup.getUid()); + + assertThat(subscription2Group.getPrimary()).isFalse(); + assertThat(subscription2Group.getPrimarySubscriptionId()).isEqualTo(subscription1.getId()); + assertThat(subscription2Group.getScheme()).isEqualTo(1); + assertThat(subscription2Group.getUid()).isEqualTo(groupSignup.getUid()); + } + + @Test + void shouldNotSignupGroupWhenProvidingInvalidCredentials() { + assertUnauthorized(() -> TestClient.createInvalidCredentialsClient().getSubscriptionGroupsController() + .signupWithSubscriptionGroup(null)); + } + +} diff --git a/tests/src/test/java/com/maxio/advancedbilling/utils/TestTeardown.java b/tests/src/test/java/com/maxio/advancedbilling/utils/TestTeardown.java index af0b56d5..72e2571f 100644 --- a/tests/src/test/java/com/maxio/advancedbilling/utils/TestTeardown.java +++ b/tests/src/test/java/com/maxio/advancedbilling/utils/TestTeardown.java @@ -8,10 +8,11 @@ import com.maxio.advancedbilling.models.Customer; import com.maxio.advancedbilling.models.ListComponentsInput; import com.maxio.advancedbilling.models.ListMetafieldsInput; +import com.maxio.advancedbilling.models.ListSubscriptionGroupsInput; +import com.maxio.advancedbilling.models.ListSubscriptionGroupsItem; import com.maxio.advancedbilling.models.ListSubscriptionsInput; import com.maxio.advancedbilling.models.Metafield; import com.maxio.advancedbilling.models.ResourceType; -import com.maxio.advancedbilling.models.SubscriptionGroupItem; import com.maxio.advancedbilling.models.SubscriptionGroupSignupResponse; import com.maxio.advancedbilling.models.SubscriptionResponse; import org.slf4j.Logger; @@ -61,22 +62,39 @@ public void deleteSubscriptions() throws IOException, ApiException { } public void deleteSubscriptionGroup(SubscriptionGroupSignupResponse groupSignup) throws IOException, ApiException { - SubscriptionGroupsController subscriptionGroupsController = advancedBillingClient.getSubscriptionGroupsController(); - List subscriptions = groupSignup.getSubscriptions(); - SubscriptionGroupItem primarySubscription = null; + deleteSubscriptionGroup(groupSignup.getPrimarySubscriptionId(), groupSignup.getSubscriptionIds(), groupSignup.getCustomerId()); + } - for (SubscriptionGroupItem subscription : subscriptions) { - if (groupSignup.getPrimarySubscriptionId().equals(subscription.getId())) { - primarySubscription = subscription; - continue; + public void deleteAllSubscriptionGroups() throws IOException, ApiException { + LOGGER.info("Deleting all subscription groups"); + List subscriptionGroups = advancedBillingClient.getSubscriptionGroupsController() + .listSubscriptionGroups(new ListSubscriptionGroupsInput()).getSubscriptionGroups(); + + while (!subscriptionGroups.isEmpty()) { + LOGGER.info("Subscription groups batch: {}", subscriptionGroups.size()); + for (ListSubscriptionGroupsItem group : subscriptionGroups) { + LOGGER.info("Purging subscription group: {}", group.getUid()); + deleteSubscriptionGroup(group.getPrimarySubscriptionId(), group.getSubscriptionIds(), group.getCustomerId()); + LOGGER.info("Subscription group purged successfully: {}", group.getUid()); } - subscriptionGroupsController.removeSubscriptionFromGroup(subscription.getId()); + + subscriptionGroups = advancedBillingClient.getSubscriptionGroupsController() + .listSubscriptionGroups(new ListSubscriptionGroupsInput()).getSubscriptionGroups(); } + } - if (primarySubscription != null) { - subscriptionGroupsController.removeSubscriptionFromGroup(primarySubscription.getId()); + public void deleteSubscriptionGroup(Integer primarySubscriptionId, List subscriptionsIds, + Integer customerId) throws IOException, ApiException { + SubscriptionGroupsController subscriptionGroupsController = advancedBillingClient.getSubscriptionGroupsController(); + + for (Integer subscriptionId : subscriptionsIds) { + if (!primarySubscriptionId.equals(subscriptionId)) { + subscriptionGroupsController.removeSubscriptionFromGroup(subscriptionId); + } } - deleteCustomer(new Customer.Builder().id(groupSignup.getCustomerId()).build()); + + subscriptionGroupsController.removeSubscriptionFromGroup(primarySubscriptionId); + deleteCustomer(new Customer.Builder().id(customerId).build()); } public void archiveComponents() throws IOException, ApiException { diff --git a/tests/src/test/java/com/maxio/advancedbilling/utils/matchers/SubscriptionGroupCreateErrorResponseErrorsGetter.java b/tests/src/test/java/com/maxio/advancedbilling/utils/matchers/SubscriptionGroupCreateErrorResponseErrorsGetter.java new file mode 100644 index 00000000..c2a34139 --- /dev/null +++ b/tests/src/test/java/com/maxio/advancedbilling/utils/matchers/SubscriptionGroupCreateErrorResponseErrorsGetter.java @@ -0,0 +1,23 @@ +package com.maxio.advancedbilling.utils.matchers; + +import com.maxio.advancedbilling.models.SubscriptionGroupMembersArrayError; +import com.maxio.advancedbilling.models.SubscriptionGroupSingleError; +import com.maxio.advancedbilling.models.containers.SubscriptionGroupCreateErrorResponseErrors; + +public class SubscriptionGroupCreateErrorResponseErrorsGetter implements SubscriptionGroupCreateErrorResponseErrors.Cases { + @Override + public R subscriptionGroupMembersArrayError(SubscriptionGroupMembersArrayError subscriptionGroupMembersArrayError) { + return (R) subscriptionGroupMembersArrayError; + } + + @Override + public R subscriptionGroupSingleError(SubscriptionGroupSingleError subscriptionGroupSingleError) { + return (R) subscriptionGroupSingleError; + } + + @Override + public R string(String string) { + return (R) string; + } + +}