Przepływy testów end-to-end
Zaimplementuj strategie testów end-to-end, aby weryfikować kompletny przebieg działań użytkownika i funkcjonalność desktopowej aplikacji Electron.
Przepływy testów end-to-end to bezpłatna lekcja Electron Desktop App Development na CoddyKit. To lekcja 3 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Electron Desktop App Development, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Electron Desktop App Development zawiera 4 lekcji w sumie.
Części tej lekcji nie zostały jeszcze przetłumaczone i są wyświetlane po angielsku.
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!
Często zadawane pytania
Czy lekcja „Przepływy testów end-to-end” jest bezpłatna?
Tak — pełny tekst „Przepływy testów end-to-end” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Electron Desktop App Development, przejdź na CoddyKit PRO. Kurs Electron Desktop App Development zawiera 4 lekcji w sumie.
Co nauczysz się w „Przepływy testów end-to-end”?
Zaimplementuj strategie testów end-to-end, aby weryfikować kompletny przebieg działań użytkownika i funkcjonalność desktopowej aplikacji Electron. Ćwiczysz Electron Desktop App Development z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.
Czy potrzebuję doświadczenia, aby zacząć Electron Desktop App Development?
Nie wymagamy żadnego doświadczenia. Electron Desktop App Development w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 4.
Ile czasu zajmuje lekcja „Przepływy testów end-to-end”?
Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.
Czy mogę pisać i uruchamiać kod w tej lekcji Electron Desktop App Development?
Tak. Każda lekcja Electron Desktop App Development zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.
Wszystkie lekcje w tym kursie
- Debugowanie procesów głównego i renderera
- Testy jednostkowe z Spectron
- Przepływy testów end-to-end
- Nowoczesne testy E2E z Playwright