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);
}
}
private static async Task Main()
{
Console.WriteLine("C# Client");
var apiKey = Environment.GetEnvironmentVariable("API_KEY");
var project = Environment.GetEnvironmentVariable("PROJECT");
using var handler = new HttpClientHandler
{
ServerCertificateCustomValidationCallback = (message, cert, chain, errors) => true
};
var serviceCollection = new ServiceCollection();
ConfigureServices(serviceCollection);
var serviceProvider = serviceCollection.BuildServiceProvider();
var logger = serviceProvider.GetService <ILoggerFactory>().CreateLogger <Program>();
using var httpClient = new HttpClient(handler);
var builder = new Client.Builder();
var client =
builder
.SetAppId("playground")
.SetHttpClient(httpClient)
.SetApiKey(apiKey)
.SetProject(project)
.SetLogger(logger)
.SetLogLevel(LogLevel.Debug)
.Build();
var asset = await GetAssetsExample(client, "23-TE-96116-04").ConfigureAwait(false);
Console.WriteLine($"{asset}");
//var data = await QueryTimeseriesDataExample(client);
}
public MainPage()
{
InitializeComponent();
Client.Builder Builder = new Client.Builder(this.appKey, this.appSecret).setLogger(Console.WriteLine);
this.KinveyClient = Builder.Build();
this.KinveyPing();
}
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 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 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 override void FinishedLaunching(UIApplication application)
{
myClient = new Client.Builder("kid_PeYFqjBcBJ", "3fee066a01784e2ab32a255151ff761b")
.setFilePath(NSFileManager.DefaultManager.GetUrls(NSSearchPathDirectory.DocumentDirectory, NSSearchPathDomain.User) [0].ToString())
.setOfflinePlatform(new SQLitePlatformIOS())
.setLogger(delegate(string msg) { Console.WriteLine(msg); })
.build();
}
public MainPage()
{
InitializeComponent();
Client.Builder Builder = new Client.Builder(this.appKey, this.appSecret);
this.KinveyClient = Builder.Build();
this.KinveyPing();
this.ProceedKinveyLiveServices();
}
public static void Main(string[] args)
{
var client = new Client.Builder()
.WithName("Name")
.WithSurname("Surname")
.WithPassport(123455)
.WithAddress("Some Address")
.Build();
}
public Form1()
{
InitializeComponent();
// Set-up the Kinvey backend connection.
mBuilder = new Client.Builder(appKey, appSecret).SetInstanceID(instanceID).setLogger(Console.WriteLine);
mKinveyClient = mBuilder.Build();
KinveyPing();
}
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);
}
private Client GetKinveyClient(string appKey, string appSecret)
{
Client kClient = new Client.Builder(appKey, appSecret)
// .setBaseURL(baseUrl)
.setFilePath(DependencyService.Get <ISQLite>().GetPath())
.setOfflinePlatform(DependencyService.Get <ISQLite>().GetConnection())
.Build();
return(kClient);
}
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 void ClientBuilderSetBaseURLBad()
{
// Arrange
Client.Builder builder = new Client.Builder(TestSetup.app_key, TestSetup.app_secret);
// Act
// Assert
Assert.ThrowsException <KinveyException>(delegate()
{
builder.setBaseURL("www.test.com");
});
}
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 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 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 ClientBuilderSetBaseURL()
{
// Arrange
const string url = "https://www.test.com/";
Client.Builder builder = new Client.Builder(TestSetup.app_key, TestSetup.app_secret);
// Act
builder.setBaseURL(url);
// Assert
Assert.IsFalse(string.IsNullOrEmpty(builder.BaseUrl));
Assert.IsTrue(string.Equals(builder.BaseUrl, url));
}
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();
}
