feat: final revamp

Signed-off-by: Animesh Pathak <[email protected]>

Author: Sonichigo

src/css/custom.css

@@ -6,7 +6,7 @@
   /* Hotfix: Changed primary color to black to resolve conflict with Docusaurus' default primary orange after disabling Tailwind preflight CSS. Added font size and line height adjustments to compensate for the removal of Tailwind preflight. */
 
   /* --ifm-color-primary-lighter: #ffb575; */
-  font-size:18px;
+  font-size:14px;
   line-height: 1.6;
   --ifm-color-primary: #000;
   --ifm-color-primary-lighter: #FFF;

versioned_docs/version-2.0.0/concepts/reference/glossary/behaviour-driven-development.md

@@ -1,15 +1,24 @@
 ---
 id: behaviour-driven-development
-title: What is Behavior Driven Development (BDD)?
+title: "Behavior Driven Development : Beginner's Guide to Collaboration"
 sidebar_label: Behaviour Driven Development
-description: Collaborative approach aligning software development with business goals through clear, readable test scenarios.
+description: Learn how BDD bridges the gap between developers, testers, and business stakeholders with practical examples, tools, and techniques.
+seoTitle: "Behavior Driven Development : Beginner's Guide to Collaboration"
+seoDescription: Learn how BDD bridges the gap between developers, testers, and business stakeholders with practical examples, tools, and techniques.
 tags:
   - explanation
   - Glossary
 keywords:
   - API
   - BDD
   - Behavior Driven Development
+  - Behavior Driven Development Tools
+  - BDD Testing Tools
+  - Behavior Driven Testing
+  - Test Automation
+  - Software Testing
+  - Software Testing Best Practices
+  - Test Automation
 ---
 
 Behavior-driven development (BDD) is an Agile software development methodology that encourages collaboration between developers, testers, and business stakeholders. BDD is based on the idea that the best way to ensure that software meets the needs of its users is to write tests that describe the desired behavior of the software in plain language.
@@ -136,17 +145,17 @@ One of the core practices in BDD is the creation of automated tests based on the
 
 Here are some of the popular BDD automation tools:
 
