Test cases added for Gradle project - directory with space

src/test/GradleTestPathDevModeActionsWSInit.ts

@@ -0,0 +1,27 @@
+
+import {  WebDriver, VSBrowser } from 'vscode-extension-tester';
+import * as utils from './utils/testUtils';
+
+
+
+describe('Open Gradle Project - path with space', () => {
+
+    let driver: WebDriver;  
+
+
+    before(() => {
+        driver = VSBrowser.instance.driver;
+        utils.createGradleProjectPathWithSpace();
+
+    });
+
+    it('Open Sample Gradle Project - path with space', async () => {       
+
+        await VSBrowser.instance.openResources(utils.getGradleProjectPathDirWithSpace());
+
+    }).timeout(25000);
+
+
+});
+
+

src/test/GradleTestPathDevModeActionsWSTasks.ts

@@ -0,0 +1,281 @@
+import { expect } from 'chai';
+import { InputBox, Workbench,SideBarView, ViewItem, ViewSection,EditorView,DefaultTreeItem, DebugView } from 'vscode-extension-tester';
+import * as utils from './utils/testUtils';
+import * as constants from './definitions/constants';
+import path = require('path');
+// import { after } from 'mocha';
+
+describe('Devmode action tests for Gradle Project - path with space', () => {
+    let sidebar: SideBarView;
+    let debugView: DebugView;
+    let section: ViewSection;
+    let item: DefaultTreeItem;    
+    let tabs: string[];
+
+    before(() => {
+        sidebar = new SideBarView();
+        debugView = new DebugView();      
+    });
+
+it('getViewControl works with the correct label',  async() => { 
+
+   const contentPart = sidebar.getContent();
+   section = await contentPart.getSection('Liberty Dashboard');   
+   console.log("Found Liberty Dashboard....");
+   expect(section).not.undefined; 
+
+}).timeout(25000);
+
+
+it('Open dasboard shows items - Gradle', async () => {
+
+
+    await utils.delay(65000);
+    await section.expand(); 
+    await utils.delay(6000);
+    const menu = await section.getVisibleItems();            
+    expect(menu).not.empty;     
+    item = await section.findItem(constants.GRADLE_PROJECT) as DefaultTreeItem;   
+    expect(item).not.undefined;   
+
+
+}).timeout(300000);
+
+
+it('Start gradle project from liberty dashboard', async () => {      
+
+
+  await utils.launchDashboardAction(item,constants.START_DASHBOARD_ACTION,constants.START_DASHBOARD_MAC_ACTION);  
+  await utils.delay(30000);
+  const serverStartStatus = await utils.checkTerminalforServerState(constants.SERVER_START_STRING);
+  if(!serverStartStatus)
+    console.log("Server started message not found in the terminal");
+  else
+  {
+    console.log("Server succuessfully started");  
+    await utils.launchDashboardAction(item, constants.STOP_DASHBOARD_ACTION, constants.STOP_DASHBOARD_MAC_ACTION);
+    const serverStopStatus= await utils.checkTerminalforServerState(constants.SERVER_STOP_STRING);   
+    if(!serverStopStatus){ 
+    console.error("Server stopped message not found in the terminal");
+    }
+    else
+      console.log("Server stopped successfully");
+    expect (serverStopStatus).to.be.true;
+}
+ expect (serverStartStatus).to.be.true; 
+
+
+}).timeout(350000);
+
+it('Run tests for gradle project', async () => {  
+
+  await utils.launchDashboardAction(item, constants.START_DASHBOARD_ACTION, constants.START_DASHBOARD_MAC_ACTION);
+  await utils.delay(30000);  
+  const serverStartStatus = await utils.checkTerminalforServerState(constants.SERVER_START_STRING);
+  console.log("after checkTerminalforServerState"); 
+  if(!serverStartStatus)
+    console.log("Server started message not found in the terminal");
+  else
+  {
+    console.log("Server succuessfully started");  
+    await utils.launchDashboardAction(item,constants.RUNTEST_DASHBOARD_ACTION,constants.RUNTEST_DASHBOARD_MAC_ACTION);    
+    const testStatus = await utils.checkTestStatus(constants.GRADLE_TEST_RUN_STRING);        
+    await utils.launchDashboardAction(item, constants.STOP_DASHBOARD_ACTION, constants.STOP_DASHBOARD_MAC_ACTION);
+    const serverStopStatus= await utils.checkTerminalforServerState(constants.SERVER_STOP_STRING);
+    if(!serverStopStatus)
+      console.error("Server stopped message not found in the terminal");    
+    else
+      console.log("Server stopped successfully");
+    expect (serverStopStatus).to.be.true;
+    expect (testStatus).to.be.true;
+}
+ expect (serverStartStatus).to.be.true; 
+
+
+}).timeout(350000);
+
+
+it('start gradle with options from liberty dashboard', async () => {      
+
+  const reportPath = path.join(utils.getGradleProjectPathDirWithSpace(),"build", "reports", "tests", "test", "index.html");
+  const deleteReport = await utils.deleteReports(reportPath);
+  expect (deleteReport).to.be.true;
+  await utils.launchDashboardAction(item, constants.START_DASHBOARD_ACTION_WITH_PARAM, constants.START_DASHBOARD_MAC_ACTION_WITH_PARAM);
+  await utils.setCustomParameter("--hotTests");  
+  await utils.delay(30000);  
+  const serverStartStatus = await utils.checkTerminalforServerState(constants.SERVER_START_STRING);
+  if(!serverStartStatus)
+    console.log("Server started with params message not found in terminal ");
+  else
+  {
+    console.log("Server succuessfully started");  
+    let checkFile = await utils.checkIfTestReportExists(reportPath);    
+    await utils.launchDashboardAction(item, constants.STOP_DASHBOARD_ACTION, constants.STOP_DASHBOARD_MAC_ACTION);    
+    console.log("after dashboard action");
+    const serverStopStatus= await utils.checkTerminalforServerState(constants.SERVER_STOP_STRING);
+    if(!serverStopStatus) 
+      console.error("Server stopped message not found in ther terminal");    
+    else
+      console.log("Server stopped successfully");
+    expect (serverStopStatus).to.be.true;
+    expect (checkFile).to.be.true;    
+}
+ expect (serverStartStatus).to.be.true;
+
+}).timeout(550000);
+
+it('start gradle with history from liberty dashboard', async () => {  
+
+  const reportPath = path.join(utils.getGradleProjectPathDirWithSpace(),"build", "reports", "tests", "test", "index.html");
+  const deleteReport = await utils.deleteReports(reportPath);
+  expect (deleteReport).to.be.true;  
+  await utils.launchDashboardAction(item, constants.START_DASHBOARD_ACTION_WITH_PARAM, constants.START_DASHBOARD_MAC_ACTION_WITH_PARAM);  
+  const foundCommand = await utils.chooseCmdFromHistory("--hotTests");
+  console.log("foundcmd:" + foundCommand);
+  expect (foundCommand).to.be.true;  
+  await utils.delay(30000);
+  const serverStartStatus = await utils.checkTerminalforServerState(constants.SERVER_START_STRING);
+  if(!serverStartStatus)
+    console.log("Server started with params message not found in the terminal ");
+  else
+  {
+    console.log("Server succuessfully started");  
+    let checkFile = await utils.checkIfTestReportExists(reportPath);    
+    await utils.launchDashboardAction(item, constants.STOP_DASHBOARD_ACTION, constants.STOP_DASHBOARD_MAC_ACTION);    
+    const serverStopStatus= await utils.checkTerminalforServerState(constants.SERVER_STOP_STRING);
+    if(!serverStopStatus)
+      console.error("Server stopped message not found in terminal");
+    else
+      console.log("Server stopped successfully");
+    expect (serverStopStatus).to.be.true;
+    expect (checkFile).to.be.true;
+}
+ expect (serverStartStatus).to.be.true;
+
+}).timeout(350000);
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+it('attach debugger for gradle with custom parameter event', async () => {
+  console.log("start attach debugger");
+  let isServerRunning: Boolean = true;
+  let attachStatus: Boolean = false;
+  try {
+    await utils.launchDashboardAction(item,constants.START_DASHBOARD_ACTION_WITH_PARAM, constants.START_DASHBOARD_MAC_ACTION_WITH_PARAM);
+    await utils.setCustomParameter("-DdebugPort=7777");   
+    await utils.delay(30000);
+
+    isServerRunning = await utils.checkTerminalforServerState(constants.SERVER_START_STRING);
+    if (!isServerRunning)
+      console.log("Server started with params message not found in terminal");
+    else {
+      console.log("Server succuessfully started");
+    await utils.launchDashboardAction(item,constants.ATTACH_DEBUGGER_DASHBOARD_ACTION, constants.ATTACH_DEBUGGER_DASHBOARD_MAC_ACTION);    
+    console.log("Attach Debugger action done");
+    await utils.delay(8000);
+    const contentPart = debugView.getContent();
+    //console.log("Get Content");
+
+    let mysecarry: Promise<ViewSection[]> = contentPart.getSections();    
+    let mysecmap: IterableIterator<[number, ViewSection]> = (await mysecarry).entries();
+    for (const [key, value] of (mysecmap)) {
+      if ((await value.getEnclosingElement().getText()).includes("BREAKPOINTS")) {
+        //console.log("******** mysecmap getEnclosingElement " + (await value.getEnclosingElement().getText()).valueOf());
+        console.log("Found Breakpoints");
+        attachStatus = true;
+        break;
+      }
+    }
+
+    await utils.stopLibertyserver();
+    isServerRunning = !await utils.checkTerminalforServerState(constants.SERVER_STOP_STRING); //negate isServerRunning
+    if (!isServerRunning)
+      console.log("Server stopped successfully ");
+  }
+  } catch (e) {
+    console.error("error - ", e)
+  } finally {
+    console.log("finally block: is server running -  ", isServerRunning);
+    if (isServerRunning) {
+      utils.stopLibertyserver();
+    }
+    else
+      console.log("good to close test - Attach Debugger for start with custom parameter(-DdebugPort=7777) event");
+  }
+  expect(attachStatus).to.be.true;
+}).timeout(550000);
+
+it('start gradle with docker from liberty dashboard', async () => {     
+
+  if((process.platform === 'darwin' ) || (process.platform === 'win32') || (process.platform == 'linux'))
+  {
+    //skip running for platforms , enable them for linux after resolving docker setup in GHA
+    return true;
+  }
+
+
+  await utils.launchDashboardAction(item, constants.START_DASHBOARD_ACTION_WITHDOCKER, constants.START_DASHBOARD_MAC_ACTION_WITHDOCKER);  
+  await utils.delay(60000);
+  const serverStartStatus = await utils.checkTerminalforServerState(constants.SERVER_START_STRING);
+  if(!serverStartStatus)
+    console.log("Server started message not found in the terminal");
+  else
+  {
+    console.log("Server succuessfully started");  
+    await utils.launchDashboardAction(item, constants.STOP_DASHBOARD_ACTION, constants.STOP_DASHBOARD_MAC_ACTION);    
+    const serverStopStatus= await utils.checkTerminalforServerState(constants.SERVER_STOP_STRING);
+    if(!serverStopStatus){ 
+    console.error("Server stopped message not found in the terminal");
+    }
+    else
+      console.log("Server stopped successfully");
+    expect (serverStopStatus).to.be.true;
+}
+ expect (serverStartStatus).to.be.true; 
+
+
+}).timeout(350000);
+
+it('View test report for gradle project', async () => {      
+
+  if((process.platform === 'darwin' ) || (process.platform === 'win32') || (process.platform == 'linux'))
+  {
+    //skip running for platforms , enable once https://github.com/OpenLiberty/liberty-tools-vscode/issues/266 is resolved
+    return true;
+  }
+
+  await utils.launchDashboardAction(item,constants.GRADLE_TR_DASHABOARD_ACTION, constants.GRADLE_TR_DASHABOARD_MAC_ACTION);   
+  tabs = await new EditorView().getOpenEditorTitles();
+ // expect (tabs[1]], "Gradle test report not found").to.equal(constants.GRADLE_TEST_REPORT_TITLE);
+ expect (tabs.indexOf(constants.GRADLE_TEST_REPORT_TITLE)>-1, "Gradle test report not found").to.equal(true); 
+
+}).timeout(30000);
+
+
+  // Now, clear the command history of the "command palette" to avoid receiving "recently used" suggestions. This action should be performed at the end of Gradle Project tests.
+it('Clear Command Palatte', async () => {
+  await utils.clearCommandPalette();
+}).timeout(100000);
+
+after(() => {
+  const gradleProjectPath = path.join(__dirname,"..","..","src", "test","resources","gradle project");
+  console.log("Current path __dirname: "+ __dirname);
+  console.log("Removing project from the path: "+ gradleProjectPath);
+  utils.removeProjectFolder(gradleProjectPath);  
+});
+
+});
+

