@raketa-cloud/admin 0.0.102 → 0.0.103

package/src/tests/handlers/RedirectsHandler.test/create.test.js

@@ -0,0 +1,83 @@
+import RedirectsHandler from "../../../handlers/RedirectsHandler";
+import Redirects from "../../../cloud/Redirects";
+
+import Factory from "../../support/factory";
+
+function buildCtx(redirect) {
+  return {
+    client: {
+      redirects: new Redirects(() => ({}), "token"),
+    },
+    resourceParams: {
+      redirect: {
+        url: redirect.url,
+        destination: redirect.destination,
+        httpResponseCode: redirect.httpResponseCode.toString(),
+        note: redirect.note,
+      },
+    },
+    locale: "en",
+  };
+}
+
+describe("Redirects", () => {
+  test("create successful", async () => {
+    const redirect = Factory.build("redirect");
+    const ctx = buildCtx(redirect);
+
+    const mockCreate = jest
+      .spyOn(ctx.client.redirects, "create")
+      .mockImplementation(() => ({ redirect: redirect, errors: null }));
+
+    const result = await RedirectsHandler.create(ctx);
+
+    expect(mockCreate).toHaveBeenCalledWith({
+      url: redirect.url,
+      destination: redirect.destination,
+      httpResponseCode: redirect.httpResponseCode,
+      note: redirect.note,
+    });
+
+    expect(result).toEqual({
+      redirect: "/en/redirects",
+    });
+  });
+
+  test("create failed", async () => {
+    const redirect = Factory.build("redirect");
+    const ctx = buildCtx(redirect);
+
+    const mockCreate = jest
+      .spyOn(ctx.client.redirects, "create")
+      .mockImplementation(() => ({
+        redirect: null,
+        errors: [{ key: "url", message: "already used" }],
+      }));
+
+    const result = await RedirectsHandler.create(ctx);
+
+    expect(mockCreate).toHaveBeenCalledWith({
+      url: redirect.url,
+      destination: redirect.destination,
+      httpResponseCode: redirect.httpResponseCode,
+      note: redirect.note,
+    });
+
+    expect(result).toEqual({
+      assigns: {
+        redirect: {
+          url: redirect.url,
+          destination: redirect.destination,
+          httpResponseCode: redirect.httpResponseCode.toString(),
+          note: redirect.note,
+        },
+        errors: {
+          redirect: {
+            url: "already used",
+          },
+        },
+        _translations: [],
+      },
+    });
+  });
+});

package/src/tests/handlers/RedirectsHandler.test/create_form.test.js

@@ -0,0 +1,27 @@
+import RedirectsHandler from "../../../handlers/RedirectsHandler";
+import Redirects from "../../../cloud/Redirects";
+
+function buildCtx() {
+  return {
+    client: {
+      redirects: new Redirects(() => ({}), "token"),
+    },
+    params: { id: 1 },
+  };
+}
+
+describe("Redirects", () => {
+  test("create_form", async () => {
+    const ctx = buildCtx();
+
+    const result = RedirectsHandler.create_form(ctx);
+
+    expect(result).toEqual({
+      assigns: {
+        redirect: {},
+        errors: {},
+        _translations: [],
+      },
+    });
+  });
+});

package/src/tests/handlers/RedirectsHandler.test/destroy.test.js

@@ -0,0 +1,53 @@
+import RedirectsHandler from "../../../handlers/RedirectsHandler";
+import Redirects from "../../../cloud/Redirects";
+
+import Factory from "../../support/factory";
+
+function buildCtx() {
+  return {
+    client: {
+      redirects: new Redirects(() => ({}), "token"),
+    },
+    params: { id: 1 },
+    locale: "en",
+  };
+}
+
+describe("Redirects", () => {
+  test("destroy successful", async () => {
+    const redirect = Factory.build("redirect");
+    const ctx = buildCtx();
+
+    const mockDelete = jest
+      .spyOn(ctx.client.redirects, "delete")
+      .mockImplementation(() => ({ redirect: redirect, errors: null }));
+
+    const result = await RedirectsHandler.destroy(ctx);
+
+    expect(mockDelete).toHaveBeenCalledWith(1);
+
+    expect(result).toEqual({
+      headers: {
+        "HX-Redirect": "/en/redirects",
+      },
+      json: {},
+    });
+  });
+
+  test("destroy failed", async () => {
+    const ctx = buildCtx();
+
+    const mockDelete = jest
+      .spyOn(ctx.client.redirects, "delete")
+      .mockImplementation(() => ({
+        redirect: null,
+        errors: [{ key: "generalError", message: "Not found" }],
+      }));
+
+    await expect(() => RedirectsHandler.destroy(ctx)).rejects.toMatch(
+      "Failed to delete redirect #1."
+    );
+
+    expect(mockDelete).toHaveBeenCalledWith(1);
+  });
+});

