Postman API Testing and Automation

The provided text details a comprehensive course on automated API testing using Postman, guiding users from manual testing to full automation. It introduces Postman’s interface, including workspaces and collections, and demonstrates manual API testing by interacting with a mock coffee shop API. The course then transitions to writing tests with JavaScript, covering variables, data types, functions, and JSON parsing. Key concepts explored include handling API keys and secrets, asserting expected behaviors in responses (status codes, headers, body, and schema validation), and leveraging Postman’s assertion library (Chai JS). Finally, the text explains automating collection runs using the Postman Collection Runner, scheduled runs in the Postman Cloud, and integrating with CI/CD pipelines via Postman CLI and GitHub Actions to ensure continuous API health and testing.

Mastering API Testing with Postman

API testing is a crucial type of software testing that verifies the functionality, reliability, performance, and security of an Application Programming Interface (API). Its primary goal is to ensure that an API behaves as expected by examining it from the viewpoint of an external user or consumer, ideally finding issues and defects before it is released. APIs have become the backbone of software development, making API testing an essential skill for developers and testers.

Here’s a detailed discussion of API testing:

1. Purpose and Importance of API Testing

• API testing ensures that an API works correctly. It’s likened to quality control in a car factory, where a car undergoes various inspections before being deemed road-ready.
• It focuses on examining the API to ensure it behaves as expected, helping to find issues and defects before the API is made available to users.
• The course “Postman API Test Automation for Beginners” emphasizes the importance of automated API tests in modern software development.

2. Types of API Testing

• The provided sources primarily focus on functional testing, which involves examining individual API endpoints to ensure they respond correctly to various HTTP requests and function as they should from a functional perspective.
• Other types of testing, such as performance tests and security tests, are mentioned but are outside the scope of the course.

3. The API Testing Process with Postman The process often begins with manual testing before moving to automation:

• Manual Testing: It is essential to understand how to manually test an API before automating it. This involves sending requests, inspecting status codes (e.g., expecting a 200 OK for success), and examining the response body to see if the data makes sense. For instance, checking if the API is “up and running” via a status endpoint is a foundational manual test.
• Transition to Automation: Manual checks are tedious and prone to human error when repeated multiple times. Automated API testing uses code to automatically check if all relevant criteria are fulfilled. This approach offers many benefits, including being faster, more accurate, and serving as documentation for expected API behavior.

4. Key Concepts and Tools in Postman for API Testing

Postman is a tool specifically designed to help with API testing and automation. Key features and concepts include:

• Postman Collections and Workspaces:
• A Postman Collection holds a group of API requests (e.g., for “Valentino’s Artisan Coffee House” API).
• A Postman Workspace is a central point for team collaboration, allowing users to see run results, write comments, and manage collections. Workspaces can be public or private.
• Forking a collection creates a copy, allowing users to make changes independently without affecting the original.
• Merging allows changes from a forked collection to be integrated back into the original, often via a pull request.
• Request Components and Interaction:
• HTTP Methods: Understanding methods like GET (for retrieving data) and POST (for creating data like an order or registering a client) is fundamental.
• Parameters: Requests can include query parameters (e.g., for pagination or filtering products by category) and path variables (e.g., for a single product ID).
• Request Body: POST requests typically have a request body where data to be sent to the API is specified, often in JSON format.
• Authentication: APIs often require authentication (e.g., an API key or token) to access certain endpoints, which should be handled securely. Postman’s “auth helper” can simplify this.
• Scripting in Postman (JavaScript):
• Postman tests are written using JavaScript.
• Pre-request Scripts execute before a request is sent.
• Tests (Post-response Scripts) execute after a response has been retrieved.
• The Postman Console is an essential debugging tool for viewing logs and request/response details chronologically.
• Variables:
• JavaScript Variables: Like containers that store data within a script, useful for temporary storage and manipulation. They have a defined scope, meaning where they are accessible (e.g., within a function or code block).
• Postman Variables: Allow information to be stored and passed between requests, persisting data long-term (e.g., base URL, API key, or data retrieved from one request for use in another). They can be collection, environment, or global variables.
• Random Postman Variables: Generate unique values (e.g., random names or emails) for testing various scenarios without hardcoding.
• Variables can be set directly from scripts (e.g., pm.collectionVariables.set()) and retrieved (pm.collectionVariables.get()).
• Data Types and Structures:
• JavaScript supports strings, numbers, booleans, objects, and arrays.
• Objects are used to group related properties (key-value pairs). Dot notation or square bracket notation can be used to access properties.
• Arrays store collections of elements, accessed by a zero-based index.
• undefined is a data type representing an uninitialized variable or a non-existent property.
• Functions and Callbacks:
• Functions are blocks of code designed to perform specific tasks, accepting arguments as input and optionally returning a value.
• Methods are functions defined within an object. The this keyword refers to the object itself within a method.
• Callback Functions are functions passed as arguments to other functions, allowing for flexible and efficient code execution. Postman’s pm.test method uses a callback function to encapsulate assertions.
• JSON and JSON Schema:
• JSON (JavaScript Object Notation) is a format used to send and retrieve data between machines, characterized by key-value pairs, double quotes for keys and string values, and curly braces for objects, and square brackets for arrays.
• Parsing JSON: The pm.response.json() method transforms a JSON string response into a JavaScript object that can be worked with in scripts.
• JSON Schema: A way to describe the structure and rules of JSON responses. It can validate if a JSON response follows an expected format, defining data types, required properties, and disallowing additional properties. Mock servers are invaluable for testing JSON schemas by simulating various response scenarios.
• Assertions:
• Assertions are used to check if an API response meets expected criteria.
• Postman primarily uses the Chai.js assertion library for readable assertions (e.g., pm.expect(value).to.equal(expected)).
• Assertions can check status codes (pm.response.to.have.status(200)), response body properties (existence, data type, value), and response headers (pm.response.headers.get(‘header-name’).to.equal(‘value’)).
• Regular Expressions can be used within assertions (e.g., to.match(regex)) to validate the format of data like IDs.

