fstest | POSIX Filesystem Test Suite

The project file specifies the wrong TargetFramework. Changing that to e.g. netcoreapp2.0 Target Framework Moniker should fix the build.

This was a bug in an interaction between the admin SDK and the regular node SDK for Firestore.

An update to @google-cloud/firestore 0.8.2 should fix this issue.

You can update your project with npm update to get this change.

Preface: Your retPromExample is mostly right. retPromExample_deux is not. :-) Details below.

1. If using bluebird should inherently be "promisifying" things?

No. Only actually using them uses them.

2. Under these cases should I just callan explicit Promise.(resolve|reject) within the sub Asynchronous function, and attach a return to it, like the format for the 2nd function?

No (more later).

3. I may be understanding the control flow of the promises incorrectly, when everything is good within the fs.readFile things will go as they should, is the async code not simulating a return when it meets that reject?

If everything is going well, you shouldn't reach the reject (more below).

It's not simulating a return, it's settling the promise that you've already returned.

4. What happens to the running Async Function after the Promise has been rejected?

In your case, by the time the promise is being resolved/rejected (collectively, "settled"), the function that started the asynchronous process (readFile) has long since ended, and the underlying asynchronous I/O process is also completed by then because you're doing it from the completion callback.

5. ...Is my promise chain methodology proper? I've used them before, and every once in a while I run into the unhandled rejection issue. I am setting up a catch block, and doing so in favor of running with format .then((res)=>{...}, (rej)=>{...}) as its an antiPattern as stated by the PromisesA+ conventions.

The promise chains at the end of your question are just fine. I'm not aware of using the second argument to then being any kind of anti-pattern, but personally I do prefer using catch, as much for formatting reasons as anything else.

You won't get "unhandled rejection" errors from the chains you've shown, because you're always handling rejections. You will get "unhandled rejection" errors from retPromExample_deux, because the promises you create with Promise.resolve and Promise.reject are never consumed anywhere, which means the rejection from Promise.reject goes unhandled. (Which is one of the reasons retPromExample_deux is incorrect.)

Re your retPromExample: That's very nearly how you use a promise with a non-promise asynchronous callback API like readFile, except you want an else that you're missing:

@(100) is an array with only one element, 100. Not an array of 100 elements. You could use $array = 0..99 to make an array with 100 elements. But I don't think that's what you want.

You could make an empty array and then add elements to it.

That's because fs.appendFile() is asynchronous. You, on the other hand, run it as if it was synchronous.

The easiest (not the best) solution would be to use fs.appendFileSync() - it would behave as you expect.

It would be better if you handled asynchronous nature of appendFile. Something like this:

Your test is not a function, but a value. Compiled to IL as a property or field (depending on reasons). xUnit looks for methods to execute, it skips properties and fields (and rightly so: how would it execute them?)

Why is it not a function? Because it doesn't have a parameter. It's an F# thing: if you have parameters, you're a function. Otherwise - value.

Just give it a parameter, it will become a function. Don't have any meaningful parameters to add? Add a unit one - then it'll be compiled to IL as a parameterless static method.