test: changed properties used for testing to protected

CodeAndWeb · CodeAndWeb · commit 3227984e939e · 2025-09-10T19:44:06.000+02:00
diff --git a/README.md b/README.md
@@ -14,7 +14,7 @@ interfaces and explains how to develop custom plugins.
 - [Migration guide ngx-translate v16 -> v17](https://ngx-translate.org/getting-started/migration-guide/)
 - [Release Notes](https://github.com/ngx-translate/core/releases)
 
-In addition to that, a getting started tutorial is available here: 
+In addition to that, a getting started tutorial is available here:
 [How to Translate Your Angular App with NGX-Translate](https://www.codeandweb.com/babeledit/tutorials/how-to-translate-your-angular-app-with-ngx-translate)
 
 ## Support for older versions
diff --git a/projects/http-loader/src/lib/http-loader-backend.spec.ts b/projects/http-loader/src/lib/http-loader-backend.spec.ts
@@ -1,12 +1,16 @@
 import { HTTP_INTERCEPTORS, provideHttpClient, withInterceptorsFromDi } from "@angular/common/http";
 import { HttpTestingController, provideHttpClientTesting } from "@angular/common/http/testing";
 import { TestBed } from "@angular/core/testing";
-import { provideTranslateService, TranslateService, Translation } from "@ngx-translate/core";
+import { TranslateService, Translation } from "@ngx-translate/core";
 import { provideTranslateHttpLoader, TranslateHttpLoader } from "../public-api";
 import { MarkerInterceptor } from "../test-helper/marker-interceptor";
+import {
+    provideTestableTranslateService,
+    TestableTranslateService,
+} from "../test-helper/testable-translate-service";
 
 describe("TranslateHttpLoader (HttpBackend)", () => {
-    let translate: TranslateService;
+    let translate: TestableTranslateService;
     let http: HttpTestingController;
 
     beforeEach(() => {
@@ -20,14 +24,15 @@ describe("TranslateHttpLoader (HttpBackend)", () => {
                 },
                 provideHttpClient(withInterceptorsFromDi()),
                 provideHttpClientTesting(),
-                provideTranslateService(),
-                provideTranslateHttpLoader({
-                    useHttpBackend: true,
+                provideTestableTranslateService({
+                    loader: provideTranslateHttpLoader({
+                        useHttpBackend: true,
+                    }),
                 }),
             ],
         });
 
-        translate = TestBed.inject(TranslateService);
+        translate = TestBed.inject(TranslateService) as TestableTranslateService;
         http = TestBed.inject(HttpTestingController);
     });
 
@@ -37,8 +42,8 @@ describe("TranslateHttpLoader (HttpBackend)", () => {
 
     it("should be able to provide TranslateHttpLoader", () => {
         expect(TranslateHttpLoader).toBeDefined();
-        expect(translate.currentLoader).toBeDefined();
-        expect(translate.currentLoader instanceof TranslateHttpLoader).toBeTruthy();
+        expect(translate.getCurrentLoader()).toBeDefined();
+        expect(translate.getCurrentLoader() instanceof TranslateHttpLoader).toBeTruthy();
     });
 
     it("should be able to get translations", () => {
diff --git a/projects/http-loader/src/lib/http-loader.spec.ts b/projects/http-loader/src/lib/http-loader.spec.ts
@@ -1,7 +1,7 @@
 import { HTTP_INTERCEPTORS, provideHttpClient, withInterceptorsFromDi } from "@angular/common/http";
 import { HttpTestingController, provideHttpClientTesting } from "@angular/common/http/testing";
 import { TestBed } from "@angular/core/testing";
-import { provideTranslateService, TranslateService, Translation } from "@ngx-translate/core";
+import { TranslateService, Translation } from "@ngx-translate/core";
 import {
     provideTranslateHttpLoader,
     provideTranslateMultiHttpLoader,
@@ -10,9 +10,13 @@ import {
     TranslateMultiHttpLoaderConfig,
 } from "../public-api";
 import { MarkerInterceptor } from "../test-helper/marker-interceptor";
+import {
+    provideTestableTranslateService,
+    TestableTranslateService,
+} from "../test-helper/testable-translate-service";
 
 describe("TranslateHttpLoader (HttpClient)", () => {
-    let translate: TranslateService;
+    let translate: TestableTranslateService;
     let http: HttpTestingController;
 
     const prepareMulti = (config: Partial<TranslateMultiHttpLoaderConfig> = {}) => {
@@ -26,12 +30,13 @@ describe("TranslateHttpLoader (HttpClient)", () => {
                 },
                 provideHttpClient(withInterceptorsFromDi()),
                 provideHttpClientTesting(),
-                provideTranslateService(),
-                provideTranslateMultiHttpLoader(config),
+                provideTestableTranslateService({
+                    loader: provideTranslateMultiHttpLoader(config),
+                }),
             ],
         });
 
-        translate = TestBed.inject(TranslateService);
+        translate = TestBed.inject(TranslateService) as TestableTranslateService;
         http = TestBed.inject(HttpTestingController);
     };
 
@@ -46,12 +51,13 @@ describe("TranslateHttpLoader (HttpClient)", () => {
                 },
                 provideHttpClient(withInterceptorsFromDi()),
                 provideHttpClientTesting(),
-                provideTranslateService(),
-                provideTranslateHttpLoader(config),
+                provideTestableTranslateService({
+                    loader: provideTranslateHttpLoader(config),
+                }),
             ],
         });
 
-        translate = TestBed.inject(TranslateService);
+        translate = TestBed.inject(TranslateService) as TestableTranslateService;
         http = TestBed.inject(HttpTestingController);
     };
 
@@ -62,8 +68,8 @@ describe("TranslateHttpLoader (HttpClient)", () => {
     it("should be able to provide TranslateHttpLoader", () => {
         prepareSingle();
         expect(TranslateHttpLoader).toBeDefined();
-        expect(translate.currentLoader).toBeDefined();
-        expect(translate.currentLoader instanceof TranslateHttpLoader).toBeTruthy();
+        expect(translate.getCurrentLoader()).toBeDefined();
+        expect(translate.getCurrentLoader() instanceof TranslateHttpLoader).toBeTruthy();
     });
 
     describe("Config", () => {
diff --git a/projects/http-loader/src/test-helper/testable-translate-service.ts b/projects/http-loader/src/test-helper/testable-translate-service.ts
@@ -0,0 +1,31 @@
+import { ClassProvider, Provider } from "@angular/core";
+import {
+    provideTranslateService,
+    RootTranslateServiceConfig,
+    TranslateCompiler,
+    TranslateLoader,
+    TranslateService,
+} from "@ngx-translate/core";
+
+export class TestableTranslateService extends TranslateService {
+    public getCurrentLoader(): TranslateLoader {
+        return this.currentLoader;
+    }
+
+    public getCompiler(): TranslateCompiler {
+        return this.compiler;
+    }
+}
+
+export function provideTestableTranslateService(
+    config: RootTranslateServiceConfig = {},
+): Provider[] {
+    const providers: Provider[] = provideTranslateService(config);
+    const translateServicedProvider: ClassProvider | undefined = providers.find(
+        (provider) => (provider as ClassProvider).provide === TranslateService,
+    ) as ClassProvider | undefined;
+    if (translateServicedProvider === undefined)
+        throw new Error("Could not find TranslateService provider in provided providers");
+    translateServicedProvider.useClass = TestableTranslateService;
+    return providers;
+}
diff --git a/projects/ngx-translate/src/lib/translate.service.ts b/projects/ngx-translate/src/lib/translate.service.ts
@@ -179,8 +179,8 @@ export class TranslateService implements ITranslateService {
     private _translationRequests: Record<Language, Observable<TranslationObject>> = {};
     private lastUseLanguage: Language | null = null;
 
-    public currentLoader = inject(TranslateLoader);
-    public compiler = inject(TranslateCompiler);
+    protected currentLoader = inject(TranslateLoader);
+    protected compiler = inject(TranslateCompiler);
     private parser = inject(TranslateParser);
     private missingTranslationHandler = inject(MissingTranslationHandler);
     private store: TranslateStore = inject(TranslateStore);
diff --git a/projects/ngx-translate/src/tests/test-helpers.ts b/projects/ngx-translate/src/tests/test-helpers.ts
@@ -1,7 +1,14 @@
-import { Injectable } from "@angular/core";
+import { ClassProvider, Injectable, Provider } from "@angular/core";
 import { Observable, of, timer } from "rxjs";
 import { map } from "rxjs/operators";
-import { TranslateLoader, TranslationObject } from "../public-api";
+import {
+    provideTranslateService,
+    RootTranslateServiceConfig,
+    TranslateCompiler,
+    TranslateLoader,
+    TranslateService,
+    TranslationObject,
+} from "../public-api";
 
 @Injectable()
 export class DelayedFakeLoader implements TranslateLoader {
@@ -26,3 +33,26 @@ export class FakeLoader implements TranslateLoader {
         return of(translations[lang]);
     }
 }
+
+export class TestableTranslateService extends TranslateService {
+    public getCurrentLoader(): TranslateLoader {
+        return this.currentLoader;
+    }
+
+    public getCompiler(): TranslateCompiler {
+        return this.compiler;
+    }
+}
+
+export function provideTestableTranslateService(
+    config: RootTranslateServiceConfig = {},
+): Provider[] {
+    const providers: Provider[] = provideTranslateService(config);
+    const translateServicedProvider: ClassProvider | undefined = providers.find(
+        (provider) => (provider as ClassProvider).provide === TranslateService,
+    ) as ClassProvider | undefined;
+    if (translateServicedProvider === undefined)
+        throw new Error("Could not find TranslateService provider in provided providers");
+    translateServicedProvider.useClass = TestableTranslateService;
+    return providers;
+}
diff --git a/projects/ngx-translate/src/tests/translate.compiler.spec.ts b/projects/ngx-translate/src/tests/translate.compiler.spec.ts
@@ -9,10 +9,10 @@ import {
     TranslateService,
     Translation,
     TranslationObject,
-    provideTranslateService,
     provideTranslateLoader,
     provideTranslateCompiler,
 } from "../public-api";
+import { provideTestableTranslateService, TestableTranslateService } from "./test-helpers";
 
 const translations: TranslationObject = { LOAD: "This is a test" };
 
@@ -25,26 +25,27 @@ class FakeLoader implements TranslateLoader {
 }
 
 describe("TranslateCompiler", () => {
-    let translate: TranslateService;
+    let translate: TestableTranslateService;
 
     describe("with default TranslateNoOpCompiler", () => {
         beforeEach(() => {
             TestBed.configureTestingModule({
                 providers: [
-                    provideTranslateService(),
-                    provideTranslateLoader(FakeLoader),
-                    provideTranslateCompiler(TranslateNoOpCompiler),
+                    provideTestableTranslateService({
+                        loader: provideTranslateLoader(FakeLoader),
+                        compiler: provideTranslateCompiler(TranslateNoOpCompiler),
+                    }),
                 ],
             });
-            translate = TestBed.inject(TranslateService);
+            translate = TestBed.inject(TranslateService) as TestableTranslateService;
 
             translate.use("en");
         });
 
         it("should use the correct compiler", () => {
             expect(translate).toBeDefined();
-            expect(translate.compiler).toBeDefined();
-            expect(translate.compiler instanceof TranslateNoOpCompiler).toBeTruthy();
+            expect(translate.getCompiler()).toBeDefined();
+            expect(translate.getCompiler() instanceof TranslateNoOpCompiler).toBeTruthy();
         });
 
         it("should use the compiler on loading translations", () => {
@@ -89,20 +90,21 @@ describe("TranslateCompiler", () => {
         beforeEach(() => {
             TestBed.configureTestingModule({
                 providers: [
-                    provideTranslateService({}),
-                    provideTranslateLoader(FakeLoader),
-                    provideTranslateCompiler(CustomCompiler),
+                    provideTestableTranslateService({
+                        loader: provideTranslateLoader(FakeLoader),
+                        compiler: provideTranslateCompiler(CustomCompiler),
+                    }),
                 ],
             });
-            translate = TestBed.inject(TranslateService);
+            translate = TestBed.inject(TranslateService) as TestableTranslateService;
 
             translate.use("en");
         });
 
         it("should use the correct compiler", () => {
             expect(translate).toBeDefined();
-            expect(translate.compiler).toBeDefined();
-            expect(translate.compiler instanceof CustomCompiler).toBeTruthy();
+            expect(translate.getCompiler()).toBeDefined();
+            expect(translate.getCompiler() instanceof CustomCompiler).toBeTruthy();
         });
 
         it("should use the compiler on loading translations", () => {
diff --git a/projects/ngx-translate/src/tests/translate.loader.spec.ts b/projects/ngx-translate/src/tests/translate.loader.spec.ts
@@ -8,9 +8,9 @@ import {
     TranslateService,
     Translation,
     TranslationObject,
-    provideTranslateService,
     provideTranslateLoader,
 } from "../public-api";
+import { provideTestableTranslateService, TestableTranslateService } from "./test-helpers";
 
 const translations: TranslationObject = { TEST: "This is a test" };
 
@@ -22,17 +22,19 @@ class FakeLoader implements TranslateLoader {
 }
 
 describe("TranslateLoader", () => {
-    let translate: TranslateService;
+    let translate: TestableTranslateService;
 
     it("should be able to provide TranslateStaticLoader", () => {
         TestBed.configureTestingModule({
-            providers: [provideTranslateService({}), provideTranslateLoader(FakeLoader)],
+            providers: [
+                provideTestableTranslateService({ loader: provideTranslateLoader(FakeLoader) }),
+            ],
         });
-        translate = TestBed.inject(TranslateService);
+        translate = TestBed.inject(TranslateService) as TestableTranslateService;
 
         expect(translate).toBeDefined();
-        expect(translate.currentLoader).toBeDefined();
-        expect(translate.currentLoader instanceof FakeLoader).toBeTruthy();
+        expect(translate.getCurrentLoader()).toBeDefined();
+        expect(translate.getCurrentLoader() instanceof FakeLoader).toBeTruthy();
 
         // the lang to use, if the lang isn't available, it will use the current loader to get them
         translate.use("en");
@@ -52,15 +54,14 @@ describe("TranslateLoader", () => {
 
         TestBed.configureTestingModule({
             providers: [
-                provideTranslateService({}),
-                { provide: TranslateLoader, useClass: CustomLoader },
+                provideTestableTranslateService({ loader: provideTranslateLoader(CustomLoader) }),
             ],
         });
-        translate = TestBed.inject(TranslateService);
+        translate = TestBed.inject(TranslateService) as TestableTranslateService;
 
         expect(translate).toBeDefined();
-        expect(translate.currentLoader).toBeDefined();
-        expect(translate.currentLoader instanceof CustomLoader).toBeTruthy();
+        expect(translate.getCurrentLoader()).toBeDefined();
+        expect(translate.getCurrentLoader() instanceof CustomLoader).toBeTruthy();
 
         // the lang to use, if the lang isn't available, it will use the current loader to get them
         translate.use("en");
@@ -73,13 +74,17 @@ describe("TranslateLoader", () => {
 
     it("TranslateNoOpLoader should return empty object", () => {
         TestBed.configureTestingModule({
-            providers: [provideTranslateService(), provideTranslateLoader(TranslateNoOpLoader)],
+            providers: [
+                provideTestableTranslateService({
+                    loader: provideTranslateLoader(TranslateNoOpLoader),
+                }),
+            ],
         });
-        translate = TestBed.inject(TranslateService);
+        translate = TestBed.inject(TranslateService) as TestableTranslateService;
 
         expect(translate).toBeDefined();
-        expect(translate.currentLoader).toBeDefined();
-        expect(translate.currentLoader instanceof TranslateNoOpLoader).toBeTruthy();
+        expect(translate.getCurrentLoader()).toBeDefined();
+        expect(translate.getCurrentLoader() instanceof TranslateNoOpLoader).toBeTruthy();
 
         translate.use("en").subscribe((res: InterpolatableTranslationObject) => {
             expect(res as object).toEqual({});
diff --git a/projects/ngx-translate/src/tests/translate.pipe.spec.ts b/projects/ngx-translate/src/tests/translate.pipe.spec.ts
@@ -23,7 +23,9 @@ describe("TranslatePipe (unit)", () => {
 
         TestBed.configureTestingModule({
             providers: [
-                provideTranslateService(),
+                provideTranslateService({
+                    loader: provideTranslateLoader(DelayedFakeLoader),
+                }),
                 {
                     provide: ChangeDetectorRef,
                     useValue: ref,
@@ -32,7 +34,6 @@ describe("TranslatePipe (unit)", () => {
                     provide: TranslatePipe,
                     useClass: TranslatePipe,
                 },
-                provideTranslateLoader(DelayedFakeLoader),
             ],
         });
 
diff --git a/projects/ngx-translate/src/tests/translate.service.spec.ts b/projects/ngx-translate/src/tests/translate.service.spec.ts
