Mongoose: मोचा 'घड़ी' के साथ अधिलेखित मॉडल त्रुटि

यह प्रोग्रामिंग त्रुटि के कारण होता है। एक ही नाम और स्कीमा के साथ mongoose.model() या connection.model() को कई बार कॉल करने से कोई त्रुटि नहीं होती है। किसी भिन्न स्कीमा के साथ मौजूद मॉडल का नाम पास करने से त्रुटि उत्पन्न होती है। ओवरराइटिंग मॉडल को वास्तव में कभी भी अनुमति नहीं दी गई थी।

अगर मोचा घड़ी को आपकी स्कीमा की फिर से आवश्यकता होती है और 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

Google समूहों के लिए अनुवर्ती पोस्ट किया गया 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 जो बहुत अच्छा काम करता है।

यह काम करता है b/ca आपके प्रत्येक परीक्षण के लिए नया कनेक्शन बनाया जाता है और मॉडल को प्रत्येक के लिए कनेक्शन के भीतर स्थानीय रूप से कैश किया जाता है। दूसरा तरीका विफल रहता है बी/सी मॉडल प्रत्येक परीक्षण के लिए नेवला मॉड्यूल स्तर पर संकलित हो रहे थे, इसलिए संघर्ष।

@aheckmann - लोकोमोटिव ऐप में अपने मॉडल का परीक्षण करने का प्रयास करते समय मुझे यह त्रुटि मिल रही है।

मूल रूप से, प्रत्येक परीक्षण फ़ाइल लोकोमोटिव ऐप को before() फ़ंक्शन में बूट करती है। ऐप को बूट करना एक मोंगो डीबी कनेक्शन बनाता है और मेरे सभी मॉडलों में लोड होता है - यह मेरी नेवला प्रारंभकर्ता फ़ाइल में है (ऐप स्टार्टअप पर एक बार चलता है):

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() भाग बस सर्वर शुरू करता है, यह कॉन्फ़िगरेशन फ़ाइल लोड करता है और इंटिलाइज़र के माध्यम से चलता है (जो केवल फाइलें हैं जिनमें कोड के विभिन्न टुकड़े होते हैं, उदाहरण के लिए डीबी कनेक्शन शुरू करना)।

लेकिन मेरी पहली परीक्षण फ़ाइल समाप्त होने के बाद, और मोचा अगली फ़ाइल लोड करने का प्रयास करता है, मुझे OverwriteModelError ।

मैं समझता हूं कि अगली परीक्षण फ़ाइल लोड करते समय कनेक्शन बंद नहीं होने के साथ शायद इसका कुछ संबंध है, या शायद मैं अपने मॉडल को खराब तरीके से प्रारंभ कर रहा हूं।

वैसे भी, मैंने अपने after() फ़ंक्शंस में mongoose.disconnect जोड़ने का प्रयास किया, लेकिन इससे कोई मदद नहीं मिली।

इसका खुले या बंद कनेक्शन से कोई लेना-देना नहीं है। आप एक ऐसे मॉडल को फिर से परिभाषित करने का प्रयास कर रहे हैं जो पहले से ही किसी भिन्न स्कीमा में मौजूद है।

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

एफडब्ल्यूआईडब्ल्यू, मुझे लगता है कि कुछ कम मामूली उदाहरण कोड इसे बार-बार आने से रोक देगा। शायद एक छोटा एक्सप्रेस ऐप, जो एक मॉडल को परिभाषित करता है, कनेक्शन को इंजेक्शन योग्य तरीके से शुरू करता है, और एक मोचा एकीकरण परीक्षण (मेरे मामले में मैं सुपरटेस्ट का उपयोग कर रहा हूं, लेकिन वास्तव में जो कुछ भी) जो इस समस्या को ट्रिगर किए बिना कनेक्शन को इंजेक्ट करता है।

अगर वहाँ कुछ ऐप है जिसे आप @aheckmann के बारे में जानते हैं जिसे हम देख सकते हैं, और आप एक विहित पैटर्न को लागू करने पर विचार करते हैं, तो यह चाल चलेगा।

यहां मैंने इसका सहारा लिया है:

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

मुझे यह पसंद नहीं है, लेकिन इससे समस्या दूर हो जाती है। अगर मैं एक नेवला विरोधी पैटर्न का उपयोग कर रहा हूं (संभावना लगता है) एक विहित उदाहरण मदद करेगा।

