EXCLUSIVE: Postman Andrew Wrench is one of the unlikely architects of a court case that sent Britain's car finance firms into a spiral amid a row over 'secret' commission paid to dealers.

Meet the motorist who exposed 'PPI 2.0': Postman with 'penchant for fast cars' took finance firm to court over 'secret' commission payments - and unearthed a compensation scandal | Daily Mail Online

The United State Postal Inspection Service is offering reward worth up to $150,000 for information that leads to the arrest of a suspect who robbed a letter carrier at gunpoint in Mattapan on Oct. 18. It was the latest in a series of incidents targeting either letter carriers or mailboxes in recent months.

Postman robbed at gunpoint; reward offered

All pensioners are required to submit a ‘life certificate' or Jeevan Pramaan Patra to pension-disbursing authorities (PDAs) such as banks and post offices in November to receive their monthly share.

Jeevan Pramaan Patra | Submission window for life certificate opens today: How to secure your pension for ₹70

Keeping with the Halloween spirit, the National Republican Congressional Committee delivered a postman costume to House Democratic Conference Chairman Pete Aguilar’s (D-CA) office after he was dubbed “Post Office Pete” by Rep.

NRCC delivers postman costume to Democrat McCarthy dubbed 'Post Office Pete'

“What Orwell feared were those who would ban books,” Postman writes. “What Huxley feared was that there would be no reason to ban a book, for there would be no one who wanted to read one. Orwell feared those who would deprive us of information. Huxley feared those who would give us so much that we would be reduced to passivity and egoism.”

DEAN POLING: Banning books vs. our appetite for distraction

Off the southwest coast of Finland, residents of the remote Turku archipelago have their post delivered by Peter Mustelin who makes a 40-kilometre run by boat once every Friday, occasionally bringing his son along for the ride.

This Finnish postman does more than deliver mail in his archipelago route

Jack Daniel's and The Row team up with Asher Postman, Josh Furse, Jaxson Deno, and Black Stabbey to create a Halloween event not to miss! [Nashville, TN] - Nashville’s southern kitchen and historic music venue, The Row Kitchen and Pub, partners with Jack ...

Jack Daniel's Presents: Fright Fest at The Row

An Australian resident was left bewildered after receiving a notification from a postal delivery worker that her parcel had been delivered at a "safe spot".

Woman Fumes After Postman Leaves Her Parcel 'Somewhere' On 800-Acre Property

But every now and again something might happen they feel they need to tell me about. It might be the arrival of the postman, or one of my neighbours getting a delivery or, perish the thought, a cat might nonchalantly stroll by. Obviously, they are always ...

This curtain closing gadget stops my hysterical dogs barking at the postman

Postman

postman

As a Product Evangelist, I regularly test and demo various APIs to better understand their capabilities. For a very long time, Postman has been my go-to tool. It’s straightforward, reliable, and does the job well. But recently, I discovered a game-changing feature that took my exploration to a whole new level and that’s the Postman’s pre-request scripts. Before now, I was running basic tests and manually inputting certain values even though I used variables for handling some auth, which worked fine but felt a little tedious over time. Yesterday, while playing around with Postman, I found a way to streamline my testing process using pre-request scripts, and the results were incredible. I started with a simple need by generating a unique transaction reference for an endpoint. Rather than manually entering a reference each time, I used Postman’s UUID function to automatically create a random 12-character transaction reference. function generateTransactionRef() {
    const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
    let result = '';
    for (let i = 0; i < 12; i++) {
        const randomIndex = Math.floor(Math.random() * characters.length);
        result += characters[randomIndex];
    }
    return result;
}

var uniqueTransactionRef = generateTransactionRef();
pm.environment.set("transactionRef", uniqueTransactionRef);

console.log("Generated transactionRef:", uniqueTransactionRef); This random reference was then shared with other endpoints, making it easy for the APIs to access the same reference seamlessly. For example, one API requires a transactionref as part of the body to simulate transfer. With the script in place, I could automatically use the generated reference across multiple requests. This eliminated manual entry and potential errors. The value generated gets reused across any endpoint that needs it, keeping my testing smooth and consistent. Another API I work with requires a token to be refreshed every 30 minutes. This was something I used to manage manually, which felt like a waste of time having to copy-paste every time the token expires. But using pre-request scripts, I automated the entire process. Now, Postman grabs the newly generated token from the first request and automatically inserts it as the bearer token for subsequent requests in the same environment. var requestOptions = {
    url: 'URL to generate the token',
    method: 'POST',
    header: {
        'Content-Type': 'application/json'
    },
    body: {
        mode: 'raw',
        raw: JSON.stringify({
            "username": "user's email",
            "password": "user's password"
        })
    }
};

pm.sendRequest(requestOptions, function (err, res) {
    if (err) {
        console.error('Error fetching token:', err);
        return;
    }

    var jsonResponse = res.json();

    if (jsonResponse.statusCode === 90000 && jsonResponse.data && jsonResponse.data.token) {
        var token = jsonResponse.data.token;
        pm.environment.set('bearerToken', token);
        console.log('Token fetched and saved:', token);
    } else {
        console.error('Error: Token not found in the response. Response:', jsonResponse);
    }
});

pm.request.headers.add({
    key: 'Authorization',
    value: 'Bearer ' + pm.environment.get('bearerToken')
}); For all the other endpoints, the script picks up this token and adds it as the authorization header. This small tweak made my workflow far more efficient, as I no longer have to pause or copy-paste for manual token updates. This new approach has 10x’d the way I test, demo, and document APIs. The flexibility and power of Postman’s scripting features have opened up new possibilities for how I approach my work. I’m excited to keep exploring more features to make my API testing even more seamless. Next on my list is setting up API monitoring. I’ve done it in the past but can’t quite remember all the steps. Once I get that up and running again, it’ll be another big win for making sure everything stays up and running smoothly. Postman is more than just a tool for running API requests seeing that with a little scripting, it’s become a critical part of my workflow, allowing me to focus more on other important projects and less on repetitive tasks. If you haven’t started using pre-request scripts yet, I highly recommend giving them a try and they might just transform how you work. Let me know what you think about this short article and if I should be sharing more in this direction. As a Product Evangelist, I regularly test and demo various APIs to better understand their capabilities. For a very long time, Postman has been my go-to tool. It’s straightforward, reliable, and does the job well. But recently, I discovered a game-changing feature that took my exploration to a whole new level and that’s the Postman’s pre-request scripts. Before now, I was running basic tests and manually inputting certain values even though I used variables for handling some auth, which worked fine but felt a little tedious over time. Yesterday, while playing around with Postman, I found a way to streamline my testing process using pre-request scripts, and the results were incredible. I started with a simple need by generating a unique transaction reference for an endpoint. Rather than manually entering a reference each time, I used Postman’s UUID function to automatically create a random 12-character transaction reference. function generateTransactionRef() {
    const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
    let result = '';
    for (let i = 0; i < 12; i++) {
        const randomIndex = Math.floor(Math.random() * characters.length);
        result += characters[randomIndex];
    }
    return result;
}

var uniqueTransactionRef = generateTransactionRef();
pm.environment.set("transactionRef", uniqueTransactionRef);

console.log("Generated transactionRef:", uniqueTransactionRef); function generateTransactionRef() {
    const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
    let result = '';
    for (let i = 0; i < 12; i++) {
        const randomIndex = Math.floor(Math.random() * characters.length);
        result += characters[randomIndex];
    }
    return result;
}

var uniqueTransactionRef = generateTransactionRef();
pm.environment.set("transactionRef", uniqueTransactionRef);

console.log("Generated transactionRef:", uniqueTransactionRef); This random reference was then shared with other endpoints, making it easy for the APIs to access the same reference seamlessly. For example, one API requires a transactionref as part of the body to simulate transfer. With the script in place, I could automatically use the generated reference across multiple requests. This eliminated manual entry and potential errors. The value generated gets reused across any endpoint that needs it, keeping my testing smooth and consistent. Another API I work with requires a token to be refreshed every 30 minutes. This was something I used to manage manually, which felt like a waste of time having to copy-paste every time the token expires. But using pre-request scripts, I automated the entire process. Now, Postman grabs the newly generated token from the first request and automatically inserts it as the bearer token for subsequent requests in the same environment. var requestOptions = {
    url: 'URL to generate the token',
    method: 'POST',
    header: {
        'Content-Type': 'application/json'
    },
    body: {
        mode: 'raw',
        raw: JSON.stringify({
            "username": "user's email",
            "password": "user's password"
        })
    }
};

