more tests for DockerfileService

static/js/services/dockerfile/dockerfile.service.impl.spec.ts

@@ -2,6 +2,116 @@ import { DockerfileServiceImpl, DockerfileInfoImpl } from './dockerfile.service.
 import Spy = jasmine.Spy;
 
 
+describe("DockerfileServiceImpl", () => {
+  var dockerfileServiceImpl: DockerfileServiceImpl;
+  var dataFileServiceMock: any;
+  var configMock: any;
+  var fileReaderMock: FileReader;
+
+  beforeEach(() => {
+    dataFileServiceMock = jasmine.createSpyObj('dataFileServiceMock', [
+      'readDataArrayAsPossibleArchive',
+      'arrayToString',
+      'blobToString',
+    ]);
+    configMock = jasmine.createSpyObj('configMock', ['getDomain']);
+    fileReaderMock = new FileReader();
+    dockerfileServiceImpl = new DockerfileServiceImpl(dataFileServiceMock, configMock, () => fileReaderMock);
+  });
+
+  describe("getDockerfile", () => {
+    var file: any;
+    var readAsFileBufferSpy: Spy;
+
+    beforeEach(() => {
+      dataFileServiceMock.readDataArrayAsPossibleArchive.and.callFake((buf, success, failure) => {
+        var files: any[] = [];
+        failure(files);
+      });
+
+      dataFileServiceMock.arrayToString.and.callFake((buf, callback) => {
+        var contents: string = "";
+        callback(contents);
+      });
+
+      dataFileServiceMock.blobToString.and.callFake((blob, callback) => {
+        var contents: string = "";
+        callback(contents);
+      });
+
+      spyOn(DockerfileInfoImpl, "forData").and.returnValue(null);
+      readAsFileBufferSpy = spyOn(fileReaderMock, "readAsArrayBuffer").and.callFake(() => {
+        var event: any = {target: {result: file}};
+        fileReaderMock.onload(event);
+      });
+
+      file = "FROM quay.io/coreos/nginx:latest";
+    });
+
+    it("calls datafile service to read given file as possible archive file", (done) => {
+      dockerfileServiceImpl.getDockerfile(file,
+        (dockerfile: DockerfileInfoImpl) => {
+          fail("Should not invoke success callback");
+          done();
+        },
+        (error: Event | string) => {
+          expect(readAsFileBufferSpy.calls.argsFor(0)[0]).toEqual(file);
+          expect(dataFileServiceMock.readDataArrayAsPossibleArchive).toHaveBeenCalled();
+          done();
+        });
+    });
+
+    it("calls datafile service to convert file to string if given file is not an archive", (done) => {
+      dockerfileServiceImpl.getDockerfile(file,
+        (dockerfile: DockerfileInfoImpl) => {
+          fail("Should not invoke success callback");
+          done();
+        },
+        (error: Event | string) => {
+          expect(dataFileServiceMock.arrayToString.calls.argsFor(0)[0]).toEqual(file);
+          done();
+        });
+    });
+
+    it("calls failure callback if given non-archive file that is not a valid Dockerfile", (done) => {
+      dockerfileServiceImpl.getDockerfile(file,
+        (dockerfile: DockerfileInfoImpl) => {
+          fail("Should not invoke success callback");
+          done();
+        },
+        (error: Event | string) => {
+          expect(error).toEqual('File chosen is not a valid Dockerfile');
+          done();
+        });
+    });
+
+    it("calls success callback with new DockerfileInfoImpl instance if given valid Dockerfile", (done) => {
+      done();
+    });
+
+    it("calls failure callback if given archive file with no Dockerfile present in root directory", (done) => {
+      done();
+    });
+
+    it("calls datafile service to convert blob to string if given file is an archive", (done) => {
+      done();
+    });
+
+    it("calls failure callback if given archive file with invalid Dockerfile", (done) => {
+      done();
+    });
+
+    it("calls success callback with new DockerfileInfoImpl instance if given archive with valid Dockerfile", (done) => {
+      done();
+    });
+  });
+
+  describe("extractDockerfile", () => {
+    // TODO
+  });
+});
+
+
 describe("DockerfileInfoImpl", () => {
   var dockerfileInfoImpl: DockerfileInfoImpl;
   var contents: string;
@@ -27,18 +137,75 @@ describe("DockerfileInfoImpl", () => {
   });
 
   describe("getRegistryBaseImage", () => {
+    var domain: string;
 
+    beforeEach(() => {
+      domain = "quay.io";
+    });
 
+    it("returns null if instance's contents do not contain a 'FROM' command", () => {
+      var getBaseImageSpy: Spy = spyOn(dockerfileInfoImpl, "getBaseImage").and.returnValue(null);
+
+      expect(dockerfileInfoImpl.getRegistryBaseImage()).toBe(null);
+      expect(getBaseImageSpy).toHaveBeenCalled();
+    });
+
+    it("returns null if the domain of the instance's config does not match that of the base image", () => {
+      configMock.getDomain.and.returnValue(domain);
+      spyOn(dockerfileInfoImpl, "getBaseImage").and.returnValue('host.com');
+
+      expect(dockerfileInfoImpl.getRegistryBaseImage()).toBe(null);
+      expect(configMock.getDomain).toHaveBeenCalled();
+    });
+
+    it("returns the registry base image", () => {
+      spyOn(dockerfileInfoImpl, "getBaseImage").and.returnValue(null);
+    });
   });
 
   describe("getBaseImage", () => {
-    var baseImageAndTag
+    var host: string;
+    var port: number;
+    var tag: string;
+    var image: string;
 
-    it("returns null if instance's contents do not contain a 'FROM' command", () => {
-      var getBaseImageAndTagSpy: Spy = spyOn(dockerfileInfoImpl, "getBaseImageAndTag").and.returnValue()
+    beforeEach(() => {
+      host = 'quay.io';
+      port = 80;
+      tag = 'latest';
+      image = 'coreos/nginx';
     });
 
-    it("returns")
+    it("returns null if instance's contents do not contain a 'FROM' command", () => {
+      var getBaseImageAndTagSpy: Spy = spyOn(dockerfileInfoImpl, "getBaseImageAndTag").and.returnValue(null);
+
+      expect(dockerfileInfoImpl.getBaseImage()).toBe(null);
+      expect(getBaseImageAndTagSpy).toHaveBeenCalled();
+    });
+
+    it("returns the image name if in the format 'someimage'", () => {
+      spyOn(dockerfileInfoImpl, "getBaseImageAndTag").and.returnValue(image);
+
+      expect(dockerfileInfoImpl.getBaseImage()).toEqual(image);
+    });
+
+    it("returns the image name if in the format 'someimage:tag'", () => {
+      spyOn(dockerfileInfoImpl, "getBaseImageAndTag").and.returnValue(`${image}:${tag}`);
+
+      expect(dockerfileInfoImpl.getBaseImage()).toEqual(image);
+    });
+
+    it("returns the host, port, and image name if in the format 'host:port/someimage'", () => {
+      spyOn(dockerfileInfoImpl, "getBaseImageAndTag").and.returnValue(`${host}:${port}/${image}`);
+
+      expect(dockerfileInfoImpl.getBaseImage()).toEqual(`${host}:${port}/${image}`);
+    });
+
+    it("returns the host, port, and image name if in the format 'host:port/someimage:tag'", () => {
+      spyOn(dockerfileInfoImpl, "getBaseImageAndTag").and.returnValue(`${host}:${port}/${image}:${tag}`);
+
+      expect(dockerfileInfoImpl.getBaseImage()).toEqual(`${host}:${port}/${image}`);
+    });
   });
 
   describe("getBaseImageAndTag", () => {
@@ -64,28 +231,3 @@ describe("DockerfileInfoImpl", () => {
     });
   });
 });
-
-
-describe("DockerfileServiceImpl", () => {
-  var dockerfileServiceImpl: DockerfileServiceImpl;
-  var dataFileServiceMock: any;
-  var configMock: any;
-
-  beforeEach(() => {
-    dataFileServiceMock = jasmine.createSpyObj('dataFileServiceMock', [
-      'readDataArrayAsPossibleArchive',
-      'arrayToString',
-      'blobToString',
-    ]);
-    configMock = jasmine.createSpyObj('configMock', ['getDomain']);
-    dockerfileServiceImpl = new DockerfileServiceImpl(dataFileServiceMock, configMock);
-  });
-
-  describe("getDockerfile", () => {
-
-  });
-
-  describe("extractDockerfile", () => {
-
-  });
-});