@juzi/file-box 1.7.0

package/package.json

@@ -0,0 +1,85 @@
+{
+  "name": "@juzi/file-box",
+  "version": "1.7.0",
+  "description": "Pack a File into Box for easy move/transfer between servers no matter of where it is.(local path, remote url, or cloud storage)",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/esm/src/mod.js",
+      "require": "./dist/cjs/src/mod.js"
+    }
+  },
+  "typings": "./dist/esm/src/mod.d.ts",
+  "engines": {
+    "node": ">=16",
+    "npm": ">=7"
+  },
+  "scripts": {
+    "clean": "shx rm -fr dist/*",
+    "dist": "npm-run-all clean build dist:commonjs",
+    "build": "tsc && tsc -p tsconfig.cjs.json",
+    "dist:commonjs": "jq -n \"{ type: \\\"commonjs\\\" }\" > dist/cjs/package.json",
+    "lint": "npm-run-all lint:es lint:ts",
+    "lint:ts": "tsc --isolatedModules --noEmit",
+    "test": "npm-run-all lint test:unit",
+    "test:unit": "cross-env NODE_OPTIONS=\"--no-warnings --loader=ts-node/esm\" tap --timeout=90 \"src/**/*.spec.ts\" \"tests/*.spec.ts\"",
+    "test:pack": "bash -x scripts/npm-pack-testing.sh",
+    "lint:es": "eslint --ignore-pattern fixtures/ \"src/**/*.ts\" \"tests/**/*.ts\""
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/huan/file-box.git"
+  },
+  "keywords": [
+    "file",
+    "virtual",
+    "cloud",
+    "url",
+    "stream",
+    "http",
+    "api"
+  ],
+  "author": "Huan LI <zixia@zixia.net>",
+  "license": "Apache-2.0",
+  "bugs": {
+    "url": "https://github.com/huan/file-box/issues"
+  },
+  "homepage": "https://github.com/huan/file-box#readme",
+  "devDependencies": {
+    "@chatie/eslint-config": "^1.0.4",
+    "@chatie/git-scripts": "^0.6.2",
+    "@chatie/semver": "^0.4.7",
+    "@chatie/tsconfig": "^4.6.2",
+    "@types/isomorphic-fetch": "0.0.35",
+    "@types/mime": "^2.0.3",
+    "@types/qrcode": "^1.4.1",
+    "@types/uuid": "^8.3.3",
+    "gts": "^3.1.0",
+    "pkg-jq": "^0.2.11",
+    "read-pkg-up": "^8.0.0",
+    "esquery": "1.4.0",
+    "reflect-metadata": "^0.1.13"
+  },
+  "dependencies": {
+    "brolog": "^1.14.2",
+    "clone-class": "^1.0.3",
+    "jimp": "^0.16.1",
+    "jsqr": "^1.4.0",
+    "mime": "^3.0.0",
+    "qrcode": "^1.5.0",
+    "uuid": "^8.3.2"
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "tag": "next"
+  },
+  "git": {
+    "scripts": {
+      "pre-push": "npx git-scripts-pre-push"
+    }
+  }
+}

package/src/config.ts

@@ -0,0 +1,5 @@
+/// <reference path="./typings.d.ts" />
+export { VERSION } from './version.js'
+
+export const HTTP_TIMEOUT = Number(process.env['FILEBOX_HTTP_TIMEOUT'])
+  || 60 * 1000

package/src/file-box.spec.ts

