diff --git a/lib/stack/bulkOperation/index.js b/lib/stack/bulkOperation/index.js index 05621003..615b22e3 100644 --- a/lib/stack/bulkOperation/index.js +++ b/lib/stack/bulkOperation/index.js @@ -9,6 +9,109 @@ export function BulkOperation (http, data = {}) { this.stackHeaders = data.stackHeaders this.urlPath = `/bulk` + /** + * The addItems request allows you to add multiple items to a release in bulk. + * @memberof BulkOperation + * @func addItems + * @returns {Promise} Response Object. + * @param {Object} params.data - The data containing the items to be added to the release. + * @param {String} [params.bulk_version] - The bulk version. + * @example + * const itemsData = { + * items: [ + * { + * uid: '{{entry_uid}}', + * content_type: '{{content_type_uid}}' + * } + * ] + * } + * client.stack({ api_key: 'api_key'}).bulkOperation().addItems({ data: itemsData }) + * .then((response) => { console.log(response) }) + */ + this.addItems = async ({ data, bulk_version = "" }) => { + this.urlPath = `/bulk/release/items`; + const headers = { + headers: { + ...cloneDeep(this.stackHeaders), + }, + }; + if (bulk_version) headers.headers.bulk_version = bulk_version; + try { + const response = await http.post(this.urlPath, data, headers); + if (response.data) { + return response.data; + } + } catch (error) { + console.error(error); + } + }; + + /** + * The updateItems request allows you to update multiple items in a release in bulk. + * @memberof BulkOperation + * @func updateItems + * @returns {Promise} Response Object. + * @param {Object} params.data - The data containing the items to be updated in the release. + * @param {String} [params.bulk_version] - The bulk version. + * @example + * const itemsData = { + * items: [ + * { + * uid: '{{entry_uid}}', + * content_type: '{{content_type_uid}}' + * } + * ] + * } + * client.stack({ api_key: 'api_key'}).bulkOperation().updateItems({ data: itemsData }) + * .then((response) => { console.log(response) }) + */ + this.updateItems = async ({ data, bulk_version = "" }) => { + this.urlPath = `/bulk/release/update_items`; + const headers = { + headers: { + ...cloneDeep(this.stackHeaders), + }, + }; + if (bulk_version) headers.headers.bulk_version = bulk_version; + try { + const response = await http.put(this.urlPath, data, headers); + if (response.data) { + return response.data; + } + } catch (error) { + console.error(error); + } + }; + + /** + * The jobStatus request allows you to check the status of a bulk job. + * @memberof BulkOperation + * @func jobStatus + * @returns {Promise} Response Object. + * @param {String} params.job_id - The ID of the job. + * @param {String} [params.bulk_version] - The bulk version. + * @example + * client.stack({ api_key: 'api_key'}).bulkOperation().jobStatus({ job_id: 'job_id' }) + * .then((response) => { console.log(response) }) + */ + this.jobStatus = async ({ job_id, bulk_version = "" }) => { + this.urlPath = `/bulk/jobs/${job_id}`; + const headers = { + headers: { + ...cloneDeep(this.stackHeaders), + }, + }; + if (bulk_version) headers.headers.bulk_version = bulk_version; + try { + const response = await http.get(this.urlPath, headers); + if (response.data) { + return response.data; + } + } catch (error) { + console.error(error); + } + }; + /** * The Publish entries and assets in bulk request allows you to publish multiple entries and assets at the same time. * @memberof BulkOperation diff --git a/lib/stack/release/items/index.js b/lib/stack/release/items/index.js index b8cd65db..dca8e75e 100644 --- a/lib/stack/release/items/index.js +++ b/lib/stack/release/items/index.js @@ -52,25 +52,36 @@ export function ReleaseItem (http, data = {}) { * client.stack({ api_key: 'api_key'}).release('release_uid').delete({items}) * .then((response) => console.log(response.notice)) */ - this.delete = async (items) => { + this.delete = async (params) => { let param = {} - if (items === undefined) { + if (params.items === undefined && params.item === undefined) { param = {all: true} + params.items = [] } try { const headers = { headers: { ...cloneDeep(this.stackHeaders) }, data: { - ...cloneDeep(items) + ...cloneDeep(params) }, params: { ...cloneDeep(param) } } || {} + + if (params.release_version) { + headers.headers['release_version'] = params.release_version; + } + + if (params.item) { + this.urlPath = `releases/${data.releaseUid}/item` + headers.data['item'] = params.item + } else + headers.data['items'] = params.items const response = await http.delete(this.urlPath, headers) if (response.data) { - return new Release(http, { ...response.data, stackHeaders: data.stackHeaders }) + return response.data } else { throw error(response) } @@ -129,9 +140,18 @@ export function ReleaseItem (http, data = {}) { ...cloneDeep(this.stackHeaders) } } || {} + + if (param.release_version) { + headers.headers['release_version'] = param.release_version; + } + if (param.item) { + this.urlPath = `releases/${data.releaseUid}/item` + param['item'] = param.item + } else + param['items'] = param.items try { - const response = await http.post(param.item ? `releases/${data.releaseUid}/item` : this.urlPath, param, headers) + const response = await http.post(this.urlPath, param, headers) if (response.data) { if (response.data) { return new Release(http, { ...response.data, stackHeaders: data.stackHeaders }) @@ -166,7 +186,10 @@ export function ReleaseItem (http, data = {}) { ...cloneDeep(param) } } || {} - + if (param.release_version) { + headers.headers['release_version'] = param.release_version; + delete headers.params.release_version; + } const response = await http.get(this.urlPath, headers) if (response.data) { return new ContentstackCollection(response, http, this.stackHeaders, ReleaseItemCollection) @@ -177,6 +200,44 @@ export function ReleaseItem (http, data = {}) { error(err) } } + + /** + * The move request allows you to move multiple items within a release. + * @memberof ReleaseItem + * @func move + * @returns {Promise} Response Object. + * @param {Object} params.param - The data containing the items to be moved within the release. + * @param {String} [params.release_version] - The release version. + * @example + * const moveData = { + * items: [ + * { + * uid: '{{entry_uid}}', + * content_type: '{{content_type_uid}}' + * } + * ] + * } + * client.stack({ api_key: 'api_key'}).release('release_uid').item().move({ param: moveData, release_version: '1.0' }) + * .then((response) => { console.log(response) }) + */ + this.move = async ({ param, release_version = '' }) => { + const headers = { + headers: { + ...cloneDeep(this.stackHeaders) + } + } || {} + if (release_version) { + headers.headers['release_version'] = release_version; + } + try { + const response = await http.put(`${this.urlPath}/move`, param, headers) + if (response.data) { + return response.data + } + } catch (err) { + throw error(err) + } + } } return this } diff --git a/test/sanity-check/api/release-test.js b/test/sanity-check/api/release-test.js index 20c9c822..befc23c0 100644 --- a/test/sanity-check/api/release-test.js +++ b/test/sanity-check/api/release-test.js @@ -1,239 +1,483 @@ -import { describe, it, setup } from 'mocha' -import { jsonReader } from '../utility/fileOperations/readwrite.js' -import { releaseCreate } from '../mock/release.js' -import { expect } from 'chai' -import { cloneDeep } from 'lodash' -import { contentstackClient } from '../utility/ContentstackClient.js' -import { multiPageCT } from '../mock/content-type.js' -import dotenv from 'dotenv' - -dotenv.config() -let client = {} -let releaseUID = '' -let releaseUID2 = '' -let entries = {} -const itemToDelete = {} - -describe('Relases api Test', () => { +import { describe, it, setup } from "mocha"; +import { jsonReader } from "../utility/fileOperations/readwrite.js"; +import { releaseCreate, releaseCreate2 } from "../mock/release.js"; +import { expect } from "chai"; +import { cloneDeep } from "lodash"; +import { contentstackClient } from "../utility/ContentstackClient.js"; +import { multiPageCT } from "../mock/content-type.js"; +import dotenv from "dotenv"; + +dotenv.config(); +let client = {}; +let releaseUID = ""; +let releaseUID2 = ""; +let releaseUID3 = ""; +let releaseUID4 = ""; +let entries = {}; +const itemToDelete = {}; +const jobId = ""; + +describe("Relases api Test", () => { setup(() => { - const user = jsonReader('loggedinuser.json') - entries = jsonReader('entry.json') - client = contentstackClient(user.authtoken) - }) + const user = jsonReader("loggedinuser.json"); + entries = jsonReader("entry.json"); + client = contentstackClient(user.authtoken); + }); - it('should create a Release', done => { + it("should create a Release", (done) => { makeRelease() .create(releaseCreate) .then((release) => { - releaseUID = release.uid - expect(release.name).to.be.equal(releaseCreate.release.name) - expect(release.description).to.be.equal(releaseCreate.release.description) - expect(release.uid).to.be.not.equal(null) - done() + releaseUID = release.uid; + expect(release.name).to.be.equal(releaseCreate.release.name); + expect(release.description).to.be.equal( + releaseCreate.release.description + ); + expect(release.uid).to.be.not.equal(null); + done(); }) - .catch(done) - }) + .catch(done); + }); - it('should fetch a Release from Uid', done => { + it("should create a Release 2", (done) => { + makeRelease() + .create(releaseCreate2) + .then((release) => { + releaseUID2 = release.uid; + expect(release.name).to.be.equal(releaseCreate2.release.name); + expect(release.description).to.be.equal( + releaseCreate2.release.description + ); + expect(release.uid).to.be.not.equal(null); + done(); + }) + .catch(done); + }); + + it("should fetch a Release from Uid", (done) => { makeRelease(releaseUID) .fetch() .then((release) => { - expect(release.name).to.be.equal(releaseCreate.release.name) - expect(release.description).to.be.equal(releaseCreate.release.description) - expect(release.uid).to.be.equal(releaseUID) - done() + expect(release.name).to.be.equal(releaseCreate.release.name); + expect(release.description).to.be.equal( + releaseCreate.release.description + ); + expect(release.uid).to.be.equal(releaseUID); + done(); }) - .catch(done) - }) + .catch(done); + }); - it('should create release item', done => { + it("should create release item", (done) => { const item = { version: entries[0]._version, uid: entries[0].uid, content_type_uid: multiPageCT.content_type.uid, - action: 'publish', - locale: 'en-us' - } + action: "publish", + locale: "en-us", + }; makeRelease(releaseUID) .item() .create({ item }) .then((release) => { - expect(release.name).to.be.equal(releaseCreate.release.name) - expect(release.description).to.be.equal(releaseCreate.release.description) - expect(release.uid).to.be.equal(releaseUID) - expect(release.items.length).to.be.equal(1) - done() + expect(release.name).to.be.equal(releaseCreate.release.name); + expect(release.description).to.be.equal( + releaseCreate.release.description + ); + expect(release.uid).to.be.equal(releaseUID); + expect(release.items.length).to.be.equal(1); + done(); }) - .catch(done) - }) + .catch(done); + }); - it('should create release items', done => { + it("should create release items", (done) => { const items = [ { version: entries[1]._version, uid: entries[1].uid, content_type_uid: multiPageCT.content_type.uid, - action: 'publish', - locale: 'en-us' + action: "publish", + locale: "en-us", }, { version: entries[2]._version, uid: entries[2].uid, content_type_uid: multiPageCT.content_type.uid, - action: 'publish', - locale: 'en-us' - } - ] + action: "publish", + locale: "en-us", + }, + ]; makeRelease(releaseUID) .item() .create({ items }) .then((release) => { - expect(release.name).to.be.equal(releaseCreate.release.name) - expect(release.description).to.be.equal(releaseCreate.release.description) - expect(release.uid).to.be.equal(releaseUID) - expect(release.items.length).to.be.equal(3) - done() + expect(release.name).to.be.equal(releaseCreate.release.name); + expect(release.description).to.be.equal( + releaseCreate.release.description + ); + expect(release.uid).to.be.equal(releaseUID); + expect(release.items.length).to.be.equal(3); + done(); }) - .catch(done) - }) + .catch(done); + }); - it('should fetch a Release items from Uid', done => { + it("should fetch a Release items from Uid", (done) => { makeRelease(releaseUID) .item() - .findAll() + .findAll({ release_version: "2.0" }) .then((collection) => { - const itemdelete = collection.items[0] - itemToDelete['version'] = itemdelete.version - itemToDelete.action = itemdelete.action - itemToDelete.uid = itemdelete.uid - itemToDelete.locale = itemdelete.locale - itemToDelete.content_type_uid = itemdelete.content_type_uid - expect(collection.items.length).to.be.equal(3) - done() - }) - .catch(done) - }) - - it('should delete specific item', done => { + const itemdelete = collection.items[0]; + itemToDelete["version"] = itemdelete.version; + itemToDelete.action = itemdelete.action; + itemToDelete.uid = itemdelete.uid; + itemToDelete.locale = itemdelete.locale; + itemToDelete.content_type_uid = itemdelete.content_type_uid; + expect(collection.items.length).to.be.equal(3); + done(); + }) + .catch(done); + }); + + it("should move release items from release1 to release2", (done) => { + const data = { + release_uid: releaseUID2, + items: [ + { + uid: entries[1].uid, + locale: "en-us", + }, + ], + }; + makeRelease(releaseUID) + .item() + .move({ param: data, release_version: "2.0" }) + .then((release) => { + expect(release.notice).to.be.equal("Release items moved successfully!"); + done(); + }) + .catch(done); + }); + + it("should delete specific item", (done) => { makeRelease(releaseUID) .item() .delete({ items: [itemToDelete] }) .then((release) => { - expect(release.name).to.be.equal(releaseCreate.release.name) - expect(release.description).to.be.equal(releaseCreate.release.description) - expect(release.uid).to.be.equal(releaseUID) - expect(release.items.length).to.be.equal(2) - done() + expect(release.notice).to.be.equal('Item(s) send to remove from release successfully.'); + done(); }) - .catch(done) - }) + .catch(done); + }); - it('should delete all items', done => { + it("should delete all items", (done) => { makeRelease(releaseUID) .item() - .delete() + .delete({ release_version: "2.0" }) .then((release) => { - expect(release.name).to.be.equal(releaseCreate.release.name) - expect(release.description).to.be.equal(releaseCreate.release.description) - expect(release.uid).to.be.equal(releaseUID) - expect(release.items.length).to.be.equal(0) - done() + expect(release.notice).to.be.equal('Items deleted from release successfully!'); + done(); }) - .catch(done) - }) + .catch(done); + }); - it('should fetch and Update a Release from Uid', done => { + it("should fetch and Update a Release from Uid", (done) => { makeRelease(releaseUID) .fetch() .then((release) => { - release.name = 'Update release name' - return release.update() + release.name = "Update release name"; + return release.update(); }) .then((release) => { - expect(release.name).to.be.equal('Update release name') - expect(release.description).to.be.equal(releaseCreate.release.description) - expect(release.uid).to.be.not.equal(null) - done() + expect(release.name).to.be.equal("Update release name"); + expect(release.description).to.be.equal( + releaseCreate.release.description + ); + expect(release.uid).to.be.not.equal(null); + done(); }) - .catch(done) - }) + .catch(done); + }); - it('should update a Release from Uid', done => { - const relaseObject = makeRelease(releaseUID) - Object.assign(relaseObject, cloneDeep(releaseCreate.release)) + it("should update a Release from Uid", (done) => { + const relaseObject = makeRelease(releaseUID); + Object.assign(relaseObject, cloneDeep(releaseCreate.release)); relaseObject .update() .then((release) => { - expect(release.name).to.be.equal(releaseCreate.release.name) - expect(release.description).to.be.equal(releaseCreate.release.description) - expect(release.uid).to.be.not.equal(null) - done() + expect(release.name).to.be.equal(releaseCreate.release.name); + expect(release.description).to.be.equal( + releaseCreate.release.description + ); + expect(release.uid).to.be.not.equal(null); + done(); }) - .catch(done) - }) + .catch(done); + }); - it('should get all Releases', done => { + it("should get all Releases", (done) => { makeRelease() .query() .find() .then((releaseCollection) => { - releaseCollection.items.forEach(release => { - expect(release.name).to.be.not.equal(null) - expect(release.uid).to.be.not.equal(null) - }) - done() + releaseCollection.items.forEach((release) => { + expect(release.name).to.be.not.equal(null); + expect(release.uid).to.be.not.equal(null); + }); + done(); }) - .catch(done) - }) + .catch(done); + }); - it('should get specific Releases with name ', done => { + it("should get specific Releases with name ", (done) => { makeRelease() .query({ query: { name: releaseCreate.release.name } }) .find() .then((releaseCollection) => { - releaseCollection.items.forEach(release => { - expect(release.name).to.be.equal(releaseCreate.release.name) - expect(release.uid).to.be.not.equal(null) - }) - done() + releaseCollection.items.forEach((release) => { + expect(release.name).to.be.equal(releaseCreate.release.name); + expect(release.uid).to.be.not.equal(null); + }); + done(); }) - .catch(done) - }) + .catch(done); + }); - it('should clone specific Releases with Uid ', done => { + it("should clone specific Releases with Uid ", (done) => { makeRelease(releaseUID) - .clone({ name: 'New Clone Name', description: 'New Desc' }) + .clone({ name: "New Clone Name", description: "New Desc" }) .then((release) => { - releaseUID2 = release.uid - expect(release.name).to.be.equal('New Clone Name') - expect(release.description).to.be.equal('New Desc') - expect(release.uid).to.be.not.equal(null) - done() + releaseUID3 = release.uid; + expect(release.name).to.be.equal("New Clone Name"); + expect(release.description).to.be.equal("New Desc"); + expect(release.uid).to.be.not.equal(null); + done(); + }) + .catch(done); + }); + + it("Bulk Operation: should add items to a release", (done) => { + const items = { + release: releaseUID, + action: "publish", + locale: ["en-us"], + reference: true, + items: [ + { + version: entries[1]._version, + uid: entries[1].uid, + content_type_uid: multiPageCT.content_type.uid, + locale: "en-us", + title: entries[1].title, + }, + { + version: entries[2]._version, + uid: entries[2].uid, + content_type_uid: multiPageCT.content_type.uid, + locale: "en-us", + title: entries[2].title, + }, + ], + }; + doBulkOperation() + .addItems({ data: items, bulk_version: "2.0" }) + .then((response) => { + jobId = response.job_id; + expect(response.notice).to.equal( + "Your add to release request is in progress." + ); + expect(response.job_id).to.not.equal(undefined); + done(); + }) + .catch(done); + }); + + it("Bulk Operation: should fetch job status details", (done) => { + doBulkOperation() + .jobStatus({ job_id: jobId, bulk_version: "2.0" }) + .then((response) => { + expect(response.job).to.not.equal(undefined); + expect(response.job._id).to.equal(jobId); + done(); + }) + .catch(done); + }); + + it("Bulk Operation: should update items to a release", (done) => { + const items = { + release: releaseUID, + action: "publish", + locale: ["en-us"], + reference: true, + items: ["$all"], + }; + doBulkOperation() + .updateItems({ data: items, bulk_version: "2.0" }) + .then((response) => { + expect(response.notice).to.equal( + "Your update release items to latest version request is in progress." + ); + expect(response.job_id).to.not.equal(undefined); + done(); }) - .catch(done) - }) + .catch(done); + }); - it('should delete specific Releases with Uid ', done => { + it("should delete specific Releases with Uid ", (done) => { makeRelease(releaseUID) .delete() .then((data) => { - expect(data.notice).to.be.equal('Release deleted successfully.') - done() + expect(data.notice).to.be.equal("Release deleted successfully."); + done(); }) - .catch(done) - }) + .catch(done); + }); - it('should delete cloned Release with Uid', done => { + it("should delete specific Releases with Uid 2", (done) => { makeRelease(releaseUID2) .delete() .then((data) => { - expect(data.notice).to.be.equal('Release deleted successfully.') - done() + expect(data.notice).to.be.equal("Release deleted successfully."); + done(); + }) + .catch(done); + }); + + it("should delete cloned Release with Uid", (done) => { + makeRelease(releaseUID3) + .delete() + .then((data) => { + expect(data.notice).to.be.equal("Release deleted successfully."); + done(); + }) + .catch(done); + }); + + it("should create a Release v2", (done) => { + makeRelease() + .create(releaseCreate) + .then((release) => { + releaseUID4 = release.uid; + expect(release.name).to.be.equal(releaseCreate.release.name); + expect(release.description).to.be.equal( + releaseCreate.release.description + ); + expect(release.uid).to.be.not.equal(null); + done(); + }) + .catch(done); + }); + + it("should create release item fo v2", (done) => { + const item = { + version: entries[0]._version, + uid: entries[0].uid, + content_type_uid: multiPageCT.content_type.uid, + action: "publish", + locale: "en-us", + title: entries[0].title, + }; + makeRelease(releaseUID4) + .item() + .create({ item, release_version: "2.0" }) + .then((release) => { + expect(release.name).to.be.equal(releaseCreate.release.name); + expect(release.description).to.be.equal( + releaseCreate.release.description + ); + expect(release.uid).to.be.equal(releaseUID4); + done(); + }) + .catch(done); + }); + + it("should delete specific item for v2", (done) => { + makeRelease(releaseUID4) + .item() + .delete({ + item: { uid: entries[0].uid, locale: "en-us" }, + release_version: "2.0", + }) + .then((release) => { + expect(release.notice).to.be.equal('Item deleted from release successfully!'); + done(); + }) + .catch(done); + }); + + it("Bulk Operation: should add items to a release 2", (done) => { + const items = { + release: releaseUID4, + action: "publish", + locale: ["en-us"], + reference: true, + items: [ + { + version: entries[1]._version, + uid: entries[1].uid, + content_type_uid: multiPageCT.content_type.uid, + locale: "en-us", + title: entries[1].title, + }, + { + version: entries[2]._version, + uid: entries[2].uid, + content_type_uid: multiPageCT.content_type.uid, + locale: "en-us", + title: entries[2].title, + }, + ], + }; + doBulkOperation() + .addItems({ data: items, bulk_version: "2.0" }) + .then((response) => { + expect(response.notice).to.equal( + "Your add to release request is in progress." + ); + expect(response.job_id).to.not.equal(undefined); + done(); + }) + .catch(done); + }); + + it("should delete specific items for v2", (done) => { + makeRelease(releaseUID4) + .item() + .delete({ + items: [ + { uid: entries[1].uid, + locale: "en-us" + }, + { + uid: entries[2].uid, + locale: "en-us", + }, + ], + release_version: "2.0", + }) + .then((release) => { + expect(release.notice).to.be.equal('Items deleted from release successfully!'); + done(); + }) + .catch(done); + }); + + it("should delete specific Releases with Uid ", (done) => { + makeRelease(releaseUID4) + .delete() + .then((data) => { + expect(data.notice).to.be.equal("Release deleted successfully."); + done(); }) - .catch(done) - }) -}) + .catch(done); + }); +}); + +function makeRelease(uid = null) { + return client.stack({ api_key: process.env.API_KEY }).release(uid); +} -function makeRelease (uid = null) { - return client.stack({ api_key: process.env.API_KEY }).release(uid) +function doBulkOperation(uid = null) { + return client.stack({ api_key: process.env.API_KEY }).bulkOperation(); } diff --git a/test/sanity-check/mock/release.js b/test/sanity-check/mock/release.js index 9bb45e77..58ed92b8 100644 --- a/test/sanity-check/mock/release.js +++ b/test/sanity-check/mock/release.js @@ -7,4 +7,13 @@ const releaseCreate = { } } -export { releaseCreate } +const releaseCreate2 = { + release: { + name: 'Second release', + description: 'Adding release date 2020-21-07', + locked: false, + archived: false + } +} + +export { releaseCreate, releaseCreate2 } diff --git a/test/unit/bulkOperation-test.js b/test/unit/bulkOperation-test.js new file mode 100644 index 00000000..e0324146 --- /dev/null +++ b/test/unit/bulkOperation-test.js @@ -0,0 +1,225 @@ +import Axios from 'axios'; +import { expect } from 'chai'; +import MockAdapter from 'axios-mock-adapter'; +import { describe, it } from 'mocha'; +import { BulkOperation } from '../../lib/stack/bulkOperation'; +import { stackHeadersMock } from './mock/objects'; + +describe('Contentstack BulkOperation test', () => { + it('BulkOperation test without uid', done => { + const bulkOperation = makeBulkOperation(); + expect(bulkOperation.urlPath).to.be.equal('/bulk'); + expect(bulkOperation.stackHeaders).to.be.equal(undefined); + expect(bulkOperation.addItems).to.not.equal(undefined); + expect(bulkOperation.publish).to.not.equal(undefined); + expect(bulkOperation.unpublish).to.not.equal(undefined); + expect(bulkOperation.delete).to.not.equal(undefined); + done(); + }); + + it('BulkOperation test with stackHeaders', done => { + const bulkOperation = makeBulkOperation({ stackHeaders: { ...stackHeadersMock } }); + expect(bulkOperation.urlPath).to.be.equal('/bulk'); + expect(bulkOperation.stackHeaders).to.not.equal(undefined); + expect(bulkOperation.stackHeaders.api_key).to.be.equal(stackHeadersMock.api_key); + expect(bulkOperation.addItems).to.not.equal(undefined); + expect(bulkOperation.publish).to.not.equal(undefined); + expect(bulkOperation.unpublish).to.not.equal(undefined); + expect(bulkOperation.delete).to.not.equal(undefined); + done(); + }); + + it('should add items to a release', async () => { + const items = { + release: 'release_uid', + action: 'publish', + locale: ['en-us'], + reference: true, + items: [ + { + content_type_uid: 'ct_1', + uid: 'entry_uid', + version: 2, + locale: 'en-us', + title: 'validation test', + }, + ], + }; + + var mock = new MockAdapter(Axios); + mock.onPost('/bulk/release/items').reply(200, { + notice: 'Your add to release request is in progress.', + job_id: 'job_id', + }); + + const response = await makeBulkOperation().addItems({ data: items, bulk_version: '2.0' }); + expect(response.notice).to.equal('Your add to release request is in progress.'); + expect(response.job_id).to.not.equal(undefined); + }); + + it('should update items to a release', async () => { + const items = { + release: 'release_uid', + action: 'publish', + locale: ['en-us'], + reference: true, + items: [ + '$all' + ], + }; + + var mock = new MockAdapter(Axios); + mock.onPut('/bulk/release/update_items').reply(200, { + notice: 'Your update release items to latest version request is in progress.', + job_id: 'job_id', + }); + + const response = await makeBulkOperation().updateItems({ data: items, bulk_version: '2.0' }); + expect(response.notice).to.equal('Your update release items to latest version request is in progress.'); + expect(response.job_id).to.not.equal(undefined); + }); + + it('should publish items in bulk', async () => { + const publishDetails = { + entries: [ + { + uid: 'entry_uid', + content_type: 'content_type_uid', + version: 'version', + locale: 'entry_locale', + }, + ], + assets: [{ uid: 'uid' }], + locales: ['en'], + environments: ['env_uid'], + }; + + var mock = new MockAdapter(Axios); + mock.onPost('/bulk/publish').reply(200, { + notice: 'Your publish request is in progress.', + job_id: 'job_id', + }); + + const response = await makeBulkOperation().publish({ details: publishDetails }); + expect(response.notice).to.equal('Your publish request is in progress.'); + expect(response.job_id).to.not.equal(undefined); + }); + + it('should unpublish items in bulk', async () => { + const unpublishDetails = { + entries: [ + { + uid: 'entry_uid', + content_type: 'content_type_uid', + version: 'version', + locale: 'entry_locale', + }, + ], + assets: [{ uid: 'uid' }], + locales: ['en'], + environments: ['env_uid'], + }; + + var mock = new MockAdapter(Axios); + mock.onPost('/bulk/unpublish').reply(200, { + notice: 'Your unpublish request is in progress.', + job_id: 'job_id', + }); + + const response = await makeBulkOperation().unpublish({ details: unpublishDetails }); + expect(response.notice).to.equal('Your unpublish request is in progress.'); + expect(response.job_id).to.not.equal(undefined); + }); + + it('should delete items in bulk', async () => { + const deleteDetails = { + entries: [ + { + uid: 'entry_uid', + content_type: 'content_type_uid', + locale: 'entry_locale', + }, + ], + assets: [{ uid: 'uid' }], + }; + + var mock = new MockAdapter(Axios); + mock.onPost('/bulk/delete').reply(200, { + notice: 'Your delete request is in progress.', + job_id: 'job_id', + }); + + const response = await makeBulkOperation().delete({ details: deleteDetails }); + expect(response.notice).to.equal('Your delete request is in progress.'); + expect(response.job_id).to.not.equal(undefined); + }); + + it('should update items in bulk', async () => { + const updateBody = { + entries: [ + { + content_type: 'content_type_uid1', + uid: 'entry_uid', + locale: 'en-us', + }, + { + content_type: 'content_type_uid2', + uid: 'entry_uid', + locale: 'en-us', + }, + ], + workflow: { + workflow_stage: { + comment: 'Workflow-related Comments', + due_date: 'Thu Dec 01 2018', + notify: false, + uid: 'workflow_stage_uid', + assigned_to: [ + { + uid: 'user_uid', + name: 'user_name', + email: 'user_email_id', + }, + ], + assigned_by_roles: [ + { + uid: 'role_uid', + name: 'role_name', + }, + ], + }, + }, + }; + + var mock = new MockAdapter(Axios); + mock.onPost('/bulk/workflow').reply(200, { + notice: 'Your update request is in progress.', + job_id: 'job_id', + }); + + const response = await makeBulkOperation().update(updateBody); + expect(response.notice).to.equal('Your update request is in progress.'); + expect(response.job_id).to.not.equal(undefined); + }); + + it('should fetch job status', async () => { + const jobId = 'job_id'; + const jobStatusDetails = { + job_id: jobId, + }; + + var mock = new MockAdapter(Axios); + mock.onGet(`/bulk/jobs/${jobId}`).reply(200, { + notice: 'Your job status request is successful.', + status: 'completed', + }); + + const response = await makeBulkOperation().jobStatus(jobStatusDetails); + expect(response.notice).to.equal('Your job status request is successful.'); + expect(response.status).to.equal('completed'); + }); +}); + +function makeBulkOperation(data) { + return new BulkOperation(Axios, data); +} \ No newline at end of file diff --git a/test/unit/index.js b/test/unit/index.js index cde49f51..a49ffca1 100644 --- a/test/unit/index.js +++ b/test/unit/index.js @@ -14,6 +14,7 @@ require('./extension-test') require('./branch-test') require('./branchAlias-test') require('./release-test') +require('./bulkOperation-test') require('./asset-test') require('./webhook-test') require('./workflow-test') diff --git a/test/unit/release-test.js b/test/unit/release-test.js index 4cc3d6b8..f20ad79a 100644 --- a/test/unit/release-test.js +++ b/test/unit/release-test.js @@ -221,6 +221,95 @@ describe('Contentstack Release test', () => { }) .catch(done) }) + + it('Release move test', done => { + var mock = new MockAdapter(Axios) + mock.onPut('/releases/UID/items/move').reply(200, { + ...noticeMock + }) + makeRelease({ + release: { + ...systemUidMock + }, + stackHeaders: stackHeadersMock + }) + .item() + .move({ data: { release_uid: 'UID2', items: ['$all'] }, release_version: '2.0' }) + .then((response) => { + expect(response.notice).to.be.equal(noticeMock.notice) + done() + }) + .catch(done) + }) + + it('Release delete item test', done => { + var mock = new MockAdapter(Axios) + mock.onDelete('/releases/UID/item').reply(200, + { ...noticeMock } + ) + makeRelease({ + release: { + ...systemUidMock + }, + stackHeaders: stackHeadersMock + }) + .item() + .delete({ item: { uid: 'UID2', locale: 'en-us' }, release_version: '2.0' }) + .then((response) => { + expect(response.notice).to.be.equal(noticeMock.notice) + done() + }) + .catch(done) + }) + + it("should delete specific item for v2", (done) => { + var mock = new MockAdapter(Axios) + mock.onDelete('/releases/UID/item').reply(200, { + notice: 'Notice' + }) + makeRelease({ + release: { + ...systemUidMock + }, + stackHeaders: stackHeadersMock + }) + .item() + .delete({ + item: { uid: 'uid', locale: "en-us" }, + release_version: "2.0", + }) + .then((response) => { + expect(response.notice).to.be.equal('Notice'); + done(); + }) + .catch(done); + }); + + it("should delete specific items for v2", (done) => { + var mock = new MockAdapter(Axios) + mock.onDelete('/releases/UID/items').reply(200, { + notice: 'Notice' + }) + makeRelease({ + release: { + ...systemUidMock + }, + stackHeaders: stackHeadersMock + }) + .item() + .delete({ + items: [ + { uid: 'uid1', locale: "en-us" }, + { uid: 'uid2', locale: "en-us" }, + ], + release_version: "2.0", + }) + .then((response) => { + expect(response.notice).to.be.equal('Notice'); + done(); + }) + .catch(done); + }); }) function makeRelease (data) { diff --git a/types/stack/bulkOperation/index.d.ts b/types/stack/bulkOperation/index.d.ts index 867345da..4a997e15 100644 --- a/types/stack/bulkOperation/index.d.ts +++ b/types/stack/bulkOperation/index.d.ts @@ -6,14 +6,17 @@ export interface BulkOperation extends SystemFields { publish(config: BulkOperationConfig): Promise unpublish(config: BulkOperationConfig): Promise delete(config: BulkDeleteConfig): Promise + addItems(config: AddItemsConfig): Promise + updateItems(config: AddItemsConfig): Promise + jobStatus(config: BulkJobStatus): Promise } - export interface BulkOperationConfig { details: PublishItems skip_workflow_stage?: boolean approvals?: boolean is_nested?: boolean api_version?: string + bulk_version?: string } export interface PublishItems extends PublishDetails { @@ -44,4 +47,14 @@ export interface BulkDeleteAsset { export interface BranchData extends AnyProperty { name: string source: string +} + +export interface BulkAddItemsConfig { + data: AnyProperty; + bulk_version?: string; +} + +export interface BulkJobStatus { + job_id: AnyProperty; + bulk_version?: string; } \ No newline at end of file diff --git a/types/stack/release/index.d.ts b/types/stack/release/index.d.ts index 0982c189..516340b2 100644 --- a/types/stack/release/index.d.ts +++ b/types/stack/release/index.d.ts @@ -30,8 +30,10 @@ export interface ReleaseDeploy extends AnyProperty { // Represents a Release item with various operations export interface ReleaseItem extends SystemFields, Creatable }> { - delete(param?: { items: Array }): Promise; // Changed return type to Promise + delete(param?: { item?: ReleaseItemData; items?: Array; release_version?: string }): Promise; // Changed return type to Promise findAll(param?: AnyProperty): Promise>; + move(param: { param: MoveReleaseItems, release_version?: string }): Promise; + create(param: { item?: ReleaseItemData; items?: Array; release_version?: string }): Promise; } // Data structure for Release item properties @@ -42,3 +44,14 @@ export interface ReleaseItemData extends AnyProperty { content_type_uid: string; action: 'publish' | 'unpublish'; } + +export interface MoveReleaseItems extends AnyProperty { + release_uid: string; + items: Array; +} + +export interface MoveItemData extends AnyProperty { + uid: string; + locale: string; + variant_id?: string; +}