Ինչպես փորձարկել Mongoose մոդելները Mongo հիշողության սերվերի միջոցով

Սկսեք արագ և հեշտությամբ փորձարկել՝ պտտելով MongoDB օրինակը հիշողության մեջ: Այս փաթեթը ձեզ հնարավորություն է տալիս կարճ ժամանակում կարգավորել:

Mongoose մոդելների փորձարկումը կարող է դժվար լինել, քանի որ դուք պետք է գրեք թեստեր, որոնք չեն խանգարում ձեր իրական տվյալների բազային: MongoDB հիշողության սերվերի փաթեթն առաջարկում է պարզ լուծում: Այն թույլ է տալիս պահպանել ձեր թեստի տվյալները հավելվածի հիշողության մեջ:

Այս ձեռնարկում դուք կստեղծեք պարզ Mongoose մոդել և կգրեք թեստեր՝ օգտագործելով Jest-ը և MongoDB հիշողության սերվերը:

Ի՞նչ է MongoDB հիշողության սերվերը:

Վերջին բանը, որ դուք ցանկանում եք, կեղծ տվյալներ պահպանելն է ձեր իրական տվյալների բազայում, ինչը կարող է տեղի ունենալ, եթե փորձարկման ընթացքում միանաք դրանց: Փոխարենը, դուք կարող եք ընտրել օգտագործել առանձին տեղական MongoDB օրինակ՝ ձեր տվյալները պահելու համար: Թեև սա աշխատում է, անհնար է, եթե ձեր թեստերն աշխատեն ամպի վրա: Ավելին, յուրաքանչյուր թեստի ընթացքում իրական տվյալների բազայի միացումը և հարցումը կարող է թանկանալ:

MongoDB հիշողության սերվերը, այնուամենայնիվ, պտտվում է իսկական MongoDB սերվերը և թույլ է տալիս պահպանել թեստային տվյալները հիշողության մեջ: Սա ավելի արագ է դարձնում, քան տեղական MongoDB տվյալների բազայի օգտագործումը, քանի որ տվյալները գրված չեն ֆիզիկական սկավառակի վրա:

Մոնգուստի մոդելի ստեղծում

Mongoose մոդելները ապահովում են ինտերֆեյս MongoDB տվյալների բազայի հետ ինտերֆեյսի համար: Դրանք ստեղծելու համար դուք պետք է դրանք կազմեք Mongoose սխեմայից, որը սահմանում է ձեր MongoDB տվյալների մոդելը: Այս ձեռնարկը կօգտագործի սխեմա անելիքների փաստաթղթի համար: Այն կպարունակի վերնագիր և լրացված դաշտեր:

Գործարկեք հետևյալ հրամանը տերմինալում՝ նոր թղթապանակ ստեղծելու և այնտեղ նավարկելու համար:

mkdir mongoose-model-test
cd mongoose-model-test

Նախաձեռնեք npm-ը հետևյալ հրամանով.

npm init -y

-y դրոշը հրահանգում է npm-ին ստեղծել լռելյայն արժեքներով package.json ֆայլ:

Կատարեք այս հրամանը՝ mongoose փաթեթը տեղադրելու համար.

npm install mongoose

Ստեղծեք նոր ֆայլ, որը կոչվում է todo.model.js և սահմանեք todo սխեման.

const mongoose = require("mongoose")
const { Schema } = mongoose
const TodoSchema = new Schema({
    item: {
        type: String,
        required: true
    },
    compeleted: {
        type: Boolean,
        required: true
    }
})

Այս ֆայլի վերջում ստեղծեք և արտահանեք todo մոդելը.

module.exports = mongoose.model("Todo", TodoSchema)

Թեստերի պլանավորում

Թեստեր գրելիս նախապես ցանկանում եք պլանավորել, թե ինչ եք փորձարկելու: Սա ապահովում է, որ դուք փորձարկում եք ձեր մոդելի բոլոր ֆունկցիոնալությունը:

Մեր ստեղծած Mongoose մոդելից todo-ն պետք է պարունակի String տիպի տարր և Բուլյան տիպի լրացված դաշտ: Այս երկու դաշտերն էլ պարտադիր են: Սա նշանակում է, որ առնվազն մեր թեստը պետք է ապահովի.

• Վավեր տարրերը հաջողությամբ պահպանվել են տվյալների բազայում:
• Առանց պարտադիր դաշտերի տարրերը չեն պահպանվում:
• Անվավեր տիպի դաշտերով տարրերը չեն պահվում:

