Unit testing is a key component of software testing that developers can handle on their own. It is used to test the smallest components of your code. As you write your code, you may use unit tests to make sure it is working as expected or yielding the desired outcomes.

All developers benefit from testing the code before submitting it to source control. NUnit, xUnit, and other frameworks are among the many available for unit testing. We shall examine the unit testing procedure in this article.

initiative for the Net Web API. Here, we are utilizing the xUnit framework, which is a free and open-source tool, to achieve the same goal. web development. Here, we'll start by addressing the most basic functions.

Creating a Testing Project
At last, we reach the stage where our tests will require the creation of a new project. We will take advantage of the handy xUnit testing project template that comes with Visual Studio 2022 when we use it.

An open-source unit testing tool for the.NET framework called xUnit makes testing easier and frees up more time to concentrate on creating tests:

In order to inject the IEmployeeService interface into our controller during testing, we now need to construct our fictitious implementation of the interface. We are going to populate its in-memory collection with our fictitious data.
public class EmployeeServiceFake : IEmployeeService
{
    public readonly Dictionary<Guid, Employee> _employees;

    public EmployeeServiceFake()
    {
        _employees = new Dictionary<Guid, Employee>
        {
            {
                new Guid("503df499-cabb-4699-8381-d76917365a9d"),
                new Employee
                {
                    Id = new Guid("503df499-cabb-4699-8381-d76917365a9d"),
                    Name = "Name1",
                    Mno = "1234567890",
                    Salary = 36000,
                    Type = EmployeeType.Permanent
                }
            },
            {
                new Guid("77cf78a6-d6e8-4d50-afeb-39eae4567c62"),
                new Employee
                {
                    Id = new Guid("77cf78a6-d6e8-4d50-afeb-39eae4567c62"),
                    Name = "Name2",
                    Mno = "1234567890",
                    Salary = 24000,
                    Type = EmployeeType.Temporary
                }
            }
        };
    }
    public bool Exists(Guid id)
    {
        return _employees.ContainsKey(id);
    }
    public Guid Create(Employee employee)
    {
        _employees.Add(employee.Id, employee);
        return employee.Id;
    }
    public void Delete(Guid id)
    {
        _employees.Remove(id);
    }
    public List<Employee> GetAll()
    {
        return _employees.Values.ToList();
    }
    public Employee GetById(Guid id)
    {
        if (!_employees.ContainsKey(id))
        {
            return null;
        }
        return _employees[id];
    }
    public Guid Update(Employee employee)
    {
        var emp = _employees[employee.Id];
        emp.Mno = employee.Mno;
        emp.Name = employee.Name;
        emp.Type = employee.Type;
        emp.Salary = employee.Salary;
        _employees[employee.Id] = emp;
        return employee.Id;
    }
}

Write some unit tests, please! We are now prepared to write tests for our EmpController's first GetAll method.

The xUnit framework uses the [Fact] attribute, which we will use to decorate test methods to identify them as the real testing methods. In the test class, in addition to the test methods, we can have an infinite number of helper methods.

The AAA principle (Arrange, Act, and Assert) is typically followed when writing unit tests.

• Arrange: this is the part where you usually get everything ready for the test or put another way, you get the scene ready for the test (making the objects and arranging them as needed).
• Act: Here is where the procedure that we are testing is carried out.
• Assert: In this last section of the test, we contrast the actual outcome of the test method's execution with our expectations.

Testing Our Actions
We will want to confirm the following in the Get method, which is the first method we are testing.

• Whether the method yields the OkObjectResult, a response code of 200 for an HTTP request.
• Whether the returned object includes every item in our list of Emps.

Testing the Get Method
public class EmployeeControllerTest
{
    private readonly EmployeeController _employeeController;
    private readonly IEmployeeService _employeeService;

    public EmployeeControllerTest()
    {
        _employeeService = new EmployeeServiceFake();
        _employeeController = new EmployeeController(_employeeService);
    }
    [Fact]
    public void Get_WhenCalled_ReturnsOkResult()
    {
        // Act
        var response = _employeeController.GetAll();
        // Assert
        Assert.IsType<OkObjectResult>(response as OkObjectResult);
    }
    [Fact]
    public void Get_WhenCalled_ReturnsAllItems()
    {
        // Act
        var response = _employeeController.GetAll() as OkObjectResult;
        // Assert
        var result = Assert.IsType<List<Employee>>(response.Value);
        Assert.Equal(2, result.Count);
    }
}

