@theia/playwright 1.25.0-next.7 → 1.25.0

package/src/tests/theia-text-editor.test.ts

@@ -0,0 +1,176 @@
+// *****************************************************************************
+// Copyright (C) 2021 logi.cals GmbH, EclipseSource and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { expect } from '@playwright/test';
+import { TheiaApp } from '../theia-app';
+import { TheiaTextEditor } from '../theia-text-editor';
+import { TheiaWorkspace } from '../theia-workspace';
+import test, { page } from './fixtures/theia-fixture';
+
+let app: TheiaApp;
+
+test.describe('Theia Text Editor', () => {
+
+    test.beforeAll(async () => {
+        const ws = new TheiaWorkspace(['src/tests/resources/sample-files1']);
+        app = await TheiaApp.load(page, ws);
+    });
+
+    test('should be visible and active after opening "sample.txt"', async () => {
+        const sampleTextEditor = await app.openEditor('sample.txt', TheiaTextEditor);
+        expect(await sampleTextEditor.isTabVisible()).toBe(true);
+        expect(await sampleTextEditor.isDisplayed()).toBe(true);
+        expect(await sampleTextEditor.isActive()).toBe(true);
+    });
+
+    test('should be possible to open "sample.txt" when already opened and then close it', async () => {
+        const sampleTextEditor = await app.openEditor('sample.txt', TheiaTextEditor);
+        expect(await sampleTextEditor.isTabVisible()).toBe(true);
+
+        await sampleTextEditor.close();
+        expect(await sampleTextEditor.isTabVisible()).toBe(false);
+    });
+
+    test('should be possible to open four text editors, switch among them, and close them', async () => {
+        const textEditor1_1_1 = await app.openEditor('sampleFolder/sampleFolder1/sampleFolder1-1/sampleFile1-1-1.txt', TheiaTextEditor);
+        const textEditor1_1_2 = await app.openEditor('sampleFolder/sampleFolder1/sampleFolder1-1/sampleFile1-1-2.txt', TheiaTextEditor);
+        const textEditor1_2_1 = await app.openEditor('sampleFolder/sampleFolder1/sampleFolder1-2/sampleFile1-2-1.txt', TheiaTextEditor);
+        const textEditor1_2_2 = await app.openEditor('sampleFolder/sampleFolder1/sampleFolder1-2/sampleFile1-2-2.txt', TheiaTextEditor);
+        const allEditors = [textEditor1_1_1, textEditor1_1_2, textEditor1_2_1, textEditor1_2_2];
+
+        // all editor tabs should be visible
+        for (const editor of allEditors) {
+            expect(await editor.isTabVisible()).toBe(true);
+        }
+
+        // activate one editor after the other and check that only this editor is active
+        for (const editor of allEditors) {
+            await editor.activate();
+            expect(await textEditor1_1_1.isActive()).toBe(textEditor1_1_1 === editor);
+            expect(await textEditor1_1_2.isActive()).toBe(textEditor1_1_2 === editor);
+            expect(await textEditor1_2_1.isActive()).toBe(textEditor1_2_1 === editor);
+            expect(await textEditor1_2_2.isActive()).toBe(textEditor1_2_2 === editor);
+        }
+
+        // close all editors
+        for (const editor of allEditors) {
+            await editor.close();
+        }
+
+        // check that all editors are closed
+        for (const editor of allEditors) {
+            expect(await editor.isTabVisible()).toBe(false);
+        }
+    });
+
+    test('should return the contents of lines by line number', async () => {
+        const sampleTextEditor = await app.openEditor('sample.txt', TheiaTextEditor);
+        expect(await sampleTextEditor.textContentOfLineByLineNumber(2)).toBe('content line 2');
+        expect(await sampleTextEditor.textContentOfLineByLineNumber(3)).toBe('content line 3');
+        expect(await sampleTextEditor.textContentOfLineByLineNumber(4)).toBe('content line 4');
+        await sampleTextEditor.close();
+    });
+
+    test('should return the contents of lines containing text', async () => {
+        const sampleTextEditor = await app.openEditor('sample.txt', TheiaTextEditor);
+        expect(await sampleTextEditor.textContentOfLineContainingText('line 2')).toBe('content line 2');
+        expect(await sampleTextEditor.textContentOfLineContainingText('line 3')).toBe('content line 3');
+        expect(await sampleTextEditor.textContentOfLineContainingText('line 4')).toBe('content line 4');
+        await sampleTextEditor.close();
+    });
+
+    test('should be dirty after changing the file contents and clean after save', async () => {
+        const sampleTextEditor = await app.openEditor('sample.txt', TheiaTextEditor);
+        await sampleTextEditor.replaceLineWithLineNumber('this is just a sample file', 1);
+        expect(await sampleTextEditor.isDirty()).toBe(true);
+
+        await sampleTextEditor.save();
+        expect(await sampleTextEditor.isDirty()).toBe(false);
+        await sampleTextEditor.close();
+    });
+
+    test('should replace the line with line number 2 with new text "new -- content line 2 -- new"', async () => {
+        const sampleTextEditor = await app.openEditor('sample.txt', TheiaTextEditor);
+        await sampleTextEditor.replaceLineWithLineNumber('new -- content line 2 -- new', 2);
+        expect(await sampleTextEditor.textContentOfLineByLineNumber(2)).toBe('new -- content line 2 -- new');
+        expect(await sampleTextEditor.isDirty()).toBe(true);
+
+        await sampleTextEditor.save();
+        expect(await sampleTextEditor.isDirty()).toBe(false);
+        await sampleTextEditor.close();
+    });
+
+    test('should replace the line with containing text "content line 2" with "even newer -- content line 2 -- even newer"', async () => {
+        const sampleTextEditor = await app.openEditor('sample.txt', TheiaTextEditor);
+        await sampleTextEditor.replaceLineContainingText('even newer -- content line 2 -- even newer', 'content line 2');
+        expect(await sampleTextEditor.textContentOfLineByLineNumber(2)).toBe('even newer -- content line 2 -- even newer');
+        await sampleTextEditor.saveAndClose();
+    });
+
+    test('should delete the line with containing text "content line 2"', async () => {
+        const sampleTextEditor = await app.openEditor('sample.txt', TheiaTextEditor);
+        await sampleTextEditor.deleteLineContainingText('content line 2');
+        expect(await sampleTextEditor.textContentOfLineByLineNumber(2)).toBe('content line 3');
+        await sampleTextEditor.saveAndClose();
+    });
+
+    test('should delete the line with line number 2', async () => {
+        const sampleTextEditor = await app.openEditor('sample.txt', TheiaTextEditor);
+        await sampleTextEditor.deleteLineByLineNumber(2);
+        expect(await sampleTextEditor.textContentOfLineByLineNumber(2)).toBe('content line 4');
+        await sampleTextEditor.saveAndClose();
+    });
+
+    test('should have more lines after adding text in new line after line containing text "sample file"', async () => {
+        const sampleTextEditor = await app.openEditor('sample.txt', TheiaTextEditor);
+        const numberOfLinesBefore = await sampleTextEditor.numberOfLines();
+
+        await sampleTextEditor.addTextToNewLineAfterLineContainingText('sample file', 'new content for line 2');
+        const numberOfLinesAfter = await sampleTextEditor.numberOfLines();
+        expect(numberOfLinesBefore).not.toBeUndefined();
+        expect(numberOfLinesAfter).not.toBeUndefined();
+        expect(numberOfLinesAfter).toBeGreaterThan(numberOfLinesBefore!);
+
+        await sampleTextEditor.saveAndClose();
+    });
+
+    test('should undo and redo text changes with correctly updated dirty states', async () => {
+        const sampleTextEditor = await app.openEditor('sample.txt', TheiaTextEditor);
+        await sampleTextEditor.replaceLineWithLineNumber('change', 1);
+        expect(await sampleTextEditor.textContentOfLineByLineNumber(1)).toBe('change');
+        expect(await sampleTextEditor.isDirty()).toBe(true);
+
+        await sampleTextEditor.undo(2);
+        expect(await sampleTextEditor.textContentOfLineByLineNumber(1)).toBe('this is just a sample file');
+        expect(await sampleTextEditor.isDirty()).toBe(false);
+
+        await sampleTextEditor.redo(2);
+        expect(await sampleTextEditor.textContentOfLineByLineNumber(1)).toBe('change');
+        expect(await sampleTextEditor.isDirty()).toBe(true);
+
+        await sampleTextEditor.saveAndClose();
+    });
+
+    test.skip('should close without saving', async () => {
+        const sampleTextEditor = await app.openEditor('sample.txt', TheiaTextEditor);
+        await sampleTextEditor.replaceLineWithLineNumber('change again', 1);
+        expect(await sampleTextEditor.isDirty()).toBe(true);
+
+        await sampleTextEditor.closeWithoutSave();
+        expect(await sampleTextEditor.isTabVisible()).toBe(false);
+    });
+
+});

