public void ItShouldBePossibleToCreateANewLogFileUponDateChange() { var loggerFileSource = TestFileUtils.CreateRootDir("Logger"); var iniFile = new IniFile(null); var logFilePath = Path.Combine(loggerFileSource, "test"); var startime = DateTime.Now; var logFilePathReal = Path.Combine(loggerFileSource, string.Format("{0}.{1:0000}{2:00}{3:00}.log", "test", startime.Year, startime.Month, startime.Day)); var logFilePathRealYesterday = Path.Combine(loggerFileSource, string.Format("{0}.{1:0000}{2:00}{3:00}.log", "test", startime.Year, startime.Month, startime.Day-1)); iniFile.SetValue("LoggerFile", logFilePath); iniFile.SetValue("LoggerLevel", "1"); var fileLogger = new TestLogger(DateTime.Now-TimeSpan.FromDays(1)); fileLogger.Initialize(iniFile, "root"); fileLogger.RunThread(); Thread.Sleep(500); fileLogger.DebugFormat("{0}","test"); Thread.Sleep(1000); Assert.IsTrue(File.Exists(logFilePathReal)); Assert.IsTrue(File.Exists(logFilePathRealYesterday)); fileLogger.Terminate(true); Thread.Sleep(1000); fileLogger.Dispose(); TestFileUtils.RemoveDir(loggerFileSource); }
public void NewLogFile( ) { TestLogger logger = new TestLogger(); logger.Log( "Hello World" ); Assert.AreEqual( "Hello World", File.ReadAllText( LogFilePath ) ); }
private async Task<int> DiscoverTests(TestSourceSettings settings, ITestLogger logger, ITestCaseDiscoverySink discoverySink) { logger = new TestLogger(logger, settings.Name, "Discover"); var count = 0; var tests = new ConcurrentBag<Guid>(); if (settings.Port > 0) { logger.Debug("Start"); var discoverCommand = new DiscoverCommand(settings.Port); await discoverCommand.Run(spec => { var testCase = CreateTestCase(settings, spec); tests.Add(testCase.Id); discoverySink.SendTestCase(testCase); count += 1; }); await new RequestRunCommand(settings.Port).Run(tests); logger.Debug("Complete: {0} tests", count); } else { logger.Error("Not connected to {0}", TestAdapterInfo.Name); } return count; }
private void RunTestHttp( string httpMethod, string origin, string configXml, string json, string requestId, string userAgent, string userHostAddress, DateTime serverSideTimeUtc, string url, int expectedResponseCode, Dictionary<string, string> expectedResponseHeaders, List<LogEntry> expectedLogEntries) { // Arrange LogResponse response = new LogResponse(); TestLogger logger = new TestLogger(); CommonTestHelpers.SetConfigCache(configXml, logger); // Act LoggerProcessor.ProcessLogRequest( json, new LogRequestBase(userAgent, userHostAddress, requestId,url, null, null, null), serverSideTimeUtc, httpMethod, origin, response); // Assert Assert.Equal(expectedResponseCode, response.StatusCode); TestLogEntries(expectedLogEntries, logger.LogEntries); TestResponseHeaders(expectedResponseHeaders, response.Headers); }
public RelationalDatabaseModelFactoryTest() { var factory = new TestLoggerFactory(); _logger = factory.Logger; _factory = new FakeScaffoldingModelFactory(factory); }
public void LogFileMaxSize( ) { const int MaxSize = 32767; // Fill the log file const string alpabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; using ( StreamWriter writer = File.CreateText( LogFilePath ) ) { for ( int i = 0; i < MaxSize / alpabet.Length; ++i ) { writer.Write( alpabet ); } writer.Write( alpabet.Substring( 0, MaxSize % alpabet.Length ) ); } const string logStr = "Hello World"; TestLogger logger = new TestLogger(); logger.Log( logStr ); using ( FileStream stream = File.OpenRead( LogFilePath ) ) { Assert.AreEqual( MaxSize, stream.Length ); // Did we shift the existing contents? StreamReader reader = new StreamReader( stream ); Assert.AreEqual( alpabet[logStr.Length], (char) reader.Read() ); // Did we append the new log? stream.Position = MaxSize - logStr.Length; reader.DiscardBufferedData(); Assert.AreEqual( logStr, reader.ReadToEnd() ); } }
public virtual void DiscoverTests(IEnumerable<string> sources, IDiscoveryContext discoveryContext, IMessageLogger logger, ITestCaseDiscoverySink discoverySink) { TestAdapterInfo = CreateTestAdapterInfo(); var testLogger = TestAdapterInfo.CreateLogger(logger); var discoverLogger = new TestLogger(testLogger, "Discover"); var testSettings = discoveryContext.RunSettings.GetTestSettings(TestAdapterInfo.SettingsName); var count = 0; var testCount = 0; foreach (var source in sources) { var sourceSettings = GetSourceSettings(source, testSettings); if (sourceSettings != null) { testCount += DiscoverTests(sourceSettings, testLogger, discoverySink).Result; count += 1; } else { discoverLogger.Warn("Could not get settings for {0}", source); } } if (count > 0 || testCount > 0) { discoverLogger.Info("{0} tests discovered in {1} test containers", testCount, count); } }
public async Task StopWithNoActivity() { TestLogger l = new TestLogger(); Guid g1 = Guid.NewGuid(); await l.StopAsync(); Assert.Equal(0, l._dict.Count); }
public void AppendToLogFile( ) { File.WriteAllText( LogFilePath, "Existing logs." ); TestLogger logger = new TestLogger(); logger.Log( "New logs." ); Assert.AreEqual( "Existing logs.New logs.", File.ReadAllText( LogFilePath ) ); }
public void AnExceptionShouldBeLoggedAndOtherEventsWillBeFired() { var events = new ITestEvents[] { new FooSink(), new CrashSink(), new BarSink() }; var logger = new TestLogger(); events.Invoke(x => x.Hello("world"), logger); Assert.That(events.OfType<FooSink>().Single().Name, Is.EqualTo("world")); Assert.That(events.OfType<BarSink>().Single().Name, Is.EqualTo("world")); Assert.That(logger.LogException, Is.TypeOf<ApplicationException>()); Assert.That(logger.LogException, Has.Property("Message").EqualTo("Illegal name 'world'")); }
public SqliteDatabaseModelFactoryTest() { _testStore = SqliteTestStore.CreateScratch(); var serviceProvider = new SqliteDesignTimeServices() .ConfigureDesignTimeServices(new ServiceCollection().AddLogging()) .BuildServiceProvider(); var logger = new TestLogger(); serviceProvider.GetService<ILoggerFactory>().AddProvider(new TestLoggerProvider(logger)); _factory = serviceProvider .GetService<IDatabaseModelFactory>() as SqliteDatabaseModelFactory; }
public SqliteScaffoldingModelFactoryTest() { _testStore = SqliteTestStore.CreateScratch(); var serviceProvider = new SqliteDesignTimeServices() .ConfigureDesignTimeServices( new ServiceCollection().AddScaffolding().AddLogging()) .AddSingleton<IFileService, FileSystemFileService>() .BuildServiceProvider(); _logger = new TestLogger(); serviceProvider.GetService<ILoggerFactory>().AddProvider(new TestLoggerProvider(_logger)); _scaffoldingModelFactory = serviceProvider .GetService<IScaffoldingModelFactory>() as RelationalScaffoldingModelFactory; }
public async Task MultiStop() { TestLogger l = new TestLogger(); Guid g1 = Guid.NewGuid(); l.Increment(g1); l._newTicks = 101; Task[] tasks = Array.ConvertAll(Enumerable.Range(1, 10).ToArray(), _ => l.StopAsync()); await Task.WhenAll(tasks); Assert.Equal(1, l._totalActive); Assert.Equal(1, l._dict.Count); Assert.Equal(1, l._dict[101]); }
private PersistentFactory CreateTestFactory(bool cleanOldDataStore = true) { var dataStorePath = Path.Combine(TestContext.TestRunDirectory, "persistent40liteDatastore"); if (cleanOldDataStore) { var dirinfo = new DirectoryInfo(dataStorePath); if (dirinfo.Exists) dirinfo.Delete(true); } var logger = new TestLogger(); var storage = new PlainFilePersistentStorage(logger, dataStorePath); var serializer = new JsonPersistentSerializer(logger); var factory = new PersistentFactory(storage, serializer, logger); return factory; }
public void ShouldImportTrunkAndBranchIfTrunkDoesNotExist() { Using.Directory("publishSvn", () => Using.SvnRepo(url => { File.WriteAllText("test.txt", ""); var log = new TestLogger(); var sourceControl = new SvnProvider(log, TimeSpan.FromSeconds(30)); var publish = new PublishToSourceControl(sourceControl); publish.FromWorkingDirectory(".") .WithMainline(url + "/trunk") .WithCommitMessage("test") .To(url + "/tags/v1"); Assert.That(sourceControl.Exists(url + "/trunk/test.txt"), "not imported into trunk\n" + log.Contents); Assert.That(sourceControl.Exists(url + "/tags/v1/test.txt"), "not branched\n" + log.Contents); })); }
public TestContainer(TestContainerList containers, IVsProject project, string source) : base(containers.Discoverer, source) { Project = project; ProjectDirectory = project.GetProjectDir(); BaseDirectory = Discoverer.BaseDirectory; Name = string.Join("/", new[] { Project.GetProjectName(), Path.GetDirectoryName(GetRelativePath(Source)).Replace('\\', '/') }.Where(s => !string.IsNullOrWhiteSpace(s))); Logger = new TestLogger(Discoverer.Logger, Name); ServerLogger = CreateServerLogger(); Logger.Debug("Creating TestContainer for {0}", GetRelativePath(Source)); Containers = containers; SourceSettings = Discoverer.TestSettings.AddSource(Name, Source); try { Init(); } catch (Exception ex) { Validate(false, "Error: " + ex.Message); Logger.Error(ex, "Could not load tests"); } FileWatchers = GetFileWatchers().Where(f => f != null).ToList(); if (IsValid) { SourceSettingsPersister.Save(Discoverer.TestAdapterInfo.SettingsFileDirectory, SourceSettings); StartTestServer(); } if (!IsValid) { Logger.Warn(InvalidReason); } else { Logger.Debug("TestContainer created"); } }
public async Task BasicAndPoll() { TestLogger l = new TestLogger(); Guid g1 = Guid.NewGuid(); // Activity within single poll interval. l.Increment(g1); // will start the timer. l.Decrement(g1); // ignored, already staretd g1. Assert.Equal(0, l._dict.Count); // Large poll, haven't written yet. l.Poll(100); l._newTicks = 200; await l.StopAsync(); // no extra counts, // StopAsync will flush and cause a write. // We still picked up g1 Assert.Equal(1, l._dict.Count); Assert.Equal(1, l._dict[100]); Assert.Equal(1, l._totalActive); }
public async Task BasicAndStop() { TestLogger l = new TestLogger(); Guid g1 = Guid.NewGuid(); // Activity within single poll interval. l.Increment(g1); // will start the timer. l.Increment(g1); // ignored, already started g1. l.Decrement(g1); // count is back to 0 before poll happens. Assert.Equal(0, l._dict.Count); // Large poll, haven't written yet. l._newTicks = 100; await l.StopAsync(); // StopAsync will flush and cause a write. // We still picked up g1 Assert.Equal(1, l._dict.Count); Assert.Equal(1, l._dict[100]); Assert.Equal(1, l._totalActive); // duplicate g1 is only counted once }
public void ShouldUpdateTrunkAndBranchWhenFileDeleted() { Using.Directory("publishSvn", () => Using.SvnRepo(url => { var log = new TestLogger(); var sourceControl = new SvnProvider(log, TimeSpan.FromSeconds(30)); Directory.CreateDirectory("import"); File.WriteAllText(@"import\test.txt", ""); sourceControl.Import("import", url + "/trunk", ""); Directory.CreateDirectory("new"); var publish = new PublishToSourceControl(sourceControl); publish.FromWorkingDirectory("new") .WithMainline(url + "/trunk") .WithCommitMessage("test") .To(url + "/tags/v1"); Assert.That(!sourceControl.Exists(url + "/trunk/test.txt"), "file not deleted in trunk\n" + log.Contents); Assert.That(!sourceControl.Exists(url + "/tags/v1/test.txt"), "file not deleted in branch\n" + log.Contents); })); }
private void RunTestHttp( string httpMethod, string origin, string configXml, string json, string requestId, string userAgent, string userHostAddress, DateTime serverSideTimeUtc, string url, int expectedResponseCode, NameValueCollection expectedResponseHeaders, List<LogEntry> expectedLogEntries) { // Arrange TestHttpResponse response = new TestHttpResponse(); TestLogger logger = new TestLogger(); XmlElement xe = Utils.ConfigToXe(configXml); // Act LoggerProcessor.ProcessLogRequest(json, userAgent, userHostAddress, serverSideTimeUtc, url, requestId, httpMethod, origin, response, logger, xe); // Assert Assert.AreEqual(expectedResponseCode, response.StatusCode); TestLogEntries(expectedLogEntries, logger.LogEntries); TestResponseHeaders(expectedResponseHeaders, response.Headers); }
public async Task Consistency() { // Simulate a steady stream over a long time. TestLogger l = new TestLogger(); for (int i = 0; i < 1000; i += 100) { var g = Guid.NewGuid(); l.Increment(g); l.Decrement(g); l.Poll(i); } l._newTicks = 1000; await l.StopAsync(); // Verify int c = 0; for (int i = 0; i < 1000; i += 100) { Assert.Equal(1, l._dict[i]); c++; } Assert.Equal(c, l._totalActive); Assert.Equal(c, l._dict.Count); }
private static void CheckMsgPackSerialization(string inputFileName, bool linearTextSpans = false, bool damaged = false, bool incorrectFilePath = false, bool compressed = false) { string path = Path.Combine(TestUtility.TestsDataPath, inputFileName); string ext = SerializationFormat.MsgPack.GetExtension(); // Serialization string[] files = File.Exists(path) ? new[] { path } : Directory.GetFiles(path); var codeRepository = new FileSourceRepository(files); var logger = new TestLogger(); var workflow = new Workflow(codeRepository) { DumpStages = new HashSet <Stage> { Stage.Ust }, DumpDir = TestUtility.TestsOutputPath, SerializationFormat = SerializationFormat.MsgPack, LineColumnTextSpans = !linearTextSpans, CompressedSerialization = compressed, Stage = Stage.Ust, Logger = logger }; WorkflowResult result = workflow.Process(); Assert.AreEqual(0, logger.ErrorCount, logger.ErrorsString); int errorOffset = 6; byte errorValue = 123; var serializedFiles = new List <string>(); foreach (string file in files) { string shortFileName = Path.GetFileName(file) + ".ust." + ext; string serializedFile = Path.Combine(TestUtility.TestsOutputPath, shortFileName); if (damaged || incorrectFilePath) { byte[] bytes = File.ReadAllBytes(serializedFile); if (damaged) { errorOffset += path.Length + 1; } else { errorOffset += 2; } bytes[errorOffset] = errorValue; File.WriteAllBytes(serializedFile, bytes); } serializedFiles.Add(serializedFile); } // Deserialization var newLogger = new TestLogger(); var newCodeRepository = new FileSourceRepository(serializedFiles); var newWorkflow = new Workflow(newCodeRepository, new DefaultPatternRepository()) { Logger = newLogger }; newWorkflow.Process(); if (damaged) { Assert.AreEqual(1, newLogger.ErrorCount); Assert.IsTrue(newLogger.ErrorsString.Contains(errorValue.ToString())); Assert.IsTrue(newLogger.ErrorsString.Contains(errorOffset.ToString())); return; } var binaryFile = (BinaryFile)newCodeRepository.ReadFile(newCodeRepository.GetFileNames().ElementAt(0)); RootUstMessagePackSerializer.Deserialize(binaryFile, new HashSet <IFile>(), null, logger, out int readSize); if (!compressed) { Assert.AreEqual(binaryFile.Data.Length, readSize); } else { double compressionRatio = (double)readSize / binaryFile.Data.Length; Console.WriteLine($"Compression ratio: {compressionRatio}"); } Assert.GreaterOrEqual(newLogger.Matches.Count, 1); if (incorrectFilePath) { string firstError = newLogger.Errors[0]; Assert.IsTrue(firstError.Contains("ReadException")); Assert.IsTrue(firstError.Contains("Error during opening the file")); return; } Assert.AreEqual(0, newLogger.ErrorCount, newLogger.ErrorsString); var match = (MatchResult)newLogger.Matches[0]; using (var sourceFilesEnumerator = result.SourceFiles.GetEnumerator()) { sourceFilesEnumerator.MoveNext(); var firstFile = (TextFile)sourceFilesEnumerator.Current; Assert.AreEqual(new LineColumnTextSpan(2, 1, 3, 25), firstFile.GetLineColumnTextSpan(match.TextSpan)); } }
public async Task CompatilibityChecker_PackageCompatibility_VerifyAvailableFrameworksIgnoresInvalidAssetsAsync() { // Arrange var sources = new List <PackageSource>(); var project1Json = @" { ""version"": ""1.0.0"", ""description"": """", ""authors"": [ ""author"" ], ""tags"": [ """" ], ""projectUrl"": """", ""licenseUrl"": """", ""frameworks"": { ""netstandard1.0"": { ""dependencies"": { ""packageA"": { ""version"": ""1.0.0"" } } } } }"; using (var workingDir = TestDirectory.Create()) { var packagesDir = new DirectoryInfo(Path.Combine(workingDir, "globalPackages")); var packageSource = new DirectoryInfo(Path.Combine(workingDir, "packageSource")); var project1 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project1")); packagesDir.Create(); packageSource.Create(); project1.Create(); sources.Add(new PackageSource(packageSource.FullName)); File.WriteAllText(Path.Combine(project1.FullName, "project.json"), project1Json); var specPath1 = Path.Combine(project1.FullName, "project.json"); var spec1 = JsonPackageSpecReader.GetPackageSpec(project1Json, "project1", specPath1); var logger = new TestLogger(); var request = new TestRestoreRequest(spec1, sources, packagesDir.FullName, logger) { LockFilePath = Path.Combine(project1.FullName, "project.lock.json") }; var packageA = new SimpleTestPackageContext("packageA"); packageA.AddFile("lib/netstandard1.1/valid.dll"); packageA.AddFile("lib/netstandard1.0/x86/invalid.dll"); await SimpleTestPackageUtility.CreatePackagesAsync(packageSource.FullName, packageA); // Act var command = new RestoreCommand(request); var result = await command.ExecuteAsync(); await result.CommitAsync(logger, CancellationToken.None); // Assert Assert.False(result.Success, logger.ShowErrors()); // Verify both libraries were installed Assert.Equal(1, result.LockFile.Libraries.Count); var issue = result.CompatibilityCheckResults.SelectMany(check => check.Issues).Single(); Assert.Equal("Package packageA 1.0.0 is not compatible with netstandard1.0 (.NETStandard,Version=v1.0). Package packageA 1.0.0 supports: netstandard1.1 (.NETStandard,Version=v1.1)", issue.Format()); } }
public void ConvertServiceModelAndStripSchemaFromDataBindingName() { // XSD to Json Schema XsdToJsonSchema xsdToJsonSchemaConverter = new XsdToJsonSchema(new XmlTextReader("Common/xsd/ServiceModel.xsd"), TestLogger.Create <XsdToJsonSchema>()); JsonSchema schemaJsonSchema = xsdToJsonSchemaConverter.AsJsonSchema(); JsonSchemaToInstanceModelGenerator converter = new JsonSchemaToInstanceModelGenerator("TestOrg", "ServiceModel", schemaJsonSchema); ServiceMetadata serviceMetadata = converter.GetServiceMetadata(); string actualDatabinding = serviceMetadata.Elements["Skjema.Skattyterinforgrp5801.Kontaktgrp5803.KontaktpersonPoststeddatadef10442.value"].DataBindingName; Assert.Equal("skattyterinforgrp5801.kontaktgrp5803.kontaktpersonPoststeddatadef10442.value", actualDatabinding); }
public TestZoneService(IIdentity ident, TestLogger logger) { m_ident = ident; m_logger = logger; }
public async Task LocalPackageMetadataResourceTests_GetMetadataPrerelease() { using (var root = TestFileSystemUtility.CreateRandomTestFolder()) { // Arrange var testLogger = new TestLogger(); var packageX = new SimpleTestPackageContext() { Id = "x", Version = "1.0.0" }; var packageA1 = new SimpleTestPackageContext() { Id = "a", Version = "1.0.0", Dependencies = new List <SimpleTestPackageContext>() { packageX } }; var packageA2 = new SimpleTestPackageContext() { Id = "a", Version = "2.0.0-preview.12.4+server.a", Dependencies = new List <SimpleTestPackageContext>() { packageX } }; var packageContexts = new SimpleTestPackageContext[] { packageA1, packageA2, packageX }; SimpleTestPackageUtility.CreatePackages(root, packageContexts); var localResource = new FindLocalPackagesResourceV2(root); var resource = new LocalPackageMetadataResource(localResource); // Act var results = (await resource.GetMetadataAsync( "A", includePrerelease: true, includeUnlisted: false, log: testLogger, token: CancellationToken.None)) .ToList(); var package = results.OrderByDescending(p => p.Identity.Version).First(); // Assert Assert.Equal("a", package.Identity.Id); Assert.Equal("2.0.0-preview.12.4+server.a", package.Identity.Version.ToFullString()); } }
public void Can_setup_decorator_pattern() { ResetDatabase(); var testLogger = new TestLogger(); var migrator = CreateMigrator<ShopContext_v1>(); new MigratorLoggingDecorator(migrator, testLogger).Update(); Assert.True(testLogger.Messages.Count > 0); }
public async Task LocalDependencyInfoResource_ResolvePackagesNearestDependencyGroup() { using (var root = TestFileSystemUtility.CreateRandomTestFolder()) { // Arrange var testLogger = new TestLogger(); var packageA = new SimpleTestPackageContext() { Id = "a", Version = "1.0", Nuspec = XDocument.Parse($@"<?xml version=""1.0"" encoding=""utf-8""?> <package> <metadata> <id>a</id> <version>1.0</version> <title /> <dependencies> <group> <dependency id=""b"" version=""1.0"" /> </group> <group targetFramework=""net46""> <dependency id=""x"" /> </group> <group targetFramework=""net461""> </group> </dependencies> </metadata> </package>") }; var packageContexts = new SimpleTestPackageContext[] { packageA }; SimpleTestPackageUtility.CreatePackages(root, packageContexts); var source = Repository.Factory.GetCoreV3(root); var localResource = new FindLocalPackagesResourceV2(root); var resource = new LocalDependencyInfoResource(localResource, source); // Act var resultNet462 = (await resource.ResolvePackages( "a", NuGetFramework.Parse("net462"), testLogger, CancellationToken.None)).Single(); var resultNet46 = (await resource.ResolvePackages( "a", NuGetFramework.Parse("net46"), testLogger, CancellationToken.None)).Single(); var resultWin8 = (await resource.ResolvePackages( "a", NuGetFramework.Parse("win8"), testLogger, CancellationToken.None)).Single(); // Assert Assert.Equal(0, resultNet462.Dependencies.Count()); Assert.Equal(1, resultNet46.Dependencies.Count()); Assert.Equal(1, resultWin8.Dependencies.Count()); Assert.Equal("x", resultNet46.Dependencies.Single().Id); Assert.Equal(VersionRange.All, resultNet46.Dependencies.Single().VersionRange); Assert.Equal("b", resultWin8.Dependencies.Single().Id); Assert.Equal(VersionRange.Parse("1.0"), resultWin8.Dependencies.Single().VersionRange); } }
public async Task LocalDependencyInfoResource_Basic() { using (var root = TestFileSystemUtility.CreateRandomTestFolder()) { // Arrange var testLogger = new TestLogger(); var packageX = new SimpleTestPackageContext() { Id = "x", Version = "1.0.0" }; var packageD = new SimpleTestPackageContext() { Id = "d", Version = "1.0.0" }; var packageD2 = new SimpleTestPackageContext() { Id = "d", Version = "2.0.0" }; var packageD3 = new SimpleTestPackageContext() { Id = "d", Version = "0.1.0" }; var packageC = new SimpleTestPackageContext() { Id = "c", Version = "1.0.0", Dependencies = new List <SimpleTestPackageContext>() { packageD } }; var packageB = new SimpleTestPackageContext() { Id = "b", Version = "1.0.0", Dependencies = new List <SimpleTestPackageContext>() { packageD2 } }; var packageA = new SimpleTestPackageContext() { Id = "a", Version = "1.0.0", Dependencies = new List <SimpleTestPackageContext>() { packageC, packageB } }; var packageContexts = new SimpleTestPackageContext[] { packageA, packageB, packageC, packageD, packageD2, packageD3, packageX }; SimpleTestPackageUtility.CreatePackages(root, packageContexts); var source = Repository.Factory.GetCoreV3(root); var localResource = new FindLocalPackagesResourceV2(root); var resource = new LocalDependencyInfoResource(localResource, source); // Act var resultsA = (await resource.ResolvePackages("a", NuGetFramework.Parse("net46"), testLogger, CancellationToken.None)).ToList(); var resultsX = (await resource.ResolvePackages("x", NuGetFramework.Parse("net46"), testLogger, CancellationToken.None)).ToList(); var resultsY = (await resource.ResolvePackages("y", NuGetFramework.Parse("net46"), testLogger, CancellationToken.None)).ToList(); // Assert Assert.Equal(1, resultsA.Count); Assert.Equal(packageA.Identity, resultsA[0], PackageIdentity.Comparer); Assert.True(resultsA[0].Listed); Assert.Contains("a.1.0.0.nupkg", resultsA[0].DownloadUri.LocalPath); Assert.Equal(2, resultsA[0].Dependencies.Count()); Assert.Equal("c", resultsA[0].Dependencies.First().Id); Assert.Equal("[1.0.0, )", resultsA[0].Dependencies.First().VersionRange.ToNormalizedString()); Assert.Equal("b", resultsA[0].Dependencies.Skip(1).First().Id); Assert.Equal("[1.0.0, )", resultsA[0].Dependencies.Skip(1).First().VersionRange.ToNormalizedString()); // no dependencies Assert.Equal(1, resultsX.Count); Assert.Equal(packageX.Identity, resultsX[0], PackageIdentity.Comparer); Assert.True(resultsX[0].Listed); Assert.Contains("x.1.0.0.nupkg", resultsX[0].DownloadUri.LocalPath); Assert.Equal(0, resultsX[0].Dependencies.Count()); // not found Assert.Equal(0, resultsY.Count); } }
public ResultStreamingTests(ITestOutputHelper output) { _output = output; _setupConfig = o => o.WithLogger(TestLogger.Create(output)); }
public async Task TestTrapV2HandlerWithV3MessageAndWrongEngineId() { var manualEvent = new ManualResetEventSlim(); // TODO: this is a hack. review it later. var engineId = new OctetString(ByteTool.Convert("80001F8880E9630000D61FF449")); var users = new UserRegistry(); users.Add(new OctetString("neither"), DefaultPrivacyProvider.DefaultPair); users.Add(new OctetString("authen"), new DefaultPrivacyProvider(new MD5AuthenticationProvider(new OctetString("authentication"))) { EngineId = engineId }); if (DESPrivacyProvider.IsSupported) { users.Add(new OctetString("privacy"), new DESPrivacyProvider(new OctetString("privacyphrase"), new MD5AuthenticationProvider(new OctetString("authentication")))); } var count = 0; var trapv1 = new TrapV1MessageHandler(); var trapv1Mapping = new HandlerMapping("v1", "TRAPV1", trapv1); var trapv2 = new TrapV2MessageHandler(); trapv2.MessageReceived += (sender, args) => { count++; }; var trapv2Mapping = new HandlerMapping("v2,v3", "TRAPV2", trapv2); var inform = new InformRequestMessageHandler(); var informMapping = new HandlerMapping("v2,v3", "INFORM", inform); var store = new ObjectStore(); var v1 = new Version1MembershipProvider(new OctetString("public"), new OctetString("public")); var v2 = new Version2MembershipProvider(new OctetString("public"), new OctetString("public")); var v3 = new Version3MembershipProvider(); var membership = new ComposedMembershipProvider(new IMembershipProvider[] { v1, v2, v3 }); var handlerFactory = new MessageHandlerFactory(new[] { trapv1Mapping, trapv2Mapping, informMapping }); var logger = new TestLogger(); logger.Handler = (obj, args) => { manualEvent.Set(); }; var pipelineFactory = new SnmpApplicationFactory(logger, store, membership, handlerFactory); var group = new EngineGroup(); var engine = new SnmpEngine(pipelineFactory, new Listener { Users = users }, group); var daemonEndPoint = new IPEndPoint(IPAddress.Loopback, port.NextId); engine.Listener.AddBinding(daemonEndPoint); engine.Start(); try { var privacy = new DefaultPrivacyProvider(new MD5AuthenticationProvider(new OctetString("authentication"))); var trap = new TrapV2Message( VersionCode.V3, 1004947569, 234419641, new OctetString("authen"), new ObjectIdentifier("1.3.6"), 0, new List <Variable>(), privacy, 0x10000, new OctetString(ByteTool.Convert("80001F8880E9630000D61FF450")), 0, 0); await trap.SendAsync(daemonEndPoint); manualEvent.Wait(); Assert.Equal(0, count); Assert.Equal(new Counter32(1), group.UnknownEngineId.Data); } finally { if (SnmpMessageExtension.IsRunningOnWindows) { engine.Stop(); } } }
public InMemoryCorsPolicyServiceTests() { _subject = new InMemoryCorsPolicyService(TestLogger.Create <InMemoryCorsPolicyService>(), _clients); }
private void PublishWithDotnetExe(string framework) { var projectFile = Path.Combine(SourceApplicationsDirectoryPath, ApplicationDirectoryName, ApplicationDirectoryName + ".csproj"); var deployPath = Path.Combine(DestinationRootDirectoryPath, ApplicationDirectoryName); TestLogger?.WriteLine($"[RemoteService]: Publishing to {deployPath}."); var process = new Process(); var startInfo = new ProcessStartInfo(); startInfo.WindowStyle = ProcessWindowStyle.Hidden; startInfo.UseShellExecute = false; startInfo.FileName = "dotnet.exe"; startInfo.RedirectStandardOutput = true; startInfo.RedirectStandardError = true; startInfo.Arguments = $"publish {projectFile} --configuration Release --runtime win-x64 --framework {framework} --output {deployPath}"; process.StartInfo = startInfo; //We cannot run dotnet publish against the same directory concurrently. //Doing so causes the publish job to fail because it can't obtain a lock on files in the obj and bin directories. lock (GetPublishLockObjectForCoreApp()) { process.Start(); var processOutput = new ProcessOutput(TestLogger, process, true); const int timeoutInMilliseconds = 3 * 60 * 1000; if (!process.WaitForExit(timeoutInMilliseconds)) { TestLogger?.WriteLine($"[RemoteService]: PublishCoreApp timed out while waiting for {ApplicationDirectoryName} to publish after {timeoutInMilliseconds} milliseconds."); try { //This usually happens because another publishing job has a lock on the file(s) being copied. //We send a termination request because we no longer want dotnet publish to continue to copy files //when there's a good chance that at least some of the files are missing. //We can only use "kill" to request termination here, because there isn't a "close" option for non-GUI apps. process.Kill(); } catch (Exception e) { TestLogger?.WriteLine($"======[RemoteService]: PublishCoreApp failed to kill process that publishes {ApplicationDirectoryName} with exception ====="); TestLogger?.WriteLine(e.ToString()); TestLogger?.WriteLine($"-----[RemoteService]: PublishCoreApp failed to kill process that publishes {ApplicationDirectoryName} end of exception -----"); } } else { Console.WriteLine($"[{DateTime.Now}] dotnet.exe exits with code {process.ExitCode}"); } processOutput.WriteProcessOutputToLog("[RemoteService]: PublishCoreApp"); if (!process.HasExited || process.ExitCode != 0) { var failedToPublishMessage = "Failed to publish Core application"; TestLogger?.WriteLine($"[RemoteService]: {failedToPublishMessage}"); throw new Exception(failedToPublishMessage); } } Console.WriteLine($"[{DateTime.Now}] Successfully published {projectFile} to {deployPath}"); }
private async Task<int> RunTests(TestSourceSettings settings, ITestLogger logger, IRunContext runContext, IFrameworkHandle frameworkHandle) { logger = new TestLogger(logger, settings.Name, "Run"); var count = 0; if (settings.Port > 0) { logger.Debug("Start"); var discoverCommand = new DiscoverCommand(settings.Port); await discoverCommand.Run(spec => { RunTest(settings, logger, runContext, frameworkHandle, spec); count += 1; }); logger.Debug("Complete: {0} tests", count); } else { logger.Error("Not connected to {0}", TestAdapterInfo.Name); } return count; }
public async Task StopAndRestart() { TestLogger l = new TestLogger(); Guid g1 = Guid.NewGuid(); Guid g2 = Guid.NewGuid(); Guid g3 = Guid.NewGuid(); l.Increment(g1); l.Increment(g2); l.Decrement(g1); l._newTicks = 100; await l.StopAsync(); Assert.Equal(2, l._dict[100]); // max was g1,g2 l.Increment(g3); // start up again l.Poll(200); l.Decrement(g2); l.Decrement(g3); l.Poll(300); l._newTicks = 301; await l.StopAsync(); Assert.Equal(2, l._dict[200]); // max was g2, g3 Assert.Equal(3, l._totalActive); Assert.Equal(2, l._dict[300]); // spill over from time-200 Assert.Equal(3, l._dict.Count); }
public async Task Project2ProjectInLockFile_VerifyProjectReferenceWithoutVersion() { // Arrange var sources = new List <PackageSource>(); var project1Json = @" { ""version"": ""2.0.0-*"", ""description"": ""Proj1 Class Library"", ""authors"": [ ""author"" ], ""tags"": [ """" ], ""projectUrl"": """", ""licenseUrl"": """", ""dependencies"": { ""project2"": { ""target"": ""project"" } }, ""frameworks"": { ""net45"": { } } }"; var project2Json = @" { ""version"": ""2.0.0-*"", ""description"": ""Proj2 Class Library"", ""authors"": [ ""author"" ], ""tags"": [ """" ], ""projectUrl"": """", ""licenseUrl"": """", ""frameworks"": { ""net45"": { } } }"; using (var packagesDir = TestFileSystemUtility.CreateRandomTestFolder()) using (var workingDir = TestFileSystemUtility.CreateRandomTestFolder()) { var project1 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project1")); var project2 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project2")); project1.Create(); project2.Create(); File.WriteAllText(Path.Combine(project1.FullName, "project.json"), project1Json); File.WriteAllText(Path.Combine(project2.FullName, "project.json"), project2Json); var specPath1 = Path.Combine(project1.FullName, "project.json"); var specPath2 = Path.Combine(project2.FullName, "project.json"); var spec1 = JsonPackageSpecReader.GetPackageSpec(project1Json, "project1", specPath1); var spec2 = JsonPackageSpecReader.GetPackageSpec(project2Json, "project2", specPath2); var logger = new TestLogger(); var request = new RestoreRequest(spec1, sources, packagesDir, logger); request.LockFilePath = Path.Combine(project1.FullName, "project.lock.json"); var format = new LockFileFormat(); // Act var command = new RestoreCommand(request); var result = await command.ExecuteAsync(); await result.CommitAsync(logger, CancellationToken.None); var lockFile = format.Read(request.LockFilePath, logger); var project2Reference = lockFile.ProjectFileDependencyGroups.First().Dependencies.Single(); // Assert Assert.True(result.Success); Assert.Equal("project2", project2Reference); } }
public async Task Project2ProjectInLockFile_PackageReferenceConflict() { // Arrange var sources = new List <PackageSource>() { new PackageSource("https://api.nuget.org/v3/index.json") }; var project1Json = @" { ""version"": ""1.0.0"", ""dependencies"": { }, ""frameworks"": { ""net45"": {} } }"; var project2Json = @" { ""version"": ""1.0.0"", ""dependencies"": { ""Microsoft.VisualBasic"": ""10.0.0"" }, ""frameworks"": { ""net45"": {} } }"; using (var packagesDir = TestFileSystemUtility.CreateRandomTestFolder()) using (var workingDir = TestFileSystemUtility.CreateRandomTestFolder()) { var project1 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project1")); var project2 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project2")); project1.Create(); project2.Create(); File.WriteAllText(Path.Combine(project1.FullName, "project.json"), project1Json); File.WriteAllText(Path.Combine(project2.FullName, "project.json"), project2Json); File.WriteAllText(Path.Combine(project1.FullName, "project1.csproj"), string.Empty); File.WriteAllText(Path.Combine(project2.FullName, "project2.csproj"), string.Empty); var specPath1 = Path.Combine(project1.FullName, "project.json"); var specPath2 = Path.Combine(project2.FullName, "project.json"); var spec1 = JsonPackageSpecReader.GetPackageSpec(project1Json, "project1", specPath1); var spec2 = JsonPackageSpecReader.GetPackageSpec(project2Json, "project2", specPath2); var logger = new TestLogger(); var request = new RestoreRequest(spec1, sources, packagesDir, logger); request.ExternalProjects.Add(new ExternalProjectReference( "project1", spec1, Path.Combine(project1.FullName, "project1.csproj"), new string[] { "project2" })); request.ExternalProjects.Add(new ExternalProjectReference( "project2", spec2, Path.Combine(project2.FullName, "project2.csproj"), new string[] { })); request.LockFilePath = Path.Combine(project1.FullName, "project.lock.json"); var format = new LockFileFormat(); // Act var command = new RestoreCommand(request); var result = await command.ExecuteAsync(); await result.CommitAsync(logger, CancellationToken.None); // Assert Assert.True(result.Success, logger.ShowMessages()); } }
/// <summary> /// Ensures, that all interface methods delegate to Write() with correct level + arguments /// and that arguments are still not evaluated up to this point (e.g. calling ToString()) /// </summary> private static void LogsMessage(string levelName) { MockRepository mocks = new MockRepository(); TestLogger log = new TestLogger(); Exception ex = new Exception(); MethodInfo[] logMethods = GetLogMethodSignatures(levelName); LogLevel logLevel = (LogLevel)Enum.Parse(typeof(LogLevel), levelName); Invoke(log, logMethods[0], "messageObject0"); Assert.AreEqual(logLevel, log.LastLogLevel); Assert.AreEqual("messageObject0", log.LastMessage); Assert.AreEqual(null, log.LastException); Invoke(log, logMethods[1], "messageObject1", ex); Assert.AreEqual(logLevel, log.LastLogLevel); Assert.AreEqual("messageObject1", log.LastMessage); Assert.AreEqual(ex, log.LastException); Invoke(log, logMethods[2], "format2 {0}", new object[] { "arg2" }); Assert.AreEqual(logLevel, log.LastLogLevel); Assert.AreEqual("format2 arg2", log.LastMessage); Assert.AreEqual(null, log.LastException); Invoke(log, logMethods[3], "format3 {0}", ex, new object[] { "arg3" }); Assert.AreEqual(logLevel, log.LastLogLevel); Assert.AreEqual("format3 arg3", log.LastMessage); Assert.AreEqual(ex, log.LastException); Invoke(log, logMethods[4], CultureInfo.CreateSpecificCulture("de-de"), "format4 {0}", new object[] { 4.1 }); Assert.AreEqual(logLevel, log.LastLogLevel); Assert.AreEqual("format4 4,1", log.LastMessage); Assert.AreEqual(null, log.LastException); Invoke(log, logMethods[5], CultureInfo.CreateSpecificCulture("de-de"), "format5 {0}", ex, new object[] { 5.1 }); Assert.AreEqual(logLevel, log.LastLogLevel); Assert.AreEqual("format5 5,1", log.LastMessage); Assert.AreEqual(ex, log.LastException); Invoke(log, logMethods[6], TestFormatMessageCallback.MessageCallback("message6")); Assert.AreEqual(logLevel, log.LastLogLevel); Assert.AreEqual("message6", log.LastMessage); Assert.AreEqual(null, log.LastException); Invoke(log, logMethods[7], TestFormatMessageCallback.MessageCallback("message7"), ex); Assert.AreEqual(logLevel, log.LastLogLevel); Assert.AreEqual("message7", log.LastMessage); Assert.AreEqual(ex, log.LastException); Invoke(log, logMethods[8], CultureInfo.CreateSpecificCulture("de-de"), TestFormatMessageCallback.MessageCallback("format8 {0}", new object[] { 8.1 })); Assert.AreEqual(logLevel, log.LastLogLevel); Assert.AreEqual("format8 8,1", log.LastMessage); Assert.AreEqual(null, log.LastException); Invoke(log, logMethods[9], CultureInfo.CreateSpecificCulture("de-de"), TestFormatMessageCallback.MessageCallback("format9 {0}", new object[] { 9.1 }), ex); Assert.AreEqual(logLevel, log.LastLogLevel); Assert.AreEqual("format9 9,1", log.LastMessage); Assert.AreEqual(ex, log.LastException); }
public async Task ToRpcInvocationRequest_Http_OmitsDuplicateBodyOfBindingData() { var logger = new TestLogger("test"); var httpContext = new DefaultHttpContext(); httpContext.Request.Host = new HostString("local"); httpContext.Request.Path = "/test"; httpContext.Request.Method = "Post"; var inputs = new List <(string name, DataType type, object val)> { ("req", DataType.String, httpContext.Request) }; var bindingData = new Dictionary <string, object> { { "req", httpContext.Request }, { "$request", httpContext.Request }, { "headers", httpContext.Request.Headers.ToDictionary(p => p.Key, p => p.Value) }, { "query", httpContext.Request.QueryString.ToString() }, { "sys", new SystemBindingData() } }; var invocationContext = new ScriptInvocationContext() { ExecutionContext = new ExecutionContext() { InvocationId = Guid.NewGuid(), FunctionName = "Test", }, BindingData = bindingData, Inputs = inputs, ResultSource = new TaskCompletionSource <ScriptInvocationResult>(), Logger = logger, AsyncExecutionContext = System.Threading.ExecutionContext.Capture() }; var functionMetadata = new FunctionMetadata { Name = "Test" }; var httpTriggerBinding = new BindingMetadata { Name = "req", Type = "httpTrigger", Direction = BindingDirection.In, Raw = new JObject() }; var httpOutputBinding = new BindingMetadata { Name = "res", Type = "http", Direction = BindingDirection.Out, Raw = new JObject(), DataType = DataType.String }; functionMetadata.Bindings.Add(httpTriggerBinding); functionMetadata.Bindings.Add(httpOutputBinding); invocationContext.FunctionMetadata = functionMetadata; Capabilities capabilities = new Capabilities(logger); MapField <string, string> addedCapabilities = new MapField <string, string> { { RpcWorkerConstants.RpcHttpTriggerMetadataRemoved, "1" }, { RpcWorkerConstants.RpcHttpBodyOnly, "1" } }; capabilities.UpdateCapabilities(addedCapabilities); var result = await invocationContext.ToRpcInvocationRequest(logger, capabilities); Assert.Equal(1, result.InputData.Count); Assert.Equal(2, result.TriggerMetadata.Count); Assert.True(result.TriggerMetadata.ContainsKey("headers")); Assert.True(result.TriggerMetadata.ContainsKey("query")); }
public void TestSetUp() { TestLogger.Clear(); }
public TestsCliProcessor() { Logger = new TestLogger(); }
public async Task Project2ProjectInLockFile_VerifyProjectsNoAddedForV1() { // Arrange var sources = new List <PackageSource>(); var project1Json = @" { ""version"": ""1.0.0"", ""dependencies"": { ""project2"": ""1.0.0-*"", }, ""frameworks"": { ""net45"": {} } }"; var project2Json = @" { ""version"": ""1.0.0"", ""dependencies"": { ""project3"": ""1.0.0-*"", }, ""frameworks"": { ""net45"": {} } }"; var project3Json = @" { ""version"": ""1.0.0"", ""dependencies"": { }, ""frameworks"": { ""net45"": {} } }"; var globalJson = @" { ""projects"": [ ""projects"" ] }"; using (var packagesDir = TestFileSystemUtility.CreateRandomTestFolder()) using (var workingDir = TestFileSystemUtility.CreateRandomTestFolder()) { var project1 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project1")); var project2 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project2")); var project3 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project3")); project1.Create(); project2.Create(); project3.Create(); File.WriteAllText(Path.Combine(project1.FullName, "project.json"), project1Json); File.WriteAllText(Path.Combine(project2.FullName, "project.json"), project2Json); File.WriteAllText(Path.Combine(project3.FullName, "project.json"), project3Json); File.WriteAllText(Path.Combine(workingDir, "global.json"), globalJson); File.WriteAllText(Path.Combine(project1.FullName, "project1.xproj"), string.Empty); File.WriteAllText(Path.Combine(project2.FullName, "project2.xproj"), string.Empty); File.WriteAllText(Path.Combine(project3.FullName, "project3.xproj"), string.Empty); var specPath1 = Path.Combine(project1.FullName, "project.json"); var spec = JsonPackageSpecReader.GetPackageSpec(project1Json, "project1", specPath1); var specPath2 = Path.Combine(project2.FullName, "project.json"); var specPath3 = Path.Combine(project3.FullName, "project.json"); var logger = new TestLogger(); var request = new RestoreRequest(spec, sources, packagesDir, logger); request.LockFilePath = Path.Combine(project1.FullName, "project.lock.json"); request.LockFileVersion = 1; var format = new LockFileFormat(); // Act var command = new RestoreCommand(request); var result = await command.ExecuteAsync(); await result.CommitAsync(logger, CancellationToken.None); var lockFile = format.Read(request.LockFilePath, logger); // Assert Assert.True(result.Success); Assert.Equal(0, lockFile.Libraries.Count); Assert.Equal(0, lockFile.Targets[0].Libraries.Count); // Verify round tripping for v1 with p2ps Assert.Equal(result.LockFile, lockFile); } }
public void JsonInstanceModelFromAutogenJson() { Mock <IRepository> moqRepository = new Mock <IRepository>(); int failCount = 0; int mismatchCount = 0; string[] files = Directory.GetFiles("Common/xsd", "*.xsd", SearchOption.AllDirectories); foreach (string file in files) { try { // XSD to Json Schema metadata XsdToJsonSchema xsdToJsonSchemaConverter = new XsdToJsonSchema(new XmlTextReader(file), TestLogger.Create <XsdToJsonSchema>()); JsonSchema schemaJsonSchema = xsdToJsonSchemaConverter.AsJsonSchema(); JsonSchemaToInstanceModelGenerator converter = new JsonSchemaToInstanceModelGenerator("org", "app", schemaJsonSchema, string.Empty); JsonObject instanceModel = converter.GetInstanceModel(); // XSD to Json Schema metadata using obsolete SeresXsdParser ServiceMetadata serviceMetadata = SeresXSDParse(moqRepository, file); JsonValue serviceMetadataValue = new JsonSerializer().Serialize <ServiceMetadata>(serviceMetadata); if (!instanceModel["Elements"].Equals(serviceMetadataValue.Object["Elements"])) { mismatchCount++; // File.WriteAllText(file + ".new.schema.json", instanceModel.GetIndentedString(0)); // File.WriteAllText(file + ".seresParser.schema.json", serviceMetadataValue.GetIndentedString(0)); } } catch (Exception) { failCount++; } } Assert.Equal(0, failCount); }
public async Task Project2ProjectInLockFile_VerifySnapshotVersionsXProj() { // Arrange var sources = new List <PackageSource>(); var project1Json = @" { ""version"": ""2.0.0-*"", ""description"": ""Proj1 Class Library"", ""authors"": [ ""author"" ], ""tags"": [ """" ], ""projectUrl"": """", ""licenseUrl"": """", ""dependencies"": { ""project2"": ""2.0.0-*"" }, ""frameworks"": { ""net45"": { } } }"; var project2Json = @" { ""version"": ""2.0.0-*"", ""description"": ""Proj2 Class Library"", ""authors"": [ ""author"" ], ""tags"": [ """" ], ""projectUrl"": """", ""licenseUrl"": """", ""frameworks"": { ""net45"": { } } }"; var globalJson = @" { ""projects"": [ ""projects"" ] }"; using (var packagesDir = TestFileSystemUtility.CreateRandomTestFolder()) using (var workingDir = TestFileSystemUtility.CreateRandomTestFolder()) { var project1 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project1")); var project2 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project2")); project1.Create(); project2.Create(); File.WriteAllText(Path.Combine(project1.FullName, "project.json"), project1Json); File.WriteAllText(Path.Combine(project2.FullName, "project.json"), project2Json); File.WriteAllText(Path.Combine(workingDir, "global.json"), globalJson); File.WriteAllText(Path.Combine(project1.FullName, "project1.csproj"), string.Empty); File.WriteAllText(Path.Combine(project2.FullName, "project2.xproj"), string.Empty); var specPath1 = Path.Combine(project1.FullName, "project.json"); var specPath2 = Path.Combine(project2.FullName, "project.json"); var spec1 = JsonPackageSpecReader.GetPackageSpec(project1Json, "project1", specPath1); var spec2 = JsonPackageSpecReader.GetPackageSpec(project2Json, "project2", specPath2); var logger = new TestLogger(); var request = new RestoreRequest(spec1, sources, packagesDir, logger); request.LockFilePath = Path.Combine(project1.FullName, "project.lock.json"); var format = new LockFileFormat(); // Act var command = new RestoreCommand(request); var result = await command.ExecuteAsync(); await result.CommitAsync(logger, CancellationToken.None); var lockFile = format.Read(request.LockFilePath, logger); var project2Lib = lockFile.GetLibrary("project2", NuGetVersion.Parse("2.0.0")); var project2Target = lockFile.GetTarget(FrameworkConstants.CommonFrameworks.Net45, runtimeIdentifier: null) .Libraries .Single(lib => lib.Name == "project2"); // Assert Assert.True(result.Success); Assert.Equal("2.0.0", project2Target.Version.ToString()); Assert.Equal("2.0.0", project2Lib.Version.ToString()); } }
public async Task CompatilibityChecker_RuntimeFoundInSamePackage_SuccessAsync() { // Arrange var sources = new List <PackageSource>(); var project1Json = @" { ""version"": ""1.0.0"", ""description"": """", ""authors"": [ ""author"" ], ""tags"": [ """" ], ""projectUrl"": """", ""licenseUrl"": """", ""frameworks"": { ""netstandard1.5"": { ""dependencies"": { ""packageA"": { ""version"": ""1.0.0"" } } } } }"; using (var workingDir = TestDirectory.Create()) { var packagesDir = new DirectoryInfo(Path.Combine(workingDir, "globalPackages")); var packageSource = new DirectoryInfo(Path.Combine(workingDir, "packageSource")); var project1 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project1")); packagesDir.Create(); packageSource.Create(); project1.Create(); sources.Add(new PackageSource(packageSource.FullName)); File.WriteAllText(Path.Combine(project1.FullName, "project.json"), project1Json); var specPath1 = Path.Combine(project1.FullName, "project.json"); var spec1 = JsonPackageSpecReader.GetPackageSpec(project1Json, "project1", specPath1); var logger = new TestLogger(); var request = new TestRestoreRequest(spec1, sources, packagesDir.FullName, logger) { LockFilePath = Path.Combine(project1.FullName, "project.lock.json") }; request.RequestedRuntimes.Add("win7-x86"); var packageA = new SimpleTestPackageContext("packageA"); packageA.AddFile("ref/netstandard1.3/a.dll"); packageA.AddFile("ref/netstandard1.3/b.dll"); packageA.AddFile("ref/netstandard1.3/c.dll"); packageA.AddFile("runtimes/win7-x86/lib/netstandard1.1/a.dll"); packageA.AddFile("runtimes/win7-x86/lib/netstandard1.1/b.ni.dll"); packageA.AddFile("runtimes/win7-x86/lib/netstandard1.1/c.dll"); await SimpleTestPackageUtility.CreatePackagesAsync(packageSource.FullName, packageA); // Act var command = new RestoreCommand(request); var result = await command.ExecuteAsync(); await result.CommitAsync(logger, CancellationToken.None); // Assert Assert.True(result.Success, logger.ShowErrors()); // Verify both libraries were installed Assert.Equal(1, result.LockFile.Libraries.Count); // Verify no compatibility issues Assert.True(result.CompatibilityCheckResults.All(check => check.Success)); } }
public DefaultUserSessionTests() { _user = IdentityServerPrincipal.Create("123", "bob"); _subject = new DefaultUserSession(_mockHttpContext, _options, TestLogger.Create <DefaultUserSession>()); }
public void TestExtensions() { var log = new TestLogger(LogLevel.Trace); var ex = new FieldAccessException("abc"); // Log log.Log(LogLevel.Trace, "trace"); CheckLastMessage(LogLevel.Trace, "trace"); log.Log(LogLevel.Debug, "msg {0} {1}", 1, "2"); CheckLastMessage(LogLevel.Debug, "msg {0} {1}", new object[] { 1, "2" }, CultureInfo.InvariantCulture); log.Log(LogLevel.Info, ex, "msg"); CheckLastMessage(LogLevel.Info, "msg", e: ex); log.Log(LogLevel.Warn, ex, "msg {0}", 1); CheckLastMessage(LogLevel.Warn, "msg {0}", new object[] { 1 }, CultureInfo.InvariantCulture, e: ex); // Trace log.Trace("trace"); CheckLastMessage(LogLevel.Trace, "trace"); log.Trace("msg {0} {1}", 1, "2"); CheckLastMessage(LogLevel.Trace, "msg {0} {1}", new object[] { 1, "2" }, CultureInfo.InvariantCulture); log.Trace(ex, "msg"); CheckLastMessage(LogLevel.Trace, "msg", e: ex); log.Trace(ex, "msg {0}", 1); CheckLastMessage(LogLevel.Trace, "msg {0}", new object[] { 1 }, CultureInfo.InvariantCulture, e: ex); // Debug log.Debug("test"); CheckLastMessage(LogLevel.Debug, "test"); log.Debug("msg {0} {1}", 1, "2"); CheckLastMessage(LogLevel.Debug, "msg {0} {1}", new object[] { 1, "2" }, CultureInfo.InvariantCulture); log.Debug(ex, "msg"); CheckLastMessage(LogLevel.Debug, "msg", e: ex); log.Debug(ex, "msg {0}", 1); CheckLastMessage(LogLevel.Debug, "msg {0}", new object[] { 1 }, CultureInfo.InvariantCulture, e: ex); // Info log.Info("test"); CheckLastMessage(LogLevel.Info, "test"); log.Info("msg {0} {1}", 1, "2"); CheckLastMessage(LogLevel.Info, "msg {0} {1}", new object[] { 1, "2" }, CultureInfo.InvariantCulture); log.Info(ex, "msg"); CheckLastMessage(LogLevel.Info, "msg", e: ex); log.Info(ex, "msg {0}", 1); CheckLastMessage(LogLevel.Info, "msg {0}", new object[] { 1 }, CultureInfo.InvariantCulture, e: ex); // Warn log.Warn("test"); CheckLastMessage(LogLevel.Warn, "test"); log.Warn("msg {0} {1}", 1, "2"); CheckLastMessage(LogLevel.Warn, "msg {0} {1}", new object[] { 1, "2" }, CultureInfo.InvariantCulture); log.Warn(ex, "msg"); CheckLastMessage(LogLevel.Warn, "msg", e: ex); log.Warn(ex, "msg {0}", 1); CheckLastMessage(LogLevel.Warn, "msg {0}", new object[] { 1 }, CultureInfo.InvariantCulture, e: ex); // Error log.Error("test"); CheckLastMessage(LogLevel.Error, "test"); log.Error("msg {0} {1}", 1, "2"); CheckLastMessage(LogLevel.Error, "msg {0} {1}", new object[] { 1, "2" }, CultureInfo.InvariantCulture); log.Error(ex, "msg"); CheckLastMessage(LogLevel.Error, "msg", e: ex); log.Error(ex, "msg {0}", 1); CheckLastMessage(LogLevel.Error, "msg {0}", new object[] { 1 }, CultureInfo.InvariantCulture, e: ex); // GetLogger var catLog = log.GetLogger("myCategory"); catLog.Info("info"); CheckLastMessage(LogLevel.Info, "info", category: "myCategory"); catLog.Log(LogLevel.Info, "info", null, null, "explicitCat", null, null); CheckLastMessage(LogLevel.Info, "info", category: "explicitCat"); catLog = catLog.GetLogger("newCat"); catLog.Info("info"); CheckLastMessage(LogLevel.Info, "info", category: "newCat"); catLog.Log(LogLevel.Info, "info", null, null, "explicitCat", null, null); CheckLastMessage(LogLevel.Info, "info", category: "explicitCat"); }
[WorkItem(126)] // Exclude secrets from log data: http://jira.sonarsource.com/browse/SONARMSBRU-126 public void ProcRunner_DoNotLogSensitiveData() { // Arrange string testDir = TestUtils.CreateTestSpecificFolder(this.TestContext); // Create a dummy exe that will produce a log file showing any input args string exeName = DummyExeHelper.CreateDummyPostProcessor(testDir, 0); TestLogger logger = new TestLogger(); // Public args - should appear in the log string[] publicArgs = new string[] { "public1", "public2", "/d:sonar.projectKey=my.key" }; string[] sensitiveArgs = new string[] { // Public args - should appear in the log "public1", "public2", "/dmy.key=value", // Sensitive args - should not appear in the log "/d:sonar.password=secret data password", "/d:sonar.login=secret data login", "/d:sonar.jdbc.password=secret data db password", "/d:sonar.jdbc.username=secret data db user name", // Sensitive args - different cases -> exclude to be on the safe side "/d:SONAR.jdbc.password=secret data db password upper", "/d:sonar.PASSWORD=secret data password upper", // Sensitive args - parameter format is slightly incorrect -> exclude to be on the safe side "/dsonar.login =secret data key typo", "sonar.password=secret data password typo" }; string[] allArgs = sensitiveArgs.Union(publicArgs).ToArray(); ProcessRunnerArguments runnerArgs = new ProcessRunnerArguments(exeName, logger) { CmdLineArgs = allArgs }; ProcessRunner runner = new ProcessRunner(); // Act bool success = runner.Execute(runnerArgs); // Assert Assert.IsTrue(success, "Expecting the process to have succeeded"); Assert.AreEqual(0, runner.ExitCode, "Unexpected exit code"); // Check public arguments are logged but private ones are not foreach (string arg in publicArgs) { logger.AssertSingleDebugMessageExists(arg); } logger.AssertSingleDebugMessageExists(SonarQube.Common.Resources.MSG_CmdLine_SensitiveCmdLineArgsAlternativeText); AssertTextDoesNotAppearInLog("secret", logger); // Check that the public and private arguments are passed to the child process string exeLogFile = DummyExeHelper.AssertDummyPostProcLogExists(testDir, this.TestContext); DummyExeHelper.AssertExpectedLogContents(exeLogFile, allArgs); }
public virtual void RunTests(IEnumerable<string> sources, IRunContext runContext, IFrameworkHandle frameworkHandle) { TestAdapterInfo = CreateTestAdapterInfo(); var testLogger = TestAdapterInfo.CreateLogger(frameworkHandle); var runLogger = new TestLogger(testLogger, "Run"); var testSettings = runContext.RunSettings.GetTestSettings(TestAdapterInfo.SettingsName); var count = 0; var testCount = 0; foreach (var source in sources) { var sourceSettings = GetSourceSettings(source, testSettings); if (sourceSettings != null) { testCount += RunTests(sourceSettings, testLogger, runContext, frameworkHandle).Result; count += 1; } else { runLogger.Warn("Could not get settings for {0}", source); } } if (count > 0 || testCount > 0) { runLogger.Info("{0} tests run in {1} test containers", testCount, count); } }
private static void AssertTextDoesNotAppearInLog(string text, TestLogger logger) { AssertTextDoesNotAppearInLog(text, logger.InfoMessages); AssertTextDoesNotAppearInLog(text, logger.Errors); AssertTextDoesNotAppearInLog(text, logger.Warnings); }
public async Task LongInstance() { TestLogger l = new TestLogger(); Guid g1 = Guid.NewGuid(); l.Increment(g1); l.Poll(10); l.Poll(20); l.Poll(30); l.Decrement(g1); l.Poll(40); // this will catch partial activity after 30 l.Poll(41); // should be 0, so no entry Assert.Equal(1, l._totalActive); Assert.Equal(4, l._dict.Count); Assert.Equal(1, l._dict[10]); Assert.Equal(1, l._dict[20]); Assert.Equal(1, l._dict[30]); // This is 1, not 0, because it's catching the partial activity between 30 and 40. // But no entry after Time40. Assert.Equal(1, l._dict[40]); }
public void OneTimeSetUp() { _nuGetHandlerMock = new Mock <IPortingAssistantNuGetHandler>(); _recommendationHandlerMock = new Mock <IPortingAssistantRecommendationHandler>(); _analysisHandler = new PortingAssistantAnalysisHandler(TestLogger.Create <PortingAssistantAnalysisHandler>(), _nuGetHandlerMock.Object, _recommendationHandlerMock.Object); }
public void CreateLogger() { log = new TestLogger(); }
public async Task Password_GrantType_Not_Supported() { var client = await _clients.FindEnabledClientByIdAsync("roclient"); var validator = Factory.CreateTokenRequestValidator(resourceOwnerValidator: new NotSupportedResouceOwnerPasswordValidator(TestLogger.Create <NotSupportedResouceOwnerPasswordValidator>())); var parameters = new NameValueCollection(); parameters.Add(OidcConstants.TokenRequest.GrantType, OidcConstants.GrantTypes.Password); parameters.Add(OidcConstants.TokenRequest.Scope, "resource"); parameters.Add(OidcConstants.TokenRequest.UserName, "bob"); parameters.Add(OidcConstants.TokenRequest.Password, "bob"); var result = await validator.ValidateRequestAsync(parameters, client); result.IsError.Should().BeTrue(); result.Error.Should().Be(OidcConstants.TokenErrors.UnsupportedGrantType); result.ErrorDescription.Should().BeNull(); }
/// <summary> /// Initializes some variables. /// </summary> /// <param name="name">Name of the test.</param> /// <param name="debug">If debug output should be written.</param> /// <param name="input">If new input file shuould be generated.</param> /// <param name="onClient">If the code was started on client.</param> public static void Initialize(String name, String appPath, Boolean debug, Boolean input, Boolean onClient) { testName = name; debugOutput = debug; generateInput = input; startedOnClient = onClient; inputFilePath = appPath + testName + "Input.txt"; generatedInputFilePath = appPath + testName + "Generated.txt"; debugFilePath = appPath + testName + "Debug.txt"; if (appPath == null) outputFilePath = testName + "Output.txt"; else outputFilePath = appPath + testName + "Output.txt"; if (!startedOnClient) logSource = new LogSource(testName); testLogger = new TestLogger(testName, startedOnClient); }
public async Task ToRpcInvocationRequest_MultipleInputBindings() { var logger = new TestLogger("test"); var httpContext = new DefaultHttpContext(); httpContext.Request.Host = new HostString("local"); httpContext.Request.Path = "/test"; httpContext.Request.Method = "Post"; var poco = new TestPoco { Id = 1, Name = "Test" }; var bindingData = new Dictionary <string, object> { { "req", httpContext.Request }, { "$request", httpContext.Request }, { "headers", httpContext.Request.Headers.ToDictionary(p => p.Key, p => p.Value) }, { "query", httpContext.Request.QueryString.ToString() }, { "sys", new SystemBindingData() } }; var inputs = new List <(string name, DataType type, object val)> { ("req", DataType.String, httpContext.Request), ("blob", DataType.String, null), // verify that null values are handled ("foo", DataType.String, "test"), ("bar1", DataType.String, poco), ("bar2", DataType.String, poco) }; var invocationContext = new ScriptInvocationContext() { ExecutionContext = new ExecutionContext() { InvocationId = Guid.NewGuid(), FunctionName = "Test", }, BindingData = bindingData, Inputs = inputs, ResultSource = new TaskCompletionSource <ScriptInvocationResult>(), Logger = logger, AsyncExecutionContext = System.Threading.ExecutionContext.Capture() }; var functionMetadata = new FunctionMetadata { Name = "Test" }; var httpTriggerBinding = new BindingMetadata { Name = "req", Type = "httpTrigger", Direction = BindingDirection.In, Raw = new JObject() }; var blobInputBinding = new BindingMetadata { Name = "blob", Type = "blob", Direction = BindingDirection.In }; var fooInputBinding = new BindingMetadata { Name = "foo", Type = "foo", Direction = BindingDirection.In }; var barInputBinding1 = new BindingMetadata { Name = "bar1", Type = "bar", Direction = BindingDirection.In }; var barInputBinding2 = new BindingMetadata { Name = "bar2", Type = "bar", Direction = BindingDirection.In }; var httpOutputBinding = new BindingMetadata { Name = "res", Type = "http", Direction = BindingDirection.Out, Raw = new JObject(), DataType = DataType.String }; functionMetadata.Bindings.Add(httpTriggerBinding); functionMetadata.Bindings.Add(blobInputBinding); functionMetadata.Bindings.Add(fooInputBinding); functionMetadata.Bindings.Add(barInputBinding1); functionMetadata.Bindings.Add(barInputBinding2); functionMetadata.Bindings.Add(httpOutputBinding); invocationContext.FunctionMetadata = functionMetadata; Capabilities capabilities = new Capabilities(logger); var result = await invocationContext.ToRpcInvocationRequest(logger, capabilities); Assert.Equal(5, result.InputData.Count); Assert.Equal("req", result.InputData[0].Name); var resultHttp = result.InputData[0].Data; Assert.Equal("http://local/test", ((RpcHttp)result.InputData[0].Data.Http).Url); // verify the null input was propagated properly Assert.Equal("blob", result.InputData[1].Name); Assert.Equal(string.Empty, result.InputData[1].Data.String); Assert.Equal("foo", result.InputData[2].Name); Assert.Equal("test", result.InputData[2].Data.String); Assert.Equal("bar1", result.InputData[3].Name); var resultPoco = result.InputData[3].Data; Assert.Equal("{\"Name\":\"Test\",\"Id\":1}", resultPoco.Json); Assert.Equal("bar2", result.InputData[4].Name); Assert.Same(resultPoco, result.InputData[4].Data); Assert.Equal(4, result.TriggerMetadata.Count); Assert.Same(resultHttp, result.TriggerMetadata["req"]); Assert.Same(resultHttp, result.TriggerMetadata["$request"]); Assert.True(result.TriggerMetadata.ContainsKey("headers")); Assert.True(result.TriggerMetadata.ContainsKey("query")); }
public async Task Project2ProjectInLockFile_CSProjToXProj() { // Arrange var sources = new List <PackageSource>(); var projectJson = @" { ""version"": ""1.0.0"", ""dependencies"": { }, ""frameworks"": { ""net45"": {} } }"; var project2Json = @" { ""version"": ""1.0.0-*"", ""description"": ""Proj2 Class Library"", ""authors"": [ ""author"" ], ""tags"": [ """" ], ""projectUrl"": """", ""licenseUrl"": """", ""frameworks"": { ""net45"": { } } }"; using (var packagesDir = TestFileSystemUtility.CreateRandomTestFolder()) using (var workingDir = TestFileSystemUtility.CreateRandomTestFolder()) { var project1 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project1")); var project2 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project2")); project1.Create(); project2.Create(); File.WriteAllText(Path.Combine(project1.FullName, "project.json"), projectJson); File.WriteAllText(Path.Combine(project2.FullName, "project.json"), project2Json); File.WriteAllText(Path.Combine(project1.FullName, "project1.csproj"), string.Empty); File.WriteAllText(Path.Combine(project2.FullName, "project2.xproj"), string.Empty); var specPath1 = Path.Combine(project1.FullName, "project.json"); var specPath2 = Path.Combine(project2.FullName, "project.json"); var spec1 = JsonPackageSpecReader.GetPackageSpec(projectJson, "project1", specPath1); var spec2 = JsonPackageSpecReader.GetPackageSpec(project2Json, "project2", specPath2); var logger = new TestLogger(); var request = new RestoreRequest(spec1, sources, packagesDir, logger); request.ExternalProjects.Add(new ExternalProjectReference( "project1", spec1, Path.Combine(project1.FullName, "project1.xproj"), new string[] { "project2" })); request.ExternalProjects.Add(new ExternalProjectReference( "project2", spec2, Path.Combine(project2.FullName, "project2.xproj"), new string[] { })); request.LockFilePath = Path.Combine(project1.FullName, "project.lock.json"); var format = new LockFileFormat(); // Act var command = new RestoreCommand(request); var result = await command.ExecuteAsync(); await result.CommitAsync(logger, CancellationToken.None); var lockFile = format.Read(request.LockFilePath, logger); var project2Lib = lockFile.GetLibrary("project2", NuGetVersion.Parse("1.0.0")); var project2Target = lockFile.GetTarget(FrameworkConstants.CommonFrameworks.Net45, runtimeIdentifier: null) .Libraries .Where(lib => lib.Name == "project2") .Single(); // Assert Assert.True(result.Success); Assert.Equal(1, lockFile.Libraries.Count); Assert.Equal("project", project2Lib.Type); Assert.Equal("../project2/project.json", project2Lib.Path); Assert.Equal("../project2/project2.xproj", project2Lib.MSBuildProject); Assert.Equal(".NETFramework,Version=v4.5", project2Target.Framework); Assert.Equal(1, project2Target.CompileTimeAssemblies.Count); Assert.Equal("net45/project2.dll", project2Target.CompileTimeAssemblies.Single().Path); } }
public async Task LocalPackageMetadataResourceTests_VerifyAllFields() { using (var root = TestFileSystemUtility.CreateRandomTestFolder()) { // Arrange var testLogger = new TestLogger(); var nuspec = XDocument.Parse($@"<?xml version=""1.0"" encoding=""utf-8""?> <package> <metadata> <id>a</id> <version>1.0.0-alpha.1.2+5</version> <title>myTitle</title> <authors>a,b,c</authors> <owners>a,b</owners> <description>package description</description> <releaseNotes>notes</releaseNotes> <summary>sum</summary> <language>en-us</language> <projectUrl>http://nuget.org/</projectUrl> <iconUrl>http://nuget.org/nuget.jpg</iconUrl> <licenseUrl>http://nuget.org/license.txt</licenseUrl> <requireLicenseAcceptance>true</requireLicenseAcceptance> <copyright>MIT</copyright> <tags>a b c</tags> <developmentDependency>true</developmentDependency> <dependencies> <group> <dependency id=""b"" version=""1.0"" /> </group> <group targetFramework=""net461""> </group> </dependencies> </metadata> </package>"); var packageA = new SimpleTestPackageContext() { Id = "a", Version = "1.0.0-alpha.1.2+5", Nuspec = nuspec }; var packageA2 = new SimpleTestPackageContext() { Id = "a", Version = "1.0.0-alpha.1.1" }; var packageContexts = new SimpleTestPackageContext[] { packageA, packageA2 }; SimpleTestPackageUtility.CreatePackages(root, packageContexts); var localResource = new FindLocalPackagesResourceV2(root); var resource = new LocalPackageMetadataResource(localResource); // Act var packages = (await resource.GetMetadataAsync( "A", includePrerelease: true, includeUnlisted: false, log: testLogger, token: CancellationToken.None)) .OrderByDescending(p => p.Identity.Version) .ToList(); var package = packages.First(); // Assert Assert.Equal(2, packages.Count); Assert.Equal("a,b,c", package.Authors); Assert.Equal(2, package.DependencySets.Count()); Assert.Equal("package description", package.Description); Assert.Equal(0, package.DownloadCount); Assert.Equal(new Uri("http://nuget.org/nuget.jpg"), package.IconUrl); Assert.Equal("1.0.0-alpha.1.2+5", package.Identity.Version.ToFullString()); Assert.Equal(new Uri("http://nuget.org/license.txt"), package.LicenseUrl); Assert.Equal("a,b", package.Owners); Assert.Equal(new Uri("http://nuget.org/"), package.ProjectUrl); Assert.NotNull(package.Published); Assert.Null(package.ReportAbuseUrl); Assert.True(package.RequireLicenseAcceptance); Assert.Equal("sum", package.Summary); Assert.Equal("a b c", package.Tags); Assert.Equal("myTitle", package.Title); Assert.Equal("notes", package.ReleaseNotes); } }
public void SimpleCoverage() { var innerMessage = ""; var inner = new TestLogger(); var adapter = new LogAdapter(inner); inner.MethodCalled += (s, e) => { innerMessage = e.Message; }; var obj = new object(); const string format = "{0}"; var formatProvider = CultureInfo.InvariantCulture; var exception = new Exception(); // we are going to call methods on the adapter and verify that the // reciprocal methods are called on the inner logger instance // Debug Object adapter.Debug(obj); Assert.AreEqual("Debug(object message)", innerMessage); // Debug Object, Exception adapter.Debug(obj, exception); Assert.AreEqual("Debug(object message, Exception exception)", innerMessage); // Error Object adapter.Error(obj); Assert.AreEqual("Error(object message)", innerMessage); // Error Object, Exception adapter.Error(obj, exception); Assert.AreEqual("Error(object message, Exception exception)", innerMessage); // Fatal Object adapter.Fatal(obj); Assert.AreEqual("Fatal(object message)", innerMessage); // Fatal Object, Exception adapter.Fatal(obj, exception); Assert.AreEqual("Fatal(object message, Exception exception)", innerMessage); // Info Object adapter.Info(obj); Assert.AreEqual("Info(object message)", innerMessage); // Info Object, Exception adapter.Info(obj, exception); Assert.AreEqual("Info(object message, Exception exception)", innerMessage); // Trace Object adapter.Trace(obj); Assert.AreEqual("Trace(object message)", innerMessage); // Trace Object, Exception adapter.Trace(obj, exception); Assert.AreEqual("Trace(object message, Exception exception)", innerMessage); // Warn Object adapter.Warn(obj); Assert.AreEqual("Warn(object message)", innerMessage); // Warn Object, Exception adapter.Warn(obj, exception); Assert.AreEqual("Warn(object message, Exception exception)", innerMessage); }
public async Task Project2ProjectInLockFile_VerifyProjectsReferencesInLibAndTargets() { // Arrange var sources = new List <PackageSource>(); var project1Json = @" { ""version"": ""1.0.0"", ""dependencies"": { ""project2"": ""1.0.0-*"", }, ""frameworks"": { ""net45"": {} } }"; var project2Json = @" { ""version"": ""1.0.0"", ""dependencies"": { ""project3"": ""1.0.0-*"", }, ""frameworks"": { ""net45"": {} } }"; var project3Json = @" { ""version"": ""1.0.0"", ""dependencies"": { }, ""frameworks"": { ""net45"": {} } }"; var globalJson = @" { ""projects"": [ ""projects"" ] }"; using (var packagesDir = TestFileSystemUtility.CreateRandomTestFolder()) using (var workingDir = TestFileSystemUtility.CreateRandomTestFolder()) { var project1 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project1")); var project2 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project2")); var project3 = new DirectoryInfo(Path.Combine(workingDir, "projects", "project3")); project1.Create(); project2.Create(); project3.Create(); File.WriteAllText(Path.Combine(project1.FullName, "project.json"), project1Json); File.WriteAllText(Path.Combine(project2.FullName, "project.json"), project2Json); File.WriteAllText(Path.Combine(project3.FullName, "project.json"), project3Json); File.WriteAllText(Path.Combine(workingDir, "global.json"), globalJson); File.WriteAllText(Path.Combine(project1.FullName, "project1.xproj"), string.Empty); File.WriteAllText(Path.Combine(project2.FullName, "project2.xproj"), string.Empty); File.WriteAllText(Path.Combine(project3.FullName, "project3.xproj"), string.Empty); var specPath1 = Path.Combine(project1.FullName, "project.json"); var spec = JsonPackageSpecReader.GetPackageSpec(project1Json, "project1", specPath1); var specPath2 = Path.Combine(project2.FullName, "project.json"); var specPath3 = Path.Combine(project3.FullName, "project.json"); var logger = new TestLogger(); var request = new RestoreRequest(spec, sources, packagesDir, logger); request.LockFilePath = Path.Combine(project1.FullName, "project.lock.json"); var format = new LockFileFormat(); // Act var command = new RestoreCommand(request); var result = await command.ExecuteAsync(); await result.CommitAsync(logger, CancellationToken.None); var lockFile = format.Read(request.LockFilePath, logger); var project1Lib = lockFile.GetLibrary("project1", NuGetVersion.Parse("1.0.0")); var project2Lib = lockFile.GetLibrary("project2", NuGetVersion.Parse("1.0.0")); var project3Lib = lockFile.GetLibrary("project3", NuGetVersion.Parse("1.0.0")); var project2Target = lockFile.GetTarget(FrameworkConstants.CommonFrameworks.Net45, runtimeIdentifier: null) .Libraries .Where(lib => lib.Name == "project2") .Single(); var project3Target = lockFile.GetTarget(FrameworkConstants.CommonFrameworks.Net45, runtimeIdentifier: null) .Libraries .Where(lib => lib.Name == "project3") .Single(); // Assert Assert.True(result.Success); Assert.Equal(2, lockFile.Libraries.Count); Assert.Equal("project", project2Lib.Type); Assert.Equal("project", project3Lib.Type); Assert.Equal("../project2/project.json", project2Lib.Path); Assert.Equal("../project3/project.json", project3Lib.Path); Assert.Equal("../project2/project2.xproj", project2Lib.MSBuildProject); Assert.Equal("../project3/project3.xproj", project3Lib.MSBuildProject); Assert.Equal(1, project2Target.CompileTimeAssemblies.Count); Assert.Equal("net45/project2.dll", project2Target.CompileTimeAssemblies.Single().Path); Assert.Equal(1, project3Target.CompileTimeAssemblies.Count); Assert.Equal("net45/project3.dll", project3Target.CompileTimeAssemblies.Single().Path); Assert.Equal(1, project2Target.Dependencies.Count); Assert.Equal("project3", project2Target.Dependencies.Single().Id); Assert.Equal("1.0.0", project2Target.Dependencies.Single().VersionRange.ToLegacyShortString()); Assert.Equal(0, project3Target.Dependencies.Count); Assert.Equal(".NETFramework,Version=v4.5", project2Target.Framework); Assert.Equal(".NETFramework,Version=v4.5", project3Target.Framework); } }