private static DataResult GetLikeCaluseInternal(NonEmptyString fieldName, NonEmptyString paramName, NonEmptyString value, LikeType likeType)
{
var escapeChar = (NonEmptyString)@"\";
var dp = new DynamicParameters();
dp.Add(paramName.Value.ToUpperInvariant(), ToLikeString(value, likeType, escapeChar).Value);
return(new DataResult((NonEmptyString)$@"{fieldName.Value.ToUpperInvariant()} LIKE @{paramName.Value.ToUpperInvariant()} ESCAPE '{escapeChar}'", dp));
}
public static async Task TaskBindT_ReturnNone_Some(NonEmptyString some)
{
var actual = await FromResult(Option.From(some.Get))
.BindTAsync(_ => FromResult(Option <int> .None))
.ConfigureAwait(false);
Assert.True(actual.IsNone);
}
public static void ObjectEquals_SomeSome_SameType_SameValue(NonEmptyString some)
{
var left = Option.From(some.Get);
var right = Option.From(some.Get);
Assert.True(left.Equals(right));
Assert.True(right.Equals(left));
}
public void Should_Not_Be_Able_To_Create_Survey_With_No_Respondent_Type()
{
const string topic = "To be, or not to be?";
const int numberOfRespondents = 1;
const string respondentType = "";
Assert.ThrowsAny <Exception>(() => new Survey(null, NonEmptyString.Create(topic), numberOfRespondents, NonEmptyString.Create(respondentType)));
}
public static void ValueFuncMatchReturn_Some(NonEmptyString some, int noneValue)
{
var actual = Option.From(some.Get).Match(
none: noneValue,
some: v => v.Length);
Assert.Equal(some.Get.Length, actual);
}
public static void Fold_NullFolder_Throws(List <string> collection, NonEmptyString state)
{
var actual = Record.Exception(() => collection.Fold(state.Get, null));
var ane = Assert.IsType <ArgumentNullException>(actual);
Assert.Contains("folder", ane.Message, Ordinal);
}
public static async Task TaskLet_Some_Null_Throws(NonEmptyString some)
{
var actual = await Record.ExceptionAsync(() => Option.From(some.Get).LetAsync(null)).ConfigureAwait(false);
var ane = Assert.IsType <ArgumentNullException>(actual);
Assert.Contains("some", ane.Message, Ordinal);
}
public static void OperatorNotEquals_NoneSome(NonEmptyString some)
{
var left = Option <string> .None;
var right = Option.From(some.Get);
Assert.True(left != right);
Assert.True(right != left);
}
public static void ActionLet_Some_Null_Throws(NonEmptyString some)
{
var actual = Record.Exception(() => Option.From(some.Get).Let(null));
var ane = Assert.IsType <ArgumentNullException>(actual);
Assert.Contains("some", ane.Message, Ordinal);
}
public static void ActionLet_Some(NonEmptyString some, NonEmptyString before)
{
var actual = before.Get;
Option.From(some.Get).Let(v => actual = v);
Assert.Equal(some.Get, actual);
}
public static void ActionLet_None(NonEmptyString before, NonEmptyString sentinel)
{
var actual = before.Get;
Option <string> .None.Let(_ => actual = sentinel.Get);
Assert.Equal(before.Get, actual);
}
private static string ToLikeStringInternal(this string input, NonEmptyString escapeChar)
{
input = input.Replace(escapeChar, string.Format("{0}{0}", escapeChar));
input = input.Replace("%", $"{escapeChar}%");
input = input.Replace("_", $"{escapeChar}_");
input = input.Replace("[", $"{escapeChar}[");
return(input);
}
public static void CopyConstructor_Left(NonEmptyString left)
{
var expected = Either <string, int> .From(left.Get);
var actual = new Either <string, int>(expected);
Assert.Equal(expected, actual);
}
public static void Value_Left_Throws(NonEmptyString left)
{
var actual = Record.Exception(() => Either.From <string, int>(left.Get).Value);
var ioe = Assert.IsType <InvalidOperationException>(actual);
Assert.Contains(EitherIsNotRight, ioe.Message, Ordinal);
}
public static void FuncRecover_Some_Null_Throws(NonEmptyString some)
{
var actual = Record.Exception(() => Option.From(some.Get).Recover(recoverer: (Func <string>)null));
var ane = Assert.IsType <ArgumentNullException>(actual);
Assert.Contains("recoverer", ane.Message, Ordinal);
}
public static void OperatorLogicalAnd_SomeSome(NonEmptyString someLeft, NonEmptyString someRight)
{
var left = Option.From(someLeft.Get);
var right = Option.From(someRight.Get);
Assert.Equal(right, left && right);
Assert.Equal(left, right && left);
}
public static async Task TaskFold_Some(NonEmptyString some, int seed)
{
var actual = await Option.From(some.Get)
.FoldAsync(seed, (s, v) => FromResult(s + v.Length))
.ConfigureAwait(false);
Assert.Equal(seed + some.Get.Length, actual);
}
public static void OperatorNotEquals_SomeSome_SameValue(NonEmptyString some)
{
var left = Option.From(some.Get);
var right = Option.From(some.Get);
Assert.False(left != right);
Assert.False(right != left);
}
public void ReturnsTheSameStringThatPasswordWasCreatedWith(
NonEmptyString nonEmptyString)
{
var passwordString = nonEmptyString.Get;
var password = Password.From(passwordString);
password.ToString().Should().Be(passwordString);
}
public static void CastOk_Err_Throws(NonEmptyString err)
{
var actual = Record.Exception(() => (Version)Try <string, Version> .From(err.Get));
var ane = Assert.IsType <InvalidOperationException>(actual);
Assert.Equal(TryIsNotOk, ane.Message, Ordinal);
}
public Property FastHash_safe_and_unsafe_should_return_same_values(NonEmptyString str)
{
var s = str.Get;
var safe = FastHash.OfString(s);
var un = FastHash.OfStringFast(s);
return((safe == un).Label("Safe and unsafe hash values should match"));
}
public static void ObjectEquals_NoneSome_DifferentType(NonEmptyString some)
{
var left = Option <int> .None;
var right = Option.From(some.Get);
Assert.False(left.Equals(right));
Assert.False(right.Equals(left));
}
public static void OperatorBitwiseOr_NoneSome(NonEmptyString some)
{
var left = Option <string> .None;
var right = Option.From(some.Get);
Assert.Equal(right, left | right);
Assert.Equal(right, right | left);
}
public static void ObjectEquals_SomeSome_DifferentType(NonEmptyString someLeft, int someRight)
{
var left = Option.From(someLeft.Get);
var right = Option.From(someRight);
Assert.False(left.Equals(right));
Assert.False(right.Equals(left));
}
public static void NamedBitwiseAnd_NoneSome(NonEmptyString some)
{
var left = Option <string> .None;
var right = Option.From(some.Get);
Assert.Equal(left, left.BitwiseAnd(right));
Assert.Equal(left, right.BitwiseAnd(left));
}
public void SetsTheEmail(NonEmptyString emailString)
{
var email = Email.From(emailString.Get);
ViewModel.Prepare(EmailParameter.With(email));
ViewModel.Email.Value.Should().Be(email);
}
public static void OperatorLogicalAnd_NoneSome(NonEmptyString some)
{
var left = Option <string> .None;
var right = Option.From(some.Get);
Assert.Equal(left, left && right);
Assert.Equal(left, right && left);
}
public void EvaluatesIndexExpression(NonEmptyString str)
{
var code = $"{escapeString(str.Item)}[0]";
var expected = str.Item[0];
using var scriptHost = BuildScriptHost();
AssertEvaluation(code, expected, scriptHost);
}
public static void NamedBitwiseAnd_SomeSome(NonEmptyString someLeft, NonEmptyString someRight)
{
var left = Option.From(someLeft.Get);
var right = Option.From(someRight.Get);
Assert.Equal(right, left.BitwiseAnd(right));
Assert.Equal(left, right.BitwiseAnd(left));
}
public void SetsTheTitle(NonEmptyString title)
{
var parameters = WorkspaceParameters.Create(10, title.Get, false);
ViewModel.Prepare(parameters);
ViewModel.Title.Should().Be(title.Get);
}
/// <summary>
/// Sends SMTP email using .config file settings.
/// </summary>
/// <param name="isBodyHtml"></param>
/// <param name="optioanlFromAddress">If null, .config from address value is used.</param>
/// <param name="optionalReplyToAddress">If null, reply-to address is the same as from address.</param>
/// <param name="subject"></param>
/// <param name="body"></param>
/// <param name="toAddresses"></param>
public static void SendSmtpEmail(bool isBodyHtml, NonEmptyString optioanlFromAddress, NonEmptyString optionalReplyToAddress, string subject, string body, params string[] toAddresses)
{
if(toAddresses != null)
toAddresses = toAddresses.Where(addr => !addr.IsBlank()).ToArray();
if(toAddresses.IsNullOrEmpty())
throw new Exception("\"To\" address must be specified");
if(subject.IsBlank() && body.IsBlank())
throw new Exception("Both subject and message body cannot be blank.");
MailMessage message = new MailMessage();
if(optioanlFromAddress != null)
message.From = new MailAddress(optioanlFromAddress);
if(optionalReplyToAddress != null)
message.ReplyToList.Add(new MailAddress(optionalReplyToAddress));
toAddresses.ForEach(toAddr => message.To.Add(new MailAddress(toAddr)));
message.Subject = subject;
message.Body = body;
message.IsBodyHtml = isBodyHtml;
SmtpClient smtpClient = SmtpClientFactory == null ? null : SmtpClientFactory();
if(smtpClient == null)
smtpClient = new SmtpClient();
using(smtpClient)
{
smtpClient.Send(message);
}
}
