s3p 3.4.7 → 3.4.8

package/package.json

@@ -50,7 +50,7 @@
     "test": "npm run nn\njest",
     "watch": "npm-watch"
   },
-  "version": "3.4.7",
+  "version": "3.4.8",
   "watch": {
     "build": {
       "extensions": [

package/build/test/Lib/FsEasy.test.js

@@ -1,4 +0,0 @@
-"use strict"
-let Caf = require('caffeine-script-runtime');
-Caf.defMod(module, () => {return Caf.importInvoke(["describe", "test"], [global, require('../StandardImport'), {mockFs: require('mock-fs')}], (describe, test) => {return describe({createParentDirs: function() {return test("no-op", () => {});}});});});
-//# sourceMappingURL=FsEasy.test.js.map

package/build/test/Lib/FsEasy.test.js.map

@@ -1,10 +0,0 @@
-{
-  "version": 3,
-  "file": "FsEasy.test.js",
-  "sourceRoot": "../../..",
-  "sources": [
-    "source/test/Lib/FsEasy.test.caf"
-  ],
-  "names": [],
-  "mappings": "AAAA;;AAAA,iFAAO,+BAAoB,mDAE3B,gBAAQ,CACN,8BAAoB,OAClB,KAAK"
-}

package/build/test/Lib/LibMisc.test.js

@@ -1,4 +0,0 @@
-"use strict"
-let Caf = require('caffeine-script-runtime');
-Caf.defMod(module, () => {return Caf.importInvoke(["test", "assert", "humanByteSize", "createS3Url", "shellExec"], [global, require('../StandardImport')], (test, assert, humanByteSize, createS3Url, shellExec) => {Caf.each2([[0, "0_B"], [10, "10_B"], [1023, "1023_B"], [10240, "10.00kB"], [Caf.pow(1024, 1), "1.00kB"], [Caf.pow(1024, 2), "1.00mB"], [Caf.pow(1024, 3), "1.00gB"], [Caf.pow(1024, 4), "1.00tB"], [Caf.pow(1024, 5), "1.00pB"], [Caf.pow(1024, 6), "1.00eB"], [Caf.pow(1024, 1) - 1, "1023_B"], [Caf.pow(1024, 2) - 1, "1024.00kB"], [Caf.pow(1024, 3) - 1, "1024.00mB"], [Caf.pow(1024, 4) - 1, "1024.00gB"], [Caf.pow(1024, 5) - 1, "1024.00tB"], [Caf.pow(1024, 6) - 100, "1024.00pB"]], ([input, output]) => test(`humanByteSize ${Caf.toString(input)} >> ${Caf.toString(output)}`, function() {return assert.eq(humanByteSize(input), output);})); Caf.each2([["s3://my-bucket/my-key", "my-bucket", null, "my-key"], ["my-folder/my-key", "my-bucket", "my-folder", "my-key"], ["my-folder/my-key", null, "my-folder", "my-key"]], ([output, ...args]) => test(`createS3Url ${Caf.toString(args.join(", "))} >> ${Caf.toString(output)}`, function() {return assert.eq(createS3Url(...args), output);})); return test("shellExec pwd", function() {return shellExec("pwd").then((out) => assert.match(out, "\/s3p"));});});});
-//# sourceMappingURL=LibMisc.test.js.map

package/build/test/Lib/LibMisc.test.js.map

@@ -1,10 +0,0 @@
-{
-  "version": 3,
-  "file": "LibMisc.test.js",
-  "sourceRoot": "../../..",
-  "sources": [
-    "source/test/Lib/LibMisc.test.caf"
-  ],
-  "names": [],
-  "mappings": "AAAA;;AAAA,4HAAO,yFAEP,UAAwB,EACpB,GAAM,SACN,IAAM,UACN,MAAM,YACN,OAAQ,aACR,cAAM,IAAE,YACR,cAAM,IAAE,YACR,cAAM,IAAE,YACR,cAAM,IAAE,YACR,cAAM,IAAE,YACR,cAAM,IAAE,YAEJ,cAAE,KAAI,GAAI,YACV,cAAE,KAAI,GAAI,eACV,cAAE,KAAI,GAAI,eACV,cAAE,KAAI,GAAI,eACV,cAAE,KAAI,GAAI,eACV,cAAE,KAAI,KAAI,oCAEhB,mCAAsB,0BAAY,uBAAW,OAC3C,UACE,cAAc,QACd,uBAEoB,EACnB,yBAAuB,aAAW,MAAK,YACvC,oBAAkB,aAAW,aAAW,YACxC,oBAAkB,MAAK,aAAW,mCAEvC,KAAI,4BAAgB,UAAU,0BAAW,uBAAW,OAClD,UACE,YAAY,UACZ,oBAEN,KAAK,6BAAkB,OACrB,UAAU,YACJ,CAAC,QACL,aAAa,KAAK"
-}

package/build/test/Lib/PromiseWorkerPool.test.js

@@ -1,4 +0,0 @@
-"use strict"
-let Caf = require('caffeine-script-runtime');
-Caf.defMod(module, () => {return Caf.importInvoke(["test", "PromiseWorkerPool", "Promise", "max", "timeout", "log", "assert"], [global, require('../StandardImport')], (test, PromiseWorkerPool, Promise, max, timeout, log, assert) => {return test("pwp", function() {let currentlyActive, maxActive, totalDone, doWork, pwp, poolSize, numQueued, into, to, i, by; currentlyActive = 0; maxActive = 0; totalDone = 0; doWork = () => {currentlyActive++; maxActive = max(currentlyActive, maxActive); return timeout(1).then(() => {totalDone++; return currentlyActive--;});}; pwp = new PromiseWorkerPool(poolSize = 10); return Promise.all((into = [], to = numQueued = 100, i = 0, by = (i < to) ? 1 : -1, (() => {while (by > 0 && i < to || by < 0 && i > to) {let v; v = i; into.push(pwp.queue(doWork)); i += by;};})(), into)).then(() => {log({currentlyActive, maxActive, poolSize, numQueued}); assert.eq(maxActive, poolSize); return assert.eq(totalDone, numQueued);});});});});
-//# sourceMappingURL=PromiseWorkerPool.test.js.map

package/build/test/Lib/PromiseWorkerPool.test.js.map

@@ -1,10 +0,0 @@
-{
-  "version": 3,
-  "file": "PromiseWorkerPool.test.js",
-  "sourceRoot": "../../..",
-  "sources": [
-    "source/test/Lib/PromiseWorkerPool.test.caf"
-  ],
-  "names": [],
-  "mappings": "AAAA;;AAAA,wIAAO,iGAEP,YAAK,iHACH,kBAAkB,GAClB,YAAY,GACZ,YAAY,GAEZ,SAAM,OACJ,mBAEA,YAAY,IAAI,iBAAiB,mBACjC,QAAQ,eAEN,oBAEA,wBAEJ,MAAM,IAAI,kBAAkB,WAAW,YAEvC,6BAAsB,YAAY,kHAChC,UAAU,sCAEP,OACH,KAAO,iBAAiB,WAAW,UAAU,aAC7C,UAAU,WAAW,kBACrB,UAAU,WAAW"
-}

package/build/test/Lib/S3Keys.test.js

@@ -1,4 +0,0 @@
-"use strict"
-let Caf = require('caffeine-script-runtime');
-Caf.defMod(module, () => {return Caf.importInvoke(["describe", "test", "assert", "getUpToNextSlash", "debugKey", "repeat", "lastKeyChar", "pad", "getNextKey", "isLastKey", "getBisectKey", "middleKeyChar", "getLastKeyWithPrefix"], [global, require('../StandardImport')], (describe, test, assert, getUpToNextSlash, debugKey, repeat, lastKeyChar, pad, getNextKey, isLastKey, getBisectKey, middleKeyChar, getLastKeyWithPrefix) => {return describe({getUpToNextSlash: function() {test(":this/is/ok 0 -> :this/   ", () => assert.eq("this/", getUpToNextSlash("this/is/ok", 0))); test(":this/is/ok 4 -> :this/   ", () => assert.eq("this/", getUpToNextSlash("this/is/ok", 4))); test(":this/is/ok 5 -> :this/is/", () => assert.eq("this/is/", getUpToNextSlash("this/is/ok", 5))); test(":this/is/ok 6 -> :this/is/", () => assert.eq("this/is/", getUpToNextSlash("this/is/ok", 6))); test(":this/is/ok 7 -> :this/is/", () => assert.eq("this/is/", getUpToNextSlash("this/is/ok", 7))); test("undefined if no /", () => assert.eq(undefined, getUpToNextSlash("this", 0))); test("undefined if > last /", () => assert.eq(undefined, getUpToNextSlash("this/is/okthere", 10))); return test("undefined if > length", () => assert.eq(undefined, getUpToNextSlash("this/is/ok", 100)));}, debugKey: function() {test("debugKey :a", () => assert.match(debugKey("a"), /^a +$/)); test("debugKey ''", () => assert.match(debugKey(""), "''                  ")); return test("debugKey :ab~~~~~~~~~~~", () => assert.eq(debugKey("ab" + repeat(lastKeyChar, 10)), "ab(~*10)            "));}, getNextKey: function() {let nextKeyMap; nextKeyMap = {a: "a~", "~": "~~", [pad("b", 1023, "~")]: pad("b", 1024, "~"), [pad("b", 1024, "~")]: "c", [pad("bc", 1024, "~")]: "bd", [pad("b~c", 1024, "~")]: "b~d"}; Caf.each2(nextKeyMap, (nextKey, key) => test(`getNextKey ${Caf.toString(key)} >>> ${Caf.toString(nextKey)}`, () => assert.eq(nextKey, getNextKey(key)))); test("isLastKey (the very last key) >>> error", () => assert.true(isLastKey(pad("", 1024, "~")))); return test("getNextKey (the very last key) >>> error", () => {let lastKey; lastKey = pad("", 1024, "~"); return assert.throws(() => getNextKey(lastKey));});}, getBisectKey: {nulls_and_errors: function() {test("matching returns null", () => assert.notPresent(getBisectKey("a", "a"))); test("invalid char in first param", () => assert.rejects(() => getBisectKey("\n", "a"))); test("invalid char in second param", () => assert.rejects(() => getBisectKey("b", "😀"))); return test("reverse-order returns null", () => assert.notPresent(getBisectKey("b", "a")));}, basic: function() {test(":alpha :alphadude -> :b", () => assert.eq("alphaB", getBisectKey("alpha", "alphadude"))); test('"alpha" "alpha me" -> "alpha "', () => assert.eq("alpha ", getBisectKey("alpha", "alpha me"))); test('"alpha" "alpha " -> "alpha "', () => assert.eq("alpha ", getBisectKey("alpha", "alpha "))); test(":a :c -> :b", () => assert.eq("b", getBisectKey("a", "c"))); test(":alphabet :c -> :b", () => assert.eq("b", getBisectKey("alphabet", "c"))); test(":aa :ac -> :ab", () => assert.eq(`aa${Caf.toString(middleKeyChar)}`, getBisectKey("aa", "ab"))); return test("with spaces", () => assert.eq("My `", getBisectKey("My Other thing.bar", "My report.foo")));}, bisectPrefix: {dirAware: function() {return Caf.each2([["alpha/beta", "z", getLastKeyWithPrefix("alpha/")], ["alpha/beta/gamma", "alpha/boomTown", getLastKeyWithPrefix("alpha/beta/")], ["alpha/beta", "alpha/foo", "alpha/d"], ["run2/bcl-sync-status/39e8278706c47520c03865b84b06921a", "u", getLastKeyWithPrefix("run2/")]], ([a, b, out]) => test(`${Caf.toString(a)} ${Caf.toString(b)} -> ${Caf.toString(out.slice(0, 25))}${Caf.toString((out.length > 25) ? "..." : undefined)}`, () => assert.eq(out, getBisectKey(a, b, true))));}, basic: function() {test(":a :c -> :b~...", () => assert.eq("b", getBisectKey("a", "c", true))); test('"alpha" "alpha me" -> "alpha "', () => assert.eq("alpha ", getBisectKey("alpha", "alpha me", true))); test(":alpha :alphadude -> :alphaB", () => assert.eq("alphaB", getBisectKey("alpha", "alphadude", true))); test(":alphabet :c -> :alph~...", () => assert.eq("b", getBisectKey("alphabet", "c", true))); return test(":alphabet :alpi -> :alpha~...", () => assert.eq("alpho", getBisectKey("alphabet", "alpi", true)));}}, regressions: function() {test(":alpha :T -> notPresent", () => assert.notPresent(getBisectKey("alpha", "T"))); test(`:alpha :alphb -> :alpha${Caf.toString(middleKeyChar)}`, () => assert.eq(`alpha${Caf.toString(middleKeyChar)}`, getBisectKey("alpha", "alphb"))); test(":./.git/objects/17/3d216b08fff7c71eeb7bf1c7d5e8aef789461e :./.git/obk -> :./.git/objq", () => assert.eq("./.git/objq", getBisectKey("./.git/objects/17/3d216b08fff7c71eeb7bf1c7d5e8aef789461e", "./.git/obk"))); test("tildeSpecial: :2/~~ :20 -> :2/~~~", () => assert.eq("2/~~~", getBisectKey("2/~~", "20"))); test("tildeSpecial: :2/~~(+1020 more) :20999 -> :20", () => assert.eq("20", getBisectKey(pad("2/", 1024, "~"), "20999"))); test("tildeSpecial: :2/~~(+1020 more) :20 -> :20", () => assert.eq("20", getBisectKey(pad("2/", 1024, "~"), "20"))); return test("tildeSpecial: original regression", () => assert.eq("filestores/kss/20", getBisectKey("filestores/kss/2/~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~", "filestores/kss/20/2001-page798-2.v0.7")));}}});});});
-//# sourceMappingURL=S3Keys.test.js.map

package/build/test/Lib/S3Keys.test.js.map

@@ -1,10 +0,0 @@
-{
-  "version": 3,
-  "file": "S3Keys.test.js",
-  "sourceRoot": "../../..",
-  "sources": [
-    "source/test/Lib/S3Keys.test.caf"
-  ],
-  "names": [],
-  "mappings": "AAAA;;AAAA,+OAAO,4LAEP,gBAAQ,CACN,8BACE,KAAK,oCAAgC,UAAU,SAAW,iBAAiB,cAAY,MACvF,KAAK,oCAAgC,UAAU,SAAW,iBAAiB,cAAY,MACvF,KAAK,oCAAgC,UAAU,YAAW,iBAAiB,cAAY,MACvF,KAAK,oCAAgC,UAAU,YAAW,iBAAiB,cAAY,MACvF,KAAK,oCAAgC,UAAU,YAAW,iBAAiB,cAAY,MACvF,KAAK,2BAAuB,UAAU,WAAW,iBAAiB,QAAQ,MAC1E,KAAK,+BAA2B,UAAU,WAAW,iBAAiB,mBAAmB,cACzF,KAAK,+BAA2B,UAAU,WAAW,iBAAiB,cAAc,UAEtF,sBACE,KAAK,qBACH,aACE,SAAS,MACT,WAEJ,KAAK,qBACH,aACE,SAAS,KACT,iCAEJ,KAAK,iCACH,UACE,SAAS,OAAM,OAAO,aAAa,MACnC,4BAEN,wCACE,aAAU,CACR,GAAI,MACJ,KAAI,MACJ,CAAC,IAAI,KAAI,MAAM,OAAO,IAAI,KAAI,MAAM,MACpC,CAAC,IAAI,KAAI,MAAM,OAAO,KACtB,CAAC,IAAI,MAAK,MAAM,OAAM,MACtB,CAAC,IAAI,OAAM,MAAM,OAAK,kBAEH,8BACnB,gCAAmB,yBAAW,kBAC5B,UAAU,SAAS,WAAW,SAElC,KAAK,iDACH,YAAY,UAAU,IAAI,IAAI,MAAM,gBAEtC,KAAK,gEACH,UAAU,IAAI,IAAI,MAAM,aACxB,cAAa,MAAI,WAAW,gBAEhC,eAEE,8BACE,KACI,+BACC,kBAAkB,aAAa,KAAG,QAEvC,KACI,qCACC,eAAc,MAAI,aAAa,MAAK,QAEzC,KACI,sCACC,eAAc,MAAI,aAAa,KAAG,gBAEvC,KACI,oCACC,kBAAkB,aAAa,KAAG,UAEzC,mBACE,KACI,iCACC,UAAU,UAAQ,aAAa,SAAO,gBAE3C,KACI,wCACC,UAAU,UAAS,aAAa,SAAO,eAE5C,KACI,sCACC,UAAU,UAAS,aAAa,SAAO,aAE5C,KACI,qBACC,UAAU,KAAG,aAAa,KAAG,QAElC,KACI,4BACC,UAAU,KAAG,aAAa,YAAU,QAEzC,KACI,wBACC,4BAAe,kBAAgB,aAAa,MAAI,gBAErD,KACI,qBACC,UACC,QACF,aACE,sBACA,sBAER,eACE,sBAAY,iBAEU,EACZ,cAAY,KAAG,qBAAqB,aACpC,oBAAkB,kBAAgB,qBAAqB,kBACvD,cAAY,aAAW,aACvB,yDAAuD,KAAG,qBAAqB,6BACrF,KAAI,gBAAI,mBAAK,sBAAQ,UAAU,GAAG,oBAAe,cAAa,kCAC5D,UAAU,KAAK,aAAa,GAAG,GAAG,YAExC,mBACE,KACI,yBACC,UAAU,KAAG,aAAa,KAAG,KAAG,SAErC,KACI,wCACC,UAAU,UAAS,aAAa,SAAO,YAAW,SAEvD,KACI,sCACC,UAAU,UAAQ,aAAa,SAAO,aAAW,SAEtD,KACI,mCACC,UACD,KACA,aAAa,YAAU,KAAG,gBAE9B,KACI,uCACC,UACD,SACA,aAAa,YAAU,QAAM,YAErC,yBACE,KACI,iCACC,kBAAkB,aAAa,SAAO,QAE3C,4CAC8B,wBACzB,+BAAkB,kBAAgB,aAAa,SAAO,YAE3D,KACI,+FACC,UAAU,eAAa,aAAa,4DAA0D,iBAEnG,KACI,2CACC,UAAU,SAAO,aAAa,QAAM,SAEzC,KACI,uDACC,UAAU,MAAI,aAAa,IAAI,MAAM,MAAM,MAAM,YAEtD,KACI,oDACC,UAAU,MAAI,aAAa,IAAI,MAAM,MAAM,MAAM,gBAEtD,KACI,2CAEA,UACE,qBACA,aACE,ogCACA"
-}

package/build/test/Lib/index.js

@@ -1,11 +0,0 @@
-// generated by Neptune Namespaces v4.x.x
-// file: test/Lib/index.js
-
-(module.exports = require('./namespace'))
-
-.addModules({
-  FsEasyTest:            require('./FsEasy.test'),
-  LibMiscTest:           require('./LibMisc.test'),
-  PromiseWorkerPoolTest: require('./PromiseWorkerPool.test'),
-  S3KeysTest:            require('./S3Keys.test')
-});

package/build/test/Lib/namespace.js

@@ -1,7 +0,0 @@
-// generated by Neptune Namespaces v4.x.x
-// file: test/Lib/namespace.js
-
-module.exports = require('../namespace').addNamespace(
-  'Lib',
-  class Lib extends Neptune.PackageNamespace {}
-);

package/build/test/S3Comprehensions.test.js

@@ -1,4 +0,0 @@
-"use strict"
-let Caf = require('caffeine-script-runtime');
-Caf.defMod(module, () => {return Caf.importInvoke(["mockS3", "describe", "test", "S3Comprehensions", "assert", "S3P", "getLargeFileList"], [global, require('./StandardImport'), require('./TestLib')], (mockS3, describe, test, S3Comprehensions, assert, S3P, getLargeFileList) => {let smallMockFs; smallMockFs = mockS3("alpha", "beta", "gamma"); return describe({map: function() {test("no map or reduce", () => S3Comprehensions.map({quiet: true, limit: 2, s3: smallMockFs}).then((result) => assert.eq(result.length, 3))); test("custom map", () => S3Comprehensions.map({quiet: true, limit: 2, s3: smallMockFs, map: ({Size}) => Size}).then((result) => assert.eq(result, [5, 4, 5]))); test("example: total-size", () => S3Comprehensions.map({quiet: true, s3: smallMockFs, map: ({Size}) => Size, reduce: (a, b) => a + b}).then((result) => assert.eq(result, 14))); test("example: smallest", () => S3Comprehensions.map({quiet: true, s3: smallMockFs, reduce: (a, b) => (a.Size < b.Size) ? a : b}).then((result) => assert.eq(result.Key, "beta"))); return test("example: newest", () => S3Comprehensions.map({quiet: true, s3: smallMockFs, reduce: (a, b) => (a != null) ? (a.LastModified < b.LastModified) ? b : a : b, finally: ({Key}) => `KEY: ${Caf.toString(Key)}`}).then((result) => {assert.isString(result); assert.match(result, /^KEY/); return assert.present(result);}));}, each: function() {test("3-items", () => S3Comprehensions.each({quiet: true, limit: 2, s3: smallMockFs}).then((result) => assert.eq(result.items, 3))); return test("10-items", () => {let items10, into, i1; items10 = (into = [], i1 = 0, (() => {while (i1 < 10) {let i; i = i1; into.push(`a${Caf.toString(i)}`); i1++;};})(), into); return S3Comprehensions.each({quiet: true, limit: 2, s3: mockS3(...items10)}).then((result) => assert.eq(result.items, 10));});}, summarize: function() {test("3-items", () => S3P.summarize({quiet: true, limit: 2, s3: smallMockFs}).then((result) => assert.selectedEq({items: 3, size: 14}, result))); return test("largeList", () => getLargeFileList().then((files) => S3P.summarize({quiet: true, s3: mockS3(files)}).then((result) => assert.selectedEq({items: files.length, size: files.join("").length}, result))));}});});});
-//# sourceMappingURL=S3Comprehensions.test.js.map

package/build/test/S3Comprehensions.test.js.map

@@ -1,10 +0,0 @@
-{
-  "version": 3,
-  "file": "S3Comprehensions.test.js",
-  "sourceRoot": "../..",
-  "sources": [
-    "source/test/S3Comprehensions.test.caf"
-  ],
-  "names": [],
-  "mappings": "AAAA;;AAAA,oJAAO,6BAAiB,sHAExB,cAAc,OACZ,SACA,QACA,iBAEF,SAAQ,CACN,iBACE,KAAK,0BACH,sBACE,OAAO,MACP,OAAO,GACP,IAAI,mBAEA,CAAC,WACL,UACE,eACA,MAEN,KAAK,oBACH,sBACE,OAAO,MACP,OAAO,GACP,IAAI,aACJ,KAAK,CAAC,CAAC,UAAU,YAEb,CAAC,WACL,UACE,SACA,GAAE,GAAE,OAEV,KAAK,6BACH,sBACE,OAAO,MACP,IAAI,aACJ,KAAK,CAAC,CAAC,UAAU,MACjB,QAAQ,CAAC,GAAG,MAAM,IAAI,SAElB,CAAC,WACL,UACE,QACA,OAEN,KAAK,2BACH,qBAAoB,CAClB,OAAO,MACP,IAAI,aACJ,QAAQ,CAAC,GAAG,MAAS,UAAS,UAAY,IAAO,SAE7C,CAAC,WACL,UACE,YACA,kBAEN,KAAK,yBACH,qBAAoB,CAClB,OAAO,MACP,IAAI,aACJ,QAAQ,CAAC,GAAG,MACV,CAAG,aACE,kBAAiB,kBAAoB,IAAO,IAC5C,GACP,SAAS,CAAC,CAAC,8BAAmB,cAE1B,CAAC,YACL,gBAAgB,SAChB,aAAa,QAAQ,gBACrB,eAAe,eAErB,kBACE,KAAK,iBACH,uBACE,OAAO,MACP,OAAO,GACP,IAAI,mBAEA,CAAC,WACL,UACE,cACA,aAEN,KAAK,0CACH,gFAA8B,iBAAI,kCAClC,sBAAqB,CACnB,OAAO,MACP,OAAO,GACP,IAAI,OAAO,mBAEP,CAAC,WACL,UACE,cACA,WAER,uBACE,KAAK,iBACH,eACE,OAAO,MACP,OAAO,GACP,IAAI,mBACA,CAAC,WACL,mBACE,OAAO,GACP,MAAM,KACN,kBAEN,KAAK,mBACH,wBACM,CAAC,UACL,cAAa,CACX,OAAO,MACP,IAAI,OAAO,cAEP,CAAC,WACL,kBAAiB,CACf,OAAQ,cACR,MAAQ,WAAW,aACnB"
-}

package/build/test/S3P.test.js

@@ -1,4 +0,0 @@
-"use strict"
-let Caf = require('caffeine-script-runtime');
-Caf.defMod(module, () => {return Caf.importInvoke(["describe", "test", "S3Comprehensions", "mockS3", "assert", "getLargeFileList"], [global, require('./StandardImport'), require('./TestLib')], (describe, test, S3Comprehensions, mockS3, assert, getLargeFileList) => {return describe({each: function() {test("3-items", () => S3Comprehensions.each({limit: 2, quiet: true, s3: mockS3("alpha", "beta", "gamma")}).then((out) => assert.selectedEq({items: 3}, out))); test("limit:3", () => S3Comprehensions.each({quiet: true, limit: 3, s3: mockS3("alpha", "beta", "gamma")}).then((out) => assert.selectedEq({items: 3}, out))); test("limit:4", () => S3Comprehensions.each({quiet: true, limit: 4, s3: mockS3("alpha", "beta", "gamma")}).then((out) => assert.selectedEq({items: 3}, out))); test("limit:2 large common prefix", () => S3Comprehensions.each({quiet: true, limit: 2, s3: mockS3("some/path/to/my/files/alpha", "some/path/to/my/files/beta", "some/path/to/my/files/gamma")}).then((out) => assert.selectedEq({items: 3}, out))); test("each_custom_count_3", () => {let count, files; count = 0; return S3Comprehensions.each({quiet: true, limit: 2, map: () => count++, s3: mockS3(files = ["alpha", "beta", "gamma"])}).then((out) => {assert.eq(files.length, count); return assert.eq(out.items, count);});}); test("each_custom_count_10", () => {let count, files; count = 0; return S3Comprehensions.each({quiet: true, limit: 2, map: () => count++, s3: mockS3(files = ["059", "0934t09g", "alpha", "alpha123", "alpha9", "as09df", "asd", "asdf", "beta", "gamma"])}).then((out) => {assert.eq(files.length, count); return assert.eq(out.items, count);});}); return test("largeList", () => getLargeFileList().then((files) => S3Comprehensions.each({quiet: true, s3: mockS3(files)}).then((result) => assert.selectedEq({items: files.length}, result))));}});});});
-//# sourceMappingURL=S3P.test.js.map

package/build/test/S3P.test.js.map

@@ -1,10 +0,0 @@
-{
-  "version": 3,
-  "file": "S3P.test.js",
-  "sourceRoot": "../..",
-  "sources": [
-    "source/test/S3P.test.caf"
-  ],
-  "names": [],
-  "mappings": "AAAA;;AAAA,6IAAO,6BAAiB,gGAExB,gBAAQ,CACN,kBACE,KAAK,iBACH,sBAAqB,CACnB,OAAO,GACP,OAAO,MACP,IAAI,OACF,SACA,QACA,gBAEE,CAAC,QACL,mBACE,OAAO,IACP,QAEN,KAAK,iBACH,sBAAqB,CACnB,OAAO,MACP,OAAO,GACP,IAAI,OACF,SACA,QACA,gBAEE,CAAC,QACL,mBACE,OAAO,IACP,QAGN,KAAK,iBACH,sBAAqB,CACnB,OAAO,MACP,OAAO,GACP,IAAI,OACF,SACA,QACA,gBAEE,CAAC,QACL,mBACE,OAAO,IACP,QAEN,KAAK,qCACH,sBAAqB,CACnB,OAAO,MACP,OAAO,GACP,IAAI,OACF,+BACA,8BACA,sCAEE,CAAC,QACL,mBACE,OAAO,IACP,QAEN,KAAK,gDACH,QAAQ,UACR,sBAAqB,CACnB,OAAO,MACP,OAAO,GACP,WAAQ,SACR,IAAI,OAAO,SACT,SACA,QACA,iBAEE,CAAC,SACL,UAAU,cAAc,eACxB,UAAU,WAAW,cAEzB,KAAK,iDACH,QAAQ,UACR,sBAAqB,CACnB,OAAO,MACP,OAAO,GACP,WAAQ,SACR,IAAI,OAAO,SACT,OACA,YACA,SACA,YACA,UACA,UACA,OACA,QACA,QACA,iBAEE,CAAC,SACL,UAAU,cAAc,eACxB,UAAU,WAAW,qBAEzB,KAAK,mBACH,wBACM,CAAC,UACL,sBAAqB,CACnB,OAAO,MACP,IAAI,OAAO,cAEP,CAAC,WACL,kBAAiB,CACf,OAAQ,eACR"
-}

package/build/test/S3PCli.js

@@ -1,13 +0,0 @@
-"use strict";
-let Caf = require("caffeine-script-runtime");
-Caf.defMod(module, () => {
-  return Caf.importInvoke(
-    ["test", "assert", "S3PCli"],
-    [global, require("./StandardImport")],
-    (test, assert, S3PCli) => {
-      return test("S3PCli", function () {
-        return assert.match(S3PCli.main({ argv: ["version"] }), /foo/);
-      });
-    }
-  );
-});

package/build/test/S3PCli.test.js

@@ -1,4 +0,0 @@
-"use strict"
-let Caf = require('caffeine-script-runtime');
-Caf.defMod(module, () => {return Caf.importInvoke(["test", "S3PCli", "assert"], [global, require('./StandardImport')], (test, S3PCli, assert) => {return test("S3PCli", function() {let output; output = []; return S3PCli.main({output: (out) => output.push(out), argv: ["nodeJs", "s3p", "version"]}).then((version) => {assert.match(version, /^\d+\.\d+\.\d+$/); return assert.eq(output, [version]);});});});});
-//# sourceMappingURL=S3PCli.test.js.map

package/build/test/S3PCli.test.js.map

@@ -1,10 +0,0 @@
-{
-  "version": 3,
-  "file": "S3PCli.test.js",
-  "sourceRoot": "../..",
-  "sources": [
-    "source/test/S3PCli.test.caf"
-  ],
-  "names": [],
-  "mappings": "AAAA;;AAAA,yFAAO,yDAEP,YAAK,kCACH,oBACA,YAAW,CACT,QAAQ,CAAC,QAAQ,YAAY,MAC7B,OAAS,UAAQ,OAAK,kBAClB,CAAC,aACL,aACE,SACA,2BAUF,UACE,SACG"
-}

package/build/test/StandardImport.js

@@ -1,4 +0,0 @@
-"use strict"
-let Caf = require('caffeine-script-runtime');
-Caf.defMod(module, () => {return require('art-standard-lib').mergeWithSelf(require('art-testbench'), require('../S3Parallel'), require('../S3Parallel').Lib, require('../S3Parallel').S3P, require('../S3Parallel').S3Comprehensions);});
-//# sourceMappingURL=StandardImport.js.map

package/build/test/StandardImport.js.map

@@ -1,10 +0,0 @@
-{
-  "version": 3,
-  "file": "StandardImport.js",
-  "sourceRoot": "../..",
-  "sources": [
-    "source/test/StandardImport.caf"
-  ],
-  "names": [],
-  "mappings": "AAAA;;AAAA,2EACE,0BACA,0BACA,8BACA,8BACA"
-}

package/build/test/TestLib.js

@@ -1,4 +0,0 @@
-"use strict"
-let Caf = require('caffeine-script-runtime');
-Caf.defMod(module, () => {return Caf.importInvoke(["compactFlatten", "Promise", "Date", "randomString"], [global, require('./StandardImport')], (compactFlatten, Promise, Date, randomString) => {let _largeListP, mockS3, generateLargeFileList, getLargeFileList; _largeListP = null; return {mockS3: mockS3 = function(...keys) {keys = compactFlatten(keys).sort(); return {list: ({limit = 1000, startAfter}) => {let count; count = 0; return Promise.then(() => Caf.array(keys, (file) => {count++; return {Key: file, Size: file.length, LastModified: new Date, ETag: "abc123", StorageClass: "STANDARD", Owner: {DisplayName: "john", ID: "abc123"}};}, (file) => file > startAfter && count < limit));}};}, generateLargeFileList: generateLargeFileList = function() {let paths, out; paths = ["run1/job-status//", "run2/job-status/", "run2/sync-status/", "run2/fluffy/", "run2/upload-status/", "run2/output/"]; return Caf.each2(paths, (path) => {let into, i1; return (into = out, i1 = 0, (() => {while (i1 < 10000) {let i; i = i1; into.push(`${Caf.toString(path)}${Caf.toString(randomString())}`); i1++;};})(), into);}, null, out = []).sort();}, getLargeFileList: getLargeFileList = function() {return _largeListP != null ? _largeListP : _largeListP = Promise.then(generateLargeFileList);}};});});
-//# sourceMappingURL=TestLib.js.map

package/build/test/TestLib.js.map

@@ -1,10 +0,0 @@
-{
-  "version": 3,
-  "file": "TestLib.js",
-  "sourceRoot": "../..",
-  "sources": [
-    "source/test/TestLib.caf"
-  ],
-  "names": [],
-  "mappings": "AAAA;;AAAA,kHAAO,kJAEP,cAAc,cAoBZ,iBAAM,QAAG,CAAC,UACR,OACE,eAAe,sBAGjB,MAAM,CAAC,CAAC,cAAY,4BAClB,QAAQ,UACR,aAAY,gBACI,iBACZ,iBACA,KAAgB,MAChB,MAAgB,aAChB,cAAgB,IAAI,MACpB,MAAgB,UAChB,cAAgB,YAChB,QACE,aAAc,QACd,IAAc,mEAGxB,+CAAqB,4BACnB,SACE,qBACA,oBACA,qBACA,gBACA,uBACA,wBAEF,UAAa,gCAAmB,eACP,kEAAG,gBACnB,qBAAO,oEAIlB,qCAAgB,YAAK,OACnB,oCAAW,cAAI,aAAa"
-}

package/build/test/index.js

@@ -1,14 +0,0 @@
-// generated by Neptune Namespaces v4.x.x
-// file: test/index.js
-
-(module.exports = require('./namespace'))
-
-.addModules({
-  S3ComprehensionsTest: require('./S3Comprehensions.test'),
-  S3PTest:              require('./S3P.test'),
-  S3PCli:               require('./S3PCli'),
-  S3PCliTest:           require('./S3PCli.test'),
-  StandardImport:       require('./StandardImport'),
-  TestLib:              require('./TestLib')
-});
-require('./Lib');

package/build/test/namespace.js

@@ -1,9 +0,0 @@
-// generated by Neptune Namespaces v4.x.x
-// file: test/namespace.js
-
-module.exports = require('neptune-namespaces-runtime').addNamespace(
-  'Test',
-  (class Test extends Neptune.PackageNamespace {})
-  ._configureNamespace(require('../../package.json'))
-);
-require('./Lib/namespace');

package/source/test/Lib/FsEasy.test.caf

@@ -1,69 +0,0 @@
-import &StandardImport, {} &mockFs
-
-describe
-  createParentDirs: ->
-    test "no-op" -> # just hates mockFs
-##
-    beforeAll ->
-      mockFs {}
-
-    afterAll ->
-      mockFs.restore()
-
-    chainedTest "createParentDirs foo/bar.txt" ->
-      createParentDirs :foo/bar.txt
-      .then (numCreated) ->
-        assert.eq numCreated, 1
-
-    .thenTest "called twice" ->
-      createParentDirs :foo/bar.txt
-      .then (numCreated) ->
-        assert.eq numCreated, 0
-
-    .thenTest "many subdirs" ->
-      createParentDirs :foo/baz/bud/bob/bar.txt
-      .then (numCreated) ->
-        assert.eq numCreated, 3
-
-    test "race condidtion" ->
-      Promise.all []
-        createParentDirs :race/bar.txt
-        createParentDirs :race/bar.txt
-      .then ([a, b]) ->
-        assert.eq a + b, 1
-        assert.ok a == 0 || b == 0
-
-    test "scratchState" ->
-      createParentDirs :withss/bar.text, scratchState = {}
-      .then ->
-        assert.eq 1, objectKeyCount scratchState
-        each entry in scratchState
-          assert.isPromise entry
-
-        Promise.all Object.values scratchState
-
-    test "createWriteStreamSafe :food/baz" ->
-      createWriteStreamSafe :food/baz
-      .then (writeStream) ->
-        writeStream.close()
-
-  # findAllFiles: ->
-  #   mockedFs =
-  #     folderA: object i til 10 with-key "" file#{i}.txt
-  #       "" contents
-  #     folderB: folderC: object i til 3 with-key "" image0#{i}.png
-  #       "" contents
-  #     README.md: "" Read it!
-
-  #   beforeAll ->
-  #     mockFs mockedFs
-
-  #   afterAll ->
-  #     mockFs.restore()
-
-  #   each expected, path in
-  #       folderA: mockedFs.folderA
-  #     test "findAllFiles '#{path}'" ->
-  #       findAllFiles path
-  #       .then (result) ->
-  #         assert.eq result, expected

package/source/test/Lib/LibMisc.test.caf

@@ -1,40 +0,0 @@
-import &StandardImport
-
-each [input, output] in []
-    0     0_B
-    10    10_B
-    1023  1023_B
-    10240   10.00kB
-    1024**1 1.00kB
-    1024**2 1.00mB
-    1024**3 1.00gB
-    1024**4 1.00tB
-    1024**5 1.00pB
-    1024**6 1.00eB
-
-    1024**1 - 1   1023_B
-    1024**2 - 1   1024.00kB
-    1024**3 - 1   1024.00mB
-    1024**4 - 1   1024.00gB
-    1024**5 - 1   1024.00tB
-    1024**6 - 100 1024.00pB
-
-  test "humanByteSize #{input} >> #{output}" ->
-    assert.eq
-      humanByteSize input
-      output
-
-each [output, args...] in []
-    [] :s3://my-bucket/my-key :my-bucket null :my-key
-    [] :my-folder/my-key :my-bucket :my-folder :my-key
-    [] :my-folder/my-key null :my-folder :my-key
-
-  test "createS3Url #{args.join ', '} >> #{output}" ->
-    assert.eq
-      createS3Url args...
-      output
-
-test "shellExec pwd" ->
-  shellExec "pwd"
-  .then (out) ->
-    assert.match out, "\/s3p"

package/source/test/Lib/PromiseWorkerPool.test.caf

@@ -1,26 +0,0 @@
-import &StandardImport
-
-test :pwp ->
-  currentlyActive = 0
-  maxActive = 0
-  totalDone = 0
-
-  doWork = ->
-    currentlyActive++
-    # log "" work-start #{currentlyActive}/#{maxActive}
-    maxActive = max currentlyActive, maxActive
-    timeout 1
-    .then ->
-      totalDone++
-      # log "" work-end #{currentlyActive}/#{maxActive}
-      currentlyActive--
-
-  pwp = new PromiseWorkerPool poolSize = 10
-
-  Promise.all array til numQueued = 100
-    pwp.queue doWork
-
-  .then ->
-    log {} currentlyActive, maxActive, poolSize, numQueued
-    assert.eq maxActive, poolSize
-    assert.eq totalDone, numQueued

package/source/test/Lib/S3Keys.test.caf

@@ -1,170 +0,0 @@
-import &StandardImport
-
-describe
-  getUpToNextSlash: ->
-    test ":this/is/ok 0 -> :this/   " -> assert.eq :this/     getUpToNextSlash :this/is/ok 0
-    test ":this/is/ok 4 -> :this/   " -> assert.eq :this/     getUpToNextSlash :this/is/ok 4
-    test ":this/is/ok 5 -> :this/is/" -> assert.eq :this/is/  getUpToNextSlash :this/is/ok 5
-    test ":this/is/ok 6 -> :this/is/" -> assert.eq :this/is/  getUpToNextSlash :this/is/ok 6
-    test ":this/is/ok 7 -> :this/is/" -> assert.eq :this/is/  getUpToNextSlash :this/is/ok 7
-    test "undefined if no /" -> assert.eq undefined, getUpToNextSlash "this", 0
-    test "undefined if > last /" -> assert.eq undefined, getUpToNextSlash "this/is/okthere", 10
-    test "undefined if > length" -> assert.eq undefined, getUpToNextSlash "this/is/ok", 100
-
-  debugKey: ->
-    test "debugKey :a" ->
-      assert.match
-        debugKey :a
-        /^a +$/
-
-    test "debugKey ''" ->
-      assert.match
-        debugKey ''
-        "''                  "
-
-    test "debugKey :ab~~~~~~~~~~~" ->
-      assert.eq
-        debugKey :ab + repeat lastKeyChar, 10
-        "ab(~*10)            "
-
-  getNextKey: ->
-    nextKeyMap =
-      a:  :a~
-      ~:  :~~
-      [pad :b, 1023, :~]:   pad :b, 1024, :~
-      [pad :b, 1024, :~]:   :c
-      [pad :bc, 1024, :~]:  :bd
-      [pad :b~c, 1024, :~]: :b~d
-
-    each nextKey, key in nextKeyMap
-      test "getNextKey #{key} >>> #{nextKey}" ->
-        assert.eq nextKey, getNextKey key
-
-    test "isLastKey (the very last key) >>> error" ->
-      assert.true isLastKey pad '', 1024, '~'
-
-    test "getNextKey (the very last key) >>> error" ->
-      lastKey = pad '', 1024, '~'
-      assert.throws -> getNextKey lastKey
-
-  getBisectKey:
-
-    nulls_and_errors: ->
-      test
-        "" matching returns null
-        -> assert.notPresent getBisectKey :a :a
-
-      test
-        "" invalid char in first param
-        -> assert.rejects -> getBisectKey "\n" :a
-
-      test
-        "" invalid char in second param
-        -> assert.rejects -> getBisectKey :b :😀
-
-      test
-        "" reverse-order returns null
-        -> assert.notPresent getBisectKey :b :a
-
-    basic: ->
-      test
-        "" :alpha :alphadude -> :b
-        -> assert.eq :alphaB getBisectKey :alpha :alphadude
-
-      test
-        "" "alpha" "alpha me" -> "alpha "
-        -> assert.eq "alpha " getBisectKey :alpha "alpha me"
-
-      test
-        "" "alpha" "alpha " -> "alpha "
-        -> assert.eq "alpha " getBisectKey :alpha "alpha "
-
-      test
-        "" :a :c -> :b
-        -> assert.eq :b getBisectKey :a :c
-
-      test
-        "" :alphabet :c -> :b
-        -> assert.eq :b getBisectKey :alphabet :c
-
-      test
-        "" :aa :ac -> :ab
-        -> assert.eq "aa#{middleKeyChar}" getBisectKey :aa :ab
-
-      test
-        "" with spaces
-        -> assert.eq
-          "" My `
-          getBisectKey
-            "My Other thing.bar"
-            "My report.foo"
-
-    bisectPrefix:
-      dirAware: ->
-
-        each [a, b, out] in []
-             [] :alpha/beta :z getLastKeyWithPrefix :alpha/
-             [] :alpha/beta/gamma :alpha/boomTown getLastKeyWithPrefix :alpha/beta/
-             [] :alpha/beta :alpha/foo :alpha/d
-             [] :run2/bcl-sync-status/39e8278706c47520c03865b84b06921a :u getLastKeyWithPrefix :run2/
-          test "#{a} #{b} -> #{out.slice(0, 25)}#{"..." if out.length > 25}" ->
-            assert.eq out, getBisectKey a, b, true
-
-      basic: ->
-        test
-          "" :a :c -> :b~...
-          -> assert.eq :b getBisectKey :a :c true
-
-        test
-          "" "alpha" "alpha me" -> "alpha "
-          -> assert.eq "alpha " getBisectKey :alpha "alpha me" true
-
-        test
-          "" :alpha :alphadude -> :alphaB
-          -> assert.eq :alphaB getBisectKey :alpha :alphadude true
-
-        test
-          "" :alphabet :c -> :alph~...
-          -> assert.eq
-            :b
-            getBisectKey :alphabet :c true
-
-        test
-          "" :alphabet :alpi -> :alpha~...
-          -> assert.eq
-            :alpho
-            getBisectKey :alphabet :alpi true
-
-    regressions: ->
-      test
-        "" :alpha :T -> notPresent
-        -> assert.notPresent getBisectKey :alpha :T
-
-      test
-        "" :alpha :alphb -> :alpha#{middleKeyChar}
-        -> assert.eq "alpha#{middleKeyChar}" getBisectKey :alpha :alphb
-
-      test
-        "" :./.git/objects/17/3d216b08fff7c71eeb7bf1c7d5e8aef789461e :./.git/obk -> :./.git/objq
-        -> assert.eq :./.git/objq getBisectKey :./.git/objects/17/3d216b08fff7c71eeb7bf1c7d5e8aef789461e :./.git/obk
-
-      test
-        "" tildeSpecial: :2/~~ :20 -> :2/~~~
-        -> assert.eq :2/~~~ getBisectKey :2/~~ :20
-
-      test
-        "" tildeSpecial: :2/~~(+1020 more) :20999 -> :20
-        -> assert.eq :20 getBisectKey pad("2/", 1024, "~"), :20999
-
-      test
-        "" tildeSpecial: :2/~~(+1020 more) :20 -> :20
-        -> assert.eq :20 getBisectKey pad("2/", 1024, "~"), :20
-
-      test
-        "" tildeSpecial: original regression
-        ->
-          assert.eq
-            :filestores/kss/20
-            getBisectKey
-              :filestores/kss/2/~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-              :filestores/kss/20/2001-page798-2.v0.7

package/source/test/S3Comprehensions.test.caf

@@ -1,118 +0,0 @@
-import &StandardImport, &TestLib
-
-smallMockFs = mockS3
-  :alpha
-  :beta
-  :gamma
-
-describe
-  map: ->
-    test "no map or reduce" ->
-      S3Comprehensions.map
-        quiet: true
-        limit: 2
-        s3: smallMockFs
-
-      .then (result) ->
-        assert.eq
-          result.length
-          3
-
-    test "custom map" ->
-      S3Comprehensions.map
-        quiet: true
-        limit: 2
-        s3: smallMockFs
-        map: ({Size}) -> Size
-
-      .then (result) ->
-        assert.eq
-          result
-          5 4 5
-
-    test "example: total-size" ->
-      S3Comprehensions.map
-        quiet: true
-        s3: smallMockFs
-        map: ({Size}) -> Size
-        reduce: (a, b) -> a + b
-
-      .then (result) ->
-        assert.eq
-          result
-          14
-
-    test "example: smallest" ->
-      S3Comprehensions.map
-        quiet: true
-        s3: smallMockFs
-        reduce: (a, b) -> if a.Size < b.Size then a else b
-
-      .then (result) ->
-        assert.eq
-          result.Key
-          :beta
-
-    test "example: newest" ->
-      S3Comprehensions.map
-        quiet: true
-        s3: smallMockFs
-        reduce: (a, b) ->
-          if a?
-            if a.LastModified < b.LastModified then b else a
-          else b
-        finally: ({Key}) => "" KEY: #{Key}
-
-      .then (result) ->
-        assert.isString result
-        assert.match result, /^KEY/
-        assert.present result
-
-  each: ->
-    test :3-items ->
-      S3Comprehensions.each
-        quiet: true
-        limit: 2
-        s3: smallMockFs
-
-      .then (result) ->
-        assert.eq
-          result.items
-          3
-
-    test :10-items ->
-      items10 = array i til 10 with "a#{i}"
-      S3Comprehensions.each
-        quiet: true
-        limit: 2
-        s3: mockS3 items10...
-
-      .then (result) ->
-        assert.eq
-          result.items
-          10
-
-  summarize: ->
-    test :3-items ->
-      S3P.summarize
-        quiet: true
-        limit: 2
-        s3: smallMockFs
-      .then (result) ->
-        assert.selectedEq
-          items: 3
-          size: 14
-          result
-
-    test :largeList ->
-      getLargeFileList()
-      .then (files) ->
-        S3P.summarize
-          quiet: true
-          s3: mockS3 files
-
-        .then (result) ->
-          assert.selectedEq
-            items:  files.length
-            size:   files.join('').length
-            result

package/source/test/S3P.test.caf

@@ -1,109 +0,0 @@
-import &StandardImport, &TestLib
-
-describe
-  each: ->
-    test :3-items ->
-      S3Comprehensions.each
-        limit: 2
-        quiet: true
-        s3: mockS3
-          :alpha
-          :beta
-          :gamma
-
-      .then (out) ->
-        assert.selectedEq
-          items: 3
-          out
-
-    test "limit:3" ->
-      S3Comprehensions.each
-        quiet: true
-        limit: 3
-        s3: mockS3
-          :alpha
-          :beta
-          :gamma
-
-      .then (out) ->
-        assert.selectedEq
-          items: 3
-          out
-
-
-    test "limit:4" ->
-      S3Comprehensions.each
-        quiet: true
-        limit: 4
-        s3: mockS3
-          :alpha
-          :beta
-          :gamma
-
-      .then (out) ->
-        assert.selectedEq
-          items: 3
-          out
-
-    test "limit:2 large common prefix" ->
-      S3Comprehensions.each
-        quiet: true
-        limit: 2
-        s3: mockS3
-          :some/path/to/my/files/alpha
-          :some/path/to/my/files/beta
-          :some/path/to/my/files/gamma
-
-      .then (out) ->
-        assert.selectedEq
-          items: 3
-          out
-
-    test :each_custom_count_3 ->
-      count = 0
-      S3Comprehensions.each
-        quiet: true
-        limit: 2
-        map: -> count++
-        s3: mockS3 files =
-          :alpha
-          :beta
-          :gamma
-
-      .then (out) ->
-        assert.eq files.length, count
-        assert.eq out.items, count
-
-    test :each_custom_count_10 ->
-      count = 0
-      S3Comprehensions.each
-        quiet: true
-        limit: 2
-        map: -> count++
-        s3: mockS3 files =
-          :059
-          :0934t09g
-          :alpha
-          :alpha123
-          :alpha9
-          :as09df
-          :asd
-          :asdf
-          :beta
-          :gamma
-
-      .then (out) ->
-        assert.eq files.length, count
-        assert.eq out.items, count
-
-    test :largeList ->
-      getLargeFileList()
-      .then (files) ->
-        S3Comprehensions.each
-          quiet: true
-          s3: mockS3 files
-
-        .then (result) ->
-          assert.selectedEq
-            items:  files.length
-            result

package/source/test/S3PCli.test.caf

@@ -1,23 +0,0 @@
-import &StandardImport
-
-test "S3PCli" ->
-  output = []
-  S3PCli.main
-    output: (out) => output.push out
-    argv: [] :nodeJs :s3p :version
-  .then (version) ->
-    assert.match
-      version
-      ///
-        ^
-        \d+
-        \.
-        \d+
-        \.
-        \d+
-        $
-
-
-    assert.eq
-      output
-      [] version

package/source/test/StandardImport.caf

@@ -1,6 +0,0 @@
-&ArtStandardLib.mergeWithSelf
-  &ArtTestbench
-  &S3Parallel
-  &S3Parallel.Lib
-  &S3Parallel.S3P
-  &S3Parallel.S3Comprehensions

package/source/test/TestLib.caf

@@ -1,59 +0,0 @@
-import &StandardImport
-
-_largeListP = null
-
-{}
-
-  ##
-    IN: keys: strings to use as Keys
-    OUT:
-      mocked AWS S3 sdk implementing minimal api:"
-
-        ##
-          IN: only limit and startAfter are supported (all S3P needs)
-          OUT:
-            list of objects with these keys:
-              Key: one of the passed in key-strings
-              Size: Key.length:
-                for easy testing, the size of simulated keys are the length of their keys
-        list: ({limit, startAfter}) ->
-
-
-    https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/S3.html#listObjectsV2-property
-  mockS3 = (keys...) ->
-    keys =
-      compactFlatten keys
-      .sort()
-
-    list: ({limit=1000, startAfter}) ->
-      count = 0
-      Promise.then ->
-        array file in keys when file > startAfter && count < limit
-          count++
-          Key:            file
-          Size:           file.length
-          LastModified:   new Date
-          ETag:           :abc123
-          StorageClass:   :STANDARD
-          Owner:
-            DisplayName:  :john
-            ID:           :abc123
-
-
-  generateLargeFileList = ->
-    paths =
-      :run1/job-status//
-      :run2/job-status/
-      :run2/sync-status/
-      :run2/fluffy/
-      :run2/upload-status/
-      :run2/output/
-
-    each path in paths into out = []
-      array i til 10000 into out
-        "" #{path}#{randomString()}
-
-    .sort()
-
-  getLargeFileList = ->
-    _largeListP ?= Promise.then generateLargeFileList