Address review comments

cloudinary · Sep 20, 2021 · fd47eea · fd47eea
1 parent 0b2e134
commit fd47eea
Show file tree

Hide file tree

Showing 27 changed files with 900 additions and 50 deletions.
diff --git a/CloudinaryDotNet.IntegrationTests/AdminApi/BrowseResourcesWithStructuredMetadataTest.cs b/CloudinaryDotNet.IntegrationTests/AdminApi/BrowseResourcesWithStructuredMetadataTest.cs
@@ -0,0 +1,104 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using CloudinaryDotNet.Actions;
+using NUnit.Framework;
+
+namespace CloudinaryDotNet.IntegrationTests.AdminApi
+{
+    public class BrowseResourcesWithStructuredMetadataTest : IntegrationTestBase
+    {
+        private const string MODERATION_MANUAL = "manual";
+        private static string m_contextKey;
+        private static string m_contextValue;
+        private static string m_publicId;
+
+        public override void Initialize()
+        {
+            base.Initialize();
+
+            m_contextKey = $"{m_uniqueTestId}_context_key";
+            m_contextValue = $"{m_uniqueTestId}_context_value";
+            var context = $"{m_contextKey}={m_contextValue}";
+
+            CreateMetadataField("resource_with_metadata", p => p.DefaultValue = p.Label);
+            var uploadResult = UploadTestImageResource(p =>
+            {
+                p.Context = new StringDictionary(context);
+                p.Moderation = MODERATION_MANUAL;
+            });
+
+            m_publicId = uploadResult.PublicId;
+        }
+
+        [Test, RetryWithDelay]
+        public async Task TestListResources()
+        {
+            var @params = new ListResourcesParams
+            {
+            };
+            await AssertMetadataFlagBehavior(@params);
+        }
+
+        [Test, RetryWithDelay]
+        public async Task TestListResourcesByTag()
+        {
+            var @params = new ListResourcesByTagParams
+            {
+                Tag = m_apiTag,
+            };
+            await AssertMetadataFlagBehavior(@params);
+        }
+
+        [Test, RetryWithDelay]
+        public async Task TestListResourcesByModerationStatus()
+        {
+            var @params = new ListResourcesByModerationParams
+            {
+                ModerationStatus = ModerationStatus.Pending,
+                ModerationKind = MODERATION_MANUAL,
+            };
+            await AssertMetadataFlagBehavior(@params);
+        }
+
+        [Test, RetryWithDelay]
+        public async Task TestListResourcesByPrefix()
+        {
+            var @params = new ListResourcesByPrefixParams
+            {
+                Type = "upload",
+                Prefix = m_test_prefix,
+            };
+            await AssertMetadataFlagBehavior(@params);
+        }
+
+        private async Task AssertMetadataFlagBehavior(ListResourcesParams @params)
+        {
+            @params.Metadata = true;
+            CommonAssertions(await m_cloudinary.ListResourcesAsync(@params), true);
+
+            @params.Metadata = false;
+            CommonAssertions(await m_cloudinary.ListResourcesAsync(@params), false);
+        }
+
+        private void CommonAssertions(ListResourcesResult result, bool shouldHaveMetadata)
+        {
+            Assert.IsNotNull(result);
+            Assert.IsNotNull(result.Resources, result.Error?.Message);
+
+            var resourceWithMetadata = result.Resources.FirstOrDefault(r => r.PublicId == m_publicId);
+            Assert.IsNotNull(resourceWithMetadata);
+
+            if (shouldHaveMetadata)
+            {
+                Assert.IsNotNull(resourceWithMetadata.MetadataFields);
+            }
+            else
+            {
+                Assert.IsNull(resourceWithMetadata.MetadataFields);
+            }
+        }
+    }
+}
diff --git a/CloudinaryDotNet.IntegrationTests/IntegrationTestBase.cs b/CloudinaryDotNet.IntegrationTests/IntegrationTestBase.cs
@@ -200,9 +200,9 @@ private void SaveEmbeddedToDisk(Assembly assembly, string sourcePath, string des
                     stream.CopyTo(fileStream);
                 }
             }
-            catch (IOException e)
+            catch (IOException)
             {
-                
+
             }
         }
 
