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);
}
