< Summary

Class:Azure.Search.Documents.SearchExtensions
Assembly:Azure.Search.Documents
File(s):C:\Git\azure-sdk-for-net\sdk\search\Azure.Search.Documents\src\SearchClientOptions.cs
C:\Git\azure-sdk-for-net\sdk\search\Azure.Search.Documents\src\Utilities\GeneratorTweaks.cs
C:\Git\azure-sdk-for-net\sdk\search\Azure.Search.Documents\src\Utilities\SearchExtensions.cs
Covered lines:42
Uncovered lines:14
Coverable lines:56
Total lines:413
Line coverage:75% (42 of 56)
Covered branches:14
Total branches:18
Branch coverage:77.7% (14 of 18)

Metrics

MethodCyclomatic complexity Line coverage Branch coverage
Validate(...)-80%50%
ToVersionString(...)-80%50%
CreateInvalidVersionException(...)-0%100%
ToSerialString(...)-100%100%
ToAutocompleteMode(...)-0%100%
ToSerialString(...)-100%100%
ToSearchMode(...)-0%100%
ToSerialString(...)-100%100%
ToSearchQueryType(...)-0%100%
AssertHttpsScheme(...)-100%100%
GetSearchServiceName(...)-100%50%
CommaJoin(...)-100%100%
CommaSplit(...)-100%100%
CopyToAsync()-73.68%75%
CopyToMemoryStreamAsync()-100%100%

File(s)

C:\Git\azure-sdk-for-net\sdk\search\Azure.Search.Documents\src\SearchClientOptions.cs