5. Automation and CI/CD Integration

• Postman Collection Runner: A tool within Postman that allows running an entire collection of requests with a single click, automating multiple tests and providing a report of passed/failed tests. It can be configured to run multiple iterations and persist response bodies for debugging.
• Scheduled Runs (Monitors): Collections can be scheduled to run automatically on the Postman cloud at predefined intervals (e.g., hourly, daily, weekly). This monitors the API’s health and sends notifications if issues arise, ideal for deployed APIs. Authentication issues in scheduled runs are often related to how API keys are stored (initial vs. current value).
• Postman CLI (Command Line Interface): A tool for running Postman collections from the command line, enabling integration with CI/CD pipelines and running tests on custom infrastructure without human intervention.
• CI/CD Integration: Postman API tests can be integrated into Continuous Integration and Continuous Deployment (CI/CD) pipelines (e.g., Jenkins, GitLab, GitHub Actions) using the Postman CLI. This automates testing every time software changes are made, catching problems early and ensuring continuous validation during development and deployment. Secure handling of API keys using environment variables or secrets in the CI/CD system is crucial.

By understanding these concepts and tools, developers and testers can effectively use Postman for robust API testing and automation.

Postman API Test Automation Handbook

Postman automation is a key aspect of modern API testing, allowing users to move beyond manual checks to automatically validate API functionality, reliability, performance, and security. It significantly enhances the efficiency and accuracy of the testing process.

Here’s a detailed discussion of Postman automation:

1. Importance and Transition to Automation

• Automated API tests are considered crucial in modern software development.
• While manual testing is essential for understanding an API, repeating these checks manually is tedious and prone to human error.
• Postman allows users to write a “tiny bit of code” that automatically verifies if all relevant criteria are met, transforming a basic form of testing into a robust automated process.
• Automated testing with Postman is faster and more accurate, as computers can execute tests repeatedly without making mistakes. It also serves as documentation for expected API behavior.

2. Key Postman Tools for Automation

Postman provides powerful tools that turn users into “API testing rockstars” by automating collection runs.

