Automatic server discovery

src/app/components/servers/server-discovery/server-discovery.component.spec.ts

@@ -8,19 +8,26 @@ import { VersionService } from "../../../services/version.service";
 import { MockedVersionService } from "../../../services/version.service.spec";
 import { Version } from "../../../models/version";
 import { Server } from "../../../models/server";
+import { ServerService } from '../../../services/server.service';
+import { MockedServerService } from '../../../services/server.service.spec';
+import { ServerDatabase } from '../../../services/server.database';
 
 
 describe('ServerDiscoveryComponent', () => {
   let component: ServerDiscoveryComponent;
   let fixture: ComponentFixture<ServerDiscoveryComponent>;
   let mockedVersionService: MockedVersionService;
-
+  let mockedServerService: MockedServerService;
+  
   beforeEach(async(() => {
+    mockedServerService = new MockedServerService();
     mockedVersionService = new MockedVersionService();
     TestBed.configureTestingModule({
       imports: [ MatCardModule ],
       providers: [
-        { provide: VersionService, useFactory: () => mockedVersionService }
+        { provide: VersionService, useFactory: () => mockedVersionService },
+        { provide: ServerService, useFactory: () => mockedServerService },
+        ServerDatabase
       ],
       declarations: [ ServerDiscoveryComponent ]
     })
@@ -29,7 +36,12 @@ describe('ServerDiscoveryComponent', () => {
 
   beforeEach(() => {
     fixture = TestBed.createComponent(ServerDiscoveryComponent);
+
     component = fixture.componentInstance;
+
+    // we don't really want to run it during testing
+    spyOn(component, 'ngOnInit').and.returnValue(null);
+
     fixture.detectChanges();
   });
 
@@ -39,18 +51,21 @@ describe('ServerDiscoveryComponent', () => {
 
   describe('isAvailable', () => {
     it('should return server object when server is available', () => {
-        const server = new Server();
+        const version = new Version();
-        server.ip = '127.0.0.1';
+        version.version = "2.1.8";
-        server.port = 3080;
 
         const getVersionSpy = spyOn(mockedVersionService, 'get')
-          .and.returnValue(Observable.of(server));
+          .and.returnValue(Observable.of(version));
 
         component.isServerAvailable('127.0.0.1', 3080).subscribe((s) => {
           expect(s.ip).toEqual('127.0.0.1');
           expect(s.port).toEqual(3080);
         });
 
+        const server = new Server();
+        server.ip = '127.0.0.1';
+        server.port = 3080;
+
         expect(getVersionSpy).toHaveBeenCalledWith(server);
     });
 
@@ -73,10 +88,86 @@ describe('ServerDiscoveryComponent', () => {
     });
   });
 
-  // describe("discovery", () => {
+  describe("discovery", () => {
-  //     it('should discovery single server', () => {
+      it('should discovery all servers available', (done) => {
-  //       component.discovery([]);
+        const version = new Version();
-  //     });
+        version.version = "2.1.8";
-  // });
+
+        spyOn(component, 'isServerAvailable').and.callFake((ip, port) => {
+          const server = new Server();
+          server.ip = ip;
+          server.port = port;
+          return Observable.of(server);
+        });
+
+        component.discovery().subscribe((discovered) => {
+          expect(discovered[0].ip).toEqual('127.0.0.1');
+          expect(discovered[0].port).toEqual(3080);
+
+          expect(discovered.length).toEqual(1);
+
+          done();
+        });
+      });
+  });
+
+  describe("discoverFirstAvailableServer", () => {
+    let server: Server;
+
+    beforeEach(function() {
+      server = new Server();
+      server.ip = '199.111.111.1',
+      server.port = 3333;
+
+      spyOn(component, 'discovery').and.callFake(() => {
+        return Observable.of([server]);
+      });
+    });
+
+    it('should get first server from discovered and with no added before', fakeAsync(() => {
+      expect(component.discoveredServer).toBeUndefined();
+      component.discoverFirstAvailableServer();
+      tick();
+      expect(component.discoveredServer.ip).toEqual('199.111.111.1');
+      expect(component.discoveredServer.port).toEqual(3333);
+    }));
+
+    it('should get first server from discovered and with already added', fakeAsync(() => {
+      mockedServerService.servers.push(server)
+
+      expect(component.discoveredServer).toBeUndefined();
+      component.discoverFirstAvailableServer();
+      tick();
+      expect(component.discoveredServer).toBeUndefined();
+    }));
+  });
+
+  describe("accepting and ignoring found server", () => {
+    let server: Server;
+    beforeEach(() => {
+      server = new Server();
+      server.ip = '199.111.111.1',
+      server.port = 3333;
+      component.discoveredServer = server;
+    });
+
+    describe("accept", () => {
+      it("should add new server", fakeAsync(() => {
+        component.accept(server);
+        tick();
+        expect(component.discoveredServer).toBeNull();
+        expect(mockedServerService.servers[0].ip).toEqual('199.111.111.1');
+        expect(mockedServerService.servers[0].name).toEqual('199.111.111.1');
+      }));
+    });
+  
+    describe("ignore", () => {
+      it("should reject server", fakeAsync(() => {
+        component.ignore(server);
+        tick();
+        expect(component.discoveredServer).toBeNull();
+      }));
+    });
+  });
 
 });

src/app/components/servers/server-discovery/server-discovery.component.ts

@@ -20,10 +20,6 @@ export class ServerDiscoveryComponent implements OnInit {
   private defaultServers = [{
       ip: '127.0.0.1',
       port: 3080
-    },
-    {
-      ip: '127.0.0.1',
-      port: 3085
     }
   ];
 
@@ -36,6 +32,10 @@ export class ServerDiscoveryComponent implements OnInit {
   ) {}
 
   ngOnInit() {
+    this.discoverFirstAvailableServer();
+  }
+
+  discoverFirstAvailableServer() {
     forkJoin(
       Observable.fromPromise(this.serverService.findAll()).pipe(map((s: Server[]) => s)),
       this.discovery()

src/app/services/server.service.spec.ts

@@ -5,9 +5,20 @@ import { Server } from "../models/server";
 import { IndexedDbService } from "./indexed-db.service";
 import { AngularIndexedDB } from "angular2-indexeddb";
 import Spy = jasmine.Spy;
+import { resolve } from 'path';
+import { reject } from 'q';
 
 
 export class MockedServerService {
+  public servers: Server[] = [];
+
+  public create(server: Server) {
+    return new Promise((resolve, reject) => {
+      this.servers.push(server);
+      resolve(server);
+    });
+  }
+
   public get(server_id: number) {
     const server = new Server();
     server.id = server_id;
@@ -21,6 +32,12 @@ export class MockedServerService {
       resolve(server);
     });
   }
+
+  public findAll() {
+    return new Promise((resolve, reject) => {
+      resolve(this.servers);
+    });
+  }
 }
 
 

src/app/services/server.service.ts

@@ -2,7 +2,6 @@ import { Injectable } from '@angular/core';
 
 import {IndexedDbService} from "./indexed-db.service";
 import {Server} from "../models/server";
-import { Observable } from "rxjs";
 
 
 @Injectable()