[non-Azure] adjust test framework to prepare for unbranded test (#2209)

* prepare test framework

* Fix

* fix

* fix ci

* add unbranded test

* fix unbranded test

* inv reg

* inv reg

Author: msyyc

eng/pipelines/ci.yml

@@ -166,6 +166,12 @@ jobs:
       - template: generated-code-checks-template.yml
         parameters:
             package: "typespec-python"
+            folderName: "azure"
+
+      - template: generated-code-checks-template.yml
+        parameters:
+            package: "typespec-python"
+            folderName: "unbranded"
 
       - script: cadl-ranch check-coverage http/
         displayName: Check Coverage

eng/pipelines/publish-release.yml

@@ -46,9 +46,14 @@ steps:
       displayName: Execute Autorest DPG Version Tolerant Tests
       workingDirectory: $(Build.SourcesDirectory)/packages/autorest.python/
     - script: |
-          cd test
+          cd test/azure
           tox run -e ci
-      displayName: Execute Cadl Tests
+      displayName: Execute Typespec Azure Tests
+      workingDirectory: $(Build.SourcesDirectory)/packages/typespec-python/
+    - script: |
+          cd test/unbranded
+          tox run -e ci
+      displayName: Execute Typespec Unbranded Tests
       workingDirectory: $(Build.SourcesDirectory)/packages/typespec-python/
 
     - script: |

packages/autorest.python/autorest/codegen/models/__init__.py

@@ -28,7 +28,7 @@
     BooleanType,
     AnyObjectType,
     UnixTimeType,
-    AzureCoreType,
+    SdkCoreType,
 )
 from .enum_type import EnumType, EnumValue
 from .base import BaseType
@@ -67,15 +67,15 @@
 )
 from .credential_types import (
     TokenCredentialType,
-    AzureKeyCredentialType,
+    KeyCredentialType,
     ARMChallengeAuthenticationPolicyType,
     BearerTokenCredentialPolicyType,
-    AzureKeyCredentialPolicyType,
+    KeyCredentialPolicyType,
     CredentialType,
 )
 
 __all__ = [
-    "AzureKeyCredentialPolicyType",
+    "KeyCredentialPolicyType",
     "AnyType",
     "BaseModel",
     "BaseType",
@@ -140,14 +140,14 @@
     "boolean": BooleanType,
     "combined": CombinedType,
     "OAuth2": TokenCredentialType,
-    "Key": AzureKeyCredentialType,
+    "Key": KeyCredentialType,
     "ARMChallengeAuthenticationPolicy": ARMChallengeAuthenticationPolicyType,
     "BearerTokenCredentialPolicy": BearerTokenCredentialPolicyType,
-    "AzureKeyCredentialPolicy": AzureKeyCredentialPolicyType,
+    "KeyCredentialPolicy": KeyCredentialPolicyType,
     "any-object": AnyObjectType,
     "unixtime": UnixTimeType,
     "credential": StringType,
-    "azurecore": AzureCoreType,
+    "sdkcore": SdkCoreType,
 }
 _LOGGER = logging.getLogger(__name__)
 

packages/autorest.python/autorest/codegen/models/client.py

@@ -205,7 +205,7 @@ def _imports_shared(self, async_mode: bool) -> FileImport:
             )
         else:
             file_import.add_submodule_import(
-                file_import.import_core,
+                file_import.import_core_pipeline_client,
                 self.pipeline_class(async_mode),
                 ImportType.SDKCORE,
             )
@@ -231,7 +231,7 @@ def _imports_shared(self, async_mode: bool) -> FileImport:
             typing_section=TypingSection.REGULAR,
         )
         file_import.add_submodule_import(
-            file_import.import_core_pipeline, "policies", ImportType.SDKCORE
+            file_import.import_core_policies, "policies", ImportType.SDKCORE
         )
         if self.code_model.options["azure_arm"]:
             async_prefix = "Async" if async_mode else ""
