In the latest Selenium guides, our enlightenment about automation testing utilizing Cucumber and Selenium instruments has deepened. Additionally, we explored the interplay between Selenium WebDriver and Cucumber.
This guide will examine different factors that influence effort estimation in Selenium automation.
Recommended IPTV Service Providers
- IPTVGREAT – Rating 4.8/5 ( 600+ Reviews )
- IPTVRESALE – Rating 5/5 ( 200+ Reviews )
- IPTVGANG – Rating 4.7/5 ( 1200+ Reviews )
- IPTVUNLOCK – Rating 5/5 ( 65 Reviews )
- IPTVFOLLOW -Rating 5/5 ( 48 Reviews )
- IPTVTOPS – Rating 5/5 ( 43 Reviews )
In the realm of software development, both planning and estimation are crucial stages in the lifecycle.
Personally, in the context of software industry, there is an obvious lack of robust methods when it comes to task completion. Considering the unique complexities and environmental variables of each project, implementation of estimation and planning strategies demands collective actions from individual teams, with essential guidance from senior members and management support.
Before embarking on an estimation for any project, it is vitally important to understand all the stages contained within that project, this will enable you to produce accurate and justified estimations.
Estimation is not only applicable to manual testing, but also holds true for automation testing in the current technological landscape. With Selenium’s growing prominence and popularity in the market, I aim to highlight some factors to bear in mind while estimating a Selenium project.
Let’s dive in!
Assume that automation initiative begins from the ground up, without any pre-existing framework.
What You Will Learn:
Factors influencing estimation of Selenium automation
The various facets influencing and to be considered during the estimation of a “Selenium” particular project are detailed below:
#1 Scope of the Project
Scope entails pinpointing the appropriate test cases for automation. Implement a “Divide and Conquer” methodology to achieve this. Break apart the application into smaller components and scrutinize each component to determine the optimal test cases for automation.
The involved steps are:
- Identify the factors used in selecting the candidate test cases.
- Segment the application into smaller components.
- Inspect each component to identify the candidate test cases.
- Compute the Return on Investment (ROI).
For additional details on correctly choosing test cases, please refer to my preceding publication: Choosing the Correct Test Cases for Automation
#2 Complexity of the Application
The steps engaged in assessing application complexity are:
- Calculate the application’s size according to the number of test cases necessitating automation.
- Evaluate complexity using Fibonacci series.
- Identify the verification points and checkpoints for each test case.
It’s critical to establish definitions for small, medium, and large applications. These definitions may differ based on an individual’s or team’s point of view. The categorization of applications as small, medium, or large can also be guided by the volume of test cases. In some cases, automating 1500 test cases may be seen as small or medium in scale. Therefore, the precise number of test cases is pivotal to estimation.
Consider the disparate checkpoints and verification points for your test cases. A single test case may have multiple checkpoints but only a solitary verification point. If a test case contains multiple verification points, it is advised to partition it into separate test cases. This method streamlines maintenance and uplifts the test suite.
#3 Utilization of Supporting Tools/Technologies
The involved steps are:
- Identify the framework and automation requirements.
- Analyze and select the suitable tools based on these requirements.
- Identify any dependencies or implications related to the use of these tools.
Selenium alone is not capable of building a complete framework or finishing the automation process. Although Selenium (Web driver) is used for scripting the test case, additional tasks like result reporting, log tracking, and capturing of screenshots necessitate the use of extra tools. It’s important to identify those supportive tools that ideally meet your needs and contribute to favorable Return On Investment (ROI).
#4 Framework Deployment
The steps encompassed in this stage are:
- Identify the input (data feeding pattern) and output (reports/test results) of your automation suite.
- Design the input files, which might vary from simple text files to complex Excel sheets containing the test data.
- Formulate the folder structure based on input parameters.
- Deploy the reporting feature using tools like ReportNG or Excel files.
- Implement logging within the framework.
- Implement the chosen build tool within the framework.
- Implement the selected unit test framework (like JUnit or TestNG).
In addition to scripting test automation with Selenium, other necessities such as reading data from files, result reporting, log tracking, and conditional script execution require a durable framework. The makeup of your framework is crucial as it ensures all these elements are effectively integrated. It’s noteworthy to realize that Selenium is not an autonomous tool but a group of jar files that mandate integration with external tools to compose a comprehensive framework.
It’s vital to appreciate that in Selenium, everything necessitates being coded, and time should be allocated for troubleshooting by searching for errors on the internet.
Constructing the framework is the most significant facet of your automation endeavor. A sturdy framework eases maintenance and enhancements, particularly in the Agile era, accommodating the integration of tests in all sprints.
It’s safe to state that the design of the framework should be the most pivotal factor in estimation. If required (primarily for intricate applications), this factor should be broken down further into a standalone Work Breakdown Structure (WBS) for precise estimation.
#5 Education & Training
Learning Selenium differs from learning other automation tools as it involves getting adept at a programming language rather than simply a scripting language. Even though scripting languages assist in framework development, understanding core Java lays a concrete foundation for Selenium automation.
In addition to mastering Java, acquiring knowledge about other technologies such as Ant/Maven (for building), TestNG/JUnit (unit test frameworks), Log4J (for logging), and reporting tools is crucial. The intricacy of this list might vary based on the complexity of your framework. The lengthier the list, the more time it demands to learn and assimilate these technologies.
If the management has chosen to adopt Selenium, learning activities can be carried out concurrently with the planning phase. Due to the boundless learning potential of these technologies, it’s advised to develop a definitive learning plan (syllabus) for the team. This ensures a systematic learning approach and ensures everyone is on the same wavelength.
In reality, testers may not possess an eager interest in in-depth programming languages, commonly perceiving them as a developer’s territory. Nonetheless, this mentality needs to evolve. Learning a programming language is equally important as learning new testing techniques. It not only boosts a tester’s familiarity with language and automation but also grants a more comprehensive understanding of how applications operate internally, broadening their ability to unveil new bugs.
#6 Setting Up the Environment
Setting up the environment encompasses tasks like:
- Configuring the code in the test and production environments.
- Scripting for triggering automated tests.
- Formulating reporting logic.
- Determining the frequency and implementation logic of test script executions.
- Creating text/Excel files for test data and cases.
- Creating property files for environment tracking and storing credentials.
#7 Coding/Scripting and Assessment
Before commencing with testification, two prerequisites must be satisfied:
- Availability of potential test cases.
- Completed framework.
Identify the actions executed by your web application. These actions can range from simple navigation, clicking, and text entry to more complicated tasks such as establishing connections to databases or dealing with Flash or Ajax. Tackle one test case at a time, identify its corresponding actions, and estimate the hours needed per test case. The sum of hours for all test cases within the suite presents the overall estimation.
Make allowances for code reviews. Code reviews can either be conducted by peers or developers. Pair programming is the most efficient and rapid option, but if it’s not feasible, allocate hours based on available resources or your organization’s review approach.
For a more thorough understanding of each factor affecting estimation:
Factor #1: Scope of the Project
Definition: Recognizing candidate test cases for automation based on Return on Investment (ROI).
Involved Steps:
- Identify the factors used to select candidate test cases.
- Segment the application into smaller components.
- Examine each component to ascertain candidate test cases.
- Calculate the ROI.
Deliverable: List of test cases for automation.
Comments: Ensure that the project scope is finalized before proceeding with other estimation steps.
Factor #2: Complexity of the Application
Definition: Determining the complexity level of the application.
Involved Steps:
- Estimate the application’s size based on the number of test cases to be automated.
- Assess complexity using the Fibonacci series.
- Identify the verification points and checkpoints for each test case.
Deliverable:
- Application size categorization (small, medium, large).
- Count of test cases and their corresponding checkpoints and verification points.
Comments: Recommended – Each test case should have a single verification point and can have multiple checkpoints. If a test case contains multiple verification points, it should be split into separate test cases.
Factor #3: Supporting Tools/Technologies
Definition: Choosing requisite tools for building the framework.
Involved Steps:
- Confirm the Integrated Development Environment (IDE).
- Settle on the unit test tool.
- Decide on the logger.
- Agree on the reporting tool.
- Establish the build tool.
Deliverable: List of required tools for framework creation.
Comments:
Examples include:
- Eclipse/RAD as the IDE.
- Ant/Maven as the build tool.
- jUnit/TestNG as the unit test framework.
- Log4j as the logger.
- ReportiNG as the reporting tool.
- Text/Excel files for environment/credential tracking.
- Perl/Python for environment setup and triggering of test scripts.
Factor #4: Framework Deployment
Definition: Constructing the framework structure.
Involved Steps:
- Design the input files.
- Formulate the folder structure.
- Integrate the logger in the framework.
- Integrate the build tool in the framework.
- Integrate the unit test framework in the framework.
Deliverable:
- Framework and folder structure created in the IDE.
- Excel sheets loaded with test data.
- Property files loaded with environment-related data and credentials.
Comments: Incorporate buffer time in the estimation as potential troubleshooting time could exceed expectations.
Factor #5: Education & Training
Definition: Acquiring knowledge about a programming language and additional technologies.
Involved Steps: Devise a plan according to your automation needs, disseminate it among the team, and motivate them to independently adhere to the syllabus to progress in their learning.
Deliverable: Training plan and its progress tracker.
Comments: Emphasize the development of logical thinking over familiarity with syntax.
Factor #6: Setting Up the Environment
Definition: Configuring code deployment in designated environments.
Involved Steps:
- Prepare input files and reporting logic.
- Create the test script triggering mechanism.
Deliverable: Functioning environment.
Comments: The framework should be designed for hassle-free code deployment in the specified environment/box with minimal text file entries (containing URL and credentials), enabling smooth execution.
Factor #7: Coding/Scripting and Assessment
Definition: Scripting test scripts and conducting code reviews.
Steps Involved:
- Ensure the presence of potential test cases and a completed framework.
- Transform test cases into automated scripts and keep track of progress.
Deliverable: Automated test scripts.
Comments: Encourage the participation of the entire team in test script development using the implemented framework. Include the efforts of the entire team when estimating.
Concluding Remarks:
Having considered all these facets, do not neglect to encompass management overhead and buffer time in your ultimate Selenium automation estimation. The most efficient and tried-and-tested approach to estimation uses the Work Breakdown Structure (WBS) methodology. This simple strategy adequately fulfills the purpose of automation estimation.
The factors mentioned are based on my experience, however, other factors could also potentially impact your approach.
The cardinal rule here is to “identify criteria, divide modules or test cases based on those criteria, and scale it.” Precise estimation can then be obtained using the scaled figure.
Upcoming Tutorial #33: Wrapping up our series of comprehensive, free Selenium online training guides with “Selenium Testing Interview Questions with Answers.”
Feel free to share any supplementary tips for Selenium project effort estimation.