Example #1
0
        public void CURDEntityWithDateProperty()
        {
            this.TestClientContext.MergeOption = MergeOption.OverwriteChanges;

            // Post an entity
            Person person = new Person
            {
                FirstName = "Sheldon",
                LastName = "Cooper",
                UserName = "******",
                BirthDate = new Date(2000, 1, 1),
                BirthDate2 = new Date(2000, 1, 1)
            };

            this.TestClientContext.AddToPeople(person);
            this.TestClientContext.SaveChanges();
            int personId = person.PersonId;

            // Count this entity
            var count = this.TestClientContext.People.Count();
            Assert.Equal(personId, count);

            // Update an entity
            person.BirthDate = new Date(2012, 12, 20);
            person.BirthDate2 = person.BirthDate;
            this.TestClientContext.UpdateObject(person);
            this.TestClientContext.SaveChanges();

            // Query an entity
            this.TestClientContext.Detach(person);
            person = this.TestClientContext.People
                .ByKey(new Dictionary<string, object> { { "PersonId", personId } }).GetValue();
            Assert.Equal("Cooper", person.LastName);

            // Delete an entity
            this.TestClientContext.DeleteObject(person);
            this.TestClientContext.SaveChanges();

            // Filter this entity
            var persons = this.TestClientContext.People
                .AddQueryOption("$filter", "BirthDate eq 1986-02-09").ToList();
            Assert.Equal(1, persons.Count);
            persons = this.TestClientContext.People
                .AddQueryOption("$filter", "year(BirthDate) eq 1986").ToList();
            Assert.Equal(1, persons.Count);
            persons = this.TestClientContext.People
                .AddQueryOption("$filter", "BirthDate2 eq 1985-01-10").ToList();
            Assert.Equal(1, persons.Count);
            persons = this.TestClientContext.People
                .AddQueryOption("$filter", "year(BirthDate2) eq 1985").ToList();
            Assert.Equal(1, persons.Count);
        }
        public void CURDEntity()
        {
            this.TestClientContext.MergeOption = Microsoft.OData.Client.MergeOption.OverwriteChanges;
            // Post an entity
            Person person = new Person()
            {
                FirstName = "Sheldon",
                LastName = "Cooper",
                UserName = "******"
            };

            this.TestClientContext.AddToPeople(person);
            this.TestClientContext.SaveChanges();
            int personId = person.PersonId;

            // Count this entity
            var count = this.TestClientContext.People.Count();
            Assert.Equal(personId, count);

            // Update an entity
            person.LastName = "Lee";
            this.TestClientContext.UpdateObject(person);
            this.TestClientContext.SaveChanges();

            // Query an entity
            this.TestClientContext.Detach(person);
            person = this.TestClientContext.People
                .ByKey(new Dictionary<string, object>() { { "PersonId", personId } }).GetValue();
            Assert.Equal("Lee", person.LastName);

            // Delete an entity
            this.TestClientContext.DeleteObject(person);
            this.TestClientContext.SaveChanges();

            // Filter this entity
            var persons = this.TestClientContext.People
                .AddQueryOption("$filter", string.Format("PersonId eq {0}", personId)).ToList();
            Assert.Equal(0, persons.Count);
        }
Example #3
0
        public void UQDateProperty()
        {
            this.TestClientContext.MergeOption = MergeOption.OverwriteChanges;

            // Post an entity
            Person person = new Person
            {
                FirstName = "Sheldon",
                LastName = "Cooper",
                UserName = "******",
                BirthDate = new Date(2000, 1, 1),
                BirthDate2 = new Date(2000, 1, 1)
            };

            this.TestClientContext.AddToPeople(person);
            this.TestClientContext.SaveChanges();
            int personId = person.PersonId;

            // Query a property
            var birthDate = this.TestClientContext.People
                .Where(p => p.PersonId == personId).Select(p => p.BirthDate)
                .SingleOrDefault();
            var birthDate2 = this.TestClientContext.People
                .Where(p => p.PersonId == personId).Select(p => p.BirthDate2)
                .SingleOrDefault();
            Assert.Equal(new Date(2000, 1, 1), birthDate);
            Assert.Equal(birthDate, birthDate2);

            // Update a property
            this.TestPut(string.Format("People({0})/BirthDate", personId), @"{""value"":""2012-12-20""}");
            this.TestPut(string.Format("People({0})/BirthDate2", personId), @"{""value"":""2012-12-20""}");

            // Query a property's value : ~/$value
            this.TestGet(string.Format("People({0})/BirthDate/$value", personId), "2012-12-20");
            this.TestGet(string.Format("People({0})/BirthDate2/$value", personId), "2012-12-20");
        }
