public void Dev10Type_ClientDynamicExpand()
{
using (TestWebRequest web = TestWebRequest.CreateForInProcessWcf())
{
web.DataServiceType = typeof(Dev10TypeDef.Dev10TypeEntitySet_Expand);
web.StartService();
string baseUri = web.BaseUri;
DataServiceContext context = new DataServiceContext(new Uri(baseUri));
var query = context.CreateQuery <Dev10TypeDef.EntityWithDynamicNavigation>("Parents").Expand("Children");
try
{
var results = query.ToList();
Assert.Fail("Exception failed to be thrown.");
}
catch (Exception ex)
{
Exception innerEx = ex;
while (innerEx.InnerException != null)
{
innerEx = innerEx.InnerException;
}
Assert.IsTrue(innerEx.Message.Contains("Internal Server Error. The type 'AstoriaUnitTests.Tests.UnitTestModule+Dev10TypeTests+EntityWithDynamicInterface' is not supported."), ex.InnerException.Message);
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="IngestManifestAssetCollection"/> class.
/// </summary>
/// <param name="cloudMediaContext">The <seealso cref="CloudMediaContext"/> instance.</param>
/// <param name="parentIngestManifest">parent manifest if collection associated with manifest </param>
internal IngestManifestAssetCollection(CloudMediaContext cloudMediaContext, IIngestManifest parentIngestManifest)
{
_cloudMediaContext = cloudMediaContext;
_dataContext = _cloudMediaContext.DataContextFactory.CreateDataServiceContext();
_parentIngestManifest = parentIngestManifest;
_query = new Lazy <IQueryable <IIngestManifestAsset> >(() => _dataContext.CreateQuery <IngestManifestAssetData>(EntitySet));
}
public void Dev10Type_ClientQueryTupleWithALinq()
{
using (TestWebRequest web = TestWebRequest.CreateForInProcessWcf())
{
web.DataServiceType = typeof(Dev10TypeDef.Dev10TypeEntitySet <Dev10TypeDef.EntityWithTupleProperty>);
web.StartService();
string baseUri = web.BaseUri;
DataServiceContext context = new DataServiceContext(new Uri(baseUri));
var query = from t in context.CreateQuery <Dev10TypeDef.EntityWithTupleProperty>("Entities")
where t.ComplexTuple.Item1 == "value 1"
select t;
try
{
string queryUri = query.ToString();
Assert.Fail("Client ALINQ with Tuple failed to throw");
}
catch (Exception ex)
{
Exception innerEx = ex;
while (innerEx.InnerException != null)
{
innerEx = innerEx.InnerException;
}
Assert.AreEqual("The type 'System.Tuple`2[System.String,System.String]' is not supported by the client library.", innerEx.Message);
}
}
}
public void WhenOrdering_ThenSucceeds()
{
var config = HttpHostConfiguration.Create();
config.Configuration.OperationHandlerFactory.Formatters.Insert(0, new JsonNetMediaTypeFormatter());
using (var ws = new HttpWebService<TestService>("http://localhost:20000", "products", config))
{
var client = new HttpClient("http://localhost:20000");
client.DefaultRequestHeaders.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("text/json"));
var context = new DataServiceContext(new Uri("http://localhost:20000"));
// We always specify how many to take, to be explicit.
var query = context.CreateQuery<Product>("products")
.Where(x => x.Owner.Name == "kzu")
.OrderBy(x => x.Id)
.ThenBy(x => x.Owner.Id)
.Skip(1)
.Take(1);
//var uri = ((DataServiceQuery)query).RequestUri;
var uri = new Uri(((DataServiceQuery)query).RequestUri.ToString().Replace("()?$", "?$"));
Console.WriteLine(uri);
var response = client.Get(uri);
Assert.True(response.IsSuccessStatusCode, "Failed : " + response.StatusCode + " " + response.ReasonPhrase);
var products = new JsonSerializer().Deserialize<List<Product>>(new JsonTextReader(new StreamReader(response.Content.ContentReadStream)));
Assert.Equal(1, products.Count);
}
}
//[TestMethod, Variation("One should not be able to get named streams via load property api")]
public void NamedStreams_LoadPropertyTest()
{
// populate the context
DataServiceContext context = new DataServiceContext(request.ServiceRoot, ODataProtocolVersion.V4);
EntityWithNamedStreams1 entity = context.CreateQuery<EntityWithNamedStreams1>("MySet1").Take(1).Single();
try
{
context.LoadProperty(entity, "Stream1");
}
catch (DataServiceClientException ex)
{
Assert.IsTrue(ex.Message.Contains(DataServicesResourceUtil.GetString("DataService_VersionTooLow", "1.0", "3", "0")), String.Format("The error message was not as expected: {0}", ex.Message));
}
try
{
context.BeginLoadProperty(
entity,
"Stream1",
(result) => { context.EndLoadProperty(result); },
null);
}
catch (DataServiceClientException ex)
{
Assert.IsTrue(ex.Message.Contains(DataServicesResourceUtil.GetString("DataService_VersionTooLow", "1.0", "3", "0")), String.Format("The error message was not as expected: {0}", ex.Message));
}
}
public void AddQueryOptionForFormatShouldThrow()
{
DataServiceContext ctx = new DataServiceContext(new Uri("http://myservice/", UriKind.Absolute));
ctx.CreateQuery <Customer>("Customers").AddQueryOption("$format", "atom").ToString().Should()
.Be("Error translating Linq expression to URI: The '$format' query option is not supported. Use the DataServiceContext.Format property to set the desired format.");
}
/// <summary>
/// Asynchronously saves this <see cref="IJobTemplate"/> when created from a copy of an existing <see cref="IJobTemplate"/>.
/// </summary>
/// <returns>A function delegate that returns the future result to be available through the Task.</returns>
public Task SaveAsync()
{
if (!string.IsNullOrWhiteSpace(this.Id))
{
// The job template was already saved, and there is no current support to update it.
throw new InvalidOperationException(StringTable.InvalidOperationSaveForSavedJobTemplate);
}
DataServiceContext dataContext = this._cloudMediaContext.DataContextFactory.CreateDataServiceContext();
this.InnerSave(dataContext);
return(dataContext
.SaveChangesAsync(SaveChangesOptions.Batch, this)
.ContinueWith(
t =>
{
t.ThrowIfFaulted();
JobTemplateData data = (JobTemplateData)t.AsyncState;
dataContext.CreateQuery <JobTemplateData>(JobTemplateBaseCollection.JobTemplateSet).Where(jt => jt.Id == data.Id).First();
dataContext.LoadProperty(data, TaskTemplatesPropertyName);
}));
}
public virtual async Task CreateAndDeleteLinkToDerivedNavigationPropertyOnBaseEntitySet()
{
// clear respository
await this.ClearRepositoryAsync("InheritanceTests_Vehicles");
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 <MiniSportBike>(r, creatorSettings);
DataServiceContext ctx = WriterClient(new Uri(this.BaseAddress), ODataProtocolVersion.V4);
ctx.AddObject("InheritanceTests_Vehicles", car);
ctx.AddObject("InheritanceTests_Vehicles", vehicle);
await ctx.SaveChangesAsync();
ctx.SetLink(car, "SingleNavigationProperty", vehicle);
await ctx.SaveChangesAsync();
ctx = ReaderClient(new Uri(this.BaseAddress), ODataProtocolVersion.V4);
var cars = (await ctx.CreateQuery <Vehicle>("InheritanceTests_Vehicles").ExecuteAsync()).ToList().OfType <Car>();
var actual = cars.First();
await ctx.LoadPropertyAsync(actual, "SingleNavigationProperty");
AssertExtension.PrimitiveEqual(vehicle, actual.SingleNavigationProperty);
await this.ClearRepositoryAsync("InheritanceTests_Vehicles");
}
public async Task Test_NavigationBidingUrlIsAsExpected()
{
var ctx = new DataServiceContext(new Uri("http://localhost"));
ctx.Format.LoadServiceModel = () => CsdlReader.Parse(XmlReader.Create(new StringReader(EDMX)));
ctx.Format.UseJson();
ctx.Configurations.ResponsePipeline.OnMessageReaderSettingsCreated((settingsArgs) =>
{
settingsArgs.Settings.Validations = ValidationKinds.None;
});
ctx.Configurations.RequestPipeline.OnMessageCreating = args => new CustomizedRequestMessage(
args,
RESPONSE,
new Dictionary <string, string>()
{
{ "Content-Type", "application/json;charset=utf-8" },
});
var query = ctx.CreateQuery <Level3>("Level3");
var values = await query.ExecuteAsync();
values = values.ToList();
var first = values.FirstOrDefault();
Assert.NotNull(first?.Id);
Assert.NotNull(ctx.Entities);
var firstEntityDescriptor = ctx.Entities.FirstOrDefault();
Assert.Equal(EXPECTED_URL, firstEntityDescriptor?.Identity?.AbsoluteUri);
}
private async Task <IEnumerable <T> > GetEntities <T>(string entitySetName)
{
DataServiceContext readClient = ReaderClient(new Uri(this.BaseAddress), ODataProtocolVersion.V4);
var query = readClient.CreateQuery <T>(entitySetName);
return(await query.ExecuteAsync());
}
public void WhenOrdering_ThenSucceeds()
{
var config = HttpHostConfiguration.Create();
config.Configuration.OperationHandlerFactory.Formatters.Insert(0, new JsonNetMediaTypeFormatter());
using (var ws = new HttpWebService <TestService>("http://localhost:20000", "products", config))
{
var client = new HttpClient("http://localhost:20000");
client.DefaultRequestHeaders.Accept.Add(new System.Net.Http.Headers.MediaTypeWithQualityHeaderValue("text/json"));
var context = new DataServiceContext(new Uri("http://localhost:20000"));
// We always specify how many to take, to be explicit.
var query = context.CreateQuery <Product>("products")
.Where(x => x.Owner.Name == "kzu")
.OrderBy(x => x.Id)
.ThenBy(x => x.Owner.Id)
.Skip(1)
.Take(1);
//var uri = ((DataServiceQuery)query).RequestUri;
var uri = new Uri(((DataServiceQuery)query).RequestUri.ToString().Replace("()?$", "?$"));
Console.WriteLine(uri);
var response = client.Get(uri);
Assert.True(response.IsSuccessStatusCode, "Failed : " + response.StatusCode + " " + response.ReasonPhrase);
var products = new JsonSerializer().Deserialize <List <Product> >(new JsonTextReader(new StreamReader(response.Content.ContentReadStream)));
Assert.Equal(1, products.Count);
}
}
private SessionRow GetSession(string id, DataServiceContext context)
{
try
{
DataServiceQuery <SessionRow> queryObj = context.CreateQuery <SessionRow>(tableName);
var query = (from session in queryObj
where session.PartitionKey == SecUtility.CombineToKey(applicationName, id)
select session).AsTableServiceQuery();
IEnumerable <SessionRow> sessions = query.Execute();
// enumerate the result and store it in a list
var sessionList = new List <SessionRow>(sessions);
if (sessionList.Count() == 1)
{
return(sessionList.First());
}
if (sessionList.Count() > 1)
{
throw new ProviderException("Multiple sessions with the same name!");
}
return(null);
}
catch (Exception e)
{
throw new ProviderException("Error accessing storage.", e);
}
}
public async Task <SegmentedResult <TItem> > SelectAsync <TItem>(Expression <Func <TItem, bool> > queryExpression, string continuationToken = null, int rowCount = 500) where TItem : class, ITableItem, new()
{
QueryExpressionVisitor <TItem> visitor = new QueryExpressionVisitor <TItem>();
_ = (Expression <Func <TItem, bool> >)visitor.Visit(queryExpression);
DataServiceContext context = new DataServiceContext(new Uri("https://tempuri.org"));
var dataServiceQuery = context.CreateQuery <TItem>("/items").Where(queryExpression);
string queryString = (((DataServiceQuery)dataServiceQuery).RequestUri).Query;
var queryCollection = HttpUtility.ParseQueryString(queryString);
TableQuery query = new TableQuery()
{
FilterString = queryCollection.Get("$filter"),
TakeCount = rowCount,
};
this.Logger.LogInformation($"Running Azure table query: {query.FilterString}");
var token = AzureStorageUtilities.DeserializeTableContinuationToken(continuationToken);
var azureResult = await this.Table.ExecuteQuerySegmentedAsync(query, token);
IEnumerable <TItem> itemsList = azureResult.Results.Select(x => this.Assembler.Assemble <TItem>((DynamicTableEntity)x));
string nextPageToken = azureResult.ContinuationToken.Serialize();
return(new SegmentedResult <TItem>(itemsList, nextPageToken, null != nextPageToken));
}
public void TestSpecialCharactersInPrimaryKey()
{
DataServiceContext ctx = new DataServiceContext(new Uri(this.BaseAddress));
var todoes = ctx.CreateQuery <SpecialCharactersLinkGenerationTestsModel>("SpecialCharactersLinkGenerationWebTests").ToList();
bool success = true;
foreach (var todo in todoes)
{
try
{
Uri selfLink;
Assert.True(ctx.TryGetUri(todo, out selfLink));
Console.WriteLine(selfLink);
//ctx.UpdateObject(todo);
//var response = ctx.SaveChanges().Single();
//Assert.Equal(204, response.StatusCode);
ctx.Execute <SpecialCharactersLinkGenerationTestsModel>(selfLink, "GET", true);
}
catch (Exception ex)
{
Console.WriteLine(ex);
success = false;
}
}
Assert.True(success);
}
private static DataServiceQuery <DataServicePackage> CreateQuery()
{
var dataServiceContext = new DataServiceContext(new Uri(NuGetOfficialFeedUrl));
var query = dataServiceContext.CreateQuery <DataServicePackage>("Package");
return(query);
}
public async Task TestSpecialCharactersInPrimaryKey()
{
var client = new DataServiceContext(new Uri(this.BaseAddress));
client.Format.UseJson(_model);
var query = client.CreateQuery <SpecialCharactersLinkGenerationTestsModel>("SpecialCharactersLinkGenerationWebTests");
var todoes = await query.ExecuteAsync();
bool success = true;
foreach (var todo in todoes)
{
try
{
Uri selfLink;
Assert.True(client.TryGetUri(todo, out selfLink));
var result = await client.ExecuteAsync <SpecialCharactersLinkGenerationTestsModel>(selfLink, "GET", true);
var fetchedTodo = result.FirstOrDefault();
Assert.NotNull(fetchedTodo);
Assert.Equal(todo.Name, fetchedTodo.Name);
}
catch (Exception ex)
{
Console.WriteLine(ex);
success = false;
}
}
Assert.True(success);
}
private RoleRow GetUserInRole(DataServiceContext svc, string rolename, string username)
{
SecUtility.CheckParameter(ref username, true, true, true, Constants.MaxTableUsernameLength, "username");
SecUtility.CheckParameter(ref rolename, true, true, true, MaxTableRoleNameLength, "rolename");
try
{
DataServiceQuery <RoleRow> queryObj = svc.CreateQuery <RoleRow>(_tableName);
var query = (from user in queryObj
where user.PartitionKey == SecUtility.CombineToKey(_applicationName, username) &&
user.RowKey == SecUtility.Escape(rolename)
select user).AsTableServiceQuery();
try
{
IEnumerable <RoleRow> userRows = query.Execute();
return(userRows.FirstOrDefault());
}
catch (InvalidOperationException e)
{
if (e.InnerException is DataServiceClientException && (e.InnerException as DataServiceClientException).StatusCode == (int)HttpStatusCode.NotFound)
{
return(null);
}
else
{
throw;
}
}
}
catch (Exception e)
{
throw new ProviderException("Error while accessing the data store.", e);
}
}
public void UpdateEntityTest_ETag()
{
IQDSP.Customer c = this.CreateCustomer();
context.MergeOption = MergeOption.OverwriteChanges;
context.AddObject("Customers", c);
context.SaveChanges();
var outdatedContext = new DataServiceContext(context.BaseUri);
IQDSP.Customer outdatedSupplier = outdatedContext.CreateQuery <IQDSP.Customer>("Customers").Where(_c => _c.CustomerID == c.CustomerID).FirstOrDefault();
c.CompanyName = "something else";
context.UpdateObject(c);
context.SaveChanges();
context.UpdateObject(c);
context.SaveChanges();
c = context.CreateQuery <IQDSP.Customer>("Customers").Where(_c => _c.CustomerID == c.CustomerID).FirstOrDefault();
Assert.AreEqual("something else", c.CompanyName);
outdatedContext.UpdateObject(outdatedSupplier);
try
{
outdatedContext.SaveChanges();
Assert.Fail("Concurrency failed to throw");
}
catch (DataServiceRequestException ex)
{
Assert.IsTrue(ex.InnerException.Message.Contains("Concurrency: precondition failed for property 'CompanyName'"));
}
}
public void TestCollectionOfSpatialTypes()
{
DSPUnitTestServiceDefinition roadTripServiceDefinition = GetRoadTripServiceDefinition(typeof(GeographyPoint), TestPoint.DefaultValues, false, false,
(m) =>
{
var resourceType = m.GetResourceType("TripLeg");
var primitiveType = Microsoft.OData.Service.Providers.ResourceType.GetPrimitiveResourceType(typeof(GeographyPoint));
m.AddCollectionProperty(resourceType, "PointsOfInterest", primitiveType);
},
(name, values) =>
{
if (name == "TripLeg")
{
var list = values.Select(kvp => kvp.Value).ToList();
values.Add(new KeyValuePair <string, object>("PointsOfInterest", list));
}
});
using (TestWebRequest request = roadTripServiceDefinition.CreateForInProcessWcf())
{
request.StartService();
DataServiceContext context = new DataServiceContext(request.ServiceRoot, ODataProtocolVersion.V4);
context.EnableAtom = true;
context.Format.UseAtom();
var tripLegs = context.CreateQuery <TripLegWithCollection <GeographyPoint> >("TripLegs").Where(t => t.ID == SpatialTestUtil.DefaultId).ToList();
var tripLeg = tripLegs.Single();
Assert.AreEqual(2, tripLeg.PointsOfInterest.Count(), "didn't materialize all the elements");
}
}
public void NamedStreams_DeepEntityProjection_CannotAccessEntitiesAcrossLevels()
{
// projecting out deep links to get stream url in DSSL property with multiple parameters in scope - both narrow type and anonymous type
{
// Querying url of the nested type - doing this makes the entity non-tracking, but populated the link property
DataServiceContext context = new DataServiceContext(request.ServiceRoot, ODataProtocolVersion.V4);
var q = from s in context.CreateQuery <EntityWithNamedStreams1>("MySet1")
where s.ID == 1
from c in s.Collection
select new EntityWithNamedStreams2()
{
ID = c.ID,
Stream1 = s.Stream1
};
try
{
q.ToList();
}
catch (NotSupportedException ex)
{
Assert.AreEqual(ex.Message, DataServicesClientResourceUtil.GetString("ALinq_CanOnlyProjectTheLeaf"), "error message should match as expected");
}
Assert.AreEqual(context.Entities.Count, 0, "there should be no entities tracked by the context in error case");
}
}
private static void RunEndToEndSmokeTestWithClient(Action <DataServiceContext> customize = null)
{
using (TestWebRequest request = TestWebRequest.CreateForInProcessWcf())
{
request.DataServiceType = typeof(KeyAsSegmentService);
request.StartService();
DataServiceContext ctx = new DataServiceContext(request.ServiceRoot, ODataProtocolVersion.V4)
{
UrlKeyDelimiter = DataServiceUrlKeyDelimiter.Slash
};
if (customize != null)
{
customize(ctx);
}
var customer = ctx.CreateQuery <Customer>("Customers").Where(c => c.ID == 0).Single();
var descriptor = ctx.GetEntityDescriptor(customer);
var navigationsLinks = descriptor.LinkInfos.Where(l => l.NavigationLink != null).ToList();
var baseUri = request.ServiceRoot.AbsoluteUri;
Assert.AreEqual(baseUri + "/Customers/0", descriptor.Identity.OriginalString);
Assert.AreEqual(baseUri + "/Customers/0", descriptor.EditLink.OriginalString);
Assert.AreEqual(baseUri + "/Customers/0/BestFriend/$ref", navigationsLinks[0].AssociationLink.OriginalString);
Assert.AreEqual(baseUri + "/Customers/0/BestFriend", navigationsLinks[0].NavigationLink.OriginalString);
Assert.AreEqual(baseUri + "/Customers/0/Orders/$ref", navigationsLinks[1].AssociationLink.OriginalString);
Assert.AreEqual(baseUri + "/Customers/0/Orders", navigationsLinks[1].NavigationLink.OriginalString);
}
}
//[TestMethod, Variation("One should not be able to get named streams via load property api")]
public void NamedStreams_LoadPropertyTest()
{
// populate the context
DataServiceContext context = new DataServiceContext(request.ServiceRoot, ODataProtocolVersion.V4);
EntityWithNamedStreams1 entity = context.CreateQuery <EntityWithNamedStreams1>("MySet1").Take(1).Single();
try
{
context.LoadProperty(entity, "Stream1");
}
catch (DataServiceClientException ex)
{
Assert.IsTrue(ex.Message.Contains(DataServicesResourceUtil.GetString("DataService_VersionTooLow", "1.0", "3", "0")), String.Format("The error message was not as expected: {0}", ex.Message));
}
try
{
context.BeginLoadProperty(
entity,
"Stream1",
(result) => { context.EndLoadProperty(result); },
null);
}
catch (DataServiceClientException ex)
{
Assert.IsTrue(ex.Message.Contains(DataServicesResourceUtil.GetString("DataService_VersionTooLow", "1.0", "3", "0")), String.Format("The error message was not as expected: {0}", ex.Message));
}
}
public void SetDollarFormatInAddQueryOption()
{
using (TestWebRequest web = TestWebRequest.CreateForInProcessWcf())
{
web.DataServiceType = typeof(DollarFormatTestService);
web.StartService();
DataServiceContext ctx = new DataServiceContext(web.ServiceRoot, ODataProtocolVersion.V4);
List <string> options = new List <string>()
{
"atom",
"json",
"jsonlight",
"xml",
};
foreach (string option in options)
{
try
{
ctx.CreateQuery <Customer>("Customers").AddQueryOption("$format", option).Execute();
}
catch (NotSupportedException e)
{
Assert.AreEqual(DataServicesClientResourceUtil.GetString("ALinq_FormatQueryOptionNotSupported"), e.Message);
}
}
}
}
private SessionRow GetSession(string id, DataServiceContext context)
{
Debug.Assert(context != null);
Debug.Assert(id != null && id.Length <= Configuration.MaxStringPropertySizeInChars);
try
{
DataServiceQuery <SessionRow> queryObj = context.CreateQuery <SessionRow>(_tableName);
var query = (from session in queryObj
where session.PartitionKey == SecUtility.CombineToKey(_applicationName, id)
select session).AsTableServiceQuery();
IEnumerable <SessionRow> sessions = query.Execute();
// enumerate the result and store it in a list
List <SessionRow> sessionList = new List <SessionRow>(sessions);
if (sessionList != null && sessionList.Count() == 1)
{
return(sessionList.First());
}
else if (sessionList != null && sessionList.Count() > 1)
{
throw new ProviderException("Multiple sessions with the same name!");
}
else
{
return(null);
}
}
catch (Exception e)
{
throw new ProviderException("Error accessing storage.", e);
}
}
public void OpenSpatialProperties()
{
// Verify that the client round tripping works with spatial open properties
DSPUnitTestServiceDefinition roadTripServiceDefinition = GetRoadTripServiceDefinition(
typeof(GeographyPoint),
TestPoint.DefaultValues,
false, // useComplexType
true, // useOpenType
null);
using (TestWebRequest request = roadTripServiceDefinition.CreateForInProcessWcf())
{
request.StartService();
DataServiceContext context = new DataServiceContext(request.ServiceRoot, ODataProtocolVersion.V4);
context.EnableAtom = true;
context.Format.UseAtom();
// Query the top level set
List <TripLeg <Geography> > results = context.CreateQuery <TripLeg <Geography> >("TripLegs").ToList();
Assert.IsTrue(results.Count == 1, "one trip leg should get materialized");
Assert.IsTrue(context.Entities.Count == 1, "One trip leg instance should get populated in the context");
// Update the property value
results[0].GeographyProperty1 = GeographyFactory.Point(22, 45);
context.UpdateObject(results[0]);
context.SaveChanges();
var data = roadTripServiceDefinition.CurrentDataSource.GetResourceSetEntities("TripLegs");
Assert.AreEqual(1, data.Count, "there should one instance of TripLeg in the set");
GeographyPoint point = (GeographyPoint)((DSPResource)data[0]).GetOpenPropertyValue("GeographyProperty1");
Assert.AreEqual(45, point.Longitude, "Make sure longitude value is updated");
Assert.AreEqual(22, point.Latitude, "Make sure latitude value is updated");
}
}
/// <summary>
/// Constructor
/// </summary>
public EntityQuery() : base()
{
var context = new DataServiceContext(new Uri(__placeholderServiceName), DataServiceProtocolVersion.V3);
DataServiceQuery = (DataServiceQuery <T>)context.CreateQuery <T>(__placeholderResourceName).Where(x => true);
QueryableType = typeof(T);
}
static void Main(string[] args)
{
Console.WriteLine("Ожидание сервера.");
Thread.Sleep(300);
var context = new DataServiceContext(new Uri(ServiceAddress))
{
};
context.BuildingRequest += (s, e) => Console.WriteLine(e.RequestUri);
context.ReceivingResponse += (s, e) => Console.WriteLine($"Response status: {e.ResponseMessage.StatusCode}");
//context.AttachTo("");
var data = context.CreateQuery <Student>("Students").Expand(s => s.School);
var query = data.Expand("School");
var uri = ((DataServiceQuery)query).RequestUri.ToString();
var items = data.ToArray();
foreach (var item in items)
{
Console.WriteLine(item);
}
Console.ReadLine();
}
public void SDPC_DSCFullLoad()
{
using (Utils.ConfigurationCacheCleaner())
using (Utils.RestoreStaticValueOnDispose(typeof(SimpleDataServiceHelper), "PageSizeCustomizer"))
{
SimpleDataServiceHelper.PageSizeCustomizer = PageSizeCustomizerFast;
SimpleWorkspace workspace = this.NorthwindWorkspacePaged;
Uri baseUri = new Uri(workspace.ServiceEndPoint + workspace.ServiceContainer.Name + ".svc", UriKind.Absolute);
DataServiceContext ctx = new DataServiceContext(baseUri);
ctx.EnableAtom = true;
ctx.Format.UseAtom();
var q = ctx.CreateQuery <northwindBinding.Customers>("Customers").Expand("Orders");
int totalCustomerCount = q.Count();
int totalOrdersCount = ctx.CreateQuery <northwindBinding.Orders>("Orders").Count();
var custs = new DataServiceCollection <northwindBinding.Customers>(q, TrackingMode.None);
for (int i = 0; i < 2; i++)
{
if (i == 1)
{
// second iteration
ctx = new DataServiceContext(baseUri);
ctx.EnableAtom = true;
ctx.Format.UseAtom();
q = ctx.CreateQuery <northwindBinding.Customers>("Customers").Expand("Orders");
custs = new DataServiceCollection <northwindBinding.Customers>(q);
}
while (custs.Continuation != null)
{
custs.Load(ctx.Execute <northwindBinding.Customers>(custs.Continuation));
}
int linksCount = 0;
int ordersCount = 0;
foreach (var c in custs)
{
while (c.Orders.Continuation != null)
{
if (linksCount++ % 2 == 0)
{
ctx.LoadProperty(c, "Orders", c.Orders.Continuation);
}
else
{
c.Orders.Load(ctx.Execute <northwindBinding.Orders>(c.Orders.Continuation));
}
}
ordersCount += c.Orders.Count;
}
Assert.IsTrue(linksCount > 0, "links Count must be greater than 0");
Assert.AreEqual(totalCustomerCount, custs.Count);
Assert.AreEqual(totalOrdersCount, ordersCount);
}
}
}
protected override IQueryable <Session> BuildQuery(DataServiceContext context)
{
var query = from s in context.CreateQuery <Session>("Sessions").Expand("Speakers")
orderby s.StartHour, s.Track ascending
select s;
return(query);
}
/// <summary>
/// Creates a data service query for data of a specified generic type.
/// create a query based on (BaseUri + relativeUri)
/// </summary>
/// <typeparam name="TIinterface">The exposed interface type of elements returned by the query.</typeparam>
/// <typeparam name="TData">The type used by the query internaly.</typeparam>
/// <param name="entitySetName">A string that resolves to a URI.</param>
/// <returns>A new System.Data.Services.Client.DataServiceQuery<TElement> instance that represents a data service query.</returns>
public IQueryable <TIinterface> CreateQuery <TIinterface, TData>(string entitySetName)
{
_clientRequestIdAdapter.ChangeCurrentRequestId();
IQueryable <TIinterface> inner = (IQueryable <TIinterface>)_dataContext.CreateQuery <TData>(entitySetName);
var result = new MediaQueryable <TIinterface, TData>(inner, _queryRetryPolicy);
return(result);
}
public IQueryable <DataServicePackage> GetPackages()
{
if (_query == null)
{
_query = _context.CreateQuery <DataServicePackage>(Constants.PackageServiceEntitySetName);
}
return(_query);
}
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 FilterCollectionWithAnyAll()
{
DataServiceContext ctx = new DataServiceContext(new Uri("http://localhost"), ODataProtocolVersion.V4);
var values = ctx.CreateQuery<EntityWithCollections>("Values");
var testCases = new[]
{
new{
q = from e in values
where e.CollectionOfInt.Any()
select e,
url = "Values?$filter=CollectionOfInt/any()"
},
new{
q = from e in values
where e.CollectionOfInt.Any() && e.ID == 0
select e,
url = "Values?$filter=CollectionOfInt/any() and ID eq 0"
},
new{
q = from e in values
where e.CollectionOfInt.Any(mv => mv == 2 )
select e,
url = "Values?$filter=CollectionOfInt/any(mv:mv eq 2)"
},
new{
q = from e in values
where e.CollectionOfInt.Any(mv => mv > e.ID ) && e.ID <100
select e,
url = "Values?$filter=CollectionOfInt/any(mv:mv gt $it/ID) and ID lt 100"
},
new{
q = from e in values
where e.CollectionOfComplexType.Any(mv => e.CollectionOfString.All(s => s.StartsWith(mv.Name)) || e.ID <100) && e.ID > 50
select e,
url = "Values?$filter=CollectionOfComplexType/any(mv:$it/CollectionOfString/all(s:startswith(s,mv/Name)) or $it/ID lt 100) and ID gt 50"
},
new{
q = from e in values
where e.CollectionOfComplexType.All(mv => mv.Name.StartsWith("a") || e.ID <100) && e.ID > 50
select e,
url = "Values?$filter=CollectionOfComplexType/all(mv:startswith(mv/Name,'a') or $it/ID lt 100) and ID gt 50"
},
new{
q = from e in values
where e.CollectionOfComplexType.All(mv => mv.Name.Contains("a") || mv.Numbers.All(n=>n % 2 == 0)) && e.ID/5 == 3
select e,
url = "Values?$filter=CollectionOfComplexType/all(mv:contains(mv/Name,'a') or mv/Numbers/all(n:n mod 2 eq 0)) and ID div 5 eq 3"
},
};
TestUtil.RunCombinations(testCases, (testCase) =>
{
Assert.AreEqual(ctx.BaseUri.AbsoluteUri + testCase.url,testCase.q.ToString(), "url == q.ToString()");
});
}
public void NamedStreams_SimpleProjectionWithStreams()
{
// Doing projection of stream properties using AddQueryOption should work
DataServiceContext context = new DataServiceContext(request.ServiceRoot, ODataProtocolVersion.V4);
context.EnableAtom = true;
context.Format.UseAtom();
var query1 = context.CreateQuery<EntityWithNamedStreams1>("MySet1").AddQueryOption("$select", "ID, Stream1");
List<EntityWithNamedStreams1> entities = query1.Execute().ToList();
Assert.AreEqual(context.Entities[0].StreamDescriptors.Count, 1, "There must be named streams associated with the entity");
}
public void NamedStreams_SimpleProjectionWithoutStreams()
{
// Doing projection of non-stream properties should work and there should be no stream descriptors populated in the context
DataServiceContext context = new DataServiceContext(request.ServiceRoot, ODataProtocolVersion.V4);
context.EnableAtom = true;
context.Format.UseAtom();
var query1 = context.CreateQuery<EntityWithNamedStreams1>("MySet1").AddQueryOption("$select", "ID");
List<EntityWithNamedStreams1> entities = query1.Execute().ToList();
Assert.AreEqual(entities.Count, 1, "There must be only 1 entities populated in the context");
Assert.AreEqual(context.Entities[0].StreamDescriptors.Count, 0, "There must be no named streams associated with the entity yet, since we didn't specify the named streams in the projection query");
}
public void ObterTodosProdutos()
{
string url = "http://localhost.fiddler:19523/Services/CatalogoDataService.svc";
var context = new DataServiceContext(new Uri(url));
var todosProdutos = context.CreateQuery<Produto>("Produtoes").ToList();
foreach (var produto in todosProdutos)
{
Console.WriteLine(produto);
}
var produtosAcima100 = context.CreateQuery<Produto>("Produtoes").
Where(p => p.Preco > 100).ToList();
foreach (var produto in produtosAcima100)
{
Console.WriteLine(produto);
}
}
public void VerifyStreamInfoAfterQuery()
{
// Verifying media link information in query scnearios
// Populate the context with a single customer instance
string payload = AtomParserTests.AnyEntry(
id: Id,
properties: Properties,
links: GetNamedStreamEditLink(MediaEditLink, contentType: MediaContentType, etag: MediaETag) + GetNamedStreamSelfLink(MediaQueryLink, contentType: MediaContentType));
string nonbatchPayload = PlaybackService.ConvertToPlaybackServicePayload(null, payload);
string batchPayload = PlaybackService.ConvertToBatchQueryResponsePayload(nonbatchPayload);
TestUtil.RunCombinations((IEnumerable<QueryMode>)Enum.GetValues(typeof(QueryMode)), (queryMode) =>
{
using (PlaybackService.OverridingPlayback.Restore())
{
if (queryMode == QueryMode.BatchAsyncExecute ||
queryMode == QueryMode.BatchAsyncExecuteWithCallback ||
queryMode == QueryMode.BatchExecute)
{
PlaybackService.OverridingPlayback.Value = batchPayload;
}
else
{
PlaybackService.OverridingPlayback.Value = nonbatchPayload;
}
DataServiceContext context = new DataServiceContext(request.ServiceRoot, ODataProtocolVersion.V4);
context.EnableAtom = true;
DataServiceQuery<Customer> q = (DataServiceQuery<Customer>)context.CreateQuery<Customer>("Customers").Where(c1 => c1.ID == 1);
Customer c = ((IEnumerable<Customer>)DataServiceContextTestUtil.ExecuteQuery(context, q, queryMode)).Single();
Assert.AreEqual(context.Entities.Count, 1, "expecting just one entitydescriptor in the context");
Assert.AreEqual(context.Entities[0].StreamDescriptors.Count, 1, "expecting just one stream info in the entitydescriptor");
StreamDescriptor streamInfo = context.Entities[0].StreamDescriptors[0];
Assert.AreEqual(streamInfo.StreamLink.SelfLink, MediaQueryLink, "Self link should be as expected");
Assert.AreEqual(streamInfo.StreamLink.EditLink, MediaEditLink, "Edit link should be as expected");
Assert.AreEqual(streamInfo.StreamLink.ContentType, MediaContentType, "Content-Type did not match");
Assert.AreEqual(streamInfo.StreamLink.ETag, MediaETag, "ETag should match");
}
});
}
private void JobEntityRefresh(DataServiceContext dataContext)
{
InvalidateCollections();
var refreshed = dataContext.CreateQuery<JobData>(JobBaseCollection.JobSet).Where(c => c.Id == this.Id).FirstOrDefault();
//it is possible that job has been cancelled and deleted while we are refreshing
if (refreshed != null)
{
this.Created = refreshed.Created;
this.EndTime= refreshed.EndTime;
this.LastModified = refreshed.LastModified;
this.Name = refreshed.Name;
this.Priority = refreshed.Priority;
this.RunningDuration = refreshed.RunningDuration;
this.StartTime = refreshed.StartTime;
this.State = refreshed.State;
this.TemplateId = refreshed.TemplateId;
this.JobNotificationSubscriptions = refreshed.JobNotificationSubscriptions;
this.Tasks = refreshed.Tasks;
}
}
public async Task TestLongTypeAsPrimaryKey()
{
var client = new DataServiceContext(new Uri(this.BaseAddress));
client.Format.UseJson(GetEdmModel());
var query = client.CreateQuery<LongPrimaryKeyType>("LongPrimaryKeyType");
var models = await query.ExecuteAsync();
foreach (var model in models)
{
Uri selfLink;
Assert.True(client.TryGetUri(model, out selfLink));
Console.WriteLine(selfLink);
client.UpdateObject(model);
var response = await client.SaveChangesAsync();
Assert.Equal(200, response.Single().StatusCode);
}
}
private void VerifyServerOrderId(int orderId, int? expectedCustomerId, String message = null)
{
var _ctx = new DataServiceContext(web.ServiceRoot);
_ctx.EnableAtom = true;
_ctx.Format.UseAtom();
var order = _ctx.CreateQuery<EFFKClient.Order>("CustomObjectContext.Orders").Expand("Customers").Where(o => o.ID == orderId).FirstOrDefault();
if (message == null)
{
message = String.Format("Order {0} expecting Customer {1}", orderId, expectedCustomerId);
}
Assert.IsNotNull(order, message);
if (expectedCustomerId.HasValue)
{
Assert.AreEqual(expectedCustomerId, order.CustomerId, message);
Assert.AreEqual(expectedCustomerId, order.Customers.ID, message);
}
else
{
Assert.IsNull(order.Customers);
}
}
private MembershipRow GetUserFromTable(DataServiceContext svc, string username)
{
SecUtility.CheckParameter(ref username, true, true, true, Constants.MaxTableUsernameLength, "username");
DataServiceQuery<MembershipRow> queryObj = svc.CreateQuery<MembershipRow>(this.tableName);
var query = (from user in queryObj
where user.PartitionKey == SecUtility.CombineToKey(this.applicationName, username) &&
user.ProfileIsCreatedByProfileProvider == false
select user).AsTableServiceQuery();
IEnumerable<MembershipRow> allUsers = query.Execute();
if (allUsers == null)
{
return null;
}
IEnumerator<MembershipRow> e = allUsers.GetEnumerator();
if (e == null)
{
return null;
}
// e.Reset() throws a not implemented exception
// according to the spec, the enumerator is at the beginning of the collections after a call to GetEnumerator()
if (!e.MoveNext())
{
return null;
}
MembershipRow ret = e.Current;
if (e.MoveNext())
{
throw new ProviderException("Duplicate elements for primary keys application and user name.");
}
return ret;
}
private RoleRow GetUserInRole(DataServiceContext svc, string rolename, string username)
{
SecUtility.CheckParameter(ref username, true, true, true, Constants.MaxTableUsernameLength, "username");
SecUtility.CheckParameter(ref rolename, true, true, true, MaxTableRoleNameLength, "rolename");
try
{
DataServiceQuery<RoleRow> queryObj = svc.CreateQuery<RoleRow>(_tableName);
IEnumerable<RoleRow> query = from user in queryObj
where user.PartitionKey == SecUtility.CombineToKey(_applicationName, username) &&
user.RowKey == SecUtility.Escape(rolename)
select user;
TableStorageDataServiceQuery<RoleRow> q = new TableStorageDataServiceQuery<RoleRow>(query as DataServiceQuery<RoleRow>, _tableRetry);
try
{
IEnumerable<RoleRow> userRows = q.ExecuteAllWithRetries();
return userRows.First();
}
catch (DataServiceQueryException e)
{
HttpStatusCode s;
if (TableStorageHelpers.EvaluateException(e, out s) && s == HttpStatusCode.NotFound)
{
return null;
}
else
{
throw;
}
}
}
catch (InvalidOperationException e)
{
throw new ProviderException("Error while accessing the data store.", e);
}
}
private SessionRow GetSession(string id, DataServiceContext context)
{
Debug.Assert(context != null, "Http context is null");
Debug.Assert(id != null && id.Length <= ProvidersConfiguration.MaxStringPropertySizeInChars, "Id is null or longer than allowed");
try
{
DataServiceQuery<SessionRow> queryObj = context.CreateQuery<SessionRow>(this.tableName);
var query = (from session in queryObj
where session.PartitionKey == SecUtility.CombineToKey(this.applicationName, id)
select session).AsTableServiceQuery();
IEnumerable<SessionRow> sessions = query.Execute();
// enumerate the result and store it in a list
var sessionList = new List<SessionRow>(sessions);
if (sessionList != null && sessionList.Count() == 1)
{
return sessionList.First();
}
else if (sessionList != null && sessionList.Count() > 1)
{
throw new ProviderException("Multiple sessions with the same name!");
}
else
{
return null;
}
}
catch (Exception e)
{
throw new ProviderException("Error accessing storage.", e);
}
}
private static DataServiceQuery<DataServicePackage> CreateQuery()
{
var dataServiceContext = new DataServiceContext(new Uri(NuGetOfficialFeedUrl));
var query = dataServiceContext.CreateQuery<DataServicePackage>("Package");
return query;
}
public void NamedSteams_VerifyGetReadStreamVersion()
{
// Verify that GetReadStream for a named stream sends version 3 headers
// Populate the context with a single customer instance
string payload = AtomParserTests.AnyEntry(
id: Id,
editLink: request.ServiceRoot.AbsoluteUri + "/editLink/Customers(1)",
properties: Properties,
links: GetNamedStreamSelfLink(request.ServiceRoot + "/Customers(1)/SelfLink/Thumbnail", contentType: MediaContentType));
TestUtil.RunCombinations(UnitTestsUtil.BooleanValues, (syncRead) =>
{
using (PlaybackService.OverridingPlayback.Restore())
{
PlaybackService.OverridingPlayback.Value = PlaybackService.ConvertToPlaybackServicePayload(null, payload);
DataServiceContext context = new DataServiceContext(request.ServiceRoot, ODataProtocolVersion.V4);
context.EnableAtom = true;
DataServiceQuery<Customer> q = (DataServiceQuery<Customer>)context.CreateQuery<Customer>("Customers").Where(c1 => c1.ID == 1);
Customer c = ((IEnumerable<Customer>)DataServiceContextTestUtil.ExecuteQuery(context, q, QueryMode.AsyncExecute)).Single();
if (syncRead)
{
context.GetReadStream(c, "Thumbnail", new DataServiceRequestArgs() { ContentType = "img/jpeg" });
}
else
{
IAsyncResult result = context.BeginGetReadStream(c, "Thumbnail", new DataServiceRequestArgs() { ContentType = "image/jpeg" }, (r) =>
{
context.EndGetReadStream(r);
},
null);
if (!result.CompletedSynchronously)
{
Assert.IsTrue(result.AsyncWaitHandle.WaitOne(new TimeSpan(0, 0, AstoriaUnitTests.TestConstants.MaxTestTimeout), false), "BeginExecute timeout");
}
}
VerifyRequestWasVersion3(PlaybackService.LastPlayback);
}
});
}
public void GetReadStreamUri()
{
// passing invalid name should not throw an exception, instead should return null
// Populate the context with a single customer instance
string payload = AtomParserTests.AnyEntry(
id: Id,
properties: Properties);
using (PlaybackService.OverridingPlayback.Restore())
{
PlaybackService.OverridingPlayback.Value = PlaybackService.ConvertToPlaybackServicePayload(null, payload);
DataServiceContext context = new DataServiceContext(request.ServiceRoot, ODataProtocolVersion.V4);
context.EnableAtom = true;
DataServiceQuery<Customer> q = (DataServiceQuery<Customer>)context.CreateQuery<Customer>("Customers").Where(c1 => c1.ID == 1);
Customer c = ((IEnumerable<Customer>)DataServiceContextTestUtil.ExecuteQuery(context, q, QueryMode.AsyncExecute)).Single();
// ask the uri for a random named stream
Assert.IsNull(context.GetReadStreamUri(c, "random"), "DataServiceContext.GetReadStreamUri should not throw if the stream with the given name is not present");
}
}
public void EmptyOrMissingHRefAttributeValue()
{
// Missing href attribute or empty href attribute on named stream link elements
TestUtil.RunCombinations(
UnitTestsUtil.BooleanValues, // empty or null href attribute value
UnitTestsUtil.BooleanValues, // edit or self link
(editLink, emptyAttributeValue) =>
{
string url = emptyAttributeValue ? "" : null;
string link = editLink ? GetNamedStreamEditLink(url, MediaContentType) : GetNamedStreamSelfLinkWithNull(url, MediaContentType);
// Populate the context with a single customer instance
string payload = AtomParserTests.AnyEntry(
id: Id,
properties: Properties,
links: link);
using (PlaybackService.OverridingPlayback.Restore())
{
PlaybackService.OverridingPlayback.Value = PlaybackService.ConvertToPlaybackServicePayload(null, payload);
DataServiceContext context = new DataServiceContext(request.ServiceRoot, ODataProtocolVersion.V4);
context.EnableAtom = true;
DataServiceQuery<Customer> q = (DataServiceQuery<Customer>)context.CreateQuery<Customer>("Customers").Where(c1 => c1.ID == 1);
((IEnumerable<Customer>)DataServiceContextTestUtil.ExecuteQuery(context, q, QueryMode.AsyncExecute)).Single();
StreamDescriptor descriptor = context.Entities.First().StreamDescriptors.First();
Uri actual = editLink ? descriptor.StreamLink.EditLink : descriptor.StreamLink.SelfLink;
if (emptyAttributeValue)
{
Assert.IsNotNull(actual, "URI should not be null");
}
else
{
Assert.IsNull(actual, "URI should be null");
}
}
});
}
public void UpdateNamedStreamOnDeletedEntity()
{
// Calling SetSaveStream on deleted entity is not supported
// Populate the context with a single customer instance
string payload = AtomParserTests.AnyEntry(
id: Id,
properties: Properties,
links: GetNamedStreamSelfLink(request.ServiceRoot + "/Customers(1)/SelfLink/Thumbnail", contentType: MediaContentType));
using (PlaybackService.OverridingPlayback.Restore())
{
PlaybackService.OverridingPlayback.Value = PlaybackService.ConvertToPlaybackServicePayload(null, payload);
DataServiceContext context = new DataServiceContext(request.ServiceRoot, ODataProtocolVersion.V4);
context.EnableAtom = true;
DataServiceQuery<Customer> q = (DataServiceQuery<Customer>)context.CreateQuery<Customer>("Customers").Where(c1 => c1.ID == 1);
Customer c = ((IEnumerable<Customer>)DataServiceContextTestUtil.ExecuteQuery(context, q, QueryMode.AsyncExecute)).Single();
context.DeleteObject(c);
try
{
context.SetSaveStream(c, "Thumbnail", new MemoryStream(), true /*closeStream*/, "image/jpeg");
}
catch (DataServiceClientException ex)
{
Assert.AreEqual(ex.Message, DataServicesClientResourceUtil.GetString("Context_SetSaveStreamOnInvalidEntityState", EntityStates.Deleted), "Error Message not as expected");
}
}
}
public void VerifyEntityDescriptorMergeFunctionality()
{
// Make sure that based on the MergeOption, the right links are exposed in the entity descriptor
TestUtil.RunCombinations(
new EntityStates[] { EntityStates.Added, EntityStates.Deleted, EntityStates.Modified, EntityStates.Unchanged },
new MergeOption[] { MergeOption.AppendOnly, MergeOption.OverwriteChanges, MergeOption.PreserveChanges },
new int[] { -1, 0, 1 }, // -1 indicates less links, 0 means exact same number of links, 1 means some extra links
UnitTestsUtil.BooleanValues,
UnitTestsUtil.BooleanValues,
(entityState, mergeOption, extraLinks, useBatchMode, returnETag) =>
{
using (PlaybackService.OverridingPlayback.Restore())
{
DataServiceContext context = new DataServiceContext(request.ServiceRoot, ODataProtocolVersion.V4);
context.EnableAtom = true;
context.MergeOption = mergeOption;
// Populate the context with a single customer instance with 2 named streams
string originalServiceRoot = "http://randomservice/Foo.svc";
string newServiceRoot = "http://randomservice1/Foo1.svc";
string payload = AtomParserTests.AnyEntry(
id: Id,
editLink: request.ServiceRoot.AbsoluteUri + "/editLink/Customers(1)",
properties: Properties,
links: GetNamedStreamSelfLink(originalServiceRoot + "/Customers(1)/SelfLink/Thumbnail", contentType: MediaContentType) +
GetNamedStreamEditLink(originalServiceRoot + "/Customers(1)/EditLink/Thumbnail", contentType: MediaContentType, etag: MediaETag) +
GetNamedStreamSelfLink(originalServiceRoot + "/Customers(1)/SelfLink/Photo", contentType: MediaContentType, name: "Photo") +
GetNamedStreamEditLink(originalServiceRoot + "/Customers(1)/EditLink/Photo", contentType: MediaContentType, name: "Photo"));
PlaybackService.OverridingPlayback.Value = PlaybackService.ConvertToPlaybackServicePayload(null, payload);
Customer c = DataServiceContextTestUtil.CreateEntity<Customer>(context, "Customers", entityState);
PlaybackService.OverridingPlayback.Value = null;
string linksPayload = null;
string newETag = returnETag ? MediaETag + 1 : null;
if (extraLinks == -1)
{
linksPayload = GetNamedStreamSelfLink(newServiceRoot + "/Customers(1)/SelfLink/Thumbnail", contentType: MediaContentType) +
GetNamedStreamEditLink(newServiceRoot + "/Customers(1)/EditLink/Thumbnail", contentType: MediaContentType, etag: newETag);
}
else if (extraLinks == 0)
{
linksPayload = GetNamedStreamSelfLink(newServiceRoot + "/Customers(1)/SelfLink/Thumbnail", contentType: MediaContentType) +
GetNamedStreamEditLink(newServiceRoot + "/Customers(1)/EditLink/Thumbnail", contentType: MediaContentType, etag: newETag) +
GetNamedStreamSelfLink(newServiceRoot + "/Customers(1)/SelfLink/Photo", contentType: MediaContentType, name: "Photo") +
GetNamedStreamEditLink(newServiceRoot + "/Customers(1)/EditLink/Photo", contentType: MediaContentType, name: "Photo", etag: newETag);
}
else
{
linksPayload = GetNamedStreamSelfLink(newServiceRoot + "/Customers(1)/SelfLink/Thumbnail", contentType: MediaContentType) +
GetNamedStreamEditLink(newServiceRoot + "/Customers(1)/EditLink/Thumbnail", contentType: MediaContentType, etag: newETag) +
GetNamedStreamSelfLink(newServiceRoot + "/Customers(1)/SelfLink/Photo", contentType: MediaContentType, name: "Photo") +
GetNamedStreamEditLink(newServiceRoot + "/Customers(1)/EditLink/Photo", contentType: MediaContentType, etag: newETag, name: "Photo") +
GetNamedStreamSelfLink(newServiceRoot + "/Customers(1)/SelfLink/HighResolutionPhoto", contentType: MediaContentType, name: "HighResolutionPhoto") +
GetNamedStreamEditLink(newServiceRoot + "/Customers(1)/EditLink/HighResolutionPhoto", contentType: MediaContentType, name: "HighResolutionPhoto", etag: newETag);
}
payload = AtomParserTests.AnyEntry(
id: Id,
editLink: request.ServiceRoot.AbsoluteUri + "/editLink/Customers(1)",
properties: Properties,
links: linksPayload);
PlaybackService.OverridingPlayback.Value = PlaybackService.ConvertToPlaybackServicePayload(null, payload);
if (useBatchMode)
{
PlaybackService.OverridingPlayback.Value = PlaybackService.ConvertToBatchQueryResponsePayload(PlaybackService.OverridingPlayback.Value);
QueryOperationResponse<Customer> resp = (QueryOperationResponse<Customer>)context.ExecuteBatch(context.CreateQuery<Customer>("/Customers(123)")).Single();
c = resp.First();
}
else
{
c = context.CreateQuery<Customer>("/Customers(123)").Execute().First();
}
EntityDescriptor entityDescriptor = context.Entities.Where(ed => Object.ReferenceEquals(c, ed.Entity)).Single();
StreamDescriptor thumbnail = entityDescriptor.StreamDescriptors.Where(ns => ns.StreamLink.Name == "Thumbnail").SingleOrDefault();
StreamDescriptor photo = entityDescriptor.StreamDescriptors.Where(ns => ns.StreamLink.Name == "Photo").SingleOrDefault();
StreamDescriptor highResPhoto = entityDescriptor.StreamDescriptors.Where(ns => ns.StreamLink.Name == "HighResolutionPhoto").SingleOrDefault();
string newSelfLink = newServiceRoot + "/Customers(1)/SelfLink/{0}";
string newEditLink = newServiceRoot + "/Customers(1)/EditLink/{0}";
string existingSelfLink = originalServiceRoot + "/Customers(1)/SelfLink/{0}";
string existingEditLink = originalServiceRoot + "/Customers(1)/EditLink/{0}";
if (entityState == EntityStates.Added)
{
Assert.AreEqual(2, context.Entities.Count, "since its in added state, we will get a new entity descriptor");
Assert.AreEqual(2 + extraLinks, entityDescriptor.StreamDescriptors.Count, "number of named streams was not as expected");
VerifyNamedStreamInfo(thumbnail, newSelfLink, newEditLink, newETag, contentType: MediaContentType);
if (extraLinks == -1)
{
Assert.AreEqual(photo, null, "photo must be null when extra links = -1 and state = added");
Assert.AreEqual(highResPhoto, null, "highResPhoto must be null when extra links = -1 and state = added");
}
else if (extraLinks == 0)
{
VerifyNamedStreamInfo(photo, newSelfLink, newEditLink, newETag, contentType: MediaContentType);
Assert.AreEqual(highResPhoto, null, "highResPhoto must be null when extra links = 0 and state = added");
}
else if (extraLinks == 1)
{
VerifyNamedStreamInfo(photo, newSelfLink, newEditLink, newETag, contentType: MediaContentType);
VerifyNamedStreamInfo(highResPhoto, newSelfLink, newEditLink, newETag, contentType: MediaContentType);
}
}
else if (mergeOption == MergeOption.OverwriteChanges ||
(mergeOption == MergeOption.PreserveChanges && (entityState == EntityStates.Deleted || entityState == EntityStates.Unchanged)))
{
Assert.AreEqual(1, context.Entities.Count, "since its not in added state, we will only have one entity descriptor");
int numOfNamedStreams = 2;
if (extraLinks == 1)
{
numOfNamedStreams = 3;
}
Assert.AreEqual(numOfNamedStreams, entityDescriptor.StreamDescriptors.Count, "number of named streams was not as expected");
VerifyNamedStreamInfo(thumbnail, newSelfLink, newEditLink, newETag ?? MediaETag, MediaContentType);
if (extraLinks == -1)
{
VerifyNamedStreamInfo(photo, existingSelfLink, existingEditLink, null, MediaContentType);
Assert.AreEqual(highResPhoto, null, "highResPhoto must be null when extra links = -1 and state = added");
}
else if (extraLinks == 0)
{
VerifyNamedStreamInfo(photo, newSelfLink, newEditLink, newETag, MediaContentType);
Assert.AreEqual(highResPhoto, null, "highResPhoto must be null when extra links = 0 and state = added");
}
else if (extraLinks == 1)
{
VerifyNamedStreamInfo(photo, newSelfLink, newEditLink, newETag, MediaContentType);
VerifyNamedStreamInfo(highResPhoto, newSelfLink, newEditLink, newETag, MediaContentType);
}
}
else
{
// no change should be made
Assert.AreEqual(1, context.Entities.Count, "since its not in added state, we will only have one entity descriptor");
Assert.AreEqual(2, entityDescriptor.StreamDescriptors.Count, "number of named streams was not as expected");
VerifyNamedStreamInfo(thumbnail, existingSelfLink, existingEditLink, MediaETag, MediaContentType);
VerifyNamedStreamInfo(photo, existingSelfLink, existingEditLink, null, MediaContentType);
Assert.AreEqual(highResPhoto, null, "highResPhoto must be null in AppendOnly");
}
}
});
}
public void NamedStreams_ProjectionMissingStream()
{
// making sure some of the invalid linq queries fail
using (PlaybackService.OverridingPlayback.Restore())
{
DataServiceContext context = new DataServiceContext(request.ServiceRoot, ODataProtocolVersion.V4);
context.EnableAtom = true;
context.Format.UseAtom();
// Populate the context with a single customer instance with 2 named streams
string originalServiceRoot = "http://randomservice/Foo.svc";
string payload = AtomParserTests.AnyEntry(
id: NamedStreamTests.Id,
editLink: request.ServiceRoot.AbsoluteUri + "/editLink/Customers(1)",
properties: NamedStreamTests.Properties,
links: NamedStreamTests.GetNamedStreamEditLink(originalServiceRoot + "/Customers(1)/EditLink/Thumbnail"));
PlaybackService.OverridingPlayback.Value = PlaybackService.ConvertToPlaybackServicePayload(null, payload);
var q = context.CreateQuery<StreamType2>("Customers").Select(s => new StreamType2()
{
ID = s.ID,
Name = s.Name,
Thumbnail = s.Thumbnail,
Photo = s.Photo // selecting named stream, but not present in payload
});
Exception ex = TestUtil.RunCatching(() => { q.FirstOrDefault(); });
Assert.IsNotNull(ex);
Assert.AreEqual(DataServicesClientResourceUtil.GetString("AtomMaterializer_PropertyMissing", "Photo"), ex.Message);
}
}
private List<MembershipRow> GetUsersInactive(DataServiceContext context, string usernameToMatch, bool startswith, ProfileAuthenticationOption auth, DateTime userInactiveSinceDateUtc)
{
DataServiceQuery<MembershipRow> queryObj = context.CreateQuery<MembershipRow>(_tableName);
CloudTableQuery<MembershipRow> query = null;
// play a trick to deal with the restrictions of currently supported linq queries
bool first, second;
if (auth == ProfileAuthenticationOption.All)
{
first = true;
second = false;
}
else if (auth == ProfileAuthenticationOption.Anonymous)
{
first = true;
second = true;
}
else
{
first = false;
second = false;
}
if (startswith && usernameToMatch == string.Empty)
{
query = (from user in queryObj
where user.PartitionKey.CompareTo(SecUtility.EscapedFirst(_applicationName)) > 0 &&
user.PartitionKey.CompareTo(SecUtility.NextComparisonString(SecUtility.EscapedFirst(_applicationName))) < 0 &&
user.LastActivityDateUtc < userInactiveSinceDateUtc &&
user.ProfileBlobName != string.Empty &&
(user.IsAnonymous == first || user.IsAnonymous == second)
select user).AsTableServiceQuery();
}
else if (startswith)
{
query = (from user in queryObj
where user.PartitionKey.CompareTo(SecUtility.EscapedFirst(_applicationName)) > 0 &&
user.PartitionKey.CompareTo(SecUtility.NextComparisonString(SecUtility.EscapedFirst(_applicationName))) < 0 &&
user.LastActivityDateUtc < userInactiveSinceDateUtc &&
user.ProfileBlobName != string.Empty &&
user.UserName.CompareTo(usernameToMatch) >= 0 &&
(user.IsAnonymous == first || user.IsAnonymous == second)
select user).AsTableServiceQuery();
}
else
{
query = (from user in queryObj
where user.PartitionKey.CompareTo(SecUtility.CombineToKey(_applicationName, usernameToMatch)) == 0 &&
user.LastActivityDateUtc < userInactiveSinceDateUtc &&
user.ProfileBlobName != string.Empty &&
(user.IsAnonymous == first || user.IsAnonymous == second)
select user).AsTableServiceQuery();
}
/*
if (auth == ProfileAuthenticationOption.All) {
query = from user in queryObj
where user.PartitionKey.CompareTo(SecUtility.EscapedFirst(_applicationName)) > 0 &&
user.PartitionKey.CompareTo(SecUtility.NextComparisonString(SecUtility.EscapedFirst(_applicationName))) < 0 &&
user.LastActivityDateUtc < userInactiveSinceDateUtc &&
user.ProfileBlobName != string.Empty
select user;
}
else if (auth == ProfileAuthenticationOption.Anonymous)
{
query = from user in queryObj
where user.PartitionKey.CompareTo(SecUtility.EscapedFirst(_applicationName)) > 0 &&
user.PartitionKey.CompareTo(SecUtility.NextComparisonString(SecUtility.EscapedFirst(_applicationName))) < 0 &&
user.LastActivityDateUtc < userInactiveSinceDateUtc &&
user.ProfileBlobName != string.Empty &&
user.IsAnonymous == true
select user;
}
else
{
Debug.Assert(auth == ProfileAuthenticationOption.Authenticated);
query = from user in queryObj
where user.PartitionKey.CompareTo(SecUtility.EscapedFirst(_applicationName)) > 0 &&
user.PartitionKey.CompareTo(SecUtility.NextComparisonString(SecUtility.EscapedFirst(_applicationName))) < 0 &&
user.LastActivityDateUtc < userInactiveSinceDateUtc &&
user.ProfileBlobName != string.Empty &&
user.IsAnonymous == false
select user;
}
*/
IEnumerable<MembershipRow> users = query.Execute();
if (users == null)
{
return new List<MembershipRow>(); ;
}
return new List<MembershipRow>(users);
}
private static DataServiceQuery<DataServicePackage> CreateQuery()
{
var dataServiceContext = new DataServiceContext(new Uri("https://nuget.org/api/v2"));
var query = dataServiceContext.CreateQuery<DataServicePackage>("Package");
return query;
}
public void NamedStreams_BindingTest()
{
// Making sure changing the DataServiceStreamLink properties raises the binding events
using (PlaybackService.OverridingPlayback.Restore())
using (PlaybackService.InspectRequestPayload.Restore())
{
DataServiceContext context = new DataServiceContext(request.ServiceRoot, ODataProtocolVersion.V4);
context.EnableAtom = true;
context.MergeOption = MergeOption.OverwriteChanges;
// Populate the context with an entity
string payload = AtomParserTests.AnyEntry(
id: Id,
editLink: request.ServiceRoot.AbsoluteUri + "/editLink/Customers(1)",
properties: Properties,
links: GetNamedStreamSelfLink(request.ServiceRoot + "/Customers(1)/SelfLink/Thumbnail", contentType: MediaContentType) +
GetNamedStreamEditLink(request.ServiceRoot.AbsoluteUri + "/Customers(1)/EditLink/Thumbnail", contentType: MediaContentType, etag: MediaETag));
PlaybackService.OverridingPlayback.Value = PlaybackService.ConvertToPlaybackServicePayload(null, payload);
var collection = new DataServiceCollection<NamedStreamWithBinding>(context.CreateQuery<NamedStreamWithBinding>("Customers").Where(c1 => c1.ID == 1), TrackingMode.AutoChangeTracking);
Assert.AreEqual(1, context.Entities.Count, "context should have one entity as tracking");
NamedStreamWithBinding entity = collection[0];
// modifying the property directly: nothing should happen...
// need to use set save stream
entity.Thumbnail = entity.Thumbnail;
Assert.AreEqual(EntityStates.Unchanged, context.Entities[0].State, "the entity should be in unchanged state");
int propertyChangedCallCount = 0;
entity.PropertyChanged += (o, args) =>
{
propertyChangedCallCount++;
};
entity.Thumbnail.PropertyChanged += (o, args) =>
{
propertyChangedCallCount++;
};
payload = AtomParserTests.AnyEntry(
id: Id,
editLink: request.ServiceRoot.AbsoluteUri + "/editLink/Customers(1)",
properties: Properties,
links: GetNamedStreamSelfLink(request.ServiceRoot + "/Customers(10)/SelfLink/Thumbnail", contentType: MediaContentType) +
GetNamedStreamEditLink(request.ServiceRoot.AbsoluteUri + "/Customers(10)/EditLink/Thumbnail", contentType: MediaContentType, etag: MediaETag));
PlaybackService.OverridingPlayback.Value = PlaybackService.ConvertToPlaybackServicePayload(null, payload);
context.CreateQuery<NamedStreamWithBinding>("Customers").Where(c1 => c1.ID == 1).Single();
Assert.AreEqual(1, context.Entities.Count, "context should have one entity as tracking");
Assert.AreEqual(request.ServiceRoot + "/Customers(10)/SelfLink/Thumbnail", entity.Thumbnail.SelfLink.AbsoluteUri);
Assert.AreEqual(7, propertyChangedCallCount);
}
}
public void NamedStreams_DataServiceStreamLinkNotAllowedInFilterAndOrderBy()
{
// Making sure that DataServiceStreamLink is not allowed only in $filter and $orderby query options
// Populate the context with a single customer instance
string payload = AtomParserTests.AnyEntry(
id: Id,
properties: Properties,
links: GetNamedStreamEditLink(MediaEditLink, contentType: MediaContentType, etag: MediaETag) + GetNamedStreamSelfLink(MediaQueryLink, contentType: MediaContentType));
string nonbatchPayload = PlaybackService.ConvertToPlaybackServicePayload(null, payload);
string batchPayload = PlaybackService.ConvertToBatchQueryResponsePayload(nonbatchPayload);
DataServiceContext context = new DataServiceContext(request.ServiceRoot);
TestUtil.RunCombinations(
(IEnumerable<QueryMode>)Enum.GetValues(typeof(QueryMode)),
new DataServiceQuery<StreamType>[] {
(DataServiceQuery<StreamType>)context.CreateQuery<StreamType>("Customers").Where(c1 => c1.StreamLink.SelfLink.AbsoluteUri.Equals("Foo")),
(DataServiceQuery<StreamType>)context.CreateQuery<StreamType>("Customers").OrderBy(c1 => c1.StreamLink) },
(queryMode, query) =>
{
using (PlaybackService.OverridingPlayback.Restore())
{
if (queryMode == QueryMode.BatchAsyncExecute ||
queryMode == QueryMode.BatchAsyncExecuteWithCallback ||
queryMode == QueryMode.BatchExecute)
{
PlaybackService.OverridingPlayback.Value = batchPayload;
}
else
{
PlaybackService.OverridingPlayback.Value = nonbatchPayload;
}
try
{
StreamType c = ((IEnumerable<StreamType>)DataServiceContextTestUtil.ExecuteQuery(context, query, queryMode)).Single();
}
catch (NotSupportedException e)
{
Assert.AreEqual(e.Message, DataServicesClientResourceUtil.GetString("ALinq_LinkPropertyNotSupportedInExpression", "StreamLink"));
}
}
});
}
private SessionRow GetSession(string id, DataServiceContext context)
{
Debug.Assert(context != null);
Debug.Assert(id != null && id.Length <= TableStorageConstants.MaxStringPropertySizeInChars);
try
{
DataServiceQuery<SessionRow> queryObj = context.CreateQuery<SessionRow>(_tableName);
IEnumerable<SessionRow> query = from session in queryObj
where session.PartitionKey == SecUtility.CombineToKey(_applicationName, id)
select session;
TableStorageDataServiceQuery<SessionRow> q = new TableStorageDataServiceQuery<SessionRow>(query as DataServiceQuery<SessionRow>, _tableRetry);
IEnumerable<SessionRow> sessions = q.ExecuteWithRetries();
// enumerate the result and store it in a list
List<SessionRow> sessionList = new List<SessionRow>(sessions);
if (sessionList != null && sessionList.Count() == 1)
{
return sessionList.First();
} else if (sessionList != null && sessionList.Count() > 1) {
throw new ProviderException("Multiple sessions with the same name!");
}
else
{
return null;
}
}
catch (Exception e)
{
throw new ProviderException("Error accessing storage.", e);
}
}
public void ResponseHeadersAndStreamExceptionTest()
{
// Execute a query using a variety of methods (including sync, async, batch) and verify the response headers and payloads
using (PlaybackService.OverridingPlayback.Restore())
using (PlaybackService.ProcessRequestOverride.Restore())
using (TestWebRequest request = TestWebRequest.CreateForInProcessWcf())
{
request.ServiceType = typeof(PlaybackService);
request.StartService();
TestUtil.RunCombinations(((IEnumerable<QueryMode>)Enum.GetValues(typeof(QueryMode))), (queryMode) =>
{
bool isBatchQuery = queryMode == QueryMode.BatchAsyncExecute || queryMode == QueryMode.BatchAsyncExecuteWithCallback || queryMode == QueryMode.BatchExecute;
PlaybackService.ProcessRequestOverride.Value = (r) => { throw new InvalidOperationException("ResponseHeadersAndStreamExceptionTest -- Bad Request."); };
DataServiceContext context = new DataServiceContext(new Uri(request.BaseUri));
HttpTestHookConsumer testHookConsumer = new HttpTestHookConsumer(context, false);
DataServiceQuery<Customer> query = context.CreateQuery<Customer>("Customers");
Exception ex = null;
try
{
foreach (var o in DataServiceContextTestUtil.ExecuteQuery(context, query, queryMode))
{
}
}
catch (Exception e)
{
ex = e;
}
// Verify response headers
Assert.AreEqual(1, testHookConsumer.ResponseHeaders.Count, "Wrong number of response headers being tracked by the test hook.");
Dictionary<string, string> actualResponseHeaders = testHookConsumer.ResponseHeaders[0];
Assert.AreEqual("InternalServerError", actualResponseHeaders["__HttpStatusCode"]);
// Verify response stream
Assert.AreEqual(1, testHookConsumer.ResponseWrappingStreams.Count, "Unexpected number of response streams tracked by the test hook.");
string actualResponsePayload = testHookConsumer.ResponseWrappingStreams[0].GetLoggingStreamAsString();
if (queryMode == QueryMode.BatchExecute)
{
Assert.AreEqual("", actualResponsePayload, "In batch the client calls the hook to get the stream but never reads from it.");
}
else
{
TestUtil.AssertContains(actualResponsePayload, "System.InvalidOperationException: ResponseHeadersAndStreamExceptionTest -- Bad Request.");
}
// Sanity check on the count of request streams, but not verifying them here. That functionality is tested more fully in another test method.
int expectedRequestStreamsCount = isBatchQuery ? 1 : 0;
Assert.AreEqual(expectedRequestStreamsCount, testHookConsumer.RequestWrappingStreams.Count, "Unexpected number of request streams.");
});
}
}
private RoleRow GetUserInRole(DataServiceContext svc, string rolename, string username)
{
SecUtility.CheckParameter(ref username, true, true, true, Constants.MaxTableUsernameLength, "username");
SecUtility.CheckParameter(ref rolename, true, true, true, MaxTableRoleNameLength, "rolename");
try
{
DataServiceQuery<RoleRow> queryObj = svc.CreateQuery<RoleRow>(_tableName);
var query = (from user in queryObj
where user.PartitionKey == SecUtility.CombineToKey(_applicationName, username) &&
user.RowKey == SecUtility.Escape(rolename)
select user).AsTableServiceQuery();
try
{
IEnumerable<RoleRow> userRows = query.Execute();
return userRows.FirstOrDefault();
}
catch (InvalidOperationException e)
{
if (e.InnerException is DataServiceClientException && (e.InnerException as DataServiceClientException).StatusCode == (int) HttpStatusCode.NotFound)
{
return null;
}
throw;
}
}
catch (Exception e)
{
throw new ProviderException("Error while accessing the data store.", e);
}
}
public void ResponseHeadersAndStreamTest()
{
// Execute a query using a variety of methods (including sync, async, batch) and verify the response headers and payloads
using (PlaybackService.OverridingPlayback.Restore())
using (TestWebRequest request = TestWebRequest.CreateForInProcessWcf())
{
request.ServiceType = typeof(PlaybackService);
request.StartService();
string nonbatchPayload =
@"<?xml version=""1.0"" encoding=""utf-8"" standalone=""yes""?>
<entry xml:base=""http://sparradevvm1:34866/TheTest/"" xmlns:d=""http://docs.oasis-open.org/odata/ns/data"" xmlns:m=""http://docs.oasis-open.org/odata/ns/metadata"" m:etag=""W/"3d9e3978-e6a7-4742-a44e-ef5a43d18d5f""" xmlns=""http://www.w3.org/2005/Atom"">
<id>http://sparradevvm1:34866/TheTest/Customers(1)</id>
<title type=""text""></title>
<updated>2010-10-12T18:07:17Z</updated>
<author>
<name />
</author>
<link rel=""edit"" title=""Customer"" href=""Customers(1)"" />
<link rel=""http://docs.oasis-open.org/odata/ns/related/BestFriend"" type=""application/atom+xml;type=entry"" title=""BestFriend"" href=""Customers(1)/BestFriend"" />
<link rel=""http://docs.oasis-open.org/odata/ns/related/Orders"" type=""application/atom+xml;type=feed"" title=""Orders"" href=""Customers(1)/Orders"" />
<category term=""#AstoriaUnitTests.Stubs.CustomerWithBirthday"" scheme=""http://docs.oasis-open.org/odata/ns/scheme"" />
<content type=""application/xml"">
<m:properties>
<d:GuidValue m:type=""Edm.Guid"">3d9e3978-e6a7-4742-a44e-ef5a43d18d5f</d:GuidValue>
<d:ID m:type=""Edm.Int32"">1</d:ID>
<d:Name>Customer 1</d:Name>
<d:NameAsHtml><html><body>Customer 1</body></html></d:NameAsHtml>
<d:Birthday m:type=""Edm.DateTimeOffset"">1980-10-12T00:00:00-07:00</d:Birthday>
<d:Address m:type=""AstoriaUnitTests.Stubs.Address"">
<d:StreetAddress>Line1</d:StreetAddress>
<d:City>Redmond</d:City>
<d:State>WA</d:State>
<d:PostalCode>98052</d:PostalCode>
</d:Address>
</m:properties>
</content>
</entry>
";
string nonbatchHttpResponse = PlaybackService.ConvertToPlaybackServicePayload(null, nonbatchPayload);
string batchPayload;
string batchHttpResponse = PlaybackService.ConvertToBatchResponsePayload(new string[] { nonbatchHttpResponse }, true, out batchPayload);
Dictionary<string, string> nonbatchHeaders = new Dictionary<string, string>();
nonbatchHeaders.Add("Content-Type", "application/atom+xml");
nonbatchHeaders.Add("__HttpStatusCode", "OK");
nonbatchHeaders.Add("Content-Length", nonbatchPayload.Length.ToString());
nonbatchHeaders.Add("Server", "Microsoft-HTTPAPI/2.0");
nonbatchHeaders.Add("Date", null);
Dictionary<string, string> batchHeaders = new Dictionary<string, string>();
batchHeaders.Add("Content-Type", "multipart/mixed; boundary=batchresponse_e9b231d9-72ab-46ea-9613-c7e8f5ece46b");
batchHeaders.Add("__HttpStatusCode", "Accepted");
batchHeaders.Add("Content-Length", batchPayload.Length.ToString());
batchHeaders.Add("Server", "Microsoft-HTTPAPI/2.0");
batchHeaders.Add("Date", null);
TestUtil.RunCombinations(((IEnumerable<QueryMode>)Enum.GetValues(typeof(QueryMode))), (queryMode) =>
{
Dictionary<string, string> expectedResponseHeaders;
string expectedResponsePayload;
bool isBatchQuery = queryMode == QueryMode.BatchAsyncExecute || queryMode == QueryMode.BatchAsyncExecuteWithCallback || queryMode == QueryMode.BatchExecute;
if (isBatchQuery)
{
PlaybackService.OverridingPlayback.Value = batchHttpResponse;
expectedResponseHeaders = batchHeaders;
expectedResponsePayload = batchPayload;
}
else
{
PlaybackService.OverridingPlayback.Value = nonbatchHttpResponse;
expectedResponseHeaders = nonbatchHeaders;
expectedResponsePayload = nonbatchPayload;
}
DataServiceContext context = new DataServiceContext(new Uri(request.BaseUri));
context.EnableAtom = true;
HttpTestHookConsumer testHookConsumer = new HttpTestHookConsumer(context, false);
DataServiceQuery<Customer> query = context.CreateQuery<Customer>("Customers");
foreach (var o in DataServiceContextTestUtil.ExecuteQuery(context, query, queryMode))
{
}
// Verify response headers
Assert.AreEqual(1, testHookConsumer.ResponseHeaders.Count, "Wrong number of response headers being tracked by the test hook.");
Dictionary<string, string> actualResponseHeaders = testHookConsumer.ResponseHeaders[0];
VerifyHeaders(expectedResponseHeaders, actualResponseHeaders);
// Verify response stream
Assert.AreEqual(1, testHookConsumer.ResponseWrappingStreams.Count, "Unexpected number of response streams tracked by the test hook.");
string actualResponsePayload = testHookConsumer.ResponseWrappingStreams[0].GetLoggingStreamAsString();
Assert.AreEqual(expectedResponsePayload, actualResponsePayload, "Response payload was not the value that was expected");
// Sanity check on the count of request streams, but not verifying them here. That functionality is tested more fully in another test method.
int expectedRequestStreamsCount = isBatchQuery ? 1 : 0;
Assert.AreEqual(expectedRequestStreamsCount, testHookConsumer.RequestWrappingStreams.Count, "Unexpected number of request streams.");
});
}
}
public void NamedStreams_Projections_MergeInfoOptions()
{
// Make sure that based on the MergeOption, the value of the DataServiceStreamLink is updated
TestUtil.RunCombinations(
new EntityStates[] { EntityStates.Added, EntityStates.Deleted, EntityStates.Modified, EntityStates.Unchanged },
new MergeOption[] { MergeOption.AppendOnly, MergeOption.OverwriteChanges, MergeOption.PreserveChanges },
new int[] { -1, 0, 1 }, // -1 indicates less links, 0 means exact same number of links, 1 means some extra links
UnitTestsUtil.BooleanValues,
(entityState, mergeOption, extraLinks, useBatchMode) =>
{
using (PlaybackService.OverridingPlayback.Restore())
{
DataServiceContext context = new DataServiceContext(request.ServiceRoot, ODataProtocolVersion.V4);
context.EnableAtom = true;
context.Format.UseAtom();
context.MergeOption = mergeOption;
// Populate the context with a single customer instance with 2 named streams
string originalServiceRoot = "http://randomservice/Foo.svc";
string newServiceRoot = "http://randomservice1/Foo1.svc";
string payload = AtomParserTests.AnyEntry(
id: NamedStreamTests.Id,
editLink: request.ServiceRoot.AbsoluteUri + "/editLink/Customers(1)",
properties: NamedStreamTests.Properties,
links: NamedStreamTests.GetNamedStreamEditLink(originalServiceRoot + "/Customers(1)/EditLink/Thumbnail"));
PlaybackService.OverridingPlayback.Value = PlaybackService.ConvertToPlaybackServicePayload(null, payload);
DataServiceQuery<StreamType2> query = (DataServiceQuery<StreamType2>)context.CreateQuery<StreamType2>("Customers");
StreamType2 c = DataServiceContextTestUtil.CreateEntity<StreamType2>(context, "Customers", entityState, query);
PlaybackService.OverridingPlayback.Value = null;
string linksPayload = null;
if (extraLinks == -1)
{
// send no links
}
else if (extraLinks == 0)
{
linksPayload = NamedStreamTests.GetNamedStreamEditLink(newServiceRoot + "/Customers(1)/EditLink/Thumbnail");
}
else
{
linksPayload = NamedStreamTests.GetNamedStreamEditLink(newServiceRoot + "/Customers(1)/EditLink/Thumbnail") +
NamedStreamTests.GetNamedStreamEditLink(newServiceRoot + "/Customers(1)/EditLink/Photo", name: "Photo");
}
payload = AtomParserTests.AnyEntry(
id: NamedStreamTests.Id,
editLink: request.ServiceRoot.AbsoluteUri + "/editLink/Customers(1)",
properties: NamedStreamTests.Properties,
links: linksPayload);
PlaybackService.OverridingPlayback.Value = PlaybackService.ConvertToPlaybackServicePayload(null, payload);
if (useBatchMode)
{
PlaybackService.OverridingPlayback.Value = PlaybackService.ConvertToBatchQueryResponsePayload(PlaybackService.OverridingPlayback.Value);
QueryOperationResponse<StreamType2> resp = (QueryOperationResponse<StreamType2>)context.ExecuteBatch((DataServiceRequest)query).Single();
c = resp.First();
}
else
{
switch (extraLinks)
{
case -1:
c = query.Select(s => new StreamType2()
{
ID = s.ID,
Name = s.Name
}).Single();
break;
case 0:
c = query.Select(s => new StreamType2()
{
ID = s.ID,
Name = s.Name,
Thumbnail = s.Thumbnail
}).Single();
break;
default:
c = query.Select(s => new StreamType2()
{
ID = s.ID,
Name = s.Name,
Thumbnail = s.Thumbnail,
Photo = s.Photo
}).Single();
break;
}
}
EntityDescriptor entityDescriptor = context.Entities.Where(ed => Object.ReferenceEquals(c, ed.Entity)).Single();
StreamDescriptor thumbnail = entityDescriptor.StreamDescriptors.Where(ns => ns.StreamLink.Name == "Thumbnail").SingleOrDefault();
//Assert.IsTrue(thumbnail == null || object.ReferenceEquals(thumbnail.EntityDescriptor, entityDescriptor), "StreamDescriptor.EntityDescriptor should point to the same instance of entity descriptor");
StreamDescriptor photo = entityDescriptor.StreamDescriptors.Where(ns => ns.StreamLink.Name == "Photo").SingleOrDefault();
//Assert.IsTrue(photo == null || object.ReferenceEquals(photo.EntityDescriptor, entityDescriptor), "StreamDescriptor.EntityDescriptor should point to the same instance of entity descriptor for photo");
string newEditLink = newServiceRoot + "/Customers(1)/EditLink/{0}";
string existingEditLink = originalServiceRoot + "/Customers(1)/EditLink/{0}";
if (entityState == EntityStates.Added)
{
Assert.AreEqual(2, context.Entities.Count, "since its in added state, we will get a new entity descriptor");
Assert.AreEqual(1 + extraLinks, entityDescriptor.StreamDescriptors.Count, "number of named streams was not as expected");
if (extraLinks == -1)
{
Assert.AreEqual(thumbnail, null, "photo must be null when extra links = -1 and state = added");
}
else if (extraLinks == 0)
{
NamedStreamTests.VerifyNamedStreamInfo(thumbnail, null, newEditLink, null, null);
}
else if (extraLinks == 1)
{
NamedStreamTests.VerifyNamedStreamInfo(thumbnail, null, newEditLink, null, null);
NamedStreamTests.VerifyNamedStreamInfo(photo, null, newEditLink, null, null);
}
}
else if (mergeOption == MergeOption.OverwriteChanges ||
(mergeOption == MergeOption.PreserveChanges && (entityState == EntityStates.Deleted || entityState == EntityStates.Unchanged)))
{
Assert.AreEqual(1, context.Entities.Count, "since its not in added state, we will only have one entity descriptor");
int numOfNamedStreams = 1;
if (extraLinks == 1)
{
numOfNamedStreams = 2;
}
Assert.AreEqual(numOfNamedStreams, entityDescriptor.StreamDescriptors.Count, "number of named streams was not as expected");
if (extraLinks == -1)
{
NamedStreamTests.VerifyNamedStreamInfo(thumbnail, null, existingEditLink, null, null);
Assert.AreEqual(photo, null, "photo must be null when extra links = -1");
}
else if (extraLinks == 0)
{
NamedStreamTests.VerifyNamedStreamInfo(thumbnail, null, newEditLink, null, null);
Assert.AreEqual(photo, null, "photo must be null when extra links = 0");
}
else if (extraLinks == 1)
{
NamedStreamTests.VerifyNamedStreamInfo(thumbnail, null, newEditLink, null, null);
NamedStreamTests.VerifyNamedStreamInfo(photo, null, newEditLink, null, null);
}
}
else
{
// no change should be made
Assert.AreEqual(1, context.Entities.Count, "since its not in added state, we will only have one entity descriptor");
Assert.AreEqual(1, entityDescriptor.StreamDescriptors.Count, "number of named streams was not as expected");
NamedStreamTests.VerifyNamedStreamInfo(thumbnail, null, existingEditLink, null, null);
Assert.AreEqual(photo, null, "photo must be null when extra links = 0");
}
}
});
}
public async Task TestSpecialCharactersInPrimaryKey()
{
var client = new DataServiceContext(new Uri(this.BaseAddress));
client.Format.UseJson(GetEdmModel());
var query = client.CreateQuery<SpecialCharactersLinkGenerationTestsModel>("SpecialCharactersLinkGenerationWebTests");
var todoes = await query.ExecuteAsync();
bool success = true;
foreach (var todo in todoes)
{
try
{
Uri selfLink;
Assert.True(client.TryGetUri(todo, out selfLink));
Console.WriteLine(selfLink);
await client.ExecuteAsync<SpecialCharactersLinkGenerationTestsModel>(selfLink, "GET", true);
}
catch (Exception ex)
{
Console.WriteLine(ex);
success = false;
}
}
Assert.True(success);
}