Today in this article we will see how to write Unit Test and Mock Automapper in ASP.NET Core application.

As we learned in our last article on Automapper, it was very easy to configure Automapper in the API pipeline using the Dependency Injection (DI) principle.

Although I found the IMapper interface does provide DI and allows us to program by Abstraction but still requires us to Initialize the Mapping configuration at startup.

Due to the same reason, IMapper can not be completely mocked by setting up a mock extension method in a regular way.

But we can very much use a declarative auto-mapper profile and inject it into our module.

Today in this article, we will cover below aspects,

Today I will talk about simple techniques to overcome this issue in this article.

Let’s first look at the SUT i.e. Software under test example.

Original Method where Automapper is used,

Please visit the below article for the complete code,

• Configure Automapper in ASP.NET Core – Getting Started

Below is how the profile is defined,

public class SourceMappingProfile : Profile
    {
        public SourceMappingProfile()
        {
            CreateMap<Source, Destination>()
                .ForMember(dest => dest.Name, o => o.MapFrom(src => src.FirstName))
                .ForMember(dest => dest.Identity, o => o.MapFrom(src => src.Id))
                .ForMember(dest => dest.Location, o => o.MapFrom(src => src.Address));
        }


    }

The test project does not have an inbuilt IoC hence we will have to initialize the Automapper configuration manually i.e. by instance invocation.

Test Initialize Mapping Profile

Here in the XUnit Test class, the constructor of TestClass gets called before the execution of any Test method. (which is equivalent to TestInitialize in MS Test terminology.)

