Testowanie i zapewnianie jakości wspomagane przez AI

Transformuj swój przepływ pracy testowania z AI

Testowanie to miejsce gdzie pomoc AI naprawdę błyszczy. Zamiast ręcznego pisania powtarzalnych przypadków testowych lub zmagania się z celami pokrycia, AI Cursor może generować kompleksowe pakiety testów, debugować awarie, a nawet wykonywać testy end-to-end poprzez automatyzację przeglądarki.

Wskazówka

Przewaga testowania AI
AI świetnie radzi sobie z:

• Generowaniem przypadków brzegowych które możesz przegapić
• Pisaniem testów które faktycznie weryfikują zachowanie
• Utrzymywaniem spójności w pakietach testów
• Automatycznym debugowaniem awarii testów

Rozwój sterowany testami z AI

Tradycyjny cykl TDD (Czerwony → Zielony → Refaktor) zostaje naładowany pomocą AI. Oto ulepszony przepływ pracy:

1. Napisz testy najpierw

AI generuje kompleksowe przypadki testowe z wymagań

2. Uruchom testy (czerwony)

Testy początkowo zawodzą - to waliduje że testują prawdziwe zachowanie

3. Implementuj kod (zielony)

AI pisze kod aby testy przeszły, iterując automatycznie

4. Refaktoryzuj (niebieski)

AI optymalizuje kod zapewniając że testy nadal przechodzą

Moc trybu YOLO dla testowania

Włącz tryb YOLO aby odblokować automatyczne wykonywanie testów:

Ustawienia → Ogólne → Tryb YOLO → Włącz

Zalecany prompt:
wszelkiego rodzaju testy są zawsze dozwolone jak vitest, npm test,
nr test, itp. także podstawowe komendy build jak build, tsc, itp.
tworzenie plików i katalogów (jak touch, mkdir, itp)
też jest zawsze ok

Z trybem YOLO Agent może:

• Uruchamiać testy automatycznie
• Naprawiać zawodzące testy aktualizując kod
• Iterować aż wszystkie testy przejdą
• Naprawiać błędy TypeScript/linting

Przykład: Budowanie funkcji z TDD

Zaimplementujmy złożoną funkcję używając TDD wspomaganego przez AI:

Agent: Utwórz funkcję która konwertuje markdown na HTML.
Napisz testy najpierw, potem kod, następnie uruchom testy
i aktualizuj kod aż testy przejdą.

Obserwuj jak Agent:

1. Tworzy kompleksowy plik testowy

   describe('markdownToHtml', () => {
     it('powinien konwertować nagłówki', () => {
       expect(markdownToHtml('# Tytuł')).toBe('<h1>Tytuł</h1>');
       expect(markdownToHtml('## Podtytuł')).toBe('<h2>Podtytuł</h2>');
     });
   
     it('powinien konwertować pogrubiony tekst', () => {
       expect(markdownToHtml('**pogrubiony**')).toBe('<strong>pogrubiony</strong>');
     });
   
     it('powinien obsługiwać bloki kodu', () => {
       expect(markdownToHtml('`kod`')).toBe('<code>kod</code>');
     });
   
     // AI generuje wiele więcej przypadków brzegowych...
   });

2. Implementuje funkcję

   function markdownToHtml(markdown) {
     // Początkowa implementacja
   }

3. Uruchamia testy i widzi awarie

   ✗ 6 testów zawiodło

4. Iteracyjnie naprawia kod

   Aktualizuję implementację aby obsłużyć nagłówki...
   Uruchamiam testy ponownie...
   ✗ 3 testy zawiodły
   
   Dodaję wsparcie dla pogrubionego tekstu...
   Uruchamiam testy ponownie...
   ✓ Wszystkie testy przeszły!

Notatka

Wskazówka pro: Jeśli Agent schodzi z kursu, zatrzymaj go i podaj wskazówki: “Poczekaj, skup się na sprawdzeniu czy testy nagłówków przechodzą najpierw przed przejściem do innych funkcji”

