javascript utilize bluebird promise to asynchronously retrieve the first file from a given list

Question

javascript utilize bluebird promise to asynchronously retrieve the first file from a given list

I am currently working on implementing promises in JavaScript to retrieve the first available file from a list of paths (for example, ["c:\\temp\\test1.json", "c:\\temp\\test2.json"]). The goal is to identify and return the first file that exists on disk, such as c:\temp\test2.json.

function getFirstFile(paths) {

    if (!paths || paths.length == 0) {
        return {};
    }

    // sequential async search (recursive)
    var filePath = paths.shift();
    return fs.readFileAsync(filePath)
        // found = stop searching
        .then(function (content) {
            return new Promise (function (resolve, reject) {
                resolve(JSON.parse(content));
            })
        })
       // continue searching further paths left in the list
       .error(function (err) {
            return getFirstFile(paths);
       });
 }    

var paths2 = ["c:\\temp\\test1.json", "c:\\temp\\test2.json"];

getFirstFile(paths2)
    .then( function (index) {
        assert.equal(index.file, ".test2.json");
    })
    .error( function(err) {
        assert.fail(err.toString());
    });

Despite the fact that the file "C:\temp\test2.json" is indeed present, it seems like the fs.readFileAsync(filePath) function doesn't trigger the .then(function (content) {

It's almost as though there's an uncaught exception or similar issue with the promise. What do you think could be causing this?

javascript recursion promise mocha.js bluebird

Answer 1

Answer №1

Upon testing, it was discovered that the code below functions properly without Mocha testing implemented. However, when integrated with Mocha testing, the test consistently passes regardless of the contents of test2.json.

var fs = require('fs');
var Promise = require('bluebird');  //faster than standard Chrome promises
if (typeof fs.readFileAsync === "undefined") {Promise.promisifyAll(fs);}  
var path = require('path');

function getFirstFile(paths) {

    if (!paths || paths.length == 0) {
        return {};
    }
    
    var filePath = paths.shift();
    return fs.readFileAsync(filePath)
        .then(function (content) {
            return new Promise (function (resolve, reject) {
                resolve(JSON.parse(content));
            })
        })
        .error(function (err) {
            return getFirstFile(paths);
        })
        .catch(function (e) {
            return getFirstFile(paths);
        });
}

var paths2 = ["c:\\temp\\test1.json", "c:\\temp\\test2.json"];

getFirstFile(paths2)
.then( function (index) {
    console.log(JSON.stringify(index));
})
.error( function(err) {
    console.log(err);
});

The issue lies in how the Mocha test was executed, as shown by the incorrect and correct test code examples:

Incorrect implementation (Mocha test always passes due to promise resolving after the test):

