UniqueSoft/openpanel
2
0
Fork 0
mirror of https://github.com/stefanpejcic/openpanel synced 2025-06-26 18:28:26 +00:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity

cleaner

Browse Source
This commit is contained in:
Stefan Pejcic
2024-05-08 19:52:27 +02:00
parent 9c8d080b57
commit 80303fadd5
2509 changed files with 0 additions and 594172 deletions
Download Patch File Download Diff File Expand all files Collapse all files

334
packages/core/src/hooks/useTelemetryData/index.spec.ts
View File

@@ -1,334 +0,0 @@
import { renderHook } from "@testing-library/react";
import { MockJSONServer, TestWrapper, mockLegacyRouterProvider } from "@test";
import { defaultRefineOptions } from "@contexts/refine";
import { useTelemetryData } from ".";
import { IRefineContextProvider } from "src/interfaces";
describe("useTelemetryData Hook", () => {
describe("authProvider", () => {
it("must be false", async () => {
const { result } = renderHook(() => useTelemetryData(), {
wrapper: TestWrapper({
dataProvider: MockJSONServer,
resources: [{ name: "posts" }],
}),
});
const { providers } = result.current;
expect(providers.auth).toBeFalsy();
});
it("legacyAuthProvider must be true", async () => {
const { result } = renderHook(() => useTelemetryData(), {
wrapper: TestWrapper({
dataProvider: MockJSONServer,
resources: [{ name: "posts" }],
legacyAuthProvider: {
login: () => Promise.resolve(),
logout: () => Promise.resolve(),
checkError: () => Promise.resolve(),
checkAuth: () => Promise.resolve(),
getPermissions: () => Promise.resolve(),
getUserIdentity: () => Promise.resolve(),
},
}),
});
const { providers } = result.current;
expect(providers.auth).toBeTruthy();
});
it("authProvider must be true", async () => {
const { result } = renderHook(() => useTelemetryData(), {
wrapper: TestWrapper({
dataProvider: MockJSONServer,
resources: [{ name: "posts" }],
authProvider: {
login: () => Promise.resolve({ success: true }),
logout: () => Promise.resolve({ success: false }),
check: () => Promise.resolve({ authenticated: true }),
onError: () => Promise.resolve({}),
},
}),
});
const { providers } = result.current;
expect(providers.auth).toBeTruthy();
});
});
describe("auditLogProvider", () => {
it("must be false", async () => {
const { result } = renderHook(() => useTelemetryData(), {
wrapper: TestWrapper({
dataProvider: MockJSONServer,
resources: [{ name: "posts" }],
}),
});
const { providers } = result.current;
expect(providers.auditLog).toBeFalsy();
});
it("must be true", async () => {
const { result } = renderHook(() => useTelemetryData(), {
wrapper: TestWrapper({
dataProvider: MockJSONServer,
resources: [{ name: "posts" }],
auditLogProvider: {
create: () => Promise.resolve(),
get: () => Promise.resolve(),
update: () => Promise.resolve(),
},
}),
});
const { providers } = result.current;
expect(providers.auditLog).toBeTruthy();
});
});
describe("liveProvider", () => {
it("must be false", async () => {
const { result } = renderHook(() => useTelemetryData(), {
wrapper: TestWrapper({
dataProvider: MockJSONServer,
resources: [{ name: "posts" }],
}),
});
const { providers } = result.current;
expect(providers.live).toBeFalsy();
});
it("must be true", async () => {
const { result } = renderHook(() => useTelemetryData(), {
wrapper: TestWrapper({
dataProvider: MockJSONServer,
resources: [{ name: "posts" }],
liveProvider: {
subscribe: () => {
return;
},
unsubscribe: () => {
return;
},
},
}),
});
const { providers } = result.current;
expect(providers.live).toBeTruthy();
});
it("must be true", async () => {
const { result } = renderHook(() => useTelemetryData(), {
wrapper: TestWrapper({
dataProvider: MockJSONServer,
resources: [{ name: "posts" }],
liveProvider: {
subscribe: undefined as any,
unsubscribe: () => {
return;
},
},
}),
});
const { providers } = result.current;
expect(providers.live).toBeTruthy();
});
});
describe("i18nProvider", () => {
it("must be false", async () => {
const { result } = renderHook(() => useTelemetryData(), {
wrapper: TestWrapper({
resources: [{ name: "posts" }],
}),
});
const { providers } = result.current;
expect(providers.i18n).toBeFalsy();
});
it("must be true", async () => {
const { result } = renderHook(() => useTelemetryData(), {
wrapper: TestWrapper({
dataProvider: MockJSONServer,
resources: [{ name: "posts" }],
i18nProvider: {
translate: () => {
return "";
},
changeLocale: () => {
return Promise.resolve();
},
getLocale: () => {
return "";
},
},
}),
});
const { providers } = result.current;
expect(providers.i18n).toBeTruthy();
});
it("must be true", async () => {
const { result } = renderHook(() => useTelemetryData(), {
wrapper: TestWrapper({
dataProvider: MockJSONServer,
resources: [{ name: "posts" }],
i18nProvider: {
changeLocale: undefined as any,
translate: () => {
return "";
},
getLocale: () => {
return "";
},
},
}),
});
const { providers } = result.current;
expect(providers.i18n).toBeTruthy();
});
it("must be true", async () => {
const { result } = renderHook(() => useTelemetryData(), {
wrapper: TestWrapper({
dataProvider: MockJSONServer,
resources: [{ name: "posts" }],
i18nProvider: {
translate: () => {
return "";
},
changeLocale: undefined as any,
getLocale: undefined as any,
},
}),
});
const { providers } = result.current;
expect(providers.i18n).toBeTruthy();
});
});
describe("notificationProvider", () => {
it("must be false", async () => {
const { result } = renderHook(() => useTelemetryData(), {
wrapper: TestWrapper({
resources: [{ name: "posts" }],
}),
});
const { providers } = result.current;
expect(providers.notification).toBeFalsy();
});
it("must be true", async () => {
const { result } = renderHook(() => useTelemetryData(), {
wrapper: TestWrapper({
dataProvider: MockJSONServer,
resources: [{ name: "posts" }],
notificationProvider: {
close: () => Promise.resolve(),
open: () => Promise.resolve(),
},
}),
});
const { providers } = result.current;
expect(providers.notification).toBeTruthy();
});
});
describe("accessControlProvider", () => {
it("must be false", async () => {
const { result } = renderHook(() => useTelemetryData(), {
wrapper: TestWrapper({
resources: [{ name: "posts" }],
}),
});
const { providers } = result.current;
expect(providers.accessControl).toBeFalsy();
});
it("must be true", async () => {
const { result } = renderHook(() => useTelemetryData(), {
wrapper: TestWrapper({
dataProvider: MockJSONServer,
resources: [{ name: "posts" }],
accessControlProvider: {
can: async () => {
return Promise.resolve({ can: true });
},
},
}),
});
const { providers } = result.current;
expect(providers.accessControl).toBeTruthy();
});
});
describe("legacy routeProvider", () => {
it("must be true", async () => {
const { result } = renderHook(() => useTelemetryData(), {
wrapper: TestWrapper({
dataProvider: MockJSONServer,
resources: [{ name: "posts" }],
legacyRouterProvider: {
...mockLegacyRouterProvider(),
useHistory: undefined as any,
},
}),
});
const { providers } = result.current;
expect(providers.router).toBeTruthy();
});
});
describe("projectId", () => {
const mockRefineProvider: IRefineContextProvider = {
hasDashboard: false,
...defaultRefineOptions,
options: defaultRefineOptions,
};
it("must be undefined", async () => {
const { result } = renderHook(() => useTelemetryData(), {
wrapper: TestWrapper({
resources: [{ name: "posts" }],
}),
});
const { projectId } = result.current;
expect(projectId).toBeUndefined();
});
it("must be defined", async () => {
const { result } = renderHook(() => useTelemetryData(), {
wrapper: TestWrapper({
resources: [{ name: "posts" }],
refineProvider: {
...mockRefineProvider,
options: {
...mockRefineProvider.options,
projectId: "test",
},
},
}),
});
const { projectId } = result.current;
expect(projectId).toBe("test");
});
});
});

