public async Task ShouldSupportDerivedComplexTypeAsync()
{
var settings = new CreatorSettings()
{
NullValueProbability = 0.0
};
var uri = new Uri(this.BaseAddress);
var entitySetName = "ComplexTypeTests_Entity";
// clear respository
await this.ClearRepositoryAsync("ComplexTypeTests_Entity");
var rand = new Random(RandomSeedGenerator.GetRandomSeed());
// post new entity to repository
var baseline = InstanceCreator.CreateInstanceOf <ComplexTypeTests_Entity>(rand, settings);
await PostNewEntityAsync(uri, entitySetName, baseline);
int id = baseline.ID;
var actual = (await GetEntitiesAsync(uri, entitySetName)).Where(t => t.ID == id).First();
AssertExtension.DeepEqual(baseline, actual);
await UpdateEntityAsync(uri, entitySetName, actual, data =>
{
data.ComplexType = InstanceCreator.CreateInstanceOf <ComplexTypeTests_ComplexType>(rand, settings);
});
var afterUpdate = (await GetEntitiesAsync(uri, entitySetName)).Where(t => t.ID == id).First();
AssertExtension.DeepEqual(actual, afterUpdate);
}
public async Task SupportPostCollectionPropertyByEntityPayload()
{
var settings = new CreatorSettings()
{
NullValueProbability = 0.0
};
var uri = new Uri(this.BaseAddress);
var entitySetName = "CollectionProperty_Entity";
// clear respository
this.ClearRepository("CollectionProperty_Entity");
var rand = new Random(RandomSeedGenerator.GetRandomSeed());
// post new entity to repository
var baseline = InstanceCreator.CreateInstanceOf <CollectionProperty_Entity>(rand, settings);
await PostNewEntityAsync(uri, entitySetName, baseline);
int id = baseline.ID;
var actual = (await GetEntitiesAsync(uri, entitySetName)).Where(t => t.ID == id).First();
AssertExtension.DeepEqual(baseline, actual);
await UpdateEntityAsync(uri, entitySetName, actual, data =>
{
data.StringList = InstanceCreator.CreateInstanceOf <List <string> >(rand, settings);
data.ComplexTypeCollection = InstanceCreator.CreateInstanceOf <Collection <CollectionProperty_ComplexType> >(rand, settings);
});
var afterUpdate = (await GetEntitiesAsync(uri, entitySetName)).Where(t => t.ID == id).First();
AssertExtension.DeepEqual(actual, afterUpdate);
}
void ReadAsTest <T>(Random rndGen)
{
T instance = InstanceCreator.CreateInstanceOf <T>(rndGen);
Log.Info("ReadAsTest<{0}>, instance = {1}", typeof(T).Name, instance);
DataContractJsonSerializer dcjs = new DataContractJsonSerializer(typeof(T));
JsonValue jv;
using (MemoryStream ms = new MemoryStream())
{
dcjs.WriteObject(ms, instance);
Log.Info("{0}: {1}", typeof(T).Name, Encoding.UTF8.GetString(ms.ToArray()));
ms.Position = 0;
jv = JsonValue.Load(ms);
}
if (instance == null)
{
Assert.Null(jv);
}
else
{
T newInstance = jv.ReadAsType <T>();
Assert.Equal(instance, newInstance);
}
}
public virtual void CreateAndDeleteLinkToDerivedNavigationPropertyOnBaseEntitySet()
{
// clear respository
this.ClearRepository("InheritanceTests_Vehicles");
Random r = new Random(RandomSeedGenerator.GetRandomSeed());
// post new entity to repository
var car = InstanceCreator.CreateInstanceOf <Car>(r);
var vehicle = InstanceCreator.CreateInstanceOf <MiniSportBike>(r, new CreatorSettings()
{
NullValueProbability = 0.0
});
DataServiceContext ctx = WriterClient(new Uri(this.BaseAddress), ODataProtocolVersion.V4);
ctx.AddObject("InheritanceTests_Vehicles", car);
ctx.AddObject("InheritanceTests_Vehicles", vehicle);
ctx.SaveChangesAsync().Wait();
ctx.SetLink(car, "SingleNavigationProperty", vehicle);
ctx.SaveChangesAsync().Wait();
ctx = ReaderClient(new Uri(this.BaseAddress), ODataProtocolVersion.V4);
var cars = ctx.CreateQuery <Vehicle>("InheritanceTests_Vehicles").ExecuteAsync().Result.ToList().OfType <Car>();
var actual = cars.First();
ctx.LoadPropertyAsync(actual, "SingleNavigationProperty").Wait();
AssertExtension.PrimitiveEqual(vehicle, actual.SingleNavigationProperty);
this.ClearRepository("InheritanceTests_Vehicles");
}
public static T CreateInstances <T>()
{
var results = InstanceCreator.CreateInstanceOf <T>(new Random(RandomSeedGenerator.GetRandomSeed()), new CreatorSettings {
NullValueProbability = 0, AllowEmptyCollection = false
});
return(results);
}
private static T CreateNewEntity <T>(Random rand)
{
var retval = (T)InstanceCreator.CreateInstanceOf(typeof(T), rand, new CreatorSettings()
{
NullValueProbability = 0.0
});
return(retval);
}
public async Task ODataCRUDShouldWorkAsync()
{
// RandomSeedGenerator.GetRandomSeed is based on date
// and these tests need something with more variance.
var randSeed = new Random();
var rand = new Random((int)randSeed.NextDouble());
var entitySetName = "MixScenarioTests_OData";
var uri = new Uri(this.BaseAddress + "/odata");
await this.ClearRepositoryAsync(entitySetName);
// post new entity to repository
var baseline = InstanceCreator.CreateInstanceOf <Vehicle>(rand);
await PostNewEntityAsync(uri, baseline, entitySetName);
// get collection of entities from repository
var entities = await GetEntitiesAsync(uri, entitySetName);
var firstVersion = entities.ToList().Where(v => v.Id == baseline.Id).FirstOrDefault();
Assert.NotNull(firstVersion);
AssertExtension.PrimitiveEqual(baseline, firstVersion);
// update entity and verify if it's saved
await UpdateEntityAsync(
uri,
firstVersion,
data =>
{
data.Model = InstanceCreator.CreateInstanceOf <string>(rand);
data.Name = InstanceCreator.CreateInstanceOf <string>(rand);
data.WheelCount = InstanceCreator.CreateInstanceOf <int>(rand);
return(data);
},
entitySetName);
var entitiesAgain = await GetEntitiesAsync(uri, entitySetName);
var secondVersion = entitiesAgain.ToList().Where(v => v.Id == firstVersion.Id).FirstOrDefault();
Assert.NotNull(secondVersion);
// firstVersion is updated in UpdatedEntityAsync
AssertExtension.PrimitiveEqual(firstVersion, secondVersion);
// delete entity
await DeleteEntityAsync(uri, secondVersion, entitySetName);
var entitiesFinal = await GetEntitiesAsync(uri, entitySetName);
var thirdVersion = entitiesFinal.ToList().Where(v => v.Id == firstVersion.Id).FirstOrDefault();
Assert.Null(thirdVersion);
}
public virtual void PostGetUpdateAndDelete(Type entityType, string entitySetName)
{
// clear respository
this.ClearRepository(entitySetName);
Random r = new Random(RandomSeedGenerator.GetRandomSeed());
// post new entity to repository
var value = InstanceCreator.CreateInstanceOf(entityType, r, new CreatorSettings()
{
NullValueProbability = 0.0
});
DataServiceContext ctx = WriterClient(new Uri(this.BaseAddress), DataServiceProtocolVersion.V3);
ctx.AddObject(entitySetName, value);
ctx.SaveChanges();
// get collection of entities from repository
ctx = ReaderClient(new Uri(this.BaseAddress), DataServiceProtocolVersion.V3);
var entities = ctx.CreateQuery <Vehicle>(entitySetName);
var beforeUpdate = entities.ToList().First();
AssertExtension.PrimitiveEqual(value, beforeUpdate);
// update entity and verify if it's saved
ctx = WriterClient(new Uri(this.BaseAddress), DataServiceProtocolVersion.V3);
ctx.AttachTo(entitySetName, beforeUpdate);
beforeUpdate.Name = InstanceCreator.CreateInstanceOf <string>(r);
ctx.UpdateObject(beforeUpdate);
ctx.SaveChanges();
// retrieve the updated entity
ctx = ReaderClient(new Uri(this.BaseAddress), DataServiceProtocolVersion.V3);
entities = ctx.CreateQuery <Vehicle>(entitySetName);
var afterUpdate = entities.Where(e => e.Id == beforeUpdate.Id).First();
Assert.Equal(beforeUpdate.Name, afterUpdate.Name);
// delete entity
ctx = WriterClient(new Uri(this.BaseAddress), DataServiceProtocolVersion.V3);
ctx.AttachTo(entitySetName, afterUpdate);
ctx.DeleteObject(afterUpdate);
ctx.SaveChanges();
// ensure that the entity has been deleted
ctx = ReaderClient(new Uri(this.BaseAddress), DataServiceProtocolVersion.V3);
entities = ctx.CreateQuery <Vehicle>(entitySetName);
Assert.Equal(0, entities.ToList().Count());
// clear repository
this.ClearRepository(entitySetName);
}
private static T UpdateEntityName <T>(T instance, Random rand)
{
var prop = typeof(T).GetProperty("Name");
// the property Name should exist and must be an string
Assert.NotNull(prop);
Assert.Equal(typeof(string), prop.PropertyType);
// set new value
prop.SetValue(instance, InstanceCreator.CreateInstanceOf <string>(rand));
return(instance);
}
public void CreateFromTests()
{
InstanceCreatorSurrogate oldSurrogate = CreatorSettings.CreatorSurrogate;
try
{
CreatorSettings.CreatorSurrogate = new NoInfinityFloatSurrogate();
DateTime now = DateTime.Now;
int seed = (10000 * now.Year) + (100 * now.Month) + now.Day;
Log.Info("Seed: {0}", seed);
Random rndGen = new Random(seed);
foreach (Type testType in testTypes)
{
object instance = InstanceCreator.CreateInstanceOf(testType, rndGen);
JsonValue jv = JsonValueExtensions.CreateFrom(instance);
if (instance == null)
{
Assert.Null(jv);
}
else
{
DataContractJsonSerializer dcjs = new DataContractJsonSerializer(instance == null ? testType : instance.GetType());
string fromDCJS;
using (MemoryStream ms = new MemoryStream())
{
dcjs.WriteObject(ms, instance);
fromDCJS = Encoding.UTF8.GetString(ms.ToArray());
}
Log.Info("{0}: {1}", testType.Name, fromDCJS);
if (instance == null)
{
Assert.Null(jv);
}
else
{
string fromJsonValue = jv.ToString();
Assert.Equal(fromDCJS, fromJsonValue);
}
}
}
}
finally
{
CreatorSettings.CreatorSurrogate = oldSurrogate;
}
}
public static IEnumerable <Product> CreateRandomProducts()
{
int seed = RandomSeedGenerator.GetRandomSeed();
var r = new Random(seed);
var products = new List <Product>();
for (int i = 0; i < r.Next(5000); i++)
{
products.Add(new Product
{
ID = r.Next(1000),
Name = InstanceCreator.CreateInstanceOf <string>(r),
Price = InstanceCreator.CreateInstanceOf <Decimal>(r),
Amount = InstanceCreator.CreateInstanceOf <double>(r),
Rating = r.Next(5),
ReleaseDate = InstanceCreator.CreateInstanceOf <DateTime?>(r),
Taxable = InstanceCreator.CreateInstanceOf <bool?>(r)
});
if (r.NextDouble() > .7)
{
products.Last().Supplier = new Supplier
{
ID = r.Next(1000),
Name = InstanceCreator.CreateInstanceOf <string>(r),
Address = new Address
{
City = InstanceCreator.CreateInstanceOf <string>(r),
State = InstanceCreator.CreateInstanceOf <string>(r)
}
};
products.Last().Supplier.Products.Add(products.Last());
}
else if (r.NextDouble() > .3)
{
products.Last().Supplier = new Supplier
{
ID = r.Next(1000),
Name = InstanceCreator.CreateInstanceOf <string>(r),
Address = null
};
products.Last().Supplier.Products.Add(products.Last());
}
}
return(products);
}
public void RoundTripObject(Type type)
{
Object[] instances = new Object[3];
Object obj = null;
DateTime now = DateTime.Now;
int seed = 10000 * now.Year + 100 * now.Month + now.Day;
Random rndGen = new Random(seed);
obj = InstanceCreator.CreateInstanceOf(type, rndGen);
if (obj != null && !(obj is MarkupExtension))
{
Object returnedObj = null;
returnedObj = XamlTestDriver.RoundTripAndCompareObjects(obj, "CacheId", "Implementation", "ImplementationVersion");
Assert.NotNull(returnedObj);
}
}
public void CRUDEntitySetShouldWork()
{
Random r = new Random(RandomSeedGenerator.GetRandomSeed());
var entitySetName = "UnicodeRouteTests_Todoü";
var uri = new Uri(this.BaseAddress + "/odataü");
// post new entity to repository
var value = InstanceCreator.CreateInstanceOf <UnicodeRouteTests_Todoü>(r);
var ctx = new DataServiceContext(uri, DataServiceProtocolVersion.V3);
ctx.AddObject(entitySetName, value);
ctx.SaveChanges();
// get collection of entities from repository
ctx = new DataServiceContext(uri, DataServiceProtocolVersion.V3);
IEnumerable <UnicodeRouteTests_Todoü> entities = ctx.CreateQuery <UnicodeRouteTests_Todoü>(entitySetName);
var beforeUpdate = entities.ToList().First();
AssertExtension.PrimitiveEqual(value, beforeUpdate);
// update entity and verify if it's saved
ctx = new DataServiceContext(uri, DataServiceProtocolVersion.V3);
ctx.AttachTo(entitySetName, beforeUpdate);
beforeUpdate.Nameü = InstanceCreator.CreateInstanceOf <string>(r);
ctx.UpdateObject(beforeUpdate);
ctx.SaveChanges();
ctx = new DataServiceContext(uri, DataServiceProtocolVersion.V3);
entities = ctx.CreateQuery <UnicodeRouteTests_Todoü>(entitySetName);
var afterUpdate = entities.ToList().First();
AssertExtension.PrimitiveEqual(beforeUpdate, afterUpdate);
//var afterUpdate = entities.Where(FilterByPk(entityType, GetIDValue(beforeUpdate))).First();
var response = ctx.LoadProperty(afterUpdate, "Nameü");
Assert.Equal(200, response.StatusCode);
// delete entity
ctx = new DataServiceContext(uri, DataServiceProtocolVersion.V3);
ctx.AttachTo(entitySetName, afterUpdate);
ctx.DeleteObject(afterUpdate);
ctx.SaveChanges();
ctx = new DataServiceContext(uri, DataServiceProtocolVersion.V3);
entities = ctx.CreateQuery <UnicodeRouteTests_Todoü>(entitySetName);
Assert.Equal(0, entities.ToList().Count());
}
public void ODataCRUDShouldWork()
{
Random r = new Random(RandomSeedGenerator.GetRandomSeed());
var entitySetName = "MixScenarioTests_OData";
var uri = new Uri(this.BaseAddress + "/odata");
this.ClearRepository(entitySetName);
// post new entity to repository
var value = InstanceCreator.CreateInstanceOf <Vehicle>(r);
var ctx = WriterClient(uri, DataServiceProtocolVersion.V3);
ctx.AddObject(entitySetName, value);
ctx.SaveChanges();
// get collection of entities from repository
ctx = ReaderClient(uri, DataServiceProtocolVersion.V3);
IEnumerable <Vehicle> entities = ctx.CreateQuery <Vehicle>(entitySetName);
var beforeUpdate = entities.ToList().First();
AssertExtension.PrimitiveEqual(value, beforeUpdate);
// update entity and verify if it's saved
ctx = WriterClient(uri, DataServiceProtocolVersion.V3);
ctx.AttachTo(entitySetName, beforeUpdate);
beforeUpdate.Model = InstanceCreator.CreateInstanceOf <string>(r);
beforeUpdate.Name = InstanceCreator.CreateInstanceOf <string>(r);
beforeUpdate.WheelCount = InstanceCreator.CreateInstanceOf <int>(r);
ctx.UpdateObject(beforeUpdate);
ctx.SaveChanges();
ctx = ReaderClient(uri, DataServiceProtocolVersion.V3);
entities = ctx.CreateQuery <Vehicle>(entitySetName);
var afterUpdate = entities.ToList().First();
AssertExtension.PrimitiveEqual(beforeUpdate, afterUpdate);
//var afterUpdate = entities.Where(FilterByPk(entityType, GetIDValue(beforeUpdate))).First();
// delete entity
ctx = WriterClient(uri, DataServiceProtocolVersion.V3);
ctx.AttachTo(entitySetName, afterUpdate);
ctx.DeleteObject(afterUpdate);
ctx.SaveChanges();
ctx = ReaderClient(uri, DataServiceProtocolVersion.V3);
entities = ctx.CreateQuery <Vehicle>(entitySetName);
Assert.Equal(0, entities.ToList().Count());
}
public void SupportPostCollectionPropertyByEntityPayload()
{
CreatorSettings settings = new CreatorSettings()
{
NullValueProbability = 0.0
};
// clear respository
this.ClearRepository("CollectionProperty_Entity");
//this.Client.GetStringAsync(this.BaseAddress + "/$metadata").Wait();
Random r = new Random(RandomSeedGenerator.GetRandomSeed());
// post new entity to repository
var expected = InstanceCreator.CreateInstanceOf <CollectionProperty_Entity>(r, settings);
DataServiceContext ctx = WriterClient(new Uri(this.BaseAddress), DataServiceProtocolVersion.V3);
ctx.AddObject("CollectionProperty_Entity", expected);
ctx.SaveChanges();
int id = expected.ID;
ctx = ReaderClient(new Uri(this.BaseAddress), DataServiceProtocolVersion.V3);
var actual = ctx.CreateQuery <CollectionProperty_Entity>("CollectionProperty_Entity").Where(t => t.ID == id).First();
AssertExtension.DeepEqual(expected, actual);
expected = actual;
ctx = WriterClient(new Uri(this.BaseAddress), DataServiceProtocolVersion.V3);
ctx.AttachTo("CollectionProperty_Entity", expected);
expected.StringList = InstanceCreator.CreateInstanceOf <List <string> >(r, settings);
expected.ComplexTypeCollection = InstanceCreator.CreateInstanceOf <Collection <CollectionProperty_ComplexType> >(r, settings);
ctx.UpdateObject(expected);
ctx.SaveChanges();
ctx = ReaderClient(new Uri(this.BaseAddress), DataServiceProtocolVersion.V3);
actual = ctx.CreateQuery <CollectionProperty_Entity>("CollectionProperty_Entity").Where(t => t.ID == id).First();
AssertExtension.DeepEqual(expected, actual);
// clear respository
this.ClearRepository("CollectionProperty_Entity");
}
public async Task CRUDEntitySetShouldWork()
{
var rand = new Random(RandomSeedGenerator.GetRandomSeed());
var entitySetName = "UnicodeRouteTests_Todoü";
var uri = new Uri(this.BaseAddress + "/odataü");
var context = new DataServiceContext(uri, ODataProtocolVersion.V4);
// post new entity to repository
CreatorSettings creatorSettings = new CreatorSettings()
{
NullValueProbability = 0,
};
var baseline = InstanceCreator.CreateInstanceOf <UnicodeRouteTests_Todoü>(rand, creatorSettings);
await PostNewEntityAsync(uri, entitySetName, baseline);
// get collection of entities from repository
var firstVersion = await GetFirstEntityAsync(uri, entitySetName);
Assert.NotNull(firstVersion);
AssertExtension.PrimitiveEqual(baseline, firstVersion);
// update entity and verify if it's saved
await UpdateEntityAsync(uri, entitySetName, firstVersion, data =>
{
data.Nameü = InstanceCreator.CreateInstanceOf <string>(rand);
});
var secondVersion = await GetFirstEntityAsync(uri, entitySetName);
Assert.NotNull(secondVersion);
AssertExtension.PrimitiveEqual(firstVersion, secondVersion);
var response = await LoadPropertyAsync(uri, entitySetName, secondVersion, "Nameü");
Assert.Equal(200, response.StatusCode);
// delete entity
await DeleteEntityAsync(uri, entitySetName, secondVersion);
var entities = await GetEntitiesAsync(uri, entitySetName);
Assert.Empty(entities.ToList());
}
public virtual void AddAndRemoveBaseNavigationPropertyInDerivedType()
{
// clear respository
this.ClearRepository("InheritanceTests_Cars");
Random r = new Random(RandomSeedGenerator.GetRandomSeed());
// post new entity to repository
CreatorSettings creatorSettings = new CreatorSettings()
{
NullValueProbability = 0,
};
var car = InstanceCreator.CreateInstanceOf <Car>(r, creatorSettings);
var vehicle = InstanceCreator.CreateInstanceOf <Vehicle>(r, creatorSettings);
DataServiceContext ctx = WriterClient(new Uri(this.BaseAddress), ODataProtocolVersion.V4);
ctx.AddObject("InheritanceTests_Cars", car);
ctx.AddRelatedObject(car, "BaseTypeNavigationProperty", vehicle);
ctx.SaveChangesAsync().Wait();
ctx = ReaderClient(new Uri(this.BaseAddress), ODataProtocolVersion.V4);
var cars = ctx.CreateQuery <Car>("InheritanceTests_Cars");
var actual = cars.ExecuteAsync().Result.First();
ctx.LoadPropertyAsync(actual, "BaseTypeNavigationProperty").Wait();
AssertExtension.PrimitiveEqual(vehicle, actual.BaseTypeNavigationProperty[0]);
ctx = WriterClient(new Uri(this.BaseAddress), ODataProtocolVersion.V4);
ctx.AttachTo("InheritanceTests_Cars", actual);
ctx.AttachTo("InheritanceTests_Vehicles", actual.BaseTypeNavigationProperty[0]);
ctx.DeleteLink(actual, "BaseTypeNavigationProperty", actual.BaseTypeNavigationProperty[0]);
ctx.SaveChangesAsync().Wait();
ctx = ReaderClient(new Uri(this.BaseAddress), ODataProtocolVersion.V4);
cars = ctx.CreateQuery <Car>("InheritanceTests_Cars");
actual = cars.ExecuteAsync().Result.First();
ctx.LoadPropertyAsync(actual, "BaseTypeNavigationProperty").Wait();
Assert.Empty(actual.BaseTypeNavigationProperty);
this.ClearRepository("InheritanceTests_Cars");
}
/// <summary>
/// Create a group of types randomly
/// </summary>
/// <param name="count">number of the types to be created</param>
/// <param name="rand">random generator</param>
public void CreateTypes(int count, Random rand)
{
// create a random GUID in the form of 00000000000000000000000000000000
var uniqueName = InstanceCreator.CreateInstanceOf <Guid>(rand).ToString("N");
var assemblyName = new AssemblyName(uniqueName);
AssemblyBuilder assemblyBuilder = AppDomain.CurrentDomain.DefineDynamicAssembly(
assemblyName, AssemblyBuilderAccess.RunAndSave);
ModuleBuilder modelBuilder = assemblyBuilder.DefineDynamicModule(
assemblyName.Name, assemblyName.Name + ".dll");
for (int i = 0; i < count; i++)
{
var choice = rand.Next(10);
if (choice < 6)
{
// Entity type
var newType = CreateEntityType(modelBuilder, rand, i.ToString());
CreateClientEntityType(modelBuilder, rand, newType);
var controller = CreateControllerType(modelBuilder, newType);
_controllerTypes.Add(controller);
}
else if (choice < 7)
{
// Enum type
var newType = CreateEnumType(modelBuilder, rand, i.ToString());
ComplexTypes.Add(newType);
}
else
{
// Complex Type
CreateCompexType(modelBuilder, rand, i.ToString());
}
}
this.Assembly = assemblyBuilder;
}
public void CreateTypes(int count, Random rndGen)
{
var uniqueName = InstanceCreator.CreateInstanceOf<Guid>(rndGen).ToString("N");
AssemblyName assemblyName = new AssemblyName(uniqueName);
AssemblyBuilder ab =
AppDomain.CurrentDomain.DefineDynamicAssembly(
assemblyName,
AssemblyBuilderAccess.RunAndSave);
ModuleBuilder mb =
ab.DefineDynamicModule(assemblyName.Name, assemblyName.Name + ".dll");
for (int i = 0; i < count; i++)
{
Type type = null;
var choice = rndGen.Next(10);
if (choice < 6)
{
// Entity type
type = CreateEntityType(mb, rndGen, i.ToString());
CreateClientEntityType(mb, rndGen, type);
CreateControllerType(mb, type);
}
else if (choice < 7)
{
// Enum type
type = CreateEnumType(mb, rndGen, i.ToString());
}
else
{
// Complex Type
type = CreateCompexType(mb, rndGen, i.ToString());
}
}
this.Assembly = ab;
}
private bool GenerateRandomDataForClient(
Type clientType,
Type serverType,
Random rand,
out object value,
int?depth = null,
CreatorSettings settings = null)
{
if (clientType == serverType)
{
value = InstanceCreator.CreateInstanceOf(clientType, rand, settings);
return(true);
}
else if (this.EntityClientTypes.Contains(clientType) ||
this.ComplexClientTypes.Contains(clientType))
{
value = GenerateClientStructureRandomData(
clientType,
serverType,
rand,
depth);
return(true);
}
else if (serverType.IsEnum)
{
value = InstanceCreator.CreateInstanceOf(serverType, rand).ToString();
return(true);
}
else if (clientType.IsGenericType)
{
if (clientType.GetGenericTypeDefinition() == typeof(ObservableCollection <>))
{
var values = Activator.CreateInstance(clientType);
if (depth <= 2)
{
var addMethod = clientType.GetMethod("Add");
Type elementType = clientType.GetGenericArguments()[0];
Type serverElementType = serverType.GetGenericArguments()[0];
int length = rand.Next(10);
for (int j = 0; j < length; j++)
{
object elementValue;
if (GenerateRandomDataForClient(elementType, serverElementType, rand, out elementValue, depth, new CreatorSettings()
{
NullValueProbability = 0.0
}))
{
addMethod.Invoke(values, new object[] { elementValue });
}
}
}
value = values;
return(true);
}
}
else if (this.primitiveTypes.Contains(clientType))
{
if (serverType == typeof(ushort) ||
serverType == typeof(uint) ||
serverType == typeof(ulong))
{
value = InstanceCreator.CreateInstanceOf <ushort>(rand);
return(true);
}
else if (serverType == typeof(char))
{
value = InstanceCreator.CreateInstanceOf <char>(rand).ToString();
return(true);
}
}
value = null;
return(false);
}
public void TestApplyPatchOnIndividualProperty()
{
// clear respository
this.ClearRepository("DeltaTests_Todoes");
this.Client.GetStringAsync(this.BaseAddress + "/$metadata").Wait();
Random r = new Random(RandomSeedGenerator.GetRandomSeed());
var s = new CreatorSettings()
{
NullValueProbability = 0.0,
MaxArrayLength = 100
};
// post new entity to repository
var todo = InstanceCreator.CreateInstanceOf <DeltaTests_TodoClient>(r, s);
todo.NullableBool = true;
todo.NullableInt = 100000;
todo.Enum = "One";
todo.Estimation = new DeltaTests_Estimation()
{
CompletedBy = new DateTime(2012, 10, 18),
EstimatedTime = TimeSpan.FromDays(1)
};
todo.XElement = @"<a><b/></a>";
DataServiceContext ctx = WriterClient(new Uri(this.BaseAddress), DataServiceProtocolVersion.V3);
ctx.ResolveName = ResolveName;
ctx.ResolveType = ResolveType;
ctx.AddObject("DeltaTests_Todoes", todo);
ctx.SaveChanges();
int id = todo.ID;
todo.ID = InstanceCreator.CreateInstanceOf <int>(r, s);
todo.Name = InstanceCreator.CreateInstanceOf <string>(r, s);
todo.Enum = "Two";
todo.NullableBool = null;
todo.Items = InstanceCreator.CreateInstanceOf <DeltaTests_TodoItems>(r, s);
todo.Tags = InstanceCreator.CreateInstanceOf <List <DeltaTests_TodoTag> >(r, s);
todo.Estimation.CompletedBy = new DateTime(2012, 11, 18);
todo.NullableInt = 999999;
todo.Bool = InstanceCreator.CreateInstanceOf <bool>(r, s);
todo.Byte = InstanceCreator.CreateInstanceOf <Byte>(r, s);
todo.ByteArray = InstanceCreator.CreateInstanceOf <byte[]>(r, s);
todo.DateTime = InstanceCreator.CreateInstanceOf <DateTime>(r, s);
todo.DateTimeOffset = InstanceCreator.CreateInstanceOf <DateTimeOffset>(r, s);
todo.Decimal = InstanceCreator.CreateInstanceOf <Decimal>(r, s);
todo.Double = InstanceCreator.CreateInstanceOf <Double>(r, s);
todo.Float = InstanceCreator.CreateInstanceOf <float>(r, s);
todo.Guid = InstanceCreator.CreateInstanceOf <Guid>(r, s);
todo.Integer = InstanceCreator.CreateInstanceOf <Int32>(r, s);
todo.Long = InstanceCreator.CreateInstanceOf <long>(r, s);
todo.Short = InstanceCreator.CreateInstanceOf <short>(r, s);
todo.String = InstanceCreator.CreateInstanceOf <string>(r, s);
todo.TimeSpan = InstanceCreator.CreateInstanceOf <TimeSpan>(r, s);
todo.XElement = @"<b><a/></b>";
ctx.UpdateObject(todo);
ctx.SaveChanges();
ctx = ReaderClient(new Uri(this.BaseAddress), DataServiceProtocolVersion.V3);
ctx.ResolveName = ResolveName;
ctx.ResolveType = ResolveType;
var actual = ctx.CreateQuery <DeltaTests_TodoClient>("DeltaTests_Todoes").Where(t => t.ID == id).First();
//Assert.Equal(id, actual.ID);
Assert.Equal(todo.Name, actual.Name);
Assert.Equal(todo.Estimation.CompletedBy, actual.Estimation.CompletedBy);
Assert.Equal(todo.Estimation.EstimatedTime, actual.Estimation.EstimatedTime);
Assert.Equal(todo.NullableBool, actual.NullableBool);
Assert.Equal(todo.NullableInt, actual.NullableInt);
Assert.Equal(todo.Bool, actual.Bool);
Assert.Equal(todo.Byte, actual.Byte);
Assert.Equal(todo.ByteArray, actual.ByteArray);
Assert.Equal(todo.DateTime, actual.DateTime);
Assert.Equal(todo.DateTimeOffset, actual.DateTimeOffset);
Assert.Equal(todo.Decimal, actual.Decimal);
Assert.Equal(todo.Double, actual.Double);
Assert.Equal(todo.Float, actual.Float);
Assert.Equal(todo.Guid, actual.Guid);
Assert.Equal(todo.Integer, actual.Integer);
Assert.Equal(todo.Long, actual.Long);
Assert.Equal(todo.Short, actual.Short);
Assert.Equal(todo.String, actual.String);
Assert.Equal(todo.TimeSpan, actual.TimeSpan);
Assert.Equal(todo.XElement, actual.XElement.Replace(" ", string.Empty).Replace(Environment.NewLine, string.Empty));
// clear respository
this.ClearRepository("DeltaTests_Todoes");
}
public static IEnumerable <Product> CreateRandomProducts()
{
int seed = RandomSeedGenerator.GetRandomSeed();
var r = new Random(seed);
var products = new List <Product>();
try
{
for (int i = 0; i < r.Next(5000); i++)
{
products.Add(new Product
{
ID = r.Next(1000),
Name = InstanceCreator.CreateInstanceOf <string>(r),
Price = InstanceCreator.CreateInstanceOf <Decimal>(r),
Rating = r.Next(5),
PublishDate = InstanceCreator.CreateInstanceOf <DateTimeOffset>(r),
ReleaseDate = InstanceCreator.CreateInstanceOf <DateTimeOffset?>(r),
Date = InstanceCreator.CreateInstanceOf <DateTime>(r),
NullableDate = r.Next(9) % 3 == 0 ? (Date?)null : InstanceCreator.CreateInstanceOf <DateTime>(r),
TimeOfDay = InstanceCreator.CreateInstanceOf <DateTimeOffset>(r).TimeOfDay,
NullableTimeOfDay = r.Next(19) % 3 == 0
? (TimeOfDay?)null
: InstanceCreator.CreateInstanceOf <DateTimeOffset>(r).TimeOfDay,
Taxable = InstanceCreator.CreateInstanceOf <bool?>(r)
});
if (r.NextDouble() > .7)
{
products.Last().Supplier = new Supplier
{
ID = r.Next(1000),
Name = InstanceCreator.CreateInstanceOf <string>(r),
Address = new Address
{
City = InstanceCreator.CreateInstanceOf <string>(r),
State = InstanceCreator.CreateInstanceOf <string>(r)
}
};
products.Last().Supplier.Products.Add(products.Last());
}
else if (r.NextDouble() > .3)
{
products.Last().Supplier = new Supplier
{
ID = r.Next(1000),
Name = InstanceCreator.CreateInstanceOf <string>(r),
Address = null
};
products.Last().Supplier.Products.Add(products.Last());
}
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
return(products);
}