package/src/tests/handlers/RedirectsHandler.test/edit_form.test.js

@@ -0,0 +1,37 @@
+import RedirectsHandler from "../../../handlers/RedirectsHandler";
+import Redirects from "../../../cloud/Redirects";
+
+import Factory from "../../support/factory";
+
+function buildCtx() {
+  return {
+    client: {
+      redirects: new Redirects(() => ({}), "token"),
+    },
+    params: { id: 1 },
+  };
+}
+
+describe("Redirects", () => {
+  test("edit_form", async () => {
+    const redirect = Factory.build("redirect");
+    const ctx = buildCtx();
+
+    const mockShow = jest
+      .spyOn(ctx.client.redirects, "find")
+      .mockImplementation(() => redirect);
+
+    const result = await RedirectsHandler.edit_form(ctx);
+
+    expect(mockShow).toHaveBeenCalledWith(1);
+
+    expect(result).toEqual({
+      assigns: {
+        id: 1,
+        redirect: redirect,
+        errors: {},
+        _translations: [],
+      },
+    });
+  });
+});

package/src/tests/handlers/RedirectsHandler.test/index.test.js

@@ -0,0 +1,41 @@
+import RedirectsHandler from "../../../handlers/RedirectsHandler";
+import Redirects from "../../../cloud/Redirects";
+
+import Factory from "../../support/factory";
+
+describe("Redirects", () => {
+  function buildCtx() {
+    return {
+      client: {
+        redirects: new Redirects(() => ({}), "token"),
+      },
+      query: { foo: "bar" },
+      req: {
+        path: "/redirects",
+      },
+    };
+  }
+
+  test("index", async () => {
+    const redirect = Factory.build("redirect");
+    const pagination = Factory.build("pagination");
+    const ctx = buildCtx();
+
+    const mockedList = jest
+      .spyOn(ctx.client.redirects, "list")
+      .mockImplementation(() => ({ list: [redirect], pagination }));
+
+    const result = await RedirectsHandler.index(ctx);
+
+    expect(mockedList).toHaveBeenCalledWith({ foo: "bar" });
+
+    expect(result).toEqual({
+      assigns: {
+        items: {
+          list: [redirect],
+          pagination: pagination,
+        },
+      },
+    });
+  });
+});

package/src/tests/handlers/RedirectsHandler.test/show.test.js

@@ -0,0 +1,41 @@
+import RedirectsHandler from "../../../handlers/RedirectsHandler";
+import Redirects from "../../../cloud/Redirects";
+
+import Factory from "../../support/factory";
+
+function buildCtx() {
+  return {
+    client: {
+      redirects: new Redirects(() => ({}), "token"),
+    },
+    params: { id: 1 },
+  };
+}
+
+describe("Redirects", () => {
+  test("show", async () => {
+    const redirect = Factory.build("redirect");
+
+    const ctx = buildCtx();
+
+    const mockShow = jest
+      .spyOn(ctx.client.redirects, "find")
+      .mockImplementation(() => redirect);
+
+    const mockHistory = jest
+      .spyOn(ctx.client.redirects, "history")
+      .mockImplementation(() => []);
+
+    const result = await RedirectsHandler.show(ctx);
+
+    expect(mockShow).toHaveBeenCalledWith(1);
+    expect(mockHistory).toHaveBeenCalledWith(1);
+
+    expect(result).toEqual({
+      assigns: {
+        item: redirect,
+        history: [],
+      },
+    });
+  });
+});

package/src/tests/handlers/RedirectsHandler.test/update.test.js

