protected override async Task ConfigureAsync() { AddDevice(new BuiltInI2CBus()); var pi2PortController = new Pi2PortController(); var ccToolsBoardController = new CCToolsBoardController(this, GetDevice <II2CBus>()); AddDevice(pi2PortController); AddDevice(ccToolsBoardController); ServiceLocator.RegisterService( typeof(OpenWeatherMapWeatherService), new OpenWeatherMapService(ApiController, ServiceLocator.GetService <IDateTimeService>(), ServiceLocator.GetService <ISchedulerService>(), ServiceLocator.GetService <ISystemInformationService>())); var configurationParser = new ConfigurationParser(this); configurationParser.RegisterConfigurationExtender(new DefaultConfigurationExtender(configurationParser, this)); configurationParser.RegisterConfigurationExtender(new CCToolsConfigurationExtender(configurationParser, this)); configurationParser.RegisterConfigurationExtender(new I2CHardwareBridgeConfigurationExtender(configurationParser, this)); configurationParser.ParseConfiguration(); InitializeAzureCloudApiEndpoint(); var ioBoardsInterruptMonitor = new InterruptMonitor(pi2PortController.GetInput(4)); ioBoardsInterruptMonitor.InterruptDetected += (s, e) => ccToolsBoardController.PollInputBoardStates(); ioBoardsInterruptMonitor.Start(); await base.ConfigureAsync(); }
/// <summary> /// Initializes a new instance of the <see cref="AzureBlobStorageMaintainer"/> class. /// </summary> /// <param name="parser">The application configuration object.</param> public AzureBlobStorageMaintainer(ConfigurationParser parser) { this.config = parser.Get(); var connectionString = string.Format(this.config.AzureBlob.ConnectionString, this.config.AzureBlob.AccountName, this.config.AzureBlob.AccountKey); this.storageClient = new BlobServiceClient(connectionString); }
public bool InitializeFiltersConfiguration() { var config = ConfigurationParser.Parse(); this.FiltersConfiguration = config; return(config != null); }
protected override void Initialize() { InitializeHealthMonitor(LedGpio); var pi2PortController = new Pi2PortController(); var ccToolsBoardController = new CCToolsBoardController(this, GetDevice <II2CBus>()); AddDevice(new BuiltInI2CBus()); AddDevice(pi2PortController); AddDevice(ccToolsBoardController); RegisterService(new OpenWeatherMapWeatherService(Timer, ApiController)); var configurationParser = new ConfigurationParser(this); configurationParser.RegisterConfigurationExtender(new DefaultConfigurationExtender(configurationParser, this)); configurationParser.RegisterConfigurationExtender(new CCToolsConfigurationExtender(configurationParser, this)); configurationParser.RegisterConfigurationExtender(new I2CHardwareBridgeConfigurationExtender(configurationParser, this)); configurationParser.ParseConfiguration(); InitializeAzureCloudApiEndpoint(); var ioBoardsInterruptMonitor = new InterruptMonitor(pi2PortController.GetInput(4)); ioBoardsInterruptMonitor.InterruptDetected += (s, e) => ccToolsBoardController.PollInputBoardStates(); ioBoardsInterruptMonitor.StartPollingAsync(); }
static void Main(string[] args) { var configFilePath = "appsettings.json"; if (args.Length > 0) { configFilePath = args[0]; } ConfigurationParser.LoadConfiguration(configFilePath); ConfigurationParser.FlattenSubscriptions(); ConfigurationParser.ExpandSubscriptionPatterns().GetAwaiter().GetResult(); SetupLogging(); Log.Logger.Information("Application started."); Log.Logger.Debug("Loaded configuration: \n{ConfigurationDump}", DependencyContext.Configuration.Dump()); ConfigurationParser.ValidateConfiguration(); ConfigurationParser.CoerceConfiguration(); SetupProgressDb().GetAwaiter().GetResult(); SetupMonitor(); DependencyContext.Monitor.StartAll(); Console.ReadLine(); DependencyContext.Monitor.StopAll(); }
public CakeConfiguration(IOmniSharpEnvironment environment, ILoggerFactory loggerFactory) { _lookup = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase); // Parse the configuration file. var configurationPath = Path.Combine(environment.TargetDirectory, "cake.config"); if (File.Exists(configurationPath)) { try { var parser = new ConfigurationParser(); var configuration = parser.Read(configurationPath); foreach (var key in configuration.Keys) { _lookup[KeyNormalizer.Normalize(key)] = configuration[key]; } } catch (Exception ex) { loggerFactory .CreateLogger <CakeConfiguration>() .LogError(ex, "Error occured while parsing Cake configuration."); } } }
public void GithubUserSourceSupport() { var processor = new ConfigurationParser(new Mock <ILogger>().Object); var source = processor.GetRepositorySource(ToJson("https://github.com/MarcStan")); source.Should().BeOfType <GithubRepositorySource>(); }
public async Task GetNotExpiredImageScansReturnsTheLatestScan() { // Arrange await using var context = JosekiTestsDb.CreateUniqueContext(); var parser = new ConfigurationParser("config.sample.yaml"); var db = new MssqlJosekiDatabase(context, parser); var tag = Guid.NewGuid().ToString(); var scans = new[] { new ImageScanResultEntity { ImageTag = tag, Date = DateTime.UtcNow.AddHours(-5), Status = joseki.db.entities.ImageScanStatus.Failed }, new ImageScanResultEntity { ImageTag = tag, Date = DateTime.UtcNow, Status = joseki.db.entities.ImageScanStatus.Queued }, new ImageScanResultEntity { ImageTag = tag, Date = DateTime.UtcNow.AddHours(-3), Status = joseki.db.entities.ImageScanStatus.Succeeded }, }; context.ImageScanResult.AddRange(scans); await context.SaveChangesAsync(); // Act & Assert var notExpiredScans = await db.GetNotExpiredImageScans(new[] { tag }); notExpiredScans.Should().HaveCount(1); notExpiredScans.First().Status.Should().Be(ImageScanStatus.Queued); }
protected override int Execute() { if (File.Exists(Helper.YamlSpecFile)) { throw new CementException("module.yaml already exists"); } var yamlTempName = Guid.NewGuid().ToString(); writer = File.CreateText(yamlTempName); var configurationsParser = new ConfigurationParser(new FileInfo(Directory.GetCurrentDirectory())); var defaultConfiguration = configurationsParser.GetDefaultConfigurationName(); var hierarchy = configurationsParser.GetConfigurationsHierarchy(); Convert(hierarchy, defaultConfiguration); writer.Close(); File.Move(yamlTempName, Helper.YamlSpecFile); ConsoleWriter.WriteOk("Successfully converted info."); ConsoleWriter.WriteInfo("Check build section."); ConsoleWriter.WriteInfo("Add install section."); return(0); }
public async Task BuildAndRunClients() { this.configuration = await ConfigurationParser.GetConfiguration(this.configFilePath); Console.WriteLine($"Working with the following Config: {JsonConvert.SerializeObject(this.configuration)}"); Console.WriteLine( $"Creating {this.configuration.ClientCount} clients."); Console.WriteLine($"Test will take {this.configuration.ClientConfiguration.TestDurationInMinutes} minutes."); BrokerFactory brokerFactory = new BrokerFactory(this.configuration.BrokerConfiguration); MessageBuilderFactory messageBuilderFactory = new MessageBuilderFactory(this.configuration.MessageBuilderConfiguration); ClientFactory clientFactory = new ClientFactory(this.configuration.ClientConfiguration, brokerFactory, messageBuilderFactory); var clients = clientFactory.Create(this.configuration.ClientCount); List <Task> taskList = new List <Task>(); foreach (var client in clients) { var clientTask = client.RunAsync(); taskList.Add(clientTask); } try { Task.WaitAll(taskList.ToArray()); } catch (AggregateException e) { for (int j = 0; j < e.InnerExceptions.Count; j++) { Console.WriteLine("\n-------------------------------------------------\n{0}", e.InnerExceptions[j].ToString()); } } Console.WriteLine($"Test ended."); }
public void Multiline_query_complex() { var sut = new ConfigurationParser(); TemplateDefinition def = sut.ParseTemplateDefinition( @"[[query]] query: ""SELECT * FROM workitems WHERE [System.WorkItemType] = 'Feature' AND [Microsoft.VSTS.Scheduling.TargetDate] >= '{TargetDateStart}' AND [Microsoft.VSTS.Scheduling.TargetDate] <= '{TargetDateEnd}' AND NOT[System.Tags] CONTAINS 'outofrelease' AND NOT[System.Tags] CONTAINS 'Report' AND [System.TeamProject] = '{teamProjectName}' AND( [System.IterationPath] = '{Iteration1}' OR [System.IterationPath] = '{Iteration2}' OR [System.IterationPath] = '{Iteration3}' OR [System.IterationPath] = '{Iteration4}' Or [System.IterationPath] = '{Iteration5}' )"" tableTemplate: 2_table.docx "); var querySection = def.AllSections.Single() as QuerySection; Assert.That(querySection.Query.Contains("Or [System.IterationPath] = '{Iteration5}'")); }
public void Query_with_hierarchy_mode() { var sut = new ConfigurationParser(); TemplateDefinition def = sut.ParseTemplateDefinition( @"[[query]] query: ""SELECT [System.Id], [System.WorkItemType], [System.Title], [System.AssignedTo], [System.State], [System.Tags] FROM workitemLinks WHERE ( [Source].[System.TeamProject] = @project AND [Source].[System.WorkItemType] = 'Feature' AND [Source].[Microsoft.VSTS.Scheduling.TargetDate] < '2002-01-01T00:00:00.0000000' AND [Source].[Microsoft.VSTS.Scheduling.TargetDate] > '2000-02-02T00:00:00.0000000' ) AND ( [System.Links.LinkType] = 'System.LinkTypes.Hierarchy-Forward' ) AND ( [Target].[System.TeamProject] = @project AND [Target].[System.WorkItemType] <> '' ) MODE (Recursive)"" hierarchyMode: task,feature,requirement,epic "); var querySection = def.AllSections.Single() as QuerySection; Assert.That(querySection.HierarchyMode, Is.EquivalentTo(new[] { "task", "feature", "requirement", "epic" })); }
public void Can_Write_Recursive_Class_To_File() { var dict = new Dictionary <string, string> { { "Item", "TEST_VAL_ITEM" }, { "SubItem_Item", "TEST_VAL_SUBITEM_ITEM" }, { "SubItem_SubSubItem_Item", "TEST_VAL_SUBITEM_SUBSUBITEM_ITEM" }, { "SubItem_SubSubItem_Bool", "true" }, { "SubItem_SubSubItem_Int", "10" }, { "SubItem_SubSubItem_Long", "10000000" }, { "SubItem_SubSubItem_Double", "2.2" }, { "SubItem_SubSubItem_Float", "2.22" } }; // Set the environment variables we're going to use. EnvironmentVariableSource.SetEnvironment(dict); var parsed = ConfigurationParser.ParseConfiguration <TestClass>(); ConfigurationWriter.WriteToFile(parsed, "cwrctf.txt", true); // Read in that file. var instance = ConfigurationParser.Parse <TestClass>("cwrctf.txt"); Assert.Equal("TEST_VAL_ITEM", instance.Item); Assert.Equal("TEST_VAL_SUBITEM_ITEM", instance?.SubItem?.Item); Assert.Equal("TEST_VAL_SUBITEM_SUBSUBITEM_ITEM", instance?.SubItem?.SubSubItem?.Item); Assert.True(instance?.SubItem?.SubSubItem?.Bool); Assert.Equal(10, instance?.SubItem?.SubSubItem?.Int); Assert.Equal(10000000, instance?.SubItem?.SubSubItem?.Long); Assert.Equal(2.2D, instance?.SubItem?.SubSubItem?.Double); Assert.Equal(2.22F, instance?.SubItem?.SubSubItem?.Float); }
public async Task GetAuditedComponentsWithHistoryReturnsOnlyOneMonthData() { // Arrange await using var context = JosekiTestsDb.CreateUniqueContext(); var parser = new ConfigurationParser("config.sample.yaml"); var db = new MssqlJosekiDatabase(context, parser); var componentId = Guid.NewGuid().ToString(); var today = DateTime.UtcNow; // create more than 31 entries, which the oldest ones would be filtered-out var entities = Enumerable.Range(0, 35) .Select(i => today.AddDays(-i)).Select(i => new AuditEntity { Date = i, ComponentId = componentId, InfrastructureComponent = new InfrastructureComponentEntity(), }); context.AddRange(entities); await context.SaveChangesAsync(); // Act & Assert var audits = await db.GetAuditedComponentsWithHistory(today); audits.Should().HaveCount(31); audits.All(i => i.Date >= today.AddDays(-30)).Should().BeTrue("All audits should be not earlier than 30 days ago"); }
// !! Event !! private void startService_Click(object sender, EventArgs e) { // 1 - Parse the xml config file try { ConfigurationParser.parseXml(configFileLocationTextBox.Text); } catch (Exception ex) // since the parseXml method does not declare any exceptions like IncorrectConfigurationException { // Cannot continue show error message box and exit from this method MessageBox.Show("The configuration file is broken. " + ex.ToString(), "Operation failed", MessageBoxButtons.OK, MessageBoxIcon.Error); return; } // 2 - Start the service try { sc.Start(); } catch (Exception ex) { // Cannot continue show error message box and exit from this method MessageBox.Show("Could not start the service. " + ex.ToString(), "Operation failed", MessageBoxButtons.OK, MessageBoxIcon.Error); return; } // 3 - Disable gui components to avoid user errors startService.Enabled = false; stopService.Enabled = false; startServiceToolStripMenuItem.Enabled = false; stopServiceToolStripMenuItem.Enabled = false; }
public void CanHandleOtherWaitSources() { //arrange var attrs = new Dictionary <string, string>() { { "JobType", typeof(DummyJob).AssemblyQualifiedName }, { "WaitSourceType", typeof(DummyWaitSource).AssemblyQualifiedName }, { "Test", "TestValue" }, { "Interval", TimeSpan.FromDays(1).ToString() }, { "from", new DateTime(2014, 1, 1, 12, 20, 0).ToString() } }; //act var job = ConfigurationParser.ParseAttributes(attrs); //assert Assert.AreEqual(typeof(DummyJob).FullName, job.Item1.FullName); Assert.IsInstanceOf <DummyWaitSource>(job.Item2); var ws = job.Item2 as DummyWaitSource; Assert.AreEqual(ws.Interval, TimeSpan.FromDays(1)); Assert.AreEqual(ws.From, new DateTime(2014, 1, 1, 12, 20, 0)); Assert.AreEqual(ws.Test, "TestValue"); }
/// <summary> /// Dumps the activities list into a json file. /// Backs up old files if any in the same name. /// </summary> public void Dump(string activityConfigurationFile = "") { logger.Info("Starting config dump operation."); if (string.IsNullOrWhiteSpace(activityConfigurationFile)) { activityConfigurationFile = ConfigurationParser.GetExecutorsConfigFile(); } //// If file name does not end with json extension, make it one. if (!activityConfigurationFile.EndsWith(".json", StringComparison.CurrentCultureIgnoreCase)) { activityConfigurationFile += ".json"; } //// back up old file if anything is available in the same name string activitiesJson = activityEntries.ToJson(); if (FileOperations.Exists(activityConfigurationFile)) { var timestamp = DateTime.Now.ToString("yyyyMMdd_hhmmss"); var newFileName = string.Format("{0}_{1}", timestamp, activityConfigurationFile); FileOperations.Copy(activityConfigurationFile, newFileName); logger.Info("Backed up old file in a different name."); } FileOperations.WriteAllText(activityConfigurationFile, activitiesJson); logger.Info("Finished dump operation."); }
public void LoadFromConfiguration() { ConfigurationParser parser = new ConfigurationParser("../../../confguration.json"); var config = parser.Read(); servicePort = config.Port; acquisitionInterval = config.AquisitionInterval * 1000; var converter = new ConfigurationDevicesConverter(); var devs = converter.ConvertToDevices(config); foreach (var item in devs.DigitalInputs) { Items.Add(item); } foreach (var item in devs.DigitalOutputs) { Items.Add(item); } foreach (var item in devs.AnalogInputs) { Items.Add(item); } foreach (var item in devs.AnalogOutputs) { Items.Add(item); } }
public void ParseAppConfiguration() { var parser = new ConfigurationParser(); var dotnetObject = parser.ParseConfigurationObject(typeof(ApplicationConfiguration)); RenderType(dotnetObject); }
public AzureBlobExporter(ConfigurationParser config) { this.blobCfg = config.GetAzBlobConfig(); this.scannerCfg = config.Get().Scanner; this.scannerVersion = config.ScannerVersion; this.azskVersion = config.AzskVersion; }
public void Does_Not_Allow_Recursive_Items() { Assert.Throws <RecursiveClassException>(() => { ConfigurationParser.ParseConfiguration <RecursiveClass>(); }); }
/// <summary> /// Creates the section from the node information. /// </summary> /// <param name="parent"></param> /// <param name="configContext">Configuration context object.</param> /// <param name="section"></param> /// <returns>The created section handler object.</returns> public object Create(object parent, object configContext, XmlNode section) { Configuration configuration = new Configuration(); ConfigurationParser.DoConfigure(configuration, section); return(configuration); }
public async Task SaveAuditResultSavesKubeMetadata() { // Arrange await using var context = JosekiTestsDb.CreateUniqueContext(); var parser = new ConfigurationParser("config.sample.yaml"); var db = new MssqlJosekiDatabase(context, parser); var audit = new Audit { MetadataKube = new MetadataKube { Date = DateTime.UtcNow, JSON = Guid.NewGuid().ToString(), }, }; // Act & Assert context.MetadataKube.Should().HaveCount(0); await db.SaveAuditResult(audit); context.MetadataKube.Should().HaveCount(1); var actual = await context.MetadataKube.FirstAsync(); actual.JSON.Should().Be(audit.MetadataKube.JSON); actual.Date.Should().Be(audit.MetadataKube.Date); }
public async Task SaveAuditResultSavesCorrectAudit() { // Arrange await using var context = JosekiTestsDb.CreateUniqueContext(); var parser = new ConfigurationParser("config.sample.yaml"); var db = new MssqlJosekiDatabase(context, parser); var audit = new Audit { ComponentId = Guid.NewGuid().ToString(), ComponentName = Guid.NewGuid().ToString(), Date = DateTime.UtcNow, ScannerId = Guid.NewGuid().ToString(), Id = Guid.NewGuid().ToString(), }; // Act & Assert context.Audit.Should().HaveCount(0); await db.SaveAuditResult(audit); context.Audit.Should().HaveCount(1); var actual = await context.Audit.FirstAsync(); actual.AuditId.Should().Be(audit.Id); actual.Date.Should().Be(audit.Date); actual.ComponentId.Should().Be(audit.ComponentId); }
/// <summary> /// Initializes a new instance of the <see cref="AzureStorageQueue"/> class. /// </summary> /// <param name="parser">The service configuration.</param> public AzureStorageQueue(ConfigurationParser parser) { var config = parser.Get(); var connectionString = string.Format(config.AzureQueue.ConnectionString, config.AzureQueue.AccountName, config.AzureQueue.AccountKey); this.imageScanQueue = new QueueClient(connectionString, config.AzureQueue.ImageScanRequestsQueue); }
public async Task SaveInProgressImageScanSavesCorrectEntity() { // Arrange await using var context = JosekiTestsDb.CreateUniqueContext(); var parser = new ConfigurationParser("config.sample.yaml"); var db = new MssqlJosekiDatabase(context, parser); var scan = new ImageScanResultWithCVEs { Date = DateTime.UtcNow, Id = Guid.NewGuid().ToString(), Description = Guid.NewGuid().ToString(), ImageTag = Guid.NewGuid().ToString(), Status = ImageScanStatus.Queued, }; // Act & Assert context.ImageScanResult.Should().HaveCount(0); await db.SaveInProgressImageScan(scan); context.ImageScanResult.Should().HaveCount(1); var actual = await context.ImageScanResult.FirstAsync(); actual.Date.Should().Be(scan.Date); actual.ExternalId.Should().Be(scan.Id); actual.Description.Should().Be(scan.Description); actual.ImageTag.Should().Be(scan.ImageTag); actual.Status.Should().Be(joseki.db.entities.ImageScanStatus.Queued); }
private static IWebHost BuildWebHost(string[] args) { var configParser = new ConfigurationParser(); var argsDictionary = configParser.ParseConfiguration(args); var settings = DeserializeSettings(argsDictionary); HandleArgument(() => Console.WriteLine(GetVerbosePage(argsDictionary)), args, _verboseArgs, false); return(WebHost.CreateDefaultBuilder(args) .UseSerilog() .ConfigureAppConfiguration((_, config) => config.AddInMemoryCollection(argsDictionary)) .UseStartup <Startup>() .UseKestrel(options => { options.AddServerHeader = false; options.Listen(IPAddress.Any, settings.Web.HttpPort); if (settings.Web.UseHttps && !string.IsNullOrWhiteSpace(settings.Web.PfxPath) && !string.IsNullOrWhiteSpace(settings.Web.PfxPassword)) { options.Listen(IPAddress.Any, settings.Web.HttpsPort, listenOptions => listenOptions.UseHttps(settings.Web.PfxPath, settings.Web.PfxPassword)); } }) .UseIIS() .Build()); }
//--------------------------------------------------------------------- public override void Initialize() { #if DEBUG //Debugger.Launch(); #endif ModelCore.UI.WriteLine("Initializing {0}...", Name); SiteVars.Initialize(); Timestep = parameters.Timestep; // Read in (input) Agent Configuration Json File here: ModelCore.UI.WriteLine(" Loading agent parameters from {0}", parameters.InputJson); configuration = ConfigurationParser.ParseConfiguration(parameters.InputJson); //create algorithm instance int iterations = 1; // Later we can decide if there should be multiple SHE sub-iterations per LANDIS-II iteration. //create dictionary projectedBiomass = ModelCore.Landscape.ToDictionary(activeSite => activeSite, activeSite => 0d); luhyLite = new LuhyLiteImplementation(iterations, configuration, ModelCore.Landscape, projectedBiomass); luhyLite.Initialize(); //remove old output files System.IO.DirectoryInfo di = new System.IO.DirectoryInfo(System.IO.Directory.GetCurrentDirectory()); foreach (System.IO.FileInfo fi in di.GetFiles("SOSIELHuman_*.csv")) { fi.Delete(); } }
public void Can_Properly_Deserialize() { var dict = new Dictionary <string, string> { { "Item", "TEST_VAL_ITEM" }, { "SubItem_Item", "TEST_VAL_SUBITEM_ITEM" }, { "SubItem_SubSubItem_Item", "TEST_VAL_SUBITEM_SUBSUBITEM_ITEM" }, { "SubItem_SubSubItem_Bool", "true" }, { "SubItem_SubSubItem_Int", "10" }, { "SubItem_SubSubItem_Long", "10000000" }, { "SubItem_SubSubItem_Double", "2.2" }, { "SubItem_SubSubItem_Float", "2.22" } }; // Set the environment variables we're going to use. EnvironmentVariableSource.SetEnvironment(dict); var instance = ConfigurationParser.ParseConfiguration <TestClass>(); Assert.Equal("TEST_VAL_ITEM", instance.Item); Assert.Equal("TEST_VAL_SUBITEM_ITEM", instance.SubItem?.Item); Assert.Equal("TEST_VAL_SUBITEM_SUBSUBITEM_ITEM", instance.SubItem?.SubSubItem?.Item); Assert.True(instance.SubItem?.SubSubItem?.Bool); Assert.Equal(10, instance.SubItem?.SubSubItem?.Int); Assert.Equal(10000000, instance.SubItem?.SubSubItem?.Long); Assert.Equal(2.2D, instance.SubItem?.SubSubItem?.Double); Assert.Equal(2.22F, instance.SubItem?.SubSubItem?.Float); }
public async Task ProcessAuditHappyPath() { // Arrange await using var context = JosekiTestsDb.CreateUniqueContext(); var parser = new ConfigurationParser("config.sample.yaml"); var checksCache = new ChecksCache(parser, context, new MemoryCache(new MemoryCacheOptions())); var blobsMock = new Mock <IBlobStorageProcessor>(MockBehavior.Strict); var dbMock = new Mock <IJosekiDatabase>(); var queueMock = new Mock <IQueue>(); var ownershipCache = new OwnershipCache(context, new MemoryCache(new MemoryCacheOptions())); var postProcessor = new Mock <ExtractOwnershipProcessor>(context, ownershipCache); var processor = new PolarisAuditProcessor(blobsMock.Object, dbMock.Object, checksCache, queueMock.Object, postProcessor.Object); var container = new ScannerContainer(Path.Combine("audits", "samples", "polaris")) { Metadata = new ScannerMetadata { Type = ScannerType.Polaris, Id = Guid.NewGuid().ToString(), }, }; var audit = new AuditBlob { Name = "meta.json", ParentContainer = container }; blobsMock .Setup(i => i.GetUnprocessedAudits(container)) .ReturnsAsync(new[] { audit }) .Verifiable(); blobsMock .Setup(i => i.DownloadFile($"{container.Name}/{audit.Name}")) .ReturnsAsync(File.OpenRead($"{container.Name}/{audit.Name}")) .Verifiable(); blobsMock .Setup(i => i.DownloadFile($"{container.Name}/audit.json")) .ReturnsAsync(File.OpenRead($"{container.Name}/audit.json")) .Verifiable(); blobsMock .Setup(i => i.DownloadFile($"{container.Name}/k8s-meta.json")) .ReturnsAsync(File.OpenRead($"{container.Name}/k8s-meta.json")) .Verifiable(); blobsMock .Setup(i => i.MarkAsProcessed(audit)) .Returns(Task.CompletedTask) .Verifiable(); // Act & Assert await processor.Process(container, CancellationToken.None); blobsMock.Verify(); dbMock.Verify(i => i.GetNotExpiredImageScans(It.Is <string[]>(tags => tags.Length == UniqueImageTagCount))); dbMock.Verify(i => i.SaveInProgressImageScan(It.IsAny <ImageScanResultWithCVEs>()), Times.Exactly(UniqueImageTagCount)); queueMock.Verify(i => i.EnqueueImageScanRequest(It.IsAny <ImageScanResultWithCVEs>()), Times.Exactly(UniqueImageTagCount)); dbMock.Verify(i => i.SaveAuditResult(It.Is <Audit>(a => VerifyHappyPathAudit(a, container)))); }
public void CanSpecifyContainersToScan() { var configuration = new ConfigurationParser().Parse("/scan:\"Ore Containers\" /scan:\"Ingot Containers\""); Assert.That(configuration.InventoryBlockNames, Is.EquivalentTo(new [] { "Ore Containers", "Ingot Containers" })); }
public void CanEnableIngot() { var configuration = new ConfigurationParser().Parse("+Uranium"); RequestedIngotConfiguration ingot; Assert.True(configuration.Ingots.TryGetValue(new ItemType("Ingot/Uranium"), out ingot)); Assert.True(ingot.Enable); }
public void CanConfigureStockpileTargetOnly() { var configuration = new ConfigurationParser().Parse("+Uranium:50"); RequestedIngotConfiguration ingot; Assert.True(configuration.Ingots.TryGetValue(new ItemType("Ingot/Uranium"), out ingot)); Assert.That(ingot.StockpileTarget, Is.EqualTo(50)); Assert.That(ingot.StockpileLimit, Is.Null); }
public static ConfigurationParser FromFile(string filename) { var document = new XmlDocument(); document.Load(filename); XmlNode structureMapNode = document.SelectSingleNode("//" + STRUCTUREMAP); if (structureMapNode == null) { throw new StructureMapException(155, filename); } var parser = new ConfigurationParser(structureMapNode); parser.FilePath = filename; return parser; }
public void CanSpecifyRefinerySpeed() { var configuration = new ConfigurationParser().Parse("/refinerySpeed:5"); Assert.That(configuration.RefinerySpeedFactor, Is.EqualTo(5)); }
public void IncludeNode(XmlNode node, string description) { var parser = new ConfigurationParser(node); parser.Description = description ?? findCallingMethod(); _parsers.Add(parser); }
public void CanSpecifyStatusDisplayName() { var configuration = new ConfigurationParser().Parse("/status:\"Display Name with a : in it\""); Assert.That(configuration.StatusDisplayName, Is.EqualTo("Display Name with a : in it")); }
public DefaultConfigReader() { this.configParser = new ConfigurationParser(); }
public void CanSpecifyAssemblerSpeed() { var configuration = new ConfigurationParser().Parse("/assemblerSpeed:4"); Assert.That(configuration.AssemblerSpeedFactor, Is.EqualTo(4)); }
public void IngotsMayBeIdentifiedByPath() { var configuration = new ConfigurationParser().Parse("+Ore/Ice"); RequestedIngotConfiguration ingot; Assert.True(configuration.Ingots.TryGetValue(new ItemType("Ore/Ice"), out ingot)); Assert.True(ingot.Enable); }
public void StockpileParametersAreIgnoredForDisabledIngots() { var configuration = new ConfigurationParser().Parse("-Platinum:50:100"); RequestedIngotConfiguration ingot; Assert.True(configuration.Ingots.TryGetValue(new ItemType("Ingot/Platinum"), out ingot)); Assert.False(ingot.Enable); }
public void Before() { this.parser = new ConfigurationParser(); }
public void IngotNamesMayBeQuoted() { var configuration = new ConfigurationParser().Parse("+\"Ore/Ice\""); RequestedIngotConfiguration ingot; Assert.True(configuration.Ingots.TryGetValue(new ItemType("Ore/Ice"), out ingot)); Assert.True(ingot.Enable); }