#LineLine coverage
 1// Copyright (c) Microsoft Corporation. All rights reserved.
 2// Licensed under the MIT License.
 3
 4using System;
 5using System.Diagnostics;
 6using Azure.Core;
 7using Azure.Core.Pipeline;
 8#if EXPERIMENTAL_SERIALIZER
 9using Azure.Core.Serialization;
 10#endif
 11
 12#pragma warning disable SA1402 // File may only contain a single type
 13
 14namespace Azure.Search.Documents
 15{
 16    /// <summary>
 17    /// Provides the client configuration options for connecting to Azure
 18    /// Cognitive Search.
 19    /// </summary>
 20    public class SearchClientOptions : ClientOptions
 21    {
 22        /// <summary>
 23        /// The versions of Azure Cognitive Search supported by this client
 24        /// library.  For more, see
 25        /// <see href="https://docs.microsoft.com/azure/search/search-api-versions" />.
 26        /// </summary>
 27        public enum ServiceVersion
 28        {
 29            #pragma warning disable CA1707 // Identifiers should not contain underscores
 30            /// <summary>
 31            /// The 2020_06_30 version of the Azure Cognitive Search
 32            /// service.
 33            /// </summary>
 34            V2020_06_30 = 1
 35            #pragma warning restore CA1707
 36        }
 37
 38        /// <summary>
 39        /// The Latest service version supported by this client library.
 40        /// </summary>
 41        internal const ServiceVersion LatestVersion = ServiceVersion.V2020_06_30;
 42
 43        /// <summary>
 44        /// The service version to use when creating continuation tokens that
 45        /// can be passed between different client libraries.  Changing this
 46        /// value requires updating <see cref="Azure.Search.Documents.Models.SearchContinuationToken"/>.
 47        /// </summary>
 48        internal const ServiceVersion ContinuationTokenVersion = ServiceVersion.V2020_06_30;
 49
 50        /// <summary>
 51        /// Gets the <see cref="ServiceVersion"/> of the service API used when
 52        /// making requests.  For more, see
 53        /// <see href="https://docs.microsoft.com/azure/search/search-api-versions" />.
 54        /// </summary>
 55        public ServiceVersion Version { get; }
 56
 57#if EXPERIMENTAL_SERIALIZER
 58        /// <summary>
 59        /// Gets or sets an <see cref="ObjectSerializer"/> that can be used to
 60        /// customize the serialization of strongly typed models.  The
 61        /// serializer needs to support JSON and <see cref="JsonObjectSerializer"/>
 62        /// will be used if no value is provided.
 63        /// </summary>
 64        public ObjectSerializer Serializer { get; set; }
 65#endif
 66
 67        /// <summary>
 68        /// Initializes a new instance of the <see cref="SearchClientOptions"/>
 69        /// class.
 70        /// </summary>
 71        /// <param name="version">
 72        /// An optional <see cref="ServiceVersion"/> to specify the version of
 73        /// the REST API to use.  For more, see
 74        /// <see href="https://docs.microsoft.com/azure/search/search-api-versions" />.
 75        ///
 76        /// If not provided, the <paramref name="version"/> will default to the
 77        /// latest supported by this client library.  It is recommended that
 78        /// application authors allow the version to float to the latest and
 79        /// library authors pin to a specific version.
 80        /// </param>
 81        /// <exception cref="ArgumentOutOfRangeException">
 82        /// Thrown when the <paramref name="version"/> is not supported by this
 83        /// client library.
 84        /// </exception>
 85        public SearchClientOptions(ServiceVersion version = LatestVersion)
 86        {
 87            Version = version.Validate();
 88            AddLoggingHeaders();
 89            AddLoggingQueryParameters();
 90        }
 91
 92        /// <summary>
 93        /// Create an <see cref="HttpPipeline"/> to send requests to the Search
 94        /// Service.
 95        /// </summary>
 96        /// <param name="credential">
 97        /// The <see cref="AzureKeyCredential"/> to authenticate requests.
 98        /// </param>
 99        /// <returns>An <see cref="HttpPipeline"/> to send requests.</returns>
 100        internal HttpPipeline Build(AzureKeyCredential credential)
 101        {
 102            Debug.Assert(credential != null);
 103            return HttpPipelineBuilder.Build(
 104                options: this,
 105                perCallPolicies: new[] { new AzureKeyCredentialPolicy(credential, Constants.ApiKeyHeaderName) },
 106                perRetryPolicies: Array.Empty<HttpPipelinePolicy>(),
 107                responseClassifier: null);
 108        }
 109
 110        /// <summary>
 111        /// Add the allow list headers to the <see cref="DiagnosticsOptions"/>
 112        /// that are considered safe for logging/exceptions by default.
 113        /// </summary>
 114        private void AddLoggingHeaders()
 115        {
 116            Diagnostics.LoggedHeaderNames.Add("Access-Control-Allow-Credentials");
 117            Diagnostics.LoggedHeaderNames.Add("Access-Control-Allow-Headers");
 118            Diagnostics.LoggedHeaderNames.Add("Access-Control-Allow-Methods");
 119            Diagnostics.LoggedHeaderNames.Add("Access-Control-Allow-Origin");
 120            Diagnostics.LoggedHeaderNames.Add("Access-Control-Expose-Headers");
 121            Diagnostics.LoggedHeaderNames.Add("Access-Control-Max-Age");
 122            Diagnostics.LoggedHeaderNames.Add("Access-Control-Request-Headers");
 123            Diagnostics.LoggedHeaderNames.Add("Access-Control-Request-Method");
 124            Diagnostics.LoggedHeaderNames.Add("client-request-id");
 125            Diagnostics.LoggedHeaderNames.Add("elapsed-time");
 126            Diagnostics.LoggedHeaderNames.Add("Location");
 127            Diagnostics.LoggedHeaderNames.Add("OData-MaxVersion");
 128            Diagnostics.LoggedHeaderNames.Add("OData-Version");
 129            Diagnostics.LoggedHeaderNames.Add("Origin");
 130            Diagnostics.LoggedHeaderNames.Add("Prefer");
 131            Diagnostics.LoggedHeaderNames.Add("request-id");
 132            Diagnostics.LoggedHeaderNames.Add("return-client-request-id");
 133            Diagnostics.LoggedHeaderNames.Add("throttle-reason");
 134        }
 135
 136        /// <summary>
 137        /// Add the allow list query parameters to the
 138        /// <see cref="DiagnosticsOptions"/> that  are considered safe for
 139        /// logging/exceptions by default.
 140        /// </summary>
 141        private void AddLoggingQueryParameters()
 142        {
 143            Diagnostics.LoggedQueryParameters.Add("api-version");
 144            Diagnostics.LoggedQueryParameters.Add("allowIndexDowntime");
 145        }
 146    }
 147
 148    /// <summary>
 149    /// Search extension methods.
 150    /// </summary>
 151    internal static partial class SearchExtensions
 152    {
 153        /// <summary>
 154        /// Validate a <see cref="SearchClientOptions.ServiceVersion"/>.
 155        /// </summary>
 156        /// <param name="version">
 157        /// The <see cref="SearchClientOptions.ServiceVersion"/> to validate.
 158        /// </param>
 159        /// <returns>
 160        /// The validated version.
 161        /// </returns>
 162        /// <exception cref="ArgumentOutOfRangeException">
 163        /// Thrown when the <paramref name="version"/> is not supported by this
 164        /// client library.
 165        /// </exception>
 166        public static SearchClientOptions.ServiceVersion Validate(this SearchClientOptions.ServiceVersion version) =>
 313167            version switch
 313168            {
 626169                SearchClientOptions.ServiceVersion.V2020_06_30 => version,
 0170                _ => throw CreateInvalidVersionException(version)
 313171            };
 172
 173        /// <summary>
 174        /// Get a version string, like "2019-05-06", corresponding to a given
 175        /// <see cref="SearchClientOptions.ServiceVersion"/> value.
 176        /// </summary>
 177        /// <param name="version">
 178        /// The <see cref="SearchClientOptions.ServiceVersion"/> value to
 179        /// convert into a version string.
 180        /// </param>
 181        /// <returns>
 182        /// The version string.
 183        /// </returns>
 184        /// <exception cref="ArgumentOutOfRangeException">
 185        /// Thrown when the <paramref name="version"/> is not supported by this
 186        /// client library.
 187        /// </exception>
 188        public static string ToVersionString(this SearchClientOptions.ServiceVersion version) =>
 432189            version switch
 432190            {
 864191                SearchClientOptions.ServiceVersion.V2020_06_30 => "2020-06-30",
 0192                _ => throw CreateInvalidVersionException(version)
 432193            };
 194
 195        /// <summary>
 196        /// Create an <see cref="ArgumentOutOfRangeException"/> to throw when
 197        /// an invalid <see cref="SearchClientOptions.ServiceVersion"/> value
 198        /// is provided.
 199        /// </summary>
 200        /// <param name="version">The invalid version value.</param>
 201        /// <returns>An exception to throw.</returns>
 202        private static ArgumentOutOfRangeException CreateInvalidVersionException(SearchClientOptions.ServiceVersion vers
 0203            new ArgumentOutOfRangeException(
 0204                nameof(version),
 0205                version,
 0206                $"The {nameof(SearchClientOptions)}.{nameof(SearchClientOptions.ServiceVersion)} specified is not suppor
 207    }
 208}

C:\Git\azure-sdk-for-net\sdk\search\Azure.Search.Documents\src\Utilities\GeneratorTweaks.cs

#LineLine coverage
 1// Copyright (c) Microsoft Corporation. All rights reserved.
 2// Licensed under the MIT License.
 3
 4using Azure.Core;
 5using Azure.Search.Documents.Models;
 6
 7#pragma warning disable SA1402 // File may only contain a single type
 8
 9namespace Azure.Search.Documents
 10{
 11    // Hide the unused ServiceClient class.
 12    internal partial class ServiceClient { }
 13
 14    // Hide the unused DataSourcesClient class.
 15    internal partial class DataSourcesClient { }
 16
 17    // Hide the unused DocumentsClient class.
 18    internal partial class DocumentsClient { }
 19
 20    // Hide the unused IndexersClient class.
 21    internal partial class IndexersClient { }
 22
 23    // Hide the unused IndexesClient class.
 24    internal partial class IndexesClient { }
 25
 26    // Hide the unused SkillsetsClient class.
 27    internal partial class SkillsetsClient { }
 28
 29    // Hide the unused SynonymMapsClient class.
 30    internal partial class SynonymMapsClient { }
 31
 32    // https://github.com/Azure/autorest.csharp/issues/486
 33    // Work-around the generator not enjoying mixing model types between the
 34    // main and .Models namespaces.
 35    internal static partial class SearchExtensions
 36    {
 37        public static string ToSerialString(this AutocompleteMode value) =>
 3238            AutocompleteModeExtensions.ToSerialString(value);
 39
 40        public static AutocompleteMode ToAutocompleteMode(this string value) =>
 041            AutocompleteModeExtensions.ToAutocompleteMode(value);
 42
 43        public static string ToSerialString(this SearchMode value) =>
 244            SearchModeExtensions.ToSerialString(value);
 45
 46        public static SearchMode ToSearchMode(this string value) =>
 047            SearchModeExtensions.ToSearchMode(value);
 48
 49        public static string ToSerialString(this SearchQueryType value) =>
 1050            SearchQueryTypeExtensions.ToSerialString(value);
 51
 52        public static SearchQueryType ToSearchQueryType(this string value) =>
 053            SearchQueryTypeExtensions.ToSearchQueryType(value);
 54    }
 55}

C:\Git\azure-sdk-for-net\sdk\search\Azure.Search.Documents\src\Utilities\SearchExtensions.cs

#LineLine coverage
 1// Copyright (c) Microsoft Corporation. All rights reserved.
 2// Licensed under the MIT License.
 3
 4using System;
 5using System.Buffers;
 6using System.Collections.Generic;
 7using System.Diagnostics;
 8using System.IO;
 9using System.Linq;
 10using System.Threading;
 11using System.Threading.Tasks;
 12using Azure.Core;
 13
 14namespace Azure.Search.Documents
 15{
 16    /// <summary>
 17    /// Search extension methods.
 18    /// </summary>
 19    internal static partial class SearchExtensions
 20    {
 21        /// <summary>
 22        /// Assert that the given URI uses HTTPS as its scheme.
 23        /// </summary>
 24        /// <param name="endpoint">The URI to validate.</param>
 25        /// <param name="paramName">
 26        /// The name of the parameter for this URI, to use with an
 27        /// <see cref="ArgumentException"/>.
 28        /// </param>
 29        /// <exception cref="ArgumentException">
 30        /// Thrown when the <paramref name="endpoint"/> is not using HTTPS as
 31        /// its scheme.
 32        /// </exception>
 33        public static void AssertHttpsScheme(this Uri endpoint, string paramName)
 34        {
 35            Debug.Assert(endpoint != null);
 32636            if (!string.Equals(endpoint.Scheme, Uri.UriSchemeHttps, StringComparison.OrdinalIgnoreCase))
 37            {
 638                throw new ArgumentException($"{paramName} only supports {Uri.UriSchemeHttps}.", paramName);
 39            }
 32040        }
 41
 42        /// <summary>
 43        /// Get the name of the Search Service from its
 44        /// <paramref name="endpoint"/>.
 45        /// </summary>
 46        /// <param name="endpoint">The endpoint of the Search Service.</param>
 47        /// <returns>The name of the Search Service.</returns>
 48        public static string GetSearchServiceName(this Uri endpoint)
 49        {
 50            Debug.Assert(endpoint != null);
 851            string host = endpoint.Host;
 852            int separator = host.IndexOf('.');
 853            return (separator > 0) ?
 854                host.Substring(0, separator) :
 855                null;
 56        }
 57
 58        /// <summary>
 59        /// Join a collection of strings into a single comma separated string.
 60        /// If the collection is null or empty, a null string will be returned.
 61        /// </summary>
 62        /// <param name="items">The items to join.</param>
 63        /// <returns>The items joined together by commas.</returns>
 64        public static string CommaJoin(this IEnumerable<string> items) =>
 76565            items != null && items.Count() > 0 ? string.Join(",", items) : null;
 66
 67        /// <summary>
 68        /// Split a collection of strings by commas.
 69        /// </summary>
 70        /// <param name="value">The value to split.</param>
 71        /// <returns>A collection of individual values.</returns>
 72        public static IList<string> CommaSplit(string value) =>
 16873            string.IsNullOrEmpty(value) ?
 16874                new List<string>() :
 16875                // TODO: #10600 - Verify we don't need to worry about escaping
 16876                new List<string>(value.Split(','));
 77
 78        /// <summary>
 79        /// Copy from a source stream to a destination either synchronously or
 80        /// asynchronously.
 81        /// </summary>
 82        /// <param name="source">The stream to read from.</param>
 83        /// <param name="destination">The stream to write to.</param>
 84        /// <param name="async">Whether to execute sync or async.</param>
 85        /// <param name="cancellationToken">
 86        /// Optional <see cref="CancellationToken"/> to propagate notifications
 87        /// that the operation should be canceled.
 88        /// </param>
 89        /// <returns>A Task representing the computation.</returns>
 90        public static async Task CopyToAsync(
 91            this Stream source,
 92            Stream destination,
 93            bool async,
 94            CancellationToken cancellationToken)
 95        {
 2696            Argument.AssertNotNull(source, nameof(source));
 2697            Argument.AssertNotNull(destination, nameof(destination));
 98
 2699            if (async)
 100            {
 0101                await source.CopyToAsync(
 0102                    destination,
 0103                    Constants.CopyBufferSize,
 0104                    cancellationToken)
 0105                    .ConfigureAwait(false);
 106            }
 107            else
 108            {
 109                // This is not using CopyTo so we can honor cancellations
 26110                byte[] buffer = ArrayPool<byte>.Shared.Rent(Constants.CopyBufferSize);
 111                try
 112                {
 26113                    while (true)
 114                    {
 52115                        cancellationToken.ThrowIfCancellationRequested();
 52116                        int read = source.Read(buffer, 0, buffer.Length);
 52117                        if (read <= 0) { break; }
 26118                        cancellationToken.ThrowIfCancellationRequested();
 26119                        destination.Write(buffer, 0, read);
 120                    }
 26121                }
 122                finally
 123                {
 26124                    destination.Flush();
 26125                    ArrayPool<byte>.Shared.Return(buffer, true);
 126                }
 127            }
 26128        }
 129
 130        /// <summary>
 131        /// Copy a Stream into memory.
 132        /// </summary>
 133        /// <param name="source">The stream to read.</param>
 134        /// <param name="async">Whether to execute sync or async.</param>
 135        /// <param name="cancellationToken">
 136        /// Optional <see cref="CancellationToken"/> to propagate notifications
 137        /// that the operation should be canceled.
 138        /// </param>
 139        /// <returns>The source stream as a MemoryStream.</returns>
 140        public static async Task<MemoryStream> CopyToMemoryStreamAsync(
 141            this Stream source,
 142            bool async,
 143            CancellationToken cancellationToken)
 144        {
 26145            MemoryStream destination = new MemoryStream();
 26146            await source.CopyToAsync(destination, async, cancellationToken).ConfigureAwait(false);
 26147            return destination;
 26148        }
 149    }
 150}
Generated by: ReportGenerator 4.6.4.0
8/12/2020 - 3:46:52 PM
GitHub | www.palmmedia.de

Methods/Properties

Validate(...)
ToVersionString(...)
CreateInvalidVersionException(...)
ToSerialString(...)
ToAutocompleteMode(...)
ToSerialString(...)
ToSearchMode(...)
ToSerialString(...)
ToSearchQueryType(...)
AssertHttpsScheme(...)
GetSearchServiceName(...)
CommaJoin(...)
CommaSplit(...)
CopyToAsync()
CopyToMemoryStreamAsync()