src/test/utils/testUtils.ts

@@ -192,4 +192,75 @@ export async function clearCommandPalette() {
   expect(buttons.length).equals(2);
   await dialog.pushButton('Clear');
 }
-
+/**
+ * Function return project path with space
+ */
+export function getGradleProjectPathDirWithSpace(): any {
+  const gradleProjectPath = path.join(__dirname, "..","..","..","src", "test","resources","gradle project", "liberty.gradle.test.wrapper.app");   
+  console.log("Gradle project path is: "+gradleProjectPath);
+
+  return gradleProjectPath;
+}
+/**
+ * Create new gradle project with space in the directory
+ */
+export function createGradleProjectPathWithSpace(): void {
+  const existingGradleProjectPath = path.join(__dirname, "..","..","..","src", "test","resources");  
+
+  const sourcepath=path.join(existingGradleProjectPath, 'gradle');
+  const gradleProjectFolder = path.join(existingGradleProjectPath, 'gradle project'); 
+
+  /* function will copy gradle project from existing gradle project */
+  copyDirectoryAndProject(sourcepath, gradleProjectFolder);
+  const gradleProjectPath = path.join(__dirname, "..","..","..","src", "test","resources","gradle project", "liberty.gradle.test.wrapper.app");
+  console.log("Gradle project copy created - path: "+gradleProjectPath);
+
+}  
+/**
+ * Function to create new folder and create a copy of the project
+ */
+async function copyDirectoryAndProject(src : string, dest : string){
+  try {
+      await fs.mkdirSync(dest, { recursive: true });
+
+      const projectFiles = await fs.readdirSync(src, { withFileTypes: true });
+
+      for (const projectFile of projectFiles) {
+          const srcPath = path.join(src, projectFile.name);
+          const destPath = path.join(dest, projectFile.name);
+
+          if (projectFile.isDirectory()) {
+              await copyDirectoryAndProject(srcPath, destPath);
+          } else {
+            await fs.copyFileSync(srcPath, destPath);
+        }
+      }
+  } catch (err) {
+      console.error(`Error copying project directory: ${err}`);
+  }
+}
+/**
+ * Remove newly created Project folder with content
+ */
+
+export async function removeProjectFolder(projectPath: string): Promise<void> {
+  try {
+    await fs.accessSync(projectPath);
+    const projectFiles = await fs.readdirSync(projectPath);
+    await Promise.all(
+      projectFiles.map(async (projectFile) => {
+            const projectFilePath = path.join(projectPath, projectFile);
+            const stats = await fs.lstatSync(projectFilePath); 
+
+            if (stats.isDirectory()) {
+                await removeProjectFolder(projectFilePath);
+            } else {
+                await fs.unlinkSync(projectFilePath);
+            }
+        })
+    );
+    await fs.rmdirSync(projectPath);
+  } catch (error) {
+      console.error(`Error removing project folder: ${error}`);
+  }
+}