Refactor to remove "Async" function name suffix

Remove convention where Async suffix is added to functions that returns
a Promise. It was a habit from C#, but is not widely used in JavaScript
/ TypeScript world, also bloats the code. The code is more consistent
with third party dependencies/frameworks without the suffix.

tests/integration/application/collections/NoDeadDocumentationUrls.spec.ts

@@ -3,7 +3,7 @@ import { expect } from 'chai';
 import { parseApplication } from '@/application/Parser/ApplicationParser';
 import { IApplication } from '@/domain/IApplication';
 import { IUrlStatus } from './StatusChecker/IUrlStatus';
-import { getUrlStatusesInParallelAsync, IBatchRequestOptions } from './StatusChecker/BatchStatusChecker';
+import { getUrlStatusesInParallel, IBatchRequestOptions } from './StatusChecker/BatchStatusChecker';
 
 describe('collections', () => {
     // arrange
@@ -25,7 +25,7 @@ describe('collections', () => {
     const testTimeoutInMs = urls.length * 60000 /* 1 minute */;
     it('have no dead urls', async () => {
         // act
-        const results = await getUrlStatusesInParallelAsync(urls, options);
+        const results = await getUrlStatusesInParallel(urls, options);
         // assert
         const deadUrls = results.filter((r) => r.code !== 200);
         expect(deadUrls).to.have.lengthOf(0, printUrls(deadUrls));

tests/integration/application/collections/StatusChecker/BatchStatusChecker.ts

@@ -1,16 +1,16 @@
-import { sleepAsync } from '@/infrastructure/Threading/AsyncSleep';
+import { sleep } from '@/infrastructure/Threading/AsyncSleep';
 import { IUrlStatus } from './IUrlStatus';
-import { getUrlStatusAsync, IRequestOptions } from './Requestor';
+import { getUrlStatus, IRequestOptions } from './Requestor';
 import { groupUrlsByDomain } from './UrlPerDomainGrouper';
 
-export async function getUrlStatusesInParallelAsync(
+export async function getUrlStatusesInParallel(
     urls: string[],
     options?: IBatchRequestOptions): Promise<IUrlStatus[]> {
     // urls = [ 'https://privacy.sexy' ]; // Here to comment out when testing
     const uniqueUrls = Array.from(new Set(urls));
     options = { ...DefaultOptions, ...options };
     console.log('Options: ', options); // tslint:disable-line: no-console
-    const results = await requestAsync(uniqueUrls, options);
+    const results = await request(uniqueUrls, options);
     return results;
 }
 
@@ -35,19 +35,19 @@ const DefaultOptions: IBatchRequestOptions = {
     },
 };
 
-function requestAsync(urls: string[], options: IBatchRequestOptions): Promise<IUrlStatus[]> {
+function request(urls: string[], options: IBatchRequestOptions): Promise<IUrlStatus[]> {
     if (!options.domainOptions.sameDomainParallelize) {
-        return runOnEachDomainWithDelayAsync(
+        return runOnEachDomainWithDelay(
             urls,
-            (url) => getUrlStatusAsync(url, options.requestOptions),
+            (url) => getUrlStatus(url, options.requestOptions),
             options.domainOptions.sameDomainDelayInMs);
     } else {
         return Promise.all(
-            urls.map((url) => getUrlStatusAsync(url, options.requestOptions)));
+            urls.map((url) => getUrlStatus(url, options.requestOptions)));
     }
 }
 
-async function runOnEachDomainWithDelayAsync(
+async function runOnEachDomainWithDelay(
     urls: string[],
     action: (url: string) => Promise<IUrlStatus>,
     delayInMs: number): Promise<IUrlStatus[]> {
@@ -58,7 +58,7 @@ async function runOnEachDomainWithDelayAsync(
             const status = await action(url);
             results.push(status);
             if (results.length !== group.length) {
-                await sleepAsync(delayInMs);
+                await sleep(delayInMs);
             }
         }
         return results;

tests/integration/application/collections/StatusChecker/ExponentialBackOffRetryHandler.ts

@@ -1,9 +1,9 @@
-import { sleepAsync } from '@/infrastructure/Threading/AsyncSleep';
+import { sleep } from '@/infrastructure/Threading/AsyncSleep';
 import { IUrlStatus } from './IUrlStatus';
 
 const DefaultBaseRetryIntervalInMs = 5 /* sec */ * 1000;
 
-export async function retryWithExponentialBackOffAsync(
+export async function retryWithExponentialBackOff(
     action: () => Promise<IUrlStatus>,
     baseRetryIntervalInMs: number = DefaultBaseRetryIntervalInMs,
     currentRetry = 1): Promise<IUrlStatus> {
@@ -14,8 +14,8 @@ export async function retryWithExponentialBackOffAsync(
             const exponentialBackOffInMs = getRetryTimeoutInMs(currentRetry, baseRetryIntervalInMs);
             // tslint:disable-next-line: no-console
             console.log(`Retrying (${currentRetry}) in ${exponentialBackOffInMs / 1000} seconds`, status);
-            await sleepAsync(exponentialBackOffInMs);
-            return retryWithExponentialBackOffAsync(action, baseRetryIntervalInMs, currentRetry + 1);
+            await sleep(exponentialBackOffInMs);
+            return retryWithExponentialBackOff(action, baseRetryIntervalInMs, currentRetry + 1);
         }
     }
     return status;

tests/integration/application/collections/StatusChecker/README.md

@@ -21,11 +21,11 @@ Coming soon 🚧
 
 Programmatic usage is supported both on Node.js and browser.
 
-### `getUrlStatusesInParallelAsync`
+### `getUrlStatusesInParallel`
 
 ```js
 // Simple example
-const statuses = await getUrlStatusesInParallelAsync([ 'https://privacy.sexy', /* ... */ ]);
+const statuses = await getUrlStatusesInParallel([ 'https://privacy.sexy', /* ... */ ]);
 if(statuses.all((r) => r.code === 200)) {
     console.log('All URLs are alive!');
 } else {
@@ -33,7 +33,7 @@ if(statuses.all((r) => r.code === 200)) {
 }
 
 // Fastest configuration
-const statuses = await getUrlStatusesInParallelAsync([ 'https://privacy.sexy', /* ... */ ], {
+const statuses = await getUrlStatusesInParallel([ 'https://privacy.sexy', /* ... */ ], {
     domainOptions: {
         sameDomainParallelize: false,
     }
@@ -53,13 +53,13 @@ const statuses = await getUrlStatusesInParallelAsync([ 'https://privacy.sexy', /
     - Sets delay between requests to same host (domain) if same domain parallelization is disabled.
 - `requestOptions` (*object*): See [request options](#request-options).
 
-### `getUrlStatusAsync`
+### `getUrlStatus`
 
 Checks whether single URL is dead or alive.
 
 ```js
 // Simple example
-const status = await getUrlStatusAsync('https://privacy.sexy');
+const status = await getUrlStatus('https://privacy.sexy');
 console.log(`Status code: ${status.code}`);
 ```
 

tests/integration/application/collections/StatusChecker/Requestor.ts

@@ -1,13 +1,13 @@
-import { retryWithExponentialBackOffAsync } from './ExponentialBackOffRetryHandler';
+import { retryWithExponentialBackOff } from './ExponentialBackOffRetryHandler';
 import { IUrlStatus } from './IUrlStatus';
 import { fetchFollow, IFollowOptions } from './FetchFollow';
 
-export async function getUrlStatusAsync(
+export async function getUrlStatus(
     url: string,
     options: IRequestOptions = DefaultOptions): Promise<IUrlStatus> {
     options = { ...DefaultOptions, ...options };
     const fetchOptions = getFetchOptions(url, options);
-    return retryWithExponentialBackOffAsync(async () => {
+    return retryWithExponentialBackOff(async () => {
         console.log('Requesting', url); // tslint:disable-line: no-console
         let result: IUrlStatus;
         try {