/
query-builder-delete.ts
137 lines (110 loc) · 4.53 KB
/
query-builder-delete.ts
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
import "reflect-metadata";
import {expect} from "chai";
import {closeTestingConnections, createTestingConnections, reloadTestingDatabases} from "../../../utils/test-utils";
import {Connection} from "../../../../src/connection/Connection";
import {User} from "./entity/User";
import {Photo} from "./entity/Photo";
import {EntityColumnNotFound} from "../../../../src/error/EntityColumnNotFound";
describe("query builder > delete", () => {
let connections: Connection[];
before(async () => connections = await createTestingConnections({
entities: [__dirname + "/entity/*{.js,.ts}"],
}));
beforeEach(() => reloadTestingDatabases(connections));
after(() => closeTestingConnections(connections));
it("should perform deletion correctly", () => Promise.all(connections.map(async connection => {
const user1 = new User();
user1.name = "Alex Messer";
await connection.manager.save(user1);
await connection.createQueryBuilder()
.delete()
.from(User)
.where("name = :name", { name: "Alex Messer" })
.execute();
const loadedUser1 = await connection.getRepository(User).findOne({ name: "Dima Zotov" });
expect(loadedUser1).to.not.exist;
const user2 = new User();
user2.name = "Alex Messer";
await connection.manager.save(user2);
await connection.getRepository(User)
.createQueryBuilder("myUser")
.delete()
.where("name = :name", { name: "Dima Zotov" })
.execute();
const loadedUser2 = await connection.getRepository(User).findOne({ name: "Dima Zotov" });
expect(loadedUser2).to.not.exist;
})));
it("should be able to delete entities by embed criteria", () => Promise.all(connections.map(async connection => {
// save few photos
await connection.manager.save(Photo, { url: "1.jpg" });
await connection.manager.save(Photo, {
url: "2.jpg",
counters: {
likes: 2,
favorites: 1,
comments: 1,
}
});
await connection.manager.save(Photo, { url: "3.jpg" });
// make sure photo with likes = 2 exist
const loadedPhoto1 = await connection.getRepository(Photo).findOne({ counters: { likes: 2 } });
expect(loadedPhoto1).to.exist;
loadedPhoto1!.should.be.eql({
id: 2,
url: "2.jpg",
counters: {
likes: 2,
favorites: 1,
comments: 1,
}
});
// delete photo now
await connection.getRepository(Photo)
.createQueryBuilder("photo")
.delete()
.where({
counters: {
likes: 2
}
})
.execute();
const loadedPhoto2 = await connection.getRepository(Photo).findOne({ url: "1.jpg" });
expect(loadedPhoto2).to.exist;
const loadedPhoto3 = await connection.getRepository(Photo).findOne({ url: "2.jpg" });
expect(loadedPhoto3).not.to.exist;
const loadedPhoto4 = await connection.getRepository(Photo).findOne({ url: "3.jpg" });
expect(loadedPhoto4).to.exist;
})));
it("should return correct delete result", () => Promise.all(connections.map(async connection => {
// don't run test for sqlite and sqljs as they don't return affected rows
if (connection.name === "sqlite" || connection.name === "sqljs" || connection.name === "sap")
return;
// save some users
const user1 = new User();
user1.name = "John Doe";
const user2 = new User();
user2.name = "Jane Doe";
await connection.manager.save([user1, user2]);
const result = await connection.createQueryBuilder()
.delete()
.from(User)
.execute();
expect(result.affected).to.equal(2);
})));
it("should throw error when unknown property in where criteria", () => Promise.all(connections.map(async connection => {
const user = new User();
user.name = "Alex Messer";
await connection.manager.save(user);
let error: Error | undefined;
try {
await connection.createQueryBuilder()
.delete()
.from(User)
.where( { unknownProp: "Alex Messer" })
.execute();
} catch (err) {
error = err;
}
expect(error).to.be.an.instanceof(EntityColumnNotFound);
})));
});