public void CreateMaybe_ShouldCreateWithoutParameters() { var response = Maybe <Student> .Create(); response.HasValue.Should().BeFalse(); response.Value.Should().BeNull(); }
public void GetSecurityPrices_WhenAllTickersExistButInvalidTradeDateProvided_FailureResultWithInvalidTradeDateError() { // Arrange var tickers = new List <string>() { "MSFT", "INTC" }; var tradeDateRepository = new Mock <ITradeDateRepository>(MockBehavior.Strict); tradeDateRepository.Setup(r => r.GetTradeDate(DATE_DEC_31_2016)) .Returns(Maybe.Create <TradeDate>(null)); var securityRepository = new Mock <ISecurityRepository>(MockBehavior.Strict); var securityPriceRepository = new Mock <ISecurityPriceRepository>(MockBehavior.Strict); // Act SecurityPriceService service = new SecurityPriceService(tradeDateRepository.Object, securityRepository.Object, securityPriceRepository.Object); var result = service.GetSecurityPrices(DATE_DEC_31_2016, tickers); // Assert result.IsSuccess.Should().BeFalse(); result.Error.Should().BeOfType <InvalidTradeDateError>(); result.Error.As <InvalidTradeDateError>().Date.Should().Be(DATE_DEC_31_2016); result.Value.Should().BeNull(); tradeDateRepository.Verify(r => r.GetLatestTradeDate(), Times.Never); tradeDateRepository.Verify(r => r.GetTradeDate(DATE_DEC_31_2016), Times.Once); tradeDateRepository.Verify(r => r.GetTradeDates(), Times.Never); }
public async Task <Maybe <ISymbol> > TryGetCurrentSymbolAsync() { var activeTextView = await GetActiveTextViewAsync(); if (activeTextView == null) { return(Maybe <ISymbol> .Nothing); } var document = GetCurrentDocument(activeTextView); if (document == null) { return(Maybe <ISymbol> .Nothing); } var syntaxTree = await document.GetSyntaxTreeAsync(); var syntaxRoot = await syntaxTree.GetRootAsync(); var span = GetSelection(activeTextView); var currentNode = syntaxRoot.FindNode(span); var semanticModel = await document.GetSemanticModelAsync(); var symbol = GetSymbolForSyntaxNode(semanticModel, currentNode); return(Maybe.Create(symbol)); }
public void GetSecurityPrices_WhenValidDateProvidedButNoPricingData_FailureResultReturnedWithApplicationError() { var tradeDateRepository = new Mock <ITradeDateRepository>(MockBehavior.Strict); tradeDateRepository.Setup(r => r.GetTradeDate(DATE_DEC_29_2016)) .Returns(Maybe.Create <TradeDate>(TRADE_DATE_DEC_29_2016)); var securityRepository = new Mock <ISecurityRepository>(MockBehavior.Strict); var securityPriceRepository = new Mock <ISecurityPriceRepository>(MockBehavior.Strict); securityPriceRepository.Setup(r => r.GetSecurityPrices(TRADE_DATE_DEC_29_2016)) .Returns(new List <SecurityPrice>()); // Empty list of prices = no pricing data // Act SecurityPriceService service = new SecurityPriceService(tradeDateRepository.Object, securityRepository.Object, securityPriceRepository.Object); var result = service.GetSecurityPrices(DATE_DEC_29_2016); // Assert result.IsSuccess.Should().BeFalse(); result.Error.Should().BeOfType <ApplicationError>(); result.Value.Should().BeNull(); tradeDateRepository.Verify(r => r.GetTradeDate(DATE_DEC_29_2016), Times.Once); tradeDateRepository.Verify(r => r.GetLatestTradeDate(), Times.Never); tradeDateRepository.Verify(r => r.GetTradeDates(), Times.Never); securityPriceRepository.Verify(r => r.GetSecurityPrices(TRADE_DATE_DEC_29_2016), Times.Once); }
/// <summary> /// Creates a TaskItemDAL from a TaskItem and CreateTaskInput /// </summary> /// <param name="taskItem"> /// Will have its data used to create a TaskItemDAL /// </param> /// <param name="input"> /// </param> /// <returns> /// TaskItemDAL created from the data of the taskItem parameter /// </returns> /* * TODO: this should probably end up in a conversion class, of some sort, in the application * layer */ private TaskItemDAL TaskItemAndInputToDAL(TaskItem taskItem, CreateTaskInput input) { Maybe <CustomNotificationFrequencyDAL> notificationFrequency = Maybe <CustomNotificationFrequencyDAL> .CreateEmpty(); //if the new task should have a custom notification frequency if (input.NotificationFrequencyType == NotificationFrequencyType.Custom) { //create a custom notification frequency DAL notificationFrequency = Maybe <CustomNotificationFrequencyDAL> .Create( new CustomNotificationFrequencyDAL( taskItem.ID, input.CustomNotificationFrequency ) ); } return(new TaskItemDAL( taskItem.ID, taskItem.Title, taskItem.Description, taskItem.StartTime, taskItem.LastNotificationTime, taskItem.Colour.R, taskItem.Colour.G, taskItem.Colour.B, notificationFrequency, (int)input.NotificationFrequencyType )); }
public void GetSecurityPrices_WhenDateProvided_PricesForThatPricingDateAreReturned() { var tradeDateRepository = new Mock <ITradeDateRepository>(MockBehavior.Strict); tradeDateRepository.Setup(r => r.GetTradeDate(DATE_DEC_29_2016)) .Returns(Maybe.Create <TradeDate>(TRADE_DATE_DEC_29_2016)); var securityRepository = new Mock <ISecurityRepository>(MockBehavior.Strict); var securityPriceRepository = new Mock <ISecurityPriceRepository>(MockBehavior.Strict); securityPriceRepository.Setup(r => r.GetSecurityPrices(TRADE_DATE_DEC_29_2016)) .Returns(new List <SecurityPrice>() { PRICE_MSFT_DEC_29, PRICE_INTC_DEC_29, PRICE_JPM_DEC_29 }); // Act SecurityPriceService service = new SecurityPriceService(tradeDateRepository.Object, securityRepository.Object, securityPriceRepository.Object); var result = service.GetSecurityPrices(DATE_DEC_29_2016); // Assert result.IsSuccess.Should().BeTrue(); result.Value.Count.Should().Be(3); result.Value.Any(s => s.Ticker == "MSFT" && s.TradeDate == DATE_DEC_29_2016).Should().BeTrue(); result.Value.Any(s => s.Ticker == "INTC" && s.TradeDate == DATE_DEC_29_2016).Should().BeTrue(); result.Value.Any(s => s.Ticker == "JPM" && s.TradeDate == DATE_DEC_29_2016).Should().BeTrue(); tradeDateRepository.Verify(r => r.GetTradeDate(DATE_DEC_29_2016), Times.Once); tradeDateRepository.Verify(r => r.GetLatestTradeDate(), Times.Never); tradeDateRepository.Verify(r => r.GetTradeDates(), Times.Never); securityPriceRepository.Verify(r => r.GetSecurityPrices(TRADE_DATE_DEC_29_2016), Times.Once); }
private static IEnumerable <TestCaseData> MaybeEqualsMaybeTestCases() { yield return(new TestCaseData( Maybe <int> .Empty(), Maybe <int> .Create(5), false ).SetName("Empty == Maybe(5) should be false")); yield return(new TestCaseData( Maybe <int> .Create(5), Maybe <int> .Empty(), false ).SetName("Maybe(5) == Empty should be false")); yield return(new TestCaseData( Maybe <int> .Create(5), Maybe <int> .Create(5), true ).SetName("Maybe(5) == Maybe(5) should be true")); yield return(new TestCaseData( Maybe <int> .Create(5), Maybe <int> .Create(6), false ).SetName("Maybe(5) == Maybe(6) should be false")); }
public void Create___Invoked_with_a_String_value___Returns_a_Something() { var something = Maybe.Create("Hello World!"); something.HasValue.Should().BeTrue(); something.Value.Should().BeEquivalentTo("Hello World!"); }
public static void NewWithNullArgumentHasValue() { object?value = null; var maybe = Maybe.Create(value); Assert.True(maybe.HasValue); Assert.Null(maybe.Value); }
public void TestFlattenInnerJust() { var instance = Maybe <Maybe <int> > .Just(Maybe.Create(1)); var result = instance.Flatten(); result.AssertJust(1); }
public void CoalesceShouldReturnValueWhenHasValue() { var value = Maybe <int> .Create(5); var result = value.Coalesce(3); result.Should().Be(5); }
public static void NewWithArgumentHasValue() { const string expect = nameof(NewWithArgumentHasValue); var maybe = Maybe.Create(expect); Assert.True(maybe.HasValue); Assert.Equal(expect, maybe.Value); }
public Maybe <TradeDate> GetTradeDate(DateTime date) { using (var connection = new SqlConnection(_connectionString)) { connection.Open(); var tradeDate = connection.QueryFirstOrDefault <TradeDate>(SINGLE_TRADE_DATE_SQL, new { TradeDate = date.Date }); return(Maybe.Create <TradeDate>(tradeDate)); } }
public Maybe <TradeDate> GetLatestTradeDate() { using (var connection = new SqlConnection(_connectionString)) { connection.Open(); var tradeDate = connection.QueryFirstOrDefault <TradeDate>(LATEST_TRADE_DATE_SQL); return(Maybe.Create <TradeDate>(tradeDate)); } }
public void CreateMaybe_ShouldCreateEncapsulatingStudent() { var student = StudentFake(); var response = Maybe <Student> .Create(student); response.HasValue.Should().BeTrue(); response.Value.Should().Be(student); }
public void CreateMaybe_ShouldCreateWithoutParameters() { var student = StudentFake(); var response = Maybe <Student> .Create(student); response.HasValue.Should().BeTrue(); response.Value.Should().Be(student); }
public void ApplyShouldCallFunctionWhenHasValue() { var none = Maybe <int> .Create(5); var action = A.Fake <Action <int> >(); none.Apply(action); A.CallTo(() => action.Invoke(5)).MustHaveHappened(); }
public void MapShouldCallFunctionWhenHasValue() { var none = Maybe <int> .Create(5); var mapFunction = A.Fake <Func <int, Maybe <int> > >(); none.Map(mapFunction); A.CallTo(() => mapFunction.Invoke(5)).MustHaveHappened(); }
public void MapEach_Maybe___On_IEnumerable_of_Null___Throws_ArgumentNullException() { var maybes = (IEnumerable <Maybe <int> >)null; Action act = () => { var _ = maybes.MapEach(m => Maybe.Create(m.ToString()), () => Maybe.Create("Nothing")).ToList(); }; act.Should().Throw <ArgumentNullException>(); }
public void WhenMaybeObjectContainsNoValueNoValueFunctionCalledInBind() { var maybe = Maybe.Create <Customer>(null); var firstName = maybe.Eval( (customer) => customer.FirstName, () => "None" ); firstName.Should().Be("None"); }
public void HasValueIsTrueForMaybeObjectWithValue() { Customer customer = new Customer() { Id = 1, FirstName = "John", LastName = "Smith" }; var maybe = Maybe.Create(customer); maybe.HasValue.Should().BeTrue(); }
public void CanConstructMaybeObjectWithValueIsObject() { Customer customer = new Customer() { Id = 1, FirstName = "John", LastName = "Smith" }; var value = Maybe.Create(customer); value.Should().NotBeNull(); }
public void TestCreateReferenceValue() { var value = new TestRef(); var instance = Maybe.Create(value); instance.AssertJust(value); value = null; instance = Maybe.Create(value); instance.AssertNothing(); }
public void TestCreateNullableValue() { var value = (bool?)true; var instance = Maybe.Create(value); instance.AssertJust((bool)value); value = null; instance = Maybe.Create(value); instance.AssertNothing(); }
public Maybe <IModelNode> TryGetParentNode(ModelNodeId modelNodeId) { var parentNodes = GetRelatedNodes(modelNodeId, CommonDirectedModelRelationshipTypes.Container).ToList(); if (parentNodes.Count > 1) { throw new Exception($"There are {parentNodes.Count} parent nodes for node {modelNodeId}."); } return(Maybe.Create(parentNodes.SingleOrDefault())); }
public static IEnumerable <object[]> ISerialize___TestData() { return(new List <object[]> { new object[] { Maybe.Create("Hello world!"), "\u0001h\u0001m\0\u0001\u0001\u0002\0\0\0\u0001\u0006\u0003\0\0\0\fHello world!\v" }, new object[] { Maybe.Nothing <string>(), "\u0001h\u0001m\0\u0001\u0001\u0002\0\0\0\0\n\v" }, new object[] { Maybe.Create(42), "\u0001h\u0001m\0\0\u0001\b\u0002\0\0\0\u0001*\0\0\0\v" }, new object[] { Maybe.Nothing <int>(), "\u0001h\u0001m\0\0\u0001\b\u0002\0\0\0\0\0\0\0\0\v" } }); }
public void MapEach_Maybe___On_IEnumerable_of_Maybe___All_Maybe_mapped() { var array = new[] { Maybe.Create(42), Maybe.Nothing <int>(), Maybe.Create(17) }; var results = array.MapEach(m => Maybe.Create(m.ToString()), () => Maybe.Create("Nothing")); var list = results.ToList(); list.Count.Should().Be(3); list[0].Should().BeEquivalentTo(Maybe.Create("42")); list[1].Should().BeEquivalentTo(Maybe.Create("Nothing")); list[2].Should().BeEquivalentTo(Maybe.Create("17")); }
public Maybe <Security> GetSecurity(string ticker) { String sql = $@"{BASE_SQL} WHERE s.Ticker = @Ticker"; using (var connection = new SqlConnection(_connectionString)) { connection.Open(); var security = connection.QueryFirstOrDefault <Security>(sql, new { Ticker = ticker }); return(Maybe.Create <Security>(security)); } }
public void InvokeEach___On_IEnumerable_of_Maybe___All_Maybe_invoked() { var array = new[] { Maybe.Create(42), Maybe.Nothing <int>(), Maybe.Create(17) }; var results = new Collection <string>(); array.InvokeEach(m => results.Add(m.ToString()), () => results.Add("Nothing")); results.Count.Should().Be(3); results[0].Should().BeEquivalentTo("42"); results[1].Should().BeEquivalentTo("Nothing"); results[2].Should().BeEquivalentTo("17"); }
public void ValuePropertyContainsTheValueObject() { Customer customer = new Customer() { Id = 1, FirstName = "John", LastName = "Smith" }; var maybe = Maybe.Create(customer); maybe.Value.Id.Should().Be(1); maybe.Value.FirstName.Should().Be("John"); maybe.Value.LastName.Should().Be("Smith"); }