app.js

global.__base = __dirname + '/';
let express = require('express');
let path = require('path');
let favicon = require('serve-favicon');
let logger = require('morgan');
let cookieParser = require('cookie-parser');
let bodyParser = require('body-parser');
let validator = require('express-validator');

let index = require('./routes/index');
let users = require('./routes/users');

let app = express();

// view engine setup
app.set('views', path.join(__dirname, 'views'));
app.set('view engine', 'jade');

// uncomment after placing your favicon in /public
//app.use(favicon(path.join(__dirname, 'public', 'favicon.ico')));
app.use(logger('dev'));
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: false }));
app.use(validator());

app.use(cookieParser());

app.use(express.static(path.join(__dirname, 'public')));

///////Routes///////
app.get('/', function(req, res) {
  res.render('email', function(err, html) {
    if (err) {
      // log any error to the console for debug
      console.log(err);
    }
    else {
      //no error, so send the html to the browser
      res.send(html)
    }
  });
});
app.use('/user', require('./core/user').router);

///////Routes///////


// catch 404 and forward to error handler
app.use(function(req, res, next) {
  let err = new Error('Not Found');
  err.status = 404;
  next(err);
});

// error handler
app.use(function(err, req, res, next) {
  // set locals, only providing error in development
  res.locals.message = err.message;
  res.locals.error = req.app.get('env') === 'development' ? err : {};

  // render the error page
  res.status(err.status || 500);
  res.render('error');
});

module.exports = app;

bin_www

#!/usr/bin/env node

/**
 * Module dependencies.
 */

let app = require('../app');
let debug = require('debug')('maroon-lab-node:server');
let http = require('http');
let io = require('socket.io')(http);
/**
 * Get port from environment and store in Express.
 */

let port = normalizePort(process.env.PORT || '3000');
app.set('port', port);

/**
 * Create HTTP server.
 */

let server = http.createServer(app);


let mongo = require('../database');

mongo.init().then(
    function () {
        console.log('connected to db');

        server.listen(port);
        io.listen(server);
        io.on('connection', function (socket) {
            console.log("got a connection");

            socket.on('hi', function () {
                console.log('got hi');
            });

            socket.on('disconnect', function () {
                console.log('dis');
            });

        });
        server.on('error', onError);
        server.on('listening', onListening);

    }
);






/**
 * Normalize a port into a number, string, or false.
 */

function normalizePort(val) {
  let port = parseInt(val, 10);

  if (isNaN(port)) {
    // named pipe
    return val;
  }

  if (port >= 0) {
    // port number
    return port;
  }

  return false;
}

/**
 * Event listener for HTTP server "error" event.
 */

function onError(error) {
  if (error.syscall !== 'listen') {
    throw error;
  }

  let bind = typeof port === 'string'
    ? 'Pipe ' + port
    : 'Port ' + port;

  // handle specific listen errors with friendly messages
  switch (error.code) {
    case 'EACCES':
      console.error(bind + ' requires elevated privileges');
      process.exit(1);
      break;
    case 'EADDRINUSE':
      console.error(bind + ' is already in use');
      process.exit(1);
      break;
    default:
      throw error;
  }
}

/**
 * Event listener for HTTP server "listening" event.
 */

function onListening() {
  let addr = server.address();
  let bind = typeof addr === 'string'
    ? 'pipe ' + addr
    : 'port ' + addr.port;
  debug('Listening on ' + bind);
}
exports = module.exports = app;

database.js

let mongodb = require('mongodb');
// console.log(mongodb.MongoClient);

module.exports.init = function () {
    "use strict";


    return new Promise(function (resolve, reject) {
        let MongoClient = mongodb.MongoClient;
        MongoClient.connect("mongodb://localhost/test", function (err, dba) {
            if (err != null) {
                console.log(err.message);
                return reject(err);
            }

            module.exports.MongoClient = MongoClient;
            module.exports.db = dba;
            module.exports.ObjectID = mongodb.ObjectID;
            console.log(new mongodb.ObjectID());
            return resolve();

        });
    });
};

want_to_do.example

let chai = require('chai');
let chaiHttp = require('chai-http');
let server = require('../../bin/www');

let group = require('../../core/group/model');
let Joi = require('joi');
let should = chai.should();
let ObjectID = require(__base + 'database');

console.log("oiD");
console.log(ObjectID);
// console.log(__base);


describe("Group model", function () {



    it('should add a dummy group to database, and overwrite the _id field', function (done) {
        // console.log(new ObjectID());
        // console.log(ObjectID);

        let testGroup = new group({name: 'bleh', admin: "me",users:[{
            _id: new ObjectID(),
        },{
            _id:new ObjectID(),
            isAdmina:false
        }]});

        testGroup.save().then(function (data) {
            // data.should.have.all.keys(['name', '_id']);
            done();
        }).catch(function (err) {
            done(err);

        });
    });

    it("should check for validation of group schema", function (done) {

        const schema = Joi.object().keys({
            name: Joi.string().required(),
            users: Joi.array().required().items(Joi.object().keys({
                    _id: Joi.required(),
                    isAdmin: Joi.boolean(),
                })
            )
        });


        let testGroup = {
            name: 'my name',
            users: [{_id: '134fasdf',isAdmin:true}]

        };
        console.log(Joi.validate(testGroup, schema,{stripUnknown:true}).value);

        should.equal(Joi.validate(testGroup, schema,{stripUnknown:undefined}).error,null);
        done();


    })


});