BBD Frame Work with Cucumber

 

What is Cucumber?

Cucumber is a testing tool that helps you write and run software tests. It follows a method called Behavior Driven Development (BDD). With Cucumber, you can write tests in plain English, so even people who are not technical can understand them.

What basic concepts must one know while working with Cucumber?

To work with Cucumber, you should know these basic concepts:

• Feature: A high-level description of a software feature you want to test.
• Scenario: A specific situation or test case for the feature.
• Step: An action or outcome in the scenario (like "Given," "When," and "Then").
• Background: Steps that are common to all scenarios in a feature.
• Gherkin: The language used to write Cucumber tests.

What is a scenario in Cucumber Testing?

A scenario in Cucumber is a single test case that describes a specific situation or use case for the software. Each scenario includes several steps that describe actions and expected outcomes. For example, a scenario might describe how a user logs into an application and what should happen when they enter the correct username and password.

What is a Scenario Outline in the Cucumber framework?

A Scenario Outline in Cucumber is used when you need to run the same test scenario multiple times with different sets of data. Instead of writing the same test steps over and over again, you use a Scenario Outline and provide different data sets in a table. Each row in the table represents a different test case.

What is a ‘feature’ in Cucumber?

A ‘feature’ in Cucumber is a high-level description of what a part of your software should do. It is written in a file called a feature file, which has a ".feature" extension. Each feature file contains one or more scenarios that describe different situations of how the feature should work. The feature file uses plain English, so everyone can understand it.

What are the Steps in the context of Cucumber?

In Cucumber, "steps" are individual actions or checks that you perform in a test scenario. Steps are written in plain English and are defined using keywords like "Given," "When," "Then," "And," and "But." Each step is connected to a piece of code called a "step definition" that performs the actual action or check described by the step.

What are annotations with respect to Cucumber?

Annotations in Cucumber are special keywords or symbols used in the step definition files to mark specific methods. They help Cucumber understand how to connect the steps written in the feature files with the corresponding code. Common annotations include:

• @Given: Marks a method that sets up a precondition.
• @When: Marks a method that performs an action.
• @Then: Marks a method that checks the outcome.
• @Before: Marks a method that runs before each scenario.
• @After: Marks a method that runs after each scenario.

What are hooks in Cucumber? How can they be used in Cucumber?

Hooks in Cucumber are blocks of code that run at specific points during the test execution cycle. They help manage setup and teardown tasks. You can use hooks to perform actions like opening a browser, setting up test data, or cleaning up after tests.

• @Before: Runs before each scenario. Used for setup tasks.
• @After: Runs after each scenario. Used for cleanup tasks.

What are tags in Cucumber, and why are they important?

Tags in Cucumber are labels that you can add to your scenarios or features to organize and control which tests to run. They are written with the "@" symbol followed by a tag name, like @smokeTest or @regression.

Tags are important because they allow you to:

• Filter tests: Run only a specific group of tests based on their tags.
• Organize tests: Categorize tests into different types (e.g., smoke tests, regression tests).
• Manage test execution: Include or exclude tests easily during test runs.

for example:

@smokeTest
Scenario: Verify user login
    Given the user is on the login page
    When the user enters valid credentials
    Then the user is redirected to the homepage    

What is a Dry Run in Cucumber?

A Dry Run in Cucumber is a special mode that checks if all the steps defined in the feature files have corresponding step definitions without actually running the tests. This helps identify any missing or unimplemented steps.

You can enable a dry run by setting the dryRun option to true in the Cucumber options. For example:

@RunWith(Cucumber.class)
@CucumberOptions(
    features = "src/test/resources/features",
    glue = "stepDefinitions",
    dryRun = true
)
public class TestRunner {
}                                                                                    

