Mongoose: TimpaModelError dengan moka 'jam tangan'

Ini disebabkan oleh kesalahan pemrograman. Memanggil mongoose.model() atau connection.model() dengan nama dan skema yang sama beberapa kali tidak akan menghasilkan kesalahan. Melewati nama model yang ada dengan skema yang berbeda menghasilkan kesalahan. Menimpa model tidak pernah benar-benar diizinkan.

Jika jam tangan mocha membutuhkan kembali skema Anda dan memanggil mongoose.model(preExistingName, newSchema) maka ya, Anda akan mendapatkan kesalahan sekarang. Sebelumnya dalam skenario ini, luwak tidak mengkompilasi model baru sama sekali, itu hanya akan menelan kesalahan pemrograman dan mengembalikan model lama, yang merupakan perilaku yang salah.

var schema = new Schema;
var A = mongoose.model('A', schema);
var B = mongoose.model('A', schema); // no error
var C = mongoose.model('A', new Schema); // previously unreported error

Oke, itu masuk akal. Terima kasih!

@aheckmann -- saya juga melakukan ini, dan tidak yakin apa yang saya lakukan salah. di bawah ini adalah bagaimana saya mengaturnya. uji coba bersih pertama tidak apa-apa, jika saya mengedit + menyimpan file, moka memicu jalankan ulang dengan --watch dan saya mendapatkan

OverwriteModelError: Cannot overwrite "User" model once compiled.

pengguna.js

var mongoose = require('mongoose'),
  Schema = mongoose.Schema,
  ObjectId = mongoose.SchemaTypes.ObjectId;

var userSchema = new Schema({
  name: { type: String }
}), 
  User;

// other virtual / static methods added to schema

User = mongoose.model('User', userSchema);
module.exports = User;

spesifikasi pengguna.js

var User = require('../models/user'),
  mongoose = require('mongoose');

