Tengo este método
        public async Task<IResponse<PerfilModelOutput>> ObtenerUsuarioAsync(
            IRequestBody<ObtenerUsuarioModelInput> obtenerUsuarioModel
        )
        {
            var body = obtenerUsuarioModel.Body;
            var fromNewVersionDb = true;
            var username = body.Usuario;
            var whitelist = await _configuracionesService.WhitelistCanalesAutenticacionAsync();

            try
            {
                if (!whitelist.Any(a => a.Equals(obtenerUsuarioModel.XCanal, StringComparison.OrdinalIgnoreCase)))
                    username = _rsaCryptoService.Decrypt(username);

                IUsuario usuario = await _usuarioV2Repository.ObtenerUsuarioAsync(
                    _encryption.GetHash(username),
                    body.NumeroDocumento
                );
                var cuil = string.Empty;

                if (usuario == null)
                {
                    Usuario usuarioLegacy = await _usuarioRepository.ObtenerUsuarioAsync(
                    username,
                    body.NumeroDocumento
                );

                    if (usuarioLegacy == null)
                    {
                        if (obtenerUsuarioModel.RequestFromKeycloak())
                        {
                            await _cacheService.SetInMinutesAsync(
                                Cache.Usuario.ObtenerUsuario(username),
                                ErrorCode.UsuarioIncorrecto,
                                1
                            );
                        }

                        return Responses.NotFound<PerfilModelOutput>(ErrorCode.UsuarioInexistente.ErrorDescription);
                    }
                    cuil = usuarioLegacy.GetCuil();
                    usuario = usuarioLegacy;
                    fromNewVersionDb = false;
                }

                var perfil = await ObtenerUsuarioAsync(usuario, cuil, fromNewVersionDb);

                return Responses.Ok(perfil);
            }
            catch (DecryptException ex)
            {
                _logger.LogError(ex, UsuarioServiceEvents.CallingObtenerUsuarioMessage);
                return Responses.NotFound<PerfilModelOutput>(ErrorCode.UsuarioInexistente.ErrorDescription);
            }
            catch (Exception ex)
            {
                _logger.LogError(
                    UsuarioServiceEvents.ExceptionCallingValidacionExistencia(obtenerUsuarioModel.Body.NumeroDocumento),
                    ex.Message,
                    ex
                );
                throw;
            }
        }

que llama a este otro método

 private async Task<PerfilModelOutput> ObtenerUsuarioAsync(IUsuario usuario, string cuil, bool migrated)
        {
            try
            {
                var firstName = string.Empty;
                var lastName = string.Empty;
                var personId = await VerificarPersonId(usuario);
                var email = usuario?.GetDatosUsuario()?.Mail ?? string.Empty;
                var documentNumber = usuario?.GetDocumentNumber() ?? string.Empty;
                var documentType = usuario?.GetDocumentType() ?? 0;


                if (migrated)
                {
                    var personaFisica = await _personasService.ObtenerInfoPersonaFisicaAsync(personId);

                    documentNumber = usuario != null ? usuario.GetDocumentNumber() : personaFisica?.NumeroDocumento;

                    if (personaFisica == null)
                    {
                        return new PerfilModelOutput
                        {
                            PersonId = personId,
                            Email = email,
                            FirstName = firstName,
                            LastName = lastName,
                            Migrated = true,
                            Cuil = cuil,
                            DocumentNumber = documentNumber,
                            DocumentType = documentType
                        };
                    }

                    firstName = string.IsNullOrEmpty(firstName) ? personaFisica.Nombre : firstName;
                    lastName = string.IsNullOrEmpty(lastName) ? personaFisica.Apellido : lastName;
                    cuil = string.IsNullOrEmpty(cuil) ? personaFisica.NumeroTributario : cuil;
                    documentType = documentType != 0 ? documentType : personaFisica.TipoDocumento;

                }
                else
                {
                    firstName = usuario.GetName();
                    lastName = usuario.GetLastName();
                }

                return new PerfilModelOutput
                {
                    PersonId = personId,
                    Email = email,
                    FirstName = firstName,
                    LastName = lastName,
                    Migrated = migrated,
                    Cuil = cuil,
                    DocumentNumber = documentNumber,
                    DocumentType = documentType
                };
            }
            catch (Exception ex)
            {
                _logger.LogError(ex, UsuarioServiceEvents.CallingObtenerUsuarioMessage);
                throw;
            }
        }

