3 | <%=url%> 4 |
5 |6 | <%=error%> 7 |8 | 9 | -------------------------------------------------------------------------------- /samples/photo_album/views/errors/500.ejs: -------------------------------------------------------------------------------- 1 | <% layout('../layouts/default') %> 2 |
3 | <%=error.message%> 4 |
5 |6 | <%=error.stack%> 7 |8 | 9 | 10 | -------------------------------------------------------------------------------- /samples/photo_album/views/errors/dotenv.ejs: -------------------------------------------------------------------------------- 1 | <% layout('../layouts/default') %> 2 |
3 | Missing .env file 4 |
5 |6 | You will need a Cloudinary account to run this demo project. 7 |
-
8 |
- 9 | If you don't have an account, sign up for free 10 | here. 11 | 12 |
- 13 | customized dotenv.example configuration file 14 | 15 |
- 16 | Rename dotenv.example to .env 17 | 18 |
- 19 | Restart your Node server process. 20 | 21 |
17 |
18 | 
19 |
20 |
19 |
21 | <%-body%>
22 |
23 |
24 |
25 |
--------------------------------------------------------------------------------
/samples/photo_album/views/photos/add.ejs:
--------------------------------------------------------------------------------
1 | <% layout('../layouts/default') %>
2 |
3 |
4 |
5 |
29 |
30 | Back to list
31 |
32 |
--------------------------------------------------------------------------------
/samples/photo_album/views/photos/add_direct.ejs:
--------------------------------------------------------------------------------
1 | <% layout('../layouts/default') %>
2 | New Photo
6 |Image file is uploaded through the server
7 |
3 |
40 |
41 | Back to list
42 |
43 |
44 |
45 |
46 |
47 | <%- cloudinary.cloudinary_js_config()%>
48 |
49 |
120 |
--------------------------------------------------------------------------------
/samples/photo_album/views/photos/add_direct_unsigned.ejs:
--------------------------------------------------------------------------------
1 | <% layout('../layouts/default') %>
2 | New Photo
4 |Direct upload from the browser
5 |You can also drag and drop an image file into the dashed area.
6 | 39 |
3 |
41 |
42 | Back to list
43 |
44 |
45 |
46 |
47 |
48 | <%- cloudinary.cloudinary_js_config()%>
49 |
50 |
120 |
--------------------------------------------------------------------------------
/samples/photo_album/views/photos/create_direct.ejs:
--------------------------------------------------------------------------------
1 | <% layout('../layouts/default') %>
2 | New Photo
4 |Direct upload from the browser Unsigned upload using a preset
5 |You can also drag and drop an image file into the dashed area.
6 | 40 |Your photo was uploaded sucessfully!
3 | 4 |
5 |
10 |
11 | Back to list
12 |
13 | <% if (upload){ %>
14 | <%= photo.title %>
6 | 7 | <%-cloudinary.image(photo.image.public_id, {width: 150, height: 150, quality: 80,crop:'fill',format:'jpg',class:'thumbnail inline'})%> 8 | 9 |
15 |
17 | <% for (let attr in upload){%>
18 |
21 |
22 | <% } %>
23 |
24 |
--------------------------------------------------------------------------------
/samples/photo_album/views/photos/create_through_server.ejs:
--------------------------------------------------------------------------------
1 | <% layout('../layouts/default') %>
2 | Upload metadata:
16 || <%= attr %> | <%= JSON.stringify(upload[attr])%> |
Your photo was uploaded sucessfully!
3 | 4 |
5 |
10 |
11 | Back to list
12 |
13 | <% if (upload){ %>
14 | <%= photo.title %>
6 | 7 | <%-cloudinary.image(photo.image.public_id, {width: 150, height: 150, quality: 80,crop:'fill',format:'jpg',class:'thumbnail inline'})%> 8 | 9 |
15 |
17 | <% for (let attr in upload){%>
18 |
21 |
22 | <% } %>
23 |
24 |
--------------------------------------------------------------------------------
/samples/photo_album/views/photos/index.ejs:
--------------------------------------------------------------------------------
1 | <% layout('../layouts/default') %>
2 |
3 |
4 | Upload metadata:
16 || <%= attr %> | <%= JSON.stringify(upload[attr])%> |
5 |
7 | <%-cloudinary.image('officialchucknorrispage',{type:'facebook',format:'png',transformation:[{height:95,width:95,crop:'thumb',gravity:'face',effect:'sepia',radius:20},{angle:10}]})%>
8 |
9 |
10 | Welcome!
11 | 12 |
13 | This is the main demo page of the PhotoAlbum sample Express application of Cloudinary.
14 | Here you can see all images you have uploaded to this application and find some information on how
15 | to implement your own Express application storing, manipulating and serving your photos using Cloudinary!
16 |
19 | All of the images you see here are transformed and served by Cloudinary. 20 | For instance, the logo and the poster frame. 21 | These two pictures weren't even have to be uploaded to Cloudinary, they are retrieved by the service, transformed, cached and distributed through a CDN. 22 |
23 | 24 |Your Photos
25 | 26 | 31 | 32 |
33 | <% if ( photos.length==0 ) { %>
34 |
90 |
91 |
--------------------------------------------------------------------------------
/samples/readme.md:
--------------------------------------------------------------------------------
1 | # Cloudinary Node Sample Projects #
2 |
3 | ## Basic sample
4 |
5 | The basic sample uploads local and remote image to Cloudinary and generates URLs for applying various image transformations on the uploaded files.
6 |
7 | ### Setting up
8 |
9 | 1. Before running the sample, copy the Environment variable configuration parameters from Cloudinary's [Management Console](https://cloudinary.com/console) of your account into `.env` file of the project or export it (i.e. export CLOUDINARY_URL=xxx).
10 | 1. Run `npm install` in project directory to bring all the required modules.
11 | 1. Run the sample using `npm run start`.
12 |
13 | ## Photo Album sample
14 |
15 | Simple application for uploading images and displaying them in a list.
16 | This sample uses [jugglingdb orm](https://github.com/1602/jugglingdb).
17 | See [schema.js](photo_album/config/schema.js) for adapter configuration.
18 |
19 | ### Setting up
20 | 1. Before running the sample, copy the Environment variable configuration parameters from Cloudinary's [Management Console](https://cloudinary.com/console) of your account into `.env` file of the project or export it (i.e. export CLOUDINARY_URL=xxx).
21 | 1. In the project directory, run `npm install` to install all the required dependencies.
22 | 1. Run `npm start` to start the server , and if you want to run a
23 | development mode server (which reloads automatically) run `npm run dev`.
24 | 1. Open the sample page in a browser: http://localhost:9000
25 |
26 |
27 | ## Additional resources ##
28 |
29 | * [Node integration documentation](http://cloudinary.com/documentation/node_integration)
30 | * [Image transformations documentation](http://cloudinary.com/documentation/node_image_manipulation)
31 | * [Node Image Upload](http://cloudinary.com/documentation/node_image_upload)
32 |
--------------------------------------------------------------------------------
/test/.eslintrc.json:
--------------------------------------------------------------------------------
1 | {
2 | "env": {
3 | "mocha": true,
4 | "browser": true
5 | }
6 | }
7 |
--------------------------------------------------------------------------------
/test/.resources/CloudBookStudy-HD.mp4:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/cloudinary/cloudinary_npm/c7f784df4c5e7c0a0245db172e39ac65594177ff/test/.resources/CloudBookStudy-HD.mp4
--------------------------------------------------------------------------------
/test/.resources/TheCompleteWorksOfShakespeare.mobi:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/cloudinary/cloudinary_npm/c7f784df4c5e7c0a0245db172e39ac65594177ff/test/.resources/TheCompleteWorksOfShakespeare.mobi
--------------------------------------------------------------------------------
/test/.resources/big-image.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/cloudinary/cloudinary_npm/c7f784df4c5e7c0a0245db172e39ac65594177ff/test/.resources/big-image.jpg
--------------------------------------------------------------------------------
/test/.resources/docx.docx:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/cloudinary/cloudinary_npm/c7f784df4c5e7c0a0245db172e39ac65594177ff/test/.resources/docx.docx
--------------------------------------------------------------------------------
/test/.resources/empty.gif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/cloudinary/cloudinary_npm/c7f784df4c5e7c0a0245db172e39ac65594177ff/test/.resources/empty.gif
--------------------------------------------------------------------------------
/test/.resources/favicon.ico:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/cloudinary/cloudinary_npm/c7f784df4c5e7c0a0245db172e39ac65594177ff/test/.resources/favicon.ico
--------------------------------------------------------------------------------
/test/.resources/logo.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/cloudinary/cloudinary_npm/c7f784df4c5e7c0a0245db172e39ac65594177ff/test/.resources/logo.png
--------------------------------------------------------------------------------
/test/.resources/sample.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/cloudinary/cloudinary_npm/c7f784df4c5e7c0a0245db172e39ac65594177ff/test/.resources/sample.jpg
--------------------------------------------------------------------------------
/test/integration/api/admin/config_spec.js:
--------------------------------------------------------------------------------
1 | const sinon = require('sinon');
2 |
3 | const cloudinary = require('../../../../lib/cloudinary');
4 | const api_http = require("https");
5 | const ClientRequest = require('_http_client').ClientRequest;
6 |
7 | describe('Admin API - Config', () => {
8 | const mocked = {};
9 |
10 | beforeEach(function () {
11 | mocked.xhr = sinon.useFakeXMLHttpRequest();
12 | mocked.write = sinon.spy(ClientRequest.prototype, 'write');
13 | mocked.request = sinon.spy(api_http, 'request');
14 | });
15 |
16 | afterEach(function () {
17 | mocked.request.restore();
18 | mocked.write.restore();
19 | mocked.xhr.restore();
20 | });
21 |
22 | describe('config', () => {
23 | it('should send a request to config endpoint', () => {
24 | cloudinary.v2.api.config();
25 |
26 | sinon.assert.calledWith(mocked.request, sinon.match({
27 | pathname: sinon.match('config'),
28 | method: sinon.match('GET'),
29 | query: sinon.match('')
30 | }));
31 | });
32 |
33 | it('should send a request to config endpoint with optional parameters', () => {
34 | cloudinary.v2.api.config({ settings: true });
35 |
36 | sinon.assert.calledWith(mocked.request, sinon.match({
37 | pathname: sinon.match('config'),
38 | method: sinon.match('GET'),
39 | query: sinon.match('settings=true')
40 | }));
41 | });
42 | });
43 | });
44 |
--------------------------------------------------------------------------------
/test/integration/api/admin/folders_api_spec.js:
--------------------------------------------------------------------------------
1 | const assert = require('assert');
2 | const sinon = require('sinon');
3 |
4 | const cloudinary = require('../../../../lib/cloudinary');
5 | const createTestConfig = require('../../../testUtils/createTestConfig');
6 | const helper = require('../../../spechelper');
7 | const api_http = require("https");
8 | const ClientRequest = require('_http_client').ClientRequest;
9 |
10 | describe('Admin API - Folders', () => {
11 | const mocked = {};
12 |
13 | beforeEach(function () {
14 | mocked.xhr = sinon.useFakeXMLHttpRequest();
15 | mocked.write = sinon.spy(ClientRequest.prototype, 'write');
16 | mocked.request = sinon.spy(api_http, 'request');
17 | });
18 |
19 | afterEach(function () {
20 | mocked.request.restore();
21 | mocked.write.restore();
22 | mocked.xhr.restore();
23 | });
24 |
25 | describe('rename_folder', () => {
26 | it('should send a request to update folder endpoint with correct parameters', () => {
27 | cloudinary.v2.api.rename_folder('old/path', 'new/path');
28 |
29 | sinon.assert.calledWith(mocked.request, sinon.match({
30 | pathname: sinon.match('old%2Fpath'),
31 | method: sinon.match('PUT')
32 | }));
33 | sinon.assert.calledWith(mocked.write, sinon.match(helper.apiJsonParamMatcher('to_folder', 'new/path')));
34 | });
35 | });
36 | });
37 |
--------------------------------------------------------------------------------
/test/integration/api/analysis/analyze_spec.js:
--------------------------------------------------------------------------------
1 | const assert = require('assert');
2 | const sinon = require('sinon');
3 | const ClientRequest = require('_http_client').ClientRequest;
4 | const api_http = require('https');
5 |
6 | const cloudinary = require('../../../../cloudinary');
7 | const helper = require('../../../spechelper');
8 |
9 | describe('Analyze API', () => {
10 | describe('uri analysis', () => {
11 | const mocked = {};
12 | const config = {};
13 |
14 | beforeEach(function () {
15 | mocked.xhr = sinon.useFakeXMLHttpRequest();
16 | mocked.write = sinon.spy(ClientRequest.prototype, 'write');
17 | mocked.request = sinon.spy(api_http, 'request');
18 |
19 | config.cloud_name = cloudinary.config().cloud_name;
20 | });
21 |
22 | afterEach(function () {
23 | mocked.request.restore();
24 | mocked.write.restore();
25 | mocked.xhr.restore();
26 | });
27 |
28 | it('should call analyze endpoint with non-custom analysis_type', () => {
29 | cloudinary.analysis.analyze_uri('https://example.com', 'captioning');
30 |
31 | sinon.assert.calledWith(mocked.request, sinon.match({
32 | pathname: sinon.match(new RegExp(`/v2/${config.cloud_name}/analysis/analyze/uri`)),
33 | method: sinon.match('POST')
34 | }));
35 | sinon.assert.calledWith(mocked.write, sinon.match(helper.apiJsonParamMatcher('uri', 'https://example.com')));
36 | sinon.assert.calledWith(mocked.write, sinon.match(helper.apiJsonParamMatcher('analysis_type', 'captioning')));
37 | });
38 |
39 | it('should call analyze endpoint with custom analysis_type', () => {
40 | cloudinary.analysis.analyze_uri('https://example.com', 'custom', {
41 | model_name: 'my_model',
42 | model_version: 1
43 | });
44 |
45 | sinon.assert.calledWith(mocked.request, sinon.match({
46 | pathname: sinon.match(new RegExp(`/v2/${config.cloud_name}/analysis/analyze/uri`)),
47 | method: sinon.match('POST')
48 | }));
49 | sinon.assert.calledWith(mocked.write, sinon.match(helper.apiJsonParamMatcher('uri', 'https://example.com')));
50 | sinon.assert.calledWith(mocked.write, sinon.match(helper.apiJsonParamMatcher('analysis_type', 'custom')));
51 | sinon.assert.calledWith(mocked.write, sinon.match(helper.apiJsonParamMatcher('parameters', {
52 | custom: {
53 | model_name: 'my_model',
54 | model_version: 1
55 | }
56 | })));
57 | });
58 |
59 | it('should not allow calling analyze endpoint with incorrect custom analysis parameters', () => {
60 | assert.throws(() => {
61 | cloudinary.analysis.analyze_uri('https://example.com', 'custom');
62 | }, {
63 | message: 'Setting analysis_type to "custom" requires additional params: "model_name" and "model_version"'
64 | });
65 | });
66 | });
67 | });
68 |
--------------------------------------------------------------------------------
/test/integration/api/authorization/oAuth_authorization_spec.js:
--------------------------------------------------------------------------------
1 | const sinon = require('sinon');
2 | const cloudinary = require("../../../../cloudinary");
3 | const helper = require("../../../spechelper");
4 | const describe = require('../../../testUtils/suite');
5 | const testConstants = require('../../../testUtils/testConstants');
6 | const { PUBLIC_IDS } = testConstants;
7 | const { PUBLIC_ID } = PUBLIC_IDS;
8 |
9 | describe("oauth_token", function(){
10 | it("should send the oauth_token option to the server (admin_api)", function() {
11 | return helper.provideMockObjects((mockXHR, writeSpy, requestSpy) => {
12 | cloudinary.v2.api.resource(PUBLIC_ID, { oauth_token: 'MTQ0NjJkZmQ5OTM2NDE1ZTZjNGZmZjI4' });
13 | return sinon.assert.calledWith(requestSpy,
14 | sinon.match.has("headers",
15 | sinon.match.has("Authorization", "Bearer MTQ0NjJkZmQ5OTM2NDE1ZTZjNGZmZjI4")
16 | ));
17 | });
18 | });
19 |
20 | it("should send the oauth_token config to the server (admin_api)", function() {
21 | return helper.provideMockObjects((mockXHR, writeSpy, requestSpy) => {
22 | cloudinary.config({
23 | api_key: undefined,
24 | api_secret: undefined,
25 | oauth_token: 'MTQ0NjJkZmQ5OTM2NDE1ZTZjNGZmZjI4'
26 | });
27 | cloudinary.v2.api.resource(PUBLIC_ID);
28 | return sinon.assert.calledWith(requestSpy,
29 | sinon.match.has("headers",
30 | sinon.match.has("Authorization", "Bearer MTQ0NjJkZmQ5OTM2NDE1ZTZjNGZmZjI4")
31 | ));
32 | });
33 | });
34 |
35 | it("should not fail when only providing api_key and secret (admin_api)", function() {
36 | cloudinary.config({
37 | api_key: "1234",
38 | api_secret: "1234",
39 | oauth_token: undefined
40 | });
41 | return helper.provideMockObjects((mockXHR, writeSpy, requestSpy) => {
42 | cloudinary.v2.api.resource(PUBLIC_ID);
43 | return sinon.assert.calledWith(requestSpy, sinon.match({ auth: "1234:1234" }));
44 | });
45 | });
46 |
47 | it("should fail when missing all credentials (admin_api)", function() {
48 | cloudinary.config({
49 | api_key: undefined,
50 | api_secret: undefined,
51 | oauth_token: undefined
52 | });
53 | expect(() => {
54 | cloudinary.v2.api.resource(PUBLIC_ID)
55 | }).to.throwError(/Must supply api_key/);
56 | });
57 |
58 | it("oauth_token as option should take priority with secret and key (admin_api)", function() {
59 | cloudinary.config({
60 | api_key: '1234',
61 | api_secret: '1234'
62 | });
63 | return cloudinary.v2.api.resource(PUBLIC_ID, {oauth_token: 'MTQ0NjJkZmQ5OTM2NDE1ZTZjNGZmZjI4'})
64 | .then(
65 | () => expect().fail()
66 | ).catch(({ error }) => expect(error.message).to.contain("Invalid token"));
67 | });
68 |
69 | it("should send the oauth_token option to the server (upload_api)", function() {
70 | return helper.provideMockObjects((mockXHR, writeSpy, requestSpy) => {
71 | cloudinary.v2.uploader.upload(PUBLIC_ID, { oauth_token: 'MTQ0NjJkZmQ5OTM2NDE1ZTZjNGZmZjI4' });
72 | return sinon.assert.calledWith(requestSpy,
73 | sinon.match.has("headers",
74 | sinon.match.has("Authorization", "Bearer MTQ0NjJkZmQ5OTM2NDE1ZTZjNGZmZjI4")
75 | ));
76 | });
77 | });
78 |
79 | it("should send the oauth_token config to the server (upload_api)", function() {
80 | return helper.provideMockObjects((mockXHR, writeSpy, requestSpy) => {
81 | cloudinary.config({
82 | api_key: undefined,
83 | api_secret: undefined,
84 | oauth_token: 'MTQ0NjJkZmQ5OTM2NDE1ZTZjNGZmZjI4'
85 | });
86 | cloudinary.v2.uploader.upload(PUBLIC_ID);
87 | return sinon.assert.calledWith(requestSpy,
88 | sinon.match.has("headers",
89 | sinon.match.has("Authorization", "Bearer MTQ0NjJkZmQ5OTM2NDE1ZTZjNGZmZjI4")
90 | ));
91 | });
92 | });
93 |
94 | it("should not fail when only providing api_key and secret (upload_api)", function() {
95 | cloudinary.config({
96 | api_key: "1234",
97 | api_secret: "1234",
98 | oauth_token: undefined
99 | });
100 | return helper.provideMockObjects((mockXHR, writeSpy, requestSpy) => {
101 | cloudinary.v2.uploader.upload(PUBLIC_ID)
102 | return sinon.assert.calledWith(requestSpy, sinon.match({ auth: null }));
103 | });
104 | });
105 |
106 | it("should fail when missing all credentials (upload_api)", function() {
107 | cloudinary.config({
108 | api_key: undefined,
109 | api_secret: undefined,
110 | oauth_token: undefined
111 | });
112 | expect(() => {
113 | cloudinary.v2.uploader.upload(PUBLIC_ID)
114 | }).to.throwError(/Must supply api_key/);
115 | });
116 |
117 | it("should not need credentials for unsigned upload", function() {
118 | cloudinary.config({
119 | api_key: undefined,
120 | api_secret: undefined,
121 | oauth_token: undefined
122 | });
123 | return helper.provideMockObjects((mockXHR, writeSpy, requestSpy) => {
124 | cloudinary.v2.uploader.unsigned_upload(PUBLIC_ID, 'preset')
125 | return sinon.assert.calledWith(requestSpy, sinon.match({ auth: null }));
126 | });
127 | });
128 | });
129 |
--------------------------------------------------------------------------------
/test/integration/api/search/search_folders_spec.js:
--------------------------------------------------------------------------------
1 | const cloudinary = require('../../../../cloudinary');
2 | const {TIMEOUT} = require('../../../testUtils/testConstants');
3 | const describe = require('../../../testUtils/suite');
4 | const wait = require('../../../testUtils/helpers/wait');
5 |
6 | const folderNames = ['testFolder1', 'testFolder2'];
7 |
8 | describe('search_folders_api', function () {
9 | describe('unit', function () {
10 | it('should create empty json', function () {
11 | const query = cloudinary.v2.search_folders.instance().to_query();
12 | expect(query).to.eql({});
13 | });
14 |
15 | it('should always return same object in fluent interface', function () {
16 | const instance = cloudinary.v2.search_folders.instance();
17 | const searchOptions = [
18 | 'expression',
19 | 'sort_by',
20 | 'max_results',
21 | 'next_cursor',
22 | 'aggregate',
23 | 'with_field'
24 | ];
25 | searchOptions.forEach(method => expect(instance).to.eql(instance[method]('emptyarg')));
26 | });
27 |
28 | it('should correctly transform whole query into search payload', function () {
29 | const query = cloudinary.v2.search_folders
30 | .expression('expression-key:expression-value')
31 | .sort_by('sort_by_field', 'asc')
32 | .max_results(1)
33 | .next_cursor('next_cursor')
34 | .aggregate('aggregate1').aggregate('aggregate2')
35 | .with_field('field1').with_field('field2')
36 | .to_query();
37 |
38 | expect(query).to.eql({
39 | expression: 'expression-key:expression-value',
40 | sort_by: [{sort_by_field: 'asc'}],
41 | max_results: 1,
42 | next_cursor: 'next_cursor',
43 | aggregate: ['aggregate1', 'aggregate2'],
44 | with_field: ['field1', 'field2']
45 | })
46 | });
47 | });
48 |
49 | describe('integration', function () {
50 | this.timeout(TIMEOUT.LONG);
51 |
52 | before(function () {
53 | return Promise.all(folderNames.map(folderName => {
54 | return cloudinary.v2.api.create_folder(folderName);
55 | })).then(wait(2));
56 | });
57 |
58 | after(function () {
59 | return Promise.all(folderNames.map(folderName => {
60 | return cloudinary.v2.api.delete_folder(folderName);
61 | }));
62 | });
63 |
64 | it('should return a search response with folders', function () {
65 | return cloudinary.v2.search_folders.expression('name=testFolder*')
66 | .execute()
67 | .then(function (results) {
68 | expect(results).to.have.key('folders');
69 | });
70 | });
71 | });
72 | });
73 |
--------------------------------------------------------------------------------
/test/integration/api/search/visual_search_spec.js:
--------------------------------------------------------------------------------
1 | const helper = require('../../../spechelper');
2 | const cloudinary = require('../../../../cloudinary');
3 | const {
4 | strictEqual,
5 | deepStrictEqual
6 | } = require('assert');
7 | const {TEST_CLOUD_NAME} = require('../../../testUtils/testConstants');
8 |
9 | describe('Visual search', () => {
10 | it('should pass the image_url parameter to the api call', () => {
11 | return helper.provideMockObjects((mockXHR, writeSpy, requestSpy) => {
12 | cloudinary.v2.api.visual_search({image_url: 'test-image-url'});
13 |
14 | const [calledWithUrl] = requestSpy.firstCall.args;
15 | strictEqual(calledWithUrl.method, 'GET');
16 | strictEqual(calledWithUrl.path, `/v1_1/${TEST_CLOUD_NAME}/resources/visual_search?image_url=test-image-url`);
17 | });
18 | });
19 |
20 | it('should pass the image_url parameter to the api call', () => {
21 | return helper.provideMockObjects((mockXHR, writeSpy, requestSpy) => {
22 | cloudinary.v2.api.visual_search({image_asset_id: 'image-asset-id'});
23 |
24 | const [calledWithUrl] = requestSpy.firstCall.args;
25 | strictEqual(calledWithUrl.method, 'GET');
26 | strictEqual(calledWithUrl.path, `/v1_1/${TEST_CLOUD_NAME}/resources/visual_search?image_asset_id=image-asset-id`);
27 | });
28 | });
29 |
30 | it('should pass the image_url parameter to the api call', () => {
31 | return helper.provideMockObjects((mockXHR, writeSpy, requestSpy) => {
32 | cloudinary.v2.api.visual_search({text: 'visual-search-input'});
33 |
34 | const [calledWithUrl] = requestSpy.firstCall.args;
35 | strictEqual(calledWithUrl.method, 'GET');
36 | strictEqual(calledWithUrl.path, `/v1_1/${TEST_CLOUD_NAME}/resources/visual_search?text=visual-search-input`);
37 | });
38 | });
39 | });
40 |
--------------------------------------------------------------------------------
/test/integration/api/uploader/auto_chaptering_spec.js:
--------------------------------------------------------------------------------
1 | const assert = require('assert');
2 | const sinon = require('sinon');
3 |
4 | const cloudinary = require('../../../../lib/cloudinary');
5 | const createTestConfig = require('../../../testUtils/createTestConfig');
6 | const helper = require('../../../spechelper');
7 | const ClientRequest = require('_http_client').ClientRequest;
8 |
9 | describe('Uploader', () => {
10 | let spy;
11 | let xhr;
12 |
13 | before(() => {
14 | xhr = sinon.useFakeXMLHttpRequest();
15 | spy = sinon.spy(ClientRequest.prototype, 'write');
16 | });
17 |
18 | after(() => {
19 | spy.restore();
20 | xhr.restore();
21 | });
22 |
23 | describe('upload', () => {
24 | it('should send a request with auto_chaptering set to true if requested', () => {
25 | cloudinary.v2.uploader.upload('irrelevant', { auto_chaptering: true });
26 | sinon.assert.calledWith(spy, sinon.match(helper.uploadParamMatcher('auto_chaptering', '1')));
27 | });
28 | });
29 |
30 | describe('explicit', () => {
31 | it('should send a request with auto_chaptering set to true if requested', () => {
32 | cloudinary.v2.uploader.explicit('irrelevant', { auto_chaptering: true });
33 | sinon.assert.calledWith(spy, sinon.match(helper.uploadParamMatcher('auto_chaptering', '1')));
34 | });
35 | });
36 | });
37 |
--------------------------------------------------------------------------------
/test/integration/api/uploader/auto_transcription_spec.js:
--------------------------------------------------------------------------------
1 | const sinon = require('sinon');
2 | const cloudinary = require('../../../../lib/cloudinary');
3 | const helper = require('../../../spechelper');
4 | const ClientRequest = require('_http_client').ClientRequest;
5 |
6 | describe('Uploader', () => {
7 | let spy;
8 | let xhr;
9 |
10 | before(() => {
11 | xhr = sinon.useFakeXMLHttpRequest();
12 | spy = sinon.spy(ClientRequest.prototype, 'write');
13 | });
14 |
15 | after(() => {
16 | spy.restore();
17 | xhr.restore();
18 | });
19 |
20 | describe('upload', () => {
21 | it('should send a request with auto_transcription set to true if requested', () => {
22 | cloudinary.v2.uploader.upload('irrelevant', { auto_transcription: true });
23 | sinon.assert.calledWith(spy, sinon.match(helper.uploadParamMatcher('auto_transcription', '1')));
24 | });
25 |
26 | it('should send a request with auto_transcription config if requested', () => {
27 | cloudinary.v2.uploader.upload('irrelevant', { auto_transcription: { translate: ['pl'] } });
28 | sinon.assert.calledWith(spy, sinon.match(helper.uploadParamMatcher('auto_transcription', '{"translate":["pl"]}')));
29 | });
30 | });
31 |
32 | describe('explicit', () => {
33 | it('should send a request with auto_transcription set to true if requested', () => {
34 | cloudinary.v2.uploader.explicit('irrelevant', { auto_transcription: true });
35 | sinon.assert.calledWith(spy, sinon.match(helper.uploadParamMatcher('auto_transcription', '1')));
36 | });
37 |
38 | it('should send a request with auto_transcription config if requested', () => {
39 | cloudinary.v2.uploader.explicit('irrelevant', { auto_transcription: { translate: ['pl'] } });
40 | sinon.assert.calledWith(spy, sinon.match(helper.uploadParamMatcher('auto_transcription', '{"translate":["pl"]}')));
41 | });
42 | });
43 | });
44 |
--------------------------------------------------------------------------------
/test/integration/api/uploader/custom_region_spec.js:
--------------------------------------------------------------------------------
1 | const assert = require('assert');
2 | const sinon = require('sinon');
3 |
4 | const cloudinary = require('../../../../lib/cloudinary');
5 | const createTestConfig = require('../../../testUtils/createTestConfig');
6 | const helper = require('../../../spechelper');
7 | const ClientRequest = require('_http_client').ClientRequest;
8 |
9 | describe('Uploader', () => {
10 | let spy;
11 | let xhr;
12 |
13 | before(() => {
14 | xhr = sinon.useFakeXMLHttpRequest();
15 | spy = sinon.spy(ClientRequest.prototype, 'write');
16 | });
17 |
18 | after(() => {
19 | spy.restore();
20 | xhr.restore();
21 | });
22 |
23 | describe('upload', () => {
24 | it('should send a request with encoded custom region gravity that represents a box', () => {
25 | cloudinary.v2.uploader.upload('irrelevant', {
26 | regions: {
27 | 'box_1': [[1, 2], [3, 4]],
28 | 'box_2': [[5, 6], [7, 8]]
29 | }
30 | });
31 |
32 | sinon.assert.calledWith(spy, sinon.match(helper.uploadParamMatcher('regions', JSON.stringify({
33 | 'box_1': [[1, 2], [3, 4]],
34 | 'box_2': [[5, 6], [7, 8]]
35 | }))));
36 | });
37 |
38 | it('should send a request with encoded custom region gravity that represents a custom shape', () => {
39 | cloudinary.v2.uploader.upload('irrelevant', {
40 | regions: {
41 | 'custom_1': [[1, 2], [3, 4], [5, 6], [7, 8]],
42 | 'custom_2': [[10, 11], [12, 13], [14, 15]]
43 | }
44 | });
45 |
46 | sinon.assert.calledWith(spy, sinon.match(helper.uploadParamMatcher('regions', JSON.stringify({
47 | 'custom_1': [[1, 2], [3, 4], [5, 6], [7, 8]],
48 | 'custom_2': [[10, 11], [12, 13], [14, 15]]
49 | }))));
50 | });
51 | });
52 |
53 | describe('explicit', () => {
54 | it('should send a request with encoded custom region gravity that represents a box', () => {
55 | cloudinary.v2.uploader.explicit('irrelevant', {
56 | regions: {
57 | 'box_1': [[1, 2], [3, 4]],
58 | 'box_2': [[5, 6], [7, 8]]
59 | }
60 | });
61 |
62 | sinon.assert.calledWith(spy, sinon.match(helper.uploadParamMatcher('regions', JSON.stringify({
63 | 'box_1': [[1, 2], [3, 4]],
64 | 'box_2': [[5, 6], [7, 8]]
65 | }))));
66 | });
67 |
68 | it('should send a request with encoded custom region gravity that represents a custom shape', () => {
69 | cloudinary.v2.uploader.explicit('irrelevant', {
70 | regions: {
71 | 'custom_1': [[1, 2], [3, 4], [5, 6], [7, 8]],
72 | 'custom_2': [[10, 11], [12, 13], [14, 15]]
73 | }
74 | });
75 |
76 | sinon.assert.calledWith(spy, sinon.match(helper.uploadParamMatcher('regions', JSON.stringify({
77 | 'custom_1': [[1, 2], [3, 4], [5, 6], [7, 8]],
78 | 'custom_2': [[10, 11], [12, 13], [14, 15]]
79 | }))));
80 | });
81 | });
82 | });
83 |
--------------------------------------------------------------------------------
/test/integration/api/uploader/slideshow_spec.js:
--------------------------------------------------------------------------------
1 | const Q = require('q');
2 | const cloudinary = require("../../../../cloudinary");
3 | const describe = require('../../../testUtils/suite');
4 | const TEST_ID = Date.now();
5 |
6 | const createTestConfig = require('../../../testUtils/createTestConfig');
7 |
8 | const testConstants = require('../../../testUtils/testConstants');
9 | const UPLOADER_V2 = cloudinary.v2.uploader;
10 |
11 | const {
12 | TIMEOUT,
13 | TAGS
14 | } = testConstants;
15 |
16 | const {
17 | TEST_TAG
18 | } = TAGS;
19 |
20 | require('jsdom-global')();
21 |
22 | describe("create slideshow tests", function () {
23 | this.timeout(TIMEOUT.LONG);
24 | after(function () {
25 | var config = cloudinary.config(true);
26 | if (!(config.api_key && config.api_secret)) {
27 | expect().fail("Missing key and secret. Please set CLOUDINARY_URL.");
28 | }
29 | return Q.allSettled([
30 | !cloudinary.config().keep_test_products ? cloudinary.v2.api.delete_resources_by_tag(TEST_TAG) : void 0,
31 | !cloudinary.config().keep_test_products ? cloudinary.v2.api.delete_resources_by_tag(TEST_TAG,
32 | {
33 | resource_type: "video"
34 | }) : void 0
35 | ]);
36 | });
37 | beforeEach(function () {
38 | cloudinary.config(true);
39 | cloudinary.config(createTestConfig());
40 | });
41 |
42 |
43 | it("should successfully create slideshow", async function () {
44 | // this.timeout(TIMEOUT.LONG);
45 | const slideshowManifest
46 | = 'w_352;h_240;du_5;fps_30;vars_(slides_((media_s64:aHR0cHM6Ly9y' +
47 | 'ZXMuY2xvdWRpbmFyeS5jb20vZGVtby9pbWFnZS91cGxvYWQvY291cGxl);(media_s64:aH' +
48 | 'R0cHM6Ly9yZXMuY2xvdWRpbmFyeS5jb20vZGVtby9pbWFnZS91cGxvYWQvc2FtcGxl)))';
49 |
50 | const slideshowManifestJson = {
51 | "w": 848,
52 | "h": 480,
53 | "du": 6,
54 | "fps": 30,
55 | "vars": {
56 | "sdur": 500,
57 | "tdur": 500,
58 | "slides": [
59 | {
60 | "media": "i:protests9"
61 | }, {
62 | "media": "i:protests8"
63 | },
64 | {
65 | "media": "i:protests7"
66 | },
67 | {
68 | "media": "i:protests6"
69 | },
70 | {
71 | "media": "i:protests2"
72 | },
73 | {
74 | "media": "i:protests1"
75 | }
76 | ]
77 | }
78 | }
79 |
80 |
81 | const res = await UPLOADER_V2.create_slideshow({
82 | manifest_transformation: {
83 | custom_function: {
84 | function_type: 'render',
85 | source: slideshowManifest
86 | }
87 | },
88 | transformation: {
89 | width: 100,
90 | height: 100,
91 | crop: 'scale'
92 | },
93 | // manifest_json: slideshowManifestJson,
94 | tags: [TEST_TAG],
95 | overwrite: true,
96 | public_id: TEST_ID,
97 | notification_url: 'https://example.com'
98 | });
99 |
100 | expect(res.status).to.be('processing');
101 | expect(res.public_id).to.be(TEST_ID.toString()); // TestID is int, Server returns a string and not an int.
102 | expect(res.batch_id.length).to.be.above(5); // some long string
103 | })
104 | })
105 |
--------------------------------------------------------------------------------
/test/integration/cache_spec.js:
--------------------------------------------------------------------------------
1 | var options;
2 | const { describe, before, it } = require('mocha');
3 |
4 | const path = require('path');
5 | const helper = require("../spechelper");
6 | const cloudinary = require('../../cloudinary').v2;
7 |
8 | const FileKeyValueStorage = require(`../../${helper.libPath}/cache/FileKeyValueStorage`);
9 | const KeyValueCacheAdapter = require(`../../${helper.libPath}/cache/KeyValueCacheAdapter`);
10 |
11 | const Cache = cloudinary.Cache;
12 | const IMAGE_FILE = helper.IMAGE_FILE;
13 | const PUBLIC_ID = "dummy";
14 | const BREAKPOINTS = [5, 3, 7, 5];
15 | const testConstants = require('../testUtils/testConstants');
16 |
17 | const {
18 | TIMEOUT,
19 | TAGS
20 | } = testConstants;
21 |
22 | const UPLOAD_TAGS = TAGS.UPLOAD_TAGS;
23 |
24 | const TRANSFORMATION_1 = {
25 | angle: 45,
26 | crop: 'scale'
27 | };
28 |
29 | const FORMAT_1 = 'png';
30 |
31 | describe("Cache", function () {
32 | before(function () {
33 | Cache.setAdapter(new KeyValueCacheAdapter(new FileKeyValueStorage()));
34 | });
35 | it("should be initialized", function () {
36 | expect(Cache).to.be.ok();
37 | });
38 | it("should set and get a value", function () {
39 | Cache.set(PUBLIC_ID, {}, BREAKPOINTS);
40 | expect(Cache.get(PUBLIC_ID, {})).to.eql(BREAKPOINTS);
41 | });
42 | describe("Upload integration", function () {
43 | this.timeout(TIMEOUT.LONG);
44 | before(function () {
45 | options = {
46 | tags: UPLOAD_TAGS,
47 | responsive_breakpoints: [
48 | {
49 | create_derived: false,
50 | transformation: { angle: 90 },
51 | format: 'gif'
52 | },
53 | {
54 | create_derived: false,
55 | transformation: TRANSFORMATION_1,
56 | format: FORMAT_1
57 | },
58 | {
59 | create_derived: false
60 | }
61 | ]
62 | };
63 | });
64 | after(function () {
65 | let config = cloudinary.config(true);
66 | if (!(config.api_key && config.api_secret)) {
67 | expect().fail("Missing key and secret. Please set CLOUDINARY_URL.");
68 | }
69 | if (!cloudinary.config().keep_test_products) {
70 | cloudinary.api.delete_resources_by_tag(helper.TEST_TAG);
71 | }
72 | });
73 | it("should save responsive breakpoints to cache after upload", function () {
74 | return cloudinary.uploader.upload(IMAGE_FILE, options)
75 | .then(function (results) {
76 | let public_id = results.public_id;
77 | let type = results.type;
78 | let resource_type = results.resource_type;
79 | results.responsive_breakpoints.forEach(function (bp) {
80 | let cachedBp = Cache.get(results.public_id, {
81 | public_id,
82 | type,
83 | resource_type,
84 | raw_transformation: bp.transformation,
85 | format: path.extname(bp.breakpoints[0].url).slice(1)
86 | });
87 | expect(cachedBp).to.eql(bp.breakpoints.map(i => i.width));
88 | });
89 | });
90 | });
91 | });
92 | it("should create srcset from cache", function () {
93 | });
94 | });
95 |
--------------------------------------------------------------------------------
/test/setup.js:
--------------------------------------------------------------------------------
1 | require('dotenv').load({
2 | silent: true
3 | });
4 |
5 | if (!process.env.CLOUDINARY_URL) {
6 | throw 'Could not start tests - Cloudinary URL is undefined'
7 | }
8 |
9 | global.expect = require('expect.js');
10 | require('./testUtils/testBootstrap');
11 |
--------------------------------------------------------------------------------
/test/testUtils/assertions/beADatasource.js:
--------------------------------------------------------------------------------
1 | const isEmpty = require("lodash/isEmpty");
2 | const includes = require('lodash/includes');
3 |
4 |
5 | const ERRORS = {
6 | MUST_CONTAIN_VALUES: `expected datasource to contain mandatory field: 'values'`,
7 | MUST_NOT_CONTAIN_VALUES: `expected datasource not to contain a 'values' field`,
8 | INNER_VALUE_MUST_BE_STRING: `expected datasource to contain item with mandatory field 'value' type string`,
9 | INNER_VALUE_MUST_NOT_BE_STRING: `expected datasource not to contain item with mandatory field 'value' type string`,
10 | EXTERNAL_ID_MUST_BE_STRING: `expected datasource field to contain item with mandatory field: 'value' type string`,
11 | EXTERNAL_ID_MUST_NOT_BE_STRING: `expected datasource not to contain item with mandatory field 'external_id' type string`,
12 | STATE_MUST_BE_ONE_OF: (states, state) => `expected datasource field state to be one of ${states}. Unknown state ${state} received`,
13 | STATE_MUST_NOT_BE_ONE_OF: states => `expected datasource field state not to be of ${states}`
14 | };
15 |
16 | /**
17 | * Asserts that a given object is a datasource.
18 | *
19 | * @returns {expect.Assertion}
20 | */
21 | expect.Assertion.prototype.beADatasource = function () {
22 | let datasource;
23 | datasource = this.obj;
24 | this.assert('values' in datasource, function () {
25 | return ERRORS.MUST_CONTAIN_VALUES;
26 | }, function () {
27 | return ERRORS.MUST_NOT_CONTAIN_VALUES;
28 | });
29 |
30 | if (!isEmpty(datasource.values)) {
31 | datasource.values.forEach((value) => {
32 | this.assert(typeof value.value === 'string', function () {
33 | return ERRORS.INNER_VALUE_MUST_BE_STRING;
34 | }, function () {
35 | return ERRORS.INNER_VALUE_MUST_NOT_BE_STRING;
36 | });
37 | this.assert(typeof value.external_id === 'string', function () {
38 | return ERRORS.EXTERNAL_ID_MUST_BE_STRING;
39 | }, function () {
40 | return ERRORS.EXTERNAL_ID_MUST_NOT_BE_STRING;
41 | });
42 | if (!isEmpty(value.state)) {
43 | const states = ['active', 'inactive'];
44 | this.assert(includes(states, value.state), function () {
45 | return ERRORS.STATE_MUST_BE_ONE_OF(states.join(', '), value.state);
46 | }, function () {
47 | return ERRORS.STATE_MUST_NOT_BE_ONE_OF(states.join(', '));
48 | });
49 | }
50 | });
51 | }
52 | return this;
53 | };
54 |
--------------------------------------------------------------------------------
/test/testUtils/assertions/beAMetadataField.js:
--------------------------------------------------------------------------------
1 | const includes = require('lodash/includes');
2 |
3 | /**
4 | * Asserts that a given object is a metadata field.
5 | * Optionally tests the values in the metadata field for equality
6 | *
7 | * @param {string} type The type of metadata field we expect
8 | * @returns {expect.Assertion}
9 | */
10 | expect.Assertion.prototype.beAMetadataField = function (type = '') {
11 | let metadataField, expectedValues;
12 | if (Array.isArray(this.obj)) {
13 | [metadataField, expectedValues] = this.obj;
14 | } else {
15 | metadataField = this.obj;
16 | }
17 | // Check that all mandatory keys exist
18 | const mandatoryKeys = ['type', 'external_id', 'label', 'mandatory', 'default_value', 'validation'];
19 | mandatoryKeys.forEach((key) => {
20 | this.assert(key in metadataField, function () {
21 | return `expected metadata field to contain mandatory field: ${key}`;
22 | }, function () {
23 | return `expected metadata field not to contain a ${key} field`;
24 | });
25 | });
26 |
27 | // If type is enum or set test it
28 | if (includes(['enum', 'set'], metadataField.type)) {
29 | this.assert('datasource' in metadataField, function () {
30 | return `expected metadata field of type ${metadataField.type} to contain a datasource field`;
31 | }, function () {
32 | return `expected metadata field of type ${metadataField.type} not to contain a datasource field`;
33 | });
34 | expect(metadataField.datasource).to.beADatasource();
35 | }
36 |
37 | // Make sure type is acceptable
38 | if (type) {
39 | this.assert(type === metadataField.type, function () {
40 | return `expected metadata field type to equal ${type}`;
41 | }, function () {
42 | return `expected metadata field type ${metadataField.type} not to equal ${type}`;
43 | });
44 | } else {
45 | const acceptableTypes = ['string', 'integer', 'date', 'enum', 'set'];
46 | this.assert(includes(acceptableTypes, metadataField.type), function () {
47 | return `expected metadata field type to be one of ${acceptableTypes.join(', ')}. Unknown field type ${metadataField.type} received`;
48 | }, function () {
49 | return `expected metadata field not to be of a certain type`;
50 | });
51 | }
52 | // Verify object values
53 | if (expectedValues) {
54 | Object.entries(expectedValues).forEach(([key, value]) => {
55 | this.assert(metadataField[key] === value, function () {
56 | return `expected metadata field's ${key} to equal ${value} but got ${metadataField[key]} instead`;
57 | }, function () {
58 | return `expected metadata field's ${key} not to equal ${value}`;
59 | });
60 | });
61 | }
62 |
63 | return this;
64 | };
65 |
--------------------------------------------------------------------------------
/test/testUtils/assertions/beAMulti.js:
--------------------------------------------------------------------------------
1 | const url = require("url");
2 |
3 | const ERRORS = {
4 | FIELD_VERSION_MUST_BE_NUMBER: `expected sprite to contain mandatory field 'version' of type string`,
5 | FIELD_VERSION_MUST_NOT_BE_NUMBER: `expected sprite not to contain mandatory field 'version' of type string`,
6 | FIELD_VALUE_MUST_BE_STRING: name => `expected sprite to contain mandatory field '${name}' of type string`,
7 | FIELD_VALUE_MUST_NOT_BE_STRING: name => `expected sprite not to contain mandatory field '${name}' of type string`,
8 | FIELD_URL_MUST_BE_ACCORDING_TO_THE_SCHEME: (name, protocol, formats) => `expected field '${name}' to contain a URL with protocol '${protocol}' and one of formats: ${formats}`,
9 | FIELD_URL_MUST_NOT_BE_ACCORDING_TO_THE_SCHEME: (name, protocol, formats) => `expected field '${name}' not to contain a URL with protocol '${protocol}' and one of formats: ${formats}`
10 | }
11 |
12 | function matchesSchema (urlStr, protocol, formats) {
13 | const urlObj = url.parse(urlStr);
14 | return urlObj.protocol === `${protocol}:` && formats.some(format => urlObj.pathname.endsWith(format));
15 | }
16 |
17 | /**
18 | * Asserts that a given object is a multi object.
19 | *
20 | * @returns {expect.Assertion}
21 | */
22 | expect.Assertion.prototype.beAMulti = function () {
23 | const multi = this.obj;
24 |
25 | const stringKeys = ["url", "secure_url", "public_id"];
26 | const supportedFormats = ["gif", "png", "webp", "webm", "mp4", "pdf"];
27 |
28 | // Check that certain mandatory keys are of the 'string' type
29 | stringKeys.forEach((key) => {
30 | this.assert(typeof multi[key] === "string", function () {
31 | return ERRORS.FIELD_VALUE_MUST_BE_STRING(key);
32 | }, function () {
33 | return ERRORS.FIELD_VALUE_MUST_NOT_BE_STRING(key);
34 | });
35 | });
36 |
37 | this.assert(typeof multi.version === "number", function () {
38 | return ERRORS.FIELD_VERSION_MUST_BE_NUMBER;
39 | }, function () {
40 | return ERRORS.FIELD_VERSION_MUST_NOT_BE_NUMBER;
41 | });
42 |
43 | // Check that 'url' fields match the protocol and file format
44 | this.assert(matchesSchema(multi.url, "http", supportedFormats), function () {
45 | return ERRORS.FIELD_URL_MUST_BE_ACCORDING_TO_THE_SCHEME("url", "http", supportedFormats);
46 | }, function () {
47 | return ERRORS.FIELD_URL_MUST_NOT_BE_ACCORDING_TO_THE_SCHEME("url", "http", supportedFormats);
48 | });
49 | this.assert(matchesSchema(multi.secure_url, "https", supportedFormats), function () {
50 | return ERRORS.FIELD_URL_MUST_BE_ACCORDING_TO_THE_SCHEME("secure_url", "https", supportedFormats);
51 | }, function () {
52 | return ERRORS.FIELD_URL_MUST_NOT_BE_ACCORDING_TO_THE_SCHEME("secure_url", "https", supportedFormats);
53 | });
54 | }
55 |
--------------------------------------------------------------------------------
/test/testUtils/assertions/beASignedDownloadUrl.js:
--------------------------------------------------------------------------------
1 | const cloudinary = require("../../../cloudinary");
2 | const url = require("url");
3 | const isEmpty = require("lodash/isEmpty");
4 | const isEqual = require("lodash/isEqual");
5 |
6 | const ERRORS = {
7 | MUST_CONTAIN_QUERY_PARAMETER: name => `expected query parameters to contain mandatory parameter: ${name}`,
8 | MUST_NOT_CONTAIN_QUERY_PARAMETER: name => `expected query parameters not to contain parameter: ${name}`,
9 | PATH_MUST_END_WITH: part => `expected path to end with: ${part}`,
10 | PATH_MUST_NOT_END_WITH: part => `expected path not to end with: ${part}`,
11 | FIELD_MUST_EQUAL_VALUE: (key, value, resultValue) => `expected field ${key} to equal ${value} but got ${resultValue} instead`,
12 | FIELD_MUST_NOT_EQUAL_VALUE: (key, value) => `expected field ${key} not to equal ${value}`
13 | }
14 |
15 | /**
16 | * Asserts that a given string is a signed url.
17 | *
18 | * @param {string} [path] Path that the url should end with
19 | * @param {Object} [params] Query paraneters that should be present in the url
20 | *
21 | * @returns {expect.Assertion}
22 | */
23 | expect.Assertion.prototype.beASignedDownloadUrl = function (path, params) {
24 | const apiUrl = this.obj;
25 |
26 | const urlOptions = url.parse(apiUrl, true)
27 | const queryParams = urlOptions.query;
28 |
29 | const defaultParams = {
30 | api_key: cloudinary.config().api_key,
31 | mode: "download"
32 | };
33 | const expectedParams = Object.assign(defaultParams, params);
34 |
35 | // Rename PHP-style multi-value params to strip '[]' from their names, e.g. urls[] -> urls
36 | for (let param in queryParams) {
37 | if (param.endsWith("[]")) {
38 | queryParams[param.slice(0, -2)] = queryParams[param];
39 | delete queryParams[param];
40 | }
41 | }
42 |
43 | this.assert("timestamp" in queryParams, function () {
44 | return ERRORS.MUST_CONTAIN_QUERY_PARAMETER("timestamp");
45 | }, function () {
46 | return ERRORS.MUST_NOT_CONTAIN_QUERY_PARAMETER("timestamp");
47 | });
48 |
49 | this.assert("signature" in queryParams, function () {
50 | return ERRORS.MUST_CONTAIN_QUERY_PARAMETER("signature");
51 | }, function () {
52 | return ERRORS.MUST_NOT_CONTAIN_QUERY_PARAMETER("signature");
53 | });
54 |
55 | if (!isEmpty(path)) {
56 | this.assert(urlOptions.pathname.endsWith(path), function () {
57 | return ERRORS.PATH_MUST_END_WITH(path);
58 | }, function () {
59 | return ERRORS.PATH_MUST_NOT_END_WITH(path);
60 | });
61 | }
62 |
63 | Object.keys(expectedParams).forEach((key) => {
64 | this.assert(isEqual(expectedParams[key], queryParams[key]), function () {
65 | return ERRORS.FIELD_MUST_EQUAL_VALUE(key, expectedParams[key], queryParams[key]);
66 | }, function() {
67 | return ERRORS.FIELD_MUST_NOT_EQUAL_VALUE(key, expectedParams[key]);
68 | });
69 | });
70 | };
71 |
--------------------------------------------------------------------------------
/test/testUtils/assertions/beASprite.js:
--------------------------------------------------------------------------------
1 | const url = require("url");
2 |
3 | const ERRORS = {
4 | FIELD_VERSION_MUST_BE_NUMBER: `expected sprite to contain mandatory field 'version' of type number`,
5 | FIELD_VERSION_MUST_NOT_BE_NUMBER: `expected sprite not to contain mandatory field 'version' of type number`,
6 | MUST_CONTAIN_IMAGE_INFOS: `expected sprite to contain mandatory field: 'image_infos'`,
7 | MUST_NOT_CONTAIN_IMAGE_INFOS: `expected sprite not to contain mandatory field: 'image_infos'`,
8 | FIELD_VALUE_MUST_BE_STRING: name => `expected sprite to contain mandatory field '${name}' of type string`,
9 | FIELD_VALUE_MUST_NOT_BE_STRING: name => `expected sprite not to contain mandatory field '${name}' of type string`,
10 | IMAGE_INFOS_VALUE_MUST_BE_NUMBER: name => `expected 'image_infos' item to contain mandatory field '${name}' of type number`,
11 | IMAGE_INFOS_VALUE_MUST_NOT_BE_NUMBER: name => `expected 'image_infos' item not to contain mandatory field '${name}' of type number`,
12 | FIELD_URL_MUST_BE_ACCORDING_TO_THE_SCHEME: (name, protocol, format) => `expected field '${name}' to contain a URL with protocol '${protocol}' and format '${format}'`,
13 | FIELD_URL_MUST_NOT_BE_ACCORDING_TO_THE_SCHEME: (name, protocol, format) => `expected field '${name}' not to contain a URL with protocol '${protocol}' and format '${format}'`
14 | }
15 |
16 | function matchesSchema (urlStr, protocol, format) {
17 | const urlObj = url.parse(urlStr);
18 | let isValid = urlObj.protocol === `${protocol}:`;
19 | if (format) {
20 | isValid = isValid && urlObj.pathname.endsWith(`.${format}`)
21 | }
22 | return isValid
23 | }
24 |
25 | /**
26 | * Asserts that a given object is a sprite object.
27 | *
28 | * @returns {expect.Assertion}
29 | */
30 | expect.Assertion.prototype.beASprite = function (format=null) {
31 | const sprite = this.obj;
32 | const stringKeys = ["css_url", "image_url", "json_url", "secure_css_url", "secure_image_url", "secure_json_url", "public_id"];
33 | const imageInfosKeys = ["width", "height", "x", "y"];
34 |
35 | // Check that certain mandatory keys are of the 'string' type
36 | stringKeys.forEach((key) => {
37 | this.assert(typeof sprite[key] === "string", function () {
38 | return ERRORS.FIELD_VALUE_MUST_BE_STRING(key);
39 | }, function () {
40 | return ERRORS.FIELD_VALUE_MUST_NOT_BE_STRING(key);
41 | });
42 | });
43 | this.assert(typeof sprite.version === "number", function () {
44 | return ERRORS.FIELD_VERSION_MUST_BE_NUMBER;
45 | }, function () {
46 | return ERRORS.FIELD_VERSION_MUST_NOT_BE_NUMBER;
47 | });
48 | this.assert("image_infos" in sprite, function () {
49 | return ERRORS.MUST_CONTAIN_IMAGE_INFOS;
50 | }, function () {
51 | return ERRORS.MUST_NOT_CONTAIN_IMAGE_INFOS;
52 | });
53 |
54 | // Check that all keys of 'image_infos' field are of the 'number' type
55 | Object.entries(sprite.image_infos).forEach(([key, imageInfos]) => {
56 | imageInfosKeys.forEach((imageInfoKey) => {
57 | this.assert(typeof imageInfos[imageInfoKey] === "number", function () {
58 | return ERRORS.IMAGE_INFOS_VALUE_MUST_BE_NUMBER(imageInfoKey);
59 | }, function () {
60 | return ERRORS.IMAGE_INFOS_VALUE_MUST_NOT_BE_NUMBER(imageInfoKey);
61 | });
62 | });
63 | });
64 |
65 | // Check that 'url' fields match the protocol and file format
66 | this.assert(matchesSchema(sprite.css_url, "http", "css"), function () {
67 | return ERRORS.FIELD_URL_MUST_BE_ACCORDING_TO_THE_SCHEME("css_url", "http", "css");
68 | }, function () {
69 | return ERRORS.FIELD_URL_MUST_NOT_BE_ACCORDING_TO_THE_SCHEME("css_url", "http", "css");
70 | });
71 | this.assert(matchesSchema(sprite.image_url, "http", format), function () {
72 | return ERRORS.FIELD_URL_MUST_BE_ACCORDING_TO_THE_SCHEME("image_url", "http", format);
73 | }, function () {
74 | return ERRORS.FIELD_URL_MUST_NOT_BE_ACCORDING_TO_THE_SCHEME("image_url", "http", format);
75 | });
76 | this.assert(matchesSchema(sprite.json_url, "http", "json"), function () {
77 | return ERRORS.FIELD_URL_MUST_BE_ACCORDING_TO_THE_SCHEME("json_url", "http", "json");
78 | }, function () {
79 | return ERRORS.FIELD_URL_MUST_NOT_BE_ACCORDING_TO_THE_SCHEME("json_url", "http", "json");
80 | });
81 | this.assert(matchesSchema(sprite.secure_css_url, "https", "css"), function () {
82 | return ERRORS.FIELD_URL_MUST_BE_ACCORDING_TO_THE_SCHEME("secure_css_url", "https", "css");
83 | }, function () {
84 | return ERRORS.FIELD_URL_MUST_NOT_BE_ACCORDING_TO_THE_SCHEME("secure_css_url", "https", "css");
85 | });
86 | this.assert(matchesSchema(sprite.secure_image_url, "https", format), function () {
87 | return ERRORS.FIELD_URL_MUST_BE_ACCORDING_TO_THE_SCHEME("secure_image_url", "https", format);
88 | }, function () {
89 | return ERRORS.FIELD_URL_MUST_NOT_BE_ACCORDING_TO_THE_SCHEME("secure_image_url", "https", format);
90 | });
91 | this.assert(matchesSchema(sprite.secure_json_url, "https", "json"), function () {
92 | return ERRORS.FIELD_URL_MUST_BE_ACCORDING_TO_THE_SCHEME("secure_json_url", "https", "json");
93 | }, function () {
94 | return ERRORS.FIELD_URL_MUST_NOT_BE_ACCORDING_TO_THE_SCHEME("secure_json_url", "https", "json");
95 | });
96 | };
97 |
--------------------------------------------------------------------------------
/test/testUtils/assertions/beServedByCloudinary.js:
--------------------------------------------------------------------------------
1 | const cloneDeep = require('lodash/cloneDeep');
2 | const http = require('http');
3 | const https = require('https');
4 | const cloudinary = require('../../../cloudinary');
5 |
6 |
7 | expect.Assertion.prototype.beServedByCloudinary = function (done) {
8 | var actual, actualOptions, callHttp, options, public_id;
9 | [public_id, options] = this.obj;
10 | actualOptions = cloneDeep(options);
11 | actual = cloudinary.url(public_id, actualOptions);
12 | if (actual.startsWith("https")) {
13 | callHttp = https;
14 | } else {
15 | callHttp = http;
16 | }
17 | callHttp.get(actual, (res) => {
18 | this.assert(res.statusCode === 200, function () {
19 | return `Expected to get ${actual} but server responded with "${res.statusCode}: ${res.headers['x-cld-error']}"`;
20 | }, function () {
21 | return `Expeted not to get ${actual}.`;
22 | });
23 | return done();
24 | });
25 | return this;
26 | };
27 |
--------------------------------------------------------------------------------
/test/testUtils/assertions/emptyOptions.js:
--------------------------------------------------------------------------------
1 | const isEmpty = require("lodash/isEmpty");
2 | const cloneDeep = require('lodash/cloneDeep');
3 | const utils = require('../../../cloudinary').utils;
4 |
5 | expect.Assertion.prototype.emptyOptions = function () {
6 | var actual, options, public_id;
7 | [public_id, options] = this.obj;
8 | actual = cloneDeep(options);
9 | utils.url(public_id, actual);
10 | this.assert(isEmpty(actual), function () {
11 | return `expected '${public_id}' and ${JSON.stringify(options)} to produce empty options but got ${JSON.stringify(actual)}`;
12 | }, function () {
13 | return `expected '${public_id}' and ${JSON.stringify(options)} not to produce empty options`;
14 | });
15 | return this;
16 | };
17 |
--------------------------------------------------------------------------------
/test/testUtils/assertions/produceUrl.js:
--------------------------------------------------------------------------------
1 | const cloneDeep = require('lodash/cloneDeep');
2 | const cloudinary = require('../../../cloudinary');
3 |
4 | expect.Assertion.prototype.produceUrl = function (url) {
5 | var actual, actualOptions, options, public_id;
6 | [public_id, options] = this.obj;
7 | actualOptions = cloneDeep(options);
8 | actual = cloudinary.url(public_id, actualOptions);
9 | this.assert(actual.match(url), function () {
10 | return `expected '${public_id}' and ${JSON.stringify(options)} to produce '${url}' but got '${actual}'`;
11 | }, function () {
12 | return `expected '${public_id}' and ${JSON.stringify(options)} not to produce '${url}' but got '${actual}'`;
13 | });
14 | return this;
15 | };
16 |
--------------------------------------------------------------------------------
/test/testUtils/createTestConfig.js:
--------------------------------------------------------------------------------
1 | const defaultConfigOptions = {
2 | urlAnalytics: false,
3 | analytics: false
4 | };
5 |
6 | /**
7 | * @description Creates a default config for testing, add properties to defaultConfigOptions to
8 | * make them global across all tests
9 | * @param {{}} [confOptions] Cloudinary's config options
10 | * @return {{} & {analytics: true} & any}
11 | */
12 | function createTestConfig(confOptions = {}) {
13 | return Object.assign({}, defaultConfigOptions, confOptions);
14 | }
15 |
16 | module.exports = createTestConfig;
17 |
--------------------------------------------------------------------------------
/test/testUtils/helpers/retry.js:
--------------------------------------------------------------------------------
1 | const { RETRY } = require('../testConstants');
2 | const wait = require('./wait')
3 |
4 | /**
5 | * Creates a proxy to retry the function call until it succeeds.
6 | * Custom retry function is used to be able to retry only assert-related
7 | * code segments of the tests and use delays between retries.
8 | *
9 | * @param {function} fn The function to retry.
10 | * @param {number} [limit=3] The number of attempts.
11 | * @param {number} [delay=1000] The delay between attempts, ms.
12 | *
13 | * @returns {function}
14 | */
15 | module.exports = async function retry(fn, limit = RETRY.LIMIT, delay= RETRY.DELAY) {
16 | while (limit--) {
17 | try {
18 | // eslint-disable-next-line no-await-in-loop
19 | return await fn();
20 | } catch (e) {
21 | if (!limit) {
22 | throw e;
23 | }
24 | }
25 |
26 | // eslint-disable-next-line no-await-in-loop
27 | await wait(delay)
28 | }
29 | }
30 |
--------------------------------------------------------------------------------
/test/testUtils/helpers/wait.js:
--------------------------------------------------------------------------------
1 | /**
2 | * @description Used when chained to promises, new Promise().then(wait(1000)).then(wait(2500)).then(log)
3 | * @param {number }ms
4 | * @return {function(...item): Promise<...item>}
5 | */
6 | function wait(ms = 0) {
7 | return (...rest) => {
8 | return new Promise((resolve) => {
9 | setTimeout(() => {
10 | resolve(...rest);
11 | }, ms);
12 | });
13 | }
14 | }
15 |
16 | module.exports = wait;
17 |
--------------------------------------------------------------------------------
/test/testUtils/reusableTests/api/toAcceptNextCursor.js:
--------------------------------------------------------------------------------
1 | const registerReusableTest = require('../reusableTests').registerReusableTest;
2 | const sinon = require('sinon');
3 | const helper = require("../../../spechelper");
4 |
5 | registerReusableTest("accepts next_cursor", function (testFunc, ...args) {
6 | it("Has a next cursor", function () {
7 | return helper.provideMockObjects((mockXHR, writeSpy, requestSpy) => {
8 | testFunc(...args, {
9 | next_cursor: 23452342
10 | });
11 |
12 | // TODO Why aren't we sure what's called here?
13 | if (writeSpy.called) {
14 | sinon.assert.calledWith(writeSpy, sinon.match(/next_cursor=23452342/));
15 | } else {
16 | sinon.assert.calledWith(requestSpy, sinon.match({
17 | query: sinon.match(/next_cursor=23452342/)
18 | }));
19 | }
20 | });
21 | });
22 | });
23 |
--------------------------------------------------------------------------------
/test/testUtils/reusableTests/api/toBeACursor.js:
--------------------------------------------------------------------------------
1 | const registerReusableTest = require('../reusableTests').registerReusableTest;
2 | const sinon = require('sinon');
3 | const helper = require("../../../spechelper");
4 |
5 | registerReusableTest("a list with a cursor", function (testFunc, ...args) {
6 | it("Cursor has max results", function () {
7 | return helper.provideMockObjects(function (mockXHR, writeSpy, requestSpy) {
8 | testFunc(...args, {
9 | max_results: 10
10 | });
11 |
12 | // TODO why don't we know what is used?
13 | if (writeSpy.called) {
14 | sinon.assert.calledWith(writeSpy, sinon.match(/max_results=10/));
15 | } else {
16 | sinon.assert.calledWith(requestSpy, sinon.match({
17 | query: sinon.match(/max_results=10/)
18 | }));
19 | }
20 | });
21 | });
22 | it("Cursor has next cursor", function () {
23 | return helper.provideMockObjects(function (mockXHR, writeSpy, requestSpy) {
24 | testFunc(...args, {
25 | next_cursor: 23452342
26 | });
27 |
28 | // TODO why don't we know what is used?
29 | if (writeSpy.called) {
30 | sinon.assert.calledWith(writeSpy, sinon.match(/next_cursor=23452342/));
31 | } else {
32 | sinon.assert.calledWith(requestSpy, sinon.match({
33 | query: sinon.match(/next_cursor=23452342/)
34 | }));
35 | }
36 | });
37 | });
38 | });
39 |
40 |
--------------------------------------------------------------------------------
/test/testUtils/reusableTests/image/imageAttributesWithClientHInts.js:
--------------------------------------------------------------------------------
1 | const registerReusableTest = require('../reusableTests').registerReusableTest;
2 | const cloudinary = require('../../../../cloudinary');
3 |
4 | const UPLOAD_PATH = "https://res.cloudinary.com/test123/image/upload";
5 | const srcRegExp = function (name, path) {
6 | return RegExp(`${name}=["']${UPLOAD_PATH}/${path}["']`.replace("/", "\/"));
7 | };
8 |
9 | registerReusableTest("Expects correct image tag attributes when client hints are used", function(options) {
10 | it("should not use data-src or set responsive class", function() {
11 | var tag = cloudinary.image('sample.jpg', options);
12 | expect(tag).to.match(/No photos were added yet.
35 | <% } else { %> 36 |-
37 | <% for(let i=0; i
40 |
85 |
86 | <% } %>
87 | <%= photo.title %>
41 | 42 | <%-cloudinary.image(photo.image.public_id, {width: 150, height: 150, quality: 80,format:'jpg',class:'thumbnail inline'})%> 43 | 44 | 45 |
46 | Show transformations
47 |
48 |
49 |
50 | Hide transformations
51 |
52 | <% const transformations = [
53 | { crop : "fill", radius : 10, height : 150, width : 150 },
54 | { crop : "scale", height : 150, width : 150 },
55 | { crop : "fit", height : 150, width : 150 },
56 | { crop : "thumb", gravity : "face", height : 150, width : 150 },
57 | { format : "png", angle : 20, transformation : {
58 | crop : "fill", gravity : "north", effect : "sepia", height : 150, width : 150 } }
59 | ] %>
60 | <% transformations.forEach(function(image_params) {%>
61 |
62 |
80 |
84 | |
63 |
64 |
65 |
68 | %>)
66 |
67 |
77 | |
78 | <% }) %>
79 |
81 | Take a look at our documentation of Image Transformations for a full list of supported transformations.
82 |
83 | 
" + "