• Postman Collection Runner
• This tool allows users to run an entire collection of requests with a single click.
• It executes requests in the order they appear in the collection, though this order can be reconfigured.
• Users can choose to disable specific requests from the run (e.g., a “register new client” request).
• The runner provides a report of passed and failed tests, indicating the number of tests that passed or failed.
• For debugging, users can enable the “persist responses in a session” flag, which saves response bodies for review, helping to understand the reason for test failures.
• The “iterations” setting allows users to run the entire collection multiple times (e.g., 10 times) to catch intermittent issues, such as a bug that only occurs occasionally.
• Scheduled Runs (Monitors)
• This feature allows the execution of Postman collections on the Postman cloud, eliminating the need for the user’s computer to be on or Postman to be open.
• It enables fully automated collection runs at predefined intervals (e.g., hourly, daily, weekly).
• Scheduled runs are ideal for monitoring already deployed APIs to check if they are still working as expected, providing notifications if issues arise.
• Authentication issues in scheduled runs are often linked to how API keys are stored. The Postman cloud primarily accesses the initial value of collection variables, not the current value. Users must ensure sensitive information like API keys is correctly set in the initial value or managed securely, although making them public might not always be advisable.
• Results from scheduled runs are uploaded to the Postman cloud and can be viewed in detail within Postman, showing test pass/fail status and console logs.
• Postman CLI (Command Line Interface)
• The Postman CLI is a command-line tool that runs Postman collections.
• It is invaluable for streamlining the testing process, enabling full automation and easy integration with Continuous Integration/Continuous Deployment (CI/CD) pipelines.
• It allows Postman tests to be run on custom infrastructure without relying on the Postman cloud.
• Key commands include postman login (for authentication with an API key) and postman collection run <collection_ID>.
• The CLI provides detailed reports on test execution.
• It allows for configuring runs with additional options, such as running only specific folders using the -i flag (e.g., postman collection run <collection_ID> -i “folder_name”).
• Results from CLI runs are also published to the Postman cloud, allowing users to view reports within the Postman interface.
• Errors like console.clear not being a function can occur with Postman CLI, requiring conditional execution in scripts (e.g., if (typeof console.clear === ‘function’) { console.clear(); }).

3. Integration with CI/CD Pipelines

• Integrating Postman API tests into CI/CD pipelines (such as Jenkins, GitLab, Circle CI, GitHub Actions) is essential for continuous validation during development and deployment.
• It ensures that APIs are continuously validated and function as expected.
• Postman tests can be run at various stages, typically after deploying the API to a pre-production environment (e.g., test environment) and after deploying to the production environment.
• The Postman CLI is the tool used for this integration, allowing collections and their tests to be run without manual intervention.
• Secret management is critical: sensitive information like API keys should never be hardcoded directly into pipeline configuration files. Instead, they should be stored securely as environment variables or secrets within the CI/CD system (e.g., GitHub repository secrets).
• Postman provides pre-configured commands for various CI/CD providers (Bitbucket Pipelines, Jenkins, GitLab, Azure Pipelines, Travis CI), simplifying the setup process.

4. Foundational Concepts for Automation Effective automation in Postman relies on several core concepts:

• Postman Variables: Used to store and pass data between requests, and persist settings like base URLs or API keys. Random Postman variables can generate unique values for testing. Variables can be set directly from scripts (pm.collectionVariables.set()) and retrieved (pm.collectionVariables.get()).
• JavaScript Scripting: Tests are written in JavaScript, executed either before a request (pre-request scripts) or after receiving a response (tests/post-response scripts). The Postman Console is crucial for debugging scripts.
• Assertions: Postman primarily uses the Chai.js assertion library to check if API responses meet expected criteria. Assertions can validate status codes, response headers, and response body properties (e.g., value, data type, existence of properties, matching regular expressions).
• JSON Schema Validation: For complex responses, JSON schemas can be used to describe the expected structure and rules of JSON data, allowing for validation of the response body against a predefined schema. Mock servers are highly valuable for testing JSON schemas by simulating various response scenarios, helping to ensure the schema itself correctly identifies issues like missing required properties or unexpected additional properties.

5. Collaboration and Workspaces

• Postman Workspaces serve as a central point for team collaboration, enabling members to see run results, write comments, and manage collections.
• Forking a collection creates a copy, allowing individual team members to work on changes independently.
• Merging changes back into the original collection (often via pull requests) helps integrate contributions and track modifications. This workflow ensures changes are reviewed and integrated effectively, supporting the overall automation strategy.

By leveraging these features and understanding the underlying concepts, Postman provides a comprehensive environment for automating API testing, from individual requests to entire CI/CD pipelines.

JavaScript Essentials for Postman Automation

JavaScript is the programming language exclusively supported by Postman for writing scripts that automate API tests. Understanding JavaScript basics is fundamental for anyone looking to effectively use Postman for automation.

