Mongoose: mocha'watch 'でOverwriteModelError

これはプログラミングエラーが原因です。 同じ名前とスキーマでmongoose.model()またはconnection.model()を複数回呼び出しても、エラーは発生しません。 別のスキーマで存在するモデルの名前を渡すと、エラーが発生します。 モデルの上書きは実際には許可されていません。

mocha watchがスキーマを再要求し、 mongoose.model(preExistingName, newSchema)を呼び出す場合、はい、エラーが発生します。 以前、このシナリオでは、マングースは新しいモデルをまったくコンパイルしていませんでした。プログラミングエラーを飲み込んで古いモデルを返すだけでしたが、これは間違った動作です。

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

わかりました、それは理にかなっています。 ありがとう！

@ aheckmann-私もこれにぶつかっていて、何が間違っているのか--watch再実行をトリガーし、次のようになります。

OverwriteModelError: Cannot overwrite "User" model once compiled.

user.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;

userSpec.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();
  });
});

マングーステストでは、毎回新しい接続を作成するだけで、うまく機能します。

var db = mongoose.createConnection()

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

グーグルグループへのフォローアップを投稿https://groups.google.com/d/topic/mongoose-orm/PXTjqqpaDFk/discussion

私もこれを見ています。 最小限の例を次に示します。

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

おそらく私はモデルを定義する正しい方法を逃しています...？

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

var Example = connection.model('Example', ExampleSchema)必要があります

うまく機能する@aheckmannに感謝します。

テストごとに新しい接続が作成され、モデルはそれぞれの接続内にローカルにキャッシュされます。 もう1つの方法では、b / cモデルがテストごとにマングースモジュールレベルでコンパイルされていたため、競合が発生していました。

@ aheckmann-機関車アプリでモデルをテストしようとすると、このエラーが発生します。

基本的に、各テストファイルはbefore()関数でLocomotiveアプリを起動します。 アプリを起動すると、mongo db接続が作成され、すべてのモデルに読み込まれます。これは、mongoose初期化ファイルにあります（アプリの起動時に1回実行されます）。

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);
  });

}

私の各モデルファイルでは、基本的に次のことを行っています。

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

そして、私のモデルテストファイルのそれぞれで、私は次のようなことをしています：

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

});

app.boot()部分はサーバーを起動するだけで、構成ファイルをロードし、イニシャライザー（db接続の開始などのさまざまなコードを含むファイル）を実行します。

しかし、最初のテストファイルが終了し、mochaが次のファイルを読み込もうとすると、 OverwriteModelErrorを取得します。

次のテストファイルをロードするときに接続が閉じられないことと関係があるか、モデルを不適切な方法で初期化している可能性があることを理解しています。

とにかく、 mongoose.disconnectをafter()関数に追加しようとしましたが、それは役に立ちませんでした。

開いている接続または閉じている接続とは何の関係もありません。 すでに存在するモデルを別のスキーマに再定義しようとしています。

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、少し些細なサンプルコードでは、これが繰り返し発生するのを防ぐことができると思います。 おそらく、単一のモデルを定義する小さなExpressアプリが、注入可能な方法で接続を初期化し、モカ統合テスト（私の場合はスーパーテストを使用していますが、実際には何でも）は、この問題をトリガーせずに接続を注入します。

@aheckmannを知っていて、標準的なパターンを実装することを検討しているアプリがある場合は、

これが私が頼ったものです：

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

私はそれが好きではありませんが、それは問題を解決します。 マングースのアンチパターンを使用している場合（可能性が高いと思われます）、正規の例が役立ちます。

こんにちは@ aheckmann-私は別のスキーマで新しいモデルを作成していないと100％確信しています。 この問題を説明するためにスケルトン/デモプロジェクトを作成しました： https ：

makeモカを開始すると、最初にテストに合格します。 ここで、 models/user.jsを編集して保存すると（たとえば、CTRL / CMD + S）、mochaが--watchで変更を取得し、 OverwriteModelErrorます。

ここに別のオプションがあります...私はnodemonを使用します。 これにより、テストが実行されるたびにプロセスが再起動されます。
$ nodemon --exec "mocha -Rmin"テスト

では、これに対する推奨される解決策は何ですか？ 各テストの前に新しい接続を作成しますか？ スペックでマングースモデルを定義し、視聴中にエラーが発生しないようにするには、他にどのような方法がありますか？

モカだけで解決しようと諦めました。 代わりに、nodemonを介してmochaを実行します。 このようにして、ノードプロセスが再起動され、問題が解消されます。

ペッターグラフ
（私のiPadから送信され、スペルミスの可能性があります:)
+1.512.784.3232
ペッター。 [email protected]

2013年2月2日には、午前5時41分AMで、オリバージョセフ・アッシュ[email protected]は書きました：

では、これに対する推奨される解決策は何ですか？ 各テストの前に新しい接続を作成しますか？ スペックでマングースモデルを定義し、視聴中にエラーが発生しないようにするには、他にどのような方法がありますか？

—
このメールに直接返信するか、GitHubで表示してください。

nodemonを介してmochaを正確に実行するにはどうすればよいですか？ 私はこれを試しましたが、おそらく遠く離れています：

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

