Future-Proof Your Web Testing: KaneAI's 5-Phase Roadmap (+ Bonus Analytics Dashboard)
Transition from Manual to AI-Powered Web Testing
Table of contents
- Introduction to KaneAI
- Phase 1: Project Setup and Manual Testing
- Phase 2: Intelligent Test Planning and Execution
- Phase 3: Advanced Test Management and Version Control
- Phase 4: Accelerated Test Execution with HyperExecute
- Phase 5: Automated Testing and Continuous Integration
- Bonus: Analyzing KaneAI Tests with LambdaTest Analytics Dashboard - 360° Test Observability
- Summary
- Conclusion
In today’s fast-moving digital world, smooth and efficient web testing is essential. KaneAI brings a smart, AI-powered solution to make your testing process faster and easier.
Introduction to KaneAI
KaneAI is setting a new standard in software testing as the first complete end-to-end software testing agent. It uses advanced AI and Large Language Models (LLMs) to completely change how tests are created, debugged, and improved. With its inbuilt natural language interface, it simplifies the entire testing process, making it faster and easier to use for everyone, from beginners to experts.
Key Innovations of KaneAI include:
Test Generation & Evolution: Effortlessly create and modify tests using natural language inputs.
Multi-Language Export: Seamlessly convert your automated tests to all major programming languages and frameworks.
Intelligent Test Planner: Automatically generate and automate test steps from high-level objectives.
Smart Show-Me Mode: Transform your actions into natural language instructions for bullet-proof test creation.
Sophisticated Testing Capabilities: Express complex conditions and assertions using natural language.
This article will guide you through a comprehensive 5-phase approach to transform your web testing workflow using KaneAI:
Project Setup and Manual Testing / Create: Effortless Test Creation
Intelligent Test Planning and Execution / Manage: Plan and Organize Test Cases
Advanced Test Management and Version Control / Execute & Schedule: Run Tests on HyperExecute
Accelerated Test Execution with HyperExecute
Automated Testing and Continuous Integration
Don't feel overwhelmed!
We'll cover everything step by step in just 5 phases. Say goodbye to manual script writing!
For a visual overview of our journey, refer to this simple flow chart illustrating the phases we'll explore:
Now, let's dive into each phase and discover how KaneAI can revolutionize your web testing process.
Phase 1: Project Setup and Manual Testing
This phase establishes the foundation for organized and efficient testing by creating a structured environment and performing initial manual tests to understand the system's behavior. KaneAI's intuitive interface makes this process seamless, allowing you to set up your project quickly and start testing right away.
Setting Up Your Project Structure
KaneAI's Test Manager provides a user-friendly environment to organize your tests logically. Here's how to create a structured project:
Navigate to the Test Manager in KaneAI.
Create a new project folder structure:
Create a main folder called "Pre-built Workflows"
Inside it, create a sub-folder (test case folder) named "Payment Workflow"
Within "Payment Workflow," create another sub-folder named "Functional"
This structure helps organize your tests logically and makes them easy to manage as your test suite grows.
Integration with Issue Tracking (e.g., Jira)
To streamline your process from the start, KaneAI offers seamless integration with popular issue tracking systems. Here's how to set up Jira integration:
Create a Jira account if you don't already have one:
Click on "Get it free"
Follow the prompts to set up your account and create your first project
In the LambdaTest platform:
Navigate to https://integrations.lambdatest.com/
Look for the Jira integration and click on "Setup"
For Instance Type, you'll see two options: Cloud and Self Hosted. Select "Cloud"
Click "Authorize App", then "Accept" to allow LambdaTest to access your Jira account.
From the dropdown, select your Jira site and click "Proceed"
You should now see a Confirmation message, indicating successful integration
With this integration in place, you'll be able to create and link Jira issues directly from your KaneAI test cases, streamlining your bug reporting and tracking process.
Manual Testing and Test Creation
Before diving into automation, it’s really important to do some manual testing. This helps you understand how users will experience your app and spot any issues that might come up. KaneAI provides several ways to get started with your testing:
AI-Powered Test Generation:
-
From the KaneAI home screen, you can write a prompt describing your test scenario.
KaneAI will use its natural language processing capabilities to evolve and identify the next steps automatically.
This is ideal for complex scenarios where you want AI assistance in test case design.
-
OR
-
These pre-built recommendations from kaneAI are tailored to help you explore and understand how the platform functions for various specific use cases.
Manual Interaction Mode:
In the Web Agent, click on "Virtual View Manual Interaction Mode"
This allows you to perform manual interactions with the website
KaneAI will automatically note the steps you take, which can then be used to create automated tests
Test Creation:
-
Click on "Create a Web Test" to open the Web Agent.
In the Web Agent, you can enter test steps and watch them being performed in a virtual environment.
This approach gives you fine-grained control over each step of your test.
-
For our example, let's use this approach to create a test for a payment workflow on a demo website.
Phase 2: Intelligent Test Planning and Execution
In this phase, we'll leverage KaneAI's intelligent test planning capabilities to create and execute our first AI-assisted test cases. KaneAI's natural language processing allows you to describe test scenarios in plain English, which it then translates into executable test steps.
Creating Your First Test Case
KaneAI's Web Agent provides an intuitive interface for creating test cases using natural language. Here's how to create your first test:
In the Web Agent, enter the following steps one by one:
1. Open https://easebuzz.in/demo/
2. Click on the 'Hosted' option
3. Select 'Credit Card'
4. Select 'UPI'
5. Select 'Netbanking'
6. Click the 'Pay' button
7. Verify the Unsuccessful Transaction Page
8. Click the 'Retry' button
As you enter each step, the Web Agent will perform the action in the virtual environment, allowing you to verify the test flow visually.
Saving and Managing Your Test Case
Once you've created your test case, it's important to save and organize it properly:
After creating your test, save it in the "Functional" folder within your "Pre-built Workflows" > "Payment Workflow" project structure.
Navigate to the Test Manager to view your saved test case.
Phase 3: Advanced Test Management and Version Control
KaneAI's Test Manager offers a comprehensive suite of tools for managing and versioning your tests. This phase focuses on utilizing these advanced features to maintain and evolve your test suite efficiently.
In the Test Manager, you'll find several important sections:
Summary: Provides an overview of your test case.
Code: Shows the generated code for your test. Here you can also access the HyperExecute feature.
Runs: Displays a history of test executions.
Issues: Tracks any problems discovered during testing.
Version History: This spotlight feature allows you to track changes to your test case over time.
Leveraging Version History
The Version History feature is particularly valuable as you evolve your test cases:
If you make updates to your test case that cause errors, you can easily revert to previous commits.
This feature provides a safety net, allowing you to experiment with test improvements without fear of breaking existing functionality.
Code Section
In the Code section, you'll find the generated code for your test case. This is where you can:
View the underlying code that KaneAI has created based on your test steps.
Make manual adjustments to the code if needed (for advanced users).
Access the HyperExecute feature to run your tests at scale.
Exporting KaneAI Tests
While KaneAI's built-in execution environment is powerful, there might be times when you want to run your tests in your own environment or integrate them into existing test suites. KaneAI makes this easy with its test export feature.
Here's how to export your KaneAI tests:
In the Test Manager, select the test case you want to export
Navigate to the "Code" tab
You'll see a list of files that make up your test, including:
test.py: The main test script
UIActions.py: Helper functions for interacting with web elements
requirements.txt: List of necessary Python packages
operations_meta_data.py: Additional metadata about the test
Click the "Export" button to download all these files as a zip archive
Once you have these files, you can:
Integrate them into your existing Python-based test framework
Run the tests using tools like pytest
Modify or extend the tests as needed for your specific environment
This flexibility allows you to leverage KaneAI's powerful test generation capabilities while maintaining control over your test execution environment.
Phase 4: Accelerated Test Execution with HyperExecute
HyperExecute is a powerful feature of KaneAI that allows you to run your tests across a wide range of browsers, operating systems, and devices at unprecedented speeds. This phase focuses on leveraging HyperExecute to accelerate your test execution and expand your test coverage.
Run generated tests across 3000+ combinations of browsers, OS and real devices.
Single click test scheduling using seamless integration with HyperExecute. Run your tests in the most efficient manner.
To take your testing to the next level, use the HyperExecute feature:
From the Test Manager, click the HyperExecute button in the Code section.
This takes you to the HyperExecute section, where you'll find:
Summary of job duration, test duration, and execution time
Detailed logs for setup, pre-steps, scenarios, and post-steps
YAML configuration, artifacts, and comprehensive reports
Exploring Test Scenarios
The Scenarios section in HyperExecute provides a detailed view of your test execution:
In the Scenarios section:
You'll see your test case (e.g., Test_Payment_Methods_TC-1)
Click the "View Test" button to dive deeper into the execution details
Phase 5: Automated Testing and Continuous Integration
In this final phase, we'll explore how to integrate KaneAI into your continuous testing workflow, ensuring ongoing quality assurance. KaneAI's automation capabilities and integrations make it easy to incorporate your tests into your CI/CD pipeline.
Automations Dashboard
The Automations Dashboard provides a comprehensive view of your test executions and results:
From the HyperExecute section, navigate to the Automations Dashboard:
Here you'll find a video replay of your test execution
Detailed information about the test run, including:
Time taken
Browser and OS configurations
Test status (passed/failed)
Advanced Analysis Tools
The Automations Dashboard offers several tabs for in-depth analysis, providing a comprehensive view of your test performance:
All Commands: View a detailed list of all commands executed during the test run.
Logs: Access detailed logs for troubleshooting and debugging.
Network: Analyze network traffic and requests made during the test.
Meta Data: Review additional information about the test execution environment.
Performance (with Lighthouse integration): Gain insights into your application's performance metrics.
Smart UI: Utilize AI-powered visual testing capabilities.
Accessibility: Assess your application's compliance with accessibility standards.
These tools provide essential and deep insights into your test execution, enabling quick identification and resolution of issues.
Utilizing the Jira Integration
KaneAI's integration with Jira streamlines the process of creating and tracking issues discovered during testing. Here's how to use this feature:
Click the three dots in the automations dashboard.
Select "Create Issue."
Choose Jira from your integration list.
Enter your issue details and click "Create Issue."
Afterwards, go to your Jira dashboard, and you will see the newly created issue.
This integration ensures that issues created during testing are immediately created and tracked in your project management system.
Returning to Test Manager
To view more details about your test:
Click on the test case ID (e.g., #tc01) in the Automations Dashboard.
This will take you back to the Test Manager, where you'll see:
Test details
Execution history
Issues (Integrated with Jira)
The Test Manager serves as your central hub for managing and analyzing your test cases.
Additional Test Creation Options
KaneAI offers multiple approaches to test creation, catering to different testing methodologies and preferences:
Templates: Pre-built test scenarios for common workflows.
Manual Test Steps: Write classical text-based steps with actions and corresponding outcomes. KaneAI can generate these for you.
BDD Scenarios: Write Behavior Driven Development scenarios in Gherkin syntax.
These options provide flexibility in how you approach test creation, allowing you to choose the method that best fits your team's workflow and expertise.
To create a test case using Manual Test Steps:
Start with an empty project and click "Add Test Case".
-
Adding a test case, you can also generate using AI. It will just give you a sample with the respective folder name.
Name your test case (e.g., "Test the login functionality with correct username and password").
Go to the created Test Case.
In the Templates dropdown, select "Manual Test Steps".
You can now either:
Write your own steps manually, or
Press Tab to let KaneAI generate steps based on your test case name.
Once your steps are in place, you can click "Automate with KaneAI" to let KaneAI perform those steps
This approach allows you to quickly create structured test cases and optionally automate them with KaneAI.
Bonus: Analyzing KaneAI Tests with LambdaTest Analytics Dashboard - 360° Test Observability
To gain deeper insights into the tests you've created and executed with KaneAI, you can leverage the powerful analytics dashboard provided by LambdaTest. This integration lets you view and analyze your KaneAI test results within the wider scope of your testing ecosystem. Here's how to maximize this feature:
Access the LambdaTest Analytics Dashboard:
- After running your KaneAI tests, navigate to the Analytics Dashboard within the LambdaTest platform. This dashboard serves as your central hub for visualizing test data and metrics across your entire testing suite, including tests generated by KaneAI.
Creating a New Dashboard for KaneAI Tests:
- Click on "Create New" to begin. You'll see two options:
Pre-built Templates: Quickly create dashboards using pre-configured widget sets, allowing you to apply filters specifically to your KaneAI test reports.
Custom Widgets: Design tailored dashboards by selecting and arranging widgets that best represent your KaneAI test metrics alongside other tests.
Setting Up a Dashboard for KaneAI Tests
- For this example, we’ll use a pre-built template to easily spotlight your KaneAI test results:
Choose "HyperExecute" from the template options.
Select the checkbox for the test name you created with KaneAI (e.g., "Payment Workflow").
Fill in any additional details as needed.
Click "Create" to generate your dashboard.
Exploring Your KaneAI Test Results The pre-built template dashboard now displays data specific to your KaneAI-generated tests within the LambdaTest ecosystem. This provides several benefits:
Holistic View: See how your KaneAI tests perform in comparison to other tests in your suite.
Performance Metrics: Analyze execution times, success rates, and other key performance indicators specific to your AI-generated tests.
Resource Utilization: Understand how efficiently your KaneAI tests are utilizing the HyperExecute platform.
Customizing Your KaneAI Test Dashboard While the pre-built template offers a great starting point, you can further tailor it to highlight KaneAI-specific insights:
Add Widgets: Incorporate additional widgets that focus on metrics most relevant to your KaneAI tests.
Apply Filters: Narrow down your view to specific KaneAI test suites or scenarios.
Arrange Layout: Organize your widgets to prioritize the most critical information for evaluating your KaneAI test performance.
Export Dashboard: Download your dashboard as a PDF for offline analysis or sharing.
By utilizing LambdaTest's Analytics Dashboard in connection with your KaneAI workflow, you're adding a powerful analytical tool to your testing process. This integration allows you to not only visualize the results of your AI-generated tests but also compare them with your broader testing efforts, providing comprehensive insights to continuously improve your overall testing strategy.
Summary
Our journey through KaneAI's 5-phase approach has showcased a transformative path for web testing:
We began by setting up our project structure and performing initial manual tests, laying a solid foundation for our testing process.
Next, we utilized KaneAI's intelligent test planning capabilities, creating and executing our first AI-assisted test cases. Using KaneAI from LambdaTest, we explored its powerful features for more efficient and intelligent testing.
We then delved into advanced test management features, including version control, which allows for flexible and iterative test development.
The power of HyperExecute was demonstrated, showing how we can dramatically accelerate our test execution.
Finally, we integrated our KaneAI tests into a continuous testing workflow, ensuring ongoing quality assurance.
Conclusion
KaneAI represents a big jump forward in web testing technology. By utilising AI and natural language processing, it simplifies the test creation process, accelerates execution, and provides deep insights into your application's performance. The integration with LambdaTest's broader ecosystem further improves its capabilities, offering a all-in-one solution for modern web testing challenges.
For more usage scenarios and examples of KaneAI's capabilities, please refer to my Google Doc. There you'll find a wide range of amazing example scenarios covering various testing situations and application types.
If this post was helpful, share it with others. For more on AI-driven testing, join the Slack community.
Thank you for reading!
- Do find my socials here : https://linktr.ee/muhammadnoorani
For more information, refer to this Getting Started docs.
Learn more about KaneAI and SignUp for Beta