Here’s a discussion of essential JavaScript concepts relevant to Postman:

1. Scripting in Postman

• In Postman, scripts can be written in two main places for each request:
• Pre-request scripts: Executed before the request is sent.
• Test scripts: Executed after the request has been sent and a response has been retrieved.
• The Postman Console (console.log()) is a crucial tool for debugging these scripts, allowing users to print messages and variable values to understand code execution. A common practice is to use console.clear() in a pre-request script to clear the console before each run, though this command might require conditional execution when using the Postman CLI.

2. JavaScript Variables

• Variables are like containers that store data for use and manipulation within a script.
• They are declared using keywords such as let or const.
• let: Used for variables whose values can be changed during script execution.
• const: Used for constants, whose values cannot be changed once defined. Attempting to reassign a const will result in an error.
• Variables are typically assigned values using the equal sign (=).
• Variable Scope: A variable’s scope defines where it is available.
• JavaScript variables are scoped only to the script where they are defined and are not persisted between separate script executions or across pre-request and test scripts.
• Variables defined within a code block (enclosed by curly braces {}) have a local scope and are not accessible outside that block. This is a common pitfall for beginners.

3. Data Types JavaScript has various data types to represent information. The most common ones encountered in Postman scripts include:

• Strings: Represent text and are enclosed in single or double quotes (e.g., “Jamie”, ‘hello’). Even numbers become strings if enclosed in quotes (e.g., “29”).
• Numbers: Represent numerical values (e.g., 20, 30, 29.65) and do not require quotes.
• Booleans: Represent a state of something (on/off, true/false). Values are true or false and do not require quotes.
• Undefined: A special data type that represents a variable that has been declared but not initialized with a value. Attempting to access an undefined property on an object will return undefined instead of throwing an error.
• Objects: Used to group related data (properties) under a single variable.
• Defined using curly braces {}.
• Properties within an object are stored as key-value pairs, separated by a colon (:).
• Accessing properties: Use dot notation (e.g., person.name) for simple property names. For properties with special characters or spaces, square bracket notation with the property name as a string is required (e.g., person[’email-address’]).
• Adding/Modifying properties: Properties can be added or modified after an object’s creation using either dot or bracket notation (e.g., person.email = “test@example.com”).
• Arrays: A data structure that stores a collection or list of elements.
• Defined using square brackets [].
• Elements are identified by an index, starting from 0 (zero-indexed). For example, hobbies accesses the second element.
• Arrays are technically a specialized form of JavaScript objects, which is why typeof an array returns ‘object’.

4. Functions

• A function is a block of code designed to perform a specific task. It promotes code organization and reusability.
• Definition: Functions are defined using the function keyword, followed by a name, parentheses for parameters, and a code block (curly braces) for the function’s body.
• Invocation (Calling): A function is executed by calling its name followed by parentheses (e.g., greet()).
• Parameters and Arguments: Functions can accept inputs through parameters defined in their signature. When the function is called, values passed to these parameters are called arguments. These parameters behave like local variables within the function’s scope.
• Return Statements: The return keyword specifies the value that a function should output. If no return statement is present, the function implicitly returns undefined.
• Methods: When a function is defined as a property of an object, it is called a method. Methods can access other properties of their parent object using the this keyword (e.g., this.firstName). console.log is an example of a method, where log is a method of the console object.
• Anonymous Functions: Functions that do not have a name. They are often stored in variables or passed directly as arguments to other functions.
• Callback Functions: Functions passed as arguments to other functions, to be executed later (often when an event occurs or an operation completes). Postman’s pm.test() function takes a callback function containing assertions.

5. JSON Parsing

• APIs often communicate using JSON (JavaScript Object Notation), which represents data in a key-value format similar to JavaScript objects, but with specific rules (e.g., keys must be double-quoted).
• Postman receives API responses as strings, which need to be parsed (transformed) into JavaScript objects before their properties can be accessed and used in scripts.
• The pm.response.json() method is used to parse the response body into a JavaScript object.

By mastering these JavaScript fundamentals, users can write robust and dynamic Postman tests, perform assertions on API responses, manage data flow between requests using Postman variables, and integrate their tests into CI/CD pipelines.

JSON Schema for API Response Validation

