I can get the correct behaviour by expecting the apply to not throw an exception, but that makes for clunky code. Is this the best way to do it?

it('should do stuff', function checkStuff() {
  expect(stuff.apply(val => {
    expect(val).to.eql("stuff");
  })).not.to.throw();
});

I stlil get the UnhandlePromiseRejectionWarning, so I feel there must be a better way....

This works, but it's even clunkier:

it('should do stuff', function checkStuff() {
  return new Promise(function (resolve, reject) {
  try {
    stuff.apply(val => {
    expect(val).to.eql("stuff");
    resolve();
  catch (error) {
    reject(error);
  }
  });
});

Looks like chai-as-promised has the right idea. I could use it if I added a

.then()

method to pulumi.Output.. if such a thing is possible...

(if I’m understanding what I think you’re trying to do)

has an example of using that style of helper within a test

Ok I have it working, and a bit smaller. There's a few improvements I'd like to make, but I think they're not really Pulumi-specific, so maybe this isn't the place to deal with them. I'll ask anyway: nothing ventured, nothing gained!

So what I have working is this little function at the top of my test file:

function promise<T>(output: pulumi.Output<T>): Promise<T | undefined> {
  return (output as any).promise() as Promise<T>;
}

This allows me to write tests like this:

it('should work', async function workTest() {
  expect(await promise(objectUnderTest.unappliedOutput)).to.eql("expected output");
});

This does the job. My questions (so far) are: Where is the

promise()

function defined? The one called in the

return

line of the first snippet? Can I hide the

await

in that function? I haven't found a way to do that yet. I've tried making it async and returning the awaited promise. That produces the expected output on failure, but on success it always produces an error to the effect of '{} doesn't equal "expected output"`. Can

pulumi.Output

or

pulumi.OutputInstance

be extended? It seems they can't because they're types not classes. I'd like to be able to make the

promise()

function an extension method of Output. If I could sort out those niggles, then I could end up with fairly elegant tests like this:

it('should work', async function workTest() {
  expect(objectUnderTest.unappliedOutput.promise()).to.eventually.eql("expected output");
});

Ah.. another gotcha. Where

apply()

on an Output property on an Output object will resolve everything, this local

promise()

function only resolves the thing being passed to it. For example, I have a

VpcDhcpOptions

Output object, but I can't use

expect(await promise(options.domainNameServers))

, I have to use

expect(await promise((await promise(options)).domainNameServers)

...