y tengo el siguiente test creado

namespace Spv.Usuarios.Test.Unit.Service.UsuariosService
{
    public class ObtenerUsuarioAsyncTest
    {
        public static IEnumerable<object[]> Datos => new List<object[]>
        {
            new object[] { "username0", DocUsuarioTest1, true, StatusCodes.Status200OK },
            new object[] { "username1", DocUsuarioTest2, true, StatusCodes.Status200OK }
        };

        private const string DocUsuarioTest1 = "12345678";
        private const string DocUsuarioTest2 = "87654321";

        private const long PersonId0 = 0;
        private const long PersonId1 = 1;

        private static readonly PersonaFisicaInfoModelOutput PersonaModelMock = new PersonaFisicaInfoModelOutput()
        {
            NumeroTributario = "20123456786",
            NumeroDocumento = "12345678"

        };

        private static readonly PersonaFisicaInfoModelOutput PersonaModelMock2 = new PersonaFisicaInfoModelOutput()
        {
            NumeroTributario = "20876543216",
            NumeroDocumento = "87654321"
        };

        private static readonly Usuario UsuarioMock = new Usuario
        {
            UserId = 0,
            UserName = "username0",
            Password = "clave_encriptada0",
            UserStatusId = 3,
            UserData = new DatosUsuario
            {
                PersonId = PersonId0.ToString()
            },
            DocumentNumber = DocUsuarioTest1,
            DocumentCountryId = "80",
            DocumentTypeId = 4,
            CUIL = "20123456786"
        };

        private static readonly UsuarioV2 UsuarioV2Mock = new UsuarioV2
        {
            UserId = 1,
            Username = "username1",
            Password = "clave_encriptada1",
            UserStatusId = (byte)UserStatus.Active,
            LoginAttempts = 0,
            LastPasswordChange = DateTime.Now.AddDays(-10),
            DocumentNumber = DocUsuarioTest2,
            DocumentCountryId = 80,
            DocumentTypeId = 4,
            PersonId = PersonId1
        };

        private static readonly ApiHeaders Headers = new ApiHeaders
        {
            XAplicacion = "app",
            XCanal = "HBI",
            XUsuario = "user",
            XRequestId = "1"
        };

        private static Usuarios.Service.UsuariosService CrearUsuarioService(
            IUsuarioRepository usuarioRepository,
            IUsuarioV2Repository usuarioV2Repository,
            IPersonasService personasService
        )
        {
            var loggerMock = new Mock<ILogger<Usuarios.Service.UsuariosService>>();
            var auditoriaLogV2Repository = new Mock<IAuditoriaLogV2Repository>();
            var configuracionesService = new Mock<IConfiguracionHbiService>();
            var configuracionesV2Service = new Mock<IConfiguracionesV2Service>();
            var encryptionMock = new Mock<IEncryption>();
            var helperDbServerMock = new Mock<IHelperDbServer>();
            var helperDbServerMockV2 = new Mock<IHelperDbServerV2>();
            var auditoriaMock = new Mock<IAuditoriaRepository>();
            var datosUsuarioRepository = new Mock<IDatosUsuarioRepository>();
            var nsbtRepository = new Mock<INsbtRepository>();
            var tDesRepository = new Mock<ITDesEncryption>();
            var historialClaveUsuariosV2Repository = new Mock<IHistorialClaveUsuariosV2Repository>();
            var historialUsuarioUsuariosV2Repository = new Mock<IHistorialUsuarioUsuariosV2Repository>();
            var historialClaveUsuariosRepository = new Mock<IHistorialClaveUsuariosRepository>();
            var reglaValidacionV2Repository = new Mock<IReglaValidacionV2Repository>();

            helperDbServerMock.Setup(m => m.ObtenerFechaAsync()).ReturnsAsync(new FechaDbServer { Now = DateTime.Now });

            helperDbServerMockV2.Setup(m => m.ObtenerFechaAsync())
                .ReturnsAsync(new FechaDbServerV2 { Now = DateTime.Now });

            configuracionesService.Setup(m => m.WhitelistCanalesAutenticacionAsync()).ReturnsAsync(new[] { "hbi" });

            return new Usuarios.Service.UsuariosService(
                loggerMock.Object,
                usuarioRepository,
                usuarioV2Repository,
                auditoriaMock.Object,
                auditoriaLogV2Repository.Object,
                configuracionesService.Object,
                configuracionesV2Service.Object,
                encryptionMock.Object,
                helperDbServerMock.Object,
                helperDbServerMockV2.Object,
                datosUsuarioRepository.Object,
                nsbtRepository.Object,
                tDesRepository.Object,
                historialClaveUsuariosV2Repository.Object,
                historialUsuarioUsuariosV2Repository.Object,
                historialClaveUsuariosRepository.Object,
                reglaValidacionV2Repository.Object,
                MapperProfile.GetAppProfile(),
                new Mock<ICacheService>().Object,
                personasService,
                new Mock<IRsaCryptoService>().Object,
                new Mock<IBackgroundJobClient>().Object
            );
        }

