refactor to read more from package.json

package.json

@@ -3,7 +3,12 @@
   "version": "0.7.5",
   "author": "undergroundwires",
   "description": "Enforce privacy & security best-practices on Windows, because privacy is sexy 🍑🍆",
+  "homepage": "https://privacy.sexy",
   "private": true,
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/undergroundwires/privacy.sexy.git"
+  },
   "scripts": {
     "serve": "vue-cli-service serve",
     "build": "vue-cli-service build",

src/application/Environment/BrowserOs/BrowserOsDetector.ts

@@ -1,4 +1,4 @@
-import { OperatingSystem } from '../OperatingSystem';
+import { OperatingSystem } from '@/domain/OperatingSystem';
 import { DetectorBuilder } from './DetectorBuilder';
 import { IBrowserOsDetector } from './IBrowserOsDetector';
 

src/application/Environment/BrowserOs/DetectorBuilder.ts

@@ -1,5 +1,5 @@
 import { IBrowserOsDetector } from './IBrowserOsDetector';
-import { OperatingSystem } from '../OperatingSystem';
+import { OperatingSystem } from '@/domain/OperatingSystem';
 
 export class DetectorBuilder {
     private readonly existingPartsInUserAgent = new Array<string>();

src/application/Environment/BrowserOs/IBrowserOsDetector.ts

@@ -1,4 +1,4 @@
-import { OperatingSystem } from '../OperatingSystem';
+import { OperatingSystem } from '@/domain/OperatingSystem';
 
 export interface IBrowserOsDetector {
     detect(userAgent: string): OperatingSystem;

src/application/Environment/Environment.ts

@@ -1,7 +1,7 @@
 import { BrowserOsDetector } from './BrowserOs/BrowserOsDetector';
 import { IBrowserOsDetector } from './BrowserOs/IBrowserOsDetector';
 import { IEnvironment } from './IEnvironment';
-import { OperatingSystem } from './OperatingSystem';
+import { OperatingSystem } from '@/domain/OperatingSystem';
 
 interface IEnvironmentVariables {
     readonly window: Window & typeof globalThis;

src/application/Environment/IEnvironment.ts

@@ -1,4 +1,4 @@
-import { OperatingSystem } from './OperatingSystem';
+import { OperatingSystem } from '@/domain/OperatingSystem';
 
 export interface IEnvironment {
     isDesktop: boolean;

src/application/Parser/ApplicationParser.ts

@@ -1,24 +1,35 @@
 import { Category } from '@/domain/Category';
 import { Application } from '@/domain/Application';
 import { IApplication } from '@/domain/IApplication';
+import { IProjectInformation } from '@/domain/IProjectInformation';
 import { ApplicationYaml } from 'js-yaml-loader!./../application.yaml';
 import { parseCategory } from './CategoryParser';
+import { ProjectInformation } from '../../domain/ProjectInformation';
 
-export function parseApplication(content: ApplicationYaml): IApplication {
+
+export function parseApplication(content: ApplicationYaml, env: NodeJS.ProcessEnv = process.env): IApplication {
     validate(content);
     const categories = new Array<Category>();
     for (const action of content.actions) {
         const category = parseCategory(action);
         categories.push(category);
     }
+    const info = readAppInformation(env);
     const app = new Application(
-        content.name,
-        content.repositoryUrl,
-        process.env.VUE_APP_VERSION,
+        info,
         categories);
     return app;
 }
 
+function readAppInformation(environment): IProjectInformation {
+    return new ProjectInformation(
+        environment.VUE_APP_NAME,
+        environment.VUE_APP_VERSION,
+        environment.VUE_APP_REPOSITORY_URL,
+        environment.VUE_APP_HOMEPAGE_URL,
+    );
+}
+
 function validate(content: ApplicationYaml): void {
     if (!content) {
         throw new Error('application is null or undefined');

src/application/State/ApplicationState.ts

@@ -39,7 +39,7 @@ export class ApplicationState implements IApplicationState {
         /** Initially selected scripts */
         public readonly defaultScripts: Script[]) {
         this.selection = new UserSelection(app, defaultScripts.map((script) => new SelectedScript(script, false)));
-        this.code = new ApplicationCode(this.selection, app.version);
+        this.code = new ApplicationCode(this.selection, app.info.version);
         this.filter = new UserFilter(app);
     }
 }

src/application/application.yaml

@@ -1,6 +1,4 @@
 # Structure documented in "./application.yaml.d.ts" (as code)
-name: privacy.sexy
-repositoryUrl: https://github.com/undergroundwires/privacy.sexy
 actions:
     -
         category: Privacy cleanup

src/application/application.yaml.d.ts

@@ -19,8 +19,6 @@ declare module 'js-yaml-loader!*' {
     }
 
     export interface ApplicationYaml {
-        name: string;
-        repositoryUrl: string;
         actions: ReadonlyArray<YamlCategory>;
     }
 

src/domain/Application.ts

@@ -2,6 +2,7 @@ import { IEntity } from '../infrastructure/Entity/IEntity';
 import { ICategory } from './ICategory';
 import { IScript } from './IScript';
 import { IApplication } from './IApplication';
+import { IProjectInformation } from './IProjectInformation';
 
 export class Application implements IApplication {
     public get totalScripts(): number { return this.flattened.allScripts.length; }
@@ -10,13 +11,11 @@ export class Application implements IApplication {
     private readonly flattened: IFlattenedApplication;
 
     constructor(
-        public readonly name: string,
-        public readonly repositoryUrl: string,
-        public readonly version: string,
+        public readonly info: IProjectInformation,
         public readonly actions: ReadonlyArray<ICategory>) {
-        if (!name) { throw Error('Application has no name'); }
-        if (!repositoryUrl) { throw Error('Application has no repository url'); }
-        if (!version) { throw Error('Version cannot be empty'); }
+        if (!info) {
+            throw new Error('info is undefined');
+        }
         this.flattened = flatten(actions);
         ensureValid(this.flattened);
         ensureNoDuplicates(this.flattened.allCategories);

src/domain/IApplication.ts

@@ -1,10 +1,9 @@
 import { IScript } from '@/domain/IScript';
 import { ICategory } from '@/domain/ICategory';
+import { IProjectInformation } from './IProjectInformation';
 
 export interface IApplication {
-    readonly name: string;
-    readonly repositoryUrl: string;
-    readonly version: string;
+    readonly info: IProjectInformation;
     readonly totalScripts: number;
     readonly totalCategories: number;
     readonly actions: ReadonlyArray<ICategory>;

src/domain/IProjectInformation.ts

@@ -0,0 +1,11 @@
+import { OperatingSystem } from './OperatingSystem';
+export interface IProjectInformation {
+    readonly name: string;
+    readonly version: string;
+    readonly repositoryUrl: string;
+    readonly homepage: string;
+    readonly feedbackUrl: string;
+    readonly releaseUrl: string;
+    readonly repositoryWebUrl: string;
+    getDownloadUrl(os: OperatingSystem): string;
+}

src/domain/ProjectInformation.ts

@@ -0,0 +1,55 @@
+import { IProjectInformation } from './IProjectInformation';
+import { OperatingSystem } from './OperatingSystem';
+
+export class ProjectInformation implements IProjectInformation {
+    public readonly repositoryWebUrl: string;
+    constructor(
+        public readonly name: string,
+        public readonly version: string,
+        public readonly repositoryUrl: string,
+        public readonly homepage: string,
+        ) {
+        if (!name) {
+            throw new Error('name is undefined');
+        }
+        if (!version || +version <= 0) {
+            throw new Error('version should be higher than zero');
+        }
+        if (!repositoryUrl) {
+            throw new Error('repositoryUrl is undefined');
+        }
+        if (!homepage) {
+            throw new Error('homepage is undefined');
+        }
+        this.repositoryWebUrl = getWebUrl(this.repositoryUrl);
+    }
+    public getDownloadUrl(os: OperatingSystem): string {
+        return `${this.repositoryWebUrl}/releases/download/${this.version}/${getFileName(os, this.version)}`;
+    }
+    public get feedbackUrl(): string {
+        return `${this.repositoryWebUrl}/issues`;
+    }
+    public get releaseUrl(): string {
+        return `${this.repositoryWebUrl}/releases/tag/${this.version}`;
+    }
+}
+
+function getWebUrl(gitUrl: string) {
+    if (gitUrl.endsWith('.git')) {
+      return gitUrl.substring(0, gitUrl.length - 4);
+    }
+    return gitUrl;
+}
+
+function getFileName(os: OperatingSystem, version: string): string {
+    switch (os) {
+        case OperatingSystem.Linux:
+            return `privacy.sexy-${version}.AppImage`;
+        case OperatingSystem.macOS:
+            return `privacy.sexy-${version}.dmg`;
+        case OperatingSystem.Windows:
+            return `privacy.sexy-Setup-${version}.exe`;
+        default:
+            throw new Error(`Unsupported os: ${OperatingSystem[os]}`);
+    }
+}

src/presentation/Scripts/TheScripts.vue

@@ -74,7 +74,7 @@
 
         public async mounted() {
             const state = await this.getCurrentStateAsync();
-            this.repositoryUrl = state.app.repositoryUrl;
+            this.repositoryUrl = state.app.info.repositoryWebUrl;
             state.filter.filterRemoved.on(() => {
                 this.isSearching = false;
             });

src/presentation/TheFooter/DownloadUrlList.vue

@@ -17,7 +17,7 @@
 <script lang="ts">
 import { Component, Vue } from 'vue-property-decorator';
 import { Environment } from '@/application/Environment/Environment';
-import { OperatingSystem } from '@/application/Environment/OperatingSystem';
+import { OperatingSystem } from '@/domain/OperatingSystem';
 import DownloadUrlListItem from './DownloadUrlListItem.vue';
 
 @Component({

src/presentation/TheFooter/DownloadUrlListItem.vue

@@ -12,7 +12,7 @@
 import { Component, Prop, Watch } from 'vue-property-decorator';
 import { StatefulVue } from '@/presentation/StatefulVue';
 import { Environment } from '@/application/Environment/Environment';
-import { OperatingSystem } from '@/application/Environment/OperatingSystem';
+import { OperatingSystem } from '@/domain/OperatingSystem';
 
 @Component
 export default class DownloadUrlListItem extends StatefulVue {
@@ -39,7 +39,7 @@ export default class DownloadUrlListItem extends StatefulVue {
 
   private async getDownloadUrlAsync(os: OperatingSystem): Promise<string> {
     const state = await this.getCurrentStateAsync();
-    return `${state.app.repositoryUrl}/releases/download/${state.app.version}/${getFileName(os, state.app.version)}`;
+    return state.app.info.getDownloadUrl(os);
   }
 }
 
@@ -62,18 +62,6 @@ function getOperatingSystemName(os: OperatingSystem): string {
     }
 }
 
-function getFileName(os: OperatingSystem, version: string): string {
-    switch (os) {
-        case OperatingSystem.Linux:
-            return `privacy.sexy-${version}.AppImage`;
-        case OperatingSystem.macOS:
-            return `privacy.sexy-${version}.dmg`;
-        case OperatingSystem.Windows:
-            return `privacy.sexy-Setup-${version}.exe`;
-        default:
-            throw new Error(`Unsupported os: ${OperatingSystem[os]}`);
-    }
-}
 </script>
 
 <style scoped lang="scss">

src/presentation/TheFooter/PrivacyPolicy.vue

@@ -48,8 +48,8 @@ export default class TheFooter extends StatefulVue {
 
   public async mounted() {
     const state = await this.getCurrentStateAsync();
-    this.repositoryUrl = state.app.repositoryUrl;
-    this.feedbackUrl = `${state.app.repositoryUrl}/issues`;
+    this.repositoryUrl = state.app.info.repositoryWebUrl;
+    this.feedbackUrl = state.app.info.feedbackUrl;
   }
 }
 </script>

src/presentation/TheFooter/TheFooter.vue

@@ -4,7 +4,7 @@
       <div class="footer__section">
         <span v-if="isDesktop" class="footer__section__item">
           <font-awesome-icon class="icon" :icon="['fas', 'globe']"  />
-          <span>Online version at <a href="https://privacy.sexy" target="_blank">https://privacy.sexy</a></span>
+          <span>Online version at <a :href="homepageUrl" target="_blank">{{ homepageUrl }}</a></span>
         </span>
         <span v-else class="footer__section__item">
           <DownloadUrlList />
@@ -66,6 +66,7 @@ export default class TheFooter extends StatefulVue {
   public repositoryUrl: string = '';
   public releaseUrl: string = '';
   public feedbackUrl: string = '';
+  public homepageUrl: string = '';
 
   constructor() {
     super();
@@ -74,12 +75,15 @@ export default class TheFooter extends StatefulVue {
 
   public async mounted() {
     const state = await this.getCurrentStateAsync();
-    this.version = state.app.version;
-    this.repositoryUrl = state.app.repositoryUrl;
-    this.releaseUrl = `${state.app.repositoryUrl}/releases/tag/${state.app.version}`;
-    this.feedbackUrl = `${state.app.repositoryUrl}/issues`;
+    const info = state.app.info;
+    this.version = info.version;
+    this.homepageUrl = info.homepage;
+    this.repositoryUrl = info.repositoryWebUrl;
+    this.releaseUrl = info.releaseUrl;
+    this.feedbackUrl = info.feedbackUrl;
   }
 }
+
 </script>
 
 <style scoped lang="scss">

src/presentation/TheHeader.vue

@@ -16,7 +16,7 @@ export default class TheHeader extends StatefulVue {
 
   public async mounted() {
     const state = await this.getCurrentStateAsync();
-    this.title = state.app.name;
+    this.title = state.app.info.name;
   }
 }
 </script>

tests/unit/application/Environment/BrowserOs/BrowserOsDetector.spec.ts

@@ -1,5 +1,5 @@
 import { expect } from 'chai';
-import { OperatingSystem } from '@/application/Environment/OperatingSystem';
+import { OperatingSystem } from '@/domain/OperatingSystem';
 import { BrowserOsDetector } from '@/application/Environment/BrowserOs/BrowserOsDetector';
 import { BrowserOsTestCases } from './BrowserOsTestCases';
 

tests/unit/application/Environment/BrowserOs/BrowserOsTestCases.ts

@@ -1,4 +1,4 @@
-import { OperatingSystem } from '@/application/Environment/OperatingSystem';
+import { OperatingSystem } from '@/domain/OperatingSystem';
 
 interface IBrowserOsTestCase {
     userAgent: string;

tests/unit/application/Environment/DesktopOsTestCases.ts

@@ -1,4 +1,4 @@
-import { OperatingSystem } from '@/application/Environment/OperatingSystem';
+import { OperatingSystem } from '@/domain/OperatingSystem';
 
 interface IDesktopTestCase {
     processPlatform: string;

tests/unit/application/Environment/Environment.spec.ts

@@ -1,5 +1,5 @@
 import { IBrowserOsDetector } from '@/application/Environment/BrowserOs/IBrowserOsDetector';
-import { OperatingSystem } from '@/application/Environment/OperatingSystem';
+import { OperatingSystem } from '@/domain/OperatingSystem';
 import { DesktopOsTestCases } from './DesktopOsTestCases';
 import { Environment } from '@/application/Environment/Environment';
 import { expect } from 'chai';

tests/unit/application/Parser/ApplicationParser.spec.ts

@@ -5,8 +5,6 @@ import 'mocha';
 import { expect } from 'chai';
 import { parseCategory } from '@/application/Parser/CategoryParser';
 
-declare var process;
-
 describe('ApplicationParser', () => {
     describe('parseApplication', () => {
         it('can parse current application file', () => {
@@ -16,74 +14,64 @@ describe('ApplicationParser', () => {
             expect(() => parseApplication(undefined)).to.throw('application is null or undefined');
         });
         it('throws when undefined actions', () => {
-            const sut: ApplicationYaml = {
-                name: 'test',
-                repositoryUrl: 'https://privacy.sexy',
-                actions: undefined,
-            };
+            const sut: ApplicationYaml = { actions: undefined };
             expect(() => parseApplication(sut)).to.throw('application does not define any action');
         });
         it('throws when has no actions', () => {
-            const sut: ApplicationYaml = {
-                name: 'test',
-                repositoryUrl: 'https://privacy.sexy',
-                actions: [],
-            };
+            const sut: ApplicationYaml = { actions: [] };
             expect(() => parseApplication(sut)).to.throw('application does not define any action');
         });
-        it('returns expected name', () => {
+        describe('information', () => {
+            it('returns expected repository version', () => {
                 // arrange
-            const expected = 'test-app-name';
-            const sut: ApplicationYaml = {
-                name: expected,
-                repositoryUrl: 'https://privacy.sexy',
-                actions: [ getTestCategory() ],
-            };
+                const expected = 'expected-version';
+                const env = getProcessEnvironmentStub();
+                env.VUE_APP_VERSION = expected;
+                const sut: ApplicationYaml = { actions: [ getTestCategory() ] };
                 // act
-            const actual = parseApplication(sut).name;
+                const actual = parseApplication(sut, env).info.version;
                 // assert
-            expect(actual).to.be.equal(actual);
+                expect(actual).to.be.equal(expected);
             });
             it('returns expected repository url', () => {
                 // arrange
-            const expected = 'https://privacy.sexy';
-            const sut: ApplicationYaml = {
-                name: 'name',
-                repositoryUrl: expected,
-                actions: [ getTestCategory() ],
-            };
+                const expected = 'https://expected-repository.url';
+                const env = getProcessEnvironmentStub();
+                env.VUE_APP_REPOSITORY_URL = expected;
+                const sut: ApplicationYaml = { actions: [ getTestCategory() ] };
                 // act
-            const actual = parseApplication(sut).repositoryUrl;
+                const actual = parseApplication(sut, env).info.repositoryUrl;
                 // assert
-            expect(actual).to.be.equal(actual);
+                expect(actual).to.be.equal(expected);
             });
-        it('returns expected repository version', () => {
+            it('returns expected name', () => {
                 // arrange
-            const expected = '1.0.0';
-            process = {
-                env: {
-                    VUE_APP_VERSION: expected,
-                },
-            };
-            const sut: ApplicationYaml = {
-                name: 'name',
-                repositoryUrl: 'https://privacy.sexy',
-                actions: [ getTestCategory() ],
-            };
+                const expected = 'expected-app-name';
+                const env = getProcessEnvironmentStub();
+                env.VUE_APP_NAME = expected;
+                const sut: ApplicationYaml = { actions: [ getTestCategory() ] };
                 // act
-            const actual = parseApplication(sut).version;
+                const actual = parseApplication(sut, env).info.name;
                 // assert
-            expect(actual).to.be.equal(actual);
+                expect(actual).to.be.equal(expected);
+            });
+            it('returns expected homepage url', () => {
+                // arrange
+                const expected = 'https://expected.sexy';
+                const env = getProcessEnvironmentStub();
+                env.VUE_APP_HOMEPAGE_URL = expected;
+                const sut: ApplicationYaml = { actions: [ getTestCategory() ] };
+                // act
+                const actual = parseApplication(sut, env).info.homepage;
+                // assert
+                expect(actual).to.be.equal(expected);
+            });
         });
         it('parses actions', () => {
             // arrange
             const actions = [ getTestCategory('test1'), getTestCategory('test2') ];
             const expected = [ parseCategory(actions[0]), parseCategory(actions[1]) ];
-            const sut: ApplicationYaml = {
-                name: 'name',
-                repositoryUrl: 'https://privacy.sexy',
-                actions,
-            };
+            const sut: ApplicationYaml = { actions };
             // act
             const actual = parseApplication(sut).actions;
             // assert
@@ -113,3 +101,12 @@ function getTestScript(scriptName: string): YamlScript {
         recommend: true,
     };
 }
+
+function getProcessEnvironmentStub(): NodeJS.ProcessEnv {
+    return {
+        VUE_APP_VERSION: 'stub-version',
+        VUE_APP_NAME: 'stub-name',
+        VUE_APP_REPOSITORY_URL: 'stub-repository-url',
+        VUE_APP_HOMEPAGE_URL: 'stub-homepage-url',
+    };
+}

tests/unit/domain/Application.spec.ts

@@ -1,8 +1,10 @@
 import { ScriptStub } from './../stubs/ScriptStub';
 import { CategoryStub } from './../stubs/CategoryStub';
-import { Application } from './../../../src/domain/Application';
+import { Application } from '@/domain/Application';
 import 'mocha';
 import { expect } from 'chai';
+import { ProjectInformation } from '@/domain/ProjectInformation';
+import { IProjectInformation } from '@/domain/IProjectInformation';
 
 describe('Application', () => {
     it('getRecommendedScripts returns as expected', () => {
@@ -11,25 +13,22 @@ describe('Application', () => {
             new ScriptStub('S3').withIsRecommended(true),
             new ScriptStub('S4').withIsRecommended(true),
         ];
-        const sut = new Application('name', 'repo', '0.1.0', [
+        const sut = new Application(createInformation(), [
             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]);
     });
+    describe('parameter validation', () => {
         it('cannot construct without categories', () => {
             // arrange
             const categories = [];
-
             // act
-        function construct() { return new Application('name', 'repo', '0.1.0', categories); }
-
+            function construct() { return new Application(createInformation(), categories); }
             // assert
             expect(construct).to.throw('Application must consist of at least one category');
         });
@@ -39,10 +38,8 @@ describe('Application', () => {
                 new CategoryStub(3),
                 new CategoryStub(2),
             ];
-
             // act
-        function construct() { return new Application('name', 'repo',  '0.1.0', categories); }
-
+            function construct() { return new Application(createInformation(), categories); }
             // assert
             expect(construct).to.throw('Application must consist of at least one script');
         });
@@ -52,13 +49,21 @@ describe('Application', () => {
                 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', 'repo', '0.1.0', categories); }
-
+            function construct() { return new Application(createInformation(), categories); }
             // assert
             expect(construct).to.throw('Application must consist of at least one recommended script');
         });
+        it('cannot construct without information', () => {
+            // arrange
+            const categories = [new CategoryStub(1).withScripts(new ScriptStub('S1').withIsRecommended(true))];
+            const information = undefined;
+            // act
+            function construct() { return new Application(information, categories); }
+            // assert
+            expect(construct).to.throw('info is undefined');
+        });
+    });
     it('totalScripts counts right', () => {
         // arrange
         const categories = [
@@ -67,9 +72,9 @@ describe('Application', () => {
             new CategoryStub(3).withCategories(new CategoryStub(4).withScripts(new ScriptStub('S4'))),
         ];
         // act
-        const application = new Application('name', 'repo', '0.1.0', categories);
+        const sut = new Application(createInformation(), categories);
         // assert
-        expect(application.totalScripts).to.equal(4);
+        expect(sut.totalScripts).to.equal(4);
     });
     it('totalCategories counts right', () => {
         // arrange
@@ -79,8 +84,22 @@ describe('Application', () => {
             new CategoryStub(3).withCategories(new CategoryStub(4).withScripts(new ScriptStub('S4'))),
         ];
         // act
-        const application = new Application('name', 'repo', '0.1.0', categories);
+        const sut = new Application(createInformation(), categories);
         // assert
-        expect(application.totalCategories).to.equal(4);
+        expect(sut.totalCategories).to.equal(4);
+    });
+    it('sets information as expected', () => {
+        // arrange
+        const expected = createInformation();
+        // act
+        const sut = new Application(
+            expected,
+            [new CategoryStub(1).withScripts(new ScriptStub('S1').withIsRecommended(true))]);
+        // assert
+        expect(sut.info).to.deep.equal(expected);
     });
 });
+
+function createInformation(): IProjectInformation {
+    return new ProjectInformation('name', 'repo', '0.1.0', 'homepage');
+}

tests/unit/domain/ProjectInformation.spec.ts

@@ -0,0 +1,128 @@
+import 'mocha';
+import { expect } from 'chai';
+import { ProjectInformation } from '@/domain/ProjectInformation';
+import { OperatingSystem } from '@/domain/OperatingSystem';
+
+describe('ProjectInformation', () => {
+    it('sets name as expected', () => {
+        // arrange
+        const expected = 'expected-name';
+        const sut = new ProjectInformation(expected, 'version', 'repositoryUrl', 'homepage');
+        // act
+        const actual = sut.name;
+        // assert
+        expect(actual).to.equal(expected);
+    });
+    it('sets version as expected', () => {
+        // arrange
+        const expected = 'expected-version';
+        const sut = new ProjectInformation('name', expected, 'repositoryUrl', 'homepage');
+        // act
+        const actual = sut.version;
+        // assert
+        expect(actual).to.equal(expected);
+    });
+    it('sets repositoryUrl as expected', () => {
+        // arrange
+        const expected = 'expected-repository-url';
+        const sut = new ProjectInformation('name', 'version', expected, 'homepage');
+        // act
+        const actual = sut.repositoryUrl;
+        // assert
+        expect(actual).to.equal(expected);
+    });
+    describe('sets repositoryWebUrl as expected', () => {
+        it('sets repositoryUrl when it does not end with .git', () => {
+            // arrange
+            const expected = 'expected-repository-url';
+            const sut = new ProjectInformation('name', 'version', expected, 'homepage');
+            // act
+            const actual = sut.repositoryWebUrl;
+            // assert
+            expect(actual).to.equal(expected);
+        });
+        it('removes ".git" from the end when it ends with ".git"', () => {
+            // arrange
+            const expected = 'expected-repository-url';
+            const sut = new ProjectInformation('name', 'version', `${expected}.git`, 'homepage');
+            // act
+            const actual = sut.repositoryWebUrl;
+            // assert
+            expect(actual).to.equal(expected);
+        });
+    });
+    it('sets homepage as expected', () => {
+        // arrange
+        const expected = 'expected-homepage';
+        const sut = new ProjectInformation('name', 'version', 'repositoryUrl', expected);
+        // act
+        const actual = sut.homepage;
+        // assert
+        expect(actual).to.equal(expected);
+    });
+    it('sets feedbackUrl to github issues page', () => {
+        // arrange
+        const repositoryUrl = 'https://github.com/undergroundwires/privacy.sexy.git';
+        const expected = 'https://github.com/undergroundwires/privacy.sexy/issues';
+        const sut = new ProjectInformation('name', 'version', repositoryUrl, 'homepage');
+        // act
+        const actual = sut.feedbackUrl;
+        // assert
+        expect(actual).to.equal(expected);
+    });
+    it('sets releaseUrl to github releases page', () => {
+        // arrange
+        const repositoryUrl = 'https://github.com/undergroundwires/privacy.sexy.git';
+        const version = '0.7.2';
+        const expected = 'https://github.com/undergroundwires/privacy.sexy/releases/tag/0.7.2';
+        const sut = new ProjectInformation('name', version, repositoryUrl, 'homepage');
+        // act
+        const actual = sut.releaseUrl;
+        // assert
+        expect(actual).to.equal(expected);
+    });
+    describe('getDownloadUrl', () => {
+        it('gets expected url for macOS', () => {
+            // arrange
+            const expected = 'https://github.com/undergroundwires/privacy.sexy/releases/download/0.7.2/privacy.sexy-0.7.2.dmg';
+            const repositoryUrl = 'https://github.com/undergroundwires/privacy.sexy.git';
+            const version = '0.7.2';
+            const sut = new ProjectInformation('name', version, repositoryUrl, 'homepage');
+            // act
+            const actual = sut.getDownloadUrl(OperatingSystem.macOS);
+            // assert
+            expect(actual).to.equal(expected);
+        });
+        it('gets expected url for Linux', () => {
+            // arrange
+            const expected = 'https://github.com/undergroundwires/privacy.sexy/releases/download/0.7.2/privacy.sexy-0.7.2.AppImage';
+            const repositoryUrl = 'https://github.com/undergroundwires/privacy.sexy.git';
+            const version = '0.7.2';
+            const sut = new ProjectInformation('name', version, repositoryUrl, 'homepage');
+            // act
+            const actual = sut.getDownloadUrl(OperatingSystem.Linux);
+            // assert
+            expect(actual).to.equal(expected);
+        });
+        it('gets expected url for Windows', () => {
+            // arrange
+            const expected = 'https://github.com/undergroundwires/privacy.sexy/releases/download/0.7.2/privacy.sexy-Setup-0.7.2.exe';
+            const repositoryUrl = 'https://github.com/undergroundwires/privacy.sexy.git';
+            const version = '0.7.2';
+            const sut = new ProjectInformation('name', version, repositoryUrl, 'homepage');
+            // act
+            const actual = sut.getDownloadUrl(OperatingSystem.Windows);
+            // assert
+            expect(actual).to.equal(expected);
+        });
+        it('throws when OS is unknown', () => {
+            // arrange
+            const sut = new ProjectInformation('name', 'version', 'repositoryUrl', 'homepage');
+            const os = OperatingSystem.Unknown;
+            // act
+            const act = () => sut.getDownloadUrl(os);
+            // assert
+            expect(act).to.throw(`Unsupported os: ${OperatingSystem[os]}`);
+        });
+    });
+});

tests/unit/stubs/ApplicationStub.ts

@@ -1,11 +1,10 @@
 import { IApplication, ICategory, IScript } from '@/domain/IApplication';
+import { ProjectInformation } from '@/domain/ProjectInformation';
 
 export class ApplicationStub implements IApplication {
     public totalScripts = 0;
     public totalCategories = 0;
-    public readonly name = 'StubApplication';
-    public readonly repositoryUrl = 'https://privacy.sexy';
-    public readonly version = '0.1.0';
+    public readonly info = new ProjectInformation('StubApplication', '0.1.0', 'https://github.com/undergroundwires/privacy.sexy', 'https://privacy.sexy');
     public readonly actions = new Array<ICategory>();
 
     public withAction(category: ICategory): ApplicationStub {

vue.config.js

@@ -1,4 +1,9 @@
-process.env.VUE_APP_VERSION = require('./package.json').version;
+const packageJson = require('./package.json');
+
+process.env.VUE_APP_VERSION         = packageJson.version;
+process.env.VUE_APP_NAME            = packageJson.name;
+process.env.VUE_APP_REPOSITORY_URL  = packageJson.repository.url;
+process.env.VUE_APP_HOMEPAGE_URL    = packageJson.homepage;
 
 module.exports = {
     pluginOptions: {