JSON Schema is a crucial tool for validating the structure and rules of API responses, especially when those responses are in JSON format. It is also written in JSON, and it helps ensure that the data you receive from an API follows the expected format.

Here’s a detailed discussion of JSON Schema:

1. Purpose and Definition

• JSON Schema is used to describe the structure and rules of responses when your APIs communicate using JSON.
• It helps you determine if the JSON data you are receiving actually adheres to the expected format, making it easier to catch errors.
• While an API response might look fine in Postman’s pretty view, the actual data is a string that needs to be parsed into a JavaScript object before its properties can be accessed or validated.

2. Structure and Key Properties A JSON Schema is itself an object and defines properties that specify the expected structure of your JSON data:

• type: This property defines the overall data type of the JSON response, often an object. It can also be array, string, number, boolean, or others, depending on what the top-level of your JSON represents.
• properties: If the top-level type is an object, the properties keyword is used to define the expected key-value pairs within that object. Each property itself can have a type (e.g., string, integer, array) and other validation keywords.
• required: This is an array of strings listing the names of properties that must be present in the JSON response. If a required property is missing, the schema validation will fail.
• additionalProperties: By default, JSON Schema allows for any additional properties not explicitly mentioned in the schema to be present without causing validation to fail. Setting additionalProperties to false (e.g., additionalProperties: false) explicitly disallows any properties not defined in the schema. This is useful for ensuring that unexpected new fields in the API response are flagged, alerting you to changes.

3. Advanced Validation with JSON Schema

• pattern: For string types, you can define a pattern using regular expressions to validate the format of the string (e.g., ensuring an ID consists only of uppercase letters and numbers and has a fixed length).
• format: This keyword can be used with string types to specify expected data formats like date-time. If the string does not match the specified format, the validation will fail.
• Nested Structures: JSON Schema can define complex nested structures, such as an array of objects, where each object in the array must conform to its own schema (e.g., an array of products, where each product object must have ID and quantity properties).

4. Using JSON Schema in Postman Tests

• In Postman’s test scripts (executed after the request and response), you can write assertions to validate the response against a JSON Schema.
• The pm.response.to.haveJsonSchema() method is used for this, taking your defined schema as an argument.
• Before validating with a schema, it’s a good practice to first parse the response body into a JavaScript object using pm.response.json(). Also, validating that the response body is Json is a common first test for API responses.
• JSON Schemas are typically defined as a const variable within the test script.

5. Testing JSON Schemas with Mock Servers

• It is crucial to ensure that your JSON Schema actually fails when it should. A schema that never fails, even when the response deviates, provides a false sense of security.
• Postman Mock Servers are invaluable for testing your JSON schemas.
• A mock server creates a fake version of your actual API, providing responses without performing real processing or validation.
• This allows you to manipulate the mock response body (by saving an example response and then modifying it) to deliberately introduce errors or missing properties, and then verify that your schema catches these issues. This is especially useful when you cannot easily modify the real API’s responses.
• To create a mock, you save an example response from a request, then create a mock collection based on that example. The mock server’s URL can be saved as an environment variable to easily switch between the real API and the mock.

6. Pitfalls and Best Practices

• Avoid Schema Generators: Do not solely rely on websites that generate schemas from given responses, as these often produce schemas that are not robust or easily understandable.
• Understand Your Schema: Always take the time to learn about JSON schemas step-by-step and write them yourself to fully understand what is being tested.
• Test for Failure: Always test if your schema will fail when necessary. This means intentionally breaking the response (e.g., via a mock server) to ensure the schema catches the error.
• Specificity: While JSON Schema can be highly specific, consider if it makes sense to hardcode every value. Sometimes, checking data types or existence of properties is more appropriate than asserting specific values, especially for dynamic data.
• External Library: Postman’s assertion syntax, including to.haveJsonSchema(), is powered by the Chai JS assertion library, which offers many options for sophisticated tests.

Postman Variables: Powering API Automation

Postman variables are powerful tools that allow you to store and manipulate data within your Postman environment, streamlining your API testing and automation workflows. They are distinct from JavaScript variables, which are temporary and scoped only to the script where they are defined.

Here’s a discussion of Postman variables:

What are Postman Variables?

Variables in Postman are like containers that store data, enabling you to reuse values, manage dynamic data, and securely handle sensitive information across your requests and scripts. Unlike JavaScript variables, Postman variables persist between requests and can store settings and data long-term, such as a base URL or an API key.

