test/mocha/DB.test.js

   1 (function() {
   2     'use strict';
   3     var db = require('../../server/class/DB').instance;
   4     var chai = require('chai');
   5     var chaiAsPromised = require('chai-as-promised');
   6     chai.use(chaiAsPromised);
   7     var expect = chai.expect;
   8     chai.should();
   9
  10     describe('DB クラス', function() {
  11
  12         var constructor = `
  13         /**
  14         * createFile
  15         *
  16         * @param name
  17         * @param directory
  18         * @returns {promise}<保存したファイルのファイル名(uuid)をresolveする>
  19         */
  20         `;
  21         describe(constructor, function() {
  22             before(function() {
  23                 return db.init()
  24             });
  25             it('should return hello when call sayHello', function() {
  26                 expect(db.sayHello()).to.equal('hello');
  27             });
  28         });
  29
  30
  31         var getDirectoryParentId = `
  32         /**
  33         * getDirectoryParentId
  34         * ディレクトリのparentIdを取得する
  35         * @param name
  36         * @returns {promise} ディレクトリが存在すればresolve(uuid), しなければreject
  37         */
  38         `;
  39         describe(getDirectoryParentId, function() {
  40             before(function() {
  41                 return db.init()
  42                 .then(function() {
  43                     return db.test2();
  44                 });
  45             });
  46
  47             it('should be rejected when a directory does not exist', function() {
  48                 return db.getDirectoryParentId('hoge').should.be.rejectedWith(Error, '"hoge" directory doesn\'t exist.');
  49             });
  50             it('should be resolved when \'one\' exists', function() {
  51                 return expect(db.getDirectoryParentId('one')).to.eventually.include.members(['1f83f620-c1ed-11e5-9657-7942989daa00']);
  52             });
  53             it('should be rejected when \'two\' exists', function() {
  54                 return expect(db.getDirectoryParentId('two')).to.eventually.have.length(2);
  55             });
  56         });
  57
  58         var getDirectoryId = `
  59         /**
  60         * getDirectoryId
  61         * ディレクトリのfileIdを取得する
  62         * @param name
  63         * @returns {promise} ディレクトリが存在すればresolve(uuid), しなければreject
  64         */
  65         `;
  66         describe(getDirectoryId, function() {
  67             before(function() {
  68                 return db.init()
  69                 .then(function() {
  70                     return db.test2();
  71                 });
  72             });
  73             it('should be rejected when a directory does not exist', function() {
  74                 return db.getDirectoryId('hoge').should.be.rejectedWith(Error, '"hoge" directory doesn\'t exist.');
  75             });
  76             it('should be resolved when \'/\' exists', function() {
  77                 return expect(db.getDirectoryId('/')).to.eventually.include.members(['1f83f620-c1ed-11e5-9657-7942989daa00']);
  78             });
  79             it('should be rejected when \'two\' exists', function() {
  80                 return expect(db.getDirectoryId('two')).to.eventually.have.length(2);
  81             });
  82         });
  83
  84
  85         var getDirectory = `
  86         /**
  87         * getDirectory
  88         * ディレクトリの情報を取得する
  89         * @param name
  90         * @returns {promise} ディレクトリが存在すればresolve(obj), しなければreject
  91         */
  92         `;
  93         describe(getDirectory, function() {
  94             before(function() {
  95                 return db.init()
  96                 .then(function() {
  97                     return db.test2();
  98                 });
  99             });
 100
 101             it('should be rejected when a directory does not exist', function() {
 102                 return db.getDirectoryId('hoge').should.be.rejectedWith(Error, '"hoge" directory doesn\'t exist.');
 103             });
 104             it('should be resolved when \'/\' exists', function() {
 105                 return expect(db.getDirectory('/')).to.eventually.have.length(1);
 106             });
 107             it('should be rejected when \'two\' exists', function() {
 108                 return expect(db.getDirectory('two')).to.eventually.have.length(2);
 109             });
 110         });
 111
 112
 113         var existFile = `
 114         /**
 115         * existFile
 116         * 同一ディレクトリに同名のファイルが存在することを確かめる
 117         * @param {string}fileName
 118         * @param {string}parentDirectory
 119         * @returns {promise}
 120         */
 121         `;
 122         describe(existFile, function() {
 123             before(function() {
 124                 return db.init()
 125                 .then(function() {
 126                     return db.test1();
 127                 })
 128                 .then(function() {
 129                     return db.test2();
 130                 });
 131             });
 132
 133             it('should be rejected when does not exist same name file in a directory', function() {
 134                 return db.existFile('hogehoge.txt', '/').should.be.rejectedWith(Error, '"hogehoge.txt" does not exist in "/" directory.');
 135             });
 136             it('should be rejected when a directory does not exist', function() {
 137                 return db.existFile('hogehoge.txt', '/hoge').should.be.rejectedWith(Error, '"/hoge" directory doesn\'t exist.');
 138             });
 139             it('should be resolved when file exists in a directory', function() {
 140                 return expect(db.existFile('hogehoge.txt', '/one')).to.eventually.be.a('string');
 141             });
 142         });
 143
 144
 145
 146         var notExistFile = `
 147         /**
 148         * notExistFile
 149         * 同一ディレクトリに同名のファイルが存在しないことを確かめる
 150         * @param {string}fileName
 151         * @param {string}parentDirectory
 152         * @returns {promise}
 153         */
 154         `;
 155         describe(notExistFile, function() {
 156             before(function() {
 157                 return db.init()
 158                 .then(function() {
 159                     return db.test1();
 160                 })
 161                 .then(function() {
 162                     return db.test2();
 163                 });
 164             });
 165
 166             it('should be rejected when the same name file has already existed in directory(1)', function() {
 167                 return db.notExistFile('hoge.txt', '/').should.be.rejectedWith(Error, '"hoge.txt" has already existed in "/" directory.');
 168             });
 169             it('should be rejected when the same name file has already existed in directory(2)', function() {
 170                 return db.notExistFile('hogehoge.txt', '/one').should.be.rejectedWith(Error, '"hogehoge.txt" has already existed in "/one" directory.');
 171             });
 172             it('should be resolved when the same name file does not exist in directory', function() {
 173                 return expect(db.notExistFile('hoge.txt', '/one')).to.eventually.equal();
 174             });
 175         });
 176
 177         var existDirectory = `
 178         /**
 179         * existDirectory
 180         * ディレクトリが存在することを確認する
 181         * @param {string} directory ディレクトリの絶対パス
 182         * @returns {promise} ディレクトリが存在しなければresolve、すればreject
 183         */
 184         `;
 185         describe(existDirectory, function() {
 186             before(function() {
 187                 return db.init()
 188                 .then(function() {
 189                     return db.test2();
 190                 })
 191             });
 192
 193             it('should be rejected when does not exist directory(1)', function() {
 194                 return db.existDirectory('/one/two/four').should.be.rejectedWith(Error, '"/one/two/four" directory doesn\'t exist.');
 195             });
 196             it('should be rejected when does not exist directory(2)', function() {
 197                 return db.existDirectory('hoge').should.be.rejectedWith(Error, 'directory name should start "/" so that it is absolute path including root.');
 198             });
 199             it('should be resolved when exists directory(1)', function() {
 200                 return expect(db.existDirectory('/')).to.eventually.equal('1f83f620-c1ed-11e5-9657-7942989daa00');
 201             });
 202             it('should be resolved when exists directory(2)', function() {
 203                 return expect(db.existDirectory('/one')).to.eventually.be.a('string');
 204             });
 205             it('should be resolved when exists directory(3)', function() {
 206                 return expect(db.existDirectory('/one/two')).to.eventually.be.a('string');
 207             });
 208             it('should be rejected when call with no parameter', function() {
 209                 return db.existDirectory().should.be.rejectedWith(Error, 'parameter "directory" is undefined');
 210             });
 211         });
 212
 213
 214         var notExistDirectory = `
 215         /**
 216         * notExistDirectory
 217         * ディレクトリが存在しないことを確認する
 218         * @param {string} directory
 219         * @returns {promise} ディレクトリが存在すればresolve、存在しなければreject
 220         */
 221         `;
 222         describe(existDirectory, function() {
 223             before(function() {
 224                 return db.init()
 225                 .then(function() {
 226                     return db.test1();
 227                 })
 228                 .then(function() {
 229                     return db.test2();
 230                 });
 231             });
 232
 233             it('should be rejected when exists directory(1)', function() {
 234                 return db.notExistDirectory('/').should.be.rejectedWith(Error,'"/" directory exists.');
 235             });
 236             it('should be rejected when exists directory(2)', function() {
 237                 return db.notExistDirectory('/one').should.be.rejectedWith(Error,'"/one" directory exists.');
 238             });
 239             it('should be rejected when exists directory(3)', function() {
 240                 return db.notExistDirectory('/one/two').should.be.rejectedWith(Error,'"/one/two" directory exists.');
 241             });
 242             it('should be resolved(1)', function() {
 243                 return expect(db.notExistDirectory()).to.eventually.equal();
 244             });
 245             it('should be resolved(2)', function() {
 246                 return expect(db.notExistDirectory('hoge')).to.eventually.equal();
 247             });
 248         });
 249
 250
 251         var createFile = `
 252         /**
 253         * createFile
 254         *
 255         * @param name
 256         * @param directory
 257         * @returns {promise}<保存したファイルのファイル名(uuid)をresolveする>
 258         */
 259         `;
 260         describe(createFile, function() {
 261             before(function() {
 262                 return db.init()
 263                 .then(function() {
 264                     return db.test1();
 265                 })
 266                 .then(function() {
 267                     return db.createFile('tarou.txt', '/');
 268                 });
 269             });
 270
 271             it('should be rejected when "parentDirectory" doesn\'t exist', function() {
 272                 return db.createFile('hoge.txt', '/hoge').should.be.rejectedWith(Error, '"/hoge" directory doesn\'t exist.');
 273             });
 274             it('should be rejected when a file has already existed in a directory.', function() {
 275                 return db.createFile('hoge.txt', '/').should.be.rejectedWith(Error, '"hoge.txt" has already existed in "/" directory.');
 276             });
 277             it('should be resolved when file creation successed.', function() {
 278                 return expect(db.existFile('tarou.txt', '/')).to.eventually.be.a('string');
 279             });
 280             it('should be rejected(1)', function() {
 281                 return db.createFile().should.be.rejectedWith(Error, 'filename is required.');
 282             });
 283             it('should be rejected(2)', function() {
 284                 return db.createFile('hoge.txt', '').should.be.rejectedWith(Error, 'parameter "directory" is undefined');
 285             });
 286             it('should be rejected(3)', function() {
 287                 return db.createFile(null, '/').should.be.rejectedWith(Error, 'filename is required.');
 288             });
 289         });
 290
 291
 292         var removeFile = `
 293         /**
 294         * removeFile
 295         * ファイルを削除する
 296         * @param {string} fileName
 297         * @param {string} parentDirectory
 298         * @returns {promise} ファイル削除に成功すればresolve、失敗すればreject
 299         */
 300         `;
 301
 302         describe(removeFile, function() {
 303             before(function() {
 304                 return db.init()
 305                 .then(function() {
 306                     return db.test1();
 307                 });
 308             });
 309             it('should be resolved when removeFile() successed', function() {
 310                 return db.removeFile('hoge.txt', '/')
 311                 .then(function() {
 312                     return db.existFile('hoge.txt', '/')
 313                 })
 314                 .should.be.rejectedWith(Error, '"hoge.txt" does not exist in "/" directory.');
 315             });
 316         });
 317
 318
 319         var createDirectory = `
 320         /**
 321         * createFile
 322         *
 323         * @param directory
 324         * @returns {promise}
 325         */
 326         `;
 327         describe(createDirectory, function() {
 328             before(function() {
 329                 return db.init()
 330                 .then(function() {
 331                     return db.test1();
 332                 })
 333                 .then(function() {
 334                     return db.test2();
 335                 })
 336                 .then(function() {
 337                     return db.createDirectory('/one/hoge');
 338                 });
 339             });
 340
 341             it('should be rejected when directory has already existed', function() {
 342                 return db.createDirectory('/one/two').should.be.rejectedWith(Error, '"/one/two" directory exists.');
 343             });
 344             it('should be rejected when parent directory does not exist.', function() {
 345                 return db.createDirectory('/four/hoge').should.be.rejectedWith(Error, '"/four" directory doesn\'t exist.');
 346             });
 347             it('should be rejected when the same name file has already existed.', function() {
 348                 return db.createDirectory('/hoge.txt').should.be.rejectedWith(Error, '"hoge.txt" has already existed in "/" directory.');
 349             });
 350             it('should be rejected when the /one/hoge directory has already existed', function() {
 351                 return db.notExistDirectory('/one/hoge').should.be.rejectedWith(Error, '"/one/hoge" directory exists.');
 352             });
 353             it('should be rejected(1)', function() {
 354                 return db.createDirectory('hoge').should.be.rejectedWith(Error, 'directory name should start "/" so that it is absolute path including root.');
 355             });
 356             it('should be rejected(2)', function() {
 357                 return db.createDirectory().should.be.rejectedWith(Error, 'directory name should start "/" so that it is absolute path including root.');
 358             });
 359         });
 360
 361         var getFiles = `
 362         /**
 363         * getFiles
 364         * ディレクトリのfileIdを取得する
 365         * @param {string} fileId ディレクトリのfileId
 366         * @returns {promise} resolve([Array]<string>fileId) 引数で与えられたディレクトリを直接の親に持つファイルのレコードの配列を返す。
 367         */
 368         `;
 369         describe(createDirectory, function() {
 370             before(function() {
 371                 return db.init()
 372                 .then(function() {
 373                     return db.test1();
 374                 })
 375                 .then(function() {
 376                     return db.test2();
 377                 });
 378             });
 379
 380             it('should be rejected when calling with invalid fileId', function() {
 381                 return db.getFiles('').should.be.rejected;
 382             });
 383             it('should be resolved(1)', function() {
 384                 return expect(db.getFiles('1f83f620-c1ed-11e5-9657-7942989daa00')).to.eventually.be.an('array');
 385             });
 386             it('should be resolved(2)', function() {
 387                 return expect(db.getFiles('1f83f620-c1ed-11e5-9657-7942989daa04')).to.eventually.be.length(2);
 388             });
 389         });
 390
 391         var getDirectories = `
 392         /**
 393         * getDirectories
 394         * ディレクトリのfileIdを取得する
 395         * @param {string} fileId ディレクトリのfileId
 396         * @returns {promise} resolve([Array]<string>fileId) 引数で与えられたディレクトリを直接の親に持つファイルのレコードの配列を返す。
 397         */
 398         `;
 399         describe(createDirectory, function() {
 400             before(function() {
 401                 return db.init()
 402                 .then(function() {
 403                     return db.test1();
 404                 })
 405                 .then(function() {
 406                     return db.test2();
 407                 });
 408             });
 409
 410             it('should be resolved', function() {
 411                 return expect(db.getDirectories()).to.eventually.be.length(4);
 412             });
 413         });
 414
 415     });
 416 })();