@@ -308,11 +308,13 @@ protected Task<RawUploadResult> UploadTestRawResourceAsync(
         /// A convenient method for creating a structured metadata field before testing.
         /// </summary>
         /// <param name="fieldLabelSuffix">The distinguishable suffix.</param>
+        /// <param name="setParamsAction">Action to set custom metadata field parameters.</param>
         /// <returns>The ExternalId of the structured metadata field.</returns>
-        protected string CreateMetadataField(string fieldLabelSuffix)
+        protected string CreateMetadataField(string fieldLabelSuffix, Action<StringMetadataFieldCreateParams> setParamsAction = null)
         {
             var metadataLabel = GetUniqueMetadataFieldLabel(fieldLabelSuffix);
             var metadataParameters = new StringMetadataFieldCreateParams(metadataLabel);
+            setParamsAction?.Invoke(metadataParameters);
             var metadataResult = m_cloudinary.AddMetadataField(metadataParameters);
 
             Assert.NotNull(metadataResult, metadataResult.Error?.Message);

diff --git a/CloudinaryDotNet.IntegrationTests/Provisioning/ProvisioningIntegrationTestBase.cs b/CloudinaryDotNet.IntegrationTests/Provisioning/ProvisioningIntegrationTestBase.cs
@@ -76,10 +76,10 @@ private string CreateUser(string userName, string userEmail)
         {
             var createUserParams = new CreateUserParams(userName, userEmail, m_userRole)
             {
-                SubAccountIds = new List<string> {m_cloudId1}
+                SubAccountIds = new List<string> { m_cloudId1 }
             };
             var createUserResult = AccountProvisioning.CreateUserAsync(createUserParams).GetAwaiter().GetResult();
-            Assert.AreEqual(HttpStatusCode.OK, createUserResult.StatusCode);
+            Assert.AreEqual(HttpStatusCode.OK, createUserResult.StatusCode, createUserResult?.Error?.Message);
             Assert.AreEqual(1, createUserResult.SubAccountIds.Length);
             Assert.AreEqual(m_cloudId1, createUserResult.SubAccountIds[0]);
 

diff --git a/CloudinaryDotNet.IntegrationTests/UploadApi/RenameMethodsTest.cs b/CloudinaryDotNet.IntegrationTests/UploadApi/RenameMethodsTest.cs
@@ -1,13 +1,26 @@
-using System.Net;
+using System.Linq;
+using System.Net;
+using System.Threading.Tasks;
 using CloudinaryDotNet.Actions;
 using NUnit.Framework;
 
 namespace CloudinaryDotNet.IntegrationTests.UploadApi
 {
     public class RenameMethodsTest : IntegrationTestBase
     {
+        private static string m_context;
+
+        public override void Initialize()
+        {
+            base.Initialize();
+
+            var contextKey = $"{m_uniqueTestId}_context_key";
+            var contextValue = $"{m_uniqueTestId}_context_value";
+            m_context = $"{contextKey}={contextValue}";
+        }
+
         [Test, RetryWithDelay]
-        public void TestRename()
+        public async Task TestRename()
         {
             var toPublicId = GetUniquePublicId();
 
@@ -16,29 +29,29 @@ public void TestRename()
                 File = new FileDescription(m_testImagePath),
                 Tags = m_apiTag
             };
-            var uploadResult1 = m_cloudinary.Upload(uploadParams);
+            var uploadResult1 = await m_cloudinary.UploadAsync(uploadParams);
 
             uploadParams.File = new FileDescription(m_testIconPath);
-            var uploadResult2 = m_cloudinary.Upload(uploadParams);
+            var uploadResult2 = await m_cloudinary.UploadAsync(uploadParams);
 
-            var renameResult = m_cloudinary.Rename(uploadResult1.PublicId, toPublicId);
+            var renameResult = await m_cloudinary.RenameAsync(uploadResult1.PublicId, toPublicId);
             Assert.AreEqual(HttpStatusCode.OK, renameResult.StatusCode, renameResult.Error?.Message);
 
-            var getResult = m_cloudinary.GetResource(toPublicId);
+            var getResult = await m_cloudinary.GetResourceAsync(toPublicId);
             Assert.NotNull(getResult);
 
-            renameResult = m_cloudinary.Rename(uploadResult2.PublicId, toPublicId);
+            renameResult = await m_cloudinary.RenameAsync(uploadResult2.PublicId, toPublicId);
             Assert.True(renameResult.StatusCode == HttpStatusCode.BadRequest, renameResult.Error?.Message);
 
-            m_cloudinary.Rename(uploadResult2.PublicId, toPublicId, true);
+            await m_cloudinary.RenameAsync(uploadResult2.PublicId, toPublicId, true);
 
-            getResult = m_cloudinary.GetResource(toPublicId);
+            getResult = await m_cloudinary.GetResourceAsync(toPublicId);
             Assert.NotNull(getResult);
             Assert.AreEqual(FILE_FORMAT_ICO, getResult.Format, getResult.Error?.Message);
         }
 
         [Test, RetryWithDelay]
-        public void TestRenameToType()
+        public async Task TestRenameToType()
         {
             string publicId = GetUniquePublicId();
             string newPublicId = GetUniquePublicId();
@@ -51,18 +64,78 @@ public void TestRenameToType()
                 Type = STORAGE_TYPE_UPLOAD
             };
 
-            var uploadResult = m_cloudinary.Upload(uploadParams);
+            var uploadResult = await m_cloudinary.UploadAsync(uploadParams);
             Assert.AreEqual(uploadResult.StatusCode, HttpStatusCode.OK, uploadResult.Error?.Message);
 
             RenameParams renameParams = new RenameParams(publicId, newPublicId)
             {
                 ToType = STORAGE_TYPE_UPLOAD
             };
 
-            var renameResult = m_cloudinary.Rename(renameParams);
+            var renameResult = await m_cloudinary.RenameAsync(renameParams);
             Assert.AreEqual(renameResult.StatusCode, HttpStatusCode.OK, renameResult.Error?.Message);
             Assert.AreEqual(renameResult.Type, STORAGE_TYPE_UPLOAD);
             Assert.AreEqual(renameResult.PublicId, newPublicId);
         }
+
+        [Test]
+        public async Task TestRenameReturnsContext()
+        {
+            string publicId = GetUniquePublicId();
+            string newPublicId = GetUniquePublicId();
+
+            await UploadImage(publicId);
+
+            var @params = new RenameParams(publicId, newPublicId)
+            {
+                Context = true
+            };
+            var renameResult = await m_cloudinary.RenameAsync(@params);
+            Assert.IsTrue(renameResult.Context.HasValues);
+
+            @params.Context = false;
+            renameResult = await m_cloudinary.RenameAsync(@params);
+            Assert.IsNull(renameResult.Context);
+        }
+
+        [Test]
+        public async Task TestRenameReturnsMetadata()
+        {
+            string publicId = GetUniquePublicId();
+            string newPublicId = GetUniquePublicId();
+
+            await UploadImage(publicId, true);
+
+            var @params = new RenameParams(publicId, newPublicId)
+            {
+                Metadata = true
+            };
+            var renameResult = await m_cloudinary.RenameAsync(@params);
+            Assert.IsTrue(renameResult.MetadataFields.HasValues);
+
+            @params.Metadata = false;
+            renameResult = await m_cloudinary.RenameAsync(@params);
+            Assert.IsNull(renameResult.MetadataFields);
+        }
+
+        private async Task UploadImage(string publicId, bool withMetadata = false)
+        {
+            if (withMetadata)
+            {
+                CreateMetadataField("rename_with_metadata", p => p.DefaultValue = p.Label);
+            }
+
+            var uploadParams = new ImageUploadParams()
+            {
+                PublicId = publicId,
+                File = new FileDescription(m_testImagePath),
+                Tags = m_apiTag,
+                Type = STORAGE_TYPE_UPLOAD,
+                Context = new StringDictionary(m_context),
+            };
+
+            var uploadResult = await m_cloudinary.UploadAsync(uploadParams);
+            Assert.AreEqual(uploadResult.StatusCode, HttpStatusCode.OK, uploadResult.Error?.Message);
+        }
     }
 }
diff --git a/CloudinaryDotNet.Tests/ApiShared.ProxyTest.cs b/CloudinaryDotNet.Tests/ApiShared.ProxyTest.cs
@@ -0,0 +1,50 @@
+#if NETSTANDARD2_0
+using NUnit.Framework;
+
+namespace CloudinaryDotNet.Tests
+{
+    public class ApiSharedProxyTest
+    {
+        private ApiShared _apiShared;
+
+        [SetUp]
+        public void SetUp()
+        {
+            _apiShared = new ApiShared();
+        }
+
+        [Test]
+        public void TestDoesNotRecreateClientOnEmptyProxy([Values(null, "")] string proxy)
+        {
+            var originalClient = _apiShared.Client;
+            _apiShared.ApiProxy = proxy;
+
+            Assert.AreEqual(originalClient, _apiShared.Client);
+        }
+
+        [Test]
+        public void TestDoesNotRecreateClientOnTheSameProxy()
+        {
+            var proxy = "http://proxy.com";
+
+            _apiShared.ApiProxy = proxy;
+            var originalClient = _apiShared.Client;
+
+            _apiShared.ApiProxy = proxy;
+
+            Assert.AreEqual(originalClient, _apiShared.Client);
+        }
+
+        [Test]
+        public void TestRecreatesClientWhenNewProxyIsSet()
+        {
+            var proxy = "http://proxy.com";
+            var originalClient = _apiShared.Client;
+
+            _apiShared.ApiProxy = proxy;
+
+            Assert.AreNotEqual(originalClient, _apiShared.Client);
+        }
+    }
+}
+#endif