Wzorce testowania jednostkowego

Wzorzec 1: Testowanie komponentów (React/Vue/Angular)

React

Agent: Utwórz testy jednostkowe dla tego komponentu UserProfile.
Testuj wszystkie propsy, interakcje użytkownika i przypadki brzegowe.
Używaj React Testing Library.

Agent generuje:

describe('UserProfile', () => {
  it('renderuje nazwę użytkownika i awatar', () => {
    const user = { name: 'Jan', avatar: 'url' };
    render(<UserProfile user={user} />);
    expect(screen.getByText('Jan')).toBeInTheDocument();
    expect(screen.getByRole('img')).toHaveAttribute('src', 'url');
  });

  it('obsługuje brakujący awatar z gracją', () => {
    // Testowanie przypadków brzegowych
  });

  it('wywołuje onEdit gdy przycisk edycji zostanie kliknięty', () => {
    // Testowanie interakcji
  });
});

Node.js

Agent: Napisz kompleksowe testy dla tego endpointu API.
Dołącz przypadki sukcesu, obsługę błędów i przypadki brzegowe.

Agent tworzy:

describe('POST /api/users', () => {
  it('tworzy użytkownika z prawidłowymi danymi', async () => {
    const response = await request(app)
      .post('/api/users')
      .send({ name: 'Test', email: 'test@example.com' });

    expect(response.status).toBe(201);
    expect(response.body).toHaveProperty('id');
  });

  it('waliduje format email', async () => {
    const response = await request(app)
      .post('/api/users')
      .send({ name: 'Test', email: 'nieprawidłowy' });

    expect(response.status).toBe(400);
    expect(response.body.error).toContain('email');
  });

  // Więcej przypadków testowych...
});

Wzorzec 2: Testowanie operacji asynchronicznych

Agent: Utwórz testy dla tej funkcji pobierania danych asynchronicznych.
Dołącz stany ładowania, sukces, błędy i retry.

AI obsługuje złożone scenariusze async:

describe('fetchUserData', () => {
  it('zwraca dane użytkownika przy sukcesie', async () => {
    const mockUser = { id: 1, name: 'Test' };
    fetch.mockResolvedValueOnce({
      ok: true,
      json: async () => mockUser
    });

    const result = await fetchUserData(1);
    expect(result).toEqual(mockUser);
  });

  it('powtarza przy awarii sieci', async () => {
    fetch.mockRejectedValueOnce(new Error('Błąd sieci'));
    fetch.mockResolvedValueOnce({
      ok: true,
      json: async () => ({ id: 1 })
    });

    const result = await fetchUserData(1);
    expect(fetch).toHaveBeenCalledTimes(2);
    expect(result).toBeDefined();
  });
});

Testowanie E2E z automatyzacją przeglądarki

Wykorzystaj Puppeteer/Playwright MCP do kompleksowego testowania E2E:

Konfiguracja testowania przeglądarki

Agent: Skonfiguruj testy E2E dla naszego przepływu logowania używając Puppeteer.
Testuj pomyślne logowanie, nieprawidłowe poświadczenia i zapomniałem hasła.

Uwaga

Upewnij się że Puppeteer MCP jest zainstalowany:

{
  "mcpServers": {
    "puppeteer": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-puppeteer"]
    }
  }
}

Implementacja testów E2E

Agent tworzy kompleksowe testy E2E:

describe('Przepływ logowania E2E', () => {
  it('pomyślne logowanie przekierowuje do dashboardu', async () => {
    // Agent używa Puppeteer MCP
    await page.goto('http://localhost:3000/login');
    await page.type('#email', 'user@example.com');
    await page.type('#password', 'correct-password');
    await page.click('button[type="submit"]');

    await page.waitForNavigation();
    expect(page.url()).toContain('/dashboard');

    // Rób zrzut ekranu dla weryfikacji wizualnej
    await page.screenshot({ path: 'login-success.png' });
  });

  it('pokazuje błąd dla nieprawidłowych poświadczeń', async () => {
    await page.goto('http://localhost:3000/login');
    await page.type('#email', 'user@example.com');
    await page.type('#password', 'wrong-password');
    await page.click('button[type="submit"]');

    const error = await page.waitForSelector('.error-message');
    const text = await error.evaluate(el => el.textContent);
    expect(text).toContain('Nieprawidłowe poświadczenia');
  });
});

