[Appconfig] consistency check

sdk/appconfiguration/azure-appconfiguration/README.md

@@ -115,7 +115,7 @@ from azure.appconfiguration import AzureAppConfigurationClient
 
 credential = DefaultAzureCredential()
 
-client = AzureAppConfigurationClient(base_url="your_endpoint_url", credential=credential)
+client = AzureAppConfigurationClient(endpoint="your_endpoint_url", credential=credential)
 ```
 
 ## Key concepts

sdk/appconfiguration/azure-appconfiguration/azure/appconfiguration/_azure_appconfiguration_client.py

@@ -4,7 +4,7 @@
 # license information.
 # -------------------------------------------------------------------------
 import binascii
-from typing import Optional, Any, Mapping, Union
+from typing import Optional, Any, Union, TYPE_CHECKING
 from requests.structures import CaseInsensitiveDict
 from azure.core import MatchConditions
 from azure.core.pipeline import Pipeline
@@ -39,44 +39,37 @@
 from ._sync_token import SyncTokenPolicy
 from ._user_agent import USER_AGENT
 
-try:
-    from typing import TYPE_CHECKING
-except ImportError:
-    TYPE_CHECKING = False
-
 if TYPE_CHECKING:
     from azure.core.paging import ItemPaged
+    from azure.core.credentials import TokenCredential
 
 
 class AzureAppConfigurationClient:
     """Represents an client that calls restful API of Azure App Configuration service.
 
-    :param str base_url: base url of the service
+    :param str endpoint: base url of the service
     :param credential: An object which can provide secrets for the app configuration service
-    :type credential: :class:`~azure.appconfiguration.AppConfigConnectionStringCredential`
-    :keyword Pipeline pipeline: If omitted, the standard pipeline is used.
-    :keyword HttpTransport transport: If omitted, the standard pipeline is used.
-    :keyword list[HTTPPolicy] policies: If omitted, the standard pipeline is used.
+    :type credential: :class:`~azure.appconfiguration.AppConfigConnectionStringCredential` or :class:`~azure.core.credentials.TokenCredential`
 
     """
 
     # pylint:disable=protected-access
 
-    def __init__(self, base_url, credential, **kwargs):
-        # type: (str, Any, **Any) -> None
+    def __init__(self, endpoint, credential, **kwargs):
+        # type: (str, Union[AppConfigConnectionStringCredential, TokenCredential], **Any) -> None
         try:
-            if not base_url.lower().startswith("http"):
-                base_url = "https://" + base_url
+            if not endpoint.lower().startswith("http"):
+                endpoint = "https://" + endpoint
         except AttributeError:
             raise ValueError("Base URL must be a string.")
 
         if not credential:
             raise ValueError("Missing credential")
 
-        self._credential_scopes = base_url.strip("/") + "/.default"
+        self._credential_scopes = endpoint.strip("/") + "/.default"
 
         self._config = AzureAppConfigurationConfiguration(
-            credential, base_url, credential_scopes=self._credential_scopes, **kwargs
+            credential, endpoint, credential_scopes=self._credential_scopes, **kwargs
         )
         self._config.user_agent_policy = UserAgentPolicy(
             base_user_agent=USER_AGENT, **kwargs
@@ -89,11 +82,11 @@ def __init__(self, base_url, credential, **kwargs):
             self._sync_token_policy = SyncTokenPolicy()
             aad_mode = not isinstance(credential, AppConfigConnectionStringCredential)
             pipeline = self._create_appconfig_pipeline(
-                credential=credential, aad_mode=aad_mode, base_url=base_url, **kwargs
+                credential=credential, aad_mode=aad_mode, endpoint=endpoint, **kwargs
             )
 
         self._impl = AzureAppConfiguration(
-            credential, base_url, pipeline=pipeline, credential_scopes=self._credential_scopes
+            credential, endpoint, pipeline=pipeline, credential_scopes=self._credential_scopes
         )
 
     @classmethod
@@ -115,22 +108,22 @@ def from_connection_string(cls, connection_string, **kwargs):
             connection_str = "<my connection string>"
             client = AzureAppConfigurationClient.from_connection_string(connection_str)
         """
-        base_url = "https://" + get_endpoint_from_connection_string(connection_string)
+        endpoint = "https://" + get_endpoint_from_connection_string(connection_string)
         return cls(
             credential=AppConfigConnectionStringCredential(connection_string),
-            base_url=base_url,
+            endpoint=endpoint,
             **kwargs
         )
 
     def _create_appconfig_pipeline(
-        self, credential, base_url=None, aad_mode=False, **kwargs
+        self, credential, endpoint=None, aad_mode=False, **kwargs
     ):
         transport = kwargs.get("transport")
         policies = kwargs.get("policies")
 
         if policies is None:  # [] is a valid policy list
             if aad_mode:
-                scope = base_url.strip("/") + "/.default"
+                scope = endpoint.strip("/") + "/.default"
                 if hasattr(credential, "get_token"):
                     credential_policy = BearerTokenCredentialPolicy(credential, scope)
                 else:
@@ -158,9 +151,8 @@ def _create_appconfig_pipeline(
         return Pipeline(transport, policies)
 
     @distributed_trace
-    def list_configuration_settings(
-        self, key_filter=None, label_filter=None, **kwargs
-    ):  # type: (Optional[str], Optional[str], **Any) -> ItemPaged[ConfigurationSetting]
+    def list_configuration_settings(self, **kwargs):
+        # type: (**Any) -> ItemPaged[ConfigurationSetting]
 
         """List the configuration settings stored in the configuration service, optionally filtered by
         label and accept_datetime
@@ -197,6 +189,8 @@ def list_configuration_settings(
                 pass  # do something
         """
         select = kwargs.pop("fields", None)
+        key_filter = kwargs.pop("key_filter", None)
+        label_filter = kwargs.pop("label_filter", None)
         if select:
             select = ["locked" if x == "read_only" else x for x in select]
         error_map = {401: ClientAuthenticationError}
@@ -219,25 +213,17 @@ def list_configuration_settings(
             raise binascii.Error("Connection string secret has incorrect padding")
 
     @distributed_trace
-    def get_configuration_setting(
-        self,
-        key,  # type: str
-        label=None,  # type: Optional[str]
-        etag="*",  # type: Optional[str]
-        match_condition=MatchConditions.Unconditionally,  # type: Optional[MatchConditions]
-        **kwargs  # type: Any
-    ):  # type: (...) -> Union[None, ConfigurationSetting]
+    def get_configuration_setting(self, key, **kwargs):
+        # type: (...) -> Union[None, ConfigurationSetting]
 
         """Get the matched ConfigurationSetting from Azure App Configuration service
 
         :param key: key of the ConfigurationSetting
         :type key: str
-        :param label: label of the ConfigurationSetting
-        :type label: str
-        :param etag: check if the ConfigurationSetting is changed. Set None to skip checking etag
-        :type etag: str or None
-        :param match_condition: The match condition to use upon the etag
-        :type match_condition: :class:`~azure.core.MatchConditions`
+        :keyword str label: label of the ConfigurationSetting
+        :keyword str etag: check if the ConfigurationSetting is changed. Set None to skip checking etag
+        :keyword match_condition: The match condition to use upon the etag
+        :paramtype match_condition: :class:`~azure.core.MatchConditions`
         :keyword datetime accept_datetime: the retrieved ConfigurationSetting that created no later than this datetime
         :keyword dict headers: if "headers" exists, its value (a dict) will be added to the http request header
         :return: The matched ConfigurationSetting object
@@ -253,6 +239,9 @@ def get_configuration_setting(
                 key="MyKey", label="MyLabel"
             )
         """
+        label = kwargs.pop("label", None)
+        etag = kwargs.pop("etag", "*")
+        match_condition = kwargs.pop("match_condition", MatchConditions.Unconditionally)
         error_map = {401: ClientAuthenticationError, 404: ResourceNotFoundError}
         if match_condition == MatchConditions.IfNotModified:
             error_map[412] = ResourceModifiedError
@@ -344,6 +333,7 @@ def set_configuration_setting(
         :param match_condition: The match condition to use upon the etag
         :type match_condition: :class:`~azure.core.MatchConditions`
         :keyword dict headers: if "headers" exists, its value (a dict) will be added to the http request header
+        :keyword str etag: check if the ConfigurationSetting is changed. Set None to skip checking etag
         :return: The ConfigurationSetting returned from the service
         :rtype: :class:`~azure.appconfiguration.ConfigurationSetting`
         :raises: :class:`HttpResponseError`, :class:`ClientAuthenticationError`, \

sdk/appconfiguration/azure-appconfiguration/azure/appconfiguration/_models.py

@@ -4,6 +4,7 @@
 # ------------------------------------
 import json
 from typing import Dict, Optional, Any, List, Union
+import six
 from msrest.serialization import Model
 from ._generated.models import KeyValue
 
@@ -118,8 +119,8 @@ class FeatureFlagConfigurationSetting(
 
     :ivar etag: Entity tag (etag) of the object
     :vartype etag: str
-    :ivar key:
-    :vartype key: str
+    :ivar feature_id:
+    :vartype feature_id: str
     :ivar value: The value of the configuration setting
     :vartype value: str
     :ivar enabled:
@@ -128,6 +129,10 @@ class FeatureFlagConfigurationSetting(
     :type filters: list[dict[str, Any]]
     :param label:
     :type label: str
+    :param display_name:
+    :type display_name: str
+    :param description:
+    :type description: str
     :param content_type:
     :type content_type: str
     :ivar last_modified:
@@ -140,7 +145,7 @@ class FeatureFlagConfigurationSetting(
 
     _attribute_map = {
         "etag": {"key": "etag", "type": "str"},
-        "key": {"key": "key", "type": "str"},
+        "feature_id": {"key": "key", "type": "str"},
         "label": {"key": "label", "type": "str"},
         "content_type": {"key": "content_type", "type": "str"},
         "value": {"key": "value", "type": "str"},
@@ -159,7 +164,7 @@ def __init__(self, feature_id, enabled, filters=[], **kwargs):  # pylint: disabl
         super(FeatureFlagConfigurationSetting, self).__init__(**kwargs)
         if not feature_id.startswith(self.key_prefix):
             feature_id = self.key_prefix + feature_id
-        self.key = feature_id
+        self.feature_id = feature_id
         self.label = kwargs.get("label", None)
         self.content_type = kwargs.get("content_type", self._feature_flag_content_type)
         self.last_modified = kwargs.get("last_modified", None)
@@ -172,7 +177,7 @@ def __init__(self, feature_id, enabled, filters=[], **kwargs):  # pylint: disabl
 
     def _validate(self):
         # type: () -> None
-        if not self.key.startswith(self.key_prefix):
+        if not self.feature_id.startswith(self.key_prefix):
             raise ValueError("All FeatureFlagConfigurationSettings should be prefixed with {}.".format(self.key_prefix))
         if not (self.value is None or isinstance(self.value, dict)):
             raise ValueError("Expect 'value' to be a dictionary.")
@@ -251,7 +256,7 @@ def _to_generated(self):
         # type: () -> KeyValue
 
         return KeyValue(
-            key=self.key,
+            key=self.feature_id,
             label=self.label,
             value=json.dumps(self.value),  # NOTE: This has to be added for valid json
             content_type=self.content_type,
@@ -271,8 +276,8 @@ class SecretReferenceConfigurationSetting(ConfigurationSetting):
     :vartype etag: str
     :ivar key:
     :vartype key: str
-    :ivar secret_uri:
-    :vartype secret_uri: str
+    :ivar secret_id:
+    :vartype secret_id: str
     :param label:
     :type label: str
     :param content_type:
@@ -302,9 +307,8 @@ class SecretReferenceConfigurationSetting(ConfigurationSetting):
     )
     kind = "SecretReference"
 
-    def __init__(self, key, secret_uri, label=None, **kwargs):
+    def __init__(self, key, secret_id, label=None, **kwargs):
         # type: (str, str, Optional[str], **Any) -> None
-        self._secret_uri = secret_uri
         super(SecretReferenceConfigurationSetting, self).__init__(**kwargs)
         self.key = key
         self.label = label
@@ -315,16 +319,18 @@ def __init__(self, key, secret_uri, label=None, **kwargs):
         self.last_modified = kwargs.get("last_modified", None)
         self.read_only = kwargs.get("read_only", None)
         self.tags = kwargs.get("tags", {})
-        self.value = {"secret_uri": self._secret_uri}
+        self.value = secret_id
+        if not isinstance(secret_id, dict) and isinstance(secret_id, six.string_types):
+            self.value = {"secret_uri": secret_id}
 
     @property
-    def secret_uri(self):
+    def secret_id(self):
         # type: () -> str
         self._validate()
         return self.value['secret_uri']
 
-    @secret_uri.setter
-    def secret_uri(self, value):
+    @secret_id.setter
+    def secret_id(self, value):
         if self.value is None or isinstance(self.value, dict):
             if self.value is None:
                 self.value = {}