chore(internal): minor reformatting (#25)

lithic-com · Jul 17, 2023 · df89dd4 · df89dd4
1 parent f73d039
commit df89dd4
Show file tree

Hide file tree

Showing 25 changed files with 110 additions and 110 deletions.
diff --git a/lithic-java-core/src/test/kotlin/com/lithic/api/models/AccountHolderDocumentTest.kt b/lithic-java-core/src/test/kotlin/com/lithic/api/models/AccountHolderDocumentTest.kt
@@ -29,6 +29,7 @@ class AccountHolderDocumentTest {
                 )
                 .build()
         assertThat(accountHolderDocument).isNotNull
+        assertThat(accountHolderDocument.token()).contains("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
         assertThat(accountHolderDocument.accountHolderToken())
             .contains("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
         assertThat(accountHolderDocument.documentType())
@@ -47,6 +48,5 @@ class AccountHolderDocumentTest {
                     .uploadUrl("string")
                     .build()
             )
-        assertThat(accountHolderDocument.token()).contains("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
     }
 }
diff --git a/lithic-java-core/src/test/kotlin/com/lithic/api/models/AccountHolderUpdateResponseTest.kt b/lithic-java-core/src/test/kotlin/com/lithic/api/models/AccountHolderUpdateResponseTest.kt
@@ -16,8 +16,8 @@ class AccountHolderUpdateResponseTest {
                 .build()
         assertThat(accountHolderUpdateResponse).isNotNull
         assertThat(accountHolderUpdateResponse.token()).contains("string")
+        assertThat(accountHolderUpdateResponse.businessAccountToken()).contains("string")
         assertThat(accountHolderUpdateResponse.email()).contains("string")
         assertThat(accountHolderUpdateResponse.phoneNumber()).contains("string")
-        assertThat(accountHolderUpdateResponse.businessAccountToken()).contains("string")
     }
 }
diff --git a/lithic-java-core/src/test/kotlin/com/lithic/api/models/AccountTest.kt b/lithic-java-core/src/test/kotlin/com/lithic/api/models/AccountTest.kt
@@ -35,12 +35,21 @@ class AccountTest {
                 )
                 .build()
         assertThat(account).isNotNull
+        assertThat(account.token()).isEqualTo("b68b7424-aa69-4cbc-a946-30d90181b621")
         assertThat(account.spendLimit())
             .isEqualTo(
                 Account.SpendLimit.builder().daily(123L).lifetime(123L).monthly(123L).build()
             )
         assertThat(account.state()).isEqualTo(Account.State.ACTIVE)
-        assertThat(account.token()).isEqualTo("b68b7424-aa69-4cbc-a946-30d90181b621")
+        assertThat(account.accountHolder())
+            .contains(
+                Account.AccountHolder.builder()
+                    .token("95e5f1b7-cfd5-4520-aa3c-2451bab8608d")
+                    .businessAccountToken("e87db14a-4abf-4901-adad-5d5c9f46aff2")
+                    .email("[email protected]")
+                    .phoneNumber("+12124007676")
+                    .build()
+            )
         assertThat(account.authRuleTokens().get()).containsExactly("string")
         assertThat(account.verificationAddress())
             .contains(
@@ -53,14 +62,5 @@ class AccountTest {
                     .address2("Apt 21")
                     .build()
             )
-        assertThat(account.accountHolder())
-            .contains(
-                Account.AccountHolder.builder()
-                    .token("95e5f1b7-cfd5-4520-aa3c-2451bab8608d")
-                    .businessAccountToken("e87db14a-4abf-4901-adad-5d5c9f46aff2")
-                    .email("[email protected]")
-                    .phoneNumber("+12124007676")
-                    .build()
-            )
     }
 }
diff --git a/lithic-java-core/src/test/kotlin/com/lithic/api/models/AddressTest.kt b/lithic-java-core/src/test/kotlin/com/lithic/api/models/AddressTest.kt
@@ -18,10 +18,10 @@ class AddressTest {
                 .build()
         assertThat(address).isNotNull
         assertThat(address.address1()).isEqualTo("123 Old Forest Way")
-        assertThat(address.address2()).contains("string")
         assertThat(address.city()).isEqualTo("Omaha")
         assertThat(address.country()).isEqualTo("USA")
         assertThat(address.postalCode()).isEqualTo("68022")
         assertThat(address.state()).isEqualTo("NE")
+        assertThat(address.address2()).contains("string")
     }
 }