हाय @aheckmann - मुझे 100% यकीन है कि मैं एक अलग स्कीमा के साथ एक नया मॉडल नहीं बना रहा हूं। मैंने इस मुद्दे को स्पष्ट करने के लिए एक कंकाल / डेमो प्रोजेक्ट बनाया: https://github.com/davisford/mongoose-test

make साथ मोचा शुरू करें और पहली बार परीक्षण पास होंगे। अब, models/user.js संपादित करें और सहेजें (उदाहरण के लिए CTRL/CMD + S), और मोचा --watch साथ परिवर्तन उठाता है, और हमने OverwriteModelError मारा।

यहाँ एक और विकल्प है... मैं nodemon का उपयोग करता हूं। यह सुनिश्चित करता है कि हर बार परीक्षण चलने पर प्रक्रिया फिर से शुरू हो:
$ नोडमॉन --exec "मोचा-आर मिन" परीक्षण

तो इसका अनुशंसित समाधान क्या है? प्रत्येक परीक्षण से पहले एक नया कनेक्शन बनाएं? हम अपने चश्मे में एक नेवला मॉडल को और कैसे परिभाषित कर सकते हैं और इसे देखने में त्रुटि नहीं है?

मैंने इसे अकेले मोचा से हल करने की कोशिश करना छोड़ दिया। इसके बजाय मैं जो करता हूं वह यह है कि मैं मोचा को नोडमॉन के माध्यम से चलाता हूं। इस तरह, नोड प्रक्रिया फिर से शुरू हो जाती है और समस्या समाप्त हो जाती है।

पेट्टर ग्रैफ़
(मेरे iPad से भेजा गया, वर्तनी की गलतियों की संभावना है :)
+1.512.784.3232
छोटा [email protected]

2 फरवरी 2013 को सुबह 5:41 बजे, ओलिवर जोसेफ ऐश ने नोटिफिकेशन @github.com लिखा:

तो इसका अनुशंसित समाधान क्या है? प्रत्येक परीक्षण से पहले एक नया कनेक्शन बनाएं? हम अपने चश्मे में एक नेवला मॉडल को और कैसे परिभाषित कर सकते हैं और इसे देखने में त्रुटि नहीं है?

-
इस ईमेल का सीधे उत्तर दें या इसे GitHub पर देखें।

आप वास्तव में नोडमॉन के माध्यम से मोचा कैसे चलाते हैं? मैंने यह कोशिश की, लेकिन मैं शायद बहुत दूर हूँ:

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

मैं उपयोग करता हूं:
नोडमॉन --exec "मोचा-आर मिन" परीक्षण

नीचे दिखाए गए उदाहरण को देखते हुए, ऐसा लगता है कि आप min के बजाय spec का उपयोग करते हैं और सर्वर/परीक्षण में अपने परीक्षण हैं ... यदि ऐसा है तो पैरामीटर बदलें ...

2 फरवरी 2013 को सुबह 7:00 बजे, ओलिवर जोसेफ ऐश ने नोटिफिकेशन @github.com लिखा:

आप वास्तव में नोडमॉन के माध्यम से मोचा कैसे चलाते हैं? मैंने यह कोशिश की, लेकिन मैं शायद बहुत दूर हूँ:

