Bird
Raised Fist0
Testing Fundamentalstesting~15 mins

When to automate vs manual test in Testing Fundamentals - Automation Approaches Compared

Choose your learning style10 modes available
Decide whether to automate or manually test a login feature
Preconditions (3)
Step 1: Open the login page in a browser
Step 2: Enter valid username 'user@example.com' in the username field
Step 3: Enter valid password 'Password123' in the password field
Step 4: Click the 'Login' button
Step 5: Observe if the user is redirected to the dashboard page
Step 6: Repeat the above steps with invalid credentials to check error message
Step 7: Consider if this test will be repeated often or needs quick feedback
Step 8: Decide if automating this test will save time and reduce human error
✅ Expected Result: User is successfully logged in with valid credentials and sees the dashboard page. With invalid credentials, an error message is shown. Decision made whether to automate based on test repetition and importance.
Automation Requirements - Selenium with Python
Assertions Needed:
Verify URL changes to dashboard page after login
Verify error message is displayed for invalid login
Best Practices:
Use explicit waits to handle page loading
Use clear and maintainable locators (id or name attributes)
Separate test logic from page element locators (Page Object Model)
Include assertions for both success and failure cases
Automated Solution
Testing Fundamentals
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
import unittest

class LoginTest(unittest.TestCase):
    def setUp(self):
        self.driver = webdriver.Chrome()
        self.driver.get('https://example.com/login')
        self.wait = WebDriverWait(self.driver, 10)

    def test_valid_login(self):
        driver = self.driver
        wait = self.wait
        driver.find_element(By.ID, 'username').send_keys('user@example.com')
        driver.find_element(By.ID, 'password').send_keys('Password123')
        driver.find_element(By.ID, 'login-button').click()
        wait.until(EC.url_contains('/dashboard'))
        self.assertIn('/dashboard', driver.current_url)

    def test_invalid_login(self):
        driver = self.driver
        wait = self.wait
        driver.get('https://example.com/login')
        driver.find_element(By.ID, 'username').send_keys('wronguser@example.com')
        driver.find_element(By.ID, 'password').send_keys('WrongPass')
        driver.find_element(By.ID, 'login-button').click()
        error = wait.until(EC.visibility_of_element_located((By.ID, 'error-message')))
        self.assertTrue(error.is_displayed())
        self.assertEqual(error.text, 'Invalid username or password.')

    def tearDown(self):
        self.driver.quit()

if __name__ == '__main__':
    unittest.main()

This script uses Selenium with Python's unittest framework to automate login tests.

In setUp, the browser opens the login page and sets an explicit wait.

The test_valid_login method enters valid credentials, clicks login, waits for the dashboard URL, and asserts the URL changed.

The test_invalid_login method enters wrong credentials, clicks login, waits for an error message, and asserts it is visible and correct.

Explicit waits ensure the test waits for page changes or elements before asserting.

Using IDs for locators keeps selectors simple and reliable.

The tearDown method closes the browser after each test.

This structure follows best practices for maintainability and clear assertions.

Common Mistakes - 4 Pitfalls
Using time.sleep() instead of explicit waits
Using brittle locators like absolute XPath
Not asserting both success and failure cases
Hardcoding test data inside test methods
Bonus Challenge

Now add data-driven testing with 3 different sets of login credentials (valid, invalid username, invalid password).

Show Hint

Practice

(1/5)
1. Which type of testing is best suited for repetitive tasks that rarely change?
easy
A. Manual testing
B. Automated testing
C. Exploratory testing
D. Ad-hoc testing

Solution

  1. Step 1: Understand the nature of repetitive tasks

    Repetitive tasks are those that happen often and have stable expected results.
  2. Step 2: Match testing type to task nature

    Automated testing is ideal for repetitive and stable tasks because it saves time and reduces human error.
  3. Final Answer:

    Automated testing -> Option B
  4. Quick Check:

    Repetitive tasks = Automated testing [OK]
