necesito generar los unit test para el siguiente fragmento de código

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using AutoMapper;
using Microsoft.Extensions.Logging;
using Newtonsoft.Json;
using Spv.Usuarios.Bff.Common.Constants;
using Spv.Usuarios.Bff.Common.Dtos.Service.ConfiguracionService.Input;
using Spv.Usuarios.Bff.Common.Dtos.Service.ConfiguracionService.Output;
using Spv.Usuarios.Bff.Common.Errors;
using Spv.Usuarios.Bff.Common.ExternalResponses;
using Spv.Usuarios.Bff.Common.LogEvents;
using Spv.Usuarios.Bff.DataAccess.ExternalWebService.Interfaces;
using Spv.Usuarios.Bff.Domain.Errors;
using Spv.Usuarios.Bff.Domain.Exceptions;
using Spv.Usuarios.Bff.Domain.Services;
using Spv.Usuarios.Bff.Service.Interface;

namespace Spv.Usuarios.Bff.Service
{
    public class ConfiguracionService : IConfiguracionService
    {
        private readonly ILogger<ConfiguracionService> _logger;
        private readonly IApiUsuariosRepositoryV2 _apiUsuariosRepositoryV2;
        private readonly IMapper _mapper;

        public ConfiguracionService(
            ILogger<ConfiguracionService> logger,
            IApiUsuariosRepositoryV2 apiUsuariosRepositoryV2,
            IMapper mapper
        )
        {
            _logger = logger;
            _apiUsuariosRepositoryV2 = apiUsuariosRepositoryV2;
            _mapper = mapper;
        }

        public async Task<IResponse<LoginHabilitadoModelOutput>> LoginHabilitadoAsync(
            IRequestBody<LoginHabilitadoModelInput> LoginModel)
        {
            try
            {
                var LoginHabilitado = await ConfiguracionDigitalCredentialsAsync(AppConstants.LogInDisabled);

                if (LoginHabilitado == null)
                {
                    return Responses.NotFound<LoginHabilitadoModelOutput>(ErrorCode.LoginHabilitado.ErrorDescription);
                }

                var result = new LoginHabilitadoModelOutput();

                if ((string)LoginHabilitado.Value == "0")
                {
                    result.Habilitado = (string)LoginHabilitado.Value;
                    return Responses.Ok(result);
                }
                else if ((string)LoginHabilitado.Value == "1" || (string)LoginHabilitado.Value == "2")
                {
                    var LoginDefaultMessaje = await ConfiguracionDigitalCredentialsAsync(AppConstants.LogInDisabledMessage);
                    if (string.IsNullOrEmpty(LoginDefaultMessaje.Description))
                    {
                        LoginDefaultMessaje =
                            await ConfiguracionDigitalCredentialsAsync(AppConstants.LogInDefaultDisabledMessage);
                    }

                    result.Mensaje = LoginDefaultMessaje.Description;
                    result.Habilitado = (string)LoginHabilitado.Value;
                }
                else
                {
                    return Responses.NotFound<LoginHabilitadoModelOutput>(ErrorCode.LoginHabilitadoFueraDeRango
                        .ErrorDescription);
                }

                return Responses.Ok(result);
            }
            catch (Exception ex)
            {
                _logger.LogError(ConfiguracionServiceEvents.ExceptionCallingLoginHabilitado, ex.Message, ex);
                throw;
            }
        }

        public async Task<IResponse<ConfiguracionModelOutput>> ConfiguracionAsync(
            IRequestBody<ConfiguracionModelInput> configuracionInput
        )
        {
            var (Config, Error) = await ConfiguracionAsync(configuracionInput.Body);
            if (Error != null)
            {
                return Responses.Error<ConfiguracionModelOutput>(
                    Error.Codigo, 
                    _mapper.Map<List<InternalCodeAndDetailErrors>>(Error.Errores)
                );
            }

            return Responses.Ok(Config);
        }

        public async Task<ConfiguracionModelOutput> ConfiguracionDigitalCredentialsAsync(string name)
        {
            var (Config, Error) = await ConfiguracionAsync(new ConfiguracionModelInput { Type = AppConstants.DigitalCredentials, Name = name });
            if (Error != null)
            {
                throw new BusinessException(Error.Detalle, Error.Codigo);
            }

            return Config;
        }

        private async Task<(ConfiguracionModelOutput Config, ApiUsuariosErrorResponse Error)> ConfiguracionAsync(ConfiguracionModelInput configuracionInput)
        {
            try
            {
                var response = await _apiUsuariosRepositoryV2.ObtenerConfiguracionAsync(configuracionInput);
                var content = await response.Content.ReadAsStringAsync();

                if (!response.IsSuccessStatusCode)
                {
                    var error = JsonConvert.DeserializeObject<ApiUsuariosErrorResponse>(content);

                    return (null, error);
                }

                var result = JsonConvert.DeserializeObject<ConfiguracionModelOutput>(content);

                return (result, null);
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, ConfiguracionServiceEvents.ExceptionConfiguracionMessage);
                throw;
            }
        }
    }
}