public virtual void Formatter_iterates_IEnumerable_property_when_its_actual_type_is_an_array_of_objects()
{
Formatter <Node> .RegisterForMembers();
var node = new Node
{
Id = "1",
Nodes =
new[]
{
new Node {
Id = "1.1"
},
new Node {
Id = "1.2"
},
new Node {
Id = "1.3"
},
}
};
var output = node.ToLogString();
StringAssert.Contains("1.1", output);
StringAssert.Contains("1.2", output);
StringAssert.Contains("1.3", output);
}
public void KapacitetTestCase3()
{
string rezultat3 = sekretarica.povecajKapacitet(55);
StringAssert.AreEqualIgnoringCase(rezultat3,
"Kapacitet uspješno povećan sa 2 na 57 poruka, a to vas je koštalo =76.725 KM.");
}
public void Formatter_iterates_IEnumerable_property_when_its_reflected_type_is_array()
{
Log.Formatters.RegisterPropertiesFormatter <Node>();
var node = new Node
{
Id = "1",
NodesArray =
new[]
{
new Node {
Id = "1.1"
},
new Node {
Id = "1.2"
},
new Node {
Id = "1.3"
},
}
};
var output = node.ToLogString();
StringAssert.Contains("1.1", output);
StringAssert.Contains("1.2", output);
StringAssert.Contains("1.3", output);
}
public void KapacitetTestCase1()
{
string rezultat1 = sekretarica.povecajKapacitet(19);
StringAssert.AreEqualIgnoringCase(rezultat1,
"Kapacitet uspješno povećan sa 2 na 21 poruka, a to vas je koštalo =29.45 KM.");
}
public void KapacitetTestCase2()
{
string rezultat2 = sekretarica.povecajKapacitet(22);
StringAssert.AreEqualIgnoringCase(rezultat2,
"Kapacitet uspješno povećan sa 2 na 24 poruka, a to vas je koštalo =32.395 KM.");
}
public void GenerateSchemaWithStringEnum()
{
JSchemaGenerator generator = new JSchemaGenerator();
generator.GenerationProviders.Add(new StringEnumGenerationProvider
{
CamelCaseText = true
});
JSchema schema = generator.Generate(typeof(Y));
string json = schema.ToString();
StringAssert.AreEqual(@"{
""type"": ""object"",
""properties"": {
""y"": {
""type"": ""string"",
""enum"": [
""no"",
""asc"",
""desc""
]
}
},
""required"": [
""y""
]
}", json);
}
private static void AssertStringContains(AssertionException result, string expectedMessage, string lambdaDescription)
{
StringAssertEx.Contains(lambdaDescription, result.Message);
var replace = result.Message.Replace(lambdaDescription, "");
StringAssertEx.Contains(expectedMessage, replace);
}
public void Generate_Person()
{
JSchemaGenerator generator = new JSchemaGenerator();
JSchema schema = generator.Generate(typeof(Person));
string json = schema.ToString();
StringAssert.AreEqual(@"{
""id"": ""Person"",
""title"": ""Title!"",
""description"": ""JsonObjectAttribute description!"",
""type"": ""object"",
""properties"": {
""Name"": {
""type"": [
""string"",
""null""
]
},
""BirthDate"": {
""type"": ""string""
},
""LastModified"": {
""type"": ""string""
}
},
""required"": [
""Name"",
""BirthDate"",
""LastModified""
]
}", json);
}
public void Generate_DefaultValueAttributeTestClass()
{
JSchemaGenerator generator = new JSchemaGenerator();
JSchema schema = generator.Generate(typeof(DefaultValueAttributeTestClass));
string json = schema.ToString();
Console.WriteLine(json);
StringAssert.AreEqual(@"{
""type"": ""object"",
""additionalProperties"": false,
""properties"": {
""TestField1"": {
""type"": ""integer"",
""default"": 21
},
""TestProperty1"": {
""type"": [
""string"",
""null""
],
""default"": ""TestProperty1Value""
}
},
""required"": [
""TestField1"",
""TestProperty1""
]
}", json);
}
public void Test_Worker_Pkg()
{
var sut = new PackageUpdaterWorker();
var executablePackage = sut.GetExecutablePackage(new FileInfo(Path.Combine(this.Update11Folder.FullName, "MyPackageBasedApp Update v. 1.1.pkg")));
StringAssert.EndsWith(@"\PackagedApp\Updates\1.1\MyPackageBasedApp Update v. 1.1.pkg", executablePackage.FullName);
Assert.IsTrue(executablePackage.Exists);
}
public void Generate_UserNullable()
{
JSchemaGenerator generator = new JSchemaGenerator();
JSchema schema = generator.Generate(typeof(UserNullable));
string json = schema.ToString();
StringAssert.AreEqual(@"{
""type"": ""object"",
""properties"": {
""Id"": {
""type"": ""string""
},
""FName"": {
""type"": [
""string"",
""null""
]
},
""LName"": {
""type"": [
""string"",
""null""
]
},
""RoleId"": {
""type"": ""integer""
},
""NullableRoleId"": {
""type"": [
""integer"",
""null""
]
},
""NullRoleId"": {
""type"": [
""integer"",
""null""
]
},
""Active"": {
""type"": [
""boolean"",
""null""
]
}
},
""required"": [
""Id"",
""FName"",
""LName"",
""RoleId"",
""NullableRoleId"",
""NullRoleId"",
""Active""
]
}", json);
}
public void Test_Worker_ZippedPkg()
{
//package which is donwloaded needs to be extracted, hence the expected executable package is in _Extracted folder
var sut = new PackageUpdaterWorker();
var executablePackage = sut.GetExecutablePackage(new FileInfo(Path.Combine(this.Update12Folder.FullName, "1.2", "MyPackageBasedApp Update v. 1.2.zip")));
Assert.IsTrue(executablePackage.Exists);
StringAssert.EndsWith(@"\PackagedApp\Updates\1.2\1.2 Extracted\UpdatePackage.pkg", executablePackage.FullName);
}
public void AddTeacher_WhenTeacherIsNull_ShouldThrowArgumentNullException()
{
var id = 100;
ITeacher nullTeacher = null;
var ex = Assert.Throws <ArgumentNullException>(() => SchoolSystemEngine.AddTeacher(id, nullTeacher));
StringAssert.Contains("cannot be null or empty", ex.Message);
}
public void AddTeacher_WhenIdIsInvalid_ShouldThrowArgumentOutOfRangeException()
{
var invalidID = -1;
var mockedTeacher = new Mock <ITeacher>();
var ex = Assert.Throws <ArgumentOutOfRangeException>(() => SchoolSystemEngine.AddTeacher(invalidID, mockedTeacher.Object));
StringAssert.Contains("cannot be less than 0!", ex.Message);
}
public void AddStudent_WhenStudentIsNull_ShouldThrowArgumentNullException()
{
var id = 100;
IStudent nullStudent = null;
var ex = Assert.Throws <ArgumentNullException>(() => SchoolSystemEngine.AddStudent(id, nullStudent));
StringAssert.Contains("cannot be null or empty", ex.Message);
}
public void MixedRequired()
{
JSchemaGenerator generator = new JSchemaGenerator();
generator.UndefinedSchemaIdHandling = JSchemaUndefinedIdHandling.None;
JSchema schema = generator.Generate(typeof(CircularReferenceWithIdClass));
string json = schema.ToString();
StringAssert.AreEqual(@"{
""id"": ""MyExplicitId"",
""type"": ""object"",
""properties"": {
""Name"": {
""type"": [
""string"",
""null""
]
},
""Child"": {
""id"": ""MyExplicitId-1"",
""type"": [
""object"",
""null""
],
""properties"": {
""Name"": {
""type"": [
""string"",
""null""
]
},
""Child"": {
""$ref"": ""#""
}
},
""required"": [
""Name"",
""Child""
]
}
},
""required"": [
""Name"",
""Child""
]
}", json);
CircularReferenceWithIdClass c = new CircularReferenceWithIdClass();
JToken t = JToken.Parse(JsonConvert.SerializeObject(c, Formatting.Indented));
Assert.IsTrue(t.IsValid(schema));
}
public virtual void Log_WithParams_comment_appears_in_output()
{
var writer = new StringWriter();
var fortyone = 41;
using (Log.Events().Subscribe(e => writer.Write(e.ToLogString())))
{
Log.WithParams(() => new { fortyone }).Write("a message");
}
StringAssert.Contains("a message", writer.ToString());
}
public void GenerateSchemaCamelCase()
{
JSchemaGenerator generator = new JSchemaGenerator();
generator.SchemaIdGenerationHandling = SchemaIdGenerationHandling.TypeName;
generator.ContractResolver = new CamelCasePropertyNamesContractResolver()
{
#if !(NETFX_CORE || PORTABLE || ASPNETCORE50 || PORTABLE40)
IgnoreSerializableAttribute = true
#endif
};
JSchema schema = generator.Generate(typeof(Version), true);
string json = schema.ToString();
StringAssert.AreEqual(@"{
""id"": ""Version"",
""type"": [
""object"",
""null""
],
""additionalProperties"": false,
""properties"": {
""major"": {
""type"": ""integer""
},
""minor"": {
""type"": ""integer""
},
""build"": {
""type"": ""integer""
},
""revision"": {
""type"": ""integer""
},
""majorRevision"": {
""type"": ""integer""
},
""minorRevision"": {
""type"": ""integer""
}
},
""required"": [
""major"",
""minor"",
""build"",
""revision"",
""majorRevision"",
""minorRevision""
]
}", json);
}
public void NestedCircularReference()
{
JSchemaGenerator generator = new JSchemaGenerator();
JSchema schema = generator.Generate(typeof(ParentCircularReferenceClass));
string json = schema.ToString();
JSchema loadedSchema = JSchema.Parse(json);
JSchema circularReferenceClassSchema = (JSchema)loadedSchema.ExtensionData["definitions"]["CircularReferenceClass"];
Assert.IsNotNull(circularReferenceClassSchema);
Assert.AreEqual(circularReferenceClassSchema, circularReferenceClassSchema.Properties["Child"]);
StringAssert.AreEqual(@"{
""definitions"": {
""CircularReferenceClass"": {
""type"": [
""object"",
""null""
],
""properties"": {
""Name"": {
""type"": ""string""
},
""Child"": {
""$ref"": ""#/definitions/CircularReferenceClass""
}
},
""required"": [
""Name""
]
}
},
""type"": ""object"",
""properties"": {
""Name"": {
""type"": [
""string"",
""null""
]
},
""Nested"": {
""$ref"": ""#/definitions/CircularReferenceClass""
}
},
""required"": [
""Name"",
""Nested""
]
}", json);
}
public void Success_and_failure_messages_can_be_configured_separately()
{
var plan = new ValidationPlan <string>
{
Validate.That <string>(s => s.As("value").Length.As("length") > 3.As("min"))
.WithErrorMessage("Fail! Your string {value} is only {length} characters.")
.WithSuccessMessage("Win! '{value}' is more than {min} characters.")
};
var failure = plan.Execute("hi").Evaluations.Single();
var success = plan.Execute("hello").Evaluations.Single();
StringAssert.Contains("Fail!", failure.Message);
StringAssert.Contains("Win!", success.Message);
}
public virtual void Log_WithParams_automatically_generates_custom_formatter_for_reference_type()
{
var writer = new StringWriter();
Log.Formatters.RegisterPropertiesFormatter <FileInfo>();
const int anInt = 23;
var fileInfo = new FileInfo(@"c:\temp\testfile.txt");
using (Log.Events().Subscribe(e => writer.Write(e.ToLogString())))
using (TestHelper.LogToConsole())
{
Log.WithParams(() => new { anInt, fileInfo }).Write("a message");
}
StringAssert.Contains(@"Directory = c:\temp", writer.ToString());
}
public void Parameter_logging_can_be_disabled_per_class()
{
var log = new StringWriter();
Extension <Boundaries> .DisableFor <InheritedWidget>();
using (Log.Events().Subscribe(e => log.Write(e.ToLogString())))
{
var w = new Widget();
var iw = new InheritedWidget();
w.DoStuff("should be in log");
iw.DoStuff("should not be in log");
}
StringAssert.Contains("should be in log", log.ToString());
StringAssert.DoesNotContain("should not be in log", log.ToString());
}
public virtual void Log_WithParams_automatically_generates_custom_formatter_for_array()
{
var writer = new StringWriter();
var myInts = new[] { 2222, 3333, 4444 };
using (Log.Events().Subscribe(e => writer.Write(e.ToLogString())))
{
Log.WithParams(() => new { myInts }).Write("a message");
}
var output = writer.ToString();
StringAssert.Contains("2222", output);
StringAssert.Contains("3333", output);
StringAssert.Contains("4444", output);
StringAssert.DoesNotContain(myInts.ToString(), output);
}
public void CircularReferenceWithMixedRequires_WithId()
{
JSchemaGenerator generator = new JSchemaGenerator();
generator.SchemaIdGenerationHandling = SchemaIdGenerationHandling.TypeName;
JSchema schema = generator.Generate(typeof(CircularReferenceClass), false);
string json = schema.ToString();
StringAssert.AreEqual(@"{
""id"": ""CircularReferenceClass"",
""definitions"": {
""CircularReferenceClass-1"": {
""id"": ""CircularReferenceClass-1"",
""type"": [
""object"",
""null""
],
""properties"": {
""Name"": {
""type"": ""string""
},
""Child"": {
""$ref"": ""CircularReferenceClass-1""
}
},
""required"": [
""Name""
]
}
},
""type"": ""object"",
""properties"": {
""Name"": {
""type"": ""string""
},
""Child"": {
""$ref"": ""CircularReferenceClass-1""
}
},
""required"": [
""Name""
]
}", json);
}
public void Exception_WithData_two_anonymous_type_objects_are_added_with_two_keys()
{
int fortyone = 41;
var string42 = "42";
var exception = new Exception();
exception.WithData(new { fortyone = fortyone }).WithData(new { string42 });
Assert.That(exception.Data.Count, Is.EqualTo(2));
var exceptionData = exception.Data["ItsLog_ExceptionData_"].ToString();
StringAssert.Contains(string.Format("fortyone = {0}", fortyone), exceptionData);
exceptionData = exception.Data["ItsLog_ExceptionData_2"].ToString();
StringAssert.Contains(string.Format("string42 = {0}", string42), exceptionData);
}
public virtual void Log_with_params_can_be_disabled_globally()
{
Extension <Params> .Disable();
var writer = new StringWriter();
var someGuid = Guid.NewGuid();
using (Log.Events().Subscribe(e => writer.Write(e.ToLogString())))
{
Log.WithParams(() => new { someGuid }).Write("a message");
}
var output = writer.ToString();
StringAssert.DoesNotContain("someGuid", output);
StringAssert.DoesNotContain(someGuid.ToLogString(), output);
}
public virtual void Log_WithParams_correctly_outputs_value_types()
{
var writer = new StringWriter();
var forty = "40";
var fortyone = 41;
using (Log.Events().Subscribe(e => writer.Write(e.ToLogString())))
{
Log.WithParams(() => new { forty, fortyone }).Write("a message");
}
var output = writer.ToString();
StringAssert.Contains("forty", output);
StringAssert.Contains("40", output);
StringAssert.Contains("fortyone", output);
Assert.IsTrue(output.Contains("41"));
}
public void CircularReferenceWithMixedRequires()
{
JSchemaGenerator generator = new JSchemaGenerator();
generator.DefaultRequired = Required.AllowNull;
JSchema schema = generator.Generate(typeof(CircularReferenceClass), false);
string json = schema.ToString();
StringAssert.AreEqual(@"{
""definitions"": {
""CircularReferenceClass"": {
""type"": [
""object"",
""null""
],
""properties"": {
""Name"": {
""type"": ""string""
},
""Child"": {
""$ref"": ""#/definitions/CircularReferenceClass""
}
},
""required"": [
""Name""
]
}
},
""type"": ""object"",
""properties"": {
""Name"": {
""type"": ""string""
},
""Child"": {
""$ref"": ""#/definitions/CircularReferenceClass""
}
},
""required"": [
""Name""
]
}", json);
}
public virtual void LogActivity_trace_outputs_updated_parameter_values()
{
var log = "";
var anInt = 1;
var aString = "a";
using (TestHelper.OnEntryPosted(e => log += e.ToLogString()))
using (var activity = Log.Enter(() => new { anInt, aString }))
{
StringAssert.Contains("anInt = 1", log);
StringAssert.Contains("aString = a", log);
anInt = 2;
aString = "b";
activity.Trace("here i am");
StringAssert.Contains("anInt = 2", log);
StringAssert.Contains("aString = b", log);
}
}
public void GenerateForNullableInt32()
{
JSchemaGenerator generator = new JSchemaGenerator();
JSchema schema = generator.Generate(typeof(NullableInt32TestClass));
string json = schema.ToString();
StringAssert.AreEqual(@"{
""type"": ""object"",
""properties"": {
""Value"": {
""type"": [
""integer"",
""null""
]
}
},
""required"": [
""Value""
]
}", json);
}