pm.sendRequest(requestOptions, function (err, res) {
    if (err) {
        console.error('Error fetching token:', err);
        return;
    }

    var jsonResponse = res.json();

    if (jsonResponse.statusCode === 90000 && jsonResponse.data && jsonResponse.data.token) {
        var token = jsonResponse.data.token;
        pm.environment.set('bearerToken', token);
        console.log('Token fetched and saved:', token);
    } else {
        console.error('Error: Token not found in the response. Response:', jsonResponse);
    }
});

pm.request.headers.add({
    key: 'Authorization',
    value: 'Bearer ' + pm.environment.get('bearerToken')
}); var requestOptions = {
    url: 'URL to generate the token',
    method: 'POST',
    header: {
        'Content-Type': 'application/json'
    },
    body: {
        mode: 'raw',
        raw: JSON.stringify({
            "username": "user's email",
            "password": "user's password"
        })
    }
};

pm.sendRequest(requestOptions, function (err, res) {
    if (err) {
        console.error('Error fetching token:', err);
        return;
    }

    var jsonResponse = res.json();

    if (jsonResponse.statusCode === 90000 && jsonResponse.data && jsonResponse.data.token) {
        var token = jsonResponse.data.token;
        pm.environment.set('bearerToken', token);
        console.log('Token fetched and saved:', token);
    } else {
        console.error('Error: Token not found in the response. Response:', jsonResponse);
    }
});

pm.request.headers.add({
    key: 'Authorization',
    value: 'Bearer ' + pm.environment.get('bearerToken')
}); For all the other endpoints, the script picks up this token and adds it as the authorization header. This small tweak made my workflow far more efficient, as I no longer have to pause or copy-paste for manual token updates. This new approach has 10x’d the way I test, demo, and document APIs. The flexibility and power of Postman’s scripting features have opened up new possibilities for how I approach my work. I’m excited to keep exploring more features to make my API testing even more seamless. Next on my list is setting up API monitoring. I’ve done it in the past but can’t quite remember all the steps. Once I get that up and running again, it’ll be another big win for making sure everything stays up and running smoothly. Postman is more than just a tool for running API requests seeing that with a little scripting, it’s become a critical part of my workflow, allowing me to focus more on other important projects and less on repetitive tasks. If you haven’t started using pre-request scripts yet, I highly recommend giving them a try and they might just transform how you work. Let me know what you think about this short article and if I should be sharing more in this direction.

Streamlining API Testing with Postman’s Pre-Request Scripts

