Timestamp generation in Postman - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Postman test script timestamp?

Consider this Postman test script snippet that generates a timestamp in milliseconds since Unix epoch. What will be the value of timestamp after running this code?

Postman

const timestamp = Date.now();
console.log(timestamp);

A Undefined, because Date.now() is not a function in Postman scripts

B A string with the current date in ISO format, e.g., '2023-06-17T12:00:00.000Z'

C An object containing date and time properties

D A number representing milliseconds since January 1, 1970, e.g., 1687000000000

💡 Hint

Date.now() returns the current time in milliseconds as a number.

Date.now() returns the number of milliseconds elapsed since January 1, 1970 (Unix epoch). It is a number, not a string or object.

❓ assertion

intermediate

Which assertion correctly verifies a timestamp is recent in Postman?

You want to write a test in Postman to check that a timestamp variable responseTimestamp is within the last 5 seconds. Which assertion is correct?

Postman

const responseTimestamp = pm.response.json().timestamp;
const now = Date.now();

A pm.expect(responseTimestamp).to.be.within(now - 5000, now);

B pm.expect(responseTimestamp).to.equal(now - 5000);

C pm.expect(responseTimestamp).to.be.above(now + 5000);

D pm.expect(responseTimestamp).to.be.a('string');

💡 Hint

Check if the timestamp is between now minus 5 seconds and now.

The assertion to.be.within(now - 5000, now) checks if responseTimestamp is between 5 seconds ago and now, which means it is recent.

🔧 Debug

advanced

Why does this Postman script fail to generate a valid timestamp?

This Postman test script tries to generate a timestamp but fails. What is the error?

Postman

const timestamp = new Date().getTime;
console.log(timestamp);

A timestamp is a function reference, not a number, because getTime is missing parentheses

B timestamp is a string instead of a number

C timestamp is undefined because Date() is not called correctly

D SyntaxError due to missing semicolon

💡 Hint

Check if getTime is called as a function.

getTime is a function and must be called with parentheses (). Without them, timestamp holds the function itself, not the time value.

🧠 Conceptual

advanced

What is the difference between Date.now() and new Date().getTime() in Postman scripts?

Both Date.now() and new Date().getTime() return timestamps. What is the key difference?

A <code>Date.now()</code> returns seconds; <code>new Date().getTime()</code> returns milliseconds

B <code>Date.now()</code> returns a string; <code>new Date().getTime()</code> returns a number

C <code>Date.now()</code> is a static method returning milliseconds; <code>new Date().getTime()</code> creates a Date object then returns milliseconds

D There is no difference; both return the current date as a formatted string

💡 Hint

One creates an object, the other does not.

Date.now() is a static method that returns the current timestamp in milliseconds directly. new Date().getTime() creates a Date object first, then returns the timestamp.

❓ framework

expert

How to reliably test timestamp freshness in Postman for asynchronous APIs?

You have an API that returns a timestamp of when data was last updated. The timestamp is in milliseconds. You want to write a Postman test that passes only if the timestamp is within 10 seconds of the current time, accounting for network delay. Which approach is best?

Postman

const responseTimestamp = pm.response.json().lastUpdated;
const now = Date.now();

A Use <code>pm.expect(responseTimestamp).to.be.a('string');</code> to verify type

B Use <code>pm.expect(responseTimestamp).to.be.within(now - 10000, now + 1000);</code> to allow 1 second future tolerance

C Use <code>pm.expect(responseTimestamp).to.equal(now);</code> for exact match

D Use <code>pm.expect(responseTimestamp).to.be.below(now - 10000);</code> to check if timestamp is older than 10 seconds

💡 Hint

Allow some tolerance for network delays and clock differences.

Because of network delays and slight clock differences, allowing a small future tolerance (e.g., 1 second) ensures the test does not fail incorrectly. Checking within 10 seconds plus a small future window is best practice.