[Breaking] Use builder pattern for store construction

Author: David Fallah

src/AsyncRedux/Store.cs

@@ -17,20 +17,10 @@ internal sealed class Store<TState> : IObservableStore<TState>
         /// <inheritdoc />
         public Store(
             [NotNull] Reducer<TState> reducer,
-            [CanBeNull] TState initialState = default,
-            [NotNull] [ItemNotNull] params Middleware<TState>[] middleware)
+            [CanBeNull] TState initialState,
+            [NotNull] [ItemNotNull] IEnumerable<Middleware<TState>> middleware)
         {
-            if (middleware is null)
-            {
-                throw new ArgumentNullException(nameof(middleware));
-            }
-
-            if (middleware.Any(it => it is null))
-            {
-                throw new ArgumentException("Middleware delegate cannot be null", nameof(middleware));
-            }
-
-            _reducer = reducer ?? throw new ArgumentNullException(nameof(reducer));
+            _reducer = reducer;
             _dispatcher = CreateDispatcher(middleware);
             _bus = BusSetup.CreateBus();
             State = initialState;

src/AsyncRedux/StoreSetup.cs

@@ -1,32 +1,103 @@
-using JetBrains.Annotations;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using JetBrains.Annotations;
 
 namespace AsyncRedux
 {
     /// <summary>
     /// Used to configure and return a new Redux store.
     /// </summary>
-    /// <remarks>
-    /// At present, no configuration is possible for the store. This class exists to support future versions
-    /// of this project that may allow for configuration, but more importantly to ensure clients access the
-    /// store through an interface and not a direct class.
-    /// </remarks>
     [PublicAPI]
     public static class StoreSetup
     {
         /// <summary>
-        /// Creates and returns a new store.
+        /// Returns a <see cref="Builder{TState}" /> to configure and create a new store.
         /// </summary>
         /// <typeparam name="TState">The type of the state handled by the store.</typeparam>
-        /// <param name="reducer">The root reducer to apply to dispatched actions.</param>
-        /// <param name="initialState">The initial state.</param>
-        /// <param name="middleware">The middleware to apply to the store.</param>
-        /// <returns>A new store.</returns>
-        public static IObservableStore<TState> CreateStore<TState>(
-            [NotNull] Reducer<TState> reducer,
-            [CanBeNull] TState initialState = default,
-            [NotNull] [ItemNotNull] params Middleware<TState>[] middleware)
+        /// <returns>A <see cref="Builder{TState}" />.</returns>
+        public static Builder<TState> CreateStore<TState>() => new Builder<TState>();
+
+        /// <summary>
+        /// Configures and builds instances of <see cref="IObservableStore{TState}" />.
+        /// </summary>
+        /// <typeparam name="TState">The type of the state handled by the store.</typeparam>
+        /// <remarks>
+        /// Middleware plugin libraries can and should extend this class with methods to configure middleware they provide.
+        /// </remarks>
+        public class Builder<TState>
         {
-            return new Store<TState>(reducer, initialState, middleware);
+            private readonly List<Middleware<TState>> _middleware;
+
+            private TState _initialState;
+            private Reducer<TState> _reducer;
+
+            /// <summary>
+            /// Initializes a new instance of the <see cref="Builder{TState}" /> class.
+            /// </summary>
+            public Builder()
+            {
+                _middleware = new List<Middleware<TState>>();
+            }
+
+            /// <summary>
+            /// Builds and returns a new store based on the configuration of this builder.
+            /// </summary>
+            /// <returns>A new store.</returns>
+            /// <exception cref="InvalidOperationException">This builder has not been configured correctly.</exception>
+            public IObservableStore<TState> Build()
+            {
+                if (_reducer is null)
+                {
+                    throw new InvalidOperationException("Root reducer for store has not been configured");
+                }
+
+                return new Store<TState>(_reducer, _initialState, _middleware);
+            }
+
+            /// <summary>
+            /// Configures the root reducer for the store. This <b>must</b> be set before building the store.
+            /// </summary>
+            /// <param name="reducer">The root reducer to apply to dispatched actions.</param>
+            /// <returns>This builder.</returns>
+            public Builder<TState> FromReducer([NotNull] Reducer<TState> reducer)
+            {
+                _reducer = reducer ?? throw new ArgumentNullException(nameof(reducer));
+                return this;
+            }
+
+            /// <summary>
+            /// Configures the middleware to apply to the store. Middleware will be applied in the order that it is provided.
+            /// </summary>
+            /// <param name="middleware">The middleware.</param>
+            /// <returns>This builder.</returns>
+            public Builder<TState> UsingMiddleware([NotNull] [ItemNotNull] params Middleware<TState>[] middleware)
+            {
+                if (middleware is null)
+                {
+                    throw new ArgumentNullException(nameof(middleware));
+                }
+
+                if (middleware.Any(it => it is null))
+                {
+                    throw new ArgumentException("Middleware delegate cannot be null", nameof(middleware));
+                }
+
+                _middleware.AddRange(middleware);
+                return this;
+            }
+
+            /// <summary>
+            /// Configures the initial state for the store. If not specified, defaults to the default value for
+            /// <typeparamref name="TState" />.
+            /// </summary>
+            /// <param name="initialState">The initial state.</param>
+            /// <returns>This builder.</returns>
+            public Builder<TState> WithInitialState([CanBeNull] TState initialState)
+            {
+                _initialState = initialState;
+                return this;
+            }
         }
     }
 }

test/AsyncRedux.Tests/ObservableStoreSpec.cs

@@ -20,7 +20,9 @@ public class ObservableStoreSpec
         /// <inheritdoc />
         public ObservableStoreSpec()
         {
-            _store = StoreSetup.CreateStore<State>(Reducers.PassThrough);
+            _store = StoreSetup.CreateStore<State>()
+                .FromReducer(Reducers.PassThrough)
+                .Build();
         }
 
         public static IEnumerable<object[]> ActionSequenceExamples
@@ -144,7 +146,11 @@ Task HandleDispatchedAction(object action)
         [Fact]
         internal void Subscribers_Implementing_IStoreSubscriber_Should_Receive_Store_On_Subscription()
         {
-            var store = StoreSetup.CreateStore(Reducers.Replace, new State(1, true));
+            var store = StoreSetup.CreateStore<State>()
+                .FromReducer(Reducers.Replace)
+                .WithInitialState(new State(1, true))
+                .Build();
+
             var subscriber = new Subscriber();
 
             store.Subscribe(subscriber);

test/AsyncRedux.Tests/StoreSpec.cs

@@ -6,6 +6,7 @@
 using Shouldly;
 using Xunit;
 
+// ReSharper disable AssignNullToNotNullAttribute
 // ReSharper disable MemberCanBePrivate.Global
 
 namespace AsyncRedux.Tests
@@ -68,16 +69,26 @@ public static IEnumerable<object[]> StateExamples
         internal void Store_Construction_Should_Throw_For_Null_Middleware_Collection()
         {
             Should.Throw<ArgumentNullException>(
-                // ReSharper disable once AssignNullToNotNullAttribute
-                () => StoreSetup.CreateStore<State>(Reducers.PassThrough, default, null));
+                () => StoreSetup.CreateStore<State>()
+                    .FromReducer(Reducers.PassThrough)
+                    .UsingMiddleware(null)
+                    .Build());
         }
 
         [Fact]
         internal void Store_Construction_Should_Throw_If_Any_Middleware_Is_Null()
         {
             Should.Throw<ArgumentException>(
-                // ReSharper disable once AssignNullToNotNullAttribute
-                () => StoreSetup.CreateStore<State>(Reducers.PassThrough, default, Middleware.IncrementInt, null));
+                () => StoreSetup.CreateStore<State>()
+                    .FromReducer(Reducers.PassThrough)
+                    .UsingMiddleware(Middleware.IncrementInt, null)
+                    .Build());
+        }
+
+        [Fact]
+        internal void Store_Construction_Should_Throw_If_Reducer_Is_Not_Specified()
+        {
+            Should.Throw<InvalidOperationException>(() => StoreSetup.CreateStore<State>().Build());
         }
 
         [Theory]