The class we wish to test is the one in which we create an instance of the EmployeeController object. It's crucial to remember that this constructor is called before every test method, which implies that the test is always run on a new object and the controller state is always reset.

This is crucial because, regardless of how often or in what order we run the tests, the test methods ought to be independent of one another and should yield consistent testing outcomes.

Testing the GetById Method
[Fact]
public void GetById_FakeGuidPassed_ReturnsNotFound()
{
    // Arrange
    var empId = Guid.NewGuid();
    // Act
    var response = _employeeController.GetById(empId);
    // Assert
    Assert.IsType<NotFoundResult>(response);
}
[Fact]
public void GetById_ValidGuidPassed_ReturnsOk()
{
    // Arrange
    var empId = new Guid("503df499-cabb-4699-8381-d76917365a9d");
    // Act
    var response = _employeeController.GetById(empId);
    // Assert
    Assert.IsType<OkObjectResult>(response);
}
[Fact]
public void GetById_ValidGuidPassed_ReturnsEmp()
{
    // Arrange
    var empId = new Guid("503df499-cabb-4699-8381-d76917365a9d");
    // Act
    var response = _employeeController.GetById(empId) as OkObjectResult;
    // Assert
    Assert.IsType<Employee>(response.Value);
    Assert.Equal(empId, (response.Value as Employee).Id);
}

Testing the Create Method
[Fact]
public void Create_Invalid_ReturnsBadRequest()
{
    // Arrange
    Employee? employee = null;
    // Act
    var response = _employeeController.Create(employee);
    // Assert
    Assert.IsType<BadRequestResult>(response);
}
[Fact]
public void Create_AlreadyExists_ReturnsBadRequest()
{
    // Arrange
    var employee = new Employee
    {
        Id = new Guid("503df499-cabb-4699-8381-d76917365a9d"),
        Name = "Name1",
        Mno = "1234567890",
        Salary = 36000,
        Type = EmployeeType.Permanent
    };
    // Act
    var response = _employeeController.Create(employee);
    // Assert
    Assert.IsType<BadRequestResult>(response);
}
[Fact]
public void Create_ValidEmployee_ReturnsOk()
{
    // Arrange
    var employee = new Employee
    {
        Id = Guid.NewGuid(),
        Name = "Name1",
        Mno = "1234567890",
        Salary = 36000,
        Type = EmployeeType.Permanent
    };
    // Act
    var response = _employeeController.Create(employee);
    // Assert
    Assert.IsType<CreatedAtActionResult>(response);
}
[Fact]
public void Create_ValidEmployee_ReturnsResponseItem()
{
    // Arrange
    var employee = new Employee
    {
        Id = Guid.NewGuid(),
        Name = "Name1",
        Mno = "1234567890",
        Salary = 36000,
        Type = EmployeeType.Permanent
    };
    // Act
    var response = _employeeController.Create(employee) as CreatedAtActionResult;
    var emp = response.Value as Employee;
    // Assert
    Assert.IsType<Employee>(emp);
    Assert.Equal(emp.Id, employee.Id);
}

In brief
The test scenarios for our EmployeeController are now complete, and we would like to briefly review some general unit testing guidelines. When writing unit tests, there are a few standards or best practices you should aim for. It will undoubtedly make your life easier and the life of your fellow developers if you respect these practices.

• Readability is a must for unit tests: Nobody wants to waste time attempting to decipher the purpose of your test. Ideally, it should be evident from the test name alone.
• Maintainability is a must for unit tests: It is our goal to write our tests so that even small modifications to the code shouldn't require us to rewrite them all. We should treat our test code the same as the production code in this situation, adhering to the DRY (don't repeat yourself) principle. This lessens the likelihood that someone will eventually reach a point where it is too difficult for them to maintain all of our tests, and they must comment them out.
• Unit sets ought to be quick: People are likely to run tests less frequently if they take too long to complete. That is undoubtedly undesirable, as nobody wants to have to wait around for tests to finish.
• Dependencies shouldn't exist in unit tests: It is crucial that test execution be possible for everyone involved in the project without requiring access to an outside database or system. Testing must be done in complete isolation.
• Make tests reliable instead of just focusing on code coverage: We should feel confident that we can find errors before they are introduced into the production system thanks to well-designed tests. It is simple to write tests that pass and have more code coverage by omitting certain assertions. However, there's no use in doing that. When it comes time to modify the code, we should make an effort to test the appropriate things so that we can rely on them.