Here we will instantiate the Automapper interface i.e. IMapper as Singleton so that the same instance will be used as-is for all Test methods.

    public class AutomapperASPNETCoreTests
    {
        private static IMapper _mapper;

        public AutomapperASPNETCoreTests()
        {
            if (_mapper == null)
            {
                var mappingConfig = new MapperConfiguration(mc =>
                {
                    mc.AddProfile(new SourceMappingProfile());
                });
                IMapper mapper = mappingConfig.CreateMapper();
                _mapper = mapper;
            }
        }

        [Fact]
        public void AutomapperASPNETCoreTest_Get_Valid_Mock_Automapper()
        {  
..
..
..

Injecting Mapper profile in Test method

Here below is the implementation of TestMethod AutomapperASPNETCoreTest_Get_Valid_Mock_Automapper.

This method when gets executed will initialize the IMapper instance with the given configuration and profile.

All the test methods will use the same instance when for one execution to simplify test method executions.

Below is the final implementation of the Test method,

The above method uses the IMapper instance as defined in the Constructor of Test class.

References:

• Configure Automapper in ASP.NET Core – Getting Started

• How to Name Unit Test cases – Best Practices

Do you have any comments or ideas or any better suggestions to share?

Please sound off your comments below.

Happy Coding !!

Please bookmark this page and share it with your friends. Please Subscribe to the blog to receive notifications on freshly published (2025) best practices and guidelines for software design and development.

The post Unit Test and Mock Automapper ASP.NET Core first appeared on TheCodeBuzz.

Today in this article we will see how to use CsvHelper – Read CSV files in C# .NET Core. Csvhelper is one of the simple and lightweight and most preferred parsers for CSV Reading and writing purposes.

.NET Core framework supports below easy to use other parsers for CSV file read and write purposes,

• TinyCSVParser

• CsvHelper

• TextFieldParser

Today in this article, we will cover the below aspects,

Getting Started

Let’s create a .NET Core application. To keep simple I have used the .NET Core console application. I have used the .NET Core 3.1 version but the below example works in any .NET Core frameworks.

Install Nuget Package

This package is available through Nuget Manager,

PM> Install-Package CsvHelper

It lets you read, parse, and write the CSV and helps you serialize and deserialize the data into proper objects too.

If the CSV file has a header to be read, then Specify the Header flag as true or false.

Here is the example of how to use CsvParser for reading,

partial class Program
    {
        static void Main(string[] args)
        {
            List<Userdetails> result;
            string jsonString;
            using (TextReader fileReader = File.OpenText("TestData.csv"))
            {
                var csv = new CsvReader(fileReader);
                csv.Configuration.HasHeaderRecord = false;
                csv.Read();
                result = csv.GetRecords<Userdetails>().ToList();
            }

            //Csv data as Json string if needed
            jsonString = JsonConvert.SerializeObject(result);
            foreach (UserDetails details in result)
            {
                Console.WriteLine(details.Name + " " + details.ID + " " + details.City + " " + details.Country);
            }
        }

I have used the model entity as below,

public class UserDetails
{
  public string ID { get; set; }
  public string Name { get; set; }
  public string City { get; set; }
  public string Country { get; set; }
}

CSV to Objects Conversion

As you can see above the GetRecords() method return result data (CSV column and row details) as Objects.

List<UserDetails> result = csv.GetRecords().ToList();

CSV to JSON Conversion

If you ever need to read a CSV file and return it JSON string in .NET Core then the below one-liner will do that trick.

jsonString = JsonConvert.SerializeObject(result);

You can use System.Text.Json as well for serialization and deserialization.

Here is the output on the console,

Other references :

• CSV Parsing in C# using TinyParser and TextFieldParser

Do you have any comments or ideas or any better suggestions to share?

Please sound off your comments below.

Happy Coding !!

Please bookmark this page and share it with your friends. Please Subscribe to the blog to receive notifications on freshly published (2025) best practices and guidelines for software design and development.

The post CsvHelper – Read CSV files in C# .NET Core first appeared on TheCodeBuzz.

Today in this article, we will cover below aspects,

Issue Description

ASP.NET Core deployment gives 502 errors with the below logs after the frequent intervals.

ASP.NET Core 502 API Gateway error with application shutdown is most visible in the logs

Error

“Application is shutting down”

Resolution

There could be multiple reasons for the application shutdown. Please make sure to validate the below steps.

Solution1 – Increase Memory Allocation

• Application shutdown could occur mainly if the application is loaded with more responsibility than it can handle.
• Please make sure you allocate enough memory or CPU depending on the number of requests API can handle. A good load test on API should provide the request load metrics of API.

Please update the YAML file,

resources:
    cpu: 2
    memory_gb: 2
    disk_size_gb: 10

If the above properties are not provided then the cloud environment will select default settings.

Example – 1 CPU or 1 GB memory etc.

Note – Application default settings could be less sustainable for your API.

Specifically if API handles a large load or more requests then above settings will need to be updated.

If you have tried the above option already still see the issue surfacing then please look at the below few options.

Solution2 – Liveness and readiness Health check probe

• Google Cloud uses liveness checks to confirm VM and the Docker container are healthy and running.
• Instances with unhealthy status are killed and restarted.
• In such a case please make sure the Liveness probe is successful as per the configuration.

Example,

 liveness_check:
  path: "/liveness_check"
  check_interval_sec: 30
  timeout_sec: 4
  failure_threshold: 2
  success_threshold: 2

Or

liveness_check:
  path: "/healthcheck"
  check_interval_sec: 30
  timeout_sec: 4
  failure_threshold: 2
  success_threshold: 2

The “path” variable can be defined by the API developer as required.

Please make sure you have a “path”: defined correctly. Example. “/liveness_check” or “/healthcheck” routes should return HTTP status 200 or OK response only.

For any reason, if “/healthcheck” is not defined or produces non-OK status then the google app engine initiates the container killing and restarting the container.

You can add health to ASP.NET Core in two simple easy steps which are explained in the below article.

Solution3 – Health route with empty route or controller “

If your API doesn’t specify any health route, then it is possible sometimes the Google app engine might look for the root route “/”.

If you have any custom health check then please specify the same else make sure you point to the correct health check here in the path: “/healthcheck”

Having a controller with an empty route “sometimes will resolve the issue.

Please try this too as one of the solutions to fix the issue.

References:

• Add Health Check in ASP.NET Core Applications
• Health Check Entity Framework Database in ASP.NET Core

Did I miss anything else in these resolution steps?

Did the above steps resolve your issue? Please sound off your comments below!

Happy Coding !!

Please bookmark this page and share it with your friends. Please Subscribe to the blog to receive notifications on freshly published (2025) best practices and guidelines for software design and development.

The post ASP.NET Core 502 API Gateway error in Google Cloud first appeared on TheCodeBuzz.

In this article, we will learn – how to enable JWT bearer Authorization in Swagger OpenAPI definition in API projects to execute various operations via swagger UI.

Today in this article we will cover below,

As we know Open API specification or Swagger V3.0 lets you define the different authentication types for an API like Basic authentication, OAuth2 Authentication, JWT bearer, etc.

In our last article, we learned how to Enable Swagger/Open API documentation to ASP.NET Core API in simple 2-3 steps.

We also learned JWT Authentication in ASP.NET Core 3.1 or .NET 5.0 with examples in our last article.

JWT Authorization Token in Swagger

Please kindly see the below article to understand the basic 2-3 steps workflow for enabling swagger in ASP.NET Core 3.1 or .NET 5 or .NET 6

• Enable Swagger/Open API documentation to ASP.NET Core

Please add two below methods as shown below,

• AddSecurityDefinition()

• AddSecurityRequirement()

AddSecurityDefinition – This method lets you define how your API is secured by defining one or more security schemes.

AddSecurityDefinition method lets you enable the below authentication schemes. (One can use multiple security schemes too if needed.)

• Basic Authentication using BasicAuthScheme

• JWT Bearer token using ApiKeyScheme

• OAuth2 authentication using OAuth2Scheme

Please make a note that there are a few breaking changes introduced in the recent ASP.NET Core 3.1 Swagger supports if you are migrating from older version.

A few major breaking changes for swagger in ASP.NET Core 3.1 and above are listed below,

• Info class renamed OpenApiInfo

• ApiKeyScheme class renamed to OpenApiSecurityScheme

• AddSecurityRequirement method has been updated to take OpenApiSecurityRequirement as an object parameter etc.

Getting started

You need the below Nuget package of Swashbuckle to work with ASP.NET Core.

 PM> Install-Package Swashbuckle.AspNetCore -Version 5.0.1 

Please use the latest available version of ‘Swashbuckle.AspNetCore‘ as and when available.

Step 1

The addSecurityDefinition method is defined as below,

c.AddSecurityDefinition("bearerAuth", new OpenApiSecurityScheme
                {
                    Name = "Authorization",
                    Type = SecuritySchemeType.Http,
                    Scheme = "bearer",
                    BearerFormat = "JWT",
                    In = ParameterLocation.Header,
                    Description = "JWT Authorization header using the Bearer scheme."
                });

In the above example, I have used the ‘Bearer’ scheme with scheme type as ApiKey.

Usually, the JWT bearer secured token can be made available as an environment variable or Secret Storage or could be made available through the DI using a configuration file.

Step 2

AddSecurityRequirement – This method lets you control the given authentication scheme applied at either the Global level or Operation level.

Please add the below code for AddSecurityRequirement()

c.AddSecurityRequirement(new OpenApiSecurityRequirement
                {
                    {
                          new OpenApiSecurityScheme
                            {
                                Reference = new OpenApiReference 
                                { 
                                    Type = ReferenceType.SecurityScheme, 
                                    Id = "bearerAuth" 
                                }
                            },
                            new string[] {}
                    }
                });

Finally, the complete code for the ConfigureServices method is as below,

Configure() method will remain as above,

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
        {
            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }

            app.UseSwagger();

            app.UseSwaggerUI(c =>
            {
                c.SwaggerEndpoint("/swagger/v1/swagger.json", "TestService");
            });

            app.UseHttpsRedirection();

            app.UseRouting();

            app.UseCors(x => x
               .AllowAnyOrigin()
               .AllowAnyMethod()
               .AllowAnyHeader());

            app.UseAuthentication();
            app.UseAuthorization();

            app.UseEndpoints(endpoints =>
            {
                endpoints.MapControllers();
            });
        }

Authorize button will be enabled in the swagger UI as below.

The security scheme configured here will be used by all routes decorated with Authorize attributes as this is enabled at the global level.

Please provide bearer value and click on Authorize.

Bearer token can be generated using a simple process and is discussed in our last article on JWT Authentication in .NET Core.

JWT (JSON Web Token)

Here let’s use the Generated JWT token in the previous article which is as below,

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJleHAiOjE1NzA5MDk3MDMsImlzcyI6Imh0dHBzOi8vbG9jYWxob3N0OjQ0MzQxIiwiYXVkIjoiaHR0cHM6Ly9sb2NhbGhvc3Q6NDQzNDEifQ.Is7QtMiknbSYHq8MFryCfXW25C8oK9tFZlD2jHEQTuo

Let’s execute the API to validate the authentication and see if it is working fine.

When using an HTTP Authentication scheme,

Note : If using SecuritySchemeType.ApiKey – token part should be appended with ‘bearer’.

Example: Bearer [token]

Note – If using SecuritySchemeType.Http – token need to be used without “bearer”

This authorization will be used for all swagger APIs that are attributed with the [Authorize] attribute due to the global settings defined above.

This token will be used for all secured APIs until it’s valid.

Response – Success ( 200)

After executing, please check the response below, we shall receive a successful response status (200: Ok)

We can see API decorated with [Authorize] keyword gets executed successfully from UI directly.

Response – Unauthorized ( 401)

If the token value is invalid or expired – You would receive 401: Unauthorized error as below,

Understanding Global Vs Operation level scheme

• Global Authentication scheme

Above we have used a global authentication scheme, this scheme will be applied to all REST APIs within Controllers and can be executed on all APIs decorated with the [Authorize] attribute.

In AddSecurityRequirement() the array of scopes MUST be empty I.e new string[] {} for JWT authorization.

• Operation-level Authentication scheme

Please see Enable JWT authorization in Swagger at the Operation level on how to enable the JWT authorization scheme at a specific operation level.

That’s all!

Other references :

• Swagger API Documentation in ASP.NET Core

• JWT Authentication in ASP.NET Core with examples

Do you have any comments or ideas or any better suggestions to share?

Please sound off your comments below.

Happy Coding !!

Summary

In this post, we learned new breaking changes with improved Swagger/ Open API document implementation.

We also learned, how to add JWT bearer authorization to Swagger documentation. Swagger or OpenAPI describes the standards and specifications of RESTFul API documentation.

It also helps to provide specifications around enabling authentication schemes BasicAuthScheme, ApiKeyScheme, and OAuth2Scheme to API using the Swashbuckle or NSwag tooling.

Please bookmark this page and share it with your friends. Please Subscribe to the blog to receive notifications on freshly published (2025) best practices and guidelines for software design and development.

The post JWT bearer Authorization in Swagger OpenAPI first appeared on TheCodeBuzz.

Today in this article we will see an easy-to-use Simple Retry pattern in C# .NET Retry pattern in C# which can be used for executing given business logic/code addressing multiple attempts to retry execution.

If you have a requirement, for adding a resilient logic processing then the code can retry attempting to execute the actions a few more times.

Such retries generally resolve the issues in the case of transient errors or any temporary issues giving the desired result for the request.

Example 1

Here is below a simple example of Retry logic using C# .NET which can be used to execute any of your custom logic bind to an action.

I am using the Console C# application below where I have static methods defined.

Below is how we can use the above Retry method in C# Calle side code

Retry(() =>PerformFileProcessing(filePath), 3);

• Here in the above example, action is mapped to the method -> PerformFileProcessing is a custom method/action that has some core logic. For example- it performs file operations like read or write.

• No of retry – For any exceptions method retries execution 3 times

private static void PerformFileProcessing(string filePath)
        {
            using (FileStream fsStrean = File.Create(filePath))
            {
                byte[] info = new UTF8Encoding(true).GetBytes("This is test file.");
                // Add details to the file.
                fsStrean.Write(info1, 0, info.Length);
            }
        }

Example 2

Alternatively, the below logic can be used for performing the retry.

private const int NumberOfRetries = 3;
  for (int i=1; i <= NumberOfRetries; ++i) {
    try {
        // Perfrom your business logic here
        break; // When done, break the  loop
        }
    catch (IOException e) when (i <= NumberOfRetries) {
    }
}

In the catch block, if needed, you can add a time delay to retry with a timeout so that each retry happens with some delay.

Retry logic comes in handy on many occasions especially if you are dealing with shared resources. Most transient errors are common examples of issues related to shared resources.

Such transient errors get auto corrected and hence retrying the logic sometimes resolves the issues.

Before retrying the logic, make sure the object is not in a faulted state and you use the clean object in the logic.

You can use the Polly library to implement the HTTP request retry mechanism easily.

Please visit this article for more details,

• Polly-Implement HTTPClient Retry resiliency using Polly

Do you have any comments or ideas or any better suggestions to share?

Please sound off your comments below.

Happy Coding !!

Please bookmark this page and share it with your friends. Please Subscribe to the blog to receive notifications on freshly published (2025) best practices and guidelines for software design and development.

The post Implement Simple Retry pattern in C# .NET- Resiliency first appeared on TheCodeBuzz.