Unit Tests for Sync and Async callable callbacks in ExecutionCall.callable constructor

[tsavo-at-pieces]

[bsutton]

I've implemented the following unit test which fails as the callback to the guard only works with a non-future callback.

I think we have a fundamental problem in that we have a method which we are trying to use for both async and sync callbacks.

From this thread:
dart-lang/language#2033

Irhn - one of the dart language devs states:

There is no idiomatic way to return a potentially synchronous/potentially asynchronous result because you should never do that.
...
Providing a way to have the same code act as both synchronous and asynchronous is not just not a goal, it's something I'd try to actively discourage.

This would appear in line with darts idiomatic style of having methods such as 'readLine' and 'readLineSync'.

DCli takes an reversed naming convention as it was originally trying to provide a mostly pure sync API and uses xxx and xxxAsync. We can argue whether reversing this was a good idea but the point is the need for two methods.

So I believe the way forward is to have a sync and an async version of the guard method.

NamedLock.guard - returns a future and takes a future callback
NamedLock.guardSync - returns a non-future and takes a non-future callback.

I will submit a PR along these lines and then we can discuss further :)

import 'dart:async';

import 'package:runtime_named_locks/runtime_named_locks.dart'
    show ExecutionCall, NamedLock;
import 'package:test/test.dart';

class IntentionalTestException implements Exception {
  final String message;
  IntentionalTestException(
      {String this.message = "Intentional test exception message."});
  @override
  String toString() => message;
}

void main() {
  test('check guard implements async callbacks correctly', () async {
    final results = <String>[];

    final execution = ExecutionCall<FutureOr<void>, IntentionalTestException>(
      callable: () async {
        results.add('line 1');
        await Future.delayed(Duration(milliseconds: 100), () {
          results.add('line 2');
        });
      },
      safe: true,
    );

    final call = await NamedLock.guard<void, IntentionalTestException>(
        name: 'async test', execution: execution);

    await call.completer;

    results.add('line 3');

    await Future.delayed(Duration(milliseconds: 500));

    expect(results.length, 3);
    expect(results[0], 'line 1');
    expect(results[1], 'line 2');
    expect(results[2], 'line 3');
  });
}