@@ -87,7 +98,10 @@ internal async Task Store_Should_Apply_Actions_In_Order_Of_Dispatch(
             object[] actions,
             State expectedFinalState)
         {
-            var store = StoreSetup.CreateStore(Reducers.Replace, initialState);
+            var store = StoreSetup.CreateStore<State>()
+                .FromReducer(Reducers.Replace)
+                .WithInitialState(initialState)
+                .Build();
 
             foreach (var action in actions)
             {
@@ -97,11 +111,33 @@ internal async Task Store_Should_Apply_Actions_In_Order_Of_Dispatch(
             store.State.ShouldBe(expectedFinalState);
         }
 
+        [Fact]
+        internal void Store_Should_Concatenate_Middleware_If_Multiple_Sets_Provided_During_Construction()
+        {
+            var initialState = new State(0, false);
+            var store = StoreSetup.CreateStore<State>()
+                .FromReducer(Reducers.Replace)
+                .WithInitialState(initialState)
+                .UsingMiddleware(Middleware.IncrementInt)
+                .UsingMiddleware(Middleware.NegateBool)
+                .Build();
+
+            store.Dispatch(new ChangeInt(1));
+            store.State.IntProperty.ShouldBe(2);
+
+            store.Dispatch(new ChangeBool(false));
+            store.State.BoolProperty.ShouldBe(true);
+        }
+
         [Theory]
         [MemberData(nameof(StateExamples))]
         internal void Store_Should_Have_Provided_Initial_State_After_Construction(State initialState)
         {
-            var store = StoreSetup.CreateStore(Reducers.Replace, initialState);
+            var store = StoreSetup.CreateStore<State>()
+                .FromReducer(Reducers.Replace)
+                .WithInitialState(initialState)
+                .Build();
+
             store.State.ShouldBe(initialState);
         }
 
@@ -110,7 +146,11 @@ internal void Store_Should_Pass_Dispatched_Actions_Through_Middleware_Before_Red
         {
             var initialState = new State(0, false);
             var middleware = new Middleware<State>[] { Middleware.IncrementInt, Middleware.NegateBool };
-            var store = StoreSetup.CreateStore(Reducers.Replace, initialState, middleware);
+            var store = StoreSetup.CreateStore<State>()
+                .FromReducer(Reducers.Replace)
+                .WithInitialState(initialState)
+                .UsingMiddleware(middleware)
+                .Build();
 
             store.Dispatch(new ChangeInt(1));
             store.State.IntProperty.ShouldBe(2);