Refactored tests and removed deprecated ones

Author: wbuchwalter

package.json

@@ -30,6 +30,7 @@
   },
   "dependencies": {
     "invariant": "^2.1.0",
+    "lodash": "^3.10.1",
     "redux": "^1.0.1"
   }
 }

src/components/connector.js

@@ -2,18 +2,25 @@ import isFunction from '../utils/isFunction';
 import isPlainObject from '../utils/isPlainObject';
 import shallowEqual from '../utils/shallowEqual';
 import invariant from 'invariant';
+import _ from 'lodash'
 
-export default function Connector(store) {
+export default function Connector(store, $injector) {
   return (selector, target) => {
 
+    invariant(
+      isPlainObject(target),
+      'The target parameter passed to connect must be a plain object. Instead received %s.',
+      typeof target
+    );
+
     //Initial update
     let slice = getStateSlice(store.getState(), selector);
-    target = angular.merge(target, slice);
+    target = _.assign(target, slice);
 
     let unsubscribe = store.subscribe(() => {
       let nextSlice = getStateSlice(store.getState(), selector);
       if (!shallowEqual(slice, nextSlice)) {
-        target = angular.merge(target, nextSlice);
+        target = _.assign(target, nextSlice);
         slice = nextSlice;
       }
     });

src/components/ngRedux.js

@@ -40,6 +40,7 @@ export default function ngReduxProvider() {
 
     let finalCreateStore = _storeEnhancers ? compose(..._storeEnhancers, createStore) : createStore;
 
+    //digestMiddleware needs to be the last one.
     resolvedMiddleware.push(digestMiddleware($injector.get('$rootScope')));
 
     store = applyMiddleware(...resolvedMiddleware)(finalCreateStore)(_reducer);

test/components/connector.spec.js

@@ -10,68 +10,53 @@ describe('Connector', () => {
 		store = createStore((state, action) => ({
       foo: 'bar',
       baz: action.payload,
-      anotherState: 12
+      anotherState: 12,
+      childObject: {child: true}
 		}));
 		connect = Connector(store);
 	});
 
-	it('Should throw when not passed a function as callback', () => {
-		expect(connect.bind(connect, () => {}, undefined)).toThrow();
-		expect(connect.bind(connect, () => {}, {})).toThrow();
-		expect(connect.bind(connect, () => {}, 15)).toThrow();
+	it('Should throw when not passed a plain object as target', () => {
+		expect(connect.bind(connect, () => ({}), () => {})).toThrow();
+		expect(connect.bind(connect, () => ({}), 15)).toThrow();
+		expect(connect.bind(connect, () => ({}), undefined)).toThrow();
+		expect(connect.bind(connect, () => ({}), {})).toNotThrow();
 	});
 
-	it('Callback should be called once directly after creation to allow initialization', () => {
-		let counter = 0;
-		let callback = () => counter++;
-		connect(state => state, callback);
-		expect(counter).toBe(1);
+	it('target should be extended with state once directly after creation', () => {
+		let target = {};
+		connect(() => ({test: 1}), target);
+		expect(target).toEqual({test: 1});
 	});
 
-	it('Should call the callback passed to connect when the store updates', () => {
-		let counter = 0;
-		let callback = () => counter++;
-		connect(state => state, callback);
+	it('Should update the target passed to connect when the store updates', () => {
+		let target = {};
+		connect(state => state, target);
 		store.dispatch({type: 'ACTION', payload: 0});
+		expect(target.baz).toBe(0);
 		store.dispatch({type: 'ACTION', payload: 1});
-		expect(counter).toBe(3);
+		expect(target.baz).toBe(1);
 	});
 
-	 it('Should prevent unnecessary updates when state does not change (shallowly)', () => {
+		//does that still makes sense?
+	 /*it('Should prevent unnecessary updates when state does not change (shallowly)', () => {
 		let counter = 0;
 		let callback = () => counter++;
 		connect(state => ({baz: state.baz}), callback);
 		store.dispatch({type: 'ACTION', payload: 0});
 		store.dispatch({type: 'ACTION', payload: 0});
 		store.dispatch({type: 'ACTION', payload: 1});
 		expect(counter).toBe(3);
-	});
+	});*/
 
-	it('Should pass the selected state as argument to the callback', () => {
-		connect(state => ({
-      myFoo: state.foo
-    }), newState => {
-      expect(newState).toEqual({myFoo: 'bar'});
-    });
-	});
-
-	it('Should allow multiple store slices to be selected', () => {
-		connect(state => ({
-			foo: state.foo,
-			anotherState: state.anotherState
-    }), ({foo, anotherState}) => {
-		 	expect(foo).toBe('bar');
-		 	expect(anotherState).toBe(12);
-		});
-	});
 
 	it('Should return an unsubscribing function', () => {
-		let counter = 0;
-		let callback = () => counter++;
-		let unsubscribe = connect(state => state, callback);
-		store.dispatch({type: 'ACTION', payload: 0});
+		let target = {};
+		let unsubscribe = connect(state => state, target);
+		store.dispatch({type: 'ACTION', payload: 1});
+		expect(target.baz).toBe(1);
 		unsubscribe();
 		store.dispatch({type: 'ACTION', payload: 2});
-		expect(counter).toBe(2);
+		expect(target.baz).toBe(1);
 	});
 });