In summary
This article has taught us the definition of unit testing and how to set up an xUnit project for unit testing. The fundamental scenarios for testing the controller logic on a few CRUD operations have also been taught to us. You should find these examples to be a great place to start when creating your own unit tests and testing larger, more intricate projects. Thank you for reading, and hopefully, this post will help you understand ASP.NET Core unit testing and concepts a little bit better. We learned the new technique and evolved together. Happy coding!

Stripe is one of the online and in-person payment processing systems. Its not open source. In below sample, we are using test version. We can do operations like create a customer, charge, invoices, refund, webook, etc.

In the below sample, I have used the Stripe.net package for Stripe payment processing in dotnet and Stripe REST API's.

The Card Tokenization with Angular 15 and various payment-related functionalities using tokens generated by Card tokenization will be covered in the upcoming article.

In this article, we will look at an operation.

• Stripe Account Setup
• Creation of Customer
• Payment method and payment intent
• Invoices and invoice line items
• Charge
• Refund

Stripe Account Setup
To begin using Stripe for payment integration, the first step is to create a Stripe account.

• Step 1. Navigate to Stripe register.
• Step 2. Fill out the required fields, such as email, full name, and password, country.
• Step 3. After creating your account, Stripe will ask you for some business details (or personal details if you're using it as an individual) to complete the setup.

Stripe operates in both test mode and live mode. In test mode, you can simulate transactions without actually charging cards. Once everything is working as expected, you can switch to live mode to begin processing real payments.

Note. Stripe uses test mode by default. You can toggle to live mode from the dashboard once you're ready.

Customer
Install a stripe.net package from nuget manager to our project.

Create Customer
The customer is the main object which will hold multiple payment methods, invoices, and billing info. we can create customer for individual or business organization.

Code Sample
// Configures the Stripe SDK with the secret key for API communication
private void ConfigureStripe()
{
    // Retrieve the secret key from the configuration settings
    string? stripeSecretKey = _configuration.GetValue<string>("SecretKey");

    // Check if the secret key is null or empty; throw an exception if validation fails
    if (string.IsNullOrEmpty(stripeSecretKey))
    {
        throw new Exception("Stripe secret key is null or empty");
    }

    // Set the Stripe secret key to the SDK's global configuration
    StripeConfiguration.ApiKey = stripeSecretKey;
}

// Creates a new customer in the Stripe system using provided customer details
public Customer CreateCustomer(StripeCustomerRequest stripeCustomerRequest)
{
    try
    {
        // Ensure Stripe is properly configured with the secret key
        ConfigureStripe();

        // Define the options for creating a Stripe customer
        var options = new CustomerCreateOptions
        {
            Email = stripeCustomerRequest.Email,        // Customer's email address
            Name = stripeCustomerRequest.Name,          // Customer's full name
            Phone = stripeCustomerRequest.Phone,        // Customer's phone number
            Description = stripeCustomerRequest.Description // Description for the customer (e.g., reason for account creation)
        };

        // Instantiate the CustomerService to interact with Stripe's Customer API
        var service = new CustomerService();

        // Create and return the new customer by making an API call to Stripe
        return service.Create(options);
    }
    catch (StripeException ex)
    {
        // Log the error message for debugging purposes
        Console.WriteLine($"Stripe Exception: {ex.StripeError.Message}");

        // Throw a new exception with a custom message and the original exception as the inner exception
        throw new Exception("Failed to create customer", ex);
    }
}

Create customers with tokenization
Creates a new customer in the Stripe system, associating a payment source; basically, it will create a customer after getting card info from users.

Code Sample
// Creates a new customer in the Stripe system, associating a payment source (e.g., tokenized card)
public Customer CreateCustomerWithToken(StripeCustomerRequest stripeCustomerRequest)
{
    try
    {
        // Ensure Stripe is properly configured with the secret key
        ConfigureStripe();

        // Define the options for creating a Stripe customer with a payment source
        var options = new CustomerCreateOptions
        {
            Email = stripeCustomerRequest.Email,                 // Customer's email address
            Name = stripeCustomerRequest.Name,                   // Customer's full name
            Phone = stripeCustomerRequest.Phone,                 // Customer's phone number
            Description = stripeCustomerRequest.Description,     // Description for the customer
            Source = stripeCustomerRequest.SourceID              // Token representing a payment source (e.g., card details)
        };

        // Instantiate the CustomerService to interact with Stripe's Customer API
        var service = new CustomerService();

        // Create and return the new customer by making an API call to Stripe
        return service.Create(options);
    }
    catch (StripeException ex)
    {
        // Log the error message for debugging purposes
        Console.WriteLine($"Stripe Exception: {ex.StripeError.Message}");

        // Throw a new exception with a custom message and the original exception as the inner exception
        throw new Exception("Failed to create customer with token", ex);
    }
}

Update Customer
We can update existing customers using customer ID. We can update the info like email, phone, description, source ID, etc.

Code Sample
// Updates an existing customer in the Stripe system with the provided customer details.
public Customer UpdateCustomer(StripeCustomerRequest stripeCustomerRequest)
{
    try
    {
        // Ensure Stripe is properly configured with the secret key
        ConfigureStripe();

        // Create an instance of CustomerUpdateOptions to define the fields to update
        var options = new CustomerUpdateOptions
        {
            Email = stripeCustomerRequest.Email,        // Update customer's email address
            Name = stripeCustomerRequest.Name,          // Update customer's full name
            Phone = stripeCustomerRequest.Phone,        // Update customer's phone number
            Description = stripeCustomerRequest.Description // Update description (e.g., reason for the update)
        };

        // If SourceID is provided, add it to the options to update the payment method (e.g., a new token)
        if (!string.IsNullOrEmpty(stripeCustomerRequest.SourceID))
        {
            options.Source = stripeCustomerRequest.SourceID; // Update the payment source for the customer
        }

        // Instantiate the CustomerService to interact with Stripe's Customer API
        var service = new CustomerService();

        // Update the customer by calling the Update method with the customer ID and the update options
        return service.Update(stripeCustomerRequest.CustomerID, options);
    }
    catch (StripeException ex)
    {
        // Log the Stripe exception error message for debugging
        Console.WriteLine($"Stripe Exception: {ex.StripeError.Message}");

        // Throw a new exception with a custom message and the original exception as the inner exception
        throw new Exception("Failed to update customer", ex);
    }
}

Stripe Customer Request Class
public class StripeCustomerRequest
{
    public string Email { get; set; }
    public string Name { get; set; }
    public string Phone { get; set; }
    public string CustomerID { get; set; }
    public string Description { get; set; }
    public string SourceID { get; set; }
}

Payment Method
A payment method is a way that customers pay for a product or service. In a brick-and-mortar store, accepted payment methods may include cash, a gift card, credit cards, prepaid cards, debit cards, or mobile payments.

Stripe will support various cards, debit, wallets, real-time transfers, bank transfers, etc.

In this sample, we are using a credit card as a payment method.

Create payment method
Code Sample
// Creates a new payment method (credit card) in Stripe
public PaymentMethod CreatePaymentMethod(CreatePaymentMethodRequest createPaymentMethodRequest)
{
    try
    {
        // Ensure Stripe is properly configured with the secret key
        ConfigureStripe();

        // Define the options for creating a payment method (credit card)
        var paymentMethodOptions = new PaymentMethodCreateOptions
        {
            Type = "card", // Specifies that the payment method is a credit card
            Card = new PaymentMethodCardOptions
            {
                Number = createPaymentMethodRequest.Number,    // Card number
                ExpMonth = createPaymentMethodRequest.ExpMonth, // Expiration month
                ExpYear = createPaymentMethodRequest.ExpYear,   // Expiration year
                Cvc = createPaymentMethodRequest.Cvc            // Card security code (CVC)
            }
        };

        // Instantiate the PaymentMethodService to interact with Stripe's API
        var paymentMethodService = new PaymentMethodService();

        // Create the payment method by calling the Create method from the service
        PaymentMethod paymentMethod = paymentMethodService.Create(paymentMethodOptions);

        // Return the created payment method
        return paymentMethod;
    }
    catch (StripeException ex)
    {
        // Log the error message for debugging
        Console.WriteLine($"Stripe Exception: {ex.StripeError.Message}");

        // Throw a new exception with a custom message and the original exception as the inner exception
        throw new Exception("Failed to create payment method", ex);
    }
}

// Request class for creating a payment method
public class CreatePaymentMethodRequest
{
    public string Number { get; set; }
    public string Cvc { get; set; }
    public int ExpMonth { get; set; }
    public int ExpYear { get; set; }
}

Attach Payment Method
Move the payment method to the customer.

code sample
// Attaches an existing payment method to a customer
public bool AttachPaymentMethod(AttachPaymentMethodRequest attachPaymentMethodRequest)
{
    try
    {
        // Ensure Stripe is properly configured with the secret key
        ConfigureStripe();

        // Define the options for attaching the payment method to the customer
        var attachOptions = new PaymentMethodAttachOptions
        {
            Customer = attachPaymentMethodRequest.CustomerId // The ID of the customer to attach the payment method to
        };

        // Instantiate the PaymentMethodService to interact with Stripe's API
        var paymentMethodService = new PaymentMethodService();

        // Attach the payment method to the customer
        paymentMethodService.Attach(attachPaymentMethodRequest.PaymentMethodId, attachOptions);

        // Return true if the attachment is successful
        return true;
    }
    catch (StripeException ex)
    {
        // Log the error message for debugging
        Console.WriteLine($"Stripe Exception: {ex.StripeError.Message}");

        // Throw a new exception with a custom message and the original exception as the inner exception
        throw new Exception("Failed to attach payment method", ex);
    }
}

// Class representing the request for attaching a payment method
public class AttachPaymentMethodRequest
{
    public string CustomerId { get; set; }
    public string PaymentMethodId { get; set; }
}

Delete payment method
Remove the payment method from the customer using the Stripe customer ID and payment method ID.

Code sample
// Deletes (detaches) a payment method from a customer
public async Task<PaymentMethod?> DeleteCard(string customerId, string cardId)
{
    try
    {
        // Ensure Stripe is properly configured with the secret key
        ConfigureStripe();
        // Instantiate the PaymentMethodService to interact with Stripe's API
        var service = new PaymentMethodService();
        // Detach the payment method (card) from the customer using the card ID
        var paymentMethod = await service.DetachAsync(cardId);
        // Return the detached payment method
        return paymentMethod;
    }
    catch (StripeException ex)
    {
        // Log the error message for debugging
        Console.WriteLine($"Stripe Exception: {ex.StripeError.Message}");

        // Throw a new exception with a custom message and the original exception as the inner exception
        throw new Exception("Failed to delete payment method", ex);
    }
}

Payment Intent
The PaymentInten defines how the customer wants to pay for the service or business, and has details about the transaction, such as the supported payment methods, the amount to collect, and the desired currency.
Create Payment Intent with a Payment Method

Code Sample
// Creates a PaymentIntent for a specific payment
public PaymentIntent CreatePaymentIntent(CreatePaymentIntentRequest createPaymentIntentRequest)
{
    try
    {
        // Ensure Stripe is properly configured with the secret key
        ConfigureStripe();

        // Define the options for creating a payment intent
        var paymentIntentOptions = new PaymentIntentCreateOptions
        {
            Amount = createPaymentIntentRequest.Amount * 100, // Convert the amount to cents (Stripe expects the amount in the smallest currency unit)
            Currency = "usd", // Specify the currency for the payment
            Customer = createPaymentIntentRequest.CustomerId, // The Stripe customer ID associated with the payment
            PaymentMethod = createPaymentIntentRequest.PaymentMethodId, // The payment method to be used
            PaymentMethodTypes = new List<string> { "card" }, // Type of payment method (e.g., "card")
            OffSession = createPaymentIntentRequest.OffSession, // Indicates if the payment is happening off-session (e.g., without user interaction)
            Confirm = true // Automatically confirms the payment when created
        };

        // Instantiate the PaymentIntentService to interact with Stripe's API
        var paymentIntentService = new PaymentIntentService();

        // Create the payment intent using the defined options
        PaymentIntent paymentIntent = paymentIntentService.Create(paymentIntentOptions);

        // Return the created payment intent
        return paymentIntent;
    }
    catch (StripeException ex)
    {
        // Log the error message for debugging
        Console.WriteLine($"Stripe Exception: {ex.StripeError.Message}");

        // Throw a new exception with a custom message and the original exception as the inner exception
        throw new Exception("Failed to create payment intent", ex);
    }
}

// Request class for creating a PaymentIntent
public class CreatePaymentIntentRequest
{
    public string CustomerId { get; set; }
    public string PaymentMethodId { get; set; }
    public long Amount { get; set; } // Amount in cents
    public bool OffSession { get; set; } // Set true if charging without customer present (e.g., subscription)
}

Create payment intent without a payment method
It's like a direct one-time payment.

Code Sample
// Creates a PaymentIntent without specifying a payment method upfront (automatic payment methods enabled)
public Task<PaymentIntent> CreatePaymentIntentWithOutPaymentMethod(PaymentRequest request)
{
    try
    {
        // Ensure Stripe is properly configured with the secret key
        ConfigureStripe();
        // Define the options for creating a payment intent without a specified payment method
        var options = new PaymentIntentCreateOptions
        {
            Amount = request.Amount * 100, // Convert the amount to cents (Stripe expects the amount in the smallest currency unit)
            Currency = "usd", // Specify the currency for the payment
            AutomaticPaymentMethods = new PaymentIntentAutomaticPaymentMethodsOptions
            {
                Enabled = true, // Automatically enable supported payment methods (e.g., card)
            },
        };

        // Instantiate the PaymentIntentService to interact with Stripe's API
        var service = new PaymentIntentService();

        // Asynchronously create the payment intent using the defined options
        var paymentIntent = service.CreateAsync(options);

        // Return the task of the payment intent creation
        return paymentIntent;
    }
    catch (StripeException ex)
    {
        // Log the error message for debugging
        Console.WriteLine($"Stripe Exception: {ex.StripeError.Message}");

        // Throw a new exception with a custom message and the original exception as the inner exception
        throw new Exception("Failed to create payment intent", ex);
    }
}

Invoices
Invoices hold detailed information about the service provided, the due amount collected from the customer, and the customer's payment method.

Generate Invoice
// Generates and sends an invoice for a customer in Stripe
public Stripe.Invoice? GenerateInvoice(Invoice invoice)
{
    try
    {
        // Ensure Stripe is properly configured with the secret key
        ConfigureStripe();

        // Create invoice item options to specify the product/service being invoiced
        var invoiceItemOptions = new InvoiceItemCreateOptions
        {
            Customer = invoice.CustomerId.ToString(), // Customer ID for the invoice
            Amount = invoice.TotalAmount, // Total amount to be invoiced (in cents)
            Currency = "usd", // Currency for the invoice
            Description = "Product or Service Description", // Description of the product/service
        };

        // Create the invoice item (add a line item to the invoice)
        var invoiceItemService = new InvoiceItemService();
        var invoiceItem = invoiceItemService.Create(invoiceItemOptions); // This creates the invoice item

        // Define invoice options to create the actual invoice for the customer
        var invoiceOptions = new InvoiceCreateOptions
        {
            Customer = invoice.CustomerId, // Customer ID for the invoice
            AutoAdvance = true // Automatically finalize and send the invoice when it's created
        };

        // Create the invoice
        var invoiceService = new InvoiceService();
        var invoice1 = invoiceService.Create(invoiceOptions); // Create the invoice

        // Finalize the invoice (making it ready for payment)
        invoiceService.FinalizeInvoice(invoice1.Id);

        // Send the invoice to the customer
        var sendInvoiceOptions = new InvoiceSendOptions();
        invoiceService.SendInvoice(invoice1.Id, sendInvoiceOptions);

        // Return the generated invoice
        return invoice1;
    }
    catch (StripeException ex)
    {
        // Log the error message for debugging purposes
        Console.WriteLine($"Stripe Exception: {ex.StripeError.Message}");

        // Throw a new exception with a custom message and include the original exception for further debugging
        throw new Exception("Failed to generate invoice", ex);
    }
}

public class Invoice
{
    public int InvoiceId { get; set; }
    public DateTime InvoiceDate { get; set; }
    public string CustomerId { get; set; }
    public long TotalAmount { get; set; }
    public List<InvoiceLineItem> LineItems { get; set; }
}

public class InvoiceLineItem
{
    public int InvoiceLineItemId { get; set; }
    public int InvoiceId { get; set; }
    public string Description { get; set; }
    public int Quantity { get; set; }
    public decimal UnitPrice { get; set; }
    public decimal LineTotal => Quantity * UnitPrice;
    public Invoice Invoice { get; set; }
}

Pay Invoice
Customers can pay the invoice later, with the preferred payment method.
// Pays an invoice using a specified payment method
public Stripe.Invoice? PayInvoice(string paymentMethodID, string invoiceID)
{
    try
    {
        // Ensure Stripe is properly configured with the secret key
        ConfigureStripe();

        // Initialize the InvoiceService to interact with Stripe's invoice system
        var invoiceService = new InvoiceService();

        // Create options for paying the invoice, including the payment method ID
        var payInvoiceOptions = new InvoicePayOptions
        {
            PaymentMethod = paymentMethodID,  // Payment method ID (obtained from the customer or frontend)
        };

        // Attempt to pay the invoice using the provided payment method
        var paidInvoice = invoiceService.Pay(invoiceID, payInvoiceOptions);

        // Return the paid invoice object
        return paidInvoice;
    }
    catch (StripeException ex)
    {
        // Log the Stripe exception message for debugging purposes
        Console.WriteLine($"Stripe Exception: {ex.StripeError.Message}");

        // Throw a new exception with a custom message and include the original exception for further debugging
        throw new Exception("Failed to pay invoice", ex);
    }
}

Refund Customer
Refund plays a key role in the payment processing system; we can refund the amount when the amount was deducted wrong.
// Processes a refund for a specific charge made by a customer
public Stripe.Refund? Refund(string customerID, long amount)
{
    try
    {
        // Ensure Stripe is properly configured with the secret key
        ConfigureStripe();

        // Initialize the RefundService to interact with Stripe's refund system
        var refunds = new RefundService();

        // Create options for the refund, including the amount and the charge ID
        var options = new RefundCreateOptions
        {
            Amount = amount,  // The amount to refund (in cents, e.g., $50.00 is 5000)
            Charge = customerID // The ID of the charge to refund (associated with the customer)
        };

        // Attempt to create the refund using the provided options
        var payment = refunds.Create(options);

        // Return the refund object containing the details of the refund
        return payment;
    }
    catch (StripeException ex)
    {
        // Log the Stripe exception message for debugging purposes
        Console.WriteLine($"Stripe Exception: {ex.StripeError.Message}");

        // Throw a new exception with a custom message and include the original exception for further debugging
        throw new Exception("Failed to refund amount", ex);
    }
}

Conclusion
This approach enables the creation of a robust payment system integrated with Stripe, giving you the ability to scale and manage payments efficiently within your application.
Attached is the sample code.

By controlling the dependencies between classes, Dependency Injection (DI), a key idea in.NET Core, encourages loose coupling and testability. It is an application of the Inversion of Control (IoC) principle, which states that dependencies be supplied to objects rather than being constructed internally.

Key Concepts

1. Dependency: A class or interface that another class relies on.
2. Dependency Injection: The process of providing these dependencies to a class from an external source rather than the class creating them itself.
3. Service Container: A component responsible for managing the lifecycle of objects and resolving dependencies.

Use Dependency Injection
1. Define the Service Interface and Implementation.
Create an interface and its implementation for the service you want to inject.

public interface IGreetingService
{
    string GetGreeting();
}

public class GreetingService : IGreetingService
{
    public string GetGreeting()
    {
        return "Hello, Dependency Injection!";
    }
}

2. Register the Service in the Dependency Injection Container.
In the Program.cs file (or Startup.cs in older versions), register your service in the DI container.
var builder = WebApplication.CreateBuilder(args);

// Add services to the DI container
builder.Services.AddTransient<IGreetingService, GreetingService>();

var app = builder.Build();

3. Inject the Service Where Needed.
In an ASP.NET Core application, inject the service into a controller via its constructor.

public class HomeController : Controller
{
    private readonly IGreetingService _greetingService;

    public HomeController(IGreetingService greetingService)
    {
        _greetingService = greetingService;
    }

    public IActionResult Index()
    {
        var message = _greetingService.GetGreeting();
        return Content(message);
    }
}

Service Lifetime in .NET Core

Benefits of Dependency Injection

• Loose Coupling: Reduces dependencies between components, making the system modular.
• Testability: Facilitates unit testing by allowing mock dependencies.
• Centralized Configuration: All dependencies are managed in a single place.
• Improved Maintainability: Adding, updating, or replacing services becomes easier.