public void GuardAgainstNull_Null_ThrowsException()
{
var ex1 = Assert.Throws <ArgumentNullException>(() =>
{
object myParam = null;
Guard.Against.Null(myParam, nameof(myParam));
});
Assert.Equal("Parameter cannot be null. (Parameter 'myParam')", ex1.Message);
var ex2 = Assert.Throws <ArgumentNullException>(() =>
{
object param1 = new object();
object param2 = new object();
object param3 = null;
object param4 = null;
Guard.Against
.Null(param1, nameof(param1))
.Null(param2, nameof(param2))
.Null(param3, nameof(param3))
.Null(param4, nameof(param4));
});
Assert.Equal("Parameter cannot be null. (Parameter 'param3')", ex2.Message);
}
public void GuardAgainstNullOrWhiteSpace_NotEmpty_DoesNotThrowsException()
{
string param = "value";
Assert.DoesNotThrows(() => Guard.Against.NullOrWhiteSpace(param, nameof(param)));
Assert.DoesNotThrows(() => Guard.Against.NullOrWhiteSpace(param, nameof(param), "My custom error message"));
}
public void GuardAgainstZeroOrLess_ZeroOrLess_ThrowsException(int zeroOrLess)
{
var ex1 = Assert.Throws <ArgumentException>(() => Guard.Against.ZeroOrLess(zeroOrLess, nameof(zeroOrLess)));
AssertMessage(ex1.Message);
var ex2 = Assert.Throws <ArgumentException>(() => Guard.Against.ZeroOrLess(Convert.ToDecimal(zeroOrLess), nameof(zeroOrLess)));
AssertMessage(ex2.Message);
var ex3 = Assert.Throws <ArgumentException>(() => Guard.Against.ZeroOrLess(Convert.ToDouble(zeroOrLess), nameof(zeroOrLess)));
AssertMessage(ex3.Message);
void AssertMessage(string actualMessage)
{
if (zeroOrLess == 0)
{
Assert.Equal("Number cannot be zero. (Parameter 'zeroOrLess')", actualMessage);
}
else
{
Assert.Equal("Number cannot be negative. (Parameter 'zeroOrLess')", actualMessage);
}
}
}
public void GuardAgainstFalse_False_ThrowsException()
{
var ex1 = Assert.Throws <ArgumentException>(() =>
{
bool myParam = false;
Guard.Against.False(myParam, nameof(myParam));
});
Assert.Equal("Parameter cannot be false. (Parameter 'myParam')", ex1.Message);
var ex2 = Assert.Throws <ArgumentException>(() =>
{
string myParam = "abc";
Guard.Against.False(_ => myParam == "a");
});
Assert.Equal("Predicate cannot be false.", ex2.Message);
var ex3 = Assert.Throws <ArgumentException>(() =>
{
string myParam = "abc";
Guard.Against.False(_ => myParam == "a", "My message when the expression is false!");
});
Assert.Equal("My message when the expression is false!", ex3.Message);
}
public void GuardAgainstNotExists_NotExists_ThrowsException(int value)
{
var orderStatus = (OrderStatus)value;
var ex = Assert.Throws <ArgumentException>(() => Guard.Against.NotExists(orderStatus));
Assert.Equal($"{value} not exists in the OrderStatus.", ex.Message);
}
public void NewEmail_ToString_StringEmail()
{
const string expected = "*****@*****.**";
Assert.Equal(expected, new Email(expected).ToString());
Assert.Equal(expected, ((Email)expected).ToString());
Assert.Equal(expected, Email.NewEmail(expected).ToString());
}
public void DoesNotThrows_TestCode_DoesNotThrows()
{
Assert.DoesNotThrows(() =>
{
object param = new object();
Guard.Against.Null(param, nameof(param));
});
}
public void NewUrl_ToString_StringUrl()
{
const string expected = "https://www.domain.com";
Assert.Equal(expected, new Url(expected).ToString());
Assert.Equal(expected, ((Url)expected).ToString());
Assert.Equal(expected, Url.NewUrl(expected).ToString());
}
public void GuardAgainstNotEmpty_Empty_DoesNotThrows()
{
Assert.DoesNotThrows(() =>
{
var myGuid = Guid.Empty;
Guard.Against.NotEmpty(myGuid, nameof(myGuid));
});
}
public void CreateInstance_NullOrEmptyNif_InstanceCreated(string nullOrEmptyNif)
{
Assert.DoesNotThrows(() =>
{
var nif = ActivatorHelper.CreateInstance <Nif>(nullOrEmptyNif);
Assert.NotNull(nif);
});
}
public void GuardAgainstTrue_False_DoesNotThrows()
{
Assert.DoesNotThrows(() =>
{
bool myParam = false;
Guard.Against.True(myParam, nameof(myParam));
Guard.Against.True(_ => "a" == "b", nameof(myParam));
});
}
public void CreateInstance_NotEmptyNif_InstanceCreated(string notEmptyNif)
{
Assert.DoesNotThrows(() =>
{
var nif = ActivatorHelper.CreateInstance <Nif>(notEmptyNif);
Assert.NotNull(nif);
Assert.Equal(notEmptyNif, nif.Value);
});
}
public void GuardAgainstFalse_True_DoesNotThrows()
{
Assert.DoesNotThrows(() =>
{
bool myParam = true;
Guard.Against.False(myParam, nameof(myParam));
Guard.Against.False(_ => "ab" == "ab", nameof(myParam));
});
}
public void EnsureContentType_NotUtf8ApplicationJson_ThrowsException(string encoding, string mediaType)
{
var response = new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent(string.Empty, Encoding.GetEncoding(encoding), mediaType)
};
Assert.Throws <HttpRequestException>(() => response.EnsureContentType());
}
public void GuardAgainstEmpty_Empty_ThrowsException()
{
var ex = Assert.Throws <ArgumentException>(() =>
{
var myGuid = Guid.Empty;
Guard.Against.Empty(myGuid, nameof(myGuid));
});
Assert.Equal("Guid cannot be empty. (Parameter 'myGuid')", ex.Message);
}
public void GuardAgainstNotEmpty_NotEmpty_ThrowsException()
{
var ex = Assert.Throws <ArgumentException>(() =>
{
var myGuid = Guid.NewGuid();
Guard.Against.NotEmpty(myGuid, nameof(myGuid));
});
Assert.Equal("Guid should be empty. (Parameter 'myGuid')", ex.Message);
}
public void GuardAgainstEmpty_Empty_ThrowsException()
{
var ex = Assert.Throws <ArgumentException>(() =>
{
var myCollection = new List <int>();
Guard.Against.Empty(myCollection, nameof(myCollection));
});
Assert.Equal("Collection cannot be empty. (Parameter 'myCollection')", ex.Message);
}
public void GuardAgainstNullOrWhiteSpace_NullOrWhiteSpace_ThrowsException(string myParam)
{
var ex1 = Assert.Throws <ArgumentNullException>(() => Guard.Against.NullOrWhiteSpace(myParam, nameof(myParam)));
Assert.Equal("Parameter cannot be null, empty or consists exclusively of white-space characters. (Parameter 'myParam')", ex1.Message);
var ex2 = Assert.Throws <ArgumentNullException>(() => Guard.Against.NullOrWhiteSpace(myParam, nameof(myParam), "My custom error message"));
Assert.Equal("My custom error message (Parameter 'myParam')", ex2.Message);
}
public void GuardAgainstNotEmpty_Empty_DoesNotThrows()
{
Assert.DoesNotThrows(() =>
{
var myCollection1 = new List <int>();
Guard.Against.NotEmpty(myCollection1, nameof(myCollection1));
var myCollection2 = new List <string>();
Guard.Against.NotEmpty(myCollection1, nameof(myCollection2));
});
}
public void NewEmail_InvalidEmail_ThrowsException(string invalidEmail)
{
var ex1 = Assert.Throws <FormatException>(() => new Email(invalidEmail));
Assert.Equal($"Invalid e-mail address: {invalidEmail}.", ex1.Message);
var ex2 = Assert.Throws <FormatException>(() => (Email)invalidEmail);
Assert.Equal($"Invalid e-mail address: {invalidEmail}.", ex2.Message);
var ex3 = Assert.Throws <FormatException>(() => Email.NewEmail(invalidEmail));
Assert.Equal($"Invalid e-mail address: {invalidEmail}.", ex3.Message);
}
public void NewUrl_InvalidUrl_ThrowsException(string invalidUrl)
{
var ex1 = Assert.Throws <FormatException>(() => new Url(invalidUrl));
Assert.Equal($"Invalid URL: {invalidUrl}.", ex1.Message);
var ex2 = Assert.Throws <FormatException>(() => (Url)invalidUrl);
Assert.Equal($"Invalid URL: {invalidUrl}.", ex2.Message);
var ex3 = Assert.Throws <FormatException>(() => Url.NewUrl(invalidUrl));
Assert.Equal($"Invalid URL: {invalidUrl}.", ex3.Message);
}
public void NewNif_InvalidNif_ThrowsException(string invalidNif)
{
var ex1 = Assert.Throws <FormatException>(() => new Nif(invalidNif));
Assert.Equal($"Invalid NIF: {invalidNif}.", ex1.Message);
var ex2 = Assert.Throws <FormatException>(() => (Nif)invalidNif);
Assert.Equal($"Invalid NIF: {invalidNif}.", ex2.Message);
var ex3 = Assert.Throws <FormatException>(() => Nif.NewNif(invalidNif));
Assert.Equal($"Invalid NIF: {invalidNif}.", ex3.Message);
}
public async Task DeserializeAsync_Literal_LiteralDeserialized()
{
// Arrange
const string json = "true";
var response = new HttpResponseMessage
{
Content = new StringContent(json, Encoding.UTF8, "application/json")
};
// Act
var result = await response.DeserializeAsync <bool>();
// Assert
Assert.True(result);
}
public void GuardAgainstPositive_Positive_ThrowsException(int positive)
{
var ex1 = Assert.Throws <ArgumentException>(() => Guard.Against.Positive(positive, nameof(positive)));
AssertMessage(ex1.Message);
var ex2 = Assert.Throws <ArgumentException>(() => Guard.Against.Positive(Convert.ToDecimal(positive), nameof(positive)));
AssertMessage(ex2.Message);
var ex3 = Assert.Throws <ArgumentException>(() => Guard.Against.Positive(Convert.ToDouble(positive), nameof(positive)));
AssertMessage(ex3.Message);
void AssertMessage(string actualMessage) => Assert.Equal("Number cannot be positive. (Parameter 'positive')", actualMessage);
}
public void GuardAgainstLessThan5_LessThan5_ThrowsException(int lessThan5)
{
var ex1 = Assert.Throws <ArgumentException>(() => Guard.Against.LessThan(5, lessThan5, nameof(lessThan5)));
AssertMessage(ex1.Message);
var ex2 = Assert.Throws <ArgumentException>(() => Guard.Against.LessThan(Convert.ToDecimal(5), lessThan5, nameof(lessThan5)));
AssertMessage(ex2.Message);
var ex3 = Assert.Throws <ArgumentException>(() => Guard.Against.LessThan(Convert.ToDouble(5), lessThan5, nameof(lessThan5)));
AssertMessage(ex3.Message);
void AssertMessage(string actualMessage) => Assert.Equal($"Number cannot be less than {lessThan5}. (Parameter 'lessThan5')", actualMessage);
}
public void EnsureContentType_DefaultContentType_DoesNotThrowsException()
{
var response1 = new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent(string.Empty, Encoding.UTF8, "application/json")
};
Assert.DoesNotThrows(() => response1.EnsureContentType());
var response2 = new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent(string.Empty, Encoding.ASCII, "text/html")
};
Assert.DoesNotThrows(() => response2.EnsureContentType("text/html; charset=us-ascii"));
}
public void NewNif_Value_ProperInstantiated()
{
var nif1 = new Nif("502155051");
Assert.Equal("502155051", nif1.Value);
Assert.Equal("502155051", nif1.ToString());
var nif2 = (Nif)"502155051";
Assert.Equal("502155051", nif2.Value);
Assert.Equal("502155051", nif2.ToString());
var nif3 = Nif.NewNif("502155051");
Assert.Equal("502155051", nif3.Value);
Assert.Equal("502155051", nif3.ToString());
}
public void GuardAgainstZero_Zero_ThrowsException()
{
var zero = 0;
var ex1 = Assert.Throws <ArgumentException>(() => Guard.Against.Zero(zero, nameof(zero)));
AssertMessage(ex1.Message);
var ex2 = Assert.Throws <ArgumentException>(() => Guard.Against.Zero(Convert.ToDecimal(zero), nameof(zero)));
AssertMessage(ex2.Message);
var ex3 = Assert.Throws <ArgumentException>(() => Guard.Against.Zero(Convert.ToDouble(zero), nameof(zero)));
AssertMessage(ex3.Message);
void AssertMessage(string actualMessage) => Assert.Equal("Number cannot be zero. (Parameter 'zero')", actualMessage);
}
public void GuardAgainstNull_NotNull_DoesNotThrowsException()
{
Assert.DoesNotThrows(() =>
{
object param = new object();
Guard.Against.Null(param, nameof(param));
});
Assert.DoesNotThrows(() =>
{
object param1 = new object();
object param2 = new object();
object param3 = new object();
object param4 = new object();
Guard.Against
.Null(param1, nameof(param1))
.Null(param2, nameof(param2))
.Null(param3, nameof(param3))
.Null(param4, nameof(param4));
});
}
public async Task DeserializeAsync_Poco_PocoDeserialized()
{
// Arrange
const string json = @"{
""age"": 35,
""name"": ""Peter"",
""enabled"": true
}";
var response = new HttpResponseMessage
{
Content = new StringContent(json, Encoding.UTF8, "application/json")
};
// Act
var result = await response.DeserializeAsync <ViewModelDummy>();
// Assert
Assert.Equal(35, result.Age);
Assert.Equal("Peter", result.Name);
Assert.True(result.Enabled);
}
