private ScanResults Scan_Integration_Core(string testAppPath, int expectedErrorCount)
{
LaunchTestApp(testAppPath);
var config = Config.Builder.ForProcessId(TestProcess.Id)
.WithOutputDirectory(OutputDir)
.WithOutputFileFormat(OutputFileFormat.A11yTest)
.Build();
var scanner = ScannerFactory.CreateScanner(config);
var output = ScanWithProvisionForBuildAgents(scanner);
// Validate for consistency
Assert.AreEqual(expectedErrorCount, output.ErrorCount);
Assert.AreEqual(expectedErrorCount, output.Errors.Count());
if (expectedErrorCount > 0)
{
var regexForExpectedFile = $"{OutputDir.Replace("\\", "\\\\")}.*\\.a11ytest";
// Validate the output file exists where it is expected
Assert.IsTrue(Regex.IsMatch(output.OutputFile.A11yTest, regexForExpectedFile));
Assert.IsTrue(File.Exists(output.OutputFile.A11yTest));
// Validate that we got some properties and patterns
Assert.IsTrue(output.Errors.All(error => error.Element.Properties != null));
Assert.IsTrue(output.Errors.All(error => error.Element.Patterns != null));
}
else
{
Assert.IsNull(output.OutputFile.A11yTest);
}
return(output);
}
public void EventClear()
{
var factory = ScannerFactory.Create();
var aggregateInner = factory.Aggregate <string>();
var aggregateOuter = factory.Aggregate(aggregateInner);
var wasPropertyChanged = false;
aggregateOuter.PropertyChanged += (sender, args) =>
{
wasPropertyChanged = true;
Assert.AreEqual("Scanners", args.PropertyName);
};
var wasCollectionChanged = false;
aggregateOuter.CollectionChanged += (sender, args) =>
{
wasCollectionChanged = true;
Assert.AreEqual(NotifyCollectionChangedAction.Reset, args.Action);
};
aggregateOuter.Scanners.Clear();
Assert.IsTrue(wasPropertyChanged, "Checking if the PropertyChanged event was raised.");
Assert.IsTrue(wasCollectionChanged, "Checking if the CollectionChanged event was raised.");
}
public void EventClear()
{
var factory = ScannerFactory.Create();
var collection = new ObservableCollection <string> {
"foo"
};
var scanner = factory.Observable(collection);
var wasPropertyChanged = false;
scanner.PropertyChanged += (sender, args) =>
{
wasPropertyChanged = true;
Assert.AreEqual("Items", args.PropertyName);
};
var wasCollectionChanged = false;
scanner.CollectionChanged += (sender, args) =>
{
wasCollectionChanged = true;
Assert.AreEqual(NotifyCollectionChangedAction.Reset, args.Action);
};
collection.Clear();
Assert.IsTrue(wasPropertyChanged, "Checking if the PropertyChanged event was raised.");
Assert.IsTrue(wasCollectionChanged, "Checking if the CollectionChanged event was raised.");
}
public void EventAdd()
{
var factory = ScannerFactory.Create();
var aggregate = factory.Aggregate <string>();
var wasPropertyChanged = false;
aggregate.PropertyChanged += (sender, args) =>
{
wasPropertyChanged = true;
Assert.AreEqual("Scanners", args.PropertyName);
};
var wasCollectionChanged = false;
aggregate.CollectionChanged += (sender, args) =>
{
wasCollectionChanged = true;
Assert.AreEqual(NotifyCollectionChangedAction.Reset, args.Action);
};
var scannerToAdd = factory.Immutable("foo");
aggregate.Scanners.Add(scannerToAdd);
Assert.IsTrue(wasPropertyChanged, "Checking if the PropertyChanged event was raised.");
Assert.IsTrue(wasCollectionChanged, "Checking if the CollectionChanged event was raised.");
}
public void CreateContextIsNotNull()
{
var factory = ScannerFactory.Create();
var context = factory.CreateContext();
Assert.IsNotNull(context);
}
public void EventExclude()
{
var factory = ScannerFactory.Create();
var appDomain = AppDomain.CurrentDomain;
var input = factory.AppDomain(appDomain).GetDefinedTypes();
IFilterScanner <TypeInfo> filter = new FilterScanner <TypeInfo>(input);
// before we can exclude, we must include something first
filter.Include(type => type.IsClass);
var wasPropertyChanged = false;
filter.PropertyChanged += (sender, args) =>
{
wasPropertyChanged = true;
Assert.AreEqual("Exclude", args.PropertyName);
};
var wasCollectionChanged = false;
filter.CollectionChanged += (sender, args) =>
{
wasCollectionChanged = true;
Assert.AreEqual(NotifyCollectionChangedAction.Reset, args.Action);
};
filter.Exclude(type => !type.IsPublic);
Assert.IsTrue(wasPropertyChanged, "Checking if the PropertyChanged event was raised.");
Assert.IsTrue(wasCollectionChanged, "Checking if the CollectionChanged event was raised.");
}
public void ScanAgainAfterEvent()
{
var factory = ScannerFactory.Create();
var context = factory.CreateContext();
var expected = Enumerable.Range(1, 5).ToArray();
var innerMock = new Mock <IScanner <int> >(MockBehavior.Strict);
innerMock.SetupGet(_ => _.Factory).Returns(factory);
innerMock.Setup(_ => _.Scan(context)).Returns(expected);
var inner = innerMock.Object;
var cache = inner.Cache();
var items1 = cache.Scan(context);
var items2 = cache.Scan(context);
CollectionAssert.AreEqual(expected, items1);
CollectionAssert.AreEqual(expected, items2);
innerMock.Verify(_ => _.Scan(context), Times.Once);
innerMock.Raise(_ => _.CollectionChanged += null, new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Reset));
var items3 = cache.Scan(context);
var items4 = cache.Scan(context);
CollectionAssert.AreEqual(expected, items3);
CollectionAssert.AreEqual(expected, items4);
innerMock.Verify(_ => _.Scan(context), Times.Exactly(2));
}
public void Scan_Integration()
{
var config = Config.Builder.ForProcessId(TestProcess.Id)
.WithOutputDirectory(OutputDir)
.WithOutputFileFormat(OutputFileFormat.A11yTest)
.Build();
var scanner = ScannerFactory.CreateScanner(config);
var output = scanner.Scan();
var regexForExpectedFile = $"{OutputDir.Replace("\\", "\\\\")}.*\\.a11ytest";
// Validate that we got some errors
Assert.IsTrue(output.ErrorCount > 0);
Assert.AreEqual(output.ErrorCount, output.Errors.Count());
// Validate that we got some properties and patterns
Assert.IsTrue(output.Errors.All(error => error.Element.Properties != null));
Assert.IsTrue(output.Errors.All(error => error.Element.Patterns != null));
// Validate the output file exists where it is expected
Assert.IsTrue(Regex.IsMatch(output.OutputFile.A11yTest, regexForExpectedFile));
Assert.IsTrue(File.Exists(output.OutputFile.A11yTest));
EnsureGeneratedFileIsReadableByOldVersionsOfAxeWindows(output, TestProcess.Id);
}
public void FactoryParamsEmpty()
{
var factory = ScannerFactory.Create();
var aggregate = factory.Aggregate <IScanner <string> >();
Assert.IsNotNull(aggregate);
CollectionAssert.IsEmpty(aggregate.Scanners);
}
public void CurrentDomain()
{
var factory = ScannerFactory.Create();
var scanner = factory.CurrentDomain();
var expected = AppDomain.CurrentDomain;
Assert.AreSame(expected, scanner.AppDomain);
}
public void CreateContextTwiceIsDifferent()
{
var factory = ScannerFactory.Create();
var context1 = factory.CreateContext();
var context2 = factory.CreateContext();
Assert.AreNotSame(context1, context2);
}
private static Scanner BuildScanner(GridModel grid, ScannerParameter kbScanParams)
{
try { return(ScannerFactory.CreateScanner(grid, kbScanParams)); }
catch (Exception e)
{
logger.Error("Building scanner for grid '{0}' failed!\n{1}", grid.Id, e.Message);
return(null);
}
}
public void Verify_can_get_diagnostic_after_instantiation()
{
var knowledgeBaseProvider = _provider.GetService <IKnowledgeBaseProvider>();
var config = _provider.GetService <HareDuConfig>();
var factory = new ScannerFactory(config, knowledgeBaseProvider);
factory.TryGet <FakeSnapshot>(out _).ShouldBeFalse();
// Assert.AreEqual(typeof(DoNothingDiagnostic<ConnectionSnapshot>).FullName.GenerateIdentifier(), diagnostic.Identifier);
}
public void FactoryParamsSingle()
{
var factory = ScannerFactory.Create();
var source1 = factory.Immutable("a");
var aggregate = factory.Aggregate(source1);
Assert.IsNotNull(aggregate);
CollectionAssert.Contains(aggregate.Scanners, source1);
}
public void ExtensionUsingSingleParam()
{
var factory = ScannerFactory.Create();
var scannerToAdd = factory.Immutable(Assembly.GetExecutingAssembly());
var sourceScanner = factory.CurrentDomain();
var aggregate = sourceScanner.Aggregate(scannerToAdd);
Assert.AreEqual(2, aggregate.Scanners.Count);
}
/// <summary>
/// This entry point does not ship, but it makes for a quick and easy way to debug through the
/// automation code. One caveat--we intentionally don't build symbols for this app, so while you
/// can use it to to debug the automation code, breakpoints set in this class will be ignored.
/// </summary>
static void Main(string[] args)
{
Dictionary <string, string> parameters = new Dictionary <string, string>();
string secondaryConfigFile = string.Empty;
char[] delimiters = { '=' };
foreach (string arg in args)
{
string[] pieces = arg.Split(delimiters);
if (pieces.Length == 2)
{
string key = pieces[0].Trim();
string value = pieces[1].Trim();
if (!string.IsNullOrWhiteSpace(key) && !string.IsNullOrWhiteSpace(value))
{
// Special case for SecondaryConfigFile
if (key.Equals("SecondaryConfigFile", StringComparison.OrdinalIgnoreCase))
{
secondaryConfigFile = value;
}
else
{
parameters[key] = value;
}
continue;
}
}
Console.WriteLine("Ignoring malformed input: {0}", arg);
}
;
while (true)
{
Console.Write("Enter process ID to capture (blank to exit): ");
string input = Console.ReadLine();
if (string.IsNullOrEmpty(input))
{
break;
}
if (!int.TryParse(input, out int processId))
{
Console.WriteLine("Not a valid int: " + input);
continue;
}
var config = Config.Builder.ForProcessId(Convert.ToInt32(input)).Build();
var scanner = ScannerFactory.CreateScanner(config);
var results = scanner.Scan();
Console.WriteLine(results);
}
}
public Finder(ScanType scanType, FileCompareType fileCompareType, bool includeSubDirectories, string searchPattern = "*")
{
var scanOptions = new ScanOptions();
scanOptions.FileCompareType = fileCompareType;
scanOptions.IncludeSubDirectories = includeSubDirectories;
scanOptions.SearchPattern = searchPattern;
var scannerFactory = new ScannerFactory();
_scanner = scannerFactory.Create(scanType, scanOptions);
}
internal static void InitializeAxe()
{
var processes = Process.GetProcessesByName("Files");
Assert.IsTrue(processes.Length > 0);
var config = Config.Builder.ForProcessId(processes[0].Id).Build();
AccessibilityScanner = ScannerFactory.CreateScanner(config);
}
public void FromMultipleParams()
{
var factory = ScannerFactory.Create();
var context = factory.CreateContext();
var scanner = factory.Immutable("a", "b");
var items = scanner.Scan(context);
var expected = new[] { "a", "b" };
CollectionAssert.AreEqual(expected, items);
}
public void ExtensionUsingMultipleParams()
{
var factory = ScannerFactory.Create();
var scannerToAdd1 = factory.Immutable(Assembly.GetExecutingAssembly());
var scannerToAdd2 = factory.Immutable(Assembly.GetExecutingAssembly(), Assembly.GetEntryAssembly());
var sourceScanner = factory.CurrentDomain();
var aggregate = sourceScanner.Aggregate(scannerToAdd1, scannerToAdd2);
Assert.AreEqual(3, aggregate.Scanners.Count);
}
public void Verify_can_return_all_scanners_1()
{
var knowledgeBaseProvider = _provider.GetService <IKnowledgeBaseProvider>();
var config = _provider.GetService <HareDuConfig>();
var factory = new ScannerFactory(config, knowledgeBaseProvider);
factory.Scanners.ShouldNotBeNull();
factory.Scanners.ShouldNotBeEmpty();
factory.Scanners.Keys.Count().ShouldBe(3);
}
private static void LoadScanner()
{
var processes = Process.GetProcessesByName("MUXControlsTestApp");
Verify.IsTrue(processes.Length > 0);
string directory = Environment.GetEnvironmentVariable("TEMP") + @"\"; // For instance C:\Users\TDPUser\AppData\Local\Temp\
var config = Config.Builder.ForProcessId(processes[0].Id).WithOutputFileFormat(OutputFileFormat.A11yTest).WithOutputDirectory(directory).Build();
scanner = ScannerFactory.CreateScanner(config);
}
public void ExcludeFailsWithNoInclude()
{
var factory = ScannerFactory.Create();
var scanner = factory.CurrentDomain();
scanner.Exclude(asm => asm.IsDynamic);
var context = factory.CreateContext();
scanner.Scan(context);
}
public void IsDefined()
{
var factory = ScannerFactory.Create();
var appDomain = AppDomain.CurrentDomain;
var input = factory.AppDomain(appDomain);
var filter = input.IsDefined(typeof(GuidAttribute), false);
var context = factory.CreateContext();
var items = filter.Scan(context).ToArray();
CollectionAssert.IsNotEmpty(items);
}
public void DuplicateNumbers()
{
var duplicate = new[] { 1, 1, 2, 3, 4, 4, 4, 6 };
var expected = new[] { 1, 2, 3, 4, 6 };
var factory = ScannerFactory.Create();
var input = factory.Immutable(duplicate);
var scanner = input.Distinct();
var output = scanner.Scan();
CollectionAssert.AreEqual(expected, output);
}
private static async Task RunScanWith(Options opts)
{
if (opts.From.HasValue != opts.To.HasValue)
{
Log.Error("Specifying the only one From or To dates is not supported. Both values should be set or removed");
return;
}
else if (opts.From.HasValue && opts.From > opts.To)
{
Log.Error("From date should be behind To date");
return;
}
var today = DateTime.UtcNow.Date;
var startDate = opts.From ?? today;
var endDate = opts.To ?? today;
if (opts.Verbose)
{
loggingLevelSwitch.MinimumLevel = LogEventLevel.Verbose;
}
var config = new ConfigurationParser(opts.ConfigPath);
var factory = new ScannerFactory(config);
// Az-Sk allows to use only one output folder for all concurrently running processes.
// Also, user has no control over this folder structure.
// Therefore it's easier to run scan sequentially.
foreach (var subscription in opts.Subscriptions)
{
try
{
var scanDate = startDate;
while (scanDate <= endDate)
{
var subscriptionScanner = new SubscriptionScanner(factory.GetScanner(), factory.GetExporter());
var result = await subscriptionScanner.Scan(subscription, scanDate);
Log
.ForContext <Program>()
.Information("Subscription {Subscription} was scanned with result: {ScanResult} at {ScanDate}", subscription, result.ScanResult, scanDate);
scanDate = scanDate.AddDays(1);
}
}
catch (Exception ex)
{
Log
.ForContext <Program>()
.Error(ex, "A subscription {Subscription} scanning failed", subscription);
}
}
}
static void Main(string[] args)
{
// TODO Testing this project
var app = new CommandLineApplication
{
Name = "TodoTracker",
Description = "Scan source code and get documentation on all of your TODOs throughout the project"
};
//TODO: Testing this project
app.HelpOption("-?|-h|--help");
app.VersionOption("-v|--version", () => {
return(string.Format("Version {0}", Assembly.GetEntryAssembly().GetCustomAttribute <AssemblyInformationalVersionAttribute>().InformationalVersion));
});
// TODO: Testing this project
var directoryOption = app.Option("-d|--directory <directory>",
"The Directory to scan, defaults to the current directory if not specified",
CommandOptionType.SingleValue);
//TODO Testing this project
app.OnExecute(() =>
{
var directory = Directory.GetCurrentDirectory();
if (directoryOption.HasValue())
{
directory = directoryOption.Value();
}
var scanner = ScannerFactory.GetScanner();
var outputFileLocation = scanner.Scan();
Console.WriteLine(string.Format("Output file containing TODOs located here: {0}", outputFileLocation));
return(0);
});
//todo: testing this project
try
{
//todo testing this project
app.Execute(args);
}
catch (CommandParsingException ex)
{
// todo: testing this project
Console.WriteLine(ex.Message);
}
catch (Exception ex)
{
// todo testing this project
Console.WriteLine("Unable to execute application: {0}", ex.Message);
}
}
public void Self()
{
var factory = ScannerFactory.Create();
var appDomain = AppDomain.CurrentDomain;
var context = factory.CreateContext();
var input = factory.AppDomain(appDomain).GetDefinedTypes();
var before = input.Scan(context);
var transform = input.Transform(info => info);
var after = transform.Scan(context);
CollectionAssert.AreEqual(before, after);
}
private static IScanner BuildScanner(IOptions options)
{
Config.Builder builder = Config.Builder
.ForProcessId(options.ProcessId)
.WithOutputFileFormat(OutputFileFormat.A11yTest);
if (!string.IsNullOrEmpty(options.OutputDirectory))
{
builder = builder.WithOutputDirectory(options.OutputDirectory);
}
return(ScannerFactory.CreateScanner(builder.Build()));
}
public void Verify_can_return_all_probes_2()
{
var knowledgeBaseProvider = _provider.GetService <IKnowledgeBaseProvider>();
var config = _provider.GetService <HareDuConfig>();
var factory = new ScannerFactory(config, knowledgeBaseProvider);
bool registered = factory.TryRegisterAllProbes();
registered.ShouldBeTrue();
factory.Probes.ShouldNotBeNull();
factory.Probes.ShouldNotBeEmpty();
factory.Probes.Keys.Count().ShouldBe(21);
}
public void ExtensionUsingEnumerable()
{
var factory = ScannerFactory.Create();
var scannerToAdd1 = factory.Immutable(Assembly.GetExecutingAssembly());
var scannerToAdd2 = factory.Immutable(Assembly.GetExecutingAssembly(), Assembly.GetEntryAssembly());
var scannersToAdd = new HashSet <IScanner <Assembly> > {
scannerToAdd1, scannerToAdd2
};
var sourceScanner = factory.CurrentDomain();
var aggregate = sourceScanner.Aggregate(scannersToAdd);
Assert.AreEqual(3, aggregate.Scanners.Count);
}
