Add access_control parameter to upload and update

Author: Amir Tocker

src/utils.coffee

@@ -452,6 +452,7 @@ exports.generate_transformation_string = (options) ->
   filter(transformations, utils.present).join "/"
 
 exports.updateable_resource_params = (options, params = {}) ->
+  params.access_control = jsonArrayParam(options.access_control) if options.access_control?
   params.auto_tagging = options.auto_tagging if options.auto_tagging?
   params.background_removal = options.background_removal if options.background_removal?
   params.categorization = options.categorization if options.categorization?
@@ -1045,7 +1046,7 @@ hashToQuery = (hash)->
 # @param [Hash|String|Array<Hash>] data
 # @return [String|nil] a JSON array string or `nil` if data is `nil`
 ###
-jsonArrayParam = (data, callback)->
+exports.jsonArrayParam = jsonArrayParam = (data, callback)->
   return unless data
 
   data = JSON.parse(data) if isString(data)

test/access_control_spec.coffee

@@ -0,0 +1,68 @@
+require('dotenv').load(silent: true)
+
+expect = require("expect.js")
+cloudinary = require("../cloudinary")
+utils = require("../lib/utils")
+sinon = require('sinon')
+ClientRequest = require('_http_client').ClientRequest
+http = require('http')
+helper = require('./spechelper')
+escapeRegexp = helper.escapeRegexp
+
+isString = require('lodash/isString')
+
+xhr = request = requestStub = requestSpy = writeSpy = options = undefined
+describe "Access Control", ()->
+  before "Verify Configuration", ->
+  config = cloudinary.config(true)
+  if(!(config.api_key && config.api_secret))
+    expect().fail("Missing key and secret. Please set CLOUDINARY_URL.")
+
+  @timeout helper.TIMEOUT_LONG
+  after ->
+    config = cloudinary.config(true)
+    if(!(config.api_key && config.api_secret))
+      expect().fail("Missing key and secret. Please set CLOUDINARY_URL.")
+    cloudinary.v2.api.delete_resources_by_tag(helper.TEST_TAG) unless cloudinary.config().keep_test_products
+
+  beforeEach ->
+    options = {
+      public_id: helper.TEST_TAG,
+      tags: [helper.UPLOAD_TAGS..., 'access_control_test']
+    }
+
+  acl = {
+      access_type: 'anonymous',
+      start: new Date(Date.UTC(2019,1,22, 16, 20, 57)),
+      end: '2019-03-22 00:00 +0200'
+  }
+  acl_2 = {
+      access_type: 'anonymous',
+      start: '2019-02-22 16:20:57Z',
+      end: '2019-03-22 00:00 +0200'
+  }
+  acl_string = 
+    '{"access_type":"anonymous","start":"2019-02-22 16:20:57 +0200","end":"2019-03-22 00:00 +0200"}'
+  
+  describe "build_upload_params", ()->
+    it "should accept a Hash value", ()->
+      params = cloudinary.utils.build_upload_params( access_control: acl)
+      expect(params).to.have.key('access_control')
+      expect(isString(params.access_control)).to.be.ok()
+      expect(params.access_control).to.match(/^\[.+\]$/)
+
+    it "should accept an array of Hash values", ()->
+      params = cloudinary.utils.build_upload_params access_control: [acl, acl_2]
+      expect(params).to.have.key('access_control')
+      expect(isString(params.access_control)).to.be.ok()
+      expect(params.access_control).to.match(/^\[.+\]$/)
+      j = JSON.parse(params.access_control)
+      expect(j.length).to.be(2)
+      expect(j[0]["access_type"]).to.equal(acl.access_type)
+      expect(Date.parse(j[0]["start"])).to.equal(Date.parse(acl.start))
+      expect(Date.parse(j[0]["end"])).to.equal(Date.parse(acl.end))
+    it "should accept a JSON string", ()->
+      params = cloudinary.utils.build_upload_params access_control: acl_string
+      expect(params).to.have.key('access_control')
+      expect(isString(params.access_control)).to.be.ok()
+      expect(params.access_control).to.equal("[#{acl_string}]")

test/api_spec.coffee

@@ -15,8 +15,9 @@ ClientRequest = require('_http_client').ClientRequest
 http = require('http')
 Q = require('q')
 fs = require('fs')
