Processus de test de bout en bout
Mettez en œuvre des stratégies de test de bout en bout pour vérifier le parcours utilisateur complet et les fonctionnalités de votre application de bureau Electron.
Processus de test de bout en bout est une leçon Electron Desktop App Development gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Electron Desktop App Development, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Electron Desktop App Development comprend 4 leçons au total.
Certaines parties de cette leçon n'ont pas encore été traduites et s'affichent en anglais.
What is End-to-End Testing?
End-to-End (E2E) testing simulates real user scenarios to verify that an application works as expected from start to finish. Think of it as putting yourself in the user's shoes!
For Electron apps, E2E tests check if your UI (HTML/CSS/JS) correctly interacts with your backend logic (Node.js) and native OS features.
Why E2E for Electron Apps?
Electron applications are complex, combining web technologies with native desktop capabilities. Unit tests check small parts, but E2E ensures everything works together.
- Real User Flow: Mimics how a user navigates and interacts.
- Integration Checks: Verifies communication between main and renderer processes.
- Catch Regressions: Detects if new changes break existing features.
- Confidence: Gives you peace of mind that your app is stable.
Choosing an E2E Tool
Several tools can perform E2E testing for web applications, and many are adaptable for Electron. Popular choices include:
- Playwright: A modern framework from Microsoft, known for speed and reliability. It has built-in support for Electron.
- Cypress: A developer-friendly tool that runs tests directly in the browser (or Electron's renderer).
- WebDriver (Selenium): A classic choice, though often more complex to set up for Electron specifically.
We'll focus on Playwright due to its strong Electron support.
Setting Up Playwright for Electron
First, you need to install Playwright and its Electron driver in your project. Open your terminal in your Electron app's root directory and run:
npm install --save-dev @playwright/test playwright-electron
This command adds the necessary packages to your development dependencies. Remember, Playwright tests are typically run in a separate test folder.
Our Sample Electron App
To test, let's use a simple Electron app. Create these files in your project root:
package.json:
{ "name": "my-electron-app",
"version": "1.0.0",
"main": "main.js",
"scripts": {
"start": "electron ."
},
"devDependencies": {
"electron": "^28.0.0"
}
}Sample App: Main Process & UI
Next, create the main process file and the user interface:
main.js:
const { app, BrowserWindow } = require('electron');
const path = require('path');
function createWindow () {
const mainWindow = new BrowserWindow({
width: 800,
height: 600,
webPreferences: {
preload: path.join(__dirname, 'preload.js'),
nodeIntegration: false,
contextIsolation: true
}
});
mainWindow.loadFile('index.html');
}
app.whenReady().then(() => {
createWindow();
app.on('activate', () => {
if (BrowserWindow.getAllWindows().length === 0) createWindow();
});
});
app.on('window-all-closed', () => {
if (process.platform !== 'darwin') app.quit();
});Sample App: HTML & Preload
Finally, our simple UI and an empty preload script:
index.html:
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>My Electron App</title>
<style>
body { font-family: sans-serif; text-align: center; padding-top: 50px; }
h1 { color: #333; }
button { padding: 10px 20px; font-size: 16px; cursor: pointer; }
</style>
</head>
<body>
<h1>Hello, CoddyKit!</h1>
<p id="message">Click the button below.</p>
<button id="myButton">Change Message</button>
<script>
document.getElementById('myButton').addEventListener('click', () => {
document.getElementById('message').textContent = 'Message Changed!';
});
</script>
</body>
</html>Writing Your First E2E Test
Create a file named e2e.spec.js in a tests folder. This test launches your Electron app and verifies its title.
tests/e2e.spec.js:
const { test, expect, _electron: electron } = require('@playwright/test');
test('app launches and shows title', async () => {
// Launch the Electron app from the current directory
const electronApp = await electron.launch({ args: ['.'] });
// Get the first window that opens
const window = await electronApp.firstWindow();
// Assert the window title
expect(await window.title()).toBe('My Electron App');
// Close the app after the test
await electronApp.close();
});Interacting & Asserting
Let's expand our test to click the button and verify the message changes. This demonstrates user interaction and making assertions.
Add to tests/e2e.spec.js:
const { test, expect, _electron: electron } = require('@playwright/test');
// ... (previous test)
test('button click changes message', async () => {
const electronApp = await electron.launch({ args: ['.'] });
const window = await electronApp.firstWindow();
// Locate the paragraph and button elements by their IDs
const messageParagraph = window.locator('#message');
const button = window.locator('#myButton');
// Wait for elements to be visible and check initial text
await messageParagraph.waitFor();
await expect(messageParagraph).toHaveText('Click the button below.');
// Click the button
await button.click();
// Assert that the text has changed
await expect(messageParagraph).toHaveText('Message Changed!');
await electronApp.close();
});E2E Workflow Check
Which of the following are key benefits of using End-to-End (E2E) testing for an Electron application?
Recap: E2E Workflows
In this lesson, we explored End-to-End (E2E) testing for Electron applications. We learned that E2E tests simulate full user interactions to ensure all parts of your app work together seamlessly.
- We identified Playwright as a powerful tool for Electron E2E.
- We set up a simple Electron app and wrote tests to launch it, interact with UI elements, and make assertions.
E2E testing is vital for building robust and reliable desktop applications!
Questions Fréquemment Posées
La leçon « Processus de test de bout en bout » est-elle gratuite ?
Oui — le texte complet de « Processus de test de bout en bout » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Electron Desktop App Development, passe à CoddyKit PRO. Le cours Electron Desktop App Development comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Processus de test de bout en bout » ?
Mettez en œuvre des stratégies de test de bout en bout pour vérifier le parcours utilisateur complet et les fonctionnalités de votre application de bureau Electron. Tu pratiques Electron Desktop App Development avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer Electron Desktop App Development ?
Aucune expérience préalable n'est requise. Electron Desktop App Development sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.
Combien de temps prend la leçon « Processus de test de bout en bout » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon Electron Desktop App Development ?
Oui. Chaque leçon Electron Desktop App Development inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Déboguer les processus principal et de rendu
- Tests unitaires avec Spectron
- Processus de test de bout en bout
- Tests E2E modernes avec Playwright