package/src/tests/theia-workspace.test.ts

@@ -0,0 +1,51 @@
+// *****************************************************************************
+// Copyright (C) 2021 logi.cals GmbH, EclipseSource and others.
+//
+// This program and the accompanying materials are made available under the
+// terms of the Eclipse Public License v. 2.0 which is available at
+// http://www.eclipse.org/legal/epl-2.0.
+//
+// This Source Code may also be made available under the following Secondary
+// Licenses when the conditions for such availability set forth in the Eclipse
+// Public License v. 2.0 are satisfied: GNU General Public License, version 2
+// with the GNU Classpath Exception which is available at
+// https://www.gnu.org/software/classpath/license.html.
+//
+// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+// *****************************************************************************
+
+import { TheiaApp } from '../theia-app';
+import { DOT_FILES_FILTER, TheiaExplorerView } from '../theia-explorer-view';
+import { TheiaWorkspace } from '../theia-workspace';
+import { expect } from '@playwright/test';
+import test, { page } from './fixtures/theia-fixture';
+
+test.describe('Theia Workspace', () => {
+
+    test('should be initialized empty by default', async () => {
+        const app = await TheiaApp.load(page);
+        const explorer = await app.openView(TheiaExplorerView);
+        const fileStatElements = await explorer.visibleFileStatNodes(DOT_FILES_FILTER);
+        expect(fileStatElements.length).toBe(0);
+    });
+
+    test('should be initialized with the contents of a file location', async () => {
+        const ws = new TheiaWorkspace(['src/tests/resources/sample-files1']);
+        const app = await TheiaApp.load(page, ws);
+        const explorer = await app.openView(TheiaExplorerView);
+        const fileStatElements = await explorer.visibleFileStatNodes(DOT_FILES_FILTER);
+        // resources/sample-files1 contains one folder and one file
+        expect(fileStatElements.length).toBe(2);
+    });
+
+    test('should be initialized with the contents of multiple file locations', async () => {
+        const ws = new TheiaWorkspace(['src/tests/resources/sample-files1', 'src/tests/resources/sample-files2']);
+        const app = await TheiaApp.load(page, ws);
+        const explorer = await app.openView(TheiaExplorerView);
+        const fileStatElements = await explorer.visibleFileStatNodes(DOT_FILES_FILTER);
+        // resources/sample-files1 contains one folder and one file
+        // resources/sample-files2 contains one file
+        expect(fileStatElements.length).toBe(3);
+    });
+
+});