Մենք կգրենք այս թեստերը մեկ թեստային բլոկում, քանի որ դրանք կապված են: Jest-ում դուք սահմանում եք այս թեստային բլոկը՝ օգտագործելով նկարագրել ֆունկցիան: Օրինակ:

describe('Todo Model Test', () => {
    // Your tests go here
}

Տվյալների բազայի կարգավորում

MongoDB հիշողության սերվեր ստեղծելու համար դուք կստեղծեք նոր Mongo հիշողության սերվերի օրինակ և միացեք Mongoose-ին: Դուք նաև կստեղծեք գործառույթներ, որոնք պատասխանատու կլինեն տվյալների բազայում բոլոր հավաքածուները հանելու և Mongo հիշողության սերվերի օրինակից անջատելու համար:

Գործարկեք հետևյալ հրամանը՝ mongodb-memory-server տեղադրելու համար:

npm install mongodb-memory-server

Ստեղծեք նոր ֆայլ, որը կոչվում է setuptestdb.js և ներմուծեք mongoose և mongodb-memory-server:

const mongoose = require("mongoose");
const { MongoMemoryServer } = require("mongodb-memory-server");

Հաջորդը, ստեղծեք connectDB() ֆունկցիա: Այս գործառույթը ստեղծում է նոր Mongo հիշողության սերվերի օրինակ և միանում է Mongoose-ին: Դուք այն կգործարկեք բոլոր թեստերից առաջ՝ թեստային տվյալների բազային միանալու համար:

let mongo = null;
 
const connectDB = async () => {
  mongo = await MongoMemoryServer.create();
  const uri = mongo.getUri();
 
  await mongoose.connect(uri, {
    useNewUrlParser: true,
    useUnifiedTopology: true,
  });
};

Ստեղծեք dropDB() ֆունկցիա՝ ավելացնելով հետևյալ կոդը. Այս գործառույթը թողնում է տվյալների բազան, փակում է Mongoose կապը և դադարեցնում Mongo հիշողության սերվերի օրինակը: Դուք կգործարկեք այս գործառույթը բոլոր թեստերն ավարտելուց հետո:

const dropDB = async () => {
  if (mongo) {
    await mongoose.connection.dropDatabase();
    await mongoose.connection.close();
    await mongo.stop();
  }
};

Վերջին գործառույթը, որը դուք կստեղծեք, կոչվում է dropCollections(): Այն թողնում է բոլոր ստեղծված Mongoose հավաքածուները: Դուք այն կգործարկեք յուրաքանչյուր թեստից հետո:

const dropCollections = async () => {
  if (mongo) {
    const collections = await mongoose.connection.db.collections();
    for (let collection of collections) {
      await collection.remove();
    }
  }
};

Վերջապես արտահանեք conenctDB(), dropDB() և dropCollections() ֆունկցիաները։

module.exports = { connectDB, dropDB, dropCollections}

Թեստեր գրելը

Ինչպես նշվեց, դուք կօգտագործեք Jest-ը թեստերը գրելու համար: Գործարկեք հետևյալ հրամանը՝ կատակները տեղադրելու համար։

npm install jest

package.json ֆայլում կարգավորեք կատակը: Փոխարինեք ձեր գոյություն ունեցող «սկրիպտների» բլոկը հետևյալով.

"scripts": {
    "test": "jest --runInBand --detectOpenHandles"
},
"jest": {
    "testEnvironment": "node"
},

Ստեղծեք նոր ֆայլ, որը կոչվում է todo.model.test.js և ներմուծեք mongoose գրադարանը, todo մոդելը և conenctDB(), dropDB() և dropCollections() ֆունկցիաները.

const mongoose = require("mongoose");
const { connectDB, dropDB, dropCollections } = require("./setupdb");
const Todo = require("./todo.model");

Բոլոր թեստերը սկսելուց առաջ պետք է գործարկել connectDB() ֆունկցիան: Jest-ի միջոցով կարող եք օգտագործել BeforeAll() մեթոդը:

Դուք նաև պետք է գործարկեք մաքրման գործառույթները: Յուրաքանչյուր թեստից հետո գործարկեք dropCollections() ֆունկցիան, իսկ dropDB() ֆունկցիան բոլոր թեստերից հետո։ Ձեզ հարկավոր չէ դա անել ձեռքով և կարող եք օգտագործել afterEach() և afterAll() մեթոդները Jest-ից:

Տվյալների բազան կարգավորելու և մաքրելու համար ավելացրեք հետևյալ կոդը todo.model.test.js ֆայլին:

beforeAll(async () => {
  await connectDB();
});
 
afterAll(async () => {
  await dropDB();
});
 
afterEach(async () => {
  await dropCollections();
});

Այժմ դուք պատրաստ եք ստեղծել թեստեր:

Առաջին թեստը կստուգի, թե արդյոք todo տարրը հաջողությամբ տեղադրվել է տվյալների բազայում: Այն կստուգի, թե արդյոք օբյեկտի Id-ն առկա է ստեղծած փաստաթղթում և արդյոք այնտեղ գտնվող տվյալները համընկնում են տվյալների բազայում ուղարկված տվյալների հետ:

Ստեղծեք նկարագրության բլոկ և ավելացրեք հետևյալ կոդը.

describe("Todo Model", () => {
  it("should create a todo item successfully", async () => {
    let validTodo = {
      item: "Do the dishes",
      completed: false,
    };
    const newTodo = await Todo(validTodo);
    await newTodo.save();
    expect(newTodo._id).toBeDefined();
    expect(newTodo.item).toBe(validTodo.item);
    expect(newTodo.completed).toBe(validTodo.completed);
  });
});

Սա ստեղծում է նոր փաստաթուղթ տվյալների բազայում, որը պարունակում է տվյալներ validTodo փոփոխականում: Այնուհետև վերադարձված օբյեկտը վավերացվում է ակնկալվող արժեքների համեմատ: Որպեսզի այս թեստն անցնի, վերադարձված արժեքը պետք է ունենա օբյեկտի ID: Բացի այդ, տարրի և լրացված դաշտերի արժեքները պետք է համապատասխանեն validTodo օբյեկտի արժեքներին:

Բացի սովորական օգտագործման դեպքի փորձարկումից, դուք նաև պետք է փորձարկեք անհաջող օգտագործման դեպքը: Մեր նախատեսած թեստերից դուք պետք է փորձարկեք մանգուստի մոդելը todo օբյեկտով, բացակայող պարտադիր դաշտով և սխալ տիպով:

Նույն նկարագրության բլոկին ավելացրեք երկրորդ թեստը հետևյալ կերպ.

  it("should fail for todo item without required fields", async () => {
    let invalidTodo = {
      item: "Do the dishes",
    };
    try {
      const newTodo = new Todo(invalidTodo);
      await newTodo.save();
    } catch (error) {
      expect(error).toBeInstanceOf(mongoose.Error.ValidationError);
      expect(error.errors.completed).toBeDefined();
    }
  });

Todo mongoose մոդելն ակնկալում է և՛ իրը, և՛ ավարտված դաշտերը: Այն պետք է սխալ առաջացնի, եթե փորձեք պահպանել աշխատանքը առանց այս դաշտերից որևէ մեկի: Այս թեստը օգտագործում է try…catch բլոկը՝ նետված սխալը բռնելու համար: Թեստն ակնկալում է, որ սխալները լինելու են մանգուստ վավերացման սխալ և բխում են բացակայող լրացված դաշտից:

Ստուգելու համար, թե արդյոք մոդելը սխալ է թույլ տալիս, եթե դուք օգտագործում եք սխալ տեսակի արժեքներ, ավելացրեք հետևյալ կոդը նկարագրության բլոկին:

  it("should fail for todo item with fields of wrong type", async () => {
    let invalidTodo = {
      item: "Do the dishes",
      completed: "False"
    };
    try {
      const newTodo = new Todo(invalidTodo);
      await newTodo.save();
    } catch (error) {
      expect(error).toBeInstanceOf(mongoose.Error.ValidationError);
      expect(error.errors.completed).toBeDefined();
    }
  });

Նկատի ունեցեք, որ լրացված դաշտի արժեքը բուլյանի փոխարեն տող է: Թեստն ակնկալում է, որ վավերացման սխալ կհայտնվի, քանի որ մոդելն ակնկալում է բուլյան արժեք:

MongoMemoryServer-ը և Jest-ը հիանալի թիմ են կազմում

Mongo-memory-server npm փաթեթը հեշտ լուծում է տալիս Mongoose մոդելների փորձարկման համար: Դուք կարող եք կեղծ տվյալները պահել հիշողության մեջ՝ չդիպչելով ձեր հավելվածի տվյալների բազային:

Դուք կարող եք օգտագործել MongoMemoryServer-ը Jest-ի հետ՝ Mongoose մոդելների համար թեստեր գրելու համար: Նկատի ունեցեք, որ այն չի ներառում բոլոր հնարավոր թեստերը, որոնք կարող եք գրել ձեր մոդելների համար: Այդ թեստերը կախված կլինեն ձեր սխեմայից: