Example #1
0
        public TodoSimpleOData(HttpClient client)
        {
            client.BaseAddress = new Uri("http://localhost:5000/odata/");
            var settings = new ODataClientSettings(client);

            _client = new Simple.OData.Client.ODataClient(settings);
        }
Example #2
0
        public async Task UpdateEntrySubcollectionWithResourceType()
        {
            var clientSettings = new ODataClientSettings
            {
                UrlBase = _serviceUri,
                IncludeResourceTypeInEntryProperties = true,
            };
            var client = new ODataClient(clientSettings);
            var ship   = await client.InsertEntryAsync("Transport/Ships", new Entry()
            {
                { "ShipName", "Test1" }
            }, true);

            var key = new Entry()
            {
                { "TransportID", ship["TransportID"] }
            };
            await client.UpdateEntryAsync("Transport/Ships", key, new Entry()
            {
                { "ShipName", "Test2" }, { FluentCommand.ResourceTypeLiteral, "Ships" }
            });

            ship = await client.GetEntryAsync("Transport", key);

            Assert.Equal("Test2", ship["ShipName"]);
        }
        public static ODataClientSettings WithHttpResponses(this ODataClientSettings settings, IEnumerable <string> responses)
        {
            var requestExecutor = new MockingRequestExecutor(settings, responses, false, false);

            settings.RequestExecutor = requestExecutor.ExecuteRequestAsync;
            return(settings);
        }
Example #4
0
        public async Task UpdateEntrySubcollectionWithAnnotations()
        {
            var clientSettings = new ODataClientSettings
            {
                BaseUri = _serviceUri,
                IncludeAnnotationsInResults = true,
            };
            var client = new ODataClient(clientSettings);
            var ship   = await client.InsertEntryAsync("Transport/Ships", new Entry()
            {
                { "ShipName", "Test1" }
            }, true);

            var key = new Entry()
            {
                { "TransportID", ship["TransportID"] }
            };
            await client.UpdateEntryAsync("Transport/Ships", key, new Entry()
            {
                { "ShipName", "Test2" }
            });

            ship = await client.GetEntryAsync("Transport", key);

            Assert.Equal("Test2", ship["ShipName"]);
        }
Example #5
0
        public async Task InsertUsingModifiedSchema()
        {
            await AssertThrowsAsync <Microsoft.Data.OData.ODataException>(async() =>
                                                                          await _client.InsertEntryAsync("Customers", new Entry()
            {
                { "CompanyName", null }
            }));

            var metadataDocument = await _client.GetMetadataDocumentAsync();

            metadataDocument = metadataDocument.Replace(@"Name=""CompanyName"" Type=""Edm.String"" Nullable=""false""", @"Name=""CompanyName"" Type=""Edm.String"" Nullable=""true""");
            ODataClient.ClearMetadataCache();
            var settings = new ODataClientSettings
            {
                BaseUri          = _serviceUri,
                MetadataDocument = metadataDocument,
            };
            var client = new ODataClient(settings);
            var model  = await client.GetMetadataAsync <IEdmModel>();

            var type     = model.FindDeclaredType("NorthwindModel.Customer");
            var property = (type as IEdmEntityType).DeclaredProperties.Single(x => x.Name == "CompanyName");

            Assert.True(property.Type.IsNullable);

            await AssertThrowsAsync <WebRequestException>(async() =>
                                                          await client.InsertEntryAsync("Customers", new Entry()
            {
                { "CompanyName", null }
            }));

            ODataClient.ClearMetadataCache();
        }
Example #6
0
        public async Task RegisterConverterGivenGenericMethodCalledAndPosted()
        {
            await TestingHost.Instance.GetNewWebHost().ConfigureAwait(true);

            var settings = new ODataClientSettings
            {
                BaseUri = TestingHost.Instance.BaseODataUrl,
                IgnoreUnmappedProperties = true,
            };

            settings.RegisterExtendableEnum <SampleStatus>();
            var client = new ODataClient(settings);

            var originalCount = DataContext.Books.Count;

            var novel = new SampleBook
            {
                Id     = Guid.NewGuid().ToString(),
                Title  = "The Never Ending Novel",
                Status = SampleStatus.Active,
            };

            await client
            .For <SampleBook>()
            .Set(novel)
            .InsertEntryAsync()
            .ConfigureAwait(true);

            Assert.AreEqual(originalCount + 1, DataContext.Books.Count);
        }