@@ -0,0 +1,88 @@
+import RedirectsHandler from "../../../handlers/RedirectsHandler";
+import Redirects from "../../../cloud/Redirects";
+
+import Factory from "../../support/factory";
+
+function buildCtx(redirect) {
+  return {
+    client: {
+      redirects: new Redirects(() => ({}), "token"),
+    },
+    params: { id: redirect.id },
+    resourceParams: {
+      redirect: {
+        url: "/updated",
+        destination: redirect.destination,
+        httpResponseCode: redirect.httpResponseCode.toString(),
+        note: redirect.note,
+      },
+    },
+    locale: "en",
+  };
+}
+
+describe("Redirects", () => {
+  test("update successful", async () => {
+    const redirect = Factory.build("redirect");
+    const ctx = buildCtx(redirect);
+
+    const mockUpdate = jest
+      .spyOn(ctx.client.redirects, "update")
+      .mockImplementation(() => ({
+        redirect: { ...redirect, url: "/updated" },
+        errors: null,
+      }));
+
+    const result = await RedirectsHandler.update(ctx);
+
+    expect(mockUpdate).toHaveBeenCalledWith(redirect.id, {
+      url: "/updated",
+      destination: redirect.destination,
+      httpResponseCode: redirect.httpResponseCode,
+      note: redirect.note,
+    });
+
+    expect(result).toEqual({
+      redirect: "/en/redirects",
+    });
+  });
+
+  test("update failed", async () => {
+    const redirect = Factory.build("redirect");
+    const ctx = buildCtx(redirect);
+
+    const mockUpdate = jest
+      .spyOn(ctx.client.redirects, "update")
+      .mockImplementation(() => ({
+        redirect: null,
+        errors: [{ key: "url", message: "already used" }],
+      }));
+
+    const result = await RedirectsHandler.update(ctx);
+
+    expect(mockUpdate).toHaveBeenCalledWith(redirect.id, {
+      url: "/updated",
+      destination: redirect.destination,
+      httpResponseCode: redirect.httpResponseCode,
+      note: redirect.note,
+    });
+
+    expect(result).toEqual({
+      assigns: {
+        redirect: {
+          id: redirect.id,
+          url: "/updated",
+          destination: redirect.destination,
+          httpResponseCode: redirect.httpResponseCode.toString(),
+          note: redirect.note,
+        },
+        errors: {
+          redirect: {
+            url: "already used",
+          },
+        },
+        _translations: [],
+      },
+    });
+  });
+});

package/src/tests/handlers/TagsHandler.test/create.test.js

@@ -0,0 +1,96 @@
+import Tags from "../../../cloud/Tags";
+import TagsHandler from "../../../handlers/TagsHandler";
+import Factory from "../../support/factory";
+
+describe("Tags Handler", () => {
+  function buildCtx(tag) {
+    return {
+      client: {
+        tags: new Tags(() => ({}), "token"),
+      },
+      resourceParams: {
+        tag: {
+          name: tag.name,
+          slug: tag.slug,
+        },
+      },
+      locale: "en",
+    };
+  }
+
+  test("create successful", async () => {
+    const tag = Factory.build("tag", {
+      name: "Test Tag",
+      slug: "test-tag",
+    });
+    const ctx = buildCtx(tag);
+
+    const mockedCreate = jest
+      .spyOn(ctx.client.tags, "create")
+      .mockImplementation(() => ({ tag, errors: null }));
+
+    const result = await TagsHandler.create(ctx);
+
+    expect(mockedCreate).toHaveBeenCalledWith(
+      {
+        name: tag.name,
+        slug: tag.slug,
+      },
+      "en"
+    );
+
+    expect(result).toEqual({
+      redirect: "/en/tags",
+    });
+  });
+
+  test("create failed", async () => {
+    const tag = Factory.build("tag", {
+      name: "Test Tag",
+      slug: "test-tag",
+    });
+    const ctx = buildCtx(tag);
+
+    const errors = [{ key: "name", message: "already taken" }];
+
+    const mockedCreate = jest
+      .spyOn(ctx.client.tags, "create")
+      .mockImplementation(() => ({
+        tag: null,
+        errors,
+      }));
+
+    const mockedFormatErrors = jest
+      .spyOn(ctx.client.tags, "formatErrors")
+      .mockImplementation(() => ({
+        name: "already taken",
+      }));
+
+    const result = await TagsHandler.create(ctx);
+
+    expect(mockedCreate).toHaveBeenCalledWith(
+      {
+        name: tag.name,
+        slug: tag.slug,
+      },
+      "en"
+    );
+
+    expect(mockedFormatErrors).toHaveBeenCalledWith(errors);
+
+    expect(result).toEqual({
+      assigns: {
+        tag: {
+          name: tag.name,
+          slug: tag.slug,
+        },
+        errors: {
+          tag: {
+            name: "already taken",
+          },
+        },
+        _translations: [],
+      },
+    });
+  });
+});

package/src/tests/handlers/TagsHandler.test/create_form.test.js

@@ -0,0 +1,25 @@
+import Tags from "../../../cloud/Tags";
+import TagsHandler from "../../../handlers/TagsHandler";
+
+describe("Tags Handler", () => {
+  function buildCtx() {
+    return {
+      client: {
+        tags: new Tags(() => ({}), "token"),
+      },
+    };
+  }
+
+  test("create_form", () => {
+    const ctx = buildCtx();
+    const result = TagsHandler.create_form(ctx);
+
+    expect(result).toEqual({
+      assigns: {
+        tag: {},
+        errors: {},
+        _translations: [],
+      },
+    });
+  });
+});

