public async Task TestObjectHash()
{
//given
await FHClient.Init();
var testObject = new JObject();
testObject["testKey"] = "Test Data";
testObject["testBoolKey"] = true;
testObject["testNumKey"] = 10;
var arr = new JArray {
"obj1", "obj2"
};
testObject["testArrayKey"] = arr;
var obj = new JObject();
obj["obj3key"] = "obj3";
obj["obj4key"] = "obj4";
testObject["testDictKey"] = obj;
//when
var hash = FHSyncUtils.GenerateSHA1Hash(testObject);
//then
Assert.AreEqual("5f4675723d658919ede35fac62fade8c6397df1d", hash);
}
public async Task ShouldOAuthRequest()
{
await FHClient.Init();
//given
ServiceFinder.RegisterType <IOAuthClientHandlerService, MockOAuthClient>();
var json = JObject.Parse(@"{
""hosts"": {""host"": ""HOST""}
}");
var config = new FHConfig(new MockDeviceService());
var props = new CloudProps(json, config);
var authRequest = new FHAuthRequest(props);
authRequest.SetAuthUser("gmail", "user", "password");
var mockHttpCLient =
new MockHttpClient {
Content = "{\"status\": \"ok\", \"url\": \"http://oauthurl.url\"}"
};
FHHttpClientFactory.Get = () => mockHttpCLient;
//when
var response = await authRequest.ExecAsync();
//then
Assert.IsNotNull(response);
var responseParams = response.GetResponseAsDictionary();
Assert.IsNotNull(responseParams);
Assert.AreEqual("token", responseParams["sessionToken"]);
}
public async Task ShouldAddRemoteCreatedRecord()
{
//given
await FHClient.Init();
var dataset = new MockResponseDataset <TaskModel>("dataset");
var task = new TaskModel
{
TaksName = "test"
};
//when
task = dataset.Create(task);
dataset.MockResponse = dataset.RemoteCreatedResponse;
await dataset.StartSyncLoop();
//then
var list = dataset.List();
Assert.AreEqual(2, list.Count);
Assert.IsTrue(list.Contains(task));
Assert.IsTrue(list.Contains(new TaskModel()
{
UID = "561b7cf1810880dc18000029"
}));
}
public async Task ShouldDeleteRecord()
{
//given
await FHClient.Init();
var dataset = new MockResponseDataset <TaskModel>("dataset");
dataset.MockResponse = dataset.AppliedCreateResponse;
var task = new TaskModel
{
TaksName = "test"
};
//when
task = dataset.Create(task);
await dataset.StartSyncLoop();
dataset.Delete(task.UID);
//then
var list = dataset.List();
Assert.AreEqual(0, list.Count);
Assert.AreEqual(1, dataset.GetPendingRecords().List().Count);
}
public async Task ShouldCreatePendingTaskForCreate()
{
//given
await FHClient.Init();
const string taskName = "task1";
var dataset1 = FHSyncDataset <TaskModel> .Build <TaskModel>("set", new FHSyncConfig(), null, null);
var task = new TaskModel
{
TaksName = taskName
};
var dataset = dataset1;
//when
var savedTask = dataset.Create(task);
//then
Assert.IsNotNull(savedTask.UID);
Assert.AreEqual(1, dataset.GetPendingRecords().List().Count);
var taskRead = dataset.Read(savedTask.UID);
Assert.IsNotNull(taskRead);
Assert.AreEqual(taskName, taskRead.TaksName);
}
public async Task ShouldOmitFieldWithNull()
{
//given
await FHClient.Init();
var dataset = new MockResponseDataset <TaskModel>("dataset")
{
KeepSyncParamType = typeof(FHSyncDataset <TaskModel> .FHSyncLoopParams)
};
dataset.MockResponse = dataset.AppliedCreateResponse;
var task = new TaskModel();
//when
dataset.Create(task);
await dataset.StartSyncLoop();
//then
Assert.IsTrue(dataset.SyncParams.GetType() == typeof(FHSyncDataset <TaskModel> .FHSyncLoopParams));
var param = (FHSyncDataset <TaskModel> .FHSyncLoopParams)dataset.SyncParams;
Assert.AreEqual(1, param.Pendings.Count);
var post = param.Pendings[0]["post"];
Assert.IsTrue(post["taskName"] == null);
}
public async Task ShouldCreateUpdate()
{
//given
await FHClient.Init();
var dataset = new MockResponseDataset <TaskModel>("dataset");
var task = new TaskModel
{
TaksName = "test"
};
//when
task = dataset.Create(task);
const string name = "super";
task.TaksName = name;
dataset.Update(task);
//then
var readTask = dataset.Read(task.UID);
Assert.IsNotNull(readTask);
Assert.AreEqual(name, readTask.TaksName);
//when
dataset.MockResponse = dataset.AwkRespone;
await dataset.StartSyncLoop();
//then
var list = dataset.List();
Assert.AreEqual(1, list.Count);
Assert.AreEqual(name, list[0].TaksName);
}
private async void InitApp()
{
await FHClient.Init();
progress.Visibility = Visibility.Collapsed;
app.Visibility = Visibility.Visible;
}
private async void InitApp()
{
await FHClient.Init();
FHClient.RegisterPush(NotificationReceived);
ShowMessage("App Ready!");
}
public override bool FinishedLaunching(UIApplication application, NSDictionary launchOptions)
{
// Override point for customization after application launch.
// If not required for your application you can safely delete this method
FHClient.Init();
return(true);
}
public async override void ViewDidLoad()
{
base.ViewDidLoad();
FH.SetLogLevel((int)LogService.LogLevels.DEBUG);
// Perform any additional setup after loading the view, typically from a nib.
await FHClient.Init();
ShowMessage("App Ready!");
}
private static async Task <MockHttpClient> InitMock()
{
await FHClient.Init();
var mock = new MockHttpClient();
FHHttpClientFactory.Get = () => mock;
return(mock);
}
public InMemoryDataStoreTest()
{
FHClient.Init();
_ioService = ServiceFinder.Resolve <IIOService>();
var dataDir = _ioService.GetDataPersistDir();
var dataPersistDir = Path.Combine(dataDir, "syncTestDir");
_dataPersistFile = Path.Combine(dataPersistDir, ".test_data_file");
}
public override async void ViewDidLoad()
{
base.ViewDidLoad();
result.Text = "Loading...";
await FHClient.Init();
result.Text = "Response here.";
button.TouchUpInside += async delegate {
CallCloudAsync();
};
}
protected override async void OnNavigatedTo(NavigationEventArgs e)
{
base.OnNavigatedTo(e);
try
{
await FHClient.Init();
}
catch (Exception)
{
}
}
private async void Button_Click(object sender, RoutedEventArgs e)
{
var response = await FHClient.GetCloudRequest("sso/session/login_host", "POST", null, GetRequestParams()).ExecAsync();
var resData = response.GetResponseAsJObject();
var sso = (string)resData["sso"];
if (!string.IsNullOrEmpty(sso))
{
webView.Visibility = Visibility.Visible;
webView.Navigate(new Uri(sso));
}
}
/// <summary>
/// Invoked when this page is about to be displayed in a Frame.
/// </summary>
/// <param name="e">
/// Event data that describes how this page was reached.
/// This parameter is typically used to configure the page.
/// </param>
protected override async void OnNavigatedTo(NavigationEventArgs e)
{
// TODO: Prepare page for display here.
// TODO: If your application contains multiple pages, ensure that you are
// handling the hardware Back button by registering for the
// Windows.Phone.UI.Input.HardwareButtons.BackPressed event.
// If you are using the NavigationHelper provided by some templates,
// this event is handled for you.
var inited = await FHClient.Init();
Debug.WriteLine("inited " + inited);
}
public async Task TestStringHash()
{
//given
await FHClient.Init();
const string text = "test";
var hasher = ServiceFinder.Resolve <IHashService>();
//when
var nativeHashed = hasher.GenerateSha1Hash(text);
Assert.AreEqual("a94a8fe5ccb19ba61c4c0873d391e987982fbbd3", nativeHashed);
}
protected override async void OnCreate(Bundle savedInstanceState)
{
base.OnCreate(savedInstanceState);
SetContentView(Resource.Layout.splash_screen_activity);
var init = await FHClient.Init();
if (init)
{
StartActivity(new Intent(this, typeof(ListOfItemsActivity)));
Finish();
}
}
protected override async void OnNavigatedTo(NavigationEventArgs e)
{
try
{
await FHClient.Init();
Label.Text = "Yay, this app is ready to go!";
//NOTE: other FH methods can only be called after FHClient.init succeeds
}
catch (FHException)
{
Label.Text = "Oops, an error occurred while processing FHClient.init";
}
}
public void SetUp()
{
FHClient.Init();
_ioService = ServiceFinder.Resolve <IIOService>();
var dataDir = _ioService.GetDataPersistDir();
_dataPersistDir = Path.Combine(dataDir, "syncTestDir");
if (Directory.Exists(_dataPersistDir))
{
Directory.Delete(_dataPersistDir);
}
_dataPersistFile = Path.Combine(_dataPersistDir, ".test_data_file");
Debug.WriteLine("Data persist path = {0}", _dataPersistFile);
}
public async Task TestReadConfig()
{
// given
await FHClient.Init();
// when
var config = FHConfig.GetInstance();
// then
Assert.AreEqual("http://192.168.28.34:8001", config.GetHost());
Assert.AreEqual("project_id_for_test", config.GetProjectId());
Assert.AreEqual("app_key_for_test", config.GetAppKey());
Assert.AreEqual("appid_for_test", config.GetAppId());
Assert.AreEqual("connection_tag_for_test", config.GetConnectionTag());
}
public override async void OnMessageReceived(string from, Bundle data)
{
if (!ServiceFinder.IsRegistered <IPush>())
{
await FHClient.Init();
FH.RegisterPush(DefaultHandleEvent);
}
var push = ServiceFinder.Resolve <IPush>() as Push;
var message = data.GetString("alert");
var messageData = data.KeySet().ToDictionary(key => key, key => data.GetString(key));
(push.Registration as GcmRegistration).OnPushNotification(message, messageData);
}
public async Task TestLoadingPushConfig()
{
//given
await FHClient.Init();
//when
var config = PushBase.ReadConfig();
//then
Assert.AreEqual(new Uri("http://192.168.28.34:8001/api/v2/ag-push"), config.UnifiedPushUri);
Assert.IsNotNull(config.Categories);
Assert.AreEqual(2, config.Categories.Count);
Assert.IsTrue(config.Categories.IndexOf("one") != -1);
Assert.IsTrue(config.Categories.IndexOf("two") != -1);
}
public async Task TestReadPushConfig()
{
// given
await FHClient.Init();
var deviceService = ServiceFinder.Resolve <IDeviceService>();
// when
var config = deviceService.ReadPushConfig();
// then
Assert.AreEqual("*****@*****.**", config.Alias);
var cat = config.Categories;
Assert.AreEqual(2, cat.Count);
Assert.IsTrue(cat.Contains("one"));
}
public async Task ShouldPerformGet()
{
//given
await FHClient.Init();
var mock = new MockHttpClient();
FHHttpClientFactory.Get = () => mock;
const string method = "GET";
//when
await FHHttpClient.SendAsync(new Uri("http://localhost/test"), method, null,
JObject.Parse("{'key-data': 'value'}"), TimeSpan.FromSeconds(20));
//then
Assert.IsNotNull(mock.Request);
Assert.AreEqual("http://localhost/test?key-data=\"value\"", mock.Request.RequestUri.ToString());
}
public override void ViewDidLoad ()
{
base.ViewDidLoad ();
var initTask = FHClient.Init();
initTask.ContinueWith(task =>
{
if (!task.IsFaulted)
{
StatusLabel.Text = "FH init successful";
}
else
{
StatusLabel.Text = "FH init in error";
Console.WriteLine("Error {0}", e);
}
}
}
protected override void OnCreate(Bundle savedInstanceState)
{
base.OnCreate(savedInstanceState);
// Set our view from the "main" layout resource
//SetContentView (Resource.Layout.Main);
var initTask = FHClient.Init();
initTask.ContinueWith(task =>
{ RunOnUiThread(() => {
if (!task.IsFaulted)
{
Toast.MakeText(this, "Init complete", ToastLength.Long).Show();
}
else
{
Toast.MakeText(this, "Init failed " + task.Exception, ToastLength.Long).Show();
}
}); });
}
private async void ShowSignedIn()
{
signedIn.Visibility = Visibility.Visible;
signIn.Visibility = Visibility.Collapsed;
webView.Visibility = Visibility.Collapsed;
var response = await FHClient.GetCloudRequest("sso/session/valid", "POST", null, GetRequestParams()).ExecAsync();
if (response.Error == null)
{
var data = response.GetResponseAsDictionary();
name.Text = string.Format("{0} {1}", data["first_name"], data["last_name"]);
email.Text = (string)data["email"];
expires.Text = ((DateTime)data["expires"]).ToString();
}
else
{
await new MessageDialog(response.Error.ToString()).ShowAsync();
}
}
public async Task TestGenerateHashWithUnderscoreInKey()
{
// given
await FHClient.Init();
var data = new JObject();
data["COMMENTS"] = "";
data["FHID"] = "2553C7ED-9025-48F9-A346-EBE3E3AF943B";
data["QUESTION_ID"] = 22;
data["QUES_VALUE"] = "NO";
data["VISIT_ID"] = 100220;
data["TEST1_ttt"] = "test";
data["TEST11_ttt"] = "test2";
// when
var hash = FHSyncUtils.GenerateSHA1Hash(data);
// then
Assert.AreEqual("824d6ded431d16fe8f2ab02b0744ca06822a3fff", hash);
}
