Removed Moq from tests & enabled .NET Core

DamianEdwards · DamianEdwards · commit 4ba159afe791 · 2015-05-20T14:41:52.000-07:00
- Introduced AssemblyWrapper to enable testing - Cleaned up properties on ResourceManagerStringLocalizer - #15 Change "Strategy" to "Provider" - #19
diff --git a/samples/LocalizationSample/Startup.cs b/samples/LocalizationSample/Startup.cs
@@ -36,9 +36,9 @@ public void Configure(IApplicationBuilder app, IStringLocalizer<Startup> SR)
                 //}
             };
 
-            // Optionally create an app-specific strategy with just a delegate, e.g. look up user preference from DB.
-            // Inserting it as position 0 ensures it has priority over any of the default strategies.
-            //options.RequestCultureStrategies.Insert(0, new CustomRequestCultureStrategy(async context =>
+            // Optionally create an app-specific provider with just a delegate, e.g. look up user preference from DB.
+            // Inserting it as position 0 ensures it has priority over any of the default providers.
+            //options.RequestCultureProviders.Insert(0, new CustomRequestCultureProvider(async context =>
             //{
                 
             //}));
@@ -74,13 +74,13 @@ await context.Response.WriteAsync(
         function useCookie() {{
             var culture = document.getElementById('culture');
             var uiCulture = document.getElementById('uiCulture');
-            var cookieValue = '{CookieRequestCultureStrategy.DefaultCookieName}=c='+culture.options[culture.selectedIndex].value+'|uic='+uiCulture.options[uiCulture.selectedIndex].value;
+            var cookieValue = '{CookieRequestCultureProvider.DefaultCookieName}=c='+culture.options[culture.selectedIndex].value+'|uic='+uiCulture.options[uiCulture.selectedIndex].value;
             document.cookie = cookieValue;
             window.location = window.location.href.split('?')[0];
         }}
 
         function clearCookie() {{
-            document.cookie='{CookieRequestCultureStrategy.DefaultCookieName}=""""';
+            document.cookie='{CookieRequestCultureProvider.DefaultCookieName}=""""';
         }}
     </script>
 </head>
@@ -101,7 +101,7 @@ function clearCookie() {{
                 await context.Response.WriteAsync("</form>");
                 await context.Response.WriteAsync("<br />");
                 await context.Response.WriteAsync("<table><tbody>");
-                await context.Response.WriteAsync($"<tr><th>Winning strategy:</th><td>{requestCultureFeature.Strategy.GetType().Name}</td></tr>");
+                await context.Response.WriteAsync($"<tr><th>Winning provider:</th><td>{requestCultureFeature.Provider.GetType().Name}</td></tr>");
                 await context.Response.WriteAsync($"<tr><th>{SR["Current request culture:"]}</th><td>{requestCulture.Culture.DisplayName} ({requestCulture.Culture})</td></tr>");
                 await context.Response.WriteAsync($"<tr><th>{SR["Current request UI culture:"]}</th><td>{requestCulture.UICulture.DisplayName} ({requestCulture.UICulture})</td></tr>");
                 await context.Response.WriteAsync($"<tr><th>{SR["Current thread culture:"]}</th><td>{CultureInfo.CurrentCulture.DisplayName} ({CultureInfo.CurrentCulture})</td></tr>");
diff --git a/src/Microsoft.AspNet.Localization/AcceptLanguageHeaderRequestCultureProvider.cs b/src/Microsoft.AspNet.Localization/AcceptLanguageHeaderRequestCultureProvider.cs
@@ -13,7 +13,7 @@ namespace Microsoft.AspNet.Localization
     /// <summary>
     /// Determines the culture information for a request via the value of the Accept-Language header.
     /// </summary>
-    public class AcceptLanguageHeaderRequestCultureStrategy : RequestCultureStrategy
+    public class AcceptLanguageHeaderRequestCultureProvider : RequestCultureProvider
     {
         /// <summary>
         /// The maximum number of values in the Accept-Language header to attempt to create a <see cref="System.Globalization.CultureInfo"/>
diff --git a/src/Microsoft.AspNet.Localization/CookieRequestCultureProvider.cs b/src/Microsoft.AspNet.Localization/CookieRequestCultureProvider.cs
@@ -12,7 +12,7 @@ namespace Microsoft.AspNet.Localization
     /// <summary>
     /// Determines the culture information for a request via the value of a cookie.
     /// </summary>
-    public class CookieRequestCultureStrategy : RequestCultureStrategy
+    public class CookieRequestCultureProvider : RequestCultureProvider
     {
         private static readonly char[] _cookieSeparator = new[] { '|' };
         private static readonly string _culturePrefix = "c=";
diff --git a/src/Microsoft.AspNet.Localization/CustomRequestCultureProvider.cs b/src/Microsoft.AspNet.Localization/CustomRequestCultureProvider.cs
@@ -11,23 +11,23 @@ namespace Microsoft.AspNet.Localization
     /// <summary>
     /// Determines the culture information for a request via the configured delegate.
     /// </summary>
-    public class CustomRequestCultureStrategy : RequestCultureStrategy
+    public class CustomRequestCultureProvider : RequestCultureProvider
     {
-        private readonly Func<HttpContext, Task<RequestCulture>> _strategy;
+        private readonly Func<HttpContext, Task<RequestCulture>> _provider;
 
         /// <summary>
-        /// Creates a new <see cref="CustomRequestCultureStrategy"/> using the specified delegate.
+        /// Creates a new <see cref="CustomRequestCultureProvider"/> using the specified delegate.
         /// </summary>
-        /// <param name="strategy">The strategy delegate.</param>
-        public CustomRequestCultureStrategy([NotNull] Func<HttpContext, Task<RequestCulture>> strategy)
+        /// <param name="provider">The provider delegate.</param>
+        public CustomRequestCultureProvider([NotNull] Func<HttpContext, Task<RequestCulture>> provider)
         {
-            _strategy = strategy;
+            _provider = provider;
         }
 
         /// <inheritdoc />
         public override Task<RequestCulture> DetermineRequestCulture([NotNull] HttpContext httpContext)
         {
-            return _strategy(httpContext);
+            return _provider(httpContext);
         }
     }
 }
diff --git a/src/Microsoft.AspNet.Localization/IRequestCultureFeature.cs b/src/Microsoft.AspNet.Localization/IRequestCultureFeature.cs
@@ -14,10 +14,10 @@ public interface IRequestCultureFeature
         RequestCulture RequestCulture { get; }
 
         /// <summary>
-        /// The <see cref="IRequestCultureStrategy"/> that determined the request's culture information.
-        /// If the value is <c>null</c> then no strategy was used and the request's culture was set to the value of
+        /// The <see cref="IRequestCultureProvider"/> that determined the request's culture information.
+        /// If the value is <c>null</c> then no provider was used and the request's culture was set to the value of
         /// <see cref="RequestLocalizationOptions.DefaultRequestCulture"/>.
         /// </summary>
-        IRequestCultureStrategy Strategy { get; }
+        IRequestCultureProvider Provider { get; }
     }
 }
diff --git a/src/Microsoft.AspNet.Localization/IRequestCultureProvider.cs b/src/Microsoft.AspNet.Localization/IRequestCultureProvider.cs
@@ -7,17 +7,17 @@
 namespace Microsoft.AspNet.Localization
 {
     /// <summary>
-    /// Represents a strategy for determining the culture information of an <see cref="HttpRequest"/>.
+    /// Represents a provider for determining the culture information of an <see cref="HttpRequest"/>.
     /// </summary>
-    public interface IRequestCultureStrategy
+    public interface IRequestCultureProvider
     {
         /// <summary>
-        /// Implements the strategy to determine the culture of the given request.
+        /// Implements the provider to determine the culture of the given request.
         /// </summary>
         /// <param name="httpContext">The <see cref="HttpContext"/> for the request.</param>
         /// <returns>
         ///     The determined <see cref="RequestCulture"/>.
-        ///     Returns <c>null</c> if the strategy couldn't determine a <see cref="RequestCulture"/>.
+        ///     Returns <c>null</c> if the provider couldn't determine a <see cref="RequestCulture"/>.
         /// </returns>
         Task<RequestCulture> DetermineRequestCulture(HttpContext httpContext);
     }
diff --git a/src/Microsoft.AspNet.Localization/QueryStringRequestCultureProvider.cs b/src/Microsoft.AspNet.Localization/QueryStringRequestCultureProvider.cs
@@ -11,7 +11,7 @@ namespace Microsoft.AspNet.Localization
     /// <summary>
     /// Determines the culture information for a request via values in the query string.
     /// </summary>
-    public class QueryStringRequestCultureStrategy : RequestCultureStrategy
+    public class QueryStringRequestCultureProvider : RequestCultureProvider
     {
         /// <summary>
         /// The key that contains the culture name.
diff --git a/src/Microsoft.AspNet.Localization/RequestCultureFeature.cs b/src/Microsoft.AspNet.Localization/RequestCultureFeature.cs
@@ -14,16 +14,16 @@ public class RequestCultureFeature : IRequestCultureFeature
         /// Creates a new <see cref="RequestCultureFeature"/> with the specified <see cref="Localization.RequestCulture"/>.
         /// </summary>
         /// <param name="requestCulture">The <see cref="Localization.RequestCulture"/>.</param>
-        public RequestCultureFeature([NotNull] RequestCulture requestCulture, IRequestCultureStrategy strategy)
+        public RequestCultureFeature([NotNull] RequestCulture requestCulture, IRequestCultureProvider provider)
         {
             RequestCulture = requestCulture;
-            Strategy = strategy;
+            Provider = provider;
         }
 
         /// <inheritdoc />
         public RequestCulture RequestCulture { get; }
 
         /// <inheritdoc />
-        public IRequestCultureStrategy Strategy { get; }
+        public IRequestCultureProvider Provider { get; }
     }
 }
diff --git a/src/Microsoft.AspNet.Localization/RequestCultureProvider.cs b/src/Microsoft.AspNet.Localization/RequestCultureProvider.cs
@@ -3,14 +3,13 @@
 
 using System.Threading.Tasks;
 using Microsoft.AspNet.Http;
-using Microsoft.Framework.Internal;
 
 namespace Microsoft.AspNet.Localization
 {
     /// <summary>
-    /// An abstract base class strategy for determining the culture information of an <see cref="HttpRequest"/>.
+    /// An abstract base class provider for determining the culture information of an <see cref="HttpRequest"/>.
     /// </summary>
-    public abstract class RequestCultureStrategy : IRequestCultureStrategy
+    public abstract class RequestCultureProvider : IRequestCultureProvider
     {
         /// <summary>
         /// The current options for the <see cref="RequestLocalizationMiddleware"/>.
diff --git a/src/Microsoft.AspNet.Localization/RequestLocalizationMiddleware.cs b/src/Microsoft.AspNet.Localization/RequestLocalizationMiddleware.cs
@@ -40,23 +40,23 @@ public async Task Invoke([NotNull] HttpContext context)
             var requestCulture = _options.DefaultRequestCulture ??
                 new RequestCulture(CultureInfo.CurrentCulture, CultureInfo.CurrentUICulture);
 
-            IRequestCultureStrategy winningStrategy = null;
+            IRequestCultureProvider winningProvider = null;
 
-            if (_options.RequestCultureStrategies != null)
+            if (_options.RequestCultureProviders != null)
             {
-                foreach (var strategy in _options.RequestCultureStrategies)
+                foreach (var provider in _options.RequestCultureProviders)
                 {
-                    var result = await strategy.DetermineRequestCulture(context);
+                    var result = await provider.DetermineRequestCulture(context);
                     if (result != null)
                     {
                         requestCulture = result;
-                        winningStrategy = strategy;
+                        winningProvider = provider;
                         break;
                     }
                 }
             }
 
-            context.SetFeature<IRequestCultureFeature>(new RequestCultureFeature(requestCulture, winningStrategy));
+            context.SetFeature<IRequestCultureFeature>(new RequestCultureFeature(requestCulture, winningProvider));
 
             SetCurrentThreadCulture(requestCulture);
 
diff --git a/src/Microsoft.AspNet.Localization/RequestLocalizationOptions.cs b/src/Microsoft.AspNet.Localization/RequestLocalizationOptions.cs
@@ -19,17 +19,17 @@ public RequestLocalizationOptions()
         {
             DefaultRequestCulture = new RequestCulture(CultureInfo.CurrentCulture, CultureInfo.CurrentUICulture);
 
-            RequestCultureStrategies = new List<IRequestCultureStrategy>
+            RequestCultureProviders = new List<IRequestCultureProvider>
             {
-                new QueryStringRequestCultureStrategy { Options = this },
-                new CookieRequestCultureStrategy { Options = this },
-                new AcceptLanguageHeaderRequestCultureStrategy { Options = this }
+                new QueryStringRequestCultureProvider { Options = this },
+                new CookieRequestCultureProvider { Options = this },
+                new AcceptLanguageHeaderRequestCultureProvider { Options = this }
             };
         }
 
         /// <summary>
         /// The default <see cref="RequestCulture"/> to use. This value will be used if none of the configured
-        /// <see cref="IRequestCultureStrategy"/> options result in a non-<c>null</c> result.
+        /// <see cref="IRequestCultureProvider"/> options result in a non-<c>null</c> result.
         /// Defaults to <see cref="RequestCulture.Culture"/> set to <see cref="CultureInfo.DefaultThreadCurrentCulture"/>
         /// and <see cref="RequestCulture.UICulture"/> set to <see cref="CultureInfo.DefaultThreadCurrentUICulture"/>.
         /// </summary>
@@ -54,16 +54,16 @@ public RequestLocalizationOptions()
         public IList<CultureInfo> SupportedUICultures { get; set; }
 
         /// <summary>
-        /// An ordered list of strategies used to determine a request's culture information. The first strategy that
+        /// An ordered list of providers used to determine a request's culture information. The first provider that
         /// returns a non-<c>null</c> result for a given request will be used.
         /// Defaults to the following:
         /// <list type="number">
-        ///     <item><description><see cref="QueryStringRequestCultureStrategy"/></description></item>
-        ///     <item><description><see cref="CookieRequestCultureStrategy"/></description></item>
-        ///     <item><description><see cref="AcceptLanguageHeaderRequestCultureStrategy"/></description></item>
+        ///     <item><description><see cref="QueryStringRequestCultureProvider"/></description></item>
+        ///     <item><description><see cref="CookieRequestCultureProvider"/></description></item>
+        ///     <item><description><see cref="AcceptLanguageHeaderRequestCultureProvider"/></description></item>
         /// </list>
         /// </summary>
         [SuppressMessage("Microsoft.Usage", "CA2227:CollectionPropertiesShouldBeReadOnly", Justification = "Improves usability")]
-        public IList<IRequestCultureStrategy> RequestCultureStrategies { get; set; }
+        public IList<IRequestCultureProvider> RequestCultureProviders { get; set; }
     }
 }
diff --git a/src/Microsoft.Framework.Localization/Internal/AssemblyWrapper.cs b/src/Microsoft.Framework.Localization/Internal/AssemblyWrapper.cs
@@ -0,0 +1,23 @@
+﻿// Copyright (c) .NET Foundation. All rights reserved. 
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System.IO;
+using System.Reflection;
+using Microsoft.Framework.Internal;
+
+namespace Microsoft.Framework.Localization.Internal
+{
+    public class AssemblyWrapper
+    {
+        public AssemblyWrapper([NotNull] Assembly assembly)
+        {
+            Assembly = assembly;
+        }
+
+        public Assembly Assembly { get; }
+
+        public virtual string FullName => Assembly.FullName;
+
+        public virtual Stream GetManifestResourceStream(string name) => Assembly.GetManifestResourceStream(name);
+    }
+}
diff --git a/src/Microsoft.Framework.Localization/ResourceManagerStringLocalizer.cs b/src/Microsoft.Framework.Localization/ResourceManagerStringLocalizer.cs
diff --git a/src/Microsoft.Framework.Localization/ResourceManagerStringLocalizerFactory.cs b/src/Microsoft.Framework.Localization/ResourceManagerStringLocalizerFactory.cs
diff --git a/src/Microsoft.Framework.Localization/ResourceManagerWithCultureStringLocalizer.cs b/src/Microsoft.Framework.Localization/ResourceManagerWithCultureStringLocalizer.cs
diff --git a/test/Microsoft.Framework.Localization.Test/ResourceManagerStringLocalizerTest.cs b/test/Microsoft.Framework.Localization.Test/ResourceManagerStringLocalizerTest.cs
diff --git a/test/Microsoft.Framework.Localization.Test/project.json b/test/Microsoft.Framework.Localization.Test/project.json

Original file line number	Diff line number	Diff line change
`@@ -13,7 +13,7 @@ namespace Microsoft.AspNet.Localization`
`13`	`13`	`/// <summary>`
`14`	`14`	`/// Determines the culture information for a request via the value of the Accept-Language header.`
`15`	`15`	`/// </summary>`
`16`		`- public class AcceptLanguageHeaderRequestCultureStrategy : RequestCultureStrategy`
	`16`	`+ public class AcceptLanguageHeaderRequestCultureProvider : RequestCultureProvider`
`17`	`17`	`{`
`18`	`18`	`/// <summary>`
`19`	`19`	`/// The maximum number of values in the Accept-Language header to attempt to create a <see cref="System.Globalization.CultureInfo"/>`
Original file line number	Diff line number	Diff line change
`@@ -12,7 +12,7 @@ namespace Microsoft.AspNet.Localization`
`12`	`12`	`/// <summary>`
`13`	`13`	`/// Determines the culture information for a request via the value of a cookie.`
`14`	`14`	`/// </summary>`
`15`		`- public class CookieRequestCultureStrategy : RequestCultureStrategy`
	`15`	`+ public class CookieRequestCultureProvider : RequestCultureProvider`
`16`	`16`	`{`
`17`	`17`	`private static readonly char[] _cookieSeparator = new[] { '\|' };`
`18`	`18`	`private static readonly string _culturePrefix = "c=";`
Original file line number	Diff line number	Diff line change
`@@ -11,23 +11,23 @@ namespace Microsoft.AspNet.Localization`
`11`	`11`	`/// <summary>`
`12`	`12`	`/// Determines the culture information for a request via the configured delegate.`
`13`	`13`	`/// </summary>`
`14`		`- public class CustomRequestCultureStrategy : RequestCultureStrategy`
	`14`	`+ public class CustomRequestCultureProvider : RequestCultureProvider`
`15`	`15`	`{`
`16`		`- private readonly Func<HttpContext, Task<RequestCulture>> _strategy;`
	`16`	`+ private readonly Func<HttpContext, Task<RequestCulture>> _provider;`
`17`	`17`
`18`	`18`	`/// <summary>`
`19`		`- /// Creates a new <see cref="CustomRequestCultureStrategy"/> using the specified delegate.`
	`19`	`+ /// Creates a new <see cref="CustomRequestCultureProvider"/> using the specified delegate.`
`20`	`20`	`/// </summary>`
`21`		`- /// <param name="strategy">The strategy delegate.</param>`
`22`		`- public CustomRequestCultureStrategy([NotNull] Func<HttpContext, Task<RequestCulture>> strategy)`
	`21`	`+ /// <param name="provider">The provider delegate.</param>`
	`22`	`+ public CustomRequestCultureProvider([NotNull] Func<HttpContext, Task<RequestCulture>> provider)`
`23`	`23`	`{`
`24`		`- _strategy = strategy;`
	`24`	`+ _provider = provider;`
`25`	`25`	`}`
`26`	`26`
`27`	`27`	`/// <inheritdoc />`
`28`	`28`	`public override Task<RequestCulture> DetermineRequestCulture([NotNull] HttpContext httpContext)`
`29`	`29`	`{`
`30`		`- return _strategy(httpContext);`
	`30`	`+ return _provider(httpContext);`
`31`	`31`	`}`
`32`	`32`	`}`
`33`	`33`	`}`
Original file line number	Diff line number	Diff line change
`@@ -14,10 +14,10 @@ public interface IRequestCultureFeature`
`14`	`14`	`RequestCulture RequestCulture { get; }`
`15`	`15`
`16`	`16`	`/// <summary>`
`17`		`- /// The <see cref="IRequestCultureStrategy"/> that determined the request's culture information.`
`18`		`- /// If the value is <c>null</c> then no strategy was used and the request's culture was set to the value of`
	`17`	`+ /// The <see cref="IRequestCultureProvider"/> that determined the request's culture information.`
	`18`	`+ /// If the value is <c>null</c> then no provider was used and the request's culture was set to the value of`
`19`	`19`	`/// <see cref="RequestLocalizationOptions.DefaultRequestCulture"/>.`
`20`	`20`	`/// </summary>`
`21`		`- IRequestCultureStrategy Strategy { get; }`
	`21`	`+ IRequestCultureProvider Provider { get; }`
`22`	`22`	`}`
`23`	`23`	`}`
Original file line number	Diff line number	Diff line change
`@@ -11,7 +11,7 @@ namespace Microsoft.AspNet.Localization`
`11`	`11`	`/// <summary>`
`12`	`12`	`/// Determines the culture information for a request via values in the query string.`
`13`	`13`	`/// </summary>`
`14`		`- public class QueryStringRequestCultureStrategy : RequestCultureStrategy`
	`14`	`+ public class QueryStringRequestCultureProvider : RequestCultureProvider`
`15`	`15`	`{`
`16`	`16`	`/// <summary>`
`17`	`17`	`/// The key that contains the culture name.`
Original file line number	Diff line number	Diff line change
`@@ -14,16 +14,16 @@ public class RequestCultureFeature : IRequestCultureFeature`
`14`	`14`	`/// Creates a new <see cref="RequestCultureFeature"/> with the specified <see cref="Localization.RequestCulture"/>.`
`15`	`15`	`/// </summary>`
`16`	`16`	`/// <param name="requestCulture">The <see cref="Localization.RequestCulture"/>.</param>`
`17`		`- public RequestCultureFeature([NotNull] RequestCulture requestCulture, IRequestCultureStrategy strategy)`
	`17`	`+ public RequestCultureFeature([NotNull] RequestCulture requestCulture, IRequestCultureProvider provider)`
`18`	`18`	`{`
`19`	`19`	`RequestCulture = requestCulture;`
`20`		`- Strategy = strategy;`
	`20`	`+ Provider = provider;`
`21`	`21`	`}`
`22`	`22`
`23`	`23`	`/// <inheritdoc />`
`24`	`24`	`public RequestCulture RequestCulture { get; }`
`25`	`25`
`26`	`26`	`/// <inheritdoc />`
`27`		`- public IRequestCultureStrategy Strategy { get; }`
	`27`	`+ public IRequestCultureProvider Provider { get; }`
`28`	`28`	`}`
`29`	`29`	`}`
Original file line number	Diff line number	Diff line change
`@@ -40,23 +40,23 @@ public async Task Invoke([NotNull] HttpContext context)`
`40`	`40`	`var requestCulture = _options.DefaultRequestCulture ??`
`41`	`41`	`new RequestCulture(CultureInfo.CurrentCulture, CultureInfo.CurrentUICulture);`
`42`	`42`
`43`		`- IRequestCultureStrategy winningStrategy = null;`
	`43`	`+ IRequestCultureProvider winningProvider = null;`
`44`	`44`
`45`		`- if (_options.RequestCultureStrategies != null)`
	`45`	`+ if (_options.RequestCultureProviders != null)`
`46`	`46`	`{`
`47`		`- foreach (var strategy in _options.RequestCultureStrategies)`
	`47`	`+ foreach (var provider in _options.RequestCultureProviders)`
`48`	`48`	`{`
`49`		`- var result = await strategy.DetermineRequestCulture(context);`
	`49`	`+ var result = await provider.DetermineRequestCulture(context);`
`50`	`50`	`if (result != null)`
`51`	`51`	`{`
`52`	`52`	`requestCulture = result;`
`53`		`- winningStrategy = strategy;`
	`53`	`+ winningProvider = provider;`
`54`	`54`	`break;`
`55`	`55`	`}`
`56`	`56`	`}`
`57`	`57`	`}`
`58`	`58`
`59`		`- context.SetFeature<IRequestCultureFeature>(new RequestCultureFeature(requestCulture, winningStrategy));`
	`59`	`+ context.SetFeature<IRequestCultureFeature>(new RequestCultureFeature(requestCulture, winningProvider));`
`60`	`60`
`61`	`61`	`SetCurrentThreadCulture(requestCulture);`
`62`	`62`