Skip to content

Add resend transaction webhook endpoint #9

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
SlimAhmad merged 1 commit into from
Sep 16, 2026
Merged

Add resend transaction webhook endpoint #9

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
301 changes: 301 additions & 0 deletions ...undations/Transactions/TransactionServiceTests.Exceptions.PostResendTransactionWebhook.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,301 @@
using FluentAssertions;
using FlutterWave.Core.Models.Services.Foundations.FlutterWave.Transactions;
using Moq;
using RESTFulSense.Exceptions;

namespace FlutterWave.Core.Tests.Unit.Services.Foundations.Transactions
{
public partial class TransactionServiceTests
{
[Fact]
public async Task ShouldThrowDependencyExceptionOnPostResendTransactionWebhookIfUrlNotFoundAsync()
{
// given
int someTransactionId = GetRandomNumber();
int someWait = GetRandomNumber();

var httpResponseUrlNotFoundException =
new HttpResponseUrlNotFoundException();

var invalidConfigurationTransactionsException =
new InvalidConfigurationTransactionsException(
httpResponseUrlNotFoundException);

var expectedTransactionsDependencyException =
new TransactionsDependencyException(
invalidConfigurationTransactionsException);

this.flutterWaveBrokerMock.Setup(broker =>
broker.PostResendTransactionWebhookAsync(someTransactionId, someWait))
.ThrowsAsync(httpResponseUrlNotFoundException);

// when
ValueTask<ResendTransactionWebhook> resendTransactionWebhookTask =
this.transactionsService.PostResendTransactionWebhookAsync(someTransactionId, someWait);

TransactionsDependencyException
actualTransactionsDependencyException =
await Assert.ThrowsAsync<TransactionsDependencyException>(
resendTransactionWebhookTask.AsTask);

// then
actualTransactionsDependencyException.Should().BeEquivalentTo(
expectedTransactionsDependencyException);

this.flutterWaveBrokerMock.Verify(broker =>
broker.PostResendTransactionWebhookAsync(someTransactionId, someWait),
Times.Once);

this.flutterWaveBrokerMock.VerifyNoOtherCalls();
this.dateTimeBrokerMock.VerifyNoOtherCalls();
}

[Theory]
[MemberData(nameof(UnauthorizedExceptions))]
public async Task ShouldThrowDependencyExceptionOnPostResendTransactionWebhookIfUnauthorizedAsync(
HttpResponseException unauthorizedException)
{
// given
int someTransactionId = GetRandomNumber();
int someWait = GetRandomNumber();

var unauthorizedTransactionsException =
new UnauthorizedTransactionsException(unauthorizedException);

var expectedTransactionsDependencyException =
new TransactionsDependencyException(unauthorizedTransactionsException);

this.flutterWaveBrokerMock.Setup(broker =>
broker.PostResendTransactionWebhookAsync(someTransactionId, someWait))
.ThrowsAsync(unauthorizedException);

// when
ValueTask<ResendTransactionWebhook> resendTransactionWebhookTask =
this.transactionsService.PostResendTransactionWebhookAsync(someTransactionId, someWait);

TransactionsDependencyException
actualTransactionsDependencyException =
await Assert.ThrowsAsync<TransactionsDependencyException>(
resendTransactionWebhookTask.AsTask);

// then
actualTransactionsDependencyException.Should().BeEquivalentTo(
expectedTransactionsDependencyException);

this.flutterWaveBrokerMock.Verify(broker =>
broker.PostResendTransactionWebhookAsync(someTransactionId, someWait),
Times.Once);

this.flutterWaveBrokerMock.VerifyNoOtherCalls();
this.dateTimeBrokerMock.VerifyNoOtherCalls();
}

[Fact]
public async Task ShouldThrowDependencyValidationExceptionOnPostResendTransactionWebhookIfNotFoundOccurredAsync()
{
// given
int someTransactionId = GetRandomNumber();
int someWait = GetRandomNumber();

var httpResponseNotFoundException =
new HttpResponseNotFoundException();

var notFoundTransactionsException =
new NotFoundTransactionsException(
httpResponseNotFoundException);

var expectedTransactionsDependencyValidationException =
new TransactionsDependencyValidationException(
notFoundTransactionsException);

this.flutterWaveBrokerMock.Setup(broker =>
broker.PostResendTransactionWebhookAsync(someTransactionId, someWait))
.ThrowsAsync(httpResponseNotFoundException);

// when
ValueTask<ResendTransactionWebhook> resendTransactionWebhookTask =
this.transactionsService.PostResendTransactionWebhookAsync(someTransactionId, someWait);

TransactionsDependencyValidationException
actualTransactionsDependencyValidationException =
await Assert.ThrowsAsync<TransactionsDependencyValidationException>(
resendTransactionWebhookTask.AsTask);

// then
actualTransactionsDependencyValidationException.Should().BeEquivalentTo(
expectedTransactionsDependencyValidationException);

this.flutterWaveBrokerMock.Verify(broker =>
broker.PostResendTransactionWebhookAsync(someTransactionId, someWait),
Times.Once);

this.flutterWaveBrokerMock.VerifyNoOtherCalls();
this.dateTimeBrokerMock.VerifyNoOtherCalls();
}

[Fact]
public async Task ShouldThrowDependencyValidationExceptionOnPostResendTransactionWebhookIfBadRequestOccurredAsync()
{
// given
int someTransactionId = GetRandomNumber();
int someWait = GetRandomNumber();

var httpResponseBadRequestException =
new HttpResponseBadRequestException();

var invalidTransactionsException =
new InvalidTransactionsException(
httpResponseBadRequestException);

var expectedTransactionsDependencyValidationException =
new TransactionsDependencyValidationException(
invalidTransactionsException);

this.flutterWaveBrokerMock.Setup(broker =>
broker.PostResendTransactionWebhookAsync(someTransactionId, someWait))
.ThrowsAsync(httpResponseBadRequestException);

// when
ValueTask<ResendTransactionWebhook> resendTransactionWebhookTask =
this.transactionsService.PostResendTransactionWebhookAsync(someTransactionId, someWait);

TransactionsDependencyValidationException
actualTransactionsDependencyValidationException =
await Assert.ThrowsAsync<TransactionsDependencyValidationException>(
resendTransactionWebhookTask.AsTask);

// then
actualTransactionsDependencyValidationException.Should().BeEquivalentTo(
expectedTransactionsDependencyValidationException);

this.flutterWaveBrokerMock.Verify(broker =>
broker.PostResendTransactionWebhookAsync(someTransactionId, someWait),
Times.Once);

this.flutterWaveBrokerMock.VerifyNoOtherCalls();
this.dateTimeBrokerMock.VerifyNoOtherCalls();
}

[Fact]
public async Task ShouldThrowDependencyValidationExceptionOnPostResendTransactionWebhookIfTooManyRequestsOccurredAsync()
{
// given
int someTransactionId = GetRandomNumber();
int someWait = GetRandomNumber();

var httpResponseTooManyRequestsException =
new HttpResponseTooManyRequestsException();

var excessiveCallTransactionsException =
new ExcessiveCallTransactionsException(
httpResponseTooManyRequestsException);

var expectedTransactionsDependencyValidationException =
new TransactionsDependencyValidationException(
excessiveCallTransactionsException);

this.flutterWaveBrokerMock.Setup(broker =>
broker.PostResendTransactionWebhookAsync(someTransactionId, someWait))
.ThrowsAsync(httpResponseTooManyRequestsException);

// when
ValueTask<ResendTransactionWebhook> resendTransactionWebhookTask =
this.transactionsService.PostResendTransactionWebhookAsync(someTransactionId, someWait);

TransactionsDependencyValidationException actualTransactionsDependencyValidationException =
await Assert.ThrowsAsync<TransactionsDependencyValidationException>(
resendTransactionWebhookTask.AsTask);

// then
actualTransactionsDependencyValidationException.Should().BeEquivalentTo(
expectedTransactionsDependencyValidationException);

this.flutterWaveBrokerMock.Verify(broker =>
broker.PostResendTransactionWebhookAsync(someTransactionId, someWait),
Times.Once);

this.flutterWaveBrokerMock.VerifyNoOtherCalls();
this.dateTimeBrokerMock.VerifyNoOtherCalls();
}

[Fact]
public async Task ShouldThrowDependencyExceptionOnPostResendTransactionWebhookIfHttpResponseErrorOccurredAsync()
{
// given
int someTransactionId = GetRandomNumber();
int someWait = GetRandomNumber();

var httpResponseException =
new HttpResponseException();

var failedServerTransactionsException =
new FailedServerTransactionsException(
httpResponseException);

var expectedTransactionsDependencyException =
new TransactionsDependencyException(
failedServerTransactionsException);

this.flutterWaveBrokerMock.Setup(broker =>
broker.PostResendTransactionWebhookAsync(someTransactionId, someWait))
.ThrowsAsync(httpResponseException);

// when
ValueTask<ResendTransactionWebhook> resendTransactionWebhookTask =
this.transactionsService.PostResendTransactionWebhookAsync(someTransactionId, someWait);

TransactionsDependencyException actualTransactionsDependencyException =
await Assert.ThrowsAsync<TransactionsDependencyException>(
resendTransactionWebhookTask.AsTask);

// then
actualTransactionsDependencyException.Should().BeEquivalentTo(
expectedTransactionsDependencyException);

this.flutterWaveBrokerMock.Verify(broker =>
broker.PostResendTransactionWebhookAsync(someTransactionId, someWait),
Times.Once);

this.flutterWaveBrokerMock.VerifyNoOtherCalls();
this.dateTimeBrokerMock.VerifyNoOtherCalls();
}

[Fact]
public async Task ShouldThrowServiceExceptionOnPostResendTransactionWebhookIfServiceErrorOccurredAsync()
{
// given
int someTransactionId = GetRandomNumber();
int someWait = GetRandomNumber();
var serviceException = new Exception();

var failedTransactionsServiceException =
new FailedTransactionsServiceException(serviceException);

var expectedTransactionsServiceException =
new TransactionsServiceException(failedTransactionsServiceException);

this.flutterWaveBrokerMock.Setup(broker =>
broker.PostResendTransactionWebhookAsync(someTransactionId, someWait))
.ThrowsAsync(serviceException);

// when
ValueTask<ResendTransactionWebhook> resendTransactionWebhookTask =
this.transactionsService.PostResendTransactionWebhookAsync(someTransactionId, someWait);

TransactionsServiceException actualTransactionsServiceException =
await Assert.ThrowsAsync<TransactionsServiceException>(
resendTransactionWebhookTask.AsTask);

// then
actualTransactionsServiceException.Should().BeEquivalentTo(
expectedTransactionsServiceException);

this.flutterWaveBrokerMock.Verify(broker =>
broker.PostResendTransactionWebhookAsync(someTransactionId, someWait),
Times.Once);

this.flutterWaveBrokerMock.VerifyNoOtherCalls();
this.dateTimeBrokerMock.VerifyNoOtherCalls();
}
}
}
57 changes: 57 additions & 0 deletions ...es/Foundations/Transactions/TransactionServiceTests.Logic.PostResendTransactionWebhook.cs
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,57 @@
using FluentAssertions;
using FlutterWave.Core.Models.Services.Foundations.ExternalFlutterWave.ExternalTransactions;
using FlutterWave.Core.Models.Services.Foundations.FlutterWave.Transactions;
using Moq;

