public void TestMetadataDataSourceParamsCheck()
{
var parameters = new MetadataDataSourceParams(null);
emptyValuesTestMessage = "Must be specified Values";
AssertCheck(parameters, emptyValuesTestMessage);
parameters.Values = new List <EntryParams>();
AssertCheck(parameters, emptyValuesTestMessage);
parameters.Values.Add(new EntryParams(null));
AssertCheck(parameters, "Must be specified Value");
}
public override void Initialize()
{
base.Initialize();
// External IDs for metadata fields that should be created and later deleted
m_externalIdGeneral = $"metadata_external_id_general_{m_uniqueTestId}";
m_externalIdDate = $"metadata_external_id_date_{m_uniqueTestId}";
m_externalIdEnum2 = $"metadata_external_id_enum_2_{m_uniqueTestId}";
m_externalIdSet = $"metadata_external_id_set_{m_uniqueTestId}";
m_externalIdSet2 = $"metadata_external_id_set_2_{m_uniqueTestId}";
m_externalIdSet3 = $"metadata_external_id_set_3_{m_uniqueTestId}";
m_externalIdDelete2 = $"metadata_deletion_2_{m_uniqueTestId}";
m_externalIdDateValidation = $"metadata_date_validation_{m_uniqueTestId}";
m_externalIdDateValidation2 = $"metadata_date_validation_2_{m_uniqueTestId}";
m_externalIdIntValidation = $"metadata_int_validation_{m_uniqueTestId}";
m_externalIdIntValidation2 = $"metadata_int_validation_2_{m_uniqueTestId}";
m_metaDataFields = new List <string>
{
m_externalIdGeneral, m_externalIdDate, m_externalIdEnum2, m_externalIdSet, m_externalIdSet2,
m_externalIdSet3, m_externalIdDelete2, m_externalIdDateValidation, m_externalIdDateValidation2,
m_externalIdIntValidation, m_externalIdIntValidation2
};
// Sample datasource data
m_datasourceEntryExternalId = $"metadata_datasource_entry_external_id{m_uniqueTestId}";
var singleEntry = new List <EntryParams>
{
new EntryParams("v1", m_datasourceEntryExternalId)
};
m_datasourceSingle = new MetadataDataSourceParams(singleEntry);
var multipleEntries = new List <EntryParams>
{
new EntryParams("v2", m_datasourceEntryExternalId),
new EntryParams("v3"),
new EntryParams("v4")
};
m_datasourceMultiple = new MetadataDataSourceParams(multipleEntries);
CreateMetadataFieldForTest <StringMetadataFieldCreateParams, string>(m_externalIdGeneral);
CreateMetadataFieldForTest <EnumMetadataFieldCreateParams, string>(m_externalIdEnum2, m_datasourceMultiple);
CreateMetadataFieldForTest <SetMetadataFieldCreateParams, List <string> >(m_externalIdSet2, m_datasourceMultiple);
CreateMetadataFieldForTest <SetMetadataFieldCreateParams, List <string> >(m_externalIdSet3, m_datasourceMultiple);
CreateMetadataFieldForTest <IntMetadataFieldCreateParams, int?>(m_externalIdDelete2);
}
public void TestCreateEnumMetadataField()
{
var singleEntry = new List <EntryParams>
{
new EntryParams("v1", datasourceEntryExternalId)
};
var datasourceSingle = new MetadataDataSourceParams(singleEntry);
var parameters = new EnumMetadataFieldCreateParams(externalIdEnum)
{
ExternalId = externalIdEnum,
DataSource = datasourceSingle
};
mockedCloudinary.AddMetadataField(parameters);
mockedCloudinary.AssertHttpCall(SystemHttp.HttpMethod.Post, "metadata_fields");
AssertEncodedRequestFields(mockedCloudinary, "enum", externalIdEnum, singleEntry[0]);
}
public void TestMetadataDataSourceParamsDictionary()
{
var entries = new List <EntryParams>
{
new EntryParams(dataSourceValue1, dataSourceId),
new EntryParams(dataSourceValue2)
};
var parameters = new MetadataDataSourceParams(entries);
Assert.DoesNotThrow(() => parameters.Check());
var dictionary = parameters.ToParamsDictionary();
var values = (List <SortedDictionary <string, object> >)dictionary["values"];
Assert.AreEqual(entries.Count, values.Count);
Assert.AreEqual(dataSourceValue1, values[0]["value"]);
Assert.AreEqual(dataSourceId, values[0]["external_id"]);
Assert.AreEqual(dataSourceValue2, values[1]["value"]);
Assert.False(values[1].ContainsKey("external_id"));
}
/// <summary>
/// Update the datasource of a supported field type (currently only enum and set).
/// The update is partial: datasource entries with an existing external_id will be updated.
/// Entries with new external_id’s (or without external_id’s) will be appended.
/// </summary>
/// <param name="fieldExternalId">The ID of the metadata field.</param>
/// <param name="parameters">Parameters of the datasource to be updated.</param>
/// <returns>Parsed result of the operation.</returns>
public MetadataDataSourceResult UpdateMetadataDataSourceEntries(string fieldExternalId, MetadataDataSourceParams parameters)
{
if (string.IsNullOrEmpty(fieldExternalId))
{
throw new ArgumentNullException(nameof(fieldExternalId));
}
var url = m_api.ApiUrlMetadataFieldV.Add(fieldExternalId).Add(Constants.DATASOURCE_MANAGMENT).BuildUrl();
var result = m_api.CallApi <MetadataDataSourceResult>(HttpMethod.PUT, url, parameters, null, PrepareHeaders());
return(result);
}
/// <summary>
/// <para>Private helper method to create metadata fields for this test.</para>
///
/// <para>Creates metadata field of specified type.
/// See <a href="https://cloudinary.com/documentation/admin_api#create_a_metadata_field">
/// Create a metadata field.</a></para>
/// </summary>
/// <param name="externalId">The ID of the metadata field.</param>
/// <param name="dataSource">Optional. Data source for a field to be created.</param>
/// <typeparam name="T">Type of the metadata field.</typeparam>
/// <typeparam name="TP">Type that can describe the field type.</typeparam>
/// <returns>Parsed result of the metadata field creating.</returns>
private MetadataFieldResult CreateMetadataFieldForTest <T, TP>(string externalId, MetadataDataSourceParams dataSource = null)
where T : MetadataFieldCreateParams <TP>
{
var parameters = (T)Activator.CreateInstance(typeof(T), externalId);
parameters.ExternalId = externalId;
if (dataSource != null)
{
parameters.DataSource = dataSource;
}
return(m_cloudinary.AddMetadataField(parameters));
}