Example #7
0
        public async Task ParallelBootstrapping()
        {
            ODataClient.ClearMetadataCache();
            int metadataCallsCount = 0;
            var settings           = new ODataClientSettings
            {
                BaseUri       = _serviceUri,
                BeforeRequest = _ => metadataCallsCount++
            };
            var client = new ODataClient(settings);

            await Task.WhenAll(
                // Dispatch 10 calls in parallel
                client.GetMetadataAsStringAsync(),
                client.GetMetadataAsStringAsync(),
                client.GetMetadataAsStringAsync(),
                client.GetMetadataAsStringAsync(),
                client.GetMetadataAsStringAsync(),
                client.GetMetadataAsStringAsync(),
                client.GetMetadataAsStringAsync(),
                client.GetMetadataAsStringAsync(),
                client.GetMetadataAsStringAsync(),
                client.GetMetadataAsStringAsync()
                );

            Assert.Equal(1, metadataCallsCount);
        }
        private async void button1_Click(object sender, EventArgs e)
        {
            try
            {
                /*
                 *  We create an Odata Client Settings to define the URL
                 *  with which we establish the connection
                 */
                ODataClientSettings odcSettings = new ODataClientSettings();
                //Define the URL
                Uri uriOdata = new Uri(datosDeConexion.Url, UriKind.Absolute);
                odcSettings.BaseUri = uriOdata;

                /*
                 * We establish the connection and we bring the metadata to know if it is connected
                 */
                ODataClient client   = new ODataClient(odcSettings);
                IEdmModel   metadata = await client.GetMetadataAsync <IEdmModel>();

                var entityTypes = metadata.SchemaElements.OfType <IEdmEntityType>().ToArray();
                button2.Enabled = true;
            }catch
            {
                MessageBox.Show("Error creating the connection.");
            }
        }
        public static ContainerBuilder RegisterODataClient(this ContainerBuilder containerBuilder, Action <ODataClientSettings> odataClientSettingsCustomizer = null)
        {
            if (containerBuilder == null)
            {
                throw new ArgumentNullException(nameof(containerBuilder));
            }

            Simple.OData.Client.V4Adapter.Reference();

            containerBuilder.Register(c =>
            {
                IClientAppProfile clientAppProfile = c.Resolve <IClientAppProfile>();

                ODataClientSettings settings = new ODataClientSettings(httpClient: c.Resolve <HttpClient>(), new Uri(clientAppProfile.ODataRoute, uriKind: UriKind.RelativeOrAbsolute))
                {
                    RenewHttpConnection = false,
                    NameMatchResolver   = ODataNameMatchResolver.AlpahumericCaseInsensitive
                };

                odataClientSettingsCustomizer?.Invoke(settings);

                IODataClient odataClient = new ODataClient(settings);

                return(odataClient);
            }).PreserveExistingDefaults();

            containerBuilder
            .Register(c => new ODataBatch(c.Resolve <IODataClient>(), reuseSession: true))
            .PreserveExistingDefaults();

            return(containerBuilder);
        }
Example #10
0
        static async Task Main(string[] args)
        {
            NetworkCredential myCred = new NetworkCredential(
                "admin", "e4+1IDevw8mIVlwi89xNENUFnnVFAvvNsqJQ14hSASo=", "");

            CredentialCache myCache = new CredentialCache();

            myCache.Add(new Uri(@"https://api.businesscentral.dynamics.com"), "Basic", myCred);

            var odataSetting = new ODataClientSettings();

            odataSetting.Credentials = myCache;
            odataSetting.BaseUri     = new Uri(@"https://api.businesscentral.dynamics.com/v2.0/9fa7c13f-5edb-418a-858d-e4384253eb21/Sandbox/ODataV4/");
            odataSetting.IgnoreResourceNotFoundException = true;
            odataSetting.OnTrace = (x, y) => Console.WriteLine(string.Format(x, y));
            var client = new ODataClient(odataSetting);

            var packages = await client
                           .FindEntriesAsync("Company('CRONUS AU')/MasterItem");

            string connectionString = @"server=ARIES-T450;Database=Testing;Trusted_Connection=True;";

            Console.WriteLine("No - Description - BaseUnitofMeasure");
            foreach (var package in packages)
            {
                Console.WriteLine($"{package["No"]} - {package["Description"]} - {package["BaseUnitofMeasure"]}");
                Console.WriteLine("Inserting into database");

                var sqlInsert = $"insert into dbo.ItemIwpi (No, Description, BaseUnitofMeasure) values ('{package["No"]}', '{package["Description"]}', '{package["BaseUnitofMeasure"]}')";
                InsertData(connectionString, sqlInsert);
            }
        }
