postman Halfway test fail

[vijaychandra1910]

[get fiction books] Check Query Params | AssertionError: Fix: There should be 2 Query Params "genre=fiction" and "checkedOut=false": expected [ 'false', index: +0, …(2) ] to equal true

facing this failed message how can i pass it.?

[rajdeepchakraborty-rc]

@vijaychandra1910 Please make sure to set the query parameters correctly. There are two parameters:

• Query param 1: genre with value fiction
• Query param 2: checkedOut with value false

[vijaychandra1910]

Where ??
I think all are perfect.

[rajdeepchakraborty-rc]

@vijaychandra1910 The spelling of genre is wrong. You have provided gerne which is not a defined query for the endpoint, causing the issue.

[Shiranakther]

{{baseUrl}}/books?genre=fiction&checkedOut=false

Copy and paste this code . It will work

[rohit-codes7]

[get fiction books] Check Query Params | AssertionError: Fix: Add Query Param "genre=fiction" to your request: expected false to equal true

[get book by id] path is set to /books/:id | AssertionError: Fix: Path should be "{{baseUrl}}/books/:id" not "{{baseUrl}}/books/id": expected '{{baseUrl}}/books' to match //books/:/

facing these failed message how can i pass it.?

// Parse body depending on version
let body = pm.response.json();
if (body.collection) {
body = body.collection;
}

const reqs = body.item;

// DEBUG: List request names and indexes
reqs.forEach((r, i) => console.log([${i}] => ${r.name}));

/** 1. get books */
const req1 = reqs[0];
pm.test("[get books] Is a GET request", function () {
pm.expect(req1.request.method, "Fix: Change the method to GET method").to.equal("GET");
});

pm.test([get books] base URL is set to {{baseUrl}}, function () {
const pattern = /^{{baseUrl}}/i;
const url = req1.request.url.raw || req1.request.url;
pm.expect(url.trim(), Fix: Set the base URL to "{{baseUrl}}").to.match(pattern);
});

pm.test("[get books] path is set to /books", function () {
const pattern = //books$/;
const url = req1.request.url.raw || req1.request.url;
pm.expect(url.trim(), Fix: Path should be "{{baseUrl}}/books").to.match(pattern);
});

/** 2. get fiction books */
const req2 = reqs[1];
pm.test("[get fiction books] is a GET request", function () {
pm.expect(req2.request.method, "Fix: Change the method to GET method").to.equal("GET");
});

pm.test([get fiction books] base URL is set to {{baseUrl}}, function () {
const pattern = /^{{baseUrl}}/i;
const url = req2.request.url.raw || req2.request.url;
pm.expect(url.trim(), Fix: Set the base URL to "{{baseUrl}}").to.match(pattern);
});

pm.test("[get fiction books] path is set to /books", function () {
const pattern = //books??/;
const url = req2.request.url.raw || req2.request.url;
pm.expect(url.trim(), Fix: Path should be "{{baseUrl}}/books").to.match(pattern);
});

pm.test("[get fiction books] Check Query Params", function () {
let url = req2.request.url;
let queryParams = [];

// Debug: log the entire request structure
console.log("Full request structure:", JSON.stringify(req2.request, null, 2));
console.log("URL structure:", JSON.stringify(url, null, 2));

// Handle different URL structures in Postman
if (typeof url === 'object') {
    if (url.query && Array.isArray(url.query)) {
        // Postman collection format with query array
        queryParams = url.query.filter(q => q.disabled !== true);
        console.log("Found query array:", queryParams);
    } else if (url.raw && typeof url.raw === 'string' && url.raw.includes('?')) {
        // Raw URL string
        const rawParams = url.raw.split('?')[1];
        console.log("Raw params string:", rawParams);
        queryParams = rawParams.split('&').map(param => {
            const [key, value] = param.split('=');
            return { key, value: decodeURIComponent(value || '') };
        });
    } else if (typeof url === 'string' && url.includes('?')) {
        // URL is stored as string in object
        const rawParams = url.split('?')[1];
        queryParams = rawParams.split('&').map(param => {
            const [key, value] = param.split('=');
            return { key, value: decodeURIComponent(value || '') };
        });
    }
} else if (typeof url === 'string' && url.includes('?')) {
    // Simple string URL
    const rawParams = url.split('?')[1];
    queryParams = rawParams.split('&').map(param => {
        const [key, value] = param.split('=');
        return { key, value: decodeURIComponent(value || '') };
    });
}

// Debug: log final query params
console.log("Final query params found:", JSON.stringify(queryParams, null, 2));

// Check each parameter individually with detailed logging
let hasGenre = false;
let hasCheckedOut = false;

queryParams.forEach((param, index) => {
    console.log(`Param ${index}:`, param);
    const key = param.key || param.name;
    const value = param.value;
    
    console.log(`  Key: "${key}", Value: "${value}"`);
    
    if (key === 'genre') {
        console.log(`  Genre found! Testing value "${value}" against "fiction"`);
        if (value && value.toLowerCase() === 'fiction') {
            hasGenre = true;
            console.log("  ✓ Genre matches!");
        }
    }
    
    if (key === 'checkedOut') {
        console.log(`  CheckedOut found! Testing value "${value}" against "false"`);
        if (value && value.toLowerCase() === 'false') {
            hasCheckedOut = true;
            console.log("  ✓ CheckedOut matches!");
        }
    }
});

console.log("Final results - Has genre:", hasGenre, "Has checkedOut:", hasCheckedOut);

// Test each parameter separately for better error messages
pm.expect(hasGenre, 'Fix: Add Query Param "genre=fiction" to your request').to.equal(true);
pm.expect(hasCheckedOut, 'Fix: Add Query Param "checkedOut=false" to your request').to.equal(true);

});

