public void GetScanResults_A11yElementNull_EmptyResult()
{
List <Tuple <Rule, Result> > elementResults = ResultsFileSarifMapper.GetScanResults(null, String.Empty);
Assert.IsNotNull(elementResults);
Assert.AreEqual(0, elementResults.Count);
}
public void GetScanResults_NoRuleResults_EmptyResult()
{
A11yElement element = GenerateA11yElement();
using (ShimsContext.Create())
{
ShimResultsFileSarifMapper.FetchOrAddRuleRuleResult = (_) =>
{
return(GenerateRule());
};
ShimResultsFileSarifMapper.GetFingerPrintContributionsA11yElementRuleResult = (_, __) =>
{
Dictionary <string, string> fingerPrintContributions = new Dictionary <string, string>();
fingerPrintContributions.Add(FrameworkKey, FrameworkValue);
fingerPrintContributions.Add("Level", "open");
fingerPrintContributions.Add("LocalizedControlType", "page");
fingerPrintContributions.Add("Name", "Welcome page");
fingerPrintContributions.Add("RuleId", "BoundingRectangleSizeReasonable");
return(fingerPrintContributions);
};
ShimResultsFileSarifMapper.GetResultMessagesListOfString = (_) =>
{
return(new Message(TestMessage, null, TestMessage, null, null, null));
};
List <Tuple <Rule, Result> > elementResults = ResultsFileSarifMapper.GetScanResults(element, String.Empty);
Assert.IsNotNull(elementResults);
Assert.AreEqual(0, elementResults.Count);
}
}
public void GenerateAndPersistSarifFile_NoResults_WritesToFile()
{
using (ShimsContext.Create())
{
Boolean fileWriteInvoked = false;
System.IO.Fakes.ShimFile.WriteAllTextStringString = (_, __) =>
{
fileWriteInvoked = true;
};
ShimResultsFileSarifMapper.GenerateEmbeddedFilesStringGuidBooleanString = (_, __, ___, ____) =>
{
return(new Dictionary <string, FileData>()
{
{ ScreenShotPathValue, new FileData() },
{ ToolOutputPathValue, new FileData() }
});
};
ShimResultsFileSarifMapper.TraverseTreeDepthFirstGuid = (_) =>
{
return(new List <Tuple <Rule, Result> >());;
};
Microsoft.CodeAnalysis.Sarif.Writers.Fakes.ShimSarifLogger.AllInstances.LogIRuleResult = (_, __, ___) => { };
ResultsFileSarifMapper.GenerateAndPersistSarifFile(SystemPath, guid, false);
Assert.IsTrue(fileWriteInvoked);
}
}
public void TraverseTreeDepthFirst_NoScanResultsInElement_EmptyResult()
{
using (ShimsContext.Create())
{
ShimResultsFileSarifMapper.GetScanResultsA11yElementString = (_, __) =>
{
return(new List <Tuple <Rule, Result> >());
};
ShimDataManager.GetDefaultInstance = () =>
{
ShimDataManager shimDM = new ShimDataManager
{
GetElementContextGuid = (_) =>
{
return(new ElementContext(new A11yElement()));
}
};
return(shimDM);
};
List <Tuple <Rule, Result> > elementResults = ResultsFileSarifMapper.TraverseTreeDepthFirst(guid);
Assert.IsNotNull(elementResults);
Assert.AreEqual(0, elementResults.Count);
}
}
public void GenerateToolInfo_ReceivesValidParameters_GeneratesToolInfo()
{
Tool toolInfo = ResultsFileSarifMapper.GenerateToolInfo();
Assert.AreEqual(Name, toolInfo.Name);
Assert.IsNotNull(toolInfo.SemanticVersion);
Assert.IsNotNull(toolInfo.Version);
}
public void GetScanResults_A11yElementScanResultsItemEmpty_EmptyResult()
{
A11yElement element = GenerateA11yElement();
List <Tuple <Rule, Result> > elementResults = ResultsFileSarifMapper.GetScanResults(element, String.Empty);
Assert.IsNotNull(elementResults);
Assert.AreEqual(0, elementResults.Count);
}
public void GetResultMessages_EmptyMessageList_ProducesMessages()
{
List <string> messages = new List <string>();
Message sarifMessage = ResultsFileSarifMapper.GetResultMessages(messages);
string returnedMessage = sarifMessage.Text.Trim();
Assert.IsTrue(string.IsNullOrEmpty(returnedMessage));
}
public void GetScanResults_ReceivesNormalParameters_ProducesScanResultList()
{
A11yElement element = GenerateA11yElement();
RuleResult result = new RuleResult();
List <RuleResult> ruleResults = new List <RuleResult>();
ruleResults.Add(result);
element.ScanResults.Items[0].Items = ruleResults;
using (ShimsContext.Create())
{
ShimResultsFileSarifMapper.FetchOrAddRuleRuleResult = (_) =>
{
return(GenerateRule());
};
ShimScanStatusExtensions.ToResultLevelScanStatus = (_) =>
{
return(ResultLevel.Open);
};
ShimResultsFileSarifMapper.GetFingerPrintContributionsA11yElementRuleResult = (_, __) =>
{
Dictionary <string, string> fingerPrintContributions = new Dictionary <string, string>();
fingerPrintContributions.Add(FrameworkKey, FrameworkValue);
fingerPrintContributions.Add("Level", "open");
fingerPrintContributions.Add("LocalizedControlType", "page");
fingerPrintContributions.Add("Name", "Welcome page");
fingerPrintContributions.Add("RuleId", "BoundingRectangleSizeReasonable");
return(fingerPrintContributions);
};
ShimResultsFileSarifMapper.GetResultMessagesListOfString = (_) =>
{
return(new Message(TestMessage, null, null, null, null, null));
};
List <Tuple <Rule, Result> > elementResults = ResultsFileSarifMapper.GetScanResults(element, String.Empty);
Assert.IsNotNull(elementResults);
Assert.AreEqual(1, elementResults.Count);
Tuple <Rule, Result> elementScanOutput = elementResults[0];
Assert.IsNotNull(elementScanOutput);
Rule rule = elementScanOutput.Item1;
Result res = elementScanOutput.Item2;
Assert.IsNotNull(rule);
Assert.IsNotNull(res);
Assert.AreEqual(TestRuleName, rule.Name.Text);
Assert.AreEqual(ResultLevel.Open, res.Level);
Assert.IsNotNull(res.PartialFingerprints);
Assert.IsTrue(res.PartialFingerprints.ContainsKey(FrameworkKey));
string partialfingerprintFramework = String.Empty;
Assert.IsTrue(res.PartialFingerprints.TryGetValue(FrameworkKey, out partialfingerprintFramework));
Assert.AreEqual(FrameworkValue, partialfingerprintFramework);
Assert.AreEqual(res.Locations[0].Annotations[0].Snippet.Text, TestGlimpse);
}
}
public void FetchOrAddStandard_NewStandard_ReturnStandard()
{
RuleResult ruleResult = GenerateRuleResult();
string[] addedStandard = ResultsFileSarifMapper.FetchOrAddStandards(ruleResult);
string standardKey = "4.1.2";
Assert.IsTrue(ResultsFileSarifMapper.A11yCriteriaList.ContainsKey(standardKey));
}
public void GetScanResults_NullRuleResultListUnderScanItems_EmptyResult()
{
// The structure is a little confusing. ScanResults has a list of Items (RuleResults)
A11yElement element = GenerateA11yElement();
element.ScanResults.Items[0].Items = null;
List <Tuple <Rule, Result> > elementResults = ResultsFileSarifMapper.GetScanResults(element, String.Empty);
Assert.IsNotNull(elementResults);
Assert.AreEqual(0, elementResults.Count);
}
public void FetchOrAddStandard_StandardExists_ReturnStandard()
{
RuleResult ruleResult = GenerateRuleResult();
string[] addedStandard = ResultsFileSarifMapper.FetchOrAddStandards(ruleResult);
string[] retrievedStandards = ResultsFileSarifMapper.FetchOrAddStandards(ruleResult);
Assert.AreEqual(addedStandard[0], retrievedStandards[0]);
string standardKey = "4.1.2";
Assert.IsTrue(ResultsFileSarifMapper.A11yCriteriaList.ContainsKey(standardKey));
}
public void GenerateInvocationInfo_ReceivesValidParameters_GeneratesInvocationInfo()
{
using (ShimsContext.Create())
{
DateTime expectedDate = new DateTime(1989, 9, 11);
System.Fakes.ShimDateTime.UtcNowGet = () => expectedDate;
List <Invocation> invocations = ResultsFileSarifMapper.GenerateInvocationInfo();
Invocation invocationOfInterest = invocations[0];
Assert.AreEqual(invocationOfInterest.EndTimeUtc.Ticks, expectedDate.Ticks);
Assert.AreEqual(invocationOfInterest.StartTimeUtc.Ticks, expectedDate.Ticks);
}
}
public void GetResultAttachments_ReceivesValidParameters_GeneratesAttachmentList()
{
List <string> fileKeyList = new List <string>()
{
ScreenShotPathValue, ToolOutputPathValue
};
List <Attachment> attachments = ResultsFileSarifMapper.GetResultAttachments(fileKeyList);
Assert.IsNotNull(attachments);
Assert.AreEqual(2, attachments.Count);
Assert.AreEqual(ScreenShotKey, attachments[0].Description.Text);
Assert.AreEqual(ToolOutputKey, attachments[1].Description.Text);
}
public void FetchOrAddRule_NullRuleResult_ReturnRule()
{
RuleResult ruleResult = GenerateRuleResult();
using (ShimsContext.Create())
{
ShimResultsFileSarifMapper.FetchOrAddStandardsRuleResult = (_) =>
{
return(new string[] { Standard });
};
Rule returnedRule = ResultsFileSarifMapper.FetchOrAddRule(null);
Assert.IsNull(returnedRule);
}
}
public void GetResultMessages_ReceivesNormalParameters_ProducesMessages()
{
List <string> messages = new List <string>();
string messageOne = "one";
string messageTwo = "two";
string messageThree = "three";
messages.Add(messageOne);
messages.Add(messageTwo);
messages.Add(messageThree);
string expectedMessage = messageOne + " " + messageTwo + " " + messageThree;
Message sarifMessage = ResultsFileSarifMapper.GetResultMessages(messages);
Assert.AreEqual(expectedMessage, sarifMessage.Text.Trim());
}
public void FetchOrAddRule_RuleExists_ReturnRule()
{
RuleResult ruleResult = GenerateRuleResult();
Rule sarifRule = GenerateRuleFromRuleResult(ruleResult);
using (ShimsContext.Create())
{
ShimResultsFileSarifMapper.FetchOrAddStandardsRuleResult = (_) =>
{
return(new string[] { Standard });
};
Rule returnedRule = ResultsFileSarifMapper.FetchOrAddRule(ruleResult);
AssertRulesEqual(sarifRule, returnedRule);
}
}
public void GenerateEmbeddedFiles_ReceivesExpectedParameters()
{
Boolean resultsKey = false;
Boolean imageResultKey = false;
FileData resultsContent = null;
FileData screenshotContent = null;
using (ShimsContext.Create())
{
ShimResultsFileSarifMapper.GetScreenShotDataGuid = (ecID) =>
{
return(GenerateFileData(ScreenshotKey));
};
ShimResultsFileSarifMapper.GenerateResultsDataStringBoolean = (path, deleteA11yTestFile) =>
{
return(GenerateFileData(Key));
};
string runGuid = Guid.NewGuid().ToString();
Dictionary <string, FileData> result = ResultsFileSarifMapper.GenerateEmbeddedFiles(null, new Guid(), false, runGuid);
foreach (string key in result.Keys)
{
if (!resultsKey)
{
resultsKey = key.Equals(ToolOutputTemplateValue.Replace("{fileGUID}", runGuid)) && result.TryGetValue(key, out resultsContent);
}
if (!imageResultKey)
{
imageResultKey = key.Equals(ScreenshotTemplateValue.Replace("{fileGUID}", runGuid)) && result.TryGetValue(key, out screenshotContent);
}
}
Assert.IsTrue(resultsKey, "Does not contain the result key / value or correct guid");
Assert.IsTrue(imageResultKey, "Does not contain the imageResultKey key / value or correct guid");
Assert.AreEqual(ScreenshotKey, Encoding.Default.GetString((Convert.FromBase64String(screenshotContent.Contents.Binary))));
Assert.AreEqual(Key, Encoding.Default.GetString((Convert.FromBase64String(resultsContent.Contents.Binary))));
}
}
public void FetchOrAddRule_NewRule_ReturnRule()
{
RuleResult ruleResult = GenerateRuleResult();
using (ShimsContext.Create())
{
ShimResultsFileSarifMapper.FetchOrAddStandardsRuleResult = (_) =>
{
return(new string[] { Standard });
};
Rule addedRule = GenerateRuleFromRuleResult(ruleResult);
Rule returnedRule = ResultsFileSarifMapper.FetchOrAddRule(ruleResult);
AssertRulesEqual(addedRule, returnedRule);
Assert.IsTrue(ResultsFileSarifMapper.RuleList.ContainsKey(ruleResult.Rule.ToString()));
}
}
public void TraverseTreeDepthFirst_ReceivesRequiredParameters_NonEmptyResult()
{
using (ShimsContext.Create())
{
ShimResultsFileSarifMapper.GetScanResultsA11yElementString = (_, __) =>
{
List <Tuple <Rule, Result> > scanResults = new List <Tuple <Rule, Result> >();
Rule rule = GenerateRule();
Result result = GenerateResult();
scanResults.Add(new Tuple <Rule, Result>(rule, result));
return(scanResults);
};
ShimDataManager.GetDefaultInstance = () =>
{
ShimDataManager shimDM = new ShimDataManager
{
GetElementContextGuid = (_) =>
{
A11yElement element = GenerateA11yElement();
A11yElement childElement = new A11yElement();
element.Children.Add(childElement);
return(new ElementContext(element));
}
};
return(shimDM);
};
List <Tuple <Rule, Result> > elementResults = ResultsFileSarifMapper.TraverseTreeDepthFirst(guid);
Assert.IsNotNull(elementResults);
Assert.AreEqual(2, elementResults.Count);
Tuple <Rule, Result> elementResult = elementResults[0];
Assert.IsNotNull(elementResult);
Assert.IsNotNull(elementResult.Item1);
Assert.IsNotNull(elementResult.Item2);
Assert.AreEqual(TestRuleName, elementResult.Item1.Name.Text);
Assert.AreEqual(ResultLevel.Open, elementResult.Item2.Level);
}
}
public void GenerateAndAddRule_ReceivesAllParameters_AddsRule()
{
ResultsFileSarifMapper.RuleList.Clear();
RuleResult ruleResult = GenerateRuleResult();
using (ShimsContext.Create())
{
ShimResultsFileSarifMapper.FetchOrAddStandardsRuleResult = (_) =>
{
return(new string[] { Standard });
};
Rule returnedRule = ResultsFileSarifMapper.GenerateAndAddRule(ruleResult);
Assert.IsNotNull(returnedRule);
Assert.IsTrue(ResultsFileSarifMapper.RuleList.ContainsKey(ruleResult.Rule.ToString()));
Assert.AreEqual(ruleResult.Rule.ToString(), returnedRule.Id);
Assert.AreEqual(ruleResult.Description, returnedRule.Name.Text);
Assert.AreEqual(ruleResult.Description, returnedRule.FullDescription.Text);
Assert.AreEqual(ruleResult.HelpUrl.Url, returnedRule.HelpUri.ToString());
string[] standards = null;
Assert.IsTrue(returnedRule.TryGetProperty <string[]>(StandardsKey, out standards));
Assert.AreEqual(Standard, standards[0]);
}
}
/// <summary>
/// Will generate and save the sarif file at the specifed path from the specified element downwards
/// </summary>
/// <param name="path"> The path at which the generated file needs to be persisted </param>
/// <param name="ecId"> the guid of the root element </param>
/// <param name="deleteGeneratedResultsFile"> Whether the generated results should be deleted </param>
/// <param name="otherProperties"></param>
public static void SaveSarifFile(string path, Guid ecId, Boolean deleteGeneratedResultsFile)
{
ResultsFileSarifMapper.GenerateAndPersistSarifFile(path, ecId, deleteGeneratedResultsFile);
}
public void GetResultMessages_NullMessages_ProducesMessages()
{
Message sarifMessage = ResultsFileSarifMapper.GetResultMessages(null);
Assert.IsTrue(string.IsNullOrEmpty(sarifMessage.Text));
}
