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"); }