@@ -414,7 +414,7 @@ def name(self) -> str:
     def _imports_shared(self, async_mode: bool) -> FileImport:
         file_import = self.init_file_import()
         file_import.add_submodule_import(
-            file_import.import_core_pipeline, "policies", ImportType.SDKCORE
+            file_import.import_core_policies, "policies", ImportType.SDKCORE
         )
         file_import.add_submodule_import(
             "typing", "Any", ImportType.STDLIB, TypingSection.CONDITIONAL

packages/autorest.python/autorest/codegen/models/credential_types.py

@@ -26,7 +26,7 @@
 class _CredentialPolicyBaseType:
     """Base class for our different credential policy types.
 
-    Inherited by our BearerTokenCredentialPolicy and AzureKeyCredentialPolicy types.
+    Inherited by our BearerTokenCredentialPolicy and KeyCredentialPolicy types.
     """
 
     def __init__(self, yaml_data: Dict[str, Any], code_model: "CodeModel") -> None:
@@ -71,7 +71,7 @@ def call(self, async_mode: bool) -> str:
         return f"{policy_name}(self.credential, *self.credential_scopes, **kwargs)"
 
 
-class AzureKeyCredentialPolicyType(_CredentialPolicyBaseType):
+class KeyCredentialPolicyType(_CredentialPolicyBaseType):
     def __init__(
         self,
         yaml_data: Dict[str, Any],
@@ -83,16 +83,26 @@ def __init__(
         self.key = key
         self.scheme = scheme
 
+    @property
+    def credential_name(self) -> str:
+        return (
+            "AzureKeyCredential"
+            if not self.code_model.options["unbranded"]
+            else "ServiceKeyCredential"
+        )
+
     def call(self, async_mode: bool) -> str:
         params = f'"{self.key}", '
         if self.scheme:
             params += f'prefix="{self.scheme}", '
-        return f"policies.AzureKeyCredentialPolicy(self.credential, {params}**kwargs)"
+        return (
+            f"policies.{self.credential_name}Policy(self.credential, {params}**kwargs)"
+        )
 
     @classmethod
     def from_yaml(
         cls, yaml_data: Dict[str, Any], code_model: "CodeModel"
-    ) -> "AzureKeyCredentialPolicyType":
+    ) -> "KeyCredentialPolicyType":
         return cls(
             yaml_data, code_model, yaml_data["key"], yaml_data.get("scheme", None)
         )
@@ -103,15 +113,15 @@ def from_yaml(
     bound=Union[
         BearerTokenCredentialPolicyType,
         ARMChallengeAuthenticationPolicyType,
-        AzureKeyCredentialPolicyType,
+        KeyCredentialPolicyType,
     ],
 )
 
 
 class CredentialType(
     Generic[CredentialPolicyType], BaseType
 ):  # pylint:disable=abstract-method
-    """Store info about the type of the credential. Can be either an AzureKeyCredential or a TokenCredential"""
+    """Store info about the type of the credential. Can be either an KeyCredential or a TokenCredential"""
 
     def __init__(
         self,
@@ -204,27 +214,27 @@ def instance_check_template(self) -> str:
         return "hasattr({}, 'get_token')"
 
 
-class AzureKeyCredentialType(
+class KeyCredentialType(
     # pylint: disable=unsubscriptable-object
-    CredentialType[AzureKeyCredentialPolicyType]
+    CredentialType[KeyCredentialPolicyType]
 ):
-    """Type for an AzureKeyCredential"""
+    """Type for an KeyCredential"""
 
     def docstring_type(self, **kwargs: Any) -> str:  # pylint: disable=unused-argument
-        return "~azure.core.credentials.AzureKeyCredential"
+        return f"~{self.init_file_import().import_core}.credentials.{self.policy.credential_name}"
 
     def type_annotation(self, **kwargs: Any) -> str:  # pylint: disable=unused-argument
-        return "AzureKeyCredential"
+        return self.policy.credential_name
 
     @property
     def instance_check_template(self) -> str:
-        return "isinstance({}, AzureKeyCredential)"
+        return "isinstance({}, " + f"{self.policy.credential_name})"
 
     def imports(self, **kwargs: Any) -> FileImport:  # pylint: disable=unused-argument
         file_import = self.init_file_import()
         file_import.add_submodule_import(
-            "azure.core.credentials",
-            "AzureKeyCredential",
+            f"{file_import.import_core}.credentials",
+            self.policy.credential_name,
             ImportType.SDKCORE,
             typing_section=TypingSection.CONDITIONAL,
         )

packages/autorest.python/autorest/codegen/models/imports.py

@@ -87,7 +87,7 @@ def __init__(
         self.async_definition = async_definition
 
 
-class FileImport:
+class FileImport:  # pylint: disable=too-many-public-methods
     def __init__(self, code_model: "CodeModel") -> None:
         self.imports: List[ImportModel] = []
         self.code_model = code_model
@@ -331,8 +331,8 @@ def import_core_credentials(self) -> str:
 
     @property
     def import_core_credentials_async(self) -> str:
-        return (
-            self.import_core + ".credentials_async"
+        return self.import_core + (
+            ".credentials_async"
             if not self.code_model.options["unbranded"]
             else ".credentials"
         )
@@ -343,10 +343,8 @@ def import_core_paging(self) -> str:
 
     @property
     def import_core_paging_async(self) -> str:
-        return (
-            self.import_core + ".async_paging"
-            if not self.code_model.options["unbranded"]
-            else ".paging"
+        return self.import_core + (
+            ".async_paging" if not self.code_model.options["unbranded"] else ".paging"
         )
 
     @property
@@ -355,20 +353,30 @@ def import_core_utils(self) -> str:
 
     @property
     def import_core_case_insensitive_enum(self) -> str:
-        return (
-            self.import_core + ""
-            if not self.code_model.options["unbranded"]
-            else ".utils"
+        return self.import_core + (
+            "" if not self.code_model.options["unbranded"] else ".utils"
         )
 
     @property
     def import_core_pipeline(self) -> str:
-        return (
-            self.import_core + ".pipeline"
+        return self.import_core + (
+            ".pipeline"
             if not self.code_model.options["unbranded"]
-            else ".runtime"
+            else ".runtime.pipeline"
+        )
+
+    @property
+    def import_core_policies(self) -> str:
+        return self.import_core + (
+            ".pipeline" if not self.code_model.options["unbranded"] else ".runtime"
         )
 
     @property
     def import_core_serialization(self) -> str:
         return f"{self.import_core}.serialization"
+
+    @property
+    def import_core_pipeline_client(self) -> str:
+        return self.import_core + (
+            "" if not self.code_model.options["unbranded"] else ".runtime"
+        )

packages/autorest.python/autorest/codegen/models/lro_operation.py

@@ -126,7 +126,7 @@ def imports(self, async_mode: bool, **kwargs: Any) -> FileImport:
         file_import = super().imports(async_mode, **kwargs)
         if self.abstract:
             return file_import
-        if async_mode:
+        if async_mode and self.code_model.options["tracing"] and self.want_tracing:
             file_import.add_submodule_import(
                 "azure.core.tracing.decorator_async",
                 "distributed_trace_async",

packages/autorest.python/autorest/codegen/models/operation.py

@@ -560,7 +560,7 @@ def imports(self, async_mode: bool, **kwargs: Any) -> FileImport:
         file_import = super().imports(async_mode, **kwargs)
         if self.abstract:
             return file_import
-        if async_mode:
+        if async_mode and self.code_model.options["tracing"] and self.want_tracing:
             file_import.add_submodule_import(
                 "azure.core.tracing.decorator_async",
                 "distributed_trace_async",

packages/autorest.python/autorest/codegen/models/primitive_types.py

@@ -606,20 +606,24 @@ def instance_check_template(self) -> str:
         return "isinstance({}, bytes)"
 
 
-class AzureCoreType(PrimitiveType):
+class SdkCoreType(PrimitiveType):
     def __init__(self, yaml_data: Dict[str, Any], code_model: "CodeModel") -> None:
         super().__init__(yaml_data=yaml_data, code_model=code_model)
         self.name = yaml_data.get("name", "")
 
     def docstring_type(self, **kwargs: Any) -> str:
-        return "~azure.core." + self.type_annotation(**kwargs)
+        return f"~{self.init_file_import().import_core}" + self.type_annotation(
+            **kwargs
+        )
 
     def type_annotation(self, **kwargs: Any) -> str:
         return self.name
 
     def imports(self, **kwargs: Any) -> FileImport:
         file_import = self.init_file_import()
-        file_import.add_submodule_import("azure.core", self.name, ImportType.SDKCORE)
+        file_import.add_submodule_import(
+            file_import.import_core, self.name, ImportType.SDKCORE
+        )
         return file_import
 
     @property

packages/autorest.python/autorest/codegen/serializers/builder_serializer.py

@@ -426,6 +426,12 @@ def serialize_path(self, builder: BuilderType) -> List[str]:
             builder.parameters.path, self.serializer_name
         )
 
+    @property
+    def pipeline_name(self) -> str:
+        if not self.code_model.options["unbranded"]:
+            return "_pipeline"
+        return "pipeline"
+
 
 ############################## REQUEST BUILDERS ##############################
 
@@ -644,7 +650,7 @@ def make_pipeline_call(self, builder: OperationType) -> List[str]:
         )
         return [
             f"_stream = {stream_value}",
-            f"pipeline_response: PipelineResponse = {self._call_method}self._client._pipeline.run(  "
+            f"pipeline_response: PipelineResponse = {self._call_method}self._client.{self.pipeline_name}.run(  "
             + f"{'# type: ignore' if type_ignore else ''} # pylint: disable=protected-access",
             "    _request,",
             "    stream=_stream,",
@@ -1055,7 +1061,7 @@ def response_headers_and_deserialization(
                 "deserialized = {}".format(
                     "response.iter_bytes()"
                     if self.code_model.options["version_tolerant"]
-                    else "response.stream_download(self._client._pipeline)"
+                    else f"response.stream_download(self._client.{self.pipeline_name})"
                 )
             )
         elif response.type:

packages/autorest.python/autorest/codegen/serializers/client_serializer.py

@@ -111,8 +111,11 @@ def should_init_super(self) -> bool:
     def initialize_pipeline_client(self, async_mode: bool) -> List[str]:
         result = []
         pipeline_client_name = self.client.pipeline_class(async_mode)
+        endpoint_name = (
+            "endpoint" if self.client.code_model.options["unbranded"] else "base_url"
+        )
         params = {
-            "base_url": self.host_variable_name,
+            endpoint_name: self.host_variable_name,
             "policies": "_policies",
         }
         if not self.client.code_model.is_legacy and self.client.request_id_header_name:

packages/autorest.python/autorest/codegen/serializers/general_serializer.py

@@ -107,7 +107,7 @@ def serialize_vendor_file(self, clients: List[Client]) -> str:
                 ImportType.STDLIB,
             )
             file_import.add_submodule_import(
-                file_import.import_core,
+                file_import.import_core_pipeline_client,
                 f"{'Async' if self.async_mode else ''}PipelineClient",
                 ImportType.SDKCORE,
                 TypingSection.TYPING,