-1. **Cucumber:** [Cucumber](https://github.com/cucumber/cucumber-js) is a free and open-source BDD tool that uses the Gherkin syntax for writing test cases in plain English. It can be programmed in several languages, including Java, Ruby, and JavaScript.
+1. **Cucumber:** Cucumber is a free and open-source BDD tool that uses the Gherkin syntax for writing test cases in plain English. It can be programmed in several languages, including Java, Ruby, and JavaScript. Learn how to implement BDD with tools like Cucumber - [read now](https://keploy.io/blog/community/bdd-testing-with-cucumber)!
 
 2. **Behave:** Behave is a behavior-driven testing tool written in Python that supports the Gherkin syntax and can be used in tandem with other testing frameworks like Pytest and Unittest.
 
 3. **JBehave:** JBehave is a Gherkin-based, Java-based BDD tool that supports many testing frameworks, including JUnit and TestNG.
 
-4. **SpecFlow:** [SpecFlow](https://github.com/SpecFlowOSS/SpecFlow) is a BDD tool that interfaces with Microsoft Studio and other .NET tools and employs the Gherkin syntax for writing specifications. It can be programmed in C# and Visual Basic, among other languages.
+4. **SpecFlow:** SpecFlowis a BDD tool that interfaces with Microsoft Studio and other .NET tools and employs the Gherkin syntax for writing specifications. It can be programmed in C# and Visual Basic, among other languages.
 
 5. **Gauge:** Gauge is an open-source BDD tool that employs a markdown-based syntax to describe tests. It can be programmed in Java, Ruby, and Python, among others.
 
-6. **Reqnroll:** [Reqnroll](https://github.com/reqnroll/Reqnroll) is an open-source Cucumber-style BDD test automation framework for .NET.
+6. **Reqnroll:** Reqnroll is an open-source Cucumber-style BDD test automation framework for .NET.
 
 These tools can help to streamline the testing process and improve communication between developers, testers, and stakeholders. This can help to ensure that the software meets the needs of the business and is of high quality.
 

versioned_docs/version-2.0.0/concepts/reference/glossary/idempotency.md

@@ -2,7 +2,7 @@
 id: idempotency
 title: How Idempotent REST APIs Boost Reliability and Error Handling
 sidebar_label: Idempotency
-description: Discover how idempotent APIs enhance user experience, reliability, and error handling. Learn best practices for implementing and testing idempotent methods.
+description: Learn how idempotent REST APIs ensure reliability, error recovery, and fault tolerance in distributed systems. Discover best practices and testing strategies for idempotent methods
 tags:
   - explanation
   - glossary
@@ -30,9 +30,9 @@ Idempotency is often associated with specific HTTP methods in RESTful APIs:
 
 ![Methods](https://www.hubspot.com/hs-fs/hubfs/Google%20Drive%20Integration/Idempotent%20Api%20Draft-1.png?width=650&name=Idempotent%20Api%20Draft-1.png)
 
-## How Idempotency Ensures Reliability ?
+## Key Benefits of Idempotent APIs
 
-In distributed systems, where network failures and message duplication can occur, idempotent operations ensure reliability by:
+In distributed systems, where multiple components often interact asynchronously, achieving consistency can be challenging. Network failures, latency, and message duplication can lead to unintended consequences if not handled carefully. This is where idempotency plays a pivotal role. Idempotent operations ensure reliability by:
 
 - **Preventing Duplicate Effects:** Even if a request is duplicated due to network issues or client retries, idempotent operations ensure that the system's state remains unchanged after the initial request.
 - **Simplifying Error Recovery:** Idempotent APIs simplify error recovery mechanisms by allowing clients to retry requests without causing additional modifications or inconsistencies in the system.
@@ -46,9 +46,9 @@ Implementing idempotent APIs involves adopting best practices such as:
 - **Request Idempotency Tokens:** Use request headers or tokens (e.g., UUIDs) to uniquely identify and handle idempotent requests to prevent duplication or unintended re-execution.
 - **Idempotent Database Operations:** Implement database transactions and queries in a way that ensures data modifications are idempotent, even under concurrent or distributed execution scenarios.
 
-### Challenges in Idempotent API Implementation
+## Common Challenges in Implementing Idempotent APIs
 
-Implementing and testing idempotent APIs can pose challenges such as:
+Although idempotency is a desirable property in many RESTful APIs, implementing it in real-world systems can be challenging like :
 
 - **Ensuring Correctness Across Systems:** Guaranteeing idempotency in distributed systems with multiple interacting components requires careful design and coordination.
 - **Handling Edge Cases:** Identifying and addressing edge cases where idempotency might be violated due to specific system behaviors or failure scenarios.
@@ -58,7 +58,7 @@ Implementing and testing idempotent APIs can pose challenges such as:
 
 Idempotency becomes particularly critical in distributed systems where network failures, message duplication, and out-of-order message delivery can occur. In such environments, ensuring that operations are idempotent helps prevent unintended side effects and ensures that the system can recover gracefully from failures without compromising data integrity.
 
-### Idempotency important in RESTful APIs
+### What is Idempotency in REST APIs?
 
 Idempotent APIs offer several benefits that contribute to the reliability, scalability, and consistency of systems. Here are some key advantages:
 
@@ -95,13 +95,39 @@ Idempotent operations yield the same result regardless of repetitions. Safe meth
 
 ![Idempotent vs Safe](https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcSNpJRr8DjkwYCknq1yp0PNVbGQ9Gy0rcBwtg&s)
 
+## Leveraging Keploy for Idempotency in API Testing
+
+[Keploy](https://keploy.io), a powerful testing tool, plays a crucial role in handling **idempotency** during the development and testing phases of API design. By offering an **automated testing framework** that can simulate various API scenarios, including retries and error recovery, Keploy ensures that your idempotent APIs are functioning as expected across all edge cases.
+
+### How Keploy Helps Ensure Idempotency?
+
+- **Automated Test Cases for Idempotent Operations:**
+  Keploy enables developers to create automated test cases that simulate repeated API requests under various conditions, such as network failures, timeouts, or duplicate submissions. This ensures that idempotent operations like **PUT**, **DELETE**, and **GET** methods behave correctly, even when called multiple times. Keploy’s test cases can automatically validate that these methods do not introduce unexpected side effects or inconsistencies, regardless of how many times the request is repeated.
+
+- **Simulating Failures and Retrying Requests:**
+  With Keploy’s capabilities, teams can simulate failure scenarios, including transient network issues or service unavailability, to ensure that retry logic in idempotent APIs works as intended. This is especially important in distributed systems where failure recovery is crucial. Keploy verifies that retries do not modify the system’s state and that the response to a repeated request is consistent with the first execution, maintaining data integrity.
+
+- **Request and Response Pairing:**
+  Keploy also tracks requests and their corresponding responses, allowing you to easily identify whether repeated requests with the same data produce identical results. This pairing feature helps test whether the API is handling **idempotent tokens** (e.g., UUIDs) correctly and consistently across different test runs, ensuring that requests are not duplicated or re-executed unnecessarily.
+
+- **Advanced Mocking and Stubbing:**
+  In scenarios where you need to test idempotent behaviors in isolation or in specific conditions, Keploy allows you to mock external services and interactions. By simulating service responses, you can ensure that your idempotent APIs are handling edge cases effectively and returning the same results even in the event of temporary failures or delays.
+
+### Example Use Case
+
+Let’s say you are building an API that allows users to update their profile information using the **PUT** method. To ensure the operation is idempotent, you would create automated tests with Keploy to verify that:
+
+1. **Multiple PUT requests with identical data** will result in the same updated resource without introducing new records or changes.
+2. **Simulated network failures** will not lead to multiple updates or changes to the user’s profile when the request is retried.
+3. **Caching behaviors** are respected, ensuring that multiple requests for the same resource return the same data without additional overhead.
+
 ## Conclusion
 
 Idempotency is a fundamental principle in designing reliable and scalable RESTful APIs. By ensuring that operations can be safely retried without adverse effects, idempotent APIs contribute to system reliability, consistency, and performance. Implementing idempotent APIs involves careful consideration of HTTP methods, data handling, and error recovery mechanisms to maintain data integrity and simplify client interactions.
 
-Certainly! Here are 6 FAQs about idempotent REST APIs:
+Tools such as Keploy simplifies handling of idempotency during testing by providing a robust platform to simulate real-world API usage and edge cases, ensuring your APIs maintain their idempotency even under adverse conditions.
 
-## Frequently Asked Questions
+## FAQ
 
 ### What does it mean for an HTTP method to be idempotent?
 
@@ -119,7 +145,7 @@ Examples of idempotent HTTP methods include:
 - **PUT:** Updating a resource with PUT results in the same state regardless of how many times it's applied.
 - **DELETE:** Deleting a resource using DELETE remains unchanged if the resource is already deleted or does not exist.
 
-### How does idempotency contribute to error handling and fault tolerance?
+### How does idempotency improve error handling in distributed systems?
 
 Idempotent APIs simplify error handling and fault tolerance by allowing clients to retry requests safely. If a request fails due to network issues or timeouts, clients can resend the request without worrying about introducing inconsistencies or unintended modifications in the server's state.
 
@@ -131,6 +157,6 @@ To ensure idempotency in API implementations, developers should:
 - Implement operations in a way that does not change the server's state if the request is repeated.
 - Use request headers or tokens to uniquely identify and handle idempotent requests to prevent duplicate execution.
 
-### How can developers test for idempotency in REST APIs?
+### How to test idempotent APIs?
 
 Testing for idempotency involves creating test cases that simulate scenarios where requests may be duplicated or retried due to network failures or client retries. Developers should verify that repeating the same request does not result in different outcomes or unintended side effects in the system's state.