package/src/theia-app.ts

@@ -24,6 +24,16 @@ import { TheiaStatusBar } from './theia-status-bar';
 import { TheiaView } from './theia-view';
 import { TheiaWorkspace } from './theia-workspace';
 
+export interface TheiaAppData {
+    loadingSelector: string;
+    shellSelector: string;
+};
+
+export const DefaultTheiaAppData: TheiaAppData = {
+    loadingSelector: '.theia-preload',
+    shellSelector: '.theia-ApplicationShell'
+};
+
 export class TheiaApp {
 
     readonly statusBar = new TheiaStatusBar(this);
@@ -31,20 +41,33 @@ export class TheiaApp {
     readonly menuBar = new TheiaMenuBar(this);
     public workspace: TheiaWorkspace;
 
-    public static async load(page: Page, initialWorkspace?: TheiaWorkspace): Promise<TheiaApp> {
-        const app = new TheiaApp(page, initialWorkspace);
-        await TheiaApp.loadOrReload(page, '/#' + app.workspace.urlEncodedPath);
-        await page.waitForSelector('.theia-preload', { state: 'detached' });
-        await page.waitForSelector('.theia-ApplicationShell');
-        await app.waitForInitialized();
-        return Promise.resolve(app);
+    static async load(page: Page, initialWorkspace?: TheiaWorkspace): Promise<TheiaApp> {
+        return this.loadApp(page, TheiaApp, initialWorkspace);
+    }
+
+    static async loadApp<T extends TheiaApp>(page: Page, appFactory: { new(page: Page, initialWorkspace?: TheiaWorkspace): T }, initialWorkspace?: TheiaWorkspace): Promise<T> {
+        const app = new appFactory(page, initialWorkspace);
+        await app.load();
+        return app;
+    }
+
+    public constructor(public page: Page, initialWorkspace?: TheiaWorkspace, protected appData = DefaultTheiaAppData) {
+        this.workspace = initialWorkspace ? initialWorkspace : new TheiaWorkspace();
+        this.workspace.initialize();
+    }
+
+    protected async load(): Promise<void> {
+        await this.loadOrReload(this.page, '/#' + this.workspace.urlEncodedPath);
+        await this.page.waitForSelector(this.appData.loadingSelector, { state: 'detached' });
+        await this.page.waitForSelector(this.appData.shellSelector);
+        await this.waitForInitialized();
     }
 
-    protected static async loadOrReload(page: Page, url: string): Promise<void> {
+    protected async loadOrReload(page: Page, url: string): Promise<void> {
         if (page.url() === url) {
             await page.reload();
         } else {
-            const wasLoadedAlready = await page.isVisible('.theia-ApplicationShell');
+            const wasLoadedAlready = await page.isVisible(this.appData.shellSelector);
             await page.goto(url);
             if (wasLoadedAlready) {
                 // Theia doesn't refresh on URL change only
@@ -54,11 +77,6 @@ export class TheiaApp {
         }
     }
 
-    protected constructor(public page: Page, initialWorkspace?: TheiaWorkspace) {
-        this.workspace = initialWorkspace ? initialWorkspace : new TheiaWorkspace();
-        this.workspace.initialize();
-    }
-
     async isMainContentPanelVisible(): Promise<boolean> {
         const contentPanel = await this.page.$('#theia-main-content-panel');
         return !!contentPanel && contentPanel.isVisible();

package/src/theia-workspace.ts

@@ -69,4 +69,8 @@ export class TheiaWorkspace {
         fs.emptyDirSync(this.workspacePath);
     }
 
+    remove(): void {
+        fs.removeSync(this.workspacePath);
+    }
+
 }