What are the various keywords used in the Cucumber tool for writing a scenario?
Cucumber uses several keywords in Gherkin to write scenarios. These keywords help to describe the behavior of the software:
Feature: Describes the feature under test.
Scenario: Defines a specific test case with a sequence of steps.
Given: Sets up the initial context or state before an action is taken.
When: Describes the action or event that triggers the test scenario.
Then: Specifies the expected outcome or result of the action.
And: Used to add more steps to Given, When, or Then.
But: Adds a condition to Given, When, or Then.
Background: Defines steps that are common to all scenarios in a feature file.
Scenario Outline: Used to run the same scenario with different sets of data.
Examples: Provides the data sets for a Scenario Outline.
What is the use of the Background keyword in Cucumber?
The Background keyword in Cucumber is used to define a set of steps that are common to all scenarios in a feature file. It helps avoid repetition by specifying steps that should be run before each scenario. The Background section runs before each scenario, ensuring that the scenarios start with a common context.
Example:
Feature: User Login
Background:
  Given the user is on the login page
Scenario: Successful login
  When the user enters valid credentials
  Then the user should be redirected to the homepage
Scenario: Unsuccessful login
  When the user enters invalid credentials
  Then the user should see an error message
What is the difference between a Background and a Scenario Outline in Cucumber?
Background:
Purpose: Used to define common steps that should be run before each scenario in a feature file.
Usage: Helps to avoid repetition by setting up a common context for all scenarios.
Placement: Placed at the beginning of a feature file, before any scenarios.
Example:
Feature: User Login

Background:
  Given the user is on the login page

Scenario: Successful login
  When the user enters valid credentials
  Then the user should be redirected to the homepage

Scenario: Unsuccessful login
  When the user enters invalid credentials
  Then the user should see an error message
Scenario Outline:
Purpose: Used to run the same scenario multiple times with different sets of data.
Usage: Helps to avoid duplication by defining a template for the scenario and providing multiple data sets.
Placement: Used within a feature file, with an Examples table to provide data sets.
Example:
Scenario Outline: User login
  Given the user is on the login page
  When the user enters "<username>" and "<password>"
  Then the user should see a "<message>"

  Examples:
    | username | password | message                                      |
    | user1          | pass1         | Welcome, user1!                          |
    | user2         | pass2         | Welcome, user2!                         |
    | user3         | wrong       | Invalid username or password |
 

How do you skip a scenario in Cucumber?
You can skip a scenario in Cucumber by using tags. By tagging a scenario with a specific tag (e.g., @skip), you can configure your test runner to exclude scenarios with that tag during execution.
Example:
@skip
Scenario: This scenario will be skipped
  Given some precondition
  When some action is taken
  Then some expected result is obtained

What is the difference between a feature and a scenario in Cucumber?
Feature:
Purpose: A feature describes a high-level behavior of the software or a particular functionality that is being tested.
Structure: Contains one or more scenarios.
Scope: Broad, covering an entire functionality.
Keyword: Starts with the keyword Feature.
Example:
Feature: User Login
  This feature allows users to log into the application.
Scenario:
Purpose: A scenario describes a specific situation or use case that needs to be tested within the feature.
Structure: Contains a sequence of steps (Given, When, Then) that define the actions and expected outcomes.
Scope: Narrow, focusing on a particular aspect of the feature.
Keyword: Starts with the keyword Scenario.
Example:
Scenario: Successful login with valid credentials
  Given the user is on the login page
  When the user enters valid username and password
  Then the user should be redirected to the homepage

What is the difference between a soft assertion and a hard assertion in Cucumber?
Soft Assertion:
Behavior: Continues executing the test even if the assertion fails, allowing multiple assertions to be checked within a single test.
Use Case: Useful for validating multiple conditions in a test scenario and reporting all failures at once.
Example: In Java, soft assertions can be implemented using libraries like softassert.
Example in Java:
SoftAssert softAssert = new SoftAssert();
softAssert.assertTrue(condition1, "Condition 1 failed");
softAssert.assertTrue(condition2, "Condition 2 failed");
softAssert.assertAll(); // Reports all assertion failures
Hard Assertion:
Behavior: Stops test execution immediately if the assertion fails, preventing any further steps or assertions from being executed.
Use Case: Useful for critical checks where subsequent steps depend on the success of the current assertion.
Example: In Java, hard assertions can be implemented using Assert class from JUnit or TestNG.
Example in Java:
Assert.assertTrue(condition1, "Condition 1 failed");
Assert.assertTrue(condition2, "Condition 2 failed"); // This will not be executed if condition1 fails