public void Should_throw_when_type_has_no_parameterless_constructor()
{
Should.Throw <ArgumentException>(() =>
{
var schema = MockarooConvert.ToSchema <BadObject>(1);
});
}
private static void RunTypeToSchemaTest <T>(int depth = 1)
{
var schema = MockarooConvert.ToSchema <T>(depth);
var json = JArray.Parse(schema.ToString()).ToString(Newtonsoft.Json.Formatting.Indented);
Diff.Approve(json, ".json");
}
public void Can_deserialize_a_response_to_a_recursive_object()
{
// Arrange
var response = TestData.GetNestedResponse();
// Act
var result = (NestedObject)MockarooConvert.FromJson(File.ReadAllText(response.FullName), typeof(NestedObject)).First();
// Assert
result.NumericValue.ShouldBeGreaterThan(0);
result.Recursive.NumericValue.ShouldBeGreaterThan(0);
result.Recursive.Recursive.NumericValue.ShouldBeGreaterThan(0);
}
public void Can_deserialize_a_partial_response()
{
// Arrange + Act
ImmutableObject result;
using (var stream = TestData.GetPartialResponse().OpenRead())
{
result = MockarooConvert.FromJson <ImmutableObject>(stream).First();
}
// Assert
result.Id.ShouldBe(22);
result.Name.ShouldBeNullOrEmpty();
}
public void Can_deserialize_a_response_for_dictionary_object()
{
// Arrange + Act
DictionaryCollection results;
using (var stream = TestData.GetDictonaryResponse().OpenRead())
{
results = MockarooConvert.FromJson <DictionaryCollection>(stream).First();
}
// Assert
results.Properties.ShouldNotBeEmpty();
results.Properties["currency"].ShouldBe("usd");
results.HashTable[4743].StringValue.ShouldNotBeNullOrEmpty();
}
public void Can_deserialize_a_response_to_an_array_objects()
{
// Act
VariousCollections results;
using (var stream = TestData.GetCollectionResponse().OpenRead())
{
results = MockarooConvert.FromJson <VariousCollections>(stream).First();
}
// Assert
results.Capacity.ShouldNotBe(0);
results.BasicObjectList.Count().ShouldBeGreaterThan(0);
results.BasicObjectList.ShouldAllBe(x => x.NumericArray.Length > 0);
results.BasicObjectList.ShouldAllBe(x => string.IsNullOrEmpty(x.StringValue) == false);
}
public void Can_deserialize_a_response_to_composite_object()
{
// Act
CompositeObject result;
using (var stream = TestData.GetCompositeResponse().OpenRead())
{
result = MockarooConvert.FromJson <CompositeObject>(stream).First();
}
// Assert
result.Id.ShouldNotBe(0);
result.Basic.StringValue.ShouldNotBeNullOrEmpty();
result.Nested.Recursive.NumericValue.ShouldNotBe(0);
result.Collection1.ShouldNotBeEmpty();
result.Collection1[0].NumericArray.ShouldNotBeEmpty();
}
public void Can_deserialize_a_response_to_basic_object()
{
// Arrange
var response = TestData.GetBasicResponse();
// Act
BasicObject result;
using (var stream = response.OpenRead())
{
result = MockarooConvert.FromJson <BasicObject>(stream).First();
}
// Assert
result.CharValue.ShouldBe('T');
result.NumericValue.ShouldNotBe(0);
result.NumericArray.ShouldNotBeEmpty();
result.StringValue.ShouldNotBeNullOrEmpty();
result.DateValue.Ticks.ShouldBeGreaterThan(0);
result.TimeValue.Ticks.ShouldBeGreaterThan(0);
result.StringCollection.ShouldNotBeEmpty();
}
// ==========
/// <summary>
/// Retrieve sample data from https://mockaroo.com.
/// </summary>
/// <typeparam name="T">The return type.</typeparam>
/// <param name="schema">The schema.</param>
/// <param name="records">The number of records to retrieve.</param>
/// <returns>An array of <typeparamref name="T"/>.</returns>
public async Task <T[]> FetchDataAsync <T>(Schema schema, int records = DEFAULT_LIMIT)
{
byte[] data = await FetchDataAsync(Endpoint(records), schema);
return(MockarooConvert.FromJson <T>(Encoding.UTF8.GetString(data)));
}
/// <summary>
/// Retrieve sample data from https://mockaroo.com.
/// </summary>
/// <typeparam name="T">The return type.</typeparam>
/// <param name="records">The number of records to retrieve.</param>
/// <param name="depth">The max-depth the serializer should traverse down the object tree.</param>
/// <returns> The array of <typeparamref name="T" /> objects.</returns>
public async Task <T[]> FetchDataAsync <T>(int records = DEFAULT_LIMIT, int depth = Schema.DEFAULT_DEPTH)
{
byte[] data = await FetchDataAsync(Endpoint(records), MockarooConvert.ToSchema(typeof(T), depth));
return(MockarooConvert.FromJson <T>(Encoding.UTF8.GetString(data)));
}
/// <summary>
/// Initializes a new instance of the <see cref="Schema" /> class.
/// </summary>
/// <param name="type">The type.</param>
/// <param name="depth">The max-depth the serializer should traverse down the object tree.</param>
public Schema(Type type, int depth = DEFAULT_DEPTH)
{
AddRange(MockarooConvert.ConvertToSchema(type, 2));
}