diff --git a/lithic-java-core/src/test/kotlin/com/lithic/api/models/AggregateBalanceTest.kt b/lithic-java-core/src/test/kotlin/com/lithic/api/models/AggregateBalanceTest.kt
@@ -22,21 +22,21 @@ class AggregateBalanceTest {
                 .updated(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
                 .build()
         assertThat(aggregateBalance).isNotNull
-        assertThat(aggregateBalance.financialAccountType())
-            .isEqualTo(AggregateBalance.FinancialAccountType.ISSUING)
-        assertThat(aggregateBalance.currency()).isEqualTo("string")
         assertThat(aggregateBalance.availableAmount()).isEqualTo(123L)
-        assertThat(aggregateBalance.pendingAmount()).isEqualTo(123L)
-        assertThat(aggregateBalance.totalAmount()).isEqualTo(123L)
         assertThat(aggregateBalance.created())
             .isEqualTo(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
-        assertThat(aggregateBalance.updated())
-            .isEqualTo(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
-        assertThat(aggregateBalance.lastTransactionToken())
+        assertThat(aggregateBalance.currency()).isEqualTo("string")
+        assertThat(aggregateBalance.financialAccountType())
+            .isEqualTo(AggregateBalance.FinancialAccountType.ISSUING)
+        assertThat(aggregateBalance.lastFinancialAccountToken())
             .isEqualTo("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
         assertThat(aggregateBalance.lastTransactionEventToken())
             .isEqualTo("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
-        assertThat(aggregateBalance.lastFinancialAccountToken())
+        assertThat(aggregateBalance.lastTransactionToken())
             .isEqualTo("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+        assertThat(aggregateBalance.pendingAmount()).isEqualTo(123L)
+        assertThat(aggregateBalance.totalAmount()).isEqualTo(123L)
+        assertThat(aggregateBalance.updated())
+            .isEqualTo(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
     }
 }
diff --git a/lithic-java-core/src/test/kotlin/com/lithic/api/models/AuthRuleTest.kt b/lithic-java-core/src/test/kotlin/com/lithic/api/models/AuthRuleTest.kt
@@ -21,13 +21,13 @@ class AuthRuleTest {
                 .build()
         assertThat(authRule).isNotNull
         assertThat(authRule.token()).contains("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
-        assertThat(authRule.state()).contains(AuthRule.State.ACTIVE)
-        assertThat(authRule.allowedMcc().get()).containsExactly("string")
-        assertThat(authRule.blockedMcc().get()).containsExactly("string")
+        assertThat(authRule.accountTokens().get()).containsExactly("string")
         assertThat(authRule.allowedCountries().get()).containsExactly("string")
+        assertThat(authRule.allowedMcc().get()).containsExactly("string")
         assertThat(authRule.blockedCountries().get()).containsExactly("string")
-        assertThat(authRule.accountTokens().get()).containsExactly("string")
+        assertThat(authRule.blockedMcc().get()).containsExactly("string")
         assertThat(authRule.cardTokens().get()).containsExactly("string")
         assertThat(authRule.programLevel()).contains(true)
+        assertThat(authRule.state()).contains(AuthRule.State.ACTIVE)
     }
 }
diff --git a/lithic-java-core/src/test/kotlin/com/lithic/api/models/BalanceTest.kt b/lithic-java-core/src/test/kotlin/com/lithic/api/models/BalanceTest.kt
@@ -22,14 +22,14 @@ class BalanceTest {
                 .updated(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
                 .build()
         assertThat(balance).isNotNull
+        assertThat(balance.token()).isEqualTo("3fa85f64-5717-4562-b3fc-2c963f66afa6")
         assertThat(balance.availableAmount()).isEqualTo(123L)
         assertThat(balance.created()).isEqualTo(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
         assertThat(balance.currency()).isEqualTo("string")
         assertThat(balance.lastTransactionEventToken())
             .isEqualTo("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
         assertThat(balance.lastTransactionToken()).isEqualTo("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
         assertThat(balance.pendingAmount()).isEqualTo(123L)
-        assertThat(balance.token()).isEqualTo("3fa85f64-5717-4562-b3fc-2c963f66afa6")
         assertThat(balance.totalAmount()).isEqualTo(123L)
         assertThat(balance.type()).isEqualTo(Balance.Type.ISSUING)
         assertThat(balance.updated()).isEqualTo(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))

diff --git a/lithic-java-core/src/test/kotlin/com/lithic/api/models/CardTest.kt b/lithic-java-core/src/test/kotlin/com/lithic/api/models/CardTest.kt
@@ -38,8 +38,8 @@ class CardTest {
                 .pan("4111111289144142")
                 .build()
         assertThat(card).isNotNull
+        assertThat(card.token()).isEqualTo("7ef7d65c-9023-4da3-b113-3b8583fd7951")
         assertThat(card.created()).isEqualTo(OffsetDateTime.parse("2021-06-28T22:53:15Z"))
-        assertThat(card.cvv()).contains("776")
         assertThat(card.funding())
             .isEqualTo(
                 Card.FundingAccount.builder()
@@ -52,18 +52,18 @@ class CardTest {
                     .nickname("x")
                     .build()
             )
-        assertThat(card.expMonth()).contains("06")
-        assertThat(card.expYear()).contains("2027")
-        assertThat(card.hostname()).contains("string")
         assertThat(card.lastFour()).isEqualTo("xxxx")
-        assertThat(card.memo()).contains("New Card")
-        assertThat(card.pan()).contains("4111111289144142")
         assertThat(card.spendLimit()).isEqualTo(123L)
         assertThat(card.spendLimitDuration()).isEqualTo(SpendLimitDuration.ANNUALLY)
         assertThat(card.state()).isEqualTo(Card.State.CLOSED)
-        assertThat(card.authRuleTokens().get()).containsExactly("string")
-        assertThat(card.token()).isEqualTo("7ef7d65c-9023-4da3-b113-3b8583fd7951")
         assertThat(card.type()).isEqualTo(Card.Type.VIRTUAL)
+        assertThat(card.authRuleTokens().get()).containsExactly("string")
+        assertThat(card.cvv()).contains("776")
         assertThat(card.digitalCardArtToken()).contains("00000000-0000-0000-1000-000000000000")
+        assertThat(card.expMonth()).contains("06")
+        assertThat(card.expYear()).contains("2027")
+        assertThat(card.hostname()).contains("string")
+        assertThat(card.memo()).contains("New Card")
+        assertThat(card.pan()).contains("4111111289144142")
     }
 }
diff --git a/lithic-java-core/src/test/kotlin/com/lithic/api/models/DisputeEvidenceTest.kt b/lithic-java-core/src/test/kotlin/com/lithic/api/models/DisputeEvidenceTest.kt
@@ -19,13 +19,13 @@ class DisputeEvidenceTest {
                 .uploadUrl("string")
                 .build()
         assertThat(disputeEvidence).isNotNull
+        assertThat(disputeEvidence.token()).isEqualTo("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
         assertThat(disputeEvidence.created())
             .isEqualTo(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
         assertThat(disputeEvidence.disputeToken()).isEqualTo("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
+        assertThat(disputeEvidence.uploadStatus()).isEqualTo(DisputeEvidence.UploadStatus.DELETED)
         assertThat(disputeEvidence.downloadUrl()).contains("string")
         assertThat(disputeEvidence.filename()).contains("string")
-        assertThat(disputeEvidence.token()).isEqualTo("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
-        assertThat(disputeEvidence.uploadStatus()).isEqualTo(DisputeEvidence.UploadStatus.DELETED)
         assertThat(disputeEvidence.uploadUrl()).contains("string")
     }
 }
diff --git a/lithic-java-core/src/test/kotlin/com/lithic/api/models/DisputeTest.kt b/lithic-java-core/src/test/kotlin/com/lithic/api/models/DisputeTest.kt
@@ -31,6 +31,7 @@ class DisputeTest {
                 .transactionToken("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
                 .build()
         assertThat(dispute).isNotNull
+        assertThat(dispute.token()).isEqualTo("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
         assertThat(dispute.amount()).isEqualTo(123L)
         assertThat(dispute.arbitrationDate())
             .contains(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
@@ -39,12 +40,12 @@ class DisputeTest {
             .contains(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
         assertThat(dispute.customerNote()).contains("string")
         assertThat(dispute.networkClaimIds().get()).containsExactly("string")
-        assertThat(dispute.primaryClaimId()).contains("string")
         assertThat(dispute.networkFiledDate())
             .contains(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
         assertThat(dispute.networkReasonCode()).contains("string")
         assertThat(dispute.prearbitrationDate())
             .contains(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+        assertThat(dispute.primaryClaimId()).contains("string")
         assertThat(dispute.reason()).isEqualTo(Dispute.Reason.ATM_CASH_MISDISPENSE)
         assertThat(dispute.representmentDate())
             .contains(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
@@ -54,7 +55,6 @@ class DisputeTest {
         assertThat(dispute.resolutionNote()).contains("string")
         assertThat(dispute.resolutionReason()).contains(Dispute.ResolutionReason.CASE_LOST)
         assertThat(dispute.status()).isEqualTo(Dispute.Status.NEW)
-        assertThat(dispute.token()).isEqualTo("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
         assertThat(dispute.transactionToken()).isEqualTo("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
     }
 }
diff --git a/lithic-java-core/src/test/kotlin/com/lithic/api/models/EmbedRequestParamsTest.kt b/lithic-java-core/src/test/kotlin/com/lithic/api/models/EmbedRequestParamsTest.kt
@@ -16,10 +16,10 @@ class EmbedRequestParamsTest {
                 .targetOrigin("string")
                 .build()
         assertThat(embedRequestParams).isNotNull
+        assertThat(embedRequestParams.token()).isEqualTo("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
         assertThat(embedRequestParams.css()).contains("string")
         assertThat(embedRequestParams.expiration())
             .contains(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
-        assertThat(embedRequestParams.token()).isEqualTo("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
         assertThat(embedRequestParams.targetOrigin()).contains("string")
     }
 }
diff --git a/lithic-java-core/src/test/kotlin/com/lithic/api/models/EventSubscriptionTest.kt b/lithic-java-core/src/test/kotlin/com/lithic/api/models/EventSubscriptionTest.kt
@@ -16,11 +16,11 @@ class EventSubscriptionTest {
                 .url("https://example.com")
                 .build()
         assertThat(eventSubscription).isNotNull
+        assertThat(eventSubscription.token()).isEqualTo("ep_1srOrx2ZWZBpBUvZwXKQmoEYga1")
         assertThat(eventSubscription.description()).isEqualTo("string")
         assertThat(eventSubscription.disabled()).isEqualTo(true)
         assertThat(eventSubscription.eventTypes().get())
             .containsExactly(EventSubscription.EventType.CARD_CREATED)
         assertThat(eventSubscription.url()).isEqualTo("https://example.com")
-        assertThat(eventSubscription.token()).isEqualTo("ep_1srOrx2ZWZBpBUvZwXKQmoEYga1")
     }
 }
diff --git a/lithic-java-core/src/test/kotlin/com/lithic/api/models/EventTest.kt b/lithic-java-core/src/test/kotlin/com/lithic/api/models/EventTest.kt
@@ -17,8 +17,8 @@ class EventTest {
                 .build()
         assertThat(event).isNotNull
         assertThat(event.token()).isEqualTo("msg_1srOrx2ZWZBpBUvZwXKQmoEYga1")
+        assertThat(event.created()).isEqualTo(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
         assertThat(event.eventType()).isEqualTo(Event.EventType.CARD_CREATED)
         assertThat(event.payload()).isEqualTo(Event.Payload.builder().build())
-        assertThat(event.created()).isEqualTo(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
     }
 }
diff --git a/lithic-java-core/src/test/kotlin/com/lithic/api/models/FinancialAccountTest.kt b/lithic-java-core/src/test/kotlin/com/lithic/api/models/FinancialAccountTest.kt
@@ -18,13 +18,13 @@ class FinancialAccountTest {
                 .routingNumber("string")
                 .build()
         assertThat(financialAccount).isNotNull
-        assertThat(financialAccount.accountNumber()).contains("string")
+        assertThat(financialAccount.token()).isEqualTo("3fa85f64-5717-4562-b3fc-2c963f66afa6")
         assertThat(financialAccount.created())
             .isEqualTo(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
-        assertThat(financialAccount.routingNumber()).contains("string")
-        assertThat(financialAccount.token()).isEqualTo("3fa85f64-5717-4562-b3fc-2c963f66afa6")
         assertThat(financialAccount.type()).isEqualTo(FinancialAccount.Type.ISSUING)
         assertThat(financialAccount.updated())
             .isEqualTo(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
+        assertThat(financialAccount.accountNumber()).contains("string")
+        assertThat(financialAccount.routingNumber()).contains("string")
     }
 }
diff --git a/lithic-java-core/src/test/kotlin/com/lithic/api/models/FinancialTransactionTest.kt b/lithic-java-core/src/test/kotlin/com/lithic/api/models/FinancialTransactionTest.kt
@@ -33,6 +33,7 @@ class FinancialTransactionTest {
                 .updated(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
                 .build()
         assertThat(financialTransaction).isNotNull
+        assertThat(financialTransaction.token()).contains("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
         assertThat(financialTransaction.category()).contains(FinancialTransaction.Category.CARD)
         assertThat(financialTransaction.created())
             .contains(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
@@ -52,7 +53,6 @@ class FinancialTransactionTest {
         assertThat(financialTransaction.result()).contains(FinancialTransaction.Result.APPROVED)
         assertThat(financialTransaction.settledAmount()).contains(123L)
         assertThat(financialTransaction.status()).contains(FinancialTransaction.Status.DECLINED)
-        assertThat(financialTransaction.token()).contains("182bd5e5-6e1a-4fe4-a799-aa6d9a6ab26e")
         assertThat(financialTransaction.updated())
             .contains(OffsetDateTime.parse("2019-12-27T18:11:19.117Z"))
     }

diff --git a/lithic-java-core/src/test/kotlin/com/lithic/api/models/KybTest.kt b/lithic-java-core/src/test/kotlin/com/lithic/api/models/KybTest.kt
@@ -98,8 +98,8 @@ class KybTest {
                 .kybPassedTimestamp("2018-05-29T21:16:05Z")
                 .build()
         assertThat(kyb).isNotNull
-        assertThat(kyb.businessEntity())
-            .isEqualTo(
+        assertThat(kyb.beneficialOwnerEntities())
+            .containsExactly(
                 Kyb.BusinessEntity.builder()
                     .address(
                         Address.builder()
@@ -118,9 +118,9 @@ class KybTest {
                     .parentCompany("string")
                     .build()
             )
-        assertThat(kyb.beneficialOwnerEntities())
+        assertThat(kyb.beneficialOwnerIndividuals())
             .containsExactly(
-                Kyb.BusinessEntity.builder()
+                Kyb.Individual.builder()
                     .address(
                         Address.builder()
                             .address1("123 Old Forest Way")
@@ -131,16 +131,17 @@ class KybTest {
                             .address2("string")
                             .build()
                     )
-                    .governmentId("114-123-1513")
-                    .legalBusinessName("Acme, Inc.")
-                    .phoneNumbers(listOf("+12124007676"))
-                    .dbaBusinessName("string")
-                    .parentCompany("string")
+                    .dob("1991-03-08 08:00:00")
+                    .email("[email protected]")
+                    .firstName("Tom")
+                    .governmentId("111-23-1412")
+                    .lastName("Bombadil")
+                    .phoneNumber("+12124007676")
                     .build()
             )
-        assertThat(kyb.beneficialOwnerIndividuals())
-            .containsExactly(
-                Kyb.Individual.builder()
+        assertThat(kyb.businessEntity())
+            .isEqualTo(
+                Kyb.BusinessEntity.builder()
                     .address(
                         Address.builder()
                             .address1("123 Old Forest Way")
@@ -151,12 +152,11 @@ class KybTest {
                             .address2("string")
                             .build()
                     )
-                    .dob("1991-03-08 08:00:00")
-                    .email("[email protected]")
-                    .firstName("Tom")
-                    .governmentId("111-23-1412")
-                    .lastName("Bombadil")
-                    .phoneNumber("+12124007676")
+                    .governmentId("114-123-1513")
+                    .legalBusinessName("Acme, Inc.")
+                    .phoneNumbers(listOf("+12124007676"))
+                    .dbaBusinessName("string")
+                    .parentCompany("string")
                     .build()
             )
         assertThat(kyb.controlPerson())
@@ -180,11 +180,11 @@ class KybTest {
                     .phoneNumber("+12124007676")
                     .build()
             )
-        assertThat(kyb.kybPassedTimestamp()).contains("2018-05-29T21:16:05Z")
         assertThat(kyb.natureOfBusiness())
             .isEqualTo("Software company selling solutions to the restaurant industry")
         assertThat(kyb.tosTimestamp()).isEqualTo("2018-05-29T21:16:05Z")
         assertThat(kyb.websiteUrl()).isEqualTo("www.mybusiness.com")
         assertThat(kyb.workflow()).isEqualTo(Kyb.Workflow.KYB_BASIC)
+        assertThat(kyb.kybPassedTimestamp()).contains("2018-05-29T21:16:05Z")
     }
 }