public async Task WithExpiredCertificate_InstallFromPMCForPC_WarnAsync(ProjectTemplate projectTemplate)
{
// Arrange
EnsureVisualStudioHost();
using (var testContext = new ApexTestContext(VisualStudio, projectTemplate, XunitLogger))
using (var trustedExpiringTestCert = SigningTestUtility.GenerateTrustedTestCertificateThatExpiresIn10Seconds())
{
XunitLogger.LogInformation("Creating package");
var package = CommonUtility.CreatePackage("ExpiredTestPackage", "1.0.0");
XunitLogger.LogInformation("Signing package");
var expiredTestPackage = CommonUtility.AuthorSignPackage(package, trustedExpiringTestCert.Source.Cert);
await SimpleTestPackageUtility.CreatePackagesAsync(testContext.PackageSource, expiredTestPackage);
XunitLogger.LogInformation("Waiting for package to expire");
SigningUtility.WaitForCertificateToExpire(trustedExpiringTestCert.Source.Cert);
var nugetConsole = GetConsole(testContext.Project);
nugetConsole.InstallPackageFromPMC(expiredTestPackage.Id, expiredTestPackage.Version);
// TODO: Fix bug where no warnings are shown when package is untrusted but still installed
//nugetConsole.IsMessageFoundInPMC("expired certificate").Should().BeTrue("expired certificate warning");
CommonUtility.AssetPackageInPackagesConfig(VisualStudio, testContext.Project, expiredTestPackage.Id, expiredTestPackage.Version, XunitLogger);
}
}
public ILogger CreateLogger(string categoryName)
{
var logger = new XunitLogger(testOutputHelper, categoryName);
loggers.Add(logger);
return(logger);
}
public async Task WithExpiredAuthorCertificate_ExpiredRepoCertificate_InstallFromPMCForPC_WarnAsync(ProjectTemplate projectTemplate)
{
// Arrange
EnsureVisualStudioHost();
using (var testContext = new ApexTestContext(VisualStudio, projectTemplate, XunitLogger))
using (var trustedExpiringTestCert = SigningTestUtility.GenerateTrustedTestCertificateThatExpiresIn5Seconds())
{
XunitLogger.LogInformation("Creating package");
var package = CommonUtility.CreatePackage("ExpiredTestPackage", "1.0.0");
XunitLogger.LogInformation("Signing and countersigning package");
var expiredTestPackage = CommonUtility.AuthorSignPackage(package, trustedExpiringTestCert.Source.Cert);
var countersignedPackage = CommonUtility.RepositoryCountersignPackage(
expiredTestPackage,
trustedExpiringTestCert.Source.Cert,
new Uri("https://v3serviceIndexUrl.test/api/index.json"));
await SimpleTestPackageUtility.CreatePackagesAsync(testContext.PackageSource, expiredTestPackage);
XunitLogger.LogInformation("Waiting for package to expire");
SigningUtility.WaitForCertificateToExpire(trustedExpiringTestCert.Source.Cert);
var nugetConsole = GetConsole(testContext.Project);
nugetConsole.InstallPackageFromPMC(expiredTestPackage.Id, expiredTestPackage.Version);
testContext.Project.Build();
testContext.NuGetApexTestService.WaitForAutoRestore();
// TODO: Fix bug where no warnings are shown when package is untrusted but still installed
//nugetConsole.IsMessageFoundInPMC("expired certificate").Should().BeTrue("expired certificate warning");
CommonUtility.AssertPackageReferenceExists(VisualStudio, testContext.Project, expiredTestPackage.Id, expiredTestPackage.Version, XunitLogger);
}
}
public void DeveTestar()
{
//Given
var settings = new RabbitMQSettings
{
HostName = "localhost",
Port = 5672,
UserName = "******",
Password = "******"
};
var logger = new XunitLogger <EventBusRabbitMQ>();
var loggerFactoryMock = new Mock <ILoggerFactory>();
loggerFactoryMock.Setup(setup => setup.CreateLogger(It.IsAny <string>())).Returns(logger);
var rabbitMQConnectionMock = new Mock <RabbitMQConnection>(loggerFactoryMock.Object, settings);
var eventBusRabbitMQ = new EventBusRabbitMQ(loggerFactoryMock.Object, rabbitMQConnectionMock.Object);
var teste = new Teste
{
Nome = Guid.NewGuid().ToString()
};
//When
eventBusRabbitMQ.Subscribe <Teste>(received: EventBusRabbitMQ_OnReceivedMessage);
eventBusRabbitMQ.Publish(teste);
//Then
logger.Logs.Should().NotBeEmpty();
}
public async Task DeveConverterIAsyncEnumerableEmIEnumerable()
{
var entity = new AggregateRoot();
var entity2 = new AggregateRoot();
//Given
var entitiesAsync = GetAllAggregateRootAsyncEnumerable(entity, entity2);
Mock <DbSet <AggregateRoot> > setMock = new Mock <DbSet <AggregateRoot> >();
setMock.Setup(set => set.AsAsyncEnumerable()).Returns(entitiesAsync);
Mock <DbContext> dbContextMock = new Mock <DbContext>();
dbContextMock.Setup(context => context.Set <AggregateRoot>()).Returns(setMock.Object);
var logger = new XunitLogger <Repository <AggregateRoot, Guid> >();
var repository = new Repository <AggregateRoot, Guid>(dbContextMock.Object, logger);
//When
var entities = await repository.GetAllAsync().AsyncEnumerableToEnumerable();
//Then
entities.Should().BeOfType <List <AggregateRoot> >();
entities.Should().HaveCount(2);
entities.FirstOrDefault(f => f.Id == entity.Id).Should().NotBeNull();
entities.FirstOrDefault(f => f.Id == entity2.Id).Should().NotBeNull();
}
public SmokeTestsOnNanoServerUsingSharedRuntime(
DotnetRuntimeSetupTestFixture dotnetRuntimeSetupTestFixture, ITestOutputHelper output)
{
_logger = new XunitLogger(output, LogLevel.Information);
_remoteDeploymentConfig = RemoteDeploymentConfigHelper.GetConfiguration();
_remoteDeploymentConfig.DotnetRuntimePathOnShare = dotnetRuntimeSetupTestFixture.DotnetRuntimePathOnShare;
_smokeTestsOnNanoServer = new SmokeTestsOnNanoServer(output, _remoteDeploymentConfig, _logger);
}
public Facts(ITestOutputHelper output)
{
MetadataResource = new Mock <PackageMetadataResource>();
Logger = new XunitLogger <VersionRangeCalculator>(output);
Target = new VersionRangeCalculator(
Task.FromResult(MetadataResource.Object),
Logger);
}
public CrudTests(ITestOutputHelper output)
{
var context = new DummyDataDBInitializer().CreateContextForInMemory();
DummyDataDBInitializer db = new DummyDataDBInitializer();
db.Seed(context);
_repo = new Repository <BaseEntity>(context);
_logger = new XunitLogger <TestController>(output);
}
protected SharedVisualStudioHostTestClass(IVisualStudioHostFixtureFactory contextFixtureFactory, ITestOutputHelper output)
{
XunitLogger = new XunitLogger(output);
_contextFixtureFactory = contextFixtureFactory;
_hostFixture = new Lazy <VisualStudioHostFixture>(() =>
{
return(_contextFixtureFactory.GetVisualStudioHostFixture());
});
}
public void Deve_Registrar_Logs_No_Repositorio()
{
//Given
var entity = new TestEntity();
var setMock = new Mock <DbSet <TestEntity> >();
setMock.Setup(setup => setup.FindAsync(It.IsAny <Guid>())).ReturnsAsync(entity);
setMock.Setup(setup => setup.Attach(It.IsAny <TestEntity>()))
.Returns <EntityEntry <TestEntity> >(entry =>
{
var entityEntryMock = new Mock <EntityEntry <TestEntity> >();
entityEntryMock.SetupProperty(p => p.State, EntityState.Added);
return(entityEntryMock.Object);
});
var coreContextMock = new Mock <CoreContext>();
coreContextMock.Setup(context => context.Set <TestEntity>()).Returns(setMock.Object);
var logger = new XunitLogger <Repository <TestEntity, Guid> >();
var loggerFactoryMock = new Mock <ILoggerFactory>();
loggerFactoryMock.Setup(setup => setup.CreateLogger(It.IsAny <string>())).Returns(logger);
var repositoryMock = new Repository <TestEntity, Guid>(coreContextMock.Object, loggerFactoryMock.Object);
//When
repositoryMock.GetByIdAsync(entity.Id);
repositoryMock.GetAllAsync();
repositoryMock.InsertAsync(entity);
repositoryMock.UpdateAsync(entity);
repositoryMock.DeleteAsync(entity.Id).ConfigureAwait(false);
repositoryMock.DeleteAsync(entity).ConfigureAwait(false);
repositoryMock.SaveChangesAsync();
//Then
var msgContructor = "Inicializando Repository<TestEntity, Guid>";
var msgGetById = $"Método: GetByIdAsync( {{ id:{ entity.Id } }} ) Retorno: type TestEntity";
var msgGetAllAsync = "Método: GetAllAsync() Retorno: IAsyncEnumerable<TestEntity>";
var msgInsertAsync = $"Método: InsertAsync( {{entity:{ entity.ToJson() }}} )";
var msgUpdateAsync = $"Método: UpdateAsync( {{entity:{ entity.ToJson() }}} )";
var msgDeleteAsync = $"Método: DeleteAsync( {{entity:{ entity.ToJson() }}} )";
var msgSaveChanges = "Método: SaveChangesAsync()";
logger.Logs.Should().HaveCount(8);
logger.Logs.Any(a => a.Equals(msgGetById)).Should().BeTrue();
logger.Logs.Any(a => a.Equals(msgContructor)).Should().BeTrue();
logger.Logs.Any(a => a.Equals(msgGetAllAsync)).Should().BeTrue();
logger.Logs.Any(a => a.Equals(msgInsertAsync)).Should().BeTrue();
logger.Logs.Any(a => a.Equals(msgUpdateAsync)).Should().BeTrue();
logger.Logs.Any(a => a.Equals(msgSaveChanges)).Should().BeTrue();
logger.Logs.Where(a => a.Equals(msgDeleteAsync)).Should().HaveCount(2);
}
public override void WriteLine(string value)
{
if (value == null)
{
XunitLogger.WriteLine();
}
else
{
XunitLogger.WriteLine(value);
}
}
public void Deve_Registrar_Logs_No_Repositorio_MongoDB()
{
//Given
var dataBaseName = "mongo-auto-create";
var entity = new AggregateRoot();
var mongoSettings = new MongoSettings
{
DatabaseName = dataBaseName,
ConnectionString = "mongodb://127.0.0.1:27017"
};
var setMock = new Mock <IMongoCollection <AggregateRoot> >();
var mongoContextMock = new Mock <MongoContext>(mongoSettings);
var logger = new XunitLogger <MongoRepository <AggregateRoot, Guid> >();
var loggerFactoryMock = new Mock <ILoggerFactory>();
loggerFactoryMock.Setup(setup => setup.CreateLogger(It.IsAny <string>())).Returns(logger);
var repositoryMock = new MongoRepository <AggregateRoot, Guid>(mongoContextMock.Object, loggerFactoryMock.Object);
//When
repositoryMock.GetByIdAsync(entity.Id).ConfigureAwait(false);
repositoryMock.GetAllAsync();
repositoryMock.InsertAsync(entity);
repositoryMock.UpdateAsync(entity);
repositoryMock.DeleteAsync(entity);
repositoryMock.DeleteAsync(entity.Id).ConfigureAwait(false);
repositoryMock.SaveChangesAsync();
//Then
var msgContructor = "Inicializando MongoRepository<AggregateRoot, Guid>";
var msgGetById = $"Método: GetByIdAsync( {{id:{ entity.Id }}} ) Retorno: type AggregateRoot";
var msgGetAllAsync = "Método: GetAllAsync() Retorno: IAsyncEnumerable<AggregateRoot>";
var msgInsertAsync = $"Método: InsertAsync( {{entity:{ entity.ToJson()}}} )";
var msgUpdateAsync = $"Método: UpdateAsync( {{entity:{ entity.ToJson()}}} )";
var msgDeleteAsync = $"Método: DeleteAsync( {{entity:{ entity.ToJson()}}} )";
var msgDeleteNotFoundAsync = $"Método: DeleteAsync( {{id:{ entity.Id }}} ) Registro não encontrado";
var msgSaveChanges = "Método: SaveChangesAsync()";
logger.Logs.Should().HaveCount(9);
logger.Logs.Any(a => a.Equals(msgGetById)).Should().BeTrue();
logger.Logs.Any(a => a.Equals(msgContructor)).Should().BeTrue();
logger.Logs.Any(a => a.Equals(msgGetAllAsync)).Should().BeTrue();
logger.Logs.Any(a => a.Equals(msgInsertAsync)).Should().BeTrue();
logger.Logs.Any(a => a.Equals(msgUpdateAsync)).Should().BeTrue();
logger.Logs.Any(a => a.Equals(msgDeleteAsync)).Should().BeTrue();
logger.Logs.Any(a => a.Equals(msgDeleteNotFoundAsync)).Should().BeTrue();
logger.Logs.Any(a => a.Equals(msgSaveChanges)).Should().BeTrue();
mongoContextMock.Object.MongoClient.DropDatabase(dataBaseName);
mongoContextMock.Object.Dispose();
}
public SmokeTestsOnNanoServer(ITestOutputHelper output)
{
_logger = new XunitLogger(output, LogLevel.Information);
var configuration = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("remoteDeploymentConfig.json")
.AddEnvironmentVariables()
.Build();
_remoteDeploymentConfig = new RemoteDeploymentConfig();
configuration.GetSection("NanoServer").Bind(_remoteDeploymentConfig);
}
public async Task ValidNavigation_DoesNotUsePageDialogService()
{
var navService = new NavigationServiceMock();
var dialogService = new PageDialogServiceMock();
var logger = new XunitLogger(TestOutputHelper);
var vm = new ReactiveMockViewModel(navService, dialogService, logger);
// Assert.True(vm.NavigateCommand.CanExecute("good"));
await vm.NavigateCommand.Execute("good");
Assert.Null(dialogService.Title);
Assert.Null(dialogService.Message);
}
public Facts(ITestOutputHelper output)
{
StorageService = new InMemoryStorageService();
HttpCacheUtility = new LocalStorageHttpCacheUtility(StorageService);
ConcurrencyUtility = new InMemoryConcurrencyUtility();
SourceRepository = Repository.Factory.GetCustomRepository(HttpCacheUtility, ConcurrencyUtility);
Logger = new XunitLogger <VersionRangeCalculator>(output);
Token = CancellationToken.None;
Target = new VersionRangeCalculator(
SourceRepository.GetResourceAsync <PackageMetadataResource>(),
Logger);
}
public async Task ValidNavigation_DoesNotUsePageDialogService()
{
var navService = new NavigationServiceMock();
var dialogService = new PageDialogServiceMock();
var logger = new XunitLogger(TestOutputHelper);
var baseServices = new BaseServices(navService, Mock.Of <IDialogService>(), dialogService, logger, Mock.Of <IEventAggregator>(), Mock.Of <IDeviceService>(), new ResxLocalize());
var vm = new ReactiveMockViewModel(baseServices);
// Assert.True(vm.NavigateCommand.CanExecute("good"));
await vm.NavigateCommand.Execute("good");
Assert.Null(dialogService.Title);
Assert.Null(dialogService.Message);
}
private void WaitForCommandAvailable(Command cmd, TimeSpan timeout)
{
var stopWatch = new Stopwatch();
stopWatch.Start();
while (stopWatch.Elapsed < timeout)
{
if (cmd.IsAvailable)
{
return;
}
System.Threading.Thread.Sleep(250);
}
XunitLogger.LogWarning($"Timed out waiting for {cmd.Name} to be available");
}
public void ShouldExpandWithinDelimitedDatesOnly()
{
// arrange
var testLogger = new XunitLogger(testOutputHelper);
// act
var sut = new Fritz.ResourceManagement.Scheduling.ScheduleManager();
testOutputHelper.WriteLine(_MySchedule.RecurringSchedules[0].Duration.TotalHours.ToString());
var results = sut.ExpandSchedule(_MySchedule, new DateTime(2019, 6, 24), new DateTime(2019, 6, 26), testLogger);
// assert
results.Should().HaveCount(2);
results.First().StartDateTime.Hour.Should().Be(0);
results.First().EndDateTime.Hour.Should().Be(0);
}
public async Task InvalidNavigation_UsesPageDialogService()
{
var navService = new NavigationServiceMock();
var dialogService = new PageDialogServiceMock();
var logger = new XunitLogger(TestOutputHelper);
var vm = new ReactiveMockViewModel(navService, dialogService, logger);
// Assert.True(vm.NavigateCommand.CanExecute("bad"));
await vm.NavigateCommand.Execute("bad");
Assert.Equal(ToolkitResources.Error, dialogService.Title);
var errorMessage = new Exception("bad").ToErrorMessage();
var dialogMessage = string.Format(ToolkitResources.AlertErrorMessageTemplate, errorMessage, vm.CorrelationId);
Assert.NotNull(vm.CorrelationId);
Assert.Contains(dialogMessage, dialogService.Message);
}
public async Task WithExpiredAuthorCertificateAtCountersigning_InstallFromPMCForPR_WarnAsync(ProjectTemplate projectTemplate)
{
// Arrange
EnsureVisualStudioHost();
var timestampService = await _fixture.GetDefaultTrustedTimestampServiceAsync();
using (var testContext = new ApexTestContext(VisualStudio, projectTemplate, XunitLogger))
using (var trustedCert = _fixture.TrustedRepositoryTestCertificate)
using (var trustedExpiringTestCert = SigningTestUtility.GenerateTrustedTestCertificateThatExpiresIn10Seconds())
{
XunitLogger.LogInformation("Creating package");
var package = CommonUtility.CreatePackage("ExpiredTestPackage", "1.0.0");
XunitLogger.LogInformation("Signing package");
var expiredTestPackage = CommonUtility.AuthorSignPackage(package, trustedExpiringTestCert.Source.Cert);
await SimpleTestPackageUtility.CreatePackagesAsync(testContext.PackageSource, expiredTestPackage);
var packageFullName = Path.Combine(testContext.PackageSource, expiredTestPackage.PackageName);
XunitLogger.LogInformation("Waiting for package to expire");
SigningUtility.WaitForCertificateToExpire(trustedExpiringTestCert.Source.Cert);
XunitLogger.LogInformation("Countersigning package");
var countersignedPackage = await SignedArchiveTestUtility.RepositorySignPackageAsync(
new X509Certificate2(trustedCert.Source.Cert),
packageFullName,
testContext.PackageSource,
new Uri("https://v3serviceIndexUrl.test/api/index.json"),
timestampService.Url);
File.Copy(countersignedPackage, packageFullName, overwrite: true);
File.Delete(countersignedPackage);
var nugetConsole = GetConsole(testContext.Project);
nugetConsole.InstallPackageFromPMC(expiredTestPackage.Id, expiredTestPackage.Version);
testContext.SolutionService.Build();
testContext.NuGetApexTestService.WaitForAutoRestore();
// TODO: Fix bug where no warnings are shown when package is untrusted but still installed
//nugetConsole.IsMessageFoundInPMC("expired certificate").Should().BeTrue("expired certificate warning");
CommonUtility.AssertPackageReferenceExists(VisualStudio, testContext.Project, expiredTestPackage.Id, expiredTestPackage.Version, XunitLogger);
}
}
public async Task Deve_Registrar_Logs_No_Servico_Ao_Obter_Todos_Registros(IEnumerable <TestEntity> entities, IEnumerable <TestViewModel> viewModels)
{
//Given
var mapperMock = new Mock <IMapper>();
mapperMock.Setup(mapper => mapper.Map <IEnumerable <TestViewModel> >(It.IsAny <TestEntity>())).Returns(viewModels);
var unitOfWork = new Mock <IUnitOfWork>();
unitOfWork.Setup(uow => uow.CommitAsync()).ReturnsAsync(1);
var readRepository = new Mock <IReadRepository <TestEntity, Guid> >();
readRepository.Setup(setup => setup.GetAllAsync()).ReturnsAsync(entities);
var writeRepository = new Mock <IWriteRepository <TestEntity, Guid> >();
var notificationContextMock = new Mock <NotificationContext>();
var logger = new XunitLogger <BaseServiceApplication <TestEntity> >();
var loggerFactoryMock = new Mock <ILoggerFactory>();
loggerFactoryMock.Setup(setup => setup.CreateLogger(It.IsAny <string>())).Returns(logger);
var service = new BaseServiceApplication <TestEntity>(
mapperMock.Object,
loggerFactoryMock.Object,
unitOfWork.Object,
readRepository.Object,
writeRepository.Object,
notificationContextMock.Object);
//When
await service.GetAllAsync <TestViewModel>();
//Then
var msgConstructor = $"Inicializando Application Service<{ nameof(TestEntity) }, Guid>";
var msgGetAllAsync = $"Método: GetAllAsync() Retorno: IEnumerable<{ nameof(TestViewModel) }>";
logger.Logs.Should().HaveCount(3);
logger.Logs.Any(a => a.Equals(msgConstructor)).Should().BeTrue();
logger.Logs.Any(a => a.Equals(msgGetAllAsync)).Should().BeTrue();
}
public async Task ValidNavigation_DoesNotUsePageDialogService()
{
var navService = new NavigationServiceMock();
var dialogService = new PageDialogServiceMock();
var logger = new XunitLogger(TestOutputHelper);
var vm = new ViewModelMock(navService, dialogService, logger);
Assert.True(vm.NavigateCommand.CanExecute("good"));
vm.NavigateCommand.Execute("good");
await Task.Run(() =>
{
while (vm.IsBusy)
{
}
});
Assert.Null(dialogService.Title);
Assert.Null(dialogService.Message);
}
public void Deve_Registrar_Logs_No_Repositorio()
{
//Given
var entity = new AggregateRoot();
Mock <DbSet <AggregateRoot> > setMock = new Mock <DbSet <AggregateRoot> >();
setMock.Setup(set => set.FindAsync(It.IsAny <Guid>())).ReturnsAsync(entity);
Mock <DbContext> dbContextMock = new Mock <DbContext>();
dbContextMock.Setup(context => context.Set <AggregateRoot>()).Returns(setMock.Object);
var logger = new XunitLogger <Repository <AggregateRoot, Guid> >();
var repository = new Repository <AggregateRoot, Guid>(dbContextMock.Object, logger);
//When
repository.GetByIdAsync(entity.Id);
repository.GetAllAsync();
repository.InsertAsync(entity);
repository.UpdateAsync(entity);
repository.DeleteAsync(entity.Id).ConfigureAwait(false);
repository.DeleteAsync(entity).ConfigureAwait(false);
repository.SaveChanges();
//Then
var msgContructor = "Inicializando Repository<AggregateRoot, Guid>";
var msgGetById = $"Método: GetByIdAsync({{ id:{ entity.Id } }}) Retorno: type AggregateRoot";
var msgGetAllAsync = "Método: GetAllAsync() Retorno: IAsyncEnumerable<AggregateRoot>";
var msgInsertAsync = $"Método: InsertAsync({{ entity:{ entity.ToJson() } }})";
var msgUpdateAsync = $"Método: UpdateAsync({{ entity:{ entity.ToJson() } }})";
var msgDeleteAsync = $"Método: DeleteAsync({{ entity:{ entity.ToJson() } }})";
var msgSaveChanges = "Método: SaveChanges()";
logger.Logs.Should().HaveCount(8);
logger.Logs.Any(a => a.Equals(msgGetById)).Should().BeTrue();
logger.Logs.Any(a => a.Equals(msgContructor)).Should().BeTrue();
logger.Logs.Any(a => a.Equals(msgGetAllAsync)).Should().BeTrue();
logger.Logs.Any(a => a.Equals(msgInsertAsync)).Should().BeTrue();
logger.Logs.Any(a => a.Equals(msgUpdateAsync)).Should().BeTrue();
logger.Logs.Any(a => a.Equals(msgSaveChanges)).Should().BeTrue();
logger.Logs.Where(a => a.Equals(msgDeleteAsync)).Should().HaveCount(2);
}
public void Deve_Logar_Informacao_Referente_Falta_Settings()
{
//Given
var logger = new XunitLogger <ConnectionStringNullException>();
var loggerFactoryMock = new Mock <ILoggerFactory>();
loggerFactoryMock.Setup(setup => setup.CreateLogger(It.IsAny <string>())).Returns(logger);
//When
var exception = new ConnectionStringNullException(loggerFactoryMock.Object);
//Then
var msg = "A string de conexão não foi encontrada no appsettings";
exception.Message.Should().Be(msg);
logger.Logs.Should().NotBeEmpty();
logger.Logs.Any(a => a.Contains("ConnectionStrings")).Should().BeTrue();
logger.Logs.Any(a => a.Contains("DefaultConnection")).Should().BeTrue();
logger.Logs.Any(a => a.Contains("IdentityConnection")).Should().BeTrue();
}
public void Deve_Logar_Informacao_Referente_Falta_Settings()
{
//Given
var logger = new XunitLogger <CorsSettingsNullException>();
var loggerFactoryMock = new Mock <ILoggerFactory>();
loggerFactoryMock.Setup(setup => setup.CreateLogger(It.IsAny <string>())).Returns(logger);
//When
var exception = new CorsSettingsNullException(loggerFactoryMock.Object);
//Then
var msg = "A configuração do CORS não foi encontrada no appsettings";
exception.Message.Should().Be(msg);
logger.Logs.Should().NotBeEmpty();
logger.Logs.Any(a => a.Contains("CorsSettings")).Should().BeTrue();
logger.Logs.Any(a => a.Contains("Policy")).Should().BeTrue();
logger.Logs.Any(a => a.Contains("Origins")).Should().BeTrue();
}
public void Deve_Logar_Informacao_Referente_Falta_Settings()
{
//Given
var logger = new XunitLogger <SecuritySettingNullException>();
var loggerFactoryMock = new Mock <ILoggerFactory>();
loggerFactoryMock.Setup(setup => setup.CreateLogger(It.IsAny <string>())).Returns(logger);
SecuritySettingNullException exception;
//When
exception = new SecuritySettingNullException(loggerFactoryMock.Object);
//Then
var msg = "A configuração de segurança não foi encontrada no appsettings";
exception.Message.Should().Be(msg);
logger.Logs.Should().NotBeEmpty();
logger.Logs.Any(a => a.Contains("SecuritySettings")).Should().BeTrue();
logger.Logs.Any(a => a.Contains("ApiName")).Should().BeTrue();
logger.Logs.Any(a => a.Contains("Authority")).Should().BeTrue();
}
public async Task WithExpiredAuthorCertificateAfterCountersigning_InstallFromPMCForPC_SucceedAsync(ProjectTemplate projectTemplate)
{
// Arrange
EnsureVisualStudioHost();
var timestampService = await _fixture.GetDefaultTrustedTimestampServiceAsync();
using (var testContext = new ApexTestContext(VisualStudio, projectTemplate, XunitLogger))
using (var trustedCert = _fixture.TrustedRepositoryTestCertificate)
using (var trustedExpiringTestCert = SigningTestUtility.GenerateTrustedTestCertificateThatExpiresIn5Seconds())
{
XunitLogger.LogInformation("Creating package");
var package = CommonUtility.CreatePackage("ExpiredTestPackage", "1.0.0");
XunitLogger.LogInformation("Signing and countersigning package");
var expiredTestPackage = CommonUtility.AuthorSignPackage(package, trustedExpiringTestCert.Source.Cert);
var countersignedPackage = CommonUtility.RepositoryCountersignPackage(
expiredTestPackage,
trustedCert.Source.Cert,
new Uri("https://v3serviceIndexUrl.test/api/index.json"),
packageOwners: null,
timestampProviderUrl: timestampService.Url);
await SimpleTestPackageUtility.CreatePackagesAsync(testContext.PackageSource, expiredTestPackage);
XunitLogger.LogInformation("Waiting for package to expire");
SigningUtility.WaitForCertificateToExpire(trustedExpiringTestCert.Source.Cert);
var nugetConsole = GetConsole(testContext.Project);
nugetConsole.InstallPackageFromPMC(expiredTestPackage.Id, expiredTestPackage.Version);
testContext.Project.Build();
testContext.NuGetApexTestService.WaitForAutoRestore();
CommonUtility.AssertPackageReferenceExists(VisualStudio, testContext.Project, expiredTestPackage.Id, expiredTestPackage.Version, XunitLogger);
}
}
public XunitLoggerTest(ITestOutputHelper output)
{
_logger = new XunitLogger(output, GetType());
_currentThread = Thread.CurrentThread.ManagedThreadId;
PlatformSettings.Logged += Log;
}
public PublishAndRunTests_OnX86(ITestOutputHelper output)
{
_logger = new XunitLogger(output, LogLevel.Information);
}
public SmokeTests_X64(ITestOutputHelper output)
{
_logger = new XunitLogger(output, LogLevel.Information);
}
public PublishAndRunTests_OnX86(ITestOutputHelper output)
{
_logger = new XunitLogger(output, LogLevel.Information);
}
public NtlmAuthenticationTests(ITestOutputHelper output)
{
_logger = new XunitLogger(output, LogLevel.Information);
}
public OpenIdConnectTests(ITestOutputHelper output)
{
_logger = new XunitLogger(output, LogLevel.Information);
}
public OpenIdConnectTests(ITestOutputHelper output)
{
_logger = new XunitLogger(output, LogLevel.Information);
}