Example #4
0
        public void QueryOptionsOnDateTimeOffsetProperty()
        {
            this.TestClientContext.MergeOption = MergeOption.OverwriteChanges;
            var birthDateTime = new DateTimeOffset(2000, 1, 1, 12, 34, 56, TimeSpan.Zero);

            // Post an entity
            Person person = new Person
            {
                FirstName = "Sheldon",
                LastName = "Cooper",
                UserName = "******",
                BirthDateTime = birthDateTime,
                BirthDateTime2 = birthDateTime,
            };

            this.TestClientContext.AddToPeople(person);
            this.TestClientContext.SaveChanges();
            int personId = person.PersonId;

            // Filter this entity
            var persons = this.TestClientContext.People
                .AddQueryOption("$filter", "BirthDateTime eq 2000-01-01T12:34:56Z")
                .ToList();
            Assert.Equal(1, persons.Count);
            persons = this.TestClientContext.People
                .AddQueryOption("$filter", "BirthDateTime2 eq 2000-01-01T12:34:56Z")
                .ToList();
            Assert.Equal(1, persons.Count);

            // Filter with Parameter alias
            // ODL Bug: https://github.com/OData/odata.net/issues/316
            //this.TestClientContext.People
            //    .AddQueryOption("$filter", string.Format("BirthDateTime eq @p1 and PersonId gt {0}&@p1=2000-01-01T12:34:56Z", personId - 1))
            //    .ToList();
            //Assert.Equal(1, persons.Count);

            // Projection
            this.TestClientContext.Detach(person);
            person = this.TestClientContext.People.Where(p => p.PersonId == personId)
                .Select(p =>
                    new Person
                    {
                        PersonId = p.PersonId,
                        UserName = p.UserName,
                        BirthDateTime = p.BirthDateTime,
                        BirthDateTime2 = p.BirthDateTime2
                    }).FirstOrDefault();
            Assert.Equal(personId, person.PersonId);
            Assert.Equal(birthDateTime, person.BirthDateTime);
            Assert.Equal(birthDateTime, person.BirthDateTime2);
            Assert.NotNull(person.UserName);
            Assert.Null(person.FirstName);
            Assert.Null(person.LastName);

            // Order by BirthDateTime desc
            var people2 = this.TestClientContext.People.OrderByDescending(p => p.BirthDateTime).ToList();
            Assert.Equal(birthDateTime, people2.First().BirthDateTime);
            people2 = this.TestClientContext.People.OrderByDescending(p => p.BirthDateTime2).ToList();
            Assert.Equal(birthDateTime, people2.First().BirthDateTime2);

            // Order by BirthDateTime
            people2 = this.TestClientContext.People.OrderBy(p => p.BirthDateTime).ToList();
            Assert.Equal(birthDateTime, people2.Last().BirthDateTime);
            people2 = this.TestClientContext.People.OrderBy(p => p.BirthDateTime2).ToList();
            Assert.Equal(birthDateTime, people2.Last().BirthDateTime2);

            // top
            people2 = this.TestClientContext.People.OrderBy(p => p.BirthDateTime).Take(3).ToList();
            Assert.Equal(3, people2.Count);
            people2 = this.TestClientContext.People.OrderBy(p => p.BirthDateTime2).Take(3).ToList();
            Assert.Equal(3, people2.Count);

            // skip
            people2 = this.TestClientContext.People.Skip(personId - 1).ToList();
            Assert.Equal(birthDateTime, people2.First().BirthDateTime);
            Assert.Equal(birthDateTime, people2.First().BirthDateTime2);

            // TODO GitHubIssue#46 : case for $count=true
        }