Hint: Automate stable, repetitive tests to save time [OK]
Common Mistakes:
  • Choosing manual testing for repetitive tasks wastes time
  • Confusing exploratory testing with repetitive testing
  • Thinking ad-hoc testing fits repetitive tasks
2. Which of the following is the correct reason to choose manual testing over automation?
easy
A. When tests require human judgment and intuition
B. When tests are simple and can be scripted easily
C. When tests need to run overnight without interruption
D. When tests are repetitive and stable

Solution

  1. Step 1: Identify when human insight is needed

    Manual testing is best when tests require human judgment, such as usability or visual checks.
  2. Step 2: Compare options to manual testing needs

    When tests require human judgment and intuition matches the need for human intuition, unlike options A, B, and C which favor automation.
  3. Final Answer:

    When tests require human judgment and intuition -> Option A
  4. Quick Check:

    Human insight = Manual testing [OK]
Hint: Manual testing fits tasks needing human judgment [OK]
Common Mistakes:
  • Choosing manual for repetitive stable tests
  • Confusing automation needs with manual testing
  • Ignoring the role of human intuition
3. Consider this scenario: A test suite runs 100 tests daily. 80 tests are stable and repetitive, 20 are new features needing exploration. Which approach is best?
medium
A. Automate all 100 tests
B. Manually test all 100 tests
C. Automate the 80 stable tests and manually test the 20 new features
D. Manually test the 80 stable tests and automate the 20 new features

Solution

  1. Step 1: Analyze test types and their nature

    80 tests are stable and repetitive, suitable for automation; 20 are new and exploratory, better for manual testing.
  2. Step 2: Match testing approach to test types

    Automate stable tests to save time; manually test new features for human insight.
  3. Final Answer:

    Automate the 80 stable tests and manually test the 20 new features -> Option C
  4. Quick Check:

    Stable = automate, new = manual [OK]
Hint: Automate stable tests, manual for new features [OK]
Common Mistakes:
  • Automating new exploratory tests that change often
  • Manually testing all tests wastes time
  • Ignoring test stability when choosing method
4. A tester wrote automated scripts for a feature still under frequent change. What is the main problem with this approach?
medium
A. Scripts will require constant updates, wasting effort
B. Automated tests run faster
C. Manual testing is slower
D. Automation tools cannot test new features

Solution

  1. Step 1: Understand impact of frequent changes on automation

    When features change often, automated scripts break and need frequent fixes.
  2. Step 2: Identify the problem caused by frequent script updates

    Constant updates waste time and reduce automation benefits.
  3. Final Answer:

    Scripts will require constant updates, wasting effort -> Option A
  4. Quick Check:

    Frequent changes = costly automation maintenance [OK]
Hint: Avoid automating unstable features to save maintenance [OK]
Common Mistakes:
  • Thinking automation tools can't test new features
  • Confusing speed with suitability
  • Ignoring maintenance cost of automation
5. You manage testing for a complex app with frequent UI changes and critical backend logic. How should you balance automation and manual testing?
hard
A. Automate UI tests and manually test backend logic
B. Automate both UI and backend tests fully
C. Manually test both UI and backend tests fully
D. Manually test UI and automate backend logic tests

Solution

  1. Step 1: Analyze UI and backend characteristics

    UI changes frequently, making automation brittle; backend logic is stable and critical, suitable for automation.
  2. Step 2: Choose testing method per component

    Manual testing fits UI due to frequent changes and human insight; automate backend logic for reliability and speed.
  3. Final Answer:

    Manually test UI and automate backend logic tests -> Option D
  4. Quick Check:

    UI frequent changes = manual, backend stable = automate [OK]
Hint: Automate stable backend; manual test changing UI [OK]
Common Mistakes:
  • Automating frequently changing UI causing flaky tests
  • Manually testing stable backend wasting time
  • Ignoring test stability and criticality
Recommended

Ready to prove it?

Pass the test and this pattern moves unknown strong while earning +1 Grip toward your certificate.

10 questions~5 mineasy hard