76
packages/core/src/hooks/useTelemetryData/index.ts
View File

@@ -1,76 +0,0 @@
import { useContext } from "react";
import { AuditLogContext } from "@contexts/auditLog";
import { LiveContext } from "@contexts/live";
import { RouterContext } from "@contexts/legacy-router";
import { DataContext } from "@contexts/data";
import { TranslationContext } from "@contexts/translation";
import { NotificationContext } from "@contexts/notification";
import { AccessControlContext } from "@contexts/accessControl";
import { useResource } from "@hooks/resource";
import { ITelemetryData } from "../../interfaces/telemetry";
import { useIsExistAuthentication, useRefineContext } from "..";
// It reads and updates from package.json during build. ref: tsup.config.ts
const REFINE_VERSION = "1.0.0";
export const useTelemetryData = (): ITelemetryData => {
const auth = useIsExistAuthentication();
const auditLogContext = useContext(AuditLogContext);
const liveContext = useContext(LiveContext);
const routerContext = useContext(RouterContext);
const dataContext = useContext(DataContext);
const { i18nProvider } = useContext(TranslationContext);
const notificationContext = useContext(NotificationContext);
const accessControlContext = useContext(AccessControlContext);
const { resources } = useResource();
const refineOptions = useRefineContext();
const auditLog =
!!auditLogContext.create ||
!!auditLogContext.get ||
!!auditLogContext.update;
const live =
!!liveContext?.publish ||
!!liveContext?.subscribe ||
!!liveContext?.unsubscribe;
const router =
!!routerContext.useHistory ||
!!routerContext.Link ||
!!routerContext.Prompt ||
!!routerContext.useLocation ||
!!routerContext.useParams;
const data = !!dataContext;
const i18n =
!!i18nProvider?.changeLocale ||
!!i18nProvider?.getLocale ||
!!i18nProvider?.translate;
const notification =
!!notificationContext.close || !!notificationContext.open;
const accessControl = !!accessControlContext.can;
const projectId = refineOptions?.options?.projectId;
return {
providers: {
auth,
auditLog,
live,
router,
data,
i18n,
notification,
accessControl,
},
version: REFINE_VERSION,
resourceCount: resources.length,
projectId,
};
};