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");
}
