test: add tests

Author: aikoven

.gitignore

@@ -7,5 +7,7 @@ node_modules
 npm-*.log
 yarn.lock
 
+tests-build
+
 # OS X
 .DS_Store

.travis.yml

@@ -6,3 +6,4 @@ node_js:
 script:
   - npm run lint
   - npm run build
+  - npm test

index.d.ts

@@ -29,7 +29,8 @@ export interface AsyncActionCreators<P, S, E> {
 }
 export interface ActionCreatorFactory {
     (type: string, commonMeta?: Object, error?: boolean): EmptyActionCreator;
-    <P>(type: string, commonMeta?: Object, isError?: ((payload: P) => boolean) | boolean): ActionCreator<P>;
+    <P>(type: string, commonMeta?: Object, isError?: boolean): ActionCreator<P>;
+    <P>(type: string, commonMeta?: Object, isError?: (payload: P) => boolean): ActionCreator<P>;
     async<P, S>(type: string, commonMeta?: Object): AsyncActionCreators<P, S, any>;
     async<P, S, E>(type: string, commonMeta?: Object): AsyncActionCreators<P, S, E>;
 }

lib/index.js

@@ -3,23 +3,14 @@ function isType(action, actionCreator) {
     return action.type === actionCreator.type;
 }
 exports.isType = isType;
