public void EFFK_1To1_BasicInsertAndBind_Batch_ChangedUriCompositionRulesOnServer()
{
// Fix URI composition in Astoria for V3 payloads
ctx = new DataServiceContext(web.ServiceRoot, Microsoft.OData.Client.ODataProtocolVersion.V4);
ctx.EnableAtom = true;
ctx.Format.UseAtom();
// Create new office type
EFFKClient.Office o = new EFFKClient.Office()
{
ID = 1, BuildingName = "Building 35", FloorNumber = 2, OfficeNumber = 2173
};
ctx.AddObject("CustomObjectContext.Offices", o);
// create new employee type
EFFKClient.Worker e = new EFFKClient.Worker()
{
ID = 1, FirstName = "Pratik", LastName = "Patel"
};
ctx.AddObject("CustomObjectContext.Workers", e);
// Establish relationship between employee and office
ctx.SetLink(o, "Worker", e);
ctx.SetLink(e, "Office", o);
ctx.SaveChanges(SaveChangesOptions.BatchWithSingleChangeset);
// clean the context
ctx.DeleteObject(e);
ctx.DeleteObject(o);
ctx.SaveChanges(SaveChangesOptions.BatchWithSingleChangeset);
}
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");
}
/// <summary>
/// Creates the manifest async.
/// </summary>
/// <param name="name">The name.</param>
/// <param name="storageAccountName">The name of storage account </param>
/// <returns><see cref="Task"/> of type <see cref="IIngestManifest"/></returns>
public Task <IIngestManifest> CreateAsync(string name, string storageAccountName)
{
if (name == null)
{
throw new ArgumentNullException("name");
}
if (storageAccountName == null)
{
throw new ArgumentNullException("storageAccountName");
}
IngestManifestData ingestManifestData = new IngestManifestData
{
Name = name,
StorageAccountName = storageAccountName
};
ingestManifestData.InitCloudMediaContext(this._cloudMediaContext);
DataServiceContext dataContext = this._cloudMediaContext.DataContextFactory.CreateDataServiceContext();
dataContext.AddObject(EntitySet, ingestManifestData);
return(dataContext
.SaveChangesAsync(ingestManifestData)
.ContinueWith <IIngestManifest>(
t =>
{
t.ThrowIfFaulted();
IngestManifestData data = (IngestManifestData)t.AsyncState;
return data;
}));
}
public virtual void PostAndGetShouldNotFailInSerialization(string data)
{
var entitySetName = "MaliciousCharactorsAttackTests_Entity";
// clear respository
this.ClearRepository(entitySetName);
MaliciousCharactorsAttackTests_Entity entity = new MaliciousCharactorsAttackTests_Entity();
entity.ID = data;
entity.StringProperty = data;
DataServiceContext ctx = WriterClient(new Uri(this.BaseAddress), DataServiceProtocolVersion.V3);
ctx.AddObject(entitySetName, entity);
try
{
ctx.SaveChanges(SaveChangesOptions.ContinueOnError);
}
catch (Exception ex)
{
if (ex.InnerException != null && !string.IsNullOrEmpty(ex.InnerException.Message))
{
Assert.False(ex.InnerException.Message.Contains("The server did not return a response for this request."),
string.Format("{0} ({1}) will cause server to close connection.", data, (int)data.First()));
}
}
// clear repository
this.ClearRepository(entitySetName);
}
private void PostTestWorkRespose(IAsyncResult asyncResult)
{
try
{
DataServiceContext asynchConnector = asyncResult.AsyncState as DataServiceContext;
DataServiceResponse response = asynchConnector.EndSaveChanges(asyncResult);
foreach (ChangeOperationResponse changset in response)
{
if (changset.Error != null)
{
throw changset.Error;
}
}
SignalUI("TestStatus", "Sent Response");
}
catch (Exception exception)
{
string wrongError = "The context is already tracking a different entity with the same resource Uri.";
if (!exception.InnerException.Message.Contains(wrongError))
{
SignalUI("TestStatus", "Failed : " + exception.StackTrace.ToString());
SignalUI("TestStatus", "Failed : " + exception.InnerException.StackTrace.ToString());
DataServiceContext dsc = GetServiceContext();
Message response = new Message();
response.ReturnValue = exception.ToString();
response.WhoSentMe = "SL";
dsc.AddObject("Messages", response);
dsc.BeginSaveChanges(PostTestWorkRespose, dsc);
}
}
}
/// <summary>
/// Create a notification endpoint object in asynchronous mode.
/// </summary>
/// <param name="name">Name of notification endpoint</param>
/// <param name="endPointType">Notification endpoint type</param>
/// <param name="endPointAddress">Notification endpoint address</param>
/// <returns>Task of creating notification endpoint.</returns>
public Task <INotificationEndPoint> CreateAsync(string name, NotificationEndPointType endPointType,
string endPointAddress)
{
NotificationEndPoint notificationEndPoint = new NotificationEndPoint
{
Name = name,
EndPointType = (int)endPointType,
EndPointAddress = endPointAddress
};
notificationEndPoint.InitCloudMediaContext(_cloudMediaContext);
DataServiceContext dataContext = DataContextFactory.CreateDataServiceContext();
dataContext.AddObject(NotificationEndPoints, notificationEndPoint);
return(dataContext
.SaveChangesAsync(notificationEndPoint)
.ContinueWith <INotificationEndPoint>(
t =>
{
t.ThrowIfFaulted();
return (NotificationEndPoint)t.AsyncState;
},
TaskContinuationOptions.ExecuteSynchronously));
}
public void ClientSerializeGeographyTest_AddDataPresentAndNamespaceNotDuplicated()
{
DataServiceContext ctx = new DataServiceContext(new Uri("http://localhost"));
ctx.AddObject("Entities", testEntity);
ClientSerializeGeographyTest_Validate(ctx);
}
private Task <IIngestManifestAsset> CreateAsync(IIngestManifest ingestManifest, IAsset asset, CancellationToken token, Action <IngestManifestAssetData> continueWith)
{
IngestManifestCollection.VerifyManifest(ingestManifest);
DataServiceContext dataContext = _cloudMediaContext.DataContextFactory.CreateDataServiceContext();
var data = new IngestManifestAssetData
{
ParentIngestManifestId = ingestManifest.Id
};
dataContext.AddObject(IngestManifestAssetCollection.EntitySet, data);
dataContext.AttachTo(AssetCollection.AssetSet, asset);
dataContext.SetLink(data, "Asset", asset);
Task <IIngestManifestAsset> task = dataContext.SaveChangesAsync(data).ContinueWith <IIngestManifestAsset>(t =>
{
t.ThrowIfFaulted();
token.ThrowIfCancellationRequested();
IngestManifestAssetData ingestManifestAsset = (IngestManifestAssetData)t.AsyncState;
continueWith(ingestManifestAsset);
return(ingestManifestAsset);
}, TaskContinuationOptions.ExecuteSynchronously);
return(task);
}
private void InnerSave(DataServiceContext dataContext)
{
X509Certificate2 certToUse = null;
dataContext.AddObject(JobTemplateBaseCollection.JobTemplateSet, this);
foreach (TaskTemplateData taskTemplate in this.TaskTemplates)
{
dataContext.AddRelatedObject(this, TaskTemplatesPropertyName, taskTemplate);
if (((ITaskTemplate)taskTemplate).Options.HasFlag(TaskOptions.ProtectedConfiguration) && (taskTemplate.Configuration != taskTemplate.ConfigurationCopied))
{
ProtectTaskConfiguration((TaskTemplateData)taskTemplate, ref certToUse, dataContext);
}
}
MatchCollection matches = Regex.Matches(this.JobTemplateBodyCopied, @"taskTemplateId=""nb:ttid:UUID:([a-zA-Z0-9\-]+)""");
this.JobTemplateBody = this.JobTemplateBodyCopied;
for (int i = 0; i < matches.Count; i++)
{
string taskTemplateId = Guid.NewGuid().ToString();
this.TaskTemplates[i].Id = string.Concat("nb:ttid:UUID:", taskTemplateId);
this.JobTemplateBody = this.JobTemplateBody.Replace(matches[i].Groups[1].Value, taskTemplateId);
}
}
public async Task ODataResultWithZeroResultShouldWork()
{
// Arrange
var ctx = new DataServiceContext(new Uri(this.BaseAddress), ODataProtocolVersion.V4);
ctx.Format.UseJson(GetEdmModel(_configuration));
ctx.AddObject(
"ODataResult_Model1",
new ODataResult_Model1()
{
ID = 1,
Name = "ABC"
});
await ctx.SaveChangesAsync();
// Act
var response = await Client.GetWithAcceptAsync(this.BaseAddress + "/ODataResult_Model1(1)/Model2?count=0", "application/json");
var responseContentString = await response.Content.ReadAsStringAsync();
// Assert
response.EnsureSuccessStatusCode();
Assert.Contains("\"@odata.nextLink\":\"ODataResult_Model2\"", responseContentString);
}
private async Task <DataServiceResponse> PostNewEntity <T>(T value, string entitySetName)
{
DataServiceContext writeClient = WriterClient(new Uri(this.BaseAddress), ODataProtocolVersion.V4);
writeClient.AddObject(entitySetName, value);
return(await writeClient.SaveChangesAsync());
}
/// <summary>
/// Creates the manifest asset file asynchronously.
/// </summary>
/// <param name="ingestManifestAsset">The parent manifest asset.</param>
/// <param name="filePath">The file path.</param>
/// <param name="token"><see cref="CancellationToken"/></param>
/// <returns><see cref="Task"/>of type <see cref="IIngestManifestFile"/></returns>
public Task <IIngestManifestFile> CreateAsync(IIngestManifestAsset ingestManifestAsset, string filePath, CancellationToken token)
{
if (ingestManifestAsset == null)
{
throw new ArgumentNullException("ingestManifestAsset");
}
if (string.IsNullOrWhiteSpace(filePath))
{
throw new ArgumentException(String.Format(CultureInfo.InvariantCulture, StringTable.ErrorCreatingIngestManifestFileEmptyFilePath));
}
AssetCreationOptions options = ingestManifestAsset.Asset.Options;
Task <IIngestManifestFile> rootTask = new Task <IIngestManifestFile>(() =>
{
token.ThrowIfCancellationRequested();
IngestManifestAssetCollection.VerifyManifestAsset(ingestManifestAsset);
if (!File.Exists(filePath))
{
throw new FileNotFoundException(String.Format(CultureInfo.InvariantCulture, StringTable.BulkIngestProvidedFileDoesNotExist, filePath));
}
FileInfo info = new FileInfo(filePath);
DataServiceContext dataContext = this._cloudMediaContext.DataContextFactory.CreateDataServiceContext();
// Set a MIME type based on the extension of the file name
string mimeType = AssetFileData.GetMimeType(filePath);
IngestManifestFileData data = new IngestManifestFileData
{
Name = info.Name,
MimeType = mimeType,
ParentIngestManifestId = ingestManifestAsset.ParentIngestManifestId,
ParentIngestManifestAssetId = ingestManifestAsset.Id,
Path = filePath,
};
SetEncryptionSettings(ingestManifestAsset, info, options, data);
dataContext.AddObject(EntitySet, data);
Task <IIngestManifestFile> task = dataContext.SaveChangesAsync(data).ContinueWith <IIngestManifestFile>(t =>
{
t.ThrowIfFaulted();
token.ThrowIfCancellationRequested();
IngestManifestFileData ingestManifestFile = (IngestManifestFileData)t.AsyncState;
return(ingestManifestFile);
});
return(task.Result);
});
rootTask.Start();
return(rootTask);
}
public virtual void AddNewRow(object newRow)
{
if (DataServiceContext == null)
{
return;
}
DataServiceContext.AddObject(EntityObjectType.Name + "s", newRow);
DataServiceContext.SaveChanges();
UpdateDataSource();
}
public void AddNewItem()
{
DataServiceContext ctx = new DataServiceContext(new Uri("http://localhost/Chapter9/MovieService.svc"));
MovieService.Film NewFilm = new MovieService.Film();
NewFilm.Title = "Pulp Fiction";
NewFilm.Length = 124;
NewFilm.Description = "Quentins classic movie";
ctx.AddObject("Films", NewFilm);
ctx.SaveChanges();
}
void PushResponseToQueue(Message request, Message response)
{
DataServiceContext AstoriaTestService = null;
AstoriaTestService = GetServiceContext();
AstoriaTestService.UsePostTunneling = true;
AstoriaTestService.AttachTo("Messages", request);
AstoriaTestService.DeleteObject(request);
//response.MessageID = 5000;
AstoriaTestService.AddObject("Messages", response);
AstoriaTestService.BeginSaveChanges(SaveChangesOptions.None, PostTestWorkRespose, AstoriaTestService);
}
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);
}
public void TestAddObjectGraph()
{
var message = new Message
{
Id = Guid.NewGuid(),
Body = "Hi!",
To = new Contact
{
Email = "[email protected]",
Name = "abc"
}
};
Setup(session => session.Store(It.Is <Contact>(actual => actual.Equals(message.To))))
.AtMostOnce();
Setup(session => session.Commit())
.AtMost(2);
_resourceFinderMock.Setup(
resourceFinder => resourceFinder.GetResource(It.IsAny <IQueryable <Contact> >(), null))
.Returns(message.To)
.AtMostOnce();
Setup(session => session.Store(It.Is <Message>(actual => actual.Equals(message))))
.AtMostOnce();
var context = new DataServiceContext(ServiceUri);
Playback(() =>
{
context.AddObject("Contacts", message.To);
context.AddObject("Messages", message);
context.SetLink(message, "To", message.To);
context.SaveChanges();
});
}
public static T CreateEntity <T>(DataServiceContext ctx, string entitySetName, EntityStates state, DataServiceQuery <T> query) where T : class, new()
{
T entity = null;
try
{
switch (state)
{
case EntityStates.Added:
entity = new T();
ctx.AddObject(entitySetName, entity);
break;
case EntityStates.Deleted:
entity = CreateEntity(ctx, entitySetName, EntityStates.Unchanged, query);
ctx.DeleteObject(entity);
break;
case EntityStates.Detached:
entity = query.Execute().Single();
Assert.AreEqual(MergeOption.NoTracking != ctx.MergeOption, ctx.Detach(entity));
break;
case EntityStates.Unchanged:
entity = query.Execute().Single();
if (MergeOption.NoTracking == ctx.MergeOption)
{
ctx.AttachTo(entitySetName, entity);
}
break;
case EntityStates.Modified:
entity = CreateEntity(ctx, entitySetName, EntityStates.Unchanged, query);
ctx.UpdateObject(entity);
break;
default:
Assert.Fail(String.Format("unexpected state encountered: {0}", state));
break;
}
}
catch (Exception ex)
{
Assert.Fail("{0}", ex);
}
return(entity);
}
protected override void OnListChanged(ListChangedEventArgs e)
{
try
{
base.OnListChanged(e);
if (context != null)
{
if (e.ListChangedType == ListChangedType.ItemAdded)
{
context.AddObject(objectName, this[e.NewIndex]);
}
}
}
catch
{ }
}
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());
}
private static ContentKeyData CreateStorageContentKey(AssetData tempAsset, NullableFileEncryption fileEncryption, DataServiceContext dataContext)
{
// Create the content key.
fileEncryption.Init();
// Encrypt it for delivery to Nimbus.
X509Certificate2 certToUse = ContentKeyCollection.GetCertificateToEncryptContentKey(dataContext, ContentKeyType.StorageEncryption);
ContentKeyData contentKeyData = ContentKeyBaseCollection.CreateStorageContentKey(fileEncryption.FileEncryption, certToUse);
dataContext.AddObject(ContentKeyCollection.ContentKeySet, contentKeyData);
dataContext.SaveChanges();
// Associate it with the asset.
((IAsset)tempAsset).ContentKeys.Add(contentKeyData);
return(contentKeyData);
}
private Task <IJobTemplate> CreateJobTemplate(string templateName, JobTemplateType templateType, params ITaskTemplate[] taskTemplates)
{
X509Certificate2 certToUse = null;
DataServiceContext dataContext = this._cloudMediaContext.DataContextFactory.CreateDataServiceContext();
JobTemplateData jobTemplateData = new JobTemplateData {
Name = templateName, TemplateType = (int)templateType
};
jobTemplateData.InitCloudMediaContext(this._cloudMediaContext);
dataContext.AddObject(JobTemplateBaseCollection.JobTemplateSet, jobTemplateData);
foreach (ITaskTemplate taskTemplate in taskTemplates)
{
Verify(taskTemplate);
dataContext.AddRelatedObject(jobTemplateData, TaskTemplatesPropertyName, taskTemplate);
if (taskTemplate.Options.HasFlag(TaskOptions.ProtectedConfiguration) && string.IsNullOrWhiteSpace(this.Id))
{
ProtectTaskConfiguration((TaskTemplateData)taskTemplate, ref certToUse, dataContext);
}
}
AssetNamingSchemeResolver <AssetData, OutputAsset> assetIdMap = new AssetNamingSchemeResolver <AssetData, OutputAsset>();
jobTemplateData.JobTemplateBody = CreateJobTemplateBody(assetIdMap, taskTemplates);
jobTemplateData.NumberofInputAssets = string.IsNullOrWhiteSpace(this.Id)
? assetIdMap.Inputs.Count
: ((IJob)this).InputMediaAssets.Count;
return(dataContext
.SaveChangesAsync(SaveChangesOptions.Batch, jobTemplateData)
.ContinueWith <IJobTemplate>(
t =>
{
t.ThrowIfFaulted();
JobTemplateData data = (JobTemplateData)t.AsyncState;
IJobTemplate jobTemplateToReturn = this._cloudMediaContext.JobTemplates.Where(c => c.Id == data.Id).First();
return jobTemplateToReturn;
}));
}
public void EdmValidNamesNotAllowedInUri()
{
DSPMetadata metadata = new DSPMetadata("Test", "TestNS");
var entityType = metadata.AddEntityType("MyType", null, null, false);
metadata.AddKeyProperty(entityType, "ID", typeof(int));
metadata.AddPrimitiveProperty(entityType, "Pròjè_x00A2_tÎð瑞갂థ్క_x0020_Iiلإَّ", typeof(string));
var resourceSet = metadata.AddResourceSet("EntitySet", entityType);
metadata.SetReadOnly();
DSPServiceDefinition service = new DSPServiceDefinition()
{
Metadata = metadata,
Writable = true
};
DSPContext data = new DSPContext();
service.CreateDataSource = (m) => { return(data); };
using (TestWebRequest request = service.CreateForInProcessWcf())
{
request.StartService();
DataServiceContext context = new DataServiceContext(request.ServiceRoot);
string value = "value of Pròjè_x00A2_tÎð瑞갂థ్క_x0020_Iiلإَّ";
context.AddObject("EntitySet", new MyType()
{
ID = 1,
Pròjè_x00A2_tÎð瑞갂థ్క_x0020_Iiلإَّ = value,
});
try
{
context.SaveChanges();
}
catch (DataServiceRequestException exception)
{
Assert.AreEqual(exception.Message, "An error occurred while processing this request.");
}
}
}
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 void TestAddObject()
{
var contact = new Contact {
Email = "[email protected]", Name = "abc"
};
Setup(session => session.Store(It.Is <Contact>(actual => actual.Equals(contact))))
.AtMostOnce();
Setup(session => session.Commit())
.AtMostOnce();
Playback(() =>
{
var context = new DataServiceContext(ServiceUri);
context.AddObject("Contacts", contact);
context.SaveChanges();
});
}
public void ODataResultWithZeroResultShouldWork()
{
DataServiceContext ctx = new DataServiceContext(new Uri(this.BaseAddress), DataServiceProtocolVersion.V3);
ctx.AddObject("ODataResult_Model1", new ODataResult_Model1()
{
ID = 1, Name = "ABC"
});
ctx.SaveChanges();
HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, this.BaseAddress + "/ODataResult_Model1(1)/Model2?count=0");
request.Headers.Accept.Add(MediaTypeWithQualityHeaderValue.Parse("application/json;odata=verbose"));
var response = this.Client.SendAsync(request).Result;
Console.WriteLine(response);
Console.WriteLine(response.Content.ReadAsStringAsync().Result);
response.EnsureSuccessStatusCode();
}
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");
}
private void PostToDev10TypeService <T>(bool exceptionExpected, string exceptionMessage)
where T : new()
{
using (TestWebRequest web = TestWebRequest.CreateForInProcessWcf())
{
web.DataServiceType = typeof(Dev10TypeDef.Dev10TypeEntitySet <T>);
web.StartService();
string baseUri = web.BaseUri;
DataServiceContext context = new DataServiceContext(new Uri(baseUri));
try
{
context.AddObject("Entities", new T());
context.SaveChanges();
Assert.IsFalse(exceptionExpected);
}
catch (Exception ex)
{
Assert.IsTrue(exceptionExpected);
if (exceptionMessage != string.Empty)
{
Exception innerEx = ex;
while (innerEx.InnerException != null)
{
innerEx = innerEx.InnerException;
}
if (exceptionMessage.StartsWith("Contains:"))
{
exceptionMessage = exceptionMessage.Substring(9);
Assert.IsTrue(innerEx.Message.Contains(exceptionMessage));
}
else
{
Assert.AreEqual(ex.Message, exceptionMessage);
}
}
}
}
}
/// <summary>
/// Executes the <see cref="DataCreateRequest{TEntity}" />.
/// </summary>
/// <param name="parameters"></param>
/// <returns></returns>
public override Message Execute(DataRequestParameters parameters)
{
if (parameters == null)
{
throw new ArgumentNullException("parameters");
}
if (Entities == null || !Entities.Any())
{
throw new ArgumentException("Could not execute request because no entities have been set.");
}
DataServiceContext serviceContext = Resolve(parameters);
foreach (TEntity entity in Entities)
{
serviceContext.AddObject(parameters.EntitySet, entity);
}
serviceContext.SaveChanges();
return(null);
}
public void EdmValidNamesNotAllowedInUri()
{
DSPMetadata metadata = new DSPMetadata("Test", "TestNS");
var entityType = metadata.AddEntityType("MyType", null, null, false);
metadata.AddKeyProperty(entityType, "ID", typeof(int));
metadata.AddPrimitiveProperty(entityType, "Pròjè_x00A2_tÎð瑞갂థ్క_x0020_Iiلإَّ", typeof(string));
var resourceSet = metadata.AddResourceSet("EntitySet", entityType);
metadata.SetReadOnly();
DSPServiceDefinition service = new DSPServiceDefinition()
{
Metadata = metadata,
Writable = true
};
DSPContext data = new DSPContext();
service.CreateDataSource = (m) => { return(data); };
using (TestWebRequest request = service.CreateForInProcessWcf())
{
request.StartService();
DataServiceContext context = new DataServiceContext(request.ServiceRoot);
context.EnableAtom = true;
context.Format.UseAtom();
string value = "value of Pròjè_x00A2_tÎð瑞갂థ్క_x0020_Iiلإَّ";
context.AddObject("EntitySet", new MyType()
{
ID = 1,
Pròjè_x00A2_tÎð瑞갂థ్క_x0020_Iiلإَّ = value,
});
context.SaveChanges();
var result = context.Execute <MyType>(new Uri("EntitySet?$orderby=Pròjè_x00A2_tÎð瑞갂థ్క_x0020_Iiلإَّ", UriKind.Relative)).First();
Assert.AreEqual(value, result.Pròjè_x00A2_tÎð瑞갂థ్క_x0020_Iiلإَّ, "The roundtrip value not as expected");
}
}
public void Collection_BatchIDataServiceHostAndChangeTracking()
{
DSPMetadata metadata = CreateMetadataForXFeatureEntity();
TestUtil.RunCombinations(
new bool[] { false, true },
new bool[] { false, true },
new Type[] { typeof(IDataServiceHost), typeof(IDataServiceHost2) },
(sendAsBatch, replaceOnUpdate, hostInterfaceType) => {
DSPServiceDefinition service = new DSPServiceDefinition() { Metadata = metadata, Writable = true, HostInterfaceType = hostInterfaceType };
DSPContext data = new DSPContext();
service.CreateDataSource = (m) => { return data; };
// This test operates just on 2 entities - so let's take just first two from the set
List<object> testEntities = CreateClientTestEntities().Take(2).ToList<object>();
SaveChangesOptions saveOptions =
(sendAsBatch ? SaveChangesOptions.BatchWithSingleChangeset : SaveChangesOptions.None) |
(replaceOnUpdate ? SaveChangesOptions.ReplaceOnUpdate : SaveChangesOptions.None);
using (TestWebRequest request = service.CreateForInProcessWcf())
using (DSPResourceWithCollectionProperty.CollectionPropertiesResettable.Restore())
{
DSPResourceWithCollectionProperty.CollectionPropertiesResettable.Value = true;
request.StartService();
// Add entities
DataServiceContext ctx = new DataServiceContext(new Uri(request.BaseUri), ODataProtocolVersion.V4);
ctx.EnableAtom = true;
ctx.Format.UseAtom();
foreach (XFeatureTestsEntity entity in testEntities)
{
ctx.AddObject("Entities", entity);
}
VerifyStateOfEntities(ctx, testEntities, EntityStates.Added);
ctx.SaveChanges(saveOptions);
VerifyStateOfEntities(ctx, testEntities, EntityStates.Unchanged);
VerifyEntitySetsMatch(testEntities, data.GetResourceSetEntities("Entities"));
// Change one of the entities
((XFeatureTestsEntity)testEntities[0]).Structs.RemoveAt(0);
ctx.UpdateObject(testEntities[0]);
VerifyStateOfEntities(ctx, new[] { testEntities[0] }, EntityStates.Modified);
VerifyStateOfEntities(ctx, new[] { testEntities[1] }, EntityStates.Unchanged);
ctx.SaveChanges(saveOptions);
VerifyStateOfEntities(ctx, testEntities, EntityStates.Unchanged);
VerifyEntitySetsMatch(testEntities, data.GetResourceSetEntities("Entities"));
// Change collection in both entities
List<string> tempCollection = ((XFeatureTestsEntity)testEntities[0]).Strings;
((XFeatureTestsEntity)testEntities[0]).Strings = ((XFeatureTestsEntity)testEntities[1]).Strings;
((XFeatureTestsEntity)testEntities[1]).Strings = tempCollection;
ctx.UpdateObject(testEntities[0]);
ctx.UpdateObject(testEntities[1]);
VerifyStateOfEntities(ctx, testEntities, EntityStates.Modified);
ctx.SaveChanges(saveOptions);
VerifyStateOfEntities(ctx, testEntities, EntityStates.Unchanged);
VerifyEntitySetsMatch(testEntities, data.GetResourceSetEntities("Entities"));
// Delete entities
ctx.DeleteObject(testEntities[0]);
ctx.DeleteObject(testEntities[1]);
VerifyStateOfEntities(ctx, testEntities, EntityStates.Deleted);
ctx.SaveChanges(saveOptions);
testEntities.RemoveAt(0);
testEntities.RemoveAt(0);
VerifyEntitySetsMatch(testEntities, data.GetResourceSetEntities("Entities"));
}
});
}
public void Collection_ChangeInterceptors()
{
var metadata = CreateMetadataForXFeatureEntity();
InterceptorServiceDefinition service = new InterceptorServiceDefinition()
{
Metadata = metadata,
CreateDataSource = (m) => new DSPContext(),
Writable = true,
EnableChangeInterceptors = true
};
// client cases
TestUtil.RunCombinations(new string[] { "POST", "PUT", "PATCH", "DELETE" }, new bool[] { false, true }, (httpMethod, batch) =>
{
using (DSPResourceWithCollectionProperty.CollectionPropertiesResettable.Restore())
using (TestWebRequest request = service.CreateForInProcessWcf())
{
DSPResourceWithCollectionProperty.CollectionPropertiesResettable.Value = true;
request.Accept = "application/atom+xml,application/xml";
request.StartService();
DataServiceContext ctx = new DataServiceContext(request.ServiceRoot, ODataProtocolVersion.V4);
ctx.EnableAtom = true;
ctx.Format.UseAtom();
if (httpMethod != "POST")
{
service.EnableChangeInterceptors = false;
PopulateClientContextWithTestEntities(ctx);
service.EnableChangeInterceptors = true;
}
ctx.IgnoreResourceNotFoundException = true;
var resource = ctx.CreateQuery<XFeatureTestsEntity>("Entities").FirstOrDefault();
SaveChangesOptions saveOptions = batch ? SaveChangesOptions.BatchWithSingleChangeset : SaveChangesOptions.None;
switch (httpMethod)
{
case "POST":
resource = new XFeatureTestsEntity() { ID = 42, Strings = new List<string>(), Structs = new List<XFeatureTestsComplexType>() };
ctx.AddObject("Entities", resource);
break;
case "PUT":
saveOptions |= SaveChangesOptions.ReplaceOnUpdate;
ctx.UpdateObject(resource);
break;
case "PATCH":
ctx.UpdateObject(resource);
break;
case "DELETE":
ctx.DeleteObject(resource);
break;
}
ctx.SaveChanges(saveOptions);
Assert.AreEqual((int?)resource.ID, service.ChangeInterceptorCalledOnEntityId, "The change interceptor was not called or it was called with a wrong entity");
service.ChangeInterceptorCalledOnEntityId = null;
}
});
service.EnableChangeInterceptors = true;
service.ChangeInterceptorCalledOnEntityId = null;
// server cases (these operations can't be done using client API)
TestUtil.RunCombinations(
new string[] { "Strings", "Structs" },
new string[] { UnitTestsUtil.MimeApplicationXml},
(collectionPropertyName, format) =>
{
using (DSPResourceWithCollectionProperty.CollectionPropertiesResettable.Restore())
using (TestWebRequest request = service.CreateForInProcessWcf())
{
DSPResourceWithCollectionProperty.CollectionPropertiesResettable.Value = true;
request.StartService();
DataServiceContext ctx = new DataServiceContext(request.ServiceRoot, ODataProtocolVersion.V4);
ctx.EnableAtom = true;
ctx.Format.UseAtom();
service.EnableChangeInterceptors = false;
PopulateClientContextWithTestEntities(ctx);
service.EnableChangeInterceptors = true;
// Get the collection property payload
var payload = UnitTestsUtil.GetResponseAsAtomXLinq(request, "/Entities(1)/" + collectionPropertyName, format);
// And send a PUT with that payload back
request.HttpMethod = "PUT";
request.Accept = format;
request.RequestContentType = format;
request.RequestUriString = "/Entities(1)/" + collectionPropertyName;
request.SetRequestStreamAsText(payload.ToString());
request.SendRequest();
Assert.AreEqual((int?)1, service.ChangeInterceptorCalledOnEntityId, "The change interceptor was not called or it was called with a wrong entity");
service.ChangeInterceptorCalledOnEntityId = null;
}
});
}
public void Collection_Blobs()
{
DSPMetadata metadata = CreateMetadataForXFeatureEntity(true);
DSPServiceDefinition service = new DSPServiceDefinition() {
Metadata = metadata,
Writable = true,
SupportMediaResource = true,
MediaResourceStorage = new DSPMediaResourceStorage()
};
byte[] clientBlob = new byte[] { 0xcc, 0x10, 0x00, 0xff };
DSPContext data = new DSPContext();
service.CreateDataSource = (m) => { return data; };
using (TestWebRequest request = service.CreateForInProcessWcf())
using (DSPResourceWithCollectionProperty.CollectionPropertiesResettable.Restore())
{
DSPResourceWithCollectionProperty.CollectionPropertiesResettable.Value = true;
request.StartService();
XFeatureTestsMLE clientMle = new XFeatureTestsMLE() {
ID = 1,
Description = "Entity 1",
Strings = new List<string>(new string[] { "string 1", "string 2", string.Empty }),
Structs = new List<XFeatureTestsComplexType>(new XFeatureTestsComplexType[] {
new XFeatureTestsComplexType() { Text = "text 1" },
new XFeatureTestsComplexType() { Text = "text 2" }}) };
DataServiceContext ctx = new DataServiceContext(new Uri(request.BaseUri), ODataProtocolVersion.V4);
ctx.EnableAtom = true;
ctx.Format.UseAtom();
ctx.AddObject("Entities", clientMle);
ctx.SetSaveStream(clientMle, new MemoryStream(clientBlob), true, "application/octet-stream", clientMle.ID.ToString());
ctx.SaveChanges();
VerifyMLEs(service, clientMle, clientBlob);
// Read stream and verify stream contents
using (Stream serverStream = ctx.GetReadStream(clientMle).Stream)
{
VerifyStream(clientBlob, serverStream);
}
// modify MLE and the corresponding stream
clientMle.Structs.Add(new XFeatureTestsComplexType() { Text = "text 3" });
clientMle.Strings.RemoveAt(0);
clientBlob[0] ^= 0xff;
ctx.UpdateObject(clientMle);
ctx.SetSaveStream(clientMle, new MemoryStream(clientBlob), true, "application/octet-stream", clientMle.ID.ToString());
ctx.SaveChanges();
VerifyMLEs(service, clientMle, clientBlob);
// delete MLE
ctx.DeleteObject(clientMle);
ctx.SaveChanges();
Assert.IsNull((DSPResource)service.CurrentDataSource.GetResourceSetEntities("Entities").
FirstOrDefault(e => (int)(((DSPResource)e).GetValue("ID")) == (int)clientMle.GetType().GetProperty("ID").GetValue(clientMle, null)),
"MLE has not been deleted.");
Assert.AreEqual(0, service.MediaResourceStorage.Content.Count(), "The stream on the server has not been deleted.");
};
}
private static ContentKeyData CreateStorageContentKey(AssetData tempAsset, NullableFileEncryption fileEncryption, DataServiceContext dataContext)
{
// Create the content key.
fileEncryption.Init();
// Encrypt it for delivery to Nimbus.
X509Certificate2 certToUse = ContentKeyCollection.GetCertificateToEncryptContentKey(dataContext, ContentKeyType.StorageEncryption);
ContentKeyData contentKeyData = ContentKeyBaseCollection.CreateStorageContentKey(fileEncryption.FileEncryption, certToUse);
dataContext.AddObject(ContentKeyCollection.ContentKeySet, contentKeyData);
dataContext.SaveChanges();
// Associate it with the asset.
((IAsset) tempAsset).ContentKeys.Add(contentKeyData);
return contentKeyData;
}
public void InsertMLEAndSetSaveStream()
{
// Making sure that inserting an MLE/MR followed by SetSaveStream works well
TestUtil.RunCombinations(
(IEnumerable<SaveChangesMode>)Enum.GetValues(typeof(SaveChangesMode)),
UnitTestsUtil.BooleanValues,
(mode, closeStream) =>
{
using (PlaybackService.OverridingPlayback.Restore())
using (PlaybackService.InspectRequestPayload.Restore())
{
DataServiceContext context = new DataServiceContext(request.ServiceRoot, ODataProtocolVersion.V4);
context.EnableAtom = true;
context.Format.UseAtom();
ClientCSharpRegressionTests.CustomerWithStream c = new ClientCSharpRegressionTests.CustomerWithStream() { ID = 1, Name = "Foo" };
context.AddObject("Customers", c);
MemoryStream defaultStream = new MemoryStream(new byte[] { 0, 1, 2, 3 });
MemoryStream thumbnailStream = new MemoryStream(new byte[] { 0, 1, 2, 3, 4 });
context.SetSaveStream(c, defaultStream, closeStream, new DataServiceRequestArgs() { ContentType = "image/bmp" });
context.SetSaveStream(c, "Thumbnail", thumbnailStream, closeStream, new DataServiceRequestArgs() { ContentType = "image/bmp" });
// verify the entity descriptor state
EntityDescriptor entityDescriptor = context.Entities.Single();
StreamDescriptor streamInfo = entityDescriptor.StreamDescriptors.Single();
Assert.IsTrue(entityDescriptor.State == EntityStates.Added, "entity must be in added state");
Assert.AreEqual(streamInfo.StreamLink.Name, "Thumbnail");
Assert.IsTrue(streamInfo.State == EntityStates.Modified, "named stream must be in modified state");
string editLink = request.ServiceRoot.AbsoluteUri + "/editLink/Customers(1)";
int i = 0;
PlaybackService.InspectRequestPayload.Value = (message) =>
{
if (i == 2)
{
// Verify that the second request was a PUT request
Assert.IsTrue(PlaybackService.LastPlayback.Contains(String.Format("PATCH {0}", editLink)), "the second request must be a PATCH request with the edit link");
Assert.AreEqual(!defaultStream.CanWrite, closeStream, "The default stream must have been in the desired state");
}
else if (i == 1)
{
// Verify the first request was a POST request
Assert.IsTrue(PlaybackService.LastPlayback.Contains(String.Format("POST {0}/Customers", request.ServiceRoot)), "the first request must be a POST request");
PlaybackService.OverridingPlayback.Value = PlaybackService.ConvertToPlaybackServicePayload(null, null);
XDocument document = XDocument.Load(message);
Assert.IsTrue(document.Element(AstoriaUnitTests.Tests.UnitTestsUtil.AtomNamespace + "entry") != null, "must contain an entry element");
Assert.AreEqual(!defaultStream.CanWrite, closeStream, "The default stream must have been in the desired state immd after the request");
}
else if (i == 0)
{
// Populate the context with a single customer instance
string payload = AtomParserTests.MediaEntry(
id: Id,
editLink: editLink,
properties: Properties,
readStreamUrl: request.ServiceRoot + "/Customers(1)/readStreamUrl/$value",
links: GetNamedStreamSelfLink(request.ServiceRoot + "/Customers(1)/SelfLink/Thumbnail", contentType: MediaContentType) +
GetNamedStreamEditLink(request.ServiceRoot.AbsoluteUri + "/Customers(1)/EditLink/Thumbnail", contentType: MediaContentType, etag: MediaETag));
var headers = new List<KeyValuePair<string, string>>() {
new KeyValuePair<string, string>("Location", "http://locationservice/locationheader") };
PlaybackService.OverridingPlayback.Value = PlaybackService.ConvertToPlaybackServicePayload(headers, payload);
// entity state should not be modified until all the responses have been changed
Assert.IsTrue(entityDescriptor.State == EntityStates.Modified, "entity must be in added state");
Assert.IsTrue(defaultStream.CanWrite, "The default stream hasn't been closed yet");
}
Assert.AreEqual(streamInfo.StreamLink.Name, "Thumbnail");
Assert.IsTrue(streamInfo.State == EntityStates.Modified, "named stream must be in modified state");
// Also the stream info links should not be modified
Assert.IsTrue(streamInfo.StreamLink.SelfLink == null, "descriptor should not have been modified yet - self link must be null");
Assert.IsTrue(streamInfo.StreamLink.EditLink == null, "descriptor should not have been modified yet - edit link must be null");
Assert.IsTrue(String.IsNullOrEmpty(streamInfo.StreamLink.ContentType), "descriptor should not have been modified yet - content type must be null");
Assert.IsTrue(String.IsNullOrEmpty(streamInfo.StreamLink.ETag), "descriptor should not have been modified yet - etag must be null");
Assert.IsTrue(thumbnailStream.CanWrite, "The thumbnail stream hasn't been closed yet");
i++;
};
DataServiceContextTestUtil.SaveChanges(context, SaveChangesOptions.None, mode);
Assert.AreEqual(i, 3, "Only 2 request should have been made");
// Verify that the second request was a PUT request
Assert.IsTrue(PlaybackService.LastPlayback.Contains(String.Format("PUT {0}", streamInfo.StreamLink.EditLink)), "the second request must be a PUT request with the edit link");
Assert.AreEqual(streamInfo.StreamLink.SelfLink.AbsoluteUri, request.ServiceRoot + "/Customers(1)/SelfLink/Thumbnail", "self link must be null, since the payload did not have self link");
Assert.AreEqual(streamInfo.StreamLink.EditLink.AbsoluteUri, request.ServiceRoot + "/Customers(1)/EditLink/Thumbnail", "edit link should have been populated");
Assert.AreEqual(!thumbnailStream.CanWrite, closeStream, "The stream must be in the desired state");
}
});
}
public void FailureOnInsertEntity()
{
// Make sure if the POST fails, then also named stream request also fails, since we don't have the edit link for the named stream
TestUtil.RunCombinations(
(IEnumerable<SaveChangesMode>)Enum.GetValues(typeof(SaveChangesMode)), UnitTestsUtil.BooleanValues,
(mode, continueOnError) =>
{
using (PlaybackService.OverridingPlayback.Restore())
using (PlaybackService.InspectRequestPayload.Restore())
{
DataServiceContext context = new DataServiceContext(request.ServiceRoot, ODataProtocolVersion.V4);
PlaybackService.OverridingPlayback.Value = null;
Customer c = new Customer() { ID = 1, Name = "Foo" };
context.AddObject("Customers", c);
context.SetSaveStream(c, "Thumbnail", new MemoryStream(new byte[] { 0, 1, 2, 3 }), true, new DataServiceRequestArgs() { ContentType = "image/bmp" });
EntityDescriptor entityDescriptor = context.Entities.Single();
StreamDescriptor streamInfo = entityDescriptor.StreamDescriptors.Single();
int i = 0;
PlaybackService.InspectRequestPayload.Value = (message) =>
{
if (i == 1)
{
// Verify the first request was a POST request
Assert.IsTrue(PlaybackService.LastPlayback.Contains(String.Format("POST {0}/Customers", request.ServiceRoot)), "the first request must be a POST request");
}
i++;
};
try
{
DataServiceContextTestUtil.SaveChanges(context, continueOnError ? SaveChangesOptions.ContinueOnError : SaveChangesOptions.None, mode);
Assert.Fail("SaveChanges should always fail");
}
catch (DataServiceRequestException ex)
{
// here the server throws instream error (bad xml), so we'll always continue on error, even if it's not set..
Assert.AreEqual(2, ((IEnumerable<OperationResponse>)ex.Response).Count(), "we are expected 2 response for this SaveChanges operation");
Assert.IsTrue(ex.Response.Where<OperationResponse>(or => or.Error == null).SingleOrDefault() == null, "all responses should have errors");
Assert.AreEqual(streamInfo.State, EntityStates.Modified, "streamdescriptor should still be in modified state, so that next save changes can try this");
Assert.AreEqual(entityDescriptor.State, EntityStates.Added, "entityDescriptor is in the added state");
}
Assert.AreEqual(i, 1, "the number of requests sent to the server will only be 1, since the named stream request fails on the client side");
// Retrying again will always fail, since we have closed the stream.
}
});
}
public void RequestHeadersAndStreamTest()
{
// SaveChanges with multiple changes, using a variety of configurations (including sync, async, batch) and verify the request headers and payloads
using (PlaybackService.InspectRequestPayload.Restore())
using (PlaybackService.OverridingPlayback.Restore())
using (TestWebRequest request = TestWebRequest.CreateForInProcessWcf())
{
request.ServiceType = typeof(PlaybackService);
request.StartService();
Customer newCustomer1 = new Customer();
newCustomer1.Address = new Address();
newCustomer1.Address.City = "CustCity1";
newCustomer1.GuidValue = new Guid();
newCustomer1.Name = "CustName1";
Customer newCustomer2 = new Customer();
newCustomer2.ID = 2;
newCustomer2.Address = new Address();
newCustomer2.Address.City = "CustCity2";
newCustomer2.GuidValue = new Guid();
newCustomer2.Name = "CustName2";
Dictionary<string, string> responseHeaders1 = new Dictionary<string, string>();
responseHeaders1.Add("Content-ID", newCustomer1.ID.ToString());
responseHeaders1.Add("Location", String.Format("{0}/Customers({1})", request.BaseUri, newCustomer1.ID));
Dictionary<string, string> responseHeaders2 = new Dictionary<string, string>();
responseHeaders2.Add("Content-ID", newCustomer2.ID.ToString());
responseHeaders2.Add("Location", String.Format("{0}/Customers({1})", request.BaseUri, newCustomer2.ID));
string[] nonBatchHttpResponses = new string[]
{
PlaybackService.ConvertToPlaybackServicePayload(responseHeaders1, null, HttpStatusCode.Created),
PlaybackService.ConvertToPlaybackServicePayload(responseHeaders2, null, HttpStatusCode.Created)
};
string batchPayload;
string batchHttpResponse = PlaybackService.ConvertToBatchResponsePayload(nonBatchHttpResponses, false, out batchPayload);
var saveChangesModes = (IEnumerable<SaveChangesMode>)Enum.GetValues(typeof(SaveChangesMode));
var saveChangesOptions = new SaveChangesOptions[] { SaveChangesOptions.None, SaveChangesOptions.BatchWithSingleChangeset };
Dictionary<string, string> expectedRequestHeadersBatch = new Dictionary<string, string>();
expectedRequestHeadersBatch.Add("Content-Type", "multipart/mixed; boundary=batch_");
expectedRequestHeadersBatch.Add("Accept", "multipart/mixed");
AddCommonRequestHeaders(expectedRequestHeadersBatch);
expectedRequestHeadersBatch.Add("__Uri", String.Format("{0}/$batch", request.BaseUri));
Dictionary<string, string> expectedRequestHeadersNonBatch = new Dictionary<string, string>();
expectedRequestHeadersNonBatch.Add("Content-Type", "application/atom+xml");
expectedRequestHeadersNonBatch.Add("Accept", "application/atom+xml,application/xml");
AddCommonRequestHeaders(expectedRequestHeadersNonBatch);
expectedRequestHeadersNonBatch.Add("__Uri", String.Format("{0}/Customers", request.BaseUri));
TestUtil.RunCombinations(saveChangesModes, saveChangesOptions, (saveChangesMode, saveChangesOption) =>
{
DataServiceContext context = new DataServiceContext(new Uri(request.BaseUri));
context.EnableAtom = true;
context.Format.UseAtom();
HttpTestHookConsumer testHookConsumer = new HttpTestHookConsumer(context, false);
bool isBatch = saveChangesOption == SaveChangesOptions.BatchWithSingleChangeset;
int actualRequestCount = 0;
PlaybackService.InspectRequestPayload.Value = (requestStream) =>
{
// Verify request headers
Assert.AreEqual(1, testHookConsumer.RequestHeaders.Count, "Wrong number of request headers tracked by the test hook");
Dictionary<string, string> actualRequestHeaders = testHookConsumer.RequestHeaders[0];
Dictionary<string, string> expectedRequestHeaders = isBatch ? expectedRequestHeadersBatch : expectedRequestHeadersNonBatch;
VerifyHeaders(expectedRequestHeaders, actualRequestHeaders);
testHookConsumer.RequestHeaders.Clear();
// Verify request stream
Assert.AreEqual(1, testHookConsumer.RequestWrappingStreams.Count, "Wrong number of request streams tracked by the test hook");
string actualString = testHookConsumer.RequestWrappingStreams[0].GetLoggingStreamAsString();
StreamReader reader = new StreamReader(requestStream);
string expectedString = reader.ReadToEnd();
Assert.AreEqual(expectedString, actualString, "Request stream does not contain the expected value in the test hook.");
testHookConsumer.RequestWrappingStreams.Clear();
// Set the response payload here because a single SaveChanges call can produce multiple requests that
// require different responses, when not using batching.
string httpResponse = isBatch ? batchHttpResponse : nonBatchHttpResponses[actualRequestCount];
PlaybackService.OverridingPlayback.Value = httpResponse;
actualRequestCount++;
};
// Add multiple objects to ensure that multiple streams in a single API call will still get passed to the test hook
context.AddObject("Customers", newCustomer1);
context.AddObject("Customers", newCustomer2);
// Verify no requests have been made yet
Assert.AreEqual(0, actualRequestCount, "No HTTP requests should have been made yet.");
DataServiceContextTestUtil.SaveChanges(context, saveChangesOption, saveChangesMode);
// Verify that the expected number of requests were made during SaveChanges
int expectedRequestCount = isBatch ? 1 : 2;
Assert.AreEqual(expectedRequestCount, actualRequestCount, "Wrong number of HTTP requests made during SaveChanges.");
});
}
}
private void InnerSubmit(DataServiceContext dataContext)
{
if (!string.IsNullOrWhiteSpace(this.TemplateId))
{
dataContext.AddObject(JobBaseCollection.JobSet, this);
foreach (IAsset asset in this.InputMediaAssets)
{
AssetData target = asset as AssetData;
if (target == null)
{
throw new ArgumentException(StringTable.ErrorInputTypeNotSupported);
}
dataContext.AttachTo(AssetCollection.AssetSet, asset);
dataContext.AddLink(this, InputMediaAssetsPropertyName, target);
}
}
else
{
X509Certificate2 certToUse = null;
Verify(this);
dataContext.AddObject(JobBaseCollection.JobSet, this);
List<AssetData> inputAssets = new List<AssetData>();
AssetNamingSchemeResolver<AssetData, OutputAsset> assetNamingSchemeResolver = new AssetNamingSchemeResolver<AssetData, OutputAsset>(inputAssets);
foreach (ITask task in ((IJob)this).Tasks)
{
Verify(task);
TaskData taskData = (TaskData)task;
if (task.Options.HasFlag(TaskOptions.ProtectedConfiguration))
{
ProtectTaskConfiguration(taskData, ref certToUse, dataContext);
}
taskData.TaskBody = CreateTaskBody(assetNamingSchemeResolver, task.InputAssets.ToArray(), task.OutputAssets.ToArray());
taskData.InputMediaAssets.AddRange(task.InputAssets.OfType<AssetData>().ToArray());
taskData.OutputMediaAssets.AddRange(
task.OutputAssets
.OfType<OutputAsset>()
.Select(
c =>
{
AssetData assetData = new AssetData { Name = c.Name, Options = (int)c.Options, AlternateId = c.AlternateId };
assetData.InitCloudMediaContext(this._cloudMediaContext);
return assetData;
})
.ToArray());
dataContext.AddRelatedObject(this, TasksPropertyName, taskData);
}
foreach (IAsset asset in inputAssets)
{
dataContext.AttachTo(AssetCollection.AssetSet, asset);
dataContext.AddLink(this, InputMediaAssetsPropertyName, asset);
}
}
}
private static void ProtectTaskConfiguration(TaskTemplateData taskTemplate, ref X509Certificate2 certToUse, DataServiceContext dataContext)
{
using (ConfigurationEncryption configEncryption = new ConfigurationEncryption())
{
// Update the task template with the required data.
taskTemplate.Configuration = configEncryption.Encrypt(taskTemplate.Configuration);
taskTemplate.EncryptionKeyId = configEncryption.GetKeyIdentifierAsString();
taskTemplate.EncryptionScheme = ConfigurationEncryption.SchemeName;
taskTemplate.EncryptionVersion = ConfigurationEncryption.SchemeVersion;
taskTemplate.InitializationVector = configEncryption.GetInitializationVectorAsString();
if (certToUse == null)
{
// Get the certificate to use to encrypt the configuration encryption key.
certToUse = ContentKeyBaseCollection.GetCertificateToEncryptContentKey(dataContext, ContentKeyType.ConfigurationEncryption);
}
// Create a content key object to hold the encryption key.
ContentKeyData contentKeyData = ContentKeyBaseCollection.CreateConfigurationContentKey(configEncryption, certToUse);
dataContext.AddObject(ContentKeyCollection.ContentKeySet, contentKeyData);
}
}
public void EdmValidNamesNotAllowedInUri()
{
DSPMetadata metadata = new DSPMetadata("Test", "TestNS");
var entityType = metadata.AddEntityType("MyType", null, null, false);
metadata.AddKeyProperty(entityType, "ID", typeof(int));
metadata.AddPrimitiveProperty(entityType, "Pròjè_x00A2_tÎð瑞갂థ్క_x0020_Iiلإَّ", typeof(string));
var resourceSet = metadata.AddResourceSet("EntitySet", entityType);
metadata.SetReadOnly();
DSPServiceDefinition service = new DSPServiceDefinition()
{
Metadata = metadata,
Writable = true
};
DSPContext data = new DSPContext();
service.CreateDataSource = (m) => { return data; };
using (TestWebRequest request = service.CreateForInProcessWcf())
{
request.StartService();
DataServiceContext context = new DataServiceContext(request.ServiceRoot);
context.EnableAtom = true;
context.Format.UseAtom();
string value = "value of Pròjè_x00A2_tÎð瑞갂థ్క_x0020_Iiلإَّ";
context.AddObject("EntitySet", new MyType() {
ID = 1,
Pròjè_x00A2_tÎð瑞갂థ్క_x0020_Iiلإَّ = value,
});
context.SaveChanges();
var result = context.Execute<MyType>(new Uri("EntitySet?$orderby=Pròjè_x00A2_tÎð瑞갂థ్క_x0020_Iiلإَّ", UriKind.Relative)).First();
Assert.AreEqual(value, result.Pròjè_x00A2_tÎð瑞갂థ్క_x0020_Iiلإَّ, "The roundtrip value not as expected");
}
}
public void ClientSerializeGeographyTest_AddDataPresentAndNamespaceNotDuplicated()
{
DataServiceContext ctx = new DataServiceContext(new Uri("http://localhost"));
ctx.AddObject("Entities", testEntity);
ClientSerializeGeographyTest_Validate(ctx);
}
private void InnerSave(DataServiceContext dataContext)
{
X509Certificate2 certToUse = null;
dataContext.AddObject(JobTemplateBaseCollection.JobTemplateSet, this);
foreach (TaskTemplateData taskTemplate in this.TaskTemplates)
{
dataContext.AddRelatedObject(this, TaskTemplatesPropertyName, taskTemplate);
if (((ITaskTemplate)taskTemplate).Options.HasFlag(TaskOptions.ProtectedConfiguration) && (taskTemplate.Configuration != taskTemplate.ConfigurationCopied))
{
ProtectTaskConfiguration((TaskTemplateData)taskTemplate, ref certToUse, dataContext);
}
}
MatchCollection matches = Regex.Matches(this.JobTemplateBodyCopied, @"taskTemplateId=""nb:ttid:UUID:([a-zA-Z0-9\-]+)""");
this.JobTemplateBody = this.JobTemplateBodyCopied;
for (int i = 0; i < matches.Count; i++)
{
string taskTemplateId = Guid.NewGuid().ToString();
this.TaskTemplates[i].Id = string.Concat("nb:ttid:UUID:", taskTemplateId);
this.JobTemplateBody = this.JobTemplateBody.Replace(matches[i].Groups[1].Value, taskTemplateId);
}
}
private static void PopulateClientContextWithTestEntities(DataServiceContext context)
{
foreach (var entity in CreateClientTestEntities())
{
context.AddObject("Entities", entity);
}
context.SaveChanges(SaveChangesOptions.BatchWithSingleChangeset);
}
/// <summary>
/// Applies this state to the specfied <paramref name="target"/> such that after invocation,
/// the target in the given <paramref name="context"/> is in this state.
/// </summary>
/// <param name="context">Context to apply changes to.</param>
/// <param name="target">Target to change state on.</param>
/// <param name="entitySetName">Name of entity set (necessary for certain transitions).</param>
public void ApplyToObject(DataServiceContext context, object target, string entitySetName)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
if (target == null)
{
throw new ArgumentNullException("target");
}
EntityStates current = GetStateForEntity(context, target);
if (current == this.state)
{
return;
}
switch (this.state)
{
case EntityStates.Added:
if (current != EntityStates.Detached)
{
context.Detach(target);
}
context.AddObject(entitySetName, target);
break;
case EntityStates.Detached:
context.Detach(target);
break;
case EntityStates.Deleted:
if (current == EntityStates.Detached)
{
context.AttachTo(entitySetName, target);
}
context.DeleteObject(target);
break;
case EntityStates.Modified:
if (current == EntityStates.Detached)
{
context.AttachTo(entitySetName, target);
}
context.UpdateObject(target);
break;
case EntityStates.Unchanged:
if (current != EntityStates.Detached)
{
context.Detach(target);
}
context.AttachTo(entitySetName, target);
break;
}
}
public static void EnsureInsert(DataServiceContext context, object entity, string entitySetName, Workspace workspace, string skipEntitySet)
{
#if !ClientSKUFramework
IEdmEntityType entityType = null;
if (DataServiceMetadata.ServiceMetadata == null)
{
DataServiceMetadata.LoadServiceMetadata(workspace.ServiceUri);
}
if (DataServiceMetadata.EntityTypes.Any(eType => eType.Name == entitySetName))
{
entityType = DataServiceMetadata.EntityTypes.First(eType => eType.Name == entitySetName);
}
if (entityType == null && DataServiceMetadata.EntityTypes.Any(eType => eType.Name == entity.GetType().Name))
{
entityType = DataServiceMetadata.EntityTypes.First(eType => eType.Name == entity.GetType().Name);
entitySetName = entity.GetType().Name;
}
if (entityType == null) return;
foreach (IEdmNavigationProperty navProperty in entityType.NavigationProperties())
{
if (context.Links.All(ld => (ld.SourceProperty != navProperty.Name)))
{
if (navProperty.TargetMultiplicity() == EdmMultiplicity.One && navProperty.Name != skipEntitySet)
{
IEdmEntityType navProperyEntityType = DataServiceMetadata.GetEntityType(navProperty);
ResourceType resourceType = workspace.ServiceContainer.ResourceTypes.First(rt => rt.Name == navProperyEntityType.Name);
object instance = resourceType.CreateInstance(false);
context.AddObject(navProperyEntityType.Name == "College" ? "Colleges" : navProperyEntityType.Name, instance);
context.SetLink(entity, navProperty.Name, instance);
}
}
}
#endif
}
public void EFFK_1To1_BasicInsertAndBind_Batch_ChangedUriCompositionRulesOnServer()
{
// Fix URI composition in Astoria for V3 payloads
ctx = new DataServiceContext(web.ServiceRoot, Microsoft.OData.Client.ODataProtocolVersion.V4);
ctx.EnableAtom = true;
ctx.Format.UseAtom();
// Create new office type
EFFKClient.Office o = new EFFKClient.Office() { ID = 1, BuildingName = "Building 35", FloorNumber = 2, OfficeNumber = 2173 };
ctx.AddObject("CustomObjectContext.Offices", o);
// create new employee type
EFFKClient.Worker e = new EFFKClient.Worker() { ID = 1, FirstName = "Pratik", LastName = "Patel" };
ctx.AddObject("CustomObjectContext.Workers", e);
// Establish relationship between employee and office
ctx.SetLink(o, "Worker", e);
ctx.SetLink(e, "Office", o);
ctx.SaveChanges(SaveChangesOptions.BatchWithSingleChangeset);
// clean the context
ctx.DeleteObject(e);
ctx.DeleteObject(o);
ctx.SaveChanges(SaveChangesOptions.BatchWithSingleChangeset);
}
