public WatchListViewModel(IWatchListService watchListService, IMarketFeedService marketFeedService, IRegionManager regionManager, IEventAggregator eventAggregator)
{
if (watchListService == null)
{
throw new ArgumentNullException("watchListService");
}
if (eventAggregator == null)
{
throw new ArgumentNullException("eventAggregator");
}
this.HeaderInfo = Resources.WatchListTitle;
this.WatchListItems = new ObservableCollection<WatchItem>();
this.marketFeedService = marketFeedService;
this.regionManager = regionManager;
this.watchList = watchListService.RetrieveWatchList();
this.watchList.CollectionChanged += delegate { this.PopulateWatchItemsList(this.watchList); };
this.PopulateWatchItemsList(this.watchList);
this.eventAggregator = eventAggregator;
this.eventAggregator.GetEvent<MarketPricesUpdatedEvent>().Subscribe(this.MarketPricesUpdated, ThreadOption.UIThread);
this.removeWatchCommand = new DelegateCommand<string>(this.RemoveWatch);
this.watchListItems.CollectionChanged += this.WatchListItems_CollectionChanged;
}
public WatchListService(IMarketFeedService marketFeedService)
{
this.marketFeedService = marketFeedService;
WatchItems = new ObservableCollection<string>();
AddWatchCommand = new DelegateCommand<string>(AddWatch);
}
public PositionSummaryPresentationModel(IPositionSummaryView view, IAccountPositionService accountPositionService
, IMarketFeedService marketFeedSvc
, IMarketHistoryService marketHistorySvc
, ITrendLinePresenter trendLinePresenter
, IOrdersController ordersController
, IEventAggregator eventAggregator)
{
View = view;
AccountPositionSvc = accountPositionService;
MarketHistorySvc = marketHistorySvc;
EventAggregator = eventAggregator;
MarketFeedSvc = marketFeedSvc;
PositionSummaryItems = new ObservableCollection<PositionSummaryItem>();
PopulatePresentationModel();
BuyCommand = ordersController.BuyCommand;
SellCommand = ordersController.SellCommand;
View.Model = this;
_trendLinePresenter = trendLinePresenter;
View.ShowTrendLine(trendLinePresenter.View);
//Initially show the FAKEINDEX
trendLinePresenter.OnTickerSymbolSelected("FAKEINDEX");
eventAggregator.GetEvent<MarketPricesUpdatedEvent>().Subscribe(MarketPricesUpdated, ThreadOption.UIThread);
InitializeEvents();
}
public WatchListViewModel(IWatchListService watchListService, IMarketFeedService marketFeedService, IRegionManager regionManager, IEventAggregator eventAggregator)
{
if (watchListService == null)
{
throw new ArgumentNullException("watchListService");
}
if (eventAggregator == null)
{
throw new ArgumentNullException("eventAggregator");
}
this.HeaderInfo = Resources.WatchListTitle;
this.WatchListItems = new ObservableCollection <WatchItem>();
this.marketFeedService = marketFeedService;
this.regionManager = regionManager;
this.watchList = watchListService.RetrieveWatchList();
this.watchList.CollectionChanged += delegate { this.PopulateWatchItemsList(this.watchList); };
this.PopulateWatchItemsList(this.watchList);
this.eventAggregator = eventAggregator;
this.eventAggregator.GetEvent <MarketPricesUpdatedEvent>().Subscribe(this.MarketPricesUpdated, ThreadOption.UIThread);
this.removeWatchCommand = new DelegateCommand <string>(this.RemoveWatch);
this.watchListItems.CollectionChanged += this.WatchListItems_CollectionChanged;
}
public PositionSummaryPresentationModel(IPositionSummaryView view, IAccountPositionService accountPositionService
, IMarketFeedService marketFeedSvc
, IMarketHistoryService marketHistorySvc
, ITrendLinePresenter trendLinePresenter
, IOrdersController ordersController
, IEventAggregator eventAggregator)
{
View = view;
AccountPositionSvc = accountPositionService;
MarketHistorySvc = marketHistorySvc;
EventAggregator = eventAggregator;
MarketFeedSvc = marketFeedSvc;
PositionSummaryItems = new ObservableCollection <PositionSummaryItem>();
PopulatePresentationModel();
BuyCommand = ordersController.BuyCommand;
SellCommand = ordersController.SellCommand;
View.Model = this;
_trendLinePresenter = trendLinePresenter;
View.ShowTrendLine(trendLinePresenter.View);
//Initially show the FAKEINDEX
trendLinePresenter.OnTickerSymbolSelected("FAKEINDEX");
eventAggregator.GetEvent <MarketPricesUpdatedEvent>().Subscribe(MarketPricesUpdated, ThreadOption.UIThread);
InitializeEvents();
}
public WatchListService(IMarketFeedService marketFeedService)
{
this.marketFeedService = marketFeedService;
WatchItems = new ObservableCollection <string>();
AddWatchCommand = new DelegateCommand <string>(AddWatch);
}
public WatchListService(IMarketFeedService marketFeedService, IEventAggregator eventAggregator)
{
this.marketFeedService = marketFeedService;
this.eventAggregator = eventAggregator;
WatchItems = new ObservableCollection <string>();
AddWatchCommand = new DelegateCommand <string>(AddWatch);
//WatchItems.CollectionChanged += (s, e) => this.eventAggregator.GetEvent<AddWatchTickerSymbolEvent>().Publish(true);
}
//private ObservableCollection<string> WatchItems { get; set; }
public WatchListService(IEventAggregator eventAggregator, IMarketFeedService marketFeedService)
{
this.marketFeedService = marketFeedService;
this.eventAggregator = eventAggregator;
//WatchItems = new ObservableCollection<string>();
AddWatchCommand = new DelegateCommand <string>(AddWatch);
}
public void WhenCurrentWatchItemSet_PropertyIsUpdated()
{
// Prepare
MockMarketPricesUpdatedEvent marketPricesUpdatedEvent = new MockMarketPricesUpdatedEvent();
Mock <TickerSymbolSelectedEvent> mockTickerSymbolSelectedEvent = new Mock <TickerSymbolSelectedEvent>();
ObservableCollection <string> watchList = new ObservableCollection <string>();
watchList.Add("A");
watchList.Add("B");
watchList.Add("C");
Mock <IWatchListService> mockWatchListService = new Mock <IWatchListService>();
mockWatchListService.Setup(x => x.RetrieveWatchList()).Returns(watchList).Verifiable();
Mock <IMarketFeedService> mockMarketFeedService = new Mock <IMarketFeedService>();
mockMarketFeedService.Setup(x => x.GetPrice("A")).Returns(1);
mockMarketFeedService.Setup(x => x.GetPrice("B")).Returns(2);
mockMarketFeedService.Setup(x => x.GetPrice("C")).Returns(3);
Mock <IRegionManager> mockRegionManager = new Mock <IRegionManager>();
Mock <IEventAggregator> mockEventAggregator = new Mock <IEventAggregator>();
mockEventAggregator.Setup(x => x.GetEvent <MarketPricesUpdatedEvent>()).Returns(marketPricesUpdatedEvent);
mockEventAggregator.Setup(x => x.GetEvent <TickerSymbolSelectedEvent>()).Returns(mockTickerSymbolSelectedEvent.Object);
IWatchListService watchListService = mockWatchListService.Object;
IMarketFeedService marketFeedService = mockMarketFeedService.Object;
IRegionManager regionManager = mockRegionManager.Object;
IEventAggregator eventAggregator = mockEventAggregator.Object;
WatchListViewModel target = new WatchListViewModel(watchListService, marketFeedService, regionManager, eventAggregator);
bool propertyChangedRaised = false;
target.PropertyChanged += delegate(object sender, PropertyChangedEventArgs e)
{
if (e.PropertyName == "CurrentWatchItem")
{
propertyChangedRaised = true;
}
};
// Act
target.CurrentWatchItem = target.WatchListItems[1];
// Verify
Assert.AreSame(target.WatchListItems[1], target.CurrentWatchItem);
Assert.IsTrue(propertyChangedRaised);
}
public ObservablePosition(IAccountPositionService accountPositionService, IMarketFeedService marketFeedService, IEventAggregator eventAggregator)
{
this.Items = new ObservableCollection <PositionSummaryItem>();
this.accountPositionService = accountPositionService;
this.marketFeedService = marketFeedService;
eventAggregator.GetEvent <MarketPricesUpdatedEvent>().Subscribe(MarketPricesUpdated, ThreadOption.UIThread);
PopulateItems();
this.accountPositionService.Updated += PositionSummaryItems_Updated;
}
public ObservablePosition(IAccountPositionService accountPositionService, IMarketFeedService marketFeedService, IEventAggregator eventAggregator)
{
this.Items = new ObservableCollection<PositionSummaryItem>();
this.accountPositionService = accountPositionService;
this.marketFeedService = marketFeedService;
eventAggregator.GetEvent<MarketPricesUpdatedEvent>().Subscribe(MarketPricesUpdated, ThreadOption.UIThread);
PopulateItems();
this.accountPositionService.Updated += PositionSummaryItems_Updated;
}
public void WhenMarketPriceChagnes_PriceUpdated()
{
// Prepare
MockMarketPricesUpdatedEvent marketPricesUpdatedEvent = new MockMarketPricesUpdatedEvent();
ObservableCollection <string> watchList = new ObservableCollection <string>();
watchList.Add("A");
watchList.Add("B");
watchList.Add("C");
Mock <IWatchListService> mockWatchListService = new Mock <IWatchListService>();
mockWatchListService.Setup(x => x.RetrieveWatchList()).Returns(watchList).Verifiable();
Mock <IMarketFeedService> mockMarketFeedService = new Mock <IMarketFeedService>();
mockMarketFeedService.Setup(x => x.GetPrice("A")).Returns(1);
mockMarketFeedService.Setup(x => x.GetPrice("B")).Returns(2);
mockMarketFeedService.Setup(x => x.GetPrice("C")).Returns(3);
Mock <IRegionManager> mockRegionManager = new Mock <IRegionManager>();
Mock <IEventAggregator> mockEventAggregator = new Mock <IEventAggregator>();
mockEventAggregator.Setup(x => x.GetEvent <MarketPricesUpdatedEvent>()).Returns(marketPricesUpdatedEvent);
IWatchListService watchListService = mockWatchListService.Object;
IMarketFeedService marketFeedService = mockMarketFeedService.Object;
IRegionManager regionManager = mockRegionManager.Object;
IEventAggregator eventAggregator = mockEventAggregator.Object;
WatchListViewModel target = new WatchListViewModel(watchListService, marketFeedService, regionManager, eventAggregator);
Dictionary <string, decimal> newPrices = new Dictionary <string, decimal>()
{
{ "A", 10 },
{ "B", 20 },
{ "C", 30 },
};
// Act
marketPricesUpdatedEvent.Publish(newPrices);
// Verify
Assert.AreEqual(3, target.WatchListItems.Count);
Assert.AreEqual(10, target.WatchListItems[0].CurrentPrice);
Assert.AreEqual(20, target.WatchListItems[1].CurrentPrice);
Assert.AreEqual(30, target.WatchListItems[2].CurrentPrice);
}
public void WhenWatchListItemAdded_NavigatesToWatchListView()
{
// Prepare
MockMarketPricesUpdatedEvent marketPricesUpdatedEvent = new MockMarketPricesUpdatedEvent();
ObservableCollection <string> watchList = new ObservableCollection <string>();
watchList.Add("A");
watchList.Add("B");
watchList.Add("C");
Mock <IWatchListService> mockWatchListService = new Mock <IWatchListService>();
mockWatchListService.Setup(x => x.RetrieveWatchList()).Returns(watchList).Verifiable();
Mock <IMarketFeedService> mockMarketFeedService = new Mock <IMarketFeedService>();
mockMarketFeedService.Setup(x => x.GetPrice("A")).Returns(1);
mockMarketFeedService.Setup(x => x.GetPrice("B")).Returns(2);
mockMarketFeedService.Setup(x => x.GetPrice("C")).Returns(3);
Mock <IRegion> mockMainRegion = new Mock <IRegion>();
mockMainRegion.Setup(x => x.RequestNavigate(new Uri("/WatchListView", UriKind.RelativeOrAbsolute), It.IsAny <Action <NavigationResult> >())).Verifiable();
Mock <IRegionManager> mockRegionManager = new Mock <IRegionManager>();
mockRegionManager.Setup(x => x.Regions[RegionNames.MainRegion]).Returns(mockMainRegion.Object);
Mock <IEventAggregator> mockEventAggregator = new Mock <IEventAggregator>();
mockEventAggregator.Setup(x => x.GetEvent <MarketPricesUpdatedEvent>()).Returns(marketPricesUpdatedEvent);
IWatchListService watchListService = mockWatchListService.Object;
IMarketFeedService marketFeedService = mockMarketFeedService.Object;
IRegionManager regionManager = mockRegionManager.Object;
IEventAggregator eventAggregator = mockEventAggregator.Object;
WatchListViewModel target = new WatchListViewModel(watchListService, marketFeedService, regionManager, eventAggregator);
// Act
target.WatchListItems.Add(new WatchItem("D", 20));
// Verify
mockMainRegion.Verify(x => x.RequestNavigate(new Uri("/WatchListView", UriKind.RelativeOrAbsolute), It.IsAny <Action <NavigationResult> >()), Times.Once());
}
public WatchListPresentationModel(IWatchListView view, IWatchListService watchListService, IMarketFeedService marketFeedService, IEventAggregator eventAggregator)
{
this.View = view;
this.HeaderInfo = Resources.WatchListTitle;
this.WatchListItems = new ObservableCollection <WatchItem>();
this.View.SetModel(this);
this.marketFeedService = marketFeedService;
this.watchList = watchListService.RetrieveWatchList();
this.watchList.CollectionChanged += delegate { this.PopulateWatchItemsList(this.watchList); };
this.PopulateWatchItemsList(this.watchList);
this.eventAggregator = eventAggregator;
this.eventAggregator.GetEvent <MarketPricesUpdatedEvent>().Subscribe(this.MarketPricesUpdated, ThreadOption.UIThread);
this.RemoveWatchCommand = new DelegateCommand <string>(this.RemoveWatch);
}
public void WhenRemoveCommandExecuted_RemovesWatchEntry()
{
// Prepare
MockMarketPricesUpdatedEvent marketPricesUpdatedEvent = new MockMarketPricesUpdatedEvent();
ObservableCollection <string> watchList = new ObservableCollection <string>();
watchList.Add("A");
watchList.Add("B");
watchList.Add("C");
Mock <IWatchListService> mockWatchListService = new Mock <IWatchListService>();
mockWatchListService.Setup(x => x.RetrieveWatchList()).Returns(watchList).Verifiable();
Mock <IMarketFeedService> mockMarketFeedService = new Mock <IMarketFeedService>();
mockMarketFeedService.Setup(x => x.GetPrice("A")).Returns(1);
mockMarketFeedService.Setup(x => x.GetPrice("B")).Returns(2);
mockMarketFeedService.Setup(x => x.GetPrice("C")).Returns(3);
Mock <IRegion> mockMainRegion = new Mock <IRegion>();
Mock <IRegionManager> mockRegionManager = new Mock <IRegionManager>();
mockRegionManager.Setup(x => x.Regions[RegionNames.MainRegion]).Returns(mockMainRegion.Object);
Mock <IEventAggregator> mockEventAggregator = new Mock <IEventAggregator>();
mockEventAggregator.Setup(x => x.GetEvent <MarketPricesUpdatedEvent>()).Returns(marketPricesUpdatedEvent);
IWatchListService watchListService = mockWatchListService.Object;
IMarketFeedService marketFeedService = mockMarketFeedService.Object;
IRegionManager regionManager = mockRegionManager.Object;
IEventAggregator eventAggregator = mockEventAggregator.Object;
WatchListViewModel target = new WatchListViewModel(watchListService, marketFeedService, regionManager, eventAggregator);
// Act
target.RemoveWatchCommand.Execute("A");
// Verify
Assert.AreEqual(2, target.WatchListItems.Count);
}
public void WhenCurrentWatchItemSet_TickerSymbolSelectedEventRaised()
{
// Prepare
MockMarketPricesUpdatedEvent marketPricesUpdatedEvent = new MockMarketPricesUpdatedEvent();
Mock <TickerSymbolSelectedEvent> mockTickerSymbolSelectedEvent = new Mock <TickerSymbolSelectedEvent>();
mockTickerSymbolSelectedEvent.Setup(x => x.Publish("B")).Verifiable();
ObservableCollection <string> watchList = new ObservableCollection <string>();
watchList.Add("A");
watchList.Add("B");
watchList.Add("C");
Mock <IWatchListService> mockWatchListService = new Mock <IWatchListService>();
mockWatchListService.Setup(x => x.RetrieveWatchList()).Returns(watchList).Verifiable();
Mock <IMarketFeedService> mockMarketFeedService = new Mock <IMarketFeedService>();
mockMarketFeedService.Setup(x => x.GetPrice("A")).Returns(1);
mockMarketFeedService.Setup(x => x.GetPrice("B")).Returns(2);
mockMarketFeedService.Setup(x => x.GetPrice("C")).Returns(3);
Mock <IRegionManager> mockRegionManager = new Mock <IRegionManager>();
Mock <IEventAggregator> mockEventAggregator = new Mock <IEventAggregator>();
mockEventAggregator.Setup(x => x.GetEvent <MarketPricesUpdatedEvent>()).Returns(marketPricesUpdatedEvent);
mockEventAggregator.Setup(x => x.GetEvent <TickerSymbolSelectedEvent>()).Returns(mockTickerSymbolSelectedEvent.Object);
IWatchListService watchListService = mockWatchListService.Object;
IMarketFeedService marketFeedService = mockMarketFeedService.Object;
IRegionManager regionManager = mockRegionManager.Object;
IEventAggregator eventAggregator = mockEventAggregator.Object;
WatchListViewModel target = new WatchListViewModel(watchListService, marketFeedService, regionManager, eventAggregator);
// Act
target.CurrentWatchItem = target.WatchListItems[1];
// Verify
mockTickerSymbolSelectedEvent.VerifyAll();
}
public void WhenConstructed_IntializesValues()
{
// Prepare
MockMarketPricesUpdatedEvent marketPricesUpdatedEvent = new MockMarketPricesUpdatedEvent();
ObservableCollection <string> watchList = new ObservableCollection <string>();
watchList.Add("A");
watchList.Add("B");
watchList.Add("C");
Mock <IWatchListService> mockWatchListService = new Mock <IWatchListService>();
mockWatchListService.Setup(x => x.RetrieveWatchList()).Returns(watchList).Verifiable();
Mock <IMarketFeedService> mockMarketFeedService = new Mock <IMarketFeedService>();
mockMarketFeedService.Setup(x => x.GetPrice("A")).Returns(1);
mockMarketFeedService.Setup(x => x.GetPrice("B")).Returns(2);
mockMarketFeedService.Setup(x => x.GetPrice("C")).Returns(3);
Mock <IRegionManager> mockRegionManager = new Mock <IRegionManager>();
Mock <IEventAggregator> mockEventAggregator = new Mock <IEventAggregator>();
mockEventAggregator.Setup(x => x.GetEvent <MarketPricesUpdatedEvent>()).Returns(marketPricesUpdatedEvent);
IWatchListService watchListService = mockWatchListService.Object;
IMarketFeedService marketFeedService = mockMarketFeedService.Object;
IRegionManager regionManager = mockRegionManager.Object;
IEventAggregator eventAggregator = mockEventAggregator.Object;
// Act
WatchListViewModel actual = new WatchListViewModel(watchListService, marketFeedService, regionManager, eventAggregator);
// Verify
Assert.IsNotNull(actual);
Assert.AreEqual("WATCH LIST", actual.HeaderInfo);
Assert.AreEqual(3, actual.WatchListItems.Count);
Assert.IsNull(actual.CurrentWatchItem);
Assert.IsNotNull(actual.RemoveWatchCommand);
mockWatchListService.VerifyAll();
}
public WatchListViewModel(IStockTraderRICommandProxy stockTraderRICommandProxy, IWatchListService watchListService, IMarketFeedService marketFeedService, IRegionManager regionManager, IEventAggregator eventAggregator)
{
if (watchListService == null)
{
throw new ArgumentNullException("watchListService");
}
if (stockTraderRICommandProxy == null)
{
throw new ArgumentNullException("stockTraderRICommandProxy");
}
if (eventAggregator == null)
{
throw new ArgumentNullException("eventAggregator");
}
//Init Prperties
this.stockTraderRICommandProxy = stockTraderRICommandProxy;
this.eventAggregator = eventAggregator;
this.watchListService = watchListService;
this.HeaderInfo = Resources.WatchListTitle;
this.WatchListItems = new ObservableCollection <WatchItem>();
this.marketFeedService = marketFeedService;
this.regionManager = regionManager;
// Setup Commands
this.removeWatchCommand = new DelegateCommand <string>(this.RemoveWatch);
// this.AddWatchCommand = new DelegateCommand<string>(AddWatch);
this.stockTraderRICommandProxy.AddToWatchListCommand.RegisterCommand(this.watchListService.AddWatchCommand);
//Setup Subscribers
this.eventAggregator.GetEvent <MarketPricesUpdatedEvent>().Subscribe(this.MarketPricesUpdated, ThreadOption.UIThread);
this.eventAggregator.GetEvent <AddWatchTickerSymbolEvent>().Subscribe(i =>
{
this.PopulateWatchItemsList(watchListService.RetrieveWatchList());
}, ThreadOption.UIThread, true
);
// Populate Watch Items to views
this.PopulateWatchItemsList(watchListService.RetrieveWatchList());
}
public void WhenMarketPriceNotAvailable_PriceSetToNull()
{
// Prepare
MockMarketPricesUpdatedEvent marketPricesUpdatedEvent = new MockMarketPricesUpdatedEvent();
ObservableCollection <string> watchList = new ObservableCollection <string>();
watchList.Add("A");
Mock <IWatchListService> mockWatchListService = new Mock <IWatchListService>();
mockWatchListService.Setup(x => x.RetrieveWatchList()).Returns(watchList).Verifiable();
Mock <IMarketFeedService> mockMarketFeedService = new Mock <IMarketFeedService>();
mockMarketFeedService.Setup(x => x.GetPrice("A")).Throws(new ArgumentException("tickerSymbol"));
Mock <IRegionManager> mockRegionManager = new Mock <IRegionManager>();
Mock <IEventAggregator> mockEventAggregator = new Mock <IEventAggregator>();
mockEventAggregator.Setup(x => x.GetEvent <MarketPricesUpdatedEvent>()).Returns(marketPricesUpdatedEvent);
IWatchListService watchListService = mockWatchListService.Object;
IMarketFeedService marketFeedService = mockMarketFeedService.Object;
IRegionManager regionManager = mockRegionManager.Object;
IEventAggregator eventAggregator = mockEventAggregator.Object;
// Act
WatchListViewModel actual = new WatchListViewModel(watchListService, marketFeedService, regionManager, eventAggregator);
// Verify
Assert.IsNotNull(actual);
Assert.AreEqual(1, actual.WatchListItems.Count);
Assert.AreEqual("A", actual.WatchListItems[0].TickerSymbol);
Assert.AreEqual(null, actual.WatchListItems[0].CurrentPrice);
}
public WatchListViewModel(/*IWatchListService watchListService, */ IMarketFeedService marketFeedService, IRegionManager regionManager, IEventAggregator eventAggregator)
{
HeaderInfo = Resources.WatchListTitle;
WatchListItems = new ObservableCollection <WatchItem>();
this.marketFeedService = marketFeedService;
//this.watchListService = watchListService ?? throw new ArgumentNullException("watchListService");
this.regionManager = regionManager;
//watchList = watchListService.RetrieveWatchList();
//watchList.CollectionChanged += PopulateWatchItemsList(watchList);
//watchList.CollectionChanged += WatchList_CollectionChanged;
//PopulateWatchItemsList(watchList);
//WatchListItems.Add(new WatchItem("STOCK0", 1.00m));
this.eventAggregator = eventAggregator ?? throw new ArgumentNullException("eventAggregator");
this.eventAggregator.GetEvent <MarketPricesUpdatedEvent>().Subscribe(MarketPricesUpdated, ThreadOption.UIThread);
this.eventAggregator.GetEvent <AddWatchStockEvent>().Subscribe(AddWatchStock, ThreadOption.UIThread);
removeWatchCommand = new DelegateCommand <string>(RemoveWatch);
watchListItems.CollectionChanged += WatchListItems_CollectionChanged;
}
public TestableWatchListService(IMarketFeedService marketFeedService)
: base(marketFeedService)
{
}
public ExpertAdvisor(IMarketFeedService marketFeed, IMarketOrderService marketOrder)
{
}
public TestableWatchListService(IMarketFeedService marketFeedService)
: base(marketFeedService)
{
}
