test(shared): ServiceBase tests

Signed-off-by: Kristóf Marussy <kristof@marussy.com>

2 files changed, 210 insertions, 0 deletions

diff --git a/packages/shared/jest.config.js b/packages/shared/jest.config.js
new file mode 100644
index 0000000..9aaf344
--- /dev/null
+++ b/packages/shared/jest.config.js
@@ -0,0 +1,4 @@
+import baseConfig from '../../config/jest.config.base.js';
+
+// eslint-disable-next-line unicorn/prefer-export-from -- Can't export from default.
+export default baseConfig;
diff --git a/packages/shared/src/stores/__tests__/ServiceBase.test.ts b/packages/shared/src/stores/__tests__/ServiceBase.test.ts
new file mode 100644
index 0000000..e7aa078
--- /dev/null
+++ b/packages/shared/src/stores/__tests__/ServiceBase.test.ts
@@ -0,0 +1,206 @@
+/*
+ * Copyright (C)  2022 Kristóf Marussy <kristof@marussy.com>
+ *
+ * This file is part of Sophie.
+ *
+ * Sophie is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as
+ * published by the Free Software Foundation, version 3.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only
+ */
+
+import type { SnapshotIn } from 'mobx-state-tree';
+
+import Certificate from '../Certificate.js';
+import Profile from '../Profile.js';
+import ServiceBase, { SecurityLabelKind } from '../ServiceBase.js';
+import type { ServiceStateSnapshotIn } from '../ServiceState.js';
+import SharedStoreBase from '../SharedStoreBase.js';
+
+const testProfile: SnapshotIn<typeof Profile> = {
+  id: 'testProfile',
+  settings: {
+    name: 'test profile',
+  },
+};
+
+const testService: SnapshotIn<typeof ServiceBase> = {
+  id: 'testService',
+  settings: {
+    name: 'testService',
+    url: 'https://example.org',
+    profile: 'testProfile',
+  },
+};
+
+const testCertificate: SnapshotIn<typeof Certificate> = {
+  data: '-----TEST DATA-----',
+  issuer: {
+    commonName: 'Test issuer',
+    country: '',
+    state: '',
+    locality: '',
+  },
+  issuerName: 'Test issuer',
+  subject: {
+    commonName: 'Test subject',
+    country: '',
+    state: '',
+    locality: '',
+  },
+  subjectName: 'Test subject',
+  serialNumber: '123456',
+  validStart: 1_653_551_516,
+  validExpiry: 1_685_087_516,
+  fingerprint: 'sha256/KUIHdVkSTzYmb2PGMotOPDm2ir52G1QyPW6rt6wUjZ0=',
+};
+
+function createTestService(
+  snapshot: Partial<SnapshotIn<typeof ServiceBase>>,
+  profileSnapshot?: Partial<SnapshotIn<typeof Profile>>,
+): ServiceBase {
+  const sharedStore = SharedStoreBase.create({
+    profilesById: {
+      testProfile: {
+        ...testProfile,
+        ...profileSnapshot,
+      },
+    },
+    servicesById: {
+      testService: {
+        ...testService,
+        ...snapshot,
+      },
+    },
+  });
+  return sharedStore.servicesById.get(testService.id)!;
+}
+
+test.each<{
+  state: ServiceStateSnapshotIn;
+  loading: boolean;
+  crashed: boolean;
+  hasError: boolean;
+}>([
+  {
+    state: { type: 'initializing' },
+    loading: true,
+    crashed: false,
+    hasError: false,
+  },
+  {
+    state: { type: 'loading' },
+    loading: true,
+    crashed: false,
+    hasError: false,
+  },
+  {
+    state: { type: 'loaded' },
+    loading: false,
+    crashed: false,
+    hasError: false,
+  },
+  {
+    state: {
+      type: 'failed',
+      errorCode: 999,
+      errorDesc: 'Test error',
+    },
+    loading: false,
+    crashed: false,
+    hasError: true,
+  },
+  {
+    state: {
+      type: 'certificateError',
+      errorCode: 'Test certificate error',
+      certificate: testCertificate,
+      trust: 'pending',
+    },
+    loading: false,
+    crashed: false,
+    hasError: true,
+  },
+  {
+    state: {
+      type: 'crashed',
+      reason: 'Test',
+      exitCode: 255,
+    },
+    loading: false,
+    crashed: true,
+    hasError: true,
+  },
+])(
+  'sets the loaded and error flags when the status is $state',
+  ({ state, loading, crashed, hasError }) => {
+    const service = createTestService({ state });
+
+    expect(service.loading).toBe(loading);
+    expect(service.crashed).toBe(crashed);
+    expect(service.hasError).toBe(hasError);
+    expect(service.alwaysShowLocationBar).toBe(hasError);
+  },
+);
+
+test.each([
+  [undefined, SecurityLabelKind.Empty, false],
+  ['', SecurityLabelKind.Empty, false],
+  ['https://example.org', SecurityLabelKind.SecureConnection, false],
+  ['http://example.org', SecurityLabelKind.NotSecureConnection, true],
+  ['https:', SecurityLabelKind.InvalidURL, true],
+  ['file:///etc/shadow', SecurityLabelKind.InvalidURL, true],
+  ['asdfasdfasdf', SecurityLabelKind.InvalidURL, true],
+])(
+  'sets the security label when the url %s is loaded',
+  (
+    url: string | undefined,
+    labelKind: SecurityLabelKind,
+    hasWarning: boolean,
+  ) => {
+    const service = createTestService({ currentUrl: url });
+
+    expect(service.securityLabel).toBe(labelKind);
+    expect(service.alwaysShowLocationBar).toBe(hasWarning);
+  },
+);
+
+test('shows a certificate error warning if there is a certificate error', () => {
+  const service = createTestService({
+    state: {
+      type: 'certificateError',
+      errorCode: 'Test certificate error',
+      certificate: testCertificate,
+      trust: 'pending',
+    },
+  });
+
+  expect(service.securityLabel).toBe(SecurityLabelKind.CertificateError);
+  expect(service.alwaysShowLocationBar).toBe(true);
+});
+
+test('does not trust an untrusted certificate', () => {
+  const service = createTestService({});
+
+  expect(service.isCertificateTemporarilyTrusted(testCertificate)).toBe(false);
+});
+
+test('trusts a trusted certificate', () => {
+  const service = createTestService(
+    {},
+    {
+      temporarilyTrustedCertificates: [testCertificate],
+    },
+  );
+
+  expect(service.isCertificateTemporarilyTrusted(testCertificate)).toBe(true);
+});