Seeding mongoose data models with references.

seed.js

var chai   = require('chai'),
sinon  = require('sinon'),
expect = chai.expect,
should = chai.should();

var mongoose = require('mongoose');
// var assert = require('assert');
var Studio = require('studioModel');
var User = require('userModel');

var UserSeed = require('userSeed');
var StudioSeed = require('studioSeed');

var config   = require('./config/database');
mongoose.connect(config.db.test);


// Add promise function to mongoose create.
mongoose.Model.seed = function(entities) {
  var promise = new mongoose.Promise;
  this.create(entities, function(err) {
    if(err) { promise.reject(err); }
    else    { promise.resolve(); }
  });
  return promise;
};

// The basic idea is to generate a list of ObjectIDs for user ids and then use 
// the same list to generate the users list and studios list.
userIds = UserSeed.getUserIds();

userData = UserSeed.generateUsers(userIds);

studioData = StudioSeed.generateStudios(userIds);



after(function(done) {
  mongoose.disconnect();
  return done();
});

// original source http://frederiknakstad.com/2013/04/12/seeding-mongodb-through-your-mongoose-models/
// before/after for the entire test suite.
before(function(done) {

  // Reset collections
  User.remove().exec()
  .then(function() {
    return Studio.remove().exec()
  })

  // Seed
  .then(function() {
    return User.seed(userData);
  })
  .then(function() {
    return Studio.seed(studioData);
  })

  // Finito!
  .then(function() {
    done();
  }, function(err) {
    return done(err);
  });

  // ...
});


// Basic tests.
describe('User and Studio data', function() {
  it('should have inserted 30 users', function(done) {
    Studio.find({}, function(err, studios) {
      if(err) return done(err);

      studios.should.have.length(30);
      done();
    });
  });
});

describe('Studio Seeds', function() {
  it('should have inserted 30 studios', function(done) {
    Studio.find({}, function(err, studios) {
      if(err) done(err);

      studios.should.have.length(30);
      done();
    });
  });

  it('should have studios', function(done) {
    Studio.find({}, function(err, studios) {
      if(err) return done(err);

      should.exist(studios);
      done();
    });
  });

  it('should have a reference to a user for the _owner field', function(done) {
    Studio.findOne({}, function(err, studio) {
      if(err) return done(err);

      should.exist(userIds.indexOf(studio._owner.toString()) > -1);
      done();
    });
  });
});

studioModel.js

// .models/studio.js
var mongoose = require('mongoose');

var Schema = mongoose.Schema;

// Studio schema
// TODO: add slug route based on name. https://github.com/larvit/larvitslugify
var studioSchema = new Schema({
  name               : { type: String, default: '', trim: true },
  description        : { type: String,
              default: 'A studio for artists to colloaborate together',
              trim   : true
            },
  date_created       : {type: Date, default: Date.now()},
  comments           : [{
    body             : { type: String, default: ''},
    user             : { type: Schema.Types.ObjectId, ref: 'User'},
    date_created     : { type: Date, default: Date.now()}
  }],
  collections        : [{type: Schema.Types.ObjectId, ref: 'Collection'}],
  _owner              : { type: Schema.Types.ObjectId, ref: 'User'},
  _members            : [{
    user             : {type: Schema.Types.ObjectId, ref: 'User'},
    join_date        : {type: Date, default: Date.now()}
  }],
  private            : {type: Boolean, default: false},
});

module.exports = mongoose.model('Studio', studioSchema);

studioSeed.js

// jshint esversion: 6
// ./test/models/studio.js

var faker = require('faker');
var mongoose = require('mongoose');
var Studio = require('studioSeed');

function generateStudios(userIds) {
  var studios = [];

  for(var i = 0; i < userIds.length; i++) {

    // get random num for user
    var random = Math.floor(Math.random() * userIds.length);

    studio =
    {
      name               : faker.company.companyName(),
      description        : faker.lorem.paragraph(),
      date_created       : faker.date.recent(),
      comments           : [{
        body             : faker.lorem.sentences(),
        user             : mongoose.Types.ObjectId(userIds[random]),
        date_created     : faker.date.recent(),
      }],
      _owner              : mongoose.Types.ObjectId(userIds[i]),
      private            : false,
    };
    studios.push(studio);
  }
  // console.log(studios[0]);
  return studios;
}

module.exports = {
  generateStudios: generateStudios
};

userModel.js

// ./models/user.js
// load required libraries.
var mongoose = require('mongoose');
var bcrypt   = require('bcryptjs');
var Schema = mongoose.Schema;
// User Schema
var userSchema = new Schema({
  local             : {
    username        : String,
    email           : String,
    password        : String,
  },
  facebook          : {
    id              : String,
    token           : String,
    email           : String,
    name            : String,
  },
  twitter           : {
    id              : String,
    token           : String,
    displayName     : String,
    username        : String,
  },
  google            : {
    id              : String,
    token           : String,
    email           : String,
    name            : String,
  }
});

// create model for users via mongoose.
module.exports = mongoose.model('User', userSchema);

userSeed.js

// jshint esversion: 6
// ./test/models/user.js

var mongoose = require('mongoose');
var User = require('userModel');
var faker = require('faker');


// Generate users and return an array of users in json format.
// accepts a geneated list of ids(that can be used by other, dependent models)
function generateUsers(idArr){
  var userSeeds = [];

  for(var i = 0; i < idArr.length; i++) {
    var user =
    {
      _id: idArr[i],
      local             : {
        username        : faker.internet.userName(),
        email           : faker.internet.email(),
        password        : faker.internet.password()
      }
    }

    userSeeds.push(user);
  }
  return userSeeds;
}

// get the seeded users ids.
function getUserIds(arr) {
  idArray = [];
  for (var i = 0; i < 30; i++) {
    idArray.push(new mongoose.Types.ObjectId());
  }
  return idArray;
}

module.exports = {
  generateUsers: generateUsers,
  getUserIds: getUserIds
};