it('My Test', function () {    
    utils.getFirstFile(["c:\\temp\\test1.json", "c:\\temp\\test2.json"])
    .then(function(index) {
        assert.equal(index.file, ".test2.json");
    })
    .catch( ....);
}

Correct implementation involves returning a promise:

it('My Test', function () {    
    return utils.getFirstFile(["c:\\temp\\test1.json", "c:\\temp\\test2.json"])
        .then(function(index) {
             assert.equal(index.file, ".test2.json");
        });
}

Answer 2

Upon testing, it was discovered that the code below functions properly without Mocha testing implemented. However, when integrated with Mocha testing, the test consistently passes regardless of the contents of test2.json.

var fs = require('fs');
var Promise = require('bluebird');  //faster than standard Chrome promises
if (typeof fs.readFileAsync === "undefined") {Promise.promisifyAll(fs);}  
var path = require('path');

function getFirstFile(paths) {

    if (!paths || paths.length == 0) {
        return {};
    }
    
    var filePath = paths.shift();
    return fs.readFileAsync(filePath)
        .then(function (content) {
            return new Promise (function (resolve, reject) {
                resolve(JSON.parse(content));
            })
        })
        .error(function (err) {
            return getFirstFile(paths);
        })
        .catch(function (e) {
            return getFirstFile(paths);
        });
}

var paths2 = ["c:\\temp\\test1.json", "c:\\temp\\test2.json"];

getFirstFile(paths2)
.then( function (index) {
    console.log(JSON.stringify(index));
})
.error( function(err) {
    console.log(err);
});

The issue lies in how the Mocha test was executed, as shown by the incorrect and correct test code examples:

Incorrect implementation (Mocha test always passes due to promise resolving after the test):

it('My Test', function () {    
    utils.getFirstFile(["c:\\temp\\test1.json", "c:\\temp\\test2.json"])
    .then(function(index) {
        assert.equal(index.file, ".test2.json");
    })
    .catch( ....);
}

Correct implementation involves returning a promise:

it('My Test', function () {    
    return utils.getFirstFile(["c:\\temp\\test1.json", "c:\\temp\\test2.json"])
        .then(function(index) {
             assert.equal(index.file, ".test2.json");
        });
}

Answer 3

Answer №2

Indeed, it is probable that the commitment ultimately ended up declining (most likely due to an error thrown by JSON.parse), yet as a result of this

   .error(function (err) {
        return getFirstFile(paths);
   });

The decline would be intercepted, prompting the function to run once more, and again. It would continuously iterate in a loop, never actually reaching the point of rejection. It is imperative to allow the promise to reject.

Answer 4

Indeed, it is probable that the commitment ultimately ended up declining (most likely due to an error thrown by JSON.parse), yet as a result of this

   .error(function (err) {
        return getFirstFile(paths);
   });

The decline would be intercepted, prompting the function to run once more, and again. It would continuously iterate in a loop, never actually reaching the point of rejection. It is imperative to allow the promise to reject.

Answer 5

Answer №3

When it comes to handling errors, the .error() method is designed to "only catch operational errors". Keep in mind that an exception thrown by JSON.parse won't be caught using this method. Instead, consider utilizing the .catch() method, especially in your final handler where you call assert.fail.

function getFirstFile(paths) {
    if (!paths || paths.length == 0) return {};

    // Perform a sequential asynchronous search (recursive)
    var filePath = paths.shift();
    return fs.readFileAsync(filePath)
    .then(JSON.parse)
    .catch(function (err) {
        return getFirstFile(paths);
    });
}

getFirstFile(["c:\\temp\\test1.json", "c:\\temp\\test2.json"])
.then(function(index) {
    assert.equal(index.file, ".test2.json");
})
.catch(function(err) {
    assert.fail(err.toString());
});

Answer 6

When it comes to handling errors, the .error() method is designed to "only catch operational errors". Keep in mind that an exception thrown by JSON.parse won't be caught using this method. Instead, consider utilizing the .catch() method, especially in your final handler where you call assert.fail.

function getFirstFile(paths) {
    if (!paths || paths.length == 0) return {};

    // Perform a sequential asynchronous search (recursive)
    var filePath = paths.shift();
    return fs.readFileAsync(filePath)
    .then(JSON.parse)
    .catch(function (err) {
        return getFirstFile(paths);
    });
}

getFirstFile(["c:\\temp\\test1.json", "c:\\temp\\test2.json"])
.then(function(index) {
    assert.equal(index.file, ".test2.json");
})
.catch(function(err) {
    assert.fail(err.toString());
});

javascript utilize bluebird promise to asynchronously retrieve the first file from a given list

Answer №1

Answer №2

Answer №3

Similar questions

Watching for changes to an object's value in an AngularJS service triggered by a controller from a separate module (Extended Edition)

What causes the closure variable to be reset after iterating over JSON data using $.each method?

Utilizing Data From External Sources in a React Application

Different method for adding child elements to the DOM

Having trouble getting NextJS to work with jsmpeg/node-rtsp-stream for displaying an RTSP stream

combine various types of wrappers in React

Steps to successfully retrieve an image using JavaScript on the client side while circumventing any CORS errors

It's next to impossible to secure expedited work on an ongoing project using Vercel

What is the best way to use Python and Selenium to click on an angularjs link by comparing it to the text entered by the user?

How can one efficiently navigate through extensive functions without risking surpassing the stack limit?

Troubleshooting VueJS's Dilemma with Quotation Marks

Ways to utilize JavaScript to identify if a flash is launching in a separate tab

How to upload a document to Alfresco using JavaScript API

What is the method for displaying a canvas scene within a designated div element?

Utilizing PHP to dynamically load HTML forms and leveraging JQuery for form submissions

How can a row in AG-Grid be updated without causing a refresh?

Pass data in JSON format from Laravel controller to AngularJS

JavaScript layout: Thymealf

What is the best way to verify the presence of # in a URL?

Retrieving radio button values in React from a different component