Hi there! Today, I'll demonstrate how you can enhance the simplicity of your API testing using AI within Postman. What is Postman? Postman is an API platform for building and using APIs. Postman simplifies each step of the API lifecycle and streamlines collaboration so you can create better APIs—faster. Setting up the environment. To begin, we require some endpoints for testing purposes. To fulfill this requirement, I've set up a dedicated server. If you're unfamiliar with and , there's no need to worry—I've prepared comprehensive instructions on how to install them (Docker/docker-compose and git installation guidelines can be found towards the end of the article). Once you have Git and Docker in place, you can proceed next: Docker Git Ensure port 8080 is unoccupied; the application is operational on this port. You need to clone a : repo open in terminal (or an equivalent) and run commands: git clone https://github.com/PavelMal/PostmanTesting.git cd PostmanTesting docker-compose up Please wait for approximately 1-2 minutes, and after this time, you should observe a log entry resembling the following: Starting qa-server ... done Attaching to qa-server … … qa-server    | 2023-08-10 05:19:17.741  INFO 1 --- [main] com.test.Application: Started Application in 5.183 seconds (JVM running for 6.1 This indicates that the application is now operational. To verify its proper functionality, simply initiate a request to: http://localhost:8080/api/check Expect a response status code of 200 OK. . We have now successfully configured the testing environment. Your progress is commendable This application offers the capability to generate and retrieve orders (an order being an object comprising three attributes: , , and ). Don't hesitate to utilize Swagger for this purpose: (It's not in vain that I added it to the project. 🙂) id name price http://localhost:8080/swagger-ui.html#/ Generate the initial order and tests to verify this functionality Let’s move on to the most interesting part - open the Postman and create your first order At this point, we can begin creating tests for that specific endpoint. However, before we proceed, consider this: we have an AI assistant at our disposal. Let's experiment with its capabilities. Well done! Click on ‘Tests’ tab Click on AI assistant button Write ‘Add tests to this request’ and submit it You’ve got your first set of tests including checking response time. Try other prompts such as: Test for response content type Test for response schema Test for response data length Test for response time within acceptable range Validation of error message Let's proceed to create tests for the validation of error messages. In Postman, input a price of 0 and initiate a request. This action should result in a response code of 400 along with the following message: "message": "Price can't be less than or equal to 0". Leverage the AI assistant to compose a script: response message should be "message": "Price can't be less or equal than 0" You now possess two tests designed to check the 400 status code and verify the error message. Great job! I've included the logic to check the name/price/ID body parameters. Your task is to identify all possible scenarios and harness AI assistance to generate the corresponding tests. Visualize response Another valuable feature is response visualization. Let's explore it together. Type 'Visualize response as table' and see the magic Postman collections Last but not least, do not underestimate the value of utilizing collections, as this will enable your tests to maintain a structured framework. By employing collections, you can effortlessly oversee API requests alongside sets of tests. I appreciate your attention! You are now prepared to harness AI for your API testing needs (Furthermore, you have acquired the fundamentals of Docker and Git). Would greatly appreciate it if you could star my . project Installation instructions for git Ubuntu: Open a terminal. Run the following command to install Git: sudo apt update sudo apt install git Once the installation is complete, verify it by typing: git --version macOS: Git is usually pre-installed on macOS. However, you can ensure you have the latest version by opening a terminal and typing: git --version If Git is not installed or you want to update it, you can install it using (a popular package manager for macOS): Homebrew /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)" brew install git Windows: Download the Git installer for Windows from the official Git website: Git for Windows Run the installer and follow the on-screen instructions. You can usually leave the default settings as they are. During the installation, you'll be asked to choose a default text editor and adjust line ending conversions. You can stick with the default options or make changes according to your preferences. After the installation is complete, open a Command Prompt or Git Bash (included with Git for Windows) and verify Git by typing: git --version Installation instruction for docker/docker-compose Ubuntu: Install Docker: Open a terminal and run the following commands: sudo apt update sudo apt install -y docker.io After the installation is complete, start and enable the Docker service: sudo systemctl start docker sudo systemctl enable docker Install Docker Compose: Run the following commands to download the latest version of Docker Compose: sudo curl -L "https://github.com/docker/compose/releases/latest/download/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose sudo chmod +x /usr/local/bin/docker-compose Verify the installation: docker-compose --version macOS: Install Docker Desktop: Download Docker Desktop from the official website and follow the installation instructions: Docker Desktop includes both Docker and Docker Compose. Open a terminal and verify that Docker and Docker Compose are installed: Docker Desktop for Mac docker --version docker-compose --version Windows: Install Docker Desktop: Download Docker Desktop from the official website and follow the installation instructions: Docker Desktop includes both Docker and Docker Compose. Open a Command Prompt or PowerShell window and verify that Docker and Docker Compose are installed: Docker Desktop for Windows docker --version docker-compose --version

Supercharge Your API Testing with Postman's AI-Powered Assistant

README.FIRST This write-up is a log of the author’s personal challenge to learn the bare minimum basics of in a tight timeline for a specific purpose. JavaScript Please, take this piece as a “foundation building up reading” if you are someone like me who just want to take API testing and the automation of rigorous tasks a step further with Postman and JavaScript. The author logged the bare-minimum JS basics he thinks are needed for API testing scripting in . As such, this article omitted a good number of important topics like and loops and - flow etc. that are a must for those who want to learn JS seriously. Postman forEach while try catch The target audience of this log is SQA engineers and testers who have prior knowledge of one or two programming languages and clearly know what they are doing to get what output. Scripting Scopes in Postman: Pre-request Script and Tests Just a humble revision to the scripting scopes in is given below: Postman : In this tab, we write the scripts that will be run before making an HTTP request. These scripts include setting up and assigning environment variables, any modification of the request body, etc. Pre-request Script : Scripts written in this tab are run after an HTTP request ends. These scripts include different tests like looking for specific data in the response body, setting up environment variables for the next request/s, testing response codes and time, etc. Tests : Response body is shown in this window. We can select format options like , etc. from there. Response JSON HTML : This tab prints the request headers, errors, and any JavaScript code outputs. Console You need not to worry about running the collection. . It is available in the cloud here For this tutorial, I used test APIs in . DummyJSON Postman has a runtime that gives us the ability to modify HTTP requests dynamically. node.js The scripts we write in the Pre-request and Tests tabs are run in the Postman sandbox. The following resources are two must bookmarks for an  API tester who uses Postman Scripting in Postman Postman JavaScript reference Day 1: Variables Variables are the fundamental building blocks of a program or script. We store values in them. A variable in JavaScript can be declared using either , or keywords. var let const As I have a specific scope for writing test cases for ,  I have chosen and for brevity after doing some R&D with a JS veteran and on the internet. Postman let const Using for variables that can be changed dynamically let let x = "ASDF"; 
console.log(x);
x = [1,2,3];
console.log(x); Using for variables that should be untouched const const lifeOfGeek = {
    first: "Family",
    second: "Geeky Things",
    third: "Career"
}; 

// avoid an accidental assignment in the same scope
lifeOfGeek = {
    first: "Greed",
    second: "Drugs",
    third: "Polygamy"
};
/*
$ node lifeOfGeek.js 
{ first: 'Family', second: 'Geeky Things', third: 'Career' }
life = {
     ^
TypeError: Assignment to constant variable.
...
*/ In the following example, we will declare some JS variables, set and get environment variables in the and tabs that are the fundamental building blocks to script in the tool. Postman Pre-request Script Tests API testing Example Request: DAY_1_All_Products_VARIABLES Action : Submit The following codes are self-explanatory: tab Pre-request Script // Set an environment variable without any initial value 
pm.environment.set("eighthProduct");

// Set an environment variable with an initial value 
pm.environment.set("PI", 3.141); tab Tests // Assign response data in a JSON object
let jsonData = pm.response.json();

// Assign the 6th object to sixthProduct
let sixthProduct = jsonData["products"][5]; 
console.log("sixthProduct: ", sixthProduct);

// Assigning value to a pre-request script environment variable 
pm.environment.set("eighthProduct", jsonData["products"][7]);
console.log("eighthProduct: ", pm.environment.get("eighthProduct"));
console.log("PI: ", pm.environment.get("PI")); Sample response {
    "products": [
        {
            "id": 1,
            "title": "iPhone 9",
            "description": "An apple mobile which is nothing like apple",
            "price": 549,
            "discountPercentage": 12.96,
            "rating": 4.69,
            "stock": 94,
            "brand": "Apple",
            "category": "smartphones",
            "thumbnail": "https://i.dummyjson.com/data/products/1/thumbnail.jpg",
            "images": [
                "https://i.dummyjson.com/data/products/1/1.jpg",
                "https://i.dummyjson.com/data/products/1/2.jpg",
                "https://i.dummyjson.com/data/products/1/3.jpg",
                "https://i.dummyjson.com/data/products/1/4.jpg",
                "https://i.dummyjson.com/data/products/1/thumbnail.jpg"
            ]
        },
... Please read the section in my GitHub repository to learn more about Day 1 7_Days_of_JS JavaScript variables. Day 2: Arrays Arrays are indexed collections of the same or different types of objects. The behavior of arrays varies on the philosophy of programming languages. A JavaScript array can hold multiple types of objects in its indexes. The basics of JS arrays are available in my GitHub repository. The examples are well commented. here In the following script, we will extract an array from a JSON response and append some arbitrary data in it. Tests : Example Request Day_2_All_Products_ARRAYS : Action Send Now look at the response JSON in the tab of the response window. We will extract the array of the sixth item from it, which  holds different images of a . Body images MacBook Pro ...
{
            "id": 6,
            "title": "MacBook Pro",
            "description": "MacBook Pro 2021 with mini-LED display may launch between September, November",
            "price": 1749,
            "discountPercentage": 11.02,
            "rating": 4.57,
            "stock": 83,
            "brand": "Apple",
            "category": "laptops",
            "thumbnail": "https://i.dummyjson.com/data/products/6/thumbnail.png",
            "images": [
                "https://i.dummyjson.com/data/products/6/1.png",
                "https://i.dummyjson.com/data/products/6/2.jpg",
                "https://i.dummyjson.com/data/products/6/3.png",
                "https://i.dummyjson.com/data/products/6/4.jpg"
            ]
        }, 
... Let’s parse the JSON, extract and print the expected array in the console let jsonData = pm.response.json();
let sixthElementImages = jsonData.products[5]["images"];
/*
The above statement is equivalent to the following-
let sixthElementImages = jsonData["products"][5]["images"];
*/
console.log("sixthElementImages values: ", sixthElementImages);
/*
Expected Output 
"sixthElementImages values: "
> (4) ["https://i.dummyjson.com/data/products/6/1.png", "https://i.dummyjson.com/data/products/6/2.jpg", "https://i.dummyjson.com/data/products/6/3.png", "https://i.dummyjson.com/data/products/6/4.jpg"]
*/ Click the small arrow sign beside to expand the object for a more readable formatted view. (4) The array contains four URLs to a laptop. MacBook Pro Now, we will different types of objects into it and see the effect. push sixthElementImages.push("A Quick Brown Fox");
sixthElementImages.push(["https://discord.com/", "https://www.notion.so/"]);
sixthElementImages.push(3.1141);

console.log("After push sixthElementImages values: ", sixthElementImages);
/*
Expected Output
"After push sixthElementImages values: " 
> (7) ["https://i.dummyjson.com/data/products/6/1.png", "https://i.dummyjson.com/data/products/6/2.jpg", "https://i.dummyjson.com/data/products/6/3.png", "https://i.dummyjson.com/data/products/6/4.jpg", "A Quick Brown Fox", …]
	0: "https://i.dummyjson.com/data/products/6/1.png"
	1: "https://i.dummyjson.com/data/products/6/2.jpg"
	2: "https://i.dummyjson.com/data/products/6/3.png"
	3: "https://i.dummyjson.com/data/products/6/4.jpg"
	4: "A Quick Brown Fox"
	5: [2]
		0: "https://discord.com/"
		1: "https://www.notion.so/"
	6: 3.1141
	*/ Notice, the length of is increased from to as we pushed three new objects into it. Basic indexed operations are similar to other programming languages. sixthElementImages 4 7 An interesting twist for geeks—  a JS array is an object under-the-hood. PoC console.log(typeof sixthElementImages); Day 3: Objects Objects, a pair entity, play a vital role in JavaScript language that is used to store different types of data, variables, and functions for using them efficiently. In JavaScript, we can directly declare objects without creating a class. key:value Let’s declare a simple object. const pcConfig = { // ... 1
	cpu: 'intel i5', 
	cores: 4,
	ram: '16 GB',
	motherBoard: 'Asus',
	'operating-system': {  // ... 2
		name: 'Debian',
		version: 11, 
		bits: 64
	}  
}; Some features of an object to be noticed: It is a common practice to declare an object with for avoiding unexpected assignments. This will be elaborated on later. const Although names can be written without quotations, it is mandatory to use them if the key contains any special character or words reserved for JS. key/property Here is a PoC why we use for declaring an object const const pcConfig = { // ... 1
	cpu: 'intel i5', 
	cores: 4,
	ram: '16 GB',
	motherBoard: 'Asus',
	'operating-system': {  // ... 2
		name: 'Debian',
		version: 11, 
		bits: 64
	}  
};

pcConfig["rgbLight"] = "N/A"; 

console.log(pcConfig);

pcConfig = "ASDF"; // avoid accidental reassignment

/*
$ node objectTest.js # Expected output 
{
  cpu: 'intel i5',
  cores: 4,
  ram: '16 GB',
  motherBoard: 'Asus',
  'operating-system': { name: 'Debian', version: 11, bits: 64 },
  rgbLight: 'N/A'
}
pcConfig = "ASDF"; 
         ^
TypeError: Assignment to constant variable.
...
*/ There are two more important fundamental concepts of and copy of JavaScript objects discussed in my . The code is self-explanatory with necessary comments. deep shallow GitHub repository In the following example, we will convert a JS object into a JSON object and send the request body in a method to create an entity in the remote server. POST // Declare a JS object
const jsObject = {
  id: 1000,
  title: 'Linux Phone 10',
  description: 'Custom Linux OS on custom embeded system',
  price: 1000,
  discountPercentage: 50,
  rating: 4.99,
  stock: 150,
  brand: 'Not Applicable',
  category: 'smartphones',
  thumbnail: 'https://linuxstans.com/wp-content/uploads/2022/02/volla-phone@2x.jpeg'
};
// The type is object
console.log(typeof jsObject);

// Convert the object into a string
let jsonData = JSON.stringify(jsObject);
// Notice: They keys or properties are now in double quotes
console.log(jsonData);

// The type is string
console.log(typeof jsonData); Note: Keep in mind that JSON and JS objects are two different things. Now paste this string into the request body, select radio button and select from the right drop-down menu and finally, click the button to make the string more readable. POST raw JSON Beautify Example Request: Day_3_POST_Add_Product_OBJECTS Action: Submit JSON in tab after beautification Body {
    "id": 1000,
    "title": "Linux Phone 10",
    "description": "Custom Linux OS on custom embeded system",
    "price": 1000,
    "discountPercentage": 50,
    "rating": 4.99,
    "stock": 150,
    "brand": "Not Applicable",
    "category": "smartphones",
    "thumbnail": "https://linuxstans.com/wp-content/uploads/2022/02/volla-phone@2x.jpeg"
} Day 4: Loops A loop repeats the workflow of a code block for a limited or infinite time. There are four types of loops in JavaScript for Conventional .. loop for in .. loop for of loop that calls a callback function to control the workflow forEach I will discuss and in a  future article. forEach while The syntax of the first three type of loops are: for // Conventional
for(let i = 0; i < lengthOfArray; i++){
    //codes here
}
// for .. in
for(index in object){
    //codes here
}

// for .. of
for(object of objectCollection){
    //codes here
} A rule of thumb to remember the .. vs .. is for in for of an of .. returns the index of an object in for in an of .. returns the value or object of a collection of objects of for of Day 5: Flow The basic execution flow of a JavaScript code is controlled by blocks. if else The following code chunk written in the block filters outs odd-number product ids that are divisible by and Tests 15 23 : Example Request Day_5_All_Products_FLOW : Action Send let jsonData = pm.response.json();
let productsArray = jsonData["products"];

for(element of productsArray){
    // Filer the odd ids that are divisable by 15
    if(element["id"] % 2 !== 0 && element["id"] % 15 === 0){
        console.log(element)
    }

    // Filer the odd ids that are divisable by 23
    else if(element["id"] % 2 !== 0 && element["id"] % 23 === 0){
        console.log(element)
    }
}

/*
Sample Output 
{id: 15, title: "Eau De Perfume Spray", description: "Genuine  Al-Rehab spray perfume from UAE/Saudi Arabia/Yemen High Quality"…}
 
{id: 23, title: "Orange Essence Food Flavou", description: "Specifications of Orange Essence Food Flavour For Cakes and Baking Food Item"…}
 
{id: 45, title: "Malai Maxi Dress", description: "Ready to wear, Unique design according to modern standard fashion, Best fitting ,Imported stuff"…}
 
{id: 69, title: "Golden Watch Pearls Bracelet Watch", description: "Product details of Golden Watch Pearls Bracelet Watch For Girls - Golden Chain Ladies Bracelate Watch for Women"…}
 
{id: 75, title: "Seven Pocket Women Bag", description: "Seven Pocket Women Bag Handbags Lady Shoulder Crossbody Bag Female Purse Seven Pocket Bag"…}

*/ I will discuss and in a future article. try catch Day 6: Functions A function is a group of codes that we can reuse in a scope. This is the very first concept of code re-usability. The format of a function in JavaScript is given below function functionName(param1, param2, ...){
	// Codes here 
	return returnValue1, returnValue1, ... ;
}

// Calling a function
functionName(param1, param2, ...); Let’s write a basic function in the tab that will check if an input is a prime number or not. Tests function isPrime (number) {
	let prime = true;
	if (number === 1 || number === 0) {
		return prime = false;
	}

	for (let i = 2; i < number; i++) {
		if (number % i === 0) {
			return prime = false;
		}
	}
	return prime;
} Now, we will use this code block in a Postman request to filter out products that have a prime number price value. : Example Request Day_6_All_Products_FUNCTIONS : Action Send let jsonData = pm.response.json();
let productsArray = jsonData["products"];
console.log("Products that have prime no. price values")
for(element of productsArray){
    // Filter prices that are prime in vlaues
    if(isPrime(element["price"])){
        console.log(element);
    }
}

/*
// A truncated view of the output in the Console

> {id: 69, title: "Golden Watch Pearls Bracelet Watch", description: "Product details of Golden Watch Pearls Bracelet Watch For Girls - Golden Chain Ladies Bracelate Watch for Women"…}
...
id: 69
title: "Golden Watch Pearls Bracelet Watch"
description: "Product details of Golden Watch Pearls Bracelet Watch For Girls - Golden Chain Ladies Bracelate Watch for Women"
price: 47
...
*/ Wrapping it Up So far this was my 7-day journey to explore the tip of the JavaScript iceberg. In the next installment, I will come back with the basics of how to write test cases in Postman using JavaScript along with other necessary API testing tips and tricks. I also wish to make Bangla video tutorials on API testing with JS and Postman in the future. Until then, ! Happy Hacking

JavaScript for Testers Part 1: JS Basics for Postman

Being featured on Postman is like hitting the jackpot for your API product! You get more eyes on your stuff, you get to network with other cool API developers, and you even get to market your API to a crowd that's actually interested. And, on top of all that, your search engine ranking will probably get a boost, making it easier for people to find you. Create a killer collection Postman has a lot to offer for API users, and as a product manager, you can leverage these features to make a better developer experience for your products. Collection Structure Organize your collection using folders and endpoints to make it easy for developers to navigate through your API products and use its features: Use pre-request scripts Postman offers the option to write scripts in Javascript that can help developers to get started with your API. The scripts can include all of the query parameters and headers required to use the API so the developer can immediately make a successful API call: Moreover, the script itself can be used as an API code example and with the power of Postman supported languages you instantly get code examples in various programming languages: Test, test, test Before you share your collection, make sure to test it thoroughly. Ensure that all requests are working as expected and that the responses are coming back as you expect. Check for typos and other errors, and make any necessary corrections. Review team settings Update your team name Update your team domain Add icon, favicon, and banner Make sure the profile is public Add highlights and description Make it public First create a public workspace: Then go to your collections settings page and move it to the public workspace: Wait Not really… Once your collection is ready, share it with the Postman community, create a github repository for it, and promote it on your website and social media channels. Ask your users for feedback and be open to suggestions for improvement. Get Featured 🥳

How to Get Featured on Postman

Introduction If you are testing the backend you need some tools, because you don't see what are you testing. These are tools you can use during testing API. I guess one of the best tools for API testing is Postman. But today we will consider the best alternative to this popular tool. Especially likes those who work with Postman all the time. Postman First, I'd like to describe the best features of Postman. Creating collections and it's running in automation mode through Newman. Saving different environments and quick switching between them during backend testing on various stands. Sharing your collections and environment with your team members. Support working on all platforms (Windows, macOS, Linux). Integration with CI/CD pipelines. The question is, do you think it possible to support all those functions for free? Of course not. And Postman has some functions only in the paid version. But what about open source similar projects? Maybe they are also good. I'll try to discuss one of them. Hoppscotch Hoppscotch is a lightweight, web-based API development suite. It was built from the ground up with ease of use and accessibility in mind providing all the functionality needed for API developers with minimalist, unobtrusive UI. It is free to use and as an added perk completely Open Source. Look at that. I guess there is only one difference from Postman. Hoppscotch is web-based and does not require installation on the machine. All others are the same, including the interface. But if you will try to use it some restrictions could be found. For instance, working with your created data is not possible simultaneously as a whole team. It presents but does not work. And contributors of Hoppscotch said that they won't supply it.
I'm not accusing developers of Hoppscotch because I think not too easy to realize these features. You need to supply some cloud servers for it. And it costs a lot of money. Let's try to use this option step by step. You open a web-based version and start to work. You are creating some API requests, combining them in the collections, and saving some different environments. After that, you are deciding to save it all and share it with your team member. First of all, you must create your account and there are a few options. One of them is email. And that brings us to the magic part of Hoppscotch because you need every time to use the magic link from an email. Sometimes emails come into the spam folder. But in the end, you can't work with this feature because there is no team in your account. Decision If you hear about open source projects try to think about who will pay for them. If it's totally free most reasonable that this product will no such good as paid competitors.

API Testing Without Postman?

¿Pruebas de API sin cartero?

Postman is a REST client tool for testing and deploying API services in a controlled workspace. Postman simplifies collaboration at each step of the API lifecycle, to help you manage an API repository down to its specifications, documentation, and various test cases. This platform utilizes intelligent tools that gather valuable insights on your API processes and is compatible with integrated software for storing source code, diving into CI/CD pipelines, monitoring performance data, triggering incident alerts, and much more. A API is ready to use whenever you initiate a REST service on a remote server via a file format. If you need to download, upload, or visualize files, that can be done through a Postman template. It will accept files written in any programming language, although HTML is optimal for viewing the content in web browsers. Postman upload file Let’s take a closer look at the file processing feature in this next tutorial. How do you upload a file using Postman? Begin by calling the API using a to launch a Postman template. Create a file processing method under the collections tab with options to upload, download, or visualize the specified file. POST HTTP request Uploading the file is fairly straightforward: Make a , delete the body contents, and construct a form data body to see the file as it’s being uploaded. postman echo request Then, click on “body” and as the body type. Assign a key to the file value so it reflects to “ ”. Click on that to open a window menu and find your file. select form-data select files Click open and the file will be automatically uploaded onto Postman. It should add a header and set the content type to multipart form data. Once you press send, a response is generated in the terminal which has the file path and its string value in a raw format. Encoded in base64, it preserves the integrity of your file as it gets sent over the internet and allows you to view the contents within text applications. The metadata below shows the file type. Uploading a file to the repository is not the same since you’re calling the request from your Postman workspace. and be sure to add your API call to the request. From the Body tab, and the file you want to upload. Click on send so it appears in the file object. Create a PUT request choose form-data What is the Filestack Upload API? Filestack Upload lets users import files directly into their apps on any mobile device, where user content is prepared by converting images, files, and videos into their optimal sizes. Filestack serves as a CDN that adapts to changing network conditions while shaving seconds off of every file download. You can actually customize the file uploader itself with just two lines of code, and watch as the UI configures to your preference. It has advanced tools to accelerate the upload speed, up to four times faster. Accessing files on Filestack is relatively easy: Drag and drop a selected file onto the demo area and auto-display the contents in a preview that connects directly to the source where users are able to download it. Buttons and links can be turned into a file dialog with only a code snippet. Another impressive feature of Filestack is its support for real-time captures of photos or audio recordings. To test it out inside an app, click on the icons to pull up a menu and grab files on social media, dropbox, or from the cloud. How would you upload a file on Filestack? Performing basic uploads on Filestack is easier than you think: To prepare a file for delivery, you’ll be asked to send an HTTP request from that file to the cloud. This can be done through the File API, which requires pointing all requests to https://www.filestackapi.com/api/file. You may have to enable security for the API by declaring the query parameters or passing the user id and password to the server. A Filestack CDN is necessary for running GET requests on the browser to download a file. You only need the Filestack handle in the method URL. On the command-line tool Curl, you would normally have a header with the content type as an image/png and include the API key after the Filestack URL. curl -X POST \

    --data-binary @filename.png \

    --header "Content-Type:image/png" \

    "https://www.filestackapi.com/api/store/S3?key=MY_API_KEY" However, there is another method involving the Postman workspace. To see it in action, simply launch Postman in your web browser. Open the tab and click “New” to create an HTTP request. Select the method type to enter the upload request URL from Filestack after the header. Collections POST Head over to the tab and select . Input the file name where it says “key” and select the file option on the dropdown. Body form-data Click to upload a file from your desktop then hit the send button to print the HTML inside the body. Be sure to set the from the tab by assigning it a value of or else the file may not parse correctly to construct the preview. Select Files Content-Type Headers image/png You would need to specify the following as shown in the sample response: {

  "url": "https://cdn.filestackcontent.com/s7tdGfE5RRKFUxwsZoYv",

  "size": 8331,

  "type": "image/png",

  "filename": "watermark.png",

  "key": "a1RyBxiglW92bS2SRmqM_watermark.png"

} Here are the in order: The URL displays a path to the Filestack CDN where the file information is stored on a local server. The size indicates the file size value. query params Type shows the image file type and is usually a PNG or JPG. The filename is the name assigned to a stored file whereas the key identifies the root path using the API key. What does Filestack bring to the table that makes uploads faster and safer? Filestack has all the capabilities of a top-performing file uploader, making uploads 3 times faster and 100 times more secure. With this API, you no longer have to worry about file uploads revealing a disorganized mess, because we are hosted on a global network in which files are delegated to the nearest ingestion point from users like you. We know that many CDNs only accelerate downloads so we’ve decided to improve upload speed by converting larger files while they’re in the middle of transit. On the CIN, your media files are uploaded asynchronously once it reaches the final destination, using a filelink that points to your cloud storage location. Filestack measure up quite well against other providers if you factor in the delays normally caused by poor network conditions responsible for request loss. Lastly, the Filestack Intelligent Ingestion will let you test networks on files with anywhere from 3 – 42 MBs of data. If you’re serious about replacing your old uploader, then you’re really going to appreciate a built-in service with less maintenance at a reasonable cost. by jenniferl Originally posted at . https://blog.filestack.com/api/beginners-guide-postman-file-uploads

A Beginner’s Guide To Postman File Uploads

Hello everyone! Postman is one of the most popular API testing tools - it combines the ability to test things manually and add some sort of automation to it. In this article you’ll know how to best organize your Workspace in Postman - it’ll help you faster reach any request your need and get rid of some manual tasks like renewing your authorization token. So let’s begin with the creation of a new Workspace! Environment Usually, there are at least a few environments in most of the projects - (where developers upload their features first and might test them on their end), (platform for QA verification) and , of couse. development staging production Every environment has a bit different base url, but path (route) usually stays the same. For example: - production https://example.com/some/route - https:// .example.com/some/route staging staging - https:// .example.com/some/route development dev See? In case of and environments - they simple have subdomains assigned, but the path (some/route) stays the same. It means that base url is one of our first candidates to become an - a value that changes between environments. staging development environment variable Usage of base url as an environment variable let us use a single template in Postman to send a request to any environment that we have configured in our collection. Now let’s create a new Environment and name it . These are the variables that we’re going to add: Production baseUrl value - https://paysis.herokuapp.com base url of test application that we’ll use in current article token authorization token - it’ll be updated dynamically, so it must be empty for now login value - adminius login for auth request password value - supers3cret password for auth request And don’t forget to click button to save our current progress with the environment. Save Production Collection Now it’s time to create a Collection to organize our templates - it is as simple as our previous step with environment variables. Let’s name new collection and select as an since this is the one that current application use. Below, in section, enter environment variable (don’t forget to put parentheses as well - that’s how you address to environment variables in Postman). After that select the Environment that we created in our previous step. Paysis Bearer Token Authorization Type Token baseUrl Once again, don’t forget to Save current collection - either press ( ) / ( ) or click (three dots) button. Control + S Windows / Linux Command + S MacOS View more actions Our Authorization config will be applied for every request in the current Collection automatically. Authorization Let’s create our first request - this one is going to be an authorization request which makes our further testing possible (since we need an authorization token to send other requests as an authorized user). To create a new request template - simply click right mouse button on your Collection name in list and select . Let’s name this one . Add Request Auth It is a request to endpoint with body: POST /auth JSON {
  "login": "{{login}}",
  "password": "{{password}}"
} , and are environment variables there that are taken from environment that we’ve created earlier. baseUrl login password Production There’s one thing that we’d want to automate here - update environment variable with a value from this request’s response, so we can reuse this value in other requests that must be executed under authorized user. To do that, let’s go to tab in current request and paste this code there: token Tests var responseData = JSON.parse(responseBody);
postman.setEnvironmentVariable("token", responseData.token); This section is there for small automated tests and scripts (just like the one that we already implemented). It accepts only. Once you’ll send a request - code from this section will be executed. JavaScript By the way, since this request doesn’t require any authentication header - we must remove it (because it was automatically applied by collection). To do that - simply go to tab of current request and select No Auth in the dropdown. Authorization Now it’s safe to execute our first request in the collection - hit button. Send Once you’ve done that - you’ll see authorization token from response in your current environment. This variable with your token will be included by default in your future requests of the current collection. Auth Functional Separation of Requests After some time you’ll see that your collection is growing and it’s hard to find a request that you need in this mess. It’s better to separate requests by groups (sub-collections of collections) right from the start. For , we have request in the root of the collection. For other logic ( , , ) there are sub-collections. Paysis Auth Users Transactions Config Don’t forget about proper naming of requests so other people could find whatever they need as well. Summary So here’s what you need for the best experience with : Postman Use in your workspace to adapt your requests to various environment. environment variables Add that automate data transitions between requests (like sharing authorization token from request into all other requests). scripts Auth Create and . sub-collections name your requests properly Thanks for reading, I hope you’ve learned something new!

Get Your Postman Workspace Organized

Kubernetes is the most widely used container-based orchestration platform today. Practitioners are often segmented by specialty: Application Developer Administrator Security Specialist According to the currently in-progress , one relevant discovery is that Kubernetes deployments do not live in isolation. Kubernetes Usage Report 2021 Most organizations are . running a combination of bare metal, VMs, and Kubernetes Due to the persistent need to manage heterogeneous infrastructure, Kubernetes specialists are often tasked with other job responsibilities. How do we wrangle the dissonance in application deployments, administration, security, and orchestration? The reality is that we're . saddled with the necessity of integration APIs all the way down Today, the communication and interaction possibilities are endless: B2B partner services Data migration Legacy system reuse (blah blah blah) APIs are the raw materials we piece together to make this magic happen. This is what's driving so much adoption of quirky mashup delights. It's not just shiny object obsession, though if we're honest with ourselves, our little raccoon paws have a wandering mind of their own. 🦝 APIs are not just glue code. They enable value chain optimizations through platform ecosystems. Here's what we're going to accomplish: Get a Kubernetes cluster up and running Build a server to fetch local Kubernetes resource files Run a proxy to the Kubernetes API Server Use Postman to deploy our application Get ready! Oof. Feeling a bit yikes? We're using a lot of buzz words here. It's important to note that some familiarity with Kubernetes, CI/CD pipelines, and GitHub would really be beneficial to following along. Pulling the strings of Kubernetes Okay, okay, okay... Let's get to it. Here's our inventory: Kubernetes kubectl Postman Deploy to Kubernetes Postman collection Sample repository Here's what we're looking to accomplish: Most people are familiar with using the CLI to send commands to their cluster. Fun fact: is just using APIs under the hood. Don't believe me? Tack to the tail end of any command, and let the HTTP wash over us. 🌊 Kubernetes is an API-driven container orchestration platform. kubectl kubectl -v=8 kubectl Now that we know we can make API calls to pull the strings of Kubernetes, let's see what we can do in Postman. Here's to follow along! a public workspace Let's step through what's going on here. 0. Pre-requisites First and foremost, we'll need a Kubernetes cluster. Cloud providers offer managed options that are relatively quick and easy to get up and running. For this walkthrough, we'll be using . One of the easiest ways to get an Amazon EKS cluster up and running is to use the . Amazon Elastic Kubernetes Service (Amazon EKS) Amazon EKS Quickstart CloudFormation template Once our cluster is up and running, we'll need to create an SSH tunnel to our bastion host. Using default security options with the Amazon EKS Quickstart template, only the has access to . This prevents outside access to our precious Pods. However, we'd like to use on our own workstations so we can test our integrations. Scott Lowe has an easy-to-follow blog post on how to do this: . bastion host kube-apiserver kubectl Using kubectl via an SSH Tunnel Before we get started with local testing, there are a couple of servers we need to run. If the Postman collection is going to deploy Kubernetes resources, it needs a way to access those resources. Furthermore, we need a way of accessing the Kubernetes API. These will require setup for both local testing and testing in our CI/CD pipeline. Proxying kube-apiserver In Kubernetes, validates and configures data for the cluster. It's exposed via a REST API and is the front door by which we'll enter. The CLI has , and we'll utilize the default URL for our local testing. kube-apiserver kubectl a built-in way to run a local proxy http://localhost:8001 When we run our Postman collection in our CI/CD workflow, we'll be where we'll use a different URL, . Don't worry. These URLs can be set as variables in Postman and changed depending on our execution environment. accessing the API from a Pod https://kubernetes.default.svc Local kube-resource-server We're going to run a local server in our CI/CD pipeline that's going to conveniently serve the Kubernetes resources over HTTP! One benefit of this is that we can actually use this server when testing our collection run in Postman. Here's a quick implementation in Node.js. After initializing a new Node.js application, be sure to install a couple of dependencies. mkdir -p ci/kube-resource-server && cd ci/kube-resource-server
npm init
npm install express ys-yaml After we have our new Node.js application and our dependencies, let's write a basic HTTP server that will aggregate Kubernetes resource YAML files and return them as JSON. Our Postman collection will use these JSON representations to deploy to Kubernetes. // ci/kube-resource-server/server.js

const fs = require("fs/promises");
const path = require("path");
const express = require("express");
const yaml = require("js-yaml");

// NOTE: Change this directory to match where our
// Kubernetes resources live. This assumes they're
// in the root of our project under the "kubernetes"
// directory.
const resourceDirectory = path.join(__dirname, "..", "kubernetes");

const app = express();

app.get("/resources", async (req, res) => {
  const canAccess = fs.access(resourceDirectory);
  if (!canAccess) {
    console.error(
      `The resource directory cannot be accessed: ${resourceDirectory}. Returning an empty array ([]).`
    );
    return res.json([]);
  }

  try {
    const files = await fs.readdir(resourceDirectory);
    const resources = files.map(async (file) => {
      const f = await fs.readFile(path.join(resourceDirectory, file), "utf8");
      const converted = yaml.load(f); // convert YAML into JSON
      return converted;
    });

    res.json(await Promise.all(resources));
  } catch (err) {
    console.error(err);
    res.json([]);
  }
});

const port = process.env.PORT || 3001;
app.listen(port, () => {
  console.log(`Listening on http://localhost:${port}`);
}); Now let's start this server before we begin testing. # in our ci/kube-resource-server directory
node ./server Remember the URL for the kube-resource-server (default: ). We'll need it later. This one stays the same whether running locally or in our CI/CD workflow. http://localhost:3001 While we're at it, let's run that Kubernetes proxy, too. kubectl proxy Next, we'll walk through each part of the Postman collection. Then we'll work on actually running it! 1. Initialize This step is only necessary when running in the Postman Collection Runner. With Postman, we want to enable both a real-time developer experience a way to automate collection runs via the command line. To do that, we'll use . For now, let's see if we can make some API calls! and Newman This step resets all collection variables that are required for the collection run. When running in Newman, we'll skip this step by only running the Run folder from this collection. 2. Fetch resources from the filesystem Finally, we get to use our nifty little Node.js server! If it isn't already running from the instructions earlier, go ahead and fire it up now. In order for this to be successful, we need to add a couple of Kubernetes YAML files to our directory. ci/kubernetes The deployment... # ci/kubernetes/deployment.yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: jsonplaceholder
  labels:
    app: jsonplaceholder
spec:
  replicas: 1
  selector:
    matchLabels:
      app: jsonplaceholder
  template:
    metadata:
      labels:
        app: jsonplaceholder
    spec:
      containers:
        - name: app
          image: svenwal/jsonplaceholder
          ports:
            - containerPort: 3000 And the service... # ci/kubernetes/service.yaml

apiVersion: v1
kind: Service
metadata:
  name: jsonplaceholder-svc
  labels:
    app: jsonplaceholder
spec:
  ports:
    - port: 3000
      protocol: TCP
  selector:
    app: jsonplaceholder 3. Deploy using the Kubernetes API Once we've got everything in place, we're ready to hit the Kubernetes API and deploy our application! The Kubernetes API can be fairly complex at times. Luckily, we already have these requests ready in Postman, and we can re-use them across all of our projects. Apps, roll out Now that we have an understanding of the collection workflow, let's take a look at the variables that make this all work. Variables Required to access the Kubernetes server and the resource server that will run in the CI/CD pipeline. - The URL for Kubernetes. If you're testing locally, you should have running, and the URL should be . If you're running this collection in Kubernetes, the URL should be . kubeBaseUrl kube proxy http://localhost:8001 https://kubernetes.default.svc - The default namespace to create/update resources. If the resource has a field, that takes precedence. kubeNamespace metadata.namespace - The URL to the service that will run in your CI/CD environment. It can return resources that can be deployed (e.g., deployment and service YAML files stored in your code repository). resourceBaseUrl - Kubernetes server-side apply requires field management. fieldManager - Only needed if resources were previously created/updated by something other than Postman, such as . More information here: . forceUpdates kubectl Server-Side Apply These can all be overridden in an environment. Here's a snapshot for a local configuration. The big reveal And finally, cue the drum roll... 🥁 When we , not only do we see all the API calls being made, we also see test execution happening for each call. The test results we see are verifying the success of our application deployment. run the collection Now, if everything worked correctly, the service should be accessible via the proxy at . http://localhost:8001/api/v1/namespaces/default/services/jsonplaceholder-svc/proxy/posts/ We did it! Finally, we have API testing for our integrated deployment environment. To put a bow on all this, we can actually automate Postman collection runs in our CI/CD pipelines using an open source CLI called . All we need to do is . Newman integrate our Git repository with an API version in Postman Here's an example of running this same collection from within a Pod in our Kubernetes cluster! There's a lot more to this, but that's a whole 'nother post. newman run \
  --folder=Run \
  --env-var=kubeBaseUrl=https://kubernetes.default.svc \
  --env-var=token=$(cat /var/run/secrets/kubernetes.io/serviceaccount/token) \
  --ssl-extra-ca-certs /var/run/secrets/kubernetes.io/serviceaccount/ca.crt \
  --verbose \
  "./postman/collections/deploy-to-kubernetes.json" Going beyond This just scratches the surface of what's possible with API-driven deployments. Here are some ideas for upgrading our workflow: Canary deployments with manual job approval. More complex orchestration with databases and message brokers. Environment promotion with Slack notifications and the CircleCI API. API-driven automation allows us to use existing tools and infrastructure, leveraging the investments we've already made. This isn't shiny object syndrome. It's perseverance. Still, it probably wouldn't hurt to just the next shiny thing... 'Til next time! ✨ try *: This post mentions Postman. I work there. 🚀* Disclaimer

How to Automate Kubernetes Deployments with Postman

Introduction Whether you’re a longtime Salesforce developer, new to the platform, or just need to integrate your system of choice to Salesforce, Postman brings you all the tools you need to make the process easier, faster, and more streamlined. In this article, we’ll show how Postman can help you start building the core of your API-driven integration on sides of the API—either as the provider or the consumer. both Developing Salesforce APIs While Salesforce has several pre-built applications for key business tasks such as Sales, Service, and Marketing, in this post we’ll focus on the capability of Salesforce as a development platform, with its own programming language: Apex. Salesforce can expose custom-coded services to third-party applications, either as SOAP web services or REST APIs. In our demo, we will develop a very lightweight REST API and demonstrate how Postman can speed up that process. How Postman accelerates development One of the most popular use cases for Postman is to explore the API of third-party apps, to better understand how to submit requests, and what to expect for responses. By seeing the requests and responses, developing your own code for handling these APIs becomes much easier. We can also develop a mock server implementation of our own API, one that generates expected responses. In this way, we don’t need to wait for a “real” implementation of the API before we can start developing for it. By using Postman’s tools for API development, we can rapidly prototype a Salesforce REST API the API—and the code that uses it—has completed development. before Bringing it Together As our first step, we'll use one of Postman’s most powerful features: mock servers. Mock Servers A mock server is a lightweight server interface that responds to your API requests realistically, allowing you to quickly and easily get a valid response without worrying too much about the details. With Postman, you can start a mock server that responds to HTTP requests of your design in a very short time, with no coding required. By pointing your code at this mock server, you can write and test your API consumer code. We’ll be using the Desktop client for our examples, but everything here should be equally applicable with Postman’s web client. Mock Servers can be found within your Workspace in Postman. Creating and Configuring the Mock Server Click on to get started. Create Mock Server Next, we can start defining the HTTP requests we’d like to mock. By specifying the HTTP request method, URL, response code, and response body, we can tell Postman how to respond to requests. In this example, we’re mocking a request for a Salesforce Account record. Rather than hardcoding a Salesforce account , we’re using Postman’s ability to use variables. By matching the variable in both the request and the response, we can return whatever value was supplied in the request. id We’ll use this feature in more detail later. For now, we will just mock that one request and click the button to finalize our Mock Server setup with a few more parameters. Next Besides naming the mock server, we’ll just stick to the defaults and click the button. This will create our mock server instance with a unique URL for receiving requests, as illustrated below. Create Mock Server We selected the option to save the mock server URL as an environment variable, however, there is an easier way to reference this. If we expand the environment dropdown in the top-right of Postman, we will see that an environment was automatically created for us. If we select this environment, the mock server URL is automatically populated for us in a parameter called . The process of creating a new mock server also created a new Postman collection for us. That collection has our request, and the request is ready for us to populate with parameters where applicable. {{url}} When we select this request, we see the user interface for building our request. By replacing the variable in the request with an example and sending the request, we should receive a response from our Mock Server that repeats that back to us. {{accountId}} id id Extending the Mock Response Now that we have our basic mock server working, we can extend the responses to be more meaningful and realistic. Expand the example request in our collection from the Workspace tree view, and click on the example (currently called “Default”). We’re going to make some changes to how the mock server responds to this request. The field is not essential. We’re just simulating how Salesforce would respond. attributes In the response body tab in the bottom section, replace the contents with the following JSON: {
  "attributes" : 
    {
      "type" : "Account",
      "url" : "/services/data/v53.0/sobjects/Account/accountId"
    },
  "Id" : "{{accountId}}",
  "Name" : "{{$randomCompanyName}}"
} Note how we made use of Postman’s convenient variable. Many useful variables can be used to generate example data, documented . $randomCompanyName here In the response headers tab in the bottom section, add a key with the value . Content-Type application/json Click to update the example response. The mock server will now respond with the updated response to the request we made earlier. Save At this point, we can add additional requests and examples to our collection. Click the ellipsis ( ) icon next to our collection name and select to generate a new one. Then, click the ellipsis icon next to the new request and select . This adds a new example response that the mock server will serve to your request. You can build a new mock server response in the same way as previously—by specifying new paths, HTTP verbs, and responses—until you’ve drafted your API.  At this point, we can even test the API from outside of Postman - one of the quickest ways to do this is via Postman’s code snippet functionality.  This allows for equally rapid development of code to consume the API. ... Add request Add example Snippets Postman provides example code for calling your APIs, mock or otherwise, in several languages and libraries. With a request selected in your workspace, click the icon on the right to expand the code snippet menu. From here, you can select a suitable language/library combination and see the example code to call your API. </> is enabled for Postman mock servers. As a result, you can stub your web apps with mocked data using the mock endpoints. Development or production web apps can then make requests to your Postman mock endpoint and receive example responses. CORS The code snippet will resolve variables where it can. In our example, where we use the variable to reference our Mock Server, this is expanded for us. This is shown in the JavaScript Fetch code example below. {{url}} this code snippet, as generated from Postman, has a small error.  HTTP GET requests sent via Fetch should set a body in the request.  For our testing, we will need to remove line 5 in the example above.  Below is the updated code, wrapped in a lightweight HTML page. Important note: not <html>
    <head>
        <script>
            var raw = "";

            var requestOptions = {
            method: 'GET',
            redirect: 'follow'
            };

            fetch("https://768bb73c-2824-49fa-8787-3967ce6ea0c1.mock.pstmn.io//Account/001000000WCFB8", requestOptions)
            .then(response => response.text())
            .then(result => console.log(result))
            .catch(error => console.log('error', error));
        </script>
    </head>
    <body>
        <p>Check the browser console to see the output from our mock server.</p>
    </body>
</html> Summary In this article, we’ve looked at the basics of setting up a Mock Server in Postman—from creating the mock server and a sample response to extending it with more meaningful JSON data and adding additional responses. We’ve also seen how simple it is to generate code snippets that show how to consume the API in the language/platform of your choice. Code snippets greatly aid the development of your own tools that utilize your API. With the tools that Postman provides, we can provide a technical requirement to both our Salesforce developers implementing the API and our developers on other platforms communicating with Salesforce as part of an integration. There is a wealth of further resources available for working with both Postman and Salesforce. Some of the ones relevant to what we’ve covered here can be found below: Building a mock API Mock Servers: The Exploratory Integrating With a Custom Salesforce App in Postman Exposing Apex Classes as REST WebServices Salesforce Trailhead: Postman API Client

Build a Lightweight REST API with Salesforce and Postman

Introduction Whether you’re a longtime Salesforce developer or you’re new to the platform, Postman brings you all the tools you need to streamline the Salesforce API integration process to be easier and faster. In this article, we’ll show how mock servers and code snippets in Postman can help you build the core of your API-driven integration with Salesforce. About the Salesforce API If you’re unfamiliar with Salesforce, think of it as a cloud-based development platform. It has several pre-built applications for key Salesforce-related business tasks. However, for this article, we’ll focus on its capabilities as a development platform. There are several Salesforce APIs available, many of which are specialized for key use cases or Salesforce products. The for all the APIs is extensive. Salesforce can also present your own developed code as a REST or SOAP APIs for use by other applications and services. documentation There is also a for exploring the various APIs that Salesforce exposes.  We’ll look at this collection and build a mock server within Postman to simulate responses from Salesforce. Postman collection About Postman Postman is like a powerful Swiss army knife for all things API-related—developing your own APIs, developing code that uses other APIs, or a mixture of both. One of the most practical use cases for Postman is to explore third-party APIs, to better understand how to submit requests and work with the subsequent responses. By seeing the requests and responses, it becomes much easier to develop your own code for handling these APIs. Bringing it Together By using Postman’s tools for API development, we can rapidly prototype the use of the Salesforce APIs ahead of the full development of the production code that will use them. To achieve this, we'll use one of Postman’s most powerful features—mock servers. For this article, we’ll use the Desktop client, but everything here is equally applicable within the Web client, with one additional step. In order to meet the requirements of Salesforce CORS (Cross-Origin Resource Sharing) security requirements when using the Web client, you must add Postman to the list of Allowed Origins in Salesforce. You can find details on how to do this step . here Installing the Salesforce API Collection The easiest way to install the collection is to click on the box at the top of the app and enter . You’ll see many results, but the one we’re interested in is by Click on its name on this list, as shown below: Search Postman Salesforce Salesforce APIs Salesforce Developers. On the next screen, we need to fork the collection to our own local workspace. Simply click the Fork button and, when prompted, give your copy a name to use locally. Once installed, you should see the collection appear in your workspace, and you can expand it to see the various API requests contained in the collection. Configuring the Collection While it is perfectly possible to develop API code and mock servers against Salesforce without access to Salesforce, it is easier if we have a real Salesforce org to work with. much In your browser, of your own. We’ll be working within the Salesforce development environment. (In Salesforce terminology, this is called a “sandbox” or a “scratch org”.) sign up for a Developer Edition account and org Once you have a Salesforce org to work with, switch back to Postman and select the Salesforce API Collection again. In the Variables tab, ensure the URL parameter has the set to . In the Authorization tab, click on . Log in to Salesforce with the username and password you created when setting up your account. When prompted, allow access for Postman. Current Value https://login.salesforce.com Get New Access Token Once you are redirected back to Postman, copy the parameter to your clipboard before clicking the button. instance_url Use Token Return to the Variables tab and populate the variable’s with the instance URL from your clipboard. Click . Your collection is now configured! _endpoint Current Value Save Mock Servers A mock server is a lightweight server interface that responds to your API requests realistically so that you can quickly and easily get a valid response without worrying about the details. With Postman, you can start a mock server that responds to HTTP requests of your design—quickly and without any coding required. By pointing your code to this mock server, you can write and test an API consumer even without having a full API implementation ready. Mock servers can be found within your Workspace view in Postman. Creating and Configuring the Mock Server While Postman allows us to create a mock server from scratch—and there are many use cases when this makes sense—we will create a mock server from the Salesforce API collection for now. Click the ellipsis icon ( ) next to your newly-forked collection and select . ... Mock collection Give the mock server a name, and stick with the defaults for all other options. Click the button. This creates our mock server instance with a unique URL for our requests’ destination: Create Mock Server Since we selected the option to save the mock server URL as an environment variable, however, there is a convenient way to reference this URL. When we expand the environment dropdown in the top-right of Postman, we see that Postman automatically created an environment for us. If we select this environment, the mock server URL is automatically populated for us in a parameter called . Next, we need to handle some other config variables we’ll soon need. {{url}} As we’ve created a mock server from the existing Salesforce collection, there are several mock responses already in place. Postman calls these “examples” because they serve as an example of how to call a particular API method, along with the response it returns.  Our mock server uses these to provide responses that match the requests. For example, if we expand the request under the section, we see an example that has been pre-created for a successful login. OAuth Username Password Auth Variables and Parameters in Postman When constructing requests in Postman, it’s useful to substitute various settings and parameters with variables. We already saw this in action when Postman created the parameter automatically for us. There are several key types of variables that can be used in Postman to simplify our requests, and these can be categorized by . {{url}} scope Scope defines where a variable is available, much like the concept of scope in programming languages. Variable scope can be (in order of narrowing breadth): Global: visible across an entire workspace, and so visible across all collections in your workspace Collection: visible to all requests in a collection, regardless of the environment Environment: visible only to a particular environment. For our purposes, this will be particularly useful for differentiating between our Mock Server endpoint versus a real Salesforce Org (whether that is a Sandbox or a Production instance). Data: variables sourced from external CSV or JSON files Local: visible only to a specific request and only at runtime. The variable is no longer available when the request is complete. It’s important to note that these are prioritized by : For example, if you had a collection-level variable and an environment-level variable , then the environment variable would be used. narrowest scope first {{url}} {{url}} In addition to the variables, there are different ways to specify parameters for our requests: Query parameters: these are appended to the end of the URL (for example, ). ?id=1&type=new Path parameters: these form part of the URL itself and are referenced by putting a colon in front of them (for example, ). /contact/:id The Salesforce API collection, by default, uses the collection-level variable to specify where the API requests should be sent to. It also uses the collection-level variable to handle authentication, as it allows us to differentiate between a production or sandbox instance. However, our mock server auto-created an environment-level variable also called for the address of our mock server. {{_endpoint}} {{url}} {{url}} You’ll recall that the narrowest scope “wins”. Therefore, in these scenarios, if we’re running in the environment that the mock server created for us, would represent that mock server address. If we were running requests from the Salesforce API collection in any other environment, then the collection-level variable would be used. {{url}} With this information, we can easily update the requests in the Salesforce API collection to use instead of when we want to work in our Mock Server environment. {{url}} {{_endpoint}} Adding Mock Responses Now that we have our basic mock server working, we can extend the responses to cover more of the Salesforce API calls. Let’s look at the REST Sobject Rows call and create a valid response mock for the call. In the Salesforce API collection, we see an request under . This call is documented . Sobject Rows REST -> SObject here When we click on the ellipsis icon alongside the request in the list, there’s an option to . Click on this, and we can build up our mock request/response. Add example We’ll replicate the example from the documentation. In the request section, we need to add some parameter values to match that example, as shown below: This demonstrates the difference between query parameters and path variables, which we covered earlier. Next, we need to define how the mock server should respond when given a request that matches those parameters. In the Response Body section in the lower half of the screen, we can use the example response given in the documentation, as follows: Notice that we’ve also specified the HTTP status code to be returned—in this case, a .  Finally, to make this a more accurate response, we click on the Headers tab of the response section and set a header to This ensures that the response is interpreted correctly as JSON and not just plain text. We save our example response. 200 Content-Type application/json. Our example server response is nearly ready to test; there’s just one more important change to make. To ensure our response comes from our mock server instead of our Salesforce org, we need to replace the in the URL to . With this change, Postman will use the address of our mock server. Note that we need to do this in both the example and the request above it, so be sure to check that they match, and then save the changes. {{_endpoint}} {{url}} Now, we’re ready to test our request. Click Send, and you'll get a response from your mock server! Code Snippets Postman also provides example code for calling your APIs—mock or otherwise—with support for several languages and libraries. With a request selected in your workspace, click the icon on the right to expand the code snippet menu. From here, you can select a suitable language/library combination and see the example code to use for calling your API. </> Postman’s code snippets will resolve variables where they can. In our example, when we use the variable to reference our mock server, this is expanded for us. The following example shows this with a C# code snippet: {{url}} In some cases, you can even copy the URL from that code request and paste it into your browser to see the mock response.  Since this particular request is a GET request and we’re not checking the auth headers in our Mock Server implementation, the response is returned as shown below: Summary In this article, we looked at the basics of setting up a mock server in Postman—from creating the mock server and a sample response to extending it with more meaningful JSON data and adding additional responses. We’ve also seen how simple it is to generate code snippets that show how to consume the API in the language of your choice, aiding the development of your own tools that use your API. With the tools that Postman provides, we can provide a technical requirement to both our Salesforce developers implementing the API and our developers on other platforms communicating with Salesforce as part of an integration. There is a wealth of additional resources for working with both Postman and Salesforce. Some of the resources relevant to what we’ve covered here include: Building a mock API - https://youtu.be/kZOwHyCl9sY Mock Servers: The Exploratory - https://youtu.be/n_7UUghLpco Integrating With a Custom Salesforce App in Postman - https://youtu.be/7NA-7TGqsNc Exposing Apex Classes as REST WebServices - https://developer.salesforce.com/docs/atlas.en-us.apexcode.meta/apexcode/apex_rest.htm Salesforce Trailhead: Postman API Client - https://trailhead.salesforce.com/en/content/learn/modules/postman-api-client

Stories, News & Mentions about POSTMAN

Postman’s Stories on HackerNoon

Postman's News & Mentions