package/src/tests/handlers/TagsHandler.test/destroy.test.js

@@ -0,0 +1,51 @@
+import Tags from "../../../cloud/Tags";
+import TagsHandler from "../../../handlers/TagsHandler";
+import Factory from "../../support/factory";
+
+describe("Tags Handler", () => {
+  function buildCtx() {
+    return {
+      client: {
+        tags: new Tags(() => ({}), "token"),
+      },
+      params: { id: "1" },
+      locale: "en",
+    };
+  }
+
+  test("destroy successful", async () => {
+    const tag = Factory.build("tag");
+    const ctx = buildCtx();
+
+    const mockedDelete = jest
+      .spyOn(ctx.client.tags, "delete")
+      .mockImplementation(() => ({ tag, errors: null }));
+
+    const result = await TagsHandler.destroy(ctx);
+
+    expect(mockedDelete).toHaveBeenCalledWith("1", "en");
+    expect(result).toEqual({
+      headers: {
+        "HX-redirect": "/en/tags",
+      },
+      json: {},
+    });
+  });
+
+  test("destroy failed", async () => {
+    const ctx = buildCtx();
+
+    const mockedDelete = jest
+      .spyOn(ctx.client.tags, "delete")
+      .mockImplementation(() => ({
+        tag: null,
+        errors: [{ key: "generalError", message: "Not found" }],
+      }));
+
+    expect(() => TagsHandler.destroy(ctx)).rejects.toMatch(
+      "Failed to delete tag #1."
+    );
+
+    expect(mockedDelete).toHaveBeenCalledWith("1", "en");
+  });
+});

package/src/tests/handlers/TagsHandler.test/edit_form.test.js

@@ -0,0 +1,60 @@
+import Tags from "../../../cloud/Tags";
+import TagsHandler from "../../../handlers/TagsHandler";
+import Factory from "../../support/factory";
+
+describe("Tags Handler", () => {
+  function buildCtx() {
+    return {
+      client: {
+        tags: new Tags(() => ({}), "token"),
+      },
+      router: {
+        req: {
+          param: () => ({ id: "1" }),
+        },
+      },
+      locale: "en",
+    };
+  }
+
+  test("edit_form", async () => {
+    const tag = Factory.build("tag", { id: "1", name: "Test Tag" });
+    const ctx = buildCtx();
+
+    const mockedFind = jest
+      .spyOn(ctx.client.tags, "find")
+      .mockImplementation(() => tag);
+
+    const result = await TagsHandler.edit_form(ctx);
+
+    expect(mockedFind).toHaveBeenCalledWith("1", "en");
+    expect(result).toEqual({
+      assigns: {
+        id: "1",
+        tag: tag,
+        errors: {},
+        _translations: [],
+      },
+    });
+  });
+
+  test("edit_form when tag does not exist", async () => {
+    const ctx = buildCtx();
+
+    const mockedFind = jest
+      .spyOn(ctx.client.tags, "find")
+      .mockImplementation(() => null);
+
+    const result = await TagsHandler.edit_form(ctx);
+
+    expect(mockedFind).toHaveBeenCalledWith("1", "en");
+    expect(result).toEqual({
+      assigns: {
+        id: "1",
+        tag: null,
+        errors: {},
+        _translations: [],
+      },
+    });
+  });
+});

package/src/tests/handlers/TagsHandler.test/index.test.js

@@ -0,0 +1,37 @@
+import Tags from "../../../cloud/Tags";
+import TagsHandler from "../../../handlers/TagsHandler";
+import Factory from "../../support/factory";
+
+describe("Tags Handler", () => {
+  function buildCtx() {
+    return {
+      client: {
+        tags: new Tags(() => ({}), "token"),
+      },
+      query: { foo: "bar" },
+      locale: "en",
+    };
+  }
+
+  test("index", async () => {
+    const tags = [
+      Factory.build("tag", { id: "1", name: "First Tag" }),
+      Factory.build("tag", { id: "2", name: "Second Tag" }),
+    ];
+
+    const ctx = buildCtx();
+
+    const mockedList = jest
+      .spyOn(ctx.client.tags, "list")
+      .mockImplementation(() => tags);
+
+    const result = await TagsHandler.index(ctx);
+
+    expect(mockedList).toHaveBeenCalledWith({ foo: "bar" }, "en");
+    expect(result).toEqual({
+      assigns: {
+        items: tags,
+      },
+    });
+  });
+});