public void RuleImportDirectiveParse_Succeeds(string ruleCode, int expectedImportCount)
{
(IPreprocessedRule ppRule, bool parsingSuccess) = RuleFileParser.Read(ruleCode.Mince());
Assert.True(parsingSuccess);
Assert.Equal(expectedImportCount, ppRule.Imports.Count);
}
public void RuleLanguageDirectiveParse_Succeeds(string ruleCode, RuleLanguage expectedLanguage = RuleLanguage.Csharp)
{
(IPreprocessedRule ppRule, bool parsingSuccess) = RuleFileParser.Read(ruleCode.Mince());
Assert.True(parsingSuccess);
Assert.Equal(expectedLanguage, ppRule.Language);
}
public void RuleLanguageDirectiveParse_Fails(string ruleCode, RuleLanguage expectedLanguage = RuleLanguage.Unknown)
{
(IPreprocessedRule ppRule, bool parsingSuccess) = RuleFileParser.Read(ruleCode.Mince());
Assert.False(parsingSuccess);
Assert.Equal(expectedLanguage, ppRule.Language);
}
internal ScriptedRuleWrapper(string ruleName, string[] ruleCode) : this(ruleName, new NullLogger())
{
(IPreprocessedRule preprocessedRule, bool parseSuccess) = RuleFileParser.Read(ruleCode);
_ruleFileParseSuccess = parseSuccess;
Initialize(preprocessedRule);
}
public void RuleCheckDirectiveParse_Succeeds(string ruleCode, bool expected)
{
(IPreprocessedRule ppRule, bool parsingSuccess) = RuleFileParser.Read(ruleCode.Mince());
Assert.True(parsingSuccess);
Assert.Equal(expected, ppRule.Settings.EnableRevisionCheck);
}
public void RuleImpersonateDirectiveParse_Succeeds(string ruleCode)
{
(IPreprocessedRule ppRule, bool parsingSuccess) = RuleFileParser.Read(ruleCode.Mince());
Assert.True(parsingSuccess);
Assert.True(ppRule.Impersonate);
}
public void RuleImpersonateDirectiveParse_Succeeds()
{
string ruleCode = @".impersonate=onBehalfOfInitiator
";
(IPreprocessedRule ppRule, bool parsingSuccess) = RuleFileParser.Read(ruleCode.Mince());
Assert.True(parsingSuccess);
Assert.True(ppRule.Impersonate);
}
public void RuleLanguageReadWrite_Succeeds(string ruleCode)
{
var mincedCode = ruleCode.Mince();
(IPreprocessedRule ppRule, _) = RuleFileParser.Read(mincedCode);
var ruleCode2 = RuleFileParser.Write(ppRule);
Assert.Equal(mincedCode, ruleCode2, StringComparer.OrdinalIgnoreCase);
}
public void RuleLanguageDefaultsCSharp_Succeeds()
{
string ruleCode = @"
return $""Hello { self.WorkItemType } #{ self.Id } - { self.Title }!"";
";
(IPreprocessedRule ppRule, bool parsingSuccess) = RuleFileParser.Read(ruleCode.Mince());
Assert.Empty(ppRule.References);
Assert.Empty(ppRule.Imports);
Assert.NotEmpty(ppRule.RuleCode);
Assert.Equal(RuleLanguage.Csharp, ppRule.Language);
Assert.True(parsingSuccess);
}
public void RuleLanguageReadWrite_Succeeds()
{
string ruleCode = @".language=C#
.reference=System.Xml.XDocument
.import=System.Diagnostics
return $""Hello { self.WorkItemType } #{ self.Id } - { self.Title }!"";
";
var mincedCode = ruleCode.Mince();
(IPreprocessedRule ppRule, _) = RuleFileParser.Read(mincedCode);
var ruleCode2 = RuleFileParser.Write(ppRule);
Assert.Equal(mincedCode, ruleCode2, StringComparer.OrdinalIgnoreCase);
}
internal async Task <IEnumerable <RuleOutputData> > ListAsync(InstanceName instance, CancellationToken cancellationToken)
{
var kudu = GetKudu(instance);
_logger.WriteInfo($"Retrieving Functions in {instance.PlainName}...");
var webFunctionApp = await GetWebApp(instance, cancellationToken);
cancellationToken.ThrowIfCancellationRequested();
var configuration = await AggregatorConfiguration.ReadConfiguration(webFunctionApp);
using (var client = new HttpClient())
{
KuduFunction[] kuduFunctions;
using (var request = await kudu.GetRequestAsync(HttpMethod.Get, $"api/functions", cancellationToken))
using (var response = await client.SendAsync(request, cancellationToken))
{
var stream = await response.Content.ReadAsStreamAsync();
if (!response.IsSuccessStatusCode)
{
_logger.WriteError($"{response.ReasonPhrase} {await response.Content.ReadAsStringAsync()}");
return(Enumerable.Empty <RuleOutputData>());
}
using (var sr = new StreamReader(stream))
using (var jtr = new JsonTextReader(sr))
{
var js = new JsonSerializer();
kuduFunctions = js.Deserialize <KuduFunction[]>(jtr);
}
}
List <RuleOutputData> ruleData = new List <RuleOutputData>();
foreach (var kuduFunction in kuduFunctions)
{
var ruleName = kuduFunction.Name;
var ruleFileUrl = $"api/vfs/site/wwwroot/{ruleName}/{ruleName}.rule";
_logger.WriteInfo($"Retrieving Function Rule Details {ruleName}...");
using (var request = await kudu.GetRequestAsync(HttpMethod.Get, ruleFileUrl, cancellationToken))
using (var response = await client.SendAsync(request, cancellationToken))
{
var stream = await response.Content.ReadAsStreamAsync();
if (!response.IsSuccessStatusCode)
{
_logger.WriteError($"{response.ReasonPhrase} {await response.Content.ReadAsStringAsync()}");
continue;
}
var ruleCode = new List <string>();
using (var sr = new StreamReader(stream))
{
string line;
while ((line = sr.ReadLine()) != null)
{
ruleCode.Add(line);
}
}
var ruleConfiguration = configuration.GetRuleConfiguration(ruleName);
var(preprocessedRule, _) = RuleFileParser.Read(ruleCode.ToArray());
ruleData.Add(new RuleOutputData(instance, ruleConfiguration, preprocessedRule.LanguageAsString()));
}
}
return(ruleData);
}
}
public void RuleCheckDirectiveParse_Fails(string ruleCode)
{
(IPreprocessedRule _, bool parsingSuccess) = RuleFileParser.Read(ruleCode.Mince());
Assert.False(parsingSuccess);
}