feat: add tests to utility functions

Author: csvenke

src/components/List/List.tsx

@@ -22,7 +22,7 @@ const List = (props: IListProps): Output => {
   const { items, children, render } = props;
   const renderProp = getRenderProp(children, render);
 
-  if (!!renderProp && isFunction(renderProp)) {
+  if (!!renderProp && isFunction<Map>(renderProp)) {
     return <React.Fragment>{items.map(renderProp)}</React.Fragment>;
   }
 

src/components/Switch/Switch.tsx

@@ -2,7 +2,7 @@ import * as PropTypes from 'prop-types';
 import * as React from 'react';
 
 import { Output } from '../../types';
-import { renderIf } from '../../utils';
+import { isElement, renderIf } from '../../utils';
 import SwitchCase from './SwitchCase';
 import SwitchDefault from './SwitchDefault';
 
@@ -14,16 +14,9 @@ interface ISwitchProps {
   children: React.ReactNode;
 }
 
-const isSwitchChild = (child: any, element: any) => {
-  return child.type.prototype === element.prototype;
-};
-
-const isValidSwitchChild = (child: any) => {
-  return (
-    React.isValidElement(child) &&
-    (isSwitchChild(child, SwitchCase) || isSwitchChild(child, SwitchDefault))
-  );
-};
+const isValidSwitchChild = (child: any) =>
+  React.isValidElement(child) &&
+  (isElement(child, SwitchCase) || isElement(child, SwitchDefault));
 
 /**
  * Renders content from first `Switch.Case` that matches `value`, else `Switch.Default` if it exists.
@@ -43,7 +36,7 @@ const Switch = (props: ISwitchProps): Output => {
   });
 
   // No match found, return default if it exists.
-  if (!match && isSwitchChild(child, SwitchDefault)) {
+  if (!match && isElement(child, SwitchDefault)) {
     return React.cloneElement(child);
   }
 

src/utils/getChildrenOrRender/getChildrenOrRender.tsx

@@ -5,11 +5,11 @@ import getRenderProp from '../getRenderProp/getRenderProp';
 import isEmptyChildren from '../isEmptyChildren/isEmptyChildren';
 import isFunction from '../isFunction/isFunction';
 
-const getChildrenOrRender = (children?: unknown, render?: unknown): Output => {
+const getChildrenOrRender = (children?: any, render?: any): Output => {
   const result = getRenderProp(children, render);
 
   if (result) {
-    if (isFunction(result)) {
+    if (isFunction<() => Output>(result)) {
       return result();
     }
 

src/utils/getRenderProp/getRenderProp.test.tsx

@@ -0,0 +1,38 @@
+import * as React from 'react';
+
+import getRenderProp from '.';
+
+const case1 = <div>children</div>;
+const case2 = () => <div>render</div>;
+
+test('should return children', () => {
+  // prettier-ignore
+  const cases = [
+    [case1, case2],
+    [case1, undefined],
+    [case1, null],
+  ];
+
+  cases.forEach(item => {
+    const result = getRenderProp(item[0], item[1]);
+    expect(result).toEqual(case1);
+  });
+});
+
+test('should return render', () => {
+  const result = getRenderProp(undefined, case2)();
+  expect(result).toEqual(case2());
+});
+
+test('should return null', () => {
+  // prettier-ignore
+  const cases = [
+    [undefined, undefined],
+    [null, null],
+  ];
+
+  cases.forEach(item => {
+    const result = getRenderProp(item[0], item[1]);
+    expect(result).toEqual(null);
+  });
+});

src/utils/getRenderProp/getRenderProp.ts

@@ -1,6 +1,6 @@
 import renderIf from '../renderIf/renderIf';
 
-const getRenderProp = (children?: unknown, render?: unknown) => {
+const getRenderProp = (children?: any, render?: any) => {
   const result = children ? children : render;
   return renderIf(!!result)(result);
 };

src/utils/index.ts

@@ -1,5 +1,6 @@
 export { default as getChildrenOrRender } from './getChildrenOrRender';
 export { default as getRenderProp } from './getRenderProp';
+export { default as isElement } from './isElement';
 export { default as isEmptyChildren } from './isEmptyChildren';
 export { default as isFunction } from './isFunction';
 export { default as renderIf } from './renderIf';

src/utils/isElement/index.ts

@@ -0,0 +1 @@
+export { default } from './isElement';

src/utils/isElement/isElement.ts

@@ -0,0 +1,6 @@
+import * as React from 'react';
+
+const isElement = (child: any, element: any): child is React.ReactElement<{}> =>
+  child.type.prototype === element.prototype;
+
+export default isElement;

src/utils/isFunction/isFunction.test.tsx

@@ -0,0 +1,26 @@
+import * as React from 'react';
+
+import isFunction from '.';
+
+test('should return true', () => {
+  const result = isFunction(() => 'something');
+  expect(result).toEqual(true);
+});
+
+test('should return false', () => {
+  const cases = [
+    'something',
+    false,
+    true,
+    undefined,
+    null,
+    <div>something</div>,
+    [1, 2, 3],
+    { a: 'a', b: 'b' },
+  ];
+
+  cases.forEach(item => {
+    const result = isFunction(item);
+    expect(result).toEqual(false);
+  });
+});

src/utils/isFunction/isFunction.ts

@@ -1,3 +1,3 @@
-const isFunction = (input: any): input is () => any => typeof input === 'function';
+const isFunction = <T>(input: any): input is T => typeof input === 'function';
 
 export default isFunction;