From e0ab67899d2085f071bdc1208f95a29f9f108da4 Mon Sep 17 00:00:00 2001
From: Alejandro Celaya <alejandro@alejandrocelaya.com>
Date: Sun, 12 Aug 2018 10:17:13 +0200
Subject: [PATCH] Created server reducer test

---
 src/servers/reducers/server.js       | 28 ++++-----
 test/servers/reducers/server.test.js | 87 ++++++++++++++++++++++++++++
 2 files changed, 102 insertions(+), 13 deletions(-)
 create mode 100644 test/servers/reducers/server.test.js

diff --git a/src/servers/reducers/server.js b/src/servers/reducers/server.js
index 5daa566b..08c86c2e 100644
--- a/src/servers/reducers/server.js
+++ b/src/servers/reducers/server.js
@@ -1,8 +1,9 @@
 import ServersService from '../services/ServersService';
+import { curry } from 'ramda';
 
-const FETCH_SERVERS = 'shlink/servers/FETCH_SERVERS';
-const CREATE_SERVER = 'shlink/servers/CREATE_SERVER';
-const DELETE_SERVER = 'shlink/servers/DELETE_SERVER';
+export const FETCH_SERVERS = 'shlink/servers/FETCH_SERVERS';
+export const CREATE_SERVER = 'shlink/servers/CREATE_SERVER';
+export const DELETE_SERVER = 'shlink/servers/DELETE_SERVER';
 
 export default function reducer(state = {}, action) {
   switch (action.type) {
@@ -17,19 +18,20 @@ export default function reducer(state = {}, action) {
   }
 }
 
-export const listServers = () => {
-  return {
-    type: FETCH_SERVERS,
-    servers: ServersService.listServers(),
-  };
-};
+export const _listServers = ServersService => ({
+  type: FETCH_SERVERS,
+  servers: ServersService.listServers(),
+});
+export const listServers = () => _listServers(ServersService);
 
-export const createServer = server => {
+export const _createServer = (ServersService, server) => {
   ServersService.createServer(server);
-  return listServers();
+  return _listServers(ServersService);
 };
+export const createServer = curry(_createServer)(ServersService);
 
-export const deleteServer = server => {
+export const _deleteServer = (ServersService, server) => {
   ServersService.deleteServer(server);
-  return listServers();
+  return _listServers(ServersService);
 };
+export const deleteServer = curry(_deleteServer)(ServersService);
diff --git a/test/servers/reducers/server.test.js b/test/servers/reducers/server.test.js
new file mode 100644
index 00000000..cd3f24b1
--- /dev/null
+++ b/test/servers/reducers/server.test.js
@@ -0,0 +1,87 @@
+import reduce, {
+  _createServer,
+  _deleteServer,
+  _listServers,
+  CREATE_SERVER,
+  DELETE_SERVER,
+  FETCH_SERVERS,
+} from '../../../src/servers/reducers/server';
+import * as sinon from 'sinon';
+
+describe('serverReducer', () => {
+  const servers = {
+    abc123: { id: 'abc123' },
+    def456: { id: 'def456' }
+  };
+  const ServersServiceMock = {
+    listServers: sinon.fake.returns(servers),
+    createServer: sinon.fake(),
+    deleteServer: sinon.fake(),
+  };
+
+  describe('reduce', () => {
+    it('returns servers when action is FETCH_SERVERS', () =>
+      expect(reduce({}, { type: FETCH_SERVERS, servers })).toEqual(servers)
+    );
+
+    it('returns servers when action is DELETE_SERVER', () =>
+      expect(reduce({}, { type: DELETE_SERVER, servers })).toEqual(servers)
+    );
+
+    it('adds server to list when action is CREATE_SERVER', () => {
+      const server = { id: 'abc123' };
+      expect(reduce({}, { type: CREATE_SERVER, server })).toEqual({
+        [server.id]: server
+      })
+    });
+
+    it('returns default when action is unknown', () =>
+      expect(reduce({}, { type: 'unknown' })).toEqual({})
+    );
+  });
+
+  describe('action creators', () => {
+    beforeEach(() => {
+      ServersServiceMock.listServers.resetHistory();
+      ServersServiceMock.createServer.resetHistory();
+      ServersServiceMock.deleteServer.resetHistory();
+    });
+
+    describe('listServers', () => {
+      it('fetches servers and returns them as part of the action', () => {
+        const result = _listServers(ServersServiceMock);
+
+        expect(result).toEqual({ type: FETCH_SERVERS, servers });
+        expect(ServersServiceMock.listServers.callCount).toEqual(1);
+        expect(ServersServiceMock.createServer.callCount).toEqual(0);
+        expect(ServersServiceMock.deleteServer.callCount).toEqual(0);
+      });
+    });
+
+    describe('createServer', () => {
+      it('adds new server and then fetches servers again', () => {
+        const serverToCreate = { id: 'abc123' };
+        const result = _createServer(ServersServiceMock, serverToCreate);
+
+        expect(result).toEqual({ type: FETCH_SERVERS, servers });
+        expect(ServersServiceMock.listServers.callCount).toEqual(1);
+        expect(ServersServiceMock.createServer.callCount).toEqual(1);
+        expect(ServersServiceMock.createServer.firstCall.calledWith(serverToCreate)).toEqual(true);
+        expect(ServersServiceMock.deleteServer.callCount).toEqual(0);
+      });
+    });
+
+    describe('deleteServer', () => {
+      it('deletes a server and then fetches servers again', () => {
+        const serverToDelete = { id: 'abc123' };
+        const result = _deleteServer(ServersServiceMock, serverToDelete);
+
+        expect(result).toEqual({ type: FETCH_SERVERS, servers });
+        expect(ServersServiceMock.listServers.callCount).toEqual(1);
+        expect(ServersServiceMock.createServer.callCount).toEqual(0);
+        expect(ServersServiceMock.deleteServer.callCount).toEqual(1);
+        expect(ServersServiceMock.deleteServer.firstCall.calledWith(serverToDelete)).toEqual(true);
+      });
+    });
+  });
+});