localmongo/test.js at main · ncryptsion/localmongo · GitHub

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
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
"use strict"

// Dependencies
const { LocalMongo } = require("./index.js")
const path = require("path")
const fs = require("fs")

// Core
describe("LocalMongo", () => {
    let mongo
    const testDbPath = path.join(__dirname, "test-db")

    beforeEach(() => {
        if (fs.existsSync(testDbPath)) {
            fs.rmSync(testDbPath, { recursive: true, force: true })
        }
        mongo = new LocalMongo(testDbPath)
    })

    afterAll(() => {
        if (fs.existsSync(testDbPath)) {
            fs.rmSync(testDbPath, { recursive: true, force: true })
        }
    })

    test("Should create database folder", () => {
        mongo.db("testdb")
        const dbPath = path.join(testDbPath, "testdb")
        expect(fs.existsSync(dbPath)).toBe(true)
    })

    describe("Collection", () => {
        let db, collection

        beforeEach(() => {
            db = mongo.db("testdb")
            collection = db.collection("users")
        })

        test("Should insert one document", () => {
            const result = collection.insertOne({ name: "John", age: 30 })
            expect(result.acknowledged).toBe(true)
            expect(result.doc.name).toBe("John")
            expect(result.doc._id).toBeDefined()
        })

        test("Should insert many documents", () => {
            const docs = [
                { name: "Alice", age: 25 },
                { name: "Bob", age: 35 }
            ]
            const result = collection.insertMany(docs)
            expect(result.acknowledged).toBe(true)
            expect(result.insertedCount).toBe(2)
            expect(result.insertedIds.length).toBe(2)
        })

        test("Should find one document", () => {
            collection.insertOne({ name: "John", age: 30 })
            const doc = collection.findOne({ name: "John" })
            expect(doc).toBeDefined()
            expect(doc.name).toBe("John")
            expect(doc.age).toBe(30)
        })

        test("Should find many documents", () => {
            collection.insertMany([
                { name: "Alice", age: 25 },
                { name: "Bob", age: 35 },
                { name: "Charlie", age: 25 }
            ])
            const docs = collection.findMany({ age: 25 })
            expect(docs.length).toBe(2)
        })

        test("Should update one document", () => {
            collection.insertOne({ name: "John", age: 30 })
            const result = collection.updateOne({ name: "John" }, { age: 31 })
            expect(result.modifiedCount).toBe(1)

            const updated = collection.findOne({ name: "John" })
            expect(updated.age).toBe(31)
        })

        test("Should update many documents", () => {
            collection.insertMany([
                { name: "Alice", age: 25 },
                { name: "Charlie", age: 25 }
            ])
            const result = collection.updateMany({ age: 25 }, { status: "active" })
            expect(result.modifiedCount).toBe(2)

            const docs = collection.findMany({ status: "active" })
            expect(docs.length).toBe(2)
        })

        test("Should delete one document", () => {
            collection.insertOne({ name: "John", age: 30 })
            const result = collection.deleteOne({ name: "John" })
            expect(result.deletedCount).toBe(1)

            const doc = collection.findOne({ name: "John" })
            expect(doc).toBeNull()
        })

        test("Should delete many documents", () => {
            collection.insertMany([
                { name: "Alice", age: 25 },
                { name: "Charlie", age: 25 }
            ])
            const result = collection.deleteMany({ age: 25 })
            expect(result.deletedCount).toBe(2)

            const docs = collection.findMany({ age: 25 })
            expect(docs.length).toBe(0)
        })

        test("Should handle $push operator", () => {
            collection.insertOne({ name: "Alice", tags: ["tech"] })
            collection.updateOne({ name: "Alice" }, { $push: { tags: "coding" } })

            const doc = collection.findOne({ name: "Alice" })
            expect(doc.tags).toContain("coding")
            expect(doc.tags.length).toBe(2)
        })

        test("Should handle $push with $each operator", () => {
            collection.insertOne({ name: "Alice", tags: ["tech"] })
            collection.updateOne({ name: "Alice" }, { $push: { tags: { $each: ["coding", "fun"] } } })

            const doc = collection.findOne({ name: "Alice" })
            expect(doc.tags.length).toBe(3)
            expect(doc.tags).toContain("coding")
            expect(doc.tags).toContain("fun")
        })

        test("Should handle $pull operator", () => {
            collection.insertOne({ name: "Alice", tags: ["tech", "coding", "fun"] })
            collection.updateOne({ name: "Alice" }, { $pull: { tags: "fun" } })

            const doc = collection.findOne({ name: "Alice" })
            expect(doc.tags).not.toContain("fun")
            expect(doc.tags.length).toBe(2)
        })

        test("Should handle $pull with query operator", () => {
            collection.insertOne({ name: "Alice", tasks: [{id: 1, name: "task 1"}, {id: 2, name: "task 2"}] })
            collection.updateOne({ name: "Alice" }, { $pull: { tasks: { id: 1 } } })

            const doc = collection.findOne({ name: "Alice" })
            expect(doc.tasks.length).toBe(1)
            expect(doc.tasks[0].id).toBe(2)
        })
    })
})