        [Theory]
        [MemberData(nameof(Datos))]
        public async Task ObtenerUsuario(string username, string nroDocumento, bool isOk, int statusCode)
        {
            // Arrange
            var usuarioRepository = new Mock<IUsuarioRepository>();
            var usuarioV2Repository = new Mock<IUsuarioV2Repository>();
            var personasService = new Mock<IPersonasService>();

            usuarioRepository.Setup(m => m.ObtenerUsuarioAsync(username, nroDocumento)).ReturnsAsync(UsuarioMock);
            usuarioV2Repository.Setup(m => m.ObtenerUsuarioAsync(username, nroDocumento)).ReturnsAsync(UsuarioV2Mock);

            personasService.Setup(m => m.ObtenerInfoPersonaFisicaAsync(It.IsAny<long>()))
                .ReturnsAsync(new PersonaFisicaInfoModelOutput());

            var datosRequestCorrectos = new ObtenerUsuarioModelInput
            {
                Usuario = username,
                NumeroDocumento = nroDocumento
            };

            var sut = CrearUsuarioService(
                usuarioRepository.Object,
                usuarioV2Repository.Object,
                personasService.Object
            );

            // Act
            var resultado = await sut.ObtenerUsuarioAsync(
                await Headers.ToRequestBodyAsync(datosRequestCorrectos, AllowedChannelsBuilder.CrearAllowedChannels())
            );

            // Assert
            resultado.IsOk.Should().Be(isOk);
            resultado.StatusCode.Should().Be(statusCode);

            if (statusCode == StatusCodes.Status200OK)
            {
                var res = resultado.Match(
                    a => a.Payload,
                    a => new PerfilModelOutput(),
                    a => new PerfilModelOutput()
                );

                if (res.Migrated)
                {
                    res.PersonId.Should().Be(UsuarioV2Mock.PersonId);
                    res.Migrated.Should().BeTrue();
                }
                else
                {
                    res.PersonId.ToString().Should().Be(UsuarioMock.UserData.PersonId);
                    res.Migrated.Should().BeFalse();
                }
                res.Cuil.Should().Be(UsuarioMock.CUIL);
                res.DocumentNumber.Should().Be(UsuarioMock.DocumentNumber);
                res.DocumentType.Should().Be(UsuarioMock.DocumentTypeId);
            }
        }

        [Fact]
        public async Task ObtenerUsuario_UsuarioMigrado()
        {
            // Arrange
            var usuarioRepository = new Mock<IUsuarioRepository>();
            var usuarioV2Repository = new Mock<IUsuarioV2Repository>();
            var personasService = new Mock<IPersonasService>();

            var datosRequestCorrectos = new ObtenerUsuarioModelInput
            {
                Usuario = "username0",
                NumeroDocumento = "87654321"
            };

            usuarioRepository.Setup(m => m.ObtenerUsuarioAsync(It.IsAny<string>(), DocUsuarioTest1))
                .ReturnsAsync(UsuarioMock);

            usuarioV2Repository.Setup(m => m.ObtenerUsuarioAsync(It.IsAny<string>(), DocUsuarioTest2))
                .ReturnsAsync(UsuarioV2Mock);

            personasService.Setup(m => m.ObtenerInfoPersonaFisicaAsync(It.IsAny<long>()))
                .ReturnsAsync(PersonaModelMock2);

            var sut = CrearUsuarioService(
                usuarioRepository.Object,
                usuarioV2Repository.Object,
                personasService.Object
            );

            // Act
            var resultado = await sut.ObtenerUsuarioAsync(
                await Headers.ToRequestBodyAsync(datosRequestCorrectos, AllowedChannelsBuilder.CrearAllowedChannels())
            );

            var res = resultado.Match(
                a => a.Payload,
                a => new PerfilModelOutput(),
                a => new PerfilModelOutput());

            // Assert
            resultado.IsOk.Should().Be(true);
            resultado.StatusCode.Should().Be(StatusCodes.Status200OK);

            res.PersonId.Should().Be(UsuarioV2Mock.GetPersonId());
            res.Migrated.Should().Be(true);
            res.Cuil.Should().Be(PersonaModelMock2.NumeroTributario);
            res.DocumentNumber.Should().Be(UsuarioV2Mock.DocumentNumber);
            res.DocumentType.Should().Be(UsuarioV2Mock.DocumentTypeId);
        }

