repo_id
stringlengths 8
105
| file_path
stringlengths 28
162
| content
stringlengths 15
661k
| __index_level_0__
int64 0
0
|
|---|---|---|---|
raw_data\ibanity-java\src\main\java\com\ibanity\apis\client\webhooks\models | raw_data\ibanity-java\src\main\java\com\ibanity\apis\client\webhooks\models\ponto_connect\AccountTransactionsCreated.java | package com.ibanity.apis.client.webhooks.models.ponto_connect;
import com.ibanity.apis.client.jsonapi.DataApiModel;
import com.ibanity.apis.client.jsonapi.RelationshipsApiModel;
import com.ibanity.apis.client.models.IbanityWebhookEvent;
import lombok.AccessLevel;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;
import java.time.Instant;
import java.util.UUID;
import java.util.function.Function;
import static com.ibanity.apis.client.mappers.IbanityWebhookEventMapper.toIbanityWebhooks;
import static java.util.UUID.fromString;
@Data
@SuperBuilder(toBuilder = true)
@NoArgsConstructor
@AllArgsConstructor(access = AccessLevel.PRIVATE)
public class AccountTransactionsCreated implements IbanityWebhookEvent {
public final static String TYPE = "pontoConnect.account.transactionsCreated";
private UUID id;
private String type;
private UUID accountId;
private int count;
private UUID synchronizationId;
private UUID organizationId;
private Instant createdAt;
public static Function<DataApiModel, AccountTransactionsCreated> mappingFunction() {
return dataApiModel -> {
AccountTransactionsCreated accountTransactionsCreated = toIbanityWebhooks(dataApiModel, AccountTransactionsCreated.class);
RelationshipsApiModel accountRelationship = dataApiModel.getRelationships().get("account");
if (accountRelationship != null) {
accountTransactionsCreated.setAccountId(fromString(accountRelationship.getData().getId()));
}
RelationshipsApiModel synchronizationRelationship = dataApiModel.getRelationships().get("synchronization");
if (synchronizationRelationship != null) {
accountTransactionsCreated.setSynchronizationId(fromString(synchronizationRelationship.getData().getId()));
}
RelationshipsApiModel organizationRelationship = dataApiModel.getRelationships().get("organization");
if (organizationRelationship != null) {
accountTransactionsCreated.setOrganizationId(fromString(organizationRelationship.getData().getId()));
}
return accountTransactionsCreated;
};
}
}
| 0 |
raw_data\ibanity-java\src\main\java\com\ibanity\apis\client\webhooks\models | raw_data\ibanity-java\src\main\java\com\ibanity\apis\client\webhooks\models\ponto_connect\AccountTransactionsUpdated.java | package com.ibanity.apis.client.webhooks.models.ponto_connect;
import com.ibanity.apis.client.jsonapi.DataApiModel;
import com.ibanity.apis.client.jsonapi.RelationshipsApiModel;
import com.ibanity.apis.client.models.IbanityWebhookEvent;
import lombok.AccessLevel;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;
import java.time.Instant;
import java.util.UUID;
import java.util.function.Function;
import static com.ibanity.apis.client.mappers.IbanityWebhookEventMapper.toIbanityWebhooks;
import static java.util.UUID.fromString;
@Data
@SuperBuilder(toBuilder = true)
@NoArgsConstructor
@AllArgsConstructor(access = AccessLevel.PRIVATE)
public class AccountTransactionsUpdated implements IbanityWebhookEvent {
public final static String TYPE = "pontoConnect.account.transactionsUpdated";
private UUID id;
private String type;
private UUID accountId;
private UUID synchronizationId;
private UUID organizationId;
private int count;
private Instant createdAt;
public static Function<DataApiModel, AccountTransactionsUpdated> mappingFunction() {
return dataApiModel -> {
AccountTransactionsUpdated accountTransactionsUpdated = toIbanityWebhooks(dataApiModel, AccountTransactionsUpdated.class);
RelationshipsApiModel accountRelationship = dataApiModel.getRelationships().get("account");
if (accountRelationship != null) {
accountTransactionsUpdated.setAccountId(fromString(accountRelationship.getData().getId()));
}
RelationshipsApiModel synchronizationRelationship = dataApiModel.getRelationships().get("synchronization");
if (synchronizationRelationship != null) {
accountTransactionsUpdated.setSynchronizationId(fromString(synchronizationRelationship.getData().getId()));
}
RelationshipsApiModel organizationRelationship = dataApiModel.getRelationships().get("organization");
if (organizationRelationship != null) {
accountTransactionsUpdated.setOrganizationId(fromString(organizationRelationship.getData().getId()));
}
return accountTransactionsUpdated;
};
}
}
| 0 |
raw_data\ibanity-java\src\main\java\com\ibanity\apis\client\webhooks\models | raw_data\ibanity-java\src\main\java\com\ibanity\apis\client\webhooks\models\ponto_connect\IntegrationAccountAdded.java | package com.ibanity.apis.client.webhooks.models.ponto_connect;
import com.ibanity.apis.client.jsonapi.DataApiModel;
import com.ibanity.apis.client.jsonapi.RelationshipsApiModel;
import com.ibanity.apis.client.models.IbanityWebhookEvent;
import lombok.AccessLevel;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;
import java.time.Instant;
import java.util.UUID;
import java.util.function.Function;
import static com.ibanity.apis.client.mappers.IbanityWebhookEventMapper.toIbanityWebhooks;
import static java.util.UUID.fromString;
@Data
@SuperBuilder(toBuilder = true)
@NoArgsConstructor
@AllArgsConstructor(access = AccessLevel.PRIVATE)
public class IntegrationAccountAdded implements IbanityWebhookEvent {
public final static String TYPE = "pontoConnect.integration.accountAdded";
private UUID id;
private String type;
private UUID account;
private UUID organization;
private Instant createdAt;
public static Function<DataApiModel, IntegrationAccountAdded> mappingFunction() {
return dataApiModel -> {
IntegrationAccountAdded integrationAccountAdded = toIbanityWebhooks(dataApiModel, IntegrationAccountAdded.class);
RelationshipsApiModel organizationRelationship = dataApiModel.getRelationships().get("organization");
if (organizationRelationship != null) {
integrationAccountAdded.setOrganization(fromString(organizationRelationship.getData().getId()));
}
RelationshipsApiModel accountRelationship = dataApiModel.getRelationships().get("account");
if (accountRelationship != null) {
integrationAccountAdded.setAccount(fromString(accountRelationship.getData().getId()));
}
return integrationAccountAdded;
};
}
}
| 0 |
raw_data\ibanity-java\src\main\java\com\ibanity\apis\client\webhooks\models | raw_data\ibanity-java\src\main\java\com\ibanity\apis\client\webhooks\models\ponto_connect\IntegrationAccountRevoked.java | package com.ibanity.apis.client.webhooks.models.ponto_connect;
import com.ibanity.apis.client.jsonapi.DataApiModel;
import com.ibanity.apis.client.jsonapi.RelationshipsApiModel;
import com.ibanity.apis.client.models.IbanityWebhookEvent;
import lombok.AccessLevel;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;
import java.time.Instant;
import java.util.UUID;
import java.util.function.Function;
import static com.ibanity.apis.client.mappers.IbanityWebhookEventMapper.toIbanityWebhooks;
import static java.util.UUID.fromString;
@Data
@SuperBuilder(toBuilder = true)
@NoArgsConstructor
@AllArgsConstructor(access = AccessLevel.PRIVATE)
public class IntegrationAccountRevoked implements IbanityWebhookEvent {
public final static String TYPE = "pontoConnect.integration.accountRevoked";
private UUID id;
private String type;
private UUID account;
private UUID organization;
private Instant createdAt;
public static Function<DataApiModel, IntegrationAccountRevoked> mappingFunction() {
return dataApiModel -> {
IntegrationAccountRevoked integrationAccountRevoked = toIbanityWebhooks(dataApiModel, IntegrationAccountRevoked.class);
RelationshipsApiModel organizationRelationship = dataApiModel.getRelationships().get("organization");
if (organizationRelationship != null) {
integrationAccountRevoked.setOrganization(fromString(organizationRelationship.getData().getId()));
}
RelationshipsApiModel accountRelationship = dataApiModel.getRelationships().get("account");
if (accountRelationship != null) {
integrationAccountRevoked.setAccount(fromString(accountRelationship.getData().getId()));
}
return integrationAccountRevoked;
};
}
}
| 0 |
raw_data\ibanity-java\src\main\java\com\ibanity\apis\client\webhooks\models | raw_data\ibanity-java\src\main\java\com\ibanity\apis\client\webhooks\models\ponto_connect\IntegrationCreated.java | package com.ibanity.apis.client.webhooks.models.ponto_connect;
import com.ibanity.apis.client.jsonapi.DataApiModel;
import com.ibanity.apis.client.jsonapi.RelationshipsApiModel;
import com.ibanity.apis.client.models.IbanityWebhookEvent;
import lombok.AccessLevel;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;
import java.time.Instant;
import java.util.UUID;
import java.util.function.Function;
import static com.ibanity.apis.client.mappers.IbanityWebhookEventMapper.toIbanityWebhooks;
import static java.util.UUID.fromString;
@Data
@SuperBuilder(toBuilder = true)
@NoArgsConstructor
@AllArgsConstructor(access = AccessLevel.PRIVATE)
public class IntegrationCreated implements IbanityWebhookEvent {
public final static String TYPE = "pontoConnect.integration.created";
private UUID id;
private String type;
private UUID organization;
private Instant createdAt;
public static Function<DataApiModel, IntegrationCreated> mappingFunction() {
return dataApiModel -> {
IntegrationCreated integrationCreated = toIbanityWebhooks(dataApiModel, IntegrationCreated.class);
RelationshipsApiModel organizationRelationship = dataApiModel.getRelationships().get("organization");
if (organizationRelationship != null) {
integrationCreated.setOrganization(fromString(organizationRelationship.getData().getId()));
}
return integrationCreated;
};
}
}
| 0 |
raw_data\ibanity-java\src\main\java\com\ibanity\apis\client\webhooks\models | raw_data\ibanity-java\src\main\java\com\ibanity\apis\client\webhooks\models\ponto_connect\IntegrationRevoked.java | package com.ibanity.apis.client.webhooks.models.ponto_connect;
import com.ibanity.apis.client.jsonapi.DataApiModel;
import com.ibanity.apis.client.jsonapi.RelationshipsApiModel;
import com.ibanity.apis.client.models.IbanityWebhookEvent;
import lombok.AccessLevel;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;
import java.time.Instant;
import java.util.UUID;
import java.util.function.Function;
import static com.ibanity.apis.client.mappers.IbanityWebhookEventMapper.toIbanityWebhooks;
import static java.util.UUID.fromString;
@Data
@SuperBuilder(toBuilder = true)
@NoArgsConstructor
@AllArgsConstructor(access = AccessLevel.PRIVATE)
public class IntegrationRevoked implements IbanityWebhookEvent {
public final static String TYPE = "pontoConnect.integration.revoked";
private UUID id;
private String type;
private UUID organization;
private Instant createdAt;
public static Function<DataApiModel, IntegrationRevoked> mappingFunction() {
return dataApiModel -> {
IntegrationRevoked integrationRevoked = toIbanityWebhooks(dataApiModel, IntegrationRevoked.class);
RelationshipsApiModel organizationRelationship = dataApiModel.getRelationships().get("organization");
if (organizationRelationship != null) {
integrationRevoked.setOrganization(fromString(organizationRelationship.getData().getId()));
}
return integrationRevoked;
};
}
}
| 0 |
raw_data\ibanity-java\src\main\java\com\ibanity\apis\client\webhooks\models | raw_data\ibanity-java\src\main\java\com\ibanity\apis\client\webhooks\models\ponto_connect\OrganizationBlocked.java | package com.ibanity.apis.client.webhooks.models.ponto_connect;
import com.ibanity.apis.client.jsonapi.DataApiModel;
import com.ibanity.apis.client.jsonapi.RelationshipsApiModel;
import com.ibanity.apis.client.models.IbanityWebhookEvent;
import lombok.AccessLevel;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;
import java.time.Instant;
import java.util.UUID;
import java.util.function.Function;
import static com.ibanity.apis.client.mappers.IbanityWebhookEventMapper.toIbanityWebhooks;
import static java.util.UUID.fromString;
@Data
@SuperBuilder(toBuilder = true)
@NoArgsConstructor
@AllArgsConstructor(access = AccessLevel.PRIVATE)
public class OrganizationBlocked implements IbanityWebhookEvent {
public final static String TYPE = "pontoConnect.organization.blocked";
private UUID id;
private String type;
private UUID organization;
private Instant createdAt;
public static Function<DataApiModel, OrganizationBlocked> mappingFunction() {
return dataApiModel -> {
OrganizationBlocked organizationBlocked = toIbanityWebhooks(dataApiModel, OrganizationBlocked.class);
RelationshipsApiModel organizationRelationship = dataApiModel.getRelationships().get("organization");
if (organizationRelationship != null) {
organizationBlocked.setOrganization(fromString(organizationRelationship.getData().getId()));
}
return organizationBlocked;
};
}
}
| 0 |
raw_data\ibanity-java\src\main\java\com\ibanity\apis\client\webhooks\models | raw_data\ibanity-java\src\main\java\com\ibanity\apis\client\webhooks\models\ponto_connect\OrganizationUnblocked.java | package com.ibanity.apis.client.webhooks.models.ponto_connect;
import com.ibanity.apis.client.jsonapi.DataApiModel;
import com.ibanity.apis.client.jsonapi.RelationshipsApiModel;
import com.ibanity.apis.client.models.IbanityWebhookEvent;
import lombok.AccessLevel;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;
import java.time.Instant;
import java.util.UUID;
import java.util.function.Function;
import static com.ibanity.apis.client.mappers.IbanityWebhookEventMapper.toIbanityWebhooks;
import static java.util.UUID.fromString;
@Data
@SuperBuilder(toBuilder = true)
@NoArgsConstructor
@AllArgsConstructor(access = AccessLevel.PRIVATE)
public class OrganizationUnblocked implements IbanityWebhookEvent {
public final static String TYPE = "pontoConnect.organization.unblocked";
private UUID id;
private String type;
private UUID organization;
private Instant createdAt;
public static Function<DataApiModel, OrganizationUnblocked> mappingFunction() {
return dataApiModel -> {
OrganizationUnblocked organizationUnblocked = toIbanityWebhooks(dataApiModel, OrganizationUnblocked.class);
RelationshipsApiModel organizationRelationship = dataApiModel.getRelationships().get("organization");
if (organizationRelationship != null) {
organizationUnblocked.setOrganization(fromString(organizationRelationship.getData().getId()));
}
return organizationUnblocked;
};
}
}
| 0 |
raw_data\ibanity-java\src\main\java\com\ibanity\apis\client\webhooks\models | raw_data\ibanity-java\src\main\java\com\ibanity\apis\client\webhooks\models\ponto_connect\SynchronizationFailed.java | package com.ibanity.apis.client.webhooks.models.ponto_connect;
import com.ibanity.apis.client.jsonapi.DataApiModel;
import com.ibanity.apis.client.jsonapi.RelationshipsApiModel;
import com.ibanity.apis.client.models.IbanityWebhookEvent;
import lombok.AccessLevel;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;
import java.time.Instant;
import java.util.UUID;
import java.util.function.Function;
import static com.ibanity.apis.client.mappers.IbanityWebhookEventMapper.toIbanityWebhooks;
import static java.util.UUID.fromString;
@Data
@SuperBuilder(toBuilder = true)
@NoArgsConstructor
@AllArgsConstructor(access = AccessLevel.PRIVATE)
public class SynchronizationFailed implements IbanityWebhookEvent {
public final static String TYPE = "pontoConnect.synchronization.failed";
private UUID id;
private String type;
private UUID accountId;
private UUID synchronizationId;
private UUID organizationId;
private String synchronizationSubtype;
private Instant createdAt;
public static Function<DataApiModel, SynchronizationFailed> mappingFunction() {
return dataApiModel -> {
SynchronizationFailed synchronizationFailed = toIbanityWebhooks(dataApiModel, SynchronizationFailed.class);
RelationshipsApiModel accountRelationship = dataApiModel.getRelationships().get("account");
if (accountRelationship != null) {
synchronizationFailed.setAccountId(fromString(accountRelationship.getData().getId()));
}
RelationshipsApiModel synchronizationRelationship = dataApiModel.getRelationships().get("synchronization");
if (synchronizationRelationship != null) {
synchronizationFailed.setSynchronizationId(fromString(synchronizationRelationship.getData().getId()));
}
RelationshipsApiModel organizationRelationship = dataApiModel.getRelationships().get("organization");
if (organizationRelationship != null) {
synchronizationFailed.setOrganizationId(fromString(organizationRelationship.getData().getId()));
}
return synchronizationFailed;
};
}
}
| 0 |
raw_data\ibanity-java\src\main\java\com\ibanity\apis\client\webhooks\models | raw_data\ibanity-java\src\main\java\com\ibanity\apis\client\webhooks\models\ponto_connect\SynchronizationSucceededWithoutChange.java | package com.ibanity.apis.client.webhooks.models.ponto_connect;
import com.ibanity.apis.client.jsonapi.DataApiModel;
import com.ibanity.apis.client.jsonapi.RelationshipsApiModel;
import com.ibanity.apis.client.models.IbanityWebhookEvent;
import lombok.AccessLevel;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;
import java.time.Instant;
import java.util.UUID;
import java.util.function.Function;
import static com.ibanity.apis.client.mappers.IbanityWebhookEventMapper.toIbanityWebhooks;
import static java.util.UUID.fromString;
@Data
@SuperBuilder(toBuilder = true)
@NoArgsConstructor
@AllArgsConstructor(access = AccessLevel.PRIVATE)
public class SynchronizationSucceededWithoutChange implements IbanityWebhookEvent {
public final static String TYPE = "pontoConnect.synchronization.succeededWithoutChange";
private UUID id;
private String type;
private UUID accountId;
private UUID synchronizationId;
private UUID organizationId;
private String synchronizationSubtype;
private Instant createdAt;
public static Function<DataApiModel, SynchronizationSucceededWithoutChange> mappingFunction() {
return dataApiModel -> {
SynchronizationSucceededWithoutChange synchronizationSucceededWithoutChange = toIbanityWebhooks(dataApiModel, SynchronizationSucceededWithoutChange.class);
RelationshipsApiModel accountRelationship = dataApiModel.getRelationships().get("account");
if (accountRelationship != null) {
synchronizationSucceededWithoutChange.setAccountId(fromString(accountRelationship.getData().getId()));
}
RelationshipsApiModel synchronizationRelationship = dataApiModel.getRelationships().get("synchronization");
if (synchronizationRelationship != null) {
synchronizationSucceededWithoutChange.setSynchronizationId(fromString(synchronizationRelationship.getData().getId()));
}
RelationshipsApiModel organizationRelationship = dataApiModel.getRelationships().get("organization");
if (organizationRelationship != null) {
synchronizationSucceededWithoutChange.setOrganizationId(fromString(organizationRelationship.getData().getId()));
}
return synchronizationSucceededWithoutChange;
};
}
}
| 0 |
raw_data\ibanity-java\src\main\java\com\ibanity\apis\client\webhooks\models | raw_data\ibanity-java\src\main\java\com\ibanity\apis\client\webhooks\models\xs2a\AccountDetailsUpdated.java | package com.ibanity.apis.client.webhooks.models.xs2a;
import com.ibanity.apis.client.jsonapi.DataApiModel;
import com.ibanity.apis.client.jsonapi.RelationshipsApiModel;
import com.ibanity.apis.client.models.IbanityWebhookEvent;
import lombok.AccessLevel;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;
import java.time.Instant;
import java.util.UUID;
import java.util.function.Function;
import static com.ibanity.apis.client.mappers.IbanityWebhookEventMapper.toIbanityWebhooks;
import static java.util.UUID.fromString;
@Data
@SuperBuilder(toBuilder = true)
@NoArgsConstructor
@AllArgsConstructor(access = AccessLevel.PRIVATE)
public class AccountDetailsUpdated implements IbanityWebhookEvent {
public final static String TYPE = "xs2a.account.detailsUpdated";
private UUID id;
private String type;
private UUID accountId;
private UUID synchronizationId;
private UUID batchSynchronizationId;
private Instant createdAt;
public static Function<DataApiModel, AccountDetailsUpdated> mappingFunction() {
return dataApiModel -> {
AccountDetailsUpdated accountDetailsUpdated = toIbanityWebhooks(dataApiModel, AccountDetailsUpdated.class);
RelationshipsApiModel accountRelationship = dataApiModel.getRelationships().get("account");
if (accountRelationship != null) {
accountDetailsUpdated.setAccountId(fromString(accountRelationship.getData().getId()));
}
RelationshipsApiModel synchronizationRelationship = dataApiModel.getRelationships().get("synchronization");
if (synchronizationRelationship != null) {
accountDetailsUpdated.setSynchronizationId(fromString(synchronizationRelationship.getData().getId()));
}
RelationshipsApiModel batchSynchronizationRelationship = dataApiModel.getRelationships().get("batchSynchronization");
if (batchSynchronizationRelationship != null) {
accountDetailsUpdated.setBatchSynchronizationId(fromString(batchSynchronizationRelationship.getData().getId()));
}
return accountDetailsUpdated;
};
}
}
| 0 |
raw_data\ibanity-java\src\main\java\com\ibanity\apis\client\webhooks\models | raw_data\ibanity-java\src\main\java\com\ibanity\apis\client\webhooks\models\xs2a\AccountPendingTransactionsCreated.java | package com.ibanity.apis.client.webhooks.models.xs2a;
import com.ibanity.apis.client.jsonapi.DataApiModel;
import com.ibanity.apis.client.jsonapi.RelationshipsApiModel;
import com.ibanity.apis.client.models.IbanityWebhookEvent;
import lombok.AccessLevel;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;
import java.time.Instant;
import java.util.UUID;
import java.util.function.Function;
import static com.ibanity.apis.client.mappers.IbanityWebhookEventMapper.toIbanityWebhooks;
import static java.util.UUID.fromString;
@Data
@SuperBuilder(toBuilder = true)
@NoArgsConstructor
@AllArgsConstructor(access = AccessLevel.PRIVATE)
public class AccountPendingTransactionsCreated implements IbanityWebhookEvent {
public final static String TYPE = "xs2a.account.pendingTransactionsCreated";
private UUID id;
private String type;
private UUID accountId;
private int count;
private UUID synchronizationId;
private UUID batchSynchronizationId;
private Instant createdAt;
public static Function<DataApiModel, AccountPendingTransactionsCreated> mappingFunction() {
return dataApiModel -> {
AccountPendingTransactionsCreated accountPendingTransactionsCreated = toIbanityWebhooks(dataApiModel, AccountPendingTransactionsCreated.class);
RelationshipsApiModel accountRelationship = dataApiModel.getRelationships().get("account");
if (accountRelationship != null) {
accountPendingTransactionsCreated.setAccountId(fromString(accountRelationship.getData().getId()));
}
RelationshipsApiModel synchronizationRelationship = dataApiModel.getRelationships().get("synchronization");
if (synchronizationRelationship != null) {
accountPendingTransactionsCreated.setSynchronizationId(fromString(synchronizationRelationship.getData().getId()));
}
RelationshipsApiModel batchSynchronizationRelationship = dataApiModel.getRelationships().get("batchSynchronization");
if (batchSynchronizationRelationship != null) {
accountPendingTransactionsCreated.setBatchSynchronizationId(fromString(batchSynchronizationRelationship.getData().getId()));
}
return accountPendingTransactionsCreated;
};
}
}
| 0 |
raw_data\ibanity-java\src\main\java\com\ibanity\apis\client\webhooks\models | raw_data\ibanity-java\src\main\java\com\ibanity\apis\client\webhooks\models\xs2a\AccountPendingTransactionsUpdated.java | package com.ibanity.apis.client.webhooks.models.xs2a;
import com.ibanity.apis.client.jsonapi.DataApiModel;
import com.ibanity.apis.client.jsonapi.RelationshipsApiModel;
import com.ibanity.apis.client.models.IbanityWebhookEvent;
import lombok.AccessLevel;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;
import java.time.Instant;
import java.util.UUID;
import java.util.function.Function;
import static com.ibanity.apis.client.mappers.IbanityWebhookEventMapper.toIbanityWebhooks;
import static java.util.UUID.fromString;
@Data
@SuperBuilder(toBuilder = true)
@NoArgsConstructor
@AllArgsConstructor(access = AccessLevel.PRIVATE)
public class AccountPendingTransactionsUpdated implements IbanityWebhookEvent {
public final static String TYPE = "xs2a.account.pendingTransactionsUpdated";
private UUID id;
private String type;
private UUID accountId;
private UUID synchronizationId;
private UUID batchSynchronizationId;
private int count;
private Instant createdAt;
public static Function<DataApiModel, AccountPendingTransactionsUpdated> mappingFunction() {
return dataApiModel -> {
AccountPendingTransactionsUpdated accountPendingTransactionsCreated = toIbanityWebhooks(dataApiModel, AccountPendingTransactionsUpdated.class);
RelationshipsApiModel accountRelationship = dataApiModel.getRelationships().get("account");
if (accountRelationship != null) {
accountPendingTransactionsCreated.setAccountId(fromString(accountRelationship.getData().getId()));
}
RelationshipsApiModel synchronizationRelationship = dataApiModel.getRelationships().get("synchronization");
if (synchronizationRelationship != null) {
accountPendingTransactionsCreated.setSynchronizationId(fromString(synchronizationRelationship.getData().getId()));
}
RelationshipsApiModel batchSynchronizationRelationship = dataApiModel.getRelationships().get("batchSynchronization");
if (batchSynchronizationRelationship != null) {
accountPendingTransactionsCreated.setBatchSynchronizationId(fromString(batchSynchronizationRelationship.getData().getId()));
}
return accountPendingTransactionsCreated;
};
}
}
| 0 |
raw_data\ibanity-java\src\main\java\com\ibanity\apis\client\webhooks\models | raw_data\ibanity-java\src\main\java\com\ibanity\apis\client\webhooks\models\xs2a\AccountTransactionsCreated.java | package com.ibanity.apis.client.webhooks.models.xs2a;
import com.ibanity.apis.client.jsonapi.DataApiModel;
import com.ibanity.apis.client.jsonapi.RelationshipsApiModel;
import com.ibanity.apis.client.models.IbanityWebhookEvent;
import lombok.AccessLevel;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;
import java.time.Instant;
import java.util.UUID;
import java.util.function.Function;
import static com.ibanity.apis.client.mappers.IbanityWebhookEventMapper.toIbanityWebhooks;
import static java.util.UUID.fromString;
@Data
@SuperBuilder(toBuilder = true)
@NoArgsConstructor
@AllArgsConstructor(access = AccessLevel.PRIVATE)
public class AccountTransactionsCreated implements IbanityWebhookEvent {
public final static String TYPE = "xs2a.account.transactionsCreated";
private UUID id;
private String type;
private UUID accountId;
private int count;
private UUID synchronizationId;
private UUID batchSynchronizationId;
private Instant createdAt;
public static Function<DataApiModel, AccountTransactionsCreated> mappingFunction() {
return dataApiModel -> {
AccountTransactionsCreated accountTransactionsCreated = toIbanityWebhooks(dataApiModel, AccountTransactionsCreated.class);
RelationshipsApiModel accountRelationship = dataApiModel.getRelationships().get("account");
if (accountRelationship != null) {
accountTransactionsCreated.setAccountId(fromString(accountRelationship.getData().getId()));
}
RelationshipsApiModel synchronizationRelationship = dataApiModel.getRelationships().get("synchronization");
if (synchronizationRelationship != null) {
accountTransactionsCreated.setSynchronizationId(fromString(synchronizationRelationship.getData().getId()));
}
RelationshipsApiModel batchSynchronizationRelationship = dataApiModel.getRelationships().get("batchSynchronization");
if (batchSynchronizationRelationship != null) {
accountTransactionsCreated.setBatchSynchronizationId(fromString(batchSynchronizationRelationship.getData().getId()));
}
return accountTransactionsCreated;
};
}
}
| 0 |
raw_data\ibanity-java\src\main\java\com\ibanity\apis\client\webhooks\models | raw_data\ibanity-java\src\main\java\com\ibanity\apis\client\webhooks\models\xs2a\AccountTransactionsDeleted.java | package com.ibanity.apis.client.webhooks.models.xs2a;
import com.ibanity.apis.client.jsonapi.DataApiModel;
import com.ibanity.apis.client.jsonapi.RelationshipsApiModel;
import com.ibanity.apis.client.models.IbanityWebhookEvent;
import lombok.AccessLevel;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;
import java.time.Instant;
import java.util.UUID;
import java.util.function.Function;
import static com.ibanity.apis.client.mappers.IbanityWebhookEventMapper.toIbanityWebhooks;
import static java.util.UUID.fromString;
@Data
@SuperBuilder(toBuilder = true)
@NoArgsConstructor
@AllArgsConstructor(access = AccessLevel.PRIVATE)
public class AccountTransactionsDeleted implements IbanityWebhookEvent {
public final static String TYPE = "xs2a.account.transactionsDeleted";
private UUID id;
private String type;
private UUID accountId;
private UUID transactionDeleteRequestId;
private Instant deletedBefore;
private int count;
private Instant createdAt;
public static Function<DataApiModel, AccountTransactionsDeleted> mappingFunction() {
return dataApiModel -> {
AccountTransactionsDeleted accountTransactionsDeleted = toIbanityWebhooks(dataApiModel, AccountTransactionsDeleted.class);
RelationshipsApiModel accountRelationship = dataApiModel.getRelationships().get("account");
if (accountRelationship != null) {
accountTransactionsDeleted.setAccountId(fromString(accountRelationship.getData().getId()));
}
RelationshipsApiModel transactionDeleteRequestRelationship = dataApiModel.getRelationships().get("transactionDeleteRequest");
if (transactionDeleteRequestRelationship != null) {
accountTransactionsDeleted.setTransactionDeleteRequestId(fromString(transactionDeleteRequestRelationship.getData().getId()));
}
return accountTransactionsDeleted;
};
}
}
| 0 |
raw_data\ibanity-java\src\main\java\com\ibanity\apis\client\webhooks\models | raw_data\ibanity-java\src\main\java\com\ibanity\apis\client\webhooks\models\xs2a\AccountTransactionsUpdated.java | package com.ibanity.apis.client.webhooks.models.xs2a;
import com.ibanity.apis.client.jsonapi.DataApiModel;
import com.ibanity.apis.client.jsonapi.RelationshipsApiModel;
import com.ibanity.apis.client.models.IbanityWebhookEvent;
import lombok.AccessLevel;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;
import java.time.Instant;
import java.util.UUID;
import java.util.function.Function;
import static com.ibanity.apis.client.mappers.IbanityWebhookEventMapper.toIbanityWebhooks;
import static java.util.UUID.fromString;
@Data
@SuperBuilder(toBuilder = true)
@NoArgsConstructor
@AllArgsConstructor(access = AccessLevel.PRIVATE)
public class AccountTransactionsUpdated implements IbanityWebhookEvent {
public final static String TYPE = "xs2a.account.transactionsUpdated";
private UUID id;
private String type;
private UUID accountId;
private UUID synchronizationId;
private UUID batchSynchronizationId;
private int count;
private Instant createdAt;
public static Function<DataApiModel, AccountTransactionsUpdated> mappingFunction() {
return dataApiModel -> {
AccountTransactionsUpdated accountTransactionsUpdated = toIbanityWebhooks(dataApiModel, AccountTransactionsUpdated.class);
RelationshipsApiModel accountRelationship = dataApiModel.getRelationships().get("account");
if (accountRelationship != null) {
accountTransactionsUpdated.setAccountId(fromString(accountRelationship.getData().getId()));
}
RelationshipsApiModel synchronizationRelationship = dataApiModel.getRelationships().get("synchronization");
if (synchronizationRelationship != null) {
accountTransactionsUpdated.setSynchronizationId(fromString(synchronizationRelationship.getData().getId()));
}
RelationshipsApiModel batchSynchronizationRelationship = dataApiModel.getRelationships().get("batchSynchronization");
if (batchSynchronizationRelationship != null) {
accountTransactionsUpdated.setBatchSynchronizationId(fromString(batchSynchronizationRelationship.getData().getId()));
}
return accountTransactionsUpdated;
};
}
}
| 0 |
raw_data\ibanity-java\src\main\java\com\ibanity\apis\client\webhooks\models | raw_data\ibanity-java\src\main\java\com\ibanity\apis\client\webhooks\models\xs2a\BulkPaymentInitiationRequestAuthorizationCompleted.java | package com.ibanity.apis.client.webhooks.models.xs2a;
import com.ibanity.apis.client.jsonapi.DataApiModel;
import com.ibanity.apis.client.jsonapi.RelationshipsApiModel;
import com.ibanity.apis.client.models.IbanityWebhookEvent;
import lombok.AccessLevel;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;
import java.time.Instant;
import java.util.UUID;
import java.util.function.Function;
import static com.ibanity.apis.client.mappers.IbanityWebhookEventMapper.toIbanityWebhooks;
import static java.util.UUID.fromString;
@Data
@SuperBuilder(toBuilder = true)
@NoArgsConstructor
@AllArgsConstructor(access = AccessLevel.PRIVATE)
public class BulkPaymentInitiationRequestAuthorizationCompleted implements IbanityWebhookEvent {
public final static String TYPE = "xs2a.bulkPaymentInitiationRequest.authorizationCompleted";
private UUID id;
private String type;
private UUID bulkPaymentInitiationRequestId;
private String status;
private Instant createdAt;
public static Function<DataApiModel, BulkPaymentInitiationRequestAuthorizationCompleted> mappingFunction() {
return dataApiModel -> {
BulkPaymentInitiationRequestAuthorizationCompleted bulkPaymentInitiationRequestAuthorizationCompleted = toIbanityWebhooks(dataApiModel, BulkPaymentInitiationRequestAuthorizationCompleted.class);
RelationshipsApiModel bulkPaymentInitiationRequestRelationship = dataApiModel.getRelationships().get("bulkPaymentInitiationRequest");
if (bulkPaymentInitiationRequestRelationship != null) {
bulkPaymentInitiationRequestAuthorizationCompleted.setBulkPaymentInitiationRequestId(fromString(bulkPaymentInitiationRequestRelationship.getData().getId()));
}
return bulkPaymentInitiationRequestAuthorizationCompleted;
};
}
}
| 0 |
raw_data\ibanity-java\src\main\java\com\ibanity\apis\client\webhooks\models | raw_data\ibanity-java\src\main\java\com\ibanity\apis\client\webhooks\models\xs2a\BulkPaymentInitiationRequestStatusUpdated.java | package com.ibanity.apis.client.webhooks.models.xs2a;
import com.ibanity.apis.client.jsonapi.DataApiModel;
import com.ibanity.apis.client.jsonapi.RelationshipsApiModel;
import com.ibanity.apis.client.models.IbanityWebhookEvent;
import lombok.AccessLevel;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;
import java.time.Instant;
import java.util.UUID;
import java.util.function.Function;
import static com.ibanity.apis.client.mappers.IbanityWebhookEventMapper.toIbanityWebhooks;
import static java.util.UUID.fromString;
@Data
@SuperBuilder(toBuilder = true)
@NoArgsConstructor
@AllArgsConstructor(access = AccessLevel.PRIVATE)
public class BulkPaymentInitiationRequestStatusUpdated implements IbanityWebhookEvent {
public final static String TYPE = "xs2a.bulkPaymentInitiationRequest.statusUpdated";
private UUID id;
private String type;
private UUID bulkPaymentInitiationRequestId;
private String status;
private Instant createdAt;
public static Function<DataApiModel, BulkPaymentInitiationRequestStatusUpdated> mappingFunction() {
return dataApiModel -> {
BulkPaymentInitiationRequestStatusUpdated bulkPaymentInitiationRequestStatusUpdated = toIbanityWebhooks(dataApiModel, BulkPaymentInitiationRequestStatusUpdated.class);
RelationshipsApiModel bulkPaymentInitiationRequestRelationship = dataApiModel.getRelationships().get("bulkPaymentInitiationRequest");
if (bulkPaymentInitiationRequestRelationship != null) {
bulkPaymentInitiationRequestStatusUpdated.setBulkPaymentInitiationRequestId(fromString(bulkPaymentInitiationRequestRelationship.getData().getId()));
}
return bulkPaymentInitiationRequestStatusUpdated;
};
}
}
| 0 |
raw_data\ibanity-java\src\main\java\com\ibanity\apis\client\webhooks\models | raw_data\ibanity-java\src\main\java\com\ibanity\apis\client\webhooks\models\xs2a\PaymentInitiationRequestAuthorizationCompleted.java | package com.ibanity.apis.client.webhooks.models.xs2a;
import com.ibanity.apis.client.jsonapi.DataApiModel;
import com.ibanity.apis.client.jsonapi.RelationshipsApiModel;
import com.ibanity.apis.client.models.IbanityWebhookEvent;
import lombok.AccessLevel;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;
import java.time.Instant;
import java.util.UUID;
import java.util.function.Function;
import static com.ibanity.apis.client.mappers.IbanityWebhookEventMapper.toIbanityWebhooks;
import static java.util.UUID.fromString;
@Data
@SuperBuilder(toBuilder = true)
@NoArgsConstructor
@AllArgsConstructor(access = AccessLevel.PRIVATE)
public class PaymentInitiationRequestAuthorizationCompleted implements IbanityWebhookEvent {
public final static String TYPE = "xs2a.paymentInitiationRequest.authorizationCompleted";
private UUID id;
private String type;
private UUID paymentInitiationRequestId;
private String status;
private Instant createdAt;
public static Function<DataApiModel, PaymentInitiationRequestAuthorizationCompleted> mappingFunction() {
return dataApiModel -> {
PaymentInitiationRequestAuthorizationCompleted paymentInitiationRequestAuthorizationCompleted = toIbanityWebhooks(dataApiModel, PaymentInitiationRequestAuthorizationCompleted.class);
RelationshipsApiModel paymentInitiationRequestRelationship = dataApiModel.getRelationships().get("paymentInitiationRequest");
if (paymentInitiationRequestRelationship != null) {
paymentInitiationRequestAuthorizationCompleted.setPaymentInitiationRequestId(fromString(paymentInitiationRequestRelationship.getData().getId()));
}
return paymentInitiationRequestAuthorizationCompleted;
};
}
}
| 0 |
raw_data\ibanity-java\src\main\java\com\ibanity\apis\client\webhooks\models | raw_data\ibanity-java\src\main\java\com\ibanity\apis\client\webhooks\models\xs2a\PaymentInitiationRequestStatusUpdated.java | package com.ibanity.apis.client.webhooks.models.xs2a;
import com.ibanity.apis.client.jsonapi.DataApiModel;
import com.ibanity.apis.client.jsonapi.RelationshipsApiModel;
import com.ibanity.apis.client.models.IbanityWebhookEvent;
import lombok.AccessLevel;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;
import java.time.Instant;
import java.util.UUID;
import java.util.function.Function;
import static com.ibanity.apis.client.mappers.IbanityWebhookEventMapper.toIbanityWebhooks;
import static java.util.UUID.fromString;
@Data
@SuperBuilder(toBuilder = true)
@NoArgsConstructor
@AllArgsConstructor(access = AccessLevel.PRIVATE)
public class PaymentInitiationRequestStatusUpdated implements IbanityWebhookEvent {
public final static String TYPE = "xs2a.paymentInitiationRequest.statusUpdated";
private UUID id;
private String type;
private UUID paymentInitiationRequestId;
private String status;
private Instant createdAt;
public static Function<DataApiModel, PaymentInitiationRequestStatusUpdated> mappingFunction() {
return dataApiModel -> {
PaymentInitiationRequestStatusUpdated paymentInitiationRequestStatusUpdated = toIbanityWebhooks(dataApiModel, PaymentInitiationRequestStatusUpdated.class);
RelationshipsApiModel paymentInitiationRequestRelationship = dataApiModel.getRelationships().get("paymentInitiationRequest");
if (paymentInitiationRequestRelationship != null) {
paymentInitiationRequestStatusUpdated.setPaymentInitiationRequestId(fromString(paymentInitiationRequestRelationship.getData().getId()));
}
return paymentInitiationRequestStatusUpdated;
};
}
}
| 0 |
raw_data\ibanity-java\src\main\java\com\ibanity\apis\client\webhooks\models | raw_data\ibanity-java\src\main\java\com\ibanity\apis\client\webhooks\models\xs2a\PeriodicPaymentInitiationRequestAuthorizationCompleted.java | package com.ibanity.apis.client.webhooks.models.xs2a;
import com.ibanity.apis.client.jsonapi.DataApiModel;
import com.ibanity.apis.client.jsonapi.RelationshipsApiModel;
import com.ibanity.apis.client.models.IbanityWebhookEvent;
import lombok.AccessLevel;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;
import java.time.Instant;
import java.util.UUID;
import java.util.function.Function;
import static com.ibanity.apis.client.mappers.IbanityWebhookEventMapper.toIbanityWebhooks;
import static java.util.UUID.fromString;
@Data
@SuperBuilder(toBuilder = true)
@NoArgsConstructor
@AllArgsConstructor(access = AccessLevel.PRIVATE)
public class PeriodicPaymentInitiationRequestAuthorizationCompleted implements IbanityWebhookEvent {
public final static String TYPE = "xs2a.periodicPaymentInitiationRequest.authorizationCompleted";
private UUID id;
private String type;
private UUID periodicPaymentInitiationRequestId;
private String status;
private Instant createdAt;
public static Function<DataApiModel, PeriodicPaymentInitiationRequestAuthorizationCompleted> mappingFunction() {
return dataApiModel -> {
PeriodicPaymentInitiationRequestAuthorizationCompleted periodicPaymentInitiationRequestAuthorizationCompleted = toIbanityWebhooks(dataApiModel, PeriodicPaymentInitiationRequestAuthorizationCompleted.class);
RelationshipsApiModel periodicPaymentInitiationRequestRelationship = dataApiModel.getRelationships().get("periodicPaymentInitiationRequest");
if (periodicPaymentInitiationRequestRelationship != null) {
periodicPaymentInitiationRequestAuthorizationCompleted.setPeriodicPaymentInitiationRequestId(fromString(periodicPaymentInitiationRequestRelationship.getData().getId()));
}
return periodicPaymentInitiationRequestAuthorizationCompleted;
};
}
}
| 0 |
raw_data\ibanity-java\src\main\java\com\ibanity\apis\client\webhooks\models | raw_data\ibanity-java\src\main\java\com\ibanity\apis\client\webhooks\models\xs2a\PeriodicPaymentInitiationRequestStatusUpdated.java | package com.ibanity.apis.client.webhooks.models.xs2a;
import com.ibanity.apis.client.jsonapi.DataApiModel;
import com.ibanity.apis.client.jsonapi.RelationshipsApiModel;
import com.ibanity.apis.client.models.IbanityWebhookEvent;
import lombok.AccessLevel;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;
import java.time.Instant;
import java.util.UUID;
import java.util.function.Function;
import static com.ibanity.apis.client.mappers.IbanityWebhookEventMapper.toIbanityWebhooks;
import static java.util.UUID.fromString;
@Data
@SuperBuilder(toBuilder = true)
@NoArgsConstructor
@AllArgsConstructor(access = AccessLevel.PRIVATE)
public class PeriodicPaymentInitiationRequestStatusUpdated implements IbanityWebhookEvent {
public final static String TYPE = "xs2a.periodicPaymentInitiationRequest.statusUpdated";
private UUID id;
private String type;
private UUID periodicPaymentInitiationRequestId;
private String status;
private Instant createdAt;
public static Function<DataApiModel, PeriodicPaymentInitiationRequestStatusUpdated> mappingFunction() {
return dataApiModel -> {
PeriodicPaymentInitiationRequestStatusUpdated periodicPaymentInitiationRequestStatusUpdated = toIbanityWebhooks(dataApiModel, PeriodicPaymentInitiationRequestStatusUpdated.class);
RelationshipsApiModel periodicPaymentInitiationRequestRelationship = dataApiModel.getRelationships().get("periodicPaymentInitiationRequest");
if (periodicPaymentInitiationRequestRelationship != null) {
periodicPaymentInitiationRequestStatusUpdated.setPeriodicPaymentInitiationRequestId(fromString(periodicPaymentInitiationRequestRelationship.getData().getId()));
}
return periodicPaymentInitiationRequestStatusUpdated;
};
}
}
| 0 |
raw_data\ibanity-java\src\main\java\com\ibanity\apis\client\webhooks\models | raw_data\ibanity-java\src\main\java\com\ibanity\apis\client\webhooks\models\xs2a\SynchronizationFailed.java | package com.ibanity.apis.client.webhooks.models.xs2a;
import com.ibanity.apis.client.jsonapi.DataApiModel;
import com.ibanity.apis.client.jsonapi.RelationshipsApiModel;
import com.ibanity.apis.client.models.IbanityWebhookEvent;
import lombok.AccessLevel;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;
import java.time.Instant;
import java.util.UUID;
import java.util.function.Function;
import static com.ibanity.apis.client.mappers.IbanityWebhookEventMapper.toIbanityWebhooks;
import static java.util.UUID.fromString;
@Data
@SuperBuilder(toBuilder = true)
@NoArgsConstructor
@AllArgsConstructor(access = AccessLevel.PRIVATE)
public class SynchronizationFailed implements IbanityWebhookEvent {
public final static String TYPE = "xs2a.synchronization.failed";
private UUID id;
private String type;
private UUID accountId;
private UUID synchronizationId;
private UUID batchSynchronizationId;
private String synchronizationSubtype;
private Instant createdAt;
public static Function<DataApiModel, SynchronizationFailed> mappingFunction() {
return dataApiModel -> {
SynchronizationFailed synchronizationFailed = toIbanityWebhooks(dataApiModel, SynchronizationFailed.class);
RelationshipsApiModel accountRelationship = dataApiModel.getRelationships().get("account");
if (accountRelationship != null) {
synchronizationFailed.setAccountId(fromString(accountRelationship.getData().getId()));
}
RelationshipsApiModel synchronizationRelationship = dataApiModel.getRelationships().get("synchronization");
if (synchronizationRelationship != null) {
synchronizationFailed.setSynchronizationId(fromString(synchronizationRelationship.getData().getId()));
}
RelationshipsApiModel batchSynchronizationRelationship = dataApiModel.getRelationships().get("batchSynchronization");
if (batchSynchronizationRelationship != null) {
synchronizationFailed.setBatchSynchronizationId(fromString(batchSynchronizationRelationship.getData().getId()));
}
return synchronizationFailed;
};
}
}
| 0 |
raw_data\ibanity-java\src\main\java\com\ibanity\apis\client\webhooks\models | raw_data\ibanity-java\src\main\java\com\ibanity\apis\client\webhooks\models\xs2a\SynchronizationSucceededWithoutChange.java | package com.ibanity.apis.client.webhooks.models.xs2a;
import com.ibanity.apis.client.jsonapi.DataApiModel;
import com.ibanity.apis.client.jsonapi.RelationshipsApiModel;
import com.ibanity.apis.client.models.IbanityWebhookEvent;
import lombok.AccessLevel;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.SuperBuilder;
import java.time.Instant;
import java.util.UUID;
import java.util.function.Function;
import static com.ibanity.apis.client.mappers.IbanityWebhookEventMapper.toIbanityWebhooks;
import static java.util.UUID.fromString;
@Data
@SuperBuilder(toBuilder = true)
@NoArgsConstructor
@AllArgsConstructor(access = AccessLevel.PRIVATE)
public class SynchronizationSucceededWithoutChange implements IbanityWebhookEvent {
public final static String TYPE = "xs2a.synchronization.succeededWithoutChange";
private UUID id;
private String type;
private UUID accountId;
private UUID synchronizationId;
private UUID batchSynchronizationId;
private String synchronizationSubtype;
private Instant createdAt;
public static Function<DataApiModel, SynchronizationSucceededWithoutChange> mappingFunction() {
return dataApiModel -> {
SynchronizationSucceededWithoutChange synchronizationSucceededWithoutChange = toIbanityWebhooks(dataApiModel, SynchronizationSucceededWithoutChange.class);
RelationshipsApiModel accountRelationship = dataApiModel.getRelationships().get("account");
if (accountRelationship != null) {
synchronizationSucceededWithoutChange.setAccountId(fromString(accountRelationship.getData().getId()));
}
RelationshipsApiModel synchronizationRelationship = dataApiModel.getRelationships().get("synchronization");
if (synchronizationRelationship != null) {
synchronizationSucceededWithoutChange.setSynchronizationId(fromString(synchronizationRelationship.getData().getId()));
}
RelationshipsApiModel batchSynchronizationRelationship = dataApiModel.getRelationships().get("batchSynchronization");
if (batchSynchronizationRelationship != null) {
synchronizationSucceededWithoutChange.setBatchSynchronizationId(fromString(batchSynchronizationRelationship.getData().getId()));
}
return synchronizationSucceededWithoutChange;
};
}
}
| 0 |
raw_data\ibanity-java\src\main\java\com\ibanity\apis\client\webhooks | raw_data\ibanity-java\src\main\java\com\ibanity\apis\client\webhooks\services\KeysService.java | package com.ibanity.apis.client.webhooks.services;
import com.ibanity.apis.client.webhooks.models.Key;
import java.util.List;
public interface KeysService {
List<Key> list();
}
| 0 |
raw_data\ibanity-java\src\main\java\com\ibanity\apis\client\webhooks | raw_data\ibanity-java\src\main\java\com\ibanity\apis\client\webhooks\services\WebhooksService.java | package com.ibanity.apis.client.webhooks.services;
import com.ibanity.apis.client.models.IbanityWebhookEvent;
public interface WebhooksService {
IbanityWebhookEvent verifyAndParseEvent(String payload, String jwt);
void verify(String payload, String jwt);
KeysService keysService();
}
| 0 |
raw_data\ibanity-java\src\main\java\com\ibanity\apis\client\webhooks\services | raw_data\ibanity-java\src\main\java\com\ibanity\apis\client\webhooks\services\impl\KeysServiceImpl.java | package com.ibanity.apis.client.webhooks.services.impl;
import com.ibanity.apis.client.http.IbanityHttpClient;
import com.ibanity.apis.client.services.ApiUrlProvider;
import com.ibanity.apis.client.utils.IbanityUtils;
import com.ibanity.apis.client.webhooks.models.Key;
import com.ibanity.apis.client.webhooks.services.KeysService;
import lombok.*;
import org.apache.http.HttpResponse;
import java.io.IOException;
import java.util.List;
import static com.ibanity.apis.client.mappers.ModelMapperHelper.readResponseContent;
import static com.ibanity.apis.client.utils.URIHelper.buildUri;
import static java.util.Collections.emptyList;
public class KeysServiceImpl implements KeysService {
private final IbanityHttpClient ibanityHttpClient;
private final ApiUrlProvider apiUrlProvider;
public KeysServiceImpl(ApiUrlProvider apiUrlProvider, IbanityHttpClient ibanityHttpClient) {
this.ibanityHttpClient = ibanityHttpClient;
this.apiUrlProvider = apiUrlProvider;
}
@Override
public List<Key> list() {
HttpResponse httpResponse = ibanityHttpClient.get(buildUri(apiUrlProvider.find("webhooks", "keys")));
try {
String payload = readResponseContent(httpResponse.getEntity());
JwksApi jwksApi = IbanityUtils.objectMapper().readValue(payload, JwksApi.class);
return jwksApi.getKeys();
} catch (IOException e) {
throw new IllegalArgumentException("Response cannot be parsed", e);
}
}
@Builder
@Getter
@NoArgsConstructor
@AllArgsConstructor(access = AccessLevel.PRIVATE)
private static class JwksApi {
@Builder.Default
private List<Key> keys = emptyList();
}
}
| 0 |
raw_data\ibanity-java\src\main\java\com\ibanity\apis\client\webhooks\services | raw_data\ibanity-java\src\main\java\com\ibanity\apis\client\webhooks\services\impl\WebhooksServiceImpl.java | package com.ibanity.apis.client.webhooks.services.impl;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonNode;
import com.ibanity.apis.client.exceptions.IbanityRuntimeException;
import com.ibanity.apis.client.http.IbanityHttpClient;
import com.ibanity.apis.client.models.IbanityWebhookEvent;
import com.ibanity.apis.client.services.ApiUrlProvider;
import com.ibanity.apis.client.utils.IbanityUtils;
import com.ibanity.apis.client.utils.WebhooksUtils;
import com.ibanity.apis.client.webhooks.services.KeysService;
import com.ibanity.apis.client.webhooks.services.WebhooksService;
import org.jose4j.jwt.MalformedClaimException;
import org.jose4j.jwt.consumer.InvalidJwtException;
import org.jose4j.jwt.consumer.JwtConsumer;
import org.jose4j.jwt.consumer.JwtContext;
import static com.ibanity.apis.client.utils.WebhooksUtils.getDigest;
public class WebhooksServiceImpl implements WebhooksService {
private final JwtConsumer jwtConsumer;
private final KeysService keysService;
public WebhooksServiceImpl(ApiUrlProvider apiUrlProvider, IbanityHttpClient ibanityHttpClient, JwtConsumer jwtConsumer) {
this.jwtConsumer = jwtConsumer;
this.keysService = new KeysServiceImpl(apiUrlProvider, ibanityHttpClient);
}
@Override
public IbanityWebhookEvent verifyAndParseEvent(String payload, String jwt) {
verify(payload, jwt);
try {
JsonNode jsonNode = IbanityUtils.objectMapper().readTree(payload);
String type = jsonNode.get("data").get("type").textValue();
return WebhooksUtils.webhookEventParser(payload, type);
} catch (JsonProcessingException exception) {
throw new IllegalArgumentException("Response cannot be parsed", exception);
}
}
@Override
public void verify(String payload, String jwt) {
try {
JwtContext jwtContext = jwtConsumer.process(jwt);
String digest = getDigest(payload);
if (!digest.equals(jwtContext.getJwtClaims().getStringClaimValue("digest"))) {
throw new IbanityRuntimeException("Signature digest value mismatch.");
}
} catch (InvalidJwtException | MalformedClaimException e) {
throw new IbanityRuntimeException(e.getMessage(), e);
}
}
@Override
public KeysService keysService() {
return keysService;
}
}
| 0 |
raw_data\ibanity-java\src\test\java\com\ibanity\apis\client | raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\helpers\IbanityClientSecurityAuthenticationPropertiesKeys.java | package com.ibanity.apis.client.helpers;
public interface IbanityClientSecurityAuthenticationPropertiesKeys {
String IBANITY_CLIENT_TLS_CERTIFICATE_PATH_PROPERTY_KEY = "client.tls.certificate.path";
String IBANITY_CLIENT_TLS_PRIVATE_KEY_PATH_PROPERTY_KEY = "client.tls.private-key.path";
String IBANITY_CLIENT_TLS_PRIVATE_KEY_PASSPHRASE_PROPERTY_KEY = "client.tls.private-key.passphrase";
String IBANITY_CLIENT_TLS_CA_CERTIFICATE_PATH_PROPERTY_KEY = "client.tls.ca.certificate.path";
}
| 0 |
raw_data\ibanity-java\src\test\java\com\ibanity\apis\client | raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\helpers\IbanityClientSecuritySignaturePropertiesKeys.java | package com.ibanity.apis.client.helpers;
public interface IbanityClientSecuritySignaturePropertiesKeys {
String IBANITY_CLIENT_SIGNATURE_CERTIFICATE_PATH_PROPERTY_KEY = "client.signature.certificate.path";
String IBANITY_CLIENT_SIGNATURE_CERTIFICATE_ID_PROPERTY_KEY = "client.signature.certificate.id";
String IBANITY_CLIENT_SIGNATURE_PRIVATE_KEY_PATH_PROPERTY_KEY = "client.signature.private-key.path";
String IBANITY_CLIENT_SIGNATURE_PRIVATE_KEY_PASSPHRASE_PROPERTY_KEY = "client.signature.private-key.passphrase";
}
| 0 |
raw_data\ibanity-java\src\test\java\com\ibanity\apis\client | raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\helpers\IbanityConfiguration.java | package com.ibanity.apis.client.helpers;
import org.apache.commons.configuration2.Configuration;
import org.apache.commons.configuration2.PropertiesConfiguration;
import org.apache.commons.configuration2.builder.FileBasedConfigurationBuilder;
import org.apache.commons.configuration2.builder.fluent.FileBasedBuilderParameters;
import org.apache.commons.configuration2.builder.fluent.Parameters;
import org.apache.commons.configuration2.ex.ConfigurationException;
import org.apache.commons.configuration2.io.*;
import java.util.Arrays;
import java.util.List;
public final class IbanityConfiguration {
public static final String IBANITY_PROPERTIES_PREFIX = "ibanity.";
public static final String IBANITY_API_ENDPOINT_PROPERTY_KEY = "api.endpoint";
public static final String IBANITY_APPLICATION_ID = "application.id";
private static final String PROPERTIES_FILE = "ibanity.properties";
private static Configuration configuration = null;
private IbanityConfiguration() {
}
public static String getConfiguration(final String configurationKey) {
return getConfiguration(configurationKey, null);
}
public static String getConfiguration(final String configurationKey, String defaultValue) {
return getConfigurationInstance().getString(IBANITY_PROPERTIES_PREFIX + configurationKey, defaultValue);
}
private static synchronized Configuration getConfigurationInstance() {
if (configuration == null) {
try {
configuration = loadProperties();
} catch (ConfigurationException configurationException) {
throw new IllegalStateException(PROPERTIES_FILE + " couldn't be found", configurationException);
}
}
return configuration;
}
private static Configuration loadProperties() throws ConfigurationException {
List<FileLocationStrategy> subs = Arrays.asList(
new ProvidedURLLocationStrategy(),
new FileSystemLocationStrategy(),
new ClasspathLocationStrategy());
FileLocationStrategy strategy = new CombinedLocationStrategy(subs);
FileBasedBuilderParameters builderParameters = new Parameters()
.fileBased()
.setLocationStrategy(strategy)
.setFileName(PROPERTIES_FILE);
return new FileBasedConfigurationBuilder<>(PropertiesConfiguration.class)
.configure(builderParameters)
.getConfiguration();
}
}
| 0 |
raw_data\ibanity-java\src\test\java\com\ibanity\apis\client | raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\helpers\IbanityTestHelper.java | package com.ibanity.apis.client.helpers;
import org.apache.commons.io.IOUtils;
import org.apache.http.Header;
import org.apache.http.HttpResponse;
import org.apache.http.ProtocolVersion;
import org.apache.http.entity.StringEntity;
import org.apache.http.message.BasicHttpResponse;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import static java.nio.charset.StandardCharsets.UTF_8;
import static java.util.Objects.requireNonNull;
public class IbanityTestHelper {
public static final ProtocolVersion HTTP = new ProtocolVersion("HTTP", 0, 0);
public static HttpResponse loadHttpResponse(String filePath) throws IOException {
String jsonResponse = loadFile(filePath);
HttpResponse httpResponse = new BasicHttpResponse(HTTP, 200, null);
httpResponse.setEntity(new StringEntity(jsonResponse));
return httpResponse;
}
public static HttpResponse createHttpResponse(String expected) throws UnsupportedEncodingException {
return createHttpResponse(expected, new Header[]{});
}
public static HttpResponse createHttpResponse(String expected, Header... headers) throws UnsupportedEncodingException {
HttpResponse postResponse = new BasicHttpResponse(HTTP, 200, null);
postResponse.setEntity(new StringEntity(expected));
postResponse.setHeaders(headers);
return postResponse;
}
public static String loadFile(String filePath) throws IOException {
return IOUtils.toString(
requireNonNull(IbanityTestHelper.class.getClassLoader().getResourceAsStream(filePath)), UTF_8);
}
}
| 0 |
raw_data\ibanity-java\src\test\java\com\ibanity\apis\client | raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\helpers\KeyToolHelper.java | package com.ibanity.apis.client.helpers;
import org.apache.commons.io.FileUtils;
import org.apache.commons.io.IOUtils;
import org.bouncycastle.jce.provider.BouncyCastleProvider;
import org.bouncycastle.openssl.PEMDecryptorProvider;
import org.bouncycastle.openssl.PEMEncryptedKeyPair;
import org.bouncycastle.openssl.PEMKeyPair;
import org.bouncycastle.openssl.PEMParser;
import org.bouncycastle.openssl.jcajce.JcaPEMKeyConverter;
import org.bouncycastle.openssl.jcajce.JcePEMDecryptorProviderBuilder;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.io.StringReader;
import java.security.PrivateKey;
import java.security.Security;
import java.security.cert.Certificate;
import java.security.cert.CertificateException;
import java.security.cert.CertificateFactory;
public final class KeyToolHelper {
private static final String CERTIFICATE_FACTORY_X509_TYPE = "X.509";
private static final CertificateFactory CERTIFICATE_FACTORY_INSTANCE;
private static final String BOUNCY_CASTLE_PROVIDER = "BC";
static {
Security.addProvider(new BouncyCastleProvider());
try {
CERTIFICATE_FACTORY_INSTANCE = CertificateFactory.getInstance(CERTIFICATE_FACTORY_X509_TYPE);
} catch (CertificateException exception) {
throw new IllegalStateException("Unable to create CERTIFICATE_FACTORY_INSTANCE");
}
}
public static Certificate loadCertificate(final String certificatePath) throws CertificateException {
try {
InputStream is = FileUtils.openInputStream(new File(certificatePath));
return getCertificateFactory().generateCertificate(is);
} catch (IOException exception) {
throw new IllegalArgumentException(new FileNotFoundException("Resource Path not found:" + certificatePath));
}
}
public static PrivateKey loadPrivateKey(String privateKeyPath, String privateKeyPassPhrase) throws IOException {
try (InputStream is = FileUtils.openInputStream(new File(privateKeyPath))) {
String privateKeyPem = new String(IOUtils.toByteArray(is));
PEMEncryptedKeyPair encryptedKeyPair = (PEMEncryptedKeyPair) new PEMParser(new StringReader(privateKeyPem)).readObject();
PEMDecryptorProvider decryptorProvider = new JcePEMDecryptorProviderBuilder()
.build(privateKeyPassPhrase.toCharArray());
PEMKeyPair pemKeyPair = encryptedKeyPair.decryptKeyPair(decryptorProvider);
JcaPEMKeyConverter jcaPEMKeyConverter = new JcaPEMKeyConverter().setProvider(BOUNCY_CASTLE_PROVIDER);
jcaPEMKeyConverter.setProvider(BOUNCY_CASTLE_PROVIDER);
return jcaPEMKeyConverter.getPrivateKey(pemKeyPair.getPrivateKeyInfo());
}
}
private static CertificateFactory getCertificateFactory() {
return CERTIFICATE_FACTORY_INSTANCE;
}
}
| 0 |
raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\http | raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\http\handler\IbanityResponseHandlerTest.java | package com.ibanity.apis.client.http.handler;
import com.ibanity.apis.client.exceptions.IbanityClientException;
import com.ibanity.apis.client.exceptions.IbanityServerException;
import com.ibanity.apis.client.models.ErrorMeta;
import com.ibanity.apis.client.models.FinancialInstitutionResponse;
import com.ibanity.apis.client.models.IbanityError;
import org.apache.http.HttpResponse;
import org.apache.http.ProtocolVersion;
import org.apache.http.client.entity.EntityBuilder;
import org.apache.http.message.BasicHeader;
import org.apache.http.message.BasicStatusLine;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import java.io.IOException;
import java.time.Instant;
import java.util.Collections;
import java.util.List;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
class IbanityResponseHandlerTest {
private static final String REQUEST_ID = "thisIsARequestId";
private static final String IBANITY_REQUEST_ID_HEADER = "ibanity-request-id";
private IbanityResponseHandler ibanityResponseHandler = new IbanityResponseHandler();
@Mock
private HttpResponse httpResponse;
@Test
void handleResponse() throws IOException {
when(httpResponse.getStatusLine()).thenReturn(new BasicStatusLine(dummyProtocolVersion(), 200, ""));
HttpResponse actual = ibanityResponseHandler.handleResponse(httpResponse);
assertThat(actual).isEqualTo(httpResponse);
}
@Test
void handleResponse_whenServerError_thenThrowIbanityServerSideException() {
//language=JSON
String expected = errorPayloadWithJson();
when(httpResponse.getEntity()).thenReturn(EntityBuilder.create().setText(expected).build());
when(httpResponse.getStatusLine()).thenReturn(new BasicStatusLine(dummyProtocolVersion(), 500, ""));
when(httpResponse.getFirstHeader(IBANITY_REQUEST_ID_HEADER)).thenReturn(new BasicHeader(IBANITY_REQUEST_ID_HEADER, REQUEST_ID));
IbanityServerException actual = assertThrows(IbanityServerException.class, () -> ibanityResponseHandler.handleResponse(httpResponse));
assertThat(actual).isEqualToComparingFieldByFieldRecursively(new IbanityServerException(createExpectedErrorsWithJson(), 500, REQUEST_ID));
}
@Test
void handleResponse_whenResourceNotFound_thenThrowIbanityClientSideException() {
//language=JSON
String expected = errorPayloadWithJson();
when(httpResponse.getEntity()).thenReturn(EntityBuilder.create().setText(expected).build());
when(httpResponse.getStatusLine()).thenReturn(new BasicStatusLine(dummyProtocolVersion(), 404, ""));
when(httpResponse.getFirstHeader(IBANITY_REQUEST_ID_HEADER)).thenReturn(new BasicHeader(IBANITY_REQUEST_ID_HEADER, REQUEST_ID));
IbanityClientException actual = assertThrows(IbanityClientException.class, () -> ibanityResponseHandler.handleResponse(httpResponse));
assertThat(actual).isEqualToComparingFieldByFieldRecursively(new IbanityServerException(createExpectedErrorsWithJson(), 404, REQUEST_ID));
}
@Test
void handleResponse_whenResourceNotFoundAndNoRequestId_thenThrowIbanityClientSideException() {
//language=JSON
String expected = errorPayloadWithHtml();
when(httpResponse.getEntity()).thenReturn(EntityBuilder.create().setText(expected).build());
when(httpResponse.getStatusLine()).thenReturn(new BasicStatusLine(dummyProtocolVersion(), 404, ""));
when(httpResponse.getFirstHeader(IBANITY_REQUEST_ID_HEADER)).thenReturn(null);
IbanityClientException actual = assertThrows(IbanityClientException.class, () -> ibanityResponseHandler.handleResponse(httpResponse));
assertThat(actual).isEqualToComparingFieldByFieldRecursively(new IbanityServerException(createExpectedErrorsWithHtml(), 404, null));
}
private List<IbanityError> createExpectedErrors(String body) {
return Collections.singletonList(IbanityError.builder()
.code("invalidCredentials")
.detail("Your credentials are invalid.")
.meta(ErrorMeta.builder()
.financialInstitutionResponse(FinancialInstitutionResponse.builder()
.body(body)
.requestId("354fwfwef4w684")
.statusCode(500)
.timestamp(Instant.parse("2019-05-09T09:18:00.000Z"))
.requestUri("http://google.com")
.build())
.build())
.build());
}
private List<IbanityError> createExpectedErrorsWithJson() {
return createExpectedErrors("{\"tppMessages\":[{\"category\":\"ERROR\",\"code\":\"NOT_FOUND\",\"text\":\"3.2 - Not Found\"}]}");
}
private List<IbanityError> createExpectedErrorsWithHtml() {
return createExpectedErrors("<html><head>SomeHtml</head></html>");
}
private String errorPayloadWithHtml() {
return "{\n" +
" \"errors\": [\n" +
" {\n" +
" \"code\": \"invalidCredentials\",\n" +
" \"detail\": \"Your credentials are invalid.\",\n" +
" \"meta\": {\n" +
" \"financialInstitutionResponse\": {\n" +
" \"statusCode\": 500,\n" +
" \"body\": \"<html><head>SomeHtml</head></html>\",\n" +
" \"requestId\": \"354fwfwef4w684\",\n" +
" \"timestamp\": \"2019-05-09T09:18:00.000Z\",\n" +
" \"requestUri\": \"http://google.com\"\n" +
" }\n" +
" " +
"}\n" +
" }\n" +
" ]\n" +
"}";
}
private String errorPayloadWithJson() {
//language=JSON
return "{\n" +
" \"errors\": [\n" +
" {\n" +
" \"code\": \"invalidCredentials\",\n" +
" \"detail\": \"Your credentials are invalid.\",\n" +
" \"meta\": {\n" +
" \"financialInstitutionResponse\": {\n" +
" \"statusCode\": 500,\n" +
" \"body\": {\n" +
" \"tppMessages\": [\n" +
" {\n" +
" \"category\": \"ERROR\",\n" +
" \"code\": \"NOT_FOUND\",\n" +
" \"text\": \"3.2 - Not Found\"\n" +
" }\n" +
" ]\n" +
" },\n" +
" \"requestId\": \"354fwfwef4w684\",\n" +
" \"timestamp\": \"2019-05-09T09:18:00.000Z\",\n" +
" \"requestUri\": \"http://google.com\"\n" +
" }\n" +
" " +
"}\n" +
" }\n" +
" ]\n" +
"}";
}
private ProtocolVersion dummyProtocolVersion() {
return new ProtocolVersion("", 0, 0);
}
}
| 0 |
raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\http | raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\http\impl\IbanityHttpClientImplTest.java | package com.ibanity.apis.client.http.impl;
import org.apache.commons.io.IOUtils;
import org.apache.http.Header;
import org.apache.http.HttpResponse;
import org.apache.http.client.HttpClient;
import org.apache.http.client.methods.HttpRequestBase;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Captor;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;
import static com.ibanity.apis.client.helpers.IbanityTestHelper.createHttpResponse;
import static java.nio.charset.StandardCharsets.UTF_8;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
class IbanityHttpClientImplTest {
@InjectMocks
private IbanityHttpClientImpl ibanityHttpClient;
@Mock
private HttpClient httpClient;
@Captor
private ArgumentCaptor<HttpRequestBase> requestArgumentCaptor;
@Test
void get() throws Exception {
String expected = "value";
when(httpClient.execute(requestArgumentCaptor.capture())).thenReturn(createHttpResponse(expected));
HttpResponse actual = ibanityHttpClient.get(uri());
assertThat(readContent(actual)).isEqualTo(expected);
assertThat(requestArgumentCaptor.getValue().getMethod()).isEqualTo("GET");
}
private URI uri() throws URISyntaxException {
return new URI("www.google.be");
}
@Test
void post() throws Exception {
String expected = "value";
when(httpClient.execute(requestArgumentCaptor.capture())).thenReturn(createHttpResponse(expected));
HttpResponse actual = ibanityHttpClient.post(uri(), "hello");
assertThat(readContent(actual)).isEqualTo(expected);
assertThat(requestArgumentCaptor.getValue().getMethod()).isEqualTo("POST");
}
@Test
void post_whenCustomerToken_thenAddHeader() throws Exception {
String expected = "value";
when(httpClient.execute(requestArgumentCaptor.capture())).thenReturn(createHttpResponse(expected));
HttpResponse actual = ibanityHttpClient.post(uri(), "hello", "accessToken");
assertThat(readContent(actual)).isEqualTo(expected);
assertThat(requestArgumentCaptor.getValue().getMethod()).isEqualTo("POST");
Header authorizationsHeader = requestArgumentCaptor.getValue().getFirstHeader("Authorization");
assertThat(authorizationsHeader.getValue()).isEqualTo("Bearer accessToken");
}
@Test
void delete() throws Exception {
String expected = "value";
when(httpClient.execute(requestArgumentCaptor.capture())).thenReturn(createHttpResponse(expected));
HttpResponse actual = ibanityHttpClient.delete(uri());
assertThat(readContent(actual)).isEqualTo(expected);
assertThat(requestArgumentCaptor.getValue().getMethod()).isEqualTo("DELETE");
}
@Test
void patch() throws Exception {
String expected = "value";
when(httpClient.execute(requestArgumentCaptor.capture())).thenReturn(createHttpResponse(expected));
HttpResponse actual = ibanityHttpClient.patch(uri(), "hello");
assertThat(readContent(actual)).isEqualTo(expected);
assertThat(requestArgumentCaptor.getValue().getMethod()).isEqualTo("PATCH");
}
private String readContent(HttpResponse actual) throws IOException {
return IOUtils.toString(actual.getEntity().getContent(), UTF_8);
}
}
| 0 |
raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\http | raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\http\interceptor\IbanitySignatureInterceptorTest.java | package com.ibanity.apis.client.http.interceptor;
import com.ibanity.apis.client.http.service.IbanityHttpSignatureService;
import org.apache.commons.io.IOUtils;
import org.apache.http.client.entity.EntityBuilder;
import org.apache.http.client.methods.HttpEntityEnclosingRequestBase;
import org.apache.http.client.methods.HttpRequestWrapper;
import org.apache.http.message.BasicHeader;
import org.apache.http.protocol.HttpContext;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import java.io.IOException;
import java.io.InputStream;
import java.net.MalformedURLException;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.URL;
import java.nio.charset.StandardCharsets;
import java.util.HashMap;
import java.util.Map;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
class IbanitySignatureInterceptorTest {
private static final String BASE_PATH = "https://api.ibanity.localhost";
private IbanitySignatureInterceptor ibanitySignatureInterceptor;
@Mock
private IbanityHttpSignatureService ibanityHttpSignatureService;
@Mock
private HttpRequestWrapper httpRequestWrapper;
@Mock
private HttpEntityEnclosingRequestBase httpRequest;
@Mock
private HttpContext httpContext;
@BeforeEach
void setUp() {
ibanitySignatureInterceptor = new IbanitySignatureInterceptor(ibanityHttpSignatureService, BASE_PATH);
}
@Test
void process() throws IOException, URISyntaxException {
String httpMethod = "POST";
InputStream body = IOUtils.toInputStream("aBody", StandardCharsets.UTF_8);
when(httpRequestWrapper.getURI()).thenReturn(new URI("/path"));
when(httpRequestWrapper.getAllHeaders()).thenReturn(new BasicHeader[0]);
when(httpRequestWrapper.getMethod()).thenReturn(httpMethod);
when(httpRequestWrapper.getOriginal()).thenReturn(httpRequest);
when(httpRequest.getEntity()).thenReturn(EntityBuilder.create().setStream(body).build());
Map<String, String> headers = getSignatureHeaders();
when(ibanityHttpSignatureService.getHttpSignatureHeaders(httpMethod, getUrl(), getRequestedHeaders(), body))
.thenReturn(headers);
ibanitySignatureInterceptor.process(httpRequestWrapper, httpContext);
verify(httpRequestWrapper).addHeader("digest", "value");
}
private Map<String, String> getSignatureHeaders() {
Map<String, String> headers = new HashMap<>();
headers.put("digest", "value");
return headers;
}
private URL getUrl() throws MalformedURLException {
return new URL(BASE_PATH + "/path");
}
private Map<String, String> getRequestedHeaders() {
return new HashMap<>();
}
}
| 0 |
raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\http | raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\http\interceptor\IdempotencyInterceptorTest.java | package com.ibanity.apis.client.http.interceptor;
import org.apache.http.HttpRequest;
import org.apache.http.RequestLine;
import org.apache.http.protocol.HttpContext;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import static org.mockito.ArgumentMatchers.anyString;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.*;
@ExtendWith(MockitoExtension.class)
class IdempotencyInterceptorTest {
@Mock
private HttpRequest httpRequest;
@Mock
private HttpContext httpContext;
@Mock
private RequestLine requestLine;
private IdempotencyInterceptor idempotencyInterceptor = new IdempotencyInterceptor();
@Test
void process_whenAlreadyAKey_thenDontOverride() {
when(httpRequest.containsHeader("ibanity-idempotency-key")).thenReturn(true);
idempotencyInterceptor.process(httpRequest, httpContext);
verify(httpRequest, never()).addHeader(anyString(), anyString());
}
@Test
void process_whenPost() {
when(httpRequest.containsHeader("ibanity-idempotency-key")).thenReturn(false);
when(httpRequest.getRequestLine()).thenReturn(requestLine);
when(requestLine.getMethod()).thenReturn("POST");
idempotencyInterceptor.process(httpRequest, httpContext);
verify(httpRequest).addHeader(eq("ibanity-idempotency-key"), anyString());
}
@Test
void process_whenPatch() {
when(httpRequest.containsHeader("ibanity-idempotency-key")).thenReturn(false);
when(httpRequest.getRequestLine()).thenReturn(requestLine);
when(requestLine.getMethod()).thenReturn("PATCH");
idempotencyInterceptor.process(httpRequest, httpContext);
verify(httpRequest).addHeader(eq("ibanity-idempotency-key"), anyString());
}
@Test
void process_whenGet_thenNoIdempotencyKey() {
when(httpRequest.containsHeader("ibanity-idempotency-key")).thenReturn(false);
when(httpRequest.getRequestLine()).thenReturn(requestLine);
when(requestLine.getMethod()).thenReturn("GET");
idempotencyInterceptor.process(httpRequest, httpContext);
verify(httpRequest, never()).addHeader(anyString(), anyString());
}
} | 0 |
raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\http\service | raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\http\service\impl\IbanityHttpSignatureServiceImplTest.java | package com.ibanity.apis.client.http.service.impl;
import org.apache.commons.io.FileUtils;
import org.apache.commons.io.IOUtils;
import org.apache.commons.lang3.StringUtils;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.NullSource;
import org.junit.jupiter.params.provider.ValueSource;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.net.MalformedURLException;
import java.net.URL;
import java.security.*;
import java.security.cert.Certificate;
import java.security.cert.CertificateException;
import java.security.cert.CertificateFactory;
import java.security.cert.X509Certificate;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.PKCS8EncodedKeySpec;
import java.time.Clock;
import java.time.Instant;
import java.time.ZoneId;
import java.util.Base64;
import java.util.HashMap;
import java.util.Map;
import static java.nio.charset.StandardCharsets.UTF_8;
import static org.assertj.core.api.Assertions.assertThat;
class IbanityHttpSignatureServiceImplTest {
private static final ZoneId ZONE_ID = ZoneId.of("UTC");
private static final String ISO_DATE = "2019-01-30T09:51:57.124733Z";
private static final Clock CLOCK = Clock.fixed(Instant.parse(ISO_DATE), ZONE_ID);
private static final String CERTIFICATE_ID = "75b5d796-de5c-400a-81ce-e72371b01cbc";
private static final String IDEMPOTENCY_KEY = "61f02718-eeee-46e1-b5eb-e8fd6e799c2d";
private static final String CERTIFICATE_FILENAME = "75b5d796-de5c-400a-81ce-e72371b01cbc-certificate.pem";
private static final String PRIVATE_KEY_FILENAME = "75b5d796-de5c-400a-81ce-e72371b01cbc-private_key.pem";
private static final String EXPECTED_DIGEST = "SHA-512=pX9+OFjSGF4KFWUh8fv1Ihh4PuSb2KnyobO/hr228nkET5vRUhi0Qj2Ai5OcBXtzmzgII18sZiaEH4PoxkYqew==";
private static final String EXPECTED_SIGNING_STRING = String.join("\n",
"(request-target): post /xs2a/customer-access-tokens?test=1&test=2",
"host: api.ibanity.com",
"digest: SHA-512=pX9+OFjSGF4KFWUh8fv1Ihh4PuSb2KnyobO/hr228nkET5vRUhi0Qj2Ai5OcBXtzmzgII18sZiaEH4PoxkYqew==",
"(created): 1548841917",
"ibanity-idempotency-key: 61f02718-eeee-46e1-b5eb-e8fd6e799c2d"
);
public static final String IBANITY_ENDPOINT = "https://api.ibanity.com";
private IbanityHttpSignatureServiceImpl httpSignatureService;
@BeforeEach
void setUp() throws Exception {
httpSignatureService = new IbanityHttpSignatureServiceImpl(loadPrivateKey(), CERTIFICATE_ID, CLOCK, "https://api.ibanity.com/");
}
@Test
void getHttpSignatureHeaders() throws MalformedURLException {
URL url = new URL(IBANITY_ENDPOINT + "/xs2a/customer-access-tokens?test=1&test=2");
Map<String, String> actual = getSignatureHeaders(url);
assertThat(actual).isNotEmpty().hasSize(2);
assertThat(actual).containsEntry("Digest", EXPECTED_DIGEST);
assertThat(actual).containsKey("Signature");
}
@ParameterizedTest
@NullSource
@ValueSource(strings = {"", "https://myproxy.com", "http://my-proxy/rewriting-the-path"})
void verifySignature(String proxyUrl) throws Exception {
String basePath = StringUtils.isBlank(proxyUrl) ? IBANITY_ENDPOINT : proxyUrl;
URL url = new URL(basePath + "/xs2a/customer-access-tokens?test=1&test=2");
httpSignatureService = new IbanityHttpSignatureServiceImpl(loadPrivateKey(), CERTIFICATE_ID, CLOCK, "https://api.ibanity.com/", proxyUrl);
Map<String, String> actual = getSignatureHeaders(url);
Signature publicSignature = Signature.getInstance("RSASSA-PSS");
publicSignature.setParameter(IbanityHttpSignatureServiceImpl.PARAMETER_SPEC);
PublicKey publicKey = loadPublicKey();
publicSignature.initVerify(publicKey);
publicSignature.update(EXPECTED_SIGNING_STRING.getBytes(UTF_8));
String signaturePart = getSignaturePart(actual);
byte[] signatureBytes = Base64.getDecoder().decode(signaturePart);
assert publicSignature.verify(signatureBytes);
}
private String getSignaturePart(Map<String, String> httpSignatureHeaders) {
String[] signatureParts = httpSignatureHeaders.get("Signature").split(",\\w+=");
return signatureParts[4].replace("\"", "");
}
private Map<String, String> getRequestHeaders() {
Map<String, String> headers = new HashMap<>();
headers.put("Ibanity-Idempotency-key", IDEMPOTENCY_KEY);
return headers;
}
private PublicKey loadPublicKey() throws CertificateException {
X509Certificate certificate = loadCertificate();
return certificate.getPublicKey();
}
private X509Certificate loadCertificate() throws CertificateException {
return (X509Certificate) loadCertificate(getPath(CERTIFICATE_FILENAME));
}
private PrivateKey loadPrivateKey() throws IOException, NoSuchAlgorithmException, InvalidKeySpecException {
String privateKeyPath = getPath(PRIVATE_KEY_FILENAME);
String privateKey = IOUtils.toString(FileUtils.openInputStream(new File(privateKeyPath)), UTF_8);
String privateKeyPEM = privateKey
.replace("-----BEGIN PRIVATE KEY-----", "")
.replaceAll(System.lineSeparator(), "")
.replace("-----END PRIVATE KEY-----", "");
byte[] encoded = Base64.getDecoder().decode(privateKeyPEM);
return KeyFactory.getInstance("RSA").generatePrivate(new PKCS8EncodedKeySpec(encoded));
}
private String getPath(String filename) {
URL resource = getClass().getClassLoader().getResource("certificate/" + filename);
return resource.getPath();
}
private String getRequestPayload() {
//language=JSON
return "{\"msg\":\"hello\"}";
}
private Map<String, String> getSignatureHeaders(URL url) throws MalformedURLException {
return httpSignatureService.getHttpSignatureHeaders("POST", url, getRequestHeaders(), getRequestPayload());
}
public static Certificate loadCertificate(final String certificatePath) throws CertificateException {
CertificateFactory certificateFactory = CertificateFactory.getInstance("X.509");
try {
InputStream is = FileUtils.openInputStream(new File(certificatePath));
return certificateFactory.generateCertificate(is);
} catch (IOException exception) {
throw new IllegalArgumentException(new FileNotFoundException("Resource Path not found:" + certificatePath));
}
}
}
| 0 |
raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\isabel_connect\services | raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\isabel_connect\services\impl\AccountReportServiceImplTest.java | package com.ibanity.apis.client.products.isabel_connect.services.impl;
import com.ibanity.apis.client.http.IbanityHttpClient;
import com.ibanity.apis.client.models.IbanityProduct;
import com.ibanity.apis.client.models.IsabelCollection;
import com.ibanity.apis.client.products.isabel_connect.models.AccountReport;
import com.ibanity.apis.client.products.isabel_connect.models.read.AccountReportReadQuery;
import com.ibanity.apis.client.products.isabel_connect.models.read.AccountReportsReadQuery;
import com.ibanity.apis.client.services.ApiUrlProvider;
import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.mockito.junit.jupiter.MockitoSettings;
import org.mockito.quality.Strictness;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.math.BigInteger;
import java.net.URI;
import java.nio.charset.StandardCharsets;
import java.time.LocalDateTime;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import static com.ibanity.apis.client.helpers.IbanityTestHelper.loadFile;
import static com.ibanity.apis.client.helpers.IbanityTestHelper.loadHttpResponse;
import static java.util.Collections.emptyMap;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
@MockitoSettings(strictness = Strictness.LENIENT)
public class AccountReportServiceImplTest {
private static final String ACCESS_TOKEN = "thisIsAnAccessToken";
private static final String ACCOUNT_REPORT_ID = "1234001";
private static final String ACCOUNT_REPORT_ENDPOINT = "https://api.ibanity.localhost/isabel-connect/account-reports/{accountReportId}";
private static final String LIST_ACCOUNT_REPORTS_ENDPOINT = "https://api.ibanity.localhost/isabel-connect/account-reports?size=20";
private static final String GET_ACCOUNT_REPORTS_ENDPOINT = "https://api.ibanity.localhost/isabel-connect/account-reports/123456";
@InjectMocks
private AccountReportServiceImpl accountReportService;
@Mock
private ApiUrlProvider apiUrlProvider;
@Mock
private IbanityHttpClient ibanityHttpClient;
@BeforeEach
void setup() {
when(apiUrlProvider.find(IbanityProduct.IsabelConnect, "accountReports"))
.thenReturn(ACCOUNT_REPORT_ENDPOINT);
}
@Test
public void list() throws Exception {
when(ibanityHttpClient.get(new URI(LIST_ACCOUNT_REPORTS_ENDPOINT), emptyMap(), ACCESS_TOKEN))
.thenReturn(loadHttpResponse("json/isabel-connect/account_reports.json"));
IsabelCollection<AccountReport> actual = accountReportService.list(AccountReportsReadQuery.builder()
.accessToken(ACCESS_TOKEN)
.build());
Assertions.assertThat(actual.getItems()).containsExactly(createExpected());
Assertions.assertThat(actual.getPagingOffset()).isEqualTo(0);
Assertions.assertThat(actual.getPagingTotal()).isEqualTo(2);
}
@Test
public void findWithCustomMapping() throws Exception {
when(ibanityHttpClient.get(new URI(GET_ACCOUNT_REPORTS_ENDPOINT), emptyMap(), ACCESS_TOKEN))
.thenReturn(loadHttpResponse("coda/coda-sample.txt"));
AccountReportReadQuery query = AccountReportReadQuery.builder()
.accessToken(ACCESS_TOKEN)
.accountReportId("123456")
.build();
List<String> actual = accountReportService.find(query, httpResponse -> {
List<String> res = null;
try {
InputStream content = httpResponse.getEntity().getContent();
BufferedReader reader = new BufferedReader(new InputStreamReader(content, StandardCharsets.UTF_8));
res = reader.lines().collect(Collectors.toList());
} catch (IOException e) {
e.printStackTrace();
}
return res;
});
Assertions.assertThat(actual).hasSize(24);
}
@Test
public void find() throws Exception {
when(ibanityHttpClient.get(new URI(GET_ACCOUNT_REPORTS_ENDPOINT), emptyMap(), ACCESS_TOKEN))
.thenReturn(loadHttpResponse("coda/coda-sample.txt"));
AccountReportReadQuery query = AccountReportReadQuery.builder()
.accessToken(ACCESS_TOKEN)
.accountReportId("123456")
.build();
String actual = accountReportService.find(query);
String expected = loadFile("coda/coda-sample.txt");
Assertions.assertThat(actual).isEqualTo(expected);
}
private AccountReport createExpected() {
String[] refs = {"BE96153112434405"};
return AccountReport.builder()
.id(ACCOUNT_REPORT_ID)
.accountReferences(Arrays.asList(refs))
.fileFormat("CODA")
.fileName("CODA_20181009_BE96153112434405")
.fileSize(BigInteger.valueOf(29680L))
.financialInstitutionName("GringotBank")
.receivedAt(LocalDateTime.parse("2018-10-09T03:55:00.710"))
.build();
}
}
| 0 |
raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\isabel_connect\services | raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\isabel_connect\services\impl\AccountServiceImplTest.java | package com.ibanity.apis.client.products.isabel_connect.services.impl;
import com.ibanity.apis.client.http.IbanityHttpClient;
import com.ibanity.apis.client.models.IbanityProduct;
import com.ibanity.apis.client.models.IsabelCollection;
import com.ibanity.apis.client.products.isabel_connect.models.Account;
import com.ibanity.apis.client.products.isabel_connect.models.read.AccountReadQuery;
import com.ibanity.apis.client.products.isabel_connect.models.read.AccountsReadQuery;
import com.ibanity.apis.client.services.ApiUrlProvider;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.mockito.junit.jupiter.MockitoSettings;
import org.mockito.quality.Strictness;
import java.net.URI;
import static com.ibanity.apis.client.helpers.IbanityTestHelper.loadHttpResponse;
import static java.util.Collections.emptyMap;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
@MockitoSettings(strictness = Strictness.LENIENT)
public class AccountServiceImplTest {
private static final String ACCESS_TOKEN = "thisIsAnAccessToken";
private static final String ACCOUNT_ID = "93ecb1fdbfb7848e7b7896c0f2d207aed3d8b4c1";
private static final String ACCOUNT_ENDPOINT = "https://api.ibanity.localhost/isabel-connect/accounts/{accountId}";
private static final String GET_ACCOUNT_ENDPOINT = "https://api.ibanity.localhost/isabel-connect/accounts/93ecb1fdbfb7848e7b7896c0f2d207aed3d8b4c1";
private static final String LIST_ACCOUNT_ENDPOINT = "https://api.ibanity.localhost/isabel-connect/accounts?size=20";
@InjectMocks
private AccountServiceImpl accountService;
@Mock
private ApiUrlProvider apiUrlProvider;
@Mock
private IbanityHttpClient ibanityHttpClient;
@BeforeEach
void setUp() {
when(apiUrlProvider.find(IbanityProduct.IsabelConnect, "accounts")).thenReturn(ACCOUNT_ENDPOINT);
}
@Test
public void find() throws Exception {
when(ibanityHttpClient.get(new URI(GET_ACCOUNT_ENDPOINT), emptyMap(), ACCESS_TOKEN))
.thenReturn(loadHttpResponse("json/isabel-connect/account.json"));
Account actual = accountService.find(AccountReadQuery.builder()
.accessToken(ACCESS_TOKEN)
.accountId(ACCOUNT_ID)
.build());
assertThat(actual).isEqualToComparingFieldByFieldRecursively(createExpected());
}
@Test
public void list() throws Exception {
when(ibanityHttpClient.get(new URI(LIST_ACCOUNT_ENDPOINT), emptyMap(), ACCESS_TOKEN))
.thenReturn(loadHttpResponse("json/isabel-connect/accounts.json"));
IsabelCollection<Account> actual = accountService.list(AccountsReadQuery.builder()
.accessToken(ACCESS_TOKEN)
.build());
assertThat(actual.getItems()).containsExactly(createExpected());
assertThat(actual.getPagingOffset()).isEqualTo(10);
assertThat(actual.getPagingTotal()).isEqualTo(11);
}
private Account createExpected() {
return Account.builder()
.id(ACCOUNT_ID)
.country("BE")
.currency("EUR")
.description("current account")
.financialInstitutionBic("KREDBEBB")
.holderAddress("Avenue du Grisbi, 1200 Bruxelles")
.holderAddressCountry("BE")
.holderName("Flouze")
.reference("BE96153112434405")
.referenceType("IBAN")
.build();
}
}
| 0 |
raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\isabel_connect\services | raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\isabel_connect\services\impl\BalanceServiceImplTest.java | package com.ibanity.apis.client.products.isabel_connect.services.impl;
import com.ibanity.apis.client.http.IbanityHttpClient;
import com.ibanity.apis.client.models.IbanityProduct;
import com.ibanity.apis.client.models.IsabelCollection;
import com.ibanity.apis.client.products.isabel_connect.models.Balance;
import com.ibanity.apis.client.products.isabel_connect.models.read.BalancesReadQuery;
import com.ibanity.apis.client.services.ApiUrlProvider;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.mockito.junit.jupiter.MockitoSettings;
import org.mockito.quality.Strictness;
import java.math.BigDecimal;
import java.net.URI;
import java.time.LocalDateTime;
import static com.ibanity.apis.client.helpers.IbanityTestHelper.loadHttpResponse;
import static java.util.Collections.emptyMap;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
@MockitoSettings(strictness = Strictness.LENIENT)
public class BalanceServiceImplTest {
private static final String ACCESS_TOKEN = "thisIsAnAccessToken";
private static final String ACCOUNT_ID = "93ecb1fdbfb7848e7b7896c0f2d207aed3d8b4c1";
private static final String BALANCES_ENDPOINT = "https://api.ibanity.localhost/isabel-connect/accounts/{accountId}/balances";
private static final String LIST_BALANCES_ENDPOINT = "https://api.ibanity.localhost/isabel-connect/accounts/93ecb1fdbfb7848e7b7896c0f2d207aed3d8b4c1/balances?size=20";
@InjectMocks
private BalanceServiceImpl balanceService;
@Mock
private ApiUrlProvider apiUrlProvider;
@Mock
private IbanityHttpClient ibanityHttpClient;
@BeforeEach
void setUp() {
when(apiUrlProvider.find(IbanityProduct.IsabelConnect, "account", "balances"))
.thenReturn(BALANCES_ENDPOINT);
}
@Test
public void list() throws Exception {
when(ibanityHttpClient.get(new URI(LIST_BALANCES_ENDPOINT), emptyMap(), ACCESS_TOKEN))
.thenReturn(loadHttpResponse("json/isabel-connect/balances.json"));
IsabelCollection<Balance> actual = balanceService.list(BalancesReadQuery.builder()
.accountId(ACCOUNT_ID)
.accessToken(ACCESS_TOKEN)
.build());
assertThat(actual.getItems()).containsExactly(createExpected());
assertThat(actual.getPagingOffset()).isEqualTo(0);
assertThat(actual.getPagingTotal()).isEqualTo(4);
}
private Balance createExpected() {
return Balance.builder()
.datetime(LocalDateTime.parse("2018-10-12T22:46:32.417"))
.amount(BigDecimal.valueOf(123456.78))
.subtype("CLBD")
.build();
}
}
| 0 |
raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\isabel_connect\services | raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\isabel_connect\services\impl\BulkPaymentInitiationRequestServiceImplTest.java | package com.ibanity.apis.client.products.isabel_connect.services.impl;
import com.ibanity.apis.client.http.IbanityHttpClient;
import com.ibanity.apis.client.models.IbanityProduct;
import com.ibanity.apis.client.products.isabel_connect.models.BulkPaymentInitiationRequest;
import com.ibanity.apis.client.products.isabel_connect.models.read.BulkPaymentInitiationRequestReadQuery;
import com.ibanity.apis.client.services.ApiUrlProvider;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.mockito.junit.jupiter.MockitoSettings;
import org.mockito.quality.Strictness;
import java.net.URI;
import java.util.Collections;
import static com.ibanity.apis.client.helpers.IbanityTestHelper.loadHttpResponse;
import static org.assertj.core.api.AssertionsForClassTypes.assertThat;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
@MockitoSettings(strictness = Strictness.LENIENT)
public class BulkPaymentInitiationRequestServiceImplTest {
public static final String ACCESS_TOKEN = "thisIsAnAccessToken";
public static final String BPIR_ENDPOINT = "https://api.ibanity.localhost/isabel-connect/bulk-payment-initiation-requests/{bulkPaymentInitiationRequestId}";
public static final String FIND_BPIR_ENDPOINT = "https://api.ibanity.localhost/isabel-connect/bulk-payment-initiation-requests/93ecb1fdbfb7848e7b7896c0f2d207aed3d8b4c1";
@InjectMocks
private BulkPaymentInitiationRequestServiceImpl service;
@Mock
private ApiUrlProvider apiUrlProvider;
@Mock
private IbanityHttpClient ibanityHttpClient;
@BeforeEach
void setUp() {
when(apiUrlProvider.find(IbanityProduct.IsabelConnect, "bulkPaymentInitiationRequests"))
.thenReturn(BPIR_ENDPOINT);
}
@Test
public void find() throws Exception {
when(ibanityHttpClient.get(new URI(FIND_BPIR_ENDPOINT), Collections.emptyMap(), ACCESS_TOKEN))
.thenReturn(loadHttpResponse("json/isabel-connect/bulk_payment_initiation_requests.json"));
BulkPaymentInitiationRequest actual = service.find(BulkPaymentInitiationRequestReadQuery.builder()
.accessToken(ACCESS_TOKEN)
.bulkPaymentInitiationRequestId("93ecb1fdbfb7848e7b7896c0f2d207aed3d8b4c1")
.build());
assertThat(actual).isEqualToComparingFieldByFieldRecursively(createExpected());
}
private BulkPaymentInitiationRequest createExpected() {
return BulkPaymentInitiationRequest.builder()
.status("processed-ok")
.id("90000410224108")
.build();
}
}
| 0 |
raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\isabel_connect\services | raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\isabel_connect\services\impl\IntradayTransactionServiceImplTest.java | package com.ibanity.apis.client.products.isabel_connect.services.impl;
import com.ibanity.apis.client.http.IbanityHttpClient;
import com.ibanity.apis.client.models.IbanityProduct;
import com.ibanity.apis.client.models.IsabelCollection;
import com.ibanity.apis.client.products.isabel_connect.models.IntradayTransaction;
import com.ibanity.apis.client.products.isabel_connect.models.read.IntradayTransactionsReadQuery;
import com.ibanity.apis.client.services.ApiUrlProvider;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.mockito.junit.jupiter.MockitoSettings;
import org.mockito.quality.Strictness;
import java.math.BigDecimal;
import java.net.URI;
import java.time.LocalDate;
import static com.ibanity.apis.client.helpers.IbanityTestHelper.loadHttpResponse;
import static java.util.Collections.emptyMap;
import static java.util.UUID.fromString;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
@MockitoSettings(strictness = Strictness.LENIENT)
public class IntradayTransactionServiceImplTest {
private static final String ACCOUNT_ID = "93ecb1fdbfb7848e7b7896c0f2d207aed3d8b4c1";
private static final String ACCESS_TOKEN = "thisIsAnAccessToken";
private static final String INTRADAY_TRANSACTIONS_ENDPOINT = "https://api.ibanity.localhost/isabel-connect/accounts/{accountId}/intraday-transactions";
private static final String LIST_INTRADAY_TRANSACTIONS_ENDPOINT = "https://api.ibanity.localhost/isabel-connect/accounts/93ecb1fdbfb7848e7b7896c0f2d207aed3d8b4c1/intraday-transactions?size=20";
@InjectMocks
private IntradayTransactionServiceImpl transactionService;
@Mock
private ApiUrlProvider apiUrlProvider;
@Mock
private IbanityHttpClient ibanityHttpClient;
@BeforeEach
void setUp() {
when(apiUrlProvider.find(IbanityProduct.IsabelConnect, "account", "intradayTransactions"))
.thenReturn(INTRADAY_TRANSACTIONS_ENDPOINT);
}
@Test
public void list() throws Exception {
when(ibanityHttpClient.get(new URI(LIST_INTRADAY_TRANSACTIONS_ENDPOINT), emptyMap(), ACCESS_TOKEN))
.thenReturn(loadHttpResponse("json/isabel-connect/intraday_transactions.json"));
IsabelCollection<IntradayTransaction> actual = transactionService.list(IntradayTransactionsReadQuery.builder()
.accessToken(ACCESS_TOKEN)
.accountId(ACCOUNT_ID)
.build());
assertThat(actual.getItems()).containsExactly(createExpected());
}
private IntradayTransaction createExpected() {
return IntradayTransaction.builder()
.id(fromString("14e2bff5-e365-4bc7-bf48-76b7bcd464e9").toString())
.amount(new BigDecimal(80000))
.counterpartName("MYBESTCLIENT")
.counterpartAccountReference("BE21210123456703")
.counterpartFinancialInstitutionBic("GEBABEBB")
.endToEndId("UNIQUE CODE CUSTOMER")
.executionDate(LocalDate.parse("2018-10-15"))
.remittanceInformation("123456789002")
.internalId("UNIQUE CODE BANK")
.remittanceInformationType("structured-be")
.status("Booked")
.valueDate(LocalDate.parse("2018-10-15"))
.additionalInformation("this is an important message")
.build();
}
}
| 0 |
raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\isabel_connect\services | raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\isabel_connect\services\impl\TokenServiceImplTest.java | package com.ibanity.apis.client.products.isabel_connect.services.impl;
import com.ibanity.apis.client.http.OAuthHttpClient;
import com.ibanity.apis.client.models.IbanityProduct;
import com.ibanity.apis.client.products.isabel_connect.models.create.AccessTokenCreateQuery;
import com.ibanity.apis.client.products.isabel_connect.models.create.InitialTokenCreateQuery;
import com.ibanity.apis.client.products.isabel_connect.models.revoke.TokenRevokeQuery;
import com.ibanity.apis.client.products.isabel_connect.models.AccessToken;
import com.ibanity.apis.client.products.isabel_connect.models.InitialToken;
import com.ibanity.apis.client.products.isabel_connect.models.Token;
import com.ibanity.apis.client.services.ApiUrlProvider;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.mockito.junit.jupiter.MockitoSettings;
import org.mockito.quality.Strictness;
import java.net.URI;
import java.util.HashMap;
import java.util.Map;
import static com.ibanity.apis.client.helpers.IbanityTestHelper.createHttpResponse;
import static com.ibanity.apis.client.helpers.IbanityTestHelper.loadHttpResponse;
import static java.util.Collections.emptyMap;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
@MockitoSettings(strictness = Strictness.LENIENT)
public class TokenServiceImplTest {
private static final String TOKEN_ENDPOINT = "https://api.ibanity.localhost/isabel-connect/oauth2/token";
private static final String REVOKE_ENDPOINT = "https://api.ibanity.localhost/isabel-connect/oauth2/revoke";
private static final String CLIENT_ID = "clientId";
private static final String CLIENT_SECRET = "thisIsASecret";
private static final String REDIRECT_URI = "https://fake-tpp.com/isabel-connect-authorization";
private static final String AUTHORIZATION_CODE = "W1qfWXH3sbboERgZFytVIpXOzicKFq1s1-QGQuKzeko.QQRNd24KDohgkrMYleOmDzAGzwMP5PIETP6B267dJ-w";
private static final String TOKEN = "I_UnPbrN5wH3-b7fhk5p4GIIL_5c5o-0BhXD4myLDoY.vNxkg6557o3pLCHsweSboi2mmeygG1pXVD6k8M95LLJ";
@InjectMocks
private TokenServiceImpl tokenService;
@Mock
private ApiUrlProvider apiUrlProvider;
@Mock
private OAuthHttpClient oAuthHttpClient;
@BeforeEach
void setUp() {
when(apiUrlProvider.find(IbanityProduct.IsabelConnect, "oAuth2", "token")).thenReturn(TOKEN_ENDPOINT);
when(apiUrlProvider.find(IbanityProduct.IsabelConnect, "oAuth2", "revoke")).thenReturn(REVOKE_ENDPOINT);
}
@Test
public void createInitialToken() throws Exception {
when(oAuthHttpClient.post(eq(new URI(TOKEN_ENDPOINT)), eq(emptyMap()), eq(createInitialTokenArguments()), eq(CLIENT_SECRET)))
.thenReturn(loadHttpResponse("json/isabel-connect/create_token.json"));
Token actual = tokenService.create(InitialTokenCreateQuery.builder()
.clientSecret(CLIENT_SECRET)
.authorizationCode(AUTHORIZATION_CODE)
.redirectUri(REDIRECT_URI)
.build());
assertThat(actual).isEqualToComparingFieldByFieldRecursively(createExpectedInitialToken());
}
@Test
public void createAccessToken() throws Exception {
when(oAuthHttpClient.post(eq(new URI(TOKEN_ENDPOINT)), eq(emptyMap()), eq(createAccessTokenArguments()), eq(CLIENT_SECRET)))
.thenReturn(loadHttpResponse("json/isabel-connect/create_token.json"));
Token actual = tokenService.create(AccessTokenCreateQuery.builder()
.clientSecret(CLIENT_SECRET)
.refreshToken(TOKEN)
.build());
assertThat(actual).isEqualToComparingFieldByFieldRecursively(createExpectedAccessToken());
}
@Test
public void revoke() throws Exception {
when(oAuthHttpClient.post(eq(new URI(REVOKE_ENDPOINT)), eq(emptyMap()), eq(revokeTokenArguments()), eq(CLIENT_SECRET)))
.thenReturn(createHttpResponse("{}"));
tokenService.revoke(TokenRevokeQuery.builder()
.clientSecret(CLIENT_SECRET)
.token(TOKEN)
.build());
verify(oAuthHttpClient).post(eq(new URI(REVOKE_ENDPOINT)), eq(emptyMap()), eq(revokeTokenArguments()), eq(CLIENT_SECRET));
}
private Map<String, String> createInitialTokenArguments() {
Map<String, String> arguments = new HashMap<>();
arguments.put("grant_type", "authorization_code");
arguments.put("code", AUTHORIZATION_CODE);
arguments.put("redirect_uri", REDIRECT_URI);
return arguments;
}
private Map<String, String> createAccessTokenArguments() {
Map<String, String> arguments = new HashMap<>();
arguments.put("grant_type", "refresh_token");
arguments.put("refresh_token", TOKEN);
return arguments;
}
private Map<String, String> revokeTokenArguments() {
Map<String, String> arguments = new HashMap<>();
arguments.put("token", TOKEN);
return arguments;
}
private Token createExpectedInitialToken() {
return InitialToken.builder()
.accessToken("access_token_1603365408")
.refreshToken("valid_refresh_token")
.expiresIn(1799)
.refreshExpiresIn(1800)
.scope("AI PI offline_access")
.tokenType("Bearer")
.build();
}
private Token createExpectedAccessToken() {
return AccessToken.builder()
.accessToken("access_token_1603365408")
.refreshToken("valid_refresh_token")
.expiresIn(1799)
.refreshExpiresIn(1800)
.scope("AI PI offline_access")
.tokenType("Bearer")
.build();
}
}
| 0 |
raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\isabel_connect\services | raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\isabel_connect\services\impl\TransactionServiceImplTest.java | package com.ibanity.apis.client.products.isabel_connect.services.impl;
import com.ibanity.apis.client.http.IbanityHttpClient;
import com.ibanity.apis.client.models.IbanityProduct;
import com.ibanity.apis.client.models.IsabelCollection;
import com.ibanity.apis.client.products.isabel_connect.models.Transaction;
import com.ibanity.apis.client.products.isabel_connect.models.read.TransactionsReadQuery;
import com.ibanity.apis.client.services.ApiUrlProvider;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.mockito.junit.jupiter.MockitoSettings;
import org.mockito.quality.Strictness;
import java.math.BigDecimal;
import java.net.URI;
import java.time.LocalDate;
import java.util.UUID;
import static com.ibanity.apis.client.helpers.IbanityTestHelper.loadHttpResponse;
import static java.util.Collections.emptyMap;
import static java.util.UUID.fromString;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
@MockitoSettings(strictness = Strictness.LENIENT)
public class TransactionServiceImplTest {
private static final String ACCOUNT_ID = "93ecb1fdbfb7848e7b7896c0f2d207aed3d8b4c1";
private static final UUID TRANSACTION_ID = fromString("14e2bff5-e365-4bc7-bf48-76b7bcd464e9");
private static final String ACCESS_TOKEN = "thisIsAnAccessToken";
private static final String TRANSACTIONS_ENDPOINT = "https://api.ibanity.localhost/isabel-connect/accounts/{accountId}/transactions";
private static final String LIST_TRANSACTIONS_ENDPOINT = "https://api.ibanity.localhost/isabel-connect/accounts/93ecb1fdbfb7848e7b7896c0f2d207aed3d8b4c1/transactions?size=20";
@InjectMocks
private TransactionServiceImpl transactionService;
@Mock
private ApiUrlProvider apiUrlProvider;
@Mock
private IbanityHttpClient ibanityHttpClient;
@BeforeEach
void setUp() {
when(apiUrlProvider.find(IbanityProduct.IsabelConnect, "account", "transactions")).thenReturn(TRANSACTIONS_ENDPOINT);
}
@Test
public void list() throws Exception {
when(ibanityHttpClient.get(new URI(LIST_TRANSACTIONS_ENDPOINT), emptyMap(), ACCESS_TOKEN))
.thenReturn(loadHttpResponse("json/isabel-connect/transactions.json"));
IsabelCollection<Transaction> actual = transactionService.list(TransactionsReadQuery.builder()
.accessToken(ACCESS_TOKEN)
.accountId(ACCOUNT_ID)
.build());
assertThat(actual.getItems()).containsExactly(createExpected());
}
private Transaction createExpected() {
return Transaction.builder()
.id(TRANSACTION_ID.toString())
.amount(new BigDecimal(80000))
.counterpartName("MYBESTCLIENT")
.counterpartAccountReference("BE21210123456703")
.counterpartFinancialInstitutionBic("GEBABEBB")
.endToEndId("UNIQUE CODE CUSTOMER")
.executionDate(LocalDate.parse("2018-10-15"))
.remittanceInformation("123456789002")
.internalId("UNIQUE CODE BANK")
.remittanceInformationType("structured-be")
.status("Booked")
.valueDate(LocalDate.parse("2018-10-15"))
.additionalInformation("this is an important message")
.build();
}
}
| 0 |
raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\ponto_connect | raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\ponto_connect\helpers\FilterHelperTest.java | package com.ibanity.apis.client.products.ponto_connect.helpers;
import com.ibanity.apis.client.products.ponto_connect.models.Filter;
import org.apache.http.client.utils.URIBuilder;
import org.junit.jupiter.api.Test;
import java.net.URISyntaxException;
import static org.assertj.core.api.Assertions.assertThat;
import static org.junit.jupiter.api.Assertions.assertThrows;
public class FilterHelperTest {
@Test
public void filterStringContains() throws URISyntaxException {
Filter actual = Filter.builder()
.field("myField")
.contains("myValue")
.build();
assertThat(encodeQueryParams(actual)).isEqualTo("filter[myField][contains]=myValue");
}
@Test
public void filterStringEq() throws URISyntaxException {
Filter actual = Filter.builder()
.field("myField")
.eq("myValue")
.build();
assertThat(encodeQueryParams(actual)).isEqualTo("filter[myField][eq]=myValue");
}
@Test
public void filterStringIn() throws URISyntaxException {
Filter actual = Filter.builder()
.field("myField")
.in("myValue1,myValue2")
.build();
assertThat(encodeQueryParams(actual)).isEqualTo("filter[myField][in]=myValue1,myValue2");
}
@Test
public void filterStringInBoolean() throws URISyntaxException {
Filter actual = Filter.builder()
.field("myField")
.in("true")
.build();
assertThat(encodeQueryParams(actual)).isEqualTo("filter[myField][in]=true");
}
@Test
public void filterFieldNull() {
assertThrows(NullPointerException.class, () -> {
Filter.builder()
.in("true")
.build();
});
}
@Test
public void filterStringAllOperators() throws URISyntaxException {
Filter actual = Filter.builder()
.field("myField")
.in("myValue1,myValue2")
.contains("myValue")
.eq("myValue1")
.build();
assertThat(encodeQueryParams(actual)).isEqualTo("filter[myField][in]=myValue1,myValue2&filter[myField][eq]=myValue1&filter[myField][contains]=myValue");
}
private String encodeQueryParams(Filter actual) throws URISyntaxException {
return new URIBuilder("www.ibanity.be")
.addParameters(FilterHelper.encode(actual)).build().getQuery();
}
}
| 0 |
raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\ponto_connect\sandbox\services | raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\ponto_connect\sandbox\services\impl\FinancialInstitutionAccountsServiceImplTest.java | package com.ibanity.apis.client.products.ponto_connect.sandbox.services.impl;
import com.ibanity.apis.client.http.IbanityHttpClient;
import com.ibanity.apis.client.models.IbanityCollection;
import com.ibanity.apis.client.models.IbanityProduct;
import com.ibanity.apis.client.products.ponto_connect.sandbox.models.FinancialInstitutionAccount;
import com.ibanity.apis.client.products.ponto_connect.sandbox.models.factory.read.FinancialInstitutionAccountReadQuery;
import com.ibanity.apis.client.products.ponto_connect.sandbox.models.factory.read.FinancialInstitutionAccountsReadQuery;
import com.ibanity.apis.client.services.ApiUrlProvider;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.mockito.junit.jupiter.MockitoSettings;
import org.mockito.quality.Strictness;
import java.io.IOException;
import java.math.BigDecimal;
import java.net.URI;
import java.util.UUID;
import static com.ibanity.apis.client.helpers.IbanityTestHelper.loadHttpResponse;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
@MockitoSettings(strictness = Strictness.LENIENT)
class FinancialInstitutionAccountsServiceImplTest {
private static final UUID ACCOUNT_ID = UUID.fromString("8a532347-3e21-4783-8aec-685c7ba0ac55");
private static final UUID FINANCIAL_INSTITUTION_ID = UUID.fromString("953934eb-229a-4fd2-8675-07794078cc7d");
private static final String ACCESS_TOKEN = "o8drk02QucaUes24017lj8VfHSvUukpwdOAZ7N_31e4.id1xyaKQjyzxg0ceqxW7FVZSci5C5RbpJVJJSSXpFdI";
private static final String ACCOUNT_ENDPOINT = "https://api.ibanity.localhost/ponto-connect/sandbox/financial-institutions/{financialInstitutionId}/financial-institution-accounts/{financialInstitutionAccountId}";
private static final String GET_ACCOUNT_ENDPOINT = "https://api.ibanity.localhost/ponto-connect/sandbox/financial-institutions/" + FINANCIAL_INSTITUTION_ID + "/financial-institution-accounts/" + ACCOUNT_ID;
private static final String LIST_ACCOUNT_ENDPOINT = "https://api.ibanity.localhost/ponto-connect/sandbox/financial-institutions/" + FINANCIAL_INSTITUTION_ID +"/financial-institution-accounts?page%5Blimit%5D=10";
@InjectMocks
private FinancialInstitutionAccountsServiceImpl financialInstitutionAccountsService;
@Mock
private ApiUrlProvider apiUrlProvider;
@Mock
private IbanityHttpClient ibanityHttpClient;
@BeforeEach
void setUp() {
when(apiUrlProvider.find(IbanityProduct.PontoConnect, "sandbox", "financialInstitution", "financialInstitutionAccounts")).thenReturn(ACCOUNT_ENDPOINT);
}
@Test
void find() throws IOException {
when(ibanityHttpClient.get(URI.create(GET_ACCOUNT_ENDPOINT), ACCESS_TOKEN)).thenReturn(loadHttpResponse("json/ponto-connect/financialInstitutionAccount.json"));
FinancialInstitutionAccountReadQuery accountReadQuery = FinancialInstitutionAccountReadQuery.builder()
.accessToken(ACCESS_TOKEN)
.financialInstitutionAccountId(ACCOUNT_ID)
.financialInstitutionId(FINANCIAL_INSTITUTION_ID)
.build();
FinancialInstitutionAccount actual = financialInstitutionAccountsService.find(accountReadQuery);
assertThat(actual).isEqualToComparingFieldByField(createExpected());
}
@Test
void list() throws IOException {
when(ibanityHttpClient.get(URI.create(LIST_ACCOUNT_ENDPOINT), ACCESS_TOKEN)).thenReturn(loadHttpResponse("json/ponto-connect/financialInstitutionAccounts.json"));
FinancialInstitutionAccountsReadQuery accountsReadQuery = FinancialInstitutionAccountsReadQuery.builder()
.accessToken(ACCESS_TOKEN)
.financialInstitutionId(FINANCIAL_INSTITUTION_ID)
.build();
IbanityCollection<FinancialInstitutionAccount> actual = financialInstitutionAccountsService.list(accountsReadQuery);
assertThat(actual.getItems()).containsExactly(createExpected());
}
private FinancialInstitutionAccount createExpected() {
return FinancialInstitutionAccount.builder()
.id(ACCOUNT_ID)
.subtype("checking")
.reference("BE17618075636065")
.referenceType("IBAN")
.description("Velit expedita voluptas.")
.currency("EUR")
.availableBalance(new BigDecimal("567.32"))
.currentBalance(new BigDecimal("567.32"))
.build();
}
}
| 0 |
raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\ponto_connect\sandbox\services | raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\ponto_connect\sandbox\services\impl\FinancialInstitutionTransactionsServiceImplTest.java | package com.ibanity.apis.client.products.ponto_connect.sandbox.services.impl;
import com.ibanity.apis.client.http.IbanityHttpClient;
import com.ibanity.apis.client.jsonapi.RequestApiModel;
import com.ibanity.apis.client.models.IbanityCollection;
import com.ibanity.apis.client.models.IbanityProduct;
import com.ibanity.apis.client.products.ponto_connect.sandbox.models.FinancialInstitutionTransaction;
import com.ibanity.apis.client.products.ponto_connect.sandbox.models.factory.create.FinancialInstitutionTransactionCreationQuery;
import com.ibanity.apis.client.products.ponto_connect.sandbox.models.factory.read.FinancialInstitutionTransactionReadQuery;
import com.ibanity.apis.client.products.ponto_connect.sandbox.models.factory.read.FinancialInstitutionTransactionsReadQuery;
import com.ibanity.apis.client.products.ponto_connect.sandbox.models.factory.update.FinancialInstitutionTransactionUpdateQuery;
import com.ibanity.apis.client.services.ApiUrlProvider;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.mockito.junit.jupiter.MockitoSettings;
import org.mockito.quality.Strictness;
import java.io.IOException;
import java.math.BigDecimal;
import java.net.URI;
import java.time.Instant;
import java.util.UUID;
import static com.ibanity.apis.client.helpers.IbanityTestHelper.loadHttpResponse;
import static java.util.UUID.fromString;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
@MockitoSettings(strictness = Strictness.LENIENT)
class FinancialInstitutionTransactionsServiceImplTest {
private static final UUID ACCOUNT_ID = fromString("8a532347-3e21-4783-8aec-685c7ba0ac55");
private static final UUID TRANSACTION_ID = fromString("f87f120d-1dd7-4226-8b0e-fd83c9ed631a");
private static final UUID FINANCIAL_INSTITUTION_ID = fromString("953934eb-229a-4fd2-8675-07794078cc7d");
private static final String ACCESS_TOKEN = "o8drk02QucaUes24017lj8VfHSvUukpwdOAZ7N_31e4.id1xyaKQjyzxg0ceqxW7FVZSci5C5RbpJVJJSSXpFdI";
private static final String TRANSACTION_ENDPOINT = "https://api.ibanity.localhost/ponto-connect/sandbox/financial-institutions/{financialInstitutionId}/financial-institution-accounts/{financialInstitutionAccountId}/financial-institution-transactions/{financialInstitutionTransactionId}";
private static final String ID_TRANSACTION_ENDPOINT = "https://api.ibanity.localhost/ponto-connect/sandbox/financial-institutions/953934eb-229a-4fd2-8675-07794078cc7d/financial-institution-accounts/8a532347-3e21-4783-8aec-685c7ba0ac55/financial-institution-transactions/f87f120d-1dd7-4226-8b0e-fd83c9ed631a";
private static final String LIST_TRANSACTION_ENDPOINT = "https://api.ibanity.localhost/ponto-connect/sandbox/financial-institutions/953934eb-229a-4fd2-8675-07794078cc7d/financial-institution-accounts/8a532347-3e21-4783-8aec-685c7ba0ac55/financial-institution-transactions?page%5Blimit%5D=10";
private static final String CREATE_TRANSACTION_ENDPOINT = "https://api.ibanity.localhost/ponto-connect/sandbox/financial-institutions/953934eb-229a-4fd2-8675-07794078cc7d/financial-institution-accounts/8a532347-3e21-4783-8aec-685c7ba0ac55/financial-institution-transactions";
@InjectMocks
private FinancialInstitutionTransactionsServiceImpl financialInstitutionTransactionsService;
@Mock
private ApiUrlProvider apiUrlProvider;
@Mock
private IbanityHttpClient ibanityHttpClient;
@BeforeEach
void setUp() {
when(apiUrlProvider.find(IbanityProduct.PontoConnect, "sandbox", "financialInstitution", "financialInstitutionAccount", "financialInstitutionTransactions")).thenReturn(TRANSACTION_ENDPOINT);
}
@Test
void find() throws IOException {
when(ibanityHttpClient.get(URI.create(ID_TRANSACTION_ENDPOINT), ACCESS_TOKEN)).thenReturn(loadHttpResponse("json/ponto-connect/financialInstitutionTransaction.json"));
FinancialInstitutionTransactionReadQuery request = FinancialInstitutionTransactionReadQuery.builder()
.accessToken(ACCESS_TOKEN)
.financialInstitutionId(FINANCIAL_INSTITUTION_ID)
.financialInstitutionAccountId(ACCOUNT_ID)
.financialInstitutionTransactionId(TRANSACTION_ID)
.build();
FinancialInstitutionTransaction actual = financialInstitutionTransactionsService.find(request);
assertThat(actual).isEqualToComparingFieldByField(createExpected());
}
@Test
void list() throws IOException {
when(ibanityHttpClient.get(URI.create(LIST_TRANSACTION_ENDPOINT), ACCESS_TOKEN)).thenReturn(loadHttpResponse("json/ponto-connect/financialInstitutionTransactions.json"));
FinancialInstitutionTransactionsReadQuery request = FinancialInstitutionTransactionsReadQuery.builder()
.accessToken(ACCESS_TOKEN)
.financialInstitutionId(FINANCIAL_INSTITUTION_ID)
.financialInstitutionAccountId(ACCOUNT_ID)
.build();
IbanityCollection<FinancialInstitutionTransaction> actual = financialInstitutionTransactionsService.list(request);
assertThat(actual.getItems()).containsExactly(createExpected());
}
@Test
void create() throws IOException {
FinancialInstitutionTransactionCreationQuery request = FinancialInstitutionTransactionCreationQuery.builder()
.accessToken(ACCESS_TOKEN)
.financialInstitutionId(FINANCIAL_INSTITUTION_ID)
.financialInstitutionAccountId(ACCOUNT_ID)
.remittanceInformationType("unstructured")
.remittanceInformation("NEW SHOES")
.description("Small Cotton Shoes")
.currency("EUR")
.counterpartName("Otro Bank")
.counterpartReference("BE9786154282554")
.amount(new BigDecimal("84.42"))
.valueDate(Instant.parse("2020-05-22T00:00:00Z"))
.executionDate(Instant.parse("2020-05-25T00:00:00Z"))
.cardReference("6666")
.cardReferenceType("MASKEDPAN")
.fee(new BigDecimal("3.14"))
.build();
when(ibanityHttpClient.post(URI.create(CREATE_TRANSACTION_ENDPOINT), createIbanityModel(request), ACCESS_TOKEN)).thenReturn(loadHttpResponse("json/ponto-connect/financialInstitutionTransaction.json"));
FinancialInstitutionTransaction actual = financialInstitutionTransactionsService.create(request);
assertThat(actual).isEqualToComparingFieldByField(createExpected());
}
@Test
void update() throws IOException {
FinancialInstitutionTransactionUpdateQuery request = FinancialInstitutionTransactionUpdateQuery.builder()
.accessToken(ACCESS_TOKEN)
.financialInstitutionId(FINANCIAL_INSTITUTION_ID)
.financialInstitutionAccountId(ACCOUNT_ID)
.financialInstitutionTransactionId(TRANSACTION_ID)
.remittanceInformation("NEW SHOES")
.description("Hole foods")
.bankTransactionCode("PMNT-IRCT-ESCT")
.proprietaryBankTransactionCode("12267")
.additionalInformation("Online payment on fake-tpp.com")
.creditorId("123498765421")
.mandateId("234")
.purposeCode("CASH")
.endToEndId("ref.243435343")
.build();
when(ibanityHttpClient.patch(URI.create(ID_TRANSACTION_ENDPOINT), createIbanityModel(request), ACCESS_TOKEN)).thenReturn(loadHttpResponse("json/ponto-connect/financialInstitutionTransaction.json"));
FinancialInstitutionTransaction actual = financialInstitutionTransactionsService.update(request);
assertThat(actual).isEqualToComparingFieldByField(createExpected());
}
private Object createIbanityModel(FinancialInstitutionTransactionUpdateQuery transactionUpdateQuery) {
FinancialInstitutionTransaction transaction = FinancialInstitutionTransaction.builder()
.remittanceInformation(transactionUpdateQuery.getRemittanceInformation())
.counterpartName(transactionUpdateQuery.getCounterpartName())
.description(transactionUpdateQuery.getDescription())
.bankTransactionCode(transactionUpdateQuery.getBankTransactionCode())
.proprietaryBankTransactionCode(transactionUpdateQuery.getProprietaryBankTransactionCode())
.additionalInformation(transactionUpdateQuery.getAdditionalInformation())
.creditorId(transactionUpdateQuery.getCreditorId())
.mandateId(transactionUpdateQuery.getMandateId())
.purposeCode(transactionUpdateQuery.getPurposeCode())
.endToEndId(transactionUpdateQuery.getEndToEndId())
.build();
return RequestApiModel.builder()
.data(
RequestApiModel.RequestDataApiModel.builder()
.attributes(transaction)
.type(com.ibanity.apis.client.products.ponto_connect.sandbox.models.FinancialInstitutionTransaction.RESOURCE_TYPE)
.build()
)
.build();
}
private Object createIbanityModel(FinancialInstitutionTransactionCreationQuery query) {
FinancialInstitutionTransaction transaction = FinancialInstitutionTransaction.builder()
.amount(query.getAmount())
.currency(query.getCurrency())
.remittanceInformation(query.getRemittanceInformation())
.remittanceInformationType(query.getRemittanceInformationType())
.counterpartName(query.getCounterpartName())
.counterpartReference(query.getCounterpartReference())
.valueDate(query.getValueDate())
.executionDate(query.getExecutionDate())
.description(query.getDescription())
.cardReference(query.getCardReference())
.cardReferenceType(query.getCardReferenceType())
.fee(query.getFee())
.build();
return RequestApiModel.builder()
.data(
RequestApiModel.RequestDataApiModel.builder()
.attributes(transaction)
.type(com.ibanity.apis.client.products.ponto_connect.sandbox.models.FinancialInstitutionTransaction.RESOURCE_TYPE)
.build()
)
.build();
}
private FinancialInstitutionTransaction createExpected() {
return FinancialInstitutionTransaction.builder()
.id(fromString("f87f120d-1dd7-4226-8b0e-fd83c9ed631a"))
.remittanceInformationType("unstructured")
.remittanceInformation("NEW SHOES")
.description("Small Cotton Shoes")
.currency("EUR")
.counterpartName("Otro Bank")
.counterpartReference("BE9786154282554")
.amount(new BigDecimal("84.42"))
.valueDate(Instant.parse("2020-05-22T00:00:00Z"))
.executionDate(Instant.parse("2020-05-25T00:00:00Z"))
.cardReference("6666")
.cardReferenceType("MASKEDPAN")
.fee(new BigDecimal("3.14"))
.build();
}
}
| 0 |
raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\ponto_connect\services | raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\ponto_connect\services\impl\AccountServiceImplTest.java | package com.ibanity.apis.client.products.ponto_connect.services.impl;
import com.ibanity.apis.client.http.IbanityHttpClient;
import com.ibanity.apis.client.models.IbanityCollection;
import com.ibanity.apis.client.models.IbanityProduct;
import com.ibanity.apis.client.products.ponto_connect.models.Account;
import com.ibanity.apis.client.products.ponto_connect.models.Synchronization;
import com.ibanity.apis.client.products.ponto_connect.models.delete.AccountDeleteQuery;
import com.ibanity.apis.client.products.ponto_connect.models.read.AccountReadQuery;
import com.ibanity.apis.client.products.ponto_connect.models.read.AccountsReadQuery;
import com.ibanity.apis.client.services.ApiUrlProvider;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.mockito.junit.jupiter.MockitoSettings;
import org.mockito.quality.Strictness;
import java.math.BigDecimal;
import java.net.URI;
import java.util.UUID;
import static com.ibanity.apis.client.helpers.IbanityTestHelper.loadHttpResponse;
import static java.time.Instant.parse;
import static java.util.Collections.emptyMap;
import static java.util.UUID.fromString;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
@MockitoSettings(strictness = Strictness.LENIENT)
public class AccountServiceImplTest {
private static final String ACCESS_TOKEN = "thisIsAnAccessToken";
private static final UUID ACCOUNT_ID = fromString("8804e34f-12b0-4b70-86bf-265f013ca232");
private static final UUID FINANCIAL_INSTITUTION_ID = fromString("953934eb-229a-4fd2-8675-07794078cc7d");
private static final String ACCOUNT_ENDPOINT = "https://api.ibanity.localhost/ponto-connect/accounts/{accountId}";
private static final String GET_ACCOUNT_ENDPOINT = "https://api.ibanity.localhost/ponto-connect/accounts/8804e34f-12b0-4b70-86bf-265f013ca232";
private static final String LIST_ACCOUNT_ENDPOINT = "https://api.ibanity.localhost/ponto-connect/accounts?page%5Blimit%5D=10";
@InjectMocks
private AccountServiceImpl accountService;
@Mock
private ApiUrlProvider apiUrlProvider;
@Mock
private IbanityHttpClient ibanityHttpClient;
@BeforeEach
void setUp() {
when(apiUrlProvider.find(IbanityProduct.PontoConnect, "accounts")).thenReturn(ACCOUNT_ENDPOINT);
}
@Test
public void find() throws Exception {
when(ibanityHttpClient.get(new URI(GET_ACCOUNT_ENDPOINT), emptyMap(), ACCESS_TOKEN))
.thenReturn(loadHttpResponse("json/ponto-connect/account.json"));
Account actual = accountService.find(AccountReadQuery.builder()
.accessToken(ACCESS_TOKEN)
.accountId(ACCOUNT_ID)
.build());
assertThat(actual).isEqualToComparingFieldByFieldRecursively(createExpected());
}
@Test
public void delete() throws Exception {
when(ibanityHttpClient.delete(new URI(GET_ACCOUNT_ENDPOINT), emptyMap(), ACCESS_TOKEN))
.thenReturn(loadHttpResponse("json/ponto-connect/account_delete.json"));
Account actual = accountService.delete(AccountDeleteQuery.builder()
.accessToken(ACCESS_TOKEN)
.accountId(ACCOUNT_ID)
.build());
assertThat(actual).isEqualToComparingFieldByFieldRecursively(Account.builder()
.id(ACCOUNT_ID)
.build());
}
@Test
public void list() throws Exception {
when(ibanityHttpClient.get(new URI(LIST_ACCOUNT_ENDPOINT), emptyMap(), ACCESS_TOKEN))
.thenReturn(loadHttpResponse("json/ponto-connect/accounts.json"));
IbanityCollection<Account> actual = accountService.list(AccountsReadQuery.builder()
.accessToken(ACCESS_TOKEN)
.build());
assertThat(actual.getItems()).containsExactly(createExpected());
assertThat(actual.getPageLimit()).isEqualTo(10);
}
private Account createExpected() {
return Account.builder()
.id(ACCOUNT_ID)
.referenceType("IBAN")
.reference("BE53586671384412")
.financialInstitutionId(FINANCIAL_INSTITUTION_ID)
.description("Repellat voluptatem aut.")
.currentBalance(new BigDecimal("6386.04"))
.currency("EUR")
.availableBalance(new BigDecimal("6386.04"))
.subtype("checking")
.deprecated(false)
.synchronizedAt(parse("2019-09-02T11:28:36.551Z"))
.latestSynchronization(createSynchronization())
.authorizedAt(parse("2020-07-15T12:01:44.166Z"))
.authorizationExpirationExpectedAt(parse("2020-10-13T12:01:44.166Z"))
.availableBalanceReferenceDate(parse("2020-06-20T00:00:00Z"))
.availableBalanceChangedAt(parse("2020-09-17T12:30:23.405Z"))
.availableBalanceVariationObservedAt(parse("2020-09-17T12:30:23.467Z"))
.currentBalanceVariationObservedAt(parse("2020-09-17T12:30:23.467Z"))
.currentBalanceReferenceDate(parse("2020-06-20T00:00:00Z"))
.currentBalanceChangedAt(parse("2020-09-17T12:30:23.405Z"))
.holderName("Malvina Dibbert")
.product("Current account")
.internalReference("99f0c729-c51a-4b4c-a4e4-abb8a52c1e12")
.build();
}
private Synchronization createSynchronization() {
return Synchronization.builder()
.id(fromString("1b3e3011-d018-4785-bbba-9aa75ba14d45"))
.createdAt(parse("2019-09-02T11:28:35.971Z"))
.updatedAt(parse("2019-09-02T11:28:36.551Z"))
.resourceId("8804e34f-12b0-4b70-86bf-265f013ca232")
.resourceType("account")
.status("success")
.subtype("accountDetails")
.build();
}
}
| 0 |
raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\ponto_connect\services | raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\ponto_connect\services\impl\BulkPaymentServiceImplTest.java | package com.ibanity.apis.client.products.ponto_connect.services.impl;
import com.ibanity.apis.client.http.IbanityHttpClient;
import com.ibanity.apis.client.models.IbanityProduct;
import com.ibanity.apis.client.products.ponto_connect.models.BulkPayment;
import com.ibanity.apis.client.products.ponto_connect.models.create.BulkPaymentCreateQuery;
import com.ibanity.apis.client.products.ponto_connect.models.delete.BulkPaymentDeleteQuery;
import com.ibanity.apis.client.products.ponto_connect.models.read.BulkPaymentReadQuery;
import com.ibanity.apis.client.services.ApiUrlProvider;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import java.io.IOException;
import java.time.LocalDate;
import java.util.UUID;
import static com.ibanity.apis.client.helpers.IbanityTestHelper.loadHttpResponse;
import static com.ibanity.apis.client.utils.URIHelper.buildUri;
import static java.util.Collections.emptyMap;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
class BulkPaymentServiceImplTest {
private static final String BULK_PAYMENT_ENDPOINT = "https://api.ibanity.localhost/ponto-connect/accounts/{accountId}/bulk-payments/{bulkPaymentId}";
private static final String BULK_PAYMENT_ENDPOINT_FOR_FIND = "https://api.ibanity.localhost/ponto-connect/accounts/8804e34f-12b0-4b70-86bf-265f013ca232/bulk-payments/6c0350b5-a724-42e5-b4ce-ca3a6994df3d";
private static final String BULK_PAYMENT_ENDPOINT_FOR_CREATE = "https://api.ibanity.localhost/ponto-connect/accounts/8804e34f-12b0-4b70-86bf-265f013ca232/bulk-payments";
private static final UUID ACCOUNT_ID = UUID.fromString("8804e34f-12b0-4b70-86bf-265f013ca232");
private static final UUID BULK_PAYMENT_ID = UUID.fromString("6c0350b5-a724-42e5-b4ce-ca3a6994df3d");
private static final String ACCESS_TOKEN = "anAccessToken";
@InjectMocks
private BulkPaymentServiceImpl bulkPaymentService;
@Mock
private ApiUrlProvider apiUrlProvider;
@Mock
private IbanityHttpClient ibanityHttpClient;
@BeforeEach
void setUp() {
when(apiUrlProvider.find(IbanityProduct.PontoConnect, "account", "bulkPayments"))
.thenReturn(BULK_PAYMENT_ENDPOINT);
}
@Test
void find() throws IOException {
BulkPaymentReadQuery paymentReadQuery = BulkPaymentReadQuery.builder()
.accountId(ACCOUNT_ID)
.bulkPaymentId(BULK_PAYMENT_ID)
.accessToken(ACCESS_TOKEN)
.build();
when(ibanityHttpClient.get(buildUri(BULK_PAYMENT_ENDPOINT_FOR_FIND), emptyMap(), ACCESS_TOKEN))
.thenReturn(loadHttpResponse("json/ponto-connect/bulk_payment.json"));
BulkPayment actual = bulkPaymentService.find(paymentReadQuery);
assertThat(actual).isEqualToComparingFieldByFieldRecursively(createExpected(null));
}
@Test
void create() throws IOException {
BulkPaymentCreateQuery paymentCreateQuery = BulkPaymentCreateQuery.builder()
.accountId(ACCOUNT_ID)
.accessToken(ACCESS_TOKEN)
.build();
when(ibanityHttpClient.post(eq(buildUri(BULK_PAYMENT_ENDPOINT_FOR_CREATE)), any(),eq(emptyMap()), eq(ACCESS_TOKEN)))
.thenReturn(loadHttpResponse("json/ponto-connect/bulk_payment_create.json"));
BulkPayment actual = bulkPaymentService.create(paymentCreateQuery);
assertThat(actual).isEqualToComparingFieldByFieldRecursively(createExpected("https://authorize.myponto.com/organizations/6680437c-8ed8-425b-84b7-2c31e5ca625d/sandbox/integrations/236d8f5c-9e19-45c7-8138-1a50910020ae/accounts/44f261ec-2cc9-47f8-8cad-bcd6994629ed/bulk-payments/e9607b48-7941-4470-8b5a-19ddfe62e67a"));
}
@Test
void delete() throws IOException {
BulkPaymentDeleteQuery paymentDeleteQuery = BulkPaymentDeleteQuery.builder()
.bulkPaymentId(BULK_PAYMENT_ID)
.accountId(ACCOUNT_ID)
.accessToken(ACCESS_TOKEN)
.build();
when(ibanityHttpClient.delete(buildUri(BULK_PAYMENT_ENDPOINT_FOR_FIND), emptyMap(), ACCESS_TOKEN))
.thenReturn(loadHttpResponse("json/ponto-connect/delete_bulk_payment.json"));
BulkPayment actual = bulkPaymentService.delete(paymentDeleteQuery);
assertThat(actual).isEqualToComparingFieldByFieldRecursively(createDeleted());
}
private BulkPayment createDeleted() {
return BulkPayment.builder()
.id(BULK_PAYMENT_ID)
.build();
}
private BulkPayment createExpected(String redirect) {
return BulkPayment.builder()
.redirectLink(redirect)
.id(BULK_PAYMENT_ID)
.reference("Invoice collection")
.batchBookingPreferred(true)
.requestedExecutionDate(LocalDate.parse("2022-02-05"))
.status("unsigned")
.build();
}
}
| 0 |
raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\ponto_connect\services | raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\ponto_connect\services\impl\FinancialInstitutionServiceImplTest.java | package com.ibanity.apis.client.products.ponto_connect.services.impl;
import com.ibanity.apis.client.http.IbanityHttpClient;
import com.ibanity.apis.client.models.IbanityCollection;
import com.ibanity.apis.client.models.IbanityProduct;
import com.ibanity.apis.client.products.ponto_connect.models.Filter;
import com.ibanity.apis.client.products.ponto_connect.models.FinancialInstitution;
import com.ibanity.apis.client.products.ponto_connect.models.read.FinancialInstitutionReadQuery;
import com.ibanity.apis.client.products.ponto_connect.models.read.FinancialInstitutionsReadQuery;
import com.ibanity.apis.client.products.ponto_connect.models.read.OrganizationFinancialInstitutionReadQuery;
import com.ibanity.apis.client.products.ponto_connect.models.read.OrganizationFinancialInstitutionsReadQuery;
import com.ibanity.apis.client.services.ApiUrlProvider;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.mockito.junit.jupiter.MockitoSettings;
import org.mockito.quality.Strictness;
import java.net.URI;
import java.util.Collections;
import java.util.UUID;
import static com.ibanity.apis.client.helpers.IbanityTestHelper.loadHttpResponse;
import static java.util.Collections.emptyMap;
import static java.util.UUID.fromString;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
@MockitoSettings(strictness = Strictness.LENIENT)
public class FinancialInstitutionServiceImplTest {
private static final String ACCESS_TOKEN = "thisIsAnAccessToken";
private static final UUID FINANCIAL_INSTITUTION_ID = fromString("953934eb-229a-4fd2-8675-07794078cc7d");
private static final UUID FINANCIAL_INSTITUTION_ID_2 = fromString("953934eb-0002-4fd2-8675-07794078cc7d");
private static final String FINANCIAL_INSTITUTION_ENDPOINT = "https://api.ibanity.localhost/ponto-connect/financial-institutions/{financialInstitutionId}";
private static final String GET_FINANCIAL_INSTITUTION_ENDPOINT = "https://api.ibanity.localhost/ponto-connect/financial-institutions/953934eb-229a-4fd2-8675-07794078cc7d";
private static final String LIST_ORGANIZATION_FINANCIAL_INSTITUTION_ENDPOINT = "https://api.ibanity.localhost/ponto-connect/financial-institutions?page%5Blimit%5D=10";
private static final String LIST_FINANCIAL_INSTITUTION_ENDPOINT = "https://api.ibanity.localhost/ponto-connect/financial-institutions?page%5Blimit%5D=10&filter%5Bname%5D%5Bcontains%5D=Bank";
@InjectMocks
private FinancialInstitutionServiceImpl financialInstitutionService;
@Mock
private ApiUrlProvider apiUrlProvider;
@Mock
private IbanityHttpClient ibanityHttpClient;
@BeforeEach
void setUp() {
when(apiUrlProvider.find(IbanityProduct.PontoConnect, "financialInstitutions")).thenReturn(FINANCIAL_INSTITUTION_ENDPOINT);
}
@Test
public void find() throws Exception {
when(ibanityHttpClient.get(new URI(GET_FINANCIAL_INSTITUTION_ENDPOINT), emptyMap(), null))
.thenReturn(loadHttpResponse("json/ponto-connect/financial_institution.json"));
FinancialInstitution actual = financialInstitutionService.find(FinancialInstitutionReadQuery.builder()
.financialInstitutionId(FINANCIAL_INSTITUTION_ID)
.build());
assertThat(actual).isEqualToComparingFieldByFieldRecursively(createExpected(FINANCIAL_INSTITUTION_ID, "Fake Bank"));
}
@Test
public void findForOrganization() throws Exception {
when(ibanityHttpClient.get(new URI(GET_FINANCIAL_INSTITUTION_ENDPOINT), emptyMap(), ACCESS_TOKEN))
.thenReturn(loadHttpResponse("json/ponto-connect/financial_institution.json"));
FinancialInstitution actual = financialInstitutionService.find(OrganizationFinancialInstitutionReadQuery.builder()
.accessToken(ACCESS_TOKEN)
.financialInstitutionId(FINANCIAL_INSTITUTION_ID)
.build());
assertThat(actual).isEqualToComparingFieldByFieldRecursively(createExpected(FINANCIAL_INSTITUTION_ID, "Fake Bank"));
}
@Test
public void listForOrganization() throws Exception {
when(ibanityHttpClient.get(new URI(LIST_ORGANIZATION_FINANCIAL_INSTITUTION_ENDPOINT), emptyMap(), ACCESS_TOKEN))
.thenReturn(loadHttpResponse("json/ponto-connect/organization_financial_institutions.json"));
IbanityCollection<FinancialInstitution> actual = financialInstitutionService.list(OrganizationFinancialInstitutionsReadQuery.builder()
.accessToken(ACCESS_TOKEN)
.build());
assertThat(actual.getItems()).containsExactly(createExpected(FINANCIAL_INSTITUTION_ID, "Fake Bank"));
assertThat(actual.getPageLimit()).isEqualTo(10);
}
@Test
public void list() throws Exception {
when(ibanityHttpClient.get(new URI(LIST_FINANCIAL_INSTITUTION_ENDPOINT), emptyMap(), null))
.thenReturn(loadHttpResponse("json/ponto-connect/financial_institutions.json"));
IbanityCollection<FinancialInstitution> actual = financialInstitutionService.list(FinancialInstitutionsReadQuery.builder()
.filters(Collections.singletonList(Filter.builder()
.field("name")
.contains("Bank")
.build()))
.build());
assertThat(actual.getItems()).containsExactly(createExpected(FINANCIAL_INSTITUTION_ID, "Full Fake Bank"), createExpected(FINANCIAL_INSTITUTION_ID_2, "Full Fake Bank 2"));
assertThat(actual.getPageLimit()).isEqualTo(10);
}
private FinancialInstitution createExpected(UUID financialInstitutionId, String name) {
return FinancialInstitution.builder()
.id(financialInstitutionId)
.name(name)
.deprecated(true)
.build();
}
}
| 0 |
raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\ponto_connect\services | raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\ponto_connect\services\impl\IntegrationAccountServiceImplTest.java | package com.ibanity.apis.client.products.ponto_connect.services.impl;
import com.ibanity.apis.client.http.IbanityHttpClient;
import com.ibanity.apis.client.models.IbanityCollection;
import com.ibanity.apis.client.models.IbanityProduct;
import com.ibanity.apis.client.paging.IbanityPagingSpec;
import com.ibanity.apis.client.products.ponto_connect.models.IntegrationAccount;
import com.ibanity.apis.client.products.ponto_connect.models.read.IntegrationAccountsReadQuery;
import com.ibanity.apis.client.services.ApiUrlProvider;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.mockito.junit.jupiter.MockitoSettings;
import org.mockito.quality.Strictness;
import java.io.IOException;
import java.net.URI;
import static com.ibanity.apis.client.helpers.IbanityTestHelper.loadHttpResponse;
import static java.time.Instant.parse;
import static java.util.Collections.emptyMap;
import static java.util.UUID.fromString;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
@MockitoSettings(strictness = Strictness.LENIENT)
class IntegrationAccountServiceImplTest {
private static final String INTEGRATION_ACCOUNT_ENDPOINT = "https://api.ibanity.localhost/ponto-connect/integration-accounts";
private static final String LIST_INTEGRATION_ACCOUNT = "https://api.ibanity.localhost/ponto-connect/integration-accounts?page%5Blimit%5D=2";
private static final String CLIENT_TOKEN = "myClientToken";
@InjectMocks
private IntegrationAccountServiceImpl integrationAccountService;
@Mock
private ApiUrlProvider apiUrlProvider;
@Mock
private IbanityHttpClient ibanityHttpClient;
@BeforeEach
void setUp() {
when(apiUrlProvider.find(IbanityProduct.PontoConnect, "integrationAccounts")).thenReturn(INTEGRATION_ACCOUNT_ENDPOINT);
}
@Test
void list() throws IOException {
when(ibanityHttpClient.get(URI.create(LIST_INTEGRATION_ACCOUNT), emptyMap(), CLIENT_TOKEN))
.thenReturn(loadHttpResponse("json/ponto-connect/integration_accounts.json"));
IbanityCollection<IntegrationAccount> integrationAccounts = integrationAccountService.list(
IntegrationAccountsReadQuery.builder()
.accessToken(CLIENT_TOKEN)
.pagingSpec(IbanityPagingSpec.builder().limit(2).build())
.build());
assertThat(integrationAccounts.getItems()).hasSize(1);
assertThat(integrationAccounts.getItems()).containsExactly(createExpected());
}
private IntegrationAccount createExpected() {
return IntegrationAccount.builder()
.id(fromString("1d676229-8462-478a-bcbd-92b5c0e447d4"))
.createdAt(parse("2023-02-28T14:36:10.319029Z"))
.lastAccessedAt(parse("2023-03-08T14:05:55.470695Z"))
.accountId(fromString("cac6b18d-e21c-42e8-9e66-95c9a3fbb8ef"))
.financialInstitutionId(fromString("953934eb-229a-4fd2-8675-07794078cc7d"))
.organizationId(fromString("6616fe6e-3e1f-44dd-867e-7ff24d8c3799"))
.build();
}
}
| 0 |
raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\ponto_connect\services | raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\ponto_connect\services\impl\IntegrationServiceImplTest.java | package com.ibanity.apis.client.products.ponto_connect.services.impl;
import com.ibanity.apis.client.http.IbanityHttpClient;
import com.ibanity.apis.client.models.IbanityProduct;
import com.ibanity.apis.client.products.ponto_connect.models.Integration;
import com.ibanity.apis.client.products.ponto_connect.models.delete.OrganizationIntegrationDeleteQuery;
import com.ibanity.apis.client.services.ApiUrlProvider;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.UUID;
import static com.ibanity.apis.client.helpers.IbanityTestHelper.loadHttpResponse;
import static java.util.Collections.emptyMap;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
class IntegrationServiceImplTest {
private static final String INTEGRATION_ENDPOINT = "https://api.ibanity.localhost/ponto-connect/organizations/{organizationId}/integration";
private static final String DELETE_INTEGRATION_ENDPOINT = "https://api.ibanity.localhost/ponto-connect/organizations/6680437c-8ed8-425b-84b7-2c31e5ca625d/integration";
private static final UUID INTEGRATION_ID = UUID.fromString("8804e34f-12b0-4b70-86bf-265f013ca232");
private static final UUID ORGANISATION_ID = UUID.fromString("6680437c-8ed8-425b-84b7-2c31e5ca625d");
private static final String ACCESS_TOKEN = "anAccessToken";
@InjectMocks
private IntegrationServiceImpl integrationService;
@Mock
private ApiUrlProvider apiUrlProvider;
@Mock
private IbanityHttpClient ibanityHttpClient;
@BeforeEach
void setUp() {
when(apiUrlProvider.find(IbanityProduct.PontoConnect, "organizations", "integration"))
.thenReturn(INTEGRATION_ENDPOINT);
}
@Test
void delete() throws IOException, URISyntaxException {
OrganizationIntegrationDeleteQuery deleteQuery = OrganizationIntegrationDeleteQuery.builder()
.accessToken(ACCESS_TOKEN)
.organizationId(ORGANISATION_ID)
.build();
when(ibanityHttpClient.delete(new URI(DELETE_INTEGRATION_ENDPOINT), emptyMap(), ACCESS_TOKEN))
.thenReturn(loadHttpResponse("json/ponto-connect/delete_organization_integration.json"));
Integration integration = integrationService.delete(deleteQuery);
assertThat(integration.getId()).isEqualTo(INTEGRATION_ID);
}
}
| 0 |
raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\ponto_connect\services | raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\ponto_connect\services\impl\OnboardingDetailsServiceImplTest.java | package com.ibanity.apis.client.products.ponto_connect.services.impl;
import com.ibanity.apis.client.http.IbanityHttpClient;
import com.ibanity.apis.client.models.IbanityProduct;
import com.ibanity.apis.client.products.ponto_connect.models.OnboardingDetails;
import com.ibanity.apis.client.products.ponto_connect.models.create.OnboardingDetailsCreateQuery;
import com.ibanity.apis.client.services.ApiUrlProvider;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.UUID;
import static com.ibanity.apis.client.helpers.IbanityTestHelper.loadHttpResponse;
import static java.util.Collections.emptyMap;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
class OnboardingDetailsServiceImplTest {
private static final String ONBOARDING_DETAILS_ENDPOINT = "https://api.ibanity.com/ponto-connect/onboarding-details";
private static final String ACCESS_TOKEN = "myToken";
@InjectMocks
private OnboardingDetailsServiceImpl onboardingDetailsService;
@Mock
private ApiUrlProvider apiUrlProvider;
@Mock
private IbanityHttpClient ibanityHttpClient;
@BeforeEach
void setUp() {
when(apiUrlProvider.find(IbanityProduct.PontoConnect, "onboardingDetails"))
.thenReturn(ONBOARDING_DETAILS_ENDPOINT);
}
@Test
void create() throws URISyntaxException, IOException {
OnboardingDetailsCreateQuery request = OnboardingDetailsCreateQuery.builder()
.accessToken(ACCESS_TOKEN)
.addressCity("Brussels")
.addressCountry("BE")
.addressPostalCode("1000")
.addressStreetAddress("123 Main St")
.email("[email protected]")
.enterpriseNumber("0999999999")
.firstName("Jo")
.lastName("Smith")
.organizationName("Smith Ltd")
.phoneNumber("+32484000000")
.vatNumber("BE0999999999")
.initialFinancialInstitutionId(UUID.fromString("8ca9b992-f415-40d3-9624-dc459619b675"))
.build();
when(ibanityHttpClient.post(eq(new URI(ONBOARDING_DETAILS_ENDPOINT)), any(),eq(emptyMap()), eq(ACCESS_TOKEN)))
.thenReturn(loadHttpResponse("json/ponto-connect/create_onboarding_details.json"));
OnboardingDetails actual = onboardingDetailsService.create(request);
assertThat(actual).isEqualToComparingFieldByField(createOnboardingDetails());
}
private OnboardingDetails createOnboardingDetails() {
return OnboardingDetails.builder()
.id(UUID.fromString("df44642f-c38e-4e8c-9373-7f8e0b9f502f"))
.addressCity("Brussels")
.addressCountry("BE")
.addressPostalCode("1000")
.addressStreetAddress("123 Main St")
.email("[email protected]")
.enterpriseNumber("0999999999")
.firstName("Jo")
.lastName("Smith")
.organizationName("Smith Ltd")
.phoneNumber("+32484000000")
.vatNumber("BE0999999999")
.initialFinancialInstitutionId(UUID.fromString("8ca9b992-f415-40d3-9624-dc459619b675"))
.build();
}
}
| 0 |
raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\ponto_connect\services | raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\ponto_connect\services\impl\PaymentActivationRequestServiceImplTest.java | package com.ibanity.apis.client.products.ponto_connect.services.impl;
import com.ibanity.apis.client.http.IbanityHttpClient;
import com.ibanity.apis.client.models.IbanityProduct;
import com.ibanity.apis.client.products.ponto_connect.models.PaymentActivationRequest;
import com.ibanity.apis.client.products.ponto_connect.models.create.PaymentActivationRequestCreateQuery;
import com.ibanity.apis.client.services.ApiUrlProvider;
import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import java.io.IOException;
import java.util.UUID;
import static com.ibanity.apis.client.helpers.IbanityTestHelper.loadHttpResponse;
import static com.ibanity.apis.client.utils.URIHelper.buildUri;
import static java.util.Collections.emptyMap;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
class PaymentActivationRequestServiceImplTest {
private static final String PAYMENT_ACTIVATION_REQUEST_ENDPOINT = "https://api.ibanity.localhost/ponto-connect/payment-activation-request";
private static final UUID PAYMENT_ACTIVATION_REQUEST_ID = UUID.fromString("7e7fca4c-cc8e-4e23-9a5f-cfa4dc175a88");
private static final String ACCESS_TOKEN = "anAccessToken";
@InjectMocks
private PaymentActivationRequestServiceImpl paymentActivationRequestService;
@Mock
private ApiUrlProvider apiUrlProvider;
@Mock
private IbanityHttpClient ibanityHttpClient;
@BeforeEach
void setUp() {
when(apiUrlProvider.find(IbanityProduct.PontoConnect, "paymentActivationRequests"))
.thenReturn(PAYMENT_ACTIVATION_REQUEST_ENDPOINT);
}
@Test
void create() throws IOException {
PaymentActivationRequestCreateQuery paymentActivationRequestCreateQuery =
PaymentActivationRequestCreateQuery.builder()
.accessToken(ACCESS_TOKEN)
.redirectUri("https://example.localhost")
.build();
when(ibanityHttpClient.post(eq(buildUri(PAYMENT_ACTIVATION_REQUEST_ENDPOINT)), any(),eq(emptyMap()), eq(ACCESS_TOKEN)))
.thenReturn(loadHttpResponse("json/ponto-connect/create_payment_activation_request.json"));
PaymentActivationRequest actual = paymentActivationRequestService.create(paymentActivationRequestCreateQuery);
Assertions.assertThat(actual).isEqualToComparingFieldByFieldRecursively(createExpected());
}
private Object createExpected() {
return PaymentActivationRequest.builder()
.id(PAYMENT_ACTIVATION_REQUEST_ID)
.redirectLink("https://authorize.development.myponto.net/organizations/6680437c-8ed8-425b-84b7-2c31e5ca625d/sandbox/integrations/1f5caef0-7dcd-41d0-9318-24bf40ba9d16/payment-activation-requests/7e7fca4c-cc8e-4e23-9a5f-cfa4dc175a88")
.build();
}
}
| 0 |
raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\ponto_connect\services | raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\ponto_connect\services\impl\PaymentServiceImplTest.java | package com.ibanity.apis.client.products.ponto_connect.services.impl;
import com.ibanity.apis.client.http.IbanityHttpClient;
import com.ibanity.apis.client.models.IbanityProduct;
import com.ibanity.apis.client.products.ponto_connect.models.Payment;
import com.ibanity.apis.client.products.ponto_connect.models.create.PaymentCreateQuery;
import com.ibanity.apis.client.products.ponto_connect.models.delete.PaymentDeleteQuery;
import com.ibanity.apis.client.products.ponto_connect.models.read.PaymentReadQuery;
import com.ibanity.apis.client.services.ApiUrlProvider;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import java.io.IOException;
import java.time.LocalDate;
import java.util.UUID;
import static com.ibanity.apis.client.helpers.IbanityTestHelper.loadHttpResponse;
import static com.ibanity.apis.client.utils.URIHelper.buildUri;
import static java.math.BigDecimal.ONE;
import static java.util.Collections.emptyMap;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
class PaymentServiceImplTest {
private static final String PAYMENT_ENDPOINT = "https://api.ibanity.localhost/ponto-connect/accounts/{accountId}/payments/{paymentId}";
private static final String PAYMENT_ENDPOINT_FOR_FIND = "https://api.ibanity.localhost/ponto-connect/accounts/8804e34f-12b0-4b70-86bf-265f013ca232/payments/6c0350b5-a724-42e5-b4ce-ca3a6994df3d";
private static final String PAYMENT_ENDPOINT_FOR_CREATE = "https://api.ibanity.localhost/ponto-connect/accounts/8804e34f-12b0-4b70-86bf-265f013ca232/payments";
private static final UUID ACCOUNT_ID = UUID.fromString("8804e34f-12b0-4b70-86bf-265f013ca232");
private static final UUID PAYMENT_ID = UUID.fromString("6c0350b5-a724-42e5-b4ce-ca3a6994df3d");
private static final String ACCESS_TOKEN = "anAccessToken";
@InjectMocks
private PaymentServiceImpl paymentService;
@Mock
private ApiUrlProvider apiUrlProvider;
@Mock
private IbanityHttpClient ibanityHttpClient;
@BeforeEach
void setUp() {
when(apiUrlProvider.find(IbanityProduct.PontoConnect, "account", "payments"))
.thenReturn(PAYMENT_ENDPOINT);
}
@Test
void find() throws IOException {
PaymentReadQuery paymentReadQuery = PaymentReadQuery.builder()
.accountId(ACCOUNT_ID)
.paymentId(PAYMENT_ID)
.accessToken(ACCESS_TOKEN)
.build();
when(ibanityHttpClient.get(buildUri(PAYMENT_ENDPOINT_FOR_FIND), emptyMap(), ACCESS_TOKEN))
.thenReturn(loadHttpResponse("json/ponto-connect/payment.json"));
Payment actual = paymentService.find(paymentReadQuery);
assertThat(actual).isEqualToComparingFieldByFieldRecursively(createExpected(null));
}
@Test
void create() throws IOException {
PaymentCreateQuery paymentCreateQuery = PaymentCreateQuery.builder()
.accountId(ACCOUNT_ID)
.accessToken(ACCESS_TOKEN)
.build();
when(ibanityHttpClient.post(eq(buildUri(PAYMENT_ENDPOINT_FOR_CREATE)), any(),eq(emptyMap()), eq(ACCESS_TOKEN)))
.thenReturn(loadHttpResponse("json/ponto-connect/payment_create.json"));
Payment actual = paymentService.create(paymentCreateQuery);
assertThat(actual).isEqualToComparingFieldByFieldRecursively(createExpected("https://authorize.myponto.com/organizations/6680437c-8ed8-425b-84b7-2c31e5ca625d/sandbox/integrations/236d8f5c-9e19-45c7-8138-1a50910020ae/accounts/44f261ec-2cc9-47f8-8cad-bcd6994629ed/payments/c3a13020-61a4-4d9e-ab57-1f0df1f20d7d"));
}
@Test
void delete() throws IOException {
PaymentDeleteQuery paymentDeleteQuery = PaymentDeleteQuery.builder()
.paymentId(PAYMENT_ID)
.accountId(ACCOUNT_ID)
.accessToken(ACCESS_TOKEN)
.build();
when(ibanityHttpClient.delete(buildUri(PAYMENT_ENDPOINT_FOR_FIND), emptyMap(), ACCESS_TOKEN))
.thenReturn(loadHttpResponse("json/ponto-connect/payment.json"));
Payment actual = paymentService.delete(paymentDeleteQuery);
assertThat(actual).isEqualToComparingFieldByFieldRecursively(createExpected(null));
}
private Payment createExpected(String redirect) {
return Payment.builder()
.amount(ONE)
.creditorAccountReference("BE84732645584359")
.creditorAccountReferenceType("IBAN")
.creditorAgent("anAgent")
.creditorAgentType("anAgentType")
.creditorName("Alex Creditor")
.currency("EUR")
.id(PAYMENT_ID)
.remittanceInformation("ThisIsATest")
.remittanceInformationType("unstructured")
.requestedExecutionDate(LocalDate.parse("2019-01-01"))
.status("pending")
.redirectLink(redirect)
.endToEndId("1234567890")
.build();
}
}
| 0 |
raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\ponto_connect\services | raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\ponto_connect\services\impl\ReauthorizationRequestServiceImplTest.java | package com.ibanity.apis.client.products.ponto_connect.services.impl;
import com.ibanity.apis.client.http.IbanityHttpClient;
import com.ibanity.apis.client.models.IbanityProduct;
import com.ibanity.apis.client.products.ponto_connect.models.ReauthorizationRequest;
import com.ibanity.apis.client.products.ponto_connect.models.create.ReauthorizationRequestCreateQuery;
import com.ibanity.apis.client.services.ApiUrlProvider;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import java.io.IOException;
import java.time.LocalDate;
import java.util.UUID;
import static com.ibanity.apis.client.helpers.IbanityTestHelper.loadHttpResponse;
import static com.ibanity.apis.client.utils.URIHelper.buildUri;
import static java.math.BigDecimal.ONE;
import static java.util.Collections.emptyMap;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
class ReauthorizationRequestServiceImplTest {
private static final String REAUTHORIZATION_REQUEST_ENDPOINT = "https://api.ibanity.localhost/ponto-connect/accounts/{accountId}/reauthorization-requests/{reauthorizationRequestId}";
private static final String REAUTHORIZATION_REQUEST_ENDPOINT_FOR_CREATE = "https://api.ibanity.localhost/ponto-connect/accounts/44f261ec-2cc9-47f8-8cad-bcd6994629ed/reauthorization-requests";
private static final UUID ACCOUNT_ID = UUID.fromString("44f261ec-2cc9-47f8-8cad-bcd6994629ed");
private static final UUID REAUTHORIZATION_REQUEST_ID = UUID.fromString("7f4a4447-eadf-4529-9145-0b3060c260c8");
private static final String ACCESS_TOKEN = "anAccessToken";
@InjectMocks
private ReauthorizationRequestServiceImpl reauthorizationRequestService;
@Mock
private ApiUrlProvider apiUrlProvider;
@Mock
private IbanityHttpClient ibanityHttpClient;
@BeforeEach
void setUp() {
when(apiUrlProvider.find(IbanityProduct.PontoConnect, "account", "reauthorizationRequests"))
.thenReturn(REAUTHORIZATION_REQUEST_ENDPOINT);
}
@Test
void create() throws IOException {
ReauthorizationRequestCreateQuery reauthorizationRequestCreateQuery = ReauthorizationRequestCreateQuery.builder()
.accountId(ACCOUNT_ID)
.accessToken(ACCESS_TOKEN)
.build();
when(ibanityHttpClient.post(eq(buildUri(REAUTHORIZATION_REQUEST_ENDPOINT_FOR_CREATE)), any(),eq(emptyMap()), eq(ACCESS_TOKEN)))
.thenReturn(loadHttpResponse("json/ponto-connect/create_reauthorization_request.json"));
ReauthorizationRequest actual = reauthorizationRequestService.create(reauthorizationRequestCreateQuery);
assertThat(actual).isEqualToComparingFieldByFieldRecursively(createExpected("https://authorize.myponto.com/organizations/6680437c-8ed8-425b-84b7-2c31e5ca625d/sandbox/integrations/236d8f5c-9e19-45c7-8138-1a50910020ae/accounts/44f261ec-2cc9-47f8-8cad-bcd6994629ed/reauthorization-requests/7f4a4447-eadf-4529-9145-0b3060c260c8"));
}
private ReauthorizationRequest createExpected(String redirect) {
return ReauthorizationRequest.builder()
.id(REAUTHORIZATION_REQUEST_ID)
.redirectLink(redirect)
.build();
}
}
| 0 |
raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\ponto_connect\services | raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\ponto_connect\services\impl\SynchronizationServiceImplTest.java | package com.ibanity.apis.client.products.ponto_connect.services.impl;
import com.ibanity.apis.client.http.IbanityHttpClient;
import com.ibanity.apis.client.mappers.IbanityModelMapper;
import com.ibanity.apis.client.models.IbanityProduct;
import com.ibanity.apis.client.products.ponto_connect.models.Synchronization;
import com.ibanity.apis.client.products.ponto_connect.models.create.SynchronizationCreateQuery;
import com.ibanity.apis.client.products.ponto_connect.models.read.SynchronizationReadQuery;
import com.ibanity.apis.client.products.ponto_connect.models.links.UpdatedTransactionsLinks;
import com.ibanity.apis.client.services.ApiUrlProvider;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.mockito.junit.jupiter.MockitoSettings;
import org.mockito.quality.Strictness;
import java.net.URI;
import java.time.Instant;
import java.util.UUID;
import static com.ibanity.apis.client.helpers.IbanityTestHelper.loadHttpResponse;
import static com.ibanity.apis.client.mappers.ModelMapperHelper.buildRequest;
import static java.util.Collections.emptyMap;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
@MockitoSettings(strictness = Strictness.LENIENT)
public class SynchronizationServiceImplTest {
private static final String SYNCHRONIZATION_ENDPOINT = "https://api.ibanity.localhost/ponto-connect/synchronizations/{synchronizationId}";
private static final String CREATE_SYNCHRONIZATION_ENDPOINT = "https://api.ibanity.localhost/ponto-connect/synchronizations";
private static final String FIND_SYNCHRONIZATION_ENDPOINT = "https://api.ibanity.localhost/ponto-connect/synchronizations/1b3e3011-d018-4785-bbba-9aa75ba14d45";
private static final String SUBTYPE = "accountDetails";
private static final String RESOURCE_ID = "8804e34f-12b0-4b70-86bf-265f013ca232";
private static final String ACCESS_TOKEN = "anAccessToken";
private static final String RESOURCE_TYPE = "account";
public static final UUID SYNCHRONIZATION_ID = UUID.fromString("1b3e3011-d018-4785-bbba-9aa75ba14d45");
@InjectMocks
private SynchronizationServiceImpl synchronizationService;
@Mock
private ApiUrlProvider apiUrlProvider;
@Mock
private IbanityHttpClient ibanityHttpClient;
@BeforeEach
void setUp() {
when(apiUrlProvider.find(IbanityProduct.PontoConnect, "synchronizations")).thenReturn(SYNCHRONIZATION_ENDPOINT);
}
@Test
public void create() throws Exception {
when(ibanityHttpClient.post(new URI(CREATE_SYNCHRONIZATION_ENDPOINT),
buildRequest(Synchronization.RESOURCE_TYPE, Synchronization.builder()
.subtype(SUBTYPE)
.resourceId(RESOURCE_ID)
.resourceType(RESOURCE_TYPE)
.customerIpAddress("0.0.0.0")
.build()),
emptyMap(),
ACCESS_TOKEN))
.thenReturn(loadHttpResponse("json/ponto-connect/synchronization_with_updated_transactions.json"));
Synchronization actual = synchronizationService.create(SynchronizationCreateQuery.builder()
.subtype(SUBTYPE)
.resourceId(RESOURCE_ID)
.accessToken(ACCESS_TOKEN)
.resourceType(RESOURCE_TYPE)
.customerIpAddress("0.0.0.0")
.build());
assertThat(actual).isEqualTo(createExpected(true));
}
@Test
public void find() throws Exception {
when(ibanityHttpClient.get(new URI(FIND_SYNCHRONIZATION_ENDPOINT),
emptyMap(),
ACCESS_TOKEN))
.thenReturn(loadHttpResponse("json/ponto-connect/synchronization.json"));
Synchronization actual = synchronizationService.find(SynchronizationReadQuery.builder()
.synchronizationId(SYNCHRONIZATION_ID)
.accessToken(ACCESS_TOKEN)
.build());
assertThat(actual).isEqualTo(createExpected(false));
}
private Synchronization createExpected(boolean withUpdatedTransactionsLinks) {
Synchronization.SynchronizationBuilder synchronizationBuilder = Synchronization.builder()
.subtype(SUBTYPE)
.resourceId(RESOURCE_ID)
.resourceType(RESOURCE_TYPE)
.id(SYNCHRONIZATION_ID)
.updatedAt(Instant.parse("2019-09-02T11:28:35.971Z"))
.status("pending")
.createdAt(Instant.parse("2019-09-02T11:28:35.971Z"));
if (withUpdatedTransactionsLinks) {
synchronizationBuilder = synchronizationBuilder.updatedTransactionsLinks(
UpdatedTransactionsLinks.builder()
.related("https://api.ibanity.com/ponto-connect/synchronizations/38ea8333-81be-443e-9852-6d86468f5b45/updated-transactions")
.build()
);
}
return synchronizationBuilder.build();
}
}
| 0 |
raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\ponto_connect\services | raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\ponto_connect\services\impl\TokenServiceImplTest.java | package com.ibanity.apis.client.products.ponto_connect.services.impl;
import com.ibanity.apis.client.http.OAuthHttpClient;
import com.ibanity.apis.client.models.IbanityProduct;
import com.ibanity.apis.client.products.ponto_connect.models.Token;
import com.ibanity.apis.client.products.ponto_connect.models.create.TokenCreateQuery;
import com.ibanity.apis.client.products.ponto_connect.models.refresh.TokenRefreshQuery;
import com.ibanity.apis.client.products.ponto_connect.models.revoke.TokenRevokeQuery;
import com.ibanity.apis.client.services.ApiUrlProvider;
import org.apache.http.message.BasicHttpResponse;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.mockito.junit.jupiter.MockitoSettings;
import org.mockito.quality.Strictness;
import java.net.URI;
import java.util.HashMap;
import java.util.Map;
import static com.ibanity.apis.client.helpers.IbanityTestHelper.HTTP;
import static com.ibanity.apis.client.helpers.IbanityTestHelper.loadHttpResponse;
import static java.util.Collections.emptyMap;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
@MockitoSettings(strictness = Strictness.LENIENT)
public class TokenServiceImplTest {
private static final String TOKEN_ENDPOINT = "https://api.ibanity.localhost/ponto-connect/oauth2/token";
private static final String REVOKE_ENDPOINT = "https://api.ibanity.localhost/ponto-connect/oauth2/revoke";
private static final String CLIENT_SECRET = "thisIsASecret";
private static final String REDIRECT_URI = "https://fake-tpp.com/ponto-authorization";
private static final String CODE_VERIFIER = "W1qfWXH3sbboERgZFytVIpXOzicKFq1s1-QGQuKzeko.QQRNd24KDohgkrMYleOmDzAGzwMP5PIETP6B267dJ-w_verifier";
private static final String AUTHORIZATION_CODE = "W1qfWXH3sbboERgZFytVIpXOzicKFq1s1-QGQuKzeko.QQRNd24KDohgkrMYleOmDzAGzwMP5PIETP6B267dJ-w";
private static final String TOKEN = "I_UnPbrN5wH3-b7fhk5p4GIIL_5c5o-0BhXD4myLDoY.vNxkg6557o3pLCHsweSboi2mmeygG1pXVD6k8M95LLJ";
@InjectMocks
private TokenServiceImpl tokenService;
@Mock
private ApiUrlProvider apiUrlProvider;
@Mock
private OAuthHttpClient oAuthHttpClient;
@BeforeEach
void setUp() {
when(apiUrlProvider.find(IbanityProduct.PontoConnect, "oauth2", "token")).thenReturn(TOKEN_ENDPOINT);
when(apiUrlProvider.find(IbanityProduct.PontoConnect, "oauth2", "revoke")).thenReturn(REVOKE_ENDPOINT);
}
@Test
public void create() throws Exception {
when(oAuthHttpClient.post(eq(new URI(TOKEN_ENDPOINT)), eq(emptyMap()), eq(createTokenArguments()), eq(CLIENT_SECRET)))
.thenReturn(loadHttpResponse("json/ponto-connect/create_access_token.json"));
Token actual = tokenService.create(TokenCreateQuery.builder()
.clientSecret(CLIENT_SECRET)
.redirectUri(REDIRECT_URI)
.codeVerifier(CODE_VERIFIER)
.authorizationCode(AUTHORIZATION_CODE)
.build());
assertThat(actual).isEqualToComparingFieldByFieldRecursively(createExcepted());
}
@Test
public void refresh() throws Exception {
when(oAuthHttpClient.post(eq(new URI(TOKEN_ENDPOINT)), eq(emptyMap()), eq(refreshTokenArguments()), eq(CLIENT_SECRET)))
.thenReturn(loadHttpResponse("json/ponto-connect/create_access_token.json"));
Token actual = tokenService.refresh(TokenRefreshQuery.builder()
.clientSecret(CLIENT_SECRET)
.refreshToken(TOKEN)
.build());
assertThat(actual).isEqualToComparingFieldByFieldRecursively(createExcepted());
}
@Test
public void revoke() throws Exception {
when(oAuthHttpClient.post(any(), any(), any(), any()))
.thenReturn(new BasicHttpResponse(HTTP, 204, null));
tokenService.revoke(TokenRevokeQuery.builder()
.clientSecret(CLIENT_SECRET)
.token(TOKEN)
.build());
verify(oAuthHttpClient).post(eq(new URI(REVOKE_ENDPOINT)), eq(emptyMap()), eq(revokeTokenArguments()), eq(CLIENT_SECRET));
}
private Map<String, String> createTokenArguments() {
Map<String, String> arguments = new HashMap<>();
arguments.put("grant_type", "authorization_code");
arguments.put("code", AUTHORIZATION_CODE);
arguments.put("code_verifier", CODE_VERIFIER);
arguments.put("redirect_uri", REDIRECT_URI);
return arguments;
}
private Map<String, String> refreshTokenArguments() {
Map<String, String> arguments = new HashMap<>();
arguments.put("grant_type", "refresh_token");
arguments.put("refresh_token", TOKEN);
return arguments;
}
private Map<String, String> revokeTokenArguments() {
Map<String, String> arguments = new HashMap<>();
arguments.put("token", TOKEN);
return arguments;
}
private Token createExcepted() {
return Token.builder()
.accessToken("MoH3t9zBrnTvlt0qB061Ptjdy0akwwYHm9VY9E6-e4E.a2nK0TfrXsTkVhKzILhKa59_6G1WIUrmvWXko6uYc28")
.expiresIn(1799)
.scope("offline_access ai pi")
.tokenType("bearer")
.refreshToken("I_UnPbrN5wH3-b7fhk5p4GIIL_5c5o-0BhXD4myLDoY.vNxkg6557o3pLCHsweSboi2mmeygG1pXVD6k8M95LLM")
.build();
}
}
| 0 |
raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\ponto_connect\services | raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\ponto_connect\services\impl\TransactionServiceImplTest.java | package com.ibanity.apis.client.products.ponto_connect.services.impl;
import com.ibanity.apis.client.http.IbanityHttpClient;
import com.ibanity.apis.client.models.IbanityCollection;
import com.ibanity.apis.client.models.IbanityProduct;
import com.ibanity.apis.client.products.ponto_connect.models.Transaction;
import com.ibanity.apis.client.products.ponto_connect.models.read.TransactionReadQuery;
import com.ibanity.apis.client.products.ponto_connect.models.read.TransactionsReadQuery;
import com.ibanity.apis.client.services.ApiUrlProvider;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.mockito.junit.jupiter.MockitoSettings;
import org.mockito.quality.Strictness;
import java.math.BigDecimal;
import java.net.URI;
import java.util.UUID;
import static com.ibanity.apis.client.helpers.IbanityTestHelper.loadHttpResponse;
import static java.time.Instant.parse;
import static java.util.Collections.emptyMap;
import static java.util.UUID.fromString;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
@MockitoSettings(strictness = Strictness.LENIENT)
public class TransactionServiceImplTest {
private static final String ACCESS_TOKEN = "thisIsAnAccessToken";
private static final UUID ACCOUNT_ID = fromString("8804e34f-12b0-4b70-86bf-265f013ca232");
private static final UUID TRANSACTION_ID = fromString("a4a47c21-b606-464f-ae17-f8e3af6772c9");
private static final UUID SYNCHRONIZATION_ID = UUID.fromString("9d36e759-b606-41dd-8d18-c882bd8db03d");
private static final String TRANSACTION_ENDPOINT = "https://api.ibanity.localhost/ponto-connect/accounts/{accountId}/transactions/{transactionId}";
private static final String GET_TRANSACTION_ENDPOINT = "https://api.ibanity.localhost/ponto-connect/accounts/8804e34f-12b0-4b70-86bf-265f013ca232/transactions/a4a47c21-b606-464f-ae17-f8e3af6772c9";
private static final String LIST_TRANSACTION_ENDPOINT = "https://api.ibanity.localhost/ponto-connect/accounts/8804e34f-12b0-4b70-86bf-265f013ca232/transactions?page%5Blimit%5D=10";
private static final String UPDATED_TRANSACTIONS_ENDPOINT = "https://api.ibanity.com/ponto-connect/synchronizations/{synchronizationId}/updated-transactions";
private static final String UPDATED_TRANSACTIONS_URI = "https://api.ibanity.com/ponto-connect/synchronizations/9d36e759-b606-41dd-8d18-c882bd8db03d/updated-transactions?page%5Blimit%5D=10";
@InjectMocks
private TransactionServiceImpl transactionService;
@Mock
private ApiUrlProvider apiUrlProvider;
@Mock
private IbanityHttpClient ibanityHttpClient;
@BeforeEach
void setUp() {
when(apiUrlProvider.find(IbanityProduct.PontoConnect, "account", "transactions")).thenReturn(TRANSACTION_ENDPOINT);
}
@Test
public void find() throws Exception {
when(ibanityHttpClient.get(new URI(GET_TRANSACTION_ENDPOINT), emptyMap(), ACCESS_TOKEN))
.thenReturn(loadHttpResponse("json/ponto-connect/transaction.json"));
Transaction actual = transactionService.find(TransactionReadQuery.builder()
.accessToken(ACCESS_TOKEN)
.accountId(ACCOUNT_ID)
.transactionId(TRANSACTION_ID)
.build());
assertThat(actual).isEqualToComparingFieldByFieldRecursively(createExpected());
}
@Test
public void list() throws Exception {
when(ibanityHttpClient.get(new URI(LIST_TRANSACTION_ENDPOINT), emptyMap(), ACCESS_TOKEN))
.thenReturn(loadHttpResponse("json/ponto-connect/transactions.json"));
IbanityCollection<Transaction> actual = transactionService.list(TransactionsReadQuery.builder()
.accessToken(ACCESS_TOKEN)
.accountId(ACCOUNT_ID)
.build());
assertThat(actual.getItems()).containsExactly(createExpected());
assertThat(actual.getPageLimit()).isEqualTo(10);
}
@Test
public void listUpdatedForSynchronization() throws Exception {
when(apiUrlProvider.find(IbanityProduct.PontoConnect, "synchronization", "updatedTransactions")).thenReturn(UPDATED_TRANSACTIONS_ENDPOINT);
when(ibanityHttpClient.get(new URI(UPDATED_TRANSACTIONS_URI), emptyMap(), ACCESS_TOKEN))
.thenReturn(loadHttpResponse("json/ponto-connect/updated-transactions.json"));
IbanityCollection<Transaction> actual = transactionService.listUpdatedForSynchronization(TransactionsReadQuery.builder()
.accessToken(ACCESS_TOKEN)
.synchronizationId(SYNCHRONIZATION_ID)
.build());
assertThat(actual.getItems()).containsExactly(createExpected());
assertThat(actual.getPageLimit()).isEqualTo(10);
}
private Transaction createExpected() {
return Transaction.builder()
.id(TRANSACTION_ID)
.valueDate(parse("2020-06-19T00:00:00.000Z"))
.executionDate(parse("2020-06-19T00:00:00.000Z"))
.amount(new BigDecimal("2.76"))
.counterpartName("Rice Ltd")
.counterpartReference("BE62467153327786")
.description("Wire transfer")
.currency("EUR")
.remittanceInformationType("unstructured")
.remittanceInformation("Tempora animi qui!")
.bankTransactionCode("PMNT-IRCT-ESCT")
.proprietaryBankTransactionCode("63058")
.endToEndId("a965fa0788c241f3b13df3fbda744a07")
.purposeCode("CASH")
.mandateId("486")
.creditorId("315")
.additionalInformation("Aut.")
.digest("2acc87e558b508f7b4bd21829adee7aaace14eedde2b65ec8459201ea7a76050")
.internalReference("ae7976b0-78b7-492f-99d2-8e85ab5ea006")
.cardReference("6666")
.cardReferenceType("MASKEDPAN")
.fee(new BigDecimal("3.14"))
.build();
}
}
| 0 |
raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\ponto_connect\services | raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\ponto_connect\services\impl\UsageServiceImplTest.java | package com.ibanity.apis.client.products.ponto_connect.services.impl;
import com.ibanity.apis.client.http.IbanityHttpClient;
import com.ibanity.apis.client.models.IbanityProduct;
import com.ibanity.apis.client.products.ponto_connect.models.OrganizationUsage;
import com.ibanity.apis.client.products.ponto_connect.models.read.OrganizationUsageReadQuery;
import com.ibanity.apis.client.services.ApiUrlProvider;
import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.mockito.junit.jupiter.MockitoSettings;
import org.mockito.quality.Strictness;
import java.io.IOException;
import java.math.BigDecimal;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.UUID;
import static com.ibanity.apis.client.helpers.IbanityTestHelper.loadHttpResponse;
import static java.util.Collections.emptyMap;
import static java.util.UUID.fromString;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
@MockitoSettings(strictness = Strictness.LENIENT)
class UsageServiceImplTest {
private static final String ACCESS_TOKEN = "thisIsAnAccessToken";
private static final UUID ORGANIZATION_ID = fromString("953934eb-229a-4fd2-8675-07794078cc7d");
private static final String MONTH = "2020-08";
private static final String ORGANIZATION_ENDPOINT = "https://api.development.ibanity.net/ponto-connect/organizations/{organizationId}/usage/{month}";
private static final String GET_ORGANIZATION_ENDPOINT = "https://api.development.ibanity.net/ponto-connect/organizations/" + ORGANIZATION_ID.toString() + "/usage/" + MONTH;
@InjectMocks
private UsageServiceImpl organizationUsageService;
@Mock
private ApiUrlProvider apiUrlProvider;
@Mock
private IbanityHttpClient ibanityHttpClient;
@BeforeEach
void setUp() {
when(apiUrlProvider.find(IbanityProduct.PontoConnect, "organizations", "usage")).thenReturn(ORGANIZATION_ENDPOINT);
}
@Test
void getOrganizationUsage() throws URISyntaxException, IOException {
when(ibanityHttpClient.get(new URI(GET_ORGANIZATION_ENDPOINT), emptyMap(), ACCESS_TOKEN))
.thenReturn(loadHttpResponse("json/ponto-connect/organizations_usage.json"));
OrganizationUsageReadQuery readQuery = OrganizationUsageReadQuery.builder()
.accessToken(ACCESS_TOKEN)
.month(MONTH)
.organizationId(ORGANIZATION_ID)
.build();
OrganizationUsage actual = organizationUsageService.getOrganizationUsage(readQuery);
Assertions.assertThat(actual).isEqualToComparingFieldByField(expected());
}
private OrganizationUsage expected() {
return OrganizationUsage.builder()
.accountCount(BigDecimal.ONE)
.paymentAccountCount(BigDecimal.TEN)
.bulkPaymentCount(new BigDecimal("1.5"))
.id(MONTH)
.paymentCount(new BigDecimal("1.1"))
.build();
}
}
| 0 |
raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\ponto_connect\services | raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\ponto_connect\services\impl\UserinfoServiceImplTest.java | package com.ibanity.apis.client.products.ponto_connect.services.impl;
import com.ibanity.apis.client.http.IbanityHttpClient;
import com.ibanity.apis.client.models.IbanityProduct;
import com.ibanity.apis.client.products.ponto_connect.models.Userinfo;
import com.ibanity.apis.client.products.ponto_connect.models.read.UserinfoReadQuery;
import com.ibanity.apis.client.services.ApiUrlProvider;
import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.mockito.junit.jupiter.MockitoSettings;
import org.mockito.quality.Strictness;
import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.UUID;
import static com.ibanity.apis.client.helpers.IbanityTestHelper.loadHttpResponse;
import static java.util.Collections.emptyMap;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
@MockitoSettings(strictness = Strictness.LENIENT)
class UserinfoServiceImplTest {
private static final String ACCESS_TOKEN = "thisIsAnAccessToken";
private static final String USERINFO_ENDPOINT = "https://api.ibanity.localhost/ponto-connect/userinfo";
@InjectMocks
private UserinfoServiceImpl userinfoService;
@Mock
private ApiUrlProvider apiUrlProvider;
@Mock
private IbanityHttpClient ibanityHttpClient;
@BeforeEach
void setUp() {
when(apiUrlProvider.find(IbanityProduct.PontoConnect, "userinfo")).thenReturn(USERINFO_ENDPOINT);
}
@Test
public void getUserinfo() throws URISyntaxException, IOException {
when(ibanityHttpClient.get(new URI(USERINFO_ENDPOINT), emptyMap(), ACCESS_TOKEN))
.thenReturn(loadHttpResponse("json/ponto-connect/userinfo.json"));
Userinfo actual = userinfoService.getUserinfo(UserinfoReadQuery.builder()
.accessToken(ACCESS_TOKEN)
.build());
Assertions.assertThat(actual).isEqualToComparingFieldByField(expected());
}
private Userinfo expected() {
return Userinfo.builder()
.paymentsActivated(true)
.onboardingComplete(true)
.representativeOrganizationName("Awesome accountant")
.representativeOrganizationId(UUID.fromString("6680437c-8ed8-425b-84b7-2c31e5ca628f"))
.name("New documentation")
.sub("6680437c-8ed8-425b-84b7-2c31e5ca625d")
.paymentsActivationRequested(true)
.build();
}
}
| 0 |
raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\xs2a\sandbox\services | raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\xs2a\sandbox\services\impl\FinancialInstitutionAccountsServiceImplTest.java | package com.ibanity.apis.client.products.xs2a.sandbox.services.impl;
import com.ibanity.apis.client.http.IbanityHttpClient;
import com.ibanity.apis.client.jsonapi.RequestApiModel;
import com.ibanity.apis.client.models.IbanityCollection;
import com.ibanity.apis.client.products.xs2a.sandbox.models.FinancialInstitutionAccount;
import com.ibanity.apis.client.products.xs2a.sandbox.models.factory.create.FinancialInstitutionAccountCreationQuery;
import com.ibanity.apis.client.products.xs2a.sandbox.models.factory.delete.FinancialInstitutionAccountDeleteQuery;
import com.ibanity.apis.client.products.xs2a.sandbox.models.factory.read.FinancialInstitutionAccountReadQuery;
import com.ibanity.apis.client.products.xs2a.sandbox.models.factory.read.FinancialInstitutionAccountsReadQuery;
import com.ibanity.apis.client.services.ApiUrlProvider;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.Collections;
import java.util.UUID;
import static com.ibanity.apis.client.helpers.IbanityTestHelper.loadHttpResponse;
import static com.ibanity.apis.client.models.IbanityProduct.Xs2a;
import static java.math.BigDecimal.ZERO;
import static java.time.Instant.parse;
import static java.util.UUID.fromString;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.util.Lists.newArrayList;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
class FinancialInstitutionAccountsServiceImplTest {
private static final UUID USER_ID = fromString("51e863e8-5213-4c3f-8303-430e83ca49fc");
private static final UUID ACCOUNT_ID = fromString("1bcb2b9e-176d-42fb-9bbb-cc9c7744d573");
private static final UUID FINANCIAL_INSTITUTION_ID = fromString("c96751a0-d43f-4f15-861e-d79ee49f152f");
private static final String API_SCHEMA_ENDPOINT = "https://api.ibanity.com/sandbox/financial-institutions/{financialInstitutionId}/financial-institution-users/{financialInstitutionUserId}/financial-institution-accounts/{financialInstitutionAccountId}";
private static final String ACCOUNT_ENPOINT = "https://api.ibanity.com/sandbox/financial-institutions/c96751a0-d43f-4f15-861e-d79ee49f152f/financial-institution-users/51e863e8-5213-4c3f-8303-430e83ca49fc/financial-institution-accounts";
private static final String FIRST_LINK = "/sandbox/financial-institutions/c96751a0-d43f-4f15-861e-d79ee49f152f/financial-institution-users/51e863e8-5213-4c3f-8303-430e83ca49fc/financial-institution-accounts";
@InjectMocks
private FinancialInstitutionAccountsServiceImpl financialInstitutionAccountsService;
@Mock
private ApiUrlProvider apiUrlProvider;
@Mock
private IbanityHttpClient ibanityHttpClient;
@BeforeEach
void setUp() {
when(apiUrlProvider.find(Xs2a, "sandbox", "financialInstitution", "financialInstitutionAccounts"))
.thenReturn(API_SCHEMA_ENDPOINT);
}
@Test
void find() throws IOException, URISyntaxException {
FinancialInstitutionAccountReadQuery query = FinancialInstitutionAccountReadQuery.builder()
.financialInstitutionAccountId(ACCOUNT_ID)
.financialInstitutionId(FINANCIAL_INSTITUTION_ID)
.financialInstitutionUserId(USER_ID)
.build();
when(ibanityHttpClient.get(new URI(ACCOUNT_ENPOINT + "/" + ACCOUNT_ID)))
.thenReturn(loadHttpResponse("json/sandbox/find_account.json"));
FinancialInstitutionAccount actual = financialInstitutionAccountsService.find(query);
assertThat(actual).isEqualToComparingFieldByFieldRecursively(createExpectedForFind());
}
@Test
void list() throws URISyntaxException, IOException {
FinancialInstitutionAccountsReadQuery query = FinancialInstitutionAccountsReadQuery.builder()
.financialInstitutionId(FINANCIAL_INSTITUTION_ID)
.financialInstitutionUserId(USER_ID)
.build();
when(ibanityHttpClient.get(new URI(ACCOUNT_ENPOINT + "?page%5Blimit%5D=10")))
.thenReturn(loadHttpResponse("json/sandbox/list_accounts.json"));
IbanityCollection<FinancialInstitutionAccount> actual = financialInstitutionAccountsService.list(query);
assertThat(actual).isEqualToComparingFieldByFieldRecursively(
IbanityCollection.builder()
.pageLimit(10)
.firstLink(FIRST_LINK)
.items(Collections.singletonList(createExpectedForFind()))
.build()
);
}
@Test
void delete() throws Exception {
when(ibanityHttpClient.delete(new URI(ACCOUNT_ENPOINT + "/" + ACCOUNT_ID)))
.thenReturn(loadHttpResponse("json/sandbox/delete_account.json"));
FinancialInstitutionAccountDeleteQuery query = FinancialInstitutionAccountDeleteQuery.builder()
.financialInstitutionAccountId(ACCOUNT_ID)
.financialInstitutionId(FINANCIAL_INSTITUTION_ID)
.financialInstitutionUserId(USER_ID)
.build();
FinancialInstitutionAccount actual = financialInstitutionAccountsService.delete(query);
assertThat(actual).isEqualToComparingFieldByFieldRecursively(FinancialInstitutionAccount.builder()
.id(ACCOUNT_ID)
.build());
}
@Test
void create() throws URISyntaxException, IOException {
FinancialInstitutionAccountCreationQuery query = FinancialInstitutionAccountCreationQuery.builder()
.availableBalance(ZERO)
.currency("EUR")
.currentBalance(ZERO)
.description("Checking account")
.reference("BE6621814485468913")
.referenceType("IBAN")
.subtype("checking")
.product("Easy account")
.holderName("John Doe")
.currentBalanceChangedAt(parse("2018-10-25T00:00:00Z"))
.currentBalanceReferenceDate(parse("2018-10-25T01:00:00Z"))
.availableBalanceChangedAt(parse("2018-10-25T02:00:00Z"))
.availableBalanceReferenceDate(parse("2018-10-25T03:00:00Z"))
.financialInstitutionId(FINANCIAL_INSTITUTION_ID)
.financialInstitutionUserId(USER_ID)
.build();
when(ibanityHttpClient.post(new URI(ACCOUNT_ENPOINT), createRequest(query)))
.thenReturn(loadHttpResponse("json/sandbox/find_account.json"));
FinancialInstitutionAccount actual = financialInstitutionAccountsService.create(query);
assertThat(actual).isEqualToComparingFieldByFieldRecursively(createExpectedForFind());
}
private RequestApiModel createRequest(FinancialInstitutionAccountCreationQuery query) {
FinancialInstitutionAccount account = FinancialInstitutionAccount.builder()
.availableBalance(query.getAvailableBalance())
.currency(query.getCurrency())
.currentBalance(query.getCurrentBalance())
.description(query.getDescription())
.reference(query.getReference())
.referenceType(query.getReferenceType())
.subtype(query.getSubtype())
.product(query.getProduct())
.holderName(query.getHolderName())
.currentBalanceChangedAt(query.getCurrentBalanceChangedAt())
.currentBalanceReferenceDate(query.getCurrentBalanceReferenceDate())
.availableBalanceChangedAt(query.getAvailableBalanceChangedAt())
.availableBalanceReferenceDate(query.getAvailableBalanceReferenceDate())
.build();
return RequestApiModel.builder()
.data(
RequestApiModel.RequestDataApiModel.builder()
.attributes(account)
.type(FinancialInstitutionAccount.RESOURCE_TYPE)
.build()
)
.build();
}
private FinancialInstitutionAccount createExpectedForFind() {
return FinancialInstitutionAccount.builder()
.id(ACCOUNT_ID)
.availableBalance(ZERO)
.createdAt(parse("2019-05-09T09:18:06.271096Z"))
.currency("EUR")
.currentBalance(ZERO)
.description("Checking account")
.reference("BE6621814485468913")
.referenceType("IBAN")
.subtype("checking")
.internalReference("account_123")
.product("Easy account")
.holderName("John Doe")
.currentBalanceChangedAt(parse("2018-10-25T00:00:00Z"))
.currentBalanceVariationObservedAt(parse("2018-10-25T00:30:00Z"))
.currentBalanceReferenceDate(parse("2018-10-25T01:00:00Z"))
.availableBalanceChangedAt(parse("2018-10-25T02:00:00Z"))
.availableBalanceVariationObservedAt(parse("2018-10-25T02:30:00Z"))
.availableBalanceReferenceDate(parse("2018-10-25T03:00:00Z"))
.authorizedAt(parse("2018-10-24T01:00:00Z"))
.authorizationExpirationExpectedAt(parse("2019-01-24T01:00:00Z"))
.updatedAt(parse("2019-05-09T09:18:06.271096Z"))
.selfLink("https://api.ibanity.com/sandbox/financial-institutions/c96751a0-d43f-4f15-861e-d79ee49f152f/financial-institution-users/51e863e8-5213-4c3f-8303-430e83ca49fc/financial-institution-accounts/1bcb2b9e-176d-42fb-9bbb-cc9c7744d573")
.financialInstitutionId(FINANCIAL_INSTITUTION_ID)
.financialInstitutionUserId(USER_ID)
.build();
}
}
| 0 |
raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\xs2a\sandbox\services | raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\xs2a\sandbox\services\impl\FinancialInstitutionTransactionsServiceImplTest.java | package com.ibanity.apis.client.products.xs2a.sandbox.services.impl;
import com.ibanity.apis.client.http.IbanityHttpClient;
import com.ibanity.apis.client.jsonapi.RequestApiModel;
import com.ibanity.apis.client.models.IbanityCollection;
import com.ibanity.apis.client.products.xs2a.sandbox.models.FinancialInstitutionTransaction;
import com.ibanity.apis.client.products.xs2a.sandbox.models.factory.create.FinancialInstitutionTransactionCreationQuery;
import com.ibanity.apis.client.products.xs2a.sandbox.models.factory.delete.FinancialInstitutionTransactionDeleteQuery;
import com.ibanity.apis.client.products.xs2a.sandbox.models.factory.read.FinancialInstitutionTransactionReadQuery;
import com.ibanity.apis.client.products.xs2a.sandbox.models.factory.read.FinancialInstitutionTransactionsReadQuery;
import com.ibanity.apis.client.services.ApiUrlProvider;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import java.io.IOException;
import java.math.BigDecimal;
import java.net.URI;
import java.net.URISyntaxException;
import java.util.Collections;
import java.util.UUID;
import static com.ibanity.apis.client.helpers.IbanityTestHelper.loadHttpResponse;
import static com.ibanity.apis.client.models.IbanityProduct.Xs2a;
import static java.time.Instant.parse;
import static java.util.UUID.fromString;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
class FinancialInstitutionTransactionsServiceImplTest {
private static final UUID USER_ID = fromString("21178928-3cbb-4e81-91b6-f8f23238cfe3");
private static final UUID ACCOUNT_ID = fromString("b865968d-c08a-49e8-a8f9-5883416d73f5");
private static final UUID FINANCIAL_INSTITUTION_ID = fromString("8465220e-55c9-446d-a717-2196fd934555");
private static final UUID TRANSACTION_ID = fromString("a7a1bdd6-5148-4165-a1ce-35a99b6ce423");
private static final String TRANSACTION_ENDPOINT = "https://api.ibanity.com/sandbox/financial-institutions/8465220e-55c9-446d-a717-2196fd934555/financial-institution-users/21178928-3cbb-4e81-91b6-f8f23238cfe3/financial-institution-accounts/b865968d-c08a-49e8-a8f9-5883416d73f5/financial-institution-transactions";
private static final String API_SCHEMA_ENDPOINT = "https://api.ibanity.com/sandbox/financial-institutions/{financialInstitutionId}/financial-institution-users/{financialInstitutionUserId}/financial-institution-accounts/{financialInstitutionAccountId}/financial-institution-transactions/{financialInstitutionTransactionId}";
public static final String FIRST_LINK = "/sandbox/financial-institutions/c96751a0-d43f-4f15-861e-d79ee49f152f/financial-institution-users/51e863e8-5213-4c3f-8303-430e83ca49fc/financial-institution-accounts";
@InjectMocks
private FinancialInstitutionTransactionsServiceImpl financialInstitutionTransactionsService;
@Mock
private ApiUrlProvider apiUrlProvider;
@Mock
private IbanityHttpClient ibanityHttpClient;
@BeforeEach
void setUp() {
when(apiUrlProvider.find(Xs2a, "sandbox", "financialInstitution", "financialInstitutionAccount", "financialInstitutionTransactions"))
.thenReturn(API_SCHEMA_ENDPOINT);
}
@Test
void find() throws IOException, URISyntaxException {
FinancialInstitutionTransactionReadQuery query = FinancialInstitutionTransactionReadQuery.builder()
.financialInstitutionAccountId(ACCOUNT_ID)
.financialInstitutionId(FINANCIAL_INSTITUTION_ID)
.financialInstitutionUserId(USER_ID)
.financialInstitutionTransactionId(TRANSACTION_ID)
.build();
when(ibanityHttpClient.get(new URI(TRANSACTION_ENDPOINT + "/" + TRANSACTION_ID)))
.thenReturn(loadHttpResponse("json/sandbox/find_transaction.json"));
FinancialInstitutionTransaction actual = financialInstitutionTransactionsService.find(query);
assertThat(actual).isEqualToComparingFieldByFieldRecursively(createExpectedForFind());
}
@Test
void list() throws URISyntaxException, IOException {
FinancialInstitutionTransactionsReadQuery query = FinancialInstitutionTransactionsReadQuery.builder()
.financialInstitutionAccountId(ACCOUNT_ID)
.financialInstitutionId(FINANCIAL_INSTITUTION_ID)
.financialInstitutionUserId(USER_ID)
.build();
when(ibanityHttpClient.get(new URI(TRANSACTION_ENDPOINT + "?page%5Blimit%5D=10")))
.thenReturn(loadHttpResponse("json/sandbox/list_transactions.json"));
IbanityCollection<FinancialInstitutionTransaction> actual = financialInstitutionTransactionsService.list(query);
assertThat(actual).isEqualToComparingFieldByFieldRecursively(
IbanityCollection.builder()
.pageLimit(10)
.firstLink(FIRST_LINK)
.items(Collections.singletonList(createExpectedForFind()))
.build()
);
}
@Test
void delete() throws Exception {
when(ibanityHttpClient.delete(new URI(TRANSACTION_ENDPOINT + "/" + TRANSACTION_ID)))
.thenReturn(loadHttpResponse("json/sandbox/delete_transaction.json"));
FinancialInstitutionTransactionDeleteQuery query = FinancialInstitutionTransactionDeleteQuery.builder()
.financialInstitutionAccountId(ACCOUNT_ID)
.financialInstitutionId(FINANCIAL_INSTITUTION_ID)
.financialInstitutionUserId(USER_ID)
.financialInstitutionTransactionId(TRANSACTION_ID)
.build();
FinancialInstitutionTransaction actual = financialInstitutionTransactionsService.delete(query);
assertThat(actual).isEqualToComparingFieldByFieldRecursively(FinancialInstitutionTransaction.builder()
.id(TRANSACTION_ID)
.build());
}
@Test
void create() throws URISyntaxException, IOException {
FinancialInstitutionTransactionCreationQuery query = FinancialInstitutionTransactionCreationQuery.builder()
.financialInstitutionAccountId(ACCOUNT_ID)
.financialInstitutionId(FINANCIAL_INSTITUTION_ID)
.financialInstitutionUserId(USER_ID)
.amount(new BigDecimal("6.99"))
.counterpartName("ALLIED BANK PHILIPPINES (UK) PLC")
.counterpartReference("BE4325885699707387")
.currency("EUR")
.description("Small Cotton Shoes")
.executionDate(parse("2018-10-25T00:00:00Z"))
.remittanceInformation("NEW SHOES")
.remittanceInformationType("unstructured")
.valueDate(parse("2018-10-22T00:00:00Z"))
.bankTransactionCode("PMNT-IRCT-ESCT")
.proprietaryBankTransactionCode("prop123")
.endToEndId("61dd468606594217af9965ad3928280d")
.purposeCode("CASH")
.mandateId("12345678")
.creditorId("98765")
.additionalInformation("addional")
.cardReference("6666")
.cardReferenceType("MASKEDPAN")
.fee(new BigDecimal("3.14"))
.build();
when(ibanityHttpClient.post(new URI(TRANSACTION_ENDPOINT), createRequest(query)))
.thenReturn(loadHttpResponse("json/sandbox/find_transaction.json"));
FinancialInstitutionTransaction actual = financialInstitutionTransactionsService.create(query);
assertThat(actual).isEqualToComparingFieldByFieldRecursively(createExpectedForFind());
}
private RequestApiModel createRequest(FinancialInstitutionTransactionCreationQuery query) {
FinancialInstitutionTransaction transaction = FinancialInstitutionTransaction.builder()
.amount(query.getAmount())
.currency(query.getCurrency())
.remittanceInformation(query.getRemittanceInformation())
.remittanceInformationType(query.getRemittanceInformationType())
.counterpartName(query.getCounterpartName())
.counterpartReference(query.getCounterpartReference())
.valueDate(query.getValueDate())
.executionDate(query.getExecutionDate())
.description(query.getDescription())
.bankTransactionCode(query.getBankTransactionCode())
.proprietaryBankTransactionCode(query.getProprietaryBankTransactionCode())
.endToEndId(query.getEndToEndId())
.purposeCode(query.getPurposeCode())
.mandateId(query.getMandateId())
.creditorId(query.getCreditorId())
.additionalInformation(query.getAdditionalInformation())
.cardReference(query.getCardReference())
.cardReferenceType(query.getCardReferenceType())
.fee(query.getFee())
.automaticBooking(query.isAutomaticBooking())
.build();
return RequestApiModel.builder()
.data(
RequestApiModel.RequestDataApiModel.builder()
.attributes(transaction)
.type(FinancialInstitutionTransaction.RESOURCE_TYPE)
.build()
)
.build();
}
private FinancialInstitutionTransaction createExpectedForFind() {
return FinancialInstitutionTransaction.builder()
.id(fromString("6411162a-fe6f-428e-ae52-850291497f6b"))
.amount(new BigDecimal("6.99"))
.counterpartName("ALLIED BANK PHILIPPINES (UK) PLC")
.counterpartReference("BE4325885699707387")
.createdAt(parse("2019-05-09T09:18:13.024220Z"))
.currency("EUR")
.description("Small Cotton Shoes")
.executionDate(parse("2018-10-25T00:00:00Z"))
.remittanceInformation("NEW SHOES")
.remittanceInformationType("unstructured")
.updatedAt(parse("2019-05-09T09:18:13.024220Z"))
.valueDate(parse("2018-10-22T00:00:00Z"))
.internalReference("transaction_12345")
.bankTransactionCode("PMNT-IRCT-ESCT")
.proprietaryBankTransactionCode("prop123")
.endToEndId("61dd468606594217af9965ad3928280d")
.purposeCode("CASH")
.mandateId("12345678")
.creditorId("98765")
.additionalInformation("addional")
.cardReference("6666")
.cardReferenceType("MASKEDPAN")
.fee(new BigDecimal("3.14"))
.automaticBooking(false)
.status("booked")
.financialInstitutionAccountId(fromString("63b35ad7-5af7-47b7-b27c-da4791320d21"))
.selfLink("https://api.ibanity.com/sandbox/financial-institutions/eb4aca94-136d-4077-bce0-220daeb50a4e/financial-institution-users/d2c3aaf0-e617-44e6-9da8-e28bed46d9d4/financial-institution-accounts/63b35ad7-5af7-47b7-b27c-da4791320d21/financial-institution-transactions/6411162a-fe6f-428e-ae52-850291497f6b")
.build();
}
}
| 0 |
raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\xs2a\sandbox\services | raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\xs2a\sandbox\services\impl\FinancialInstitutionUsersServiceImplTest.java | package com.ibanity.apis.client.products.xs2a.sandbox.services.impl;
import com.ibanity.apis.client.http.IbanityHttpClient;
import com.ibanity.apis.client.jsonapi.RequestApiModel;
import com.ibanity.apis.client.models.IbanityCollection;
import com.ibanity.apis.client.paging.IbanityPagingSpec;
import com.ibanity.apis.client.products.xs2a.sandbox.models.FinancialInstitutionUser;
import com.ibanity.apis.client.products.xs2a.sandbox.models.factory.delete.FinancialInstitutionUserDeleteQuery;
import com.ibanity.apis.client.products.xs2a.sandbox.models.factory.read.FinancialInstitutionUserReadQuery;
import com.ibanity.apis.client.products.xs2a.sandbox.models.factory.read.FinancialInstitutionUsersReadQuery;
import com.ibanity.apis.client.products.xs2a.sandbox.models.factory.update.FinancialInstitutionUserUpdateQuery;
import com.ibanity.apis.client.services.ApiUrlProvider;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import java.net.URI;
import java.util.UUID;
import static com.ibanity.apis.client.helpers.IbanityTestHelper.loadHttpResponse;
import static com.ibanity.apis.client.models.IbanityProduct.Xs2a;
import static java.time.Instant.parse;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
class FinancialInstitutionUsersServiceImplTest {
private static final UUID USER_ID = UUID.fromString("868af9c1-8fa8-485a-b798-dfb1f5ae1142");
private static final UUID PREVIOUS_USER_ID = UUID.fromString("868af9c1-8fa8-485a-b798-dfb1f5ae1141");
private static final UUID FOLLOWING_USER_ID = UUID.fromString("868af9c1-8fa8-485a-b798-dfb1f5ae1143");
private static final String USERS_ENDPOINT = "https://api.ibanity.com/sandbox/financial-institution-users";
private static final String API_SCHEMA_ENDPOINT = "https://api.ibanity.com/sandbox/financial-institution-users/{financialInstitutionUserId}";
private static final String USER_ID_ENDPOINT = "https://api.ibanity.com/sandbox/financial-institution-users/868af9c1-8fa8-485a-b798-dfb1f5ae1142";
private static final String NEXT_LINK = "https://api.ibanity.com/sandbox/financial-institution-users?after=d500ddac-27e8-447b-b0a1-dbca8c181b99";
private static final String PREVIOUS_LINK = "https://api.ibanity.com/sandbox/financial-institution-users?before=9089414a-77f8-46b2-b979-edcfad5c2218";
@InjectMocks
private FinancialInstitutionUsersServiceImpl financialInstitutionUsersService;
@Mock
private ApiUrlProvider apiUrlProvider;
@Mock
private IbanityHttpClient ibanityHttpClient;
@BeforeEach
void setUp() {
when(apiUrlProvider.find(Xs2a, "sandbox", "financialInstitutionUsers"))
.thenReturn(API_SCHEMA_ENDPOINT);
}
@Test
void list() throws Exception {
FinancialInstitutionUsersReadQuery query = FinancialInstitutionUsersReadQuery.builder()
.pagingSpec(IbanityPagingSpec.builder()
.after(PREVIOUS_USER_ID)
.build())
.build();
when(ibanityHttpClient.get(new URI(USERS_ENDPOINT + "?page%5Bafter%5D=868af9c1-8fa8-485a-b798-dfb1f5ae1141&page%5Blimit%5D=10"))).thenReturn(loadHttpResponse("json/sandbox/list_users.json"));
IbanityCollection<FinancialInstitutionUser> actual = financialInstitutionUsersService.list(query);
assertThat(actual.getItems()).containsExactly(createExpected());
assertThat(actual.getBeforeCursor()).isEqualTo(PREVIOUS_USER_ID);
assertThat(actual.getAfterCursor()).isEqualTo(FOLLOWING_USER_ID);
assertThat(actual.getNextLink()).isEqualTo(NEXT_LINK);
assertThat(actual.getPreviousLink()).isEqualTo(PREVIOUS_LINK);
}
@Test
void find() throws Exception {
when(ibanityHttpClient.get(new URI(USER_ID_ENDPOINT))).thenReturn(loadHttpResponse("json/sandbox/user.json"));
FinancialInstitutionUserReadQuery query = FinancialInstitutionUserReadQuery.builder()
.financialInstitutionUserId(USER_ID)
.build();
FinancialInstitutionUser actual = financialInstitutionUsersService.find(query);
assertThat(actual).isEqualToComparingFieldByFieldRecursively(createExpected());
}
@Test
void delete() throws Exception {
when(ibanityHttpClient.delete(new URI(USER_ID_ENDPOINT))).thenReturn(loadHttpResponse("json/sandbox/delete_user.json"));
FinancialInstitutionUserDeleteQuery query = FinancialInstitutionUserDeleteQuery.builder()
.financialInstitutionUserId(USER_ID)
.build();
FinancialInstitutionUser actual = financialInstitutionUsersService.delete(query);
FinancialInstitutionUser expected = FinancialInstitutionUser.builder().id(USER_ID).build();
assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
}
@Test
void create() throws Exception {
when(ibanityHttpClient.post(new URI(USERS_ENDPOINT), createRequest())).thenReturn(loadHttpResponse("json/sandbox/user.json"));
FinancialInstitutionUserUpdateQuery query = FinancialInstitutionUserUpdateQuery.builder()
.firstName("aFirstName")
.lastName("aLastName")
.password("aPassword")
.login("aLogin")
.build();
FinancialInstitutionUser actual = financialInstitutionUsersService.create(query);
assertThat(actual).isEqualToComparingFieldByFieldRecursively(createExpected());
}
@Test
void update() throws Exception {
when(ibanityHttpClient.patch(new URI(USER_ID_ENDPOINT), createRequest())).thenReturn(loadHttpResponse("json/sandbox/user.json"));
FinancialInstitutionUserUpdateQuery query = FinancialInstitutionUserUpdateQuery.builder()
.firstName("aFirstName")
.lastName("aLastName")
.password("aPassword")
.login("aLogin")
.financialInstitutionUserId(USER_ID)
.build();
FinancialInstitutionUser actual = financialInstitutionUsersService.update(query);
assertThat(actual).isEqualToComparingFieldByFieldRecursively(createExpected());
}
private RequestApiModel createRequest() {
return RequestApiModel.builder()
.data(RequestApiModel.RequestDataApiModel.builder()
.type(FinancialInstitutionUser.RESOURCE_TYPE)
.attributes(FinancialInstitutionUser.builder()
.firstName("aFirstName")
.lastName("aLastName")
.password("aPassword")
.login("aLogin")
.build())
.build())
.build();
}
private FinancialInstitutionUser createExpected() {
return FinancialInstitutionUser.builder()
.createdAt(parse("2019-05-09T09:20:00.140764Z"))
.firstName("Elmer")
.lastName("Lynch")
.login("elynch")
.password("password")
.updatedAt(parse("2019-05-09T09:20:00.140764Z"))
.id(USER_ID)
.selfLink(USER_ID_ENDPOINT)
.build();
}
}
| 0 |
raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\xs2a\sandbox\services | raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\xs2a\sandbox\services\impl\SandboxFinancialInstitutionsServiceImplTest.java | package com.ibanity.apis.client.products.xs2a.sandbox.services.impl;
import com.ibanity.apis.client.http.IbanityHttpClient;
import com.ibanity.apis.client.jsonapi.RequestApiModel;
import com.ibanity.apis.client.products.xs2a.models.FinancialInstitution;
import com.ibanity.apis.client.products.xs2a.sandbox.models.factory.create.FinancialInstitutionCreationQuery;
import com.ibanity.apis.client.products.xs2a.sandbox.models.factory.delete.FinancialInstitutionDeleteQuery;
import com.ibanity.apis.client.products.xs2a.sandbox.models.factory.update.FinancialInstitutionUpdateQuery;
import com.ibanity.apis.client.services.ApiUrlProvider;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import java.net.URI;
import java.util.Arrays;
import java.util.List;
import java.util.UUID;
import static com.ibanity.apis.client.helpers.IbanityTestHelper.loadHttpResponse;
import static com.ibanity.apis.client.models.IbanityProduct.Xs2a;
import static java.util.UUID.fromString;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
class SandboxFinancialInstitutionsServiceImplTest {
private static final UUID FINANCIAL_INSTITUTION_ID = fromString("1c57b438-6a38-437f-8130-a186f547c6b7");
private static final String API_ENDPOINT = "https://api.ibanity.com/sandbox/financial-institutions";
private static final String API_SCHEMA_ENDPOINT = "https://api.ibanity.com/sandbox/financial-institutions/{financialInstitutionId}";
private static final String API_ENDPOINT_WITH_ID = API_ENDPOINT + "/" + FINANCIAL_INSTITUTION_ID;
private static final List<String> AUTHORIZATION_MODELS = Arrays.asList("detailed", "financialInstitutionOffered");
@InjectMocks
private SandboxFinancialInstitutionsServiceImpl sandboxFinancialInstitutionsService;
@Mock
private IbanityHttpClient ibanityHttpClient;
@Mock
private ApiUrlProvider apiUrlProvider;
@BeforeEach
void setUp() {
when(apiUrlProvider.find(Xs2a, "sandbox", "financialInstitutions")).thenReturn(API_SCHEMA_ENDPOINT);
}
@Test
void create() throws Exception {
FinancialInstitutionCreationQuery query = FinancialInstitutionCreationQuery.builder()
.name("aName")
.financialInstitutionCustomerReferenceRequired(true)
.sharedBrandName("ABC INTERNATIONAL BANK PLC")
.sharedBrandReference("abc-international-bank-plc-be")
.timeZone("Europe/Brussels")
.build();
when(ibanityHttpClient.post(new URI(API_ENDPOINT), createRequest()))
.thenReturn(loadHttpResponse("json/sandbox/financial_institution.json"));
FinancialInstitution actual = sandboxFinancialInstitutionsService.create(query);
assertThat(actual).isEqualToComparingFieldByFieldRecursively(createExpected());
}
@Test
void createWithAuthorizationModels() throws Exception {
FinancialInstitutionCreationQuery query = FinancialInstitutionCreationQuery.builder()
.authorizationModels(AUTHORIZATION_MODELS)
.name("aName")
.financialInstitutionCustomerReferenceRequired(true)
.sharedBrandName("ABC INTERNATIONAL BANK PLC")
.sharedBrandReference("abc-international-bank-plc-be")
.timeZone("Europe/Brussels")
.build();
when(ibanityHttpClient.post(new URI(API_ENDPOINT), createRequest(AUTHORIZATION_MODELS)))
.thenReturn(loadHttpResponse("json/sandbox/financial_institution.json"));
FinancialInstitution actual = sandboxFinancialInstitutionsService.create(query);
assertThat(actual).isEqualToComparingFieldByFieldRecursively(createExpected());
}
@Test
void update() throws Exception {
FinancialInstitutionUpdateQuery query = FinancialInstitutionUpdateQuery.builder()
.name("aName")
.financialInstitutionId(FINANCIAL_INSTITUTION_ID)
.financialInstitutionCustomerReferenceRequired(true)
.sharedBrandName("ABC INTERNATIONAL BANK PLC")
.sharedBrandReference("abc-international-bank-plc-be")
.timeZone("Europe/Brussels")
.build();
when(ibanityHttpClient.patch(new URI(API_ENDPOINT_WITH_ID), createRequest()))
.thenReturn(loadHttpResponse("json/sandbox/financial_institution.json"));
FinancialInstitution actual = sandboxFinancialInstitutionsService.update(query);
assertThat(actual).isEqualToComparingFieldByFieldRecursively(createExpected());
}
@Test
void delete() throws Exception {
FinancialInstitutionDeleteQuery query = FinancialInstitutionDeleteQuery.builder()
.financialInstitutionId(FINANCIAL_INSTITUTION_ID)
.build();
when(ibanityHttpClient.delete(new URI(API_ENDPOINT_WITH_ID)))
.thenReturn(loadHttpResponse("json/sandbox/financial_institution.json"));
FinancialInstitution actual = sandboxFinancialInstitutionsService.delete(query);
assertThat(actual).isEqualToComparingFieldByFieldRecursively(createExpected());
}
private FinancialInstitution createExpected() {
return FinancialInstitution.builder()
.name("MetaBank")
.authorizationModels(AUTHORIZATION_MODELS)
.sandbox(true)
.timeZone("Europe/Brussels")
.id(FINANCIAL_INSTITUTION_ID)
.build();
}
private RequestApiModel createRequest() {
return createRequest(null);
}
private RequestApiModel createRequest(List<String> authorizationModels) {
return RequestApiModel.builder()
.data(RequestApiModel.RequestDataApiModel.builder()
.type(FinancialInstitution.RESOURCE_TYPE)
.attributes(FinancialInstitution.builder()
.authorizationModels(authorizationModels)
.name("aName")
.sandbox(true)
.financialInstitutionCustomerReferenceRequired(true)
.sharedBrandName("ABC INTERNATIONAL BANK PLC")
.sharedBrandReference("abc-international-bank-plc-be")
.timeZone("Europe/Brussels")
.build())
.build())
.build();
}
}
| 0 |
raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\xs2a\services | raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\xs2a\services\impl\AccountInformationAccessRequestAuthorizationsServiceImplTest.java | package com.ibanity.apis.client.products.xs2a.services.impl;
import com.ibanity.apis.client.http.IbanityHttpClient;
import com.ibanity.apis.client.jsonapi.RequestApiModel;
import com.ibanity.apis.client.models.IbanityProduct;
import com.ibanity.apis.client.products.xs2a.models.AccountInformationAccessRequestAuthorization;
import com.ibanity.apis.client.products.xs2a.models.create.AccountInformationAccessRequestAuthorizationCreationQuery;
import com.ibanity.apis.client.products.xs2a.models.links.AccountInformationAccessRequestAuthorizationLinks;
import com.ibanity.apis.client.services.ApiUrlProvider;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Captor;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
import static com.ibanity.apis.client.helpers.IbanityTestHelper.loadHttpResponse;
import static com.ibanity.apis.client.utils.URIHelper.buildUri;
import static java.util.Collections.emptyMap;
import static java.util.UUID.fromString;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
class AccountInformationAccessRequestAuthorizationsServiceImplTest {
private static final UUID FINANCIAL_INSTITUTION_ID = fromString("4876fdd6-7333-4f9f-b142-ba520ca497b1");
private static final UUID ACCOUNT_INFORMATION_ACCESS_REQUEST_ID = fromString("cd273ba1-cb2a-464d-b85d-62c9fc4dc8d9");
private static final UUID AUTHORIZATION_ID = fromString("cd273ba1-cb2a-464d-b85d-62c9fc4dc8d9");
private static final String AUTHORIZATION_CODE = "fndsfhskdfslfjhdskfjdsn";
private static final String CUSTOMER_ACCESS_TOKEN = "kdsfldsfmnvlds;md,vms.kvmdsk.vmd";
private static final String AUTHORIZATION_ENDPOINT = "https://api.ibanity.com/xs2a/customer/financial-institutions/{financialInstitutionId}/account-information-access-requests/{accountInformationAccessRequestId}/authorizations/{authorizationId}";
private static final String AUTHORIZATION_ENDPOINT_FOR_CREATE = "https://api.ibanity.com/xs2a/customer/financial-institutions/4876fdd6-7333-4f9f-b142-ba520ca497b1/account-information-access-requests/cd273ba1-cb2a-464d-b85d-62c9fc4dc8d9/authorizations";
@InjectMocks
private AccountInformationAccessRequestAuthorizationsServiceImpl authorizationsService;
@Mock
private ApiUrlProvider apiUrlProvider;
@Mock
private IbanityHttpClient ibanityHttpClient;
@Captor
private ArgumentCaptor<RequestApiModel> argumentCaptor;
@BeforeEach
void setUp() {
when(apiUrlProvider.find(IbanityProduct.Xs2a, "customer", "financialInstitution", "accountInformationAccessRequest", "authorizations"))
.thenReturn(AUTHORIZATION_ENDPOINT);
}
@Test
void create() throws IOException {
Map<String, String> queryParams = new HashMap<>();
queryParams.put("code", AUTHORIZATION_CODE);
AccountInformationAccessRequestAuthorizationCreationQuery creationQuery = AccountInformationAccessRequestAuthorizationCreationQuery.builder()
.customerAccessToken(CUSTOMER_ACCESS_TOKEN)
.queryParameters(queryParams)
.financialInstitutionId(FINANCIAL_INSTITUTION_ID)
.accountInformationAccessRequestId(ACCOUNT_INFORMATION_ACCESS_REQUEST_ID)
.build();
when(ibanityHttpClient.post(eq(buildUri(AUTHORIZATION_ENDPOINT_FOR_CREATE)), argumentCaptor.capture(), eq(emptyMap()), eq(CUSTOMER_ACCESS_TOKEN))).thenReturn(loadHttpResponse("json/createAuthorization.json"));
AccountInformationAccessRequestAuthorization authorization = authorizationsService.create(creationQuery);
assertThat(authorization).isEqualTo(expected());
AccountInformationAccessRequestAuthorizationsServiceImpl.AccountInformationAccessRequestAuthorization authorizationRequest =
(AccountInformationAccessRequestAuthorizationsServiceImpl.AccountInformationAccessRequestAuthorization) argumentCaptor.getValue().getData().getAttributes();
assertThat(authorizationRequest.getQueryParameters().get("code")).isEqualTo(AUTHORIZATION_CODE);
}
private AccountInformationAccessRequestAuthorization expected() {
return AccountInformationAccessRequestAuthorization.builder()
.id(AUTHORIZATION_ID)
.status("succeeded")
.links(
AccountInformationAccessRequestAuthorizationLinks.builder()
.nextRedirect("https://my-bank.localhost/step-2")
.build()
)
.build();
}
}
| 0 |
raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\xs2a\services | raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\xs2a\services\impl\AccountInformationAccessRequestsServiceImplTest.java | package com.ibanity.apis.client.products.xs2a.services.impl;
import com.ibanity.apis.client.http.IbanityHttpClient;
import com.ibanity.apis.client.jsonapi.RequestApiModel;
import com.ibanity.apis.client.models.IbanityProduct;
import com.ibanity.apis.client.products.xs2a.models.AccountInformationAccessRequest;
import com.ibanity.apis.client.products.xs2a.models.create.AccountInformationAccessRequestCreationQuery;
import com.ibanity.apis.client.products.xs2a.models.create.AuthorizationPortalCreationQuery;
import com.ibanity.apis.client.products.xs2a.models.create.MetaRequestCreationQuery;
import com.ibanity.apis.client.products.xs2a.models.links.AccountInformationAccessLinks;
import com.ibanity.apis.client.products.xs2a.models.links.AccountLinks;
import com.ibanity.apis.client.products.xs2a.models.links.InitialAccountTransactionsSynchronizationsLinks;
import com.ibanity.apis.client.products.xs2a.models.read.AccountInformationAccessRequestReadQuery;
import com.ibanity.apis.client.services.ApiUrlProvider;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Captor;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import java.io.IOException;
import java.math.BigDecimal;
import java.util.Arrays;
import java.util.Collections;
import java.util.UUID;
import static com.ibanity.apis.client.helpers.IbanityTestHelper.loadHttpResponse;
import static com.ibanity.apis.client.utils.URIHelper.buildUri;
import static java.util.Collections.emptyMap;
import static java.util.UUID.fromString;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
class AccountInformationAccessRequestsServiceImplTest {
private static final UUID FINANCIAL_INSTITUTION_ID = fromString("4876fdd6-7333-4f9f-b142-ba520ca497b1");
private static final UUID ACCOUNT_INFORMATION_ACCESS_REQUEST_ID = fromString("cd273ba1-cb2a-464d-b85d-62c9fc4dc8d9");
private static final String CONSENT_REFERENCE = "ae63691f-64e4-4563-a055-a387d38f07e2";
private static final String CUSTOMER_ACCESS_TOKEN = "itsme";
private static final String AIAR_ENDPOINT = "https://api.ibanity.com/xs2a/customer/financial-institutions/{financialInstitutionId}/account-information-access-requests/{accountInformationAccessRequestId}";
private static final String AIAR_ENDPOINT_FOR_FIND = "https://api.ibanity.com/xs2a/customer/financial-institutions/4876fdd6-7333-4f9f-b142-ba520ca497b1/account-information-access-requests/cd273ba1-cb2a-464d-b85d-62c9fc4dc8d9";
private static final String AIAR_ENDPOINT_FOR_CREATE = "https://api.ibanity.com/xs2a/customer/financial-institutions/4876fdd6-7333-4f9f-b142-ba520ca497b1/account-information-access-requests";
private static final String CALLBACK = "https://callback.ibanity.com/sandbox/fi/aiar/i?state=dmF1bHQ6djE6Q3drVzA5VUdCVkhPOUxLc1NjdStpeUZmMmh2L3EremUrdWNUemxwUmlaemtsclgwS095cW15WFJTbGRsN2FFKzRmYjZmMFFkSWxZWUJNQnVCWFJiY2RISUZlNUJQVG1qVjFFTDIvM1BpWXhEVXY4WHA5cEZLdHFrK1FBS2xFYXRYSlhRaXMwNEVndHZNcTJHS1VGK0d2T3h3SkZQalRjUDlJVWRaRzZiMFdHck5nS2tDdTZhck03NEtoalRGR2lCNnVDVjBkdHNIMmNVWEZud1haYUMvN3YyWFFjTzkyZTlyYTRBOVdjd2dSSmtoYnNLS1E0ODgyNWI0WUJMSW8wRW5qNDBRdjd0Z3F2WUY5TElFb1ZpL0VScFNtemx0eER0a0pvSEREUEJlV1phTUVjZUU5RytpLzNieUhuaFdzci84cU02NXJBVjZ3eG1LbEVZR3UzUmRrRTVlL2kyQ0ZxdjRYNEJWNXFZU0JvY2xZZDFxeFZRVUtjVGRPWWk1RG02UjFZZVBvdW4rRDNDbW53eFhRWDNiVlplSFY0UFpPelJHSDJHa1V6UGN2Sjhnei9kN2VFeXBvTk9MaEVQOWNkT0FleUxSUTQ3WXVsN2k1d2NLdHpSYUtFR0JoTTJtdkJoREM2SWY5K1BHK0pKcU9QeGkrRVNCdWovMm5lNWMzWXYxMHMwZGpVV0NPUDRXR3JCakcvbDAwQVhCU2EyaEJmZGFIZ1dlUjZYMVlQOVM1V2pLQzVUOXFxQlRWMklUZWtDUkxzem5PRFZ2ZUtJMUtWald5ajVJUXpTWEkvVE5RTGU4NDhSODFtZTRMSjFaY1pBNkdSaXhSN1p0Y0hrSTNidVlRSWdydmJCNWhMOXVMb2Q5UDFvc0w3dVB6Y205WW50UlVnUDE3SmFVN0RQL2lVYklNeGVjTUxPOEV3YTdvSVdkTG5LUFRyRTk2VkxBaFZMM2lVUXBBY0lJbVk2ekJhMDBRUjg0TUk3Vjh0MXE0aHgzNnBaaWVaRElMVmQ2WXR3cXk5MTZ5YWp0YzNaSWZXYVpMNVByNE1CUjVOTXd0RE1XQTVWNlMySGJPOE5Sd0NZQnB2MytDeFBzVTFuQW54MXN6Uy9sbGpVQTBlU29IbFJDSUJQZUg4Q08wZittMlVYd2hCQXYvKzRudGJWNm12STdCQkJhOGJUcDg0SkE1QjhmNUdWcUx0QWwxdC9hOXNPTEw5ZlNwU3FpbTM2MjhPS3E1UlhoVGRzMytPYWRudkJFSEszSmhpYWxndEVmOTQ1SE1TTHlkK2x2eVFEUHdkTTM3N3ZkQjVZUFBLR2ljaVI0YmFRWjNuZVdZOFBGOHpSQXh1dmplN1l6L0ROZUllc2lQY0xkU1FUMFA5TXg0LzRZRVpKdVE9PQ==";
private static final String RELATED_ACCOUNTS = "https://api.ibanity.com/xs2a/customer/financial-institutions/4876fdd6-7333-4f9f-b142-ba520ca497b1/account-information-access-requests/df9069eb-0577-484c-b9f0-c4b0ebbba11e/accounts";
@InjectMocks
private AccountInformationAccessRequestsServiceImpl accountInformationAccessRequestsService;
@Mock
private ApiUrlProvider apiUrlProvider;
@Mock
private IbanityHttpClient ibanityHttpClient;
@Captor
private ArgumentCaptor<RequestApiModel> requestApiModelArgumentCaptor;
@BeforeEach
void setUp() {
when(apiUrlProvider.find(IbanityProduct.Xs2a, "customer", "financialInstitution", "accountInformationAccessRequests"))
.thenReturn(AIAR_ENDPOINT);
}
@Test
void create() throws IOException {
AccountInformationAccessRequestCreationQuery creationQuery =
AccountInformationAccessRequestCreationQuery.builder()
.customerAccessToken(CUSTOMER_ACCESS_TOKEN)
.financialInstitutionId(FINANCIAL_INSTITUTION_ID)
.redirectUri("https://fake-tpp.com/access-granted")
.consentReference(CONSENT_REFERENCE)
.requestedAccountReferences(Collections.singletonList("BE9766801628897565"))
.locale("fr")
.customerIpAddress("0.0.0.0")
.state("aCustomState")
.allowMulticurrencyAccounts(true)
.financialInstitutionCustomerReference("jdoe0001")
.allowedAccountSubtypes(Arrays.asList("checking", "savings"))
.skipIbanityCompletionCallback(true)
.allowFinancialInstitutionRedirectUri(true)
.metaRequestCreationQuery(MetaRequestCreationQuery.builder()
.requestedPastTransactionDays(BigDecimal.TEN)
.authorizationPortalCreationQuery(AuthorizationPortalCreationQuery.builder()
.disclaimerContent("disclaimerContent")
.build())
.build())
.build();
when(ibanityHttpClient.post(eq(buildUri(AIAR_ENDPOINT_FOR_CREATE)), requestApiModelArgumentCaptor.capture(), eq(emptyMap()), eq(creationQuery.getCustomerAccessToken())))
.thenReturn(loadHttpResponse("json/createAccountInformationAccessRequest.json"));
AccountInformationAccessRequest actual = accountInformationAccessRequestsService.create(creationQuery);
assertThat(actual).isEqualToComparingFieldByFieldRecursively(createExpectedForCreate());
AccountInformationAccessRequestsServiceImpl.AccountInformationAccessRequest attributes =
(AccountInformationAccessRequestsServiceImpl.AccountInformationAccessRequest) requestApiModelArgumentCaptor.getValue().getData().getAttributes();
assertThat(attributes.getState()).isEqualTo("aCustomState");
assertThat(attributes.getFinancialInstitutionCustomerReference()).isEqualTo("jdoe0001");
}
@Test
void find_AccountInformationAccessRequestCreationQuery() throws Exception {
AccountInformationAccessRequestCreationQuery creationQuery =
AccountInformationAccessRequestCreationQuery.builder()
.customerAccessToken(CUSTOMER_ACCESS_TOKEN)
.financialInstitutionId(FINANCIAL_INSTITUTION_ID)
.accountInformationAccessRequestId(ACCOUNT_INFORMATION_ACCESS_REQUEST_ID)
.build();
when(ibanityHttpClient.get(buildUri(AIAR_ENDPOINT_FOR_FIND), emptyMap(), creationQuery.getCustomerAccessToken()))
.thenReturn(loadHttpResponse("json/accountInformationAccessRequest.json"));
AccountInformationAccessRequest actual = accountInformationAccessRequestsService.find(creationQuery);
assertThat(actual).isEqualToComparingFieldByField(expectedForFind());
}
@Test
void find() throws Exception {
AccountInformationAccessRequestReadQuery creationQuery =
AccountInformationAccessRequestReadQuery.builder()
.customerAccessToken(CUSTOMER_ACCESS_TOKEN)
.financialInstitutionId(FINANCIAL_INSTITUTION_ID)
.accountInformationAccessRequestId(ACCOUNT_INFORMATION_ACCESS_REQUEST_ID)
.build();
when(ibanityHttpClient.get(buildUri(AIAR_ENDPOINT_FOR_FIND), emptyMap(), creationQuery.getCustomerAccessToken()))
.thenReturn(loadHttpResponse("json/accountInformationAccessRequest.json"));
AccountInformationAccessRequest actual = accountInformationAccessRequestsService.find(creationQuery);
assertThat(actual).isEqualToComparingFieldByField(expectedForFind());
}
private AccountInformationAccessRequest expectedForFind() {
return AccountInformationAccessRequest.builder()
.id(ACCOUNT_INFORMATION_ACCESS_REQUEST_ID)
.requestedAccountReferences(Collections.singletonList("BE9386908098818901"))
.status("received")
.accountInformationAccessLinks(AccountInformationAccessLinks.builder().build())
.skipIbanityCompletionCallback(true)
.allowFinancialInstitutionRedirectUri(true)
.accountLinks(AccountLinks.builder()
.related("https://api.ibanity.com/xs2a/customer/financial-institutions/4876fdd6-7333-4f9f-b142-ba520ca497b1/account-information-access-requests/cd273ba1-cb2a-464d-b85d-62c9fc4dc8d9/accounts")
.build())
.initialAccountTransactionsSynchronizationsLinks(InitialAccountTransactionsSynchronizationsLinks.builder()
.related("https://api.ibanity.com/xs2a/customer/financial-institutions/4876fdd6-7333-4f9f-b142-ba520ca497b1/account-information-access-requests/cd273ba1-cb2a-464d-b85d-62c9fc4dc8d9/initial-account-transactions-synchronizations")
.build())
.build();
}
private AccountInformationAccessRequest createExpectedForCreate() {
return AccountInformationAccessRequest.builder()
.id(ACCOUNT_INFORMATION_ACCESS_REQUEST_ID)
.status("received")
.requestedAccountReferences(Arrays.asList("BE9386908098818901"))
.skipIbanityCompletionCallback(true)
.allowFinancialInstitutionRedirectUri(true)
.accountInformationAccessLinks(AccountInformationAccessLinks.builder()
.redirect(CALLBACK)
.build())
.accountLinks(AccountLinks.builder()
.related(RELATED_ACCOUNTS)
.build())
.build();
}
}
| 0 |
raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\xs2a\services | raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\xs2a\services\impl\AccountsServiceImplTest.java | package com.ibanity.apis.client.products.xs2a.services.impl;
import com.ibanity.apis.client.http.IbanityHttpClient;
import com.ibanity.apis.client.models.*;
import com.ibanity.apis.client.products.xs2a.models.Account;
import com.ibanity.apis.client.products.xs2a.models.Synchronization;
import com.ibanity.apis.client.products.xs2a.models.delete.AccountDeleteQuery;
import com.ibanity.apis.client.products.xs2a.models.read.AccountReadQuery;
import com.ibanity.apis.client.products.xs2a.models.read.AccountsReadQuery;
import com.ibanity.apis.client.services.ApiUrlProvider;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.mockito.junit.jupiter.MockitoSettings;
import org.mockito.quality.Strictness;
import java.math.BigDecimal;
import java.net.URI;
import java.util.Collections;
import java.util.UUID;
import static com.ibanity.apis.client.helpers.IbanityTestHelper.loadHttpResponse;
import static java.time.Instant.parse;
import static java.util.Collections.emptyMap;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
@MockitoSettings(strictness = Strictness.LENIENT)
class AccountsServiceImplTest {
private static final UUID ACCOUNT_ID = UUID.fromString("d6d2a2bc-6607-467b-ac78-86e4e19963ff");
private static final UUID SYNCHRONIZATION_ID = UUID.fromString("d57d0a33-dcc0-4a45-b517-ca6a9d978fac");
private static final UUID FINANCIAL_INSTITUTION_ID = UUID.fromString("43a02473-1023-4b70-a881-6c9b1857e8e6");
private static final UUID ACCOUNT_INFORMATION_ACCESS_REQUEST_ID = UUID.fromString("4e4293b4-ffbd-4bc6-a02d-3899d199a6cc");
private static final String CUSTOMER_ACCESS_TOKEN = "itsme";
private static final String ACCOUNT_ENDPOINT = "https://api.ibanity.com/xs2a/customer/accounts/d6d2a2bc-6607-467b-ac78-86e4e19963ff";
private static final String ACCOUNT_BY_AIAR_ENDPOINT = "https://api.ibanity.com/xs2a/customer/financial-institutions/43a02473-1023-4b70-a881-6c9b1857e8e6/account-information-access-requests/4e4293b4-ffbd-4bc6-a02d-3899d199a6cc/accounts";
private static final String ACCOUNT_BY_FINANCIAL_INSTITUTION_ENDPOINT = "https://api.ibanity.com/xs2a/customer/financial-institutions/43a02473-1023-4b70-a881-6c9b1857e8e6/accounts/d6d2a2bc-6607-467b-ac78-86e4e19963ff";
@InjectMocks
private AccountsServiceImpl accountsService;
@Mock
private ApiUrlProvider apiUrlProvider;
@Mock
private IbanityHttpClient ibanityHttpClient;
@BeforeEach
void setUp() {
when(apiUrlProvider.find(IbanityProduct.Xs2a, "customer", "accounts")).thenReturn(ACCOUNT_ENDPOINT);
when(apiUrlProvider.find(IbanityProduct.Xs2a, "customer", "financialInstitution", "accounts")).thenReturn(ACCOUNT_BY_FINANCIAL_INSTITUTION_ENDPOINT);
when(apiUrlProvider.find(IbanityProduct.Xs2a, "customer", "financialInstitution", "accountInformationAccessRequest", "accounts")).thenReturn(ACCOUNT_BY_AIAR_ENDPOINT);
}
@Test
void find() throws Exception {
AccountReadQuery accountReadQuery =
AccountReadQuery.builder()
.accountId(ACCOUNT_ID)
.customerAccessToken(CUSTOMER_ACCESS_TOKEN)
.financialInstitutionId(FINANCIAL_INSTITUTION_ID)
.build();
when(ibanityHttpClient.get(new URI(ACCOUNT_BY_FINANCIAL_INSTITUTION_ENDPOINT + "/" + ACCOUNT_ID), emptyMap(), CUSTOMER_ACCESS_TOKEN))
.thenReturn(loadHttpResponse("json/account.json"));
Account actual = accountsService.find(accountReadQuery);
assertThat(actual).isEqualToComparingFieldByField(createExpected());
}
@Test
void delete() throws Exception {
AccountDeleteQuery accountReadQuery =
AccountDeleteQuery.builder()
.accountId(ACCOUNT_ID)
.customerAccessToken(CUSTOMER_ACCESS_TOKEN)
.financialInstitutionId(FINANCIAL_INSTITUTION_ID)
.build();
when(ibanityHttpClient.delete(new URI(ACCOUNT_BY_FINANCIAL_INSTITUTION_ENDPOINT + "/" + ACCOUNT_ID), emptyMap(), CUSTOMER_ACCESS_TOKEN))
.thenReturn(loadHttpResponse("json/deleteAccount.json"));
Account actual = accountsService.delete(accountReadQuery);
assertThat(actual).isEqualToComparingFieldByField(Account.builder()
.id(ACCOUNT_ID)
.build());
}
@Test
void list_forAccountInformationAccessRequest() throws Exception {
AccountsReadQuery accountsReadQuery = AccountsReadQuery.builder()
.customerAccessToken(CUSTOMER_ACCESS_TOKEN)
.financialInstitutionId(FINANCIAL_INSTITUTION_ID)
.accountInformationAccessRequestId(ACCOUNT_INFORMATION_ACCESS_REQUEST_ID)
.build();
when(ibanityHttpClient.get(new URI(ACCOUNT_BY_AIAR_ENDPOINT + "?page%5Blimit%5D=10"), emptyMap(), CUSTOMER_ACCESS_TOKEN))
.thenReturn(loadHttpResponse("json/accounts.json"));
IbanityCollection<Account> actual = accountsService.list(accountsReadQuery);
assertThat(actual.getItems()).containsExactly(createExpected());
assertThat(actual.getPageLimit()).isEqualTo(10);
}
@Test
void list_forFinancialInstitutions() throws Exception {
AccountsReadQuery accountsReadQuery = AccountsReadQuery.builder()
.customerAccessToken(CUSTOMER_ACCESS_TOKEN)
.financialInstitutionId(FINANCIAL_INSTITUTION_ID)
.build();
when(ibanityHttpClient.get(new URI(ACCOUNT_BY_FINANCIAL_INSTITUTION_ENDPOINT + "?page%5Blimit%5D=10"), emptyMap(), CUSTOMER_ACCESS_TOKEN))
.thenReturn(loadHttpResponse("json/accounts.json"));
IbanityCollection<Account> actual = accountsService.list(accountsReadQuery);
assertThat(actual.getItems()).containsExactly(createExpected());
assertThat(actual.getPageLimit()).isEqualTo(10);
}
@Test
void list_forErrorInSynchronization() throws Exception {
AccountsReadQuery accountsReadQuery = AccountsReadQuery.builder()
.customerAccessToken(CUSTOMER_ACCESS_TOKEN)
.financialInstitutionId(FINANCIAL_INSTITUTION_ID)
.build();
when(ibanityHttpClient.get(new URI(ACCOUNT_BY_FINANCIAL_INSTITUTION_ENDPOINT + "?page%5Blimit%5D=10"), emptyMap(), CUSTOMER_ACCESS_TOKEN))
.thenReturn(loadHttpResponse("json/accounts_with_sync_errors.json"));
IbanityCollection<Account> actual = accountsService.list(accountsReadQuery);
Account expected = createExpected();
expected.setLatestSynchronization(createSynchronizationError());
assertThat(actual.getItems()).containsExactly(expected);
assertThat(actual.getPageLimit()).isEqualTo(10);
}
@Test
void list() throws Exception {
AccountsReadQuery accountsReadQuery = AccountsReadQuery.builder()
.customerAccessToken(CUSTOMER_ACCESS_TOKEN)
.build();
when(ibanityHttpClient.get(new URI(ACCOUNT_ENDPOINT + "?page%5Blimit%5D=10"), emptyMap(), CUSTOMER_ACCESS_TOKEN))
.thenReturn(loadHttpResponse("json/accounts.json"));
IbanityCollection<Account> actual = accountsService.list(accountsReadQuery);
assertThat(actual.getItems()).containsExactly(createExpected());
assertThat(actual.getPageLimit()).isEqualTo(10);
}
private Account createExpected() {
return Account.builder()
.id(ACCOUNT_ID)
.selfLink(ACCOUNT_BY_FINANCIAL_INSTITUTION_ENDPOINT)
.referenceType("IBAN")
.reference("BE0178572046576544")
.financialInstitutionId(FINANCIAL_INSTITUTION_ID)
.description("Checking account")
.currentBalance(BigDecimal.ZERO)
.currency("EUR")
.availableBalance(BigDecimal.ZERO)
.subtype("checking")
.internalReference("account_123")
.product("Easy account")
.holderName("John Doe")
.availability("available")
.currentBalanceChangedAt(parse("2018-10-25T00:00:00Z"))
.currentBalanceVariationObservedAt(parse("2018-10-25T00:30:00Z"))
.currentBalanceReferenceDate(parse("2018-10-25T01:00:00Z"))
.availableBalanceChangedAt(parse("2018-10-25T02:00:00Z"))
.availableBalanceVariationObservedAt(parse("2018-10-25T02:30:00Z"))
.availableBalanceReferenceDate(parse("2018-10-25T03:00:00Z"))
.authorizedAt(parse("2018-10-24T01:00:00Z"))
.authorizationExpirationExpectedAt(parse("2019-01-24T01:00:00Z"))
.synchronizedAt(parse("2019-05-09T09:19:37.683Z"))
.latestSynchronization(createSynchronization())
.build();
}
private Synchronization createSynchronization() {
return Synchronization.builder()
.id(SYNCHRONIZATION_ID)
.resourceId(ACCOUNT_ID.toString())
.resourceType("account")
.status("success")
.subtype("accountDetails")
.createdAt(parse("2019-05-09T09:19:37.683Z"))
.updatedAt(parse("2019-05-09T09:19:37.683Z"))
.build();
}
private Synchronization createSynchronizationError() {
return Synchronization.builder()
.id(SYNCHRONIZATION_ID)
.resourceId(ACCOUNT_ID.toString())
.resourceType("account")
.status("error")
.errors(Collections.singletonList(IbanityError.builder()
.code("authorizationInvalid")
.detail("The authorization is invalid, you should ask the customer to reauthorize the account")
.meta(ErrorMeta.builder()
.financialInstitutionResponse(FinancialInstitutionResponse.builder()
.body("{\"tppMessages\":[{\"category\":\"ERROR\",\"code\":\"NOT_FOUND\",\"text\":\"3.2 - Not Found\"}]}")
.requestId("354fwfwef4w684")
.statusCode(500)
.timestamp(parse("2019-05-09T09:18:00.000Z"))
.requestUri("http://google.com")
.build())
.build())
.build()))
.subtype("accountDetails")
.createdAt(parse("2019-05-09T09:19:37.683Z"))
.updatedAt(parse("2019-05-09T09:19:37.683Z"))
.build();
}
}
| 0 |
raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\xs2a\services | raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\xs2a\services\impl\AuthorizationsServiceImplTest.java | package com.ibanity.apis.client.products.xs2a.services.impl;
import com.ibanity.apis.client.http.IbanityHttpClient;
import com.ibanity.apis.client.jsonapi.RequestApiModel;
import com.ibanity.apis.client.models.IbanityProduct;
import com.ibanity.apis.client.products.xs2a.models.Authorization;
import com.ibanity.apis.client.products.xs2a.models.create.AuthorizationCreationQuery;
import com.ibanity.apis.client.services.ApiUrlProvider;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Captor;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
import static com.ibanity.apis.client.helpers.IbanityTestHelper.loadHttpResponse;
import static com.ibanity.apis.client.utils.URIHelper.buildUri;
import static java.util.Collections.emptyMap;
import static java.util.UUID.fromString;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
class AuthorizationsServiceImplTest {
private static final UUID FINANCIAL_INSTITUTION_ID = fromString("4876fdd6-7333-4f9f-b142-ba520ca497b1");
private static final UUID ACCOUNT_INFORMATION_ACCESS_REQUEST_ID = fromString("cd273ba1-cb2a-464d-b85d-62c9fc4dc8d9");
private static final UUID AUTHORIZATION_ID = fromString("cd273ba1-cb2a-464d-b85d-62c9fc4dc8d9");
private static final String AUTHORIZATION_CODE = "fndsfhskdfslfjhdskfjdsn";
private static final String CUSTOMER_ACCESS_TOKEN = "kdsfldsfmnvlds;md,vms.kvmdsk.vmd";
private static final String AUTHORIZATION_ENDPOINT = "https://api.ibanity.com/xs2a/customer/financial-institutions/{financialInstitutionId}/account-information-access-requests/{accountInformationAccessRequestId}/authorizations/{authorizationId}";
private static final String AUTHORIZATION_ENDPOINT_FOR_CREATE = "https://api.ibanity.com/xs2a/customer/financial-institutions/4876fdd6-7333-4f9f-b142-ba520ca497b1/account-information-access-requests/cd273ba1-cb2a-464d-b85d-62c9fc4dc8d9/authorizations";
@InjectMocks
private AuthorizationsServiceImpl authorizationsService;
@Mock
private ApiUrlProvider apiUrlProvider;
@Mock
private IbanityHttpClient ibanityHttpClient;
@Captor
private ArgumentCaptor<RequestApiModel> argumentCaptor;
@BeforeEach
void setUp() {
when(apiUrlProvider.find(IbanityProduct.Xs2a, "customer", "financialInstitution", "accountInformationAccessRequest", "authorizations"))
.thenReturn(AUTHORIZATION_ENDPOINT);
}
@Test
void create() throws IOException {
Map<String, String> queryParams = new HashMap<>();
queryParams.put("code", AUTHORIZATION_CODE);
AuthorizationCreationQuery creationQuery = AuthorizationCreationQuery.builder()
.customerAccessToken(CUSTOMER_ACCESS_TOKEN)
.queryParameters(queryParams)
.financialInstitutionId(FINANCIAL_INSTITUTION_ID)
.accountInformationAccessRequestId(ACCOUNT_INFORMATION_ACCESS_REQUEST_ID)
.build();
when(ibanityHttpClient.post(eq(buildUri(AUTHORIZATION_ENDPOINT_FOR_CREATE)), argumentCaptor.capture(), eq(emptyMap()), eq(CUSTOMER_ACCESS_TOKEN))).thenReturn(loadHttpResponse("json/createAuthorization.json"));
Authorization authorization = authorizationsService.create(creationQuery);
assertThat(authorization).isEqualTo(expected());
AuthorizationsServiceImpl.Authorization authorizationRequest = (AuthorizationsServiceImpl.Authorization) argumentCaptor.getValue().getData().getAttributes();
assertThat(authorizationRequest.getQueryParameters().get("code")).isEqualTo(AUTHORIZATION_CODE);
}
private Authorization expected() {
return Authorization.builder()
.id(AUTHORIZATION_ID)
.status("succeeded")
.build();
}
}
| 0 |
raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\xs2a\services | raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\xs2a\services\impl\BatchSynchronizationServiceImplTest.java | package com.ibanity.apis.client.products.xs2a.services.impl;
import com.ibanity.apis.client.helpers.IbanityTestHelper;
import com.ibanity.apis.client.http.IbanityHttpClient;
import com.ibanity.apis.client.jsonapi.RequestApiModel;
import com.ibanity.apis.client.models.IbanityProduct;
import com.ibanity.apis.client.products.xs2a.models.BatchSynchronization;
import com.ibanity.apis.client.products.xs2a.models.Synchronization;
import com.ibanity.apis.client.products.xs2a.models.create.BatchSynchronizationCreationQuery;
import com.ibanity.apis.client.services.ApiUrlProvider;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import java.net.URI;
import java.time.Instant;
import java.util.Arrays;
import java.util.UUID;
import static java.util.Collections.emptyMap;
import static java.util.UUID.fromString;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
class BatchSynchronizationServiceImplTest {
private static final UUID BATCH_SYNCHRONIZATION_ID = fromString("04e98b21-8213-4aec-b373-13eb51f948e9");
private static final String BATCH_SYNCHRONIZATION_ENDPOINT = "https://api.ibanity.com/xs2a/batch-synchronizations";
private static final Instant BATCH_SYNCHRONIZATION_X_DATE = Instant.parse("2022-05-17T00:00:00.000Z");
@Mock
private ApiUrlProvider apiUrlProvider;
@Mock
private IbanityHttpClient ibanityHttpClient;
@InjectMocks
private BatchSynchronizationServiceImpl batchSynchronizationService;
@BeforeEach
void setUp() {
when(apiUrlProvider.find(IbanityProduct.Xs2a, "batchSynchronizations")).thenReturn(BATCH_SYNCHRONIZATION_ENDPOINT);
}
@Test
void create() throws Exception {
BatchSynchronizationCreationQuery batchSynchronizationCreationQuery =
BatchSynchronizationCreationQuery.builder()
.resourceType("account")
.cancelAfter(BATCH_SYNCHRONIZATION_X_DATE)
.unlessSynchronizedAfter(BATCH_SYNCHRONIZATION_X_DATE)
.subtypes(Arrays.asList("accountDetails", "accountTransactions"))
.build();
when(ibanityHttpClient.post(new URI(BATCH_SYNCHRONIZATION_ENDPOINT), createRequest(batchSynchronizationCreationQuery), emptyMap(), null))
.thenReturn(IbanityTestHelper.loadHttpResponse("json/createBatchSynchronization.json"));
BatchSynchronization actual = batchSynchronizationService.create(batchSynchronizationCreationQuery);
assertThat(actual).isEqualToComparingFieldByField(createExpected());
}
private RequestApiModel createRequest(BatchSynchronizationCreationQuery batchSynchronizationCreationQuery) {
BatchSynchronization batchSynchronization = BatchSynchronization.builder()
.resourceType(batchSynchronizationCreationQuery.getResourceType())
.subtypes(batchSynchronizationCreationQuery.getSubtypes())
.cancelAfter(batchSynchronizationCreationQuery.getCancelAfter())
.unlessSynchronizedAfter(batchSynchronizationCreationQuery.getUnlessSynchronizedAfter())
.build();
return RequestApiModel.builder()
.data(
RequestApiModel.RequestDataApiModel.builder()
.attributes(batchSynchronization)
.type(Synchronization.RESOURCE_TYPE)
.build()
)
.build();
}
private BatchSynchronization createExpected() {
BatchSynchronization.BatchSynchronizationBuilder batchSynchronizationBuilder = BatchSynchronization.builder()
.id(BATCH_SYNCHRONIZATION_ID)
.resourceType("account")
.cancelAfter(BATCH_SYNCHRONIZATION_X_DATE)
.unlessSynchronizedAfter(BATCH_SYNCHRONIZATION_X_DATE)
.subtypes(Arrays.asList("accountDetails", "accountTransactions"));
return batchSynchronizationBuilder
.build();
}
}
| 0 |
raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\xs2a\services | raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\xs2a\services\impl\BulkPaymentInitiationRequestAuthorizationsServiceImplTest.java | package com.ibanity.apis.client.products.xs2a.services.impl;
import com.ibanity.apis.client.http.IbanityHttpClient;
import com.ibanity.apis.client.jsonapi.RequestApiModel;
import com.ibanity.apis.client.models.IbanityProduct;
import com.ibanity.apis.client.products.xs2a.models.BulkPaymentInitiationRequestAuthorization;
import com.ibanity.apis.client.products.xs2a.models.create.BulkPaymentInitiationRequestAuthorizationCreationQuery;
import com.ibanity.apis.client.products.xs2a.models.links.BulkPaymentInitiationRequestAuthorizationLinks;
import com.ibanity.apis.client.services.ApiUrlProvider;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Captor;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
import static com.ibanity.apis.client.helpers.IbanityTestHelper.loadHttpResponse;
import static com.ibanity.apis.client.utils.URIHelper.buildUri;
import static java.util.Collections.emptyMap;
import static java.util.UUID.fromString;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
class BulkPaymentInitiationRequestAuthorizationsServiceImplTest {
private static final UUID FINANCIAL_INSTITUTION_ID = fromString("4876fdd6-7333-4f9f-b142-ba520ca497b1");
private static final UUID PAYMENT_INITIATION_REQUEST_ID = fromString("cd273ba1-cb2a-464d-b85d-62c9fc4dc8d9");
private static final UUID AUTHORIZATION_ID = fromString("cd273ba1-cb2a-464d-b85d-62c9fc4dc8d9");
private static final String AUTHORIZATION_CODE = "fndsfhskdfslfjhdskfjdsn";
private static final String CUSTOMER_ACCESS_TOKEN = "kdsfldsfmnvlds;md,vms.kvmdsk.vmd";
private static final String AUTHORIZATION_ENDPOINT = "https://api.ibanity.com/xs2a/customer/financial-institutions/{financialInstitutionId}/payment-initiation-requests/{paymentInitiationRequestId}/authorizations/{authorizationId}";
private static final String AUTHORIZATION_ENDPOINT_FOR_CREATE = "https://api.ibanity.com/xs2a/customer/financial-institutions/4876fdd6-7333-4f9f-b142-ba520ca497b1/payment-initiation-requests/cd273ba1-cb2a-464d-b85d-62c9fc4dc8d9/authorizations";
@InjectMocks
private BulkPaymentInitiationRequestAuthorizationsServiceImpl authorizationsService;
@Mock
private ApiUrlProvider apiUrlProvider;
@Mock
private IbanityHttpClient ibanityHttpClient;
@Captor
private ArgumentCaptor<RequestApiModel> argumentCaptor;
@BeforeEach
void setUp() {
when(apiUrlProvider.find(IbanityProduct.Xs2a, "customer", "financialInstitution", "bulkPaymentInitiationRequest", "authorizations"))
.thenReturn(AUTHORIZATION_ENDPOINT);
}
@Test
void create() throws IOException {
Map<String, String> queryParams = new HashMap<>();
queryParams.put("code", AUTHORIZATION_CODE);
BulkPaymentInitiationRequestAuthorizationCreationQuery creationQuery = BulkPaymentInitiationRequestAuthorizationCreationQuery.builder()
.customerAccessToken(CUSTOMER_ACCESS_TOKEN)
.queryParameters(queryParams)
.financialInstitutionId(FINANCIAL_INSTITUTION_ID)
.paymentInitiationRequestId(PAYMENT_INITIATION_REQUEST_ID)
.build();
when(ibanityHttpClient.post(eq(buildUri(AUTHORIZATION_ENDPOINT_FOR_CREATE)), argumentCaptor.capture(), eq(emptyMap()), eq(CUSTOMER_ACCESS_TOKEN))).thenReturn(loadHttpResponse("json/createPaymentInitiationRequestAuthorization.json"));
BulkPaymentInitiationRequestAuthorization authorization = authorizationsService.create(creationQuery);
assertThat(authorization).isEqualTo(expected());
BulkPaymentInitiationRequestAuthorizationsServiceImpl.BulkPaymentInitiationRequestAuthorization authorizationRequest =
(BulkPaymentInitiationRequestAuthorizationsServiceImpl.BulkPaymentInitiationRequestAuthorization) argumentCaptor.getValue().getData().getAttributes();
assertThat(authorizationRequest.getQueryParameters().get("code")).isEqualTo(AUTHORIZATION_CODE);
}
private BulkPaymentInitiationRequestAuthorization expected() {
return BulkPaymentInitiationRequestAuthorization.builder()
.id(AUTHORIZATION_ID)
.status("succeeded")
.links(BulkPaymentInitiationRequestAuthorizationLinks.builder()
.nextRedirect("https://www.bnpp.com/next-step")
.build())
.build();
}
}
| 0 |
raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\xs2a\services | raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\xs2a\services\impl\BulkPaymentInitiationRequestServiceImplTest.java | package com.ibanity.apis.client.products.xs2a.services.impl;
import com.ibanity.apis.client.http.IbanityHttpClient;
import com.ibanity.apis.client.jsonapi.RequestApiModel;
import com.ibanity.apis.client.models.IbanityProduct;
import com.ibanity.apis.client.products.xs2a.models.BulkPaymentInitiationRequest;
import com.ibanity.apis.client.products.xs2a.models.create.BulkPaymentInitiationRequestCreationQuery;
import com.ibanity.apis.client.products.xs2a.models.links.BulkPaymentInitiationAuthorizationLinks;
import com.ibanity.apis.client.products.xs2a.models.links.FinancialInstitutionLinks;
import com.ibanity.apis.client.products.xs2a.models.read.BulkPaymentInitiationRequestReadQuery;
import com.ibanity.apis.client.services.ApiUrlProvider;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import java.io.IOException;
import java.math.BigDecimal;
import java.time.LocalDate;
import java.util.Collections;
import java.util.UUID;
import java.util.stream.Collectors;
import static com.ibanity.apis.client.helpers.IbanityTestHelper.loadHttpResponse;
import static com.ibanity.apis.client.utils.URIHelper.buildUri;
import static java.util.Collections.emptyMap;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
class BulkPaymentInitiationRequestServiceImplTest {
private static final UUID FINANCIAL_INSTITUTION_ID = UUID.fromString("9c6dad12-4927-4a40-af87-20f8ff4a4433");
private static final UUID PAYMENT_INITIATION_REQUEST_ID = UUID.fromString("7fbdf174-325a-4c1a-808e-4eec951c1b4d");
private static final String BULK_PAYMENT_INITIATION_REQUEST_ENDPOINT = "https://api.ibanity.com/xs2a/customer/financial-institutions/{financialInstitutionId}/bulk-payment-initiation-requests/{paymentInitiationRequestId}";
private static final String BULK_PAYMENT_INITIATION_REQUEST_ENDPOINT_FOR_CREATE = "https://api.ibanity.com/xs2a/customer/financial-institutions/9c6dad12-4927-4a40-af87-20f8ff4a4433/bulk-payment-initiation-requests";
private static final String BULK_PAYMENT_INITIATION_REQUEST_ENDPOINT_WITH_ID = "https://api.ibanity.com/xs2a/customer/financial-institutions/9c6dad12-4927-4a40-af87-20f8ff4a4433/bulk-payment-initiation-requests/7fbdf174-325a-4c1a-808e-4eec951c1b4d";
private static final String REDIRECT_LINK = "https://callback.ibanity.com/sandbox/fi/pir/i?state=dmF1bHQ6djE6OWNXTHNwRkxoSk9vUjRoVk0rN1k2Z1N0SXBqNjNPNXdkSDZBTHpXaDVMZW9DSFEwTTBweVdpdFNXUlp2UC8wc0dId1NvVmVsT2lPaGxWK2J5SUlOb1JhbjlNUjBLei81UER2ZzNpcVF4TDRWUE5rUVMvRnhpUTFMZkhsT3ZHeDB2Uy9nLzhwRGd3VG1XTzkxR3pPSEUwQkxQR3YxS3AweDBpRzFaS0tiMVhlL3g5L1UzcEZkV1doMllVRWZ5bHZhMWJiUzAvTllXZUV0ZVhMYTJsT01YMFJ6UURTM3VOMDNvWE9nWlAzcmZrYUtiZENQMzFld1VVVDdHVjBhNWpQci9ZTmswUVVoWTBYVXZVY0VMVVRSdU9rM2psTnU0STQ2UzN5TlMxeCtybFFuVDNtQjN1OTk0aDdxbEk2OXcxbEdsbGlvUjZtR3pyZU0xR2psQlVzdG8zcmRNazlkK3lPK0hwS0tlbitRSkFEa2loS0kweklwWnBvK0dCdEFwSWNMakhUTEtCQ2pBaFgwQlRiSkhXZmFYVlR3a2NveUV1M05WSEZ6Qjg0cTNoQ1ZtN28xdlNaU0Mvd21TV2RRMWJGK0lTRWFXY2ZQQ1d2SGx1SjFmOVRJWGt3dzhFeGVROXRESWlMVUF5L0l3TTBWb2F4VWYyR0MrT1hMWkpzZkR0NGJ1YzdSdmRiVUFKaGhpSkhlZG0wVTMxN2JGTmRObXNLc3NLUVRSY2Rwb2NXaWh4YWxJS3hjTDVjNWpNNTRiaGVYNzVpTStGekZFTDk1MnQ2SVp5L2tITWJoUDNzVkN4d0M1SElpT29PUGp1a3BQbm1xVDRqWC8zQlNwVS8rbUhOOTBsSmVXK2c2Q3F0bWJ1MVNUWGsrQmxhNGZOZW9ETHFhbjM1Yk5TUEh2Y2xPdXRBWExKVjBSMXV6U3phMThXV3MrYU9vMUh5NE9OMEQxeklhK0tnS2Z1VU1JMXVLdXFBSGJHQ0hzOXZVcjRWRjQ0bEJ4WEZzTDlaM21KRDlXMkdzTEtJZzc2R2RubnFVTjUvOVhkZ1NZWXdnYU01b2pjanAyR0NseFozRjEyT0ZFTlN1c25ZUldtb3J1S1cxOUhVMENHYXlNeS80MDQ3b05qdUZnM0NlKy9QUk5ZNktqRVdUOXA0Q3d2b2Y5UGtXbnJYU2lLYkc1dGt6d3BMdzBSTWdSWnlIM2F4NHRxSHN3UDF2Vnh0SlVzMWhNMXpzS2VTMTRXeWRNc3QrU3c9PQ==";
private static final String CUSTOMER_TOKEN_REFERENCE = "itsme";
private static final String FINANCIAL_INSTITUTION_RELATED_LINK = "https://api.ibanity.com/xs2a/financial-institutions/9c6dad12-4927-4a40-af87-20f8ff4a4433";
private static final String CUSTOM_STATE = "myState";
@InjectMocks
private BulkPaymentInitiationRequestServiceImpl bulkPaymentInitiationRequestService;
@Mock
private ApiUrlProvider apiUrlProvider;
@Mock
private IbanityHttpClient ibanityHttpClient;
@BeforeEach
void setUp() {
when(apiUrlProvider.find(IbanityProduct.Xs2a, "customer", "financialInstitution", "bulkPaymentInitiationRequests"))
.thenReturn(BULK_PAYMENT_INITIATION_REQUEST_ENDPOINT);
}
@Test
void create() throws Exception {
BulkPaymentInitiationRequestCreationQuery requestCreationQuery =
BulkPaymentInitiationRequestCreationQuery.builder()
.customerAccessToken(CUSTOMER_TOKEN_REFERENCE)
.financialInstitutionId(FINANCIAL_INSTITUTION_ID)
.customerIpAddress("1.2.3.4")
.locale("fr")
.skipIbanityCompletionCallback(true)
.allowFinancialInstitutionRedirectUri(true)
.batchBookingPreferred(true)
.state(CUSTOM_STATE)
.requestedExecutionDate(LocalDate.parse("2020-02-05"))
.financialInstitutionCustomerReference("jdoe001")
.payments(Collections.singletonList(
BulkPaymentInitiationRequestCreationQuery.Payment
.builder()
.amount(new BigDecimal("59"))
.creditorAccountReference("BE4215561520006651")
.creditorAccountReferenceType("IBAN")
.creditorAgent("NBBEBEBB203")
.creditorAgentType("BIC")
.creditorName("Alex Creditor")
.currency("EUR")
.endToEndId("f4fdab3742af4a1386df4ca82c05ced6")
.remittanceInformation("payment")
.remittanceInformationType("unstructured").build()
)
)
.build();
when(ibanityHttpClient.post(buildUri(BULK_PAYMENT_INITIATION_REQUEST_ENDPOINT_FOR_CREATE), mapRequest(requestCreationQuery), emptyMap(), CUSTOMER_TOKEN_REFERENCE))
.thenReturn(loadHttpResponse("json/createBulkPaymentInitiationRequest.json"));
BulkPaymentInitiationRequest actual = bulkPaymentInitiationRequestService.create(requestCreationQuery);
assertThat(actual).isEqualToComparingFieldByFieldRecursively(createExpectedForCreate());
}
@Test
void delete() throws IOException {
BulkPaymentInitiationRequestReadQuery requestReadQuery =
BulkPaymentInitiationRequestReadQuery.builder()
.customerAccessToken(CUSTOMER_TOKEN_REFERENCE)
.financialInstitutionId(FINANCIAL_INSTITUTION_ID)
.paymentInitiationRequestId(PAYMENT_INITIATION_REQUEST_ID)
.build();
when(ibanityHttpClient.delete(buildUri(BULK_PAYMENT_INITIATION_REQUEST_ENDPOINT_WITH_ID), emptyMap(), CUSTOMER_TOKEN_REFERENCE))
.thenReturn(loadHttpResponse("json/deleteBulkPaymentInitiationRequest.json"));
BulkPaymentInitiationRequest actual = bulkPaymentInitiationRequestService.delete(requestReadQuery);
assertThat(actual).isEqualToComparingFieldByField(createExpectedForDelete());
}
@Test
void find() throws Exception {
BulkPaymentInitiationRequestReadQuery readQuery =
BulkPaymentInitiationRequestReadQuery.builder()
.paymentInitiationRequestId(PAYMENT_INITIATION_REQUEST_ID)
.financialInstitutionId(FINANCIAL_INSTITUTION_ID)
.customerAccessToken(CUSTOMER_TOKEN_REFERENCE)
.build();
when(ibanityHttpClient.get(buildUri(BULK_PAYMENT_INITIATION_REQUEST_ENDPOINT_WITH_ID), emptyMap(), CUSTOMER_TOKEN_REFERENCE))
.thenReturn(loadHttpResponse("json/bulkPaymentInitiationRequest.json"));
BulkPaymentInitiationRequest actual = bulkPaymentInitiationRequestService.find(readQuery);
assertThat(actual).isEqualToComparingFieldByField(createExpectedForFind());
}
private BulkPaymentInitiationRequest createExpectedForDelete() {
return BulkPaymentInitiationRequest.builder()
.id(PAYMENT_INITIATION_REQUEST_ID)
.build();
}
private RequestApiModel mapRequest(BulkPaymentInitiationRequestCreationQuery query) {
BulkPaymentInitiationRequestServiceImpl.BulkPaymentInitiationRequest bulkPaymentInitiationRequest = BulkPaymentInitiationRequestServiceImpl.BulkPaymentInitiationRequest.builder()
.financialInstitutionId(query.getFinancialInstitutionId())
.payments(query.getPayments().stream().map(payment -> {
return BulkPaymentInitiationRequestServiceImpl.BulkPaymentInitiationRequest.Payment.builder()
.amount(payment.getAmount())
.creditorAccountReference(payment.getCreditorAccountReference())
.creditorAccountReferenceType(payment.getCreditorAccountReferenceType())
.creditorName(payment.getCreditorName())
.currency(payment.getCurrency())
.endToEndId(payment.getEndToEndId())
.remittanceInformation(payment.getRemittanceInformation())
.remittanceInformationType(payment.getRemittanceInformationType())
.creditorAgent(payment.getCreditorAgent())
.creditorAgentType(payment.getCreditorAgentType())
.build();
}).collect(Collectors.toList()))
.consentReference(query.getConsentReference())
.productType(query.getProductType())
.redirectUri(query.getRedirectUri())
.debtorAccountReference(query.getDebtorAccountReference())
.debtorAccountReferenceType(query.getDebtorAccountReferenceType())
.debtorName(query.getDebtorName())
.customerIpAddress(query.getCustomerIpAddress())
.locale(query.getLocale())
.state(query.getState())
.skipIbanityCompletionCallback(query.isSkipIbanityCompletionCallback())
.allowFinancialInstitutionRedirectUri(query.isAllowFinancialInstitutionRedirectUri())
.batchBookingPreferred(query.isBatchBookingPreferred())
.requestedExecutionDate(query.getRequestedExecutionDate())
.financialInstitutionCustomerReference(query.getFinancialInstitutionCustomerReference())
.build();
return RequestApiModel.builder()
.data(
RequestApiModel.RequestDataApiModel.builder()
.attributes(bulkPaymentInitiationRequest)
.type(BulkPaymentInitiationRequest.RESOURCE_TYPE)
.build()
)
.build();
}
private BulkPaymentInitiationRequest createExpectedForFind() {
return BulkPaymentInitiationRequest.builder()
.id(PAYMENT_INITIATION_REQUEST_ID)
.consentReference("ad8f28f9-7ba1-4caf-9e7d-df2c04f88dd8")
.productType("sepa-credit-transfer")
.payments(
Collections.singletonList(
BulkPaymentInitiationRequest.Payment.builder()
.remittanceInformation("payment")
.remittanceInformationType("unstructured")
.currency("EUR")
.amount(new BigDecimal("59"))
.creditorName("Alex Creditor")
.creditorAccountReference("BE4215561520006651")
.creditorAccountReferenceType("IBAN")
.creditorAgent("NBBEBEBB203")
.creditorAgentType("BIC")
.endToEndId("f4fdab3742af4a1386df4ca82c05ced6")
.build()
)
)
.requestedExecutionDate(LocalDate.parse("2020-02-05"))
.debtorName("Delmer Hermann")
.debtorAccountReference("BE5283671456644082")
.debtorAccountReferenceType("IBAN")
.status("error")
.statusReason("invalid")
.skipIbanityCompletionCallback(true)
.allowFinancialInstitutionRedirectUri(true)
.batchBookingPreferred(true)
.financialInstitutionLink(FinancialInstitutionLinks.builder().related(FINANCIAL_INSTITUTION_RELATED_LINK).build())
.financialInstitutionId(FINANCIAL_INSTITUTION_ID)
.build();
}
private BulkPaymentInitiationRequest createExpectedForCreate() {
return BulkPaymentInitiationRequest.builder()
.id(PAYMENT_INITIATION_REQUEST_ID)
.consentReference("ad8f28f9-7ba1-4caf-9e7d-df2c04f88dd8")
.productType("sepa-credit-transfer")
.requestedExecutionDate(LocalDate.parse("2020-02-05"))
.debtorName("Delmer Hermann")
.debtorAccountReference("BE5283671456644082")
.debtorAccountReferenceType("IBAN")
.skipIbanityCompletionCallback(true)
.allowFinancialInstitutionRedirectUri(true)
.batchBookingPreferred(true)
.payments(
Collections.singletonList(
BulkPaymentInitiationRequest.Payment.builder()
.remittanceInformation("payment")
.remittanceInformationType("unstructured")
.currency("EUR")
.amount(new BigDecimal("59"))
.creditorName("Alex Creditor")
.creditorAccountReference("BE4215561520006651")
.creditorAccountReferenceType("IBAN")
.creditorAgent("NBBEBEBB203")
.creditorAgentType("BIC")
.endToEndId("f4fdab3742af4a1386df4ca82c05ced6")
.build()
)
)
.links(BulkPaymentInitiationAuthorizationLinks.builder().redirect(REDIRECT_LINK).build())
.financialInstitutionLink(FinancialInstitutionLinks.builder().related(FINANCIAL_INSTITUTION_RELATED_LINK).build())
.financialInstitutionId(FINANCIAL_INSTITUTION_ID)
.financialInstitutionCustomerReference("jdoe001")
.build();
}
}
| 0 |
raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\xs2a\services | raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\xs2a\services\impl\CustomerAccessTokensServiceImplTest.java | package com.ibanity.apis.client.products.xs2a.services.impl;
import com.ibanity.apis.client.http.IbanityHttpClient;
import com.ibanity.apis.client.jsonapi.RequestApiModel;
import com.ibanity.apis.client.models.IbanityProduct;
import com.ibanity.apis.client.products.xs2a.models.CustomerAccessToken;
import com.ibanity.apis.client.products.xs2a.models.create.CustomerAccessTokenCreationQuery;
import com.ibanity.apis.client.services.ApiUrlProvider;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import java.net.URI;
import java.util.UUID;
import static com.ibanity.apis.client.helpers.IbanityTestHelper.loadHttpResponse;
import static java.util.Collections.emptyMap;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
class CustomerAccessTokensServiceImplTest {
private static final String APPLICATION_REFERENCE = "666";
private static final String CUSTOMER_ACCESS_TOKEN_ENDPOINT = "https://api.ibanity.com/xs2a/customer-access-tokens";
@InjectMocks
private CustomerAccessTokensServiceImpl customerAccessTokensService;
@Mock
private IbanityHttpClient httpClient;
@Mock
private ApiUrlProvider apiUrlProvider;
@Test
void create() throws Exception {
CustomerAccessTokenCreationQuery creationQuery =
CustomerAccessTokenCreationQuery.builder()
.applicationCustomerReference(APPLICATION_REFERENCE)
.build();
when(apiUrlProvider.find(IbanityProduct.Xs2a, "customerAccessTokens")).thenReturn(CUSTOMER_ACCESS_TOKEN_ENDPOINT);
when(httpClient.post(new URI(CUSTOMER_ACCESS_TOKEN_ENDPOINT), buildRequest(), emptyMap(), null))
.thenReturn(loadHttpResponse("json/customerAccessToken.json"));
CustomerAccessToken actual = customerAccessTokensService.create(creationQuery);
assertThat(actual).isEqualToComparingFieldByField(createExpected());
}
private RequestApiModel buildRequest() {
CustomerAccessToken request = CustomerAccessToken.builder().applicationCustomerReference(APPLICATION_REFERENCE).build();
return RequestApiModel.builder()
.data(
RequestApiModel.RequestDataApiModel.builder()
.attributes(request)
.type(CustomerAccessToken.RESOURCE_TYPE)
.build()
)
.build();
}
private CustomerAccessToken createExpected() {
return CustomerAccessToken.builder()
.id(UUID.fromString("10afe599-bb51-49f0-974c-4d396a1af5d0"))
.token("eyJhbGciOiJSUzI1NiJ9.eyJqdGkiOiIxMGFmZTU5OS1iYjUxLTQ5ZjAtOTc0Yy00ZDM5NmExYWY1ZDAiLCJpc3MiOiIyZTM2YTVlNy0wYjFlLTRkYjctOGEwMy03OTAyZjc4NWI0MTYiLCJhdWQiOiJ1c2VyX2FjY291bnRfYWNjZXNzIiwic3ViIjoiNzY1MGE1ZmYtNzY1Ni00OGEwLTg3MDAtMDdjNzAwMmFlMDcxIiwiZGF0YSI6e319.nG2A4HbF0JCNCabmMIn4u7XqQI2P9xNFPfC2VuqfP8zgi-sIS8rjUFKaLG6cUjvAAIbRgxkLCGq2KsegPEgXIavfnGq7FV6POF-pAyvdOfGtqP08wmkdrXzD5GHsQngWr_1sMv7oCsTrxDtZQxx7Gv1UOTnJYUxJEBirCgeAm0oPjRr5V97BN4Bh4XB3FhLnLZGqlO01-sDykdWY764BYQM-76WElXP2c6CNFF_ZklsL5LRzJ4tHhV5F5jYf7o5s6cxEQnC7sAuwVV1YXoKMxlwYbPhr64rB3MJBmBlAMkHJO4wkyV2eTpb7pIvq0jRbK-2CNWhCYqPi93NnXcpxQw")
.build();
}
}
| 0 |
raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\xs2a\services | raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\xs2a\services\impl\CustomerServiceImplTest.java | package com.ibanity.apis.client.products.xs2a.services.impl;
import com.ibanity.apis.client.http.IbanityHttpClient;
import com.ibanity.apis.client.models.IbanityProduct;
import com.ibanity.apis.client.products.xs2a.models.Customer;
import com.ibanity.apis.client.products.xs2a.models.delete.CustomerDeleteQuery;
import com.ibanity.apis.client.services.ApiUrlProvider;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import java.net.URI;
import java.util.UUID;
import static com.ibanity.apis.client.helpers.IbanityTestHelper.loadHttpResponse;
import static java.util.Collections.emptyMap;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
class CustomerServiceImplTest {
private static final String CUSTOMER_ACCESS_TOKEN = "itsme";
private static final String CUSTOMER_API = "https://api.ibanity.localhost/xs2a/customer";
private static final UUID CUSTOMER_ID = UUID.fromString("894be17a-aa66-47f8-8447-b352338eacbd");
@InjectMocks
private CustomerServiceImpl customerService;
@Mock
private ApiUrlProvider apiUrlProvider;
@Mock
private IbanityHttpClient ibanityHttpClient;
@BeforeEach
void setUp() {
when(apiUrlProvider.find(IbanityProduct.Xs2a, "customer", "self")).thenReturn(CUSTOMER_API);
}
@Test
void delete() throws Exception {
CustomerDeleteQuery customerDeleteQuery =
CustomerDeleteQuery.builder()
.customerAccessToken(CUSTOMER_ACCESS_TOKEN)
.build();
when(ibanityHttpClient.delete(new URI(CUSTOMER_API), emptyMap(), CUSTOMER_ACCESS_TOKEN))
.thenReturn(loadHttpResponse("json/customer.json"));
Customer actual = customerService.delete(customerDeleteQuery);
assertThat(actual).isEqualToComparingFieldByField(createExpected());
}
private Customer createExpected() {
return Customer.builder()
.id(CUSTOMER_ID)
.build();
}
}
| 0 |
raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\xs2a\services | raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\xs2a\services\impl\FinancialInstitutionCountriesServiceImplTest.java | package com.ibanity.apis.client.products.xs2a.services.impl;
import com.ibanity.apis.client.http.IbanityHttpClient;
import com.ibanity.apis.client.models.Collection;
import com.ibanity.apis.client.models.IbanityProduct;
import com.ibanity.apis.client.paging.IbanityPagingSpec;
import com.ibanity.apis.client.products.xs2a.models.FinancialInstitutionCountry;
import com.ibanity.apis.client.products.xs2a.models.read.FinancialInstitutionCountriesReadQuery;
import com.ibanity.apis.client.services.ApiUrlProvider;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;
import static com.ibanity.apis.client.helpers.IbanityTestHelper.loadHttpResponse;
import static java.util.Collections.emptyMap;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
class FinancialInstitutionCountriesServiceImplTest {
private static final String FINANCIAL_INSTITUTION_COUNTRIES_API = "https://api.ibanity.localhost/xs2a/financial-institution-countries";
@InjectMocks
private FinancialInstitutionCountriesServiceImpl countriesService;
@Mock
private ApiUrlProvider apiUrlProvider;
@Mock
private IbanityHttpClient ibanityHttpClient;
@BeforeEach
void setUp() {
when(apiUrlProvider.find(IbanityProduct.Xs2a, "financialInstitutionCountries")).thenReturn(FINANCIAL_INSTITUTION_COUNTRIES_API);
}
@Test
void list() throws URISyntaxException, IOException {
FinancialInstitutionCountriesReadQuery readQuery =
FinancialInstitutionCountriesReadQuery.builder()
.pagingSpec(IbanityPagingSpec.builder()
.after("AU")
.build())
.build();
when(ibanityHttpClient.get(new URI(FINANCIAL_INSTITUTION_COUNTRIES_API + "?page%5Bafter%5D=AU&page%5Blimit%5D=10"), emptyMap(), null))
.thenReturn(loadHttpResponse("json/financialInstitutionCountries.json"));
Collection<FinancialInstitutionCountry> actual = countriesService.list(readQuery);
assertThat(actual.getItems()).containsExactly(createExpected("BE"), createExpected("NL"));
assertThat(actual.getPageLimit()).isEqualTo(10);
}
private FinancialInstitutionCountry createExpected(String country) {
return FinancialInstitutionCountry.builder().id(country).build();
}
}
| 0 |
raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\xs2a\services | raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\xs2a\services\impl\FinancialInstitutionsServiceImplTest.java | package com.ibanity.apis.client.products.xs2a.services.impl;
import com.ibanity.apis.client.helpers.IbanityTestHelper;
import com.ibanity.apis.client.http.IbanityHttpClient;
import com.ibanity.apis.client.models.IbanityCollection;
import com.ibanity.apis.client.models.IbanityProduct;
import com.ibanity.apis.client.paging.IbanityOffsetPagingSpec;
import com.ibanity.apis.client.paging.IbanityPagingSpec;
import com.ibanity.apis.client.products.ponto_connect.models.Filter;
import com.ibanity.apis.client.products.xs2a.models.FinancialInstitution;
import com.ibanity.apis.client.products.xs2a.models.read.FinancialInstitutionReadQuery;
import com.ibanity.apis.client.products.xs2a.models.read.FinancialInstitutionsReadQuery;
import com.ibanity.apis.client.services.ApiUrlProvider;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.mockito.junit.jupiter.MockitoSettings;
import org.mockito.quality.Strictness;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.UUID;
import static com.ibanity.apis.client.utils.URIHelper.buildUri;
import static java.time.Instant.parse;
import static java.util.Collections.emptyMap;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
@MockitoSettings(strictness = Strictness.LENIENT)
class FinancialInstitutionsServiceImplTest {
private static final UUID FINANCIAL_INSTITUTION_ID = UUID.fromString("268c9f39-736b-4a9a-b198-4191030c0e21");
private static final String CUSTOMER_ACCESS_TOKEN = "itsme";
private static final String FINANCIAL_INSTITUTION_CUSTOMER_ENDPOINT = "https://api.ibanity.com/xs2a/customer/financial-institutions";
private static final String FINANCIAL_INSTITUTION_ENDPOINT = "https://api.ibanity.localhost/xs2a/financial-institutions/{financialInstitutionId}";
private static final String FINANCIAL_INSTITUTION_ENDPOINT_ID = "https://api.ibanity.localhost/xs2a/financial-institutions/" + FINANCIAL_INSTITUTION_ID;
@InjectMocks
private FinancialInstitutionsServiceImpl financialInstitutionsService;
@Mock
private ApiUrlProvider apiUrlProvider;
@Mock
private IbanityHttpClient ibanityHttpClient;
@BeforeEach
void setUp() {
when(apiUrlProvider.find(IbanityProduct.Xs2a, "financialInstitutions")).thenReturn(FINANCIAL_INSTITUTION_ENDPOINT);
when(apiUrlProvider.find(IbanityProduct.Xs2a, "customer", "financialInstitutions")).thenReturn(FINANCIAL_INSTITUTION_CUSTOMER_ENDPOINT);
}
@Test
void list() throws Exception {
List<Filter> filters = Collections.singletonList(Filter.builder().field("country").eq("be").build());
FinancialInstitutionsReadQuery financialInstitutionsReadQuery = FinancialInstitutionsReadQuery.builder()
.filters(filters)
.build();
when(ibanityHttpClient.get(buildUri("https://api.ibanity.localhost/xs2a/financial-institutions", IbanityPagingSpec.DEFAULT_PAGING_SPEC, filters), emptyMap(), null))
.thenReturn(IbanityTestHelper.loadHttpResponse("json/financialInstitutions.json"));
IbanityCollection<FinancialInstitution> actual = financialInstitutionsService.list(financialInstitutionsReadQuery);
assertThat(actual.getItems()).containsExactly(createExpected());
assertThat(actual.getPageLimit()).isEqualTo(10);
}
@Test
void list_offsetBased() throws Exception {
List<Filter> filters = Collections.singletonList(Filter.builder().field("country").eq("be").build());
IbanityOffsetPagingSpec offsetPagingSpec = IbanityOffsetPagingSpec.builder()
.pageNumber(2)
.pageSize(1)
.build();
FinancialInstitutionsReadQuery financialInstitutionsReadQuery = FinancialInstitutionsReadQuery.builder()
.offsetPagingSpec(offsetPagingSpec)
.filters(filters)
.build();
when(ibanityHttpClient.get(buildUri("https://api.ibanity.localhost/xs2a/financial-institutions", offsetPagingSpec, filters), emptyMap(), null))
.thenReturn(IbanityTestHelper.loadHttpResponse("json/financialInstitutionsOffset.json"));
IbanityCollection<FinancialInstitution> actual = financialInstitutionsService.list(financialInstitutionsReadQuery);
assertThat(actual.getItems()).containsExactly(createExpected());
assertThat(actual.getPageNumber()).isEqualTo(2);
assertThat(actual.getPageSize()).isEqualTo(2);
assertThat(actual.getTotalEntries()).isEqualTo(7);
assertThat(actual.getTotalPages()).isEqualTo(4);
}
@Test
void list_whenCustomerAccessTokenProvided_fetchesFinancialInstitutionForCustomer() throws Exception {
FinancialInstitutionsReadQuery financialInstitutionsReadQuery =
FinancialInstitutionsReadQuery.builder()
.customerAccessToken(CUSTOMER_ACCESS_TOKEN)
.build();
when(ibanityHttpClient.get(buildUri(FINANCIAL_INSTITUTION_CUSTOMER_ENDPOINT, IbanityPagingSpec.DEFAULT_PAGING_SPEC), emptyMap(), CUSTOMER_ACCESS_TOKEN))
.thenReturn(IbanityTestHelper.loadHttpResponse("json/financialInstitutions.json"));
IbanityCollection<FinancialInstitution> actual = financialInstitutionsService.list(financialInstitutionsReadQuery);
assertThat(actual.getItems()).containsExactly(createExpected());
assertThat(actual.getPageLimit()).isEqualTo(10);
}
@Test
void find() throws Exception {
FinancialInstitutionReadQuery financialInstitutionsReadQuery = FinancialInstitutionReadQuery
.builder()
.financialInstitutionId(FINANCIAL_INSTITUTION_ID)
.build();
when(ibanityHttpClient.get(buildUri(FINANCIAL_INSTITUTION_ENDPOINT_ID), emptyMap(), null))
.thenReturn(IbanityTestHelper.loadHttpResponse("json/financialInstitution.json"));
FinancialInstitution actual = financialInstitutionsService.find(financialInstitutionsReadQuery);
assertThat(actual).isEqualToComparingFieldByField(createExpectedForFind());
}
private FinancialInstitution createExpectedForFind() {
return FinancialInstitution.builder()
.id(FINANCIAL_INSTITUTION_ID)
.selfLink("https://api.ibanity.com/xs2a/financial-institutions/268c9f39-736b-4a9a-b198-4191030c0e21")
.bic("NBBEBEBB203")
.country("BE")
.status("stable")
.authorizationModels(Arrays.asList("single", "financialInstitutionOffered"))
.periodicPaymentsEnabled(true)
.periodicPaymentsProductTypes(Collections.singletonList("sepaCreditTransfer"))
.bulkPaymentsEnabled(true)
.bulkPaymentsProductTypes(Collections.singletonList("sepaCreditTransfer"))
.paymentsEnabled(true)
.paymentsProductTypes(Collections.singletonList("sepaCreditTransfer"))
.name("ALKEN ASSET MANAGEMENT 0")
.futureDatedPaymentsAllowed(true)
.logoUrl("https://s3.eu-central-1.amazonaws.com/ibanity-production-financial-institution-assets/sandbox.png")
.primaryColor("#7d39ff")
.requiresCredentialStorage(false)
.requiresCustomerIpAddress(false)
.secondaryColor("#3DF2C2")
.minRequestedAccountReferences(0L)
.sandbox(true)
.financialInstitutionCustomerReferenceRequired(true)
.sharedBrandName("Deckow")
.sharedBrandReference("deckow-be")
.maintenanceType("internal")
.maintenanceFrom(parse("2018-10-25T00:00:00Z"))
.maintenanceTo(parse("2018-11-25T00:00:00Z"))
.build();
}
private FinancialInstitution[] createExpected() {
return new FinancialInstitution[]{
FinancialInstitution.builder()
.id(FINANCIAL_INSTITUTION_ID)
.selfLink("https://api.ibanity.com/xs2a/financial-institutions/268c9f39-736b-4a9a-b198-4191030c0e21")
.bic("NBBEBEBB203")
.name("ABN AMRO FUND MANAGERS LIMITED 0")
.futureDatedPaymentsAllowed(true)
.logoUrl("https://s3.eu-central-1.amazonaws.com/ibanity-production-financial-institution-assets/sandbox.png")
.primaryColor("#7d39ff")
.requiresCredentialStorage(true)
.requiresCustomerIpAddress(true)
.secondaryColor("#3DF2C2")
.minRequestedAccountReferences(0L)
.sandbox(true)
.build(),
FinancialInstitution.builder()
.id(UUID.fromString("c0f14bd6-ae49-4611-9709-0ea553464a1a"))
.selfLink("https://api.ibanity.com/xs2a/financial-institutions/c0f14bd6-ae49-4611-9709-0ea553464a1a")
.bic("NBBEBEBB203")
.name("PGMS (GLASGOW) LIMITED 2")
.logoUrl("https://s3.eu-central-1.amazonaws.com/ibanity-production-financial-institution-assets/sandbox.png")
.primaryColor("#7d39ff")
.maxRequestedAccountReferences(0L)
.secondaryColor("#3DF2C2")
.build()
};
}
}
| 0 |
raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\xs2a\services | raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\xs2a\services\impl\HoldingsServiceImplTest.java | package com.ibanity.apis.client.products.xs2a.services.impl;
import com.ibanity.apis.client.helpers.IbanityTestHelper;
import com.ibanity.apis.client.http.IbanityHttpClient;
import com.ibanity.apis.client.models.IbanityCollection;
import com.ibanity.apis.client.models.IbanityProduct;
import com.ibanity.apis.client.products.xs2a.models.Holding;
import com.ibanity.apis.client.products.xs2a.models.Synchronization;
import com.ibanity.apis.client.products.xs2a.models.read.HoldingReadQuery;
import com.ibanity.apis.client.products.xs2a.models.read.HoldingsReadQuery;
import com.ibanity.apis.client.services.ApiUrlProvider;
import org.assertj.core.api.Assertions;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import java.io.IOException;
import java.math.BigDecimal;
import java.net.URI;
import java.net.URISyntaxException;
import java.time.Instant;
import java.time.LocalDate;
import java.util.Collections;
import java.util.UUID;
import static java.math.BigDecimal.TEN;
import static java.util.Collections.emptyMap;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
class HoldingsServiceImplTest {
private static final UUID ACCOUNT_ID = UUID.fromString("9fe37230-9103-49bd-a432-2bad72d5abb2");
private static final UUID HOLDING_ID = UUID.fromString("eb535c31-f619-4092-9db2-4db84149ddcb");
private static final UUID FINANCIAL_INSTITUTION_ID = UUID.fromString("f252866e-638e-4d28-a575-20a406223777");
private static final String CUSTOMER_ACCESS_TOKEN = UUID.randomUUID().toString();
private static final String HOLDINGS_ENDPOINT = "https://api.ibanity.localhost/xs2a/customer/financial-institutions/{financialInstitutionId}/accounts/{accountId}/holdings/{holdingId}";
private static final String HOLDING_URI = "https://api.ibanity.localhost/xs2a/customer/financial-institutions/f252866e-638e-4d28-a575-20a406223777/accounts/9fe37230-9103-49bd-a432-2bad72d5abb2/holdings/eb535c31-f619-4092-9db2-4db84149ddcb";
private static final String HOLDINGS_URI = "https://api.ibanity.localhost/xs2a/customer/financial-institutions/f252866e-638e-4d28-a575-20a406223777/accounts/9fe37230-9103-49bd-a432-2bad72d5abb2/holdings?page%5Blimit%5D=10";
private static final String FIRST_LINK = "https://api.ibanity.localhost/xs2a/customer/financial-institutions/f252866e-638e-4d28-a575-20a406223777/accounts/9fe37230-9103-49bd-a432-2bad72d5abb2/holdings";
@Mock
private ApiUrlProvider apiUrlProvider;
@Mock
private IbanityHttpClient ibanityHttpClient;
@InjectMocks
private HoldingsServiceImpl holdingsService;
@BeforeEach
void setUp() {
when(apiUrlProvider.find(IbanityProduct.Xs2a, "customer", "financialInstitution", "account", "holdings")).thenReturn(HOLDINGS_ENDPOINT);
}
@Test
void list() throws URISyntaxException, IOException {
IbanityCollection<Holding> expected =
IbanityCollection.<Holding>builder()
.pageLimit(10)
.firstLink(FIRST_LINK)
.items(Collections.singletonList(createExpected()))
.latestSynchronization(Synchronization.builder()
.resourceId("9fe37230-9103-49bd-a432-2bad72d5abb2")
.resourceType("account")
.subtype("accountHoldings")
.status("success")
.id(UUID.fromString("b2d3b6ad-5299-40be-9829-d8abb69c58b6"))
.createdAt(Instant.parse("2020-02-04T14:07:41.089Z"))
.updatedAt(Instant.parse("2020-02-04T14:07:42.169Z"))
.build())
.build();
when(ibanityHttpClient.get(new URI(HOLDINGS_URI), emptyMap(), CUSTOMER_ACCESS_TOKEN))
.thenReturn(IbanityTestHelper.loadHttpResponse("json/holdings.json"));
IbanityCollection<Holding> holdings = holdingsService.list(HoldingsReadQuery.builder()
.accountId(ACCOUNT_ID)
.customerAccessToken(CUSTOMER_ACCESS_TOKEN)
.financialInstitutionId(FINANCIAL_INSTITUTION_ID)
.build());
Assertions.assertThat(holdings).isEqualToComparingFieldByFieldRecursively(expected);
}
private Holding createExpected() {
return Holding.builder()
.id(UUID.fromString("a5af9187-9d11-4c30-9263-7c35ff036f6c"))
.selfLink("https://api.ibanity.localhost/xs2a/customer/financial-institutions/f252866e-638e-4d28-a575-20a406223777/accounts/9fe37230-9103-49bd-a432-2bad72d5abb2/holdings/a5af9187-9d11-4c30-9263-7c35ff036f6c")
.lastValuation(TEN)
.quantity(new BigDecimal("10.55"))
.lastValuationCurrency("USD")
.lastValuationDate(LocalDate.parse("2020-01-01"))
.totalValuation(new BigDecimal("105.5"))
.totalValuationCurrency("USD")
.subtype("STOCK")
.referenceType("ISIN")
.reference("ISINBE6456789")
.name("AAPL")
.build();
}
@Test
void find() throws Exception {
when(ibanityHttpClient.get(new URI(HOLDING_URI), emptyMap(), CUSTOMER_ACCESS_TOKEN))
.thenReturn(IbanityTestHelper.loadHttpResponse("json/holding.json"));
Holding holding = holdingsService.find(HoldingReadQuery.builder()
.accountId(ACCOUNT_ID)
.customerAccessToken(CUSTOMER_ACCESS_TOKEN)
.holdingId(HOLDING_ID)
.financialInstitutionId(FINANCIAL_INSTITUTION_ID)
.build());
Assertions.assertThat(holding).isEqualToComparingFieldByFieldRecursively(createExpected());
}
}
| 0 |
raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\xs2a\services | raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\xs2a\services\impl\PaymentInitiationRequestAuthorizationsServiceImplTest.java | package com.ibanity.apis.client.products.xs2a.services.impl;
import com.ibanity.apis.client.http.IbanityHttpClient;
import com.ibanity.apis.client.jsonapi.RequestApiModel;
import com.ibanity.apis.client.models.IbanityProduct;
import com.ibanity.apis.client.products.xs2a.models.PaymentInitiationRequestAuthorization;
import com.ibanity.apis.client.products.xs2a.models.create.PaymentInitiationRequestAuthorizationCreationQuery;
import com.ibanity.apis.client.products.xs2a.models.links.PaymentInitiationRequestAuthorizationLinks;
import com.ibanity.apis.client.services.ApiUrlProvider;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Captor;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
import static com.ibanity.apis.client.helpers.IbanityTestHelper.loadHttpResponse;
import static com.ibanity.apis.client.utils.URIHelper.buildUri;
import static java.util.Collections.emptyMap;
import static java.util.UUID.fromString;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
class PaymentInitiationRequestAuthorizationsServiceImplTest {
private static final UUID FINANCIAL_INSTITUTION_ID = fromString("4876fdd6-7333-4f9f-b142-ba520ca497b1");
private static final UUID PAYMENT_INITIATION_REQUEST_ID = fromString("cd273ba1-cb2a-464d-b85d-62c9fc4dc8d9");
private static final UUID AUTHORIZATION_ID = fromString("cd273ba1-cb2a-464d-b85d-62c9fc4dc8d9");
private static final String AUTHORIZATION_CODE = "fndsfhskdfslfjhdskfjdsn";
private static final String CUSTOMER_ACCESS_TOKEN = "kdsfldsfmnvlds;md,vms.kvmdsk.vmd";
private static final String AUTHORIZATION_ENDPOINT = "https://api.ibanity.com/xs2a/customer/financial-institutions/{financialInstitutionId}/payment-initiation-requests/{paymentInitiationRequestId}/authorizations/{authorizationId}";
private static final String AUTHORIZATION_ENDPOINT_FOR_CREATE = "https://api.ibanity.com/xs2a/customer/financial-institutions/4876fdd6-7333-4f9f-b142-ba520ca497b1/payment-initiation-requests/cd273ba1-cb2a-464d-b85d-62c9fc4dc8d9/authorizations";
@InjectMocks
private PaymentInitiationRequestAuthorizationsServiceImpl authorizationsService;
@Mock
private ApiUrlProvider apiUrlProvider;
@Mock
private IbanityHttpClient ibanityHttpClient;
@Captor
private ArgumentCaptor<RequestApiModel> argumentCaptor;
@BeforeEach
void setUp() {
when(apiUrlProvider.find(IbanityProduct.Xs2a, "customer", "financialInstitution", "paymentInitiationRequest", "authorizations"))
.thenReturn(AUTHORIZATION_ENDPOINT);
}
@Test
void create() throws IOException {
Map<String, String> queryParams = new HashMap<>();
queryParams.put("code", AUTHORIZATION_CODE);
PaymentInitiationRequestAuthorizationCreationQuery creationQuery = PaymentInitiationRequestAuthorizationCreationQuery.builder()
.customerAccessToken(CUSTOMER_ACCESS_TOKEN)
.queryParameters(queryParams)
.financialInstitutionId(FINANCIAL_INSTITUTION_ID)
.paymentInitiationRequestId(PAYMENT_INITIATION_REQUEST_ID)
.build();
when(ibanityHttpClient.post(eq(buildUri(AUTHORIZATION_ENDPOINT_FOR_CREATE)), argumentCaptor.capture(), eq(emptyMap()), eq(CUSTOMER_ACCESS_TOKEN))).thenReturn(loadHttpResponse("json/createPaymentInitiationRequestAuthorization.json"));
PaymentInitiationRequestAuthorization authorization = authorizationsService.create(creationQuery);
assertThat(authorization).isEqualTo(expected());
PaymentInitiationRequestAuthorizationsServiceImpl.PaymentInitiationRequestAuthorization authorizationRequest =
(PaymentInitiationRequestAuthorizationsServiceImpl.PaymentInitiationRequestAuthorization) argumentCaptor.getValue().getData().getAttributes();
assertThat(authorizationRequest.getQueryParameters().get("code")).isEqualTo(AUTHORIZATION_CODE);
}
private PaymentInitiationRequestAuthorization expected() {
return PaymentInitiationRequestAuthorization.builder()
.id(AUTHORIZATION_ID)
.status("succeeded")
.links(PaymentInitiationRequestAuthorizationLinks.builder()
.nextRedirect("https://www.bnpp.com/next-step")
.build())
.build();
}
}
| 0 |
raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\xs2a\services | raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\xs2a\services\impl\PaymentInitiationRequestServiceImplTest.java | package com.ibanity.apis.client.products.xs2a.services.impl;
import com.ibanity.apis.client.http.IbanityHttpClient;
import com.ibanity.apis.client.jsonapi.RequestApiModel;
import com.ibanity.apis.client.models.IbanityProduct;
import com.ibanity.apis.client.products.xs2a.models.PaymentInitiationRequest;
import com.ibanity.apis.client.products.xs2a.models.create.PaymentInitiationRequestCreationQuery;
import com.ibanity.apis.client.products.xs2a.models.links.FinancialInstitutionLinks;
import com.ibanity.apis.client.products.xs2a.models.links.PaymentInitiationAuthorizationLinks;
import com.ibanity.apis.client.products.xs2a.models.read.PaymentInitiationRequestReadQuery;
import com.ibanity.apis.client.services.ApiUrlProvider;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import java.io.IOException;
import java.math.BigDecimal;
import java.time.LocalDate;
import java.util.UUID;
import static com.ibanity.apis.client.helpers.IbanityTestHelper.loadHttpResponse;
import static com.ibanity.apis.client.utils.URIHelper.buildUri;
import static java.util.Collections.emptyMap;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
class PaymentInitiationRequestServiceImplTest {
private static final UUID FINANCIAL_INSTITUTION_ID = UUID.fromString("9c6dad12-4927-4a40-af87-20f8ff4a4433");
private static final UUID PAYMENT_INITIATION_REQUEST_ID = UUID.fromString("7fbdf174-325a-4c1a-808e-4eec951c1b4d");
private static final String PIR_ENDPOINT = "https://api.ibanity.com/xs2a/customer/financial-institutions/{financialInstitutionId}/payment-initiation-requests/{paymentInitiationRequestId}";
private static final String PIR_ENDPOINT_FOR_CREATE = "https://api.ibanity.com/xs2a/customer/financial-institutions/9c6dad12-4927-4a40-af87-20f8ff4a4433/payment-initiation-requests";
private static final String REDIRECT_LINK = "https://callback.ibanity.com/sandbox/fi/pir/i?state=dmF1bHQ6djE6OWNXTHNwRkxoSk9vUjRoVk0rN1k2Z1N0SXBqNjNPNXdkSDZBTHpXaDVMZW9DSFEwTTBweVdpdFNXUlp2UC8wc0dId1NvVmVsT2lPaGxWK2J5SUlOb1JhbjlNUjBLei81UER2ZzNpcVF4TDRWUE5rUVMvRnhpUTFMZkhsT3ZHeDB2Uy9nLzhwRGd3VG1XTzkxR3pPSEUwQkxQR3YxS3AweDBpRzFaS0tiMVhlL3g5L1UzcEZkV1doMllVRWZ5bHZhMWJiUzAvTllXZUV0ZVhMYTJsT01YMFJ6UURTM3VOMDNvWE9nWlAzcmZrYUtiZENQMzFld1VVVDdHVjBhNWpQci9ZTmswUVVoWTBYVXZVY0VMVVRSdU9rM2psTnU0STQ2UzN5TlMxeCtybFFuVDNtQjN1OTk0aDdxbEk2OXcxbEdsbGlvUjZtR3pyZU0xR2psQlVzdG8zcmRNazlkK3lPK0hwS0tlbitRSkFEa2loS0kweklwWnBvK0dCdEFwSWNMakhUTEtCQ2pBaFgwQlRiSkhXZmFYVlR3a2NveUV1M05WSEZ6Qjg0cTNoQ1ZtN28xdlNaU0Mvd21TV2RRMWJGK0lTRWFXY2ZQQ1d2SGx1SjFmOVRJWGt3dzhFeGVROXRESWlMVUF5L0l3TTBWb2F4VWYyR0MrT1hMWkpzZkR0NGJ1YzdSdmRiVUFKaGhpSkhlZG0wVTMxN2JGTmRObXNLc3NLUVRSY2Rwb2NXaWh4YWxJS3hjTDVjNWpNNTRiaGVYNzVpTStGekZFTDk1MnQ2SVp5L2tITWJoUDNzVkN4d0M1SElpT29PUGp1a3BQbm1xVDRqWC8zQlNwVS8rbUhOOTBsSmVXK2c2Q3F0bWJ1MVNUWGsrQmxhNGZOZW9ETHFhbjM1Yk5TUEh2Y2xPdXRBWExKVjBSMXV6U3phMThXV3MrYU9vMUh5NE9OMEQxeklhK0tnS2Z1VU1JMXVLdXFBSGJHQ0hzOXZVcjRWRjQ0bEJ4WEZzTDlaM21KRDlXMkdzTEtJZzc2R2RubnFVTjUvOVhkZ1NZWXdnYU01b2pjanAyR0NseFozRjEyT0ZFTlN1c25ZUldtb3J1S1cxOUhVMENHYXlNeS80MDQ3b05qdUZnM0NlKy9QUk5ZNktqRVdUOXA0Q3d2b2Y5UGtXbnJYU2lLYkc1dGt6d3BMdzBSTWdSWnlIM2F4NHRxSHN3UDF2Vnh0SlVzMWhNMXpzS2VTMTRXeWRNc3QrU3c9PQ==";
private static final String CUSTOMER_TOKEN_REFERENCE = "itsme";
private static final String FINANCIAL_INSTITUTION_RELATED_LINK = "https://api.ibanity.com/xs2a/financial-institutions/9c6dad12-4927-4a40-af87-20f8ff4a4433";
private static final String PIR_ENDPOINT_WITH_ID = "https://api.ibanity.com/xs2a/customer/financial-institutions/9c6dad12-4927-4a40-af87-20f8ff4a4433/payment-initiation-requests/7fbdf174-325a-4c1a-808e-4eec951c1b4d";
private static final String CUSTOM_STATE = "myState";
@InjectMocks
private PaymentInitiationRequestServiceImpl paymentInitiationRequestService;
@Mock
private ApiUrlProvider apiUrlProvider;
@Mock
private IbanityHttpClient ibanityHttpClient;
@BeforeEach
void setUp() {
when(apiUrlProvider.find(IbanityProduct.Xs2a, "customer", "financialInstitution", "paymentInitiationRequests"))
.thenReturn(PIR_ENDPOINT);
}
@Test
void create() throws Exception {
PaymentInitiationRequestCreationQuery requestCreationQuery =
PaymentInitiationRequestCreationQuery.builder()
.customerAccessToken(CUSTOMER_TOKEN_REFERENCE)
.financialInstitutionId(FINANCIAL_INSTITUTION_ID)
.customerIpAddress("1.2.3.4")
.locale("fr")
.skipIbanityCompletionCallback(true)
.allowFinancialInstitutionRedirectUri(true)
.state(CUSTOM_STATE)
.requestedExecutionDate(LocalDate.now())
.financialInstitutionCustomerReference("jdoe001")
.build();
when(ibanityHttpClient.post(buildUri(PIR_ENDPOINT_FOR_CREATE), mapRequest(requestCreationQuery), emptyMap(), CUSTOMER_TOKEN_REFERENCE))
.thenReturn(loadHttpResponse("json/createPaymentInitiationRequest.json"));
PaymentInitiationRequest actual = paymentInitiationRequestService.create(requestCreationQuery);
assertThat(actual).isEqualToComparingFieldByFieldRecursively(createExpectedForCreate());
}
@Test
void delete() throws IOException {
PaymentInitiationRequestReadQuery requestReadQuery =
PaymentInitiationRequestReadQuery.builder()
.customerAccessToken(CUSTOMER_TOKEN_REFERENCE)
.financialInstitutionId(FINANCIAL_INSTITUTION_ID)
.paymentInitiationRequestId(PAYMENT_INITIATION_REQUEST_ID)
.build();
when(ibanityHttpClient.delete(buildUri(PIR_ENDPOINT_WITH_ID), emptyMap(), CUSTOMER_TOKEN_REFERENCE))
.thenReturn(loadHttpResponse("json/deletePaymentInitiationRequest.json"));
PaymentInitiationRequest actual = paymentInitiationRequestService.delete(requestReadQuery);
assertThat(actual).isEqualToComparingFieldByField(createExpectedForDelete());
}
@Test
void find() throws Exception {
PaymentInitiationRequestReadQuery readQuery =
PaymentInitiationRequestReadQuery.builder()
.paymentInitiationRequestId(PAYMENT_INITIATION_REQUEST_ID)
.financialInstitutionId(FINANCIAL_INSTITUTION_ID)
.customerAccessToken(CUSTOMER_TOKEN_REFERENCE)
.build();
when(ibanityHttpClient.get(buildUri(PIR_ENDPOINT_WITH_ID), emptyMap(), CUSTOMER_TOKEN_REFERENCE))
.thenReturn(loadHttpResponse("json/paymentInitiationRequest.json"));
PaymentInitiationRequest actual = paymentInitiationRequestService.find(readQuery);
assertThat(actual).isEqualToComparingFieldByField(createExpectedForFind());
}
private PaymentInitiationRequest createExpectedForDelete() {
return PaymentInitiationRequest.builder()
.id(PAYMENT_INITIATION_REQUEST_ID)
.build();
}
private RequestApiModel mapRequest(PaymentInitiationRequestCreationQuery query) {
PaymentInitiationRequestServiceImpl.PaymentInitiationRequest paymentInitiationRequest = PaymentInitiationRequestServiceImpl.PaymentInitiationRequest.builder()
.financialInstitutionId(query.getFinancialInstitutionId())
.amount(query.getAmount())
.consentReference(query.getConsentReference())
.creditorAccountReference(query.getCreditorAccountReference())
.creditorAccountReferenceType(query.getCreditorAccountReferenceType())
.creditorName(query.getCreditorName())
.currency(query.getCurrency())
.endToEndId(query.getEndToEndId())
.productType(query.getProductType())
.redirectUri(query.getRedirectUri())
.remittanceInformation(query.getRemittanceInformation())
.remittanceInformationType(query.getRemittanceInformationType())
.creditorAgent(query.getCreditorAgent())
.creditorAgentType(query.getCreditorAgentType())
.debtorAccountReference(query.getDebtorAccountReference())
.debtorAccountReferenceType(query.getDebtorAccountReferenceType())
.debtorName(query.getDebtorName())
.customerIpAddress(query.getCustomerIpAddress())
.locale(query.getLocale())
.state(query.getState())
.skipIbanityCompletionCallback(query.isSkipIbanityCompletionCallback())
.allowFinancialInstitutionRedirectUri(query.isAllowFinancialInstitutionRedirectUri())
.requestedExecutionDate(LocalDate.now())
.financialInstitutionCustomerReference(query.getFinancialInstitutionCustomerReference())
.build();
return RequestApiModel.builder()
.data(
RequestApiModel.RequestDataApiModel.builder()
.attributes(paymentInitiationRequest)
.type(PaymentInitiationRequest.RESOURCE_TYPE)
.build()
)
.build();
}
private PaymentInitiationRequest createExpectedForFind() {
return PaymentInitiationRequest.builder()
.id(PAYMENT_INITIATION_REQUEST_ID)
.consentReference("ad8f28f9-7ba1-4caf-9e7d-df2c04f88dd8")
.productType("sepa-credit-transfer")
.remittanceInformation("payment")
.remittanceInformationType("unstructured")
.requestedExecutionDate(LocalDate.parse("2020-02-05"))
.currency("EUR")
.amount(new BigDecimal("59"))
.debtorName("Delmer Hermann")
.debtorAccountReference("BE5283671456644082")
.debtorAccountReferenceType("IBAN")
.creditorName("Alex Creditor")
.creditorAccountReference("BE4215561520006651")
.creditorAccountReferenceType("IBAN")
.creditorAgent("NBBEBEBB203")
.creditorAgentType("BIC")
.endToEndId("f4fdab3742af4a1386df4ca82c05ced6")
.status("error")
.statusReason("invalid")
.financialInstitutionLink(FinancialInstitutionLinks.builder().related(FINANCIAL_INSTITUTION_RELATED_LINK).build())
.financialInstitutionId(FINANCIAL_INSTITUTION_ID)
.build();
}
private PaymentInitiationRequest createExpectedForCreate() {
return PaymentInitiationRequest.builder()
.id(PAYMENT_INITIATION_REQUEST_ID)
.consentReference("ad8f28f9-7ba1-4caf-9e7d-df2c04f88dd8")
.productType("sepa-credit-transfer")
.remittanceInformation("payment")
.remittanceInformationType("unstructured")
.requestedExecutionDate(LocalDate.parse("2020-02-05"))
.currency("EUR")
.amount(new BigDecimal("59"))
.debtorName("Delmer Hermann")
.debtorAccountReference("BE5283671456644082")
.debtorAccountReferenceType("IBAN")
.creditorName("Alex Creditor")
.creditorAccountReference("BE4215561520006651")
.creditorAccountReferenceType("IBAN")
.creditorAgent("NBBEBEBB203")
.creditorAgentType("BIC")
.endToEndId("f4fdab3742af4a1386df4ca82c05ced6")
.links(PaymentInitiationAuthorizationLinks.builder().redirect(REDIRECT_LINK).build())
.financialInstitutionLink(FinancialInstitutionLinks.builder().related(FINANCIAL_INSTITUTION_RELATED_LINK).build())
.financialInstitutionId(FINANCIAL_INSTITUTION_ID)
.financialInstitutionCustomerReference("jdoe001")
.build();
}
}
| 0 |
raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\xs2a\services | raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\xs2a\services\impl\PendingTransactionsServiceImplTest.java | package com.ibanity.apis.client.products.xs2a.services.impl;
import com.ibanity.apis.client.helpers.IbanityTestHelper;
import com.ibanity.apis.client.http.IbanityHttpClient;
import com.ibanity.apis.client.models.ErrorMeta;
import com.ibanity.apis.client.models.FinancialInstitutionResponse;
import com.ibanity.apis.client.models.IbanityCollection;
import com.ibanity.apis.client.models.IbanityError;
import com.ibanity.apis.client.models.IbanityProduct;
import com.ibanity.apis.client.products.xs2a.models.PendingTransaction;
import com.ibanity.apis.client.products.xs2a.models.Synchronization;
import com.ibanity.apis.client.products.xs2a.models.read.PendingTransactionReadQuery;
import com.ibanity.apis.client.products.xs2a.models.read.PendingTransactionsReadQuery;
import com.ibanity.apis.client.services.ApiUrlProvider;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import java.math.BigDecimal;
import java.net.URI;
import java.time.Instant;
import java.util.Collections;
import java.util.UUID;
import static java.util.Collections.emptyMap;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
public class PendingTransactionsServiceImplTest {
private static final UUID ACCOUNT_ID = UUID.fromString("1c020714-759c-4ee6-ae87-5ce667937e77");
private static final UUID PENDING_TRANSACTION_ID = UUID.fromString("eb535c31-f619-4092-9db2-4db84149ddcb");
private static final UUID FINANCIAL_INSTITUTION_ID = UUID.fromString("99477654-a061-414c-afb4-19e37d13c5a3");
private static final UUID SYNCHRONIZATION_ID = UUID.fromString("9d36e759-b606-41dd-8d18-c882bd8db03d");
private static final String CUSTOMER_ACCESS_TOKEN = UUID.randomUUID().toString();
private static final String PENDING_TRANSACTION_ENDPOINT = "https://api.ibanity.com/xs2a/customer/financial-institutions/{financialInstitutionId}/accounts/{accountId}/pending-transactions/{pendingTransactionId}";
private static final String PENDING_TRANSACTION_URI = "https://api.ibanity.com/xs2a/customer/financial-institutions/99477654-a061-414c-afb4-19e37d13c5a3/accounts/1c020714-759c-4ee6-ae87-5ce667937e77/pending-transactions/eb535c31-f619-4092-9db2-4db84149ddcb";
private static final String PENDING_TRANSACTIONS_URI = "https://api.ibanity.com/xs2a/customer/financial-institutions/99477654-a061-414c-afb4-19e37d13c5a3/accounts/1c020714-759c-4ee6-ae87-5ce667937e77/pending-transactions?page%5Blimit%5D=10";
private static final String FIRST_LINK = "https://api.ibanity.com/xs2a/customer/financial-institutions/99477654-a061-414c-afb4-19e37d13c5a3/accounts/1c020714-759c-4ee6-ae87-5ce667937e77/pending-transactions";
private static final String UPDATED_PENDING_TRANSACTIONS_ENDPOINT = "https://api.ibanity.com/xs2a/customer/synchronizations/{synchronizationId}/updated-pending-transactions";
private static final String UPDATED_PENDING_TRANSACTIONS_URI = "https://api.ibanity.com/xs2a/customer/synchronizations/9d36e759-b606-41dd-8d18-c882bd8db03d/updated-pending-transactions?page%5Blimit%5D=10";
@Mock
private ApiUrlProvider apiUrlProvider;
@Mock
private IbanityHttpClient ibanityHttpClient;
@InjectMocks
private PendingTransactionsServiceImpl pendingTransactionsService;
@Test
public void find() throws Exception {
when(apiUrlProvider.find(IbanityProduct.Xs2a, "customer", "financialInstitution", "account", "pendingTransactions")).thenReturn(PENDING_TRANSACTION_ENDPOINT);
PendingTransactionReadQuery pendingTransactionReadQuery =
PendingTransactionReadQuery.builder()
.pendingTransactionId(PENDING_TRANSACTION_ID)
.accountId(ACCOUNT_ID)
.financialInstitutionId(FINANCIAL_INSTITUTION_ID)
.customerAccessToken(CUSTOMER_ACCESS_TOKEN)
.build();
when(ibanityHttpClient.get(new URI(PENDING_TRANSACTION_URI), emptyMap(), CUSTOMER_ACCESS_TOKEN))
.thenReturn(IbanityTestHelper.loadHttpResponse("json/pendingTransaction.json"));
PendingTransaction actual = pendingTransactionsService.find(pendingTransactionReadQuery);
assertThat(actual).isEqualTo(createExpected());
}
@Test
public void listForAccount() throws Exception {
when(apiUrlProvider.find(IbanityProduct.Xs2a, "customer", "financialInstitution", "account", "pendingTransactions")).thenReturn(PENDING_TRANSACTION_ENDPOINT);
IbanityCollection<PendingTransaction> expected =
IbanityCollection.<PendingTransaction>builder()
.pageLimit(10)
.firstLink(FIRST_LINK)
.items(Collections.singletonList(createExpected()))
.latestSynchronization(Synchronization.builder()
.resourceId("1c020714-759c-4ee6-ae87-5ce667937e77")
.resourceType("account")
.subtype("accountPendingTransactions")
.status("success")
.errors(Collections.singletonList(IbanityError.builder()
.code("authorizationInvalid")
.detail("The authorization is invalid, you should ask the customer to reauthorize the account")
.meta(ErrorMeta.builder()
.financialInstitutionResponse(FinancialInstitutionResponse.builder()
.body("{\"tppMessages\":[{\"category\":\"ERROR\",\"code\":\"NOT_FOUND\",\"text\":\"3.2 - Not Found\"}]}")
.requestId("354fwfwef4w684")
.statusCode(500)
.timestamp(Instant.parse("2019-05-09T09:18:00.000Z"))
.requestUri("http://google.com")
.build())
.build())
.build()))
.id(UUID.fromString("b49dff7e-ad7b-4992-9753-8f2a004cf343"))
.createdAt(Instant.parse("2019-04-25T09:06:07.171Z"))
.updatedAt(Instant.parse("2019-04-25T09:06:08.044Z"))
.build())
.build();
PendingTransactionsReadQuery pendingTransactionReadQuery =
PendingTransactionsReadQuery.builder()
.accountId(ACCOUNT_ID)
.financialInstitutionId(FINANCIAL_INSTITUTION_ID)
.customerAccessToken(CUSTOMER_ACCESS_TOKEN)
.build();
when(ibanityHttpClient.get(new URI(PENDING_TRANSACTIONS_URI), emptyMap(), CUSTOMER_ACCESS_TOKEN))
.thenReturn(IbanityTestHelper.loadHttpResponse("json/pendingTransactions.json"));
IbanityCollection<PendingTransaction> actual = pendingTransactionsService.list(pendingTransactionReadQuery);
assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
}
@Test
public void listUpdatedForSynchronization() throws Exception {
when(apiUrlProvider.find(IbanityProduct.Xs2a, "customer", "synchronization", "updatedPendingTransactions")).thenReturn(UPDATED_PENDING_TRANSACTIONS_ENDPOINT);
IbanityCollection<PendingTransaction> expected =
IbanityCollection.<PendingTransaction>builder()
.pageLimit(10)
.firstLink("https://api.ibanity.com/xs2a/customer/synchronizations/9d36e759-b606-41dd-8d18-c882bd8db03d/updated-pending-transactions")
.items(Collections.singletonList(createExpected()))
.build();
PendingTransactionsReadQuery pendingTransactionReadQuery =
PendingTransactionsReadQuery.builder()
.synchronizationId(SYNCHRONIZATION_ID)
.customerAccessToken(CUSTOMER_ACCESS_TOKEN)
.build();
when(ibanityHttpClient.get(new URI(UPDATED_PENDING_TRANSACTIONS_URI), emptyMap(), CUSTOMER_ACCESS_TOKEN))
.thenReturn(IbanityTestHelper.loadHttpResponse("json/updatedPendingTransactions.json"));
IbanityCollection<PendingTransaction> actual = pendingTransactionsService.listUpdatedForSynchronization(pendingTransactionReadQuery);
assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
}
private PendingTransaction createExpected() {
return PendingTransaction.builder()
.amount(new BigDecimal("6.99"))
.currency("EUR")
.remittanceInformationType("unstructured")
.remittanceInformation("NEW SHOES")
.description("Small Cotton Shoes")
.valueDate(Instant.parse("2018-10-22T00:00:00Z"))
.counterpartName("ABBOTSTONE AGRICULTURAL PROPERTY UNIT TRUST")
.counterpartReference("BE4779002273920627")
.executionDate(Instant.parse("2018-10-25T00:00:00.000Z"))
.internalReference("transaction_12345")
.bankTransactionCode("PMNT-IRCT-ESCT")
.proprietaryBankTransactionCode("prop123")
.endToEndId("61dd468606594217af9965ad3928280d")
.purposeCode("CASH")
.mandateId("12345678")
.creditorId("98765")
.additionalInformation("addional")
.selfLink(PENDING_TRANSACTION_URI)
.id(PENDING_TRANSACTION_ID)
.cardReference("6666")
.cardReferenceType("MASKEDPAN")
.fee(new BigDecimal("3.14"))
.build();
}
}
| 0 |
raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\xs2a\services | raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\xs2a\services\impl\PeriodicPaymentInitiationRequestAuthorizationsServiceImplTest.java | package com.ibanity.apis.client.products.xs2a.services.impl;
import com.ibanity.apis.client.http.IbanityHttpClient;
import com.ibanity.apis.client.jsonapi.RequestApiModel;
import com.ibanity.apis.client.models.IbanityProduct;
import com.ibanity.apis.client.products.xs2a.models.PeriodicPaymentInitiationRequestAuthorization;
import com.ibanity.apis.client.products.xs2a.models.create.PeriodicPaymentInitiationRequestAuthorizationCreationQuery;
import com.ibanity.apis.client.products.xs2a.models.links.PeriodicPaymentInitiationRequestAuthorizationLinks;
import com.ibanity.apis.client.services.ApiUrlProvider;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Captor;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
import static com.ibanity.apis.client.helpers.IbanityTestHelper.loadHttpResponse;
import static com.ibanity.apis.client.utils.URIHelper.buildUri;
import static java.util.Collections.emptyMap;
import static java.util.UUID.fromString;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
class PeriodicPaymentInitiationRequestAuthorizationsServiceImplTest {
private static final UUID FINANCIAL_INSTITUTION_ID = fromString("4876fdd6-7333-4f9f-b142-ba520ca497b1");
private static final UUID PAYMENT_INITIATION_REQUEST_ID = fromString("cd273ba1-cb2a-464d-b85d-62c9fc4dc8d9");
private static final UUID AUTHORIZATION_ID = fromString("cd273ba1-cb2a-464d-b85d-62c9fc4dc8d9");
private static final String AUTHORIZATION_CODE = "fndsfhskdfslfjhdskfjdsn";
private static final String CUSTOMER_ACCESS_TOKEN = "kdsfldsfmnvlds;md,vms.kvmdsk.vmd";
private static final String AUTHORIZATION_ENDPOINT = "https://api.ibanity.com/xs2a/customer/financial-institutions/{financialInstitutionId}/periodic-payment-initiation-requests/{paymentInitiationRequestId}/authorizations/{authorizationId}";
private static final String AUTHORIZATION_ENDPOINT_FOR_CREATE = "https://api.ibanity.com/xs2a/customer/financial-institutions/4876fdd6-7333-4f9f-b142-ba520ca497b1/periodic-payment-initiation-requests/cd273ba1-cb2a-464d-b85d-62c9fc4dc8d9/authorizations";
@InjectMocks
private PeriodicPaymentInitiationRequestAuthorizationsServiceImpl authorizationsService;
@Mock
private ApiUrlProvider apiUrlProvider;
@Mock
private IbanityHttpClient ibanityHttpClient;
@Captor
private ArgumentCaptor<RequestApiModel> argumentCaptor;
@BeforeEach
void setUp() {
when(apiUrlProvider.find(IbanityProduct.Xs2a, "customer", "financialInstitution", "periodicPaymentInitiationRequest", "authorizations"))
.thenReturn(AUTHORIZATION_ENDPOINT);
}
@Test
void create() throws IOException {
Map<String, String> queryParams = new HashMap<>();
queryParams.put("code", AUTHORIZATION_CODE);
PeriodicPaymentInitiationRequestAuthorizationCreationQuery creationQuery = PeriodicPaymentInitiationRequestAuthorizationCreationQuery.builder()
.customerAccessToken(CUSTOMER_ACCESS_TOKEN)
.queryParameters(queryParams)
.financialInstitutionId(FINANCIAL_INSTITUTION_ID)
.paymentInitiationRequestId(PAYMENT_INITIATION_REQUEST_ID)
.build();
when(ibanityHttpClient.post(eq(buildUri(AUTHORIZATION_ENDPOINT_FOR_CREATE)), argumentCaptor.capture(), eq(emptyMap()), eq(CUSTOMER_ACCESS_TOKEN))).thenReturn(loadHttpResponse("json/createPeriodicPaymentInitiationRequestAuthorization.json"));
PeriodicPaymentInitiationRequestAuthorization authorization = authorizationsService.create(creationQuery);
assertThat(authorization).isEqualTo(expected());
PeriodicPaymentInitiationRequestAuthorizationsServiceImpl.PeriodicPaymentInitiationRequestAuthorization authorizationRequest =
(PeriodicPaymentInitiationRequestAuthorizationsServiceImpl.PeriodicPaymentInitiationRequestAuthorization) argumentCaptor.getValue().getData().getAttributes();
assertThat(authorizationRequest.getQueryParameters().get("code")).isEqualTo(AUTHORIZATION_CODE);
}
private PeriodicPaymentInitiationRequestAuthorization expected() {
return PeriodicPaymentInitiationRequestAuthorization.builder()
.id(AUTHORIZATION_ID)
.status("succeeded")
.links(PeriodicPaymentInitiationRequestAuthorizationLinks.builder()
.nextRedirect("https://www.bnpp.com/next-step")
.build())
.build();
}
}
| 0 |
raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\xs2a\services | raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\xs2a\services\impl\PeriodicPaymentInitiationRequestServiceImplTest.java | package com.ibanity.apis.client.products.xs2a.services.impl;
import com.ibanity.apis.client.http.IbanityHttpClient;
import com.ibanity.apis.client.jsonapi.RequestApiModel;
import com.ibanity.apis.client.models.IbanityProduct;
import com.ibanity.apis.client.products.xs2a.models.PeriodicPaymentInitiationRequest;
import com.ibanity.apis.client.products.xs2a.models.create.PeriodicPaymentInitiationRequestCreationQuery;
import com.ibanity.apis.client.products.xs2a.models.links.FinancialInstitutionLinks;
import com.ibanity.apis.client.products.xs2a.models.links.PeriodicPaymentInitiationAuthorizationLinks;
import com.ibanity.apis.client.products.xs2a.models.read.PeriodicPaymentInitiationRequestReadQuery;
import com.ibanity.apis.client.services.ApiUrlProvider;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import java.io.IOException;
import java.math.BigDecimal;
import java.time.LocalDate;
import java.util.UUID;
import static com.ibanity.apis.client.helpers.IbanityTestHelper.loadHttpResponse;
import static com.ibanity.apis.client.utils.URIHelper.buildUri;
import static java.util.Collections.emptyMap;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
class PeriodicPaymentInitiationRequestServiceImplTest {
private static final UUID FINANCIAL_INSTITUTION_ID = UUID.fromString("9c6dad12-4927-4a40-af87-20f8ff4a4433");
private static final UUID PAYMENT_INITIATION_REQUEST_ID = UUID.fromString("7fbdf174-325a-4c1a-808e-4eec951c1b4d");
private static final String PERIODIC_PAYMENT_INITIATION_REQUEST_ENDPOINT = "https://api.ibanity.com/xs2a/customer/financial-institutions/{financialInstitutionId}/periodic-payment-initiation-requests/{paymentInitiationRequestId}";
private static final String PERIODIC_PAYMENT_INITIATION_REQUEST_ENDPOINT_FOR_CREATE = "https://api.ibanity.com/xs2a/customer/financial-institutions/9c6dad12-4927-4a40-af87-20f8ff4a4433/periodic-payment-initiation-requests";
private static final String PERIODIC_PAYMENT_INITIATION_REQUEST_ENDPOINT_WITH_ID = "https://api.ibanity.com/xs2a/customer/financial-institutions/9c6dad12-4927-4a40-af87-20f8ff4a4433/periodic-payment-initiation-requests/7fbdf174-325a-4c1a-808e-4eec951c1b4d";
private static final String REDIRECT_LINK = "https://callback.ibanity.com/sandbox/fi/pir/i?state=dmF1bHQ6djE6OWNXTHNwRkxoSk9vUjRoVk0rN1k2Z1N0SXBqNjNPNXdkSDZBTHpXaDVMZW9DSFEwTTBweVdpdFNXUlp2UC8wc0dId1NvVmVsT2lPaGxWK2J5SUlOb1JhbjlNUjBLei81UER2ZzNpcVF4TDRWUE5rUVMvRnhpUTFMZkhsT3ZHeDB2Uy9nLzhwRGd3VG1XTzkxR3pPSEUwQkxQR3YxS3AweDBpRzFaS0tiMVhlL3g5L1UzcEZkV1doMllVRWZ5bHZhMWJiUzAvTllXZUV0ZVhMYTJsT01YMFJ6UURTM3VOMDNvWE9nWlAzcmZrYUtiZENQMzFld1VVVDdHVjBhNWpQci9ZTmswUVVoWTBYVXZVY0VMVVRSdU9rM2psTnU0STQ2UzN5TlMxeCtybFFuVDNtQjN1OTk0aDdxbEk2OXcxbEdsbGlvUjZtR3pyZU0xR2psQlVzdG8zcmRNazlkK3lPK0hwS0tlbitRSkFEa2loS0kweklwWnBvK0dCdEFwSWNMakhUTEtCQ2pBaFgwQlRiSkhXZmFYVlR3a2NveUV1M05WSEZ6Qjg0cTNoQ1ZtN28xdlNaU0Mvd21TV2RRMWJGK0lTRWFXY2ZQQ1d2SGx1SjFmOVRJWGt3dzhFeGVROXRESWlMVUF5L0l3TTBWb2F4VWYyR0MrT1hMWkpzZkR0NGJ1YzdSdmRiVUFKaGhpSkhlZG0wVTMxN2JGTmRObXNLc3NLUVRSY2Rwb2NXaWh4YWxJS3hjTDVjNWpNNTRiaGVYNzVpTStGekZFTDk1MnQ2SVp5L2tITWJoUDNzVkN4d0M1SElpT29PUGp1a3BQbm1xVDRqWC8zQlNwVS8rbUhOOTBsSmVXK2c2Q3F0bWJ1MVNUWGsrQmxhNGZOZW9ETHFhbjM1Yk5TUEh2Y2xPdXRBWExKVjBSMXV6U3phMThXV3MrYU9vMUh5NE9OMEQxeklhK0tnS2Z1VU1JMXVLdXFBSGJHQ0hzOXZVcjRWRjQ0bEJ4WEZzTDlaM21KRDlXMkdzTEtJZzc2R2RubnFVTjUvOVhkZ1NZWXdnYU01b2pjanAyR0NseFozRjEyT0ZFTlN1c25ZUldtb3J1S1cxOUhVMENHYXlNeS80MDQ3b05qdUZnM0NlKy9QUk5ZNktqRVdUOXA0Q3d2b2Y5UGtXbnJYU2lLYkc1dGt6d3BMdzBSTWdSWnlIM2F4NHRxSHN3UDF2Vnh0SlVzMWhNMXpzS2VTMTRXeWRNc3QrU3c9PQ==";
private static final String CUSTOMER_TOKEN_REFERENCE = "itsme";
private static final String FINANCIAL_INSTITUTION_RELATED_LINK = "https://api.ibanity.com/xs2a/financial-institutions/9c6dad12-4927-4a40-af87-20f8ff4a4433";
private static final String CUSTOM_STATE = "myState";
@InjectMocks
private PeriodicPaymentInitiationRequestServiceImpl periodicPaymentInitiationRequestService;
@Mock
private ApiUrlProvider apiUrlProvider;
@Mock
private IbanityHttpClient ibanityHttpClient;
@BeforeEach
void setUp() {
when(apiUrlProvider.find(IbanityProduct.Xs2a, "customer", "financialInstitution", "periodicPaymentInitiationRequests"))
.thenReturn(PERIODIC_PAYMENT_INITIATION_REQUEST_ENDPOINT);
}
@Test
void create() throws Exception {
PeriodicPaymentInitiationRequestCreationQuery requestCreationQuery =
PeriodicPaymentInitiationRequestCreationQuery.builder()
.customerAccessToken(CUSTOMER_TOKEN_REFERENCE)
.financialInstitutionId(FINANCIAL_INSTITUTION_ID)
.customerIpAddress("1.2.3.4")
.locale("fr")
.skipIbanityCompletionCallback(true)
.allowFinancialInstitutionRedirectUri(true)
.state(CUSTOM_STATE)
.startDate(LocalDate.now())
.endDate(LocalDate.now())
.frequency("monthly")
.executionRule("following")
.financialInstitutionCustomerReference("jdoe001")
.build();
when(ibanityHttpClient.post(buildUri(PERIODIC_PAYMENT_INITIATION_REQUEST_ENDPOINT_FOR_CREATE), mapRequest(requestCreationQuery), emptyMap(), CUSTOMER_TOKEN_REFERENCE))
.thenReturn(loadHttpResponse("json/createPeriodicPaymentInitiationRequest.json"));
PeriodicPaymentInitiationRequest actual = periodicPaymentInitiationRequestService.create(requestCreationQuery);
assertThat(actual).isEqualToComparingFieldByFieldRecursively(createExpectedForCreate());
}
@Test
void delete() throws IOException {
PeriodicPaymentInitiationRequestReadQuery requestReadQuery =
PeriodicPaymentInitiationRequestReadQuery.builder()
.customerAccessToken(CUSTOMER_TOKEN_REFERENCE)
.financialInstitutionId(FINANCIAL_INSTITUTION_ID)
.paymentInitiationRequestId(PAYMENT_INITIATION_REQUEST_ID)
.build();
when(ibanityHttpClient.delete(buildUri(PERIODIC_PAYMENT_INITIATION_REQUEST_ENDPOINT_WITH_ID), emptyMap(), CUSTOMER_TOKEN_REFERENCE))
.thenReturn(loadHttpResponse("json/deletePeriodicPaymentInitiationRequest.json"));
PeriodicPaymentInitiationRequest actual = periodicPaymentInitiationRequestService.delete(requestReadQuery);
assertThat(actual).isEqualToComparingFieldByField(createExpectedForDelete());
}
@Test
void find() throws Exception {
PeriodicPaymentInitiationRequestReadQuery readQuery =
PeriodicPaymentInitiationRequestReadQuery.builder()
.paymentInitiationRequestId(PAYMENT_INITIATION_REQUEST_ID)
.financialInstitutionId(FINANCIAL_INSTITUTION_ID)
.customerAccessToken(CUSTOMER_TOKEN_REFERENCE)
.build();
when(ibanityHttpClient.get(buildUri(PERIODIC_PAYMENT_INITIATION_REQUEST_ENDPOINT_WITH_ID), emptyMap(), CUSTOMER_TOKEN_REFERENCE))
.thenReturn(loadHttpResponse("json/periodicPaymentInitiationRequest.json"));
PeriodicPaymentInitiationRequest actual = periodicPaymentInitiationRequestService.find(readQuery);
assertThat(actual).isEqualToComparingFieldByField(createExpectedForFind());
}
private PeriodicPaymentInitiationRequest createExpectedForDelete() {
return PeriodicPaymentInitiationRequest.builder()
.id(PAYMENT_INITIATION_REQUEST_ID)
.build();
}
private RequestApiModel mapRequest(PeriodicPaymentInitiationRequestCreationQuery query) {
PeriodicPaymentInitiationRequestServiceImpl.PeriodicPaymentInitiationRequest periodicPaymentInitiationRequest = PeriodicPaymentInitiationRequestServiceImpl.PeriodicPaymentInitiationRequest.builder()
.financialInstitutionId(query.getFinancialInstitutionId())
.amount(query.getAmount())
.consentReference(query.getConsentReference())
.creditorAccountReference(query.getCreditorAccountReference())
.creditorAccountReferenceType(query.getCreditorAccountReferenceType())
.creditorName(query.getCreditorName())
.currency(query.getCurrency())
.endToEndId(query.getEndToEndId())
.productType(query.getProductType())
.redirectUri(query.getRedirectUri())
.remittanceInformation(query.getRemittanceInformation())
.remittanceInformationType(query.getRemittanceInformationType())
.creditorAgent(query.getCreditorAgent())
.creditorAgentType(query.getCreditorAgentType())
.debtorAccountReference(query.getDebtorAccountReference())
.debtorAccountReferenceType(query.getDebtorAccountReferenceType())
.debtorName(query.getDebtorName())
.customerIpAddress(query.getCustomerIpAddress())
.locale(query.getLocale())
.state(query.getState())
.skipIbanityCompletionCallback(query.isSkipIbanityCompletionCallback())
.allowFinancialInstitutionRedirectUri(query.isAllowFinancialInstitutionRedirectUri())
.startDate(LocalDate.now())
.endDate(LocalDate.now())
.frequency("monthly")
.executionRule("following")
.financialInstitutionCustomerReference(query.getFinancialInstitutionCustomerReference())
.build();
return RequestApiModel.builder()
.data(
RequestApiModel.RequestDataApiModel.builder()
.attributes(periodicPaymentInitiationRequest)
.type(PeriodicPaymentInitiationRequest.RESOURCE_TYPE)
.build()
)
.build();
}
private PeriodicPaymentInitiationRequest createExpectedForFind() {
return PeriodicPaymentInitiationRequest.builder()
.id(PAYMENT_INITIATION_REQUEST_ID)
.consentReference("ad8f28f9-7ba1-4caf-9e7d-df2c04f88dd8")
.productType("sepa-credit-transfer")
.remittanceInformation("payment")
.remittanceInformationType("unstructured")
.startDate(LocalDate.parse("2020-02-05"))
.endDate(LocalDate.parse("2022-02-05"))
.frequency("monthly")
.executionRule("following")
.currency("EUR")
.amount(new BigDecimal("59"))
.debtorName("Delmer Hermann")
.debtorAccountReference("BE5283671456644082")
.debtorAccountReferenceType("IBAN")
.creditorName("Alex Creditor")
.creditorAccountReference("BE4215561520006651")
.creditorAccountReferenceType("IBAN")
.creditorAgent("NBBEBEBB203")
.creditorAgentType("BIC")
.endToEndId("f4fdab3742af4a1386df4ca82c05ced6")
.status("error")
.statusReason("invalid")
.skipIbanityCompletionCallback(true)
.allowFinancialInstitutionRedirectUri(true)
.financialInstitutionLink(FinancialInstitutionLinks.builder().related(FINANCIAL_INSTITUTION_RELATED_LINK).build())
.financialInstitutionId(FINANCIAL_INSTITUTION_ID)
.build();
}
private PeriodicPaymentInitiationRequest createExpectedForCreate() {
return PeriodicPaymentInitiationRequest.builder()
.id(PAYMENT_INITIATION_REQUEST_ID)
.consentReference("ad8f28f9-7ba1-4caf-9e7d-df2c04f88dd8")
.productType("sepa-credit-transfer")
.remittanceInformation("payment")
.remittanceInformationType("unstructured")
.startDate(LocalDate.parse("2020-02-05"))
.endDate(LocalDate.parse("2020-02-05"))
.frequency("monthly")
.executionRule("following")
.currency("EUR")
.amount(new BigDecimal("59"))
.debtorName("Delmer Hermann")
.debtorAccountReference("BE5283671456644082")
.debtorAccountReferenceType("IBAN")
.creditorName("Alex Creditor")
.creditorAccountReference("BE4215561520006651")
.creditorAccountReferenceType("IBAN")
.creditorAgent("NBBEBEBB203")
.creditorAgentType("BIC")
.endToEndId("f4fdab3742af4a1386df4ca82c05ced6")
.skipIbanityCompletionCallback(true)
.allowFinancialInstitutionRedirectUri(true)
.links(PeriodicPaymentInitiationAuthorizationLinks.builder().redirect(REDIRECT_LINK).build())
.financialInstitutionLink(FinancialInstitutionLinks.builder().related(FINANCIAL_INSTITUTION_RELATED_LINK).build())
.financialInstitutionId(FINANCIAL_INSTITUTION_ID)
.financialInstitutionCustomerReference("jdoe001")
.build();
}
}
| 0 |
raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\xs2a\services | raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\xs2a\services\impl\SynchronizationServiceImplTest.java | package com.ibanity.apis.client.products.xs2a.services.impl;
import com.ibanity.apis.client.helpers.IbanityTestHelper;
import com.ibanity.apis.client.http.IbanityHttpClient;
import com.ibanity.apis.client.jsonapi.RequestApiModel;
import com.ibanity.apis.client.models.ErrorMeta;
import com.ibanity.apis.client.models.FinancialInstitutionResponse;
import com.ibanity.apis.client.models.IbanityError;
import com.ibanity.apis.client.models.IbanityProduct;
import com.ibanity.apis.client.products.xs2a.models.Synchronization;
import com.ibanity.apis.client.products.xs2a.models.create.SynchronizationCreationQuery;
import com.ibanity.apis.client.products.xs2a.models.links.UpdatedTransactionsLinks;
import com.ibanity.apis.client.products.xs2a.models.read.SynchronizationReadQuery;
import com.ibanity.apis.client.services.ApiUrlProvider;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import java.net.URI;
import java.time.Instant;
import java.util.Collections;
import java.util.UUID;
import static java.util.Collections.emptyMap;
import static java.util.UUID.fromString;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
class SynchronizationServiceImplTest {
private static final UUID SYNCHRONIZATION_ID = fromString("04e98b21-8213-4aec-b373-13eb51f948e9");
private static final String ACCOUNT_ID = "d0027fc6-0097-41f7-a9bb-3c400b5a3e2a";
private static final String SYNCHRONIZATION_ENDPOINT = "https://api.ibanity.com/xs2a/customer/synchronizations";
private static final String CUSTOMER_ACCESS_TOKEN = "itsme";
@Mock
private ApiUrlProvider apiUrlProvider;
@Mock
private IbanityHttpClient ibanityHttpClient;
@InjectMocks
private SynchronizationServiceImpl synchronizationService;
@BeforeEach
void setUp() {
when(apiUrlProvider.find(IbanityProduct.Xs2a, "customer", "synchronizations")).thenReturn(SYNCHRONIZATION_ENDPOINT);
}
@Test
void create() throws Exception {
SynchronizationCreationQuery synchronizationCreationQuery =
SynchronizationCreationQuery.builder()
.resourceType("account")
.subtype("accountDetails")
.resourceId(ACCOUNT_ID)
.customerOnline(true)
.customerIpAddress("0.0.0.0")
.customerAccessToken(CUSTOMER_ACCESS_TOKEN)
.build();
when(ibanityHttpClient.post(new URI(SYNCHRONIZATION_ENDPOINT), createRequest(synchronizationCreationQuery), emptyMap(), CUSTOMER_ACCESS_TOKEN))
.thenReturn(IbanityTestHelper.loadHttpResponse("json/createSynchronization.json"));
Synchronization actual = synchronizationService.create(synchronizationCreationQuery);
assertThat(actual).isEqualToComparingFieldByField(createExpected("pending", "somehtml", false));
}
@Test
void find() throws Exception {
SynchronizationReadQuery synchronizationReadQuery =
SynchronizationReadQuery.builder()
.customerAccessToken(CUSTOMER_ACCESS_TOKEN)
.synchronizationId(SYNCHRONIZATION_ID)
.build();
when(ibanityHttpClient.get(new URI(SYNCHRONIZATION_ENDPOINT + "/" + SYNCHRONIZATION_ID), emptyMap(), CUSTOMER_ACCESS_TOKEN))
.thenReturn(IbanityTestHelper.loadHttpResponse("json/synchronization.json"));
Synchronization actual = synchronizationService.find(synchronizationReadQuery);
assertThat(actual).isEqualToComparingFieldByField(createExpected("error", "somehtml", true));
}
@Test
void find_when_error_contains_json() throws Exception {
SynchronizationReadQuery synchronizationReadQuery =
SynchronizationReadQuery.builder()
.customerAccessToken(CUSTOMER_ACCESS_TOKEN)
.synchronizationId(SYNCHRONIZATION_ID)
.build();
when(ibanityHttpClient.get(new URI(SYNCHRONIZATION_ENDPOINT + "/" + SYNCHRONIZATION_ID), emptyMap(), CUSTOMER_ACCESS_TOKEN))
.thenReturn(IbanityTestHelper.loadHttpResponse("json/synchronization_with_json_error.json"));
Synchronization actual = synchronizationService.find(synchronizationReadQuery);
assertThat(actual).isEqualToComparingFieldByField(createExpected("error", "{\"tppMessages\":[{\"category\":\"ERROR\",\"code\":\"NOT_FOUND\",\"text\":\"3.2 - Not Found\"}]}", false));
}
private RequestApiModel createRequest(SynchronizationCreationQuery synchronizationCreationQuery) {
Synchronization synchronization = Synchronization.builder()
.resourceId(synchronizationCreationQuery.getResourceId())
.resourceType(synchronizationCreationQuery.getResourceType())
.subtype(synchronizationCreationQuery.getSubtype())
.customerOnline(synchronizationCreationQuery.getCustomerOnline())
.customerIpAddress(synchronizationCreationQuery.getCustomerIpAddress())
.build();
return RequestApiModel.builder()
.data(
RequestApiModel.RequestDataApiModel.builder()
.attributes(synchronization)
.type(Synchronization.RESOURCE_TYPE)
.build()
)
.build();
}
private Synchronization createExpected(String status, String body, boolean withUpdatedTransactionsLinks) {
Synchronization.SynchronizationBuilder synchronizationBuilder = Synchronization.builder()
.id(SYNCHRONIZATION_ID)
.resourceId(ACCOUNT_ID)
.resourceType("account")
.status(status)
.subtype("accountDetails")
.customerOnline(true)
.createdAt(Instant.parse("2019-05-09T09:18:58.358Z"))
.updatedAt(Instant.parse("2019-05-09T09:18:59.012Z"));
if ("error".equalsIgnoreCase(status)) {
synchronizationBuilder = synchronizationBuilder.errors(Collections.singletonList(IbanityError.builder()
.code("authorizationInvalid")
.detail("The authorization is invalid, you should ask the customer to reauthorize the account")
.meta(ErrorMeta.builder()
.financialInstitutionResponse(FinancialInstitutionResponse.builder()
.body(body)
.requestId("354fwfwef4w684")
.statusCode(500)
.timestamp(Instant.parse("2019-05-09T09:18:00.000Z"))
.requestUri("http://google.com")
.build())
.build())
.build()));
}
if (withUpdatedTransactionsLinks) {
synchronizationBuilder = synchronizationBuilder.updatedTransactionsLinks(
UpdatedTransactionsLinks.builder()
.related("https://api.ibanity.com/xs2a/customer/synchronizations/38ea8333-81be-443e-9852-6d86468f5b45/updated-transactions")
.build()
);
}
return synchronizationBuilder
.build();
}
}
| 0 |
raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\xs2a\services | raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\xs2a\services\impl\TransactionDeleteRequestsServiceImplTest.java | package com.ibanity.apis.client.products.xs2a.services.impl;
import com.ibanity.apis.client.helpers.IbanityTestHelper;
import com.ibanity.apis.client.http.IbanityHttpClient;
import com.ibanity.apis.client.jsonapi.RequestApiModel;
import com.ibanity.apis.client.models.IbanityProduct;
import com.ibanity.apis.client.products.xs2a.models.TransactionDeleteRequest;
import com.ibanity.apis.client.products.xs2a.models.create.TransactionDeleteRequestCreationQuery;
import com.ibanity.apis.client.services.ApiUrlProvider;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import java.net.URI;
import java.time.Instant;
import java.util.UUID;
import static java.util.Collections.emptyMap;
import static java.util.UUID.fromString;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
class TransactionDeleteRequestsServiceImplTest {
private static final UUID ACCOUNT_ID = UUID.fromString("1c020714-759c-4ee6-ae87-5ce667937e77");
private static final UUID FINANCIAL_INSTITUTION_ID = UUID.fromString("99477654-a061-414c-afb4-19e37d13c5a3");
private static final UUID TRANSACTION_DELETE_REQUEST_ID = fromString("04e98b21-8213-4aec-b373-13eb51f948e9");
private static final String TRANSACTION_DELETE_REQUEST_FOR_APPLICATION_ENDPOINT = "https://api.ibanity.com/xs2a/transaction-delete-requests";
private static final String TRANSACTION_DELETE_REQUEST_FOR_CUSTOMER_ENDPOINT = "https://api.ibanity.com/xs2a/customer/transaction-delete-requests";
private static final String TRANSACTION_DELETE_REQUEST_FOR_ACCOUNT_ENDPOINT = "https://api.ibanity.com/xs2a/customer/financial-institutions/id/accounts/1c020714-759c-4ee6-ae87-5ce667937e77/transaction-delete-requests";
private static final Instant TRANSACTION_DELETE_REQUEST_X_DATE = Instant.parse("2022-05-17T00:00:00.000Z");
private static final String CUSTOMER_ACCESS_TOKEN = "itsme";
@Mock
private ApiUrlProvider apiUrlProvider;
@Mock
private IbanityHttpClient ibanityHttpClient;
@InjectMocks
private TransactionDeleteRequestsServiceImpl transactionDeleteRequestsService;
@Test
void createForApplication() throws Exception {
when(apiUrlProvider.find(IbanityProduct.Xs2a, "transactionDeleteRequests")).thenReturn(TRANSACTION_DELETE_REQUEST_FOR_APPLICATION_ENDPOINT);
TransactionDeleteRequestCreationQuery transactionDeleteRequestCreationQuery =
TransactionDeleteRequestCreationQuery.builder()
.beforeDate(TRANSACTION_DELETE_REQUEST_X_DATE)
.build();
when(ibanityHttpClient.post(new URI(TRANSACTION_DELETE_REQUEST_FOR_APPLICATION_ENDPOINT), createRequest(transactionDeleteRequestCreationQuery), emptyMap(), null))
.thenReturn(IbanityTestHelper.loadHttpResponse("json/createTransactionDeleteRequest.json"));
TransactionDeleteRequest actual = transactionDeleteRequestsService.createForApplication(transactionDeleteRequestCreationQuery);
assertThat(actual).isEqualToComparingFieldByField(createExpected());
}
@Test
void createForCustomer() throws Exception {
when(apiUrlProvider.find(IbanityProduct.Xs2a, "customer", "transactionDeleteRequests")).thenReturn(TRANSACTION_DELETE_REQUEST_FOR_CUSTOMER_ENDPOINT);
TransactionDeleteRequestCreationQuery transactionDeleteRequestCreationQuery =
TransactionDeleteRequestCreationQuery.builder()
.customerAccessToken(CUSTOMER_ACCESS_TOKEN)
.beforeDate(TRANSACTION_DELETE_REQUEST_X_DATE)
.build();
when(ibanityHttpClient.post(new URI(TRANSACTION_DELETE_REQUEST_FOR_CUSTOMER_ENDPOINT), createRequest(transactionDeleteRequestCreationQuery), emptyMap(), CUSTOMER_ACCESS_TOKEN))
.thenReturn(IbanityTestHelper.loadHttpResponse("json/createTransactionDeleteRequest.json"));
TransactionDeleteRequest actual = transactionDeleteRequestsService.createForCustomer(transactionDeleteRequestCreationQuery);
assertThat(actual).isEqualToComparingFieldByField(createExpected());
}
@Test
void createForAccount() throws Exception {
when(apiUrlProvider.find(IbanityProduct.Xs2a, "customer", "financialInstitution", "account", "transactionDeleteRequests")).thenReturn(TRANSACTION_DELETE_REQUEST_FOR_ACCOUNT_ENDPOINT);
TransactionDeleteRequestCreationQuery transactionDeleteRequestCreationQuery =
TransactionDeleteRequestCreationQuery.builder()
.customerAccessToken(CUSTOMER_ACCESS_TOKEN)
.financialInstitutionId(FINANCIAL_INSTITUTION_ID)
.accountId(ACCOUNT_ID)
.beforeDate(TRANSACTION_DELETE_REQUEST_X_DATE)
.build();
when(ibanityHttpClient.post(new URI(TRANSACTION_DELETE_REQUEST_FOR_ACCOUNT_ENDPOINT), createRequest(transactionDeleteRequestCreationQuery), emptyMap(), CUSTOMER_ACCESS_TOKEN))
.thenReturn(IbanityTestHelper.loadHttpResponse("json/createTransactionDeleteRequest.json"));
TransactionDeleteRequest actual = transactionDeleteRequestsService.createForAccount(transactionDeleteRequestCreationQuery);
assertThat(actual).isEqualToComparingFieldByField(createExpected());
}
private RequestApiModel createRequest(TransactionDeleteRequestCreationQuery transactionDeleteRequestCreationQuery) {
TransactionDeleteRequest transactionDeleteRequest = TransactionDeleteRequest.builder()
.beforeDate(transactionDeleteRequestCreationQuery.getBeforeDate())
.build();
return RequestApiModel.builder()
.data(
RequestApiModel.RequestDataApiModel.builder()
.attributes(transactionDeleteRequest)
.type(TransactionDeleteRequest.RESOURCE_TYPE)
.build()
)
.build();
}
private TransactionDeleteRequest createExpected() {
TransactionDeleteRequest.TransactionDeleteRequestBuilder transactionDeleteRequestBuilder = TransactionDeleteRequest.builder()
.id(TRANSACTION_DELETE_REQUEST_ID)
.beforeDate(TRANSACTION_DELETE_REQUEST_X_DATE);
return transactionDeleteRequestBuilder
.build();
}
}
| 0 |
raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\xs2a\services | raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\products\xs2a\services\impl\TransactionsServiceImplTest.java | package com.ibanity.apis.client.products.xs2a.services.impl;
import com.ibanity.apis.client.helpers.IbanityTestHelper;
import com.ibanity.apis.client.http.IbanityHttpClient;
import com.ibanity.apis.client.models.ErrorMeta;
import com.ibanity.apis.client.models.FinancialInstitutionResponse;
import com.ibanity.apis.client.models.IbanityCollection;
import com.ibanity.apis.client.models.IbanityError;
import com.ibanity.apis.client.models.IbanityProduct;
import com.ibanity.apis.client.products.xs2a.models.Synchronization;
import com.ibanity.apis.client.products.xs2a.models.Transaction;
import com.ibanity.apis.client.products.xs2a.models.read.TransactionReadQuery;
import com.ibanity.apis.client.products.xs2a.models.read.TransactionsReadQuery;
import com.ibanity.apis.client.services.ApiUrlProvider;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import java.math.BigDecimal;
import java.net.URI;
import java.time.Instant;
import java.util.Collections;
import java.util.UUID;
import static java.util.Collections.emptyMap;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.when;
@ExtendWith(MockitoExtension.class)
public class TransactionsServiceImplTest {
private static final UUID ACCOUNT_ID = UUID.fromString("1c020714-759c-4ee6-ae87-5ce667937e77");
private static final UUID TRANSACTION_ID = UUID.fromString("eb535c31-f619-4092-9db2-4db84149ddcb");
private static final UUID FINANCIAL_INSTITUTION_ID = UUID.fromString("99477654-a061-414c-afb4-19e37d13c5a3");
private static final UUID SYNCHRONIZATION_ID = UUID.fromString("9d36e759-b606-41dd-8d18-c882bd8db03d");
private static final String CUSTOMER_ACCESS_TOKEN = UUID.randomUUID().toString();
private static final String TRANSACTION_ENDPOINT = "https://api.ibanity.com/xs2a/customer/financial-institutions/{financialInstitutionId}/accounts/{accountId}/transactions/{transactionId}";
private static final String TRANSACTION_URI = "https://api.ibanity.com/xs2a/customer/financial-institutions/99477654-a061-414c-afb4-19e37d13c5a3/accounts/1c020714-759c-4ee6-ae87-5ce667937e77/transactions/eb535c31-f619-4092-9db2-4db84149ddcb";
private static final String TRANSACTIONS_URI = "https://api.ibanity.com/xs2a/customer/financial-institutions/99477654-a061-414c-afb4-19e37d13c5a3/accounts/1c020714-759c-4ee6-ae87-5ce667937e77/transactions?page%5Blimit%5D=10";
private static final String FIRST_LINK = "https://api.ibanity.com/xs2a/customer/financial-institutions/99477654-a061-414c-afb4-19e37d13c5a3/accounts/1c020714-759c-4ee6-ae87-5ce667937e77/transactions";
private static final String UPDATED_TRANSACTIONS_ENDPOINT = "https://api.ibanity.com/xs2a/customer/synchronizations/{synchronizationId}/updated-transactions";
private static final String UPDATED_TRANSACTIONS_URI = "https://api.ibanity.com/xs2a/customer/synchronizations/9d36e759-b606-41dd-8d18-c882bd8db03d/updated-transactions?page%5Blimit%5D=10";
@Mock
private ApiUrlProvider apiUrlProvider;
@Mock
private IbanityHttpClient ibanityHttpClient;
@InjectMocks
private TransactionsServiceImpl transactionsService;
@Test
public void find() throws Exception {
when(apiUrlProvider.find(IbanityProduct.Xs2a, "customer", "financialInstitution", "account", "transactions")).thenReturn(TRANSACTION_ENDPOINT);
TransactionReadQuery transactionReadQuery =
TransactionReadQuery.builder()
.transactionId(TRANSACTION_ID)
.accountId(ACCOUNT_ID)
.financialInstitutionId(FINANCIAL_INSTITUTION_ID)
.customerAccessToken(CUSTOMER_ACCESS_TOKEN)
.build();
when(ibanityHttpClient.get(new URI(TRANSACTION_URI), emptyMap(), CUSTOMER_ACCESS_TOKEN))
.thenReturn(IbanityTestHelper.loadHttpResponse("json/transaction.json"));
Transaction actual = transactionsService.find(transactionReadQuery);
assertThat(actual).isEqualTo(createExpected());
}
@Test
public void listForAccount() throws Exception {
when(apiUrlProvider.find(IbanityProduct.Xs2a, "customer", "financialInstitution", "account", "transactions")).thenReturn(TRANSACTION_ENDPOINT);
IbanityCollection<Transaction> expected =
IbanityCollection.<Transaction>builder()
.pageLimit(10)
.firstLink(FIRST_LINK)
.items(Collections.singletonList(createExpected()))
.latestSynchronization(Synchronization.builder()
.resourceId("1c020714-759c-4ee6-ae87-5ce667937e77")
.resourceType("account")
.subtype("accountTransactions")
.status("success")
.errors(Collections.singletonList(IbanityError.builder()
.code("authorizationInvalid")
.detail("The authorization is invalid, you should ask the customer to reauthorize the account")
.meta(ErrorMeta.builder()
.financialInstitutionResponse(FinancialInstitutionResponse.builder()
.body("{\"tppMessages\":[{\"category\":\"ERROR\",\"code\":\"NOT_FOUND\",\"text\":\"3.2 - Not Found\"}]}")
.requestId("354fwfwef4w684")
.statusCode(500)
.timestamp(Instant.parse("2019-05-09T09:18:00.000Z"))
.requestUri("http://google.com")
.build())
.build())
.build()))
.id(UUID.fromString("b49dff7e-ad7b-4992-9753-8f2a004cf343"))
.createdAt(Instant.parse("2019-04-25T09:06:07.171Z"))
.updatedAt(Instant.parse("2019-04-25T09:06:08.044Z"))
.build())
.build();
TransactionsReadQuery transactionReadQuery =
TransactionsReadQuery.builder()
.accountId(ACCOUNT_ID)
.financialInstitutionId(FINANCIAL_INSTITUTION_ID)
.customerAccessToken(CUSTOMER_ACCESS_TOKEN)
.build();
when(ibanityHttpClient.get(new URI(TRANSACTIONS_URI), emptyMap(), CUSTOMER_ACCESS_TOKEN))
.thenReturn(IbanityTestHelper.loadHttpResponse("json/transactions.json"));
IbanityCollection<Transaction> actual = transactionsService.list(transactionReadQuery);
assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
}
@Test
public void listUpdatedForSynchronization() throws Exception {
when(apiUrlProvider.find(IbanityProduct.Xs2a, "customer", "synchronization", "updatedTransactions")).thenReturn(UPDATED_TRANSACTIONS_ENDPOINT);
IbanityCollection<Transaction> expected =
IbanityCollection.<Transaction>builder()
.pageLimit(10)
.firstLink("https://api.ibanity.com/xs2a/customer/synchronizations/9d36e759-b606-41dd-8d18-c882bd8db03d/updated-transactions")
.items(Collections.singletonList(createExpected()))
.build();
TransactionsReadQuery transactionReadQuery =
TransactionsReadQuery.builder()
.synchronizationId(SYNCHRONIZATION_ID)
.customerAccessToken(CUSTOMER_ACCESS_TOKEN)
.build();
when(ibanityHttpClient.get(new URI(UPDATED_TRANSACTIONS_URI), emptyMap(), CUSTOMER_ACCESS_TOKEN))
.thenReturn(IbanityTestHelper.loadHttpResponse("json/updatedTransactions.json"));
IbanityCollection<Transaction> actual = transactionsService.listUpdatedForSynchronization(transactionReadQuery);
assertThat(actual).isEqualToComparingFieldByFieldRecursively(expected);
}
private Transaction createExpected() {
return Transaction.builder()
.amount(new BigDecimal("6.99"))
.currency("EUR")
.remittanceInformationType("unstructured")
.remittanceInformation("NEW SHOES")
.description("Small Cotton Shoes")
.valueDate(Instant.parse("2018-10-22T00:00:00Z"))
.counterpartName("ABBOTSTONE AGRICULTURAL PROPERTY UNIT TRUST")
.counterpartReference("BE4779002273920627")
.executionDate(Instant.parse("2018-10-25T00:00:00.000Z"))
.internalReference("transaction_12345")
.bankTransactionCode("PMNT-IRCT-ESCT")
.proprietaryBankTransactionCode("prop123")
.endToEndId("61dd468606594217af9965ad3928280d")
.purposeCode("CASH")
.mandateId("12345678")
.creditorId("98765")
.additionalInformation("addional")
.selfLink(TRANSACTION_URI)
.id(TRANSACTION_ID)
.cardReference("6666")
.cardReferenceType("MASKEDPAN")
.fee(new BigDecimal("3.14"))
.build();
}
}
| 0 |
raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\services | raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\services\impl\ApiUrlProviderImplTest.java | package com.ibanity.apis.client.services.impl;
import com.ibanity.apis.client.http.IbanityHttpClient;
import com.ibanity.apis.client.models.IbanityProduct;
import org.apache.http.HttpResponse;
import org.apache.http.entity.StringEntity;
import org.apache.http.message.BasicHttpResponse;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import java.io.UnsupportedEncodingException;
import static com.ibanity.apis.client.helpers.IbanityTestHelper.HTTP;
import static java.net.URI.create;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.lenient;
@ExtendWith({MockitoExtension.class})
class ApiUrlProviderImplTest {
public static final String API_ENDPOINT = "https://api.ibanity.localhost";
public static final String PROXY_ENDPOINT = "http://myproxy.com";
@Mock
private IbanityHttpClient ibanityHttpClient;
private ApiUrlProviderImpl apiUrlProvider;
@BeforeEach
void setUp() throws UnsupportedEncodingException {
lenient().when(ibanityHttpClient.get(eq(create(PROXY_ENDPOINT + "/xs2a")), eq(null))).thenReturn(getHttpResponse());
lenient().when(ibanityHttpClient.get(eq(create(API_ENDPOINT + "/xs2a")), eq(null))).thenReturn(getHttpResponse());
}
private HttpResponse getHttpResponse() throws UnsupportedEncodingException {
HttpResponse httpResponse = new BasicHttpResponse(HTTP, 200, null);
httpResponse.setEntity(new StringEntity(getSchema()));
return httpResponse;
}
@Test
void find_whenProxyIsSetup() {
apiUrlProvider = new ApiUrlProviderImpl(ibanityHttpClient, API_ENDPOINT, PROXY_ENDPOINT);
String actual = apiUrlProvider.find(IbanityProduct.Xs2a, "customer", "financialInstitution", "accountInformationAccessRequest", "accounts");
assertThat(actual).isEqualTo(PROXY_ENDPOINT + "/xs2a/customer/financial-institutions/{financialInstitutionId}/account-information-access-requests/{accountInformationAccessRequestId}/accounts");
}
@Test
void find() {
apiUrlProvider = new ApiUrlProviderImpl(ibanityHttpClient, API_ENDPOINT);
String actual = apiUrlProvider.find(IbanityProduct.Xs2a, "customer", "financialInstitution", "accountInformationAccessRequest", "accounts");
assertThat(actual).isEqualTo(API_ENDPOINT + "/xs2a/customer/financial-institutions/{financialInstitutionId}/account-information-access-requests/{accountInformationAccessRequestId}/accounts");
}
@Test
void find_whenPathNotFound_throwIllegalArgumentException() {
apiUrlProvider = new ApiUrlProviderImpl(ibanityHttpClient, API_ENDPOINT, PROXY_ENDPOINT);
assertThatExceptionOfType(IllegalArgumentException.class).isThrownBy(() -> apiUrlProvider.find(IbanityProduct.Xs2a, "customer", "financiulInstitution", "accountInformationAccessRequest", "accounts"));
}
private String getSchema() {
//language=JSON
return "{\n" +
" \"links\": {\n" +
" \"customer\": {\n" +
" \"accounts\": \"https://api.ibanity.localhost/xs2a/customer/accounts\",\n" +
" \"financialInstitution\": {\n" +
" \"accountInformationAccessRequest\": {\n" +
" \"accounts\": \"https://api.ibanity.localhost/xs2a/customer/financial-institutions/{financialInstitutionId}/account-information-access-requests/{accountInformationAccessRequestId}/accounts\"\n" +
" },\n" +
" \"accountInformationAccessRequests\": \"https://api.ibanity.localhost/xs2a/customer/financial-institutions/{financialInstitutionId}/account-information-access-requests/{accountInformationAccessRequestId}\",\n" +
" \"accounts\": \"https://api.ibanity.localhost/xs2a/customer/financial-institutions/{financialInstitutionId}/accounts/{accountId}\",\n" +
" \"paymentInitiationRequests\": \"https://api.ibanity.localhost/xs2a/customer/financial-institutions/{financialInstitutionId}/payment-initiation-requests/{paymentInitiationRequestId}\",\n" +
" \"transactions\": \"https://api.ibanity.localhost/xs2a/customer/financial-institutions/{financialInstitutionId}/accounts/{accountId}/transactions/{transactionId}\"\n" +
" },\n" +
" \"financialInstitutions\": \"https://api.ibanity.localhost/xs2a/customer/financial-institutions\",\n" +
" \"self\": \"https://api.ibanity.localhost/xs2a/customer\",\n" +
" \"synchronizations\": \"https://api.ibanity.localhost/xs2a/customer/synchronizations/{synchronizationId}\"\n" +
" },\n" +
" \"customerAccessTokens\": \"https://api.ibanity.localhost/xs2a/customer-access-tokens\",\n" +
" \"financialInstitutions\": \"https://api.ibanity.localhost/xs2a/financial-institutions/{financialInstitutionId}\",\n" +
" \"sandbox\": {\n" +
" \"financialInstitution\": {\n" +
" \"financialInstitutionAccount\": {\n" +
" \"financialInstitutionTransactions\": \"https://api.ibanity.localhost/sandbox/financial-institutions/{financialInstitutionId}/financial-institution-users/{financialInstitutionUserId}/financial-institution-accounts/{financialInstitutionAccountId}/financial-institution-transactions/{financialInstitutionTransactionId}\"\n" +
" },\n" +
" \"financialInstitutionAccounts\": \"https://api.ibanity.localhost/sandbox/financial-institutions/{financialInstitutionId}/financial-institution-users/{financialInstitutionUserId}/financial-institution-accounts/{financialInstitutionAccountId}\"\n" +
" },\n" +
" \"financialInstitutionUsers\": \"https://api.ibanity.localhost/sandbox/financial-institution-users/{financialInstitutionUserId}\",\n" +
" \"financialInstitutions\": \"https://api.ibanity.localhost/sandbox/financial-institutions/{financialInstitutionId}\"\n" +
" }\n" +
" }\n" +
"}";
}
}
| 0 |
raw_data\ibanity-java\src\test\java\com\ibanity\apis\client | raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\utils\WebhooksUtilsTest.java | package com.ibanity.apis.client.utils;
import com.ibanity.apis.client.models.IbanityWebhookEvent;
import com.ibanity.apis.client.webhooks.models.ponto_connect.SynchronizationSucceededWithoutChange;
import org.junit.jupiter.api.Test;
import java.io.IOException;
import java.time.Instant;
import java.util.UUID;
import static com.ibanity.apis.client.helpers.IbanityTestHelper.loadFile;
import static org.assertj.core.api.Assertions.assertThat;
class WebhooksUtilsTest {
@Test
void webhookEventParser_xs2a() throws IOException {
String payload = loadFile("json/webhooks/xs2a/synchronizationSucceededWithoutChange.json");
IbanityWebhookEvent ibanityWebhookEvent = WebhooksUtils.webhookEventParser(payload, "xs2a.synchronization.succeededWithoutChange");
assertThat(ibanityWebhookEvent.getType()).isEqualTo(ibanityWebhookEvent.getType());
}
@Test
void webhookEventParser_pontoConnect() throws IOException {
String payload = loadFile("json/webhooks/ponto-connect/synchronizationSucceededWithoutChange.json");
IbanityWebhookEvent ibanityWebhookEvent = WebhooksUtils.webhookEventParser(payload, "pontoConnect.synchronization.succeededWithoutChange");
assertThat(ibanityWebhookEvent).isEqualTo(createExpectedWebhook()).usingRecursiveComparison();
}
private SynchronizationSucceededWithoutChange createExpectedWebhook() {
return SynchronizationSucceededWithoutChange.builder()
.type("pontoConnect.synchronization.succeededWithoutChange")
.synchronizationSubtype("accountDetails")
.accountId(UUID.fromString("12036924-f070-4832-8321-3fe18ba37480"))
.synchronizationId(UUID.fromString("cabf4560-6e4a-4790-8af6-4f4df4bf441b"))
.organizationId(UUID.fromString("429fd324-c238-4ee9-8420-01fa455cdcdc"))
.id(UUID.fromString("93f515c8-2edb-4b71-8a70-89b535c3c3cd"))
.createdAt(Instant.parse("2021-11-10T13:52:33.012Z"))
.build();
}
}
| 0 |
raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\webhooks\services | raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\webhooks\services\impl\KeysServiceImplTest.java | package com.ibanity.apis.client.webhooks.services.impl;
import com.ibanity.apis.client.http.IbanityHttpClient;
import com.ibanity.apis.client.services.ApiUrlProvider;
import com.ibanity.apis.client.utils.IbanityUtils;
import com.ibanity.apis.client.webhooks.models.Key;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import java.io.IOException;
import java.util.List;
import static com.ibanity.apis.client.helpers.IbanityTestHelper.loadFile;
import static com.ibanity.apis.client.helpers.IbanityTestHelper.loadHttpResponse;
import static com.ibanity.apis.client.utils.URIHelper.buildUri;
import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.when;
@ExtendWith({MockitoExtension.class})
class KeysServiceImplTest {
private static final String KEYS_ENDPOINT = "http://api.ibanity.com/webhooks/keys";
@InjectMocks
private KeysServiceImpl keysService;
@Mock
private ApiUrlProvider apiUrlProvider;
@Mock
private IbanityHttpClient ibanityHttpClient;
@Test
void listKeys() throws IOException {
when(apiUrlProvider.find("webhooks", "keys")).thenReturn(KEYS_ENDPOINT);
when(ibanityHttpClient.get(eq(buildUri(KEYS_ENDPOINT)))).thenReturn(loadHttpResponse("certificate/jwks.json"));
List<Key> actual = keysService.list();
assertThat(actual).containsExactly(expected());
}
private Key expected() throws IOException {
String jwk = loadFile("certificate/jwk.json");
return IbanityUtils.objectMapper().readValue(jwk, Key.class);
}
}
| 0 |
raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\webhooks\services | raw_data\ibanity-java\src\test\java\com\ibanity\apis\client\webhooks\services\impl\WebhooksServiceImplTest.java | package com.ibanity.apis.client.webhooks.services.impl;
import com.ibanity.apis.client.builders.IbanityConfiguration;
import com.ibanity.apis.client.exceptions.IbanityRuntimeException;
import com.ibanity.apis.client.factory.JwtConsumerFactory;
import com.ibanity.apis.client.http.IbanityHttpClient;
import com.ibanity.apis.client.models.IbanityWebhookEvent;
import com.ibanity.apis.client.services.ApiUrlProvider;
import com.ibanity.apis.client.webhooks.models.xs2a.SynchronizationSucceededWithoutChange;
import org.jose4j.jwa.AlgorithmConstraints;
import org.jose4j.jwk.JsonWebKeySet;
import org.jose4j.jwt.NumericDate;
import org.jose4j.jwt.consumer.JwtConsumer;
import org.jose4j.jwt.consumer.JwtConsumerBuilder;
import org.jose4j.keys.resolvers.JwksVerificationKeyResolver;
import org.jose4j.lang.JoseException;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import java.io.IOException;
import java.time.Instant;
import java.util.UUID;
import static com.ibanity.apis.client.helpers.IbanityTestHelper.loadFile;
import static org.assertj.core.api.Assertions.assertThat;
import static org.jose4j.jwa.AlgorithmConstraints.ConstraintType.PERMIT;
import static org.jose4j.jws.AlgorithmIdentifiers.RSA_USING_SHA512;
@ExtendWith({MockitoExtension.class})
public class WebhooksServiceImplTest {
private static final String JWT = "eyJhbGciOiJSUzUxMiIsImtpZCI6InZlcnlfc2VjdXJlX2tleV8xIn0.eyJhdWQiOiJhZjYxNzM2NS0xYzNmLTQzNTUtOWM4NC0wOWRiNzc1MTIwNWQiLCJkaWdlc3QiOiJyNDNZbHAxN3NjMWF4NWVybHlHaDZWMnBzWGVEVjBWUWM0eTk3cDRoWVVjaEYvS1pPbDVBcGxuL3ZYSkNZZC9maWpWUUZyL1QrSWpBVWtJWXJlcUx5QT09IiwiZXhwIjoxNjM2NTU0NDY0LCJpYXQiOjE2MzY1NTQ0MDQsImlzcyI6Imh0dHBzOi8vYXBpLmliYW5pdHkubG9jYWxob3N0IiwianRpIjoiOWZkODE3YmQtMTcwMC00YmIxLThhNzktNmYzYTc1OTE3ZmI3In0.NxrkGr0X7bYKuUtrDVyDl5GZpNVlcrVIfk6zEHsO6xYdXx78WFjKaZXwa0pATt2p152Ww4PlT262dE2B5KPvbuMvEs1On327IZPD7pgN8dweUgdZMqYj7t3zNo-qboRZhY1K2PU74Tcp4erBOKQYmffm5KSJzAmVPvHFIJgJslk6caRAPYMnS6vGXcTNRPcyNOcDrSq3YVbLvNMCnuGWRSTDB0OHxhDRXWTxdQ5_YihewenWI0GOE7NsbQqewFjmHWdIOiYcS8lAIeqcPxt4k_1lvRPM2cMCIJJ_aXQ_Kekit9i8ERWcvnLqGKMY7SHRiDq_uxO9ujgK4U5o_f_wMZCzKdqLpgEyQDUoUG6zAkqf4-9cEuHZtPir5zzZIOYvS_nOhOYJVfTQ49rW0Y6oIjqQgQziBfqYcK3l8ILt2eAL7nGoBwmihH37BWSiRwKz2UjqRT7RnAPerMtaWd9kfhdus-3UlxZfDqzrxkJYU9Liehc8BP74jyScyByXDxzlBOvftZ7VIKBFkSimmezDbDI76ob0XMCPXYTlq_8tyhQiAnfpRJJkDvJD-a-mWEzCAX8p8Aqf5dY2iVAkQDxCHcv3hc0GgSAlrCQ8H0rzY4BlbPKMw4RiOvPRCRQtXV8FEickFC_fJMMdads4DpK01QpBXQmJcAekIQA1HrfMniI";
private static final String AUDIENCE = "af617365-1c3f-4355-9c84-09db7751205d";
private static final int DATE_FROM_JWT_GENERATION = 1636554460;
private WebhooksServiceImpl webhooksSignatureService;
@Mock
private ApiUrlProvider apiUrlProvider;
@Mock
private IbanityHttpClient ibanityHttpClient;
@BeforeEach
void setUp() throws IOException, JoseException {
webhooksSignatureService = new WebhooksServiceImpl(apiUrlProvider, ibanityHttpClient, getJwtConsumer(AUDIENCE, false));
}
@Test
public void verify() throws Exception {
webhooksSignatureService.verify(payload(), JWT);
}
@Test
public void verifyAndParseEvent() throws Exception {
IbanityWebhookEvent webhooks = webhooksSignatureService.verifyAndParseEvent(payload(), JWT);
assertThat(webhooks).isInstanceOf(SynchronizationSucceededWithoutChange.class);
assertThat(webhooks).isEqualTo(createExpectedWebhook()).usingRecursiveComparison();
}
private SynchronizationSucceededWithoutChange createExpectedWebhook() {
return SynchronizationSucceededWithoutChange.builder()
.type("xs2a.synchronization.succeededWithoutChange")
.synchronizationSubtype("accountDetails")
.accountId(UUID.fromString("12036924-f070-4832-8321-3fe18ba37480"))
.synchronizationId(UUID.fromString("cabf4560-6e4a-4790-8af6-4f4df4bf441b"))
.id(UUID.fromString("93f515c8-2edb-4b71-8a70-89b535c3c3cd"))
.createdAt(Instant.parse("2021-11-10T13:52:33.012Z"))
.build();
}
@Test
public void verify_invalidDigest() {
IbanityRuntimeException thrown = Assertions.assertThrows(IbanityRuntimeException.class, () -> webhooksSignatureService.verify("{temperedPayload}", JWT));
assertThat(thrown.getMessage()).contains("Signature digest value mismatch.");
}
@Test
public void verify_invalidAudience() throws Exception {
webhooksSignatureService = new WebhooksServiceImpl(apiUrlProvider, ibanityHttpClient, getJwtConsumer("test-audience", false));
IbanityRuntimeException thrown = Assertions.assertThrows(IbanityRuntimeException.class, () -> webhooksSignatureService.verify(payload(), JWT));
assertThat(thrown.getMessage()).contains("Audience (aud) claim [af617365-1c3f-4355-9c84-09db7751205d] doesn't contain an acceptable identifier");
}
@Test
public void verify_Expiration() throws Exception {
webhooksSignatureService = new WebhooksServiceImpl(apiUrlProvider, ibanityHttpClient, getJwtConsumer(AUDIENCE, true));
IbanityRuntimeException thrown = Assertions.assertThrows(IbanityRuntimeException.class, () -> webhooksSignatureService.verify(payload(), JWT));
assertThat(thrown.getMessage()).contains("The JWT is no longer valid");
}
private JwtConsumer getJwtConsumer(String audience, boolean checkJwtExpiration) throws JoseException, IOException {
JwksVerificationKeyResolver mockedJwkResolver = getMockedJwkResolver();
if (checkJwtExpiration) {
IbanityConfiguration ibanityConfiguration = IbanityConfiguration.builder()
.applicationId(audience)
.build();
return JwtConsumerFactory.build(ibanityConfiguration, mockedJwkResolver);
} else {
return new JwtConsumerBuilder()
.setRequireExpirationTime()
.setRequireIssuedAt()
.setExpectedAudience(audience)
.setVerificationKeyResolver(mockedJwkResolver)
.setEvaluationTime(NumericDate.fromSeconds(DATE_FROM_JWT_GENERATION))
.setExpectedIssuers(true, "https://api.ibanity.localhost")
.setJwsAlgorithmConstraints(new AlgorithmConstraints(PERMIT, RSA_USING_SHA512)).build();
}
}
private JwksVerificationKeyResolver getMockedJwkResolver() throws IOException, JoseException {
String jwks = loadFile("certificate/jwks.json");
JsonWebKeySet jsonWebKeySet = new JsonWebKeySet(jwks);
return new JwksVerificationKeyResolver(jsonWebKeySet.getJsonWebKeys());
}
private String payload() throws IOException {
return loadFile("json/webhooks/xs2a/synchronizationSucceededWithoutChange.json").trim();
}
}
| 0 |
raw_data\ibanity-java\src\test\java\com\ibanity | raw_data\ibanity-java\src\test\java\com\ibanity\samples\AuthorizationSample.java | package com.ibanity.samples;
import com.ibanity.apis.client.products.xs2a.models.AccountInformationAccessRequest;
import com.ibanity.apis.client.products.xs2a.models.Authorization;
import com.ibanity.apis.client.products.xs2a.models.CustomerAccessToken;
import com.ibanity.apis.client.products.xs2a.models.FinancialInstitution;
import com.ibanity.apis.client.products.xs2a.models.create.AccountInformationAccessRequestCreationQuery;
import com.ibanity.apis.client.products.xs2a.models.create.AuthorizationCreationQuery;
import com.ibanity.apis.client.products.xs2a.models.create.AuthorizationPortalCreationQuery;
import com.ibanity.apis.client.products.xs2a.models.create.MetaRequestCreationQuery;
import com.ibanity.apis.client.products.xs2a.services.AccountInformationAccessRequestsService;
import com.ibanity.apis.client.products.xs2a.services.AuthorizationsService;
import com.ibanity.apis.client.services.IbanityService;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
public class AuthorizationSample {
private final AuthorizationsService authorizationsService;
private final AccountInformationAccessRequestsService accountInformationAccessRequestsService;
public AuthorizationSample(IbanityService ibanityService) {
accountInformationAccessRequestsService = ibanityService.xs2aService().accountInformationAccessRequestsService();
authorizationsService = ibanityService.xs2aService().authorizationsService();
}
public AccountInformationAccessRequest createAiar(
FinancialInstitution financialInstitution,
CustomerAccessToken customerAccessToken,
String consentReference, String redirectUrl) {
AccountInformationAccessRequestCreationQuery accountInformationAccessRequestCreationQuery =
AccountInformationAccessRequestCreationQuery.builder()
.customerAccessToken(customerAccessToken.getToken())
.financialInstitutionId(financialInstitution.getId())
.redirectUri(redirectUrl)
.consentReference(consentReference)
.allowFinancialInstitutionRedirectUri(true)
.customerIpAddress("1.1.1.1")
.allowedAccountSubtypes(Arrays.asList("checking", "savings", "securities"))
.skipIbanityCompletionCallback(true)
.state("myCustomState")
.metaRequestCreationQuery(MetaRequestCreationQuery.builder()
.authorizationPortalCreationQuery(AuthorizationPortalCreationQuery.builder()
.disclaimerContent("thisIsACusomOneContent")
.disclaimerTitle("thisIsACusomOneTitle")
.financialInstitutionPrimaryColor("#000000")
.financialInstitutionSecondaryColor("#000000")
.build())
.build())
.build();
return accountInformationAccessRequestsService.create(accountInformationAccessRequestCreationQuery);
}
public Authorization create(AccountInformationAccessRequest accountInformationAccessRequest, FinancialInstitution financialInstitution, CustomerAccessToken customerAccessToken, String code) {
Map<String, String> authorizationCode = new HashMap<>();
authorizationCode.put("code", code);
AuthorizationCreationQuery authorizationCreationQuery = AuthorizationCreationQuery.builder()
.accountInformationAccessRequestId(accountInformationAccessRequest.getId())
.customerAccessToken(customerAccessToken.getToken())
.financialInstitutionId(financialInstitution.getId())
.queryParameters(authorizationCode)
.build();
return authorizationsService.create(authorizationCreationQuery);
}
}
| 0 |
raw_data\ibanity-java\src\test\java\com\ibanity | raw_data\ibanity-java\src\test\java\com\ibanity\samples\ClientSample.java | package com.ibanity.samples;
import com.ibanity.apis.client.builders.IbanityServiceBuilder;
import com.ibanity.apis.client.builders.OptionalPropertiesBuilder;
import com.ibanity.apis.client.helpers.IbanityClientSecuritySignaturePropertiesKeys;
import com.ibanity.apis.client.products.xs2a.models.*;
import com.ibanity.apis.client.products.xs2a.models.read.FinancialInstitutionCountriesReadQuery;
import com.ibanity.apis.client.services.IbanityService;
import com.ibanity.samples.customer.*;
import com.ibanity.samples.helper.SampleHelper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.IOException;
import java.security.PrivateKey;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.List;
import java.util.UUID;
import static com.ibanity.apis.client.helpers.IbanityClientSecurityAuthenticationPropertiesKeys.*;
import static com.ibanity.apis.client.helpers.IbanityClientSecuritySignaturePropertiesKeys.*;
import static com.ibanity.apis.client.helpers.IbanityConfiguration.IBANITY_API_ENDPOINT_PROPERTY_KEY;
import static com.ibanity.apis.client.helpers.IbanityConfiguration.getConfiguration;
import static com.ibanity.samples.helper.SampleHelper.*;
public class ClientSample {
private static final Logger LOGGER = LoggerFactory.getLogger(ClientSample.class);
private final CustomerAccessTokenSample customerAccessTokenSample;
private final FinancialInstitutionSample financialInstitutionSample;
private final AccountInformationAccessRequestSample accountInformationAccessRequestSample;
private final AccountSample accountSample;
private final TransactionSample transactionSample;
private final PaymentInitiationRequestSample paymentInitiationRequestSample;
private final SynchronizationSample synchronizationSample;
private final CustomerSample customerSample;
private final AuthorizationSample authorizationSample;
private final HoldingSample holdingSample;
// Configurations
private final String fakeTppAccountInformationAccessRedirectUrl = getConfiguration("tpp.account-information-access-result.redirect-url");
private final String fakeTppPaymentInitiationRedirectUrl = getConfiguration("tpp.payment-initiation-result.redirect-url");
public ClientSample(IbanityService ibanityService) {
customerAccessTokenSample = new CustomerAccessTokenSample(ibanityService);
financialInstitutionSample = new FinancialInstitutionSample(ibanityService);
accountInformationAccessRequestSample = new AccountInformationAccessRequestSample(ibanityService);
accountSample = new AccountSample(ibanityService);
transactionSample = new TransactionSample(ibanityService);
paymentInitiationRequestSample = new PaymentInitiationRequestSample(ibanityService);
synchronizationSample = new SynchronizationSample(ibanityService);
customerSample = new CustomerSample(ibanityService);
authorizationSample = new AuthorizationSample(ibanityService);
holdingSample = new HoldingSample(ibanityService);
}
public static void main(String[] args) throws CertificateException, IOException {
String passphrase = getConfiguration(IBANITY_CLIENT_TLS_PRIVATE_KEY_PASSPHRASE_PROPERTY_KEY);
PrivateKey privateKey = loadPrivateKey(getConfiguration(IBANITY_CLIENT_TLS_PRIVATE_KEY_PATH_PROPERTY_KEY), passphrase);
X509Certificate certificate = loadCertificate(getConfiguration(IBANITY_CLIENT_TLS_CERTIFICATE_PATH_PROPERTY_KEY));
OptionalPropertiesBuilder ibanityServiceBuilder = IbanityServiceBuilder.builder()
.ibanityApiEndpoint(getConfiguration(IBANITY_API_ENDPOINT_PROPERTY_KEY))
.tlsPrivateKey(privateKey)
.passphrase(passphrase)
.tlsCertificate(certificate)
.withHttpRequestInterceptors((request, context) -> LOGGER.info("This is a HttpRequestInterceptor"))
.withHttpResponseInterceptors((response, context) -> LOGGER.info("This is a HttpResponseInterceptor"))
.connectTimeout(10_000)
.socketTimeout(60_000)
.connectionRequestTimeout(10_000)
;
if (getConfiguration(IBANITY_CLIENT_TLS_CA_CERTIFICATE_PATH_PROPERTY_KEY) != null) {
ibanityServiceBuilder.caCertificate(loadCa(getConfiguration(IBANITY_CLIENT_TLS_CA_CERTIFICATE_PATH_PROPERTY_KEY)));
}
if (getConfiguration(IbanityClientSecuritySignaturePropertiesKeys.IBANITY_CLIENT_SIGNATURE_CERTIFICATE_ID_PROPERTY_KEY) != null) {
String signaturePassphrase = getConfiguration(IBANITY_CLIENT_SIGNATURE_PRIVATE_KEY_PASSPHRASE_PROPERTY_KEY, "");
ibanityServiceBuilder
.requestSignaturePrivateKey(loadPrivateKey(getConfiguration(IBANITY_CLIENT_SIGNATURE_PRIVATE_KEY_PATH_PROPERTY_KEY), signaturePassphrase))
.requestSignaturePassphrase(signaturePassphrase)
.requestSignatureCertificate(loadCertificate(getConfiguration(IBANITY_CLIENT_SIGNATURE_CERTIFICATE_PATH_PROPERTY_KEY)))
.signatureCertificateId(getConfiguration(IBANITY_CLIENT_SIGNATURE_CERTIFICATE_ID_PROPERTY_KEY));
}
IbanityService ibanityService = ibanityServiceBuilder.build();
ClientSample clientSample = new ClientSample(ibanityService);
CustomerAccessToken customerAccessToken = clientSample.customerAccessTokenSamples();
List<FinancialInstitution> financialInstitutions = clientSample.financialInstitutionSamples();
List<FinancialInstitutionCountry> financialInstitutionCountries = clientSample.financialInstitutionCountrySamples(ibanityService);
clientSample.accountInformationAccessRequestSamples(customerAccessToken, financialInstitutions);
Authorization authorization = clientSample.authorizationSamples(customerAccessToken, financialInstitutions);
LOGGER.info("Authorization: {}", authorization);
List<Account> accounts = clientSample.accountSamples(customerAccessToken, financialInstitutions);
List<Transaction> transactions = clientSample.transactionSamples(customerAccessToken, financialInstitutions, accounts);
List<Holding> holdings = clientSample.holdingSample(customerAccessToken, financialInstitutions, accounts);
Synchronization synchronization = clientSample.synchronizationSamples(customerAccessToken, accounts);
PaymentInitiationRequest paymentInitiationRequest = clientSample.paymentInitiationRequestSamples();
LOGGER.info("List of financialInstitutionCountries: {}", financialInstitutionCountries);
LOGGER.info("List of financialInstitutions: {}", financialInstitutions);
LOGGER.info("List of accounts: {}", accounts);
LOGGER.info("List of transactions: {}", transactions);
LOGGER.info("List of holdings: {}", holdings);
LOGGER.info("synchronization: {}", synchronization);
LOGGER.info("paymentInitiationRequest: {}", paymentInitiationRequest);
clientSample.customerSamples(customerAccessToken);
LOGGER.info("Samples end");
}
private List<FinancialInstitutionCountry> financialInstitutionCountrySamples(IbanityService ibanityService) {
return ibanityService.xs2aService().financialInstitutionCountriesService()
.list(FinancialInstitutionCountriesReadQuery.builder()
.build())
.getItems();
}
private Customer customerSamples(CustomerAccessToken customerAccessToken) {
return customerSample.delete(customerAccessToken);
}
private Synchronization synchronizationSamples(CustomerAccessToken customerAccessToken, List<Account> accounts) {
Account account = accounts.get(0);
Synchronization synchronization = synchronizationSample.create(customerAccessToken, account.getId());
synchronization = synchronizationSample.find(customerAccessToken, synchronization.getId());
return synchronization;
}
public CustomerAccessToken customerAccessTokenSamples() {
LOGGER.info("Customer Access Token samples");
String consentReference = "application_customer_reference-" + UUID.randomUUID().toString();
return customerAccessTokenSample.create(consentReference);
}
public List<FinancialInstitution> financialInstitutionSamples() {
LOGGER.info("Financial Institution samples");
return financialInstitutionSample.list();
}
public AccountInformationAccessRequest accountInformationAccessRequestSamples(CustomerAccessToken customerAccessToken, List<FinancialInstitution> financialInstitutions) {
LOGGER.info("Account Information Access Request samples");
String consentReference = "application_customer_reference-" + UUID.randomUUID().toString();
AccountInformationAccessRequest accountInformationAccessRequest =
this.accountInformationAccessRequestSample.create(
financialInstitutions.get(0), customerAccessToken,
consentReference, fakeTppAccountInformationAccessRedirectUrl);
SampleHelper.waitForAuthorizationWebFlow(accountInformationAccessRequest);
accountInformationAccessRequest = accountInformationAccessRequestSample.find(accountInformationAccessRequest, financialInstitutions.get(0), customerAccessToken);
return accountInformationAccessRequest;
}
public Authorization authorizationSamples(CustomerAccessToken customerAccessToken, List<FinancialInstitution> financialInstitutions) {
LOGGER.info("Authorization samples");
String consentReference = "application_customer_reference-" + UUID.randomUUID().toString();
FinancialInstitution financialInstitution = financialInstitutions.get(0);
AccountInformationAccessRequest accountInformationAccessRequest =
authorizationSample.createAiar(financialInstitution, customerAccessToken, consentReference, fakeTppAccountInformationAccessRedirectUrl);
String code = waitForAuthorizationWebFlow(accountInformationAccessRequest);
return authorizationSample.create(accountInformationAccessRequest, financialInstitution, customerAccessToken, code);
}
public List<Account> accountSamples(CustomerAccessToken customerAccessToken, List<FinancialInstitution> financialInstitutions) {
LOGGER.info("Accounts samples");
FinancialInstitution financialInstitution = financialInstitutions.get(0);
List<Account> accounts = accountSample.list(customerAccessToken, financialInstitution).getItems();
accountSample.get(customerAccessToken, financialInstitution, accounts.get(0).getId());
return accounts;
}
public List<Transaction> transactionSamples(CustomerAccessToken customerAccessToken, List<FinancialInstitution> financialInstitutionList, List<Account> accountList) {
LOGGER.info("Transactions samples");
FinancialInstitution financialInstitution = financialInstitutionList.get(0);
Account account = accountList.get(0);
List<Transaction> transactions = transactionSample.list(customerAccessToken, financialInstitution, account);
transactionSample.get(customerAccessToken, financialInstitution, account, transactions.get(0).getId());
return transactions;
}
public List<Holding> holdingSample(CustomerAccessToken customerAccessToken, List<FinancialInstitution> financialInstitutionList, List<Account> accountList) {
LOGGER.info("Holdings samples");
FinancialInstitution financialInstitution = financialInstitutionList.get(0);
Account account = accountList.stream().filter(account1 -> account1.getSubtype().equalsIgnoreCase("securities")).findFirst().get();
List<Holding> holdings = holdingSample.list(customerAccessToken, financialInstitution, account);
holdingSample.get(customerAccessToken, financialInstitution, account, holdings.get(0).getId());
return holdings;
}
public PaymentInitiationRequest paymentInitiationRequestSamples() {
LOGGER.info("Payment Initiation Request samples");
String consentReference = "application_customer_reference-" + UUID.randomUUID().toString();
CustomerAccessToken customerAccessToken = customerAccessTokenSample.create(consentReference);
FinancialInstitution financialInstitution = financialInstitutionSample.list().get(0);
return paymentInitiationRequestSample.create(financialInstitution, customerAccessToken, fakeTppPaymentInitiationRedirectUrl);
}
}
| 0 |
raw_data\ibanity-java\src\test\java\com\ibanity | raw_data\ibanity-java\src\test\java\com\ibanity\samples\ClientSandboxSample.java | package com.ibanity.samples;
import com.ibanity.apis.client.builders.IbanityServiceBuilder;
import com.ibanity.apis.client.builders.OptionalPropertiesBuilder;
import com.ibanity.apis.client.helpers.IbanityClientSecuritySignaturePropertiesKeys;
import com.ibanity.apis.client.products.xs2a.models.FinancialInstitution;
import com.ibanity.apis.client.products.xs2a.sandbox.models.FinancialInstitutionAccount;
import com.ibanity.apis.client.products.xs2a.sandbox.models.FinancialInstitutionHolding;
import com.ibanity.apis.client.products.xs2a.sandbox.models.FinancialInstitutionTransaction;
import com.ibanity.apis.client.products.xs2a.sandbox.models.FinancialInstitutionUser;
import com.ibanity.apis.client.services.IbanityService;
import com.ibanity.samples.sandbox.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.IOException;
import java.security.cert.CertificateException;
import static com.ibanity.apis.client.helpers.IbanityClientSecurityAuthenticationPropertiesKeys.*;
import static com.ibanity.apis.client.helpers.IbanityClientSecuritySignaturePropertiesKeys.*;
import static com.ibanity.apis.client.helpers.IbanityConfiguration.IBANITY_API_ENDPOINT_PROPERTY_KEY;
import static com.ibanity.apis.client.helpers.IbanityConfiguration.getConfiguration;
import static com.ibanity.samples.helper.SampleHelper.*;
public class ClientSandboxSample {
private static final Logger LOGGER = LoggerFactory.getLogger(ClientSandboxSample.class);
private final FinancialInstitutionSample financialInstitutionSample;
private final FinancialInstitutionUserSample financialInstitutionUserSample;
private final FinancialInstitutionAccountSample financialInstitutionAccountSample;
private final FinancialInstitutionTransactionSample financialInstitutionTransactionSample;
private final FinancialInstitutionHoldingSample financialInstitutionHoldingSample;
public ClientSandboxSample(IbanityService ibanityService) {
financialInstitutionSample = new FinancialInstitutionSample(ibanityService);
financialInstitutionUserSample = new FinancialInstitutionUserSample(ibanityService);
financialInstitutionAccountSample = new FinancialInstitutionAccountSample(ibanityService);
financialInstitutionTransactionSample = new FinancialInstitutionTransactionSample(ibanityService);
financialInstitutionHoldingSample = new FinancialInstitutionHoldingSample(ibanityService);
}
public static void main(String[] args) throws CertificateException, IOException {
String passphrase = getConfiguration(IBANITY_CLIENT_TLS_PRIVATE_KEY_PASSPHRASE_PROPERTY_KEY);
OptionalPropertiesBuilder ibanityServiceBuilder = IbanityServiceBuilder.builder()
.ibanityApiEndpoint(getConfiguration(IBANITY_API_ENDPOINT_PROPERTY_KEY))
.tlsPrivateKey(loadPrivateKey(getConfiguration(IBANITY_CLIENT_TLS_PRIVATE_KEY_PATH_PROPERTY_KEY), passphrase))
.passphrase(passphrase)
.tlsCertificate(loadCertificate(getConfiguration(IBANITY_CLIENT_TLS_CERTIFICATE_PATH_PROPERTY_KEY)))
.caCertificate(loadCa(getConfiguration(IBANITY_CLIENT_TLS_CA_CERTIFICATE_PATH_PROPERTY_KEY)));
if (getConfiguration(IbanityClientSecuritySignaturePropertiesKeys.IBANITY_CLIENT_SIGNATURE_CERTIFICATE_ID_PROPERTY_KEY) != null) {
String signaturePassphrase = getConfiguration(IBANITY_CLIENT_SIGNATURE_PRIVATE_KEY_PASSPHRASE_PROPERTY_KEY, "");
ibanityServiceBuilder
.requestSignaturePrivateKey(loadPrivateKey(getConfiguration(IBANITY_CLIENT_SIGNATURE_PRIVATE_KEY_PATH_PROPERTY_KEY), signaturePassphrase))
.requestSignaturePassphrase(signaturePassphrase)
.requestSignatureCertificate(loadCertificate(getConfiguration(IBANITY_CLIENT_SIGNATURE_CERTIFICATE_PATH_PROPERTY_KEY)))
.signatureCertificateId(getConfiguration(IBANITY_CLIENT_SIGNATURE_CERTIFICATE_ID_PROPERTY_KEY));
}
IbanityService ibanityService = ibanityServiceBuilder.build();
ClientSandboxSample clientSandboxSample = new ClientSandboxSample(ibanityService);
FinancialInstitution financialInstitution = clientSandboxSample.financialInstitutionSamples();
LOGGER.info("Financial institution {}", financialInstitution);
FinancialInstitutionUser financialInstitutionUser = clientSandboxSample.financialInstitutionUserSamples();
LOGGER.info("Financial institution user {}", financialInstitutionUser);
FinancialInstitutionAccount financialInstitutionAccount = clientSandboxSample.financialInstitutionAccountSamples();
LOGGER.info("Financial institution account {}", financialInstitutionAccount);
FinancialInstitutionTransaction financialInstitutionTransaction = clientSandboxSample.financialInstitutionTransactionSamples();
LOGGER.info("Financial institution transaction {}", financialInstitutionTransaction);
FinancialInstitutionHolding financialInstitutionHoldingSamples = clientSandboxSample.financialInstitutionHoldingSamples();
LOGGER.info("Financial institution holding {}", financialInstitutionHoldingSamples);
LOGGER.info("Samples end");
}
public FinancialInstitution financialInstitutionSamples() {
LOGGER.info("Financial Institution samples");
FinancialInstitution financialInstitution = financialInstitutionSample.create();
FinancialInstitution update = financialInstitutionSample.update(financialInstitution);
financialInstitutionSample.find(financialInstitution.getId());
deleteFinancialInstitution(financialInstitution);
return financialInstitution;
}
private void deleteFinancialInstitution(FinancialInstitution financialInstitution) {
financialInstitutionSample.delete(financialInstitution);
}
public FinancialInstitutionUser financialInstitutionUserSamples() {
LOGGER.info("Financial Institution User samples");
FinancialInstitutionUser financialInstitutionUser = financialInstitutionUserSample.create();
FinancialInstitutionUser update = financialInstitutionUserSample.update(financialInstitutionUser);
financialInstitutionUserSample.find(financialInstitutionUser.getId());
financialInstitutionUserSample.delete(financialInstitutionUser);
return financialInstitutionUser;
}
public FinancialInstitutionAccount financialInstitutionAccountSamples() {
LOGGER.info("Financial Institution Account samples");
// create related objects
FinancialInstitution financialInstitution = financialInstitutionSample.create();
FinancialInstitutionUser financialInstitutionUser = financialInstitutionUserSample.create();
FinancialInstitutionAccount financialInstitutionAccount =
financialInstitutionAccountSample.create(financialInstitution, financialInstitutionUser);
financialInstitutionAccountSample.find(financialInstitution, financialInstitutionUser, financialInstitutionAccount.getId());
FinancialInstitutionAccount delete = financialInstitutionAccountSample.delete(financialInstitution, financialInstitutionUser, financialInstitutionAccount);
// clean related objects
deleteFinancialInstitution(financialInstitution);
financialInstitutionUserSample.delete(financialInstitutionUser);
return financialInstitutionAccount;
}
public FinancialInstitutionTransaction financialInstitutionTransactionSamples() {
LOGGER.info("Financial Institution Transaction samples");
// create related objects
FinancialInstitution financialInstitution = financialInstitutionSample.create();
FinancialInstitutionUser financialInstitutionUser = financialInstitutionUserSample.create();
FinancialInstitutionAccount financialInstitutionAccount =
financialInstitutionAccountSample.create(financialInstitution, financialInstitutionUser);
FinancialInstitutionTransaction financialInstitutionTransaction =
this.financialInstitutionTransactionSample.create(financialInstitution, financialInstitutionUser, financialInstitutionAccount);
this.financialInstitutionTransactionSample.find(financialInstitution, financialInstitutionUser,
financialInstitutionAccount, financialInstitutionTransaction.getId());
this.financialInstitutionTransactionSample.delete(financialInstitution, financialInstitutionUser,
financialInstitutionAccount, financialInstitutionTransaction);
// clean related objects
this.financialInstitutionAccountSample.delete(financialInstitution, financialInstitutionUser, financialInstitutionAccount);
deleteFinancialInstitution(financialInstitution);
this.financialInstitutionUserSample.delete(financialInstitutionUser);
return financialInstitutionTransaction;
}
public FinancialInstitutionHolding financialInstitutionHoldingSamples() {
LOGGER.info("Financial Institution Holding samples");
FinancialInstitution financialInstitution = financialInstitutionSample.create();
FinancialInstitutionUser financialInstitutionUser = financialInstitutionUserSample.create();
FinancialInstitutionAccount financialInstitutionAccount =
financialInstitutionAccountSample.create(financialInstitution, financialInstitutionUser);
FinancialInstitutionHolding financialInstitutionHolding =
financialInstitutionHoldingSample.create(financialInstitution, financialInstitutionUser, financialInstitutionAccount);
financialInstitutionHoldingSample.find(financialInstitution, financialInstitutionUser,
financialInstitutionAccount, financialInstitutionHolding.getId());
financialInstitutionHoldingSample.delete(financialInstitution, financialInstitutionUser,
financialInstitutionAccount, financialInstitutionHolding);
// clean related objects
this.financialInstitutionAccountSample.delete(financialInstitution, financialInstitutionUser, financialInstitutionAccount);
deleteFinancialInstitution(financialInstitution);
this.financialInstitutionUserSample.delete(financialInstitutionUser);
return financialInstitutionHolding;
}
}
| 0 |
raw_data\ibanity-java\src\test\java\com\ibanity | raw_data\ibanity-java\src\test\java\com\ibanity\samples\CustomerSample.java | package com.ibanity.samples;
import com.ibanity.apis.client.products.xs2a.models.Customer;
import com.ibanity.apis.client.products.xs2a.models.CustomerAccessToken;
import com.ibanity.apis.client.products.xs2a.models.delete.CustomerDeleteQuery;
import com.ibanity.apis.client.products.xs2a.services.CustomerService;
import com.ibanity.apis.client.services.IbanityService;
public class CustomerSample {
private final CustomerService customerService;
public CustomerSample(IbanityService ibanityService) {
customerService = ibanityService.xs2aService().customerService();
}
public Customer delete(CustomerAccessToken customerAccessToken) {
return customerService.delete(CustomerDeleteQuery.builder()
.customerAccessToken(customerAccessToken.getToken())
.build());
}
}
| 0 |
raw_data\ibanity-java\src\test\java\com\ibanity | raw_data\ibanity-java\src\test\java\com\ibanity\samples\IsabelConnectClientSample.java | package com.ibanity.samples;
import com.ibanity.apis.client.builders.IbanityServiceBuilder;
import com.ibanity.apis.client.builders.OptionalPropertiesBuilder;
import com.ibanity.apis.client.helpers.IbanityClientSecuritySignaturePropertiesKeys;
import com.ibanity.apis.client.models.IsabelCollection;
import com.ibanity.apis.client.products.isabel_connect.models.*;
import com.ibanity.apis.client.products.isabel_connect.models.create.AccessTokenCreateQuery;
import com.ibanity.apis.client.products.isabel_connect.models.create.BulkPaymentInitiationRequestCreateQuery;
import com.ibanity.apis.client.products.isabel_connect.models.create.InitialTokenCreateQuery;
import com.ibanity.apis.client.products.isabel_connect.models.read.*;
import com.ibanity.apis.client.products.isabel_connect.services.*;
import org.apache.commons.io.IOUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.File;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.security.cert.CertificateException;
import java.time.LocalDate;
import static com.ibanity.apis.client.helpers.IbanityClientSecurityAuthenticationPropertiesKeys.*;
import static com.ibanity.apis.client.helpers.IbanityClientSecuritySignaturePropertiesKeys.*;
import static com.ibanity.apis.client.helpers.IbanityConfiguration.IBANITY_API_ENDPOINT_PROPERTY_KEY;
import static com.ibanity.apis.client.helpers.IbanityConfiguration.getConfiguration;
import static com.ibanity.samples.helper.SampleHelper.loadCertificate;
import static com.ibanity.samples.helper.SampleHelper.loadPrivateKey;
public class IsabelConnectClientSample {
private static final Logger LOGGER = LoggerFactory.getLogger(IsabelConnectClientSample.class);
private static final String clientId = getConfiguration("isabel-connect.oauth2.client_id");
private static final String clientSecret = getConfiguration("isabel-connect.oauth2.client_secret");
private static final String authorizationCode = getConfiguration("isabel-connect.oauth2.authorization_code");
private static final String redirectUrl = getConfiguration("isabel-connect.oauth2.redirect_url");
private static final String bulkPaymentFile = getConfiguration("isabel-connect.bulk_payment.file");
private static final String bulkPaymentFilename = getConfiguration("isabel-connect.bulk_payment.file_name");
private static String reportId;
private static String accountId;
public static void main(String[] args) throws CertificateException, IOException {
String passphrase = getConfiguration(IBANITY_CLIENT_TLS_PRIVATE_KEY_PASSPHRASE_PROPERTY_KEY);
OptionalPropertiesBuilder ibanityServiceBuilder = IbanityServiceBuilder.builder()
.ibanityApiEndpoint(getConfiguration(IBANITY_API_ENDPOINT_PROPERTY_KEY))
.tlsPrivateKey(loadPrivateKey(getConfiguration(IBANITY_CLIENT_TLS_PRIVATE_KEY_PATH_PROPERTY_KEY), passphrase))
.passphrase(passphrase)
.tlsCertificate(loadCertificate(getConfiguration(IBANITY_CLIENT_TLS_CERTIFICATE_PATH_PROPERTY_KEY)))
.caCertificate(loadCertificate(getConfiguration(IBANITY_CLIENT_TLS_CA_CERTIFICATE_PATH_PROPERTY_KEY)));
if (getConfiguration(IbanityClientSecuritySignaturePropertiesKeys.IBANITY_CLIENT_SIGNATURE_CERTIFICATE_ID_PROPERTY_KEY) != null) {
String signaturePassphrase = getConfiguration(IBANITY_CLIENT_SIGNATURE_PRIVATE_KEY_PASSPHRASE_PROPERTY_KEY, "");
ibanityServiceBuilder
.requestSignaturePrivateKey(loadPrivateKey(getConfiguration(IBANITY_CLIENT_SIGNATURE_PRIVATE_KEY_PATH_PROPERTY_KEY), signaturePassphrase))
.requestSignaturePassphrase(signaturePassphrase)
.requestSignatureCertificate(loadCertificate(getConfiguration(IBANITY_CLIENT_SIGNATURE_CERTIFICATE_PATH_PROPERTY_KEY)))
.signatureCertificateId(getConfiguration(IBANITY_CLIENT_SIGNATURE_CERTIFICATE_ID_PROPERTY_KEY));
}
IsabelConnectService isabelConnectService = ibanityServiceBuilder
.isabelConnectOauth2ClientId(clientId)
.build()
.isabelConnectService();
AccessToken token = createToken(isabelConnectService.tokenService());
listAccountReports(isabelConnectService.accountReportService(), token);
getAccountReport(isabelConnectService.accountReportService(), token);
listAccounts(isabelConnectService.accountService(), token);
getAccount(isabelConnectService.accountService(), token);
listBalances(isabelConnectService.balanceService(), token);
listTransactions(isabelConnectService.transactionService(), token);
listIntradayTransactions(isabelConnectService.intradayTransactionService(), token);
createBulkPaymentInitiationRequest(isabelConnectService.bulkPaymentInitiationRequestService(), token);
}
private static BulkPaymentInitiationRequest createBulkPaymentInitiationRequest(
BulkPaymentInitiationRequestService bpir,
AccessToken token) {
LOGGER.info("Bulk payments");
BulkPaymentInitiationRequestCreateQuery query = BulkPaymentInitiationRequestCreateQuery.builder()
.accessToken(token.getAccessToken())
.filename(bulkPaymentFilename)
.file(new File(bulkPaymentFile))
.build();
return bpir.create(query);
}
private static AccessToken createToken(TokenService tokenService) {
LOGGER.info("Token samples");
InitialToken initialToken = tokenService.create(InitialTokenCreateQuery.builder()
.authorizationCode(authorizationCode)
.redirectUri(redirectUrl)
.clientSecret(clientSecret)
.build());
LOGGER.info("InitialToken {}", initialToken);
AccessToken accessToken = tokenService.create(AccessTokenCreateQuery.builder()
.clientSecret(clientSecret)
.refreshToken(initialToken.getRefreshToken())
.build());
LOGGER.info("AccessToken {}", accessToken);
return accessToken;
}
private static void listAccountReports(AccountReportService accountReportService, AccessToken token) {
LOGGER.info("List account reports");
AccountReportsReadQuery query = AccountReportsReadQuery.builder()
.accessToken(token.getAccessToken())
.build();
IsabelCollection<AccountReport> reports = accountReportService.list(query);
reportId = reports.getItems().stream().findFirst().get().getId();
LOGGER.info("Account reports {}", reports);
}
private static void getAccountReport(AccountReportService service, AccessToken token) {
LOGGER.info("Account reports");
AccountReportReadQuery query = AccountReportReadQuery.builder()
.accessToken(token.getAccessToken())
.accountReportId(reportId)
.build();
String content = service.find(query, resp -> {
try {
return IOUtils.toString(resp.getEntity().getContent(), StandardCharsets.UTF_8);
} catch (IOException e) {
throw new IllegalStateException(e);
}
});
LOGGER.info("Account report {}", content);
}
private static void listAccounts(AccountService service, AccessToken token) {
LOGGER.info("List accounts");
AccountsReadQuery query = AccountsReadQuery.builder()
.accessToken(token.getAccessToken())
.build();
IsabelCollection<Account> accounts = service.list(query);
accountId = accounts.getItems().stream().findFirst().get().getId();
LOGGER.info("Accounts {}", accounts);
}
private static void getAccount(AccountService service, AccessToken token) {
LOGGER.info("Get account");
AccountReadQuery query = AccountReadQuery.builder()
.accessToken(token.getAccessToken())
.accountId(accountId)
.build();
Account account = service.find(query);
LOGGER.info("Account {}", account);
}
private static void listBalances(BalanceService service, AccessToken token) {
LOGGER.info("List balances");
LocalDate today = LocalDate.now();
BalancesReadQuery query = BalancesReadQuery.builder()
.accessToken(token.getAccessToken())
.accountId(accountId)
.pagingSpec(IsabelPagingSpec.builder()
.from(today.minusDays(15))
.to(today).build())
.build();
IsabelCollection<Balance> balances = service.list(query);
LOGGER.info("Balances: {}", balances);
}
private static void listTransactions(TransactionService service, AccessToken token) {
LOGGER.info("List transactions");
LocalDate now = LocalDate.now();
TransactionsReadQuery query = TransactionsReadQuery.builder()
.accessToken(token.getAccessToken())
.accountId(accountId)
.pagingSpec(IsabelPagingSpec.builder()
.from(now.minusDays(60))
.to(now).build())
.build();
IsabelCollection<Transaction> transactions = service.list(query);
LOGGER.info("Transactions {}", transactions);
}
private static void listIntradayTransactions(IntradayTransactionService service, AccessToken token) {
LOGGER.info("List transactions");
IntradayTransactionsReadQuery query = IntradayTransactionsReadQuery.builder()
.accessToken(token.getAccessToken())
.accountId(accountId)
.build();
IsabelCollection<IntradayTransaction> transactions = service.list(query);
LOGGER.info("Intraday transactions {}", transactions);
}
}
| 0 |
raw_data\ibanity-java\src\test\java\com\ibanity | raw_data\ibanity-java\src\test\java\com\ibanity\samples\PontoConnectClientSample.java | package com.ibanity.samples;
import com.ibanity.apis.client.builders.IbanityServiceBuilder;
import com.ibanity.apis.client.builders.OptionalPropertiesBuilder;
import com.ibanity.apis.client.helpers.IbanityClientSecuritySignaturePropertiesKeys;
import com.ibanity.apis.client.models.IbanityCollection;
import com.ibanity.apis.client.products.ponto_connect.models.*;
import com.ibanity.apis.client.products.ponto_connect.models.create.BulkPaymentCreateQuery;
import com.ibanity.apis.client.products.ponto_connect.models.create.PaymentCreateQuery;
import com.ibanity.apis.client.products.ponto_connect.models.create.SynchronizationCreateQuery;
import com.ibanity.apis.client.products.ponto_connect.models.create.TokenCreateQuery;
import com.ibanity.apis.client.products.ponto_connect.models.delete.BulkPaymentDeleteQuery;
import com.ibanity.apis.client.products.ponto_connect.models.delete.PaymentDeleteQuery;
import com.ibanity.apis.client.products.ponto_connect.models.read.*;
import com.ibanity.apis.client.products.ponto_connect.models.refresh.TokenRefreshQuery;
import com.ibanity.apis.client.products.ponto_connect.models.revoke.TokenRevokeQuery;
import com.ibanity.apis.client.products.ponto_connect.sandbox.models.FinancialInstitutionAccount;
import com.ibanity.apis.client.products.ponto_connect.sandbox.models.FinancialInstitutionTransaction;
import com.ibanity.apis.client.products.ponto_connect.sandbox.models.factory.create.FinancialInstitutionTransactionCreationQuery;
import com.ibanity.apis.client.products.ponto_connect.sandbox.models.factory.read.FinancialInstitutionAccountReadQuery;
import com.ibanity.apis.client.products.ponto_connect.sandbox.models.factory.read.FinancialInstitutionAccountsReadQuery;
import com.ibanity.apis.client.products.ponto_connect.sandbox.models.factory.read.FinancialInstitutionTransactionReadQuery;
import com.ibanity.apis.client.products.ponto_connect.sandbox.models.factory.read.FinancialInstitutionTransactionsReadQuery;
import com.ibanity.apis.client.products.ponto_connect.sandbox.models.factory.update.FinancialInstitutionTransactionUpdateQuery;
import com.ibanity.apis.client.products.ponto_connect.sandbox.services.FinancialInstitutionAccountsService;
import com.ibanity.apis.client.products.ponto_connect.sandbox.services.FinancialInstitutionTransactionsService;
import com.ibanity.apis.client.products.ponto_connect.sandbox.services.SandboxService;
import com.ibanity.apis.client.products.ponto_connect.services.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.IOException;
import java.math.BigDecimal;
import java.security.cert.CertificateException;
import java.time.Instant;
import java.time.LocalDate;
import java.util.Collections;
import java.util.List;
import java.util.UUID;
import static com.ibanity.apis.client.helpers.IbanityClientSecurityAuthenticationPropertiesKeys.*;
import static com.ibanity.apis.client.helpers.IbanityClientSecuritySignaturePropertiesKeys.*;
import static com.ibanity.apis.client.helpers.IbanityConfiguration.IBANITY_API_ENDPOINT_PROPERTY_KEY;
import static com.ibanity.apis.client.helpers.IbanityConfiguration.getConfiguration;
import static com.ibanity.samples.helper.SampleHelper.loadCertificate;
import static com.ibanity.samples.helper.SampleHelper.loadPrivateKey;
public class PontoConnectClientSample {
private static final Logger LOGGER = LoggerFactory.getLogger(PontoConnectClientSample.class);
private static final String pontoConnectRedirectUrl = getConfiguration("ponto-connect.oauth2.redirect-url");
private static final String clientId = getConfiguration("ponto-connect.oauth2.client_id");
private static final String clientSecret = getConfiguration("ponto-connect.oauth2.client_secret");
private static final String codeVerifier = getConfiguration("ponto-connect.oauth2.code_verifier");
private static final String authorizationCode = getConfiguration("ponto-connect.oauth2.authorization_code");
public static void main(String[] args) throws CertificateException, IOException {
String passphrase = getConfiguration(IBANITY_CLIENT_TLS_PRIVATE_KEY_PASSPHRASE_PROPERTY_KEY);
OptionalPropertiesBuilder ibanityServiceBuilder = IbanityServiceBuilder.builder()
.ibanityApiEndpoint(getConfiguration(IBANITY_API_ENDPOINT_PROPERTY_KEY))
.tlsPrivateKey(loadPrivateKey(getConfiguration(IBANITY_CLIENT_TLS_PRIVATE_KEY_PATH_PROPERTY_KEY), passphrase))
.passphrase(passphrase)
.tlsCertificate(loadCertificate(getConfiguration(IBANITY_CLIENT_TLS_CERTIFICATE_PATH_PROPERTY_KEY)))
.caCertificate(loadCertificate(getConfiguration(IBANITY_CLIENT_TLS_CA_CERTIFICATE_PATH_PROPERTY_KEY)));
if (getConfiguration(IbanityClientSecuritySignaturePropertiesKeys.IBANITY_CLIENT_SIGNATURE_CERTIFICATE_ID_PROPERTY_KEY) != null) {
String signaturePassphrase = getConfiguration(IBANITY_CLIENT_SIGNATURE_PRIVATE_KEY_PASSPHRASE_PROPERTY_KEY, "");
ibanityServiceBuilder
.requestSignaturePrivateKey(loadPrivateKey(getConfiguration(IBANITY_CLIENT_SIGNATURE_PRIVATE_KEY_PATH_PROPERTY_KEY), signaturePassphrase))
.requestSignaturePassphrase(signaturePassphrase)
.requestSignatureCertificate(loadCertificate(getConfiguration(IBANITY_CLIENT_SIGNATURE_CERTIFICATE_PATH_PROPERTY_KEY)))
.signatureCertificateId(getConfiguration(IBANITY_CLIENT_SIGNATURE_CERTIFICATE_ID_PROPERTY_KEY));
}
PontoConnectService pontoConnectService = ibanityServiceBuilder
.pontoConnectOauth2ClientId(clientId)
.build()
.pontoConnectService();
String accessToken = createToken(pontoConnectService.tokenService());
List<FinancialInstitution> financialInstitutions = financialInstitutions(pontoConnectService.financialInstitutionService(), accessToken);
LOGGER.info("List of financialInstitutions {}", financialInstitutions);
Userinfo userinfo = userinfo(pontoConnectService.userinfoService(), accessToken);
LOGGER.info("Userinfo {}", userinfo);
sampleSandbox(pontoConnectService.sandboxService(), financialInstitutions.stream().map(FinancialInstitution::getId).findFirst().orElseThrow(RuntimeException::new), accessToken);
List<Account> accounts = accounts(pontoConnectService.accountService(), accessToken);
LOGGER.info("List of accounts {}", accounts);
UUID accountId = accounts.stream().map(Account::getId).findFirst().orElseThrow(RuntimeException::new);
Synchronization synchronization = synchronization(pontoConnectService.synchronizationService(), accountId, accessToken);
LOGGER.info("Synchronization {}", synchronization);
List<Transaction> transactions = transactions(pontoConnectService.transactionService(), accountId, accessToken);
LOGGER.info("List of transactions {}", transactions);
Payment payment = payments(pontoConnectService.paymentService(), accountId, accessToken);
LOGGER.info("payment {}", payment);
BulkPayment bulkPayment = bulkPayments(pontoConnectService.bulkPaymentService(), accountId, accessToken);
LOGGER.info("bulk payment {}", bulkPayment);
revokeToken(pontoConnectService.tokenService(), accessToken);
}
private static Userinfo userinfo(UserinfoService userinfoService, String accessToken) {
return userinfoService.getUserinfo(UserinfoReadQuery.builder()
.accessToken(accessToken)
.build());
}
private static void sampleSandbox(SandboxService sandboxService, UUID financialInstitutionId, String accessToken) {
List<FinancialInstitutionAccount> financialInstitutionAccounts = financialInstitutionAccounts(sandboxService.financialInstitutionAccountsService(), financialInstitutionId, accessToken);
LOGGER.info("List of financialInstitutionAccounts {}", financialInstitutionAccounts);
UUID financialInstitutionAccountId = financialInstitutionAccounts.stream().map(FinancialInstitutionAccount::getId).findFirst().orElseThrow(RuntimeException::new);
List<FinancialInstitutionTransaction> financialInstitutionAccountTransaction = financialInstitutionTransactions(sandboxService.financialInstitutionTransactionsService(), financialInstitutionId, financialInstitutionAccountId, accessToken);
LOGGER.info("List of financialInstitutionAccountTransaction {}", financialInstitutionAccountTransaction);
}
private static List<FinancialInstitutionTransaction> financialInstitutionTransactions(FinancialInstitutionTransactionsService financialInstitutionTransactionsService, UUID financialInstitutionId, UUID financialInstitutionAccountId, String accessToken) {
UUID financialInstitutionTransactionId = financialInstitutionTransactionsService.create(FinancialInstitutionTransactionCreationQuery.builder()
.accessToken(accessToken)
.remittanceInformationType("unstructured")
.remittanceInformation("NEW SHOES")
.description("Small Cotton Shoes")
.currency("EUR")
.counterpartName("Otro Bank")
.purposeCode("DEBIT")
.counterpartReference("BE9786154282554")
.amount(new BigDecimal("84.42"))
.valueDate(Instant.parse("2020-05-22T00:00:00Z"))
.executionDate(Instant.parse("2020-05-25T00:00:00Z"))
.financialInstitutionAccountId(financialInstitutionAccountId)
.financialInstitutionId(financialInstitutionId)
.build()).getId();
financialInstitutionTransactionsService.update(FinancialInstitutionTransactionUpdateQuery.builder()
.accessToken(accessToken)
.financialInstitutionId(financialInstitutionId)
.financialInstitutionAccountId(financialInstitutionAccountId)
.financialInstitutionTransactionId(financialInstitutionTransactionId)
.remittanceInformation("NEW SHOES")
.description("Hole foods")
.bankTransactionCode("PMNT-IRCT-ESCT")
.proprietaryBankTransactionCode("12267")
.additionalInformation("Online payment on fake-tpp.com")
.creditorId("123498765421")
.mandateId("234")
.purposeCode("CASH")
.endToEndId("ref.243435343")
.build());
financialInstitutionTransactionsService.find(FinancialInstitutionTransactionReadQuery.builder()
.accessToken(accessToken)
.financialInstitutionId(financialInstitutionId)
.financialInstitutionAccountId(financialInstitutionAccountId)
.financialInstitutionTransactionId(financialInstitutionTransactionId)
.build());
return financialInstitutionTransactionsService.list(FinancialInstitutionTransactionsReadQuery.builder()
.accessToken(accessToken)
.financialInstitutionId(financialInstitutionId)
.financialInstitutionAccountId(financialInstitutionAccountId)
.build()).getItems();
}
private static List<FinancialInstitutionAccount> financialInstitutionAccounts(FinancialInstitutionAccountsService financialInstitutionAccountsService, UUID financialInstitutionId, String accessToken) {
IbanityCollection<FinancialInstitutionAccount> list = financialInstitutionAccountsService.list(FinancialInstitutionAccountsReadQuery.builder()
.accessToken(accessToken)
.financialInstitutionId(financialInstitutionId)
.build());
UUID financialInstitutionAccountId = list.getItems().stream().map(FinancialInstitutionAccount::getId).findFirst().orElseThrow(RuntimeException::new);
financialInstitutionAccountsService.find(FinancialInstitutionAccountReadQuery.builder()
.accessToken(accessToken)
.financialInstitutionId(financialInstitutionId)
.financialInstitutionAccountId(financialInstitutionAccountId)
.build());
return list.getItems();
}
private static void revokeToken(TokenService tokenService, String accessToken) {
tokenService.revoke(TokenRevokeQuery.builder()
.token(accessToken)
.clientSecret(clientSecret)
.build());
}
private static String createToken(TokenService tokenService) {
LOGGER.info("Token samples");
Token token = tokenService.create(TokenCreateQuery.builder()
.authorizationCode(authorizationCode)
.clientSecret(clientSecret)
.codeVerifier(codeVerifier)
.redirectUri(pontoConnectRedirectUrl)
.build());
LOGGER.info("Token {}", token);
token = tokenService.refresh(TokenRefreshQuery.builder()
.clientSecret(clientSecret)
.refreshToken(token.getRefreshToken())
.build());
LOGGER.info("Token {}", token);
return token.getAccessToken();
}
private static Synchronization synchronization(SynchronizationService synchronizationService, UUID accountId, String accessToken) {
LOGGER.info("Synchronization samples");
Synchronization synchronization = synchronizationService.create(SynchronizationCreateQuery.builder()
.accessToken(accessToken)
.resourceId(accountId.toString())
.resourceType("account")
.subtype("accountDetails")
.build());
return synchronizationService.find(SynchronizationReadQuery.builder()
.synchronizationId(synchronization.getId())
.accessToken(accessToken)
.build());
}
private static List<FinancialInstitution> financialInstitutions(FinancialInstitutionService financialInstitutionService, String accessToken) {
LOGGER.info("Transactions samples");
IbanityCollection<FinancialInstitution> financialInstitutions = financialInstitutionService.list(OrganizationFinancialInstitutionsReadQuery.builder()
.accessToken(accessToken)
.build());
FinancialInstitution financialInstitution = financialInstitutions.getItems().stream().findFirst().orElseThrow(RuntimeException::new);
financialInstitutionService.find(OrganizationFinancialInstitutionReadQuery.builder()
.financialInstitutionId(financialInstitution.getId())
.accessToken(accessToken).build());
return financialInstitutions.getItems();
}
private static List<Transaction> transactions(TransactionService transactionService, UUID accountId, String accessToken) {
LOGGER.info("Transactions samples");
IbanityCollection<Transaction> transactions = transactionService.list(TransactionsReadQuery.builder()
.accessToken(accessToken)
.accountId(accountId)
.build());
UUID transactionId = transactions.getItems().stream().map(Transaction::getId).findFirst().orElseThrow(RuntimeException::new);
transactionService.find(TransactionReadQuery.builder()
.accessToken(accessToken)
.accountId(accountId)
.transactionId(transactionId)
.build());
return transactions.getItems();
}
private static List<Account> accounts(AccountService accountService, String accessToken) {
LOGGER.info("Accounts samples");
IbanityCollection<Account> accounts = accountService.list(AccountsReadQuery.builder()
.accessToken(accessToken)
.build());
UUID accountId = accounts.getItems().stream().map(Account::getId).findFirst().orElseThrow(RuntimeException::new);
accountService.find(AccountReadQuery.builder()
.accessToken(accessToken)
.accountId(accountId)
.build());
return accounts.getItems();
}
private static Payment payments(PaymentService paymentService, UUID accountId, String accessToken) {
LOGGER.info("Payments samples");
Payment payment = paymentService.create(PaymentCreateQuery.builder()
.accessToken(accessToken)
.accountId(accountId)
.remittanceInformation("payment")
.remittanceInformationType("unstructured")
.requestedExecutionDate(LocalDate.now().plusDays(1))
.currency("EUR")
.amount(BigDecimal.valueOf(59))
.creditorName("Alex Creditor")
.creditorAccountReference("BE55732022998044")
.creditorAccountReferenceType("IBAN")
.creditorAgent("NBBEBEBB203")
.creditorAgentType("BIC")
.build());
payment = paymentService.find(PaymentReadQuery.builder()
.accessToken(accessToken)
.accountId(accountId)
.paymentId(payment.getId())
.build());
paymentService.delete(PaymentDeleteQuery.builder()
.accessToken(accessToken)
.accountId(accountId)
.paymentId(payment.getId())
.build());
return payment;
}
private static BulkPayment bulkPayments(BulkPaymentService bulkPaymentService, UUID accountId, String accessToken) {
LOGGER.info("BulkPayments samples");
BulkPayment bulkPayment = bulkPaymentService.create(BulkPaymentCreateQuery.builder()
.accessToken(accessToken)
.batchBookingPreferred(true)
.reference("myReference")
.requestedExecutionDate(LocalDate.now().plusDays(1))
.redirectUri(pontoConnectRedirectUrl)
.accountId(accountId)
.payments(Collections.singletonList(createPayment()))
.build());
bulkPayment = bulkPaymentService.find(BulkPaymentReadQuery.builder()
.accessToken(accessToken)
.accountId(accountId)
.bulkPaymentId(bulkPayment.getId())
.build());
bulkPaymentService.delete(BulkPaymentDeleteQuery.builder()
.accessToken(accessToken)
.accountId(accountId)
.bulkPaymentId(bulkPayment.getId())
.build());
return bulkPayment;
}
private static BulkPaymentCreateQuery.Payment createPayment() {
return BulkPaymentCreateQuery.Payment.builder()
.remittanceInformation("payment")
.remittanceInformationType("unstructured")
.currency("EUR")
.amount(BigDecimal.valueOf(59))
.creditorName("Alex Creditor")
.creditorAccountReference("BE55732022998044")
.creditorAccountReferenceType("IBAN")
.creditorAgent("NBBEBEBB203")
.creditorAgentType("BIC")
.build();
}
}
| 0 |
raw_data\ibanity-java\src\test\java\com\ibanity | raw_data\ibanity-java\src\test\java\com\ibanity\samples\WebhooksSample.java | package com.ibanity.samples;
import com.ibanity.apis.client.builders.IbanityServiceBuilder;
import com.ibanity.apis.client.builders.OptionalPropertiesBuilder;
import com.ibanity.apis.client.models.IbanityWebhookEvent;
import com.ibanity.apis.client.webhooks.models.xs2a.*;
import com.ibanity.apis.client.webhooks.services.WebhooksService;
import java.io.IOException;
import java.security.cert.CertificateException;
import static com.ibanity.apis.client.helpers.IbanityClientSecurityAuthenticationPropertiesKeys.*;
import static com.ibanity.apis.client.helpers.IbanityConfiguration.*;
import static com.ibanity.samples.helper.SampleHelper.loadCertificate;
import static com.ibanity.samples.helper.SampleHelper.loadPrivateKey;
public class WebhooksSample {
private static final String JWT = "eyJhbGciOiJSUzUxMiIsImtpZCI6ImR1bW15XzEifQ.eyJhdWQiOiI1ODZjYzI1YS05NDc4LTRjOGEtOWIzYy0wMzQ3ZWRlZDIzOTAiLCJkaWdlc3QiOiJVaXhtaTRrUGtjUk5IMUpYUlg2eUVnWXZEakZ5ejAyUUdoVStNY2lrWjQ2SlZleE9sNTF4RnoyMFpvcXQ3NjNIeVQwVHJHTHFSSFoxcjVYYkp1UE5lQT09IiwiZXhwIjoxNjM3MDY4NDI3LCJpYXQiOjE2MzcwNjgzNjcsImlzcyI6Imh0dHBzOi8vYXBpLmRldmVsb3BtZW50LmliYW5pdHkubmV0IiwianRpIjoiYWI2MDg1YTQtM2ZjMi00NWUxLThjOTktMTY1MmYzYTk5ODI0In0.SFJLT5ql18qNYBQHrc-ne3cu3tnOfGNg3CkINcUUidb61-hJMaxYwEnOVGj-yzRDl0d8MksoZt8PavXcw2toW4uPESG8Q6r5mOcLMIUiKacdGbEDbcx01ocAPIJ1fPgND_XTTIt7PFkpcxLjbDk_W_DCFs7L0OHn6u9ltth75wePUw--PdnZLUnUpu6Vj2mKbIWBWH3foaGo0Z0uflvgCQmVnr8Csa5Fe0DrfNUgkI8b-abmz4cIDE76zb1VZDu0hecgR7p_zqjEZeOkIitwdNTJkrVlvWFaag8_lvuxAaWGy3CisGCs5-HCTqwbOglQRTU8kOb7oQFsxazGWfVofizXU7GEX8sbxqsIBlL1TR1MLB3UG0KB8OEYrW7kcL4XkQsMxguEi3oR6I1PsVd8rd-uJ6Z01iB-fiLtZXpQx1ojYGnzuuPDNCCwBLVpSela3eGgB90If4u_mohpaPdff4sfRQBW-Kmvk5All2R_AF3dBUeeRqWH7NklU6DoqdPw5s32tc8mMhHeo3r0LYy-K2v3e-1Gp9Qd8bUNNKaBTKzKJ7oEy5qhoDDxJMtre_iFWOkmKtEch4xr7nr0krrN7p5KCdIYpYdhZZ9y_06vlTuk0gMlT6Njbb181UqE-H0RxXRerG23KUCro0XFNpe0BX_g2GOOSgvQOGT3cwACjfk";
private static final String PAYLOAD = "{\"data\":{\"attributes\":{\"createdAt\":\"2021-11-16T13:11:15.136Z\",\"synchronizationSubtype\":\"accountTransactions\"},\"id\":\"344f89b0-6c3c-420e-92ba-d03490c2adb0\",\"relationships\":{\"account\":{\"data\":{\"id\":\"3e3e7824-ebbf-4801-90eb-0cf5ef1edace\",\"type\":\"account\"}},\"synchronization\":{\"data\":{\"id\":\"92b12aac-039c-4eba-a9e9-a14acf83de36\",\"type\":\"synchronization\"}}},\"type\":\"xs2a.synchronization.succeededWithoutChange\"}}";
public static void main(String[] args) throws CertificateException, IOException {
String passphrase = getConfiguration(IBANITY_CLIENT_TLS_PRIVATE_KEY_PASSPHRASE_PROPERTY_KEY);
OptionalPropertiesBuilder ibanityServiceBuilder = IbanityServiceBuilder.builder()
.ibanityApiEndpoint(getConfiguration(IBANITY_API_ENDPOINT_PROPERTY_KEY))
.tlsPrivateKey(loadPrivateKey(getConfiguration(IBANITY_CLIENT_TLS_PRIVATE_KEY_PATH_PROPERTY_KEY), passphrase))
.passphrase(passphrase)
.tlsCertificate(loadCertificate(getConfiguration(IBANITY_CLIENT_TLS_CERTIFICATE_PATH_PROPERTY_KEY)))
.webhooksJwksCacheTTLMillis(30_000)
.webhooksJwtClockSkewSeconds(3600000)
.applicationId(getConfiguration(IBANITY_APPLICATION_ID))
;
WebhooksService webhooksService = ibanityServiceBuilder.build().webhooksService();
System.out.println(webhooksService.keysService().list());
IbanityWebhookEvent ibanityWebhookEvent = webhooksService.verifyAndParseEvent(PAYLOAD, JWT);
switch (ibanityWebhookEvent.getType()) {
case AccountDetailsUpdated.TYPE:
System.out.println("AccountDetailsUpdated received");
break;
case AccountTransactionsCreated.TYPE:
System.out.println("AccountTransactionsCreated received");
break;
case AccountTransactionsUpdated.TYPE:
System.out.println("AccountTransactionsUpdated received");
break;
case AccountPendingTransactionsCreated.TYPE:
System.out.println("AccountPendingTransactionsCreated received");
break;
case AccountPendingTransactionsUpdated.TYPE:
System.out.println("AccountPendingTransactionsUpdated received");
break;
case SynchronizationFailed.TYPE:
System.out.println("SynchronizationFailed received");
break;
case SynchronizationSucceededWithoutChange.TYPE:
System.out.println("SynchronizationSucceededWithoutChange received");
break;
}
}
}
| 0 |
raw_data\ibanity-java\src\test\java\com\ibanity\samples | raw_data\ibanity-java\src\test\java\com\ibanity\samples\customer\AccountInformationAccessRequestSample.java | package com.ibanity.samples.customer;
import java.util.Arrays;
import com.ibanity.apis.client.products.xs2a.models.AccountInformationAccessRequest;
import com.ibanity.apis.client.products.xs2a.models.CustomerAccessToken;
import com.ibanity.apis.client.products.xs2a.models.FinancialInstitution;
import com.ibanity.apis.client.products.xs2a.models.create.AccountInformationAccessRequestCreationQuery;
import com.ibanity.apis.client.products.xs2a.models.create.AuthorizationPortalCreationQuery;
import com.ibanity.apis.client.products.xs2a.models.create.MetaRequestCreationQuery;
import com.ibanity.apis.client.products.xs2a.models.read.AccountInformationAccessRequestReadQuery;
import com.ibanity.apis.client.products.xs2a.services.AccountInformationAccessRequestsService;
import com.ibanity.apis.client.services.IbanityService;
public class AccountInformationAccessRequestSample {
private final AccountInformationAccessRequestsService accountInformationAccessRequestsService;
public AccountInformationAccessRequestSample(IbanityService ibanityService) {
accountInformationAccessRequestsService = ibanityService.xs2aService().accountInformationAccessRequestsService();
}
public AccountInformationAccessRequest create(
FinancialInstitution financialInstitution,
CustomerAccessToken customerAccessToken,
String consentReference, String redirectUrl) {
AccountInformationAccessRequestCreationQuery accountInformationAccessRequestCreationQuery =
AccountInformationAccessRequestCreationQuery.builder()
.customerAccessToken(customerAccessToken.getToken())
.financialInstitutionId(financialInstitution.getId())
.redirectUri(redirectUrl)
.consentReference(consentReference)
.allowFinancialInstitutionRedirectUri(true)
.customerIpAddress("1.1.1.1")
.allowedAccountSubtypes(Arrays.asList("checking", "savings", "securities"))
.skipIbanityCompletionCallback(false)
.metaRequestCreationQuery(MetaRequestCreationQuery.builder()
.authorizationPortalCreationQuery(AuthorizationPortalCreationQuery.builder()
.disclaimerContent("thisIsACusomOneContent")
.disclaimerTitle("thisIsACusomOneTitle")
.financialInstitutionPrimaryColor("#000000")
.financialInstitutionSecondaryColor("#000000")
.build())
.build())
.build();
return accountInformationAccessRequestsService.create(accountInformationAccessRequestCreationQuery);
}
public AccountInformationAccessRequest find(AccountInformationAccessRequest accountInformationAccessRequest, FinancialInstitution financialInstitution, CustomerAccessToken customerAccessToken) {
return accountInformationAccessRequestsService.find(AccountInformationAccessRequestReadQuery.builder()
.accountInformationAccessRequestId(accountInformationAccessRequest.getId())
.financialInstitutionId(financialInstitution.getId())
.customerAccessToken(customerAccessToken.getToken())
.build());
}
}
| 0 |
raw_data\ibanity-java\src\test\java\com\ibanity\samples | raw_data\ibanity-java\src\test\java\com\ibanity\samples\customer\AccountSample.java | package com.ibanity.samples.customer;
import com.ibanity.apis.client.models.IbanityCollection;
import com.ibanity.apis.client.products.xs2a.models.Account;
import com.ibanity.apis.client.products.xs2a.models.CustomerAccessToken;
import com.ibanity.apis.client.products.xs2a.models.FinancialInstitution;
import com.ibanity.apis.client.products.xs2a.models.delete.AccountDeleteQuery;
import com.ibanity.apis.client.products.xs2a.models.read.AccountReadQuery;
import com.ibanity.apis.client.products.xs2a.models.read.AccountsReadQuery;
import com.ibanity.apis.client.products.xs2a.services.AccountsService;
import com.ibanity.apis.client.services.IbanityService;
import java.util.UUID;
public class AccountSample {
private final AccountsService accountsService;
public AccountSample(IbanityService ibanityService) {
accountsService = ibanityService.xs2aService().accountsService();
}
public IbanityCollection<Account> list(CustomerAccessToken customerAccessToken, FinancialInstitution financialInstitution) {
AccountsReadQuery accountsReadQuery = AccountsReadQuery.builder()
.customerAccessToken(customerAccessToken.getToken())
.financialInstitutionId(financialInstitution.getId())
.build();
return accountsService.list(accountsReadQuery);
}
public Account get(CustomerAccessToken customerAccessToken, FinancialInstitution financialInstitution, UUID accountId) {
AccountReadQuery accountReadQuery = AccountReadQuery.builder()
.customerAccessToken(customerAccessToken.getToken())
.financialInstitutionId(financialInstitution.getId())
.accountId(accountId)
.build();
return accountsService.find(accountReadQuery);
}
public Account delete(CustomerAccessToken customerAccessToken, FinancialInstitution financialInstitution, UUID accountId) {
AccountDeleteQuery accountDeleteQuery = AccountDeleteQuery.builder()
.customerAccessToken(customerAccessToken.getToken())
.financialInstitutionId(financialInstitution.getId())
.accountId(accountId)
.build();
return accountsService.delete(accountDeleteQuery);
}
}
| 0 |
raw_data\ibanity-java\src\test\java\com\ibanity\samples | raw_data\ibanity-java\src\test\java\com\ibanity\samples\customer\CustomerAccessTokenSample.java | package com.ibanity.samples.customer;
import com.ibanity.apis.client.products.xs2a.models.CustomerAccessToken;
import com.ibanity.apis.client.products.xs2a.models.create.CustomerAccessTokenCreationQuery;
import com.ibanity.apis.client.products.xs2a.services.CustomerAccessTokensService;
import com.ibanity.apis.client.services.IbanityService;
public class CustomerAccessTokenSample {
private final CustomerAccessTokensService customerAccessTokensService;
public CustomerAccessTokenSample(IbanityService ibanityService) {
customerAccessTokensService = ibanityService.xs2aService().customerAccessTokensService();
}
public CustomerAccessToken create(String consentReference) {
CustomerAccessTokenCreationQuery customerAccessTokenCreationQuery =
CustomerAccessTokenCreationQuery.builder().applicationCustomerReference(consentReference).build();
return customerAccessTokensService.create(customerAccessTokenCreationQuery);
}
}
| 0 |