Types of Postman Variables

1. Collection Variables:

• Scope: These variables are scoped to an entire Postman Collection, meaning they can be accessed by any request within that collection. This is ideal for values that are common to all requests in a collection, such as an API key or a specific product ID.
• Setting: You can set collection variables manually by editing the collection details under the ‘Variables’ tab.
• Current vs. Initial Value: When defining a collection variable, you’ll see “Initial Value” and “Current Value”.
• Initial Value is what is shared with others in a public workspace.
• Current Value is the one actively used by Postman when running requests on your machine. This distinction is crucial for handling secrets like API keys: storing them as a current value prevents them from being exposed in public workspaces, while still allowing you to use them in your requests. For Postman Cloud runs (like scheduled runs), the Postman cloud typically only has access to the initial value, which means you might need to move your secret to the initial value for cloud-based automation, with caution.
• Example: An API key or a product ID that you want to reuse across multiple requests within a collection.

1. Environment Variables:

• While not explicitly detailed as a separate type in the provided text, the source mentions that a mock server’s URL can be saved as an environment variable. This implies that environment variables can be used to store configuration details that might change between different environments (e.g., development, testing, production, or mock servers). When an environment is selected, its variables can override collection variables of the same name.

1. Random Postman Variables:

• These are dynamically generated values provided by Postman for testing various scenarios without hardcoding specific data.
• Syntax: They use a specific syntax like {{$randomFullName}} or {{$randomEmail}} within the request builder.
• Use Cases: Useful for generating unique customer names or emails for new registrations or orders.
• Important Note: Each time a random Postman variable is invoked, a new value is generated. This means if you use {{$randomFullName}} in the request body and then try to assert its value in the test script using the same syntax, they might differ because two separate generations occurred. To work around this, you can generate the value once in a pre-request script and store it in a Postman variable, then use that variable in both the request body and the test script.

Setting and Getting Postman Variables

• Using Variables in Request Builder: You can reference Postman variables in your request URLs, headers, or bodies by enclosing their names in double curly braces (e.g., {{productID}}). Postman automatically replaces these placeholders with their current values before sending the request.
• Setting Variables from Scripts:
• You can dynamically update or create Postman variables from your pre-request scripts or test scripts.
• The pm.collectionVariables.set(“variableName”, value) method is used to set or update a collection variable. This is particularly useful for extracting data from a response and passing it to subsequent requests, such as capturing a newly created orderID and using it to retrieve that order.
• Getting Variables from Scripts:
• To access the value of a Postman variable within a script, you use pm.collectionVariables.get(“variableName”).
• It’s important to remember that the {{variableName}} syntax does not work inside scripts; it’s only for the request builder.
• For random Postman variables accessed within scripts, pm.variables.replaceIn(“{{$randomFullName}}”) can be used to get the generated value.

Importance in API Test Automation

• Eliminating Manual Data Transfer: Postman variables are crucial for avoiding the manual copy-pasting of data between requests. For instance, an orderID generated by one API call can be automatically captured and used in a subsequent call to retrieve that specific order, significantly automating the workflow.
• Managing Dynamic Values: APIs often return dynamic data (e.g., unique IDs, timestamps). Variables allow you to capture and use these values in your tests without hardcoding, making your tests more robust and adaptable.
• Handling Authentication: API keys and tokens can be stored as collection variables, making it easy to manage authentication across multiple requests without embedding credentials directly in each request.
• Configuring Environments: Variables, especially environment variables, allow you to easily switch between different API environments (e.g., development, staging, production, or mock servers) by changing a single variable value.
• Debugging: By logging variable values to the Postman Console, you can inspect the data flow and troubleshoot your scripts effectively.

In essence, Postman variables are fundamental for building flexible, robust, and automated API tests, allowing for efficient management of data and secrets throughout your Postman collections.

By Amjad Izhar
Contact: amjad.izhar@gmail.com
https://amjadizhar.blog

Affiliate Disclosure: This blog may contain affiliate links, which means I may earn a small commission if you click on the link and make a purchase. This comes at no additional cost to you. I only recommend products or services that I believe will add value to my readers. Your support helps keep this blog running and allows me to continue providing you with quality content. Thank you for your support!