Example #11
0
        static async Task MainAsync(string[] args)
        {
            ODataClientSettings settings = new ODataClientSettings(url);

            settings.IgnoreResourceNotFoundException = true;
            settings.PreferredUpdateMethod           = ODataUpdateMethod.Put;
            // Get application base directory
            string basedir = AppDomain.CurrentDomain.BaseDirectory;

            log = new LoggerConfiguration()
                  .WriteTo.RollingFile(basedir + "/Logs/consoleAppLog-{Date}.txt")
                  .CreateLogger();

            settings.OnTrace = (x, y) =>
            {
                log.Information(string.Format(x, y));
                Console.WriteLine(string.Format(x, y));
            };

            var client = new ODataClient(settings);

            //Test client on Racuni collection
            await FetchRacuni(client);

            //Test client on Stavke collection
            await FetchStavke(client);
        }
Example #12
0
        private void CreateClient(string serverAddress, string userName, string password)
        {
            var credential = new NetworkCredential(userName, password);
            var settings   = new ODataClientSettings(new Uri(serverAddress), credential);

            _client = new ODataClient(settings);
        }
        public WorkOutSimpleData(HttpClient client)
        {
            client.BaseAddress = new Uri("http://localhost:52949/odata");
            var settings = new ODataClientSettings(client);

            _client = new ODataClient(settings);
        }
Example #14
0
        public HomeController()
        {
            credentials = new NetworkCredential("SES_DT_02", "everisCentros04");
            settings    = new ODataClientSettings(new Uri("http://213.130.35.45:8000/sap/opu/odata/sap/zpruebaodata_srv/TextosGeneralesSet"), credentials);

            client = new ODataClient(settings);
        }
Example #15
0
        public void CtorWithBaseUriTypeCache()
        {
            var settings  = new ODataClientSettings(new Uri("http://localhost"));
            var settings2 = new ODataClientSettings(new Uri("http://localhost"));

            Assert.Same(settings.TypeCache, settings2.TypeCache);
        }