Example #5
0
        public void CURDEntityWithTimeOfDayProperty()
        {
            this.TestClientContext.MergeOption = MergeOption.OverwriteChanges;

            // Post an entity
            Person person = new Person
            {
                FirstName = "Sheldon",
                LastName = "Cooper",
                UserName = "******",
                BirthTime = new TimeOfDay(12, 12, 12, 340),
                BirthTime2 = new TimeOfDay(12, 12, 12, 340)
            };

            this.TestClientContext.AddToPeople(person);
            this.TestClientContext.SaveChanges();
            int personId = person.PersonId;

            // Count this entity
            var count = this.TestClientContext.People.Count();
            Assert.Equal(personId, count);

            // Update an entity
            person.BirthTime = new TimeOfDay(12, 12, 12, 340);
            person.BirthTime2 = person.BirthTime;
            this.TestClientContext.UpdateObject(person);
            this.TestClientContext.SaveChanges();

            // Query an entity
            this.TestClientContext.Detach(person);
            person = this.TestClientContext.People
                .ByKey(new Dictionary<string, object> { { "PersonId", personId } }).GetValue();
            Assert.Equal("Cooper", person.LastName);

            // Delete an entity
            this.TestClientContext.DeleteObject(person);
            this.TestClientContext.SaveChanges();

            // Filter this entity
            var persons = this.TestClientContext.People
                .AddQueryOption("$filter", "BirthTime eq 22:58:02.0000000").ToList();
            Assert.Equal(1, persons.Count);
            persons = this.TestClientContext.People
                .AddQueryOption("$filter", "hour(BirthTime) eq 22").ToList();
            Assert.Equal(1, persons.Count);
            persons = this.TestClientContext.People
                .AddQueryOption("$filter", "BirthTime2 eq 23:59:01.0000000").ToList();
            Assert.Equal(1, persons.Count);
            persons = this.TestClientContext.People
                .AddQueryOption("$filter", "hour(BirthTime2) eq 23").ToList();
            Assert.Equal(1, persons.Count);
        }
Example #6
0
 public void PostReturnBadRequestStatusWithSeviceValidationMessage()
 {
     Person person = new Person() { FirstName = "Fn", LastName = "" };
     this.TestClientContext.AddToPeople(person);
     var ex = Assert.Throws<DataServiceRequestException>(() => this.TestClientContext.SaveChanges());
     var clientException = Assert.IsAssignableFrom<DataServiceClientException>(ex.InnerException);
     Assert.Equal(400, clientException.StatusCode);
     Assert.Contains(
         "The field LastName must be a string or array type with a minimum length of '1'",
         clientException.Message);
 }