-
 helper = require("./spechelper")
+mockTest = helper.mockTest
+
 sharedExamples = helper.sharedExamples
 itBehavesLike = helper.itBehavesLike
 TEST_TAG        = helper.TEST_TAG
@@ -56,6 +57,7 @@ sharedExamples "a list with a cursor", (testFunc, args...)->
     writeSpy.restore()
     requestSpy.restore()
     xhr.restore()
+
   specify ":max_results", ()->
     testFunc args..., max_results: 10
     if writeSpy.called
@@ -690,6 +692,28 @@ describe "api", ->
           done()
         true
 
+    describe "access_control", ()->
+      acl = {
+        access_type: 'anonymous',
+        start: new Date(Date.UTC(2019,1,22, 16, 20, 57)),
+        end: '2019-03-22 00:00 +0200'
+      }
+      acl_string =
+        '{"access_type":"anonymous","start":"2019-02-22T16:20:57.000Z","end":"2019-03-22 00:00 +0200"}'
+      options = {
+        public_id: helper.TEST_TAG,
+        tags: [helper.UPLOAD_TAGS..., 'access_control_test']
+      }
+
+      it "should allow the user to define ACL in the update parameters2", ()->
+        helper.mockPromise((xhr, writeSpy, requestSpy)->
+          options.access_control = [acl]
+          cloudinary.v2.api.update("id", options)
+          sinon.assert.calledWith(writeSpy, sinon.match((arg)->
+            helper.apiParamMatcher('access_control', "[#{acl_string}]")(arg)
+          ))
+        )
+
   it "should support listing by moderation kind and value", (done) ->
     itBehavesLike "a list with a cursor", cloudinary.v2.api.resources_by_moderation, "manual", "approved"
     @timeout helper.TIMEOUT_MEDIUM

test/uploader_spec.coffee

@@ -38,8 +38,9 @@ describe "uploader", ->
   # Upload an image to be tested on.
   # @callback the callback receives the public_id of the uploaded image
   ###
-  upload_image = (callback)->
-    cloudinary.v2.uploader.upload IMAGE_FILE, tags: UPLOAD_TAGS, (error, result) ->
+  upload_image = (options, callback)->
+    [options, callback] = if isFunction(options) then [{tags: UPLOAD_TAGS}, options] else [options, callback] 
+    cloudinary.v2.uploader.upload IMAGE_FILE, options, (error, result) ->
       expect(error).to.be undefined
       callback?(result)
 
@@ -618,4 +619,42 @@ describe "uploader", ->
     expect(input_element.getAttribute("name")).to.be('file');
     expect(input_element.getAttribute("type")).to.be('file');
 
+  describe "access_control", ()->
+    writeSpy = undefined
+    requestSpy = undefined
+    options = undefined
+
+    beforeEach ->
+      writeSpy = sinon.spy(ClientRequest.prototype, 'write')
+      requestSpy = sinon.spy(http, 'request')
+      options = {
+        public_id: helper.TEST_TAG,
+        tags: [helper.UPLOAD_TAGS..., 'access_control_test']
+      }
+
+    afterEach ->
+      requestSpy.restore()
+      writeSpy.restore()
+
+    acl = {
+      access_type: 'anonymous',
+      start: new Date(Date.UTC(2019,1,22, 16, 20, 57)),
+      end: '2019-03-22 00:00 +0200'
+    }
+    acl_string =
+      '{"access_type":"anonymous","start":"2019-02-22T16:20:57.000Z","end":"2019-03-22 00:00 +0200"}'
+
+    it "should allow the user to define ACL in the upload parameters", ()->
+      options.access_control = [acl]
+      upload_image(options).then (resource)=>
+        sinon.assert.calledWith(writeSpy, sinon.match(
+          helper.uploadParamMatcher('access_control', helper.escapeRegexp("[#{acl_string}]"))
+        ))
+        expect(resource).to.have.key('access_control')
+        response_acl = resource["access_control"]
+        expect(response_acl.length).to.be(1)
+        expect(response_acl[0]["access_type"]).to.be("anonymous")
+        expect(Date.parse(response_acl[0]["start"])).to.be(Date.parse(acl.start))
+        expect(Date.parse(response_acl[0]["end"])).to.be(Date.parse(acl.end))
+