        [Fact]
        public async Task ObtenerUsuario_UsuarioNoMigrado()
        {
            // Arrange
            var usuarioRepository = new Mock<IUsuarioRepository>();
            var usuarioV2Repository = new Mock<IUsuarioV2Repository>();
            var personasService = new Mock<IPersonasService>();

            var datosRequestCorrectos = new ObtenerUsuarioModelInput
            {
                Usuario = "username1",
                NumeroDocumento = "12345678"
            };

            usuarioRepository.Setup(m => m.ObtenerUsuarioAsync(It.IsAny<string>(), DocUsuarioTest1))
                .ReturnsAsync(UsuarioMock);

            personasService.Setup(m => m.ObtenerInfoPersonaFisicaAsync(It.IsAny<long>()))
                .ReturnsAsync(new PersonaFisicaInfoModelOutput());

            var sut = CrearUsuarioService(
                usuarioRepository.Object,
                usuarioV2Repository.Object,
                personasService.Object
            );

            // Act
            var resultado = await sut.ObtenerUsuarioAsync(
                await Headers.ToRequestBodyAsync(datosRequestCorrectos, AllowedChannelsBuilder.CrearAllowedChannels())
            );

            var res = resultado.Match(
                a => a.Payload,
                a => new PerfilModelOutput(),
                a => new PerfilModelOutput()
            );

            // Assert
            resultado.IsOk.Should().Be(true);
            resultado.StatusCode.Should().Be(StatusCodes.Status200OK);

            res.PersonId.Should().Be(UsuarioMock.GetPersonId());
            res.Migrated.Should().Be(false);
            res.Cuil.Should().Be(UsuarioMock.CUIL);
            res.DocumentNumber.Should().Be(UsuarioMock.DocumentNumber);
            res.DocumentType.Should().Be(UsuarioMock.DocumentTypeId);
        }

        [Fact]
        public async Task ObtenerUsuario_ThrowException()
        {
            // Arrange
            var usuarioRepository = new Mock<IUsuarioRepository>();
            var usuarioV2Repository = new Mock<IUsuarioV2Repository>();
            var personasService = new Mock<IPersonasService>();

            var datosRequestCorrectos = new ObtenerUsuarioModelInput
            {
                Usuario = "username1",
                NumeroDocumento = "12345678"
            };

            usuarioRepository.Setup(m => m.ObtenerUsuarioAsync(It.IsAny<string>(), It.IsAny<string>()))
                .ReturnsAsync(UsuarioMock);

            usuarioV2Repository.Setup(m => m.ObtenerUsuarioAsync(It.IsAny<string>(), It.IsAny<string>()))
                .Throws(new Exception("Excepción no controlada"));

            var sut = CrearUsuarioService(
                usuarioRepository.Object,
                usuarioV2Repository.Object,
                personasService.Object
            );

            // Act
            var resultado = await Assert.ThrowsAsync<Exception>(async () =>
                await sut.ObtenerUsuarioAsync(
                    await Headers.ToRequestBodyAsync(
                        datosRequestCorrectos,
                        AllowedChannelsBuilder.CrearAllowedChannels()
                    )
                )
            );

            // Assert
            resultado.Message.Should().Be("Excepción no controlada");
        }


    }
}

Pero el Sonarqube me dice que no estoy cubriendo varias lineas del método

                var perfil = await ObtenerUsuarioAsync(usuario, cuil, fromNewVersionDb);