public void GetETagTEntity_Returns_ETagInHeader()
        {
            // Arrange
            CustomersModelWithInheritance model = new CustomersModelWithInheritance();

            HttpRequestMessage request = new HttpRequestMessage();

            request.EnableHttpDependencyInjectionSupport(model.Model);

            Dictionary <string, object> properties = new Dictionary <string, object> {
                { "City", "Foo" }
            };
            EntityTagHeaderValue etagHeaderValue = new DefaultODataETagHandler().CreateETag(properties);

            ODataPath odataPath = new ODataPath(new EntitySetSegment(model.Customers));

            request.ODataProperties().Path = odataPath;

            // Act
            ETag <Customer> result        = request.GetETag <Customer>(etagHeaderValue);
            dynamic         dynamicResult = result;

            // Assert
            Assert.Equal("Foo", result["City"]);
            Assert.Equal("Foo", dynamicResult.City);
        }
        public void GetETag_Returns_ETagInHeader_ForInteger(byte byteValue, short shortValue, long longValue)
        {
            // Arrange
            Dictionary <string, object> properties = new Dictionary <string, object>
            {
                { "ByteVal", byteValue },
                { "LongVal", longValue },
                { "ShortVal", shortValue }
            };
            EntityTagHeaderValue etagHeaderValue = new DefaultODataETagHandler().CreateETag(properties);

            var builder = new ODataConventionModelBuilder();

            builder.EntitySet <MyEtagOrder>("Orders");
            IEdmModel          model     = builder.GetEdmModel();
            IEdmEntitySet      orders    = model.FindDeclaredEntitySet("Orders");
            ODataPath          odataPath = new ODataPath(new EntitySetSegment(orders));
            HttpRequestMessage request   = new HttpRequestMessage();

            request.EnableHttpDependencyInjectionSupport(model);
            request.ODataProperties().Path = odataPath;

            // Act
            ETag    result        = request.GetETag(etagHeaderValue);
            dynamic dynamicResult = result;

            // Assert
            byte actualByte = Assert.IsType <byte>(result["ByteVal"]);

            Assert.Equal(actualByte, dynamicResult.ByteVal);
            Assert.Equal(byteValue, actualByte);

            short actualShort = Assert.IsType <short>(result["ShortVal"]);

            Assert.Equal(actualShort, dynamicResult.ShortVal);
            Assert.Equal(shortValue, actualShort);

            long actualLong = Assert.IsType <long>(result["LongVal"]);

            Assert.Equal(actualLong, dynamicResult.LongVal);
            Assert.Equal(longValue, actualLong);
        }
        public void GetETag_Returns_ETagInHeader_ForDouble(double value, bool isEqual)
        {
            // Arrange
            Dictionary <string, object> properties = new Dictionary <string, object> {
                { "Version", value }
            };
            EntityTagHeaderValue etagHeaderValue = new DefaultODataETagHandler().CreateETag(properties);

            var builder = new ODataConventionModelBuilder();

            builder.EntitySet <MyEtagCustomer>("Customers");
            IEdmModel     model     = builder.GetEdmModel();
            IEdmEntitySet customers = model.FindDeclaredEntitySet("Customers");
            ODataPath     odataPath = new ODataPath(new EntitySetSegment(customers));

            HttpRequestMessage request = new HttpRequestMessage();

            request.EnableHttpDependencyInjectionSupport(model);
            request.ODataProperties().Path = odataPath;

            // Act
            ETag    result        = request.GetETag(etagHeaderValue);
            dynamic dynamicResult = result;

            // Assert
            double actual = Assert.IsType <double>(result["Version"]);

            Assert.Equal(actual, dynamicResult.Version);

            if (isEqual)
            {
                Assert.Equal(value, actual);
            }
            else
            {
                Assert.NotEqual(value, actual);

                Assert.True(actual - value < 0.0000001);
            }
        }