hendrik/lens
1
0
Fork 0
mirror of https://github.com/lensapp/lens.git synced 2025-05-20 05:10:56 +00:00
Code Issues Projects Releases Wiki Activity

Improve name of guarding injectable for stores and apis

Browse Source 
- New name better implies that it is just a guard state and does not do
  anything

Signed-off-by: Sebastian Malton <sebastian@malton.name>
This commit is contained in:
Sebastian Malton 2022-05-13 09:48:39 -04:00
parent b3c42e0dd1
commit cb0540f83c
90 changed files with 192 additions and 192 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/common/k8s-api/__tests__/deployment.api.test.ts
View File

@ -4,7 +4,7 @@
*/
import { getDiForUnitTesting } from "../../../renderer/getDiForUnitTesting";
import createStoresAndApisInjectable from "../../../renderer/create-stores-apis.injectable";
import storesAndApisCanBeCreatedInjectable from "../../../renderer/stores-apis-can-be-created.injectable";
import apiKubeInjectable from "../../../renderer/k8s/api-kube.injectable";
import type { DeploymentApi } from "../endpoints/deployment.api";
import deploymentApiInjectable from "../endpoints/deployment.api.injectable";
@ -17,7 +17,7 @@ describe("DeploymentApi", () => {
beforeEach(() => {
const di = getDiForUnitTesting({ doGeneralOverrides: true });
di.override(createStoresAndApisInjectable, () => true);
di.override(storesAndApisCanBeCreatedInjectable, () => true);
kubeJsonApi = {
getResponse: jest.fn(),
get: jest.fn(),

4
src/common/k8s-api/__tests__/stateful-set.api.test.ts
View File

@ -3,7 +3,7 @@
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
import createStoresAndApisInjectable from "../../../renderer/create-stores-apis.injectable";
import storesAndApisCanBeCreatedInjectable from "../../../renderer/stores-apis-can-be-created.injectable";
import { getDiForUnitTesting } from "../../../renderer/getDiForUnitTesting";
import apiKubeInjectable from "../../../renderer/k8s/api-kube.injectable";
import type { StatefulSetApi } from "../endpoints";
@ -17,7 +17,7 @@ describe("StatefulSetApi", () => {
beforeEach(() => {
const di = getDiForUnitTesting({ doGeneralOverrides: true });
di.override(createStoresAndApisInjectable, () => true);
di.override(storesAndApisCanBeCreatedInjectable, () => true);
kubeJsonApi = {
getResponse: jest.fn(),
get: jest.fn(),

4
src/common/k8s-api/api-manager/manager.injectable.ts
View File

@ -3,7 +3,7 @@
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
import { getInjectable, getInjectionToken } from "@ogre-tools/injectable";
import { createStoresAndApisInjectionToken } from "../create-stores-apis.token";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import type { KubeObjectStore } from "../kube-object.store";
import { ApiManager } from "./api-manager";
@ -16,7 +16,7 @@ const apiManagerInjectable = getInjectable({
instantiate: (di) => {
const apiManager = new ApiManager();
if (di.inject(createStoresAndApisInjectionToken)) {
if (di.inject(storesAndApisCanBeCreatedInjectionToken)) {
const stores = di.injectMany(kubeObjectStoreInjectionToken);
for (const store of stores) {

4
src/common/k8s-api/endpoints/cluster-role-binding.api.injectable.ts
View File

@ -4,13 +4,13 @@
*/
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { createStoresAndApisInjectionToken } from "../create-stores-apis.token";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { ClusterRoleBindingApi } from "./cluster-role-binding.api";
const clusterRoleBindingApiInjectable = getInjectable({
id: "cluster-role-binding-api",
instantiate: (di) => {
assert(di.inject(createStoresAndApisInjectionToken), "clusterRoleBindingApi is only accessible in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "clusterRoleBindingApi is only accessible in certain environments");
return new ClusterRoleBindingApi();
},

4
src/common/k8s-api/endpoints/cluster-role.api.injectable.ts
View File

@ -4,13 +4,13 @@
*/
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { createStoresAndApisInjectionToken } from "../create-stores-apis.token";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { ClusterRoleApi } from "./cluster-role.api";
const clusterRoleApiInjectable = getInjectable({
id: "cluster-role-api",
instantiate: (di) => {
assert(di.inject(createStoresAndApisInjectionToken), "clusterRoleApi is only available in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "clusterRoleApi is only available in certain environments");
return new ClusterRoleApi();
},

4
src/common/k8s-api/endpoints/cluster.api.injectable.ts
View File

@ -4,13 +4,13 @@
*/
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { createStoresAndApisInjectionToken } from "../create-stores-apis.token";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { ClusterApi } from "./cluster.api";
const clusterApiInjectable = getInjectable({
id: "cluster-api",
instantiate: (di) => {
assert(di.inject(createStoresAndApisInjectionToken), "clusterApi is only available in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "clusterApi is only available in certain environments");
return new ClusterApi();
},

4
src/common/k8s-api/endpoints/component-status.api.injectable.ts
View File

@ -4,13 +4,13 @@
*/
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { createStoresAndApisInjectionToken } from "../create-stores-apis.token";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { ComponentStatusApi } from "./component-status.api";
const componentStatusApiInjectable = getInjectable({
id: "component-status-api",
instantiate: (di) => {
assert(di.inject(createStoresAndApisInjectionToken), "componentStatusApi is only available in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "componentStatusApi is only available in certain environments");
return new ComponentStatusApi();
},

4
src/common/k8s-api/endpoints/config-map.api.injectable.ts
View File

@ -4,13 +4,13 @@
*/
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { createStoresAndApisInjectionToken } from "../create-stores-apis.token";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { ConfigMapApi } from "./config-map.api";
const configMapApiInjectable = getInjectable({
id: "config-map-api",
instantiate: (di) => {
assert(di.inject(createStoresAndApisInjectionToken), "configMapApi is only available in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "configMapApi is only available in certain environments");
return new ConfigMapApi();
},

4
src/common/k8s-api/endpoints/cron-job.api.injectable.ts
View File

@ -4,13 +4,13 @@
*/
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { createStoresAndApisInjectionToken } from "../create-stores-apis.token";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { CronJobApi } from "./cron-job.api";
const cronJobApiInjectable = getInjectable({
id: "cron-job-api",
instantiate: (di) => {
assert(di.inject(createStoresAndApisInjectionToken), "cronJobApi is only available in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "cronJobApi is only available in certain environments");
return new CronJobApi();
},

4
src/common/k8s-api/endpoints/custom-resource-definition.api.injectable.ts
View File

@ -4,13 +4,13 @@
*/
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { createStoresAndApisInjectionToken } from "../create-stores-apis.token";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { CustomResourceDefinitionApi } from "./custom-resource-definition.api";
const customResourceDefinitionApiInjectable = getInjectable({
id: "custom-resource-definition-api",
instantiate: (di) => {
assert(di.inject(createStoresAndApisInjectionToken), "customResourceDefinitionApi is only available in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "customResourceDefinitionApi is only available in certain environments");
return new CustomResourceDefinitionApi();
},

4
src/common/k8s-api/endpoints/daemon-set.api.injectable.ts
View File

@ -4,13 +4,13 @@
*/
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { createStoresAndApisInjectionToken } from "../create-stores-apis.token";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { DaemonSetApi } from "./daemon-set.api";
const daemonSetApiInjectable = getInjectable({
id: "daemon-set-api",
instantiate: (di) => {
assert(di.inject(createStoresAndApisInjectionToken), "daemonSetApi is only available in certain environements");
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "daemonSetApi is only available in certain environements");
return new DaemonSetApi();
},

4
src/common/k8s-api/endpoints/deployment.api.injectable.ts
View File

@ -4,13 +4,13 @@
*/
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { createStoresAndApisInjectionToken } from "../create-stores-apis.token";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { DeploymentApi } from "./deployment.api";
const deploymentApiInjectable = getInjectable({
id: "deployment-api",
instantiate: (di) => {
assert(di.inject(createStoresAndApisInjectionToken), "deploymentApi is only available in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "deploymentApi is only available in certain environments");
return new DeploymentApi();
},

4
src/common/k8s-api/endpoints/endpoint.api.injectable.ts
View File

@ -4,13 +4,13 @@
*/
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { createStoresAndApisInjectionToken } from "../create-stores-apis.token";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { EndpointsApi } from "./endpoint.api";
const endpointsApiInjectable = getInjectable({
id: "endpoints-api",
instantiate: (di) => {
assert(di.inject(createStoresAndApisInjectionToken), "endpointsApi is only available in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "endpointsApi is only available in certain environments");
return new EndpointsApi();
},

4
src/common/k8s-api/endpoints/events.api.injectable.ts
View File

@ -4,13 +4,13 @@
*/
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { createStoresAndApisInjectionToken } from "../create-stores-apis.token";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { KubeEventApi } from "./events.api";
const kubeEventApiInjectable = getInjectable({
id: "kube-event-api",
instantiate: (di) => {
assert(di.inject(createStoresAndApisInjectionToken), "kubeEventApi is only available in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "kubeEventApi is only available in certain environments");
return new KubeEventApi();
},

4
src/common/k8s-api/endpoints/horizontal-pod-autoscaler.api.injectable.ts
View File

@ -4,13 +4,13 @@
*/
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { createStoresAndApisInjectionToken } from "../create-stores-apis.token";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { HorizontalPodAutoscalerApi } from "./horizontal-pod-autoscaler.api";
const horizontalPodAutoscalerApiInjectable = getInjectable({
id: "horizontal-pod-autoscaler-api",
instantiate: (di) => {
assert(di.inject(createStoresAndApisInjectionToken), "horizontalPodAutoscalerApi is only available in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "horizontalPodAutoscalerApi is only available in certain environments");
return new HorizontalPodAutoscalerApi();
},

4
src/common/k8s-api/endpoints/ingress.api.injectable.ts
View File

@ -4,13 +4,13 @@
*/
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { createStoresAndApisInjectionToken } from "../create-stores-apis.token";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { IngressApi } from "./ingress.api";
const ingressApiInjectable = getInjectable({
id: "ingress-api",
instantiate: (di) => {
assert(di.inject(createStoresAndApisInjectionToken), "ingressApi is only available in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "ingressApi is only available in certain environments");
return new IngressApi();
},

4
src/common/k8s-api/endpoints/job.api.injectable.ts
View File

@ -4,13 +4,13 @@
*/
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { createStoresAndApisInjectionToken } from "../create-stores-apis.token";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { JobApi } from "./job.api";
const jobApiInjectable = getInjectable({
id: "job-api",
instantiate: (di) => {
assert(di.inject(createStoresAndApisInjectionToken), "jobApi is only available in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "jobApi is only available in certain environments");
return new JobApi();
},

4
src/common/k8s-api/endpoints/limit-range.api.injectable.ts
View File

@ -4,13 +4,13 @@
*/
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { createStoresAndApisInjectionToken } from "../create-stores-apis.token";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { LimitRangeApi } from "./limit-range.api";
const limitRangeApiInjectable = getInjectable({
id: "limit-range-api",
instantiate: (di) => {
assert(di.inject(createStoresAndApisInjectionToken), "limitRangeApi is only available in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "limitRangeApi is only available in certain environments");
return new LimitRangeApi();
},

4
src/common/k8s-api/endpoints/namespace.api.injectable.ts
View File

@ -4,13 +4,13 @@
*/
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { createStoresAndApisInjectionToken } from "../create-stores-apis.token";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { NamespaceApi } from "./namespace.api";
const namespaceApiInjectable = getInjectable({
id: "namespace-api",
instantiate: (di) => {
assert(di.inject(createStoresAndApisInjectionToken), "namespaceApi is only available in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "namespaceApi is only available in certain environments");
return new NamespaceApi();
},

4
src/common/k8s-api/endpoints/network-policy.api.injectable.ts
View File

@ -4,13 +4,13 @@
*/
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { createStoresAndApisInjectionToken } from "../create-stores-apis.token";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { NetworkPolicyApi } from "./network-policy.api";
const networkPolicyApiInjectable = getInjectable({
id: "network-policy-api",
instantiate: (di) => {
assert(di.inject(createStoresAndApisInjectionToken), "networkPolicyApi is only available in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "networkPolicyApi is only available in certain environments");
return new NetworkPolicyApi();
},

4
src/common/k8s-api/endpoints/node.api.injectable.ts
View File

@ -4,13 +4,13 @@
*/
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { createStoresAndApisInjectionToken } from "../create-stores-apis.token";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { NodeApi } from "./node.api";
const nodeApiInjectable = getInjectable({
id: "node-api",
instantiate: (di) => {
assert(di.inject(createStoresAndApisInjectionToken), "nodeApi is only available in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "nodeApi is only available in certain environments");
return new NodeApi();
},

4
src/common/k8s-api/endpoints/persistent-volume-claim.api.injectable.ts
View File

@ -4,13 +4,13 @@
*/
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { createStoresAndApisInjectionToken } from "../create-stores-apis.token";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { PersistentVolumeClaimApi } from "./persistent-volume-claim.api";
const persistentVolumeClaimApiInjectable = getInjectable({
id: "persistent-volume-claim-api",
instantiate: (di) => {
assert(di.inject(createStoresAndApisInjectionToken), "persistentVolumeClaimApi is only available in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "persistentVolumeClaimApi is only available in certain environments");
return new PersistentVolumeClaimApi();
},

4
src/common/k8s-api/endpoints/persistent-volume.api.injectable.ts
View File

@ -4,13 +4,13 @@
*/
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { createStoresAndApisInjectionToken } from "../create-stores-apis.token";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { PersistentVolumeApi } from "./persistent-volume.api";
const persistentVolumeApiInjectable = getInjectable({
id: "persistent-volume-api",
instantiate: (di) => {
assert(di.inject(createStoresAndApisInjectionToken), "persistentVolumeApi is only available in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "persistentVolumeApi is only available in certain environments");
return new PersistentVolumeApi();
},

4
src/common/k8s-api/endpoints/pod-disruption-budget.api.injectable.ts
View File

@ -4,13 +4,13 @@
*/
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { createStoresAndApisInjectionToken } from "../create-stores-apis.token";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { PodDisruptionBudgetApi } from "./pod-disruption-budget.api";
const podDisruptionBudgetApiInjectable = getInjectable({
id: "pod-disruption-budget-api",
instantiate: (di) => {
assert(di.inject(createStoresAndApisInjectionToken), "podDisruptionBudgetApi is only available in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "podDisruptionBudgetApi is only available in certain environments");
return new PodDisruptionBudgetApi();
},

4
src/common/k8s-api/endpoints/pod-metrics.api.injectable.ts
View File

@ -4,13 +4,13 @@
*/
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { createStoresAndApisInjectionToken } from "../create-stores-apis.token";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { PodMetricsApi } from "./pod-metrics.api";
const podMetricsApiInjectable = getInjectable({
id: "pod-metrics-api",
instantiate: (di) => {
assert(di.inject(createStoresAndApisInjectionToken), "podMetricsApi is only available in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "podMetricsApi is only available in certain environments");
return new PodMetricsApi();
},

4
src/common/k8s-api/endpoints/pod-security-policy.api.injectable.ts
View File

@ -4,13 +4,13 @@
*/
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { createStoresAndApisInjectionToken } from "../create-stores-apis.token";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { PodSecurityPolicyApi } from "./pod-security-policy.api";
const podSecurityPolicyApiInjectable = getInjectable({
id: "pod-security-policy-api",
instantiate: (di) => {
assert(di.inject(createStoresAndApisInjectionToken), "podSecurityPolicyApi is only available in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "podSecurityPolicyApi is only available in certain environments");
return new PodSecurityPolicyApi();
},

4
src/common/k8s-api/endpoints/pod.api.injectable.ts
View File

@ -4,13 +4,13 @@
*/
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { createStoresAndApisInjectionToken } from "../create-stores-apis.token";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { PodApi } from "./pod.api";
const podApiInjectable = getInjectable({
id: "pod-api",
instantiate: (di) => {
assert(di.inject(createStoresAndApisInjectionToken), "podApi is only available in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "podApi is only available in certain environments");
return new PodApi();
},

4
src/common/k8s-api/endpoints/replica-set.api.injectable.ts
View File

@ -4,13 +4,13 @@
*/
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { createStoresAndApisInjectionToken } from "../create-stores-apis.token";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { ReplicaSetApi } from "./replica-set.api";
const replicaSetApiInjectable = getInjectable({
id: "replica-set-api",
instantiate: (di) => {
assert(di.inject(createStoresAndApisInjectionToken), "replicaSetApi is only available in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "replicaSetApi is only available in certain environments");
return new ReplicaSetApi();
},

4
src/common/k8s-api/endpoints/resource-quota.api.injectable.ts
View File

@ -4,13 +4,13 @@
*/
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { createStoresAndApisInjectionToken } from "../create-stores-apis.token";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { ResourceQuotaApi } from "./resource-quota.api";
const resourceQuotaApiInjectable = getInjectable({
id: "resource-quota-api",
instantiate: (di) => {
assert(di.inject(createStoresAndApisInjectionToken), "resourceQuotaApi is only available in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "resourceQuotaApi is only available in certain environments");
return new ResourceQuotaApi();
},

4
src/common/k8s-api/endpoints/role-binding.api.injectable.ts
View File

@ -4,13 +4,13 @@
*/
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { createStoresAndApisInjectionToken } from "../create-stores-apis.token";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { RoleBindingApi } from "./role-binding.api";
const roleBindingApiInjectable = getInjectable({
id: "role-binding-api",
instantiate: (di) => {
assert(di.inject(createStoresAndApisInjectionToken), "roleBindingApi is only available in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "roleBindingApi is only available in certain environments");
return new RoleBindingApi();
},

4
src/common/k8s-api/endpoints/role.api.injectable.ts
View File

@ -4,13 +4,13 @@
*/
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { createStoresAndApisInjectionToken } from "../create-stores-apis.token";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { RoleApi } from "./role.api";
const roleApiInjectable = getInjectable({
id: "role-api",
instantiate: (di) => {
assert(di.inject(createStoresAndApisInjectionToken), "roleApi is only available in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "roleApi is only available in certain environments");
return new RoleApi();
},

4
src/common/k8s-api/endpoints/secret.api.injectable.ts
View File

@ -4,13 +4,13 @@
*/
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { createStoresAndApisInjectionToken } from "../create-stores-apis.token";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { SecretApi } from "./secret.api";
const secretApiInjectable = getInjectable({
id: "secret-api",
instantiate: (di) => {
assert(di.inject(createStoresAndApisInjectionToken), "secretApi is only available in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "secretApi is only available in certain environments");
return new SecretApi();
},

4
src/common/k8s-api/endpoints/self-subject-rules-reviews.api.injectable.ts
View File

@ -4,13 +4,13 @@
*/
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { createStoresAndApisInjectionToken } from "../create-stores-apis.token";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { SelfSubjectRulesReviewApi } from "./self-subject-rules-reviews.api";
const selfSubjectRulesReviewApiInjectable = getInjectable({
id: "self-subject-rules-review-api",
instantiate: (di) => {
assert(di.inject(createStoresAndApisInjectionToken), "selfSubjectRulesReviewApi is only available in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "selfSubjectRulesReviewApi is only available in certain environments");
return new SelfSubjectRulesReviewApi();
},

4
src/common/k8s-api/endpoints/service-account.api.injectable.ts
View File

@ -4,13 +4,13 @@
*/
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { createStoresAndApisInjectionToken } from "../create-stores-apis.token";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { ServiceAccountApi } from "./service-account.api";
const serviceAccountApiInjectable = getInjectable({
id: "service-account-api",
instantiate: (di) => {
assert(di.inject(createStoresAndApisInjectionToken), "serviceAccountApi is only available in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "serviceAccountApi is only available in certain environments");
return new ServiceAccountApi();
},

4
src/common/k8s-api/endpoints/service.api.injectable.ts
View File

@ -4,13 +4,13 @@
*/
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { createStoresAndApisInjectionToken } from "../create-stores-apis.token";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { ServiceApi } from "./service.api";
const serviceApiInjectable = getInjectable({
id: "service-api",
instantiate: (di) => {
assert(di.inject(createStoresAndApisInjectionToken), "serviceApi is only available in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "serviceApi is only available in certain environments");
return new ServiceApi();
},

4
src/common/k8s-api/endpoints/stateful-set.api.injectable.ts
View File

@ -4,13 +4,13 @@
*/
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { createStoresAndApisInjectionToken } from "../create-stores-apis.token";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { StatefulSetApi } from "./stateful-set.api";
const statefulSetApiInjectable = getInjectable({
id: "stateful-set-api",
instantiate: (di) => {
assert(di.inject(createStoresAndApisInjectionToken), "statefulSetApi is only available in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "statefulSetApi is only available in certain environments");
return new StatefulSetApi();
},

4
src/common/k8s-api/endpoints/storage-class.api.injectable.ts
View File

@ -4,13 +4,13 @@
*/
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { createStoresAndApisInjectionToken } from "../create-stores-apis.token";
import { storesAndApisCanBeCreatedInjectionToken } from "../stores-apis-can-be-created.token";
import { StorageClassApi } from "./storage-class.api";
const storageClassApiInjectable = getInjectable({
id: "storage-class-api",
instantiate: (di) => {
assert(di.inject(createStoresAndApisInjectionToken), "storageClassApi is only available in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "storageClassApi is only available in certain environments");
return new StorageClassApi();
},

4
src/common/k8s-api/selected-filter-namespaces.injectable.ts
View File

@ -5,12 +5,12 @@
import { getInjectable } from "@ogre-tools/injectable";
import { computed } from "mobx";
import namespaceStoreInjectable from "../../renderer/components/+namespaces/store.injectable";
import { createStoresAndApisInjectionToken } from "./create-stores-apis.token";
import { storesAndApisCanBeCreatedInjectionToken } from "./stores-apis-can-be-created.token";
const selectedFilterNamespacesInjectable = getInjectable({
id: "selected-filter-namespaces",
instantiate: (di) => {
if (!di.inject(createStoresAndApisInjectionToken)) {
if (!di.inject(storesAndApisCanBeCreatedInjectionToken)) {
// Dummy value so that this works in all environments
return computed(() => []);
}

4
src/common/k8s-api/create-stores-apis.token.ts → src/common/k8s-api/stores-apis-can-be-created.token.ts
View File

@ -5,6 +5,6 @@
import { getInjectionToken } from "@ogre-tools/injectable";
export const createStoresAndApisInjectionToken = getInjectionToken<boolean>({
id: "create-stores-and-apis-token",
export const storesAndApisCanBeCreatedInjectionToken = getInjectionToken<boolean>({
id: "stores-and-apis-can-be-created-token",
});

14
src/main/create-stores-api.injectable.ts
View File

@ -1,14 +0,0 @@
/**
* Copyright (c) OpenLens Authors. All rights reserved.
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
import { getInjectable } from "@ogre-tools/injectable";
import { createStoresAndApisInjectionToken } from "../common/k8s-api/create-stores-apis.token";
const createStoresAndApisInjectable = getInjectable({
id: "create-stores-and-apis",
instantiate: () => false,
injectionToken: createStoresAndApisInjectionToken,
});
export default createStoresAndApisInjectable;

14
src/main/stores-apis-can-be-created.injectable.ts Normal file
View File

@ -0,0 +1,14 @@
/**
* Copyright (c) OpenLens Authors. All rights reserved.
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
import { getInjectable } from "@ogre-tools/injectable";
import { storesAndApisCanBeCreatedInjectionToken } from "../common/k8s-api/stores-apis-can-be-created.token";
const storesAndApisCanBeCreatedInjectable = getInjectable({
id: "create-stores-and-apis",
instantiate: () => false,
injectionToken: storesAndApisCanBeCreatedInjectionToken,
});
export default storesAndApisCanBeCreatedInjectable;

4
src/renderer/components/+cluster/cluster-overview-store/cluster-overview-store.injectable.ts
View File

@ -9,7 +9,7 @@ import { ClusterOverviewStore, MetricNodeRole, MetricType } from "./cluster-over
import createStorageInjectable from "../../../utils/create-storage/create-storage.injectable";
import { kubeObjectStoreInjectionToken } from "../../../../common/k8s-api/api-manager/manager.injectable";
import clusterApiInjectable from "../../../../common/k8s-api/endpoints/cluster.api.injectable";
import createStoresAndApisInjectable from "../../../create-stores-apis.injectable";
import storesAndApisCanBeCreatedInjectable from "../../../stores-apis-can-be-created.injectable";
import assert from "assert";
import nodeStoreInjectable from "../../+nodes/store.injectable";
@ -17,7 +17,7 @@ const clusterOverviewStoreInjectable = getInjectable({
id: "cluster-overview-store",
instantiate: (di) => {
assert(di.inject(createStoresAndApisInjectable), "clusterOverviewStore is only available in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectable), "clusterOverviewStore is only available in certain environments");
const createStorage = di.inject(createStorageInjectable);
const clusterApi = di.inject(clusterApiInjectable);

4
src/renderer/components/+config-autoscalers/store.injectable.ts
View File

@ -6,13 +6,13 @@ import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/manager.injectable";
import horizontalPodAutoscalerApiInjectable from "../../../common/k8s-api/endpoints/horizontal-pod-autoscaler.api.injectable";
import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
import { HorizontalPodAutoscalerStore } from "./store";
const horizontalPodAutoscalerStoreInjectable = getInjectable({
id: "horizontal-pod-autoscaler-store",
instantiate: (di) => {
assert(di.inject(createStoresAndApisInjectable), "horizontalPodAutoscalerStore is only available in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectable), "horizontalPodAutoscalerStore is only available in certain environments");
const api = di.inject(horizontalPodAutoscalerApiInjectable);

4
src/renderer/components/+config-limit-ranges/store.injectable.ts
View File

@ -6,13 +6,13 @@ import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/manager.injectable";
import limitRangeApiInjectable from "../../../common/k8s-api/endpoints/limit-range.api.injectable";
import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
import { LimitRangeStore } from "./store";
const limitRangeStoreInjectable = getInjectable({
id: "limit-range-store",
instantiate: (di) => {
assert(di.inject(createStoresAndApisInjectable), "limitRangeStore is only available in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectable), "limitRangeStore is only available in certain environments");
const api = di.inject(limitRangeApiInjectable);

4
src/renderer/components/+config-maps/store.injectable.ts
View File

@ -6,13 +6,13 @@ import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/manager.injectable";
import configMapApiInjectable from "../../../common/k8s-api/endpoints/config-map.api.injectable";
import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
import { ConfigMapStore } from "./store";
const configMapStoreInjectable = getInjectable({
id: "config-map-store",
instantiate: (di) => {
assert(di.inject(createStoresAndApisInjectable), "configMapStore is only available in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectable), "configMapStore is only available in certain environments");
const api = di.inject(configMapApiInjectable);

4
src/renderer/components/+config-pod-disruption-budgets/store.injectable.ts
View File

@ -6,13 +6,13 @@ import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/manager.injectable";
import podDisruptionBudgetApiInjectable from "../../../common/k8s-api/endpoints/pod-disruption-budget.api.injectable";
import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
import { PodDisruptionBudgetStore } from "./store";
const podDisruptionBudgetStoreInjectable = getInjectable({
id: "pod-disruption-budget-store",
instantiate: (di) => {
assert(di.inject(createStoresAndApisInjectable), "podDisruptionBudgetStore is only available in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectable), "podDisruptionBudgetStore is only available in certain environments");
const api = di.inject(podDisruptionBudgetApiInjectable);

4
src/renderer/components/+config-resource-quotas/store.injectable.ts
View File

@ -6,13 +6,13 @@ import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/manager.injectable";
import resourceQuotaApiInjectable from "../../../common/k8s-api/endpoints/resource-quota.api.injectable";
import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
import { ResourceQuotaStore } from "./store";
const resourceQuotaStoreInjectable = getInjectable({
id: "resource-quota-store",
instantiate: (di) => {
assert(di.inject(createStoresAndApisInjectable), "resourceQuotaStore is only available in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectable), "resourceQuotaStore is only available in certain environments");
const api = di.inject(resourceQuotaApiInjectable);

4
src/renderer/components/+config-secrets/store.injectable.ts
View File

@ -6,13 +6,13 @@ import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/manager.injectable";
import secretApiInjectable from "../../../common/k8s-api/endpoints/secret.api.injectable";
import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
import { SecretStore } from "./store";
const secretStoreInjectable = getInjectable({
id: "secret-store",
instantiate: (di) => {
assert(di.inject(createStoresAndApisInjectable), "secretStore is only available in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectable), "secretStore is only available in certain environments");
const api = di.inject(secretApiInjectable);

4
src/renderer/components/+custom-resources/custom-resources.injectable.ts
View File

@ -5,7 +5,7 @@
import { getInjectable } from "@ogre-tools/injectable";
import { computed } from "mobx";
import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
import subscribeStoresInjectable from "../../kube-watch-api/subscribe-stores.injectable";
import customResourceDefinitionStoreInjectable from "./definition.store.injectable";
@ -13,7 +13,7 @@ const customResourceDefinitionsInjectable = getInjectable({
id: "custom-resource-definitions",
instantiate: (di) => {
const createStoresAndApis = di.inject(createStoresAndApisInjectable);
const createStoresAndApis = di.inject(storesAndApisCanBeCreatedInjectable);
if (!createStoresAndApis) {
return computed(() => []);

4
src/renderer/components/+custom-resources/definition.store.injectable.ts
View File

@ -7,13 +7,13 @@ import assert from "assert";
import autoRegistrationEmitterInjectable from "../../../common/k8s-api/api-manager/auto-registration-emitter.injectable";
import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/manager.injectable";
import customResourceDefinitionApiInjectable from "../../../common/k8s-api/endpoints/custom-resource-definition.api.injectable";
import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
import { CustomResourceDefinitionStore } from "./definition.store";
const customResourceDefinitionStoreInjectable = getInjectable({
id: "custom-resource-definition-store",
instantiate: (di) => {
assert(di.inject(createStoresAndApisInjectable), "customResourceDefinitionStore is only available in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectable), "customResourceDefinitionStore is only available in certain environments");
const api = di.inject(customResourceDefinitionApiInjectable);

4
src/renderer/components/+events/store.injectable.ts
View File

@ -7,13 +7,13 @@ import assert from "assert";
import getPodByIdInjectable from "../+workloads-pods/get-pod-by-id.injectable";
import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/manager.injectable";
import kubeEventApiInjectable from "../../../common/k8s-api/endpoints/events.api.injectable";
import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
import { EventStore } from "./store";
const eventStoreInjectable = getInjectable({
id: "event-store",
instantiate: (di) => {
assert(di.inject(createStoresAndApisInjectable), "eventStore is only available in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectable), "eventStore is only available in certain environments");
const api = di.inject(kubeEventApiInjectable);

4
src/renderer/components/+namespaces/store.injectable.ts
View File

@ -8,13 +8,13 @@ import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manag
import createStorageInjectable from "../../utils/create-storage/create-storage.injectable";
import namespaceApiInjectable from "../../../common/k8s-api/endpoints/namespace.api.injectable";
import assert from "assert";
import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
const namespaceStoreInjectable = getInjectable({
id: "namespace-store",
instantiate: (di) => {
assert(di.inject(createStoresAndApisInjectable), "namespaceStore is only available in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectable), "namespaceStore is only available in certain environments");
const createStorage = di.inject(createStorageInjectable);
const api = di.inject(namespaceApiInjectable);

4
src/renderer/components/+network-endpoints/store.injectable.ts
View File

@ -6,13 +6,13 @@ import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/manager.injectable";
import endpointsApiInjectable from "../../../common/k8s-api/endpoints/endpoint.api.injectable";
import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
import { EndpointsStore } from "./store";
const endpointsStoreInjectable = getInjectable({
id: "endpoints-store",
instantiate: (di) => {
assert(di.inject(createStoresAndApisInjectable), "endpointsStore is only available in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectable), "endpointsStore is only available in certain environments");
const api = di.inject(endpointsApiInjectable);

4
src/renderer/components/+network-ingresses/store.injectable.ts
View File

@ -6,13 +6,13 @@ import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/manager.injectable";
import ingressApiInjectable from "../../../common/k8s-api/endpoints/ingress.api.injectable";
import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
import { IngressStore } from "./store";
const ingressStoreInjectable = getInjectable({
id: "ingress-store",
instantiate: (di) => {
assert(di.inject(createStoresAndApisInjectable), "ingressStore is only available in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectable), "ingressStore is only available in certain environments");
const api = di.inject(ingressApiInjectable);

4
src/renderer/components/+network-policies/store.injectable.ts
View File

@ -6,13 +6,13 @@ import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/manager.injectable";
import networkPolicyApiInjectable from "../../../common/k8s-api/endpoints/network-policy.api.injectable";
import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
import { NetworkPolicyStore } from "./store";
const networkPolicyStoreInjectable = getInjectable({
id: "network-policy-store",
instantiate: (di) => {
assert(di.inject(createStoresAndApisInjectable), "networkPolicyStore is only available in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectable), "networkPolicyStore is only available in certain environments");
const api = di.inject(networkPolicyApiInjectable);

4
src/renderer/components/+network-services/store.injectable.ts
View File

@ -6,13 +6,13 @@ import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/manager.injectable";
import serviceApiInjectable from "../../../common/k8s-api/endpoints/service.api.injectable";
import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
import { ServiceStore } from "./store";
const serviceStoreInjectable = getInjectable({
id: "service-store",
instantiate: (di) => {
assert(di.inject(createStoresAndApisInjectable), "serviceStore is only available in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectable), "serviceStore is only available in certain environments");
const api = di.inject(serviceApiInjectable);

4
src/renderer/components/+nodes/store.injectable.ts
View File

@ -6,13 +6,13 @@ import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/manager.injectable";
import nodeApiInjectable from "../../../common/k8s-api/endpoints/node.api.injectable";
import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
import { NodeStore } from "./store";
const nodeStoreInjectable = getInjectable({
id: "node-store",
instantiate: (di) => {
assert(di.inject(createStoresAndApisInjectable), "nodeStore is only available in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectable), "nodeStore is only available in certain environments");
const api = di.inject(nodeApiInjectable);

4
src/renderer/components/+pod-security-policies/store.injectable.ts
View File

@ -6,13 +6,13 @@ import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/manager.injectable";
import podSecurityPolicyApiInjectable from "../../../common/k8s-api/endpoints/pod-security-policy.api.injectable";
import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
import { PodSecurityPolicyStore } from "./store";
const podSecurityPolicyStoreInjectable = getInjectable({
id: "pod-security-policy-store",
instantiate: (di) => {
assert(di.inject(createStoresAndApisInjectable), "podSecurityPolicyStore is only available in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectable), "podSecurityPolicyStore is only available in certain environments");
const api = di.inject(podSecurityPolicyApiInjectable);

4
src/renderer/components/+storage-classes/store.injectable.ts
View File

@ -7,13 +7,13 @@ import assert from "assert";
import getPersistentVolumesByStorageClassInjectable from "../+storage-volumes/get-persisten-volumes-by-storage-class.injectable";
import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/manager.injectable";
import storageClassApiInjectable from "../../../common/k8s-api/endpoints/storage-class.api.injectable";
import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
import { StorageClassStore } from "./store";
const storageClassStoreInjectable = getInjectable({
id: "storage-class-store",
instantiate: (di) => {
assert(di.inject(createStoresAndApisInjectable), "storageClassStore is only available in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectable), "storageClassStore is only available in certain environments");
const api = di.inject(storageClassApiInjectable);

4
src/renderer/components/+storage-volume-claims/store.injectable.ts
View File

@ -6,13 +6,13 @@ import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/manager.injectable";
import persistentVolumeClaimApiInjectable from "../../../common/k8s-api/endpoints/persistent-volume-claim.api.injectable";
import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
import { PersistentVolumeClaimStore } from "./store";
const persistentVolumeClaimStoreInjectable = getInjectable({
id: "persistent-volume-claim-store",
instantiate: (di) => {
assert(di.inject(createStoresAndApisInjectable), "persistentVolumeClaimStore is only available in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectable), "persistentVolumeClaimStore is only available in certain environments");
const api = di.inject(persistentVolumeClaimApiInjectable);

4
src/renderer/components/+storage-volumes/store.injectable.ts
View File

@ -6,13 +6,13 @@ import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/manager.injectable";
import persistentVolumeApiInjectable from "../../../common/k8s-api/endpoints/persistent-volume.api.injectable";
import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
import { PersistentVolumeStore } from "./store";
const persistentVolumeStoreInjectable = getInjectable({
id: "persistent-volume-store",
instantiate: (di) => {
assert(di.inject(createStoresAndApisInjectable), "persistentVolumeStore is only available in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectable), "persistentVolumeStore is only available in certain environments");
const api = di.inject(persistentVolumeApiInjectable);

4
src/renderer/components/+user-management/+cluster-role-bindings/__tests__/dialog.test.tsx
View File

@ -11,7 +11,7 @@ import { getDiForUnitTesting } from "../../../../getDiForUnitTesting";
import type { DiRender } from "../../../test-utils/renderFor";
import { renderFor } from "../../../test-utils/renderFor";
import clusterRoleStoreInjectable from "../../+cluster-roles/store.injectable";
import createStoresAndApisInjectable from "../../../../create-stores-apis.injectable";
import storesAndApisCanBeCreatedInjectable from "../../../../stores-apis-can-be-created.injectable";
import ipcRendererInjectable from "../../../../app-paths/get-value-from-registered-channel/ipc-renderer/ipc-renderer.injectable";
describe("ClusterRoleBindingDialog tests", () => {
@ -20,7 +20,7 @@ describe("ClusterRoleBindingDialog tests", () => {
beforeEach(async () => {
const di = getDiForUnitTesting({ doGeneralOverrides: true });
di.override(createStoresAndApisInjectable, () => true);
di.override(storesAndApisCanBeCreatedInjectable, () => true);
di.override(ipcRendererInjectable, () => ({
on: jest.fn(),
invoke: jest.fn(), // TODO: replace with proper mocking via the IPC bridge

4
src/renderer/components/+user-management/+cluster-role-bindings/store.injectable.ts
View File

@ -4,7 +4,7 @@
*/
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { createStoresAndApisInjectionToken } from "../../../../common/k8s-api/create-stores-apis.token";
import { storesAndApisCanBeCreatedInjectionToken } from "../../../../common/k8s-api/stores-apis-can-be-created.token";
import clusterRoleBindingApiInjectable from "../../../../common/k8s-api/endpoints/cluster-role-binding.api.injectable";
import { kubeObjectStoreInjectionToken } from "../../../../common/k8s-api/api-manager/manager.injectable";
import { ClusterRoleBindingStore } from "./store";
@ -12,7 +12,7 @@ import { ClusterRoleBindingStore } from "./store";
const clusterRoleBindingStoreInjectable = getInjectable({
id: "cluster-role-binding-store",
instantiate: (di) => {
assert(di.inject(createStoresAndApisInjectionToken), "clusterRoleBindingStore is only accessible in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "clusterRoleBindingStore is only accessible in certain environments");
const api = di.inject(clusterRoleBindingApiInjectable);

4
src/renderer/components/+user-management/+cluster-roles/store.injectable.ts
View File

@ -4,7 +4,7 @@
*/
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { createStoresAndApisInjectionToken } from "../../../../common/k8s-api/create-stores-apis.token";
import { storesAndApisCanBeCreatedInjectionToken } from "../../../../common/k8s-api/stores-apis-can-be-created.token";
import clusterRoleApiInjectable from "../../../../common/k8s-api/endpoints/cluster-role.api.injectable";
import { kubeObjectStoreInjectionToken } from "../../../../common/k8s-api/api-manager/manager.injectable";
import { ClusterRolesStore } from "./store";
@ -12,7 +12,7 @@ import { ClusterRolesStore } from "./store";
const clusterRoleStoreInjectable = getInjectable({
id: "cluster-role-store",
instantiate: (di) => {
assert(di.inject(createStoresAndApisInjectionToken), "clusterRoleStore is only available in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "clusterRoleStore is only available in certain environments");
const api = di.inject(clusterRoleApiInjectable);

4
src/renderer/components/+user-management/+role-bindings/__tests__/dialog.test.tsx
View File

@ -12,7 +12,7 @@ import type { DiRender } from "../../../test-utils/renderFor";
import { renderFor } from "../../../test-utils/renderFor";
import directoryForUserDataInjectable from "../../../../../common/app-paths/directory-for-user-data/directory-for-user-data.injectable";
import clusterRoleStoreInjectable from "../../+cluster-roles/store.injectable";
import createStoresAndApisInjectable from "../../../../create-stores-apis.injectable";
import storesAndApisCanBeCreatedInjectable from "../../../../stores-apis-can-be-created.injectable";
import ipcRendererInjectable from "../../../../app-paths/get-value-from-registered-channel/ipc-renderer/ipc-renderer.injectable";
describe("RoleBindingDialog tests", () => {
@ -21,7 +21,7 @@ describe("RoleBindingDialog tests", () => {
beforeEach(async () => {
const di = getDiForUnitTesting({ doGeneralOverrides: true });
di.override(createStoresAndApisInjectable, () => true);
di.override(storesAndApisCanBeCreatedInjectable, () => true);
di.override(directoryForUserDataInjectable, () => "some-directory-for-user-data");
di.override(ipcRendererInjectable, () => ({
on: jest.fn(),

4
src/renderer/components/+user-management/+role-bindings/store.injectable.ts
View File

@ -6,13 +6,13 @@ import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import { kubeObjectStoreInjectionToken } from "../../../../common/k8s-api/api-manager/manager.injectable";
import roleBindingApiInjectable from "../../../../common/k8s-api/endpoints/role-binding.api.injectable";
import createStoresAndApisInjectable from "../../../create-stores-apis.injectable";
import storesAndApisCanBeCreatedInjectable from "../../../stores-apis-can-be-created.injectable";
import { RoleBindingStore } from "./store";
const roleBindingStoreInjectable = getInjectable({
id: "role-binding-store",
instantiate: (di) => {
assert(di.inject(createStoresAndApisInjectable), "roleBindingStore is only available in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectable), "roleBindingStore is only available in certain environments");
const api = di.inject(roleBindingApiInjectable);

4
src/renderer/components/+user-management/+roles/store.injectable.ts
View File

@ -5,14 +5,14 @@
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import roleApiInjectable from "../../../../common/k8s-api/endpoints/role.api.injectable";
import createStoresAndApisInjectable from "../../../create-stores-apis.injectable";
import storesAndApisCanBeCreatedInjectable from "../../../stores-apis-can-be-created.injectable";
import { kubeObjectStoreInjectionToken } from "../../../../common/k8s-api/api-manager/manager.injectable";
import { RoleStore } from "./store";
const roleStoreInjectable = getInjectable({
id: "role-store",
instantiate: (di) => {
assert(di.inject(createStoresAndApisInjectable), "roleStore is only available in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectable), "roleStore is only available in certain environments");
const api = di.inject(roleApiInjectable);

4
src/renderer/components/+user-management/+service-accounts/store.injectable.ts
View File

@ -5,14 +5,14 @@
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import serviceAccountApiInjectable from "../../../../common/k8s-api/endpoints/service-account.api.injectable";
import createStoresAndApisInjectable from "../../../create-stores-apis.injectable";
import storesAndApisCanBeCreatedInjectable from "../../../stores-apis-can-be-created.injectable";
import { kubeObjectStoreInjectionToken } from "../../../../common/k8s-api/api-manager/manager.injectable";
import { ServiceAccountStore } from "./store";
const serviceAccountStoreInjectable = getInjectable({
id: "service-account-store",
instantiate: (di) => {
assert(di.inject(createStoresAndApisInjectable), "serviceAccountStore is only available in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectable), "serviceAccountStore is only available in certain environments");
const api = di.inject(serviceAccountApiInjectable);

4
src/renderer/components/+workloads-cronjobs/store.injectable.ts
View File

@ -7,13 +7,13 @@ import assert from "assert";
import getJobsByOwnerInjectable from "../+workloads-jobs/get-jobs-by-owner.injectable";
import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/manager.injectable";
import cronJobApiInjectable from "../../../common/k8s-api/endpoints/cron-job.api.injectable";
import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
import { CronJobStore } from "./store";
const cronJobStoreInjectable = getInjectable({
id: "cron-job-store",
instantiate: (di) => {
assert(di.inject(createStoresAndApisInjectable), "cronJobStore is only available in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectable), "cronJobStore is only available in certain environments");
const api = di.inject(cronJobApiInjectable);

4
src/renderer/components/+workloads-daemonsets/store.injectable.ts
View File

@ -6,14 +6,14 @@ import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import getPodsByOwnerIdInjectable from "../+workloads-pods/get-pods-by-owner-id.injectable";
import daemonSetApiInjectable from "../../../common/k8s-api/endpoints/daemon-set.api.injectable";
import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/manager.injectable";
import { DaemonSetStore } from "./store";
const daemonSetStoreInjectable = getInjectable({
id: "daemon-set-store",
instantiate: (di) => {
assert(di.inject(createStoresAndApisInjectable), "daemonSetStore is only available in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectable), "daemonSetStore is only available in certain environments");
const api = di.inject(daemonSetApiInjectable);

4
src/renderer/components/+workloads-deployments/scale/dialog.test.tsx
View File

@ -14,7 +14,7 @@ import { getDiForUnitTesting } from "../../../getDiForUnitTesting";
import deploymentApiInjectable from "../../../../common/k8s-api/endpoints/deployment.api.injectable";
import type { OpenDeploymentScaleDialog } from "./open.injectable";
import openDeploymentScaleDialogInjectable from "./open.injectable";
import createStoresAndApisInjectable from "../../../create-stores-apis.injectable";
import storesAndApisCanBeCreatedInjectable from "../../../stores-apis-can-be-created.injectable";
import type { DiRender } from "../../test-utils/renderFor";
import { renderFor } from "../../test-utils/renderFor";
@ -90,7 +90,7 @@ describe("<DeploymentScaleDialog />", () => {
beforeEach(() => {
const di = getDiForUnitTesting({ doGeneralOverrides: true });
di.override(createStoresAndApisInjectable, () => true);
di.override(storesAndApisCanBeCreatedInjectable, () => true);
deploymentApi = di.inject(deploymentApiInjectable);
openDeploymentScaleDialog = di.inject(openDeploymentScaleDialogInjectable);

4
src/renderer/components/+workloads-deployments/store.injectable.ts
View File

@ -6,14 +6,14 @@ import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import podStoreInjectable from "../+workloads-pods/store.injectable";
import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/manager.injectable";
import { createStoresAndApisInjectionToken } from "../../../common/k8s-api/create-stores-apis.token";
import { storesAndApisCanBeCreatedInjectionToken } from "../../../common/k8s-api/stores-apis-can-be-created.token";
import deploymentApiInjectable from "../../../common/k8s-api/endpoints/deployment.api.injectable";
import { DeploymentStore } from "./store";
const deploymentStoreInjectable = getInjectable({
id: "deployment-store",
instantiate: (di) => {
assert(di.inject(createStoresAndApisInjectionToken), "deploymentStore is only available in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "deploymentStore is only available in certain environments");
const api = di.inject(deploymentApiInjectable);

4
src/renderer/components/+workloads-jobs/store.injectable.ts
View File

@ -7,13 +7,13 @@ import assert from "assert";
import getPodsByOwnerIdInjectable from "../+workloads-pods/get-pods-by-owner-id.injectable";
import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/manager.injectable";
import jobApiInjectable from "../../../common/k8s-api/endpoints/job.api.injectable";
import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
import { JobStore } from "./store";
const jobStoreInjectable = getInjectable({
id: "job-store",
instantiate: (di) => {
assert(di.inject(createStoresAndApisInjectable), "jobStore is only available in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectable), "jobStore is only available in certain environments");
const api = di.inject(jobApiInjectable);

4
src/renderer/components/+workloads-pods/store.injectable.ts
View File

@ -5,7 +5,7 @@
import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import podApiInjectable from "../../../common/k8s-api/endpoints/pod.api.injectable";
import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/manager.injectable";
import { PodStore } from "./store";
import podMetricsApiInjectable from "../../../common/k8s-api/endpoints/pod-metrics.api.injectable";
@ -13,7 +13,7 @@ import podMetricsApiInjectable from "../../../common/k8s-api/endpoints/pod-metri
const podStoreInjectable = getInjectable({
id: "pod-store",
instantiate: (di) => {
assert(di.inject(createStoresAndApisInjectable), "podStore is only available in certain environements");
assert(di.inject(storesAndApisCanBeCreatedInjectable), "podStore is only available in certain environements");
const api = di.inject(podApiInjectable);

4
src/renderer/components/+workloads-replicasets/scale-dialog/dialog.test.tsx
View File

@ -12,7 +12,7 @@ import type { ReplicaSetApi } from "../../../../common/k8s-api/endpoints/replica
import { ReplicaSet } from "../../../../common/k8s-api/endpoints/replica-set.api";
import type { OpenReplicaSetScaleDialog } from "./open.injectable";
import replicaSetApiInjectable from "../../../../common/k8s-api/endpoints/replica-set.api.injectable";
import createStoresAndApisInjectable from "../../../create-stores-apis.injectable";
import storesAndApisCanBeCreatedInjectable from "../../../stores-apis-can-be-created.injectable";
import { getDiForUnitTesting } from "../../../getDiForUnitTesting";
import { type DiRender, renderFor } from "../../test-utils/renderFor";
import openReplicaSetScaleDialogInjectable from "./open.injectable";
@ -83,7 +83,7 @@ describe("<ReplicaSetScaleDialog />", () => {
beforeEach(() => {
const di = getDiForUnitTesting({ doGeneralOverrides: true });
di.override(createStoresAndApisInjectable, () => true);
di.override(storesAndApisCanBeCreatedInjectable, () => true);
render = renderFor(di);
replicaSetApi = di.inject(replicaSetApiInjectable);

4
src/renderer/components/+workloads-replicasets/store.injectable.ts
View File

@ -6,14 +6,14 @@ import { getInjectable } from "@ogre-tools/injectable";
import assert from "assert";
import getPodsByOwnerIdInjectable from "../+workloads-pods/get-pods-by-owner-id.injectable";
import replicaSetApiInjectable from "../../../common/k8s-api/endpoints/replica-set.api.injectable";
import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/manager.injectable";
import { ReplicaSetStore } from "./store";
const replicaSetStoreInjectable = getInjectable({
id: "replica-set-store",
instantiate: (di) => {
assert(di.inject(createStoresAndApisInjectable), "replicaSetStore is only available in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectable), "replicaSetStore is only available in certain environments");
const api = di.inject(replicaSetApiInjectable);

4
src/renderer/components/+workloads-statefulsets/scale/dialog.test.tsx
View File

@ -13,7 +13,7 @@ import React from "react";
import type { OpenStatefulSetScaleDialog } from "./open-dialog.injectable";
import { getDiForUnitTesting } from "../../../getDiForUnitTesting";
import statefulSetApiInjectable from "../../../../common/k8s-api/endpoints/stateful-set.api.injectable";
import createStoresAndApisInjectable from "../../../create-stores-apis.injectable";
import storesAndApisCanBeCreatedInjectable from "../../../stores-apis-can-be-created.injectable";
import openStatefulSetScaleDialogInjectable from "./open-dialog.injectable";
import { type DiRender, renderFor } from "../../test-utils/renderFor";
@ -94,7 +94,7 @@ describe("<StatefulSetScaleDialog />", () => {
beforeEach(() => {
const di = getDiForUnitTesting({ doGeneralOverrides: true });
di.override(createStoresAndApisInjectable, () => true);
di.override(storesAndApisCanBeCreatedInjectable, () => true);
render = renderFor(di);
statefulSetApi = di.inject(statefulSetApiInjectable);

4
src/renderer/components/+workloads-statefulsets/store.injectable.ts
View File

@ -7,13 +7,13 @@ import assert from "assert";
import getPodsByOwnerIdInjectable from "../+workloads-pods/get-pods-by-owner-id.injectable";
import { kubeObjectStoreInjectionToken } from "../../../common/k8s-api/api-manager/manager.injectable";
import statefulSetApiInjectable from "../../../common/k8s-api/endpoints/stateful-set.api.injectable";
import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
import { StatefulSetStore } from "./store";
const statefulSetStoreInjectable = getInjectable({
id: "stateful-set-store",
instantiate: (di) => {
assert(di.inject(createStoresAndApisInjectable), "statefulSetStore is only available in certain environment");
assert(di.inject(storesAndApisCanBeCreatedInjectable), "statefulSetStore is only available in certain environment");
const api = di.inject(statefulSetApiInjectable);

4
src/renderer/components/__tests__/cronjob.store.test.ts
View File

@ -5,7 +5,7 @@
import type { CronJobStore } from "../+workloads-cronjobs/store";
import cronJobStoreInjectable from "../+workloads-cronjobs/store.injectable";
import { CronJob } from "../../../common/k8s-api/endpoints";
import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
import { getDiForUnitTesting } from "../../getDiForUnitTesting";
const scheduledCronJob = new CronJob({
@ -119,7 +119,7 @@ describe("CronJob Store tests", () => {
beforeEach(() => {
const di = getDiForUnitTesting({ doGeneralOverrides: true });
di.override(createStoresAndApisInjectable, () => true);
di.override(storesAndApisCanBeCreatedInjectable, () => true);
cronJobStore = di.inject(cronJobStoreInjectable);
});

4
src/renderer/components/__tests__/daemonset.store.test.ts
View File

@ -8,7 +8,7 @@ import type { DaemonSetStore } from "../+workloads-daemonsets/store";
import daemonSetStoreInjectable from "../+workloads-daemonsets/store.injectable";
import podStoreInjectable from "../+workloads-pods/store.injectable";
import { DaemonSet, Pod } from "../../../common/k8s-api/endpoints";
import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
import { getDiForUnitTesting } from "../../getDiForUnitTesting";
const runningDaemonSet = new DaemonSet({
@ -136,7 +136,7 @@ describe("DaemonSet Store tests", () => {
beforeEach(() => {
const di = getDiForUnitTesting({ doGeneralOverrides: true });
di.override(createStoresAndApisInjectable, () => true);
di.override(storesAndApisCanBeCreatedInjectable, () => true);
const podStore = di.inject(podStoreInjectable);

4
src/renderer/components/__tests__/deployments.store.test.ts
View File

@ -9,7 +9,7 @@ import deploymentStoreInjectable from "../+workloads-deployments/store.injectabl
import podStoreInjectable from "../+workloads-pods/store.injectable";
import type { PodSpec } from "../../../common/k8s-api/endpoints";
import { Deployment, Pod } from "../../../common/k8s-api/endpoints";
import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
import { getDiForUnitTesting } from "../../getDiForUnitTesting";
const spec: PodSpec = {
@ -208,7 +208,7 @@ describe("Deployment Store tests", () => {
beforeEach(() => {
const di = getDiForUnitTesting({ doGeneralOverrides: true });
di.override(createStoresAndApisInjectable, () => true);
di.override(storesAndApisCanBeCreatedInjectable, () => true);
const podStore = di.inject(podStoreInjectable);

4
src/renderer/components/__tests__/job.store.test.ts
View File

@ -8,7 +8,7 @@ import type { JobStore } from "../+workloads-jobs/store";
import jobStoreInjectable from "../+workloads-jobs/store.injectable";
import podStoreInjectable from "../+workloads-pods/store.injectable";
import { Job, Pod } from "../../../common/k8s-api/endpoints";
import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
import { getDiForUnitTesting } from "../../getDiForUnitTesting";
const runningJob = new Job({
@ -173,7 +173,7 @@ describe("Job Store tests", () => {
beforeEach(() => {
const di = getDiForUnitTesting({ doGeneralOverrides: true });
di.override(createStoresAndApisInjectable, () => true);
di.override(storesAndApisCanBeCreatedInjectable, () => true);
jobStore = di.inject(jobStoreInjectable);

4
src/renderer/components/__tests__/pods.store.test.ts
View File

@ -6,7 +6,7 @@
import { Pod } from "../../../common/k8s-api/endpoints";
import type { PodStore } from "../+workloads-pods/store";
import podStoreInjectable from "../+workloads-pods/store.injectable";
import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
import { getDiForUnitTesting } from "../../getDiForUnitTesting";
const runningPod = new Pod({
@ -119,7 +119,7 @@ describe("Pod Store tests", () => {
beforeEach(() => {
const di = getDiForUnitTesting({ doGeneralOverrides: true });
di.override(createStoresAndApisInjectable, () => true);
di.override(storesAndApisCanBeCreatedInjectable, () => true);
podStore = di.inject(podStoreInjectable);
});

4
src/renderer/components/__tests__/replicaset.store.test.ts
View File

@ -8,7 +8,7 @@ import podStoreInjectable from "../+workloads-pods/store.injectable";
import replicasetsStoreInjectable from "../+workloads-replicasets/store.injectable";
import type { ReplicaSetStore } from "../+workloads-replicasets/store";
import { ReplicaSet, Pod } from "../../../common/k8s-api/endpoints";
import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
import { getDiForUnitTesting } from "../../getDiForUnitTesting";
const runningReplicaSet = new ReplicaSet({
@ -136,7 +136,7 @@ describe("ReplicaSet Store tests", () => {
beforeEach(() => {
const di = getDiForUnitTesting({ doGeneralOverrides: true });
di.override(createStoresAndApisInjectable, () => true);
di.override(storesAndApisCanBeCreatedInjectable, () => true);
const podStore = di.inject(podStoreInjectable);

4
src/renderer/components/__tests__/statefulset.store.test.ts
View File

@ -8,7 +8,7 @@ import podStoreInjectable from "../+workloads-pods/store.injectable";
import type { StatefulSetStore } from "../+workloads-statefulsets/store";
import statefulSetStoreInjectable from "../+workloads-statefulsets/store.injectable";
import { StatefulSet, Pod } from "../../../common/k8s-api/endpoints";
import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
import { getDiForUnitTesting } from "../../getDiForUnitTesting";
const runningStatefulSet = new StatefulSet({
@ -136,7 +136,7 @@ describe("StatefulSet Store tests", () => {
beforeEach(() => {
const di = getDiForUnitTesting({ doGeneralOverrides: true });
di.override(createStoresAndApisInjectable, () => true);
di.override(storesAndApisCanBeCreatedInjectable, () => true);
statefulSetStore = di.inject(statefulSetStoreInjectable);

4
src/renderer/components/delete-cluster-dialog/__tests__/delete-cluster-dialog.test.tsx
View File

@ -18,7 +18,7 @@ import type { DiRender } from "../../test-utils/renderFor";
import { renderFor } from "../../test-utils/renderFor";
import type { OpenDeleteClusterDialog } from "../open.injectable";
import openDeleteClusterDialogInjectable from "../open.injectable";
import createStoresAndApisInjectable from "../../../create-stores-apis.injectable";
import storesAndApisCanBeCreatedInjectable from "../../../stores-apis-can-be-created.injectable";
import createKubeconfigManagerInjectable from "../../../../main/kubeconfig-manager/create-kubeconfig-manager.injectable";
import ipcRendererInjectable from "../../../app-paths/get-value-from-registered-channel/ipc-renderer/ipc-renderer.injectable";
@ -104,7 +104,7 @@ describe("<DeleteClusterDialog />", () => {
mainDi.override(createKubeconfigManagerInjectable, () => () => undefined);
mockFs();
rendererDi.override(createStoresAndApisInjectable, () => true);
rendererDi.override(storesAndApisCanBeCreatedInjectable, () => true);
rendererDi.override(ipcRendererInjectable, () => ({
on: jest.fn(),
invoke: jest.fn(), // TODO: replace with proper mocking via the IPC bridge

4
src/renderer/components/hotbar/__tests__/hotbar-remove-command.test.tsx
View File

@ -18,7 +18,7 @@ import directoryForUserDataInjectable from "../../../../common/app-paths/directo
import getConfigurationFileModelInjectable from "../../../../common/get-configuration-file-model/get-configuration-file-model.injectable";
import appVersionInjectable from "../../../../common/get-configuration-file-model/app-version/app-version.injectable";
import type { HotbarStore } from "../../../../common/hotbars/store";
import createStoresAndApisInjectable from "../../../create-stores-apis.injectable";
import storesAndApisCanBeCreatedInjectable from "../../../stores-apis-can-be-created.injectable";
import ipcRendererInjectable from "../../../app-paths/get-value-from-registered-channel/ipc-renderer/ipc-renderer.injectable";
const mockHotbars: Partial<Record<string, any>> = {
@ -45,7 +45,7 @@ describe("<HotbarRemoveCommand />", () => {
mockFs();
di.override(createStoresAndApisInjectable, () => true);
di.override(storesAndApisCanBeCreatedInjectable, () => true);
di.override(directoryForUserDataInjectable, () => "some-directory-for-user-data");
di.override(ipcRendererInjectable, () => ({
on: jest.fn(),

4
src/renderer/components/test-utils/get-application-builder.tsx
View File

@ -33,7 +33,7 @@ import navigateToPreferencesInjectable from "../../../common/front-end-routing/r
import type { MenuItemOpts } from "../../../main/menu/application-menu-items.injectable";
import applicationMenuItemsInjectable from "../../../main/menu/application-menu-items.injectable";
import type { MenuItem, MenuItemConstructorOptions } from "electron";
import createStoresAndApisInjectable from "../../create-stores-apis.injectable";
import storesAndApisCanBeCreatedInjectable from "../../stores-apis-can-be-created.injectable";
type Callback = (dis: DiContainers) => void | Promise<void>;
@ -81,7 +81,7 @@ export const getApplicationBuilder = () => {
} as unknown as ClusterStore;
rendererDi.override(clusterStoreInjectable, () => clusterStoreStub);
rendererDi.override(createStoresAndApisInjectable, () => true);
rendererDi.override(storesAndApisCanBeCreatedInjectable, () => true);
mainDi.override(clusterStoreInjectable, () => clusterStoreStub);
const beforeSetupsCallbacks: Callback[] = [];

4
src/renderer/k8s/api-kube.injectable.ts
View File

@ -7,13 +7,13 @@ import assert from "assert";
import { onApiError } from "../api/on-api-error";
import { apiKubePrefix, isDevelopment } from "../../common/vars";
import { apiKubeInjectionToken } from "../../common/k8s-api/api-kube";
import { createStoresAndApisInjectionToken } from "../../common/k8s-api/create-stores-apis.token";
import { storesAndApisCanBeCreatedInjectionToken } from "../../common/k8s-api/stores-apis-can-be-created.token";
import { KubeJsonApi } from "../../common/k8s-api/kube-json-api";
const apiKubeInjectable = getInjectable({
id: "api-kube",
instantiate: (di) => {
assert(di.inject(createStoresAndApisInjectionToken), "apiKube is only available in certain environments");
assert(di.inject(storesAndApisCanBeCreatedInjectionToken), "apiKube is only available in certain environments");
const apiKube = new KubeJsonApi({
serverAddress: `http://127.0.0.1:${window.location.port}`,

8
src/renderer/create-stores-apis.injectable.ts → src/renderer/stores-apis-can-be-created.injectable.ts
View File

@ -3,13 +3,13 @@
* Licensed under MIT License. See LICENSE in root directory for more information.
*/
import { getInjectable } from "@ogre-tools/injectable";
import { createStoresAndApisInjectionToken } from "../common/k8s-api/create-stores-apis.token";
import { storesAndApisCanBeCreatedInjectionToken } from "../common/k8s-api/stores-apis-can-be-created.token";
import { getClusterIdFromHost } from "./utils";
const createStoresAndApisInjectable = getInjectable({
const storesAndApisCanBeCreatedInjectable = getInjectable({
id: "create-stores-and-apis",
instantiate: () => Boolean(getClusterIdFromHost(location.host)),
injectionToken: createStoresAndApisInjectionToken,
injectionToken: storesAndApisCanBeCreatedInjectionToken,
});
export default createStoresAndApisInjectable;
export default storesAndApisCanBeCreatedInjectable;