Breaking Hardware Testing Barriers: Plume’s Journey with Requestly’s API Mocking
Introduction
When dealing with hardware-dependent products, testing new features can become a logistical nightmare. For Plume — A leader in smart home and Wi-Fi optimization solutions — this was a daily challenge. Replicating complex, real-world environments for testing was both time-consuming and costly. That is, until they discovered Requestly.
The Challenge: Complex Testing in a Hardware-Dependent Ecosystem
Replicating Real-Life Environments
Plume’s innovative solutions rely heavily on a diverse range of physical devices with varying capabilities. Setting up test environments meant configuring multiple devices like Wi-Fi routers. Each device required specific firmware versions, network configurations, and sometimes unique hardware setups. Preparing these environments could take hours or even days.
The complexity of physical setups made it difficult to replicate real-life environments accurately and efficiently and also required high Operational Costs in acquiring and maintaining a fleet of devices.
Handling Diverse Device Capabilities and GraphQL APIs
Devices differed in processing power, memory, and supported protocols. Testing had to account for various firmware capabilities. Additionally, Plume’s backend services extensively use GraphQL APIs, adding another layer of complexity.
Before Requestly: Charles Proxy and Custom Code
Before adopting Requestly, Plume relied on Charles Proxy and custom code.
Charles Proxy
The user interface of Charles Proxy was not intuitive, making it hard for team members to use it effectively. It lacked modern features like searchable rule lists and conditional breakpoints.
Lack of GraphQL Support
Charles Proxy lacked specialized features for GraphQL, making it less straightforward to target and modify specific GraphQL operations. Without the ability to filter based on operationName or other GraphQL-specific attributes, targeting precise modifications was challenging.
Complex SSL Handling
Handling HTTPS traffic with Charles Proxy required manual installation and trust of SSL certificates, which was cumbersome and could conflict with VPNs. The complexity increased when dealing with secure environments, adding friction to the testing process.
Requestly over Charles Proxy
Though the Plume team initially used a licensed version of Charles Proxy, they found Requestly’s user interface to be more intuitive and advanced. Requestly offered specialized support for GraphQL, making it easier to manage and modify GraphQL requests, which enhanced their testing experience significantly.
Requestly lightyears ahead of Charles, very intuitive and mordern.
Writing Custom Code
Creating scripts or applications to mock API responses required significant effort. Developers had to write and maintain custom HTTP servers or middleware. Scripts were often tailored to specific scenarios and not easily adaptable due to hard-coded values and configurations.
Sharing and maintaining code across the team was cumbersome, with version control conflicts and dependency management issues arising frequently.
Requestly saves at least an hour of developer time in writing code to simulate a unique scenario.
The Solution: Requestly
Requestly offered a comprehensive suite of features that addressed Plume’s challenges head-on.
Modify API Response: Mimicking Without the Hardware
With Requestly’s Modify API Response feature, Plume could intercept and modify API responses in real time. They used Requestly’s ability to match API endpoints and replace or edit the JSON payloads.
They created rule sets that mimicked various hardware specifications by altering response attributes like deviceType, firmwareVersion, and supportedFeatures.
GraphQL Specific Features
One of the standout benefits was Requestly’s dedicated support for GraphQL APIs. Plume could target specific operations by filtering based on operationName or other request payload attributes. It allowed the team to simulate different backend conditions and test various client-side behaviors without changing the server code.
Simplified SSL Handling
Requestly’s browser extension eliminated the need for complex SSL configurations, leveraging browser APIs to intercept and modify traffic. This ensured compatibility with VPNs and secure environments. The team no longer had to install and trust SSL certificates manually, reducing setup time and avoiding conflicts with secure networks.
Requestly gives us the ability to create an environment without having to build an environment.
One-Click feature Flagging
Before using Requestly, Plume relied on Google Firebase’s feature flagging to test specific features. However, the process was time-consuming and required changes to both the code and the database.
With Requestly, Plume has moved to a much simpler, one-click approach to feature flagging. Using Requestly’s “Modify API Response” rule, the team can now easily enable or disable features for testing, all without touching the code or database. This shift has made testing faster, smoother, and more efficient for the team
Collaborative Testing with Workspaces
With Requestly’s Workspaces, Plume streamlined collaborative testing by allowing team members to manage rules together. Everyone could access, edit, and update rules in real time, with changes instantly visible to the entire team. This setup enabled the team to work on projects with specific rule sets effortlessly, without the need to manually copy or import rules individually.
Seamless Integration into Existing Workflows
Operating directly within Chrome as a browser extension, Requestly required no additional software. Rules were applied immediately without restarting the browser or application.
Advanced Testing with Delay and Cancel Rules
Delay Rule
The Delay Rule helped Plume simulate network latency by introducing artificial delays to API responses. They configured delay durations in milliseconds for specific endpoints, to see and test how a system responds to network delay
Cancel Rule
By using the Cancel Rule, Plume could block API calls and prevent certain requests from reaching the server. This allowed them to block and test certain features for specific devices.
Accelerator Program Partner
Requestly offered Plume a generous 3-month trial with full access to all its features. This allowed the Plume team to thoroughly test how Requestly fit into their day-to-day workflow, from setup to usage, helping them see the value it could bring to their processes. This trial period played an essential role in making the team comfortable with the tool, leading to a smoother and more confident adoption.
Responsive Support and Continuous Improvement
Knowing that the Requestly team is responsive gave Plume confidence in relying on their tool. Regular updates introduced new features and enhancements based on user feedback. Access to documentation, tutorials, and responsive customer support ensured quick resolution of issues and assistance with complex use cases.
Conclusion: A New Era in Testing for Plume
Requestly redefined Plume’s testing — eliminated the need for a physical environment, boosting quality, and freeing up resources for innovation, all while seamlessly integrating into their agile workflow.
Contents
- Introduction
- The Challenge: Complex Testing in a Hardware-Dependent Ecosystem
- Replicating Real-Life Environments
- Handling Diverse Device Capabilities and GraphQL APIs
- Before Requestly: Charles Proxy and Custom Code
- Charles Proxy
- Lack of GraphQL Support
- Complex SSL Handling
- The Solution: Requestly
- Modify API Response: Mimicking Without the Hardware
- GraphQL Specific Features
- Simplified SSL Handling
- One-Click feature Flagging
- Collaborative Testing with Workspaces
- Seamless Integration into Existing Workflows
- Advanced Testing with Delay and Cancel Rules
- Delay Rule
- Cancel Rule
- Accelerator Program Partner
- Responsive Support and Continuous Improvement
- Conclusion: A New Era in Testing for Plume
Subscribe for latest updates
Share this article
Related posts
