| 1 |
|
| 2 |
|
| 3 | var { HelperMongo } = require("../../dist/index")
|
| 4 | var connStr = "sh_test"
|
| 5 | var helperMongo = new HelperMongo(connStr, true);
|
| 6 | var mongojs = require('mongojs')
|
| 7 | var db = mongojs(connStr)
|
| 8 | var moment = require("moment")
|
| 9 |
|
| 10 | var should = require("chai").should()
|
| 11 |
|
| 12 | var userColl = "users"
|
| 13 | var diffHour = -5.5
|
| 14 |
|
| 15 | describe("HelperMongo", () => {
|
| 16 |
|
| 17 | beforeEach((done) => {
|
| 18 | db.collection(userColl).remove({}, done)
|
| 19 | })
|
| 20 |
|
| 21 | after(function (done) {
|
| 22 | this.timeout(5000);
|
| 23 | db.dropDatabase(done)
|
| 24 | })
|
| 25 |
|
| 26 | describe("#getDateFormat()", () => {
|
| 27 |
|
| 28 | beforeEach(done => {
|
| 29 | db.collection(userColl).remove({}, done)
|
| 30 | })
|
| 31 |
|
| 32 | it("should return Year format", (done) => {
|
| 33 | var date = new Date()
|
| 34 | var user = {
|
| 35 | name: 'Akash',
|
| 36 | cTime: date
|
| 37 | }
|
| 38 |
|
| 39 | db.collection(userColl).insert(user, function (err, result) {
|
| 40 | if (result) {
|
| 41 | db.collection(userColl).aggregate([{
|
| 42 | $project: {
|
| 43 | year: {
|
| 44 | $dateToString: {
|
| 45 | format: helperMongo.getDateFormat("year"),
|
| 46 | date: "$cTime"
|
| 47 | }
|
| 48 | }
|
| 49 | }
|
| 50 | }], function (err, result) {
|
| 51 | result.should.be.an("array")
|
| 52 | result.length.should.be.eql(1)
|
| 53 | result[0].year.should.be.eql(moment(date).add(diffHour, 'hour').format("YYYY"))
|
| 54 | done()
|
| 55 | })
|
| 56 | } else {
|
| 57 | console.log("Failed to Insert User in should return Year format");
|
| 58 | done("Failed to insert User in should return Year format")
|
| 59 | }
|
| 60 | })
|
| 61 | })
|
| 62 | it("should return Month format", (done) => {
|
| 63 | var date = new Date()
|
| 64 | var user = {
|
| 65 | name: 'Akash',
|
| 66 | cTime: date
|
| 67 | }
|
| 68 |
|
| 69 | db.collection(userColl).insert(user, function (err, result) {
|
| 70 | if (result) {
|
| 71 | db.collection(userColl).aggregate([{
|
| 72 | $project: {
|
| 73 | year: {
|
| 74 | $dateToString: {
|
| 75 | format: helperMongo.getDateFormat("month"),
|
| 76 | date: "$cTime"
|
| 77 | }
|
| 78 | }
|
| 79 | }
|
| 80 | }], function (err, result) {
|
| 81 | result.should.be.an("array")
|
| 82 | result.length.should.be.eql(1)
|
| 83 | result[0].year.should.be.eql(moment(date).add(diffHour, 'hour').format("YYYY-MM"))
|
| 84 | done()
|
| 85 | })
|
| 86 | } else {
|
| 87 | console.log("Failed to Insert User in should return Month format");
|
| 88 | done("Failed to insert User in should return Month format")
|
| 89 | }
|
| 90 | })
|
| 91 | })
|
| 92 | it("should return Day format", (done) => {
|
| 93 | var date = new Date();
|
| 94 | var user = {
|
| 95 | name: 'Akash',
|
| 96 | cTime: date
|
| 97 | }
|
| 98 |
|
| 99 | db.collection(userColl).insert(user, function (err, result) {
|
| 100 | if (result) {
|
| 101 | db.collection(userColl).aggregate([{
|
| 102 | $project: {
|
| 103 | year: {
|
| 104 | $dateToString: {
|
| 105 | format: helperMongo.getDateFormat("day"),
|
| 106 | date: "$cTime"
|
| 107 | }
|
| 108 | }
|
| 109 | }
|
| 110 | }], function (err, result) {
|
| 111 | result.should.be.an("array")
|
| 112 | result.length.should.be.eql(1)
|
| 113 | result[0].year.should.be.eql(moment(date).add(diffHour, 'hour').format("YYYY-MM-DD"))
|
| 114 | done()
|
| 115 | })
|
| 116 | } else {
|
| 117 | console.log("Failed to Insert User in should return Day format");
|
| 118 | done("Failed to insert User in should return Day format")
|
| 119 | }
|
| 120 | })
|
| 121 | })
|
| 122 | it("should return Hour format", (done) => {
|
| 123 | var date = new Date();
|
| 124 | var user = {
|
| 125 | name: 'Akash',
|
| 126 | cTime: date
|
| 127 | }
|
| 128 |
|
| 129 | db.collection(userColl).insert(user, function (err, result) {
|
| 130 | if (result) {
|
| 131 | db.collection(userColl).aggregate([{
|
| 132 | $project: {
|
| 133 | year: {
|
| 134 | $dateToString: {
|
| 135 | format: helperMongo.getDateFormat("hour"),
|
| 136 | date: "$cTime"
|
| 137 | }
|
| 138 | }
|
| 139 | }
|
| 140 | }], function (err, result) {
|
| 141 | result.should.be.an("array")
|
| 142 | result.length.should.be.eql(1)
|
| 143 | result[0].year.should.be.eql(moment(date).add(diffHour, 'hour').format("YYYY-MM-DDTHH"))
|
| 144 | done()
|
| 145 | })
|
| 146 | } else {
|
| 147 | console.log("Failed to Insert User in should return Hour format");
|
| 148 | done("Failed to insert User in should return Hour format")
|
| 149 | }
|
| 150 | })
|
| 151 | })
|
| 152 | it("should return Minute format", (done) => {
|
| 153 | var date = new Date();
|
| 154 | var user = {
|
| 155 | name: 'Akash',
|
| 156 | cTime: date
|
| 157 | }
|
| 158 |
|
| 159 | db.collection(userColl).insert(user, function (err, result) {
|
| 160 | if (result) {
|
| 161 | db.collection(userColl).aggregate([{
|
| 162 | $project: {
|
| 163 | year: {
|
| 164 | $dateToString: {
|
| 165 | format: helperMongo.getDateFormat("min"),
|
| 166 | date: "$cTime"
|
| 167 | }
|
| 168 | }
|
| 169 | }
|
| 170 | }], function (err, result) {
|
| 171 | result.should.be.an("array")
|
| 172 | result.length.should.be.eql(1)
|
| 173 | result[0].year.should.be.eql(moment(date).add(diffHour, 'hour').format("YYYY-MM-DDTHH:mm"))
|
| 174 | done()
|
| 175 | })
|
| 176 | } else {
|
| 177 | console.log("Failed to Insert User in should return Minute format");
|
| 178 | done("Failed to insert User in should return Minute format")
|
| 179 | }
|
| 180 | })
|
| 181 | })
|
| 182 | it("should return Second format", (done) => {
|
| 183 | var date = new Date();
|
| 184 | var user = {
|
| 185 | name: 'Akash',
|
| 186 | cTime: date
|
| 187 | }
|
| 188 |
|
| 189 | db.collection(userColl).insert(user, function (err, result) {
|
| 190 | if (result) {
|
| 191 | db.collection(userColl).aggregate([{
|
| 192 | $project: {
|
| 193 | year: {
|
| 194 | $dateToString: {
|
| 195 | format: helperMongo.getDateFormat("sec"),
|
| 196 | date: "$cTime"
|
| 197 | }
|
| 198 | }
|
| 199 | }
|
| 200 | }], function (err, result) {
|
| 201 | result.should.be.an("array")
|
| 202 | result.length.should.be.eql(1)
|
| 203 | result[0].year.should.be.eql(moment(date).add(diffHour, 'hour').format("YYYY-MM-DDTHH:mm:ss"))
|
| 204 | done()
|
| 205 | })
|
| 206 | } else {
|
| 207 | console.log("Failed to Insert User in should return Second format");
|
| 208 | done("Failed to insert User in should return Second format")
|
| 209 | }
|
| 210 | })
|
| 211 | })
|
| 212 | it("should return Millisecond format", (done) => {
|
| 213 | var date = new Date();
|
| 214 | var user = {
|
| 215 | name: 'Akash',
|
| 216 | cTime: date
|
| 217 | }
|
| 218 |
|
| 219 | db.collection(userColl).insert(user, function (err, result) {
|
| 220 | if (result) {
|
| 221 | db.collection(userColl).aggregate([{
|
| 222 | $project: {
|
| 223 | year: {
|
| 224 | $dateToString: {
|
| 225 | format: helperMongo.getDateFormat("milli"),
|
| 226 | date: "$cTime"
|
| 227 | }
|
| 228 | }
|
| 229 | }
|
| 230 | }], function (err, result) {
|
| 231 | result.should.be.an("array")
|
| 232 | result.length.should.be.eql(1)
|
| 233 | result[0].year.should.be.eql(moment(date).add(diffHour, 'hour').format("YYYY-MM-DDTHH:mm:ss.SSS"))
|
| 234 | done()
|
| 235 | })
|
| 236 | } else {
|
| 237 | console.log("Failed to Insert User in should return MilliSecond format");
|
| 238 | done("Failed to insert User in should return MilliSecond format")
|
| 239 | }
|
| 240 | })
|
| 241 | })
|
| 242 | it("should return Day format by default", (done) => {
|
| 243 | var date = new Date();
|
| 244 | var user = {
|
| 245 | name: 'Akash',
|
| 246 | cTime: date
|
| 247 | }
|
| 248 |
|
| 249 | db.collection(userColl).insert(user, function (err, result) {
|
| 250 | if (result) {
|
| 251 | db.collection(userColl).aggregate([{
|
| 252 | $project: {
|
| 253 | year: {
|
| 254 | $dateToString: {
|
| 255 | format: helperMongo.getDateFormat("asdf"),
|
| 256 | date: "$cTime"
|
| 257 | }
|
| 258 | }
|
| 259 | }
|
| 260 | }], function (err, result) {
|
| 261 | result.should.be.an("array")
|
| 262 | result.length.should.be.eql(1)
|
| 263 | result[0].year.should.be.eql(moment(date).add(diffHour, 'hour').format("YYYY-MM-DD"))
|
| 264 | done()
|
| 265 | })
|
| 266 | } else {
|
| 267 | console.log("Failed to Insert User in should return day format by default");
|
| 268 | done("Failed to insert User in should return day format by default")
|
| 269 | }
|
| 270 | })
|
| 271 | })
|
| 272 | })
|
| 273 |
|
| 274 | describe("#validateExistence()", () => {
|
| 275 | it("should return true if atleast one document was found for the given query", done => {
|
| 276 | var data = {
|
| 277 | name: "test"
|
| 278 | }
|
| 279 | db.collection("validateExistenceColl").insert(data, (err, result) => {
|
| 280 | if (result) {
|
| 281 | helperMongo.validateExistence("validateExistenceColl", { name: "test" }, (err, result) => {
|
| 282 |
|
| 283 | should.not.exist(err);
|
| 284 | result.should.be.ok;
|
| 285 |
|
| 286 | done()
|
| 287 | })
|
| 288 | } else {
|
| 289 | console.warn("Unable to insert data to test validateExistence")
|
| 290 | }
|
| 291 | })
|
| 292 | })
|
| 293 | })
|
| 294 |
|
| 295 | describe("#validateNonExistence()", () => {
|
| 296 | it("should return true if there was no document found for the given query", (done) => {
|
| 297 | helperMongo.validateNonExistence('validateNonExistence1', { name: 'test' }, (err, result) => {
|
| 298 | should.not.exist(err)
|
| 299 | result.should.be.ok;
|
| 300 |
|
| 301 | done()
|
| 302 | })
|
| 303 | })
|
| 304 | it("should return 'Duplicate Document' if there was a document found for the given query and no Err Msg was specified", (done) => {
|
| 305 | var data = {
|
| 306 | name: 'test'
|
| 307 | }
|
| 308 | db.collection('validateNonExistence2').insert(data, (err, result) => {
|
| 309 | if (!err) {
|
| 310 | helperMongo.validateNonExistence('validateNonExistence2', { name: 'test' }, (err1, result1) => {
|
| 311 | should.exist(err1);
|
| 312 | err1.should.be.eql("Duplicate Document")
|
| 313 | should.not.exist(result1)
|
| 314 | done()
|
| 315 | })
|
| 316 |
|
| 317 | } else {
|
| 318 | console.error('Failed to insert data in validateNonExistence');
|
| 319 |
|
| 320 | done(err);
|
| 321 | }
|
| 322 | })
|
| 323 | })
|
| 324 | it("should return errMsg if atleast one document was found for the given query and errMsg was given", (done) => {
|
| 325 | var data = {
|
| 326 | name: 'test'
|
| 327 | }
|
| 328 | db.collection('validateNonExistence').insert(data, (err, result) => {
|
| 329 | if (!err) {
|
| 330 | helperMongo.validateNonExistence('validateNonExistence', {
|
| 331 | query: { name: 'test' },
|
| 332 | errMsg: "Duplicate Name"
|
| 333 | }, (err1, result1) => {
|
| 334 | should.exist(err1);
|
| 335 | err1.should.be.eql("Duplicate Name")
|
| 336 | should.not.exist(result1)
|
| 337 | done()
|
| 338 | })
|
| 339 |
|
| 340 | } else {
|
| 341 | console.error('Failed to insert data in validateNonExistence');
|
| 342 | done(err);
|
| 343 | }
|
| 344 | })
|
| 345 | })
|
| 346 | it("should iterate through all the validations", done => {
|
| 347 | var data1 = {
|
| 348 | name: 'test1',
|
| 349 | checking: 'validations',
|
| 350 | type: "multi"
|
| 351 | }
|
| 352 | var data2 = {
|
| 353 | name: 'test2',
|
| 354 | checking: 'validations',
|
| 355 | type: "multi"
|
| 356 | }
|
| 357 |
|
| 358 | db.collection('validateNonExistence').insert([data1, data2], (err, result) => {
|
| 359 | if (!err) {
|
| 360 | let validations = [
|
| 361 | {
|
| 362 | query: {
|
| 363 | name: 'test3'
|
| 364 | },
|
| 365 | errMsg: "Duplicate Name"
|
| 366 | }, {
|
| 367 | query: {
|
| 368 | checking: 'validations',
|
| 369 | type: 'multi'
|
| 370 | },
|
| 371 | errMsg: 'Duplicate Methods'
|
| 372 | }
|
| 373 | ]
|
| 374 | helperMongo.validateNonExistence('validateNonExistence', validations, (err, result) => {
|
| 375 | should.exist(err);
|
| 376 | should.not.exist(result);
|
| 377 | err.should.be.eql("Duplicate Methods")
|
| 378 |
|
| 379 | done()
|
| 380 | })
|
| 381 | } else {
|
| 382 | console.error("Failed to insert into validateNonExistence")
|
| 383 |
|
| 384 | done(err);
|
| 385 | }
|
| 386 | })
|
| 387 | })
|
| 388 | })
|
| 389 |
|
| 390 | describe("#validateNonExistenceOnUpdate()", () => {
|
| 391 | it("should validate _id for a valid mongo id", (done) => {
|
| 392 | helperMongo.validateNonExistenceOnUpdate('validateNonExistenceOnUpdate1', { _id: "asdf" }, {}, (err, result) => {
|
| 393 | should.exist(err);
|
| 394 | err.should.be.eql("Invalid Id");
|
| 395 |
|
| 396 | done()
|
| 397 | })
|
| 398 | })
|
| 399 | it("should return corresponding errMsg or 'Duplicate Document' if a document with the query is already present", (done) => {
|
| 400 | var data1 = {
|
| 401 | name: "test1",
|
| 402 | checking: 'validateNonExistenceOnUpdate'
|
| 403 | }
|
| 404 | var data2 = {
|
| 405 | name: "test2",
|
| 406 | checking: 'validateNonExistenceOnUpdate'
|
| 407 | }
|
| 408 | db.collection("validateNonExistenceOnUpdate2").insert([data1, data2], (err, result) => {
|
| 409 |
|
| 410 | if (!err) {
|
| 411 | var validations = [
|
| 412 | {
|
| 413 | name: "name"
|
| 414 | }
|
| 415 | ]
|
| 416 | result[0].name = 'test2'
|
| 417 | helperMongo.validateNonExistenceOnUpdate('validateNonExistenceOnUpdate2', result[0], validations, (err, result) => {
|
| 418 | should.exist(err);
|
| 419 | err.should.be.eql("Duplicate name");
|
| 420 | result.should.be.eql(1)
|
| 421 |
|
| 422 | done()
|
| 423 | })
|
| 424 |
|
| 425 | } else {
|
| 426 | console.error('Failed to insert into validateNonExistenceOnUpdate2')
|
| 427 | done(err);
|
| 428 | }
|
| 429 | })
|
| 430 | })
|
| 431 | it("should iterate over the validations only for the fields which have been changed wrt the ones present in DB", (done) => {
|
| 432 | var data1 = {
|
| 433 | name: "test1",
|
| 434 | checking: 'validateNonExistenceOnUpdate'
|
| 435 | }
|
| 436 | var data2 = {
|
| 437 | name: "test2",
|
| 438 | checking: 'validateNonExistenceOnUpdate'
|
| 439 | }
|
| 440 | db.collection("validateNonExistenceOnUpdate3").insert([data1, data2], (err, result) => {
|
| 441 |
|
| 442 | if (!err) {
|
| 443 | var validations = [
|
| 444 | {
|
| 445 | name: "name"
|
| 446 | }, {
|
| 447 | name: "checking"
|
| 448 | }
|
| 449 | ]
|
| 450 | result[0].name = 'test3'
|
| 451 | helperMongo.validateNonExistenceOnUpdate('validateNonExistenceOnUpdate3', result[0], validations, (err, result) => {
|
| 452 | should.not.exist(err);
|
| 453 | result.should.be.eql(1);
|
| 454 |
|
| 455 | done()
|
| 456 | })
|
| 457 |
|
| 458 | } else {
|
| 459 | console.error('Failed to insert into validateNonExistenceOnUpdate3')
|
| 460 | done(err)
|
| 461 | }
|
| 462 | })
|
| 463 | })
|
| 464 | it("should use query if present else form a query based on the name field given", (done) => {
|
| 465 | var data = [{
|
| 466 | name: 'test1'
|
| 467 | }, {
|
| 468 | name: 'test2'
|
| 469 | }]
|
| 470 | db.collection('validateNonExistenceOnUpdate4').insert(data, (err, result) => {
|
| 471 | if (!err) {
|
| 472 | result[0].name = 'test2'
|
| 473 | var validations = [
|
| 474 | {
|
| 475 | name: "name",
|
| 476 | query: {
|
| 477 | name: 'test2'
|
| 478 | },
|
| 479 | errMsg: "Customised Error"
|
| 480 | }
|
| 481 | ]
|
| 482 | helperMongo.validateNonExistenceOnUpdate('validateNonExistenceOnUpdate4', result[0], validations, (err, result) => {
|
| 483 | should.exist(err);
|
| 484 | err.should.be.eql("Customised Error");
|
| 485 | result.should.be.eql(1);
|
| 486 |
|
| 487 | done()
|
| 488 | })
|
| 489 | } else {
|
| 490 | console.log('Failed to insert into validateNonExistenceOnUpdate4');
|
| 491 |
|
| 492 | done(err);
|
| 493 | }
|
| 494 | })
|
| 495 | })
|
| 496 | })
|
| 497 |
|
| 498 | describe("#getById()", () => {
|
| 499 | it("should return 'Invalid Id' if a invalid Mongo Id is passed", (done) => {
|
| 500 | helperMongo.getById("getById1", "asdf", (err, result) => {
|
| 501 | should.exist(err)
|
| 502 | err.should.be.eql("Invalid Id")
|
| 503 |
|
| 504 | done();
|
| 505 | })
|
| 506 | })
|
| 507 | it("should return the document if a document is present for the given _id", (done) => {
|
| 508 | var data = {
|
| 509 | name: 'test'
|
| 510 | }
|
| 511 | db.collection("getById2").insert(data, (err, result) => {
|
| 512 | if (!err) {
|
| 513 | helperMongo.getById("getById2", result._id, (err, result1) => {
|
| 514 | should.not.exist(err);
|
| 515 | result1._id.should.be.eql(result._id);
|
| 516 | result1.name.should.be.eql(result.name);
|
| 517 |
|
| 518 | done();
|
| 519 | })
|
| 520 | } else {
|
| 521 | console.error('Failed to insert into getById2');
|
| 522 | done(err);
|
| 523 | }
|
| 524 | })
|
| 525 | })
|
| 526 | })
|
| 527 |
|
| 528 | describe("#getMaxValue()", () => {
|
| 529 | it("should find the max value of a field in a collection", (done) => {
|
| 530 | var data = [{
|
| 531 | num: 1
|
| 532 | }, {
|
| 533 | num: 2
|
| 534 | }, {
|
| 535 | num: 10
|
| 536 | }]
|
| 537 |
|
| 538 | db.collection("getMaxValue1").insert(data, (err, result) => {
|
| 539 | if (!err) {
|
| 540 | var maxQuery = {
|
| 541 | query: {
|
| 542 | num: { $exists: true }
|
| 543 | },
|
| 544 | key: 'num'
|
| 545 | }
|
| 546 | helperMongo.getMaxValue('getMaxValue1', maxQuery, (err, result) => {
|
| 547 | should.not.exist(err);
|
| 548 | result.should.be.eql(10);
|
| 549 | done();
|
| 550 | })
|
| 551 | } else {
|
| 552 | console.error('Failed to insert into getMaxValue1');
|
| 553 | done(err);
|
| 554 | }
|
| 555 | })
|
| 556 | })
|
| 557 | it("should find the max value within a document array", (done) => {
|
| 558 | var data = [{
|
| 559 | name: 'test1',
|
| 560 | arr: [
|
| 561 | {
|
| 562 | num: 1
|
| 563 | }, {
|
| 564 | num: 2
|
| 565 | }, {
|
| 566 | num: 10
|
| 567 | }
|
| 568 | ]
|
| 569 | }]
|
| 570 |
|
| 571 | db.collection("getMaxValue2").insert(data, (err) => {
|
| 572 | if (!err) {
|
| 573 | var maxQuery = {
|
| 574 | query: {
|
| 575 | name: 'test1'
|
| 576 | },
|
| 577 | unwind: '$arr',
|
| 578 | key: 'arr.num'
|
| 579 | }
|
| 580 | helperMongo.getMaxValue("getMaxValue2", maxQuery, (err, result) => {
|
| 581 | should.not.exist(err);
|
| 582 | result.should.be.eql(10);
|
| 583 |
|
| 584 | done()
|
| 585 | })
|
| 586 | } else {
|
| 587 | console.error('Failed to insert into getMaxValue2');
|
| 588 | done(err)
|
| 589 | }
|
| 590 | })
|
| 591 | })
|
| 592 | })
|
| 593 |
|
| 594 | describe("#getNextSeqNo()", () => {
|
| 595 | it("should get Next sequence no for the given collection on the specified key", (done) => {
|
| 596 | var data = [
|
| 597 | {
|
| 598 | num: 1
|
| 599 | }, {
|
| 600 | num: 2
|
| 601 | }, {
|
| 602 | num: 10
|
| 603 | },
|
| 604 | ]
|
| 605 | db.collection("getNextSeqNo1").insert(data, (err) => {
|
| 606 | if (!err) {
|
| 607 | var nextSeqQuery = {
|
| 608 |
|
| 609 | key: 'num'
|
| 610 | }
|
| 611 | helperMongo.getNextSeqNo('getNextSeqNo1', nextSeqQuery, (err, result) => {
|
| 612 | should.not.exist(err);
|
| 613 | result.should.be.eql(11);
|
| 614 |
|
| 615 | done()
|
| 616 | })
|
| 617 | } else {
|
| 618 | console.error('Failed to insert into getNextSeqNo1');
|
| 619 | done(err);
|
| 620 | }
|
| 621 | })
|
| 622 | })
|
| 623 | it("should get next sequence no within the given maxValue", (done) => {
|
| 624 | var data = [
|
| 625 | {
|
| 626 | num: 1
|
| 627 | }, {
|
| 628 | num: 2
|
| 629 | }, {
|
| 630 | num: 10
|
| 631 | },
|
| 632 | ]
|
| 633 | db.collection("getNextSeqNo2").insert(data, (err) => {
|
| 634 | if (!err) {
|
| 635 | var nextSeqQuery = {
|
| 636 |
|
| 637 | key: 'num',
|
| 638 | maxValue: 11
|
| 639 | }
|
| 640 | helperMongo.getNextSeqNo('getNextSeqNo2', nextSeqQuery, (err, result) => {
|
| 641 | should.not.exist(err);
|
| 642 | result.should.be.eql(11);
|
| 643 |
|
| 644 | done()
|
| 645 | })
|
| 646 | } else {
|
| 647 | console.error('Failed to insert into getNextSeqNo2');
|
| 648 | done(err);
|
| 649 | }
|
| 650 | })
|
| 651 | })
|
| 652 | it("should check for next sequence no from the minValue if the maxValue has been crossed", (done) => {
|
| 653 | var data = [
|
| 654 | {
|
| 655 | num: 1
|
| 656 | }, {
|
| 657 | num: 2
|
| 658 | }, {
|
| 659 | num: 10
|
| 660 | },
|
| 661 | ]
|
| 662 | db.collection("getNextSeqNo3").insert(data, (err) => {
|
| 663 | if (!err) {
|
| 664 | var nextSeqQuery = {
|
| 665 |
|
| 666 | key: 'num',
|
| 667 | maxValue: 10
|
| 668 | }
|
| 669 | helperMongo.getNextSeqNo('getNextSeqNo3', nextSeqQuery, (err, result) => {
|
| 670 | should.not.exist(err);
|
| 671 | result.should.be.eql(3);
|
| 672 |
|
| 673 | done()
|
| 674 | })
|
| 675 | } else {
|
| 676 | console.error('Failed to insert into getNextSeqNo3');
|
| 677 | done(err);
|
| 678 | }
|
| 679 | })
|
| 680 | })
|
| 681 | it("should return errMsg if there is no seq remaining within the maxValue", (done) => {
|
| 682 | var data = [
|
| 683 | {
|
| 684 | num: 1
|
| 685 | }, {
|
| 686 | num: 2
|
| 687 | }, {
|
| 688 | num: 3
|
| 689 | },
|
| 690 | ]
|
| 691 | db.collection("getNextSeqNo4").insert(data, (err) => {
|
| 692 | if (!err) {
|
| 693 | var nextSeqQuery = {
|
| 694 |
|
| 695 | key: 'num',
|
| 696 | maxValue: 3,
|
| 697 | minValue: 1
|
| 698 | }
|
| 699 | helperMongo.getNextSeqNo('getNextSeqNo4', nextSeqQuery, (err, result) => {
|
| 700 | should.exist(err);
|
| 701 | err.should.be.eql("Could not Get Next Sequence Number")
|
| 702 |
|
| 703 | done()
|
| 704 | })
|
| 705 | } else {
|
| 706 | console.error('Failed to insert into getNextSeqNo4');
|
| 707 | done(err);
|
| 708 | }
|
| 709 | })
|
| 710 | })
|
| 711 | it("should return given errMsg if there is no seq remaining within the maxValue", (done) => {
|
| 712 | var data = [
|
| 713 | {
|
| 714 | num: 1
|
| 715 | }, {
|
| 716 | num: 2
|
| 717 | }, {
|
| 718 | num: 3
|
| 719 | },
|
| 720 | ]
|
| 721 | db.collection("getNextSeqNo5").insert(data, (err) => {
|
| 722 | if (!err) {
|
| 723 | var nextSeqQuery = {
|
| 724 |
|
| 725 | key: 'num',
|
| 726 | maxValue: 3,
|
| 727 | minValue: 1,
|
| 728 | errMsg: "No SeqNo Available"
|
| 729 | }
|
| 730 | helperMongo.getNextSeqNo('getNextSeqNo5', nextSeqQuery, (err, result) => {
|
| 731 | should.exist(err);
|
| 732 | err.should.be.eql("No SeqNo Available")
|
| 733 |
|
| 734 | done()
|
| 735 | })
|
| 736 | } else {
|
| 737 | console.error('Failed to insert into getNextSeqNo5');
|
| 738 | done(err);
|
| 739 | }
|
| 740 | })
|
| 741 | })
|
| 742 | it("should be able to create a next seq no within a doc array", (done) => {
|
| 743 | var data = [
|
| 744 | {
|
| 745 | name: 'test',
|
| 746 | arr: [
|
| 747 | {
|
| 748 | num: 1
|
| 749 | }, {
|
| 750 | num: 2
|
| 751 | }, {
|
| 752 | num: 3
|
| 753 | }, {
|
| 754 | num: 10
|
| 755 | },
|
| 756 | ]
|
| 757 | }
|
| 758 | ]
|
| 759 | db.collection("getNextSeqNo6").insert(data, (err, result) => {
|
| 760 | if (!err) {
|
| 761 | var maxQuery = {
|
| 762 | query: { name: 'test' },
|
| 763 | unwind: 'arr',
|
| 764 | key: 'arr.num',
|
| 765 | maxValue: 10,
|
| 766 | minValue: 1
|
| 767 | }
|
| 768 | helperMongo.getNextSeqNo('getNextSeqNo6', maxQuery, (err, result) => {
|
| 769 | should.not.exist(err);
|
| 770 | result.should.be.eql(4);
|
| 771 |
|
| 772 | done();
|
| 773 | })
|
| 774 | } else {
|
| 775 | console.error('Failed to insert into getNextSeqNo6');
|
| 776 | done(err);
|
| 777 | }
|
| 778 | })
|
| 779 | })
|
| 780 | })
|
| 781 |
|
| 782 | describe("#update()", () => {
|
| 783 | it("should validate the given _id in the document", (done) => {
|
| 784 | helperMongo.update("update1", { _id: 'asdf' }, (err, result) => {
|
| 785 | should.exist(err);
|
| 786 | err.should.be.eql("Invalid Id");
|
| 787 |
|
| 788 | done();
|
| 789 | })
|
| 790 | })
|
| 791 | it("should update all the specified field for the given document", (done) => {
|
| 792 | var data = {
|
| 793 | name: 'test'
|
| 794 | }
|
| 795 | db.collection("update2").insert(data, (err, result) => {
|
| 796 | if (!err) {
|
| 797 |
|
| 798 | result.name = 'test1'
|
| 799 | helperMongo.update('update2', result, (err, result1) => {
|
| 800 |
|
| 801 | should.not.exist(err);
|
| 802 | result1.should.be.an("object");
|
| 803 | result1.n.should.be.eql(1);
|
| 804 |
|
| 805 | db.collection("update2").findOne(result, (err, result2) => {
|
| 806 | if (!err) {
|
| 807 | should.exist(result2);
|
| 808 | result2.should.be.an("object");
|
| 809 | result2.name.should.be.eql("test1");
|
| 810 |
|
| 811 | done();
|
| 812 | } else {
|
| 813 | console.error('Failed to get doc in update2');
|
| 814 | done(err);
|
| 815 | }
|
| 816 | })
|
| 817 | })
|
| 818 | } else {
|
| 819 | console.error('Failed to insert into update2');
|
| 820 | done(err);
|
| 821 | }
|
| 822 | })
|
| 823 | })
|
| 824 | it("should update the utime field on the updated document", (done) => {
|
| 825 | var data = {
|
| 826 | name: 'test'
|
| 827 | }
|
| 828 | db.collection('update3').insert(data, (err, result) => {
|
| 829 | if (!err) {
|
| 830 | helperMongo.update('update3', result, (err, result1) => {
|
| 831 | should.not.exist(err);
|
| 832 | result1.should.be.an("object");
|
| 833 | result1.n.should.be.eql(1);
|
| 834 |
|
| 835 | db.collection("update3").findOne(result, (err, result2) => {
|
| 836 | should.not.exist(err);
|
| 837 | result2.should.be.an("object");
|
| 838 | should.exist(result2.utime);
|
| 839 |
|
| 840 | done()
|
| 841 | })
|
| 842 | })
|
| 843 | } else {
|
| 844 | console.error('Failed to insert into update3');
|
| 845 | done(err);
|
| 846 | }
|
| 847 | })
|
| 848 | })
|
| 849 | })
|
| 850 |
|
| 851 | describe("#getList()", () => {
|
| 852 | it("should fetch all the document in the collection if recordsPerPage is not specified", (done) => {
|
| 853 | var data = [
|
| 854 | {
|
| 855 | name: 'test1'
|
| 856 | }, {
|
| 857 | name: 'test2'
|
| 858 | }, {
|
| 859 | name: 'test3'
|
| 860 | }
|
| 861 | ]
|
| 862 | db.collection('getList1').insert(data, (err, result) => {
|
| 863 | if (!err) {
|
| 864 | helperMongo.getList("getList1", {}, (err, result1) => {
|
| 865 | should.not.exist(err);
|
| 866 | result1.should.be.an("object");
|
| 867 | result1.count.should.be.eql(3);
|
| 868 | result1.list.length.should.be.eql(3);
|
| 869 |
|
| 870 | done();
|
| 871 | })
|
| 872 | } else {
|
| 873 | console.error('Failed to insert into getList1');
|
| 874 | done(err);
|
| 875 | }
|
| 876 | })
|
| 877 | })
|
| 878 | it("should fetch documents for the given query", (done) => {
|
| 879 | var data = [
|
| 880 | {
|
| 881 | name: 'test1',
|
| 882 | show: true,
|
| 883 | }, {
|
| 884 | name: 'test2',
|
| 885 | show: true
|
| 886 | }, {
|
| 887 | name: 'test3'
|
| 888 | }
|
| 889 | ]
|
| 890 | db.collection('getList2').insert(data, (err, result) => {
|
| 891 | if (!err) {
|
| 892 | helperMongo.getList("getList2", {
|
| 893 | query: {
|
| 894 | show: true
|
| 895 | }
|
| 896 | }, (err, result1) => {
|
| 897 | should.not.exist(err);
|
| 898 | result1.should.be.an("object");
|
| 899 | result1.count.should.be.eql(2);
|
| 900 | result1.list.length.should.be.eql(2);
|
| 901 |
|
| 902 | done();
|
| 903 | })
|
| 904 | } else {
|
| 905 | console.error('Failed to insert into getList2');
|
| 906 | done(err);
|
| 907 | }
|
| 908 | })
|
| 909 | })
|
| 910 | it("should project only the specified fields", (done) => {
|
| 911 | var data = [
|
| 912 | {
|
| 913 | name: 'test1'
|
| 914 | }, {
|
| 915 | name: 'test2'
|
| 916 | }, {
|
| 917 | name: 'test3'
|
| 918 | }
|
| 919 | ]
|
| 920 | db.collection('getList3').insert(data, (err, result) => {
|
| 921 | if (!err) {
|
| 922 | helperMongo.getList("getList3", {
|
| 923 | project: { name: 1, _id: 0 },
|
| 924 | }, (err, result1) => {
|
| 925 | should.not.exist(err);
|
| 926 | result1.should.be.an("object");
|
| 927 | result1.count.should.be.eql(3);
|
| 928 | result1.list.length.should.be.eql(3);
|
| 929 |
|
| 930 | done();
|
| 931 | })
|
| 932 | } else {
|
| 933 | console.error('Failed to insert into getList3');
|
| 934 | done(err);
|
| 935 | }
|
| 936 | })
|
| 937 | })
|
| 938 | it("shoud sort the document", (done) => {
|
| 939 | var data = [
|
| 940 | {
|
| 941 | name: 'test1'
|
| 942 | }, {
|
| 943 | name: 'test2'
|
| 944 | }, {
|
| 945 | name: 'test3'
|
| 946 | }
|
| 947 | ]
|
| 948 | db.collection('getList4').insert(data, (err, result) => {
|
| 949 | if (!err) {
|
| 950 | helperMongo.getList("getList4", {
|
| 951 | project: { name: 1, _id: 0 },
|
| 952 | sort: { name: -1 }
|
| 953 | }, (err, result1) => {
|
| 954 | should.not.exist(err);
|
| 955 | result1.should.be.an("object");
|
| 956 | result1.count.should.be.eql(3);
|
| 957 | result1.list.length.should.be.eql(3);
|
| 958 | result1.list[0].name.should.be.eql("test3")
|
| 959 | result1.list[1].name.should.be.eql("test2")
|
| 960 | result1.list[2].name.should.be.eql("test1")
|
| 961 |
|
| 962 | done();
|
| 963 | })
|
| 964 | } else {
|
| 965 | console.error('Failed to insert into getList4');
|
| 966 | done(err);
|
| 967 | }
|
| 968 | })
|
| 969 | })
|
| 970 | it("should perform search query on searchField", (done) => {
|
| 971 | var data = [
|
| 972 | {
|
| 973 | name: 'test1'
|
| 974 | }, {
|
| 975 | name: 'test2'
|
| 976 | }, {
|
| 977 | name: 'test3'
|
| 978 | }, {
|
| 979 | name: 'asdf1'
|
| 980 | }
|
| 981 | ]
|
| 982 | db.collection('getList5').insert(data, (err, result) => {
|
| 983 | if (!err) {
|
| 984 | helperMongo.getList("getList5", {
|
| 985 | search: 'test',
|
| 986 | searchField: 'name'
|
| 987 | }, (err, result1) => {
|
| 988 | should.not.exist(err);
|
| 989 | result1.should.be.an("object");
|
| 990 | result1.count.should.be.eql(3);
|
| 991 | result1.list.length.should.be.eql(3);
|
| 992 | var names = ['test1', 'test2', 'test3']
|
| 993 | result1.list.forEach((res) => {
|
| 994 | names.indexOf(res.name).should.not.eql(-1)
|
| 995 | })
|
| 996 |
|
| 997 | done();
|
| 998 | })
|
| 999 | } else {
|
| 1000 | console.error('Failed to insert into getList1');
|
| 1001 | done(err);
|
| 1002 | }
|
| 1003 | })
|
| 1004 | })
|
| 1005 | it("should return the required pageNo documents", (done) => {
|
| 1006 | var data = [
|
| 1007 | {
|
| 1008 | name: 'test1'
|
| 1009 | }, {
|
| 1010 | name: 'test2'
|
| 1011 | }, {
|
| 1012 | name: 'test3'
|
| 1013 | }
|
| 1014 | ]
|
| 1015 | db.collection('getList6').insert(data, (err, result) => {
|
| 1016 | if (!err) {
|
| 1017 | helperMongo.getList("getList6", {
|
| 1018 | sort: { name: 1 },
|
| 1019 | pageNo: 2,
|
| 1020 | recordsPerPage: 2
|
| 1021 | }, (err, result1) => {
|
| 1022 | should.not.exist(err);
|
| 1023 | result1.should.be.an("object");
|
| 1024 | result1.count.should.be.eql(3);
|
| 1025 | result1.list.length.should.be.eql(1);
|
| 1026 | result1.list[0].name.should.be.eql("test3")
|
| 1027 |
|
| 1028 | done();
|
| 1029 | })
|
| 1030 | } else {
|
| 1031 | console.error('Failed to insert into getList6');
|
| 1032 | done(err);
|
| 1033 | }
|
| 1034 | })
|
| 1035 | })
|
| 1036 | it("should JSON.parse the query object if its a string", (done) => {
|
| 1037 | var data = [
|
| 1038 | {
|
| 1039 | name: 'test1'
|
| 1040 | }, {
|
| 1041 | name: 'test2'
|
| 1042 | }, {
|
| 1043 | name: 'test3'
|
| 1044 | }
|
| 1045 | ]
|
| 1046 | db.collection('getList7').insert(data, (err, result) => {
|
| 1047 | if (!err) {
|
| 1048 | helperMongo.getList("getList7", {
|
| 1049 | project: JSON.stringify({ name: 1, _id: 0 }),
|
| 1050 | sort: JSON.stringify({ name: -1 })
|
| 1051 | }, (err, result1) => {
|
| 1052 | should.not.exist(err);
|
| 1053 | result1.should.be.an("object");
|
| 1054 | result1.count.should.be.eql(3);
|
| 1055 | result1.list.length.should.be.eql(3);
|
| 1056 | result1.list[0].name.should.be.eql("test3")
|
| 1057 | result1.list[1].name.should.be.eql("test2")
|
| 1058 | result1.list[2].name.should.be.eql("test1")
|
| 1059 |
|
| 1060 | done();
|
| 1061 | })
|
| 1062 | } else {
|
| 1063 | console.error('Failed to insert into getList7');
|
| 1064 | done(err);
|
| 1065 | }
|
| 1066 | })
|
| 1067 | })
|
| 1068 | it("should sort the document even if the format is 'name'/'-name'", (done) => {
|
| 1069 | var data = [
|
| 1070 | {
|
| 1071 | name: 'test1'
|
| 1072 | }, {
|
| 1073 | name: 'test2'
|
| 1074 | }, {
|
| 1075 | name: 'test3'
|
| 1076 | }
|
| 1077 | ]
|
| 1078 | db.collection('getList8').insert(data, (err, result) => {
|
| 1079 | if (!err) {
|
| 1080 | helperMongo.getList("getList8", {
|
| 1081 | project: { name: 1, _id: 0 },
|
| 1082 | sort: '-name'
|
| 1083 | }, (err, result1) => {
|
| 1084 | should.not.exist(err);
|
| 1085 | result1.should.be.an("object");
|
| 1086 | result1.count.should.be.eql(3);
|
| 1087 | result1.list.length.should.be.eql(3);
|
| 1088 | result1.list[0].name.should.be.eql("test3")
|
| 1089 | result1.list[1].name.should.be.eql("test2")
|
| 1090 | result1.list[2].name.should.be.eql("test1")
|
| 1091 |
|
| 1092 | done();
|
| 1093 | })
|
| 1094 | } else {
|
| 1095 | console.error('Failed to insert into getList8');
|
| 1096 | done(err);
|
| 1097 | }
|
| 1098 | })
|
| 1099 | })
|
| 1100 | })
|
| 1101 |
|
| 1102 | describe("#remove()", () => {
|
| 1103 | it("should validate the given id", (done) => {
|
| 1104 | helperMongo.remove("remove1", "asdf", true, (err) => {
|
| 1105 | should.exist(err);
|
| 1106 | err.should.be.eql("Invalid Id")
|
| 1107 |
|
| 1108 | done();
|
| 1109 | })
|
| 1110 | })
|
| 1111 | it("should remove the document matching the given id", (done) => {
|
| 1112 | var data = {
|
| 1113 | name: 'test'
|
| 1114 | }
|
| 1115 | db.collection('remove2').insert(data, (err, result) => {
|
| 1116 | if (!err) {
|
| 1117 | helperMongo.remove("remove2", result._id, true, (err, result1) => {
|
| 1118 | should.not.exist(err);
|
| 1119 |
|
| 1120 | db.collection('remove2').findOne({ _id: result._id }, (err, result2) => {
|
| 1121 | should.not.exist(err);
|
| 1122 | should.not.exist(result2);
|
| 1123 |
|
| 1124 | done();
|
| 1125 | })
|
| 1126 | })
|
| 1127 | } else {
|
| 1128 | console.error('Failed to insert into remove2');
|
| 1129 | done(err)
|
| 1130 | }
|
| 1131 | })
|
| 1132 | })
|
| 1133 | it("should set isDeleted on the document for the given id", (done) => {
|
| 1134 | var data = {
|
| 1135 | name: 'test'
|
| 1136 | }
|
| 1137 | db.collection('remove3').insert(data, (err, result) => {
|
| 1138 | if (!err) {
|
| 1139 | helperMongo.remove("remove3", result._id, false, (err, result1) => {
|
| 1140 | should.not.exist(err);
|
| 1141 |
|
| 1142 | db.collection('remove3').findOne({ _id: result._id }, (err, result2) => {
|
| 1143 | should.not.exist(err);
|
| 1144 | result2.should.be.an("object");
|
| 1145 | result2.isDeleted.should.be.ok;
|
| 1146 | should.exist(result2.deltime)
|
| 1147 |
|
| 1148 | done();
|
| 1149 | })
|
| 1150 | })
|
| 1151 | } else {
|
| 1152 | console.error('Failed to insert into remove3');
|
| 1153 | done(err)
|
| 1154 | }
|
| 1155 | })
|
| 1156 | })
|
| 1157 | })
|
| 1158 |
|
| 1159 | describe.skip("#splitTimeThenGrp()", () => {
|
| 1160 | it("should split the given time into required slot and pick one point from each")
|
| 1161 | })
|
| 1162 |
|
| 1163 | describe("#selectNinM()", () => {
|
| 1164 | it("should select N points from M points, given that N < M", (done) => {
|
| 1165 | var data = [];
|
| 1166 | for (var i = 0; i < 100; i++) {
|
| 1167 | data.push({
|
| 1168 | name: 'test' + i,
|
| 1169 | num: i
|
| 1170 | })
|
| 1171 | }
|
| 1172 |
|
| 1173 | db.collection("selectNinM1").insert(data, (err, result) => {
|
| 1174 | if (!err) {
|
| 1175 | var obj = {
|
| 1176 | numOfPoints: 10,
|
| 1177 | groupLogic: '$first',
|
| 1178 | project: ['name', 'num'],
|
| 1179 | query: {}
|
| 1180 | }
|
| 1181 | helperMongo.selectNinM('selectNinM1', obj, (err, result1) => {
|
| 1182 |
|
| 1183 | should.not.exist(err);
|
| 1184 | result1.should.be.an('array');
|
| 1185 | result1.length.should.be.eql(obj.numOfPoints);
|
| 1186 |
|
| 1187 | done()
|
| 1188 | })
|
| 1189 | } else {
|
| 1190 | console.error('Failed to insert into selectNinM1');
|
| 1191 | done(err);
|
| 1192 | }
|
| 1193 | })
|
| 1194 | })
|
| 1195 | })
|
| 1196 | })
|