namespace FlutterWave.Core.Tests.Unit.Services.Foundations.Transactions
{
public partial class TransactionServiceTests
{
[Fact]
public async Task ShouldResendTransactionWebhookWithTransactionIdAsync()
{
// given
int inputTransactionId = GetRandomNumber();
int inputWait = GetRandomNumber();

dynamic resendTransactionWebhookRandomProperties =
CreateRandomResendTransactionWebhookProperties();

var externalResendTransactionWebhookResponse = new ExternalResendTransactionWebhookResponse
{
Status = resendTransactionWebhookRandomProperties.Status,
Message = resendTransactionWebhookRandomProperties.Message,
Data = resendTransactionWebhookRandomProperties.Data,
};

var expectedResendTransactionWebhookResponse = new ResendTransactionWebhookResponse
{
Status = resendTransactionWebhookRandomProperties.Status,
Message = resendTransactionWebhookRandomProperties.Message,
Data = resendTransactionWebhookRandomProperties.Data,
};

var expectedResendTransactionWebhook = new ResendTransactionWebhook
{
Response = expectedResendTransactionWebhookResponse
};

this.flutterWaveBrokerMock.Setup(broker =>
broker.PostResendTransactionWebhookAsync(inputTransactionId, inputWait))
.ReturnsAsync(externalResendTransactionWebhookResponse);

// when
ResendTransactionWebhook actualResendTransactionWebhook =
await this.transactionsService.PostResendTransactionWebhookAsync(inputTransactionId, inputWait);

// then
actualResendTransactionWebhook.Should().BeEquivalentTo(expectedResendTransactionWebhook);

this.flutterWaveBrokerMock.Verify(broker =>
broker.PostResendTransactionWebhookAsync(inputTransactionId, inputWait),
Times.Once);

this.flutterWaveBrokerMock.VerifyNoOtherCalls();
}
}
}
Loading
Loading