mongoose.connection.on('error', function (err) {
  console.log(err);
}

mongoose.connection.on('open', function () {
  console.log('connected');
}

describe('User', function () {

  before(function (done) {
    mongoose.connect('mongodb://localhost/test');
    done();
  }

  after(function (done) {
    mongoose.disconnect(function () {
      console.log('disconnected');
      done();
    });
  });

  it('should test something', function (done) {
     // tests
     done();
  });
});

untuk tes luwak kami hanya membuat koneksi baru setiap kali dan itu berfungsi dengan baik.

var db = mongoose.createConnection()

https://github.com/LearnBoost/mongoose/blob/master/test/common.js#L74 -L98

Tindak lanjut yang diposting ke grup google https://groups.google.com/d/topic/mongoose-orm/PXTjqqpaDFk/discussion

Saya melihat ini juga. Berikut adalah contoh minimal:

https://github.com/j0ni/mongoose-strangeness

Mungkin saya kehilangan cara yang tepat untuk mendefinisikan model ...?

https://github.com/j0ni/mongoose-strangeness/blob/master/test.spec.js#L21

seharusnya var Example = connection.model('Example', ExampleSchema)

Terima kasih @aheckmann yang bekerja dengan baik.

itu berfungsi b/ca koneksi baru dibuat untuk setiap pengujian Anda dan model di-cache secara lokal di dalam koneksi untuk masing-masing. cara lain gagal b/c model dikompilasi pada tingkat modul luwak untuk setiap tes, karenanya konflik.

@aheckmann - Saya mendapatkan kesalahan ini ketika mencoba menguji model saya di aplikasi Lokomotif .

Pada dasarnya, setiap file pengujian mem-boot aplikasi Lokomotif dalam fungsi before() . Mem-boot aplikasi membuat koneksi mongo db dan memuat di semua model saya - ini ada di file penginisialisasi luwak saya (berjalan sekali saat startup aplikasi):

var mongoose = require("mongoose"),
    fs = require("fs");

module.exports = function() {

  // Connect to DB
  switch (this.env) {
    case 'development':
      mongoose.connect('mongodb://localhost/slipfeed');
      break;
    case 'test':
      mongoose.connect('mongodb://localhost/slipfeed');
      break;
    case 'production':
      mongoose.connect('mongodb://mongodb.example.com/prod');
      break;
  }

  // Load models  
  var app = this,
      modelPath = app.get('models');
  fs.readdirSync(modelPath).forEach(function(file) {
    var name = file.substr(0, file.lastIndexOf('.'));
    require(modelPath + '/' + name)(mongoose, app);
  });

}

Di setiap file model saya, pada dasarnya saya melakukan ini:

module.exports = function(mongoose, app) {
  var Schema = mongoose.Schema;
  var User = new Schema(...);
  app.User = mongoose.model('User', User);
});

Dan di setiap file pengujian model saya, saya melakukan sesuatu seperti ini:

var locomotive = require("locomotive"),
    app = new locomotive.Locomotive(),
    should = require("should");

describe( "User", function() {

  before( function (done) {
    app.boot( process.cwd(), 'test', function () {
      done();
    });
  });

  after( function (done) {
    mongoose.disconnect( function (err) {
      if (err) throw err;
      console.log('DISCONNECT')
      done();
    })
  });      

  ...tests go here

});

Bagian app.boot() baru saja memulai server, memuat file konfigurasi dan berjalan melalui penginisialisasi (yang hanya file yang berisi berbagai potongan kode, misalnya memulai koneksi db).

Tetapi setelah file pengujian pertama saya selesai, dan mocha mencoba memuat file berikutnya, saya akan mendapatkan OverwriteModelError .

Saya mengerti bahwa itu mungkin ada hubungannya dengan koneksi yang tidak ditutup saat memuat file pengujian berikutnya, atau mungkin saya menginisialisasi model saya dengan cara yang buruk.

Bagaimanapun, saya mencoba menambahkan mongoose.disconnect ke fungsi after() , tetapi itu tidak membantu.

itu tidak ada hubungannya dengan koneksi terbuka atau tertutup. Anda mencoba untuk mendefinisikan kembali model yang sudah ada untuk skema yang berbeda.

var a = new Schema({ x: 'string' });
var b = new Schema({ x: 'string' });
mongoose.model('Thingy', a);
mongoose.model('Thingy', a); // ok, a === the registered schema instance
mongoose.model('Thingy', b); // error a !== the registered schema

FWIW, saya pikir beberapa kode contoh yang sedikit kurang sepele akan mencegah hal ini muncul berulang kali. Mungkin aplikasi ekspres kecil, yang mendefinisikan satu model, menginisialisasi koneksi dengan cara yang dapat disuntikkan, dan tes integrasi moka (dalam kasus saya, saya menggunakan supertest, tapi apa pun sebenarnya) yang menyuntikkan koneksi tanpa memicu masalah ini.

Jika ada beberapa aplikasi di luar sana yang Anda ketahui tentang @aheckmann yang dapat kami

Inilah yang saya lakukan:

https://github.com/j0ni/beachenergy.ca/blob/master/datamodel/index.js

Saya tidak menyukainya, tetapi itu membuat masalahnya hilang. Jika saya menggunakan anti-pola luwak (tampaknya mungkin) contoh kanonik akan membantu.

Hai @aheckmann - Saya 100% yakin saya tidak membuat model baru dengan skema yang berbeda. Saya membuat proyek kerangka/demo untuk mengilustrasikan masalah ini: https://github.com/davisford/mongoose-test

Mulai moka dengan make dan untuk pertama kalinya, tes akan lulus. Sekarang, edit models/user.js dan simpan (misalnya CTRL/CMD + S), dan moka mengambil perubahan dengan --watch , dan kita menekan OverwriteModelError .

Ini pilihan lain... Saya menggunakan nodemon. Ini memastikan bahwa proses dimulai ulang setiap kali pengujian berjalan:
$ nodemon --exec "mocha -R min" tes

Jadi apa solusi yang disarankan untuk ini? Buat koneksi baru sebelum setiap pengujian? Bagaimana lagi kita bisa mendefinisikan model Mongoose dalam spesifikasi kita dan tidak mengalami kesalahan saat menonton?

Saya menyerah mencoba menyelesaikannya dengan moka saja. Alih-alih yang saya lakukan adalah menjalankan mocha melalui nodemon. Dengan cara ini, proses simpul dimulai ulang dan masalah dihilangkan.

Petter Graff
(dikirim dari iPad saya, kemungkinan kesalahan ejaan :)
+1.512.784.3232
petter. [email protected]

Pada 2 Februari 2013, pukul 05:41, Oliver Joseph Ash [email protected] menulis:

Jadi apa solusi yang disarankan untuk ini? Buat koneksi baru sebelum setiap pengujian? Bagaimana lagi kita bisa mendefinisikan model Mongoose dalam spesifikasi kita dan tidak mengalami kesalahan saat menonton?

—
Balas email ini secara langsung atau lihat di GitHub.

Bagaimana Anda menjalankan moka melalui nodemon dengan tepat? Saya mencoba ini, tetapi saya mungkin jauh:

nodemon /usr/local/share/npm/bin/mocha --reporter spec --ui bdd --watch ./server/test/*.js

Saya menggunakan:
nodemon --exec "mocha -R min" tes

Mengingat contoh yang Anda tunjukkan di bawah, sepertinya Anda menggunakan spec daripada min dan melakukan pengujian di server/test... Jika demikian, ubah saja parameternya...

Pada 2 Februari 2013, pukul 7:00, Oliver Joseph Ash [email protected] menulis:

Bagaimana Anda menjalankan moka melalui nodemon dengan tepat? Saya mencoba ini, tetapi saya mungkin jauh:

nodemon /usr/local/share/npm/bin/mocha --reporter spec --ui bdd --watch ./server/test/*.js
—
Balas email ini secara langsung atau lihat di GitHub.

Bagus. Tidak secepat --watch , tetapi yang lebih penting, ini berfungsi.

Saya juga memperhatikan bahwa ketika perubahan dibuat pada skema yang diperlukan tes Mocha, Mocha tidak akan memuat ulang karena di-cache :(

Pada 2 Februari 2013, pukul 15:23, Petter Graff [email protected] menulis:

Saya menggunakan:
nodemon --exec "mocha -R min" tes

Mengingat contoh yang Anda tunjukkan di bawah, sepertinya Anda menggunakan spec daripada min dan melakukan pengujian di server/test... Jika demikian, ubah saja parameternya...

Pada 2 Februari 2013, pukul 7:00, Oliver Joseph Ash [email protected] menulis:

Bagaimana Anda menjalankan moka melalui nodemon dengan tepat? Saya mencoba ini, tetapi saya mungkin jauh:

nodemon /usr/local/share/npm/bin/mocha --reporter spec --ui bdd --watch ./server/test/*.js
—
Balas email ini secara langsung atau lihat di GitHub.

—
Balas email ini secara langsung atau lihat di GitHub.

Solusi @ j0ni bekerja dengan baik untuk saya. Saya akhirnya mengganti semua panggilan ke "mongoose.model" dengan:

try {
    // Throws an error if "Name" hasn't been registered
    mongoose.model("Name")
} catch (e) {
    mongoose.model("Name", Schema)
}

Saya setuju bahwa tidak cantik harus membuang kode seseorang dengan panggilan seperti itu. Akan menyenangkan memiliki singkatan untuk ini yang berfungsi untuk kasus yang paling umum, yaitu bahwa modul hanya diurai ulang saat runtime tanpa perubahan pada skema. Mungkin menyebutnya sesuatu seperti mongoose.getOrCreate(name, schema) .

@yourcelf menerima saran Anda dan bekerja untuk saya. Terima kasih.

module.exports = getOrCreateModel('User', UserSchema);

Ada opsi lain: membersihkan luwak dari semua model dan skema.
Dalam kode pengujian saya, saya menambahkan:

 mongoose.models = {};
 mongoose.modelSchemas = {};

Dan itu berfungsi dengan baik, setidaknya untuk saya.

@remicastaing Sempurna, bekerja untuk saya. Terima kasih!

@remicastaing solusi terbaik sejauh ini!

@remicastaing Juga bekerja untuk saya, tampaknya menjadi solusi terbaik sejauh ini

@remicastaing ya, sepertinya solusi yang berfungsi.

Itu masih belum tahu apa masalah sebenarnya.

@remicastaing Terima kasih, bekerja untuk saya juga!

@remicastaing Bekerja untuk saya juga. Terima kasih.

Maaf menggaruk gatal lama, tetapi saya menghadapi masalah yang sama mencoba menjalankan mocha -w dengan luwak, mencoba setiap solusi yang mungkin tetapi sekarang saya menabrak dinding.

di mana saya harus meletakkan?

 mongoose.models = {};
 mongoose.modelSchemas = {};

?

beforeEach, afterEach, after, before ?

Haruskah saya luwak.createConnection() di beforeEach, tutup afterEach ?

saya meletakkan

mongoose.models = {};
mongoose.modelSchemas = {};

tepat setelah

var mongoose = require('mongoose');

dalam file config.test.js langsung di folder test ( config.test.js satu-satunya file *.test.js di folder tes, file *.test.js ada di sub folder). Saat moka berjalan secara rekursif ( opsi --recursive di mocha.opts ) melalui folder uji, itu dimulai dengan config.test.js .

@remicastaing terima kasih! Bekerja untuk saya juga (melati)

Hanya kasus lain:
Saya mengalami masalah ini, ketika saya membutuhkan model dengan huruf yang berbeda dalam kode dan dalam pengujian.
Misalnya dalam spesifikasi:
var User = require('./models/user');
dan dalam kode
var User = require('./models/User');
Perlu diingat, tidak ada versi cache untuk pengetikan yang berbeda

+1 untuk apa yang dialami @asci . Jika Anda memerlukan model yang sama tetapi dengan kasing yang berbeda di dua file yang berbeda, dan kemudian Anda memerlukannya di yang lain, itu akan menimbulkan kesalahan 'Tidak dapat menimpa'

@iandoe saya menggunakan mongoose.connect dan dimasukkan ke dalam tes moka

after(function(done){
  mongoose.models = {};
  mongoose.modelSchemas = {};
  mongoose.connection.close();
  done();
});

:+1: :membungkuk:

:+1:

Jika Anda ingin membuat model di beforeEach , buat koneksi baru dengan var db = mongoose.createConnection(); lalu db.model(...) sebagai lawan dari mongoose.model(...); di beforeEach . Perilaku ini berdasarkan desain dan bukan bug.

Saya memiliki kode yang dapat dimuat ulang saat runtime jadi saya ingin menimpa model yang ada jika saya membuat perubahan pada skema atau fungsi model selama pengembangan.

Kecuali ada alasan bagus untuk tidak melakukannya, saya tidak mengerti mengapa saya tidak bisa melakukan hal seperti ini.

Contoh

delete mongoose.models['somemodel'];
var somemodel = db.mongoose.model('somemodel', someschema);

Ini bekerja untuk saya, saya telah melakukannya seperti itu selama sekitar satu tahun.

Atau mungkin ada cara untuk mengubah skema dan fungsi model tanpa menghapus model/skema yang ada tetapi saya tidak repot-repot menyelidiki lebih lanjut.

Saya menjadi solusi ini dapat membantu

@yourself benar.

:+1:

Saya tahu ini sudah tua tetapi jika ada yang menemukan ini, saya menyelesaikannya dengan membuat file utilitas uji basis data seperti ini:

// DatabaseUtils.js
import mongoose from 'mongoose';
const MONGO_URI = 'mongodb://localhost:27017/collectionname'

export function tearDown(){
  mongoose.models = {};
  mongoose.modelSchemas = {};
  resetDb();
  if(mongoose.connection.readyState) mongoose.disconnect();
}

export function setUp(){
  if(!mongoose.connection.readyState) mongoose.connect(MONGO_URI);
}

export function resetDb(){
  if(mongoose.connection.db) mongoose.connection.db.dropDatabase();
}

Kemudian dari file pengujian Anda, Anda dapat menggunakan:

import { setUp, tearDown, resetDb } from './DatabaseUtils'

describe('Testing MongoDB models', function(){
  before(setUp)
  after(tearDown)
  afterEach(resetDb)

  it('Some test of a mongoose model', () =>  {
  // Test code here.
  }
})

Jawaban StackOverflow ini menyelesaikannya seperti ini:

let users
try { users = mongoose.model('users') }
catch (e) { users = mongoose.model('users', <UsersSchema...>) }

Sunting: Seperti yang ditunjukkan oleh @DanielRamosAcosta , "Masalahnya adalah jika Skema Anda berubah, perubahan tidak akan berlaku."

Terima kasih @remicastaing , saya telah kehilangan 5 menit sampai saya mencapai solusi Anda, harus lebih jelas :)

Terima kasih @juanpabloaj , itu berhasil untuk saya

@gunar Masalahnya adalah jika Skema Anda berubah, perubahan tidak akan berlaku.

@juanpabloaj Terima kasih bro!

Saya cukup menggunakan, alih-alih membuat try/catch yang jelek:

let users = mongoose.models.users || mongoose.model('users', <UsersSchema...>)

Diskusi ini benar-benar memalukan
Penulis luwak yang sebenarnya memberikan solusi yang benar ( 1 dan 2 ) namun semua jempol mengarah ke solusi peretasan yang salah.
Sungguh memalukan

@tomyam1 , mungkin karena solusi

Terkadang solusi yang nyaman bekerja lebih baik daripada yang benar secara teknis :)

@tomyam1 Tidak ada yang memalukan tentang berkolaborasi untuk memecahkan masalah dan saya berterima kasih kepada semua orang yang telah memposting solusi mereka sendiri di sini. Tanpa merinci - dalam kasus saya, salah satu saran 'retas yang salah' telah bekerja dengan sempurna, dan kedua dari apa yang Anda sebut solusi 'benar' tidak.

Saling membantu bukanlah hal yang memalukan. Terima kasih semua orang yang telah membuat posting yang konstruktif.

Baik pak (garethdown44, fega), maka kami tidak setuju.
Untuk menghindari membuat lebih banyak spam, silakan gunakan reaksi emoji.

Untuk meringkas utas ini:

Hanya ada tiga solusi berbeda di halaman ini:

1. Gunakan model yang di-cache jika ada:

mongoose.models.users || mongoose.model('users', <UsersSchema...>)

atau

try {
    // Throws an error if "Name" hasn't been registered
    mongoose.model("Name")
} catch (e) {
    mongoose.model("Name", Schema)
}

Ini bukan solusi karena tidak akan mengambil perubahan dalam model.

1. Hapus cache model

 mongoose.models = {};
 mongoose.modelSchemas = {};

Mencoba solusi ini dan tidak berhasil, dan siapa yang tahu mengapa?
Itu bergantung pada modifikasi variabel internal yang tidak berdokumen.
Mungkin berhasil ketika diusulkan pada 2013, tetapi 4 tahun kemudian.

1. Simpan model pada koneksi.
   Ini adalah solusi resmi yang diusulkan oleh penulis mogoose.
   Namun itu hampir sepenuhnya diabaikan. Bagi saya, ini memalukan.

const Mongoose = require('mongoose');
const DB = Mongoose.createConnection(...);
const Model = DB.model("Name", schema);

@tomyam1 - Setuju pada prinsipnya dengan apa yang Anda katakan. Namun untuk bersikap adil bahwa solusi itu memang datang dua tahun setelah solusi (retas) lainnya !!

Dalam kasus saya, saya memilih solusi nodemon. Ketika saya menyadari apa yang terjadi dan cara kode pengujian disusun, itu akan membutuhkan refactoring besar yang saya tidak punya waktu untuk melakukannya. Saya senang bahwa solusi nodemon diusulkan dan orang-orang memberi +1. Itu saja yang saya katakan.

Sayangnya, Nodemon memulai ulang seluruh rangkaian pengujian. mocha --watch memuat ulang jauh lebih cepat

Sayangnya, Nodemon memulai ulang seluruh rangkaian pengujian, jadi mocha --watch memuat ulang jauh lebih cepat

reload lambat dan pengembang waras adalah tradeoff saya akan membuat lebih dari mengiris milidetik (atau detik) dari uji coba.

juga, karena belum disebutkan di sini, npm-watch adalah alat untuk melakukan ini (membungkus nodemon) sehingga Anda dapat mendefinisikan skrip npm sederhana watch https://www.npmjs. com/package/npm-watch

Saya memiliki masalah yang sama, jadi saya memeriksa mongoose.modelNames() dan menentukan apakah saya mengkompilasi model atau hanya mengambil model yang sudah dikompilasi, karena mocha --watch menyebabkan masalah ini. Jadi di sini adalah kode:

mongoose.modelNames().indexOf("User") === -1 //if my model has not been compiled...
 ? mongoose.model("User", UserSchema) //...compile model and return it
 : mongoose.connection.model("User"); //else it is already compiled, so return this model

sekarang Anda mengembalikan ini sebagai fungsi (ganti "Pengguna" dengan argumen, dan UserSchema dengan argumen untuk Skema Anda) untuk module.exports dan ketika Anda memerlukannya, Anda memanggil fungsi ini.

https://stackoverflow.com/a/49806603/5674976

@remicastaing bekerja seperti pesona, terima kasih!

Pada beberapa instantiasi khusus, mungkin diperlukan untuk menghapus referensi models

after((done) => {
  Object.keys(mongoose.models).forEach((k) => {
    delete mongoose.models[k];
  });
  Object.keys(mongoose.modelSchemas).forEach((k) => {
    delete mongoose.modelSchemas[k];
  });
  mongoose.connection.close();
  done();
});

mocha --watch tidak memerlukan apa pun di luar describe , yaitu tidak akan mendefinisikan ulang Skema Anda.

Cara pengujian yang paling efisien, elegan, dan mudah dipahami yang membuat jumlah koneksi ke db paling sedikit adalah dengan menyiapkan koneksi, skema, dan model Anda di luar rangkaian pengujian Anda.

Kode ini sangat KERING dibandingkan dengan contoh saya yang lain dalam menyiapkan model sebelum setiap pengujian (tidak perlu bagi saya).

Rangkaian pengujian berikut berfungsi:

const expect = require("chai").expect;
const mongoose = require("mongoose"),
  UserSchema = require("../data/models/User");
const connection = mongoose.createConnection(
  process.env.MONGO_URL || "mongodb://127.0.0.1/test"
);
const User = connection.model("User", UserSchema);

describe("Database Testing", function() {
  it("MongoDB is working and repeatedly testable", function(done) {
    let user = User({
      username: "My user"
    });

    user
      .save()
      .then(doc => {
        console.log(doc); // This outputs the doc.
        expect(doc.username).to.equal("My user");
        done();
      })
      .catch(err => {
        console.error(err);
        expect(err).to.be.null;
        done();
      });
  });
});

Dari ../data/models/User.js

let mongoose = require("mongoose");

let UserSchema = new mongoose.Schema({
  username: String
});
module.exports = UserSchema; // 

Saya dulu bingung tentang bagaimana MongoDb membuat koneksi, Skema, dan modelnya. Saya tidak menyadari bahwa Anda dapat menentukan satu model dan menggunakannya berkali-kali (obv. tapi ...)

Saya mengikuti dokumentasi dengan tepat dan membuat modul yang mendefinisikan skema dan mengembalikan model.

Ini berarti bahwa jika saya memerlukannya dalam pengujian, Skema akan didefinisikan ulang berkali-kali, karena terus membutuhkan modul yang mendefinisikan skema. Dan beberapa definisi Skema bukanlah bueno.

Solusi orang (yang berfungsi, meskipun kurang efisien) membuat Anda membuat koneksi baru sebelum setiap pengujian dan sering kali model baru sebelum setiap pengujian.

Tapi pemahaman sederhana bahwa:

• mocha --watch tidak menjalankan apa pun di luar describe lebih dari sekali
• Anda dapat menggunakan koneksi, Skema, dan model yang sama beberapa kali untuk hal yang berbeda.

memecahkan ini secara efisien dan elegan.

Di bawah ini adalah cara saya yang kurang efisien dan orisinal untuk membuatnya berfungsi.

./test/db.spec.js

const expect = require("chai").expect;
const mongoose = require("mongoose"),

  // mocha --watch does not rerequire anything
  // outside of the test suite ("describe").
  // Define your Schemas and models separately, so
  // that you can define your Schema once above
  // your test suites, and your models many times
  // when testing. 
  UserSchema = require("../data/models/User");

describe("mongoose strangeness", function() {
  var connection = mongoose.createConnection(
    process.env.MONGO_URL || "mongodb://127.0.0.1/test"
  );

  // I tried the beforeEach and afterEach, but this wasn't needed:

  // beforeEach(function(done) {
  //   connection = mongoose.createConnection(
  //     process.env.MONGO_URL || "mongodb://127.0.0.1/test"
  //   );
  //   connection.once("open", function() {
  //     done();
  //   });
  // });

  // afterEach(function(done) {
  //   connection.close(function() {
  //     done();
  //   });
  // });

  it("MongoDB testable", function(done) {
    let User = connection.model("User", UserSchema);

    let user = User({
      username: "My user"
    });

    user
      .save()
      .then(doc => {
        console.log(doc); // This outputs the doc every time.
        expect(doc.username).to.equal("My user");
        done();
      })
      .catch(err => {
        console.error(err);
        expect(err).to.be.null;
        done();
      });
  });
});

Selamat MongoDbing.

Kode ini berfungsi untuk saya:

if (mongoose.modelNames().includes('Model')) {
    mongoose.deleteModel('Model');
}

mongoose.model('Model', new mongoose.Schema({ ... }));

@verheyenkoen benar. Berikut tautan ke dokumen deleteModel: https://mongoosejs.com/docs/api/connection.html#connection_Connection -deleteModel