ngx-edu-sharing-ui 0.7.0

package/src/lib/spinner/spinner.component.scss

@@ -0,0 +1,141 @@
+/*SPINNER*/
+$path: '../../../../assets/spinner/';
+.spinner {
+    margin: 0 auto;
+}
+.spinnercontainer {
+    margin: auto;
+    margin-top: 20px;
+    height: 54px;
+    color: rgba(0, 0, 0, 0); /*do not change*/
+    text-align: center;
+    float: left;
+    width: 100%;
+}
+
+.inner {
+    width: 30px;
+    height: 50px;
+    display: inline-block;
+}
+
+.spinner1 {
+    background: url(data:image/svg+xml;base64,PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0idXRmLTgiPz4KPCEtLSBHZW5lcmF0b3I6IEFkb2JlIElsbHVzdHJhdG9yIDEyLjAuMCwgU1ZHIEV4cG9ydCBQbHVnLUluIC4gU1ZHIFZlcnNpb246IDYuMDAgQnVpbGQgNTE0NDgpICAtLT4KPCFET0NUWVBFIHN2ZyBQVUJMSUMgIi0vL1czQy8vRFREIFNWRyAxLjEvL0VOIiAiaHR0cDovL3d3dy53My5vcmcvR3JhcGhpY3MvU1ZHLzEuMS9EVEQvc3ZnMTEuZHRkIiBbCgk8IUVOVElUWSBuc19zdmcgImh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KCTwhRU5USVRZIG5zX3hsaW5rICJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hsaW5rIj4KXT4KPHN2ZyAgdmVyc2lvbj0iMS4xIiBpZD0iTGF5ZXJfMSIgeG1sbnM9IiZuc19zdmc7IiB4bWxuczp4bGluaz0iJm5zX3hsaW5rOyIgd2lkdGg9IjE1LjY1NyIgaGVpZ2h0PSIxMy41NTkiCgkgdmlld0JveD0iMCAwIDE1LjY1NyAxMy41NTkiIG92ZXJmbG93PSJ2aXNpYmxlIiBlbmFibGUtYmFja2dyb3VuZD0ibmV3IDAgMCAxNS42NTcgMTMuNTU5IiB4bWw6c3BhY2U9InByZXNlcnZlIj4KPHBvbHlnb24gb3BhY2l0eT0iMC42IiBmaWxsPSIjYzFjNmUzIiBwb2ludHM9IjMuOTE0LDEzLjU1OSAwLDYuNzggMy45MTQsMCAxMS43NDMsMCAxNS42NTcsNi43OCAxMS43NDMsMTMuNTU5ICIvPgo8L3N2Zz4K);
+    background-repeat: no-repeat;
+    background-position: center;
+    background-size: 50px;
+    width: 50px;
+    height: 50px;
+    -webkit-animation: spin 2s infinite ease-in;
+    -moz-animation: spin 2s infinite ease-in;
+    -ms-animation: spin 2s infinite ease-in;
+    -o-animation: spin 2s infinite ease-in;
+    animation: spin 2s infinite ease-in;
+    -webkit-animation-delay: 0.1s;
+    -moz-animation-delay: 0.1s;
+    animation-delay: 0.1s;
+}
+
+.spinner2 {
+    background: url(data:image/svg+xml;base64,PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0idXRmLTgiPz4KPCEtLSBHZW5lcmF0b3I6IEFkb2JlIElsbHVzdHJhdG9yIDEyLjAuMCwgU1ZHIEV4cG9ydCBQbHVnLUluIC4gU1ZHIFZlcnNpb246IDYuMDAgQnVpbGQgNTE0NDgpICAtLT4KPCFET0NUWVBFIHN2ZyBQVUJMSUMgIi0vL1czQy8vRFREIFNWRyAxLjEvL0VOIiAiaHR0cDovL3d3dy53My5vcmcvR3JhcGhpY3MvU1ZHLzEuMS9EVEQvc3ZnMTEuZHRkIiBbCgk8IUVOVElUWSBuc19zdmcgImh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KCTwhRU5USVRZIG5zX3hsaW5rICJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hsaW5rIj4KXT4KPHN2ZyAgdmVyc2lvbj0iMS4xIiBpZD0iTGF5ZXJfMSIgeG1sbnM9IiZuc19zdmc7IiB4bWxuczp4bGluaz0iJm5zX3hsaW5rOyIgd2lkdGg9IjE1LjY1NyIgaGVpZ2h0PSIxMy41NTkiCgkgdmlld0JveD0iMCAwIDE1LjY1NyAxMy41NTkiIG92ZXJmbG93PSJ2aXNpYmxlIiBlbmFibGUtYmFja2dyb3VuZD0ibmV3IDAgMCAxNS42NTcgMTMuNTU5IiB4bWw6c3BhY2U9InByZXNlcnZlIj4KPHBvbHlnb24gb3BhY2l0eT0iMC42IiBmaWxsPSIjN2Y5MWMzIiBwb2ludHM9IjMuOTE0LDEzLjU1OSAwLDYuNzggMy45MTQsMCAxMS43NDMsMCAxNS42NTcsNi43OCAxMS43NDMsMTMuNTU5ICIvPgo8L3N2Zz4K);
+    background-repeat: no-repeat;
+    background-position: center;
+    background-size: 50px;
+    width: 50px;
+    height: 50px;
+    -webkit-animation: spin 2s infinite ease-in;
+    -moz-animation: spin 2s infinite ease-in;
+    -ms-animation: spin 2s infinite ease-in;
+    -o-animation: spin 2s infinite ease-in;
+    animation: spin 2s infinite ease-in;
+    -webkit-animation-delay: 0.25s;
+    -moz-animation-delay: 0.25s;
+    animation-delay: 0.25s;
+}
+
+.spinner3 {
+    background: url(data:image/svg+xml;base64,PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0idXRmLTgiPz4KPCEtLSBHZW5lcmF0b3I6IEFkb2JlIElsbHVzdHJhdG9yIDEyLjAuMCwgU1ZHIEV4cG9ydCBQbHVnLUluIC4gU1ZHIFZlcnNpb246IDYuMDAgQnVpbGQgNTE0NDgpICAtLT4KPCFET0NUWVBFIHN2ZyBQVUJMSUMgIi0vL1czQy8vRFREIFNWRyAxLjEvL0VOIiAiaHR0cDovL3d3dy53My5vcmcvR3JhcGhpY3MvU1ZHLzEuMS9EVEQvc3ZnMTEuZHRkIiBbCgk8IUVOVElUWSBuc19zdmcgImh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KCTwhRU5USVRZIG5zX3hsaW5rICJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hsaW5rIj4KXT4KPHN2ZyAgdmVyc2lvbj0iMS4xIiBpZD0iTGF5ZXJfMSIgeG1sbnM9IiZuc19zdmc7IiB4bWxuczp4bGluaz0iJm5zX3hsaW5rOyIgd2lkdGg9IjE1LjY1NyIgaGVpZ2h0PSIxMy41NTkiCgkgdmlld0JveD0iMCAwIDE1LjY1NyAxMy41NTkiIG92ZXJmbG93PSJ2aXNpYmxlIiBlbmFibGUtYmFja2dyb3VuZD0ibmV3IDAgMCAxNS42NTcgMTMuNTU5IiB4bWw6c3BhY2U9InByZXNlcnZlIj4KPHBvbHlnb24gb3BhY2l0eT0iMC42IiBmaWxsPSIjMzE2MmE3IiBwb2ludHM9IjMuOTE0LDEzLjU1OSAwLDYuNzggMy45MTQsMCAxMS43NDMsMCAxNS42NTcsNi43OCAxMS43NDMsMTMuNTU5ICIvPgo8L3N2Zz4K);
+    background-repeat: no-repeat;
+    background-position: center;
+    background-size: 50px;
+    width: 50px;
+    height: 50px;
+    -webkit-animation: spin 2s infinite ease-in;
+    -moz-animation: spin 2s infinite ease-in;
+    -ms-animation: spin 2s infinite ease-in;
+    -o-animation: spin 2s infinite ease-in;
+    animation: spin 2s infinite ease-in;
+    -webkit-animation-delay: 0.5s;
+    -moz-animation-delay: 0.5s;
+    animation-delay: 0.5s;
+}
+
+@-webkit-keyframes spin {
+    0% {
+        transform: scale(1);
+    }
+
+    50% {
+        transform: scale(0.5);
+    }
+
+    100% {
+        transform: scale(1);
+    }
+}
+
+@-moz-keyframes spin {
+    0% {
+        transform: scale(1);
+    }
+
+    50% {
+        transform: scale(0.5);
+    }
+
+    100% {
+        transform: scale(1);
+    }
+}
+
+@-ms-keyframes spin {
+    0% {
+        transform: scale(1);
+    }
+
+    50% {
+        transform: scale(0.5);
+    }
+
+    100% {
+        transform: scale(1);
+    }
+}
+
+@-o-keyframes spin {
+    0% {
+        transform: scale(1);
+    }
+
+    50% {
+        transform: scale(0.5);
+    }
+
+    100% {
+        transform: scale(1);
+    }
+}
+
+@keyframes spin {
+    0% {
+        transform: scale(1);
+    }
+
+    50% {
+        transform: scale(0.5) rotate(90deg);
+    }
+
+    100% {
+        transform: scale(1);
+    }
+}

package/src/lib/spinner/spinner.component.ts

@@ -0,0 +1,12 @@
+import { Component, HostBinding, OnInit } from '@angular/core';
+
+@Component({
+    selector: 'es-spinner',
+    templateUrl: 'spinner.component.html',
+    styleUrls: ['spinner.component.scss'],
+})
+export class SpinnerComponent {
+    @HostBinding('attr.data-test') readonly dataTest = 'loading-spinner';
+
+    constructor() {}
+}

package/src/lib/translations/README.md

@@ -0,0 +1,44 @@
+# Translations
+
+Depending on the application mode, translations are loaded locally or are provided by the backend.
+
+-   In **development mode**, translations are loaded from `assets/i18n/<language>.json`)
+-   In **production mode**, translations are provided by the backend.
+
+## Usage
+
+If possible, use the `translate` directive:
+
+```html
+<div translate [translateParams]="{value: 'world'}">HELLO</div>
+```
+
+... or the `translate` pipe:
+
+```html
+<div>{{ 'HELLO' | translate:{value: 'world'} }}</div>
+```
+
+You can also translate strings programmatically:
+
+```ts
+import { TranslateService } from "@ngx-translate/core";
+import { TranslationsService } from '../translations/translations.service';
+
+constructor(
+    private translate: TranslateService,
+    private translations: TranslationsService,
+) {
+    // This is the preferred way of programmatically using translations.
+    this.translate.get('HELLO', {value: 'world'}).subscribe((translatedString) => {
+        // Do stuff.
+    });
+
+    // Do this only if you have to use `translate.instant()`.
+    this.translations.waitForInit().subscribe(() => {
+        // You can safely use `this.translate.instant()` here.
+    });
+}
+```
+
+See https://github.com/ngx-translate/core for more information.

