feat: add glossary (#182)

* feat:add glossary page

* feat: added glossary pages

* feat:add glossary page

Signed-off-by: Diganta Kr Banik <digantabanik2000@gmail.com>

* feat: added glossary pages

Signed-off-by: Diganta Kr Banik <digantabanik2000@gmail.com>

* fix:styling for glossary letters

Signed-off-by: Diganta Kr Banik <digantabanik2000@gmail.com>

---------

Signed-off-by: Diganta Kr Banik <digantabanik2000@gmail.com>
Signed-off-by: Animesh Pathak <sonichigi@Animeshs-MacBook-Air.local>
Co-authored-by: Animesh Pathak <sonichigi@Animeshs-MacBook-Air.local>

docs/concepts/general-glossary.md

@@ -1,6 +1,6 @@
 ---
 id: general-glossary
-title: General Glossary for Users 
+title: General Glossary for Users
 sidebar_label: Glossary
 description: This glossary has an explanation of all the terminologies that beginners find difficult to understand at first glance.
 tags:
@@ -13,19 +13,16 @@ keywords:
 
 API mocking is a simulation of real APIs and is performed when the production API is not ready. You may come across a situation where you cannot send an API request to the server because it is not prepared. In such cases, you can mock a chunk of data from the response and eventually, when you make requests the mocked data will be returned.
 
-
 ### 2. **Idempotency**
 
 An API is idempotent when the outcome of a successful request remains unchanged on making the same request frequently.
 
-
 ### 3. **Noisy field**
 
-Noisy field refers to the random data whose value changes each time you make a request. 
-
-For example, a Timestamp is one such property that returns the time when the request is made. Its value is not fed manually but is automatically recorded therefore, at every call it differs. 
+Noisy field refers to the random data whose value changes each time you make a request.
 
+For example, a Timestamp is one such property that returns the time when the request is made. Its value is not fed manually but is automatically recorded therefore, at every call it differs.
 
 ### 4. **Interoperability**
 
-Interoperability refers to the situation when the behavior of the data is in its original (native) format when transferred from one platform to other. It reduces the dependency of files by replacing them with optimized code giving the same result. 
+Interoperability refers to the situation when the behavior of the data is in its original (native) format when transferred from one platform to other. It reduces the dependency of files by replacing them with optimized code giving the same result.

docs/concepts/reference/glossary.md

@@ -0,0 +1,13 @@
+---
+id: glossary
+title: Glossary for Users
+sidebar_label: Glossary
+description: This glossary has an explanation of all the terminologies that beginners find difficult to understand at first glance.
+tags:
+  - explanation
+keywords:
+  - API
+---
+
+1. [Acceptance Testing](/docs/concepts/reference/glossary/acceptance-testing)
+2. [Agile Unit Testing](/docs/concepts/reference/glossary/agile-unit-testing)

docs/concepts/reference/glossary/acceptance-testing.md

@@ -0,0 +1,32 @@
+---
+id: acceptance-testing
+title: Acceptance Testing
+sidebar_label: Acceptance Testing
+description: This glossary has an explanation of all the terminologies that beginners find difficult to understand at first glance.
+tags:
+  - explanation
+keywords:
+  - API
+---
+
+### What is Acceptance Testing?
+
+Acceptance testing (AT) is a formal testing process that is conducted to determine whether a software system meets the requirements of the customer or end user. AT is the last phase of software testing, and it is conducted after all other levels of testing have been completed.
+
+The purpose of AT is to ensure that the software system is acceptable to the customer or end user. This means that the system must meet the customer's or end user's needs and expectations. AT also helps to identify any defects or problems with the software system that may have been missed during earlier phases of testing.
+
+### Acceptance Testing Types:
+
+- **User acceptance testing (UAT)**: This is the most common type of AT. It involves the customer or end user using the software system in a way that simulates how they will use it in the real world.
+- **Systematic testing**: This involves using a set of predetermined test cases to test the software system.
+- **Acceptance test-driven development (ATDD)**: This is a technique that combines AT with test-driven development (TDD). TDD is a software development process that involves writing unit tests before the code is written. ATDD extends TDD by adding acceptance tests to the mix.
+
+### Benefits of Acceptance Testing:
+
+- It helps to ensure that the software system meets the needs and expectations of the customer or end user.
+- It helps to identify any defects or problems with the software system that may have been missed during earlier phases of testing.
+- It helps to improve the overall quality of the software system.
+- It helps to reduce the risk of defects and problems with the software system.
+- It helps to ensure that the software system is ready for release.
+
+Acceptance testing is vital in ensuring software meets stakeholder demands and quality standards.

docs/concepts/reference/glossary/agile-testing.md

@@ -0,0 +1,36 @@
+---
+id: agile-unit-testing
+title: Agile Unit Testing
+sidebar_label: Agile Unit Testing
+description: This glossary has an explanation of all the terminologies that beginners find difficult to understand at first glance.
+tags:
+  - explanation
+keywords:
+  - API
+---
+
+Agile unit testing is a software testing process that is used in agile development teams. It involves writing small, self-contained tests that verify the behavior of individual units of code. These tests are typically written by the developers themselves, and they are run frequently throughout the development process.
+
+### Why is agile unit testing important?
+
+Agile unit testing is important because it can help to improve the quality of software applications. By finding and fixing defects early, agile unit testing can help to prevent bugs from reaching production, which can save time and money.
+
+### How does agile unit testing work?
+
+Agile unit testing is typically done by developers. Developers write unit tests that verify the behavior of individual units of code. These unit tests are then run automatically as part of the development process.
+
+### What are the benefits of agile unit testing?
+
+1. It helps to ensure the quality of the code by catching bugs early in the development process.
+2. It can help to improve the maintainability of the code by making it easier to track changes and to identify regressions.
+3. It can help to speed up the development process by reducing the amount of time that is spent debugging.
+
+### Key Principles of agile unit testing:
+
+1. **Test-driven development (TDD)**: TDD is a development methodology that involves writing unit tests before writing the code. This helps to ensure that the code is designed with testing in mind, and it can help to improve the quality of the code.
+2. **Continuous integration (CI)**: CI is a process that involves automating the build and testing of software. This helps to ensure that the code is always in a releasable state, and it can help to catch bugs early in the development process.
+3. **Continuous delivery (CD)**: CD is a process that involves automating the deployment of software. This helps to ensure that the software is always available to users, and it can help to improve the speed of deployment.
+
+### Conclusion
+
+Agile unit testing is a valuable tool for improving the quality of software applications. By following the best practices for agile unit testing, developers can help to ensure that their applications are free of defects and meet the needs of their users.

docs/concepts/reference/glossary/behaviour-driven-development.md

@@ -0,0 +1,44 @@
+---
+id: behaviour-driven-development
+title: Behaviour Driven Development
+sidebar_label: Behaviour Driven Development
+description: This glossary has an explanation of all the terminologies that beginners find difficult to understand at first glance.
+tags:
+  - explanation
+keywords:
+  - API
+---
+
+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.
+
+### Benefits of BDD
+
+1. **Improved communication**: BDD encourages communication between developers, testers, and business stakeholders. This helps to ensure that everyone is on the same page and that the software meets the needs of its users.
+2. **Increased collaboration**: BDD encourages collaboration between developers, testers, and business stakeholders. This helps to ensure that the software is developed in a way that is efficient and effective.
+3. **Improved testability**: BDD tests are written in plain language, which makes them easier to understand and maintain. This helps to improve the testability of the software.
+4. **Increased confidence**: BDD tests provide a high degree of confidence that the software meets the needs of its users. This helps to reduce the risk of defects and to improve the quality of the software.
+
+Overall, BDD is a software development process that can help to improve communication, collaboration, and testing. This can lead to the development of higher-quality software that meets the needs of the business.
+
+### BDD Automation Tools
+
+Here are some of the popular BDD automation tools:
+
+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.
+
+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 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.
+
+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.
+
+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.
+
+### Key Points to remember while using BDD
+
+1. **BDD is not a silver bullet**: BDD is not a magic solution that will solve all of your software development problems. However, it can be a valuable tool for improving communication, collaboration, and testability.
+2. **BDD requires buy-in from everyone involved**: BDD is most effective when everyone involved in the software development process is on board. This includes developers, testers, and business stakeholders.
+3. **BDD takes time to learn and implement**: BDD is a new approach to software development, and it takes time to learn and implement. However, the benefits of BDD can be significant, so it is worth the investment.
+4. **BDD is not a replacement for other testing methods**: BDD is not a replacement for other testing methods, such as unit testing and integration testing. Instead, it should be used in conjunction with these methods to improve the overall quality of the software.

docs/concepts/reference/glossary/beta-testing.md

@@ -0,0 +1,50 @@
+---
+id: beta-testing
+title: Beta Testing
+sidebar_label: Beta Testing
+description: This glossary has an explanation of all the terminologies that beginners find difficult to understand at first glance.
+tags:
+  - explanation
+keywords:
+  - API
+---
+
+# Beta Testing
+
+Beta testing is a type of software testing in which end users assess the product's performance and usability in a real-world context. It is the last stage of software testing before the product is released to the general public.
+
+## Purpose of Beta Testing
+
+The purpose of beta testing is to find bugs and get user input before a product is launched. This helps to ensure that the product is of high quality and meets the needs of its users.
+
+## Types of Beta Testing
+
+There are two main types of beta testing: open beta testing and closed beta testing.
+
+- **Open beta testing** is when the beta version of the product is made available to the general public for evaluation. This type of beta testing is often used for consumer products, such as smartphone apps and web services.
+- **Closed beta testing** is when the beta version of the product is made available to a select group of users who have been invited to participate. This type of beta testing is often used for enterprise software and other niche products.
+
+## Benefits of Beta Testing
+
+There are many benefits to beta testing, including:
+
+- **Early problem detection:** Bugs and flaws can be found and fixed early in the development process, which saves time and money.
+- **Improved user experience:** Beta testers can provide feedback on how to improve the user experience.
+- **Gathering feedback:** Beta testers can provide feedback on the product's features, functionality, and performance.
+- **Promoting user acceptance:** Beta testing can help to promote user acceptance of the product by getting the word out about it.
+- **Boosting software quality:** Beta testing can help to boost the quality of the software by ensuring that it is as stable, safe, and functional as possible.
+
+## How to Beta Test
+
+Beta testing should be planned and executed carefully. The right beta testers should be selected, and the testing process should be well-organized.
+
+Here are some tips for beta testing:
+
+- **Start with a small group of beta testers.** This will help you to identify and fix any major problems before the product is released to a wider audience.
+- **Provide beta testers with clear instructions.** Tell them what you are looking for in their feedback, and how they can submit their feedback.
+- **Gather feedback from beta testers.** This feedback should be used to improve the product before it is released to the general public.
+- **Thank beta testers for their participation.** Their feedback is valuable, and they deserve to be thanked for their time and effort.
+
+## Conclusion
+
+Beta testing is an important part of the software development process. By beta testing a product, developers can get valuable feedback from real users and improve the quality of the product before it is released to the general public.

docs/concepts/reference/glossary/black-box-testing.md

@@ -0,0 +1,52 @@
+---
+id: black-box-testing
+title: Black Box Testing
+sidebar_label: Black Box Testing
+description: This glossary has an explanation of all the terminologies that beginners find difficult to understand at first glance.
+tags:
+  - explanation
+keywords:
+  - API
+---
+
+# Black-Box Testing
+
+Black-box testing is a software testing method that does not require knowledge of the internal structure or implementation details of the software being tested. Instead, the tester focuses on the software's external behavior and how it interacts with users.
+
+## Benefits of Black-Box Testing
+
+- Can be performed by testers with a variety of skill levels
+- Can find a wide range of defects, including those that are related to the software's external behavior
+- Can be used to verify the software's functionality, usability, and performance
+- Can be used to identify potential security vulnerabilities
+
+## Types of Black-Box Testing
+
+### Equivalence partitioning
+
+Divides the input space into equivalence classes, and then tests each class to ensure that the software behaves as expected.
+
+### Boundary value analysis
+
+Tests the software at the boundaries of the input space, where unexpected behavior may occur.
+
+### Decision table testing
+
+Creates a table that lists all possible input combinations and their expected outputs. The software is then tested to ensure that it produces the correct output for each combination.
+
+### State transition testing
+
+Tests the software as it moves from one state to another. This can be used to verify that the software behaves correctly in all possible states and transitions.
+
+## Comparison of Black-Box Testing and White-Box Testing
+
+| Black-box testing                                                                                           | White-box testing                                                                                   |
+| ----------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------- |
+| Does not require knowledge of the internal structure or implementation details of the software being tested | Requires knowledge of the internal structure or implementation details of the software being tested |
+| Focuses on the software's external behavior and how it interacts with users                                 | Focuses on the software's internal logic and how it works                                           |
+| Can be performed by testers with a variety of skill levels                                                  | Requires testers with specialized knowledge and skills                                              |
+| Can find a wide range of defects                                                                            | Can find defects that are related to the software's internal logic                                  |
+
+## Conclusion
+
+Black-box testing is a valuable tool for ensuring the quality of software. It can be used to find a wide range of defects, and it can be performed by testers with a variety of skill levels. The best testing strategy for a particular software project will depend on the specific needs of the project. In some cases, black-box testing may be sufficient. In other cases, white-box testing may be necessary to find all the defects in the software.

docs/concepts/reference/glossary/code-coverage.md

@@ -0,0 +1,12 @@
+---
+id: code-coverage
+title: Code Coverage
+sidebar_label: Code Coverage
+description: This glossary has an explanation of all the terminologies that beginners find difficult to understand at first glance.
+tags:
+  - explanation
+keywords:
+  - API
+---
+
+Code coverage is a metric that measures the extent to which the code in a program has been executed during testing. It is a valuable tool for software testers because it can help them to identify areas of the code that have not been tested and to ensure that the entire program has been adequately tested.