私が使う：
nodemon --exec "mocha -Rmin"テスト

以下に示す例を考えると、minではなくspecを使用し、サーバー/テストにテストがあるようです...その場合は、パラメーターを変更するだけです...

2013年2月2日午前7：00、Oliver [email protected]は次のように書いています。

nodemonを介してmochaを正確に実行するにはどうすればよいですか？ 私はこれを試しましたが、おそらく遠く離れています：

nodemon / usr / local / share / npm / bin / mocha --reporter spec --ui bdd --watch ./server/test/*.js
—
このメールに直接返信するか、GitHubで表示してください。

良いですね。 --watchほど速くはありませんが、さらに重要なことに、それは機能します。

また、Mochaテストに必要なスキーマに変更が加えられた場合、それらはキャッシュされているため、Mochaはそれらをリロードしないことに気付きました:(

2013年2月2日、15：23で、ペターGraffの[email protected]書きました：

私が使う：
nodemon --exec "mocha -Rmin"テスト

以下に示す例を考えると、minではなくspecを使用し、サーバー/テストにテストがあるようです...その場合は、パラメーターを変更するだけです...

2013年2月2日午前7：00、Oliver [email protected]は次のように書いています。

nodemonを介してmochaを正確に実行するにはどうすればよいですか？ 私はこれを試しましたが、おそらく遠く離れています：

nodemon / usr / local / share / npm / bin / mocha --reporter spec --ui bdd --watch ./server/test/*.js
—
このメールに直接返信するか、GitHubで表示してください。

—
このメールに直接返信するか、GitHubで表示してください。

@ j0niのソリューションは私にとってうまく機能しました。 最終的に、「mongoose.model」へのすべての呼び出しを次のように置き換えました。

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

私は、そのような呼び出しで自分のコードを散らかさなければならないのはきれいではないことに同意します。 最も一般的なケース、つまり、スキーマを変更せずにモジュールが実行時に再解析されるだけの場合に機能する、これの省略形があると便利です。 たぶんそれをmongoose.getOrCreate(name, schema)ようなものと呼んでください。

@yourcelfはあなたの提案を

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

別のオプションがあります：すべてのモデルとスキーマからマングースを掃除します。
テストコードに、次のものを追加しました。

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

そして、少なくとも私にとっては問題なく動作します。

@remicastaingパーフェクト、私のために働きます。 ありがとう！

@remicastaingこれまでで最高の回避策！

@remicastaing私のためにも働いた、これまでのところ最良の解決策のようです

@remicastaingはい、実用的なソリューションのようです。

しかし、実際の問題が何であるかはまだわかりません。

@remicastaingありがとう、私にも働きます！

@remicastaing私のためにも働いています。 ありがとう。

古いかゆみを掻いて申し訳ありませんが、マングースでmocha -wを実行しようとすると同じ問題に直面し、考えられるすべての解決策を試しましたが、今は壁にぶつかっています。

どこに置けばいいの？

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

？

beforeEach、afterEach、after、before？

beforeEachでmongoose.createConnection（）を実行し、afterEachで閉じる必要がありますか？

私は入れました

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

直後の

var mongoose = require('mongoose');

config.test.jsファイル内のtestフォルダーに直接（ config.test.jsはテストフォルダー内の唯一の*.test.jsファイルであり、他の*.test.jsファイルはサブフォルダ）。 モカは（再帰的に行くように--recursiveでオプションmocha.optsテストフォルダ経由）、それはで始まるconfig.test.js 。

@remicastaingありがとう！ 私のためにも働く（ジャスミン）

ちょうど別のケース：
コードとテストで大文字と小文字が異なるモデルが必要なときに、この問題が発生しました。
たとえば、仕様では：
var User = require('./models/user');
とコードで
var User = require('./models/User');
ただ覚えておいてください、異なるタイピングのためのキャッシュされたバージョンはありませんでした

@asciが経験したことへの+1。 同じモデルが必要であるが、2つの異なるファイルで大文字と小文字が異なる場合、別のファイルでそれらが必要な場合は、「上書きできません」エラーがスローされます。

@iandoe mongoose.connectを使用して、モカテストを行います

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

：+1 ：： bow：

：+1：

beforeEachでモデルを作成する場合は、 beforeEach mongoose.model(...);ではなく、 var db = mongoose.createConnection(); 、次にdb.model(...)新しい接続を作成します。 。 この動作は、バグではなく仕様によるものです。

実行時に再ロードできるコードがあるので、開発中にスキーマまたはモデル関数に変更を加えた場合、既存のモデルを上書きしたいと思います。

正当な理由がない限り、なぜこのようなことができないのかわかりません。

例

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

これは私にとってはうまくいきます、私はそれを約1年間そのようにやっています。

または、既存のモデル/スキーマを消去せずにスキーマとモデル関数を変更する方法があるかもしれませんが、私はこれ以上調査する必要はありません。

私はこの解決策が役立つことがあります

@yourcelfには権利があります。

：+1：

私はこれが古いことを知っていますが、誰かがこれに遭遇した場合、私は次のようなデータベーステストユーティリティファイルを作成することによってそれを解決しました：

// 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();
}

次に、テストファイルから次のものを使用できます。

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.
  }
})

このStackOverflowの回答は、次のように解決します。

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

編集： @DanielRamosAcostaが指摘している

@remicastaingに感謝し

ありがとう@juanpabloaj 、それは私のために働いた🎉

@gunar問題は、スキーマが変更された場合、変更が有効にならないことです。

@juanpabloajありがとう仲間！

醜いtry / catchを作成する代わりに、単に使用します。

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

この議論は本当に恥ずべきことです
マングースの実際の作者は正しい解決策（ 1と2 ）を与えましたが、すべての親指は間違ったハッキーな解決策に行きます。
本当に恥ずかしい

@ tomyam1 、おそらくそれらのハッキーな解決策が問題なく私たちの問題を解決しているからです...：smiley：

技術的に正しいソリューションよりも便利なソリューションの方がうまくいく場合があります:)

@ tomyam1問題を解決するために協力することについて恥ずべきことは何もありません。ここに解決策について独自の

互いに助け合うことは恥ずべきことではありません。 建設的な投稿をしてくれたすべての人に感謝します。

サー（garethdown44、fega）、それでは同意しません。
スパムの作成を防ぐために、絵文字の反応を使用してください。

このスレッドを要約すると：

このページには、3つの異なるソリューションしかありません。

1. キャッシュされたモデルが存在する場合はそれを使用します。

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

また

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

モデルの変更を取得しないため、これは解決策ではありません。

1. モデルキャッシュをクリアする

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

この解決策を試しましたが、うまくいきませんでした。理由は誰にもわかりません。
これは、文書化されていない内部変数の変更に依存しています。
2013年に提案されたときはおそらく機能しましたが、4年後です。

1. 接続にモデルを保存します。
   これは、mogooseの作者によって提案された公式の解決策です。
   それでも、それはほとんど完全に見落とされていました。 私にとって、これは恥ずべきことです。

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

@ tomyam1-原則としてあなたの言っていることに同意します。 しかし、公平を期すために、その解決策は他の（ハッキーな）解決策の2年後に来ました!!

私の場合、nodemonソリューションを選択しました。 何が起こっているのか、そしてテストコードがどのように構成されているのかを理解したとき、それは私がする時間がない大きなリファクタリングを必要としたでしょう。 nodemonソリューションが提案され、人々がそれを+1したことをうれしく思います。 私が言っているのはそれだけです。

悲しいことに、Nodemonはテストスイート全体を再起動します。 mocha --watchリロードがはるかに高速

悲しいことに、Nodemonはテストスイート全体を再起動するため、mocha--watchのリロードがはるかに高速になります

遅いリロードと正気の開発者はトレードオフです。テスト実行からミリ秒（または秒）のスライスをやり過ぎます。

また、ここでnpm-watch言及されていないため、 watch https：//www.npmjsを定義できます

同じ問題が発生したので、 mongoose.modelNames()をチェックして、モデルをコンパイルするか、コンパイル済みのモデルを取得するかを判断します。mocha--watchがこの問題を引き起こします。 だからここにコードがあります：

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

これをmodule.exports関数として返し（「User」を引数に、UserSchemaをスキーマの引数に置き換えます）、必要に応じてこの関数を呼び出します。

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

@remicastaingは魅力のように

一部の特別なインスタンス化では、 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は、 describe以外のものを必要としません。つまり、スキーマを再定義しません。

データベースへの接続数を最小限に抑える、最も効率的でエレガント、かつ理解しやすいテスト方法は、テストスイートの外部で接続、スキーマ、およびモデルをセットアップすることです。

このコードは、各テストの前にモデルを設定する他の例と比較すると、非常に乾燥しています（私には必要ありません）。

次のテストスイートが機能します。

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();
      });
  });
});

../data/models/User.js

let mongoose = require("mongoose");

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

私は以前、MongoDbがどのように接続、スキーマ、モデルを作成したかについて混乱状態にありました。 1つのモデルを定義して、それを何度も使用できることに気づいていませんでした（もちろんですが...）

ドキュメントに正確に従い、スキーマを定義してモデルを返すモジュールを作成しました。

つまり、テストで必要になった場合、スキーマを定義するモジュールが引き続き必要になるため、スキーマは何度も再定義されます。 そして、スキーマの複数の定義はブエノではありません。

人々のソリューション（効率は劣りますが）では、各テストの前に新しい接続を作成し、多くの場合、各テストの前に新しいモデルを作成します。

しかし、それを簡単に理解する：

• mocha --watchはdescribe以外では何も実行しません
• 同じ接続、スキーマ、モデルをさまざまな目的で複数回使用できます。

これを効率的かつエレガントに解決しました。

以下は、これを機能させるための効率の悪い独自の方法です。

./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();
      });
  });
});

幸せなMongoDbing。

このコードは私のために働きます：

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

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

@verheyenkoenは正しいです。 deleteModelドキュメントへのリンクは次のとおりです： https ：//mongoosejs.com/docs/api/connection.html#connection_Connection -deleteModel