Trust types a little more, and add coverage

src/typeUtils.ts

@@ -2,9 +2,9 @@ import { Headers, HeadersInit, Request, RequestInfo } from 'node-fetch';
 
 export function createFetchHeaders (axiosHeaders: Record<string, string> = {}): Headers {
   const headers = new Headers();
-  Object.keys(axiosHeaders).forEach((name) => {
-    const values = axiosHeaders[name]?.split(/, */);
-    values?.forEach((value) => headers.append(name, value));
+  Object.entries(axiosHeaders).forEach(([key, value]) => {
+    const values = value.split(/, */);
+    values.forEach((value) => headers.append(key, value));
   });
   return headers;
 }
@@ -14,12 +14,9 @@ export function createAxiosHeaders (headers: HeadersInit = {}): Record<string, s
 
   if (headers instanceof Headers) {
     const headersRaw = headers.raw();
-    for (const name of headers.keys()) {
-      const value = headersRaw[name];
-      if (value) {
-        rawHeaders[name] = value.join(', ');
-      }
-    }
+    Object.entries(headersRaw).forEach(([key, value]) => {
+      rawHeaders[key] = value.join(', ');
+    });
   } else if (Array.isArray(headers)) {
     headers.forEach(([name, ...values]) => {
       rawHeaders[name!] = values.join(', ');

test/typeUtils.test.ts

@@ -0,0 +1,69 @@
+import test from 'ava';
+import {
+  createAxiosHeaders,
+  createFetchHeaders,
+  getUrl
+} from '../src/typeUtils';
+import { Headers, Request } from 'node-fetch';
+
+const headersObject = {
+  key1: 'value1',
+  key2: 'value2, value3'
+};
+
+const headersArray = [
+  ['key1', 'value1'],
+  ['key2', 'value2', 'value3']
+];
+
+const headersClass = new Headers();
+headersClass.append('key1', 'value1');
+headersClass.append('key2', 'value2');
+headersClass.append('key2', 'value3');
+
+const testUrl = 'http://test.test.test';
+
+test('createFetchHeaders will return an empty object on undefined', (t) => {
+  const expected = new Headers();
+  t.deepEqual(createFetchHeaders(), expected);
+});
+
+test('createFetchHeaders will create a proper Headers object', (t) => {
+  t.deepEqual(createFetchHeaders(headersObject).raw(), headersClass.raw());
+});
+
+test('createAxiosHeaders will return an empty object on undefined', (t) => {
+  t.deepEqual(createAxiosHeaders(), {});
+});
+
+test('createAxiosHeaders will format a Headers object for Axios', (t) => {
+  t.deepEqual(createAxiosHeaders(headersClass), headersObject);
+});
+
+test('createAxiosHeaders will format header strings for Axios', (t) => {
+  t.deepEqual(createAxiosHeaders(headersArray), headersObject);
+});
+
+test('createAxiosHeaders will assign headers to a new object', (t) => {
+  const actual = createAxiosHeaders(headersObject);
+  t.not(actual, headersObject);
+  t.deepEqual(actual, headersObject);
+});
+
+test('getUrl will return undefined on undefined input', (t) => {
+  t.is(getUrl(), undefined);
+});
+
+test('getUrl will return an input string', (t) => {
+  t.is(getUrl(testUrl), testUrl);
+});
+
+test('getUrl will return a string for a URLLike object', (t) => {
+  const urlLike = { href: testUrl };
+  t.is(getUrl(urlLike), testUrl);
+});
+
+test('getUrl will return a string for a Request object', (t) => {
+  const request = new Request(testUrl);
+  t.is(getUrl(request), `${testUrl}/`);
+});