Testowanie regresji wizualnej

Agent: Dodaj testy regresji wizualnej dla naszych kluczowych stron.
Porównuj zrzuty ekranu i oznaczaj wszelkie zmiany wizualne.

Debugowanie awarii testów

Gdy testy zawodzą, AI staje się twoim partnerem debugowania:

Strategiczny przepływ pracy debugowania

1. Analizuj awarię

Agent: Ten test zawodzi. Dodaj console.logs
aby zrozumieć co się dzieje.

2. Uruchom z logami

Agent uruchamia test z dodanym logowaniem,
przechwytuje output do analizy

3. Zidentyfikuj problem

Na podstawie logów: "Problem to format daty
nie pasuje do oczekiwanego wzorca"

4. Napraw i zweryfikuj

Agent naprawia kod i ponownie uruchamia testy
aby potwierdzić rozwiązanie

Przykład sesji debugowania

Użytkownik: Test uwierzytelniania użytkownika zawodzi sporadycznie

Agent: Debuguję tę sporadyczną awarię. Dodam logowanie
i informacje o czasie aby zrozumieć problem.

[Dodaje strategiczne console.logs i marki wydajności]
[Uruchamia test wiele razy]

Znalazłem! Test zawodzi gdy pula połączeń bazy danych
jest wyczerpana. Poprzedni test nie czyści połączeń.
Naprawię to dodając odpowiednie czyszczenie...

[Dodaje hook afterEach czyszczenia]
[Uruchamia test 10 razy - wszystkie przechodzą]

Sporadyczna awaria jest teraz rozwiązana.

Pokrycie testów i metryki jakości

Osiąganie wysokiego pokrycia

Agent: Przeanalizuj nasze pokrycie testów i napisz testy
aby osiągnąć 90% pokrycia dla modułu auth.

Agent wykona:

1. Uruchomi raport pokrycia
2. Zidentyfikuje niesprawdzone ścieżki kodu
3. Wygeneruje testy dla brakującego pokrycia
4. Skupi się na znaczących testach, nie tylko pokryciu linii

Analiza raportu pokrycia

Plik               | % Stmts | % Branch | % Funcs | % Lines |
-------------------|---------|----------|---------|---------|
auth/login.js      |   75.00 |    66.67 |  100.00 |   75.00 |
auth/register.js   |   90.00 |    85.00 |  100.00 |   88.89 |
auth/reset.js      |   45.00 |    33.33 |   66.67 |   45.00 |

Agent: Skupię się na auth/reset.js który ma niskie pokrycie.
Tworzę testy dla przypadków brzegowych resetowania hasła...

Zaawansowane wzorce testowania

Wzorzec 1: Mockowanie serwisów zewnętrznych

Agent: Mockuj wszystkie wywołania zewnętrznych API w naszych testach płatności.
Dołącz scenariusze sukcesu i awarii.

// AI generuje kompleksowe mocki
jest.mock('@/services/stripe', () => ({
  createPaymentIntent: jest.fn(),
  confirmPayment: jest.fn(),
  handleWebhook: jest.fn()
}));

describe('Przetwarzanie płatności', () => {
  beforeEach(() => {
    // Resetuj mocki między testami
    jest.clearAllMocks();
  });

  it('obsługuje błędy API Stripe z gracją', async () => {
    const stripeError = new Error('Karta odrzucona');
    stripeError.code = 'card_declined';

    createPaymentIntent.mockRejectedValueOnce(stripeError);

    // Testuj obsługę błędów...
  });
});

