Skip to content

Commit 677f04b

Browse files
sheetalkamatsheetalkamat
committed
Test to verify project loading events with default event handler
1 parent f7189e1 commit 677f04b

File tree

1 file changed

+149
-110
lines changed

1 file changed

+149
-110
lines changed

‎src/testRunner/unittests/tsserverProjectSystem.ts

Lines changed: 149 additions & 110 deletions
Original file line numberDiff line numberDiff line change
@@ -9467,141 +9467,180 @@ export const x = 10;`
94679467
const configBPath = `${projectRoot}/b/tsconfig.json`;
94689468
const files = [libFile, aTs, configA];
94699469

9470-
function createSessionWithEventHandler(files: ReadonlyArray<File>) {
9471-
const host = createServerHost(files);
9470+
function verifyProjectLoadingStartAndFinish(createSession: (host: TestServerHost) => {
9471+
session: TestSession;
9472+
getNumberOfEvents: () => number;
9473+
clearEvents: () => void;
9474+
verifyProjectLoadEvents: (expected: [server.ProjectLoadingStartEvent, server.ProjectLoadingFinishEvent]) => void;
9475+
}) {
9476+
function createSessionToVerifyEvent(files: ReadonlyArray<File>) {
9477+
const host = createServerHost(files);
9478+
const originalReadFile = host.readFile;
9479+
const { session, getNumberOfEvents, clearEvents, verifyProjectLoadEvents } = createSession(host);
9480+
host.readFile = file => {
9481+
if (file === configA.path || file === configBPath) {
9482+
assert.equal(getNumberOfEvents(), 1, "Event for loading is sent before reading config file");
9483+
}
9484+
return originalReadFile.call(host, file);
9485+
};
9486+
const service = session.getProjectService();
9487+
return { host, session, verifyEvent, verifyEventWithOpenTs, service, getNumberOfEvents };
94729488

9473-
const originalReadFile = host.readFile;
9474-
host.readFile = file => {
9475-
if (file === configA.path || file === configBPath) {
9476-
assert.equal(events.length, 1, "Event for loading is sent before reading config file");
9489+
function verifyEvent(project: server.Project, reason: string) {
9490+
verifyProjectLoadEvents([
9491+
{ eventName: server.ProjectLoadingStartEvent, data: { project, reason } },
9492+
{ eventName: server.ProjectLoadingFinishEvent, data: { project } }
9493+
]);
9494+
clearEvents();
94779495
}
9478-
return originalReadFile.call(host, file);
9479-
};
9480-
const { session, events } = createSessionWithEventTracking<server.ProjectLoadingStartEvent | server.ProjectLoadingFinishEvent>(host, server.ProjectLoadingStartEvent, server.ProjectLoadingFinishEvent);
9481-
const service = session.getProjectService();
9482-
return { host, session, verifyEvent, verifyEventWithOpenTs, service, events };
94839496

9484-
function verifyEvent(project: server.Project, reason: string) {
9485-
assert.deepEqual(events, [
9486-
{ eventName: server.ProjectLoadingStartEvent, data: { project, reason } },
9487-
{ eventName: server.ProjectLoadingFinishEvent, data: { project } }
9488-
]);
9489-
events.length = 0;
9497+
function verifyEventWithOpenTs(file: File, configPath: string, configuredProjects: number) {
9498+
openFilesForSession([file], session);
9499+
checkNumberOfProjects(service, { configuredProjects });
9500+
const project = service.configuredProjects.get(configPath)!;
9501+
assert.isDefined(project);
9502+
verifyEvent(project, `Creating possible configured project for ${file.path} to open`);
9503+
}
94909504
}
94919505

9492-
function verifyEventWithOpenTs(file: File, configPath: string, configuredProjects: number) {
9493-
openFilesForSession([file], session);
9494-
checkNumberOfProjects(service, { configuredProjects });
9495-
const project = service.configuredProjects.get(configPath)!;
9496-
assert.isDefined(project);
9497-
verifyEvent(project, `Creating possible configured project for ${file.path} to open`);
9498-
}
9499-
}
9500-
9501-
it("when project is created by open file", () => {
9502-
const bTs: File = {
9503-
path: bTsPath,
9504-
content: "export class B {}"
9505-
};
9506-
const configB: File = {
9507-
path: configBPath,
9508-
content: "{}"
9509-
};
9510-
const { verifyEventWithOpenTs } = createSessionWithEventHandler(files.concat(bTs, configB));
9511-
verifyEventWithOpenTs(aTs, configA.path, 1);
9512-
verifyEventWithOpenTs(bTs, configB.path, 2);
9513-
});
9506+
it("when project is created by open file", () => {
9507+
const bTs: File = {
9508+
path: bTsPath,
9509+
content: "export class B {}"
9510+
};
9511+
const configB: File = {
9512+
path: configBPath,
9513+
content: "{}"
9514+
};
9515+
const { verifyEventWithOpenTs } = createSessionToVerifyEvent(files.concat(bTs, configB));
9516+
verifyEventWithOpenTs(aTs, configA.path, 1);
9517+
verifyEventWithOpenTs(bTs, configB.path, 2);
9518+
});
95149519

9515-
it("when change is detected in the config file", () => {
9516-
const { host, verifyEvent, verifyEventWithOpenTs, service } = createSessionWithEventHandler(files);
9517-
verifyEventWithOpenTs(aTs, configA.path, 1);
9520+
it("when change is detected in the config file", () => {
9521+
const { host, verifyEvent, verifyEventWithOpenTs, service } = createSessionToVerifyEvent(files);
9522+
verifyEventWithOpenTs(aTs, configA.path, 1);
95189523

9519-
host.writeFile(configA.path, configA.content);
9520-
host.checkTimeoutQueueLengthAndRun(2);
9521-
const project = service.configuredProjects.get(configA.path)!;
9522-
verifyEvent(project, `Change in config file detected`);
9523-
});
9524+
host.writeFile(configA.path, configA.content);
9525+
host.checkTimeoutQueueLengthAndRun(2);
9526+
const project = service.configuredProjects.get(configA.path)!;
9527+
verifyEvent(project, `Change in config file detected`);
9528+
});
95249529

9525-
it("when opening original location project", () => {
9526-
const aDTs: File = {
9527-
path: `${projectRoot}/a/a.d.ts`,
9528-
content: `export declare class A {
9530+
it("when opening original location project", () => {
9531+
const aDTs: File = {
9532+
path: `${projectRoot}/a/a.d.ts`,
9533+
content: `export declare class A {
95299534
}
95309535
//# sourceMappingURL=a.d.ts.map
95319536
`
9532-
};
9533-
const aDTsMap: File = {
9534-
path: `${projectRoot}/a/a.d.ts.map`,
9535-
content: `{"version":3,"file":"a.d.ts","sourceRoot":"","sources":["./a.ts"],"names":[],"mappings":"AAAA,qBAAa,CAAC;CAAI"}`
9536-
};
9537-
const bTs: File = {
9538-
path: bTsPath,
9539-
content: `import {A} from "../a/a"; new A();`
9540-
};
9541-
const configB: File = {
9542-
path: configBPath,
9543-
content: JSON.stringify({
9544-
references: [{ path: "../a" }]
9545-
})
9546-
};
9537+
};
9538+
const aDTsMap: File = {
9539+
path: `${projectRoot}/a/a.d.ts.map`,
9540+
content: `{"version":3,"file":"a.d.ts","sourceRoot":"","sources":["./a.ts"],"names":[],"mappings":"AAAA,qBAAa,CAAC;CAAI"}`
9541+
};
9542+
const bTs: File = {
9543+
path: bTsPath,
9544+
content: `import {A} from "../a/a"; new A();`
9545+
};
9546+
const configB: File = {
9547+
path: configBPath,
9548+
content: JSON.stringify({
9549+
references: [{ path: "../a" }]
9550+
})
9551+
};
95479552

9548-
const { service, session, verifyEventWithOpenTs, verifyEvent } = createSessionWithEventHandler(files.concat(aDTs, aDTsMap, bTs, configB));
9549-
verifyEventWithOpenTs(bTs, configB.path, 1);
9553+
const { service, session, verifyEventWithOpenTs, verifyEvent } = createSessionToVerifyEvent(files.concat(aDTs, aDTsMap, bTs, configB));
9554+
verifyEventWithOpenTs(bTs, configB.path, 1);
95509555

9551-
session.executeCommandSeq<protocol.ReferencesRequest>({
9552-
command: protocol.CommandTypes.References,
9553-
arguments: {
9554-
file: bTs.path,
9555-
...protocolLocationFromSubstring(bTs.content, "A()")
9556-
}
9556+
session.executeCommandSeq<protocol.ReferencesRequest>({
9557+
command: protocol.CommandTypes.References,
9558+
arguments: {
9559+
file: bTs.path,
9560+
...protocolLocationFromSubstring(bTs.content, "A()")
9561+
}
9562+
});
9563+
9564+
checkNumberOfProjects(service, { configuredProjects: 2 });
9565+
const project = service.configuredProjects.get(configA.path)!;
9566+
assert.isDefined(project);
9567+
verifyEvent(project, `Creating project for original file: ${aTs.path} for location: ${aDTs.path}`);
95579568
});
95589569

9559-
checkNumberOfProjects(service, { configuredProjects: 2 });
9560-
const project = service.configuredProjects.get(configA.path)!;
9561-
assert.isDefined(project);
9562-
verifyEvent(project, `Creating project for original file: ${aTs.path} for location: ${aDTs.path}`);
9563-
});
9570+
describe("with external projects and config files ", () => {
9571+
const projectFileName = `${projectRoot}/a/project.csproj`;
95649572

9565-
describe("with external projects and config files ", () => {
9566-
const projectFileName = `${projectRoot}/a/project.csproj`;
9573+
function createSession(lazyConfiguredProjectsFromExternalProject: boolean) {
9574+
const { session, service, verifyEvent: verifyEventWorker, getNumberOfEvents } = createSessionToVerifyEvent(files);
9575+
service.setHostConfiguration({ preferences: { lazyConfiguredProjectsFromExternalProject } });
9576+
service.openExternalProject(<protocol.ExternalProject>{
9577+
projectFileName,
9578+
rootFiles: toExternalFiles([aTs.path, configA.path]),
9579+
options: {}
9580+
});
9581+
checkNumberOfProjects(service, { configuredProjects: 1 });
9582+
return { session, service, verifyEvent, getNumberOfEvents };
95679583

9568-
function createSession(lazyConfiguredProjectsFromExternalProject: boolean) {
9569-
const { session, service, verifyEvent: verifyEventWorker, events } = createSessionWithEventHandler(files);
9570-
service.setHostConfiguration({ preferences: { lazyConfiguredProjectsFromExternalProject } });
9571-
service.openExternalProject(<protocol.ExternalProject>{
9572-
projectFileName,
9573-
rootFiles: toExternalFiles([aTs.path, configA.path]),
9574-
options: {}
9584+
function verifyEvent() {
9585+
const projectA = service.configuredProjects.get(configA.path)!;
9586+
assert.isDefined(projectA);
9587+
verifyEventWorker(projectA, `Creating configured project in external project: ${projectFileName}`);
9588+
}
9589+
}
9590+
9591+
it("when lazyConfiguredProjectsFromExternalProject is false", () => {
9592+
const { verifyEvent } = createSession(/*lazyConfiguredProjectsFromExternalProject*/ false);
9593+
verifyEvent();
95759594
});
9576-
checkNumberOfProjects(service, { configuredProjects: 1 });
9577-
return { session, service, verifyEvent, events };
95789595

9579-
function verifyEvent() {
9580-
const projectA = service.configuredProjects.get(configA.path)!;
9581-
assert.isDefined(projectA);
9582-
verifyEventWorker(projectA, `Creating configured project in external project: ${projectFileName}`);
9583-
}
9584-
}
9596+
it("when lazyConfiguredProjectsFromExternalProject is true and file is opened", () => {
9597+
const { verifyEvent, getNumberOfEvents, session } = createSession(/*lazyConfiguredProjectsFromExternalProject*/ true);
9598+
assert.equal(getNumberOfEvents(), 0);
95859599

9586-
it("when lazyConfiguredProjectsFromExternalProject is false", () => {
9587-
const { verifyEvent } = createSession(/*lazyConfiguredProjectsFromExternalProject*/ false);
9588-
verifyEvent();
9589-
});
9600+
openFilesForSession([aTs], session);
9601+
verifyEvent();
9602+
});
95909603

9591-
it("when lazyConfiguredProjectsFromExternalProject is true and file is opened", () => {
9592-
const { verifyEvent, events, session } = createSession(/*lazyConfiguredProjectsFromExternalProject*/ true);
9593-
assert.equal(events.length, 0);
9604+
it("when lazyConfiguredProjectsFromExternalProject is disabled", () => {
9605+
const { verifyEvent, getNumberOfEvents, service } = createSession(/*lazyConfiguredProjectsFromExternalProject*/ true);
9606+
assert.equal(getNumberOfEvents(), 0);
95949607

9595-
openFilesForSession([aTs], session);
9596-
verifyEvent();
9608+
service.setHostConfiguration({ preferences: { lazyConfiguredProjectsFromExternalProject: false } });
9609+
verifyEvent();
9610+
});
95979611
});
9612+
}
95989613

9599-
it("when lazyConfiguredProjectsFromExternalProject is disabled", () => {
9600-
const { verifyEvent, events, service } = createSession(/*lazyConfiguredProjectsFromExternalProject*/ true);
9601-
assert.equal(events.length, 0);
9614+
describe("when using event handler", () => {
9615+
verifyProjectLoadingStartAndFinish(host => {
9616+
const { session, events } = createSessionWithEventTracking<server.ProjectLoadingStartEvent | server.ProjectLoadingFinishEvent>(host, server.ProjectLoadingStartEvent, server.ProjectLoadingFinishEvent);
9617+
return {
9618+
session,
9619+
getNumberOfEvents: () => events.length,
9620+
clearEvents: () => events.length = 0,
9621+
verifyProjectLoadEvents: expected => assert.deepEqual(events, expected)
9622+
};
9623+
});
9624+
});
96029625

9603-
service.setHostConfiguration({ preferences: { lazyConfiguredProjectsFromExternalProject: false } });
9604-
verifyEvent();
9626+
describe("when using default event handler", () => {
9627+
verifyProjectLoadingStartAndFinish(host => {
9628+
const { session, getEvents, clearEvents } = createSessionWithDefaultEventHandler<protocol.ProjectLoadingStartEvent | protocol.ProjectLoadingFinishEvent>(host, server.ProjectLoadingStartEvent, {}, server.ProjectLoadingFinishEvent);
9629+
return {
9630+
session,
9631+
getNumberOfEvents: () => getEvents().length,
9632+
clearEvents,
9633+
verifyProjectLoadEvents
9634+
};
9635+
9636+
function verifyProjectLoadEvents(expected: [server.ProjectLoadingStartEvent, server.ProjectLoadingFinishEvent]) {
9637+
const actual = getEvents().map(e => ({ eventName: e.event, data: e.body }));
9638+
const mappedExpected = expected.map(e => {
9639+
const { project, ...rest } = e.data;
9640+
return { eventName: e.eventName, data: { projectName: project.getProjectName(), ...rest } };
9641+
});
9642+
assert.deepEqual(actual, mappedExpected);
9643+
}
96059644
});
96069645
});
96079646
});

0 commit comments

Comments
 (0)