package/src/lib/translations/fallback-translation-handler.ts

@@ -0,0 +1,7 @@
+import { MissingTranslationHandler, MissingTranslationHandlerParams } from '@ngx-translate/core';
+
+export class FallbackTranslationHandler implements MissingTranslationHandler {
+    handle(params: MissingTranslationHandlerParams) {
+        return (params.interpolateParams as any)?.fallback ?? params.key;
+    }
+}

package/src/lib/translations/languages.ts

@@ -0,0 +1,6 @@
+import { Locale } from 'ngx-edu-sharing-api';
+
+export const LANGUAGES: { [key: string]: Locale } = {
+    de: 'de_DE',
+    en: 'en_US',
+};

package/src/lib/translations/translation-loader.spec.ts

@@ -0,0 +1,352 @@
+import { HttpClient } from '@angular/common/http';
+import { fakeAsync, tick } from '@angular/core/testing';
+import { ConfigService } from 'ngx-edu-sharing-api';
+import * as rxjs from 'rxjs';
+import { Observable } from 'rxjs';
+import { TRANSLATION_LIST, TranslationLoader } from './translation-loader';
+import { TranslationSource } from './translation-source';
+import { EduSharingUiConfiguration } from '../edu-sharing-ui-configuration';
+
+class HttpClientStub {
+    get(url: string): Observable<any> {
+        return rxjs.of(null);
+    }
+}
+class EduSharingUiConfigurationStub {
+    production = false;
+}
+class ConfigStub {
+    observeTranslationOverrides(lang: string): Observable<any> {
+        return rxjs.of(null);
+    }
+    observeDefaultTranslations(lang: string): Observable<any> {
+        return rxjs.of(null);
+    }
+    setLocale(lang: string): void {}
+}
+
+describe('TranslationLoader', () => {
+    let translationLoader: TranslationLoader;
+    let httpClient: HttpClientStub;
+    let config: ConfigStub;
+    let uiConfig: EduSharingUiConfigurationStub;
+
+    beforeEach(() => {
+        httpClient = new HttpClientStub();
+        config = new ConfigStub();
+        uiConfig = new EduSharingUiConfigurationStub();
+        translationLoader = TranslationLoader.create(
+            httpClient as HttpClient,
+            config as unknown as ConfigService,
+            uiConfig as unknown as EduSharingUiConfiguration,
+        );
+    });
+
+    describe('getTranslation', () => {
+        function callGetTranslation(lang: string) {
+            return new Promise((resolve) => {
+                fakeAsync(() => {
+                    translationLoader
+                        .getTranslation(lang)
+                        .subscribe((result) => resolve(result), fail);
+                    tick(100);
+                })();
+            });
+        }
+
+        it('should run', async () => {
+            const result = await callGetTranslation('de');
+            expect(result).toEqual({});
+        });
+
+        describe('Source = Local', () => {
+            beforeEach(() => {
+                (translationLoader as any).source = TranslationSource.Local;
+            });
+
+            it('should call nothing for lang=none', async () => {
+                const getSpy = spyOn(httpClient, 'get').and.callThrough();
+                const getConfigLanguageSpy = spyOn(
+                    config,
+                    'observeTranslationOverrides',
+                ).and.callThrough();
+                const getLanguageDefaultsSpy = spyOn(
+                    config,
+                    'observeDefaultTranslations',
+                ).and.callThrough();
+                await callGetTranslation('none');
+                expect(getSpy.calls.count()).toBe(0);
+                expect(getConfigLanguageSpy.calls.count()).toBe(0);
+                expect(getLanguageDefaultsSpy.calls.count()).toBe(0);
+            });
+
+            it('should call http get', async () => {
+                const getSpy = spyOn(httpClient, 'get').and.callThrough();
+                await callGetTranslation('de');
+                expect(getSpy.calls.count()).toBe(TRANSLATION_LIST.length);
+                expect(getSpy.calls.first().args).toEqual(['assets/i18n/common/de.json']);
+                expect(getSpy.calls.mostRecent().args).toEqual(['assets/i18n/override/de.json']);
+            });
+
+            it('should call observeTranslationOverrides', async () => {
+                const getConfigLanguageSpy = spyOn(
+                    config,
+                    'observeTranslationOverrides',
+                ).and.callThrough();
+                await callGetTranslation('de');
+                expect(getConfigLanguageSpy.calls.count()).toBe(1);
+            });
+
+            it('should call setLocale with correct locale', async () => {
+                const setLocaleSpy = spyOn(config, 'setLocale').and.callThrough();
+                await callGetTranslation('de');
+                expect(setLocaleSpy.calls.mostRecent().args).toEqual(['de_DE']);
+            });
+
+            it('should not call observeDefaultTranslations', async () => {
+                const getLanguageDefaultsSpy = spyOn(
+                    config,
+                    'observeDefaultTranslations',
+                ).and.callThrough();
+                await callGetTranslation('de');
+                expect(getLanguageDefaultsSpy.calls.count()).toBe(0);
+            });
+
+            it('should include translations via http', async () => {
+                httpClient.get = (url) => {
+                    if (url === 'assets/i18n/common/de.json') {
+                        return rxjs.of({ foo: 'bar' });
+                    }
+                    return rxjs.of(null);
+                };
+                const result = await callGetTranslation('de');
+                expect(result).toEqual({ foo: 'bar' });
+            });
+
+            it('should merge translations via http', async () => {
+                httpClient.get = (url) => {
+                    if (url === 'assets/i18n/common/de.json') {
+                        return rxjs.of({ foo: 'bar' });
+                    } else if (url === 'assets/i18n/admin/de.json') {
+                        return rxjs.of({ bar: 'baz' });
+                    }
+                    return rxjs.of(null);
+                };
+                const result = await callGetTranslation('de');
+                expect(result).toEqual({ foo: 'bar', bar: 'baz' });
+            });
+
+            it('should override nested translations via http', async () => {
+                httpClient.get = (url) => {
+                    if (url === 'assets/i18n/common/de.json') {
+                        return rxjs.of({ prefix: { foo: 'bar' } });
+                    } else if (url === 'assets/i18n/admin/de.json') {
+                        return rxjs.of({ prefix: { bar: 'baz' } });
+                    }
+                    return rxjs.of(null);
+                };
+                const result = await callGetTranslation('de');
+                expect(result).toEqual({ prefix: { bar: 'baz' } });
+            });
+
+            it('should include translations via observeTranslationOverrides', async () => {
+                config.observeTranslationOverrides = (lang) => {
+                    return rxjs.of({ foo: 'bar' });
+                };
+                const result = await callGetTranslation('de');
+                expect(result).toEqual({ foo: 'bar' });
+            });
+
+            it('should override translations via observeTranslationOverrides', async () => {
+                httpClient.get = (url) => {
+                    if (url === 'assets/i18n/common/de.json') {
+                        return rxjs.of({ foo: 'bar' });
+                    }
+                    return rxjs.of(null);
+                };
+                config.observeTranslationOverrides = (lang) => {
+                    return rxjs.of({ foo: 'baz' });
+                };
+                const result = await callGetTranslation('de');
+                expect(result).toEqual({ foo: 'baz' });
+            });
+
+            it('should merge translations via observeTranslationOverrides', async () => {
+                httpClient.get = (url) => {
+                    if (url === 'assets/i18n/common/de.json') {
+                        return rxjs.of({ foo: 'bar' });
+                    }
+                    return rxjs.of(null);
+                };
+                config.observeTranslationOverrides = (lang) => {
+                    return rxjs.of({ bar: 'baz' });
+                };
+                const result = await callGetTranslation('de');
+                expect(result).toEqual({ foo: 'bar', bar: 'baz' });
+            });
+
+            it('should override nested translations via observeTranslationOverrides', async () => {
+                httpClient.get = (url) => {
+                    if (url === 'assets/i18n/common/de.json') {
+                        return rxjs.of({ prefix: { foo: 'bar' } });
+                    }
+                    return rxjs.of(null);
+                };
+                config.observeTranslationOverrides = (lang) => {
+                    return rxjs.of({ prefix: { bar: 'baz' } });
+                };
+                const result = await callGetTranslation('de');
+                expect(result).toEqual({ prefix: { bar: 'baz' } });
+            });
+
+            it('should deep-merge translations via observeTranslationOverrides', async () => {
+                httpClient.get = (url) => {
+                    if (url === 'assets/i18n/common/de.json') {
+                        return rxjs.of({ prefix: { foo: 'bar' } });
+                    }
+                    return rxjs.of(null);
+                };
+                config.observeTranslationOverrides = (lang) => {
+                    return rxjs.of({ 'prefix.bar': 'baz' });
+                };
+                const result = await callGetTranslation('de');
+                expect(result).toEqual({ prefix: { foo: 'bar', bar: 'baz' } });
+            });
+
+            it('should deep-merge translations via observeTranslationOverrides (3 levels)', async () => {
+                httpClient.get = (url) => {
+                    if (url === 'assets/i18n/common/de.json') {
+                        return rxjs.of({
+                            l1: { l2: { l3: { foo: 'bar' } } },
+                        });
+                    }
+                    return rxjs.of(null);
+                };
+                config.observeTranslationOverrides = (lang) => {
+                    return rxjs.of({ 'l1.l2.l3.bar': 'baz' });
+                };
+                const result = await callGetTranslation('de');
+                expect(result).toEqual({
+                    l1: { l2: { l3: { foo: 'bar', bar: 'baz' } } },
+                });
+            });
+
+            it('should create missing levels via observeTranslationOverrides', async () => {
+                httpClient.get = (url) => {
+                    if (url === 'assets/i18n/common/de.json') {
+                        return rxjs.of({});
+                    }
+                    return rxjs.of(null);
+                };
+                config.observeTranslationOverrides = (lang) => {
+                    return rxjs.of({ 'l1.l2.l3.bar': 'baz' });
+                };
+                const result = await callGetTranslation('de');
+                expect(result).toEqual({
+                    l1: { l2: { l3: { bar: 'baz' } } },
+                });
+            });
+        });
+
+        describe('Source = Repository', () => {
+            beforeEach(() => {
+                (translationLoader as any).source = TranslationSource.Repository;
+            });
+
+            it('should call nothing for lang=none', async () => {
+                const getSpy = spyOn(httpClient, 'get').and.callThrough();
+                const getConfigLanguageSpy = spyOn(
+                    config,
+                    'observeTranslationOverrides',
+                ).and.callThrough();
+                const getLanguageDefaultsSpy = spyOn(
+                    config,
+                    'observeDefaultTranslations',
+                ).and.callThrough();
+                await callGetTranslation('none');
+                expect(getSpy.calls.count()).toBe(0);
+                expect(getConfigLanguageSpy.calls.count()).toBe(0);
+                expect(getLanguageDefaultsSpy.calls.count()).toBe(0);
+            });
+
+            it('should not call http get', async () => {
+                const getSpy = spyOn(httpClient, 'get').and.callThrough();
+                await callGetTranslation('de');
+                expect(getSpy.calls.count()).toBe(0);
+            });
+
+            it('should call observeTranslationOverrides', async () => {
+                const getConfigLanguageSpy = spyOn(
+                    config,
+                    'observeTranslationOverrides',
+                ).and.callThrough();
+                await callGetTranslation('de');
+                expect(getConfigLanguageSpy.calls.count()).toBe(1);
+            });
+
+            it('should call observeDefaultTranslations', async () => {
+                const getLanguageDefaultsSpy = spyOn(
+                    config,
+                    'observeDefaultTranslations',
+                ).and.callThrough();
+                await callGetTranslation('de');
+                expect(getLanguageDefaultsSpy.calls.count()).toBe(1);
+            });
+
+            it('should call setLocale with correct locale', async () => {
+                const setLocaleSpy = spyOn(config, 'setLocale').and.callThrough();
+                await callGetTranslation('de');
+                expect(setLocaleSpy.calls.mostRecent().args).toEqual(['de_DE']);
+            });
+
+            it('should include translations via observeDefaultTranslations', async () => {
+                config.observeDefaultTranslations = (lang) => {
+                    return rxjs.of({ foo: 'bar' });
+                };
+                const result = await callGetTranslation('de');
+                expect(result).toEqual({ foo: 'bar' });
+            });
+
+            it('should include translations via observeTranslationOverrides', async () => {
+                config.observeTranslationOverrides = (lang) => {
+                    return rxjs.of({ foo: 'bar' });
+                };
+                const result = await callGetTranslation('de');
+                expect(result).toEqual({ foo: 'bar' });
+            });
+
+            it('should merge translations via observeTranslationOverrides', async () => {
+                config.observeDefaultTranslations = (lang) => {
+                    return rxjs.of({ foo: 'bar' });
+                };
+                config.observeTranslationOverrides = (lang) => {
+                    return rxjs.of({ bar: 'baz' });
+                };
+                const result = await callGetTranslation('de');
+                expect(result).toEqual({ foo: 'bar', bar: 'baz' });
+            });
+
+            it('should override nested translations via observeTranslationOverrides', async () => {
+                config.observeDefaultTranslations = (lang) => {
+                    return rxjs.of({ prefix: { foo: 'bar' } });
+                };
+                config.observeTranslationOverrides = (lang) => {
+                    return rxjs.of({ prefix: { bar: 'baz' } });
+                };
+                const result = await callGetTranslation('de');
+                expect(result).toEqual({ prefix: { bar: 'baz' } });
+            });
+
+            it('should deep-merge translations via observeTranslationOverrides', async () => {
+                config.observeDefaultTranslations = (lang) => {
+                    return rxjs.of({ prefix: { foo: 'bar' } });
+                };
+                config.observeTranslationOverrides = (lang) => {
+                    return rxjs.of({ 'prefix.bar': 'baz' });
+                };
+                const result = await callGetTranslation('de');
+                expect(result).toEqual({ prefix: { foo: 'bar', bar: 'baz' } });
+            });
+        });
+    });
+});