-var isDev = (process && process.env && process.env.NODE_ENV) !== 'production';
-function wrapIsError(default_, isError) {
-    if (isError === undefined) {
-        return default_;
-    }
-    if (typeof isError === "boolean") {
-        return function () { return isError; };
-    }
-    return isError;
-}
 function actionCreatorFactory(prefix, defaultIsError) {
     if (defaultIsError === void 0) { defaultIsError = function (p) { return p instanceof Error; }; }
     var actionTypes = {};
     var base = prefix ? prefix + "/" : "";
-    function baseActionCreator(isError, type, commonMeta) {
-        var fullType = "" + base + type;
-        if (isDev) {
+    function actionCreator(type, commonMeta, isError) {
+        if (isError === void 0) { isError = defaultIsError; }
+        var fullType = base + type;
+        if (process.env.NODE_ENV !== 'production') {
             if (actionTypes[fullType])
                 throw new Error("Duplicate action type: " + fullType);
             actionTypes[fullType] = true;
@@ -28,20 +19,19 @@ function actionCreatorFactory(prefix, defaultIsError) {
             var action = {
                 type: fullType,
                 payload: payload,
-                meta: Object.assign({}, commonMeta, meta),
             };
-            if (isError(payload)) {
+            if (commonMeta || meta) {
+                action.meta = Object.assign({}, commonMeta, meta);
+            }
+            if (isError && (typeof isError === 'boolean' || isError(payload))) {
                 action.error = true;
             }
             return action;
         }, { type: fullType });
     }
-    var actionCreator = function (type, commonMeta, isError) {
-        return baseActionCreator(wrapIsError(defaultIsError, isError), type, commonMeta);
-    };
     function asyncActionCreators(type, commonMeta) {
         return {
-            type: prefix ? prefix + "/" + type : type,
+            type: base + type,
             started: actionCreator(type + "_STARTED", commonMeta, false),
             done: actionCreator(type + "_DONE", commonMeta, false),
             failed: actionCreator(type + "_FAILED", commonMeta, true),

package.json

@@ -14,15 +14,18 @@
   "repository": "aikoven/redux-typescript-actions",
   "scripts": {
     "clean": "rimraf es6 lib",
-    "lint": "tslint -c tslint.json src/**/*.ts",
+    "lint": "tslint -c tslint.json src/**/*.ts tests/**/*.ts",
+    "test": "tsc -p tsconfig.tests.json && tape tests-build/tests/*.js",
     "build": "tsc",
     "prepublish": "npm run clean && npm run build"
   },
   "author": "Daniel Lytkin <dan.lytkin@gmail.com>",
   "license": "MIT",
   "devDependencies": {
+    "@types/tape": "^4.2.28",
     "redux": "^3.6.0",
     "rimraf": "^2.5.4",
+    "tape": "^4.6.2",
     "tslint": "^3.15.1",
     "typescript": "^2.0.3"
   }

tests/index.ts

@@ -0,0 +1,134 @@
+import test = require('tape');
+import actionCreatorFactory, {isType} from "../src/index";
+
+test('isType', assert => {
+  const actionCreator = actionCreatorFactory();
+
+  const action1 = actionCreator('ACTION_1');
+  const action2 = actionCreator('ACTION_2');
+
+  const action = action1();
+
+  assert.true(isType(action, action1));
+  assert.false(isType(action, action2));
+
+  assert.end();
+});
+
+test('basic', assert => {
+  const actionCreator = actionCreatorFactory();
+
+  const someAction = actionCreator<{foo: string}>('ACTION_TYPE');
+
+  assert.throws(() => actionCreator('ACTION_TYPE'),
+    'Duplicate action type ACTION_TYPE');
+
+  assert.equal(someAction.type, 'ACTION_TYPE');
+
+  const action = someAction({foo: 'bar'});
+
+  assert.equal(action.type, 'ACTION_TYPE');
+  assert.equal(action.error, undefined);
+  assert.equal(action.meta, undefined);
+  assert.deepEqual(action.payload, {foo: 'bar'});
+
+  assert.end();
+});
+
+test('meta', assert => {
+  const actionCreator = actionCreatorFactory();
+
+  const someAction = actionCreator('ACTION_TYPE');
+
+  const action = someAction(undefined, {foo: 'bar'});
+
+  assert.deepEqual(action.meta, {foo: 'bar'});
+
+  const someActionWithMeta = actionCreator('ACTION_WITH_META', {foo: 'bar'});
+
+  const actionWithMeta = someActionWithMeta(undefined);
+
+  assert.deepEqual(actionWithMeta.meta, {foo: 'bar'});
+
+  const actionWithExtraMeta = someActionWithMeta(undefined, {fizz: 'buzz'});
+
+  assert.deepEqual(actionWithExtraMeta.meta, {foo: 'bar', fizz: 'buzz'});
+
+  assert.end();
+});
+
+test('error actions', assert => {
+  const actionCreator = actionCreatorFactory();
+
+  const errorAction = actionCreator('ERROR_ACTION', null, true);
+
+  const action = errorAction();
+
+  assert.true(action.error);
+
+  const inferredErrorAction = actionCreator<any>('INF_ERROR_ACTION', null);
+
+  assert.false(inferredErrorAction({}).error);
+  assert.true(inferredErrorAction(new Error()).error);
+
+  const customErrorAction = actionCreator<{
+    isError: boolean;
+  }>('CUSTOM_ERROR_ACTION', null, payload => payload.isError);
+
+  assert.false(customErrorAction({isError: false}).error);
+  assert.true(customErrorAction({isError: true}).error);
+
+  const actionCreator2 = actionCreatorFactory(null,
+    payload => payload.isError);
+
+  const customErrorAction2 = actionCreator2<{
+    isError: boolean;
+  }>('CUSTOM_ERROR_ACTION');
+
+  assert.false(customErrorAction2({isError: false}).error);
+  assert.true(customErrorAction2({isError: true}).error);
+
+  assert.end();
+});
+
+test('prefix', assert => {
+  const actionCreator = actionCreatorFactory('somePrefix');
+
+  const someAction = actionCreator('SOME_ACTION');
+
+  assert.equal(someAction.type, 'somePrefix/SOME_ACTION');
+
+  const action = someAction();
+
+  assert.equal(action.type, 'somePrefix/SOME_ACTION');
+
+  assert.end();
+});
+
+test('async', assert => {
+  const actionCreator = actionCreatorFactory('prefix');
+
+  const asyncActions = actionCreator.async<
+    {foo: string},
+    {bar: string}
+  >('DO_SOMETHING', {baz: 'baz'});
+
+  assert.equal(asyncActions.type, 'prefix/DO_SOMETHING');
+  assert.equal(asyncActions.started.type, 'prefix/DO_SOMETHING_STARTED');
+  assert.equal(asyncActions.done.type, 'prefix/DO_SOMETHING_DONE');
+  assert.equal(asyncActions.failed.type, 'prefix/DO_SOMETHING_FAILED');
+
+  const started = asyncActions.started({foo: 'foo'});
+  assert.equal(started.type, 'prefix/DO_SOMETHING_STARTED');
+  assert.deepEqual(started.payload, {foo: 'foo'});
+  assert.deepEqual(started.meta, {baz: 'baz'});
+  assert.true(!started.error);
+
+  const done = asyncActions.done({params: {foo: 'foo'}, result: {bar: 'bar'}});
+  assert.true(!done.error);
+
+  const failed = asyncActions.failed({params: {foo: 'foo'}, error: 'error'});
+  assert.true(failed.error);
+
+  assert.end();
+});

tsconfig.tests.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "ES5",
+    "lib": ["es5", "es2015.core"],
+    "moduleResolution": "node",
+    "outDir": "tests-build",
+    "noImplicitReturns": true,
+    "module": "commonjs"
+  },
+  "files": [
+    "tests/index.ts"
+  ]
+}