default selection is now none

tests/unit/application/UserSelection.spec.ts

@@ -11,7 +11,7 @@ describe('UserSelection', () => {
         // arrange
         const app = new ApplicationStub()
             .withCategory(new CategoryStub(1)
-                .withScripts('s1', 's2', 's3', 's4'));
+                .withScriptIds('s1', 's2', 's3', 's4'));
         const selectedScripts = [new ScriptStub('s1'), new ScriptStub('s2'), new ScriptStub('s3')];
         const sut = new UserSelection(app, selectedScripts);
 
@@ -26,7 +26,7 @@ describe('UserSelection', () => {
         // arrange
         const app = new ApplicationStub()
             .withCategory(new CategoryStub(1)
-            .withScripts('s1', 's2', 's3', 's4'));
+            .withScriptIds('s1', 's2', 's3', 's4'));
         const selectedScripts = [new ScriptStub('s1'), new ScriptStub('s2'), new ScriptStub('s3')];
         const sut = new UserSelection(app, selectedScripts);
         const expected = [new ScriptStub('s2'), new ScriptStub('s3'), new ScriptStub('s4')];

tests/unit/domain/Application.spec.ts

@@ -0,0 +1,62 @@
+import { ScriptStub } from './../stubs/ScriptStub';
+import { CategoryStub } from './../stubs/CategoryStub';
+import { Application } from './../../../src/domain/Application';
+import 'mocha';
+import { expect } from 'chai';
+
+describe('Application', () => {
+    it('getRecommendedScripts returns as expected', () => {
+        // arrange
+        const expected =  [
+            new ScriptStub('S3').withIsRecommended(true),
+            new ScriptStub('S4').withIsRecommended(true),
+        ];
+        const sut = new Application('name', 2, [
+            new CategoryStub(3).withScripts(expected[0], new ScriptStub('S1').withIsRecommended(false)),
+            new CategoryStub(2).withScripts(expected[1], new ScriptStub('S2').withIsRecommended(false)),
+        ]);
+
+        // act
+        const actual = sut.getRecommendedScripts();
+
+        // assert
+        expect(expected[0]).to.deep.equal(actual[0]);
+        expect(expected[1]).to.deep.equal(actual[1]);
+    });
+    it('cannot construct without categories', () => {
+        // arrange
+        const categories = [];
+
+        // act
+        function construct() { return new Application('name', 2, categories); }
+
+        // assert
+        expect(construct).to.throw('Application must consist of at least one category');
+    });
+    it('cannot construct without scripts', () => {
+        // arrange
+        const categories = [
+            new CategoryStub(3),
+            new CategoryStub(2),
+        ];
+
+        // act
+        function construct() { return new Application('name', 2, categories); }
+
+        // assert
+        expect(construct).to.throw('Application must consist of at least one script');
+    });
+    it('cannot construct without  any recommended scripts', () => {
+        // arrange
+        const categories = [
+            new CategoryStub(3).withScripts(new ScriptStub('S1').withIsRecommended(false)),
+            new CategoryStub(2).withScripts(new ScriptStub('S2').withIsRecommended(false)),
+        ];
+
+        // act
+        function construct() { return new Application('name', 2, categories); }
+
+        // assert
+        expect(construct).to.throw('Application must consist of at least one recommended script');
+    });
+});

tests/unit/domain/Script.spec.ts

@@ -4,12 +4,12 @@ import { Script } from '@/domain/Script';
 
 describe('Script', () => {
 
-    it('cannot construct with duplicate lines', async () => {
+    it('cannot construct with duplicate lines', () => {
         // arrange
         const code = 'duplicate\nduplicate\ntest\nduplicate';
 
         // act
-        function construct() { return new Script('ScriptName', code, []); }
+        function construct() { return new Script('ScriptName', code, [], true); }
 
         // assert
         expect(construct).to.throw();

tests/unit/stubs/ApplicationStub.ts

@@ -1,6 +1,10 @@
 import { IApplication, ICategory, IScript } from '@/domain/IApplication';
 
 export class ApplicationStub implements IApplication {
+    public readonly totalScripts = 0;
+    public readonly totalCategories = 0;
+    public readonly name = 'StubApplication';
+    public readonly version = 1;
     public readonly categories = new Array<ICategory>();
 
     public withCategory(category: ICategory): IApplication {
@@ -10,11 +14,12 @@ export class ApplicationStub implements IApplication {
     public findCategory(categoryId: number): ICategory {
         throw new Error('Method not implemented.');
     }
-
+    public getRecommendedScripts(): readonly IScript[] {
+        throw new Error('Method not implemented.');
+    }
     public findScript(scriptId: string): IScript {
         throw new Error('Method not implemented.');
     }
-
     public getAllScripts(): ReadonlyArray<IScript> {
         throw new Error('Method not implemented.');
     }

tests/unit/stubs/CategoryStub.ts

@@ -11,10 +11,16 @@ export class CategoryStub extends BaseEntity<number> implements ICategory  {
     constructor(id: number) {
         super(id);
     }
-    public withScripts(...scriptIds: string[]): CategoryStub {
+    public withScriptIds(...scriptIds: string[]): CategoryStub {
         for (const scriptId of scriptIds) {
             this.scripts.push(new ScriptStub(scriptId));
         }
         return this;
     }
+    public withScripts(...scripts: IScript[]): CategoryStub {
+        for (const script of scripts) {
+            this.scripts.push(script);
+        }
+        return this;
+    }
 }

tests/unit/stubs/ScriptStub.ts

@@ -5,8 +5,14 @@ export class ScriptStub extends BaseEntity<string> implements IScript {
     public readonly name = `name${this.id}`;
     public readonly code = `name${this.id}`;
     public readonly documentationUrls = new Array<string>();
+    public isRecommended = false;
 
     constructor(public readonly id: string) {
         super(id);
     }
+
+    public withIsRecommended(value: boolean): ScriptStub {
+        this.isRecommended = value;
+        return this;
+    }
 }