org.simantics.maps.server/node/node-v4.8.0-win-x64/node_modules/npm/test/tap/access.js

   1 var fs = require('fs')
   2 var path = require('path')
   3 var mkdirp = require('mkdirp')
   4 var rimraf = require('rimraf')
   5 var mr = require('npm-registry-mock')
   6
   7 var test = require('tap').test
   8 var common = require('../common-tap.js')
   9
  10 var pkg = path.resolve(__dirname, 'access')
  11 var server
  12
  13 var scoped = {
  14   name: '@scoped/pkg',
  15   version: '1.1.1'
  16 }
  17
  18 test('setup', function (t) {
  19   mkdirp(pkg, function (er) {
  20     t.ifError(er, pkg + ' made successfully')
  21
  22     mr({port: common.port}, function (err, s) {
  23       t.ifError(err, 'registry mocked successfully')
  24       server = s
  25
  26       fs.writeFile(
  27         path.join(pkg, 'package.json'),
  28         JSON.stringify(scoped),
  29         function (er) {
  30           t.ifError(er, 'wrote package.json')
  31           t.end()
  32         }
  33       )
  34     })
  35   })
  36 })
  37
  38 test('npm access public on current package', function (t) {
  39   server.post('/-/package/%40scoped%2Fpkg/access', JSON.stringify({
  40     access: 'public'
  41   })).reply(200, {
  42     accessChanged: true
  43   })
  44   common.npm([
  45     'access',
  46     'public',
  47     '--registry', common.registry,
  48     '--loglevel', 'silent'
  49   ], {
  50     cwd: pkg
  51   },
  52   function (er, code, stdout, stderr) {
  53     t.ifError(er, 'npm access')
  54     t.equal(code, 0, 'exited OK')
  55     t.equal(stderr, '', 'no error output')
  56     t.end()
  57   })
  58 })
  59
  60 test('npm access public when no package passed and no package.json', function (t) {
  61   // need to simulate a missing package.json
  62   var missing = path.join(__dirname, 'access-public-missing-guard')
  63   mkdirp.sync(path.join(missing, 'node_modules'))
  64
  65   common.npm([
  66     'access',
  67     'public',
  68     '--registry', common.registry
  69   ], {
  70     cwd: missing
  71   },
  72   function (er, code, stdout, stderr) {
  73     t.ifError(er, 'npm access')
  74     t.match(stderr, /no package name passed to command and no package.json found/)
  75     rimraf.sync(missing)
  76     t.end()
  77   })
  78 })
  79
  80 test('npm access public when no package passed and invalid package.json', function (t) {
  81   // need to simulate a missing package.json
  82   var invalid = path.join(__dirname, 'access-public-invalid-package')
  83   mkdirp.sync(path.join(invalid, 'node_modules'))
  84   // it's hard to force `read-package-json` to break w/o ENOENT, but this will do it
  85   fs.writeFileSync(path.join(invalid, 'package.json'), '{\n')
  86
  87   common.npm([
  88     'access',
  89     'public',
  90     '--registry', common.registry
  91   ], {
  92     cwd: invalid
  93   },
  94   function (er, code, stdout, stderr) {
  95     t.ifError(er, 'npm access')
  96     t.match(stderr, /Failed to parse json/)
  97     rimraf.sync(invalid)
  98     t.end()
  99   })
 100 })
 101
 102 test('npm access restricted on current package', function (t) {
 103   server.post('/-/package/%40scoped%2Fpkg/access', JSON.stringify({
 104     access: 'restricted'
 105   })).reply(200, {
 106     accessChanged: true
 107   })
 108   common.npm([
 109     'access',
 110     'restricted',
 111     '--registry', common.registry,
 112     '--loglevel', 'silent'
 113   ], {
 114     cwd: pkg
 115   },
 116   function (er, code, stdout, stderr) {
 117     t.ifError(er, 'npm access')
 118     t.equal(code, 0, 'exited OK')
 119     t.equal(stderr, '', 'no error output')
 120     t.end()
 121   })
 122 })
 123
 124 test('npm access on named package', function (t) {
 125   server.post('/-/package/%40scoped%2Fanother/access', {
 126     access: 'public'
 127   }).reply(200, {
 128     accessChaged: true
 129   })
 130   common.npm(
 131     [
 132       'access',
 133       'public', '@scoped/another',
 134       '--registry', common.registry,
 135       '--loglevel', 'silent'
 136     ],
 137     { cwd: pkg },
 138     function (er, code, stdout, stderr) {
 139       t.ifError(er, 'npm access')
 140       t.equal(code, 0, 'exited OK')
 141       t.equal(stderr, '', 'no error output')
 142
 143       t.end()
 144     }
 145   )
 146 })
 147
 148 test('npm change access on unscoped package', function (t) {
 149   common.npm(
 150     [
 151       'access',
 152       'restricted', 'yargs',
 153       '--registry', common.registry
 154     ],
 155     { cwd: pkg },
 156     function (er, code, stdout, stderr) {
 157       t.ok(code, 'exited with Error')
 158       t.matches(
 159         stderr, /access commands are only accessible for scoped packages/)
 160       t.end()
 161     }
 162   )
 163 })
 164
 165 test('npm access grant read-only', function (t) {
 166   server.put('/-/team/myorg/myteam/package', {
 167     permissions: 'read-only',
 168     package: '@scoped/another'
 169   }).reply(201, {
 170     accessChaged: true
 171   })
 172   common.npm(
 173     [
 174       'access',
 175       'grant', 'read-only',
 176       'myorg:myteam',
 177       '@scoped/another',
 178       '--registry', common.registry
 179     ],
 180     { cwd: pkg },
 181     function (er, code, stdout, stderr) {
 182       t.ifError(er, 'npm access grant')
 183       t.equal(code, 0, 'exited with Error')
 184       t.end()
 185     }
 186   )
 187 })
 188
 189 test('npm access grant read-write', function (t) {
 190   server.put('/-/team/myorg/myteam/package', {
 191     permissions: 'read-write',
 192     package: '@scoped/another'
 193   }).reply(201, {
 194     accessChaged: true
 195   })
 196   common.npm(
 197     [
 198       'access',
 199       'grant', 'read-write',
 200       'myorg:myteam',
 201       '@scoped/another',
 202       '--registry', common.registry
 203     ],
 204     { cwd: pkg },
 205     function (er, code, stdout, stderr) {
 206       t.ifError(er, 'npm access grant')
 207       t.equal(code, 0, 'exited with Error')
 208       t.end()
 209     }
 210   )
 211 })
 212
 213 test('npm access grant others', function (t) {
 214   common.npm(
 215     [
 216       'access',
 217       'grant', 'rerere',
 218       'myorg:myteam',
 219       '@scoped/another',
 220       '--registry', common.registry
 221     ],
 222     { cwd: pkg },
 223     function (er, code, stdout, stderr) {
 224       t.ok(code, 'exited with Error')
 225       t.matches(stderr, /read-only/)
 226       t.matches(stderr, /read-write/)
 227       t.end()
 228     }
 229   )
 230 })
 231
 232 test('npm access revoke', function (t) {
 233   server.delete('/-/team/myorg/myteam/package', {
 234     package: '@scoped/another'
 235   }).reply(200, {
 236     accessChaged: true
 237   })
 238   common.npm(
 239     [
 240       'access',
 241       'revoke',
 242       'myorg:myteam',
 243       '@scoped/another',
 244       '--registry', common.registry
 245     ],
 246     { cwd: pkg },
 247     function (er, code, stdout, stderr) {
 248       t.ifError(er, 'npm access grant')
 249       t.equal(code, 0, 'exited with Error')
 250       t.end()
 251     }
 252   )
 253 })
 254
 255 test('npm access ls-packages with no team', function (t) {
 256   var serverPackages = {
 257     '@foo/bar': 'write',
 258     '@foo/util': 'read'
 259   }
 260   var clientPackages = {
 261     '@foo/bar': 'read-write',
 262     '@foo/util': 'read-only'
 263   }
 264   server.get(
 265     '/-/org/username/package?format=cli'
 266   ).reply(200, serverPackages)
 267   common.npm(
 268     [
 269       'access',
 270       'ls-packages',
 271       '--registry', common.registry
 272     ],
 273     { cwd: pkg },
 274     function (er, code, stdout, stderr) {
 275       t.ifError(er, 'npm access ls-packages')
 276       t.same(JSON.parse(stdout), clientPackages)
 277       t.end()
 278     }
 279   )
 280 })
 281
 282 test('npm access ls-packages on team', function (t) {
 283   var serverPackages = {
 284     '@foo/bar': 'write',
 285     '@foo/util': 'read'
 286   }
 287   var clientPackages = {
 288     '@foo/bar': 'read-write',
 289     '@foo/util': 'read-only'
 290   }
 291   server.get(
 292     '/-/team/myorg/myteam/package?format=cli'
 293   ).reply(200, serverPackages)
 294   common.npm(
 295     [
 296       'access',
 297       'ls-packages',
 298       'myorg:myteam',
 299       '--registry', common.registry
 300     ],
 301     { cwd: pkg },
 302     function (er, code, stdout, stderr) {
 303       t.ifError(er, 'npm access ls-packages')
 304       t.same(JSON.parse(stdout), clientPackages)
 305       t.end()
 306     }
 307   )
 308 })
 309
 310 test('npm access ls-packages on org', function (t) {
 311   var serverPackages = {
 312     '@foo/bar': 'write',
 313     '@foo/util': 'read'
 314   }
 315   var clientPackages = {
 316     '@foo/bar': 'read-write',
 317     '@foo/util': 'read-only'
 318   }
 319   server.get(
 320     '/-/org/myorg/package?format=cli'
 321   ).reply(200, serverPackages)
 322   common.npm(
 323     [
 324       'access',
 325       'ls-packages',
 326       'myorg',
 327       '--registry', common.registry
 328     ],
 329     { cwd: pkg },
 330     function (er, code, stdout, stderr) {
 331       t.ifError(er, 'npm access ls-packages')
 332       t.same(JSON.parse(stdout), clientPackages)
 333       t.end()
 334     }
 335   )
 336 })
 337
 338 test('npm access ls-packages on user', function (t) {
 339   var serverPackages = {
 340     '@foo/bar': 'write',
 341     '@foo/util': 'read'
 342   }
 343   var clientPackages = {
 344     '@foo/bar': 'read-write',
 345     '@foo/util': 'read-only'
 346   }
 347   server.get(
 348     '/-/org/myorg/package?format=cli'
 349   ).reply(404, {error: 'nope'})
 350   server.get(
 351     '/-/user/myorg/package?format=cli'
 352   ).reply(200, serverPackages)
 353   common.npm(
 354     [
 355       'access',
 356       'ls-packages',
 357       'myorg',
 358       '--registry', common.registry
 359     ],
 360     { cwd: pkg },
 361     function (er, code, stdout, stderr) {
 362       t.ifError(er, 'npm access ls-packages')
 363       t.same(JSON.parse(stdout), clientPackages)
 364       t.end()
 365     }
 366   )
 367 })
 368
 369 test('npm access ls-packages with no package specified or package.json', function (t) {
 370   // need to simulate a missing package.json
 371   var missing = path.join(__dirname, 'access-missing-guard')
 372   mkdirp.sync(path.join(missing, 'node_modules'))
 373
 374   var serverPackages = {
 375     '@foo/bar': 'write',
 376     '@foo/util': 'read'
 377   }
 378   var clientPackages = {
 379     '@foo/bar': 'read-write',
 380     '@foo/util': 'read-only'
 381   }
 382   server.get(
 383     '/-/org/myorg/package?format=cli'
 384   ).reply(404, {error: 'nope'})
 385   server.get(
 386     '/-/user/myorg/package?format=cli'
 387   ).reply(200, serverPackages)
 388   common.npm(
 389     [
 390       'access',
 391       'ls-packages',
 392       'myorg',
 393       '--registry', common.registry
 394     ],
 395     { cwd: missing },
 396     function (er, code, stdout, stderr) {
 397       t.ifError(er, 'npm access ls-packages')
 398       t.same(JSON.parse(stdout), clientPackages)
 399       rimraf.sync(missing)
 400       t.end()
 401     }
 402   )
 403 })
 404
 405 test('npm access ls-collaborators on current', function (t) {
 406   var serverCollaborators = {
 407     'myorg:myteam': 'write',
 408     'myorg:anotherteam': 'read'
 409   }
 410   var clientCollaborators = {
 411     'myorg:myteam': 'read-write',
 412     'myorg:anotherteam': 'read-only'
 413   }
 414   server.get(
 415     '/-/package/%40scoped%2Fpkg/collaborators?format=cli'
 416   ).reply(200, serverCollaborators)
 417   common.npm(
 418     [
 419       'access',
 420       'ls-collaborators',
 421       '--registry', common.registry
 422     ],
 423     { cwd: pkg },
 424     function (er, code, stdout, stderr) {
 425       t.ifError(er, 'npm access ls-collaborators')
 426       t.same(JSON.parse(stdout), clientCollaborators)
 427       t.end()
 428     }
 429   )
 430 })
 431
 432 test('npm access ls-collaborators on package', function (t) {
 433   var serverCollaborators = {
 434     'myorg:myteam': 'write',
 435     'myorg:anotherteam': 'read'
 436   }
 437   var clientCollaborators = {
 438     'myorg:myteam': 'read-write',
 439     'myorg:anotherteam': 'read-only'
 440   }
 441   server.get(
 442     '/-/package/%40scoped%2Fanother/collaborators?format=cli'
 443   ).reply(200, serverCollaborators)
 444   common.npm(
 445     [
 446       'access',
 447       'ls-collaborators',
 448       '@scoped/another',
 449       '--registry', common.registry
 450     ],
 451     { cwd: pkg },
 452     function (er, code, stdout, stderr) {
 453       t.ifError(er, 'npm access ls-collaborators')
 454       t.same(JSON.parse(stdout), clientCollaborators)
 455       t.end()
 456     }
 457   )
 458 })
 459
 460 test('npm access ls-collaborators on current w/user filter', function (t) {
 461   var serverCollaborators = {
 462     'myorg:myteam': 'write',
 463     'myorg:anotherteam': 'read'
 464   }
 465   var clientCollaborators = {
 466     'myorg:myteam': 'read-write',
 467     'myorg:anotherteam': 'read-only'
 468   }
 469   server.get(
 470     '/-/package/%40scoped%2Fanother/collaborators?format=cli&user=zkat'
 471   ).reply(200, serverCollaborators)
 472   common.npm(
 473     [
 474       'access',
 475       'ls-collaborators',
 476       '@scoped/another',
 477       'zkat',
 478       '--registry', common.registry
 479     ],
 480     { cwd: pkg },
 481     function (er, code, stdout, stderr) {
 482       t.ifError(er, 'npm access ls-collaborators')
 483       t.same(JSON.parse(stdout), clientCollaborators)
 484       t.end()
 485     }
 486   )
 487 })
 488
 489 test('npm access edit', function (t) {
 490   common.npm(
 491     [
 492       'access',
 493       'edit', '@scoped/another',
 494       '--registry', common.registry
 495     ],
 496     { cwd: pkg },
 497     function (er, code, stdout, stderr) {
 498       t.ok(code, 'exited with Error')
 499       t.match(stderr, /edit subcommand is not implemented yet/)
 500       t.end()
 501     }
 502   )
 503 })
 504
 505 test('npm access blerg', function (t) {
 506   common.npm(
 507     [
 508       'access',
 509       'blerg', '@scoped/another',
 510       '--registry', common.registry
 511     ],
 512     { cwd: pkg },
 513     function (er, code, stdout, stderr) {
 514       t.ok(code, 'exited with Error')
 515       t.matches(stderr, /Usage:/)
 516       t.end()
 517     }
 518   )
 519 })
 520
 521 test('cleanup', function (t) {
 522   t.pass('cleaned up')
 523   rimraf.sync(pkg)
 524   server.done()
 525   server.close()
 526   t.end()
 527 })