Example #16
0
        public async Task IgnoredUnmappedColumn()
        {
            var settings = new ODataClientSettings
            {
                UrlBase = _serviceUri,
                IgnoreUnmappedProperties = true,
            };
            var client = new ODataClient(settings);

            var product = await client
                          .For <ProductWithUnmappedProperty>("Products")
                          .Set(new ProductWithUnmappedProperty {
                ProductName = "Test1"
            })
                          .InsertEntryAsync();

            await client
            .For <ProductWithUnmappedProperty>("Products")
            .Key(product.ProductID)
            .Set(new ProductWithUnmappedProperty {
                ProductName = "Test2"
            })
            .UpdateEntryAsync(false);

            product = await client
                      .For <ProductWithUnmappedProperty>("Products")
                      .Key(product.ProductID)
                      .FindEntryAsync();

            Assert.Equal("Test2", product.ProductName);
        }
 public async Task GetEntryNonExistingIgnoreException()
 {
     var settings = new ODataClientSettings
     {
         BaseUri = _serviceUri,
         IgnoreResourceNotFoundException = true,
     };
     var client = new ODataClient(settings);
Example #18
0
        public void CtorWithHttpClientAndBaseAddress()
        {
            var settings = new ODataClientSettings(new HttpClient {
                BaseAddress = new Uri("http://localhost")
            });

            Assert.Equal("http://localhost/", settings.BaseUri.AbsoluteUri);
        }
Example #19
0
        public void DefaultCtorAndBaseUri()
        {
            var settings = new ODataClientSettings {
                BaseUri = new Uri("http://localhost")
            };

            Assert.Equal("http://localhost/", settings.BaseUri.AbsoluteUri);
        }
Example #20
0
        public void CtorWithHttpClientAndBaseAddressAndRelativeUrl()
        {
            var settings = new ODataClientSettings(new HttpClient {
                BaseAddress = new Uri("http://localhost")
            }, new Uri("api", UriKind.Relative));

            Assert.Equal("http://localhost/api", settings.BaseUri.AbsoluteUri);
        }
 public MockingRequestExecutor(ODataClientSettings settings, string mockDataPathBase, bool validate, bool recording)
 {
     _settings         = settings;
     _mockDataPathBase = mockDataPathBase;
     _mockResponses    = null;
     _validate         = validate;
     _recording        = recording;
 }
 public MockingRequestExecutor(ODataClientSettings settings, IEnumerable <string> mockResponses, bool validate, bool recording)
 {
     _settings         = settings;
     _mockDataPathBase = null;
     _mockResponses    = mockResponses.ToArray();
     _validate         = validate;
     _recording        = recording;
 }
        public async Task ExecuteXCsrfFetchPriorToBatchExecution()
        {
            IDictionary <string, object> product1 = null;
            IDictionary <string, object> product2 = null;

            // None of the existing sample service endpoints actually provide an xcsrf token,
            // but in scenarios where a developer may need to use a csrf token, this is an
            // example of how to acquire one and send it in on subsequent batch requests.
            var token    = "";
            var settings = new ODataClientSettings(_serviceUri);

            settings.BeforeRequest += (request) =>
            {
                request.Headers.Add("x-csrf-token", "fetch");
            };
            settings.AfterResponse += (response) =>
            {
                // Assuming that because the service end points don't return tokens at this time
                // that we won't be setting the value of the token here.
                IEnumerable <string> values;
                token = response.Headers.TryGetValues("x-csrf-token", out values) ? values.First() : "myToken";
            };

            // Execute an arbitrary request to retrieve the csrf token
            var client = new ODataClient(settings);
            await client.GetMetadataDocumentAsync();

            // Since the token was never updated it should still be an empty string.
            Assert.NotNull(token);

            // Change the settings for the client so we can re-use the session and create a new request with different headers
            var newHeaders = new Dictionary <string, IEnumerable <string> >
            {
                { "x-csrf-token", new List <string> {
                      token
                  } }
            };

            client.UpdateRequestHeaders(newHeaders);

            var batch = new ODataBatch(client, reuseSession: true);

            batch += async x => product1 = await x.InsertEntryAsync("Products", CreateProduct(5015, "Test15"));

            batch += async x => product2 = await x.InsertEntryAsync("Products", CreateProduct(5016, "Test16"));

            batch += async x => await x.InsertEntryAsync("Categories", CreateCategory(5017, "Test17", new[] { product1, product2 }), false);

            await batch.ExecuteAsync();

            var category = await _client
                           .For("Categories")
                           .Key(5017)
                           .Expand("Products")
                           .FindEntryAsync();

            Assert.Equal(2, (category["Products"] as IEnumerable <object>).Count());
        }
Example #24
0
        internal static ODataClient CreateODataClient(ErpSession session, string transactionId = null)
        {
            var settings = new ODataClientSettings()
            {
                BaseUri = session.ServiceRoot,
                IncludeAnnotationsInResults = true,
                IgnoreUnmappedProperties    = true,
                BeforeRequest = (req) =>
                {
                    // Debug POST/PATCH requests
                    if (req.Content != null)
                    {
                        req.Content.ReadAsStringAsync().ContinueWith(t => Console.WriteLine(t.Result));
                    }
                    var options = session.RequestOptions.ToString();
                    if (!string.IsNullOrEmpty(options))
                    {
                        if (!string.IsNullOrEmpty(req.RequestUri.Query))
                        {
                            options = "&options=" + options;
                        }
                        else
                        {
                            options = "?options=" + options;
                        }
                        req.RequestUri = new Uri(req.RequestUri + options);
                    }
                    if (session.authorizationHeader != null)
                    {
                        req.Headers.Add("Authorization", session.authorizationHeader);
                    }
                    if (transactionId != null)
                    {
                        req.Headers.Add("TransactionId", transactionId);
                    }
                },
                AfterResponse = async(resp) =>
                {
                    if (session.Metadata == null && resp.RequestMessage.RequestUri.ToString().Contains("$metadata"))
                    {
                        session.Metadata = await resp.Content.ReadAsStringAsync();
                    }
                },
                OnTrace = (str, o) =>
                {
                    Console.WriteLine(str, o);
                },
                PayloadFormat = ODataPayloadFormat.Json
                                //IncludeAnnotationsInResults = true
            };

            if (session.Metadata != null)
            {
                settings.MetadataDocument = session.Metadata;
            }
            return(new ODataClient(settings));
        }
        /// <summary>
        /// Registers type converters with the ODataSettings to be used with an ODataClient for all ExtendableEnums in the <see cref="Assembly"/> that contais the given <see cref="Type"/>.
        /// </summary>
        /// <param name="settings">The <see cref="ODataClientSettings" /> with which to register the type converter.</param>
        /// <param name="assemblyMarkerType">The <see cref="Type"/> to use as a reference to find the containing <see cref="Assembly"/> that will be searched for ExtendableEnums to be registered.</param>
        public static void RegisterAllExtendableEnums(this ODataClientSettings settings, Type assemblyMarkerType)
        {
            if (assemblyMarkerType == null)
            {
                throw new ArgumentNullException(nameof(assemblyMarkerType));
            }

            RegisterAllExtendableEnums(settings, assemblyMarkerType.Assembly);
        }
 internal ODataClient(ODataClientSettings settings, ConcurrentDictionary <object, IDictionary <string, object> > batchEntries)
     : this(settings)
 {
     if (batchEntries != null)
     {
         BatchEntries = batchEntries;
         BatchWriter  = new Lazy <IBatchWriter>(() => Session.Adapter.GetBatchWriter(BatchEntries));
     }
 }
Example #27
0
        static async Task Main(string[] args)
        {
            var settings = new ODataClientSettings(new Uri($"https://localhost:{Constants.Port}/{Constants.Api}"));
            var client   = new ODataClient(settings);

            var result = await client
                         .For <Contact>()
                         .FindEntriesAsync();
        }
Example #28
0
        /// <summary>
        /// Creates and returns a new <see cref="ODataClient"/> which is configured to talk to <paramref name="testServer"/>.
        /// </summary>
        /// <param name="testServer"></param>
        /// <param name="odataBaseUrl"></param>
        /// <returns></returns>
        protected virtual ODataClient CreateODataClient(TestServer testServer, string odataBaseUrl = "/odata/")
        {
            var baseUrl = new Uri(new Uri("http://localhost/"), odataBaseUrl);
            ODataClientSettings oDataClientSettings = new ODataClientSettings(baseUrl)
            {
                OnCreateMessageHandler = () => testServer.Handler
            };

            return(new ODataClient(oDataClientSettings));
        }
 public void GetEntryNonExistingIgnoreException()
 {
     var settings = new ODataClientSettings
     {
         UrlBase = _serviceUri,
         IgnoreResourceNotFoundException = true,
     };
     var client = new ODataClient(settings);
     Assert.Null(client.GetEntry("Products", new Entry() { { "ProductID", -1 } }));
 }
        protected override void OnSetup()
        {
            base.OnSetup();

            var odataFeed = new ODataFeed(this.Settings);

            _clientSettings = odataFeed.ClientSettings;
            _schema         = Utils.ExecuteAndUnwrap(() =>
                                                     ODataClient.GetSchemaAsync(_clientSettings.UrlBase, _clientSettings.Credentials));
        }
        public async Task InterceptResponseAsync()
        {
            var settings = new ODataClientSettings
            {
                BaseUri            = _serviceUri,
                AfterResponseAsync = x => { throw new InvalidOperationException(); },
            };
            var client = new ODataClient(settings);

            await AssertThrowsAsync <InvalidOperationException>(async() => await client.FindEntriesAsync("Products"));
        }
 public async Task FilterWithMetadataDocument()
 {
     var metadataDocument = await _client.GetMetadataDocumentAsync();
     ODataClient.ClearMetadataCache();
     var settings = new ODataClientSettings()
     {
         BaseUri = _serviceUri,
         PayloadFormat = _payloadFormat,
         MetadataDocument = metadataDocument,
     };
     var client = new ODataClient(settings);
     var products = await client
         .For("Products")
         .Filter("Name eq 'Milk'")
         .FindEntriesAsync();
     Assert.Equal("Milk", products.Single()["Name"]);
 }
        public async Task InsertUsingModifiedSchema()
        {
            await AssertThrowsAsync<Microsoft.Data.OData.ODataException>(async () => 
                await _client.InsertEntryAsync("Customers", new Entry() { { "CompanyName", null } }));

            var metadataDocument = await _client.GetMetadataDocumentAsync();
            metadataDocument = metadataDocument.Replace(@"Name=""CompanyName"" Type=""Edm.String"" Nullable=""false""", @"Name=""CompanyName"" Type=""Edm.String"" Nullable=""true""");
            ODataClient.ClearMetadataCache();
            var settings = new ODataClientSettings
            {
                BaseUri = _serviceUri,
                MetadataDocument = metadataDocument,
            };
            var client = new ODataClient(settings);
            var model = await client.GetMetadataAsync<IEdmModel>();
            var type = model.FindDeclaredType("NorthwindModel.Customers");
            var property = (type as IEdmEntityType).DeclaredProperties.Single(x => x.Name == "CompanyName");
            Assert.Equal(true, property.Type.IsNullable);

            await AssertThrowsAsync<WebRequestException>(async () => 
                await client.InsertEntryAsync("Customers", new Entry() { { "CompanyName", null } }));

            ODataClient.ClearMetadataCache();
        }
 public async Task AllDerivedClassEntriesWithAnnotations()
 {
     var x = ODataDynamic.Expression;
     var clientSettings = new ODataClientSettings
     {
         BaseUri = _serviceUri,
         IncludeAnnotationsInResults = true,
     };
     var client = new ODataClient(clientSettings);
     var transport = await client
         .For(x.Transport)
         .As(x.Ships)
         .FindEntriesAsync();
     Assert.Equal("Titanic", (transport as IEnumerable<dynamic>).Single().ShipName);
     Assert.Equal("NorthwindModel.Ships", ((transport as IEnumerable<dynamic>).Single()[FluentCommand.AnnotationsLiteral] as ODataEntryAnnotations).TypeName);
 }
 public async Task BaseClassEntriesWithAnnotations()
 {
     var x = ODataDynamic.Expression;
     var clientSettings = new ODataClientSettings
     {
         BaseUri = _serviceUri,
         IncludeAnnotationsInResults = true,
     };
     var client = new ODataClient(clientSettings);
     IEnumerable<dynamic> transport = await client
         .For(x.Transport)
         .FindEntriesAsync();
     Assert.Equal(2, transport.Count());
     Assert.True(transport.All(y => y.AsDictionary().ContainsKey(FluentCommand.AnnotationsLiteral)));
 }
 public async Task AllDerivedClassEntriesWithResourceTypes()
 {
     var x = ODataDynamic.Expression;
     var clientSettings = new ODataClientSettings
     {
         BaseUri = _serviceUri,
         IncludeResourceTypeInEntryProperties = true,
     };
     var client = new ODataClient(clientSettings);
     var transport = await client
         .For(x.Transport)
         .As(x.Ships)
         .FindEntriesAsync();
     Assert.Equal("Titanic", (transport as IEnumerable<dynamic>).Single().ShipName);
     Assert.Equal("Ships", (transport as IEnumerable<dynamic>).Single()[FluentCommand.ResourceTypeLiteral]);
 }
 public async Task BaseClassEntriesWithAnnotations()
 {
     var clientSettings = new ODataClientSettings
                              {
                                  BaseUri = _serviceUri,
                                  IncludeAnnotationsInResults = true,
                              };
     var client = new ODataClient(clientSettings);
     var transport = await client
         .For("Transport")
         .FindEntriesAsync();
     Assert.Equal(2, transport.Count());
     Assert.True(transport.All(x => x.ContainsKey(FluentCommand.AnnotationsLiteral)));
 }
 public async Task BaseClassEntriesWithAnnotations()
 {
     var clientSettings = new ODataClientSettings
     {
         BaseUri = _serviceUri,
         IncludeAnnotationsInResults = true,
     };
     var client = new ODataClient(clientSettings);
     var transport = await client
         .For<Transport>()
         .FindEntriesAsync();
     Assert.Equal(2, transport.Count());
 }
        public async Task IgnoredUnmappedColumn()
        {
            var settings = new ODataClientSettings
            {
                BaseUri = _serviceUri,
                IgnoreUnmappedProperties = true,
            };
            var client = new ODataClient(settings);

            var product = await client
                .For<ProductWithUnmappedProperty>("Products")
                .Set(new ProductWithUnmappedProperty { ProductName = "Test1" })
                .InsertEntryAsync();

            await client
                .For<ProductWithUnmappedProperty>("Products")
                .Key(product.ProductID)
                .Set(new ProductWithUnmappedProperty { ProductName = "Test2" })
                .UpdateEntryAsync(false);

            product = await client
                .For<ProductWithUnmappedProperty>("Products")
                .Key(product.ProductID)
                .FindEntryAsync();
            Assert.Equal("Test2", product.ProductName);
        }
 protected WebApiTestsBase(ODataClientSettings settings)
 {
     _client = new ODataClient(settings);
 }
 public void AllDerivedClassEntriesWithResourceTypes()
 {
     var x = ODataDynamic.Expression;
     var clientSettings = new ODataClientSettings
     {
         UrlBase = _serviceUri,
         IncludeResourceTypeInEntryProperties = true,
     };
     var client = new ODataClient(clientSettings);
     IEnumerable<dynamic> transport = client
         .For(x.Transport)
         .As(x.Ships)
         .FindEntries();
     Assert.Equal("Titanic", transport.Single().ShipName);
     Assert.Equal("Ships", transport.Single()[ODataCommand.ResourceTypeLiteral]);
 }
 public void FindBaseClassEntriesWithResourceTypes()
 {
     var clientSettings = new ODataClientSettings
                              {
                                  UrlBase = _serviceUri,
                                  IncludeResourceTypeInEntryProperties = true,
                              };
     var client = new ODataClient(clientSettings);
     var transport = client
         .For("Transport")
         .FindEntries();
     Assert.Equal(2, transport.Count());
     Assert.True(transport.All(x => x.ContainsKey(ODataCommand.ResourceTypeLiteral)));
 }
 public async Task InterceptResponse()
 {
     var settings = new ODataClientSettings
     {
         BaseUri = _serviceUri,
         AfterResponse = x => { throw new InvalidOperationException(); },
     };
     var client = new ODataClient(settings);
     await AssertThrowsAsync<InvalidOperationException>(async () => await client.FindEntriesAsync("Products"));
 }
        public void UpdateEntrySubcollectionWithResourceType()
        {
            var clientSettings = new ODataClientSettings
            {
                UrlBase = _serviceUri,
                IncludeResourceTypeInEntryProperties = true,
            };
            var client = new ODataClient(clientSettings);
            var ship = client.InsertEntry("Transport/Ships", new Entry() { { "ShipName", "Test1" } }, true);
            var key = new Entry() { { "TransportID", ship["TransportID"] } };
            client.UpdateEntry("Transport/Ships", key, new Entry() { { "ShipName", "Test2" }, { ODataCommand.ResourceTypeLiteral, "Ships" } });

            ship = client.GetEntry("Transport", key);
            Assert.Equal("Test2", ship["ShipName"]);
        }
        public void DeleteEntrySubCollectionWithResourceType()
        {
            var clientSettings = new ODataClientSettings
            {
                UrlBase = _serviceUri,
                IncludeResourceTypeInEntryProperties = true,
            };
            var client = new ODataClient(clientSettings);
            var ship = client.InsertEntry("Transport/Ships", new Entry() { { "ShipName", "Test3" } }, true);
            ship = client.FindEntry("Transport?$filter=TransportID eq " + ship["TransportID"]);
            Assert.NotNull(ship);

            client.DeleteEntry("Transport", ship);

            ship = client.FindEntry("Transport?$filter=TransportID eq " + ship["TransportID"]);
            Assert.Null(ship);
        }
        public async Task GetEntryNonExistingIgnoreException()
        {
            var settings = new ODataClientSettings
            {
                BaseUri = _serviceUri,
                IgnoreResourceNotFoundException = true,
            };
            var client = new ODataClient(settings);
<<<<<<< HEAD:Simple.OData.Client.Tests.Net40/ClientTests.cs
            var product = await client.GetEntryAsync("Products", new Entry() {{"ProductID", -1}});

            Assert.Null(product);
        }
 public void BaseClassEntriesWithResourceTypes()
 {
     var x = ODataDynamic.Expression;
     var clientSettings = new ODataClientSettings
     {
         UrlBase = _serviceUri,
         IncludeResourceTypeInEntryProperties = true,
     };
     var client = new ODataClient(clientSettings);
     IEnumerable<dynamic> transport = client
         .For(x.Transport)
         .FindEntries();
     Assert.Equal(2, transport.Count());
     Assert.True(transport.All(y => y.AsDictionary().ContainsKey(ODataCommand.ResourceTypeLiteral)));
 }
 public async Task BaseClassEntriesWithResourceTypes()
 {
     var clientSettings = new ODataClientSettings
                              {
                                  BaseUri = _serviceUri,
                                  IncludeResourceTypeInEntryProperties = true,
                              };
     var client = new ODataClient(clientSettings);
     var transport = await client
         .For("Transport")
         .FindEntriesAsync();
     Assert.Equal(2, transport.Count());
     Assert.True(transport.All(x => x.ContainsKey(FluentCommand.ResourceTypeLiteral)));
 }
        public async Task DeleteEntrySubCollectionWithAnnotations()
        {
            var clientSettings = new ODataClientSettings
            {
                BaseUri = _serviceUri,
                IncludeAnnotationsInResults = true,
            };
            var client = new ODataClient(clientSettings);
            var ship = await client.InsertEntryAsync("Transport/Ships", new Entry() { { "ShipName", "Test3" } }, true);
            ship = await client.FindEntryAsync("Transport?$filter=TransportID eq " + ship["TransportID"]);
            Assert.NotNull(ship);

            await client.DeleteEntryAsync("Transport", ship);

            ship = await client.FindEntryAsync("Transport?$filter=TransportID eq " + ship["TransportID"]);
            Assert.Null(ship);
        }
 public async Task AllDerivedClassEntriesWithResourceTypes()
 {
     var clientSettings = new ODataClientSettings
     {
         BaseUri = _serviceUri,
         IncludeResourceTypeInEntryProperties = true,
     };
     var client = new ODataClient(clientSettings);
     var transport = await client
         .For("Transport")
         .As("Ships")
         .FindEntriesAsync();
     Assert.Equal("Titanic", transport.Single()["ShipName"]);
     Assert.Equal("Ships", transport.Single()[FluentCommand.ResourceTypeLiteral]);
 }
        public async Task UpdateEntrySubcollectionWithAnnotations()
        {
            var clientSettings = new ODataClientSettings
            {
                BaseUri = _serviceUri,
                IncludeAnnotationsInResults = true,
            };
            var client = new ODataClient(clientSettings);
            var ship = await client.InsertEntryAsync("Transport/Ships", new Entry() { { "ShipName", "Test1" } }, true);
            var key = new Entry() { { "TransportID", ship["TransportID"] } };
            await client.UpdateEntryAsync("Transport/Ships", key, new Entry() { { "ShipName", "Test2" }, { FluentCommand.ResourceTypeLiteral, "Ships" } });

            ship = await client.GetEntryAsync("Transport", key);
            Assert.Equal("Test2", ship["ShipName"]);
        }
 public SchemaRequestRunner(ODataClientSettings settings)
 {
 }
        public async Task SelectMultipleRename()
        {
            var settings = new ODataClientSettings
            {
                BaseUri = _serviceUri,
                IgnoreUnmappedProperties = true,
            };
            var client = new ODataClient(settings);

            var product = await client
                .For<ProductWithUnmappedProperty>("Products")
                .Filter(x => x.ProductName == "Chai")
                .Select(x => new { x.ProductID, UnmappedName = x.ProductName })
                .FindEntryAsync();
            Assert.Equal("Chai", product.UnmappedName);
            Assert.Null(product.ProductName);
        }
 public void InterceptResponse()
 {
     var settings = new ODataClientSettings
     {
         UrlBase = _serviceUri,
         AfterResponse = x => { throw new InvalidOperationException(); },
     };
     var client = new ODataClient(settings);
     Assert.Throws<InvalidOperationException>(() => client.FindEntries("Products"));
 }
 public async Task AllDerivedClassEntriesWithAnnotations()
 {
     var clientSettings = new ODataClientSettings
     {
         BaseUri = _serviceUri,
         IncludeAnnotationsInResults = true,
     };
     var client = new ODataClient(clientSettings);
     var transport = await client
         .For<Transport>()
         .As<Ship>()
         .FindEntriesAsync();
     Assert.Equal("Titanic", transport.Single().ShipName);
 }
 public async Task AllDerivedClassEntriesWithAnnotations()
 {
     var clientSettings = new ODataClientSettings
     {
         BaseUri = _serviceUri,
         IncludeAnnotationsInResults = true,
     };
     var client = new ODataClient(clientSettings);
     var transport = await client
         .For("Transport")
         .As("Ships")
         .FindEntriesAsync();
     Assert.Equal("Titanic", transport.Single()["ShipName"]);
     Assert.Equal("NorthwindModel.Ships", (transport.Single()[FluentCommand.AnnotationsLiteral] as ODataEntryAnnotations).TypeName);
 }
 public void InterceptRequest()
 {
     var settings = new ODataClientSettings
                        {
                            UrlBase = _serviceUri,
                            BeforeRequest = x => x.Method = "PUT",
                        };
     var client = new ODataClient(settings);
     Assert.Throws<WebRequestException>(() => client.FindEntries("Products"));
 }
 public void BaseClassEntriesWithResourceTypes()
 {
     var clientSettings = new ODataClientSettings
     {
         UrlBase = _serviceUri,
         IncludeResourceTypeInEntryProperties = true,
     };
     var client = new ODataClient(clientSettings);
     var transport = client
         .For<Transport>()
         .FindEntries();
     Assert.Equal(2, transport.Count());
 }
 public void AllDerivedClassEntriesWithResourceTypes()
 {
     var clientSettings = new ODataClientSettings
     {
         UrlBase = _serviceUri,
         IncludeResourceTypeInEntryProperties = true,
     };
     var client = new ODataClient(clientSettings);
     var transport = client
         .For<Transport>()
         .As<Ship>()
         .FindEntries();
     Assert.Equal("Titanic", transport.Single().ShipName);
 }
 public async Task InterceptRequest()
 {
     var settings = new ODataClientSettings
     {
         BaseUri = _serviceUri,
         BeforeRequest = x => x.Method = new HttpMethod("PUT"),
     };
     var client = new ODataClient(settings);
     await AssertThrowsAsync<WebRequestException>(async () => await client.FindEntriesAsync("Products"));
 }