/** 3. get book by id */
// Try multiple variations of the request name
const req3 = reqs.find(r => {
if (!r.name) return false;
const name = r.name.toLowerCase();
return name.includes("book by id") ||
name.includes("get book") ||
name.includes("book/:id") ||
name.includes("single book") ||
name.includes("one book") ||
name === "book by id" ||
name === "get book by id";
});

// Debug: List all request names to help identify the correct one
console.log("All request names:", reqs.map(r => r.name));

if (req3) {
pm.test("[get book by id] Is a GET request", function () {
pm.expect(req3.request.method, "Fix: Change the method to GET method").to.equal("GET");
});

pm.test(`[get book by id] base URL is set to {{baseUrl}}`, function () {
    const pattern = /^{{baseUrl}}/i;
    const url = req3.request.url.raw || req3.request.url;
    pm.expect(url.trim(), `Fix: Set the base URL to "{{baseUrl}}"`).to.match(pattern);
});

pm.test(`[get book by id] path is set to /books/:id`, function () {
    const pattern = /\/books\/:/;
    const url = req3.request.url.raw || req3.request.url;
    pm.expect(url.trim(), `Fix: Path should be "{{baseUrl}}/books/:id" not "{{baseUrl}}/books/id"`).to.match(pattern);
});

} else {
pm.test("[get book by id] Request not found", function () {
pm.expect.fail("Fix: Create a request with name containing 'book by id', 'get book', or similar. Available requests: " + reqs.map(r => r.name).join(", "));
});
}

/** 4. add a book */
const req4 = reqs.find(r => r.name && r.name.toLowerCase().includes("add book"));
if (req4) {
pm.test("[add a book] is a POST request", function () {
pm.expect(req4.request.method, "Fix: Change the method to POST method").to.equal("POST");
});

pm.test(`[add a book] Base URL is set to {{baseUrl}}`, function () {
    const pattern = /^{{baseUrl}}/i;
    const url = req4.request.url.raw || req4.request.url;
    pm.expect(url.trim(), `Fix: Set the base URL to {{baseUrl}}`).to.match(pattern);
});

pm.test(`[add a book] path is set to /books`, function () {
    const pattern = /\/books$/;
    const url = req4.request.url.raw || req4.request.url;
    pm.expect(url.trim(), `Fix: Path should be "{{baseUrl}}/books"`).to.match(pattern);
});

pm.test(`[add a book] has a JSON body with title, author, genre, yearPublished`, function () {
    pm.expect(req4.request.body, "Fix: Add request body").to.exist;
    pm.expect(req4.request.body.raw, "Fix: Add JSON body").to.exist;
    
    const b = JSON.parse(req4.request.body.raw);
    pm.expect(b, `Fix: Add JSON body with required fields`).to.have.property('title');
    pm.expect(b).to.have.property('author');
    pm.expect(b).to.have.property('genre');
    pm.expect(b).to.have.property('yearPublished');
});

pm.test(`[add a book] has post-request script in Scripts tab`, function () {
    pm.expect(req4.event, "Fix: Add post-request script").to.exist;
    pm.expect(req4.event.length, "Fix: Script is missing").to.be.greaterThan(0);
});

} else {
pm.test("[add a book] Request not found", function () {
pm.expect.fail("Fix: Create a request named 'add book' or similar");
});
}

/** Collection Auth */
pm.test([COLLECTION] Collection level Auth is set to API Key, function () {
console.log(body.auth);
pm.expect(body.auth, "Fix: Set collection level auth").to.exist;
pm.expect(body.auth.type, Fix: Set collection level auth to api-key).to.equal(apikey);

if (body.auth.apikey) {
    if (body.auth.apikey.key) {
        pm.expect(body.auth.apikey.key, "Fix: Set API key name to 'api-key'").to.equal(`api-key`);
    } else if (Array.isArray(body.auth.apikey)) {
        pm.expect(body.auth.apikey.some(o => o.key === 'key' && o.value === 'api-key'), 
            `Fix: Set collection level auth api-key`).to.equal(true);
    }
} else {
    pm.expect.fail("Fix: Configure API key authentication");
}

});