Example #7
0
        public void CURDCollectionNavigationPropertyAndRef()
        {
            this.TestClientContext.MergeOption = MergeOption.OverwriteChanges;

            Person person = new Person()
            {
                FirstName = "Sheldon",
                LastName = "Cooper",
                UserName = "******"
            };

            this.TestClientContext.AddToPeople(person);
            this.TestClientContext.SaveChanges();
            int personId = person.PersonId;

            var startDate = DateTime.Now;
            Trip trip1 = new Trip()
            {
                PersonId = personId,
                TrackGuid = Guid.NewGuid(),
                ShareId = new Guid("c95d15e8-582b-44cf-9e97-ff63a5f26091"),
                Name = "Honeymoon",
                Budget = 2000.0f,
                Description = "Happy honeymoon trip",
                StartsAt = startDate,
                EndsAt = startDate.AddDays(3),
                LastUpdated = DateTime.UtcNow,
            };

            Trip trip2 = new Trip()
            {
                PersonId = personId,
                TrackGuid = Guid.NewGuid(),
                ShareId = new Guid("56947cf5-2133-43b8-81f0-b6c3f1e5e51a"),
                Name = "Honeymoon",
                Budget = 3000.0f,
                Description = "Happy honeymoon trip",
                StartsAt = startDate.AddDays(1),
                EndsAt = startDate.AddDays(5),
                LastUpdated = DateTime.UtcNow,
            };

            this.TestClientContext.AddToTrips(trip1);
            this.TestClientContext.SaveChanges();

            // Create a related entity by Navigation link
            this.TestClientContext.AddRelatedObject(person, "Trips", trip2);
            this.TestClientContext.SaveChanges();

            // Query Navigation properties.
            var trips = this.TestClientContext.People
                .ByKey(new Dictionary<string, object> { { "PersonId", personId } })
                .Trips.ToList();
            Assert.Equal(2, trips.Count());
            Assert.True(trips.Any(t => t.TripId == trip1.TripId));
            Assert.True(trips.Any(t => t.TripId == trip2.TripId));

            // Get $ref
            HttpWebRequestMessage request = new HttpWebRequestMessage(
                new DataServiceClientRequestMessageArgs(
                    "Get",
                    new Uri(string.Format(this.TestClientContext.BaseUri + "/People({0})/Trips/$ref", personId),
                        UriKind.Absolute),
                    false,
                    false,
                    new Dictionary<string, string>()));

            using (var response = request.GetResponse() as HttpWebResponseMessage)
            {
                Assert.Equal(200, response.StatusCode);
                using (var stream = response.GetStream())
                {
                    StreamReader reader = new StreamReader(stream);
                    var expectedPayload = "{"
                        + "\r\n"
                        + @"  ""@odata.context"":""http://*****:*****@"    {"
                        + "\r\n"
                        + string.Format(@"      ""@odata.id"":""http://*****:*****@"      ""@odata.id"":""http://localhost:18384/api/Trippin/Trips({0})""", trip2.TripId)
                        + "\r\n"
                        + "    }"
                        + "\r\n"
                        + "  ]"
                        + "\r\n"
                        + "}";
                    var content = reader.ReadToEnd();
                    Assert.Equal(expectedPayload, content);
                }
            }

            // Delete $ref
            this.TestClientContext.DeleteLink(person, "Trips", trip2);
            this.TestClientContext.SaveChanges();

            // Expand Navigation properties
            this.TestClientContext.Detach(trip1);
            person = this.TestClientContext.People
                .ByKey(new Dictionary<string, object> { { "PersonId", personId } })
                .Expand(t => t.Trips)
                .GetValue();
            Assert.Equal(1, person.Trips.Count);
            Assert.True(person.Trips.Any(t => t.TripId == trip1.TripId));

            Person person2 = new Person()
            {
                FirstName = "Sheldon2",
                LastName = "Cooper2",
                UserName = "******"
            };

            this.TestClientContext.AddToPeople(person2);
            this.TestClientContext.SaveChanges();
            personId = person2.PersonId;

            // Add $ref
            this.TestClientContext.AddLink(person2, "Trips", trip2);
            this.TestClientContext.SaveChanges();

            // Expand Navigation properties
            this.TestClientContext.Detach(trip1);
            this.TestClientContext.Detach(trip2);
            person = this.TestClientContext.People
                .ByKey(new Dictionary<string, object> { { "PersonId", personId } })
                .Expand(t => t.Trips)
                .GetValue();
            Assert.Equal(1, person.Trips.Count);
            Assert.True(person.Trips.Any(t => t.TripId == trip2.TripId));
        }
Example #8
0
        public void QueryOptions()
        {
            this.TestClientContext.MergeOption = Microsoft.OData.Client.MergeOption.OverwriteChanges;
            // Post an entity
            Person person = new Person()
            {
                FirstName = "Sheldon",
                LastName = "Cooper",
                UserName = "******"
            };

            this.TestClientContext.AddToPeople(person);
            this.TestClientContext.SaveChanges();
            int personId = person.PersonId;

            // Filter this entity
            var persons = this.TestClientContext.People
                .AddQueryOption("$filter", string.Format("PersonId eq {0}", personId))
                .ToList();
            Assert.Equal(1, persons.Count);

            // Filter with Parameter alias
            this.TestClientContext.People
                .AddQueryOption("$filter", string.Format("FirstName eq @p1 and PersonId gt {0}&@p1='Sheldon'", personId - 1))
                .ToList();
            Assert.Equal(1, persons.Count);

            // Projection
            this.TestClientContext.Detach(person);
            person = this.TestClientContext.People.Where(p => p.PersonId == personId)
                .Select(p =>
                    new Person()
                    {
                        PersonId = p.PersonId,
                        UserName = p.UserName
                    }).FirstOrDefault();
            Assert.Equal(personId, person.PersonId);
            Assert.NotNull(person.UserName);
            Assert.Null(person.FirstName);
            Assert.Null(person.LastName);

            // Order by PersonId desc
            var people2 = this.TestClientContext.People.OrderByDescending(p => p.PersonId).ToList();
            Assert.Equal(personId, people2.First().PersonId);

            // Order by PersonId
            people2 = this.TestClientContext.People.OrderBy(p => p.PersonId).ToList();
            Assert.Equal(personId, people2.Last().PersonId);

            // top
            people2 = this.TestClientContext.People.OrderBy(p => p.PersonId).Take(3).ToList();
            Assert.Equal(3, people2.Count);

            // skip
            people2 = this.TestClientContext.People.Skip(personId - 1).ToList();
            Assert.Equal(personId, people2.First().PersonId);

            // TODO GitHubIssue#46 : case for $count=true
        }
Example #9
0
        public void UQProperty()
        {
            this.TestClientContext.MergeOption = MergeOption.OverwriteChanges;
            // Post an entity
            Person person = new Person()
            {
                FirstName = "Sheldon",
                LastName = "Cooper",
                UserName = "******"
            };

            this.TestClientContext.AddToPeople(person);
            this.TestClientContext.SaveChanges();
            int personId = person.PersonId;

            // Query a property
            var lastName = this.TestClientContext.People
                .Where(p => p.PersonId == personId).Select(p => p.LastName)
                .SingleOrDefault();
            Assert.Equal("Cooper", lastName);

            // Update a property
            Dictionary<string, string> headers = new Dictionary<string, string>() 
            {
                { "Content-Type", "application/json" } 
            };

            HttpWebRequestMessage request = new HttpWebRequestMessage(
                new DataServiceClientRequestMessageArgs(
                    "Put",
                    new Uri(string.Format(this.TestClientContext.BaseUri + "/People({0})/LastName", personId),
                        UriKind.Absolute),
                    false,
                    false,
                    headers));
            using (var stream = request.GetStream())
            using (StreamWriter writer = new StreamWriter(stream))
            {
                var Payload = @"{""value"":""Lee""}";
                writer.Write(Payload);
            }

            using (var response = request.GetResponse() as HttpWebResponseMessage)
            {
                Assert.Equal(200, response.StatusCode);
            }

            // Query a property's value : ~/$value
            headers.Clear();
            ODataMessageReaderSettings readerSettings = new ODataMessageReaderSettings { BaseUri = this.TestClientContext.BaseUri };

            request = new HttpWebRequestMessage(
                new DataServiceClientRequestMessageArgs(
                    "Get",
                    new Uri(string.Format(this.TestClientContext.BaseUri + "/People({0})/LastName/$value", personId),
                        UriKind.Absolute),
                    false,
                    false,
                    headers));
            using (var response = request.GetResponse() as HttpWebResponseMessage)
            {
                Assert.Equal(200, response.StatusCode);
                using (var stream = response.GetStream())
                {
                    StreamReader reader = new StreamReader(stream);
                    var expectedPayload = "Lee";
                    var content = reader.ReadToEnd();
                    Assert.Equal(expectedPayload, content);
                }
            }
        }
Example #10
0
        public void QueryOptions()
        {
            this.TestClientContext.MergeOption = Microsoft.OData.Client.MergeOption.OverwriteChanges;
            // Post an entity
            Person person = new Person()
            {
                FirstName = "Sheldon",
                LastName = "Cooper",
                UserName = "******"
            };

            this.TestClientContext.AddToPeople(person);
            this.TestClientContext.SaveChanges();
            int personId = person.PersonId;

            // Filter this entity
            var persons = this.TestClientContext.People
                .AddQueryOption("$filter", string.Format("PersonId eq {0}", personId))
                .ToList();
            Assert.Equal(1, persons.Count);

            // Filter with Parameter alias
            this.TestClientContext.People
                .AddQueryOption("$filter", string.Format("FirstName eq @p1 and PersonId gt {0}&@p1='Sheldon'", personId - 1))
                .ToList();
            Assert.Equal(1, persons.Count);

            // Projection
            this.TestClientContext.Detach(person);
            person = this.TestClientContext.People.Where(p => p.PersonId == personId)
                .Select(p =>
                    new Person()
                    {
                        PersonId = p.PersonId,
                        UserName = p.UserName
                    }).FirstOrDefault();
            Assert.Equal(personId, person.PersonId);
            Assert.NotNull(person.UserName);
            Assert.Null(person.FirstName);
            Assert.Null(person.LastName);

            // Order by PersonId desc
            var people2 = this.TestClientContext.People.OrderByDescending(p => p.PersonId).ToList();
            Assert.Equal(personId, people2.First().PersonId);

            // Order by PersonId
            people2 = this.TestClientContext.People.OrderBy(p => p.PersonId).ToList();
            Assert.Equal(personId, people2.Last().PersonId);

            // top
            people2 = this.TestClientContext.People.OrderBy(p => p.PersonId).Take(3).ToList();
            Assert.Equal(3, people2.Count);

            // skip
            people2 = this.TestClientContext.People.Skip(personId - 1).ToList();
            Assert.Equal(personId, people2.First().PersonId);
            
            // count
            var countQuery = this.TestClientContext.People.IncludeTotalCount().Skip(1).Take(2) as DataServiceQuery<Person>;
            var response = countQuery.Execute() as QueryOperationResponse<Person>;
            Assert.Equal(response.TotalCount, 14);
            
            // count with expand
            countQuery = this.TestClientContext.People.IncludeTotalCount().Expand("Friends").Skip(1).Take(2) as DataServiceQuery<Person>;
            response = countQuery.Execute() as QueryOperationResponse<Person>;
            Assert.Equal(response.TotalCount, 14);
        }