public void ScanDirectory_MultipleAnalyzerAssemblies()
{
// Arrange
TestLogger logger = new TestLogger();
DiagnosticAssemblyScanner scanner = new DiagnosticAssemblyScanner(logger);
string testDirectoryPath = Path.Combine(TestContext.DeploymentDirectory, "twoAnalyzers");
string exampleAnalyzer1Path = Path.Combine(testDirectoryPath, "ExampleAnalyzer1.dll");
Assert.IsTrue(File.Exists(exampleAnalyzer1Path), "Test setup error: expected assembly does not exist: {0}", exampleAnalyzer1Path);
string exampleAnalyzer2Path = Path.Combine(testDirectoryPath, "ExampleAnalyzer2.dll");
Assert.IsTrue(File.Exists(exampleAnalyzer2Path), "Test setup error: expected assembly does not exist: {0}", exampleAnalyzer2Path);
// Act
IEnumerable<DiagnosticAnalyzer> csharpDiagnostics = scanner.InstantiateDiagnostics(testDirectoryPath, LanguageNames.CSharp);
IEnumerable<DiagnosticAnalyzer> vbDiagnostics = scanner.InstantiateDiagnostics(testDirectoryPath, LanguageNames.VisualBasic);
// Assert
// ConfigurableAnalyzer is both C# and VB, so should appear in both
Assert.AreEqual(3, csharpDiagnostics.Count(), "Expecting 3 C# analyzers");
Assert.AreEqual(2, vbDiagnostics.Count(), "Expecting 2 VB analyzers");
// Using name comparison because type comparison fails if the types are from assemblies with different paths (even if copied)
// Loaded from ExampleAnalyzer1.dll
Assert_AnalyzerIsPresent(csharpDiagnostics, "ExampleAnalyzer1.CSharpAnalyzer");
Assert_AnalyzerIsPresent(csharpDiagnostics, "ExampleAnalyzer1.ConfigurableAnalyzer");
Assert_AnalyzerNotPresent(csharpDiagnostics, "ExampleAnalyzer1.AbstractAnalyzer");
Assert_AnalyzerIsPresent(vbDiagnostics, "ExampleAnalyzer1.VBAnalyzer");
Assert_AnalyzerIsPresent(vbDiagnostics, "ExampleAnalyzer1.ConfigurableAnalyzer");
Assert_AnalyzerNotPresent(vbDiagnostics, "ExampleAnalyzer1.AbstractAnalyzer");
// Loaded from ExampleAnalyzer2.dll
Assert_AnalyzerIsPresent(csharpDiagnostics, "ExampleAnalyzer2.ExampleAnalyzer2");
}
public void JarBuilder_Build()
{
// Arrange
IJdkWrapper jdkWrapper = new JdkWrapper();
TestLogger logger = new TestLogger();
string inputsDir = TestUtils.CreateTestDirectory(this.TestContext, "in");
string outputsDir = TestUtils.CreateTestDirectory(this.TestContext, "out");
string file1 = TestUtils.CreateTextFile("file1.txt", inputsDir, "file1 content");
string file2 = TestUtils.CreateTextFile("file2.txt", inputsDir, "file2 content");
// Act
JarBuilder builder = new JarBuilder(logger, jdkWrapper);
builder.SetManifestPropety("prop1", "prop1 value");
builder.AddFile(file1, null);
builder.AddFile(file2, "myorg\\myapp\\f2.txt");
string finalJarPath = Path.Combine(outputsDir, "newJar.jar");
bool success = builder.Build(finalJarPath);
// Assert
Assert.IsTrue(success, "Failed to build the jar file");
new JarChecker(this.TestContext, finalJarPath)
.JarContainsFiles(
"META-INF\\MANIFEST.MF",
"file1.txt",
"myorg\\myapp\\f2.txt");
}
public void ArgProc_AnalyzerRef_Invalid()
{
// 0. Setup
TestLogger logger;
string[] rawArgs;
ProcessedArgs actualArgs;
// 1. No value
logger = new TestLogger();
rawArgs = new string [] { "/analyzer:" };
actualArgs = ArgumentProcessor.TryProcessArguments(rawArgs, logger);
AssertArgumentsNotProcessed(actualArgs, logger);
// 2. Id and missing version
logger = new TestLogger();
rawArgs = new string[] { "/analyzer:testing.id.missing.version:" };
actualArgs = ArgumentProcessor.TryProcessArguments(rawArgs, logger);
AssertArgumentsNotProcessed(actualArgs, logger);
// 3. Id and invalid version
logger = new TestLogger();
rawArgs = new string[] { "/analyzer:testing.id.invalid.version:1.0.-invalid.version.1" };
actualArgs = ArgumentProcessor.TryProcessArguments(rawArgs, logger);
AssertArgumentsNotProcessed(actualArgs, logger);
// 4. Missing id
logger = new TestLogger();
rawArgs = new string[] { "/analyzer::2.1.0" };
actualArgs = ArgumentProcessor.TryProcessArguments(rawArgs, logger);
AssertArgumentsNotProcessed(actualArgs, logger);
}
public void Generate_LicenseAcceptanceNotRequired_Succeeds()
{
// Arrange
string outputDir = TestUtils.CreateTestDirectory(this.TestContext, ".out");
RemoteRepoBuilder remoteRepoBuilder = new RemoteRepoBuilder(this.TestContext);
// Multi-level dependencies: no package requires license acceptence
IPackage grandchild = CreatePackageWithAnalyzer(remoteRepoBuilder, "grandchild.id", "1.2", License.NotRequired /* no dependencies */);
IPackage child = CreatePackageWithAnalyzer(remoteRepoBuilder, "child.id", "1.1", License.NotRequired, grandchild);
CreatePackageWithAnalyzer(remoteRepoBuilder, "parent.id", "1.0", License.NotRequired, child);
TestLogger logger = new TestLogger();
AnalyzerPluginGenerator apg = CreateTestSubjectWithFakeRemoteRepo(remoteRepoBuilder, logger);
// 1. Acceptance not required -> succeeds if accept = false
ProcessedArgs args = CreateArgs("parent.id", "1.0", "cs", null, false /* accept licenses */ , outputDir);
bool result = apg.Generate(args);
Assert.IsTrue(result, "Generator should succeed if there are no licenses to accept");
logger.AssertErrorsLogged(0);
logger.AssertWarningNotLogged("parent.id"); // not expecting warnings about packages that don't require acceptance
logger.AssertWarningNotLogged("child.id");
logger.AssertWarningNotLogged("grandchild.id");
// 2. Acceptance not required -> succeeds if accept = true
args = CreateArgs("parent.id", "1.0", "cs", null, true /* accept licenses */ , outputDir);
result = apg.Generate(args);
Assert.IsTrue(result, "Generator should succeed if there are no licenses to accept");
logger.AssertErrorsLogged(0);
logger.AssertWarningNotLogged("parent.id"); // not expecting warnings about packages that don't require acceptance
logger.AssertWarningNotLogged("child.id");
logger.AssertWarningNotLogged("grandchild.id");
}
public void ArgProc_AnalyzerRef_Valid()
{
// 0. Setup
TestLogger logger;
string[] rawArgs;
ProcessedArgs actualArgs;
// 1. Id but no version
logger = new TestLogger();
rawArgs = new string[] { "/a:testing.id.no.version" };
actualArgs = ArgumentProcessor.TryProcessArguments(rawArgs, logger);
AssertArgumentsProcessed(actualArgs, logger, "testing.id.no.version", null, null, false);
// 2. Id and version
logger = new TestLogger();
rawArgs = new string[] { "/analyzer:testing.id.with.version:1.0.0-rc1" };
actualArgs = ArgumentProcessor.TryProcessArguments(rawArgs, logger);
AssertArgumentsProcessed(actualArgs, logger, "testing.id.with.version", "1.0.0-rc1", null, false);
// 3. Id containing a colon, with version
logger = new TestLogger();
rawArgs = new string[] { "/analyzer:id.with:colon:2.1.0" };
actualArgs = ArgumentProcessor.TryProcessArguments(rawArgs, logger);
AssertArgumentsProcessed(actualArgs, logger, "id.with:colon", "2.1.0", null, false);
}
public void ArgProc_AcceptLicensesInvalid()
{
// 0. Setup
TestLogger logger;
string[] rawArgs;
ProcessedArgs actualArgs;
// 1. Correct text, wrong case -> invalid
logger = new TestLogger();
rawArgs = new string[] { "/a:validId", "/ACCEPTLICENSES" };
actualArgs = ArgumentProcessor.TryProcessArguments(rawArgs, logger);
AssertArgumentsNotProcessed(actualArgs, logger);
// 2. Unrecognized argument -> invalid
logger = new TestLogger();
rawArgs = new string[] { "/a:validId", "/acceptLicenses=true" };
actualArgs = ArgumentProcessor.TryProcessArguments(rawArgs, logger);
AssertArgumentsNotProcessed(actualArgs, logger);
// 3. Unrecognized argument -> invalid
logger = new TestLogger();
rawArgs = new string[] { "/a:validId", "/acceptLicensesXXX" };
actualArgs = ArgumentProcessor.TryProcessArguments(rawArgs, logger);
AssertArgumentsNotProcessed(actualArgs, logger);
}
public void Generate_NoAnalyzersFoundInPackage_GenerateFails()
{
// Arrange
string outputDir = TestUtils.CreateTestDirectory(this.TestContext, ".out");
TestLogger logger = new TestLogger();
// Create a fake remote repo containing a package that does not contain analyzers
RemoteRepoBuilder remoteRepoBuilder = new RemoteRepoBuilder(this.TestContext);
remoteRepoBuilder.CreatePackage("no.analyzers.id", "0.9", TestUtils.CreateTextFile("dummy.txt", outputDir), License.NotRequired /* no dependencies */ );
NuGetPackageHandler nuGetHandler = new NuGetPackageHandler(remoteRepoBuilder.FakeRemoteRepo, GetLocalNuGetDownloadDir(), logger);
AnalyzerPluginGenerator apg = new AnalyzerPluginGenerator(nuGetHandler, logger);
ProcessedArgs args = CreateArgs("no.analyzers.id", "0.9", "cs", null, false, false, outputDir);
// Act
bool result = apg.Generate(args);
// Assert
Assert.IsFalse(result, "Expecting generation to fail");
logger.AssertSingleWarningExists(String.Format(UIResources.APG_NoAnalyzersFound, "no.analyzers.id"));
logger.AssertSingleWarningExists(UIResources.APG_NoAnalyzersInTargetSuggestRecurse);
logger.AssertWarningsLogged(2);
AssertSqaleTemplateDoesNotExist(outputDir);
}
public void RoslynPlugin_GenerateForMultiLevelAnalyzers_Succeeds()
{
// Arrange
TestLogger logger = new TestLogger();
string outputDir = TestUtils.CreateTestDirectory(this.TestContext, ".out");
// Create a valid analyzer package
RoslynAnalyzer11.CSharpAnalyzer analyzer = new RoslynAnalyzer11.CSharpAnalyzer();
// Parent and children all have analyzers, expecting plugins for all three
string fakeRemoteNuGetDir = TestUtils.CreateTestDirectory(this.TestContext, ".fakeRemoteNuGet");
IPackageManager fakeRemotePkgMgr = CreatePackageManager(fakeRemoteNuGetDir);
IPackage child1 = AddPackage(fakeRemotePkgMgr, "Analyzer.Child1", "1.1.0", analyzer.GetType().Assembly.Location);
IPackage child2 = AddPackage(fakeRemotePkgMgr, "Analyzer.Child2", "1.2.0", analyzer.GetType().Assembly.Location);
IPackage targetPkg = AddPackage(fakeRemotePkgMgr, "Empty.Parent", "1.0.0", analyzer.GetType().Assembly.Location, child1, child2);
string localPackageDestination = TestUtils.CreateTestDirectory(this.TestContext, ".localpackages");
// Act
NuGetPackageHandler nuGetHandler = new NuGetPackageHandler(fakeRemotePkgMgr.LocalRepository, localPackageDestination, logger);
AnalyzerPluginGenerator apg = new AnalyzerPluginGenerator(nuGetHandler, logger);
ProcessedArgs args = new ProcessedArgs(targetPkg.Id, targetPkg.Version, "cs", null, false,
true /* generate plugins for dependencies with analyzers*/, outputDir);
bool result = apg.Generate(args);
// Assert
Assert.IsTrue(result);
// Expecting one plugin per dependency with analyzers
CheckJarGeneratedForPackage(outputDir, analyzer, targetPkg);
CheckJarGeneratedForPackage(outputDir, analyzer, child1);
CheckJarGeneratedForPackage(outputDir, analyzer, child2);
AssertJarsGenerated(outputDir, 3);
}
public void AssemblyResolver_NoImpactOnDefaultResolution()
{
// Arrange
TestLogger logger = new TestLogger();
string testFolder = TestUtils.CreateTestDirectory(this.TestContext);
CompileSimpleAssembly("SimpleAssembly.dll", testFolder, logger);
object simpleObject = null;
// Act
using (AssemblyResolver resolver = new AssemblyResolver(logger, testFolder))
{
// Look in every assembly under the supplied directory
foreach (string assemblyPath in Directory.GetFiles(testFolder, "*.dll", SearchOption.AllDirectories))
{
Assembly assembly = Assembly.LoadFile(assemblyPath);
foreach (Type type in assembly.GetExportedTypes())
{
if (!type.IsAbstract)
{
simpleObject = Activator.CreateInstance(type);
}
}
}
// Assert
Assert.IsNotNull(simpleObject);
Assert.AreEqual<string>("SimpleProgram", simpleObject.GetType().ToString());
AssertResolverCaller(resolver);
}
}
public void RuleGen_SimpleRules()
{
// Arrange
TestLogger logger = new TestLogger();
ConfigurableAnalyzer analyzer = new ConfigurableAnalyzer();
var diagnostic1 = analyzer.RegisterDiagnostic(key: "DiagnosticID1", description: "Some description", helpLinkUri: "www.bing.com", tags: new[] { "unnecessary" });
var diagnostic2 = analyzer.RegisterDiagnostic(key: "Diagnostic2", description: "");
IRuleGenerator generator = new RuleGenerator(logger);
// Act
Rules rules = generator.GenerateRules(new[] { analyzer });
// Assert
AssertExpectedRuleCount(2, rules);
Rule rule1 = rules.Single(r => r.Key == diagnostic1.Id);
VerifyRule(diagnostic1, rule1);
Assert.IsTrue(rule1.Description.Contains(diagnostic1.Description.ToString()), "Invalid rule description");
Assert.IsTrue(rule1.Description.Contains(diagnostic1.HelpLinkUri), "Invalid rule description");
Assert.IsFalse(rule1.Description.Trim().StartsWith("<![CDATA"), "Description should not be formatted as a CData section");
Rule rule2 = rules.Single(r => r.Key == diagnostic2.Id);
VerifyRule(diagnostic2, rule2);
Assert.IsTrue(rule2.Description.Contains(UIResources.RuleGen_NoDescription), "Invalid rule description");
}
public void RepoFactory_MultipleEnabledSources_RepoCreated()
{
// Arrange
TestLogger logger = new TestLogger();
// Create a valid config settings file that specifies the package sources to use
string configXml = @"<?xml version=""1.0"" encoding=""utf-8""?>
<configuration>
<packageSources>
<add key=""local1_inactive"" value=""c:\inactiveCache\should.be.ignored"" />
<add key=""local2_active"" value=""d:\active_cache"" />
<add key=""local3_active"" value=""c:\another\active\cache"" />
</packageSources>
<disabledPackageSources>
<add key=""local1_inactive"" value=""true"" />
</disabledPackageSources>
</configuration>";
Settings settings = CreateSettingsFromXml(configXml);
// Act
IPackageRepository actualRepo = NuGetRepositoryFactory.CreateRepository(settings, logger);
// Assert
Assert.IsInstanceOfType(actualRepo, typeof(AggregateRepository));
AggregateRepository actualAggregateRepo = (AggregateRepository)actualRepo;
AssertExpectedPackageSources(actualAggregateRepo,
"d:\\active_cache",
"c:\\another\\active\\cache");
logger.AssertErrorsLogged(0);
logger.AssertWarningsLogged(0);
}
public void PluginBuilder_Simple()
{
// Arrange
TestLogger logger = new TestLogger();
PluginBuilder builder = CreateValidBuilder(logger);
// Act and assert
BuildAndCheckSucceeds(builder, logger);
}
public void PluginBuilder_PluginNameIsRequired()
{
// Arrange
TestLogger logger = new TestLogger();
PluginBuilder builder = CreateValidBuilder(logger);
builder.SetProperty(WellKnownPluginProperties.PluginName, null);
// Act and assert
AssertException.Expect<System.InvalidOperationException>(() => builder.Build());
}
public void PluginBuilder_InvalidSource()
{
// Arrange
TestLogger logger = new TestLogger();
PluginBuilder builder = CreateValidBuilder(logger);
string invalidSource = this.CreateInputSourceFile("Program.java", "invalid java code");
builder.AddSourceFile(invalidSource);
// Act
BuildAndCheckCompileFails(builder, logger);
}
public void ArgProc_EmptyArgs()
{
// Arrange
TestLogger logger = new TestLogger();
string[] rawArgs = { };
// Act
ProcessedArgs actualArgs = ArgumentProcessor.TryProcessArguments(rawArgs, logger);
// Assert
AssertArgumentsNotProcessed(actualArgs, logger);
}
public void InstantiateDiags_CSharp_NoFiles()
{
// Arrange
TestLogger logger = new TestLogger();
DiagnosticAssemblyScanner scanner = new DiagnosticAssemblyScanner(logger);
// Act
IEnumerable<DiagnosticAnalyzer> result = scanner.InstantiateDiagnostics(LanguageNames.CSharp /* no files */);
// Assert
Assert.IsNotNull(result, "Not expecting InstantiateDiagnostics to return null");
Assert.IsFalse(result.Any(), "Not expecting any diagnostics to have been found");
}
public void ArgProc_AcceptLicenses_Valid()
{
// 0. Setup
TestLogger logger;
string[] rawArgs;
ProcessedArgs actualArgs;
// 1. Correct argument -> valid and accept is true
logger = new TestLogger();
rawArgs = new string[] { "/a:validId", "/acceptLicenses" };
actualArgs = ArgumentProcessor.TryProcessArguments(rawArgs, logger);
AssertArgumentsProcessed(actualArgs, logger, "validId", null, null, true);
}
public void TestAssemblyNameFileNameAssociation()
{
// Arrange
TestLogger logger = new TestLogger();
Assembly assembly = typeof(AssemblyResolver).Assembly;
string assemblyName = assembly.FullName;
string actualFileName = Path.GetFileName(assembly.Location);
// Act
string testFileName = AssemblyResolver.CreateFileNameFromAssemblyName(assemblyName);
// Assert
Assert.AreEqual<string>(actualFileName, testFileName);
}
public void AssemblyResolver_NonExistentAssembly_ResolutionFails()
{
// Arrange
TestLogger logger = new TestLogger();
string testFolder = TestUtils.CreateTestDirectory(this.TestContext);
// Act
using (AssemblyResolver resolver = new AssemblyResolver(logger, testFolder))
{
AssertAssemblyLoadFails("nonexistent library");
// Assert
AssertResolverCaller(resolver);
}
}
public void NuGet_TestDependencyResolutionFailure()
{
// Arrange
string testDir = TestUtils.CreateTestDirectory(this.TestContext);
TestLogger logger = new TestLogger();
NuGetPackageHandler handler = new NuGetPackageHandler(logger);
// Act
// Fetch a package that should fail due to pre-release dependencies
IPackage package = handler.FetchPackage(AnalyzerPluginGenerator.NuGetPackageSource, "codeCracker", null, testDir);
// Assert
// No files should have been downloaded
Assert.IsTrue(Directory.GetFiles(testDir).Length == 0);
Assert.IsNull(package);
}
public void RoslynPlugin_GenerateForValidAnalyzer_Succeeds()
{
// Arrange
TestLogger logger = new TestLogger();
string outputDir = TestUtils.CreateTestDirectory(this.TestContext, ".out");
PluginInspector inspector = CreatePluginInspector(logger);
// Create a valid analyzer package
ExampleAnalyzer1.CSharpAnalyzer analyzer = new ExampleAnalyzer1.CSharpAnalyzer();
string packageId = "analyzer1.id1";
string localNuGetDir = TestUtils.CreateTestDirectory(this.TestContext, ".localNuGet");
IPackageManager localNuGetStore = CreatePackageManager(localNuGetDir);
AddPackage(localNuGetStore, packageId, "1.0", analyzer.GetType().Assembly.Location);
// Act
NuGetPackageHandler nuGetHandler = new NuGetPackageHandler(localNuGetDir, logger);
AnalyzerPluginGenerator apg = new AnalyzerPluginGenerator(nuGetHandler, logger);
bool result = apg.Generate(new Roslyn.CommandLine.NuGetReference(packageId, new SemanticVersion("1.0")), "cs", null, outputDir);
// Assert
Assert.IsTrue(result);
string jarFilePath = AssertPluginJarExists(outputDir);
JarInfo jarInfo = inspector.GetPluginDescription(jarFilePath);
if (jarInfo != null)
{
this.TestContext.AddResultFile(jarInfo.FileName);
}
Assert.IsNotNull(jarInfo, "Failed to process the generated jar successfully");
AssertPropertyDefinitionExists(packageId + "_sarif.AnalyzerId", jarInfo);
AssertPropertyDefinitionExists(packageId + "_sarif.RuleNamespace", jarInfo);
AssertPropertyDefinitionExists(packageId + "_sarif.nuget.packageId", jarInfo);
AssertPropertyDefinitionExists(packageId + "_sarif.nuget.packageVersion", jarInfo);
JarInfo.RulesDefinition rulesDefn = AssertRulesDefinitionExists(jarInfo);
AssertRepositoryIsValid(rulesDefn.Repository);
AssertExpectedRulesExist(analyzer, rulesDefn.Repository);
Assert.AreEqual(5, jarInfo.Extensions.Count, "Unexpected number of extensions");
}
public void InstantiateDiags_VB_AnalyzersFound()
{
// Arrange
TestLogger logger = new TestLogger();
DiagnosticAssemblyScanner scanner = new DiagnosticAssemblyScanner(logger);
string roslynAnalyzer11DllPath = typeof(RoslynAnalyzer11.CSharpAnalyzer).Assembly.Location;
// Act
IEnumerable<DiagnosticAnalyzer> result = scanner.InstantiateDiagnostics(LanguageNames.VisualBasic, roslynAnalyzer11DllPath);
// Assert
Assert_AnalyzerIsPresent(result, typeof(RoslynAnalyzer11.VBAnalyzer));
Assert_AnalyzerIsPresent(result, typeof(RoslynAnalyzer11.ConfigurableAnalyzer));
Assert_AnalyzerNotPresent(result, typeof(RoslynAnalyzer11.AbstractAnalyzer)); // not expecting abstract analyzers
Assert.AreEqual(2, result.Count(), "Expecting 2 VB analyzers");
}
public void InstantiateDiags_VB_NoAnalyzers()
{
// Arrange
TestLogger logger = new TestLogger();
DiagnosticAssemblyScanner scanner = new DiagnosticAssemblyScanner(logger);
string corLibDllPath = typeof(object).Assembly.Location;
string thisDllPath = this.GetType().Assembly.Location;
// Act
IEnumerable<DiagnosticAnalyzer> result = scanner.InstantiateDiagnostics(LanguageNames.VisualBasic,
corLibDllPath,
thisDllPath);
// Assert
Assert.IsNotNull(result, "Not expecting InstantiateDiagnostics to return null");
Assert.IsFalse(result.Any(), "Not expecting any diagnostics to have been found");
}
public void ScanDirectoryWithNoAnalyzerAssemblies()
{
// Arrange
TestLogger logger = new TestLogger();
DiagnosticAssemblyScanner scanner = new DiagnosticAssemblyScanner(logger);
// place a single assembly in the test directory, that does not have any analyzers in it
string noAnalyzerAssemblyPath = typeof(DiagnosticAssemblyScannerTests).Assembly.Location;
string testDirectoryPath = TestUtils.CreateTestDirectory(this.TestContext);
string testAssemblyPath = Path.Combine(testDirectoryPath, Path.GetFileName(noAnalyzerAssemblyPath));
File.Copy(noAnalyzerAssemblyPath, testAssemblyPath);
// Act
IEnumerable<DiagnosticAnalyzer> csharpDiagnostics = scanner.InstantiateDiagnostics(testDirectoryPath, LanguageNames.CSharp);
IEnumerable<DiagnosticAnalyzer> vbDiagnostics = scanner.InstantiateDiagnostics(testDirectoryPath, LanguageNames.VisualBasic);
// Assert
Assert.AreEqual(0, csharpDiagnostics.Count(), "No analyzers should have been detected");
Assert.AreEqual(0, vbDiagnostics.Count(), "No analyzers should have been detected");
}
public void CheckNoTags()
{
// Arrange
TestLogger logger = new TestLogger();
ConfigurableAnalyzer analyzer = new ConfigurableAnalyzer();
var diagnostic1 = analyzer.RegisterDiagnostic(key: "DiagnosticID1", tags: new[] { "t1" });
var diagnostic2 = analyzer.RegisterDiagnostic(key: "DiagnosticID2", tags: new[] { "T2" });
IRuleGenerator generator = new RuleGenerator(logger);
// Act
Rules rules = generator.GenerateRules(new[] { analyzer });
// Assert
foreach (Rule rule in rules)
{
VerifyRuleValid(rule);
Assert.IsNull(rule.Tags);
}
}
public void InstantiateDiags_CSharp_AnalyzersFound()
{
// Arrange
TestLogger logger = new TestLogger();
DiagnosticAssemblyScanner scanner = new DiagnosticAssemblyScanner(logger, this.TestContext.DeploymentDirectory);
string roslynAnalyzer11DllPath = typeof(RoslynAnalyzer11.CSharpAnalyzer).Assembly.Location;
// Act
IEnumerable<DiagnosticAnalyzer> result = scanner.InstantiateDiagnostics(LanguageNames.CSharp, roslynAnalyzer11DllPath);
// Assert
Assert_AnalyzerIsPresent(result, typeof(RoslynAnalyzer11.CSharpAnalyzer));
Assert_AnalyzerIsPresent(result, typeof(RoslynAnalyzer11.ConfigurableAnalyzer));
Assert_AnalyzerIsPresent(result, "RoslynAnalyzer11.InternalAnalyzer");
Assert_AnalyzerNotPresent(result, typeof(RoslynAnalyzer11.AbstractAnalyzer)); // not expecting abstract analyzers
Assert_AnalyzerNotPresent(result, typeof(RoslynAnalyzer11.UnattributedAnalyzer)); // not expecting analyzers without attributes
Assert.AreEqual(3, result.Count(), "Expecting 3 C# analyzers");
}
public void NuGet_TestPackageDownload_PreRelease_Release()
{
// Arrange
string targetNuGetRoot = TestUtils.CreateTestDirectory(this.TestContext, ".nuget.target");
// Create test NuGet payload and packages
IPackageRepository fakeRemoteRepo = CreateTestPackageWithSingleDependency(PreReleaseVersion, ReleaseVersion);
TestLogger logger = new TestLogger();
NuGetPackageHandler handler = new NuGetPackageHandler(fakeRemoteRepo, targetNuGetRoot, logger);
// Act
// Attempt to download a package which is not released with a dependency that is released
IPackage package = handler.FetchPackage(DependentPackageId, null);
// Assert
AssertExpectedPackage(package, DependentPackageId, PreReleaseVersion);
// Packages should have been downloaded
AssertPackageDownloaded(targetNuGetRoot, DependentPackageId, PreReleaseVersion);
AssertPackageDownloaded(targetNuGetRoot, TestPackageId, ReleaseVersion);
}
public void NuGet_TestPackageDownload_PreRelease_Release()
{
// Arrange
string testDir = TestUtils.CreateTestDirectory(this.TestContext);
string testDownloadDir = Path.Combine(testDir, "download");
// Create test NuGet payload and packages
BuildTestPackages(false, true);
TestLogger logger = new TestLogger();
NuGetPackageHandler handler = new NuGetPackageHandler(testDir, logger);
// Act
// Attempt to download a package which is not released with a dependency that is released
IPackage package = handler.FetchPackage(DependentPackageName, null, testDownloadDir);
// Assert
AssertExpectedPackage(package, DependentPackageName, PreReleaseVersion);
// Packages should have been downloaded
AssertPackageDownloaded(testDownloadDir, DependentPackageName, PreReleaseVersion);
AssertPackageDownloaded(testDownloadDir, TestPackageName, ReleaseVersion);
}
public void JarBuilder_Layout()
{
// Arrange
TestLogger logger = new TestLogger();
string inputsDir = TestUtils.CreateTestDirectory(this.TestContext, "inputs");
string rootTempDir = TestUtils.CreateTestDirectory(this.TestContext, "temp");
string contentDir = Path.Combine(rootTempDir, JarBuilder.JAR_CONTENT_DIRECTORY_NAME);
string file1 = TestUtils.CreateTextFile("file1.txt", inputsDir, "file1 content");
string file2 = TestUtils.CreateTextFile("file2.txt", inputsDir, "file2 content");
string file3 = TestUtils.CreateTextFile("file3.txt", inputsDir, "file3 content");
// Act
JarBuilder builder = new JarBuilder(logger, new MockJdkWrapper());
builder.SetManifestPropety("prop1", "prop1 value");
builder.SetManifestPropety("prop2", "prop2 value");
builder.SetManifestPropety("prop3", "prop3 value");
builder.AddFile(file1, null);
builder.AddFile(file2, "myorg\\myapp\\f2.txt");
builder.AddFile(file3, "resources\\f3.txt");
builder.LayoutFiles(rootTempDir);
// Assert
string content = TestUtils.AssertFileExists(JdkWrapper.MANIFEST_FILE_NAME, rootTempDir);
AssertManifestPropertyExists(content, "prop1", "prop1 value");
AssertManifestPropertyExists(content, "prop2", "prop2 value");
AssertManifestPropertyExists(content, "prop3", "prop3 value");
content = TestUtils.AssertFileExists("file1.txt", contentDir);
Assert.AreEqual("file1 content", content, "Unexpected file content");
content = TestUtils.AssertFileExists("myorg\\myapp\\f2.txt", contentDir);
Assert.AreEqual("file2 content", content, "Unexpected file content");
content = TestUtils.AssertFileExists("resources\\f3.txt", contentDir);
Assert.AreEqual("file3 content", content, "Unexpected file content");
}
public void RulesMustHaveDescription()
{
// Arrange
TestLogger logger = new TestLogger();
ConfigurableAnalyzer analyzer = new ConfigurableAnalyzer();
var diagnostic1 = analyzer.RegisterDiagnostic(key: "DiagnosticID1", description: null);
var diagnostic2 = analyzer.RegisterDiagnostic(key: "DiagnosticID1", description: "");
var diagnostic3 = analyzer.RegisterDiagnostic(key: "DiagnosticID2", description: " ");
IRuleGenerator generator = new RuleGenerator(logger);
// Act
Rules rules = generator.GenerateRules(new[] { analyzer });
// Assert
foreach (Rule rule in rules)
{
VerifyRuleValid(rule);
Assert.AreEqual(rule.Description, UIResources.RuleGen_NoDescription);
}
}
