Why Cypress architecture (runs in browser)? - Purpose & Use Cases

The Big Idea

What if your tests could run inside the browser just like a real user, but without mistakes or delays?

The Scenario

Imagine you have to test a website by clicking buttons and checking results manually every time you make a small change.

You open the browser, click around, write notes, and repeat this for every feature.

The Problem

This manual way is slow and boring.

You might miss bugs because you forget steps or make mistakes.

It's hard to test many things quickly or often.

The Solution

Cypress runs tests inside the browser automatically.

It controls the website like a user but faster and without errors.

You write tests once, and Cypress repeats them perfectly every time.

Before vs After

✗ Before

Open browser -> Click button -> Check result -> Write notes

✓ After

cy.get('button').click(); cy.get('.result').should('contain', 'Success');

What It Enables

Automated browser tests that run fast, reliably, and show exactly what happens step-by-step.

Real Life Example

When a developer changes a website, Cypress tests run instantly in the browser to catch bugs before users see them.

Key Takeaways

Manual testing is slow and error-prone.

Cypress runs tests inside the browser automatically.

This makes testing faster, reliable, and easier to repeat.

Practice

1. What is a key feature of Cypress architecture regarding where tests run?

easy

A. Tests run on a cloud service without local browser access.

B. Tests run only on the server without browser interaction.

C. Tests run in a separate virtual machine outside the browser.

D. Tests run inside the browser, controlling the app like a real user.

Solution

1. Step 1: Understand Cypress test execution environment

   Cypress runs tests directly inside the browser, allowing it to control and observe the app as a user would.

2. Step 2: Compare with other options

   Other options describe architectures not used by Cypress, such as server-only or cloud-only test runs.

3. Final Answer:

   Tests run inside the browser, controlling the app like a real user. -> Option D

4. Quick Check:

   Cypress tests run in browser = A [OK]

Hint: Remember: Cypress tests run inside the browser environment [OK]

Common Mistakes:

• Thinking tests run only on the server
• Assuming tests run outside the browser
• Confusing Cypress with cloud-only test runners

2. Which of the following is the correct way to write a Cypress command to visit a webpage?

easy

A. cy.visit('https://example.com')

B. visit.cy('https://example.com')

C. cy.goTo('https://example.com')

D. browser.visit('https://example.com')

Solution

1. Step 1: Recall Cypress command syntax

   Cypress commands start with cy. followed by the command name, so cy.visit() is correct.

2. Step 2: Check other options for syntax errors

   Options A, B, and D use incorrect method names or object references not valid in Cypress.

3. Final Answer:

   cy.visit('https://example.com') -> Option A

4. Quick Check:

   Correct Cypress command syntax = C [OK]

Hint: Cypress commands always start with 'cy.' [OK]

Common Mistakes:

• Swapping method and object order
• Using non-existent Cypress commands
• Using browser object instead of cy

3. Given the following Cypress test code, what will be the output in the test runner?

describe('My Test', () => {
  it('checks page title', () => {
    cy.visit('https://example.cypress.io')
    cy.title().should('include', 'Kitchen')
  })
})

medium

A. Test throws a syntax error due to missing semicolons.

B. Test passes if the page title includes 'Kitchen'.

C. Test passes regardless of the page title content.

D. Test fails because cy.title() is not a valid command.

Solution

1. Step 1: Understand the test steps

   The test visits the Cypress example page and asserts the page title includes the word 'Kitchen'.

2. Step 2: Validate command correctness and assertion

   cy.title() is a valid Cypress command that gets the page title. The assertion should('include', 'Kitchen') checks if the title contains 'Kitchen'.

3. Final Answer:

   Test passes if the page title includes 'Kitchen'. -> Option B

4. Quick Check:

   cy.title() assertion success = D [OK]

Hint: cy.title() gets page title; check with should() [OK]

Common Mistakes:

• Thinking cy.title() is invalid
• Ignoring assertion logic
• Confusing syntax errors with missing semicolons

4. Identify the error in this Cypress test code snippet:

it('checks button click', () => {
  cy.visit('https://example.com')
  cy.get('#submit').click
})

medium

A. Incorrect selector syntax for cy.get().

B. cy.visit() should be inside beforeEach block.

C. Missing parentheses after click command.

D. Using cy.get() without chaining should() causes error.

Solution

1. Step 1: Review the click command usage

   The click command must be called as a function with parentheses: click().

2. Step 2: Check other parts of the code

   The selector #submit is valid, cy.visit() can be inside the test, and chaining should() is optional.

3. Final Answer:

   Missing parentheses after click command. -> Option C

4. Quick Check:

   click() needs parentheses = B [OK]

Hint: Always call commands like click() with parentheses [OK]

Common Mistakes:

• Forgetting parentheses on commands
• Misunderstanding selector syntax
• Thinking visit() must be in beforeEach

5. Why does Cypress run tests inside the browser instead of outside it, and what advantage does this provide?

hard

A. Running inside the browser allows Cypress to control the app like a user, making tests faster and easier to debug.

B. Running inside the browser reduces network traffic by avoiding server calls.

C. Running outside the browser is impossible due to browser security restrictions.

D. Running inside the browser enables tests to run without any JavaScript.

Solution

1. Step 1: Understand Cypress architecture purpose

   Cypress runs tests inside the browser to interact with the app as a real user would, giving precise control and observation.

2. Step 2: Identify benefits of this approach

   This approach makes tests fast, reliable, and easy to debug because Cypress can directly access the app's DOM and network.

3. Final Answer:

   Running inside the browser allows Cypress to control the app like a user, making tests faster and easier to debug. -> Option A

4. Quick Check:

   Browser test run = faster, easier debug = A [OK]

Hint: Tests inside browser = real user control + fast debugging [OK]

Common Mistakes:

• Thinking tests run outside browser for speed
• Confusing network traffic with test speed
• Believing tests run without JavaScript