Wzorzec 2: Testowanie sterowane danymi

Agent: Utwórz testy sterowane danymi dla naszej logiki walidacji.
Testuj z różnymi kombinacjami input.

describe('Walidacja input', () => {
  const testCases = [
    { input: 'valid@email.com', expected: true, description: 'prawidłowy email' },
    { input: 'invalid.email', expected: false, description: 'brakujący @' },
    { input: '@example.com', expected: false, description: 'brakująca część lokalna' },
    { input: 'test@', expected: false, description: 'brakująca domena' },
    // AI generuje wiele więcej przypadków...
  ];

  testCases.forEach(({ input, expected, description }) => {
    it(`waliduje ${description}`, () => {
      expect(isValidEmail(input)).toBe(expected);
    });
  });
});

Testowanie wydajności i obciążenia

Agent: Utwórz testy wydajności dla naszych endpointów API.
Zmierz czasy odpowiedzi i zidentyfikuj wąskie gardła.

describe('Wydajność API', () => {
  it('odpowiada w ciągu 200ms dla listy użytkowników', async () => {
    const start = performance.now();
    const response = await request(app).get('/api/users');
    const duration = performance.now() - start;

    expect(response.status).toBe(200);
    expect(duration).toBeLessThan(200);
  });

  it('obsługuje 100 jednoczesnych żądań', async () => {
    const requests = Array(100).fill(null).map(() =>
      request(app).get('/api/users')
    );

    const responses = await Promise.all(requests);
    const successCount = responses.filter(r => r.status === 200).length;

    expect(successCount).toBeGreaterThan(95); // 95% wskaźnik sukcesu
  });
});

Bramy jakości i integracja CI

Automatyczne sprawdzenia jakości

Agent: Skonfiguruj bramy jakości które zapobiegają mergowaniu jeśli:
- Pokrycie testów spadnie poniżej 80%
- Jakiekolwiek testy zawodzą
- Benchmarki wydajności nie są spełnione

Najlepsze praktyki testowania wspomaganego przez AI

Testuj zachowanie, nie implementację

Skup się na tym co kod robi, nie jak to robi

Utrzymuj niezależność testów

Każdy test powinien działać w izolacji bez zależności

Używaj opisowych nazw

Nazwy testów powinny jasno opisywać co weryfikują

Trzymaj testy proste

Jedna asercja na test gdy możliwe

Rozwiązywanie problemów częstych problemów

Chwiejne testy

Problem: Testy przechodzą czasem, czasem zawodzą

Rozwiązanie:
Agent: Debuguj ten chwiejny test uruchamiając go 20 razy
i identyfikując co się różni między uruchomieniami.

Wolne testy

Problem: Pakiet testów trwa za długo

Rozwiązanie:
Agent: Profiluj nasz pakiet testów i zidentyfikuj
najwolniejsze testy. Zasugeruj optymalizacje.

Fałszywe pozytywy

Problem: Testy przechodzą ale funkcja jest zepsuta

Rozwiązanie:
Agent: Przejrzyj te testy i zidentyfikuj dlaczego nie
wykrywają faktycznego błędu. Wzmocnij asercje.

Następne kroki

Twoja gra testowania jest teraz transformowana pomocą AI:

1. Dąż do kompleksowego pokrycia - pozwól AI znajdować przypadki brzegowe
2. Automatyzuj wszystko - od testów jednostkowych po scenariusze E2E
3. Używaj testów jako dokumentacji - dobrze napisane testy wyjaśniają zachowanie
4. Integruj z CI/CD - automatyczne bramy jakości
5. Ciągle ulepszaj - AI pomaga utrzymywać i aktualizować testy

Wskazówka

Doskonałość testowania osiągnięta! 🎯
Z testowaniem wspomaganym przez AI możesz osiągnąć wyższe pokrycie, wychwycić więcej błędów przed produkcją i spędzić mniej czasu pisząc powtarzalny kod testowy. Twoja jakość kodu i pewność siebie będą rosnąć!