示例#1
0
        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 ) );
        }
示例#3
0
 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() );
            }
        }
示例#7
0
 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 ) );
        }
示例#10
0
        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]);
        }
示例#14
0
        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;
        }
示例#15
0
        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);
            }));
        }
示例#16
0
 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
        }
示例#19
0
        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);
        }
示例#22
0
        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);
        }
示例#25
0
 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);
        }
示例#28
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);
            }
        }
示例#29
0
        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));
        }
示例#31
0
        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();
                }
            }
        }
示例#32
0
 public InMemoryCorsPolicyServiceTests()
 {
     _subject = new InMemoryCorsPolicyService(TestLogger.Create <InMemoryCorsPolicyService>(), _clients);
 }
示例#33
0
        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}");
        }
示例#34
0
 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); 
        }
示例#36
0
        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);
                }
        }
示例#37
0
        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);
        }
示例#39
0
        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"));
        }
示例#40
0
 public void TestSetUp()
 {
     TestLogger.Clear();
 }
示例#41
0
 public TestsCliProcessor()
 {
     Logger = new TestLogger();
 }
示例#42
0
        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);
        }
示例#44
0
        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>());
 }
示例#47
0
        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);
        }
示例#49
0
        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);
 }
示例#53
0
 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();
        }
示例#55
0
 /// <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);
 }
示例#56
0
        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"));
        }
示例#57
0
        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);



        }
示例#60
0
        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);
                }
        }