@@ -0,0 +1,480 @@
+#!/usr/bin/env -S node --no-warnings --loader ts-node/esm
+
+import 'reflect-metadata'
+
+import assert                       from 'assert'
+import { PassThrough, Readable }    from 'stream'
+import { test, sinon }              from 'tstest'
+import { instanceToClass }          from 'clone-class'
+
+import { FileBox }      from './file-box.js'
+import { FileBoxType }  from './file-box.type.js'
+
+const requiredMetadataKey = Symbol('required')
+
+const tstest = {
+  classFixture () {
+    return (constructor: Function) => {
+      console.info(constructor.name)
+      console.info(constructor.prototype.name)
+    }
+  },
+  methodFixture () {
+    return (
+      ..._: any[]
+      // target      : Object,
+      // propertyKey : string,
+      // descriptor  : PropertyDescriptor,
+    ) => {
+      console.info('@fixture()')
+    }
+  },
+  parameterFixture () {
+    return (target: object, propertyKey: string | symbol, parameterIndex: number) => {
+      console.info(propertyKey)
+      const existingRequiredParameters: number[] = Reflect.getOwnMetadata(requiredMetadataKey, target, propertyKey) || []
+      existingRequiredParameters.push(parameterIndex)
+      Reflect.defineMetadata(requiredMetadataKey, existingRequiredParameters, target, propertyKey)
+    }
+  },
+}
+
+test('File smoke testing', async t => {
+  t.throws(() => FileBox.fromFile('x'), 'should throw for a non-existing file')
+})
+
+@tstest.classFixture()
+export class FixtureFileBox {
+
+  @tstest.methodFixture()
+  public static localFileFixture () {
+    return {
+      content: 'T',
+      name: 'test.txt',
+      size: '1',
+      type: 'plain/text',
+    }
+  }
+
+}
+
+// tslint:disable:max-classes-per-file
+
+export class TestFileBox {
+
+  public static testFileCreateLocal (
+    @tstest.parameterFixture() localFileFixture: any,
+  ) {
+    const file = FileBox.fromFile(localFileFixture)
+
+    test('File.createLocal()', async t => {
+      t.ok(file, 'ok')
+
+    })
+
+    test('File.fromRemote()', async t => {
+      const URL = 'http://httpbin.org/response-headers?Content-Type=text/plain;%20charset=UTF-8&Content-Disposition=attachment;%20filename%3d%22test.json%22'
+      assert(URL)
+      t.pass('ok')
+    })
+
+  }
+
+}
+
+test('toBase64()', async t => {
+  const BASE64_DECODED = 'FileBoxBase64\n'
+  const BASE64_ENCODED = 'RmlsZUJveEJhc2U2NAo='
+
+  const fileBox = FileBox.fromBase64(BASE64_ENCODED, 'test.txt')
+  const base64 = await fileBox.toBase64()
+
+  t.equal(base64, BASE64_ENCODED, 'should get base64 back')
+
+  const text = Buffer.from(base64, 'base64').toString()
+  t.equal(text, BASE64_DECODED, 'should get the text right')
+})
+
+test('fromBuffer() & toBase64()', async t => {
+  const BASE64_ENCODED = 'RmlsZUJveEJhc2U2NAo='
+
+  const buffer = Buffer.from(BASE64_ENCODED, 'base64')
+  const fileBox = FileBox.fromBuffer(buffer, 'test.txt')
+  const base64 = await fileBox.toBase64()
+
+  t.equal(base64, BASE64_ENCODED, 'should get base64 back from buffer')
+})
+
+test('syncRemote()', async t => {
+  class FileBoxTest extends FileBox {
+
+    static override fromUrl (...args: any[]): FileBoxTest { return (super.fromUrl as any)(...args) }
+    override _syncUrlMetadata () { return super._syncUrlMetadata() }
+
+  }
+
+  const URL = 'http://httpbin.org/response-headers?Content-Disposition=attachment;%20filename%3d%22test.txt%22&filename=test.txt'
+
+  const EXPECTED_NAME_FROM_URL    = 'response-headers'
+  const EXPECTED_TYPE_FROM_URL    = 'application/unknown'
+
+  const EXPECTED_NAME_FROM_HEADER = 'test.txt'
+  const EXPECTED_SIZE_FROM_HEADER = 159
+  const EXPECTED_TYPE_FROM_HEADER = 'application/json'
+
+  const fileBox = FileBoxTest.fromUrl(URL)
+
+  t.equal(fileBox.name, EXPECTED_NAME_FROM_URL, 'should get the name from url')
+  t.equal(fileBox.mediaType, EXPECTED_TYPE_FROM_URL, 'should get the mime type from url')
+
+  await fileBox._syncUrlMetadata()
+
+  t.equal(fileBox.size,       EXPECTED_SIZE_FROM_HEADER,  'should get the size from remote header')
+  t.equal(fileBox.name,       EXPECTED_NAME_FROM_HEADER,  'should get the name from remote header')
+  t.equal(fileBox.mediaType,  EXPECTED_TYPE_FROM_HEADER,  'should get the mime type from remote http header')
+})
+
+test('fromURL() deal with url with querystring', async t => {
+  const URL = 'https://zixia.net/a.jpg?name=value&t=1324'
+  const EXPECTED_NAME = 'a.jpg'
+
+  const fileBox = FileBox.fromUrl(URL)
+  t.equal(fileBox.name, EXPECTED_NAME, 'should get basename from url with querystring')
+})
+
+test('toDataURL()', async t => {
+  const FILE_PATH         = 'tests/fixtures/data.bin'
+  const EXPECTED_DATA_URL = 'data:application/octet-stream;base64,dGVzdA=='
+
+  const fileBox = FileBox.fromFile(FILE_PATH)
+
+  const dataUrl = await fileBox.toDataURL()
+
+  t.equal(dataUrl, EXPECTED_DATA_URL, 'should get the data url right')
+})
+
+test('toString()', async t => {
+  const FILE_PATH     = 'tests/fixtures/data.bin'
+  const EXPECT_STRING = 'FileBox#File<data.bin>'
+
+  const fileBox = FileBox.fromFile(FILE_PATH)
+  t.equal(fileBox.toString(), EXPECT_STRING, 'should get the toString() result')
+})
+
+test('toBuffer()', async t => {
+  const FILE_PATH     = 'tests/fixtures/data.bin'
+  const EXPECT_STRING = 'test'
+
+  const fileBox = FileBox.fromFile(FILE_PATH)
+  const buffer = await fileBox.toBuffer()
+
+  t.equal(buffer.toString(), EXPECT_STRING, 'should get the toBuffer() result')
+})
+
+/**
+ * Huan(202106): we keep this unit test for trying to figure out which operation system can support this long file name.
+ *  See: https://github.com/huan/file-box/issues/58
+ */
+test('toFile() with long name', async t => {
+  const IMAGE_URL = 'https://s3.cn-north-1.amazonaws.com.cn/xiaoju-material/public/5ffd393fc503f00039101dae_1620978346435_%E7%94%B5%E6%B1%A0%E5%9E%8B%E5%8F%B7%09%E8%BF%9B%E8%B4%A7%E4%BB%B7%E6%A0%BC%09%E5%8E%9F%E5%94%AE%E5%90%8E%E8%A1%A5%E6%AC%BE%E4%BB%B7%E6%A0%BC%09%E7%8E%B0%E5%85%AC%E5%8F%B8%E6%89%BF%E6%8B%85%E4%B8%80%E5%8D%8A%E7%9A%84%E4%BB%B7%E6%A0%BC%0AZD-20-100%09420%09270%09135%0AZD-Q85-D23L%09360%09270%09135%0AZD-H6-L3%09420%09315%09157.5%0A%E6%80%BB%E8%AE%A1%EF%BC%9A%091200%09855%09427.5%0A'
+
+  const linux = {
+    code    : 'ENAMETOOLONG',
+    errno   : -36,
+    syscall : 'open',
+  }
+  const darwin = {
+    code    : 'ENAMETOOLONG',
+    errno   : -63,
+    syscall : 'open',
+  }
+  const win32 = {
+    code    : 'ENOENT',
+    errno   : -4058,
+    syscall : 'open',
+  }
+
+  const FIXTURE_ERROR: {
+    [key in typeof process.platform]?: Object
+  } = {
+    darwin,
+    linux,
+    win32,
+  }
+
+  const fileBox = FileBox.fromUrl(IMAGE_URL)
+  await t.rejects(
+    fileBox.toFile(),
+    FIXTURE_ERROR[process.platform],
+    `should reject toFile() with ${JSON.stringify(FIXTURE_ERROR[process.platform])}`,
+  )
+})
+
+test('metadata', async t => {
+  const FILE_PATH     = 'tests/fixtures/data.bin'
+
+  const EXPECTED_NAME = 'myname'
+  const EXPECTED_AGE  = 'myage'
+  const EXPECTED_MOL  = 42
+
+  // interface MetadataType {
+  //   metaname : string,
+  //   metaage  : number,
+  //   metaobj: {
+  //     mol: number,
+  //   }
+  // }
+
+  const EXPECTED_METADATA = {
+    metaage: EXPECTED_AGE,
+    metaname: EXPECTED_NAME,
+    metaobj: {
+      mol: EXPECTED_MOL,
+    },
+  }
+
+  const fileBox = FileBox.fromFile(FILE_PATH)
+
+  t.same((fileBox as FileBox).metadata, {}, 'should get a empty {} if not set')
+
+  t.doesNotThrow(
+    () => {
+      (fileBox as FileBox).metadata = EXPECTED_METADATA
+    },
+    'should not throw for set metadata for the first time',
+  )
+
+  t.throws(
+    () => {
+      (fileBox as FileBox).metadata = EXPECTED_METADATA
+    },
+    'should throw for set metadata again',
+  )
+
+  t.throws(
+    () => {
+      (fileBox as FileBox).metadata['mol'] = EXPECTED_MOL
+    },
+    'should throw for change value of a property on metadata',
+  )
+
+  t.same((fileBox as FileBox).metadata, EXPECTED_METADATA, 'should get the metadata')
+})
+
+test('fromQRCode()', async t => {
+  const QRCODE_VALUE = 'hello, world!'
+  const EXPECTED_QRCODE_IMAGE_BASE64 = [
+    'iVBORw0KGgoAAAANSUhEUgAAAHQAAAB0CAYAAABUmhYnAAAAAklEQVR4AewaftIAAAKcSURBVO3BQY7',
+    'cQAwEwSxC//9yeo88NSBIsx7TjIg/WGMUa5RijVKsUYo1SrFGKdYoxRqlWKMUa5RijVKsUYo1SrFGKd',
+    'YoxRrl4qEk/CaVkyTcoXKShN+k8kSxRinWKMUa5eJlKm9Kwh0qn6TypiS8qVijFGuUYo1y8WFJuEPlj',
+    'iR0Kl0SOpUuCZ3KHUm4Q+WTijVKsUYp1igXw6n8T4o1SrFGKdYoF8MloVOZrFijFGuUYo1y8WEq3yQJ',
+    'ncoTKt+kWKMUa5RijXLxsiR8M5UuCZ3KSRK+WbFGKdYoxRrl4iGVf5nKicq/pFijFGuUYo0Sf/BAEjq',
+    'VLglvUnkiCZ3KSRLepPJJxRqlWKMUa5SLlyXhROU3JaFT6ZJwonKShCeS0Kk8UaxRijVKsUaJP3hREj',
+    'qVO5JwotIloVO5Iwl3qJwk4Q6VNxVrlGKNUqxRLv6yJJyodEl4Igl3qHRJ6FTuUPmkYo1SrFGKNcrFQ',
+    '0k4ScITSehUuiScJKFT6ZLQqXRJuEPljiR0Kk8Ua5RijVKsUS4eUvkmSbhDpUvCHUk4UflNxRqlWKMU',
+    'a5SLh5Lwm1Q6lS4JdyThCZWTJJyovKlYoxRrlGKNcvEylTcl4SQJnUqXhCdUuiScJOFvKtYoxRqlWKN',
+    'cfFgS7lB5k0qXhDuS0Kl0SehUTpLQJaFTeaJYoxRrlGKNcjFcEjqVJ5JwkoROpVP5pGKNUqxRijXKxX',
+    '8mCScqXRJOVE6S0Kl8UrFGKdYoxRrl4sNUPknlDpUuCV0SOpWTJHyTYo1SrFGKNcrFy5Lwm5LQqXQqX',
+    'RI6lZMkdConKidJ6FTeVKxRijVKsUaJP1hjFGuUYo1SrFGKNUqxRinWKMUapVijFGuUYo1SrFGKNUqx',
+    'RinWKMUa5Q8Ztu740xD9iQAAAABJRU5ErkJggg==',
+  ].join('')
+
+  const fileBox = FileBox.fromQRCode(QRCODE_VALUE)
+  const base64Text = await fileBox.toBase64()
+
+  t.equal(base64Text, EXPECTED_QRCODE_IMAGE_BASE64, 'should encode QR Code value to expected image')
+})
+
+test('toQRCode()', async t => {
+  const QRCODE_IMAGE_BASE64 = [
+    'iVBORw0KGgoAAAANSUhEUgAAAMgAAADIAQMAAACXljzdAAAABlBMVEX///8AAABVwtN+AAAA',
+    'CXBIWXMAAA7EAAAOxAGVKw4bAAAA7klEQVRYw+2WsQ3EIAxFjShSMgKjZLRktIzCCJQpIv7Z',
+    'hCiXO/qzT/wCWXo0X3wbEw0NWVaEKM187KHW2QLZ+AhpXovfQ+J6skEWHELqBa5NEeCwR7iS',
+    'V7BDzuzAiZ9eqn5IWjfWXHf7VCO5tPAM6U9AjSRideyHFn4FiuvDqV5CM9rZXuF2pZmIAjZy',
+    'x4S0MDdBxEmu3TrliPf7iglPvuLlRydfU3P70UweCSK+ZYK0mUg1O4AVcv0/8itGkC7SdiTH',
+    '0+Mz19oJZ4NkhhSPbIhQkQGI8u1HJzmzs7p7pzNAru2pJb6z8ykkQ0P/pheK6vjurjf7+wAA',
+    'AABJRU5ErkJggg==',
+  ].join('')
+  const EXPECTED_QRCODE_TEXT = 'hello, world!'
+
+  const fileBox = FileBox.fromBase64(QRCODE_IMAGE_BASE64, 'qrcode.png')
+  const qrCodeValue = await fileBox.toQRCode()
+
+  t.equal(qrCodeValue, EXPECTED_QRCODE_TEXT, 'should decode qrcode image base64 to qr code value')
+})
+
+test('toJSON()', async t => {
+  // const BASE64_DECODED = 'FileBoxBase64\n'
+  const BASE64_ENCODED = 'RmlsZUJveEJhc2U2NAo='
+  const BASE64_FILENAME = 'test.txt'
+
+  /**
+   * Huan(202111): we have both `type` and `boxType` is because the compatible issue #73
+   *  @see https://github.com/huan/file-box/issues/73
+   */
+  const EXPECTED_JSON_TEXT = '{"metadata":{},"name":"test.txt","size":14,"base64":"RmlsZUJveEJhc2U2NAo=","type":1,"boxType":1}'
+
+  const fileBox = FileBox.fromBase64(BASE64_ENCODED, BASE64_FILENAME)
+  const jsonText = JSON.stringify(fileBox)
+
+  t.equal(jsonText, EXPECTED_JSON_TEXT, 'should get expected json text')
+
+  const newFileBox = FileBox.fromJSON(jsonText)
+  const newBase64 = await newFileBox.toBase64()
+
+  t.equal(newBase64, BASE64_ENCODED, 'should get base64 back')
+})
+
+test('toJSON() for not supported type', async t => {
+  const BASE64_ENCODED = 'RmlsZUJveEJhc2U2NAo='
+
+  const buffer = Buffer.from(BASE64_ENCODED, 'base64')
+  const fileBox = FileBox.fromBuffer(buffer, 'test.txt')
+
+  t.equal(fileBox.type, FileBoxType.Buffer, 'should get type() as Buffer')
+  t.throws(() => JSON.stringify(fileBox), 'should throw for buffer type of FileBox')
+})
+
+/**
+ * Issue #50: Stream can not be consumed twice
+ *  https://github.com/huan/file-box/issues/50
+ */
+test('toStream() twice for a stream', async t => {
+  const stream = new PassThrough()
+  const box    = FileBox.fromStream(stream, 'hello.dat')
+
+  stream.end('hello, world!')
+
+  // consume it
+  await t.resolves(box.toBase64(), 'should successful to read the stream for the first time')
+
+  // consume it twice
+  await t.rejects(box.toBuffer(), 'should throw when the file-box be consumed twice')
+})
+
+test('toUuid()', async t => {
+  const BASE64_ENCODED = 'RmlsZUJveEJhc2U2NAo='
+  const UUID = '12345678-1234-1234-1234-123456789012'
+
+  class FileBoxTest extends FileBox {}
+
+  const buffer = Buffer.from(BASE64_ENCODED, 'base64')
+  const fileBox = FileBoxTest.fromBuffer(buffer, 'test.txt')
+
+  await t.rejects(fileBox.toUuid(), 'should reject without `FileBox.setUuidSaver()` call`')
+
+  FileBoxTest.setUuidSaver(() => Promise.resolve(UUID))
+  t.equal(await fileBox.toUuid(), UUID, `should get UUID: ${UUID}`)
+})
+
+test('fromUuid()', async t => {
+  const UUID = '12345678-1234-1234-1234-123456789012'
+  const TEXT = 'hello, world!'
+
+  class FileBoxTest extends FileBox {}
+
+  const stream = new PassThrough()
+  stream.end(TEXT)
+
+  const uuidBox = FileBoxTest.fromUuid(UUID, { name: 'test.txt' })
+
+  await t.rejects(uuidBox.toBase64(), 'should reject without `FileBox.setUuidLoader()` call`')
+
+  FileBoxTest.setUuidLoader((_: string) => Promise.resolve(stream))
+  t.equal((await uuidBox.toBuffer()).toString(), TEXT, `should get BASE64: ${TEXT}`)
+})
+
+test('setUuidLoader()', async t => {
+  class FileBoxTest1 extends FileBox {}
+  class FileBoxTest2 extends FileBox {}
+
+  t.doesNotThrow(() => FileBoxTest1.setUuidLoader((_: string) => ({} as any)), 'should not throw for set loader for the first time')
+  t.throws(() => FileBoxTest1.setUuidLoader((_: string) => ({} as any)), 'should throw for set loader twice')
+
+  t.doesNotThrow(() => FileBoxTest2.setUuidLoader((_: string) => ({} as any)), 'should not throw for set loader for the first time')
+  t.throws(() => FileBoxTest2.setUuidLoader((_: string) => ({} as any)), 'should throw for set loader twice')
+})
+
+test('setUuidSaver()', async t => {
+  class FileBoxTest1 extends FileBox {}
+  class FileBoxTest2 extends FileBox {}
+
+  t.doesNotThrow(() => FileBoxTest1.setUuidSaver((_: Readable) => Promise.resolve('uuid')), 'should not throw for set loader for the first time')
+  t.throws(() => FileBoxTest1.setUuidSaver((_: Readable) => Promise.resolve('uuid')), 'should throw for set loader twice')
+
+  t.doesNotThrow(() => FileBoxTest2.setUuidSaver((_: Readable) => Promise.resolve('uuid')), 'should not throw for set loader for the first time')
+  t.throws(() => FileBoxTest2.setUuidSaver((_: Readable) => Promise.resolve('uuid')), 'should throw for set loader twice')
+})
+
+test('setUuidLoader() & setUuidSsaver() with `this`', async t => {
+  const sandbox = sinon.createSandbox()
+
+  const loader  = sandbox.stub()
+    .returns(await FileBox.fromQRCode('qr').toStream())
+  const saver   = sandbox.stub()
+    .returns('uuid')
+
+  class FileBoxTest extends FileBox {}
+
+  FileBoxTest.setUuidLoader(loader)
+  FileBoxTest.setUuidSaver(saver)
+
+  const fileBox = FileBoxTest.fromUuid('uuid', { name: 'test.txt' })
+  await fileBox.toBuffer()
+  t.equal(loader.thisValues[0], fileBox, 'should call loader with `this`')
+
+  const fileBox2 = FileBoxTest.fromBuffer(Buffer.from('test'), 'test.txt')
+  await fileBox2.toUuid()
+  t.equal(saver.thisValues[0], fileBox2, 'should call saver with `this`')
+})
+
+test('FileBox.validInterface()', async t => {
+  const fileBox = FileBox.fromQRCode('test')
+  /**
+   * 2 OK
+   */
+  t.ok(FileBox.validInstance(fileBox), 'should satisfy instance validation for a FileBox instance')
+  t.ok(FileBox.validInterface(fileBox), 'should satisfy interface validation for a FileBox instance')
+  t.ok(FileBox.valid(fileBox), 'should satisfy interface validation')
+  t.ok(fileBox instanceof FileBox, 'should be instance of FileBox')
+
+  const copy = {} as any
+  Object.getOwnPropertyNames(
+    Object.getPrototypeOf(fileBox),
+  ).forEach(prop => {
+    copy[prop] = (fileBox as FileBox)[prop as keyof FileBox]
+  })
+
+  function NOT_FILE_BOX_CONSTRUCTOR () {}
+  const target = {
+    ...copy,
+    constructor: NOT_FILE_BOX_CONSTRUCTOR,
+  }
+
+  /**
+   * 1 OK, 1 NG
+   */
+  t.ok(FileBox.validInstance(target), 'should pass instance validation instance test')
+  t.ok(FileBox.validInterface(target), 'should pass interface validation for an object with FileBox properties')
+  t.ok(FileBox.valid(target), 'should satisfy interface validation')
+  t.ok(target instanceof FileBox, 'should be instance of FileBox')
+
+  /**
+   * 2 NG
+   */
+  delete target.size
+  t.notOk(FileBox.validInterface(target), 'should not be a valid interface if it lack any property')
+  t.notOk(FileBox.valid(target), 'should not satisfy interface validation')
+})
+
+test('fromJSON() should keep class', async t => {
+  const JSON_TEXT = '{"metadata":{},"name":"smoke-testing.ts","size":735,"type":7,"uuid":"82f461b9-e654-422d-aade-222d05cb02ad","boxType":7}'
+
+  class FileBoxUuid extends FileBox {}
+  FileBoxUuid.setUuidLoader(() => ({} as any))
+  FileBoxUuid.setUuidSaver(() => ({} as any))
+
+  const fileBoxUuid = FileBoxUuid.fromJSON(JSON_TEXT)
+  const FromJsonKlass = instanceToClass(fileBoxUuid, FileBox)
+  t.equal(FromJsonKlass, FileBoxUuid, 'should get back FileBoxUuid class')
+})