public async Task SpecsAreBoundEvenWithErrorsWhenCancelOnFirstFailureIsDisabled()
{
var module1 = ModuleDescriptor.CreateForTesting("Module1");
var moduleWithContent = CreateEmptyContent()
.AddContent(module1, "This spec is not DScript;");
var queue = CreateParsingQueueFromContent(new[] { moduleWithContent });
var modules = new[]
{
GetModuleDefinitionFromContent(module1, moduleWithContent),
};
var parsingResult = await queue.ProcessAsync(modules);
// There should be one spec and one failure
XAssert.AreEqual(1, parsingResult.SpecCount);
XAssert.AreEqual(1, parsingResult.Failures.Count);
// The spec should be bound
var sourceFile = parsingResult.SpecSources.First().Value.SourceFile;
XAssert.AreEqual(SourceFileState.Bound, sourceFile.State);
}
public async Task ParsingCompletesWhenCancelOnFirstFailureIsDisabled()
{
var module1 = ModuleDescriptor.CreateForTesting("Module1");
var module2 = ModuleDescriptor.CreateForTesting("Module2");
var moduleWithContent = CreateEmptyContent()
.AddContent(module1, "This spec is not DScript;")
.AddContent(module2, "return 2;");
var queue = CreateParsingQueueFromContent(new[] { moduleWithContent });
var modules = new[]
{
GetModuleDefinitionFromContent(module1, moduleWithContent),
GetModuleDefinitionFromContent(module2, moduleWithContent)
};
var parsingResult = await queue.ProcessAsync(modules);
// There should be one failure
XAssert.IsTrue(AssertSingleFailureAndGetIt(parsingResult) is ParsingFailure);
// But still there should be 2 modules in the result and parsing should not be cancelled
XAssert.AreEqual(2, parsingResult.SpecModules.Count);
}
public void TargetWorkspaceHasAllTransitiveDependencies()
{
// Arrange
// One module:
// Spec3 -> Spec2 -> Spec1
var moduleDescriptor = ModuleDescriptor.CreateForTesting("MyModule");
var spec1 = SourceFile(specFile);
var spec2 = SourceFile(specFile2);
var spec3 = SourceFile(specFile3);
var workspace = CreateWorkspace(
CreateEmptyParsedModule(moduleDescriptor, spec1, spec2, spec3));
AddUpStreamDependency(workspace, spec2, specFile);
AddUpStreamDependency(workspace, spec3, specFile2);
// Filter takes only myModule.dsc
var filter = ModuleFilterBySpecFullPath(specFile3);
// Act
FilterWorkspace(workspace, filter);
// Assert
var moduleFromFilteredWorksapce = workspace.SpecModules.FirstOrDefault(m => m.Descriptor.Name == "MyModule");
Assert.NotNull(moduleFromFilteredWorksapce);
Assert.Equal(moduleFromFilteredWorksapce.Specs.Count, 3);
}
public void TargetWorkspaceHasNonFilteredModuleAndItsUpstreamDependency()
{
// Arrange
// Base module. The root module with no dependencies.
var baseModule = ModuleDescriptor.CreateForTesting("MyBaseModule");
// MyModule depends on BaseModule
var moduleDescriptor = ModuleDescriptor.CreateForTesting("MyModule");
var moduleSourceFile = SourceFile(myModule);
moduleSourceFile.AddModuleDependency("MyBaseModule");
// MyDerived module depends on MyModule
var derivedDescriptor = ModuleDescriptor.CreateForTesting("MyDerivedModule");
var myDerivedSourceFile = SourceFile(myDerivedModule);
myDerivedSourceFile.AddModuleDependency("MyModule");
var workspace = CreateWorkspace(
CreateEmptyParsedModule(moduleDescriptor, moduleSourceFile),
CreateEmptyParsedModule(baseModule),
CreateEmptyParsedModule(derivedDescriptor, myDerivedSourceFile));
var filter = ModuleFilterByModuleName("MyModule");
// Act
FilterWorkspace(workspace, filter);
// Assert
Assert.NotNull(workspace.SpecModules.FirstOrDefault(m => m.Descriptor.Name == "MyModule"));
Assert.NotNull(workspace.SpecModules.FirstOrDefault(m => m.Descriptor.Name == "MyBaseModule"));
Assert.Null(workspace.SpecModules.FirstOrDefault(m => m.Descriptor.Name == "MyDerivedModule"));
}
public void TargetWorkspaceHasOneFileFromTheCurrentModuleAndTheirDependencies()
{
// Arrange
// Base module. Root spec
var baseModule = ModuleDescriptor.CreateForTesting("MyBaseModule");
var baseModuleSourceFile = SourceFile(baseSpec);
var baseModuleSourceFile2 = SourceFile(baseSpec2);
// MyModule: depends on a spec from the base module
var moduleDescriptor = ModuleDescriptor.CreateForTesting("MyModule");
var mySpecPath = myModule;
var moduleSourceFile = SourceFile(mySpecPath);
var moduleSourceFile2 = SourceFile(myModule2);
// MyDerivedModule: depends on MyModule spec
var derivedModule = ModuleDescriptor.CreateForTesting("MyDerivedModule");
var myDerivedSourceFile = SourceFile(myDerivedModule);
var workspace = CreateWorkspace(
CreateEmptyParsedModule(moduleDescriptor, moduleSourceFile, moduleSourceFile2),
CreateEmptyParsedModule(baseModule, baseModuleSourceFile, baseModuleSourceFile2),
CreateEmptyParsedModule(derivedModule, myDerivedSourceFile));
// Can add dependencies only when the workspace is constructed
AddUpStreamDependency(workspace, moduleSourceFile, baseSpec);
AddUpStreamModuleDependency(moduleSourceFile, "MyBaseModule");
AddUpStreamDependency(workspace, myDerivedSourceFile, mySpecPath);
AddUpStreamModuleDependency(myDerivedSourceFile, "MyModule");
// Filter takes only myModule.dsc
var filter = ModuleFilterBySpecFullPath(mySpecPath);
// Act
FilterWorkspace(workspace, filter);
// Assert
var moduleFromFilteredWorksapce = workspace.SpecModules.FirstOrDefault(m => m.Descriptor.Name == "MyModule");
Assert.NotNull(moduleFromFilteredWorksapce);
// MyModule in filtered workspace has just one spec
Assert.Equal(moduleFromFilteredWorksapce.Specs.Count, 1);
Assert.Equal(moduleFromFilteredWorksapce.Specs.First().Value, moduleSourceFile);
// Filtered workspace has the base module as well, because there is a dependency between MyModule and BaseModule
var baseModuleFromFilteredWorkspace = workspace.SpecModules.FirstOrDefault(m => m.Descriptor.Name == "MyBaseModule");
Assert.NotNull(baseModuleFromFilteredWorkspace);
// MyBaseModule in filtered workspace has just one spec
Assert.Equal(baseModuleFromFilteredWorkspace.Specs.Count, 1);
Assert.Equal(baseModuleFromFilteredWorkspace.Specs.First().Value, baseModuleSourceFile);
}
public async Task CreateWorkspaceForASpec()
{
var moduleReference = ModuleDescriptor.CreateForTesting("MyModule");
var moduleWithContent = CreateEmptyContent().AddContent(moduleReference, "return 1;");
var pathToFirstSpec = moduleWithContent.GetPathToModuleAndSpec(moduleReference, 0);
var workspaceProvider = CreateWorkspaceProviderFromContent(false, moduleWithContent);
var workspace = await workspaceProvider.CreateWorkspaceFromSpecAsync(pathToFirstSpec);
var module = AssertSuccessAndGetFirstModule(workspace);
XAssert.AreEqual(moduleReference, module.Descriptor);
}
public async Task AModuleWithNoSpecsDoesNotStallTheQueue()
{
var module1 = ModuleDescriptor.CreateForTesting("Module1");
var moduleWithContent = CreateEmptyContent()
.AddContent(module1);
var queue = CreateParsingQueueFromContent(new[] { moduleWithContent }, fileSystem: new NotImplementedFileSystem());
var modules = new[] { GetModuleDefinitionFromContent(module1, moduleWithContent) };
var parsingResult = await queue.ProcessAsync(modules);
XAssert.IsTrue(parsingResult.Succeeded);
}
public async Task ResolverNotFoundIsReportedForUnknownStartingSpec()
{
var myModule = ModuleDescriptor.CreateForTesting("MyModule");
var moduleWithContent = CreateEmptyContent()
.AddContent(myModule, "return 1;");
var workspaceProvider = CreateWorkspaceProviderFromContent(false, moduleWithContent);
// No resolver knows about a spec '42.dsc'
var path = moduleWithContent.RootDir.Combine(PathTable, "42.dsc");
var workspace = await workspaceProvider.CreateWorkspaceFromSpecAsync(path);
XAssert.IsTrue(AssertSingleFailureAndGetIt(workspace) is ResolverNotFoundForPathFailure);
}
public async Task ResolverNotFoundIsReportedForUnknownStartingModule()
{
var myModule = ModuleDescriptor.CreateForTesting("MyModule");
var moduleWithContent = CreateEmptyContent()
.AddContent(myModule, "return 1;");
var workspaceProvider = CreateWorkspaceProviderFromContent(false, moduleWithContent);
// No resolver knows about this module
var module = ModuleDescriptor.CreateForTesting("UnknownModule");
var workspace = await workspaceProvider.CreateWorkspaceFromModuleAsync(module);
XAssert.IsTrue(AssertSingleFailureAndGetIt(workspace) is ResolverNotFoundForModuleDescriptorFailure);
}
public async Task CreateWorkspaceForAModule()
{
var moduleReference = ModuleDescriptor.CreateForTesting("MyModule");
var moduleWithContent = CreateEmptyContent().AddContent(moduleReference, "return 1;");
var workspaceProvider = CreateWorkspaceProviderFromContent(false, moduleWithContent);
var workspace = await workspaceProvider.CreateWorkspaceFromModuleAsync(moduleReference);
// The module should have the right name and the expected parsed spec
var module = AssertSuccessAndGetFirstModule(workspace);
XAssert.AreEqual(moduleReference, module.Descriptor);
// There should be one spec
XAssert.AreEqual(1, module.Specs.Count);
}
/// <nodoc/>
public PipSchedulingTestBase(ITestOutputHelper output, bool usePassThroughFileSystem = false) : base(output, usePassThroughFileSystem)
{
TestPath = AbsolutePath.Create(PathTable, TestRoot);
m_testModule = ModuleDefinition.CreateModuleDefinitionWithImplicitReferences(
ModuleDescriptor.CreateForTesting("Test"),
TestPath,
TestPath.Combine(PathTable, "module.config.bm"),
new[] { TestPath.Combine(PathTable, "spec.dsc") },
allowedModuleDependencies: null,
cyclicalFriendModules: null);
m_configFilePath = TestPath.Combine(PathTable, "config.dsc");
PopulateMainConfigAndPrelude();
}
public void TestUpdateExternalModuleReference()
{
var content = @"const x = 42";
var parser = new Parser();
var sourceFile = parser.ParseSourceFileContent(content);
var referenceResolver = new ModuleReferenceResolver(PathTable);
var module =
ModuleDefinition.CreateModuleDefinitionWithExplicitReferencesWithEmptyQualifierSpace(
ModuleDescriptor.CreateForTesting("Test"), m_fakeMainFile, m_fakeModuleConfigFile, new[] { m_fakeMainFile }, PathTable);
Failure failure;
var result = referenceResolver.TryUpdateExternalModuleReference(sourceFile, module, out failure);
XAssert.IsTrue(result);
XAssert.IsTrue(sourceFile.ResolvedModules.ContainsKey("Test"));
}
public async Task ExceptionsAreProperlyPropagated()
{
var moduleName = ModuleDescriptor.CreateForTesting("MyModule");
var moduleWithContent = CreateEmptyContent().AddContent(moduleName, "return 1;");
var queue = CreateParsingQueueFromContent(new[] { moduleWithContent }, new NotImplementedFileSystem());
var modules = new[] { GetModuleDefinitionFromContent(moduleName, moduleWithContent) };
try
{
var parsingResult = await queue.ProcessAsync(modules);
XAssert.Fail("Should never get here");
}
catch (NotImplementedException)
{
}
}
public async Task TestSimple()
{
const string Spec0 = "import {Transformer} from 'Sdk.Transformers';\r\nexport const x = Transformer.copyFile(f`src-x.txt`, Context.getNewOutputDirectory('test').combine('dest-x.txt'));";
const string Spec1 = "import {Transformer} from 'Sdk.Transformers';\r\nexport const y = Transformer.copyFile(f`src-y.txt`, Context.getNewOutputDirectory('test').combine('dest-y.txt'));";
var helperFull = new WorkspaceEvaluationHelper(TestOutputDirectory, context: null, forTesting: true);
var testModule = ModuleDescriptor.CreateForTesting("MyModule1");
// evaluate full
var repo = helperFull.NewModuleRepoWithPrelude().AddContent(testModule, Spec0, Spec1);
var pipGraph = await helperFull.EvaluateAsync(repo);
var fullGraphPipCounts = new Dictionary <PipType, int>
{
[PipType.CopyFile] = 2,
};
AssertPipGraphCounts(pipGraph, fullGraphPipCounts);
// evaluate partial without patching --> result is a smaller graph
{
var helperPartial = new WorkspaceEvaluationHelper(TestOutputDirectory, context: helperFull.FrontEndContext, forTesting: true);
var partialRepo = helperPartial.NewModuleRepoWithPrelude().AddContent(testModule, Spec0);
var newPipGraph = await helperPartial.EvaluateAsync(partialRepo);
AssertPipGraphCounts(newPipGraph, new Dictionary <PipType, int>
{
[PipType.CopyFile] = 1,
});
}
// evaluate partial with patching --> same as full graph
{
// NOTE: must start with previous PathTable, because some paths from the old build might not be seen in the partial workspace
var helperPartial = new WorkspaceEvaluationHelper(TestOutputDirectory, context: helperFull.FrontEndContext, forTesting: true);
var partialRepo = helperPartial.NewModuleRepoWithPrelude().AddContent(testModule, Spec0);
var changedSpecs = new[] { repo.GetPathToModuleAndSpec(testModule, 0) };
var newPipGraph = await helperPartial.EvaluateWithGraphPatchingAsync(partialRepo, oldPipGraph : pipGraph, changedSpecs : changedSpecs, specsToIgnore : null);
AssertPipGraphCounts(newPipGraph, fullGraphPipCounts);
}
}
public void TargetWorkspaceHasAllModulesFromFilter()
{
// Arrange
var myOtherModule = ModuleDescriptor.CreateForTesting("MyOtherModule");
var myModule = ModuleDescriptor.CreateForTesting("MyModule");
var workspace = CreateWorkspace(
CreateEmptyParsedModule(myModule),
CreateEmptyParsedModule(myOtherModule));
var filter = ModuleFilterByModuleName("MyModule");
// Act
FilterWorkspace(workspace, filter);
// Assert
Assert.NotNull(workspace.SpecModules.FirstOrDefault(m => m.Descriptor.Name == "MyModule"));
// MyModule and MyOtherModule are not related, so the "other" module should be filtered out.
Assert.Null(workspace.SpecModules.FirstOrDefault(m => m.Descriptor.Name == "MyOtherModule"));
}
protected KeyValuePair <AbsolutePath, ISourceFile> LoadAndTypecheckFile(
FrontEndContext context,
string testSource,
string[] extraSources,
Dictionary <string, string> modules,
out Workspace workspace,
bool preserveTrivia = false)
{
var wsHelper = new WorkspaceTestBase(pathTable: context.PathTable, preludeName: FrontEndHost.PreludeModuleName, nameResolutionSemantics: NameResolutionSemantics.ImplicitProjectReferences);
var repo = wsHelper.CreateEmptyContent();
var testModule = ModuleDescriptor.CreateForTesting("TestModule");
repo.AddContent(testModule, testSource);
if (extraSources != null)
{
repo.AddContent(testModule, extraSources);
}
repo.AddContent(FrontEndHost.PreludeModuleName,
File.ReadAllText(@"Libs/lib.core.d.ts"),
File.ReadAllText(@"Libs/Prelude.IO.ts"),
"namespace Tool {export declare function option(value: string): any;}");
if (modules != null)
{
foreach (var kv in modules)
{
repo.AddContent(ModuleDescriptor.CreateForTesting(kv.Key), kv.Value);
}
}
workspace = wsHelper.CreateSematicWorkspaceFromContent(testModule, preserveTrivia, repo).GetAwaiter().GetResult();
WorkspaceTestBase.AssertNoWorkspaceFailures(workspace);
var semanticModel = workspace.GetSemanticModel();
WorkspaceTestBase.AssertNoSemanticErrors(semanticModel);
return(workspace.Modules.First(m => m.Descriptor.Name == "TestModule").Specs.First(f => f.Key.GetName(context.PathTable).ToString(context.StringTable) == "0.dsc"));
}
public void TestUpdateInternalModuleReferences(string internalReference)
{
var content = "import * as Foo from \"" + internalReference + "\";";
// We create a module with a fake main file at the root and one project under SubDir
var projectDir = AbsolutePath.Create(PathTable, A("c", "SubDir", "project.dsc"));
var parser = new Parser();
var sourceFile = parser.ParseSourceFileContent(projectDir.ToString(PathTable), content);
var referenceResolver = new ModuleReferenceResolver(PathTable);
var module =
ModuleDefinition.CreateModuleDefinitionWithExplicitReferencesWithEmptyQualifierSpace(
ModuleDescriptor.CreateForTesting("Test"), m_fakeMainFile, m_fakeModuleConfigFile, new[] { m_fakeMainFile, projectDir },
PathTable);
Failure[] failures;
var result = referenceResolver.TryUpdateAllInternalModuleReferences(sourceFile, module, out failures);
XAssert.IsTrue(result);
XAssert.IsTrue(sourceFile.ResolvedModules.ContainsKey(internalReference));
}
public void TestInternalReferencesOutsideModuleAreNotAllowed()
{
var content = "import * as Foo from \"./DoesNotExist.dsc\";";
var parser = new Parser();
var sourceFile = parser.ParseSourceFileContent(m_fakeMainFile.ToString(PathTable), content);
var referenceResolver = new ModuleReferenceResolver(PathTable);
var module = ModuleDefinition.CreateModuleDefinitionWithExplicitReferencesWithEmptyQualifierSpace(
ModuleDescriptor.CreateForTesting("Test"),
m_fakeMainFile,
m_fakeModuleConfigFile,
new[] { m_fakeMainFile },
PathTable);
Failure[] failures;
var result = referenceResolver.TryUpdateAllInternalModuleReferences(sourceFile, module, out failures);
XAssert.IsFalse(result);
XAssert.AreEqual(1, failures.Length);
XAssert.IsTrue(failures[0] is SpecNotUnderAModuleFailure);
}
public async Task AllSpecsAreAddedToTheModuleWhenCancelOnFirstFailureIsDisabled()
{
var module1 = ModuleDescriptor.CreateForTesting("Module1");
var moduleWithContent = CreateEmptyContent()
.AddContent(
module1,
"This spec is not DScript;",
"This spec is not DScript either;");
var queue = CreateParsingQueueFromContent(new[] { moduleWithContent });
var modules = new[]
{
GetModuleDefinitionFromContent(module1, moduleWithContent),
};
var parsingResult = await queue.ProcessAsync(modules);
// There should be two specs and two failures
XAssert.AreEqual(2, parsingResult.SpecCount);
XAssert.AreEqual(2, parsingResult.Failures.Count);
}
public async Task ClosureContainsAllElements(string importOrExport)
{
var module1 = ModuleDescriptor.CreateForTesting("Module1");
var module2 = ModuleDescriptor.CreateForTesting("Module2");
var module3 = ModuleDescriptor.CreateForTesting("Module3");
var moduleWithContent = CreateEmptyContent()
.AddContent(module1, importOrExport + " * from \"Module2\";")
.AddContent(module2, importOrExport + " * from \"Module3\";")
.AddContent(module3, "return 3;")
.AddContent("Module4", "return 4;");
var workspaceProvider = CreateWorkspaceProviderFromContent(false, moduleWithContent);
var workspace = await workspaceProvider.CreateWorkspaceFromModuleAsync(module1);
var modules = AssertSuccessAndGetAllModules(workspace);
// We should have module 1, 2 and 3. Not 4.
XAssert.AreEqual(3, modules.Count);
var names = modules.Select(module => module.Descriptor);
XAssert.AreEqual(3, names.Intersect(new[] { module1, module2, module3 }).Count());
}
/// <summary>
/// From a given <param name="path"/> that points to a module and spec, returns its module.
/// </summary>
public ModuleDescriptor GetModuleFromPath(AbsolutePath path)
{
var moduleName = path.GetParent(PathTable).GetName(PathTable).ToString(PathTable.StringTable);
return(ModuleDescriptor.CreateForTesting(moduleName));
}
private ParsedModule ConfigurationModule()
{
return(CreateEmptyParsedModule(ModuleDescriptor.CreateForTesting(Names.ConfigModuleName)));
}
private ParsedModule Prelude()
{
return(CreateEmptyParsedModule(ModuleDescriptor.CreateForTesting("Sdk.Prelude")));
}
/// <summary>
/// Convenience method, mainly for testing. <see cref="AddContent(ModuleDescriptor,string[])"/>
/// </summary>.
public ModuleRepository AddContent(string moduleName, params string[] content)
{
return(AddContent(ModuleDescriptor.CreateForTesting(moduleName), content));
}
public void TargetWorkspaceHasFullModulesAndPartialModulesBasedOnAFilter()
{
// Arrange
// Base module. Root spec
var baseModule = ModuleDescriptor.CreateForTesting("MyBaseModule");
var baseModuleSourceFile = SourceFile(baseSpec);
var baseModuleSourceFile2 = SourceFile(baseSpec2);
// MyModule: depends on a spec from the base module
var moduleDescriptor = ModuleDescriptor.CreateForTesting("MyModule");
var mySpecPath = myModule;
var moduleSourceFile = SourceFile(mySpecPath);
var moduleSourceFile2 = SourceFile(myModule2);
// MyDerivedModule: depends on MyModule spec
var derivedDescriptor = ModuleDescriptor.CreateForTesting("MyDerivedModule");
var myDerivedSourceFile = SourceFile(myDerivedModule);
var workspace = CreateWorkspace(
CreateEmptyParsedModule(moduleDescriptor, moduleSourceFile, moduleSourceFile2),
CreateEmptyParsedModule(baseModule, baseModuleSourceFile, baseModuleSourceFile2),
CreateEmptyParsedModule(derivedDescriptor, myDerivedSourceFile));
AddUpStreamDependency(workspace, moduleSourceFile, baseSpec);
AddUpStreamDependency(workspace, myDerivedSourceFile, mySpecPath);
// Filter takes base module and one spec from the derived one
var filter = new EvaluationFilter(
m_symbolTable,
m_pathTable,
valueNamesToResolve: CollectionUtilities.EmptyArray <FullSymbol>(),
valueDefinitionRootsToResolve: new List <AbsolutePath>()
{
AbsolutePath.Create(m_pathTable, mySpecPath)
},
modulesToResolver: new List <StringId>()
{
StringId.Create(StringTable, "MyBaseModule")
});
// Act
FilterWorkspace(workspace, filter);
// Assert
var moduleFromFilteredWorksapce = workspace.SpecModules.FirstOrDefault(m => m.Descriptor.Name == "MyModule");
Assert.NotNull(moduleFromFilteredWorksapce);
// MyModule in filtered workspace has just one spec
Assert.Equal(moduleFromFilteredWorksapce.Specs.Count, 1);
Assert.Equal(moduleFromFilteredWorksapce.Specs.First().Value, moduleSourceFile);
// Filtered workspace has the base module as well, because there is a dependency between MyModule and BaseModule
var baseModuleFromFilteredWorkspace = workspace.SpecModules.FirstOrDefault(m => m.Descriptor.Name == "MyBaseModule");
Assert.NotNull(baseModuleFromFilteredWorkspace);
// Both specs from the base module shoudl be presented.
Assert.Equal(baseModuleFromFilteredWorkspace.Specs.Count, 2);
}
public GraphBasedTestBase(ITestOutputHelper output) : base(output)
{
TestModule = ModuleDescriptor.CreateForTesting("TestModule");
}
