Debian Codegraph @

__tests__/internal/move-after-handle-request/route-handlers/function-handler/serialize-test.js

raw
1 import { Server, Model, Collection, ActiveModelSerializer } from "miragejs";
2 import uniqBy from "lodash.uniqby";
3
4 describe("Integration | Route handlers | Function handler | #serialize", () => {
5 let server;
6
7 beforeEach(() => {
8 server = new Server({
9 environment: "development",
10 models: {
11 user: Model.extend({}),
12 },
13 serializers: {
14 application: ActiveModelSerializer,
15 sparseUser: ActiveModelSerializer.extend({
16 attrs: ["id", "name", "tall"],
17 }),
18 },
19 });
20 server.timing = 0;
21 server.logging = false;
22 });
23
24 afterEach(() => {
25 server.shutdown();
26 });
27
28 test("it uses the default serializer on a model", async () => {
29 expect.assertions(1);
30
31 server.create("user", { name: "Sam" });
32
33 server.get("/users", function (schema) {
34 let user = schema.users.first();
35 let json = this.serialize(user);
36
37 expect(json).toEqual({
38 user: {
39 id: "1",
40 name: "Sam",
41 },
42 });
43
44 return true;
45 });
46
47 await fetch("/users");
48 });
49
50 test("it uses the default serializer on a collection", async () => {
51 expect.assertions(1);
52
53 server.create("user", { name: "Sam" });
54
55 server.get("/users", function (schema) {
56 let users = schema.users.all();
57 let json = this.serialize(users);
58
59 expect(json).toEqual({
60 users: [{ id: "1", name: "Sam" }],
61 });
62
63 return true;
64 });
65
66 await fetch("/users");
67 });
68
69 test("it takes an optional serializer type", async () => {
70 expect.assertions(1);
71
72 server.create("user", { name: "Sam", tall: true, evil: false });
73 server.create("user", { name: "Ganondorf", tall: true, evil: true });
74
75 server.get("/users", function (schema) {
76 let users = schema.users.all();
77 let json = this.serialize(users, "sparse-user");
78
79 expect(json).toEqual({
80 users: [
81 { id: "1", name: "Sam", tall: true },
82 { id: "2", name: "Ganondorf", tall: true },
83 ],
84 });
85
86 return true;
87 });
88
89 await fetch("/users");
90 });
91
92 test("it throws an error when trying to specify a serializer that doesnt exist", async () => {
93 expect.assertions(2);
94
95 server.create("user", { name: "Sam" });
96 server.get("/users", function (schema) {
97 let users = schema.users.all();
98
99 this.serialize(users, "foo-user");
100 });
101
102 let res = await fetch("/users");
103 let data = await res.json();
104
105 expect(res.status).toBe(500);
106 expect(data.message).toMatch(`that serializer doesn't exist`);
107 });
108
109 test("it noops on plain JS arrays", async () => {
110 expect.assertions(1);
111
112 server.create("user", { name: "Sam" });
113 server.create("user", { name: "Ganondorf" });
114
115 server.get("/users", function (schema) {
116 let names = schema.users.all().models.map((user) => user.name);
117 let json = this.serialize(names);
118
119 expect(json).toEqual(names);
120 });
121
122 await fetch("/users");
123 });
124
125 test("it can take an optional serializer type on a Collection", async () => {
126 expect.assertions(1);
127
128 server.create("user", { name: "Sam", tall: true, evil: false });
129 server.create("user", { name: "Sam", tall: true, evil: false });
130 server.create("user", { name: "Ganondorf", tall: true, evil: true });
131
132 server.get("/users", function (schema) {
133 let users = schema.users.all().models;
134 let uniqueNames = uniqBy(users, "name");
135 let collection = new Collection("user", uniqueNames);
136 let json = this.serialize(collection, "sparse-user");
137
138 expect(json).toEqual({
139 users: [
140 { id: "1", name: "Sam", tall: true },
141 { id: "3", name: "Ganondorf", tall: true },
142 ],
143 });
144 });
145
146 await fetch("/users");
147 });
148 });