public async Task TestSetApiVersionKinveyClientRequests() { // Arrange var notSupportingApiVersion = int.MaxValue.ToString(); var builder = new Client.Builder(AppKey, AppSecret); builder.SetFilePath(TestSetup.db_dir); if (MockData) { builder.setBaseURL("http://localhost:8080"); builder.setMICHostName("http://localhost:8081"); } var client1 = builder.Build(); builder.SetApiVersion(notSupportingApiVersion); var client2 = builder.Build(); builder.SetApiVersion(KinveyHeaders.kinveyApiVersion); var client3 = builder.Build(); if (MockData) { MockResponses(3); } // Act var pingResponse1 = await client1.PingAsync(); var exception = await Assert.ThrowsExceptionAsync <KinveyException>(async delegate { await client2.PingAsync(); }); var pingResponse3 = await client3.PingAsync(); // Assert Assert.AreEqual(typeof(KinveyException), exception.GetType()); var kinveyException = exception as KinveyException; Assert.IsTrue(kinveyException.ErrorCategory == EnumErrorCategory.ERROR_BACKEND); Assert.IsTrue(kinveyException.ErrorCode == EnumErrorCode.ERROR_JSON_RESPONSE); Assert.IsNotNull(pingResponse1.kinvey); Assert.IsTrue(pingResponse1.kinvey.StartsWith("hello", StringComparison.Ordinal)); Assert.IsNotNull(pingResponse1.version); Assert.IsNotNull(pingResponse3.kinvey); Assert.IsTrue(pingResponse3.kinvey.StartsWith("hello", StringComparison.Ordinal)); Assert.IsNotNull(pingResponse3.version); Assert.AreEqual(KinveyHeaders.kinveyApiVersion, client1.ApiVersion); Assert.AreEqual(notSupportingApiVersion, client2.ApiVersion); Assert.AreEqual(KinveyHeaders.kinveyApiVersion, client3.ApiVersion); }
public void TestClientBuilderWithInvalidRequirements() { // Arrange var builder = new Client.Builder(TestSetup.app_key, TestSetup.app_secret); DynamicBuilder.CreateAssemblyWithType(); // Act var exception = Assert.ThrowsException <KinveyException>(delegate { builder.Build(); }); // Assert Assert.AreEqual(typeof(KinveyException), exception.GetType()); var ke = exception as KinveyException; Assert.AreEqual(EnumErrorCategory.ERROR_REQUIREMENT, ke.ErrorCategory); Assert.AreEqual(EnumErrorCode.ERROR_REQUIREMENT_MISSING_GET_SET_ACCESSORS, ke.ErrorCode); Assert.AreEqual("There is the incorrect field TestField in the type TestType", ke.Info); //Teardown /* The type `TestType` was created dynamically and added to the primary domain above. * This type must be unloaded from the domain to avoid exceptions in other tests as they use the `Client.Builder` class too. * There is not any explicit possibility to do it in .Net Core like it was in .Net Framework. * For example, unloading an assembly from a domain or a whole domain. * There is only some implicit possibility.This is the using of GC. In this case the assembly with the `TestType` type will be unloaded from the domain by means of GC like it is no longer accessible. * After this, all subsequent tests will run correctly. */ GC.Collect(); GC.WaitForPendingFinalizers(); }
protected KinveyService() { var builder = new Client.Builder(appKey, appSecret) .setLogger(Console.WriteLine); kinveyClient = builder.Build(); }
public async Task TestCustomEndpoint() { if (MockData) { // Arrange Client.Builder builder = ClientBuilder.setFilePath(TestSetup.db_dir); builder.setBaseURL("http://localhost:8080"); builder.Build(); MockResponses(2); await User.LoginAsync(TestSetup.user, TestSetup.pass); // Act JObject obj = new JObject { { "input", 1 } }; CustomEndpoint <JObject, ToDo[]> ce = Client.SharedClient.CustomEndpoint <JObject, ToDo[]>(); var result = await ce.ExecuteCustomEndpoint("test", obj); string outputstr = result[1].DueDate; int output = int.Parse(outputstr); // Assert Assert.AreEqual(3, output); Assert.AreEqual(2, result.Length); } }
public MainPage() { InitializeComponent(); Client.Builder Builder = new Client.Builder(this.appKey, this.appSecret).setLogger(Console.WriteLine); this.KinveyClient = Builder.Build(); this.KinveyPing(); }
public void BuildClient() { Client.Builder cb = new Client.Builder(appKey, appSecret) .setFilePath(NSFileManager.DefaultManager.GetUrls(NSSearchPathDirectory.DocumentDirectory, NSSearchPathDomain.User)[0].ToString()) .setOfflinePlatform(new SQLitePlatformIOS()) .setLogger(delegate(string msg) { Console.WriteLine(msg); }); cb.Build(); // create a new window instance based on the screen size Window = new UIWindow(UIScreen.MainScreen.Bounds); if (Client.SharedClient.IsUserLoggedIn()) { var alreadyLoggedInController = new PatientViewController(); var navController = new UINavigationController(alreadyLoggedInController); Window.RootViewController = navController; } else { vc = new LoginViewController(); var navController = new UINavigationController(vc); Window.RootViewController = navController; } // make the window visible Window.MakeKeyAndVisible(); }
public void InitKinvey() { string appKey = "kid_SJ0SNjQCl"; // LiveService-DirectedCommunication string appSecret = "00f2e44bd8e14b4e9762cd0fb3ccbfdc"; // LiveService-DirectedCommunication Client.Builder cb = new Client.Builder(appKey, appSecret) .setFilePath(NSFileManager.DefaultManager.GetUrls(NSSearchPathDirectory.DocumentDirectory, NSSearchPathDomain.User)[0].ToString()) .setOfflinePlatform(new SQLitePlatformIOS()) .setLogger(delegate(string msg) { Console.WriteLine(msg); }); cb.Build(); // create a new window instance based on the screen size Window = new UIWindow(UIScreen.MainScreen.Bounds); if (Client.SharedClient.IsUserLoggedIn()) { Client.SharedClient.ActiveUser.Logout(); } var loginController = new LoginViewController(); var navController = new UINavigationController(loginController); Window.RootViewController = navController; // make the window visible Window.MakeKeyAndVisible(); }
public async Task TestMICRenderURLScopeID() { // Arrange var builder = new Client.Builder(TestSetup.app_key, TestSetup.app_secret); var client = builder.Build(); var autoEvent = new System.Threading.AutoResetEvent(false); string urlToTestForScopeID = String.Empty; var micDelegate = new KinveyMICDelegate <User>() { onError = (user) => { }, onSuccess = (error) => { }, onReadyToRender = (url) => { urlToTestForScopeID = url; autoEvent.Set(); } }; // Act User.LoginWithMIC("mytestredirectURI", micDelegate); bool signal = autoEvent.WaitOne(5000); // Assert Assert.IsTrue(signal); Assert.IsFalse(urlToTestForScopeID.Equals(string.Empty)); Assert.IsTrue(urlToTestForScopeID.Contains("scope=openid")); }
public async Task TestClientPingAsyncBad() { // Arrange Client.Builder builder = ClientBuilderFake; if (MockData) { builder.setBaseURL("http://localhost:8080"); } Client client = builder.Build(); if (MockData) { MockResponses(1, client); } // Act Exception e = await Assert.ThrowsExceptionAsync <KinveyException>(async delegate { PingResponse pr = await client.PingAsync(); }); // Assert Assert.IsTrue(e.GetType() == typeof(KinveyException)); KinveyException ke = e as KinveyException; Assert.IsTrue(ke.ErrorCategory == EnumErrorCategory.ERROR_BACKEND); Assert.IsTrue(ke.ErrorCode == EnumErrorCode.ERROR_JSON_RESPONSE); }
public async Task TestClientPingAsync() { // Arrange Client.Builder builder = ClientBuilder; if (MockData) { builder.setBaseURL("http://localhost:8080"); } Client client = builder.Build(); if (MockData) { MockResponses(1, client); } // Act PingResponse pr = await client.PingAsync(); // Assert Assert.IsNotNull(pr.kinvey); Assert.IsFalse(pr.kinvey == string.Empty); Assert.IsTrue(pr.kinvey.StartsWith("hello")); Assert.IsNotNull(pr.version); Assert.IsFalse(pr.version == string.Empty); }
public MainPage() { InitializeComponent(); Client.Builder Builder = new Client.Builder(this.appKey, this.appSecret); this.KinveyClient = Builder.Build(); this.KinveyPing(); this.ProceedKinveyLiveServices(); }
public Form1() { InitializeComponent(); // Set-up the Kinvey backend connection. mBuilder = new Client.Builder(appKey, appSecret).SetInstanceID(instanceID).setLogger(Console.WriteLine); mKinveyClient = mBuilder.Build(); KinveyPing(); }
private async Task <Client> BuildClient() { Client.Builder cb = new Client.Builder(app_key, app_secret) //.setFilePath (NSFileManager.DefaultManager.GetUrls (NSSearchPathDirectory.DocumentDirectory, NSSearchPathDomain.User) [0].ToString ()) .setFilePath(DependencyService.Get <ISQLite>().GetPath()) .setOfflinePlatform(DependencyService.Get <ISQLite>().GetConnection()); //.setLogger (delegate (string msg) { Console.WriteLine (msg); }) return(cb.Build()); }
public override void Setup() { base.Setup(); Client.Builder builder = ClientBuilder; if (MockData) { builder.setBaseURL("http://localhost:8080"); } kinveyClient = builder.Build(); }
public void TestDotnetClientBuilder() { // Arrange var builder = new Client.Builder(TestSetup.app_key, TestSetup.app_secret); // Act var client = builder.Build(); // Assert Assert.IsTrue(Constants.DevicePlatform.NET == client.DevicePlatform); }
public async Task TestMICLoginAutomatedAuthFlowBad() { // Arrange var moqRestClient = new Mock <HttpClientHandler>(); var moqResponse = new HttpResponseMessage(); JObject moqResponseContent = new JObject { { "error", "MOCK RESPONSE ERROR" }, { "description", "Mock Gaetway Timeout error" }, { "debug", "Mock debug" } }; moqResponse.Content = new StringContent(JsonConvert.SerializeObject(moqResponseContent)); moqResponse.StatusCode = System.Net.HttpStatusCode.GatewayTimeout; // Status Code - 504 moqRestClient .Protected() .Setup <Task <HttpResponseMessage> >( "SendAsync", ItExpr.IsAny <HttpRequestMessage>(), ItExpr.IsAny <CancellationToken>() ) .ReturnsAsync(moqResponse) .Verifiable(); Client.Builder cb = new Client.Builder(TestSetup.app_key, TestSetup.app_secret) .setFilePath(TestSetup.db_dir) .SetRestClient(new HttpClient(moqRestClient.Object)); Client c = cb.Build(); c.MICApiVersion = "v2"; string username = "******"; string password = "******"; string redirectURI = "kinveyAuthDemo://"; // Act // Assert Exception er = await Assert.ThrowsExceptionAsync <KinveyException>(async delegate() { await User.LoginWithAuthorizationCodeAPIAsync(username, password, redirectURI, c); }); Assert.IsNotNull(er); KinveyException ke = er as KinveyException; Assert.AreEqual(EnumErrorCategory.ERROR_BACKEND, ke.ErrorCategory); Assert.AreEqual(EnumErrorCode.ERROR_JSON_RESPONSE, ke.ErrorCode); Assert.AreEqual(504, ke.StatusCode); // HttpStatusCode.GatewayTimeout }
public void ClientCheckDefaultMICAPIVersion() { // Arrange Client.Builder builder = new Client.Builder(TestSetup.app_key, TestSetup.app_secret); // Act Client testClient = builder.Build(); // Assert Assert.IsFalse(string.IsNullOrEmpty(testClient.MICApiVersion)); Assert.IsTrue(string.Equals(testClient.MICApiVersion, Constants.STR_MIC_DEFAULT_VERSION)); }
public async Task TestClientBuilderSetOrgID() { // Arrange const string TEST_ORG = "testOrg"; Client.Builder builder = new Client.Builder(TestSetup.app_key, TestSetup.app_secret); // Act builder.SetSSOGroupKey(TEST_ORG); Client c = builder.Build(); // Assert Assert.IsTrue(c.SSOGroupKey.Equals(TEST_ORG)); }
public void TestClientBuilderDoNotSetOrgID() { // Arrange const string TEST_ORG = "testOrg"; Client.Builder builder = new Client.Builder(TestSetup.app_key, TestSetup.app_secret); // Act Client c = builder.Build(); // Assert Assert.IsFalse(c.SSOGroupKey.Equals(TEST_ORG)); Assert.IsTrue(c.SSOGroupKey.Equals(TestSetup.app_key)); }
public async Task TestUserInitFromCredential() { // Setup Client.Builder builder1 = ClientBuilder .setFilePath(TestSetup.db_dir); if (MockData) { builder1.setBaseURL("http://localhost:8080"); } Client kinveyClient1 = builder1.Build(); if (MockData) { MockResponses(1); } // Arrange User activeUser = await User.LoginAsync(TestSetup.user, TestSetup.pass, kinveyClient1); // Act Client.Builder builder2 = ClientBuilder .setFilePath(TestSetup.db_dir); if (MockData) { builder2.setBaseURL("http://localhost:8080"); } Client kinveyClient2 = builder2.Build(); // Assert Assert.IsTrue(activeUser?.AccessToken == kinveyClient2?.ActiveUser?.AccessToken); Assert.AreEqual(activeUser?.Attributes.Count, kinveyClient2?.ActiveUser?.Attributes.Count); if (MockData) { Assert.AreEqual(2, kinveyClient2?.ActiveUser?.Attributes.Count); Assert.AreEqual(activeUser?.Attributes["email"], kinveyClient2?.ActiveUser?.Attributes["email"]); } Assert.AreEqual(activeUser?.Attributes["_acl"]["creator"], kinveyClient2?.ActiveUser?.Attributes["_acl"]["creator"]); Assert.IsTrue(activeUser?.AuthToken == kinveyClient2?.ActiveUser?.AuthToken); Assert.IsTrue(activeUser?.Id == kinveyClient2?.ActiveUser?.Id); Assert.AreEqual(0, kinveyClient2?.ActiveUser?.Metadata.Count); Assert.AreEqual(activeUser?.Metadata.Count, kinveyClient2?.ActiveUser?.Metadata.Count); Assert.IsTrue(activeUser?.UserName == kinveyClient2?.ActiveUser?.UserName); }
public void TestClientBuilderBasic() { // Arrange const string url = "https://baas.kinvey.com/"; Client.Builder builder = new Client.Builder(TestSetup.app_key, TestSetup.app_secret); // Act Client client = builder.Build(); // Assert Assert.IsFalse(client == null); Assert.IsFalse(string.IsNullOrEmpty(client.BaseUrl)); Assert.IsTrue(string.Equals(client.BaseUrl, url)); }
public override void Setup() { base.Setup(); Client.Builder builder = ClientBuilder .SetFilePath(TestSetup.db_dir); if (MockData) { builder.setBaseURL("http://localhost:8080"); } kinveyClient = builder.Build(); testPush = new TestPush(kinveyClient); token = Guid.NewGuid().ToString(); }
public void TestClientBuilderSetValues() { // Arrange Client.Builder builder = new Client.Builder(TestSetup.app_key, TestSetup.app_secret); // Act builder.setFilePath("") .setLogger(delegate(string msg) { Console.WriteLine(msg); }); // Assert Client client = builder.Build(); Assert.IsFalse(client == null); Assert.IsFalse(string.IsNullOrEmpty(client.BaseUrl)); Assert.IsFalse(client.Store == null); Assert.IsFalse(client.logger == null); Assert.IsFalse(string.IsNullOrEmpty(client.MICHostName)); }
public MainPage() { InitializeComponent(); try { Client.Builder cb = new Client.Builder(this.app_key, this.app_secret).SetFilePath(DependencyService.Get <ISQLite>().GetPath()); cb.Build(); } catch (KinveyException knvExc) { // Handle any Kinvey exception. Console.WriteLine("Kinvey Exception: " + knvExc.Message); } catch (Exception exc) { // Handle any General exception. Console.WriteLine("General Exception: " + exc.Message); } // Listen for connectivity changes. CrossConnectivity.Current.ConnectivityChanged += (sender, args) => { // Make sure to log messages. Console.WriteLine("Connectivity Changed. IsConnected: " + CrossConnectivity.Current.IsConnected); }; // Listen for connectivity type changes. CrossConnectivity.Current.ConnectivityTypeChanged += (sender, args) => { // Make sure to log messages. Console.WriteLine("Connectivity Type Changed. Types: " + args.ConnectionTypes.FirstOrDefault()); // If there's internet connection, reconnect to Kinvey Live Services. if (CrossConnectivity.Current.IsConnected) { this.ProceedKinveyLiveServices(); } }; // Kick-off the process. this.ProceedKinveyLiveServices(); }
public void ClientBuilderSetInstanceID() { // Arrange const string instanceID = "testInstanceID"; Client.Builder builder = new Client.Builder(TestSetup.app_key, TestSetup.app_secret); // Act builder.SetInstanceID(instanceID); var client = builder.Build(); // Assert Assert.IsFalse(string.IsNullOrEmpty(builder.BaseUrl)); Assert.IsFalse(string.Equals(builder.BaseUrl, AbstractClient.DefaultBaseUrl)); Assert.IsTrue(string.Equals(builder.BaseUrl, "https://testInstanceID-baas.kinvey.com/")); Assert.IsFalse(string.Equals(client.MICHostName, "https://auth.kinvey.com/")); Assert.IsTrue(string.Equals(client.MICHostName, "https://testInstanceID-auth.kinvey.com/")); }
public async Task TestCustomEndpointBad() { // Arrange Client.Builder builder = ClientBuilder .SetFilePath(TestSetup.db_dir); if (MockData) { builder.setBaseURL("http://localhost:8080"); } builder.Build(); if (MockData) { MockResponses(2); } await User.LoginAsync(TestSetup.user, TestSetup.pass); // Act JObject obj = new JObject { { "input", 1 } }; CustomEndpoint <JObject, ToDo[]> ce = Client.SharedClient.CustomEndpoint <JObject, ToDo[]>(); Exception e = await Assert.ThrowsExceptionAsync <KinveyException>(async delegate { await ce.ExecuteCustomEndpoint("test_bad", obj); }); // Teardown Client.SharedClient.ActiveUser.Logout(); // Assert Assert.IsNotNull(e); Assert.IsTrue(e.GetType() == typeof(KinveyException)); KinveyException ke = e as KinveyException; Assert.AreEqual(404, ke.StatusCode); }
public async Task TestLoginAsyncBad() { // Arrange Client.Builder builder = ClientBuilderFake; if (MockData) { builder.setBaseURL("http://localhost:8080"); MockResponses(3); } Client fakeClient = builder.Build(); // Act // Assert await Assert.ThrowsExceptionAsync <KinveyException>(async delegate() { await User.LoginAsync(fakeClient); }); await Assert.ThrowsExceptionAsync <KinveyException>(async delegate() { await User.LoginAsync(TestSetup.user, TestSetup.pass, fakeClient); }); }
public async Task TestMICValidateAuthServiceID() { // Arrange Client.Builder builder = new Client.Builder(TestSetup.app_key, TestSetup.app_secret); Client client = builder.Build(); string appKey = ((KinveyClientRequestInitializer)client.RequestInitializer).AppKey; string micID = "12345"; string expectedClientId = TestSetup.app_key + "." + micID; // Act // Test AuthServiceID after setting a clientId var requestWithClientID = User.GetMICToken(client, "fake_code", appKey + Constants.CHAR_PERIOD + micID); string clientId = ((KinveyClientRequestInitializer)client.RequestInitializer).AuthServiceID; // Test to verify that initializing a request other than `/oauth/token` will // reset the AuthServiceID back to the default, which is AppKey. var req = User.BuildMICTempURLRequest(client, null); string shouldBeDefaultClientId = ((KinveyClientRequestInitializer)client.RequestInitializer).AuthServiceID; // Assert Assert.IsTrue(clientId == expectedClientId); Assert.IsTrue(shouldBeDefaultClientId == appKey); }
public void TestSync() { var moqRestClient = new Mock <HttpClientHandler>(); Client.Builder clientBuilder = new Client.Builder(TestSetup.app_key, TestSetup.app_secret) .setFilePath(TestSetup.db_dir) .SetRestClient(new HttpClient(moqRestClient.Object)); Client client = clientBuilder.Build(); if (client.ActiveUser != null) { client.ActiveUser.Logout(); } { var moqResponse = new HttpResponseMessage(); JObject moqResponseContent = new JObject { ["_id"] = new Guid().ToString(), ["username"] = new Guid().ToString() }; var kmd = new JObject { ["authtoken"] = new Guid().ToString() }; moqResponseContent["_kmd"] = kmd; moqResponse.Content = new StringContent(JsonConvert.SerializeObject(moqResponseContent)); moqResponse.StatusCode = System.Net.HttpStatusCode.OK; // Status Code - 504 moqRestClient .Protected() .Setup <Task <HttpResponseMessage> >( "SendAsync", ItExpr.IsAny <HttpRequestMessage>(), ItExpr.IsAny <CancellationToken>() ) .ReturnsAsync(moqResponse) .Verifiable(); } var user = User.LoginAsync(client).Result; var dataStore = DataStore <Person> .Collection("Person", DataStoreType.SYNC, client); dataStore.ClearCache(); var person = new Person { FirstName = "Victor" }; Assert.AreEqual(0, dataStore.GetSyncCount()); person = dataStore.SaveAsync(person).Result; Assert.AreEqual(1, dataStore.GetSyncCount()); { HttpRequestMessage request = null; moqRestClient .Protected() .Setup <Task <HttpResponseMessage> >( "SendAsync", ItExpr.IsAny <HttpRequestMessage>(), ItExpr.IsAny <CancellationToken>() ) .Callback <HttpRequestMessage, CancellationToken>((req, token) => request = req) .ReturnsAsync(() => new HttpResponseMessage { RequestMessage = request, StatusCode = System.Net.HttpStatusCode.OK, // Status Code - 504 Content = new StringContent(JsonConvert.SerializeObject(new JObject { ["_id"] = Guid.NewGuid().ToString(), ["FirstName"] = person.FirstName })) }) .Verifiable(); } var syncResultTask = dataStore.SyncAsync(); person.LastName = "Hugo"; var person2 = dataStore.SaveAsync(person).Result; var syncResult = syncResultTask.Result; Assert.AreEqual(1, dataStore.GetSyncCount()); Assert.AreEqual(1, syncResult.PushResponse.PushCount); Assert.AreEqual(1, syncResult.PushResponse.PushEntities.Count); person.LastName = "Barros"; var person3 = dataStore.SaveAsync(person).Result; { HttpRequestMessage request = null; moqRestClient .Protected() .Setup <Task <HttpResponseMessage> >( "SendAsync", ItExpr.IsAny <HttpRequestMessage>(), ItExpr.IsAny <CancellationToken>() ) .Callback <HttpRequestMessage, CancellationToken>((req, token) => request = req) .ReturnsAsync(() => new HttpResponseMessage { RequestMessage = request, StatusCode = System.Net.HttpStatusCode.OK, // Status Code - 504 Content = new StringContent(JsonConvert.SerializeObject(new JObject { ["_id"] = new Guid().ToString(), ["LastName"] = person.LastName })) }) .Verifiable(); } var syncResult2 = dataStore.SyncAsync().Result; Assert.AreEqual(0, dataStore.GetSyncCount()); Assert.AreEqual(1, syncResult.PushResponse.PushCount); Assert.AreEqual(1, syncResult.PushResponse.PushEntities.Count); }