]*?>([^]*?)<\/DeleteResult>/);
+ resp.body = xmlToJson(_regRes?.[1], { forceArray: ['deleted', 'error'] });
+ }
+ return callback(null, resp);
+ });
+}
+
+/**
+ *
+ * @param {String} method POST/GET/HEAD/DELETE
+ * @param {String} path Path to a ressource
+ * @param {Object} options { headers: {}, body: "Buffer", queries: {}, defaultQueries: '' }
+ * @param {Function} callback function(err, resp):void = The `err` is null by default. `resp` is the HTTP response including: { statusCode: 200, headers: {}, body: "Buffer/Object/String" }
+ * @returns
+ */
+function request (method, path, options, callback) {
+
+ if (_config.activeStorage >= _config.storages.length) {
+ /** Reset the index of the main storage if any storage are available */
+ _config.activeStorage = 0;
+ log(`S3 Storage | All storages are not available - switch to the main storage`, 'error');
+ return callback(new Error('All S3 storages are not available'));
+ } else if (_config.activeStorage !== 0 && options?.requestStorageIndex === undefined && retryReconnectMainStorage === false) {
+ /**
+ * Retry to reconnect to the main storage if a child storage is active by requesting GET "/": Request "ListBuckets". Notes:
+ * - "requestStorageIndex" option is used to request a specific storage, disable the retry and not create an infinite loop of requests into child storages
+ * - "retryReconnectMainStorage" global variable is used to request one time and not create SPAM parallele requests to the main storage.
+ */
+ retryReconnectMainStorage = true;
+ request('GET', `/`, { requestStorageIndex: 0 }, function (err, resp) {
+ /** If everything is alright, the active storage is reset to the main */
+ if (resp?.statusCode === 200) {
+ log(`🟢 S3 Storage | Main storage available - reconnecting for next requests`);
+ _config.activeStorage = 0;
+ }
+ retryReconnectMainStorage = false;
+ });
+ }
+
+ /** Get active storage based on an index */
+ const _activeStorage = _config.storages[options?.requestStorageIndex ?? _config.activeStorage];
+ options.originalStorage = _config.activeStorage;
+
+ /**
+ * Return a bucket name based on an alias and current active storage.
+ * If the alias does not exist, the alias is returned as bucket name
+ */
+ const _activeBucket = _activeStorage?.buckets?.[options?.alias] ?? options?.alias;
+ let _path = path;
+ if (options?.alias !== _activeBucket) {
+ _path = _path.replace(options?.alias, _activeBucket);
+ }
+
+ const _urlParams = getUrlParameters(options?.queries ?? '', options?.defaultQueries ?? '');
+ const _requestParams = aws4.sign({
+ method: method,
+ url: `https://${_activeStorage.url}${_path}${_urlParams ?? ''}`,
+ ...(options?.body ? { body: options?.body } : {}),
+ headers: {
+ ...(options?.headers ? options?.headers : {})
+ },
+ timeout: _config.timeout,
+ /** REQUIRED FOR AWS4 SIGNATURE */
+ service: 's3',
+ hostname: _activeStorage.url,
+ path: `${path}${_urlParams ?? ''}`,
+ region: _activeStorage.region,
+ protocol: 'https:'
+ }, {
+ accessKeyId: _activeStorage.accessKeyId,
+ secretAccessKey: _activeStorage.secretAccessKey
+ })
+
+ const _requestCallback = function (err, res, body) {
+ if ((err || res?.statusCode >= 500 || res?.statusCode === 401) && options?.requestStorageIndex === undefined) {
+ /** Protection when requesting storage in parallel, another request may have already switch to a child storage on Error */
+ if (options.originalStorage === _config.activeStorage) {
+ log(`S3 Storage | Activate fallback storage: switch from "${_config.activeStorage}" to "${_config.activeStorage + 1}" | ${err?.toString() || "Status code: " + res?.statusCode}`, 'warning');
+ _config.activeStorage += 1;
+ }
+ return request(method, path, options, callback);
+ } else if (err) {
+ return callback(err, res);
+ }
+ /** If the response is an error as XML and not a stream, the error is parsed as JSON */
+ if (res.statusCode >= 400 && res?.headers?.['content-type'] === 'application/xml' && !options?.stream) {
+ body = xmlToJson(body?.toString() ?? '');
+ }
+ return options?.stream === true ? callback(null, res) : callback(null, { headers : res.headers, statusCode: res.statusCode, body : body });
+ }
+ return options?.stream === true ? get(_requestParams, _requestCallback) : get.concat(_requestParams, _requestCallback);
+}
+
+/**
+ * Set HTTP requests timeout
+ * @param {Number} timeout
+ */
+function setTimeout(timeout) {
+ _config.timeout = timeout;
+}
+
+/**
+ * Return S3 configurations requests and list of credentials
+ * @returns
+ */
+function getConfig() {
+ return _config;
+}
+
+/**
+ * Set a new list of S3 credentials and set the active storage to the first storage on the list
+ * @param {Object|Array} newConfig
+ */
+function setConfig(newConfig) {
+ if (newConfig?.constructor === Object) {
+ newConfig = [newConfig];
+ }
+
+ for (let i = 0; i < newConfig.length; i++) {
+ const _auth = newConfig[i];
+ if (!_auth?.accessKeyId || !_auth?.secretAccessKey || !_auth?.url || !_auth?.region) {
+ throw new Error("S3 Storage credentials not correct or missing - did you provide correct credentials?")
+ }
+ }
+
+ _config.storages = [...newConfig];
+ _config.accessKeyId = _config.storages[0].accessKeyId;
+ _config.secretAccessKey = _config.storages[0].secretAccessKey;
+ _config.region = _config.storages[0].region;
+ _config.url = _config.storages[0].url;
+ _config.activeStorage = 0;
+}
+
+module.exports = (config) => {
+ setConfig(config);
+ return {
+ downloadFile,
+ uploadFile,
+ deleteFile,
+ deleteFiles,
+ listFiles,
+ headBucket,
+ listBuckets,
+ getFileMetadata,
+ setFileMetadata,
+ setTimeout,
+ getConfig,
+ setConfig,
+ xmlToJson,
+ setLogFunction,
+ getMetadataTotalBytes
+ }
+}
+
+/******************** UTILS **********************/
+
+/**
+ * Used for the 'Content-MD5' header:
+ * The base64-encoded 128-bit MD5 digest of the message
+ * (without the headers) according to RFC 1864.
+ */
+function getMD5 (data) {
+ try {
+ return crypto.createHash('md5').update(typeof data === 'string' ? Buffer.from(data) : data ).digest('base64');
+ } catch(err) {
+ log(`S3 Storage | getMD5: ${err.toString()}`, "error");
+ return '';
+ }
+}
+
+/**
+ * Convert an object of queries into a concatenated string of URL parameters.
+ * @param {Object|String} queries
+ * @param {String} defaultQueries
+ * @returns {String} URL parameters
+ */
+function getUrlParameters (queries, defaultQueries) {
+ let _queries = '';
+
+ if (defaultQueries) {
+ _queries += defaultQueries + '&';
+ }
+
+ if (queries && typeof queries === 'string') {
+ _queries += queries;
+ } else if (queries && typeof queries === "object") {
+ const _queriesEntries = Object.keys(queries);
+ const _totalQueries = _queriesEntries.length;
+ for (let i = 0; i < _totalQueries; i++) {
+ _queries += `${_queriesEntries[i]}=${encodeURIComponent(queries[_queriesEntries[i]])}`
+ if (i + 1 !== _totalQueries) {
+ _queries += '&'
+ }
+ }
+ }
+ return _queries ? '?' + _queries : '';
+}
+
+function getMetadataTotalBytes(header){
+ let _str = '';
+ for (const key in header) {
+ const element = header[key];
+ if (key.includes('x-amz-meta-') === true ) {
+ _str += key.replace('x-amz-meta-', ''); /** must count the metadata name without "x-amz-meta-" */
+ _str += element;
+ }
+ }
+ return Buffer.from(_str).length
+}
+
+/**
+ * log messages
+ *
+ * @param {String} msg Message
+ * @param {type} type warning, error
+ */
+function log(msg, level = '') {
+ return console.log(level === 'error' ? `❗️ Error: ${msg}` : level === 'warning' ? `⚠️ ${msg}` : msg );
+}
+
+/**
+ * Override the log function, it takes to arguments: message, level
+ * @param {Function} newLogFunction (message, level) => {} The level can be: `info`, `warning`, `error`
+ */
+function setLogFunction (newLogFunction) {
+ if (newLogFunction) {
+ // eslint-disable-next-line no-func-assign
+ log = newLogFunction;
+ }
+}
\ No newline at end of file
diff --git a/swift.js b/swift.js
new file mode 100644
index 0000000..b8970c1
--- /dev/null
+++ b/swift.js
@@ -0,0 +1,709 @@
+const get = require('simple-get');
+const fs = require('fs');
+const { Readable } = require('stream');
+
+let _config = {
+ storages: [],
+ activeStorage: 0,
+ endpoints: {},
+ token: '',
+ timeout: 5000
+}
+
+/**
+ * @description Authenticate and initialise the auth token and retreive the endpoint based on the region
+ *
+ * @param {function} callback function(err):void = The `err` is null by default, return an object if an error occurs.
+ */
+function connection (callback, originStorage = 0) {
+ const arrayArguments = [callback, originStorage];
+
+ if (_config.activeStorage === _config.storages.length) {
+ /** Reset the index of the actual storage */
+ _config.activeStorage = 0;
+ log(`Object Storages are not available`, 'error');
+ return callback(new Error('Object Storages are not available'));
+ }
+ const _storage = _config.storages[_config.activeStorage];
+ log(`Object Storage index "${_config.activeStorage}" region "${_storage.region}" connection...`, 'info');
+ const _json = {
+ auth : {
+ identity : {
+ methods : ['password'],
+ password : {
+ user : {
+ name : _storage.username,
+ domain : { id : 'default' },
+ password : _storage.password
+ }
+ }
+ },
+ scope : {
+ project : {
+ domain : {
+ id : 'default'
+ },
+ name : _storage.tenantName
+ }
+ }
+ }
+ };
+
+ get.concat({
+ url : `${_storage.authUrl}/auth/tokens`,
+ method : 'POST',
+ json : true,
+ body : _json,
+ timeout: _config.timeout
+ }, (err, res, data) => {
+ if (err) {
+ log(`Object Storage index "${_config.activeStorage}" region "${_storage.region}" Action "connection" ${err.toString()}`, 'error');
+ activateFallbackStorage(originStorage);
+ arrayArguments[1] = _config.activeStorage;
+ return connection.apply(null, arrayArguments);
+ }
+
+ if (res.statusCode < 200 || res.statusCode >= 300) {
+ log(`Object Storage index "${_config.activeStorage}" region "${_storage.region}" connexion failled | Status ${res.statusCode.toString()} | Message: ${res.statusMessage}`, 'error');
+ activateFallbackStorage(originStorage);
+ arrayArguments[1] = _config.activeStorage;
+ return connection.apply(null, arrayArguments);
+ }
+
+ _config.token = res.headers['x-subject-token'];
+
+ const _serviceCatalog = data.token.catalog.find((element) => {
+ return element.type === 'object-store';
+ });
+
+ if (!_serviceCatalog) {
+ log(`Object Storage index "${_config.activeStorage}" region "${_storage.region}" Storage catalog not found`, 'error');
+ activateFallbackStorage(originStorage);
+ arrayArguments[1] = _config.activeStorage;
+ return connection.apply(null, arrayArguments);
+ }
+
+ _config.endpoints = _serviceCatalog.endpoints.find((element) => {
+ return element.region === _storage.region;
+ });
+
+ if (!_config.endpoints) {
+ log(`Object Storage index "${_config.activeStorage}" region "${_storage.region} Storage endpoint not found, invalid region`, 'error');
+ activateFallbackStorage(originStorage);
+ arrayArguments[1] = _config.activeStorage;
+ return connection.apply(null, arrayArguments);
+ }
+ log(`Object Storage index "${_config.activeStorage}" region "${_storage.region}" connected!`, 'info');
+ return callback(null);
+ });
+}
+/**
+ * @description List objects from a container. It is possible to pass as a second argument as an object with queries or headers to overwrite the request.
+ *
+ * @param {String} container container name
+ * @param {Object} options [OPTIONAL]: { headers: {}, queries: {} } List of headers and queries: https://docs.openstack.org/api-ref/object-store/?expanded=show-container-details-and-list-objects-detail#show-container-details-and-list-objects
+ * @param {function} callback function(err, body):void = The second argument `body` is the content of the file as a Buffer. The `err` argument is null by default, return an object if an error occurs.
+ */
+function listFiles(container, options, callback) {
+ const arrayArguments = [...arguments];
+
+ if (callback === undefined) {
+ callback = options;
+ arrayArguments.push(options);
+ options = { headers: {}, queries: {} };
+ arrayArguments[1] = options;
+ }
+
+ arrayArguments.push({ originStorage : _config.activeStorage })
+
+ const { headers, queries } = getHeaderAndQueryParameters(options);
+ get.concat({
+ url : `${_config.endpoints.url}/${container}${queries}`,
+ method : 'GET',
+ headers : {
+ 'X-Auth-Token' : _config.token,
+ Accept : 'application/json',
+ ...headers
+ },
+ timeout: _config.timeout
+ }, (err, res, body) => {
+
+ /** Manage special errors: timeouts, too many redirects or any unexpected behavior */
+ res = res || {};
+ res.error = err && err.toString().length > 0 ? err.toString() : null;
+
+ checkIsConnected(res, 'listFiles', arrayArguments, (error) => {
+ if (error) {
+ return callback(error);
+ }
+
+ if (res && res.statusCode === 404) {
+ return callback(new Error('Container does not exist'));
+ }
+
+ err = err || checkResponseError(res);
+
+ /** TODO: remove? it should never happen as every error switch to another storage */
+ if (err) {
+ return callback(err);
+ }
+
+ return callback(null, body);
+ });
+ });
+}
+
+/**
+ * @description Save a file on the OVH Object Storage
+ *
+ * @param {string} container Container name
+ * @param {string} filename file to store
+ * @param {string|Buffer} localPathOrBuffer absolute path to the file
+ * @param {Object} options [OPTIONAL]: { headers: {}, queries: {} } List of query parameters and headers: https://docs.openstack.org/api-ref/object-store/?expanded=create-or-replace-object-detail#create-or-replace-object
+ * @param {function} callback function(err):void = The `err` is null by default, return an object if an error occurs.
+ * @returns {void}
+ */
+function uploadFile (container, filename, localPathOrBuffer, options, callback) {
+ let readStream = Buffer.isBuffer(localPathOrBuffer) === true ? Readable.from(localPathOrBuffer) : fs.createReadStream(localPathOrBuffer);
+
+ const arrayArguments = [...arguments];
+
+ if (callback === undefined) {
+ callback = options;
+ arrayArguments.push(options);
+ options = { headers: {}, queries: {} };
+ arrayArguments[3] = options;
+ }
+
+ arrayArguments.push({ originStorage : _config.activeStorage })
+
+ const { headers, queries } = getHeaderAndQueryParameters(options);
+ get.concat({
+ url : `${_config.endpoints.url}/${container}/${filename}${queries}`,
+ method : 'PUT',
+ body : readStream,
+ headers : {
+ 'X-Auth-Token' : _config.token,
+ Accept : 'application/json',
+ ...headers
+ },
+ timeout: _config.timeout
+ }, (err, res, body) => {
+
+ /** Manage special errors: timeouts, too many redirects or any unexpected behavior */
+ res = res || {};
+ res.error = err && err.toString().length > 0 && err.code !== 'ENOENT' ? err.toString() : null;
+
+ checkIsConnected(res, 'uploadFile', arrayArguments, (error) => {
+ if (error) {
+ return callback(error);
+ }
+
+ err = err || checkResponseError(res, body.toString());
+
+ if (err) {
+ if (err.code === 'ENOENT') {
+ return callback(new Error('The local file does not exist'));
+ }
+
+ return callback(err);
+ }
+ return callback(null);
+ });
+ });
+}
+
+/**
+ * @description Download a file from the OVH Object Storage
+ *
+ * @param {string} container Container name
+ * @param {string} filename filename to download
+ * @param {function} callback function(err, body):void = The second argument `body` is the content of the file as a Buffer. The `err` argument is null by default, return an object if an error occurs.
+ * @returns {void}
+ */
+function downloadFile (container, filename, callback) {
+
+ const arrayArguments = [...arguments, { originStorage : _config.activeStorage }];
+
+ get.concat({
+ url : `${_config.endpoints.url}/${container}/${filename}`,
+ method : 'GET',
+ headers : {
+ 'X-Auth-Token' : _config.token,
+ Accept : 'application/json'
+ },
+ timeout: _config.timeout
+ }, (err, res, body) => {
+
+ /** Manage special errors: timeouts, too many redirects or any unexpected behavior */
+ res = res || {};
+ res.error = err && err.toString().length > 0 ? err.toString() : null;
+
+ checkIsConnected(res, 'downloadFile', arrayArguments, (error) => {
+ if (error) {
+ return callback(error);
+ }
+
+ if (res && res.statusCode === 404) {
+ return callback(new Error('File does not exist'));
+ }
+
+ err = err || checkResponseError(res);
+
+ /** TODO: remove? it should never happen as every error switch to another storage */
+ if (err) {
+ return callback(err);
+ }
+
+ return callback(null, body, res.headers);
+ });
+ });
+}
+
+/**
+ * @description Delete a file from the OVH Object Storage
+ *
+ * @param {string} container Container name
+ * @param {string} filename filename to store
+ * @param {function} callback function(err):void = The `err` argument is null by default, return an object if an error occurs.
+ * @returns {void}
+ */
+function deleteFile (container, filename, callback) {
+
+ const arrayArguments = [...arguments, { originStorage : _config.activeStorage }];
+
+ get.concat({
+ url : `${_config.endpoints.url}/${container}/${filename}`,
+ method : 'DELETE',
+ headers : {
+ 'X-Auth-Token' : _config.token,
+ Accept : 'application/json'
+ },
+ timeout: _config.timeout
+ }, (err, res) => {
+
+ /** Manage special errors: timeouts, too many redirects or any unexpected behavior */
+ res = res || {};
+ res.error = err && err.toString().length > 0 ? err.toString() : null;
+
+ checkIsConnected(res, 'deleteFile', arrayArguments, (error) => {
+ if (error) {
+ return callback(error);
+ }
+
+ if (res && res.statusCode === 404) {
+ return callback(new Error('File does not exist'));
+ }
+
+ err = err || checkResponseError(res);
+
+ /** TODO: remove? it should never happen as every error switch to another storage */
+ if (err) {
+ return callback(err);
+ }
+
+ return callback(null);
+ });
+ });
+}
+
+/**
+ * @description Get object metadata
+ *
+ * @param {string} container Container name
+ * @param {string} filename filename to store
+ * @param {function} callback function(err, headers):void = The `err` argument is null by default, return an object if an error occurs.
+ * @returns {void}
+ */
+function getFileMetadata(container, filename, callback) {
+ const arrayArguments = [...arguments, { originStorage : _config.activeStorage }];
+
+ get.concat({
+ url : `${_config.endpoints.url}/${container}/${filename}`,
+ method : 'HEAD',
+ headers : {
+ 'X-Auth-Token' : _config.token,
+ Accept : 'application/json'
+ },
+ timeout: _config.timeout
+ }, (err, res) => {
+
+ /** Manage special errors: timeouts, too many redirects or any unexpected behavior */
+ res = res || {};
+ res.error = err && err.toString().length > 0 ? err.toString() : null;
+
+ checkIsConnected(res, 'getFileMetadata', arrayArguments, (error) => {
+ if (error) {
+ return callback(error);
+ }
+
+ if (res && res.statusCode === 404) {
+ return callback(new Error('File does not exist'));
+ }
+
+ err = err || checkResponseError(res);
+
+ /** TODO: remove? it should never happen as every error switch to another storage */
+ if (err) {
+ return callback(err);
+ }
+
+ return callback(null, res.headers);
+ });
+ });
+ }
+
+ /**
+ * @description Create or update object metadata.
+ * @description To create or update custom metadata
+ * @description use the X-Object-Meta-name header,
+ * @description where name is the name of the metadata item.
+ *
+ * @param {string} container Container name
+ * @param {string} filename file to store
+ * @param {string|Buffer} localPathOrBuffer absolute path to the file
+ * @param {Object} options { headers: {}, queries: {} } List of query parameters and headers: https://docs.openstack.org/api-ref/object-store/?expanded=create-or-update-object-metadata-detail#create-or-update-object-metadata
+ * @param {function} callback function(err, headers):void = The `err` is null by default, return an object if an error occurs.
+ * @returns {void}
+ */
+function setFileMetadata (container, filename, options, callback) {
+
+ const arrayArguments = [...arguments];
+
+ if (callback === undefined) {
+ callback = options;
+ arrayArguments.push(options);
+ options = { headers: {}, queries: {} };
+ arrayArguments[3] = options;
+ }
+
+ arrayArguments.push({ originStorage : _config.activeStorage })
+
+ const { headers, queries } = getHeaderAndQueryParameters(options);
+ get.concat({
+ url : `${_config.endpoints.url}/${container}/${filename}${queries}`,
+ method : 'POST',
+ headers : {
+ 'X-Auth-Token' : _config.token,
+ Accept : 'application/json',
+ ...headers
+ },
+ timeout: _config.timeout
+ }, (err, res) => {
+
+ /** Manage special errors: timeouts, too many redirects or any unexpected behavior */
+ res = res || {};
+ res.error = err && err.toString().length > 0 ? err.toString() : null;
+
+ checkIsConnected(res, 'setFileMetadata', arrayArguments, (error) => {
+ if (error) {
+ return callback(error);
+ }
+
+ if (res && res.statusCode === 404) {
+ return callback(new Error('File does not exist'));
+ }
+
+ err = err || checkResponseError(res);
+
+ /** TODO: remove? it should never happen as every error switch to another storage */
+ if (err) {
+ return callback(err);
+ }
+ return callback(null, res.headers);
+ });
+ });
+}
+
+ /**
+ * @description Send a custom request to the object storage
+ *
+ * @param {string} method HTTP method used (POST, COPY, etc...)
+ * @param {string} path path requested, passing an empty string will request the account details. For container request pass the container name, such as: '/containerName'. For file request, pass the container and the file, such as: '/container/filename.txt'.
+ * @param {Object} options { headers: {}, queries: {}, body: '' } Pass to the request the body, query parameters and/or headers. List of headers: https://docs.openstack.org/api-ref/object-store/?expanded=create-or-update-object-metadata-detail#create-or-update-object-metadata
+ * @param {function} callback function(err, body, headers):void = The `err` is null by default.
+ * @returns {void}
+ */
+function request (method, path, options, callback) {
+
+ const arrayArguments = [...arguments];
+
+ if (callback === undefined) {
+ callback = options;
+ arrayArguments.push(options);
+ options = { headers: {}, queries: {}, body: null };
+ arrayArguments[3] = options;
+ }
+
+ arrayArguments.push({ originStorage : _config.activeStorage })
+
+ const { headers, queries, body } = getHeaderAndQueryParameters(options);
+
+ const _requestOptions = {
+ url : `${_config.endpoints.url}${path}${queries}`,
+ method : method,
+ headers : {
+ 'X-Auth-Token' : _config.token,
+ Accept : 'application/json',
+ ...headers
+ },
+ timeout: _config.timeout,
+ ...(body ? { body } : {})
+ }
+
+ const _requestCallback = function (err, res, body) {
+ /** Manage special errors: timeouts, too many redirects or any unexpected behavior */
+ res = res || {};
+ res.error = err && err.toString().length > 0 ? err.toString() : null;
+ checkIsConnected(res, 'request', arrayArguments, (error) => {
+ if (error) {
+ return callback(error);
+ }
+ err = err || checkResponseError(res);
+
+ /** TODO: remove? it should never happen as every error switch to another storage */
+ if (err) {
+ return callback(err);
+ }
+ return options?.stream === true ? callback(null, res) : callback(null, body, res.headers);
+ });
+ }
+ return options?.stream === true ? get(_requestOptions, _requestCallback) : get.concat(_requestOptions, _requestCallback);
+}
+
+/**
+ * @description Check the response status code and return an Error.
+ *
+ * @param {Object} response Response object from request
+ * @returns {null|Error}
+ */
+function checkResponseError (response, body = '') {
+ /** TODO: remove? it should never happen as every error switch to another storage */
+ if (!response) {
+ return new Error('No response');
+ }
+
+ if (response.statusCode < 200 || response.statusCode >= 300) {
+ return new Error(`${response.statusCode.toString()} ${response.statusMessage || body}`);
+ }
+
+ return null;
+}
+
+/**
+ * @description Check if the request is authorized, if not, it authenticate again to generate a new token, and execute again the initial request.
+ *
+ * @param {Object} response Request response
+ * @param {String} from Original function called
+ * @param {Object} args Arguments of the original function.
+ * @param {function} callback function(err):void = The `err` argument is null by default, return an object if an error occurs.
+ * @returns {void}
+ */
+function checkIsConnected (response, from, args, callback) {
+ if (!response || (response?.statusCode < 500 && response?.statusCode !== 401) || (!response?.statusCode && !!response?.error !== true)) {
+ return callback(null);
+ }
+
+ if (response?.statusCode >= 500) {
+ log(`Object Storage index "${_config.activeStorage}" region "${_config.storages[_config.activeStorage].region}" Action "${from}" Status ${response?.statusCode}`, 'error');
+ activateFallbackStorage(args[args.length - 1].originStorage);
+ }
+
+ if (!!response?.error === true) {
+ log(`Object Storage index "${_config.activeStorage}" region "${_config.storages[_config.activeStorage].region}" Action "${from}" ${response.error}`, 'error');
+ activateFallbackStorage(args[args.length - 1].originStorage);
+ }
+
+ if (response?.statusCode === 401) {
+ log(`Object Storage index "${_config.activeStorage}" region "${_config.storages[_config.activeStorage].region}" try reconnect...`, 'info');
+ }
+
+ // Reconnect to object storage
+ connection((err) => {
+ if (err) {
+ return callback(err);
+ }
+
+ switch (from) {
+ case 'downloadFile':
+ downloadFile.apply(null, args);
+ break;
+ case 'uploadFile':
+ uploadFile.apply(null, args);
+ break;
+ case 'deleteFile':
+ deleteFile.apply(null, args);
+ break;
+ case 'listFiles':
+ listFiles.apply(null, args);
+ break;
+ case 'getFileMetadata':
+ getFileMetadata.apply(null, args);
+ break;
+ case 'setFileMetadata':
+ setFileMetadata.apply(null, args);
+ break;
+ case 'request':
+ request.apply(null, args);
+ break;
+ default:
+ /** TODO: remove? it should never happen */
+ return callback(null);
+ }
+ }, args[args.length - 1].originStorage);
+}
+
+
+/**
+ * @description Set and overwrite the Object Storage SDK configurations
+ *
+ * @param {Object} config
+ * @param {String} config.authUrl URL used for authentication, default: "https://auth.cloud.ovh.net/v3"
+ * @param {String} config.username Username for authentication
+ * @param {String} config.password Password for authentication
+ * @param {String} config.tenantName Tenant Name/Tenant ID for authentication
+ * @param {String} config.region Region used to retreive the Object Storage endpoint to request
+ */
+function setStorages(storages) {
+ _config.token = '';
+ _config.endpoints = {};
+ _config.activeStorage = 0;
+ if (Array.isArray(storages) === true) {
+ /** List of storage */
+ _config.storages = storages;
+ } else if (typeof storages === 'object') {
+ /** Only a single storage is passed */
+ _config.storages = [];
+ _config.storages.push(storages)
+ }
+}
+
+/**
+ * Set the timeout
+ *
+ * @param {Integer} timeout
+ */
+function setTimeout(timeout) {
+ _config.timeout = timeout;
+}
+
+/**
+ * @description Return the list of storages
+ *
+ * @returns {String} The list of storages
+ */
+function getStorages() {
+ return _config.storages;
+}
+
+/**
+ * @description Return the configuration object
+ *
+ * @returns {String} The list of storages
+ */
+function getConfig() {
+ return _config;
+}
+
+/**
+ * log messages
+ *
+ * @param {String} msg Message
+ * @param {type} type warning, error
+ */
+function log(msg, level = 'info') {
+ return console.log(level === 'error' ? `❗️ Error: ${msg}` : level === 'warning' ? `⚠️ ${msg}` : msg );
+}
+
+/**
+ * Override the log function, it takes to arguments: message, level
+ * @param {Function} newLogFunction (message, level) => {} The level can be: `info`, `warning`, `error`
+ */
+function setLogFunction (newLogFunction) {
+ if (newLogFunction) {
+ // eslint-disable-next-line no-func-assign
+ log = newLogFunction;
+ }
+}
+
+/**
+ *
+ * @description Initialise and return an instance of the Object Storage SDK.
+ *
+ * @param {Object} config
+ * @param {String} config.authUrl URL used for authentication, default: "https://auth.cloud.ovh.net/v3"
+ * @param {String} config.username Username for authentication
+ * @param {String} config.password Password for authentication
+ * @param {String} config.tenantName Tenant Name/Tenant ID for authentication
+ * @param {String} config.region Region used to retreive the Object Storage endpoint to request
+ */
+module.exports = (config) => {
+ setStorages(config)
+ return {
+ connection,
+ uploadFile,
+ downloadFile,
+ deleteFile,
+ listFiles,
+ getFileMetadata,
+ setFileMetadata,
+ setTimeout,
+ setStorages,
+ getStorages,
+ getConfig,
+ setLogFunction,
+ request
+ }
+}
+
+/** ============ Utils =========== */
+
+/**
+ * Convert an Object of query parameters into a string
+ * Example: { "prefix" : "user_id_1234", "format" : "xml"} => "?prefix=user_id_1234&format=xml"
+ *
+ * @param {Object} queries
+ * @returns
+ */
+function getQueryParameters (queries) {
+ let _queries = '';
+
+ if (queries && typeof queries === "object") {
+ const _queriesEntries = Object.keys(queries);
+ const _totalQueries = _queriesEntries.length;
+ for (let i = 0; i < _totalQueries; i++) {
+ if (i === 0) {
+ _queries += '?'
+ }
+ _queries += `${_queriesEntries[i]}=${queries[_queriesEntries[i]]}`
+ if (i + 1 !== _totalQueries) {
+ _queries += '&'
+ }
+ }
+ }
+ return _queries;
+}
+
+function getHeaderAndQueryParameters (options) {
+ let headers = {};
+ let queries = '';
+ let body = null
+
+ if (options?.queries) {
+ queries = getQueryParameters(options.queries);
+ }
+ if (options?.headers) {
+ headers = options.headers;
+ }
+ if (options?.body) {
+ body = options.body;
+ }
+ return { headers, queries, body }
+}
+
+function activateFallbackStorage(originStorage) {
+ if (originStorage === _config.activeStorage && _config.activeStorage + 1 <= _config.storages.length) {
+ _config.activeStorage += 1;
+ log(`Object Storage Activate Fallback Storage index "${_config.activeStorage}" 🚩`, 'warning');
+ }
+}
\ No newline at end of file
diff --git a/tests/assets/listObjects.prefix.response.json b/tests/assets/listObjects.prefix.response.json
new file mode 100644
index 0000000..ea23be1
--- /dev/null
+++ b/tests/assets/listObjects.prefix.response.json
@@ -0,0 +1,22 @@
+{
+ "name": "www",
+ "keycount": 2,
+ "maxkeys": 2,
+ "istruncated": true,
+ "contents": [
+ {
+ "key": "document-1.docx",
+ "lastmodified": "2023-03-07T17:03:59.000Z",
+ "etag": "a55b475be5fc06d42e1baf84231253ce",
+ "size": 236208,
+ "storageclass": "STANDARD"
+ },
+ {
+ "key": "document-2.odt",
+ "lastmodified": "2023-03-02T07:18:55.000Z",
+ "etag": "fde6d729123cee4db6bfa3606306bc8c",
+ "size": 11822,
+ "storageclass": "STANDARD"
+ }
+ ]
+}
\ No newline at end of file
diff --git a/tests/assets/listObjects.prefix.response.xml b/tests/assets/listObjects.prefix.response.xml
new file mode 100644
index 0000000..39ba3f3
--- /dev/null
+++ b/tests/assets/listObjects.prefix.response.xml
@@ -0,0 +1,22 @@
+
+
+ www
+
+ 2
+ 2
+ true
+
+ document-1.docx
+ 2023-03-07T17:03:59.000Z
+ "a55b475be5fc06d42e1baf84231253ce"
+ 236208
+ STANDARD
+
+
+ document-2.odt
+ 2023-03-02T07:18:55.000Z
+ "fde6d729123cee4db6bfa3606306bc8c"
+ 11822
+ STANDARD
+
+
\ No newline at end of file
diff --git a/tests/assets/listObjects.response.json b/tests/assets/listObjects.response.json
new file mode 100644
index 0000000..f0323d5
--- /dev/null
+++ b/tests/assets/listObjects.response.json
@@ -0,0 +1,36 @@
+{
+ "name": "www",
+ "keycount": 4,
+ "maxkeys": 1000,
+ "istruncated": false,
+ "contents": [
+ {
+ "key": "file-1.docx",
+ "lastmodified": "2023-03-07T17:03:54.000Z",
+ "etag": "7ad22b1297611d62ef4a4704c97afa6b",
+ "size": 61396,
+ "storageclass": "STANDARD"
+ },
+ {
+ "key": "file-2.odt",
+ "lastmodified": "2023-03-07T17:03:56.000Z",
+ "etag": "fa5678c105413929aa8f800b7a944d8e",
+ "size": 358358,
+ "storageclass": "STANDARD"
+ },
+ {
+ "key": "document-1.docx",
+ "lastmodified": "2023-03-07T17:03:59.000Z",
+ "etag": "a55b475be5fc06d42e1baf84231253ce",
+ "size": 236208,
+ "storageclass": "STANDARD"
+ },
+ {
+ "key": "document-2.odt",
+ "lastmodified": "2023-03-02T07:18:55.000Z",
+ "etag": "fde6d729123cee4db6bfa3606306bc8c",
+ "size": 11822,
+ "storageclass": "STANDARD"
+ }
+ ]
+}
\ No newline at end of file
diff --git a/tests/assets/listObjects.response.xml b/tests/assets/listObjects.response.xml
new file mode 100644
index 0000000..f69b9ce
--- /dev/null
+++ b/tests/assets/listObjects.response.xml
@@ -0,0 +1,36 @@
+
+
+ www
+
+ 4
+ 1000
+ false
+
+ file-1.docx
+ 2023-03-07T17:03:54.000Z
+ "7ad22b1297611d62ef4a4704c97afa6b"
+ 61396
+ STANDARD
+
+
+ file-2.odt
+ 2023-03-07T17:03:56.000Z
+ "fa5678c105413929aa8f800b7a944d8e"
+ 358358
+ STANDARD
+
+
+ document-1.docx
+ 2023-03-07T17:03:59.000Z
+ "a55b475be5fc06d42e1baf84231253ce"
+ 236208
+ STANDARD
+
+
+ document-2.odt
+ 2023-03-02T07:18:55.000Z
+ "fde6d729123cee4db6bfa3606306bc8c"
+ 11822
+ STANDARD
+
+
\ No newline at end of file
diff --git a/tests/s3.test.js b/tests/s3.test.js
new file mode 100644
index 0000000..62186c3
--- /dev/null
+++ b/tests/s3.test.js
@@ -0,0 +1,2494 @@
+const s3 = require('../s3.js');
+const assert = require('assert');
+const nock = require('nock');
+const fs = require('fs');
+const path = require('path');
+
+let storage = {};
+const url1S3 = 'https://s3.gra.first.cloud.test';
+const url2S3 = 'https://s3.de.first.cloud.test';
+
+/** ASSETS for download/upload */
+const fileTxtPath = path.join(__dirname, 'assets', 'file.txt');
+const fileTxt = fs.readFileSync(fileTxtPath).toString();
+const fileXmlPath = path.join(__dirname, 'assets', 'files.xml');
+const fileXml = fs.readFileSync(fileXmlPath).toString();
+/** ASSETS for List objects Requests */
+const _listObjectsResponseXML = fs.readFileSync(path.join(__dirname, "./assets", 'listObjects.response.xml'));
+const _listObjectsResponseJSON = require('./assets/listObjects.response.json');
+
+describe.only('S3 SDK', function () {
+
+ beforeEach(function() {
+ storage = s3([{
+ accessKeyId : '2371bebbe7ac4b2db39c09eadf011661',
+ secretAccessKey: '9978f6abf7f445566a2d316424aeef2',
+ url : url1S3.replace('https://', ''),
+ region : 'gra',
+ buckets : {
+ invoices : "invoices-gra-1234"
+ }
+ },
+ {
+ accessKeyId : '2371bebbe7ac4b2db39c09eadf011661',
+ secretAccessKey: '9978f6abf7f445566a2d316424aeef2',
+ url : url2S3.replace('https://', ''),
+ region : 'de',
+ buckets : {
+ invoices : "invoices-de-8888"
+ }
+ }]);
+ })
+
+ describe('constructor/getConfig/setConfig/setTimeout', function () {
+ it("should create a new s3 instance if the authentication is provided as Object", function () {
+ const _authS3 = { accessKeyId: '-', secretAccessKey: '-', region: '-', url: '-' }
+ const _storage = s3(_authS3);
+ const _config = _storage.getConfig()
+ assert.strictEqual(_config.timeout, 5000);
+ assert.strictEqual(_config.activeStorage, 0);
+ assert.strictEqual(_config.storages.length, 1);
+ assert.strictEqual(JSON.stringify(_config.storages[0]), JSON.stringify(_authS3))
+ })
+
+ it("should create a new s3 instance if the authentication is provided as List of objects", function () {
+ const _authS3 = [{ accessKeyId: 1, secretAccessKey: 2, region: 3, url: 4 }, { accessKeyId: 5, secretAccessKey: 6, region: 7, url: 8 }, { accessKeyId: 9, secretAccessKey: 10, region: 11, url: 12 }]
+ const _storage = s3(_authS3);
+ const _config = _storage.getConfig()
+ assert.strictEqual(_config.timeout, 5000);
+ assert.strictEqual(_config.activeStorage, 0);
+ assert.strictEqual(_config.storages.length, 3);
+ assert.strictEqual(JSON.stringify(_config.storages), JSON.stringify(_authS3))
+ })
+
+ it("should throw an error if authentication values are missing", function() {
+ assert.throws(function(){ s3({}) }, Error);
+ /** As object */
+ assert.throws(function(){ s3({accessKeyId: '', secretAccessKey: '', url: ''}) }, Error); // missing region
+ assert.throws(function(){ s3({accessKeyId: '', secretAccessKey: '', region: ''}) }, Error); // missing url
+ assert.throws(function(){ s3({accessKeyId: '', url: '', region: ''}) }, Error); // missing secretAccessKey
+ assert.throws(function(){ s3({secretAccessKey: '', url: '', region: ''}) }, Error); // missing accessKeyId
+ /** As array */
+ assert.throws(function(){ s3([{ accessKeyId: 1, secretAccessKey: 2, region: 3, url: 4 }, { accessKeyId: 5, secretAccessKey: 6, url: 8 }]) }, Error); // missing region
+ assert.throws(function(){ s3([{ accessKeyId: 1, secretAccessKey: 2, region: 3, url: 4 }, { accessKeyId: 5, secretAccessKey: 6, region: 8 }]) }, Error); // missing url
+ assert.throws(function(){ s3([{ accessKeyId: 1, secretAccessKey: 2, region: 3, url: 4 }, { accessKeyId: 5, region: 6, url: 8 }]) }, Error); // missing secretAccessKey
+ assert.throws(function(){ s3([{ accessKeyId: 1, secretAccessKey: 2, region: 3, url: 4 }, { secretAccessKey: 5, region: 6, url: 8 }]) }, Error); // missing accessKeyId
+ });
+
+ it("should set a new config", function () {
+ const _storage = s3({ accessKeyId: '-', secretAccessKey: '-', region: '-', url: '-' });
+ const _authS3 = [{ accessKeyId: 1, secretAccessKey: 2, region: 3, url: 4 }, { accessKeyId: 5, secretAccessKey: 6, region: 7, url: 8 }]
+ _storage.setConfig(_authS3)
+ const _config = _storage.getConfig()
+ assert.strictEqual(_config.timeout, 5000);
+ assert.strictEqual(_config.activeStorage, 0);
+ assert.strictEqual(_config.storages.length, 2);
+ assert.strictEqual(JSON.stringify(_config.storages), JSON.stringify(_authS3))
+ })
+
+ it("should set a new timeout value", function() {
+ const _storage = s3({ accessKeyId: '-', secretAccessKey: '-', region: '-', url: '-' });
+ assert.strictEqual(_storage.getConfig().timeout, 5000);
+ _storage.setTimeout(10000);
+ assert.strictEqual(_storage.getConfig().timeout, 10000);
+ });
+ })
+
+ describe('request - CALLBACK', function() {
+
+ describe("REQUEST MAIN STORAGE", function () {
+
+ });
+
+ describe("SWITCH TO CHILD STORAGE", function () {
+ });
+
+ });
+
+ describe('request - STREAM', function() {
+
+ describe("REQUEST MAIN STORAGE", function () {
+ });
+
+ describe("SWITCH TO CHILD STORAGE", function () {
+ });
+
+ });
+
+ describe('headBucket', function() {
+ describe("REQUEST MAIN STORAGE", function () {
+
+ it('should return code 200, and request signed with AWS4', function (done) {
+ const nockRequest = nock(url1S3,
+ {
+ reqheaders: {
+ 'x-amz-content-sha256': () => true,
+ 'x-amz-date': () => true,
+ 'authorization': () => true,
+ 'host': () => true
+ }
+ }).intercept("/customBucket", "HEAD").reply(200, '');
+
+ storage.headBucket('customBucket', function(err, resp) {
+ assert.strictEqual(err, null);
+ assert.strictEqual(resp.statusCode, 200);
+ assert.strictEqual(resp.body.toString(), '');
+ assert.strictEqual(nockRequest.pendingMocks().length, 0);
+ done();
+ });
+ });
+
+ it('should return code 200 and request a bucket as ALIAS', function (done) {
+ const nockRequest = nock(url1S3,
+ {
+ reqheaders: {
+ 'x-amz-content-sha256': () => true,
+ 'x-amz-date': () => true,
+ 'authorization': () => true,
+ 'host': () => true
+ }
+ }).intercept("/invoices-gra-1234", "HEAD").reply(200, '');
+
+ storage.headBucket('invoices', function(err, resp) {
+ assert.strictEqual(err, null);
+ assert.strictEqual(resp.statusCode, 200);
+ assert.strictEqual(resp.body.toString(), '');
+ assert.strictEqual(nockRequest.pendingMocks().length, 0);
+ done();
+ });
+ });
+
+ it('should return code 403 Forbidden', function (done) {
+ const nockRequest = nock(url1S3).intercept("/customBucket", "HEAD").reply(403, '');
+
+ storage.headBucket('customBucket', function(err, resp) {
+ assert.strictEqual(err, null);
+ assert.strictEqual(resp.statusCode, 403);
+ assert.strictEqual(resp.body.toString(), '');
+ assert.strictEqual(nockRequest.pendingMocks().length, 0);
+ done();
+ });
+ });
+ });
+
+ describe("SWITCH TO CHILD STORAGE", function () {
+ it('should switch to the child storage and return code 200 with bucket as ALIAS', function (done) {
+ const nockRequestS1 = nock(url1S3).intercept("/invoices-gra-1234", "HEAD").reply(500, '');
+ const nockRequestS2 = nock(url2S3).intercept("/invoices-de-8888", "HEAD").reply(200, '');
+ const nockRequestS3 = nock(url1S3).get('/').reply(500);
+
+ storage.headBucket('invoices', function(err, resp) {
+ assert.strictEqual(err, null);
+ assert.strictEqual(resp.statusCode, 200);
+ assert.strictEqual(resp.body.toString(), '');
+ assert.strictEqual(nockRequestS1.pendingMocks().length, 0);
+ assert.strictEqual(nockRequestS2.pendingMocks().length, 0);
+ assert.strictEqual(nockRequestS3.pendingMocks().length, 0);
+ done();
+ });
+ });
+ })
+ });
+
+ describe('listBuckets', function() {
+
+ describe("REQUEST MAIN STORAGE", function () {
+ it('should fetch a list of buckets', function (done) {
+ const _header = {
+ 'content-type': 'application/xml',
+ 'content-length': '366',
+ 'x-amz-id-2': 'tx606add09487142fa88e67-00641aacf4',
+ 'x-amz-request-id': 'tx606add09487142fa88e67-00641aacf4',
+ 'x-trans-id': 'tx606add09487142fa88e67-00641aacf4',
+ 'x-openstack-request-id': 'tx606add09487142fa88e67-00641aacf4',
+ date: 'Wed, 22 Mar 2023 07:23:32 GMT',
+ connection: 'close'
+ }
+
+ const nockRequest = nock(url1S3)
+ .defaultReplyHeaders(_header)
+ .get('/')
+ .reply(200, () => {
+ return "89123456:user-feiowjfOEIJW12345678:user-feiowjfOEIJWinvoices2023-02-27T11:46:24.000Zwww2023-02-27T11:46:24.000Z";
+ });
+
+ storage.listBuckets((err, resp) => {
+ assert.strictEqual(err, null);
+ assert.strictEqual(resp.statusCode, 200);
+ assert.strictEqual(JSON.stringify(resp.body), JSON.stringify({
+ "bucket": [
+ { "name": "invoices", "creationdate": "2023-02-27T11:46:24.000Z" },
+ { "name": "www", "creationdate": "2023-02-27T11:46:24.000Z" }
+ ]
+ }));
+ assert.strictEqual(JSON.stringify(resp.headers), JSON.stringify(_header))
+ assert.strictEqual(nockRequest.pendingMocks().length, 0);
+ done();
+ })
+ })
+
+ it('should return an error if credentials are not correct', function (done) {
+ const _header = {
+ 'x-amz-request-id': 'BEFVPYB9PM889VMS',
+ 'x-amz-id-2': 'Pnby9XcoK7X/GBpwr+vVV/X3XyadxsUkTzGdSJS5zRMhs2RvZDGroWleytOYGmYRSszFbsaZWUo=',
+ 'content-type': 'application/xml',
+ 'transfer-encoding': 'chunked',
+ date: 'Wed, 22 Mar 2023 07:37:22 GMT',
+ server: 'AmazonS3',
+ connection: 'close'
+ }
+
+ const nockRequest = nock(url1S3)
+ .defaultReplyHeaders(_header)
+ .get('/')
+ .reply(403, () => {
+ return "InvalidAccessKeyIdThe AWS Access Key Id you provided does not exist in our records.AKIAUO7WHYLVFADDFL57eBSTT951V1FREKS2XzWFC8ZOiZvyxTUgcYjHDD9rmPDG81TCJHkZhAv4zgguuR5I9aeqSFA9Ns4r5PdKy9+9o+xDLpOk=";
+ });
+
+ storage.listBuckets((err, resp) => {
+ assert.strictEqual(err, null);
+ assert.strictEqual(resp.statusCode, 403);
+ assert.strictEqual(JSON.stringify(resp.body), JSON.stringify({
+ error: {
+ code: 'InvalidAccessKeyId',
+ message: 'The AWS Access Key Id you provided does not exist in our records.',
+ awsaccesskeyid: 'AKIAUO7WHYLVFADDFL57e',
+ requestid: 'BSTT951V1FREKS2X',
+ hostid: 'zWFC8ZOiZvyxTUgcYjHDD9rmPDG81TCJHkZhAv4zgguuR5I9aeqSFA9Ns4r5PdKy9+9o+xDLpOk='
+ }
+ }));
+ assert.strictEqual(JSON.stringify(resp.headers), JSON.stringify(_header))
+ assert.strictEqual(nockRequest.pendingMocks().length, 0);
+ done();
+ })
+ })
+ });
+
+ describe("SWITCH TO CHILD STORAGE", function () {
+ it('should fetch a list of buckets', function (done) {
+ const nockRequestS1 = nock(url1S3)
+ .get('/')
+ .reply(500, '');
+
+ const nockRequestS2 = nock(url2S3)
+ .get('/')
+ .reply(200, () => {
+ return "89123456:user-feiowjfOEIJW12345678:user-feiowjfOEIJWinvoices2023-02-27T11:46:24.000Zwww2023-02-27T11:46:24.000Z";
+ });
+
+ const nockRequestS3 = nock(url1S3)
+ .get('/')
+ .reply(500);
+
+ storage.listBuckets((err, resp) => {
+ assert.strictEqual(err, null);
+ assert.strictEqual(resp.statusCode, 200);
+ assert.strictEqual(JSON.stringify(resp.body), JSON.stringify({
+ "bucket": [
+ { "name": "invoices", "creationdate": "2023-02-27T11:46:24.000Z" },
+ { "name": "www", "creationdate": "2023-02-27T11:46:24.000Z" }
+ ]
+ }));
+ assert.strictEqual(JSON.stringify(resp.headers), JSON.stringify({}))
+ assert.strictEqual(nockRequestS1.pendingMocks().length, 0);
+ assert.strictEqual(nockRequestS2.pendingMocks().length, 0);
+ assert.strictEqual(nockRequestS3.pendingMocks().length, 0);
+ done();
+ })
+ })
+ });
+
+ describe("Options 'requestStorageIndex'", function() {
+
+ it("should request the first storage and should return an error if the first storage is not available", function(done) {
+ const nockRequestS1 = nock(url1S3)
+ .get('/')
+ .reply(500, '');
+
+ storage.listBuckets({ requestStorageIndex: 0 }, (err, resp) => {
+ assert.strictEqual(err, null);
+ assert.strictEqual(resp.statusCode, 500);
+ assert.strictEqual(resp.body.toString(), '');
+ assert.strictEqual(JSON.stringify(resp.headers), JSON.stringify({}))
+ assert.strictEqual(nockRequestS1.pendingMocks().length, 0);
+ done();
+ })
+ })
+
+ it("should request the second storage and should return an error if the second storage is not available", function(done) {
+ const nockRequestS1 = nock(url2S3)
+ .get('/')
+ .reply(500, '');
+
+ storage.listBuckets({ requestStorageIndex: 1 }, (err, resp) => {
+ assert.strictEqual(err, null);
+ assert.strictEqual(resp.statusCode, 500);
+ assert.strictEqual(resp.body.toString(), '');
+ assert.strictEqual(JSON.stringify(resp.headers), JSON.stringify({}))
+ assert.strictEqual(nockRequestS1.pendingMocks().length, 0);
+ done();
+ })
+ })
+
+ it("should request the second storage and get a list of buckets", function(done) {
+ const nockRequestS1 = nock(url2S3)
+ .get('/')
+ .reply(200, () => {
+ return "89123456:user-feiowjfOEIJW12345678:user-feiowjfOEIJWinvoices2023-02-27T11:46:24.000Zwww2023-02-27T11:46:24.000Z";
+ });
+
+ storage.listBuckets({ requestStorageIndex: 1 }, (err, resp) => {
+ assert.strictEqual(err, null);
+ assert.strictEqual(resp.statusCode, 200);
+ assert.strictEqual(JSON.stringify(resp.body), JSON.stringify({
+ "bucket": [
+ { "name": "invoices", "creationdate": "2023-02-27T11:46:24.000Z" },
+ { "name": "www", "creationdate": "2023-02-27T11:46:24.000Z" }
+ ]
+ }));
+ assert.strictEqual(JSON.stringify(resp.headers), JSON.stringify({}))
+ assert.strictEqual(nockRequestS1.pendingMocks().length, 0);
+ done();
+ })
+ })
+ })
+
+ });
+
+ describe('listFiles', function() {
+
+ describe("REQUEST MAIN STORAGE", function () {
+ it('should fetch a list of objects', function (done) {
+ const _header = {
+ 'content-type': 'application/xml',
+ 'content-length': '1887',
+ 'x-amz-id-2': 'txf0b438dfd25b444ba3f60-00641807d7',
+ 'x-amz-request-id': 'txf0b438dfd25b444ba3f60-00641807d7',
+ 'x-trans-id': 'txf0b438dfd25b444ba3f60-00641807d7',
+ 'x-openstack-request-id': 'txf0b438dfd25b444ba3f60-00641807d7',
+ date: 'Mon, 20 Mar 2023 07:14:31 GMT',
+ connection: 'close'
+ }
+
+ const nockRequest = nock(url1S3)
+ .defaultReplyHeaders(_header)
+ .get('/bucket')
+ .query({ 'list-type' : 2 })
+ .reply(200, () => {
+ return _listObjectsResponseXML;
+ });
+
+ storage.listFiles('bucket', (err, resp) => {
+ assert.strictEqual(err, null);
+ assert.strictEqual(resp.statusCode, 200);
+ assert.strictEqual(JSON.stringify(resp.body), JSON.stringify(_listObjectsResponseJSON));
+ assert.strictEqual(JSON.stringify(resp.headers), JSON.stringify(_header))
+ assert.strictEqual(nockRequest.pendingMocks().length, 0);
+ done();
+ })
+ })
+
+ it('should fetch a list of objects from a bucket as ALIAS', function (done) {
+ const _header = {
+ 'content-type': 'application/xml',
+ 'content-length': '1887',
+ 'x-amz-id-2': 'txf0b438dfd25b444ba3f60-00641807d7',
+ 'x-amz-request-id': 'txf0b438dfd25b444ba3f60-00641807d7',
+ 'x-trans-id': 'txf0b438dfd25b444ba3f60-00641807d7',
+ 'x-openstack-request-id': 'txf0b438dfd25b444ba3f60-00641807d7',
+ date: 'Mon, 20 Mar 2023 07:14:31 GMT',
+ connection: 'close'
+ }
+
+ const nockRequest = nock(url1S3)
+ .defaultReplyHeaders(_header)
+ .get('/invoices-gra-1234')
+ .query({ 'list-type' : 2 })
+ .reply(200, () => {
+ return _listObjectsResponseXML;
+ });
+
+ storage.listFiles('invoices', (err, resp) => {
+ assert.strictEqual(err, null);
+ assert.strictEqual(resp.statusCode, 200);
+ assert.strictEqual(JSON.stringify(resp.body), JSON.stringify(_listObjectsResponseJSON));
+ assert.strictEqual(JSON.stringify(resp.headers), JSON.stringify(_header))
+ assert.strictEqual(nockRequest.pendingMocks().length, 0);
+ done();
+ })
+ })
+
+ it('should fetch a list of objects with query parameters (prefix & limit)', function (done) {
+ const _header = {
+ 'content-type': 'application/xml',
+ 'content-length': '1887',
+ 'x-amz-id-2': 'txf0b438dfd25b444ba3f60-00641807d7',
+ 'x-amz-request-id': 'txf0b438dfd25b444ba3f60-00641807d7',
+ 'x-trans-id': 'txf0b438dfd25b444ba3f60-00641807d7',
+ 'x-openstack-request-id': 'txf0b438dfd25b444ba3f60-00641807d7',
+ date: 'Mon, 20 Mar 2023 07:14:31 GMT',
+ connection: 'close'
+ }
+
+ const nockRequest = nock(url1S3)
+ .defaultReplyHeaders(_header)
+ .get('/bucket')
+ .query({
+ "list-type" : 2,
+ "prefix" : "document",
+ "max-keys" : 2
+ })
+ .reply(200, () => {
+ return _listObjectsResponseXML;
+ });
+
+ storage.listFiles('bucket', { queries: { "prefix": "document", "max-keys": 2 } }, (err, resp) => {
+ assert.strictEqual(err, null);
+ assert.strictEqual(resp.statusCode, 200);
+ assert.strictEqual(JSON.stringify(resp.body), JSON.stringify(_listObjectsResponseJSON));
+ assert.strictEqual(JSON.stringify(resp.headers), JSON.stringify(_header))
+ assert.strictEqual(nockRequest.pendingMocks().length, 0);
+ done();
+ })
+ })
+
+ it("should return an error if the bucket does not exist", function (done) {
+ const _headers = {
+ 'content-type': 'application/xml',
+ 'x-amz-id-2': 'tx8fa5f00b19af4756b9ef3-0064184d77',
+ 'x-amz-request-id': 'tx8fa5f00b19af4756b9ef3-0064184d77',
+ 'x-trans-id': 'tx8fa5f00b19af4756b9ef3-0064184d77',
+ 'x-openstack-request-id': 'tx8fa5f00b19af4756b9ef3-0064184d77',
+ date: 'Mon, 20 Mar 2023 12:11:35 GMT',
+ 'transfer-encoding': 'chunked',
+ connection: 'close'
+ }
+ const _expectedBody = {
+ error: {
+ code: 'NoSuchBucket',
+ message: 'The specified bucket does not exist.',
+ requestid: 'txe285e692106542e88a2f5-0064184e80',
+ bucketname: 'buckeeeet'
+ }
+ }
+ const nockRequest = nock(url1S3)
+ .defaultReplyHeaders(_headers)
+ .get('/buckeeeet')
+ .query({
+ "list-type" : 2
+ })
+ .reply(404, () => {
+ return "NoSuchBucketThe specified bucket does not exist.txe285e692106542e88a2f5-0064184e80buckeeeet";
+ });
+ storage.listFiles('buckeeeet', (err, resp) => {
+ assert.strictEqual(err, null);
+ assert.strictEqual(resp.statusCode, 404);
+ assert.strictEqual(JSON.stringify(resp.body), JSON.stringify(_expectedBody));
+ assert.strictEqual(JSON.stringify(resp.headers), JSON.stringify(_headers))
+ assert.strictEqual(nockRequest.pendingMocks().length, 0);
+ done();
+ })
+ })
+ })
+
+ describe("SWITCH TO CHILD STORAGE", function () {
+ it('should fetch a list of objects', function (done) {
+ const nockRequestS1 = nock(url1S3)
+ .get('/bucket')
+ .query({ 'list-type' : 2 })
+ .reply(500, '');
+
+ const nockRequestS2 = nock(url2S3)
+ .get('/bucket')
+ .query({ 'list-type' : 2 })
+ .reply(200, () => {
+ return _listObjectsResponseXML;
+ });
+
+ const nockRequestS3 = nock(url1S3)
+ .get('/')
+ .reply(500);
+
+ storage.listFiles('bucket', (err, resp) => {
+ assert.strictEqual(err, null);
+ assert.strictEqual(resp.statusCode, 200);
+ assert.strictEqual(JSON.stringify(resp.body), JSON.stringify(_listObjectsResponseJSON));
+ assert.strictEqual(JSON.stringify(resp.headers), JSON.stringify({}))
+ assert.strictEqual(nockRequestS1.pendingMocks().length, 0);
+ assert.strictEqual(nockRequestS2.pendingMocks().length, 0);
+ assert.strictEqual(nockRequestS3.pendingMocks().length, 0);
+ done();
+ })
+ })
+ });
+
+ });
+
+ describe('downloadFile', function() {
+
+ describe("REQUEST MAIN STORAGE", function () {
+ it('should download a file', function(done) {
+ const _header = {
+ 'content-length': '1492',
+ 'last-modified': 'Wed, 03 Nov 2021 13:02:39 GMT',
+ date: 'Wed, 03 Nov 2021 14:28:48 GMT',
+ etag: 'a30776a059eaf26eebf27756a849097d',
+ 'x-amz-request-id': '318BC8BC148832E5',
+ 'x-amz-id-2': 'eftixk72aD6Ap51TnqcoF8eFidJG9Z/2mkiDFu8yU9AS1ed4OpIszj7UDNEHGran'
+ }
+ const nockRequest = nock(url1S3)
+ .defaultReplyHeaders(_header)
+ .get('/bucket/file.docx')
+ .reply(200, () => {
+ return fileTxt;
+ });
+ storage.downloadFile('bucket', 'file.docx', function (err, resp) {
+ assert.strictEqual(err, null);
+ assert.strictEqual(resp.statusCode, 200);
+ assert.strictEqual(resp.body.toString(), fileTxt);
+ assert.strictEqual(JSON.stringify(resp.headers), JSON.stringify(_header))
+ assert.strictEqual(nockRequest.pendingMocks().length, 0);
+ done();
+ })
+ })
+
+ it('should download a file as STREAM', function(done) {
+ const _header = {
+ 'content-length': '1492',
+ 'last-modified': 'Wed, 03 Nov 2021 13:02:39 GMT',
+ date: 'Wed, 03 Nov 2021 14:28:48 GMT',
+ etag: 'a30776a059eaf26eebf27756a849097d',
+ 'x-amz-request-id': '318BC8BC148832E5',
+ 'x-amz-id-2': 'eftixk72aD6Ap51TnqcoF8eFidJG9Z/2mkiDFu8yU9AS1ed4OpIszj7UDNEHGran'
+ }
+ const nockRequest = nock(url1S3)
+ .defaultReplyHeaders(_header)
+ .get('/bucket/file.docx')
+ .reply(200, () => {
+ return fileTxt;
+ });
+ storage.downloadFile('bucket', 'file.docx', { stream: true }, function (err, resp) {
+ assert.strictEqual(err, null);
+ assert.strictEqual(resp.statusCode, 200);
+ let data = '';
+ resp.on('data', chunk => data += chunk);
+ resp.on('end', function () {
+ assert.strictEqual(data,fileTxt)
+ assert.strictEqual(nockRequest.pendingMocks().length, 0);
+ assert.strictEqual(JSON.stringify(resp.headers), JSON.stringify(_header))
+ done();
+ });
+ })
+ })
+
+ it('should download a file from an alias', function(done) {
+ const _header = {
+ 'content-length': '1492',
+ 'last-modified': 'Wed, 03 Nov 2021 13:02:39 GMT',
+ date: 'Wed, 03 Nov 2021 14:28:48 GMT',
+ etag: 'a30776a059eaf26eebf27756a849097d',
+ 'x-amz-request-id': '318BC8BC148832E5',
+ 'x-amz-id-2': 'eftixk72aD6Ap51TnqcoF8eFidJG9Z/2mkiDFu8yU9AS1ed4OpIszj7UDNEHGran'
+ }
+ const nockRequest = nock(url1S3)
+ .defaultReplyHeaders(_header)
+ .get('/invoices-gra-1234/file.docx')
+ .reply(200, () => {
+ return fileTxt;
+ });
+ storage.downloadFile('invoices', 'file.docx', function (err, resp) {
+ assert.strictEqual(err, null);
+ assert.strictEqual(resp.statusCode, 200);
+ assert.strictEqual(resp.body.toString(), fileTxt);
+ assert.strictEqual(JSON.stringify(resp.headers), JSON.stringify(_header))
+ assert.strictEqual(nockRequest.pendingMocks().length, 0);
+ done();
+ })
+ })
+
+ it('should download a file with options', function(done) {
+ const _header = {
+ 'content-length': '1492',
+ 'last-modified': 'Wed, 03 Nov 2021 13:02:39 GMT',
+ date: 'Wed, 03 Nov 2021 14:28:48 GMT',
+ etag: 'a30776a059eaf26eebf27756a849097d',
+ 'x-amz-request-id': '318BC8BC148832E5',
+ 'x-amz-id-2': 'eftixk72aD6Ap51TnqcoF8eFidJG9Z/2mkiDFu8yU9AS1ed4OpIszj7UDNEHGran'
+ }
+ const _options = {
+ headers: {
+ "x-amz-server-side-encryption-customer-key-MD5": "SSECustomerKeyMD5",
+ "x-amz-checksum-mode": "ChecksumMode"
+ },
+ queries: {
+ test : "2",
+ partNumber : "PartNumber"
+ }
+ }
+ const nockRequest = nock(url1S3, {
+ reqheaders: {
+ 'x-amz-server-side-encryption-customer-key-MD5': () => true,
+ 'x-amz-checksum-mode': () => true
+ }
+ })
+ .defaultReplyHeaders(_header)
+ .get('/bucket/file.docx')
+ .query(_options.queries)
+ .reply(200, () => {
+ return fileTxt;
+ });
+ storage.downloadFile('bucket', 'file.docx', _options, function (err, resp) {
+ assert.strictEqual(err, null);
+ assert.strictEqual(resp.statusCode, 200);
+ assert.strictEqual(resp.body.toString(), fileTxt);
+ assert.strictEqual(JSON.stringify(resp.headers), JSON.stringify(_header))
+ assert.strictEqual(nockRequest.pendingMocks().length, 0);
+ done();
+ })
+ })
+
+ it('should return code 404 if the file does not exist', function(done) {
+ const _header = {'content-type': 'application/xml'}
+ const nockRequest = nock(url1S3)
+ .defaultReplyHeaders(_header)
+ .get('/bucket/file.docx')
+ .reply(404, "NoSuchKeyThe specified key does not exist.txc03d49a36c324653854de-006408d963template222.odt");
+ storage.downloadFile('bucket', 'file.docx', function (err, resp) {
+ assert.strictEqual(err, null);
+ assert.strictEqual(resp.statusCode, 404);
+ assert.strictEqual(JSON.stringify(resp.body), JSON.stringify({
+ error: {
+ code: 'NoSuchKey',
+ message: 'The specified key does not exist.',
+ requestid: 'txc03d49a36c324653854de-006408d963',
+ key: 'template222.odt'
+ }
+ }));
+ assert.strictEqual(JSON.stringify(resp.headers), JSON.stringify(_header))
+ assert.strictEqual(nockRequest.pendingMocks().length, 0);
+ done();
+ })
+ })
+
+
+ it('[STREAM] should return code 404 if the file does not exist and should convert the XML as JSON', function(done) {
+ const _header = {'content-type': 'application/xml'}
+ const nockRequest = nock(url1S3)
+ .defaultReplyHeaders(_header)
+ .get('/bucket/file.docx')
+ .reply(404, "NoSuchKeyThe specified key does not exist.txc03d49a36c324653854de-006408d963template222.odt");
+ storage.downloadFile('bucket', 'file.docx', { stream: true }, function (err, resp) {
+ assert.strictEqual(err, null);
+ assert.strictEqual(resp.statusCode, 404);
+ let data = '';
+ resp.on('data', chunk => data += chunk);
+ resp.on('end', function () {
+ assert.strictEqual(JSON.stringify(storage.xmlToJson(data)), JSON.stringify({
+ error: {
+ code: 'NoSuchKey',
+ message: 'The specified key does not exist.',
+ requestid: 'txc03d49a36c324653854de-006408d963',
+ key: 'template222.odt'
+ }
+ }))
+ assert.strictEqual(nockRequest.pendingMocks().length, 0);
+ assert.strictEqual(JSON.stringify(resp.headers), JSON.stringify(_header))
+ done();
+ });
+ })
+ })
+
+ it("should return an error if the bucket does not exist", function (done) {
+ const _header = {
+ 'content-type': 'application/xml',
+ 'x-amz-id-2': 'txfa644d038be848a9938e3-00641850f0',
+ 'x-amz-request-id': 'txfa644d038be848a9938e3-00641850f0',
+ 'x-trans-id': 'txfa644d038be848a9938e3-00641850f0',
+ 'x-openstack-request-id': 'txfa644d038be848a9938e3-00641850f0',
+ date: 'Mon, 20 Mar 2023 12:26:24 GMT',
+ 'transfer-encoding': 'chunked',
+ connection: 'close'
+ }
+ const nockRequest = nock(url1S3)
+ .defaultReplyHeaders(_header)
+ .get('/buckeeeet/file.docx')
+ .reply(404, () => {
+ return "NoSuchBucketThe specified bucket does not exist.txfa644d038be848a9938e3-00641850f0buckeeeet";
+ });
+ storage.downloadFile('buckeeeet', 'file.docx', function (err, resp) {
+ assert.strictEqual(err, null);
+ assert.strictEqual(resp.statusCode, 404);
+ assert.strictEqual(JSON.stringify(resp.body), JSON.stringify({
+ error: {
+ code: 'NoSuchBucket',
+ message: 'The specified bucket does not exist.',
+ requestid: 'txfa644d038be848a9938e3-00641850f0',
+ bucketname: 'buckeeeet'
+ }
+ }));
+ assert.strictEqual(JSON.stringify(resp.headers), JSON.stringify(_header))
+ assert.strictEqual(nockRequest.pendingMocks().length, 0);
+ done();
+ })
+ })
+ });
+
+ describe("SWITCH TO CHILD STORAGE", function () {
+ it('should download a file from the second storage if the main storage returns a 500 error', function(done) {
+ const nockRequestS1 = nock(url1S3)
+ .get('/bucket/file.docx')
+ .reply(500);
+ const nockRequestS2 = nock(url2S3)
+ .get('/bucket/file.docx')
+ .reply(200, () => {
+ return fileTxt
+ });
+ const nockRequestS3 = nock(url1S3)
+ .get('/')
+ .reply(500);
+
+ storage.downloadFile('bucket', 'file.docx', function (err, resp) {
+ assert.strictEqual(err, null);
+ assert.strictEqual(resp.statusCode, 200);
+ assert.strictEqual(resp.body.toString(), fileTxt);
+ const _config = storage.getConfig();
+ assert.strictEqual(_config.activeStorage, 1);
+ assert.strictEqual(nockRequestS1.pendingMocks().length, 0);
+ assert.strictEqual(nockRequestS2.pendingMocks().length, 0);
+ assert.strictEqual(nockRequestS3.pendingMocks().length, 0);
+ done();
+ })
+ })
+
+ it('should download a file from the second storage if the main storage returns a 500 error and the container is an ALIAS', function(done) {
+ const nockRequestS1 = nock(url1S3)
+ .get('/invoices-gra-1234/file.docx')
+ .reply(500);
+ const nockRequestS2 = nock(url2S3)
+ .get('/invoices-de-8888/file.docx')
+ .reply(200, () => {
+ return fileTxt
+ });
+ const nockRequestS3 = nock(url1S3)
+ .get('/')
+ .reply(500);
+
+ storage.downloadFile('invoices', 'file.docx', function (err, resp) {
+ assert.strictEqual(err, null);
+ assert.strictEqual(resp.statusCode, 200);
+ assert.strictEqual(resp.body.toString(), fileTxt);
+ const _config = storage.getConfig();
+ assert.strictEqual(_config.activeStorage, 1);
+ assert.strictEqual(nockRequestS1.pendingMocks().length, 0);
+ assert.strictEqual(nockRequestS2.pendingMocks().length, 0);
+ assert.strictEqual(nockRequestS3.pendingMocks().length, 0);
+ done();
+ })
+ })
+
+ it('should download a file from the second storage if the main storage returns a 500 error, then should RECONNECT to the main storage', function(done) {
+ const nockRequestS1 = nock(url1S3)
+ .get('/bucket/file.docx')
+ .reply(500)
+ const nockRequestS2 = nock(url2S3)
+ .get('/bucket/file.docx')
+ .reply(200, () => {
+ return fileTxt
+ });
+ const nockRequestS3 = nock(url1S3)
+ .get('/')
+ .reply(200);
+
+ storage.downloadFile('bucket', 'file.docx', function (err, resp) {
+ assert.strictEqual(err, null);
+ assert.strictEqual(resp.statusCode, 200);
+ assert.strictEqual(resp.body.toString(), fileTxt);
+ const _config = storage.getConfig();
+ assert.strictEqual(_config.activeStorage, 0);
+ assert.strictEqual(nockRequestS1.pendingMocks().length, 0);
+ assert.strictEqual(nockRequestS2.pendingMocks().length, 0);
+ assert.strictEqual(nockRequestS3.pendingMocks().length, 0);
+ done();
+ })
+ })
+
+ it('should download a file from the second storage if the authentication on the main storage is not allowed', function(done) {
+ let nockRequestS1 = nock(url1S3)
+ .get('/bucket/file.docx')
+ .reply(401, 'Unauthorized')
+
+ const nockRequestS2 = nock(url2S3)
+ .get('/bucket/file.docx')
+ .reply(200, () => {
+ return fileTxt
+ });
+ const nockRequestS3 = nock(url1S3)
+ .get('/')
+ .reply(401, 'Unauthorized')
+
+ storage.downloadFile('bucket', 'file.docx', function (err, resp) {
+ assert.strictEqual(err, null);
+ assert.strictEqual(resp.statusCode, 200);
+ assert.strictEqual(resp.body.toString(), fileTxt);
+ const _config = storage.getConfig();
+ assert.strictEqual(_config.activeStorage, 1);
+ assert.strictEqual(nockRequestS1.pendingMocks().length, 0);
+ assert.strictEqual(nockRequestS2.pendingMocks().length, 0);
+ assert.strictEqual(nockRequestS3.pendingMocks().length, 0);
+ done();
+ })
+ })
+
+ it('should download a file from the second storage if the main storage timeout', function(done) {
+ storage.setTimeout(200);
+ let nockRequestS1 = nock(url1S3)
+ .get('/bucket/file.docx')
+ .delayConnection(500)
+ .reply(200, {});
+ const nockRequestS2 = nock(url2S3)
+ .get('/bucket/file.docx')
+ .reply(200, () => {
+ return fileTxt
+ });
+ const nockRequestS3 = nock(url1S3)
+ .get('/')
+ .delayConnection(500)
+ .reply(200, {});
+
+ storage.downloadFile('bucket', 'file.docx', function (err, resp) {
+ assert.strictEqual(err, null);
+ assert.strictEqual(resp.statusCode, 200);
+ assert.strictEqual(resp.body.toString(), fileTxt);
+ const _config = storage.getConfig();
+ assert.strictEqual(_config.activeStorage, 1);
+ assert.strictEqual(nockRequestS1.pendingMocks().length, 0);
+ assert.strictEqual(nockRequestS2.pendingMocks().length, 0);
+ assert.strictEqual(nockRequestS3.pendingMocks().length, 0);
+ done();
+ })
+ })
+
+ it('should download a file from the second storage if the main storage returns any kind of error', function(done) {
+ let nockRequestS1 = nock(url1S3)
+ .get('/bucket/file.docx')
+ .replyWithError('Error Message 1234');
+
+ const nockRequestS2 = nock(url2S3)
+ .get('/bucket/file.docx')
+ .reply(200, () => {
+ return fileTxt
+ });
+ const nockRequestS3 = nock(url1S3)
+ .get('/')
+ .replyWithError('Error Message 1234');
+
+ storage.downloadFile('bucket', 'file.docx', function (err, resp) {
+ assert.strictEqual(err, null);
+ assert.strictEqual(resp.statusCode, 200);
+ assert.strictEqual(resp.body.toString(), fileTxt);
+ const _config = storage.getConfig();
+ assert.strictEqual(_config.activeStorage, 1);
+ assert.strictEqual(nockRequestS1.pendingMocks().length, 0);
+ assert.strictEqual(nockRequestS2.pendingMocks().length, 0);
+ assert.strictEqual(nockRequestS3.pendingMocks().length, 0);
+ done();
+ })
+ })
+
+ it('should return an error if all storage are not available, and reset the active storage to the main', function(done) {
+ const nockRequestS1 = nock(url1S3)
+ .get('/bucket/file.docx')
+ .reply(500)
+ const nockRequestS2 = nock(url2S3)
+ .get('/bucket/file.docx')
+ .reply(500, () => {
+ return fileTxt
+ });
+ const nockRequestS3 = nock(url1S3)
+ .get('/')
+ .reply(500);
+
+ storage.downloadFile('bucket', 'file.docx', function (err, resp) {
+ assert.strictEqual(err.toString(), 'Error: All S3 storages are not available');
+ assert.strictEqual(resp, undefined);
+ const _config = storage.getConfig();
+ assert.strictEqual(_config.activeStorage, 0);
+ assert.strictEqual(nockRequestS1.pendingMocks().length, 0);
+ assert.strictEqual(nockRequestS2.pendingMocks().length, 0);
+ assert.strictEqual(nockRequestS3.pendingMocks().length, 0);
+ done();
+ })
+ })
+ });
+
+ describe("PARALLEL REQUESTS", function () {
+
+ function getDownloadFilePromise() {
+ return new Promise((resolve, reject) => {
+ try {
+ storage.downloadFile('bucket', 'file.odt', function (err, resp) {
+ if (err) {
+ return reject(err);
+ }
+ return resolve(resp);
+ });
+ } catch(err) {
+ return reject(err);
+ }
+ });
+ }
+
+ it('should fallback to a child if the main storage return any kind of errors, then should reconnect to the main storage automatically', function (done) {
+ const nockRequestS1 = nock(url1S3)
+ .get('/bucket/file.odt')
+ .reply(500)
+ .get('/bucket/file.odt')
+ .reply(500);
+ const nockRequestS2 = nock(url2S3)
+ .get('/bucket/file.odt')
+ .reply(200, () => {
+ return fileTxt
+ })
+ .get('/bucket/file.odt')
+ .reply(200, () => {
+ return fileTxt
+ });
+ const nockRequestS3 = nock(url1S3)
+ .get('/')
+ .reply(200);
+ const nockRequestS4 = nock(url1S3)
+ .get('/bucket/file.odt')
+ .reply(200, () => {
+ return fileTxt
+ })
+
+ let promise1 = getDownloadFilePromise()
+ let promise2 = getDownloadFilePromise()
+
+ Promise.all([promise1, promise2]).then(results => {
+ assert.strictEqual(results.length, 2)
+ assert.strictEqual(results[0].body.toString(), fileTxt);
+ assert.strictEqual(results[0].statusCode, 200);
+ assert.strictEqual(results[1].body.toString(), fileTxt);
+ assert.strictEqual(results[1].statusCode, 200);
+ assert.strictEqual(nockRequestS1.pendingMocks().length, 0);
+ assert.strictEqual(nockRequestS2.pendingMocks().length, 0);
+ assert.strictEqual(nockRequestS3.pendingMocks().length, 0);
+ assert.deepStrictEqual(storage.getConfig().activeStorage, 0);
+ /** Last batch requesting the main storage, everything is ok */
+ storage.downloadFile('bucket', 'file.odt', function (err, resp) {
+ assert.strictEqual(err, null);
+ assert.strictEqual(resp.body.toString(), fileTxt);
+ assert.strictEqual(resp.statusCode, 200);
+ assert.strictEqual(nockRequestS4.pendingMocks().length, 0);
+ assert.deepStrictEqual(storage.getConfig().activeStorage, 0);
+ done();
+ });
+ }).catch(err => {
+ assert.strictEqual(err, null);
+ done();
+ });
+ })
+
+ it('should fallback to a child if the main storage return any kind of errors, then should reconnect to the main storage after multiple try', function (done) {
+ /** First Batch */
+ const nockRequestS1 = nock(url1S3)
+ .get('/bucket/file.odt')
+ .reply(500)
+ .get('/bucket/file.odt')
+ .reply(500);
+ const nockRequestS2 = nock(url2S3)
+ .get('/bucket/file.odt')
+ .reply(200, () => {
+ return fileTxt
+ })
+ .get('/bucket/file.odt')
+ .reply(200, () => {
+ return fileTxt
+ });
+ const nockRequestS3 = nock(url1S3)
+ .get('/')
+ .reply(500);
+
+ /** Second Batch */
+ const nockRequestS4 = nock(url2S3)
+ .get('/bucket/file.odt')
+ .reply(200, () => {
+ return fileTxt
+ })
+ .get('/bucket/file.odt')
+ .reply(200, () => {
+ return fileTxt
+ });
+ const nockRequestS5 = nock(url1S3)
+ .get('/')
+ .reply(500);
+
+ /** Third Batch */
+ const nockRequestS6 = nock(url2S3)
+ .get('/bucket/file.odt')
+ .reply(200, () => {
+ return fileTxt
+ })
+ const nockRequestS7 = nock(url1S3)
+ .get('/')
+ .reply(200);
+ /** Fourth Batch */
+ const nockRequestS8 = nock(url1S3)
+ .get('/bucket/file.odt')
+ .reply(200, () => {
+ return fileTxt
+ })
+
+ /** First batch of requests > S3 main return error > Child storage response ok */
+ let promise1 = getDownloadFilePromise()
+ let promise2 = getDownloadFilePromise()
+ Promise.all([promise1, promise2]).then(function (results) {
+ assert.strictEqual(results.length, 2)
+ assert.strictEqual(results[0].body.toString(), fileTxt);
+ assert.strictEqual(results[0].statusCode, 200);
+ assert.strictEqual(results[1].body.toString(), fileTxt);
+ assert.strictEqual(results[1].statusCode, 200);
+ assert.strictEqual(nockRequestS1.pendingMocks().length, 0);
+ assert.strictEqual(nockRequestS2.pendingMocks().length, 0);
+ assert.strictEqual(nockRequestS3.pendingMocks().length, 0);
+ assert.deepStrictEqual(storage.getConfig().activeStorage, 1);
+ /** Second batch of requests > Still requesting the child storage, the main storage is still not available */
+ let promise3 = getDownloadFilePromise()
+ let promise4 = getDownloadFilePromise()
+ Promise.all([promise3, promise4]).then(function (results) {
+ assert.strictEqual(results.length, 2)
+ assert.strictEqual(results[0].body.toString(), fileTxt);
+ assert.strictEqual(results[0].statusCode, 200);
+ assert.strictEqual(results[1].body.toString(), fileTxt);
+ assert.strictEqual(results[1].statusCode, 200);
+ assert.strictEqual(nockRequestS4.pendingMocks().length, 0);
+ assert.strictEqual(nockRequestS5.pendingMocks().length, 0);
+ assert.deepStrictEqual(storage.getConfig().activeStorage, 1);
+ /** Third batch of requests > Still requesting the child storage, the main storage is now Available! Active storage is reset to the main storage */
+ storage.downloadFile('bucket', 'file.odt', function (err, resp) {
+ assert.strictEqual(err, null);
+ assert.strictEqual(resp.body.toString(), fileTxt);
+ assert.strictEqual(resp.statusCode, 200);
+ assert.strictEqual(nockRequestS6.pendingMocks().length, 0);
+ assert.strictEqual(nockRequestS7.pendingMocks().length, 0);
+ assert.deepStrictEqual(storage.getConfig().activeStorage, 0);
+ /** Fourth batch requesting the main storage, everything is ok */
+ storage.downloadFile('bucket', 'file.odt', function (err, resp) {
+ assert.strictEqual(err, null);
+ assert.strictEqual(resp.body.toString(), fileTxt);
+ assert.strictEqual(resp.statusCode, 200);
+ assert.strictEqual(nockRequestS8.pendingMocks().length, 0);
+ assert.deepStrictEqual(storage.getConfig().activeStorage, 0);
+ done();
+ });
+ });
+ }).catch(function (err) {
+ assert.strictEqual(err, null);
+ done();
+ });
+ }).catch(function (err) {
+ assert.strictEqual(err, null);
+ done();
+ });
+ })
+
+ });
+
+ });
+
+ describe('uploadFile', function() {
+
+ describe("REQUEST MAIN STORAGE", function () {
+ const _header = {
+ 'content-length': '0',
+ 'last-modified': 'Wed, 03 Nov 2021 13:02:39 GMT',
+ date: 'Wed, 03 Nov 2021 14:28:48 GMT',
+ etag: 'a30776a059eaf26eebf27756a849097d',
+ 'x-amz-request-id': '318BC8BC148832E5',
+ 'x-amz-id-2': 'eftixk72aD6Ap51TnqcoF8eFidJG9Z/2mkiDFu8yU9AS1ed4OpIszj7UDNEHGran'
+ }
+
+ it("should upload a file provided as buffer", function() {
+
+ const nockRequestS1 = nock(url1S3)
+ .defaultReplyHeaders(_header)
+ .put('/bucket/file.pdf')
+ .reply(200, (uri, requestBody) => {
+ assert.strictEqual(requestBody, fileXml);
+ return '';
+ });
+
+ storage.uploadFile('bucket', 'file.pdf', Buffer.from(fileXml), function(err, resp) {
+ assert.strictEqual(err, null);
+ assert.strictEqual(resp.statusCode, 200);
+ assert.strictEqual(JSON.stringify(resp.headers), JSON.stringify(_header));
+ assert.strictEqual(resp.body.toString(), '');
+ assert.strictEqual(nockRequestS1.pendingMocks().length, 0);
+ })
+ })
+
+ it("should upload a file provided as buffer to a bucket alias", function() {
+
+ const nockRequestS1 = nock(url1S3)
+ .defaultReplyHeaders(_header)
+ .put('/invoices-gra-1234/file.pdf')
+ .reply(200, (uri, requestBody) => {
+ assert.strictEqual(requestBody, fileXml);
+ return '';
+ });
+
+ storage.uploadFile('invoices', 'file.pdf', Buffer.from(fileXml), function(err, resp) {
+ assert.strictEqual(err, null);
+ assert.strictEqual(resp.statusCode, 200);
+ assert.strictEqual(JSON.stringify(resp.headers), JSON.stringify(_header));
+ assert.strictEqual(resp.body.toString(), '');
+ assert.strictEqual(nockRequestS1.pendingMocks().length, 0);
+ })
+ })
+
+ it("should upload a file provided as local path", function() {
+
+ const nockRequestS1 = nock(url1S3)
+ .defaultReplyHeaders(_header)
+ .put('/bucket/file.pdf')
+ .reply(200, (uri, requestBody) => {
+ assert.strictEqual(requestBody, fileXml);
+ return '';
+ });
+
+ storage.uploadFile('bucket', 'file.pdf', fileXmlPath, function(err, resp) {
+ assert.strictEqual(err, null);
+ assert.strictEqual(resp.statusCode, 200);
+ assert.strictEqual(JSON.stringify(resp.headers), JSON.stringify(_header));
+ assert.strictEqual(resp.body.toString(), '');
+ assert.strictEqual(nockRequestS1.pendingMocks().length, 0);
+ })
+ })
+
+ it("should return an error if the file provided as local path does not exist", function() {
+
+ storage.uploadFile('bucket', 'file.pdf', '/var/random/path/file.pdf', function(err, resp) {
+ assert.strictEqual(err.toString(), "Error: ENOENT: no such file or directory, open '/var/random/path/file.pdf'");
+ assert.strictEqual(resp, undefined);
+ })
+ })
+
+ it("should upload a file provided as buffer with OPTIONS (like metadata)", function(done) {
+ const _options = {
+ headers: {
+ "x-amz-meta-name": "carbone",
+ "x-amz-checksum-sha256": "0ea4be78f6c3948588172edc6d8789ffe3cec461f385e0ac447e581731c429b5"
+ },
+ queries: {
+ test : "2"
+ }
+ }
+
+ const nockRequestS1 = nock(url1S3, {
+ reqheaders: {
+ 'x-amz-content-sha256': () => true,
+ 'x-amz-date': () => true,
+ 'authorization': () => true,
+ 'host': () => true,
+ 'x-amz-meta-name': () => true,
+ 'x-amz-checksum-sha256': () => true
+ }
+ })
+ .defaultReplyHeaders(_header)
+ .put('/bucket/file.pdf')
+ .query(_options.queries)
+ .reply(200, (uri, requestBody) => {
+ assert.strictEqual(requestBody, fileXml);
+ return '';
+ });
+
+
+ storage.uploadFile('bucket', 'file.pdf', Buffer.from(fileXml), _options, function(err, resp) {
+ assert.strictEqual(err, null);
+ assert.strictEqual(resp.statusCode, 200);
+ assert.strictEqual(JSON.stringify(resp.headers), JSON.stringify(_header));
+ assert.strictEqual(resp.body.toString(), '');
+ assert.strictEqual(nockRequestS1.pendingMocks().length, 0);
+ done();
+ })
+ })
+
+ it("should return an error if the bucket does not exist", function (done) {
+
+ const _headers = {
+ 'content-type': 'application/xml',
+ 'x-amz-id-2': 'tx33e4496c9d8746ad9cfcb-006418540f',
+ 'x-amz-request-id': 'tx33e4496c9d8746ad9cfcb-006418540f',
+ 'x-trans-id': 'tx33e4496c9d8746ad9cfcb-006418540f',
+ 'x-openstack-request-id': 'tx33e4496c9d8746ad9cfcb-006418540f',
+ date: 'Mon, 20 Mar 2023 12:39:43 GMT',
+ 'transfer-encoding': 'chunked',
+ connection: 'close'
+ }
+
+ const nockRequestS1 = nock(url1S3)
+ .defaultReplyHeaders(_headers)
+ .put('/buckeeeet/file.pdf')
+ .reply(404, (uri, requestBody) => {
+ assert.strictEqual(requestBody, fileXml);
+ return Buffer.from("NoSuchBucketThe specified bucket does not exist.tx9d1553e8d8de401bb8949-00641851bdbuckeeeet");
+ });
+
+ storage.uploadFile('buckeeeet', 'file.pdf', fileXmlPath, function(err, resp) {
+ assert.strictEqual(err, null);
+ assert.strictEqual(resp.statusCode, 404);
+ assert.strictEqual(JSON.stringify(resp.headers), JSON.stringify(_headers));
+ assert.strictEqual(JSON.stringify(resp.body), JSON.stringify({
+ error: {
+ code: 'NoSuchBucket',
+ message: 'The specified bucket does not exist.',
+ requestid: 'tx9d1553e8d8de401bb8949-00641851bd',
+ bucketname: 'buckeeeet'
+ }
+ }));
+ assert.strictEqual(nockRequestS1.pendingMocks().length, 0);
+ done();
+ })
+ })
+
+ });
+
+ describe("SWITCH TO CHILD STORAGE", function () {
+
+ it("should upload a file into a child storage", function(done) {
+ const _header = {
+ 'content-type': 'application/xml',
+ 'x-amz-id-2': 'txd14fbe8bc05341c0b548a-00640b2752',
+ 'x-amz-request-id': 'txd14fbe8bc05341c0b548a-00640b2752',
+ 'x-trans-id': 'txd14fbe8bc05341c0b548a-00640b2752',
+ 'x-openstack-request-id': 'txd14fbe8bc05341c0b548a-00640b2752',
+ date: 'Fri, 10 Mar 2023 12:49:22 GMT',
+ 'transfer-encoding': 'chunked',
+ connection: 'close'
+ }
+
+ const nockRequestS1 = nock(url1S3)
+ .defaultReplyHeaders(_header)
+ .put('/bucket/file.pdf')
+ .reply(500, '');
+
+ const nockRequestS2 = nock(url2S3)
+ .defaultReplyHeaders(_header)
+ .put('/bucket/file.pdf')
+ .reply(200, (uri, requestBody) => {
+ assert.strictEqual(requestBody, fileXml);
+ return '';
+ });
+ const nockRequestS3 = nock(url1S3)
+ .get('/')
+ .reply(500);
+
+ storage.uploadFile('bucket', 'file.pdf', Buffer.from(fileXml), function(err, resp) {
+ assert.strictEqual(err, null);
+ assert.strictEqual(resp.statusCode, 200);
+ assert.strictEqual(resp.body.toString(), '');
+ assert.strictEqual(JSON.stringify(resp.headers), JSON.stringify(_header));
+ assert.strictEqual(nockRequestS1.pendingMocks().length, 0);
+ assert.strictEqual(nockRequestS2.pendingMocks().length, 0);
+ assert.strictEqual(nockRequestS3.pendingMocks().length, 0);
+ done();
+ })
+ })
+
+ it("should upload a file into a child storage into a bucket as ALIAS", function(done) {
+ const _header = {
+ 'content-type': 'application/xml',
+ 'x-amz-id-2': 'txd14fbe8bc05341c0b548a-00640b2752',
+ 'x-amz-request-id': 'txd14fbe8bc05341c0b548a-00640b2752',
+ 'x-trans-id': 'txd14fbe8bc05341c0b548a-00640b2752',
+ 'x-openstack-request-id': 'txd14fbe8bc05341c0b548a-00640b2752',
+ date: 'Fri, 10 Mar 2023 12:49:22 GMT',
+ 'transfer-encoding': 'chunked',
+ connection: 'close'
+ }
+
+ const nockRequestS1 = nock(url1S3)
+ .defaultReplyHeaders(_header)
+ .put('/invoices-gra-1234/file.pdf')
+ .reply(500, '');
+
+ const nockRequestS2 = nock(url2S3)
+ .defaultReplyHeaders(_header)
+ .put('/invoices-de-8888/file.pdf')
+ .reply(200, (uri, requestBody) => {
+ assert.strictEqual(requestBody, fileXml);
+ return '';
+ });
+ const nockRequestS3 = nock(url1S3)
+ .get('/')
+ .reply(500);
+
+ storage.uploadFile('invoices', 'file.pdf', Buffer.from(fileXml), function(err, resp) {
+ assert.strictEqual(err, null);
+ assert.strictEqual(resp.statusCode, 200);
+ assert.strictEqual(resp.body.toString(), '');
+ assert.strictEqual(JSON.stringify(resp.headers), JSON.stringify(_header));
+ assert.strictEqual(nockRequestS1.pendingMocks().length, 0);
+ assert.strictEqual(nockRequestS2.pendingMocks().length, 0);
+ assert.strictEqual(nockRequestS3.pendingMocks().length, 0);
+ done();
+ })
+ })
+
+ it("should not be able to upload a file into a child storage if the write access is denied.", function(done) {
+ const _header = {
+ 'content-type': 'application/xml',
+ 'x-amz-id-2': 'txd14fbe8bc05341c0b548a-00640b2752',
+ 'x-amz-request-id': 'txd14fbe8bc05341c0b548a-00640b2752',
+ 'x-trans-id': 'txd14fbe8bc05341c0b548a-00640b2752',
+ 'x-openstack-request-id': 'txd14fbe8bc05341c0b548a-00640b2752',
+ date: 'Fri, 10 Mar 2023 12:49:22 GMT',
+ 'transfer-encoding': 'chunked',
+ connection: 'close'
+ }
+
+ const nockRequestS1 = nock(url1S3)
+ .defaultReplyHeaders(_header)
+ .put('/bucket/file.pdf')
+ .reply(500, '');
+
+ const nockRequestS2 = nock(url2S3)
+ .defaultReplyHeaders(_header)
+ .put('/bucket/file.pdf')
+ .reply(403, () => {
+ return "AccessDeniedAccess Denied.txd14fbe8bc05341c0b548a-00640b2752";
+ })
+ const nockRequestS3 = nock(url1S3)
+ .get('/')
+ .reply(500);
+
+ const _expectedBody = {
+ error: {
+ code: 'AccessDenied',
+ message: 'Access Denied.',
+ requestid: 'txd14fbe8bc05341c0b548a-00640b2752'
+ }
+ }
+
+ storage.uploadFile('bucket', 'file.pdf', Buffer.from(fileXml), function(err, resp) {
+ assert.strictEqual(err, null);
+ assert.strictEqual(resp.statusCode, 403);
+ assert.strictEqual(JSON.stringify(resp.body), JSON.stringify(_expectedBody));
+ assert.strictEqual(JSON.stringify(resp.headers), JSON.stringify(_header));
+ assert.strictEqual(nockRequestS1.pendingMocks().length, 0);
+ assert.strictEqual(nockRequestS2.pendingMocks().length, 0);
+ assert.strictEqual(nockRequestS3.pendingMocks().length, 0);
+ done();
+ })
+ })
+
+ });
+
+ });
+
+ describe('deleteFile', function() {
+
+ describe("REQUEST MAIN STORAGE", function () {
+
+ it('should delete an object (return the same response if the object does not exist)', function(done) {
+ const _headers = {
+ 'content-type': 'text/html; charset=UTF-8',
+ 'content-length': '0',
+ 'x-amz-id-2': 'txf010ba580ff0471ba3a0b-0064181698',
+ 'x-amz-request-id': 'txf010ba580ff0471ba3a0b-0064181698',
+ 'x-trans-id': 'txf010ba580ff0471ba3a0b-0064181698',
+ 'x-openstack-request-id': 'txf010ba580ff0471ba3a0b-0064181698',
+ date: 'Mon, 20 Mar 2023 08:17:29 GMT',
+ connection: 'close'
+ }
+
+ const nockRequestS1 = nock(url1S3)
+ .defaultReplyHeaders(_headers)
+ .delete('/www/file.pdf')
+ .reply(204, '');
+
+ storage.deleteFile('www', 'file.pdf', (err, resp) => {
+ assert.strictEqual(err, null);
+ assert.strictEqual(resp.statusCode, 204);
+ assert.strictEqual(resp.body.toString(), '');
+ assert.strictEqual(JSON.stringify(resp.headers), JSON.stringify(_headers));
+ assert.strictEqual(nockRequestS1.pendingMocks().length, 0);
+ done();
+ })
+ })
+
+ it('should delete an object into a bucket as ALIAS', function(done) {
+ const _headers = {
+ 'content-type': 'text/html; charset=UTF-8',
+ 'content-length': '0',
+ 'x-amz-id-2': 'txf010ba580ff0471ba3a0b-0064181698',
+ 'x-amz-request-id': 'txf010ba580ff0471ba3a0b-0064181698',
+ 'x-trans-id': 'txf010ba580ff0471ba3a0b-0064181698',
+ 'x-openstack-request-id': 'txf010ba580ff0471ba3a0b-0064181698',
+ date: 'Mon, 20 Mar 2023 08:17:29 GMT',
+ connection: 'close'
+ }
+
+ const nockRequestS1 = nock(url1S3)
+ .defaultReplyHeaders(_headers)
+ .delete('/invoices-gra-1234/file.pdf')
+ .reply(204, '');
+
+ storage.deleteFile('invoices', 'file.pdf', (err, resp) => {
+ assert.strictEqual(err, null);
+ assert.strictEqual(resp.statusCode, 204);
+ assert.strictEqual(resp.body.toString(), '');
+ assert.strictEqual(JSON.stringify(resp.headers), JSON.stringify(_headers));
+ assert.strictEqual(nockRequestS1.pendingMocks().length, 0);
+ done();
+ })
+ })
+
+ it("should return an error if the bucket does not exist", function (done) {
+ const _headers = {
+ 'content-type': 'application/xml',
+ 'x-amz-id-2': 'tx424f2a5a6e684da581e77-0064185482',
+ 'x-amz-request-id': 'tx424f2a5a6e684da581e77-0064185482',
+ 'x-trans-id': 'tx424f2a5a6e684da581e77-0064185482',
+ 'x-openstack-request-id': 'tx424f2a5a6e684da581e77-0064185482',
+ date: 'Mon, 20 Mar 2023 12:41:38 GMT',
+ 'transfer-encoding': 'chunked',
+ connection: 'close'
+ }
+
+ const nockRequestS1 = nock(url1S3)
+ .defaultReplyHeaders(_headers)
+ .delete('/buckeeet/file.pdf')
+ .reply(404, "NoSuchBucketThe specified bucket does not exist.tx424f2a5a6e684da581e77-0064185482buckeeet");
+
+ storage.deleteFile('buckeeet', 'file.pdf', (err, resp) => {
+ assert.strictEqual(err, null);
+ assert.strictEqual(resp.statusCode, 404);
+ assert.strictEqual(JSON.stringify(resp.body), JSON.stringify({
+ error: {
+ code: 'NoSuchBucket',
+ message: 'The specified bucket does not exist.',
+ requestid: 'tx424f2a5a6e684da581e77-0064185482',
+ bucketname: 'buckeeet'
+ }
+ }));
+ assert.strictEqual(JSON.stringify(resp.headers), JSON.stringify(_headers));
+ assert.strictEqual(nockRequestS1.pendingMocks().length, 0);
+ done();
+ })
+ })
+
+ });
+
+ describe("SWITCH TO CHILD STORAGE", function () {
+
+ it('should delete an object from the second bucket', function(done) {
+ const _headers = {
+ 'content-type': 'text/html; charset=UTF-8',
+ 'content-length': '0',
+ 'x-amz-id-2': 'txf010ba580ff0471ba3a0b-0064181698',
+ 'x-amz-request-id': 'txf010ba580ff0471ba3a0b-0064181698',
+ 'x-trans-id': 'txf010ba580ff0471ba3a0b-0064181698',
+ 'x-openstack-request-id': 'txf010ba580ff0471ba3a0b-0064181698',
+ date: 'Mon, 20 Mar 2023 08:17:29 GMT',
+ connection: 'close'
+ }
+
+ const nockRequestS1 = nock(url1S3)
+ .delete('/www/file.pdf')
+ .reply(500, '');
+
+ const nockRequestS2 = nock(url2S3)
+ .defaultReplyHeaders(_headers)
+ .delete('/www/file.pdf')
+ .reply(204, '');
+
+ const nockRequestS3 = nock(url1S3)
+ .get('/')
+ .reply(500, '');
+
+ storage.deleteFile('www', 'file.pdf', (err, resp) => {
+ assert.strictEqual(err, null);
+ assert.strictEqual(resp.statusCode, 204);
+ assert.strictEqual(resp.body.toString(), '');
+ assert.strictEqual(JSON.stringify(resp.headers), JSON.stringify(_headers));
+ assert.strictEqual(nockRequestS1.pendingMocks().length, 0);
+ assert.strictEqual(nockRequestS2.pendingMocks().length, 0);
+ assert.strictEqual(nockRequestS3.pendingMocks().length, 0);
+ done();
+ })
+ })
+
+ it('should delete an object from the second bucket as ALIAS', function(done) {
+ const _headers = {
+ 'content-type': 'text/html; charset=UTF-8',
+ 'content-length': '0',
+ 'x-amz-id-2': 'txf010ba580ff0471ba3a0b-0064181698',
+ 'x-amz-request-id': 'txf010ba580ff0471ba3a0b-0064181698',
+ 'x-trans-id': 'txf010ba580ff0471ba3a0b-0064181698',
+ 'x-openstack-request-id': 'txf010ba580ff0471ba3a0b-0064181698',
+ date: 'Mon, 20 Mar 2023 08:17:29 GMT',
+ connection: 'close'
+ }
+
+ const nockRequestS1 = nock(url1S3)
+ .delete('/invoices-gra-1234/file.pdf')
+ .reply(500, '');
+
+ const nockRequestS2 = nock(url2S3)
+ .defaultReplyHeaders(_headers)
+ .delete('/invoices-de-8888/file.pdf')
+ .reply(204, '');
+
+ const nockRequestS3 = nock(url1S3)
+ .get('/')
+ .reply(500, '');
+
+ storage.deleteFile('invoices', 'file.pdf', (err, resp) => {
+ assert.strictEqual(err, null);
+ assert.strictEqual(resp.statusCode, 204);
+ assert.strictEqual(resp.body.toString(), '');
+ assert.strictEqual(JSON.stringify(resp.headers), JSON.stringify(_headers));
+ assert.strictEqual(nockRequestS1.pendingMocks().length, 0);
+ assert.strictEqual(nockRequestS2.pendingMocks().length, 0);
+ assert.strictEqual(nockRequestS3.pendingMocks().length, 0);
+ done();
+ })
+ })
+
+ it("should not be able to delete a file of a child storage if the write permission is disallowed", function(done) {
+ const _bodyErrorAccessDenied = "AccessDeniedAccess Denied.txb40580debedc4ff9b36dc-00641818cb"
+ const _bodyJson = {
+ error: {
+ code: 'AccessDenied',
+ message: 'Access Denied.',
+ requestid: 'txb40580debedc4ff9b36dc-00641818cb'
+ }
+ }
+
+ const _headers = {
+ 'content-type': 'application/xml',
+ 'x-amz-id-2': 'txb40580debedc4ff9b36dc-00641818cb',
+ 'x-amz-request-id': 'txb40580debedc4ff9b36dc-00641818cb',
+ 'x-trans-id': 'txb40580debedc4ff9b36dc-00641818cb',
+ 'x-openstack-request-id': 'txb40580debedc4ff9b36dc-00641818cb',
+ date: 'Mon, 20 Mar 2023 08:26:51 GMT',
+ 'transfer-encoding': 'chunked',
+ connection: 'close'
+ }
+
+ const nockRequestS1 = nock(url1S3)
+ .delete('/www/file.pdf')
+ .reply(500, '');
+
+ const nockRequestS2 = nock(url2S3)
+ .defaultReplyHeaders(_headers)
+ .delete('/www/file.pdf')
+ .reply(403, _bodyErrorAccessDenied);
+
+ const nockRequestS3 = nock(url1S3)
+ .get('/')
+ .reply(500, '');
+
+ storage.deleteFile('www', 'file.pdf', (err, resp) => {
+ assert.strictEqual(err, null);
+ assert.strictEqual(resp.statusCode, 403);
+ assert.strictEqual(JSON.stringify(resp.body), JSON.stringify(_bodyJson));
+ assert.strictEqual(JSON.stringify(resp.headers), JSON.stringify(_headers));
+ assert.strictEqual(nockRequestS1.pendingMocks().length, 0);
+ assert.strictEqual(nockRequestS2.pendingMocks().length, 0);
+ assert.strictEqual(nockRequestS3.pendingMocks().length, 0);
+ done();
+ })
+ })
+
+ });
+
+ });
+
+ describe('deleteFiles', function() {
+
+ describe("REQUEST MAIN STORAGE", function () {
+
+ it('should delete a list of objects', function(done) {
+ const _headers = {
+ 'content-type': 'text/html; charset=UTF-8',
+ 'content-length': '269',
+ 'x-amz-id-2': 'txb383f29c0dad46f9919b5-00641844ba',
+ 'x-amz-request-id': 'txb383f29c0dad46f9919b5-00641844ba',
+ 'x-trans-id': 'txb383f29c0dad46f9919b5-00641844ba',
+ 'x-openstack-request-id': 'txb383f29c0dad46f9919b5-00641844ba',
+ date: 'Mon, 20 Mar 2023 11:34:18 GMT',
+ connection: 'close'
+ }
+
+ const _filesToDelete = [
+ { key: 'invoice 2023.pdf' },
+ { key: 'carbone(1).png' },
+ { key: 'file.txt' }
+ ]
+
+ const _expectedBody = {
+ deleted: _filesToDelete.map((value) => {
+ return {
+ key: encodeURIComponent(value.key)
+ }
+ })
+ }
+
+ const nockRequestS1 = nock(url1S3)
+ .defaultReplyHeaders(_headers)
+ .post('/www/')
+ .query((actualQueryObject) => {
+ assert.strictEqual(actualQueryObject.delete !== undefined, true);
+ return true;
+ })
+ .reply(200, function() {
+ return "invoice%202023.pdfcarbone(1).pngfile.txt";
+ })
+
+ storage.deleteFiles('www', _filesToDelete, (err, resp) => {
+ assert.strictEqual(err, null);
+ assert.strictEqual(resp.statusCode, 200);
+ assert.strictEqual(JSON.stringify(resp.body), JSON.stringify(_expectedBody));
+ assert.strictEqual(JSON.stringify(resp.headers), JSON.stringify(_headers));
+ assert.strictEqual(nockRequestS1.pendingMocks().length, 0);
+ done();
+ })
+ })
+
+ it('should delete a list of objects with Bucket as ALIAS', function(done) {
+ const _headers = {
+ 'content-type': 'text/html; charset=UTF-8',
+ 'content-length': '269',
+ 'x-amz-id-2': 'txb383f29c0dad46f9919b5-00641844ba',
+ 'x-amz-request-id': 'txb383f29c0dad46f9919b5-00641844ba',
+ 'x-trans-id': 'txb383f29c0dad46f9919b5-00641844ba',
+ 'x-openstack-request-id': 'txb383f29c0dad46f9919b5-00641844ba',
+ date: 'Mon, 20 Mar 2023 11:34:18 GMT',
+ connection: 'close'
+ }
+
+ const _filesToDelete = [
+ { key: 'invoice 2023.pdf' },
+ { key: 'carbone(1).png' },
+ { key: 'file.txt' }
+ ]
+
+ const _expectedBody = {
+ deleted: _filesToDelete.map((value) => {
+ return {
+ key: encodeURIComponent(value.key)
+ }
+ })
+ }
+
+ const nockRequestS1 = nock(url1S3)
+ .defaultReplyHeaders(_headers)
+ .post('/invoices-gra-1234/')
+ .query((actualQueryObject) => {
+ assert.strictEqual(actualQueryObject.delete !== undefined, true);
+ return true;
+ })
+ .reply(200, function() {
+ return "invoice%202023.pdfcarbone(1).pngfile.txt";
+ })
+
+ storage.deleteFiles('invoices', _filesToDelete, (err, resp) => {
+ assert.strictEqual(err, null);
+ assert.strictEqual(resp.statusCode, 200);
+ assert.strictEqual(JSON.stringify(resp.body), JSON.stringify(_expectedBody));
+ assert.strictEqual(JSON.stringify(resp.headers), JSON.stringify(_headers));
+ assert.strictEqual(nockRequestS1.pendingMocks().length, 0);
+ done();
+ })
+ })
+
+ it('should delete a list of objects with mix success/errors (access denied)', function(done) {
+ const _headers = {
+ 'content-type': 'text/html; charset=UTF-8',
+ 'content-length': '269',
+ 'x-amz-id-2': 'tx3cf216266bf24a888354a-0064184a78',
+ 'x-amz-request-id': 'tx3cf216266bf24a888354a-0064184a78',
+ 'x-trans-id': 'tx3cf216266bf24a888354a-0064184a78',
+ 'x-openstack-request-id': 'tx3cf216266bf24a888354a-0064184a78',
+ date: 'Mon, 20 Mar 2023 11:58:49 GMT',
+ connection: 'close'
+ }
+
+ const _filesToDelete = [
+ { key: 'sample1.txt' },
+ { key: 'sample2.txt' }
+ ]
+
+ const _expectedBody = {
+ deleted: [
+ { key: 'sample1.txt' }
+ ],
+ error: [
+ {
+ key : 'sample2.txt',
+ code : 'AccessDenied',
+ message: 'Access Denied'
+ }
+ ]
+ }
+
+ const nockRequestS1 = nock(url1S3)
+ .defaultReplyHeaders(_headers)
+ .post('/www/')
+ .query((actualQueryObject) => {
+ assert.strictEqual(actualQueryObject.delete !== undefined, true);
+ return true;
+ })
+ .reply(200, function() {
+ return "sample1.txtsample2.txtAccessDeniedAccess Denied";
+ })
+
+ storage.deleteFiles('www', _filesToDelete, (err, resp) => {
+ assert.strictEqual(err, null);
+ assert.strictEqual(resp.statusCode, 200);
+ assert.strictEqual(JSON.stringify(resp.body), JSON.stringify(_expectedBody));
+ assert.strictEqual(JSON.stringify(resp.headers), JSON.stringify(_headers));
+ assert.strictEqual(nockRequestS1.pendingMocks().length, 0);
+ done();
+ })
+ })
+
+ it("should return an error if the bucket does not exist", function (done) {
+ const _headers = {
+ 'content-type': 'application/xml',
+ 'x-amz-id-2': 'tx84736ac6d5544b44ba91a-0064185021',
+ 'x-amz-request-id': 'tx84736ac6d5544b44ba91a-0064185021',
+ 'x-trans-id': 'tx84736ac6d5544b44ba91a-0064185021',
+ 'x-openstack-request-id': 'tx84736ac6d5544b44ba91a-0064185021',
+ date: 'Mon, 20 Mar 2023 12:22:57 GMT',
+ 'transfer-encoding': 'chunked',
+ connection: 'close'
+ }
+
+ const _filesToDelete = [
+ { key: 'invoice 2023.pdf' },
+ { key: 'carbone(1).png' },
+ { key: 'file.txt' }
+ ]
+
+ const _expectedBody = {
+ error: {
+ code: 'NoSuchBucket',
+ message: 'The specified bucket does not exist.',
+ requestid: 'tx84736ac6d5544b44ba91a-0064185021',
+ bucketname: 'buckeeeet'
+ }
+ }
+
+ const nockRequestS1 = nock(url1S3)
+ .defaultReplyHeaders(_headers)
+ .post('/buckeeeet/')
+ .query((actualQueryObject) => {
+ assert.strictEqual(actualQueryObject.delete !== undefined, true);
+ return true;
+ })
+ .reply(404, function() {
+ return "NoSuchBucketThe specified bucket does not exist.tx84736ac6d5544b44ba91a-0064185021buckeeeet";
+ })
+
+ storage.deleteFiles('buckeeeet', _filesToDelete, (err, resp) => {
+ assert.strictEqual(err, null);
+ assert.strictEqual(resp.statusCode, 404);
+ assert.strictEqual(JSON.stringify(resp.body), JSON.stringify(_expectedBody));
+ assert.strictEqual(JSON.stringify(resp.headers), JSON.stringify(_headers));
+ assert.strictEqual(nockRequestS1.pendingMocks().length, 0);
+ done();
+ })
+ })
+
+
+ });
+
+ describe("SWITCH TO CHILD STORAGE", function () {
+
+ it("should not be able to delete a file of a child storage if the write permission is disallowed (access denied)", function(done) {
+ const _headers = {
+ 'content-type': 'text/html; charset=UTF-8',
+ 'content-length': '431',
+ 'x-amz-id-2': 'txe69b17ed1cf04260b9090-0064184b17',
+ 'x-amz-request-id': 'txe69b17ed1cf04260b9090-0064184b17',
+ 'x-trans-id': 'txe69b17ed1cf04260b9090-0064184b17',
+ 'x-openstack-request-id': 'txe69b17ed1cf04260b9090-0064184b17',
+ date: 'Mon, 20 Mar 2023 12:01:28 GMT',
+ connection: 'close'
+ }
+
+ const _filesToDelete = [
+ { key: 'invoice 2023.pdf' },
+ { key: 'carbone(1).png' },
+ { key: 'file.txt' }
+ ]
+
+ const _expectedBody = {
+ error: _filesToDelete.map((value) => {
+ return {
+ key : encodeURIComponent(value.key),
+ code : 'AccessDenied',
+ message: 'Access Denied'
+ }
+ })
+ }
+
+ const nockRequestS1 = nock(url1S3)
+ .post('/www/')
+ .query((actualQueryObject) => {
+ assert.strictEqual(actualQueryObject.delete !== undefined, true);
+ return true;
+ })
+ .reply(500, '')
+
+ const nockRequestS2 = nock(url2S3)
+ .defaultReplyHeaders(_headers)
+ .post('/www/')
+ .query((actualQueryObject) => {
+ assert.strictEqual(actualQueryObject.delete !== undefined, true);
+ return true;
+ })
+ .reply(200, function() {
+ return "invoice%202023.pdfAccessDeniedAccess Deniedcarbone(1).pngAccessDeniedAccess Deniedfile.txtAccessDeniedAccess Denied";
+ })
+ const nockRequestS3 = nock(url1S3)
+ .get('/')
+ .reply(500, '');
+
+ storage.deleteFiles('www', _filesToDelete, (err, resp) => {
+ assert.strictEqual(err, null);
+ assert.strictEqual(resp.statusCode, 200);
+ assert.strictEqual(JSON.stringify(resp.body), JSON.stringify(_expectedBody));
+ assert.strictEqual(JSON.stringify(resp.headers), JSON.stringify(_headers));
+ assert.strictEqual(nockRequestS1.pendingMocks().length, 0);
+ assert.strictEqual(nockRequestS2.pendingMocks().length, 0);
+ assert.strictEqual(nockRequestS3.pendingMocks().length, 0);
+ done();
+ })
+ })
+
+ });
+
+ });
+
+ describe('getFileMetadata', function() {
+
+ describe("REQUEST MAIN STORAGE", function () {
+
+ it('should get file metadata', function(done){
+ const _headers = {
+ 'content-type': 'application/x-www-form-urlencoded; charset=utf-8',
+ 'content-length': '11822',
+ 'x-amz-storage-class': 'STANDARD',
+ 'x-amz-meta-name': 'Carbone.io',
+ 'x-amz-meta-version': '858585',
+ etag: '"fde6d729123cee4db6bfa3606306bc8c"',
+ 'x-amz-version-id': '1679316796.606606',
+ 'last-modified': 'Mon, 20 Mar 2023 12:53:16 GMT',
+ 'x-amz-id-2': 'txd2aa2b0a02554657b5efe-0064185752',
+ 'x-amz-request-id': 'txd2aa2b0a02554657b5efe-0064185752',
+ 'x-trans-id': 'txd2aa2b0a02554657b5efe-0064185752',
+ 'x-openstack-request-id': 'txd2aa2b0a02554657b5efe-0064185752',
+ date: 'Mon, 20 Mar 2023 12:53:38 GMT',
+ connection: 'close'
+ }
+
+ const nockRequestS1 = nock(url1S3)
+ .defaultReplyHeaders(_headers)
+ .intercept("/bucket/file.pdf", "HEAD")
+ .reply(200, "");
+
+ storage.getFileMetadata('bucket', 'file.pdf', function(err, resp) {
+ assert.strictEqual(err, null);
+ assert.strictEqual(resp.statusCode, 200);
+ assert.strictEqual(resp.body.toString(), '');
+ assert.strictEqual(JSON.stringify(resp.headers), JSON.stringify(_headers));
+ assert.strictEqual(nockRequestS1.pendingMocks().length, 0);
+ done();
+ });
+ })
+
+ it('should get file metadata from a bucket as ALIAS', function(done){
+ const _headers = {
+ 'content-type': 'application/x-www-form-urlencoded; charset=utf-8',
+ 'content-length': '11822',
+ 'x-amz-storage-class': 'STANDARD',
+ 'x-amz-meta-name': 'Carbone.io',
+ 'x-amz-meta-version': '858585',
+ etag: '"fde6d729123cee4db6bfa3606306bc8c"',
+ 'x-amz-version-id': '1679316796.606606',
+ 'last-modified': 'Mon, 20 Mar 2023 12:53:16 GMT',
+ 'x-amz-id-2': 'txd2aa2b0a02554657b5efe-0064185752',
+ 'x-amz-request-id': 'txd2aa2b0a02554657b5efe-0064185752',
+ 'x-trans-id': 'txd2aa2b0a02554657b5efe-0064185752',
+ 'x-openstack-request-id': 'txd2aa2b0a02554657b5efe-0064185752',
+ date: 'Mon, 20 Mar 2023 12:53:38 GMT',
+ connection: 'close'
+ }
+
+ const nockRequestS1 = nock(url1S3)
+ .defaultReplyHeaders(_headers)
+ .intercept("/invoices-gra-1234/file.pdf", "HEAD")
+ .reply(200, "");
+
+ storage.getFileMetadata('invoices', 'file.pdf', function(err, resp) {
+ assert.strictEqual(err, null);
+ assert.strictEqual(resp.statusCode, 200);
+ assert.strictEqual(resp.body.toString(), '');
+ assert.strictEqual(JSON.stringify(resp.headers), JSON.stringify(_headers));
+ assert.strictEqual(nockRequestS1.pendingMocks().length, 0);
+ done();
+ });
+ })
+
+ it('should return an error if the object or bucket don\'t exist', function(done){
+ const _headers = {
+ 'content-type': 'application/xml',
+ 'x-amz-id-2': 'tx10b87fee8896442cb93ce-00641855ea',
+ 'x-amz-request-id': 'tx10b87fee8896442cb93ce-00641855ea',
+ 'x-trans-id': 'tx10b87fee8896442cb93ce-00641855ea',
+ 'x-openstack-request-id': 'tx10b87fee8896442cb93ce-00641855ea',
+ date: 'Mon, 20 Mar 2023 12:47:38 GMT',
+ connection: 'close'
+ }
+
+ const nockRequestS1 = nock(url1S3)
+ .defaultReplyHeaders(_headers)
+ .intercept("/bucket/file.pdf", "HEAD")
+ .reply(404, "");
+
+ storage.getFileMetadata('bucket', 'file.pdf', function(err, resp) {
+ assert.strictEqual(err, null);
+ assert.strictEqual(resp.statusCode, 404);
+ assert.strictEqual(JSON.stringify(resp.body), JSON.stringify({}));
+ assert.strictEqual(JSON.stringify(resp.headers), JSON.stringify(_headers));
+ assert.strictEqual(nockRequestS1.pendingMocks().length, 0);
+ done();
+ });
+ })
+ });
+
+ describe("SWITCH TO CHILD STORAGE", function () {
+
+ it('should get file metadata in the second storage', function(done){
+ const _headers = {
+ 'content-type': 'application/x-www-form-urlencoded; charset=utf-8',
+ 'content-length': '11822',
+ 'x-amz-storage-class': 'STANDARD',
+ 'x-amz-meta-name': 'Carbone.io',
+ 'x-amz-meta-version': '858585',
+ etag: '"fde6d729123cee4db6bfa3606306bc8c"',
+ 'x-amz-version-id': '1679316796.606606',
+ 'last-modified': 'Mon, 20 Mar 2023 12:53:16 GMT',
+ 'x-amz-id-2': 'txd2aa2b0a02554657b5efe-0064185752',
+ 'x-amz-request-id': 'txd2aa2b0a02554657b5efe-0064185752',
+ 'x-trans-id': 'txd2aa2b0a02554657b5efe-0064185752',
+ 'x-openstack-request-id': 'txd2aa2b0a02554657b5efe-0064185752',
+ date: 'Mon, 20 Mar 2023 12:53:38 GMT',
+ connection: 'close'
+ }
+
+ const nockRequestS1 = nock(url1S3)
+ .intercept("/bucket/file.pdf", "HEAD")
+ .reply(500, "");
+
+ const nockRequestS2 = nock(url2S3)
+ .defaultReplyHeaders(_headers)
+ .intercept("/bucket/file.pdf", "HEAD")
+ .reply(200, "");
+
+ const nockRequestS3 = nock(url1S3)
+ .get('/')
+ .reply(500, '');
+
+ storage.getFileMetadata('bucket', 'file.pdf', function(err, resp) {
+ assert.strictEqual(err, null);
+ assert.strictEqual(resp.statusCode, 200);
+ assert.strictEqual(resp.body.toString(), '');
+ assert.strictEqual(JSON.stringify(resp.headers), JSON.stringify(_headers));
+ assert.strictEqual(nockRequestS1.pendingMocks().length, 0);
+ assert.strictEqual(nockRequestS2.pendingMocks().length, 0);
+ assert.strictEqual(nockRequestS3.pendingMocks().length, 0);
+ done();
+ });
+ })
+
+ it('should get file metadata in the second storage with a bucket as ALIAS', function(done){
+ const _headers = {
+ 'content-type': 'application/x-www-form-urlencoded; charset=utf-8',
+ 'content-length': '11822',
+ 'x-amz-storage-class': 'STANDARD',
+ 'x-amz-meta-name': 'Carbone.io',
+ 'x-amz-meta-version': '858585',
+ etag: '"fde6d729123cee4db6bfa3606306bc8c"',
+ 'x-amz-version-id': '1679316796.606606',
+ 'last-modified': 'Mon, 20 Mar 2023 12:53:16 GMT',
+ 'x-amz-id-2': 'txd2aa2b0a02554657b5efe-0064185752',
+ 'x-amz-request-id': 'txd2aa2b0a02554657b5efe-0064185752',
+ 'x-trans-id': 'txd2aa2b0a02554657b5efe-0064185752',
+ 'x-openstack-request-id': 'txd2aa2b0a02554657b5efe-0064185752',
+ date: 'Mon, 20 Mar 2023 12:53:38 GMT',
+ connection: 'close'
+ }
+
+ const nockRequestS1 = nock(url1S3)
+ .intercept("/invoices-gra-1234/file.pdf", "HEAD")
+ .reply(500, "");
+
+ const nockRequestS2 = nock(url2S3)
+ .defaultReplyHeaders(_headers)
+ .intercept("/invoices-de-8888/file.pdf", "HEAD")
+ .reply(200, "");
+
+ const nockRequestS3 = nock(url1S3)
+ .get('/')
+ .reply(500, '');
+
+ storage.getFileMetadata('invoices', 'file.pdf', function(err, resp) {
+ assert.strictEqual(err, null);
+ assert.strictEqual(resp.statusCode, 200);
+ assert.strictEqual(resp.body.toString(), '');
+ assert.strictEqual(JSON.stringify(resp.headers), JSON.stringify(_headers));
+ assert.strictEqual(nockRequestS1.pendingMocks().length, 0);
+ assert.strictEqual(nockRequestS2.pendingMocks().length, 0);
+ assert.strictEqual(nockRequestS3.pendingMocks().length, 0);
+ done();
+ });
+ })
+
+
+ });
+
+ });
+
+
+ describe('setFileMetadata', function() {
+
+ describe("REQUEST MAIN STORAGE", function () {
+
+ it('should set file metadata', function(done){
+
+ const _headers2 = {
+ 'content-type': 'application/xml',
+ 'content-length': '224',
+ 'x-amz-version-id': '1679317926.773804',
+ 'last-modified': 'Mon, 20 Mar 2023 13:13:06 GMT',
+ 'x-amz-copy-source-version-id': '1679317926.773804',
+ 'x-amz-storage-class': 'STANDARD',
+ 'x-amz-id-2': 'tx1cbdc88e9f104c038aa3d-0064185be2',
+ 'x-amz-request-id': 'tx1cbdc88e9f104c038aa3d-0064185be2',
+ 'x-trans-id': 'tx1cbdc88e9f104c038aa3d-0064185be2',
+ 'x-openstack-request-id': 'tx1cbdc88e9f104c038aa3d-0064185be2',
+ date: 'Mon, 20 Mar 2023 13:13:06 GMT',
+ connection: 'close'
+ }
+
+ const nockRequestS2 = nock(url1S3, {
+ reqheaders: {
+ 'x-amz-copy-source': () => true,
+ 'x-amz-metadata-directive': () => true
+ }
+ })
+ .defaultReplyHeaders(_headers2)
+ .put('/bucket/file.pdf')
+ .reply(200, "2023-03-20T13:13:06.000Z\"fde6d729123cee4db6bfa3606306bc8c\"");
+
+ storage.setFileMetadata('bucket', 'file.pdf', { headers: { "x-amz-meta-name": "Invoice 2023", "x-amz-meta-version": "1.2.3" } }, (err, resp) => {
+ assert.strictEqual(err, null);
+ assert.strictEqual(resp.statusCode, 200);
+ assert.strictEqual(JSON.stringify(resp.body), JSON.stringify({
+ lastmodified: '2023-03-20T13:13:06.000Z',
+ etag: 'fde6d729123cee4db6bfa3606306bc8c'
+ }));
+ assert.strictEqual(JSON.stringify(resp.headers), JSON.stringify(_headers2));
+ assert.strictEqual(nockRequestS2.pendingMocks().length, 0);
+ done();
+ })
+ })
+
+ it('should set file metadata with a bucket as ALIAS', function(done){
+
+ const _headers2 = {
+ 'content-type': 'application/xml',
+ 'content-length': '224',
+ 'x-amz-version-id': '1679317926.773804',
+ 'last-modified': 'Mon, 20 Mar 2023 13:13:06 GMT',
+ 'x-amz-copy-source-version-id': '1679317926.773804',
+ 'x-amz-storage-class': 'STANDARD',
+ 'x-amz-id-2': 'tx1cbdc88e9f104c038aa3d-0064185be2',
+ 'x-amz-request-id': 'tx1cbdc88e9f104c038aa3d-0064185be2',
+ 'x-trans-id': 'tx1cbdc88e9f104c038aa3d-0064185be2',
+ 'x-openstack-request-id': 'tx1cbdc88e9f104c038aa3d-0064185be2',
+ date: 'Mon, 20 Mar 2023 13:13:06 GMT',
+ connection: 'close'
+ }
+
+ const nockRequestS2 = nock(url1S3, {
+ reqheaders: {
+ 'x-amz-copy-source': () => true,
+ 'x-amz-metadata-directive': () => true
+ }
+ })
+ .defaultReplyHeaders(_headers2)
+ .put('/invoices-gra-1234/file.pdf')
+ .reply(200, "2023-03-20T13:13:06.000Z\"fde6d729123cee4db6bfa3606306bc8c\"");
+
+ storage.setFileMetadata('invoices', 'file.pdf', { headers: { "x-amz-meta-name": "Invoice 2023", "x-amz-meta-version": "1.2.3" } }, (err, resp) => {
+ assert.strictEqual(err, null);
+ assert.strictEqual(resp.statusCode, 200);
+ assert.strictEqual(JSON.stringify(resp.body), JSON.stringify({
+ lastmodified: '2023-03-20T13:13:06.000Z',
+ etag: 'fde6d729123cee4db6bfa3606306bc8c'
+ }));
+ assert.strictEqual(JSON.stringify(resp.headers), JSON.stringify(_headers2));
+ assert.strictEqual(nockRequestS2.pendingMocks().length, 0);
+ done();
+ })
+ })
+
+ it('should return an error if the object does not exist', function(done){
+ const _headers = {
+ 'content-type': 'application/xml',
+ 'x-amz-id-2': 'txb4919778632448bbac785-0064185d71',
+ 'x-amz-request-id': 'txb4919778632448bbac785-0064185d71',
+ 'x-trans-id': 'txb4919778632448bbac785-0064185d71',
+ 'x-openstack-request-id': 'txb4919778632448bbac785-0064185d71',
+ date: 'Mon, 20 Mar 2023 13:19:45 GMT',
+ 'transfer-encoding': 'chunked',
+ connection: 'close'
+ }
+
+ const nockRequestS2 = nock(url1S3, {
+ reqheaders: {
+ 'x-amz-copy-source': () => true,
+ 'x-amz-metadata-directive': () => true
+ }
+ })
+ .defaultReplyHeaders(_headers)
+ .put('/bucket/fiiile.pdf')
+ .reply(404, "NoSuchKeyThe specified key does not exist.txb4919778632448bbac785-0064185d71fiiile.pdf");
+
+ storage.setFileMetadata('bucket', 'fiiile.pdf', { headers: { "x-amz-meta-name": "Invoice 2023", "x-amz-meta-version": "1.2.3" } }, (err, resp) => {
+ assert.strictEqual(err, null);
+ assert.strictEqual(resp.statusCode, 404);
+ assert.strictEqual(JSON.stringify(resp.body), JSON.stringify({
+ error: {
+ code: 'NoSuchKey',
+ message: 'The specified key does not exist.',
+ requestid: 'txb4919778632448bbac785-0064185d71',
+ key: 'fiiile.pdf'
+ }
+ }));
+ assert.strictEqual(JSON.stringify(resp.headers), JSON.stringify(_headers));
+ assert.strictEqual(nockRequestS2.pendingMocks().length, 0);
+ done();
+ })
+ })
+
+ it('should return an error if the bucket does not exist', function(done){
+ const _headers = {
+ 'content-type': 'application/xml',
+ 'x-amz-id-2': 'txb63fe612d3364257bec19-0064185fcf',
+ 'x-amz-request-id': 'txb63fe612d3364257bec19-0064185fcf',
+ 'x-trans-id': 'txb63fe612d3364257bec19-0064185fcf',
+ 'x-openstack-request-id': 'txb63fe612d3364257bec19-0064185fcf',
+ date: 'Mon, 20 Mar 2023 13:29:51 GMT',
+ 'transfer-encoding': 'chunked',
+ connection: 'close'
+ }
+
+ const nockRequestS2 = nock(url1S3, {
+ reqheaders: {
+ 'x-amz-copy-source': () => true,
+ 'x-amz-metadata-directive': () => true
+ }
+ })
+ .defaultReplyHeaders(_headers)
+ .put('/buckeeet/file.pdf')
+ .reply(404, "NoSuchBucketThe specified bucket does not exist.txb63fe612d3364257bec19-0064185fcfbuckeeet");
+
+ storage.setFileMetadata('buckeeet', 'file.pdf', { headers: { "x-amz-meta-name": "Invoice 2023", "x-amz-meta-version": "1.2.3" } }, (err, resp) => {
+ assert.strictEqual(err, null);
+ assert.strictEqual(resp.statusCode, 404);
+ assert.strictEqual(JSON.stringify(resp.body), JSON.stringify({
+ error: {
+ code: 'NoSuchBucket',
+ message: 'The specified bucket does not exist.',
+ requestid: 'txb63fe612d3364257bec19-0064185fcf',
+ bucketname: 'buckeeet'
+ }
+ }));
+ assert.strictEqual(JSON.stringify(resp.headers), JSON.stringify(_headers));
+ assert.strictEqual(nockRequestS2.pendingMocks().length, 0);
+ done();
+ })
+ })
+
+ it('should return an error if metadata headers aceed the maximum allowed metadata size (2048 Bytes)', function(done){
+ const _headers = {
+ 'content-type': 'application/xml',
+ 'x-amz-id-2': 'txb63fe612d3364257bec19-0064185fcf',
+ 'x-amz-request-id': 'txb63fe612d3364257bec19-0064185fcf',
+ 'x-trans-id': 'txb63fe612d3364257bec19-0064185fcf',
+ 'x-openstack-request-id': 'txb63fe612d3364257bec19-0064185fcf',
+ date: 'Mon, 20 Mar 2023 13:29:51 GMT',
+ 'transfer-encoding': 'chunked',
+ connection: 'close'
+ }
+
+ const nockRequestS2 = nock(url1S3, {
+ reqheaders: {
+ 'x-amz-copy-source': () => true,
+ 'x-amz-metadata-directive': () => true
+ }
+ })
+ .defaultReplyHeaders(_headers)
+ .put('/bucket/file.pdf')
+ .reply(400, "MetadataTooLargeYour metadata headers exceed the maximum allowed metadata size307220484SJA4PV72M8WXZ46GHxUyWQsQrv4DNU+X6K2YYqBN65twd+IZH0g3yRz7HQ7EXcVlfE8e81eJ559/3SyY0FscUdsyWY=");
+
+ storage.setFileMetadata('bucket', 'file.pdf', { headers: { "x-amz-meta-name": "Invoice 2023", "x-amz-meta-version": "1.2.3" } }, (err, resp) => {
+ assert.strictEqual(err, null);
+ assert.strictEqual(resp.statusCode, 400);
+ assert.strictEqual(JSON.stringify(resp.body), JSON.stringify({
+ error: {
+ code: 'MetadataTooLarge',
+ message: 'Your metadata headers exceed the maximum allowed metadata size',
+ size: 3072,
+ maxsizeallowed: 2048,
+ requestid: '4SJA4PV72M8WXZ46',
+ hostid: 'GHxUyWQsQrv4DNU+X6K2YYqBN65twd+IZH0g3yRz7HQ7EXcVlfE8e81eJ559/3SyY0FscUdsyWY='
+ }
+ }));
+ assert.strictEqual(JSON.stringify(resp.headers), JSON.stringify(_headers));
+ assert.strictEqual(nockRequestS2.pendingMocks().length, 0);
+ done();
+ })
+ })
+
+ });
+
+ describe("SWITCH TO CHILD STORAGE", function () {
+
+ it('should set file metadata in the child storage', function(done){
+
+ const _headers2 = {
+ 'content-type': 'application/xml',
+ 'content-length': '224',
+ 'x-amz-version-id': '1679317926.773804',
+ 'last-modified': 'Mon, 20 Mar 2023 13:13:06 GMT',
+ 'x-amz-copy-source-version-id': '1679317926.773804',
+ 'x-amz-storage-class': 'STANDARD',
+ 'x-amz-id-2': 'tx1cbdc88e9f104c038aa3d-0064185be2',
+ 'x-amz-request-id': 'tx1cbdc88e9f104c038aa3d-0064185be2',
+ 'x-trans-id': 'tx1cbdc88e9f104c038aa3d-0064185be2',
+ 'x-openstack-request-id': 'tx1cbdc88e9f104c038aa3d-0064185be2',
+ date: 'Mon, 20 Mar 2023 13:13:06 GMT',
+ connection: 'close'
+ }
+
+
+ const nockRequestS1 = nock(url1S3, {
+ reqheaders: {
+ 'x-amz-copy-source': () => true,
+ 'x-amz-metadata-directive': () => true
+ }
+ })
+ .put('/bucket/file.pdf')
+ .reply(500, "");
+
+ const nockRequestS2 = nock(url2S3, {
+ reqheaders: {
+ 'x-amz-copy-source': () => true,
+ 'x-amz-metadata-directive': () => true
+ }
+ })
+ .defaultReplyHeaders(_headers2)
+ .put('/bucket/file.pdf')
+ .reply(200, "2023-03-20T13:13:06.000Z\"fde6d729123cee4db6bfa3606306bc8c\"");
+
+ const nockRequestS3 = nock(url1S3)
+ .get('/')
+ .reply(500, "");
+
+
+ storage.setFileMetadata('bucket', 'file.pdf', { headers: { "x-amz-meta-name": "Invoice 2023", "x-amz-meta-version": "1.2.3" } }, (err, resp) => {
+ assert.strictEqual(err, null);
+ assert.strictEqual(resp.statusCode, 200);
+ assert.strictEqual(JSON.stringify(resp.body), JSON.stringify({
+ lastmodified: '2023-03-20T13:13:06.000Z',
+ etag: 'fde6d729123cee4db6bfa3606306bc8c'
+ }));
+ assert.strictEqual(JSON.stringify(resp.headers), JSON.stringify(_headers2));
+ assert.strictEqual(nockRequestS1.pendingMocks().length, 0);
+ assert.strictEqual(nockRequestS2.pendingMocks().length, 0);
+ assert.strictEqual(nockRequestS3.pendingMocks().length, 0);
+ done();
+ })
+ })
+
+ it('should set file metadata in the child storage with a bucket as ALIAS', function(done){
+
+ const _headers2 = {
+ 'content-type': 'application/xml',
+ 'content-length': '224',
+ 'x-amz-version-id': '1679317926.773804',
+ 'last-modified': 'Mon, 20 Mar 2023 13:13:06 GMT',
+ 'x-amz-copy-source-version-id': '1679317926.773804',
+ 'x-amz-storage-class': 'STANDARD',
+ 'x-amz-id-2': 'tx1cbdc88e9f104c038aa3d-0064185be2',
+ 'x-amz-request-id': 'tx1cbdc88e9f104c038aa3d-0064185be2',
+ 'x-trans-id': 'tx1cbdc88e9f104c038aa3d-0064185be2',
+ 'x-openstack-request-id': 'tx1cbdc88e9f104c038aa3d-0064185be2',
+ date: 'Mon, 20 Mar 2023 13:13:06 GMT',
+ connection: 'close'
+ }
+
+
+ const nockRequestS1 = nock(url1S3, {
+ reqheaders: {
+ 'x-amz-copy-source': () => true,
+ 'x-amz-metadata-directive': () => true
+ }
+ })
+ .put('/invoices-gra-1234/file.pdf')
+ .reply(500, "");
+
+ const nockRequestS2 = nock(url2S3, {
+ reqheaders: {
+ 'x-amz-copy-source': () => true,
+ 'x-amz-metadata-directive': () => true
+ }
+ })
+ .defaultReplyHeaders(_headers2)
+ .put('/invoices-de-8888/file.pdf')
+ .reply(200, "2023-03-20T13:13:06.000Z\"fde6d729123cee4db6bfa3606306bc8c\"");
+
+ const nockRequestS3 = nock(url1S3)
+ .get('/')
+ .reply(500, "");
+
+
+ storage.setFileMetadata('invoices', 'file.pdf', { headers: { "x-amz-meta-name": "Invoice 2023", "x-amz-meta-version": "1.2.3" } }, (err, resp) => {
+ assert.strictEqual(err, null);
+ assert.strictEqual(resp.statusCode, 200);
+ assert.strictEqual(JSON.stringify(resp.body), JSON.stringify({
+ lastmodified: '2023-03-20T13:13:06.000Z',
+ etag: 'fde6d729123cee4db6bfa3606306bc8c'
+ }));
+ assert.strictEqual(JSON.stringify(resp.headers), JSON.stringify(_headers2));
+ assert.strictEqual(nockRequestS1.pendingMocks().length, 0);
+ assert.strictEqual(nockRequestS2.pendingMocks().length, 0);
+ assert.strictEqual(nockRequestS3.pendingMocks().length, 0);
+ done();
+ })
+ })
+
+ it("should not be able to write file metadata of a child storage if the write permission is disallowed", function(done) {
+
+ const _headers2 = {
+ 'content-type': 'application/xml',
+ 'x-amz-id-2': 'tx439620795cdd41b08c58c-0064186222',
+ 'x-amz-request-id': 'tx439620795cdd41b08c58c-0064186222',
+ 'x-trans-id': 'tx439620795cdd41b08c58c-0064186222',
+ 'x-openstack-request-id': 'tx439620795cdd41b08c58c-0064186222',
+ date: 'Mon, 20 Mar 2023 13:39:46 GMT',
+ 'transfer-encoding': 'chunked',
+ connection: 'close'
+ }
+
+ const nockRequestS1 = nock(url1S3)
+ .put('/bucket/file.pdf')
+ .reply(500, "");
+
+
+ const nockRequestS2 = nock(url2S3, {
+ reqheaders: {
+ 'x-amz-copy-source': () => true,
+ 'x-amz-metadata-directive': () => true
+ }
+ })
+ .defaultReplyHeaders(_headers2)
+ .put('/bucket/file.pdf')
+ .reply(403, "AccessDeniedAccess Denied.tx439620795cdd41b08c58c-0064186222");
+
+ const nockRequestS3 = nock(url1S3)
+ .get('/')
+ .reply(500, "");
+
+ storage.setFileMetadata('bucket', 'file.pdf', { headers: { "x-amz-meta-name": "Invoice 2023", "x-amz-meta-version": "1.2.3" } }, (err, resp) => {
+ assert.strictEqual(err, null);
+ assert.strictEqual(resp.statusCode, 403);
+ assert.strictEqual(JSON.stringify(resp.body), JSON.stringify({
+ error: {
+ code: 'AccessDenied',
+ message: 'Access Denied.',
+ requestid: 'tx439620795cdd41b08c58c-0064186222'
+ }
+ }));
+ assert.strictEqual(JSON.stringify(resp.headers), JSON.stringify(_headers2));
+ assert.strictEqual(nockRequestS1.pendingMocks().length, 0);
+ assert.strictEqual(nockRequestS2.pendingMocks().length, 0);
+ assert.strictEqual(nockRequestS3.pendingMocks().length, 0);
+ done();
+ })
+ })
+
+ });
+
+ });
+
+ describe('getMetadataTotalBytes', function() {
+
+ it('should count headers metadata size', function(done) {
+ /** value + "name-1" */
+ assert.strictEqual(storage.getMetadataTotalBytes({
+ "x-amz-meta-name-1": "ehseedwosyevblphjjeqfwhfiuojgznptwtpogzyiqiakqpyfsehfoafciyzjuugmjmtvrwjfgfdhbiocoowyggqpzwmfcogmqvaebcfchaxwkllqspdxdisbaxqnbgexpzkllonbkjjmmtccbosocwjgatjeokarbklcagejpzyypjbrinqzqdbxjgeswyhcmgiuifnwrgqhkpthtfuehseedwosyevblphjjeqfwhfiuojgznptwtpogzyiqiakqpyfsehfoafciyzjuugmjmtvrwjfgfdhbiocoowyggqpzwmfcogmqvaebcfchaxwkllqspdxdisbaxqnbgexpzkllonbkjjmmtccbosocwjgatjeokarbklcagejpzyypjbrinqzqdbxjgeswyhcmgiuifnwrgqhkpthtfuehseedwosyevblphjjeqfwhfiuojgznptwtpogzyiqiakqpyfsehfoafciyzjuugmjmtvrwjfgfdhbiocoowyggqpzwmfcogmqvaebcfchaxwkllqspdxdisbaxqnbgexpzkllonbkjjmmtccbosocwjgatjeokarbklcagejpzyypjbrinqzqdbxjgeswyhcmgiuifnwrgqhkpthtfu"
+ }), 642)
+ /** values + "name-1" + "name-2" and ignore "x-amz-metadata" */
+ assert.strictEqual(storage.getMetadataTotalBytes({
+ "x-amz-metadata": "should not count",
+ "x-amz-meta-name-1": "123456",
+ "x-amz-meta-name-2": "789",
+ }), 21)
+ /** should ignore if none start with x-amz-meta- */
+ assert.strictEqual(storage.getMetadataTotalBytes({
+ "x-amz-metadata": "should not count",
+ "name-1": "123456",
+ "name-2": "789",
+ }), 0)
+ done();
+ })
+ })
+
+ describe('setLogFunction', function () {
+ it('should overload the log function', function (done) {
+ let i = 0;
+
+ storage.setLogFunction(function (message, level) {
+ assert.strictEqual(message.length > 0, true)
+ assert.strictEqual(level.length > 0, true)
+ i++;
+ })
+
+ const nockRequestS1 = nock(url1S3)
+ .intercept("/bucket", "HEAD")
+ .reply(500, "");
+ const nockRequestS2 = nock(url2S3)
+ .intercept("/bucket", "HEAD")
+ .reply(200, "");
+
+ storage.headBucket('bucket', (err) => {
+ assert.strictEqual(err, null);
+ assert.strictEqual(i > 0, true);
+ assert.strictEqual(nockRequestS1.pendingMocks().length, 0);
+ assert.strictEqual(nockRequestS2.pendingMocks().length, 0);
+ done();
+ });
+ });
+ });
+
+});
\ No newline at end of file
diff --git a/tests/storage.test.js b/tests/swift.test.js
similarity index 98%
rename from tests/storage.test.js
rename to tests/swift.test.js
index 879c789..6f3ae67 100644
--- a/tests/storage.test.js
+++ b/tests/swift.test.js
@@ -1,4 +1,4 @@
-const storageSDK = require('../index.js');
+const storageSDK = require('../swift.js');
const nock = require('nock');
const assert = require('assert');
const fs = require('fs');
@@ -112,7 +112,7 @@ describe('Ovh Object Storage High Availability Node Client', function () {
storage.connection((err) => {
assert.strictEqual(err, null);
- assert.deepStrictEqual(storage.getConfig().actifStorage, 1);
+ assert.deepStrictEqual(storage.getConfig().activeStorage, 1);
assert.deepStrictEqual(storage.getConfig().token, tokenAuth);
assert.deepStrictEqual(storage.getConfig().endpoints.url, connectionResultSuccessV3.token.catalog[9].endpoints[4].url);
assert.strictEqual(firstNock.pendingMocks().length, 0);
@@ -144,7 +144,7 @@ describe('Ovh Object Storage High Availability Node Client', function () {
storage.connection((err) => {
assert.strictEqual(err, null);
- assert.deepStrictEqual(storage.getConfig().actifStorage, 1);
+ assert.deepStrictEqual(storage.getConfig().activeStorage, 1);
assert.deepStrictEqual(storage.getConfig().token, tokenAuth);
assert.deepStrictEqual(storage.getConfig().endpoints.url, connectionResultSuccessV3.token.catalog[9].endpoints[4].url);
assert.strictEqual(firstNock.pendingMocks().length, 0);
@@ -179,7 +179,7 @@ describe('Ovh Object Storage High Availability Node Client', function () {
storage.connection((err) => {
assert.strictEqual(err, null);
- assert.deepStrictEqual(storage.getConfig().actifStorage, 1);
+ assert.deepStrictEqual(storage.getConfig().activeStorage, 1);
assert.deepStrictEqual(storage.getConfig().token, tokenAuth);
assert.deepStrictEqual(storage.getConfig().endpoints.url, connectionResultSuccessV3.token.catalog[9].endpoints[4].url);
assert.strictEqual(firstNock.pendingMocks().length, 0);
@@ -211,7 +211,7 @@ describe('Ovh Object Storage High Availability Node Client', function () {
storage.connection((err) => {
assert.strictEqual(err, null);
- assert.deepStrictEqual(storage.getConfig().actifStorage, 1);
+ assert.deepStrictEqual(storage.getConfig().activeStorage, 1);
assert.deepStrictEqual(storage.getConfig().token, tokenAuth);
assert.deepStrictEqual(storage.getConfig().endpoints.url, connectionResultSuccessV3.token.catalog[9].endpoints[4].url);
assert.strictEqual(firstNock.pendingMocks().length, 0);
@@ -243,7 +243,7 @@ describe('Ovh Object Storage High Availability Node Client', function () {
storage.connection((err) => {
assert.strictEqual(err, null);
- assert.deepStrictEqual(storage.getConfig().actifStorage, 1);
+ assert.deepStrictEqual(storage.getConfig().activeStorage, 1);
assert.deepStrictEqual(storage.getConfig().token, tokenAuth);
assert.deepStrictEqual(storage.getConfig().endpoints.url, connectionResultSuccessV3.token.catalog[9].endpoints[4].url);
assert.strictEqual(firstNock.pendingMocks().length, 0);
@@ -280,7 +280,7 @@ describe('Ovh Object Storage High Availability Node Client', function () {
assert.strictEqual(err.message, 'Object Storages are not available');
storage.connection((err) => {
assert.strictEqual(err, null);
- assert.deepStrictEqual(storage.getConfig().actifStorage, 0);
+ assert.deepStrictEqual(storage.getConfig().activeStorage, 0);
assert.deepStrictEqual(storage.getConfig().token, tokenAuth);
assert.deepStrictEqual(storage.getConfig().endpoints.url, connectionResultSuccessV3.token.catalog[9].endpoints[20].url);
assert.strictEqual(firstNock.pendingMocks().length, 0);
@@ -489,7 +489,7 @@ describe('Ovh Object Storage High Availability Node Client', function () {
assert.strictEqual(err.message, 'Object Storages are not available');
assert.strictEqual(body, undefined);
assert.strictEqual(firstNock.pendingMocks().length, 0);
- assert.deepStrictEqual(storage.getConfig().actifStorage, 0);
+ assert.deepStrictEqual(storage.getConfig().activeStorage, 0);
done();
});
});
@@ -573,7 +573,7 @@ describe('Ovh Object Storage High Availability Node Client', function () {
assert.strictEqual(firstNock.pendingMocks().length, 0);
assert.strictEqual(secondNock.pendingMocks().length, 0);
assert.strictEqual(thirdNock.pendingMocks().length, 0);
- assert.deepStrictEqual(storage.getConfig().actifStorage, 1);
+ assert.deepStrictEqual(storage.getConfig().activeStorage, 1);
done();
});
});
@@ -608,7 +608,7 @@ describe('Ovh Object Storage High Availability Node Client', function () {
assert.strictEqual(firstNock.pendingMocks().length, 0);
assert.strictEqual(secondNock.pendingMocks().length, 0);
assert.strictEqual(thirdNock.pendingMocks().length, 0);
- assert.deepStrictEqual(storage.getConfig().actifStorage, 1);
+ assert.deepStrictEqual(storage.getConfig().activeStorage, 1);
done();
});
});
@@ -647,7 +647,7 @@ describe('Ovh Object Storage High Availability Node Client', function () {
assert.strictEqual(firstNock.pendingMocks().length, 0);
assert.strictEqual(secondNock.pendingMocks().length, 0);
assert.strictEqual(thirdNock.pendingMocks().length, 0);
- assert.deepStrictEqual(storage.getConfig().actifStorage, 1);
+ assert.deepStrictEqual(storage.getConfig().activeStorage, 1);
done();
});
});
@@ -677,7 +677,7 @@ describe('Ovh Object Storage High Availability Node Client', function () {
assert.strictEqual(firstNock.pendingMocks().length, 0);
assert.strictEqual(secondNock.pendingMocks().length, 0);
assert.strictEqual(thirdNock.pendingMocks().length, 0);
- assert.deepStrictEqual(storage.getConfig().actifStorage, 1);
+ assert.deepStrictEqual(storage.getConfig().activeStorage, 1);
done();
});
});
@@ -747,7 +747,7 @@ describe('Ovh Object Storage High Availability Node Client', function () {
assert.strictEqual(_listFiles2[0].name.length > 0, true)
assert.strictEqual(_listFiles2[0].content_type.length > 0, true)
- assert.deepStrictEqual(storage.getConfig().actifStorage, 1);
+ assert.deepStrictEqual(storage.getConfig().activeStorage, 1);
assert.strictEqual(firstNock.pendingMocks().length, 0);
assert.strictEqual(secondNock.pendingMocks().length, 0);
assert.strictEqual(thirdNock.pendingMocks().length, 0);
@@ -839,7 +839,7 @@ describe('Ovh Object Storage High Availability Node Client', function () {
assert.strictEqual(_listFiles4[0].name.length > 0, true)
assert.strictEqual(_listFiles4[0].content_type.length > 0, true)
- assert.deepStrictEqual(storage.getConfig().actifStorage, 1);
+ assert.deepStrictEqual(storage.getConfig().activeStorage, 1);
assert.strictEqual(firstNock.pendingMocks().length, 0);
assert.strictEqual(secondNock.pendingMocks().length, 0);
assert.strictEqual(thirdNock.pendingMocks().length, 0);
@@ -899,7 +899,7 @@ describe('Ovh Object Storage High Availability Node Client', function () {
assert.strictEqual(_listFiles2[0].name.length > 0, true)
assert.strictEqual(_listFiles2[0].content_type.length > 0, true)
- assert.deepStrictEqual(storage.getConfig().actifStorage, 1);
+ assert.deepStrictEqual(storage.getConfig().activeStorage, 1);
assert.strictEqual(firstNock.pendingMocks().length, 0);
assert.strictEqual(secondNock.pendingMocks().length, 0);
assert.strictEqual(thirdNock.pendingMocks().length, 0);
@@ -957,7 +957,7 @@ describe('Ovh Object Storage High Availability Node Client', function () {
assert.strictEqual(_listFiles2[0].name.length > 0, true)
assert.strictEqual(_listFiles2[0].content_type.length > 0, true)
- assert.deepStrictEqual(storage.getConfig().actifStorage, 1);
+ assert.deepStrictEqual(storage.getConfig().activeStorage, 1);
assert.strictEqual(firstNock.pendingMocks().length, 0);
assert.strictEqual(secondNock.pendingMocks().length, 0);
assert.strictEqual(thirdNock.pendingMocks().length, 0);
@@ -1019,7 +1019,7 @@ describe('Ovh Object Storage High Availability Node Client', function () {
assert.strictEqual(_listFiles2[0].name.length > 0, true)
assert.strictEqual(_listFiles2[0].content_type.length > 0, true)
- assert.deepStrictEqual(storage.getConfig().actifStorage, 1);
+ assert.deepStrictEqual(storage.getConfig().activeStorage, 1);
assert.strictEqual(firstNock.pendingMocks().length, 0);
assert.strictEqual(secondNock.pendingMocks().length, 0);
assert.strictEqual(thirdNock.pendingMocks().length, 0);
@@ -1212,7 +1212,7 @@ describe('Ovh Object Storage High Availability Node Client', function () {
assert.strictEqual(firstNock.pendingMocks().length, 0);
assert.strictEqual(secondNock.pendingMocks().length, 0);
assert.strictEqual(thirdNock.pendingMocks().length, 0);
- assert.deepStrictEqual(storage.getConfig().actifStorage, 1);
+ assert.deepStrictEqual(storage.getConfig().activeStorage, 1);
done();
});
@@ -1256,7 +1256,7 @@ describe('Ovh Object Storage High Availability Node Client', function () {
assert.strictEqual(firstNock.pendingMocks().length, 0);
assert.strictEqual(secondNock.pendingMocks().length, 0);
assert.strictEqual(thirdNock.pendingMocks().length, 0);
- assert.deepStrictEqual(storage.getConfig().actifStorage, 1);
+ assert.deepStrictEqual(storage.getConfig().activeStorage, 1);
done();
});
})
@@ -1298,7 +1298,7 @@ describe('Ovh Object Storage High Availability Node Client', function () {
assert.strictEqual(headers['date'].length > 0, true);
assert.strictEqual(firstNock.pendingMocks().length, 0);
assert.strictEqual(secondNock.pendingMocks().length, 0);
- assert.deepStrictEqual(storage.getConfig().actifStorage, 1);
+ assert.deepStrictEqual(storage.getConfig().activeStorage, 1);
assert.strictEqual(thirdNock.pendingMocks().length, 0);
done();
});
@@ -1340,7 +1340,7 @@ describe('Ovh Object Storage High Availability Node Client', function () {
assert.strictEqual(firstNock.pendingMocks().length, 0);
assert.strictEqual(secondNock.pendingMocks().length, 0);
assert.strictEqual(thirdNock.pendingMocks().length, 0);
- assert.deepStrictEqual(storage.getConfig().actifStorage, 1);
+ assert.deepStrictEqual(storage.getConfig().activeStorage, 1);
done();
});
});
@@ -1414,7 +1414,7 @@ describe('Ovh Object Storage High Availability Node Client', function () {
assert.strictEqual(firstNock.pendingMocks().length, 0);
assert.strictEqual(secondNock.pendingMocks().length, 0);
assert.strictEqual(thirdNock.pendingMocks().length, 0);
- assert.deepStrictEqual(storage.getConfig().actifStorage, 1);
+ assert.deepStrictEqual(storage.getConfig().activeStorage, 1);
done();
}).catch(err => {
assert.strictEqual(err, null);
@@ -1475,7 +1475,7 @@ describe('Ovh Object Storage High Availability Node Client', function () {
assert.strictEqual(results[1].headers['x-openstack-request-id'].length > 0, true);
assert.strictEqual(results[1].headers['content-length'].length > 0, true);
assert.strictEqual(results[1].headers['date'].length > 0, true);
- assert.deepStrictEqual(storage.getConfig().actifStorage, 1);
+ assert.deepStrictEqual(storage.getConfig().activeStorage, 1);
assert.strictEqual(firstNock.pendingMocks().length, 0);
assert.strictEqual(secondNock.pendingMocks().length, 0);
assert.strictEqual(thirdNock.pendingMocks().length, 0);
@@ -1537,7 +1537,7 @@ describe('Ovh Object Storage High Availability Node Client', function () {
assert.strictEqual(results[1].headers['x-openstack-request-id'].length > 0, true);
assert.strictEqual(results[1].headers['content-length'].length > 0, true);
assert.strictEqual(results[1].headers['date'].length > 0, true);
- assert.deepStrictEqual(storage.getConfig().actifStorage, 1);
+ assert.deepStrictEqual(storage.getConfig().activeStorage, 1);
assert.strictEqual(firstNock.pendingMocks().length, 0);
assert.strictEqual(secondNock.pendingMocks().length, 0);
assert.strictEqual(thirdNock.pendingMocks().length, 0);
@@ -1598,7 +1598,7 @@ describe('Ovh Object Storage High Availability Node Client', function () {
assert.strictEqual(results[1].headers['x-openstack-request-id'].length > 0, true);
assert.strictEqual(results[1].headers['content-length'].length > 0, true);
assert.strictEqual(results[1].headers['date'].length > 0, true);
- assert.deepStrictEqual(storage.getConfig().actifStorage, 1);
+ assert.deepStrictEqual(storage.getConfig().activeStorage, 1);
assert.strictEqual(firstNock.pendingMocks().length, 0);
assert.strictEqual(secondNock.pendingMocks().length, 0);
assert.strictEqual(thirdNock.pendingMocks().length, 0);
@@ -1942,7 +1942,7 @@ describe('Ovh Object Storage High Availability Node Client', function () {
assert.strictEqual(results.length, 2);
assert.strictEqual(results[0], undefined)
assert.strictEqual(results[1], undefined)
- assert.deepStrictEqual(storage.getConfig().actifStorage, 1);
+ assert.deepStrictEqual(storage.getConfig().activeStorage, 1);
assert.strictEqual(firstNock.pendingMocks().length, 0);
assert.strictEqual(secondNock.pendingMocks().length, 0);
assert.strictEqual(thirdNock.pendingMocks().length, 0);
@@ -2014,7 +2014,7 @@ describe('Ovh Object Storage High Availability Node Client', function () {
let _result3 = await uploadFilePromise();
assert.strictEqual(_result3, undefined);
- assert.deepStrictEqual(storage.getConfig().actifStorage, 1);
+ assert.deepStrictEqual(storage.getConfig().activeStorage, 1);
assert.strictEqual(firstNock.pendingMocks().length, 0);
assert.strictEqual(secondNock.pendingMocks().length, 0);
assert.strictEqual(thirdNock.pendingMocks().length, 0);
@@ -2062,7 +2062,7 @@ describe('Ovh Object Storage High Availability Node Client', function () {
assert.strictEqual(results[0], undefined)
assert.strictEqual(results[1], undefined)
- assert.deepStrictEqual(storage.getConfig().actifStorage, 1);
+ assert.deepStrictEqual(storage.getConfig().activeStorage, 1);
assert.strictEqual(firstNock.pendingMocks().length, 0);
assert.strictEqual(secondNock.pendingMocks().length, 0);
assert.strictEqual(thirdNock.pendingMocks().length, 0);
@@ -2109,7 +2109,7 @@ describe('Ovh Object Storage High Availability Node Client', function () {
assert.strictEqual(results[0], undefined)
assert.strictEqual(results[1], undefined)
- assert.deepStrictEqual(storage.getConfig().actifStorage, 1);
+ assert.deepStrictEqual(storage.getConfig().activeStorage, 1);
assert.strictEqual(firstNock.pendingMocks().length, 0);
assert.strictEqual(secondNock.pendingMocks().length, 0);
assert.strictEqual(thirdNock.pendingMocks().length, 0);
@@ -2384,7 +2384,7 @@ describe('Ovh Object Storage High Availability Node Client', function () {
assert.strictEqual(results.length, 2);
assert.strictEqual(results[0], undefined)
assert.strictEqual(results[1], undefined)
- assert.deepStrictEqual(storage.getConfig().actifStorage, 1);
+ assert.deepStrictEqual(storage.getConfig().activeStorage, 1);
assert.strictEqual(firstNock.pendingMocks().length, 0);
assert.strictEqual(secondNock.pendingMocks().length, 0);
assert.strictEqual(thirdNock.pendingMocks().length, 0);
@@ -2443,7 +2443,7 @@ describe('Ovh Object Storage High Availability Node Client', function () {
let _result3 = await deleteFilePromise();
assert.strictEqual(_result3, undefined);
- assert.deepStrictEqual(storage.getConfig().actifStorage, 1);
+ assert.deepStrictEqual(storage.getConfig().activeStorage, 1);
assert.strictEqual(firstNock.pendingMocks().length, 0);
assert.strictEqual(secondNock.pendingMocks().length, 0);
assert.strictEqual(thirdNock.pendingMocks().length, 0);
@@ -2484,7 +2484,7 @@ describe('Ovh Object Storage High Availability Node Client', function () {
assert.strictEqual(results[0], undefined)
assert.strictEqual(results[1], undefined)
- assert.deepStrictEqual(storage.getConfig().actifStorage, 1);
+ assert.deepStrictEqual(storage.getConfig().activeStorage, 1);
assert.strictEqual(firstNock.pendingMocks().length, 0);
assert.strictEqual(secondNock.pendingMocks().length, 0);
assert.strictEqual(thirdNock.pendingMocks().length, 0);
@@ -2523,7 +2523,7 @@ describe('Ovh Object Storage High Availability Node Client', function () {
assert.strictEqual(results[0], undefined)
assert.strictEqual(results[1], undefined)
- assert.deepStrictEqual(storage.getConfig().actifStorage, 1);
+ assert.deepStrictEqual(storage.getConfig().activeStorage, 1);
assert.strictEqual(firstNock.pendingMocks().length, 0);
assert.strictEqual(secondNock.pendingMocks().length, 0);
assert.strictEqual(thirdNock.pendingMocks().length, 0);
@@ -2713,7 +2713,7 @@ describe('Ovh Object Storage High Availability Node Client', function () {
assert.strictEqual(firstNock.pendingMocks().length, 0);
assert.strictEqual(secondNock.pendingMocks().length, 0);
assert.strictEqual(thirdNock.pendingMocks().length, 0);
- assert.deepStrictEqual(storage.getConfig().actifStorage, 1);
+ assert.deepStrictEqual(storage.getConfig().activeStorage, 1);
done();
});
@@ -2756,7 +2756,7 @@ describe('Ovh Object Storage High Availability Node Client', function () {
assert.strictEqual(firstNock.pendingMocks().length, 0);
assert.strictEqual(secondNock.pendingMocks().length, 0);
assert.strictEqual(thirdNock.pendingMocks().length, 0);
- assert.deepStrictEqual(storage.getConfig().actifStorage, 1);
+ assert.deepStrictEqual(storage.getConfig().activeStorage, 1);
done();
});
})
@@ -2797,7 +2797,7 @@ describe('Ovh Object Storage High Availability Node Client', function () {
assert.strictEqual(headers['date'].length > 0, true);
assert.strictEqual(firstNock.pendingMocks().length, 0);
assert.strictEqual(secondNock.pendingMocks().length, 0);
- assert.deepStrictEqual(storage.getConfig().actifStorage, 1);
+ assert.deepStrictEqual(storage.getConfig().activeStorage, 1);
assert.strictEqual(thirdNock.pendingMocks().length, 0);
done();
});
@@ -2838,7 +2838,7 @@ describe('Ovh Object Storage High Availability Node Client', function () {
assert.strictEqual(firstNock.pendingMocks().length, 0);
assert.strictEqual(secondNock.pendingMocks().length, 0);
assert.strictEqual(thirdNock.pendingMocks().length, 0);
- assert.deepStrictEqual(storage.getConfig().actifStorage, 1);
+ assert.deepStrictEqual(storage.getConfig().activeStorage, 1);
done();
});
});
@@ -2910,7 +2910,7 @@ describe('Ovh Object Storage High Availability Node Client', function () {
assert.strictEqual(firstNock.pendingMocks().length, 0);
assert.strictEqual(secondNock.pendingMocks().length, 0);
assert.strictEqual(thirdNock.pendingMocks().length, 0);
- assert.deepStrictEqual(storage.getConfig().actifStorage, 1);
+ assert.deepStrictEqual(storage.getConfig().activeStorage, 1);
done();
}).catch(err => {
assert.strictEqual(err, null);
@@ -2969,7 +2969,7 @@ describe('Ovh Object Storage High Availability Node Client', function () {
assert.strictEqual(results[1]['x-openstack-request-id'].length > 0, true);
assert.strictEqual(results[1]['content-length'].length > 0, true);
assert.strictEqual(results[1]['date'].length > 0, true);
- assert.deepStrictEqual(storage.getConfig().actifStorage, 1);
+ assert.deepStrictEqual(storage.getConfig().activeStorage, 1);
assert.strictEqual(firstNock.pendingMocks().length, 0);
assert.strictEqual(secondNock.pendingMocks().length, 0);
assert.strictEqual(thirdNock.pendingMocks().length, 0);
@@ -3029,7 +3029,7 @@ describe('Ovh Object Storage High Availability Node Client', function () {
assert.strictEqual(results[1]['x-openstack-request-id'].length > 0, true);
assert.strictEqual(results[1]['content-length'].length > 0, true);
assert.strictEqual(results[1]['date'].length > 0, true);
- assert.deepStrictEqual(storage.getConfig().actifStorage, 1);
+ assert.deepStrictEqual(storage.getConfig().activeStorage, 1);
assert.strictEqual(firstNock.pendingMocks().length, 0);
assert.strictEqual(secondNock.pendingMocks().length, 0);
assert.strictEqual(thirdNock.pendingMocks().length, 0);
@@ -3088,7 +3088,7 @@ describe('Ovh Object Storage High Availability Node Client', function () {
assert.strictEqual(results[1]['x-openstack-request-id'].length > 0, true);
assert.strictEqual(results[1]['content-length'].length > 0, true);
assert.strictEqual(results[1]['date'].length > 0, true);
- assert.deepStrictEqual(storage.getConfig().actifStorage, 1);
+ assert.deepStrictEqual(storage.getConfig().activeStorage, 1);
assert.strictEqual(firstNock.pendingMocks().length, 0);
assert.strictEqual(secondNock.pendingMocks().length, 0);
assert.strictEqual(thirdNock.pendingMocks().length, 0);
@@ -3483,7 +3483,7 @@ describe('Ovh Object Storage High Availability Node Client', function () {
assert.strictEqual(results[1]['x-openstack-request-id'].length > 0, true);
assert.strictEqual(results[1]['content-length'] === '0', true);
assert.strictEqual(results[1]['date'].length > 0, true);
- assert.deepStrictEqual(storage.getConfig().actifStorage, 1);
+ assert.deepStrictEqual(storage.getConfig().activeStorage, 1);
assert.strictEqual(firstNock.pendingMocks().length, 0);
assert.strictEqual(secondNock.pendingMocks().length, 0);
assert.strictEqual(thirdNock.pendingMocks().length, 0);
@@ -3567,7 +3567,7 @@ describe('Ovh Object Storage High Availability Node Client', function () {
assert.strictEqual(_result3['content-length'] === '0', true);
assert.strictEqual(_result3['date'].length > 0, true);
- assert.deepStrictEqual(storage.getConfig().actifStorage, 1);
+ assert.deepStrictEqual(storage.getConfig().activeStorage, 1);
assert.strictEqual(firstNock.pendingMocks().length, 0);
assert.strictEqual(secondNock.pendingMocks().length, 0);
assert.strictEqual(thirdNock.pendingMocks().length, 0);
@@ -3626,7 +3626,7 @@ describe('Ovh Object Storage High Availability Node Client', function () {
assert.strictEqual(results[1]['content-length'] === '0', true);
assert.strictEqual(results[1]['date'].length > 0, true);
- assert.deepStrictEqual(storage.getConfig().actifStorage, 1);
+ assert.deepStrictEqual(storage.getConfig().activeStorage, 1);
assert.strictEqual(firstNock.pendingMocks().length, 0);
assert.strictEqual(secondNock.pendingMocks().length, 0);
assert.strictEqual(thirdNock.pendingMocks().length, 0);
@@ -3684,7 +3684,7 @@ describe('Ovh Object Storage High Availability Node Client', function () {
assert.strictEqual(results[1]['content-length'] === '0', true);
assert.strictEqual(results[1]['date'].length > 0, true);
- assert.deepStrictEqual(storage.getConfig().actifStorage, 1);
+ assert.deepStrictEqual(storage.getConfig().activeStorage, 1);
assert.strictEqual(firstNock.pendingMocks().length, 0);
assert.strictEqual(secondNock.pendingMocks().length, 0);
assert.strictEqual(thirdNock.pendingMocks().length, 0);
@@ -4133,7 +4133,7 @@ describe('Ovh Object Storage High Availability Node Client', function () {
assert.strictEqual(results[1]['headers']['content-length'] === '0', true);
assert.strictEqual(results[1]['headers']['date'].length > 0, true);
assert.strictEqual(results[1]['body'].toString(), 'OK');
- assert.deepStrictEqual(storage.getConfig().actifStorage, 1);
+ assert.deepStrictEqual(storage.getConfig().activeStorage, 1);
assert.strictEqual(firstNock.pendingMocks().length, 0);
assert.strictEqual(secondNock.pendingMocks().length, 0);
assert.strictEqual(thirdNock.pendingMocks().length, 0);
@@ -4221,7 +4221,7 @@ describe('Ovh Object Storage High Availability Node Client', function () {
assert.strictEqual(_result3['headers']['date'].length > 0, true);
assert.strictEqual(_result3['body'].toString(), 'OK');
- assert.deepStrictEqual(storage.getConfig().actifStorage, 1);
+ assert.deepStrictEqual(storage.getConfig().activeStorage, 1);
assert.strictEqual(firstNock.pendingMocks().length, 0);
assert.strictEqual(secondNock.pendingMocks().length, 0);
assert.strictEqual(thirdNock.pendingMocks().length, 0);
@@ -4282,7 +4282,7 @@ describe('Ovh Object Storage High Availability Node Client', function () {
assert.strictEqual(results[1]['headers']['date'].length > 0, true);
assert.strictEqual(results[1]['body'].toString(), 'OK');
- assert.deepStrictEqual(storage.getConfig().actifStorage, 1);
+ assert.deepStrictEqual(storage.getConfig().activeStorage, 1);
assert.strictEqual(firstNock.pendingMocks().length, 0);
assert.strictEqual(secondNock.pendingMocks().length, 0);
assert.strictEqual(thirdNock.pendingMocks().length, 0);
@@ -4342,7 +4342,7 @@ describe('Ovh Object Storage High Availability Node Client', function () {
assert.strictEqual(results[1]['headers']['date'].length > 0, true);
assert.strictEqual(results[1]['body'].toString(), 'OK');
- assert.deepStrictEqual(storage.getConfig().actifStorage, 1);
+ assert.deepStrictEqual(storage.getConfig().activeStorage, 1);
assert.strictEqual(firstNock.pendingMocks().length, 0);
assert.strictEqual(secondNock.pendingMocks().length, 0);
assert.strictEqual(thirdNock.pendingMocks().length, 0);
@@ -4665,7 +4665,7 @@ describe('Ovh Object Storage High Availability Node Client', function () {
assert.strictEqual(results.length, 2);
assert.strictEqual(results[0], 'The platypus, sometimes referred to as the duck-billed platypus, is a semiaquatic, egg-laying mammal endemic to eastern Australia.');
assert.strictEqual(results[1], 'The platypus, sometimes referred to as the duck-billed platypus, is a semiaquatic, egg-laying mammal endemic to eastern Australia.');
- assert.deepStrictEqual(storage.getConfig().actifStorage, 1);
+ assert.deepStrictEqual(storage.getConfig().activeStorage, 1);
assert.strictEqual(firstNock.pendingMocks().length, 0);
assert.strictEqual(secondNock.pendingMocks().length, 0);
assert.strictEqual(thirdNock.pendingMocks().length, 0);
@@ -4733,7 +4733,7 @@ describe('Ovh Object Storage High Availability Node Client', function () {
let _result3 = await copyRequestPromise();
assert.strictEqual(_result3, 'The platypus, sometimes referred to as the duck-billed platypus, is a semiaquatic, egg-laying mammal endemic to eastern Australia.');
- assert.deepStrictEqual(storage.getConfig().actifStorage, 1);
+ assert.deepStrictEqual(storage.getConfig().activeStorage, 1);
assert.strictEqual(firstNock.pendingMocks().length, 0);
assert.strictEqual(secondNock.pendingMocks().length, 0);
assert.strictEqual(thirdNock.pendingMocks().length, 0);
@@ -4777,7 +4777,7 @@ describe('Ovh Object Storage High Availability Node Client', function () {
assert.strictEqual(results.length, 2);
assert.strictEqual(results[0], 'The platypus, sometimes referred to as the duck-billed platypus, is a semiaquatic, egg-laying mammal endemic to eastern Australia.');
assert.strictEqual(results[1], 'The platypus, sometimes referred to as the duck-billed platypus, is a semiaquatic, egg-laying mammal endemic to eastern Australia.');
- assert.deepStrictEqual(storage.getConfig().actifStorage, 1);
+ assert.deepStrictEqual(storage.getConfig().activeStorage, 1);
assert.strictEqual(firstNock.pendingMocks().length, 0);
assert.strictEqual(secondNock.pendingMocks().length, 0);
assert.strictEqual(thirdNock.pendingMocks().length, 0);
@@ -4821,7 +4821,7 @@ describe('Ovh Object Storage High Availability Node Client', function () {
assert.strictEqual(results[0], 'The platypus, sometimes referred to as the duck-billed platypus, is a semiaquatic, egg-laying mammal endemic to eastern Australia.');
assert.strictEqual(results[1], 'The platypus, sometimes referred to as the duck-billed platypus, is a semiaquatic, egg-laying mammal endemic to eastern Australia.');
- assert.deepStrictEqual(storage.getConfig().actifStorage, 1);
+ assert.deepStrictEqual(storage.getConfig().activeStorage, 1);
assert.strictEqual(firstNock.pendingMocks().length, 0);
assert.strictEqual(secondNock.pendingMocks().length, 0);
assert.strictEqual(thirdNock.pendingMocks().length, 0);
diff --git a/tests/xmlToJson.test.js b/tests/xmlToJson.test.js
new file mode 100644
index 0000000..318a4b3
--- /dev/null
+++ b/tests/xmlToJson.test.js
@@ -0,0 +1,277 @@
+const xmlToJson = require('../xmlToJson.js')
+const assert = require('assert')
+
+const _assert = (actual, expected) => {
+ assert.strictEqual(JSON.stringify(actual), JSON.stringify(expected))
+}
+
+describe('xmlToJson', function () {
+ it('should not crash with empty/null/undefiend/weird', function () {
+ _assert(xmlToJson(''), {})
+ _assert(xmlToJson(null), {})
+ _assert(xmlToJson(undefined), {})
+ _assert(xmlToJson({}), {})
+ _assert(xmlToJson([]), {})
+ _assert(xmlToJson('<</>/><a/>'), {})
+ })
+
+ it('should return simple object', function () {
+ const _json = xmlToJson('EricBlue')
+
+ const _expected = {
+ name: 'Eric',
+ color: 'Blue',
+ }
+
+ _assert(_json, _expected)
+ })
+
+ it('should return simple object, and overwrite an existing field', function () {
+ const _json = xmlToJson('BlueRed')
+
+ const _expected = {
+ color: 'Red',
+ }
+
+ _assert(_json, _expected)
+ })
+
+ it('should return simple nested object', function () {
+ const _json = xmlToJson(
+ 'EricBlue',
+ )
+
+ const _expected = {
+ bucket: {
+ name: 'Eric',
+ color: 'Blue',
+ },
+ }
+
+ _assert(_json, _expected)
+ })
+
+ it('should return simple nested object', function () {
+ const _json = xmlToJson(
+ 'BlueJohn',
+ )
+
+ const _expected = {
+ bucket: {
+ color: 'Blue',
+ },
+ name: 'John',
+ }
+
+ _assert(_json, _expected)
+ })
+
+ it('should parse a simple nested object', function () {
+ let _xml =
+ 'templatestemplate.odt'
+ const _json = xmlToJson(_xml)
+
+ const _expected = {
+ name: 'templates',
+ contents: {
+ key: 'template.odt',
+ },
+ }
+ _assert(_json, _expected)
+ })
+
+ it('should parse a simple nested object', function () {
+ let _xml =
+ 'templates11000falsetemplate.odt2023-03-02T07:18:55.000Z"fde6d729123cee4db6bfa3606306bc8c"11822STANDARD'
+ const _json = xmlToJson(_xml)
+
+ const _expected = {
+ name: 'templates',
+ keycount: 1,
+ maxkeys: 1000,
+ istruncated: false,
+ contents: {
+ key: 'template.odt',
+ lastmodified: '2023-03-02T07:18:55.000Z',
+ etag: 'fde6d729123cee4db6bfa3606306bc8c',
+ size: 11822,
+ storageclass: 'STANDARD',
+ },
+ }
+ _assert(_json, _expected)
+ })
+
+ it('should parse a simple nested object, if the name is the same, it should be overwrited', function () {
+ let _xml = 'BlueGreen'
+ const _json = xmlToJson(_xml)
+
+ const _expected = {
+ colors: {
+ name: 'Green',
+ },
+ }
+ _assert(_json, _expected)
+ })
+
+ it('should return simple nested object as Array', function () {
+ const _json = xmlToJson(
+ 'EricBlueJohnGreen',
+ )
+
+ const _expected = {
+ bucket: [
+ {
+ name: 'Eric',
+ color: 'Blue',
+ },
+ {
+ name: 'John',
+ color: 'Green',
+ },
+ ],
+ }
+
+ _assert(_json, _expected)
+ })
+
+ it('should parse a the response of "ListObjects V2"', function () {
+ let _xml =
+ 'templates11000falsetemplate.odt2023-03-02T07:18:55.000Z"fde6d729123cee4db6bfa3606306bc8c"11822STANDARDtemplate.docx2024-03-02T07:18:55.000Z"fde6d729123cee4db6bfa1111306b222"85000STANDARD'
+ const _json = xmlToJson(_xml)
+
+ const _expected = {
+ name: 'templates',
+ keycount: 1,
+ maxkeys: 1000,
+ istruncated: false,
+ contents: [
+ {
+ key: 'template.odt',
+ lastmodified: '2023-03-02T07:18:55.000Z',
+ etag: 'fde6d729123cee4db6bfa3606306bc8c',
+ size: 11822,
+ storageclass: 'STANDARD',
+ },
+ {
+ key: 'template.docx',
+ lastmodified: '2024-03-02T07:18:55.000Z',
+ etag: 'fde6d729123cee4db6bfa1111306b222',
+ size: 85000,
+ storageclass: 'STANDARD',
+ },
+ ],
+ }
+ _assert(_json, _expected)
+ })
+
+ it('should parse a the response of "ListObjects V2" and return an Array for "contents" even if the Content list has one element.', function () {
+ let _xml =
+ 'templates11000truetemplate.odt2023-03-02T07:18:55.000Z"fde6d729123cee4db6bfa3606306bc8c"11822STANDARD'
+ const _json = xmlToJson(_xml, { forceArray: ['contents'] })
+
+ const _expected = {
+ name: 'templates',
+ keycount: 1,
+ maxkeys: 1000,
+ istruncated: true,
+ contents: [
+ {
+ key: 'template.odt',
+ lastmodified: '2023-03-02T07:18:55.000Z',
+ etag: 'fde6d729123cee4db6bfa3606306bc8c',
+ size: 11822,
+ storageclass: 'STANDARD',
+ }
+ ],
+ }
+ _assert(_json, _expected)
+ })
+
+ it('should parse a simple nested object and force an element to be a Array (options: forceArray)', function () {
+ let _xml =
+ 'templates11000falsetemplate.odt2023-03-02T07:18:55.000Z"fde6d729123cee4db6bfa3606306bc8c"11822STANDARD'
+ const _json = xmlToJson(_xml, { forceArray: ['contents'] })
+
+ const _expected = {
+ name: 'templates',
+ keycount: 1,
+ maxkeys: 1000,
+ istruncated: false,
+ contents: [
+ {
+ key: 'template.odt',
+ lastmodified: '2023-03-02T07:18:55.000Z',
+ etag: 'fde6d729123cee4db6bfa3606306bc8c',
+ size: 11822,
+ storageclass: 'STANDARD',
+ },
+ ],
+ }
+ _assert(_json, _expected)
+ })
+
+ it('should parse the response of "ListObject V2" and skip the 2 depth object', function () {
+ const _xml =
+ '' +
+ '' +
+ 'bucket' +
+ '' +
+ '205' +
+ '1000' +
+ 'false' +
+ '' +
+ 'my-image.jpg' +
+ '2009-10-12T17:50:30.000Z' +
+ '"fba9dede5f27731c9771645a39863328"' +
+ '434234' +
+ 'STANDARD' +
+ '' +
+ '' +
+ 'my-image2.jpg' +
+ '2009-10-12T17:50:30.000Z' +
+ '"fba9dede5f27731c9771645a39863328"' +
+ '434234' +
+ 'STANDARD' +
+ '' +
+ ''
+
+ const _json = xmlToJson(_xml)
+
+ const _expected = {
+ listbucketresult: {
+ name: 'bucket',
+ keycount: 205,
+ maxkeys: 1000,
+ istruncated: false,
+ contents:
+ 'my-image2.jpg2009-10-12T17:50:30.000Z"fba9dede5f27731c9771645a39863328"434234STANDARD',
+ },
+ }
+
+ _assert(_json, _expected)
+ })
+
+ it('should return the Error response from S3 as JSON', function () {
+ const _xml =
+ '' +
+ '' +
+ 'NoSuchKey' +
+ 'The resource you requested does not exist' +
+ '/mybucket/myfoto.jpg' +
+ '4442587FB7D0A2F9' +
+ ''
+
+ const _json = xmlToJson(_xml)
+
+ const _expected = {
+ error: {
+ code: 'NoSuchKey',
+ message: 'The resource you requested does not exist',
+ resource: '/mybucket/myfoto.jpg',
+ requestid: '4442587FB7D0A2F9',
+ }
+ }
+
+ _assert(_json, _expected)
+ })
+})
diff --git a/xmltoJson.js b/xmltoJson.js
new file mode 100644
index 0000000..04ea527
--- /dev/null
+++ b/xmltoJson.js
@@ -0,0 +1,106 @@
+/**
+ * Convert XML to JSON, supports only 1 object depth such as: "{ child: [], child2: {} }".
+ *
+ * @param {String} xml
+ * @param {Object} options (Optional) accepts "forceArray" a list of strings, define if "child" of one element must be lists
+ * @returns {Object} XML as JSON
+ */
+function xmlToJson (xml, options) {
+
+ options = options ?? {};
+
+ /** JSON variables */
+ let root = {};
+ let child = null;
+ let childName = null;
+ let _previousTag = '';
+ let _previousTagFull = '';
+ let _skipObject = null;
+ /** Regex variables */
+ const _xmlTagRegExp = /<([^>]+?)>/g;
+ let _previousLastIndex = 0;
+ let _tagParsed = [];
+ /** Loop through all XML tags */
+ try {
+ while ((_tagParsed = _xmlTagRegExp.exec(xml))) {
+ const _tagStr = _tagParsed[1];
+ const _tagAttributeIndex = _tagStr.indexOf(' '); /** remove attributes from HTML tags */
+ const _tagFull = _tagStr.slice(0, _tagAttributeIndex > 0 ? _tagAttributeIndex : _tagStr.length);
+ const _tag = _tagFull.replace('/', '').toLowerCase();
+
+ /** End of skipped elements */
+ if (_skipObject === _tag && _tagFull[0] === '/') {
+ _skipObject = null;
+ }
+
+ if (_tagFull === '?xml' || _tagFull?.[_tagFull.length - 1] === '/' || _skipObject !== null) {
+ continue;
+ }
+
+ /** Create a new child {}/[] if two opening tags are different, such as: value */
+ if(_tag !== _previousTag && (child === null && _previousTag !== '' && _tagFull[0] !== '/' && _previousTagFull[0] !== '/')) {
+ child = options?.forceArray?.includes(_previousTag) === true ? [{}] : {};
+ childName = _previousTag;
+ } /** If a child already exist, and the two tags are equal, the existing element is retreive from the JSON and transformed as LIST */
+ else if (_tag === _previousTag && _tagFull[0] !== '/' && _previousTagFull[0] === '/' && child === null && (root[_tag]?.constructor === Object || root[_tag]?.constructor === Array)) {
+ child = root[_tag]?.constructor === Object ? [root[_tag]] : root[_tag];
+ childName = _tag;
+ } /** Skip objects of 2 depth */
+ else if (_tag !== _previousTag && child !== null && childName !== _previousTag && _tagFull[0] !== '/' && _previousTagFull[0] !== '/') {
+ _skipObject = _previousTag;
+ continue;
+ }
+
+ /** When we reach the end of a list of child tags ``, the child is assigned to the root object */
+ if (_tagFull[0] === '/' && _previousTagFull[0] === '/' && child) {
+ root[childName] = child?.constructor === Array ? [ ...child ] : { ...child };
+ child = null;
+ childName = null;
+ } /** When we reach the end of a tag red, the value is assign to the child or root object */
+ else if (_tagFull[0] === '/') {
+ const _value = getValue(xml.slice(_previousLastIndex, _tagParsed.index))
+ if (child) {
+ if (child?.constructor === Array) {
+ /** Tag already exist, we must create a new element on the list */
+ if (child[child.length - 1]?.[_tag]) {
+ child.push({});
+ }
+ child[child.length - 1][_tag] = _value;
+ }
+ child[_tag] = _value;
+ } else {
+ root[_tag] = _value;
+ }
+ }
+
+ _previousTag = _tag;
+ _previousTagFull = _tagFull;
+ _previousLastIndex = _xmlTagRegExp.lastIndex;
+ }
+ } catch(_) {
+ return root;
+ }
+ return root;
+}
+
+/**
+ * Function to convert string to corresponding types
+ * @param {String} str value
+ * @returns {String|Boolean|Number}
+ */
+const getValue = (str) => {
+ if (!isNaN(str) && !isNaN(parseFloat(str))) {
+ return parseInt(str)
+ } else if (str.toLowerCase() === "true") {
+ return true;
+ } else if (str.toLowerCase() === "false") {
+ return false;
+ }
+ /** S3 Storage returns the "MD5" hash wrapped with double quotes, must be removed. */
+ if (str[0] === '"' && str?.[str.length - 1] === '"') {
+ return str.slice(1, str.length - 1);
+ }
+ return str;
+}
+
+module.exports = xmlToJson;
\ No newline at end of file