nodemon /usr/local/share/npm/bin/mocha --reporter spec --ui bdd --watch ./server/test/*.js
-
इस ईमेल का सीधे उत्तर दें या इसे GitHub पर देखें।

अच्छा है। --watch जितना तेज़ नहीं है, लेकिन इससे भी महत्वपूर्ण बात यह है कि यह काम करता है।

मैंने यह भी देखा कि जब मोचा परीक्षण के लिए आवश्यक स्कीमा में परिवर्तन किए जाते हैं, तो मोचा उन्हें कैश किए जाने पर पुनः लोड नहीं करेगा :(

2 फरवरी 2013 को 15:23 बजे, पेट्टर ग्रेफ नोटिफिकेशन @github.com ने लिखा:

मैं उपयोग करता हूं:
नोडमॉन --exec "मोचा-आर मिन" परीक्षण

नीचे दिखाए गए उदाहरण को देखते हुए, ऐसा लगता है कि आप min के बजाय spec का उपयोग करते हैं और सर्वर/परीक्षण में अपने परीक्षण हैं ... यदि ऐसा है तो पैरामीटर बदलें ...

2 फरवरी 2013 को सुबह 7:00 बजे, ओलिवर जोसेफ ऐश ने नोटिफिकेशन @github.com लिखा:

आप वास्तव में नोडमॉन के माध्यम से मोचा कैसे चलाते हैं? मैंने यह कोशिश की, लेकिन मैं शायद बहुत दूर हूँ:

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 मेरे लिए भी काम कर रहा है। धन्यवाद।

एक पुरानी खुजली को खरोंचने के लिए क्षमा करें, लेकिन मुझे उसी समस्या का सामना करना पड़ रहा है जो मोचा-डब्ल्यू को नेवले के साथ चलाने की कोशिश कर रही है, हर संभव समाधान की कोशिश की लेकिन अब मैं दीवार से टकरा रहा हूं।

मुझे कहाँ रखना चाहिए

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

?

प्रत्येक से पहले, प्रत्येक के बाद, बाद में, पहले?

क्या मुझे पहले प्रत्येक पर mongoose.createConnection () करना चाहिए, प्रत्येक के बाद बंद करें?

मैंने रखा

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');
बस ध्यान रखें, विभिन्न टाइपिंग के लिए कोई कैश्ड संस्करण नहीं था

+1 जो @asci ने अनुभव किया। यदि आपको एक ही मॉडल की आवश्यकता है, लेकिन दो अलग-अलग फाइलों में एक अलग मामले के साथ, और फिर आपको दूसरे की आवश्यकता है, तो यह 'ओवरराइट नहीं कर सकता' त्रुटि को फेंक देगा

@iandoe मैं mongoose.connect उपयोग करता हूं और मोचा परीक्षण में

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

:+1: :धनुष:

:+1:

आप में एक मॉडल बनाना चाहते हैं beforeEach , के साथ एक नया कनेक्शन बनाने var db = mongoose.createConnection(); और फिर db.model(...) के रूप में करने का विरोध किया mongoose.model(...); में beforeEach . यह व्यवहार बग के बजाय डिज़ाइन द्वारा है।

मेरे पास कोड है जिसे रनटाइम पर पुनः लोड किया जा सकता है इसलिए यदि मैं विकास के दौरान स्कीमा या मॉडल फ़ंक्शंस में परिवर्तन करता हूं तो मैं मौजूदा मॉडल को ओवरराइट करना चाहता हूं।

जब तक कोई अच्छा कारण न हो, मैं नहीं देखता कि मुझे ऐसा कुछ करने में सक्षम क्यों नहीं होना चाहिए।

उदाहरण

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

यह मेरे लिए काम करता है, मैं इसे लगभग एक साल से कर रहा हूं।

या हो सकता है कि मौजूदा मॉडल/स्कीमा को मिटाए बिना स्कीमा और मॉडल फ़ंक्शंस को बदलने का कोई तरीका हो लेकिन मैंने आगे की जांच करने की जहमत नहीं उठाई।

मेरा हो यह समाधान मददगार हो सकता है

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

यह स्टैक ओवरफ्लो उत्तर इसे इस तरह हल करता है:

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

संपादित करें: जैसा कि @DanielRamosAcosta द्वारा बताया गया है, "समस्या यह है कि यदि आपकी स्कीमा बदलती है, तो परिवर्तन प्रभावी नहीं होंगे।"

धन्यवाद @remicastaing , मैं आपके समाधान तक पहुंचने तक 5 मिनट खो चुका हूं, और अधिक स्पष्ट होना चाहिए :)

धन्यवाद @juanpabloaj , जिसने मेरे लिए काम किया

@gunar समस्या यह है कि यदि आपकी स्कीमा बदलती है, तो परिवर्तन प्रभावी नहीं होंगे।

@juanpabloaj धन्यवाद भाई!

मैं बस बदसूरत कोशिश/पकड़ बनाने के बजाय उपयोग करता हूं:

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

यह चर्चा वाकई शर्मनाक है
नेवले के वास्तविक लेखकों ने सही समाधान ( 1 और 2 ) दिया, फिर भी सभी अंगूठे गलत हैकी समाधानों पर चले गए।
वाकई शर्मनाक

@ tomyam1 , शायद इसलिए कि वे

कभी-कभी एक सुविधाजनक समाधान तकनीकी रूप से सही से बेहतर काम करता है :)

@tomyam1 किसी समस्या को हल करने में सहयोग करने में कुछ भी शर्मनाक नहीं है और मैं उन सभी का आभारी हूं जिन्होंने यहां समाधान पर अपना स्वयं का विचार पोस्ट किया है। विस्तार में जाने के बिना - मेरे मामले में, 'गलत हैकी' सुझावों में से एक ने पूरी तरह से काम किया है, और जिसे आप 'सही' समाधान कह रहे हैं, दोनों ने नहीं किया।

एक दूसरे की मदद करना शर्मनाक नहीं है। सभी को धन्यवाद जिन्होंने एक रचनात्मक पोस्ट की है।

खैर महोदय (गैरेथडाउन 44, फेगा), तो हम असहमत हैं।
अधिक स्पैम बनाने से बचने के लिए, कृपया इमोजी प्रतिक्रियाओं का उपयोग करें।

इस धागे को समेटने के लिए:

इस पृष्ठ में केवल तीन अलग-अलग समाधान हैं:

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. कनेक्शन पर मॉडल सहेजें।
   यह आधिकारिक समाधान है जो मोगोज़ के लेखकों द्वारा प्रस्तावित किया गया था।
   और फिर भी इसे लगभग पूरी तरह से अनदेखा कर दिया गया था। मेरे लिए यह शर्मनाक है।

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

@ tomyam1 - आप जो कह रहे हैं उससे सैद्धांतिक रूप से सहमत हैं। हालांकि निष्पक्ष होने के लिए समाधान दूसरे (हैकी) समाधान के दो साल बाद आया !!

मेरे मामले में मैंने नोडमोन समाधान चुना। जब मुझे एहसास हुआ कि क्या हो रहा था और जिस तरह से टेस्ट कोड को संरचित किया गया था, उसके लिए एक बड़े रिफैक्टरिंग की आवश्यकता होगी, जिसके लिए मेरे पास समय नहीं है। मुझे खुशी है कि नोडमॉन समाधान प्रस्तावित किया गया था और लोगों ने इसे +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 लिए एक फ़ंक्शन के रूप में वापस कर दें ("उपयोगकर्ता" को तर्क के साथ बदलें, और 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 बाहर किसी भी चीज़ की आवश्यकता नहीं है, यानी आपकी स्कीमा को फिर से परिभाषित नहीं करेगा।

परीक्षण करने का सबसे कुशल, सुरुचिपूर्ण, और समझने योग्य तरीका जो डीबी से कम से कम कनेक्शन बनाता है, अपने परीक्षण सूट के बाहर अपना कनेक्शन, स्कीमा और मॉडल सेट करना है।

प्रत्येक परीक्षण (मेरे लिए आवश्यक नहीं) से पहले एक मॉडल स्थापित करने के मेरे अन्य उदाहरण की तुलना में यह कोड बहुत DRY है।

निम्नलिखित परीक्षण सूट काम करता है:

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 ने अपने कनेक्शन, स्कीमा और मॉडल कैसे बनाए। मुझे नहीं पता था कि आप एक मॉडल को परिभाषित कर सकते हैं और इसे कई बार इस्तेमाल कर सकते हैं (obv। लेकिन...)

मैंने प्रलेखन का बिल्कुल पालन किया और एक मॉड्यूल बनाया जिसने स्कीमा को परिभाषित किया और एक मॉडल लौटाया।

इसका मतलब यह था कि अगर मुझे एक परीक्षण में इसकी आवश्यकता होती है, तो स्कीमा को कई बार फिर से परिभाषित किया जाएगा, क्योंकि यह उस मॉड्यूल को फिर से परिभाषित करता है जो स्कीमा को परिभाषित करता है। और स्कीमा की कई परिभाषाएँ कोई ब्यूनो नहीं हैं।

लोगों के समाधान (जो काम करते हैं, हालांकि कम कुशलता से) क्या आपने प्रत्येक परीक्षण से पहले एक नया कनेक्शन बनाया है और अक्सर प्रत्येक परीक्षण से पहले एक नया मॉडल बनाया है।

लेकिन एक साधारण समझ है कि:

• मोचा --वॉच 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();
      });
  });
});

हैप्पी मोंगोडबिंग।

यह कोड मेरे लिए काम करता है:

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