public async Task should_allow_for_async_execution_of_code()
{
var storeReducerReached = 0;
var reducer = new SimpleReducer <List <string> >(() => new List <string> {
"a"
}).When <SomeAction>((s, e) =>
{
storeReducerReached += 1;
return(s);
});
var store = new Store <List <string> >(reducer);
var result = await store.Dispatch(store.asyncAction <int>(async(dispatcher, store2) =>
{
await Task.Delay(300);
Assert.That(store2()[0], Is.EqualTo("a"));
dispatcher(new SomeAction());
return(112);
}));
Assert.That(storeReducerReached, Is.EqualTo(1));
Assert.That(result, Is.EqualTo(112));
await store.Dispatch(new AsyncAction1());
Assert.That(storeReducerReached, Is.EqualTo(2));
}
public async Task should_allow_for_passing_parameters_to_async_actions()
{
var storeReducerReached = 0;
var reducer = new SimpleReducer <List <string> >(() => new List <string> {
"a"
}).When <SomeAction>((s, e) =>
{
storeReducerReached += 1;
return(s);
});
var store = new Store <List <string> >(reducer);
var action1 = store.asyncAction <LoginInfo, int>(async(dispatcher, store2, msg) =>
{
await Task.Delay(300);
Assert.That(msg.username, Is.EqualTo("John"));
dispatcher(new SomeAction());
return(112);
});
var result = await store.Dispatch(action1(new LoginInfo
{
username = "******"
}));
Assert.That(storeReducerReached, Is.EqualTo(1));
Assert.That(result, Is.EqualTo(112));
var result2 = await store.Dispatch(new AsyncAction2 { Param = 60 });
Assert.That(storeReducerReached, Is.EqualTo(2));
Assert.That(result2, Is.EqualTo(60));
}
public static SimpleReducer <MovieState> All()
{
var reducer = new SimpleReducer <MovieState>()
.When <LoadMoviesAction>((state, action) =>
{
return(new MovieState
{
Error = string.Empty,
Movies = new Movie[0],
Status = LoadStatus.Loading
});
})
.When <LoadMoviesErrorAction>((state, action) => new MovieState
{
Error = action.Error,
Movies = new Movie[0],
Status = LoadStatus.Error
})
.When <LoadMoviesSuccessAction>((state, action) => new MovieState
{
Error = string.Empty,
Movies = action.Movies,
Status = LoadStatus.Loaded
})
.When <SelectMovieAction>((state, action) => new MovieState
{
Error = state.Error,
Movies = state.Movies,
CurrentMovie = action.SelectedMovie,
Status = state.Status
});
return(reducer);
}
public void should_allow_middleware_to_hook_into_dispatching()
{
var storeReducerReached = 0;
var reducer = new SimpleReducer<List<string>>().When<SomeAction>((s, e) =>
{
storeReducerReached += 1;
return s;
});
var store = new Store<List<string>>(reducer);
var middlewareCounter = 0;
store.Middleware(
s => next => action =>
{
middlewareCounter += 3;
Assert.That(middlewareCounter, Is.EqualTo(3));
next(action);
middlewareCounter += 3000;
Assert.That(middlewareCounter, Is.EqualTo(3333));
},
s => next => action =>
{
middlewareCounter += 30;
Assert.That(middlewareCounter, Is.EqualTo(33));
Assert.That(storeReducerReached, Is.EqualTo(0));
next(action);
Assert.That(storeReducerReached, Is.EqualTo(1));
middlewareCounter += 300;
Assert.That(middlewareCounter, Is.EqualTo(333));
}
);
store.Dispatch(new SomeAction());
Assert.That(middlewareCounter, Is.EqualTo(3333));
Assert.That(storeReducerReached, Is.EqualTo(1));
}
public void should_notify_subscribers_while_they_are_subscribed()
{
var reducer = new SimpleReducer <List <string> >(() => new List <string> {
"Use ReduxVVM"
});
var store = new Store <List <string> >(reducer);
var changed = 0;
var unsub = store.Subscribe(state =>
{
Assert.NotNull(state);
changed += 1;
});
store.Dispatch(new ItemAdded {
item = "Read the Redux docs"
});
store.Dispatch(new ItemAdded {
item = "Read the Redux docs"
});
Assert.That(changed, Is.EqualTo(2));
unsub();
store.Dispatch(new ItemAdded {
item = ""
});
Assert.That(changed, Is.EqualTo(2));
}
public async void should_allow_for_passing_parameters_to_async_actions()
{
var storeReducerReached = 0;
var reducer = new SimpleReducer<List<string>>(() => new List<string> {"a"}).When<SomeAction>((s, e) =>
{
storeReducerReached += 1;
return s;
});
var store = new Store<List<string>>(reducer);
var action1 = store.asyncAction<LoginInfo, int>(async (dispatcher, store2, msg) =>
{
await Task.Delay(300);
Assert.That(msg.username, Is.EqualTo("John"));
dispatcher(new SomeAction());
return 112;
});
var result = await store.Dispatch(action1(new LoginInfo
{
username = "******"
}));
Assert.That(storeReducerReached, Is.EqualTo(1));
Assert.That(result, Is.EqualTo(112));
}
public void should_prvide_way_to_create_deep_hierarchy_of_reducers()
{
var originReducer = new SimpleReducer<Address>().When<SetOrigin>((s, e) => e.newAddress);
var destinationReducer = new CompositeReducer<Destination>()
.Part(s => s.deliver,
new SimpleReducer<DeliveryMethod>().When<BehindSchedule>((s, a) => DeliveryMethod.REGULAR)
.When<SetDelivery>((_, a) => a.method))
.Part(s => s.addr, new SimpleReducer<Address>().When<SetDestination>((s, a) => a.newAddress));
var orderReducer = new CompositeReducer<Order>()
.Part(s => s.origin, originReducer)
.Part(s => s.destination, destinationReducer);
var store = new Store<Order>(orderReducer);
store.Dispatch(new SetOrigin {newAddress = new Address {streetNr = "Laugavegur 26", city = "Reykjavík"}});
store.Dispatch(new SetDestination {newAddress = new Address {streetNr = "5th Avenue", city = "New York"}});
store.Dispatch(new SetDelivery {method = DeliveryMethod.GUARANTEED});
store.Dispatch(new BehindSchedule());
Assert.AreEqual(new Order
{
origin = new Address {streetNr = "Laugavegur 26", city = "Reykjavík"},
destination =
new Destination
{
addr = new Address {streetNr = "5th Avenue", city = "New York"},
deliver = DeliveryMethod.REGULAR
}
}, store.GetState());
}
public static SimpleReducer <AuthState> All()
{
var reducer = new SimpleReducer <AuthState>()
.When <StartLogin>((state, action) =>
{
return(new AuthState(LoginStatus.LoginStarted, action.Username, string.Empty));
})
.When <LoginSucceeded>((state, action) =>
{
return(new AuthState(LoginStatus.LoggedIn, state.UserName, action.Token));
})
.When <LoginFailed>((state, action) =>
{
return(new AuthState(LoginStatus.LoginError, state.UserName, state.Token, action.Error));
})
.When <LoadUser>((state, action) =>
{
var status = string.IsNullOrEmpty(action.Token) ?
LoginStatus.None :
LoginStatus.LoggedIn;
return(new AuthState(status, action.Username, action.Token));
})
.When <StartLogout>((state, action) => new AuthState(LoginStatus.None, String.Empty, String.Empty));
return(reducer);
}
public void should_allow_middleware_to_shortcut_lower_middleware()
{
var storeReducerReached = 0;
var reducer = new SimpleReducer <List <string> >().When <SomeAction>((s, e) =>
{
storeReducerReached += 1;
return(s);
});
var stateStore = new Store <List <string> >(reducer);
var middlewareCounter = 0;
stateStore.Middleware(
store => next => action =>
{
middlewareCounter += 3;
Assert.That(middlewareCounter, Is.EqualTo(3));
middlewareCounter += 3000;
Assert.That(middlewareCounter, Is.EqualTo(3003));
},
store => next => action =>
{
middlewareCounter += 30;
Assert.That(middlewareCounter, Is.EqualTo(33));
Assert.That(storeReducerReached, Is.EqualTo(0));
next(action);
Assert.That(storeReducerReached, Is.EqualTo(1));
middlewareCounter += 300;
Assert.That(middlewareCounter, Is.EqualTo(333));
}
);
stateStore.Dispatch(new SomeAction());
Assert.That(middlewareCounter, Is.EqualTo(3003));
Assert.That(storeReducerReached, Is.EqualTo(0));
}
public async Task all_in_one_example()
{
var reducer = new SimpleReducer <AppState>()
.When <LoginStarted>((state, action) => {
state.Username = action.Username;
state.Token = "";
state.Status = LoginStatus.LoginInProgress;
return(state);
})
.When <LoginSucceeded>((state, action) => {
state.Token = action.Token;
state.Status = LoginStatus.LoggedIn;
return(state);
})
.When <LoginFailed>((state, action) => {
state.Status = LoginStatus.NotLoggedIn;
return(state);
});
var store = new Store <AppState>(reducer);
var loginAsyncAction = store.asyncAction(async(dispatch, getState) => {
dispatch(new LoginStarted {
Username = "******"
});
// faking authentication of user
await Task.Delay(500);
var authenticated = new Random().Next() % 2 == 0;
if (authenticated)
{
dispatch(new LoginSucceeded {
Token = "1234"
});
}
else
{
dispatch(new LoginFailed());
}
return(authenticated);
});
var logged = await store.Dispatch(loginAsyncAction);
if (logged)
{
Assert.That(store.GetState().Status, Is.EqualTo(LoginStatus.LoggedIn));
}
else
{
Assert.That(store.GetState().Status, Is.EqualTo(LoginStatus.NotLoggedIn));
}
}
public void should_prvide_way_to_combine_reducers()
{
var topicReducer = new SimpleReducer<string>().When<TopicSet>((s, e) => e.topic);
var visibilityReducer = new SimpleReducer<bool>().When<FilterVisibility>((s, e) => e.visible);
var reducer = new CompositeReducer<AppStore>(() => new AppStore {redditTopic = "react", visibility = false})
.Part(s => s.redditTopic, topicReducer)
.Part(s => s.visibility, visibilityReducer);
var store = new Store<AppStore>(reducer);
store.Dispatch(new TopicSet {topic = "Redux is awesome"});
store.Dispatch(new FilterVisibility {visible = true});
Assert.AreEqual(new AppStore {redditTopic = "Redux is awesome", visibility = true}, store.GetState());
}
public void should_register_root_reducer_with_builder()
{
var reducer = new SimpleReducer<List<string>>(() => new List<string> {"Use ReduxVVM"})
.When<ItemAdded>((state, action) =>
{
var newSatte = new List<string>(state);
newSatte.Add(action.item);
return newSatte;
})
.Get();
var store = new Store<List<string>>(reducer);
store.Dispatch(new ItemAdded {item = "Read the Redux docs"});
CollectionAssert.AreEqual(store.GetState(), new List<string> {"Use ReduxVVM", "Read the Redux docs"});
}
public void should_return_same_state_when_command_not_for_that_reducer()
{
var reducer = new SimpleReducer <List <string> >(() => new List <string> {
"Use ReduxVVM"
});
var store = new Store <List <string> >(reducer);
store.Dispatch(new ItemAdded {
item = "Read the Redux docs"
});
CollectionAssert.AreEqual(store.GetState(), new List <string> {
"Use ReduxVVM"
});
}
public async Task should_execute_async_action_inside_async_action()
{
var storeReducerReached = 0;
var reducer = new SimpleReducer <List <string> >(() => new List <string> {
"a"
}).When <SomeAction>((s, e) =>
{
storeReducerReached += 1;
return(s);
});
var store = new Store <List <string> >(reducer);
var result = await store.Dispatch(new AsyncAction3 { Param = 60 });
Assert.That(storeReducerReached, Is.EqualTo(2));
Assert.That(result, Is.EqualTo(120));
}
public void should_prvide_way_to_create_deep_hierarchy_of_reducers()
{
var originReducer = new SimpleReducer <Address>().When <SetOrigin>((s, e) => e.newAddress);
var destinationReducer = new CompositeReducer <Destination>()
.Part(state => state.deliver,
new SimpleReducer <DeliveryMethod>().When <BehindSchedule>((s, a) => DeliveryMethod.REGULAR)
.When <SetDelivery>((_, a) => a.method))
.Part(state => state.addr, new SimpleReducer <Address>().When <SetDestination>((s, a) => a.newAddress));
var orderReducer = new CompositeReducer <Order>()
.Part(state => state.origin, originReducer)
.Part(state => state.destination, destinationReducer);
var store = new Store <Order>(orderReducer);
store.Dispatch(new SetOrigin {
newAddress = new Address {
streetNr = "Laugavegur 26", city = "Reykjavík"
}
});
store.Dispatch(new SetDestination {
newAddress = new Address {
streetNr = "5th Avenue", city = "New York"
}
});
store.Dispatch(new SetDelivery {
method = DeliveryMethod.GUARANTEED
});
store.Dispatch(new BehindSchedule());
Assert.AreEqual(new Order
{
origin = new Address {
streetNr = "Laugavegur 26", city = "Reykjavík"
},
destination =
new Destination
{
addr = new Address {
streetNr = "5th Avenue", city = "New York"
},
deliver = DeliveryMethod.REGULAR
}
}, store.GetState());
}
public async void all_in_one_example(){
var reducer = new SimpleReducer<AppState>()
.When<LoginStarted>((status, action) => {
status.Username = action.Username;
status.Token = "";
status.Status = LoginStatus.LoginInProgress;
return status;
})
.When<LoginSucceeded>((status, action) => {
status.Token = action.Token;
status.Status = LoginStatus.LoggedIn;
return status;
})
.When<LoginFailed>((status, action) => {
status.Status = LoginStatus.NotLoggedIn;
return status;
});
var store = new Store<AppState>(reducer);
var loginAsyncAction = store.asyncAction(async(dispatch, getState) => {
dispatch(new LoginStarted{Username = "******"});
// faking authentication of user
await Task.Delay(500);
var authenticated = new Random().Next() % 2 == 0;
if (authenticated) {
dispatch(new LoginSucceeded{Token = "1234"});
} else {
dispatch(new LoginFailed());
}
return authenticated;
});
var logged = await store.Dispatch(loginAsyncAction);
if (logged){
Assert.That(store.GetState().Status, Is.EqualTo(LoginStatus.LoggedIn));
} else {
Assert.That(store.GetState().Status, Is.EqualTo(LoginStatus.NotLoggedIn));
}
}
public void should_notify_subscribers_while_they_are_subscribed()
{
var reducer = new SimpleReducer<List<string>>(() => new List<string> {"Use ReduxVVM"});
var store = new Store<List<string>>(reducer);
var changed = 0;
var unsub = store.Subscribe(state =>
{
Assert.NotNull(state);
changed += 1;
});
store.Dispatch(new ItemAdded {item = "Read the Redux docs"});
store.Dispatch(new ItemAdded {item = "Read the Redux docs"});
Assert.That(changed, Is.EqualTo(2));
unsub();
store.Dispatch(new ItemAdded {item = ""});
Assert.That(changed, Is.EqualTo(2));
}
public async void should_allow_for_async_execution_of_code()
{
var storeReducerReached = 0;
var reducer = new SimpleReducer<List<string>>(() => new List<string> {"a"}).When<SomeAction>((s, e) =>
{
storeReducerReached += 1;
return s;
});
var store = new Store<List<string>>(reducer);
var result = await store.Dispatch(store.asyncAction<int>(async (dispatcher, store2) =>
{
await Task.Delay(300);
Assert.That(store2()[0], Is.EqualTo("a"));
dispatcher(new SomeAction());
return 112;
}));
Assert.That(storeReducerReached, Is.EqualTo(1));
Assert.That(result, Is.EqualTo(112));
}
public void should_register_root_reducer_with_builder()
{
var reducer = new SimpleReducer <List <string> >(() => new List <string> {
"Use ReduxVVM"
})
.When <ItemAdded>((state, action) =>
{
var newSatte = new List <string>(state);
newSatte.Add(action.item);
return(newSatte);
})
.Get();
var store = new Store <List <string> >(reducer);
store.Dispatch(new ItemAdded {
item = "Read the Redux docs"
});
CollectionAssert.AreEqual(store.GetState(), new List <string> {
"Use ReduxVVM", "Read the Redux docs"
});
}
public void should_prvide_way_to_combine_reducers()
{
var topicReducer = new SimpleReducer <string>().When <TopicSet>((s, e) => e.topic);
var visibilityReducer = new SimpleReducer <bool>().When <FilterVisibility>((s, e) => e.visible);
var reducer = new CompositeReducer <AppStore>(() => new AppStore {
redditTopic = "react", visibility = false
})
.Part(state => state.redditTopic, topicReducer)
.Part(state => state.visibility, visibilityReducer);
var store = new Store <AppStore>(reducer);
store.Dispatch(new TopicSet {
topic = "Redux is awesome"
});
store.Dispatch(new FilterVisibility {
visible = true
});
Assert.AreEqual(new AppStore {
redditTopic = "Redux is awesome", visibility = true
}, store.GetState());
}
public static SimpleReducer <TicketsState> All()
{
var reducer = new SimpleReducer <TicketsState>()
.When <LoadTicketsAction>((s, a) => new TicketsState
{
Error = null,
Tickets = new Ticket[0],
Status = LoadStatus.Loading
})
.When <LoadTicketsErrorAction>((s, a) => new TicketsState
{
Error = a.Error,
Tickets = new Ticket[0],
Status = LoadStatus.Error
})
.When <LoadTicketsSuccessAction>((s, a) => new TicketsState
{
Error = null,
Tickets = a.Tickets,
Status = LoadStatus.Loaded
});
return(reducer);
}
public StorePro(SimpleReducer <T> rootReducer) : base(rootReducer)
{
init();
}
public RxStore(SimpleReducer <TState> rootReducer) : base(rootReducer)
{
_stateChanged = new BehaviorSubject <TState>(GetState());
SubscribeToStateChange();
}
public void should_return_same_state_when_command_not_for_that_reducer()
{
var reducer = new SimpleReducer<List<string>>(() => new List<string> {"Use ReduxVVM"});
var store = new Store<List<string>>(reducer);
store.Dispatch(new ItemAdded {item = "Read the Redux docs"});
CollectionAssert.AreEqual(store.GetState(), new List<string> {"Use ReduxVVM"});
}
