Change Fault to Outcome in class and file names

Polly-Contrib · Nov 30, 2019 · 7741373 · 7741373
1 parent 446fc57
commit 7741373
Show file tree

Hide file tree

Showing 10 changed files with 34 additions and 34 deletions.
diff --git a/...Outcomes/AsyncInjectFaultOptionsSyntax.cs → ...tcomes/AsyncInjectOutcomeOptionsSyntax.cs b/...Outcomes/AsyncInjectFaultOptionsSyntax.cs → ...tcomes/AsyncInjectOutcomeOptionsSyntax.cs
@@ -14,9 +14,9 @@ public partial class MonkeyPolicy
         /// </summary>
         /// <param name="configureOptions">A callback to configure policy options.</param>
         /// <returns>The policy instance.</returns>
-        public static AsyncInjectOutcomePolicy InjectExceptionAsync(Action<InjectFaultAsyncOptions<Exception>> configureOptions)
+        public static AsyncInjectOutcomePolicy InjectExceptionAsync(Action<InjectOutcomeAsyncOptions<Exception>> configureOptions)
         {
-            var options = new InjectFaultAsyncOptions<Exception>();
+            var options = new InjectOutcomeAsyncOptions<Exception>();
             configureOptions(options);
 
             if (options.Outcome == null) throw new ArgumentNullException(nameof(options.Outcome));
@@ -32,9 +32,9 @@ public static AsyncInjectOutcomePolicy InjectExceptionAsync(Action<InjectFaultAs
         /// </summary>
         /// <param name="configureOptions">A callback to configure policy options.</param>
         /// <returns>The policy instance.</returns>
-        public static AsyncInjectOutcomePolicy<TResult> InjectResultAsync<TResult>(Action<InjectFaultAsyncOptions<TResult>> configureOptions)
+        public static AsyncInjectOutcomePolicy<TResult> InjectResultAsync<TResult>(Action<InjectOutcomeAsyncOptions<TResult>> configureOptions)
         {
-            var options = new InjectFaultAsyncOptions<TResult>();
+            var options = new InjectOutcomeAsyncOptions<TResult>();
             configureOptions(options);
 
             if (options.Outcome == null) throw new ArgumentNullException(nameof(options.Outcome));
@@ -50,9 +50,9 @@ public static AsyncInjectOutcomePolicy<TResult> InjectResultAsync<TResult>(Actio
         /// </summary>
         /// <param name="configureOptions">A callback to configure policy options.</param>
         /// <returns>The policy instance.</returns>
-        public static AsyncInjectOutcomePolicy<TResult> InjectResultAsync<TResult>(Action<InjectFaultAsyncOptions<Exception>> configureOptions)
+        public static AsyncInjectOutcomePolicy<TResult> InjectResultAsync<TResult>(Action<InjectOutcomeAsyncOptions<Exception>> configureOptions)
         {
-            var options = new InjectFaultAsyncOptions<Exception>();
+            var options = new InjectOutcomeAsyncOptions<Exception>();
             configureOptions(options);
 
             if (options.Outcome == null) throw new ArgumentNullException(nameof(options.Outcome));

diff --git a/src/Polly.Contrib.Simmy/Outcomes/AsyncInjectOutcomePolicy.cs b/src/Polly.Contrib.Simmy/Outcomes/AsyncInjectOutcomePolicy.cs
@@ -19,7 +19,7 @@ internal AsyncInjectOutcomePolicy(Func<Context, CancellationToken, Task<Exceptio
             _faultProvider = faultProvider ?? throw new ArgumentNullException(nameof(faultProvider));
         }
 
-        internal AsyncInjectOutcomePolicy(InjectFaultAsyncOptions<Exception> options)
+        internal AsyncInjectOutcomePolicy(InjectOutcomeAsyncOptions<Exception> options)
             : base(options.InjectionRate, options.Enabled)
         {
             _faultProvider = options.Outcome ?? throw new ArgumentNullException(nameof(options.Outcome));
@@ -62,13 +62,13 @@ internal AsyncInjectOutcomePolicy(Func<Context, CancellationToken, Task<TResult>
             _resultProvider = resultProvider ?? throw new ArgumentNullException(nameof(resultProvider));
         }
 
-        internal AsyncInjectOutcomePolicy(InjectFaultAsyncOptions<Exception> options)
+        internal AsyncInjectOutcomePolicy(InjectOutcomeAsyncOptions<Exception> options)
             : base(options.InjectionRate, options.Enabled)
         {
             _faultProvider = options.Outcome ?? throw new ArgumentNullException(nameof(options.Outcome));
         }
 
-        internal AsyncInjectOutcomePolicy(InjectFaultAsyncOptions<TResult> options)
+        internal AsyncInjectOutcomePolicy(InjectOutcomeAsyncOptions<TResult> options)
             : base(options.InjectionRate, options.Enabled)
         {
             _resultProvider = options.Outcome ?? throw new ArgumentNullException(nameof(options.Outcome));

diff --git a/....Simmy/Outcomes/AsyncInjectFaultSyntax.cs → ...immy/Outcomes/AsyncInjectOutcomeSyntax.cs b/....Simmy/Outcomes/AsyncInjectFaultSyntax.cs → ...immy/Outcomes/AsyncInjectOutcomeSyntax.cs
diff --git a/...Simmy/Outcomes/InjectFaultAsyncOptions.cs → ...mmy/Outcomes/InjectOutcomeAsyncOptions.cs b/...Simmy/Outcomes/InjectFaultAsyncOptions.cs → ...mmy/Outcomes/InjectOutcomeAsyncOptions.cs
@@ -7,7 +7,7 @@ namespace Polly.Contrib.Simmy.Outcomes
     /// <summary>
     /// Options used to configure an <see cref="InjectOutcomePolicy"/>
     /// </summary>
-    public class InjectFaultAsyncOptions<TResult> : InjectOptionsAsyncBase
+    public class InjectOutcomeAsyncOptions<TResult> : InjectOptionsAsyncBase
     {
         /// <summary>
         /// Outcome Delegate to be executed

diff --git a/...omes/InjectFaultAsyncOptionsExtensions.cs → ...es/InjectOutcomeAsyncOptionsExtensions.cs b/...omes/InjectFaultAsyncOptionsExtensions.cs → ...es/InjectOutcomeAsyncOptionsExtensions.cs
@@ -7,22 +7,22 @@ namespace Polly.Contrib.Simmy.Outcomes
     /// <summary>
     /// Allows configuration of fault for asynchronous monkey fault-injection policies.
     /// </summary>
-    public static class InjectFaultAsyncOptionsExtensions
+    public static class InjectOutcomeAsyncOptionsExtensions
     {
         /// <summary>
         /// Configure fault to inject with the monkey policy.
         /// </summary>
         /// <param name="options">The configuration object.</param>
         /// <param name="fault">The exception to inject.</param>
-        public static InjectFaultAsyncOptions<Exception> Fault(this InjectFaultAsyncOptions<Exception> options, Exception fault)
+        public static InjectOutcomeAsyncOptions<Exception> Fault(this InjectOutcomeAsyncOptions<Exception> options, Exception fault)
             => Fault(options, (_, __) => Task.FromResult(fault));
 
         /// <summary>
         /// Configure fault to inject with the monkey policy.
         /// </summary>
         /// <param name="options">The configuration object.</param>
         /// <param name="fault">A delegate representing the fault to inject.</param>
-        public static InjectFaultAsyncOptions<Exception> Fault(this InjectFaultAsyncOptions<Exception> options, Func<Context, CancellationToken, Task<Exception>> fault)
+        public static InjectOutcomeAsyncOptions<Exception> Fault(this InjectOutcomeAsyncOptions<Exception> options, Func<Context, CancellationToken, Task<Exception>> fault)
         {
             options.Outcome = fault;
             return options;
@@ -33,15 +33,15 @@ public static InjectFaultAsyncOptions<Exception> Fault(this InjectFaultAsyncOpti
         /// </summary>
         /// <param name="options">The configuration object.</param>
         /// <param name="fault">The result to inject</param>
-        public static InjectFaultAsyncOptions<Exception> Fault<TResult>(this InjectFaultAsyncOptions<Exception> options, Exception fault) =>
+        public static InjectOutcomeAsyncOptions<Exception> Fault<TResult>(this InjectOutcomeAsyncOptions<Exception> options, Exception fault) =>
             Fault<TResult>(options, (_, __) => Task.FromResult(fault));
 
         /// <summary>
         /// Configure fault to inject with the monkey policy.
         /// </summary>
         /// <param name="options">The configuration object.</param>
         /// <param name="fault">A delegate representing the result to inject.</param>
-        public static InjectFaultAsyncOptions<Exception> Fault<TResult>(this InjectFaultAsyncOptions<Exception> options, Func<Context, CancellationToken, Task<Exception>> fault)
+        public static InjectOutcomeAsyncOptions<Exception> Fault<TResult>(this InjectOutcomeAsyncOptions<Exception> options, Func<Context, CancellationToken, Task<Exception>> fault)
         {
             options.Outcome = fault;
             return options;
@@ -52,15 +52,15 @@ public static InjectFaultAsyncOptions<Exception> Fault<TResult>(this InjectFault
         /// </summary>
         /// <param name="options">The configuration object.</param>
         /// <param name="result">The result to inject</param>
-        public static InjectFaultAsyncOptions<TResult> Result<TResult>(this InjectFaultAsyncOptions<TResult> options, TResult result) =>
+        public static InjectOutcomeAsyncOptions<TResult> Result<TResult>(this InjectOutcomeAsyncOptions<TResult> options, TResult result) =>
             Result(options, (_, __) => Task.FromResult(result));
 
         /// <summary>
         /// Configure result to inject with the monkey policy.
         /// </summary>
         /// <param name="options">The configuration object.</param>
         /// <param name="result">A delegate representing the result to inject.</param>
-        public static InjectFaultAsyncOptions<TResult> Result<TResult>(this InjectFaultAsyncOptions<TResult> options, Func<Context, CancellationToken, Task<TResult>> result)
+        public static InjectOutcomeAsyncOptions<TResult> Result<TResult>(this InjectOutcomeAsyncOptions<TResult> options, Func<Context, CancellationToken, Task<TResult>> result)
         {
             options.Outcome = result;
             return options;

diff --git a/...trib.Simmy/Outcomes/InjectFaultOptions.cs → ...ib.Simmy/Outcomes/InjectOutcomeOptions.cs b/...trib.Simmy/Outcomes/InjectFaultOptions.cs → ...ib.Simmy/Outcomes/InjectOutcomeOptions.cs
@@ -6,7 +6,7 @@ namespace Polly.Contrib.Simmy.Outcomes
     /// <summary>
     /// Options used to configure an <see cref="InjectOutcomePolicy"/>
     /// </summary>
-    public class InjectFaultOptions<TResult> : InjectOptionsBase
+    public class InjectOutcomeOptions<TResult> : InjectOptionsBase
     {
         /// <summary>
         /// Outcome Delegate to be executed

diff --git a/.../Outcomes/InjectFaultOptionsExtensions.cs → ...utcomes/InjectOutcomeOptionsExtensions.cs b/.../Outcomes/InjectFaultOptionsExtensions.cs → ...utcomes/InjectOutcomeOptionsExtensions.cs
@@ -6,22 +6,22 @@ namespace Polly.Contrib.Simmy.Outcomes
     /// <summary>
     /// Allows configuration of fault for synchronous monkey fault-injection policies.
     /// </summary>
-    public static class InjectFaultOptionsExtensions
+    public static class InjectOutcomeOptionsExtensions
     {
         /// <summary>
         /// Configure fault to inject with the monkey policy.
         /// </summary>
         /// <param name="options">The configuration object.</param>
         /// <param name="fault">The exception to inject.</param>
-        public static InjectFaultOptions<Exception> Fault(this InjectFaultOptions<Exception> options, Exception fault)
+        public static InjectOutcomeOptions<Exception> Fault(this InjectOutcomeOptions<Exception> options, Exception fault)
             => Fault(options, (_, __) => fault);
 
         /// <summary>
         /// Configure fault to inject with the monkey policy.
         /// </summary>
         /// <param name="options">The configuration object.</param>
         /// <param name="fault">A delegate representing the fault to inject.</param>
-        public static InjectFaultOptions<Exception> Fault(this InjectFaultOptions<Exception> options, Func<Context, CancellationToken, Exception> fault)
+        public static InjectOutcomeOptions<Exception> Fault(this InjectOutcomeOptions<Exception> options, Func<Context, CancellationToken, Exception> fault)
         {
             options.OutcomeInternal = fault;
             return options;
@@ -32,15 +32,15 @@ public static InjectFaultOptions<Exception> Fault(this InjectFaultOptions<Except
         /// </summary>
         /// <param name="options">The configuration object.</param>
         /// <param name="fault">The result to inject</param>
-        public static InjectFaultOptions<Exception> Fault<TResult>(this InjectFaultOptions<Exception> options, Exception fault) =>
+        public static InjectOutcomeOptions<Exception> Fault<TResult>(this InjectOutcomeOptions<Exception> options, Exception fault) =>
             Fault<TResult>(options, (_, __) => fault);
 
         /// <summary>
         /// Configure fault to inject with the monkey policy.
         /// </summary>
         /// <param name="options">The configuration object.</param>
         /// <param name="fault">A delegate representing the result to inject.</param>
-        public static InjectFaultOptions<Exception> Fault<TResult>(this InjectFaultOptions<Exception> options, Func<Context, CancellationToken, Exception> fault)
+        public static InjectOutcomeOptions<Exception> Fault<TResult>(this InjectOutcomeOptions<Exception> options, Func<Context, CancellationToken, Exception> fault)
         {
             options.OutcomeInternal = fault;
             return options;
@@ -51,15 +51,15 @@ public static InjectFaultOptions<Exception> Fault<TResult>(this InjectFaultOptio
         /// </summary>
         /// <param name="options">The configuration object.</param>
         /// <param name="result">The result to inject</param>
-        public static InjectFaultOptions<TResult> Result<TResult>(this InjectFaultOptions<TResult> options, TResult result) =>
+        public static InjectOutcomeOptions<TResult> Result<TResult>(this InjectOutcomeOptions<TResult> options, TResult result) =>
             Result(options, (_, __) => result);
 
         /// <summary>
         /// Configure result to inject with the monkey policy.
         /// </summary>
         /// <param name="options">The configuration object.</param>
         /// <param name="result">A delegate representing the result to inject.</param>
-        public static InjectFaultOptions<TResult> Result<TResult>(this InjectFaultOptions<TResult> options, Func<Context, CancellationToken, TResult> result)
+        public static InjectOutcomeOptions<TResult> Result<TResult>(this InjectOutcomeOptions<TResult> options, Func<Context, CancellationToken, TResult> result)
         {
             options.OutcomeInternal = result;
             return options;

diff --git a/...immy/Outcomes/InjectFaultOptionsSyntax.cs → ...my/Outcomes/InjectOutcomeOptionsSyntax.cs b/...immy/Outcomes/InjectFaultOptionsSyntax.cs → ...my/Outcomes/InjectOutcomeOptionsSyntax.cs
@@ -14,9 +14,9 @@ public partial class MonkeyPolicy
         /// </summary>
         /// <param name="configureOptions">A callback to configure policy options.</param>
         /// <returns>The policy instance.</returns>
-        public static InjectOutcomePolicy InjectException(Action<InjectFaultOptions<Exception>> configureOptions)
+        public static InjectOutcomePolicy InjectException(Action<InjectOutcomeOptions<Exception>> configureOptions)
         {
-            var options = new InjectFaultOptions<Exception>();
+            var options = new InjectOutcomeOptions<Exception>();
             configureOptions(options);
 
             if (options.OutcomeInternal == null) throw new ArgumentNullException(nameof(options.OutcomeInternal));
@@ -32,9 +32,9 @@ public static InjectOutcomePolicy InjectException(Action<InjectFaultOptions<Exce
         /// </summary>
         /// <param name="configureOptions">A callback to configure policy options.</param>
         /// <returns>The policy instance.</returns>
-        public static InjectOutcomePolicy<TResult> InjectResult<TResult>(Action<InjectFaultOptions<TResult>> configureOptions)
+        public static InjectOutcomePolicy<TResult> InjectResult<TResult>(Action<InjectOutcomeOptions<TResult>> configureOptions)
         {
-            var options = new InjectFaultOptions<TResult>();
+            var options = new InjectOutcomeOptions<TResult>();
             configureOptions(options);
 
             if (options.OutcomeInternal == null) throw new ArgumentNullException(nameof(options.OutcomeInternal));
@@ -50,9 +50,9 @@ public static InjectOutcomePolicy<TResult> InjectResult<TResult>(Action<InjectFa
         /// </summary>
         /// <param name="configureOptions">A callback to configure policy options.</param>
         /// <returns>The policy instance.</returns>
-        public static InjectOutcomePolicy<TResult> InjectResult<TResult>(Action<InjectFaultOptions<Exception>> configureOptions)
+        public static InjectOutcomePolicy<TResult> InjectResult<TResult>(Action<InjectOutcomeOptions<Exception>> configureOptions)
         {
-            var options = new InjectFaultOptions<Exception>();
+            var options = new InjectOutcomeOptions<Exception>();
             configureOptions(options);
 
             if (options.OutcomeInternal == null) throw new ArgumentNullException(nameof(options.OutcomeInternal));

diff --git a/src/Polly.Contrib.Simmy/Outcomes/InjectOutcomePolicy.cs b/src/Polly.Contrib.Simmy/Outcomes/InjectOutcomePolicy.cs
@@ -18,7 +18,7 @@ internal InjectOutcomePolicy(Func<Context, CancellationToken, Exception> faultPr
             _faultProvider = faultProvider ?? throw new ArgumentNullException(nameof(faultProvider));
         }
 
-        internal InjectOutcomePolicy(InjectFaultOptions<Exception> options)
+        internal InjectOutcomePolicy(InjectOutcomeOptions<Exception> options)
             : base(options.InjectionRate, options.Enabled)
         {
             _faultProvider = options.OutcomeInternal ?? throw new ArgumentNullException(nameof(options.OutcomeInternal));
@@ -59,13 +59,13 @@ internal InjectOutcomePolicy(Func<Context, CancellationToken, TResult> resultPro
             _resultProvider = resultProvider ?? throw new ArgumentNullException(nameof(resultProvider));
         }
 
-        internal InjectOutcomePolicy(InjectFaultOptions<Exception> options)
+        internal InjectOutcomePolicy(InjectOutcomeOptions<Exception> options)
             : base(options.InjectionRate, options.Enabled)
         {
             _faultProvider = options.OutcomeInternal ?? throw new ArgumentNullException(nameof(options.OutcomeInternal));
         }
 
-        internal InjectOutcomePolicy(InjectFaultOptions<TResult> options)
+        internal InjectOutcomePolicy(InjectOutcomeOptions<TResult> options)
             : base(options.InjectionRate, options.Enabled)
         {
             _resultProvider = options.OutcomeInternal ?? throw new ArgumentNullException(nameof(options.OutcomeInternal));

diff --git a/...ntrib.Simmy/Outcomes/InjectFaultSyntax.cs → ...rib.Simmy/Outcomes/InjectOutcomeSyntax.cs b/...ntrib.Simmy/Outcomes/InjectFaultSyntax.cs → ...rib.Simmy/Outcomes/InjectOutcomeSyntax.cs