public async Task SyncThroughHttp()
{
using (var server = new KestrellTestServer())
{
var serverHandler = new RequestDelegate(async context =>
{
SqlSyncProvider serverProvider = new SqlSyncProvider(this.fixture.ServerConnectionString);
SyncConfiguration configuration = new SyncConfiguration(this.fixture.Tables);
configuration.DownloadBatchSizeInKB = 500;
WebProxyServerProvider proxyServerProvider = new WebProxyServerProvider(serverProvider);
proxyServerProvider.Configuration = configuration;
await proxyServerProvider.HandleRequestAsync(context);
});
var clientHandler = new ResponseDelegate(async(serviceUri) =>
{
var proxyProvider = new WebProxyClientProvider(new Uri(serviceUri));
var clientProvider = new SqlSyncProvider(this.fixture.Client1ConnectionString);
SyncAgent agent = new SyncAgent(clientProvider, proxyProvider);
var session = await agent.SynchronizeAsync();
Assert.Equal(5, session.TotalChangesDownloaded);
Assert.Equal(0, session.TotalChangesUploaded);
});
await server.Run(serverHandler, clientHandler);
}
}
public async Task SyncNoRows(SyncConfiguration conf)
{
using (var server = new KestrellTestServer())
{
var serverHandler = new RequestDelegate(async context =>
{
conf.Add(fixture.Tables);
serverProvider.SetConfiguration(conf);
proxyServerProvider.SerializationFormat = conf.SerializationFormat;
await proxyServerProvider.HandleRequestAsync(context);
});
var clientHandler = new ResponseDelegate(async(serviceUri) =>
{
proxyClientProvider.ServiceUri = new Uri(serviceUri);
proxyClientProvider.SerializationFormat = conf.SerializationFormat;
var session = await agent.SynchronizeAsync();
Assert.Equal(0, session.TotalChangesDownloaded);
Assert.Equal(0, session.TotalChangesUploaded);
});
await server.Run(serverHandler, clientHandler);
}
}
public async Task Kestrell_Server_Request_EnsureSuccess()
{
using (var server = new KestrellTestServer())
{
var clientHandler = new ResponseDelegate(async baseAdress => {
var httpClient = new HttpClient();
var response = await httpClient.GetAsync(baseAdress + "first");
response.EnsureSuccessStatusCode();
var resString = await response.Content.ReadAsStringAsync();
Assert.Equal("first_first", resString);
});
var serverHandler = new RequestDelegate(async context =>
{
var pathFirst = new PathString("/first");
Assert.Equal(context.Request.Path, pathFirst);
await context.Response.WriteAsync("first_first");
});
await server.Run(serverHandler, clientHandler);
};
}
public async Task SyncReinitialize()
{
using (var sqlConnection = new SqlConnection(fixture.Client1ConnectionString))
{
var script = $@"UPDATE Customers SET LastName='DoeClient' WHERE CustomerID=1;";
using (var sqlCmd = new SqlCommand(script, sqlConnection))
{
sqlConnection.Open();
sqlCmd.ExecuteNonQuery();
sqlConnection.Close();
}
}
var serverHandler = new RequestDelegate(async context =>
{
//configuration.AddTable(fixture.Tables);
serverProvider.SetConfiguration(configuration);
proxyServerProvider.SerializationFormat = SerializationFormat.Json;
await proxyServerProvider.HandleRequestAsync(context);
});
using (var server = new KestrellTestServer())
{
var clientHandler = new ResponseDelegate(async(serviceUri) =>
{
proxyClientProvider.ServiceUri = new Uri(serviceUri);
proxyClientProvider.SerializationFormat = SerializationFormat.Json;
var syncAgent = new SyncAgent(clientProvider, proxyClientProvider);
var session = await syncAgent.SynchronizeAsync(SyncType.Reinitialize);
Assert.Equal(7, session.TotalChangesDownloaded);
Assert.Equal(0, session.TotalChangesUploaded);
});
await server.Run(serverHandler, clientHandler);
}
string lastName = null;
using (var sqlConnection = new SqlConnection(fixture.Client1ConnectionString))
{
var script = $@"SELECT LastName FROM Customers WHERE CustomerID=1;";
using (var sqlCmd = new SqlCommand(script, sqlConnection))
{
sqlConnection.Open();
lastName = (string)sqlCmd.ExecuteScalar();
sqlConnection.Close();
}
}
Assert.Equal("Doe", lastName);
}
public async Task InsertFromClient(SyncConfiguration conf)
{
Guid newId = Guid.NewGuid();
var insertRowScript =
$@"INSERT INTO [ServiceTickets] ([ServiceTicketID], [Title], [Description], [StatusValue], [EscalationLevel], [Opened], [Closed], [CustomerID])
VALUES (@id, 'Insert One Row in Sqlite client', 'Description Insert One Row', 1, 0, datetime('now'), NULL, 1)";
int nbRowsInserted = 0;
using (var sqlConnection = new SqliteConnection(fixture.ClientSqliteConnectionString))
{
using (var sqlCmd = new SqliteCommand(insertRowScript, sqlConnection))
{
sqlCmd.Parameters.AddWithValue("@id", newId);
sqlConnection.Open();
nbRowsInserted = sqlCmd.ExecuteNonQuery();
sqlConnection.Close();
}
}
if (nbRowsInserted < 0)
{
throw new Exception("Row not inserted");
}
using (var server = new KestrellTestServer())
{
var serverHandler = new RequestDelegate(async context =>
{
conf.Add(fixture.Tables);
serverProvider.SetConfiguration(conf);
proxyServerProvider.SerializationFormat = conf.SerializationFormat;
await proxyServerProvider.HandleRequestAsync(context);
});
var clientHandler = new ResponseDelegate(async(serviceUri) =>
{
proxyClientProvider.ServiceUri = new Uri(serviceUri);
proxyClientProvider.SerializationFormat = conf.SerializationFormat;
var session = await agent.SynchronizeAsync();
Assert.Equal(0, session.TotalChangesDownloaded);
Assert.Equal(1, session.TotalChangesUploaded);
});
await server.Run(serverHandler, clientHandler);
}
}
public async Task DeleteFromClient(SyncConfiguration conf)
{
int count;
var selectcount = $@"Select count(*) From [ServiceTickets]";
var updateRowScript = $@"Delete From [ServiceTickets]";
using (var sqlConnection = new SqlConnection(fixture.Client1ConnectionString))
{
sqlConnection.Open();
using (var sqlCmd = new SqlCommand(selectcount, sqlConnection))
count = (int)sqlCmd.ExecuteScalar();
using (var sqlCmd = new SqlCommand(updateRowScript, sqlConnection))
sqlCmd.ExecuteNonQuery();
sqlConnection.Close();
}
using (var server = new KestrellTestServer())
{
var serverHandler = new RequestDelegate(async context =>
{
conf.Add(fixture.Tables);
serverProvider.SetConfiguration(conf);
proxyServerProvider.SerializationFormat = conf.SerializationFormat;
await proxyServerProvider.HandleRequestAsync(context);
});
var clientHandler = new ResponseDelegate(async(serviceUri) =>
{
proxyClientProvider.ServiceUri = new Uri(serviceUri);
proxyClientProvider.SerializationFormat = conf.SerializationFormat;
var session = await agent.SynchronizeAsync();
Assert.Equal(0, session.TotalChangesDownloaded);
Assert.Equal(count, session.TotalChangesUploaded);
});
await server.Run(serverHandler, clientHandler);
}
// check all rows deleted on server side
using (var sqlConnection = new SqlConnection(fixture.ServerConnectionString))
{
sqlConnection.Open();
using (var sqlCmd = new SqlCommand(selectcount, sqlConnection))
count = (int)sqlCmd.ExecuteScalar();
}
Assert.Equal(0, count);
}
public async Task Initialize()
{
var serverHandler = new RequestDelegate(async context =>
{
//configuration.AddTable(fixture.Tables);
serverProvider.SetConfiguration(configuration);
proxyServerProvider.SerializationFormat = SerializationFormat.Json;
await proxyServerProvider.HandleRequestAsync(context);
});
using (var server = new KestrellTestServer())
{
var clientHandler = new ResponseDelegate(async(serviceUri) =>
{
proxyClientProvider.ServiceUri = new Uri(serviceUri);
proxyClientProvider.SerializationFormat = SerializationFormat.Json;
var syncAgent = new SyncAgent(clientProvider, proxyClientProvider);
var session = await syncAgent.SynchronizeAsync();
Assert.Equal(7, session.TotalChangesDownloaded);
Assert.Equal(0, session.TotalChangesUploaded);
});
await server.Run(serverHandler, clientHandler);
}
// check relation has been created on client :
int foreignKeysCount;
using (var sqlConnection = new SqlConnection(fixture.Client1ConnectionString))
{
var script = $@"Select count(*) from sys.foreign_keys where name = 'FK_ServiceTickets_Customers'";
using (var sqlCmd = new SqlCommand(script, sqlConnection))
{
sqlConnection.Open();
foreignKeysCount = (int)sqlCmd.ExecuteScalar();
sqlConnection.Close();
}
}
Assert.Equal(1, foreignKeysCount);
}
public async Task UpdateFromServer(SyncConfiguration conf)
{
string title = $"Update from server at {DateTime.Now.Ticks.ToString()}";
var updateRowScript =
$@" Declare @id uniqueidentifier;
Select top 1 @id = ServiceTicketID from ServiceTickets;
Update [ServiceTickets] Set [Title] = '{title}' Where ServiceTicketId = @id";
using (var sqlConnection = new SqlConnection(fixture.ServerConnectionString))
{
using (var sqlCmd = new SqlCommand(updateRowScript, sqlConnection))
{
sqlConnection.Open();
sqlCmd.ExecuteNonQuery();
sqlConnection.Close();
}
}
using (var server = new KestrellTestServer())
{
var serverHandler = new RequestDelegate(async context =>
{
conf.Add(fixture.Tables);
serverProvider.SetConfiguration(conf);
proxyServerProvider.SerializationFormat = conf.SerializationFormat;
await proxyServerProvider.HandleRequestAsync(context);
});
var clientHandler = new ResponseDelegate(async(serviceUri) =>
{
proxyClientProvider.ServiceUri = new Uri(serviceUri);
proxyClientProvider.SerializationFormat = conf.SerializationFormat;
var session = await agent.SynchronizeAsync();
Assert.Equal(1, session.TotalChangesDownloaded);
Assert.Equal(0, session.TotalChangesUploaded);
});
await server.Run(serverHandler, clientHandler);
}
}
public async Task InsertFromServer(SyncConfiguration conf)
{
var insertRowScript =
$@"INSERT [ServiceTickets] ([ServiceTicketID], [Title], [Description], [StatusValue], [EscalationLevel], [Opened], [Closed], [CustomerID])
VALUES (newid(), N'Insert One Row', N'Description Insert One Row', 1, 0, getdate(), NULL, 1)";
using (var sqlConnection = new SqlConnection(fixture.ServerConnectionString))
{
using (var sqlCmd = new SqlCommand(insertRowScript, sqlConnection))
{
sqlConnection.Open();
sqlCmd.ExecuteNonQuery();
sqlConnection.Close();
}
}
using (var server = new KestrellTestServer())
{
var serverHandler = new RequestDelegate(async context =>
{
conf.Add(fixture.Tables);
serverProvider.SetConfiguration(conf);
proxyServerProvider.SerializationFormat = conf.SerializationFormat;
await proxyServerProvider.HandleRequestAsync(context);
});
var clientHandler = new ResponseDelegate(async(serviceUri) =>
{
proxyClientProvider.ServiceUri = new Uri(serviceUri);
proxyClientProvider.SerializationFormat = conf.SerializationFormat;
var session = await agent.SynchronizeAsync();
Assert.Equal(1, session.TotalChangesDownloaded);
Assert.Equal(0, session.TotalChangesUploaded);
});
await server.Run(serverHandler, clientHandler);
}
}
public async Task Initialize()
{
using (var server = new KestrellTestServer())
{
var serverHandler = new RequestDelegate(async context =>
{
serverProvider.SetConfiguration(configuration);
proxyServerProvider.SerializationFormat = SerializationFormat.Json;
await proxyServerProvider.HandleRequestAsync(context);
});
var clientHandler = new ResponseDelegate(async(serviceUri) =>
{
proxyClientProvider.ServiceUri = new Uri(serviceUri);
proxyClientProvider.SerializationFormat = SerializationFormat.Json;
var session = await agent.SynchronizeAsync();
Assert.Equal(50, session.TotalChangesDownloaded);
Assert.Equal(0, session.TotalChangesUploaded);
});
await server.Run(serverHandler, clientHandler);
}
}
public async Task ConflictInsertInsertConfigurationClientWins(SyncConfiguration conf)
{
Guid id = Guid.NewGuid();
using (var sqlConnection = new SqlConnection(fixture.Client1ConnectionString))
{
var script = $@"INSERT [ServiceTickets]
([ServiceTicketID], [Title], [Description], [StatusValue], [EscalationLevel], [Opened], [Closed], [CustomerID])
VALUES
(N'{id.ToString()}', N'Conflict Line Client', N'Description client', 1, 0, getdate(), NULL, 1)";
using (var sqlCmd = new SqlCommand(script, sqlConnection))
{
sqlConnection.Open();
sqlCmd.ExecuteNonQuery();
sqlConnection.Close();
}
}
using (var sqlConnection = new SqlConnection(fixture.ServerConnectionString))
{
var script = $@"INSERT [ServiceTickets]
([ServiceTicketID], [Title], [Description], [StatusValue], [EscalationLevel], [Opened], [Closed], [CustomerID])
VALUES
(N'{id.ToString()}', N'Conflict Line Server', N'Description client', 1, 0, getdate(), NULL, 1)";
using (var sqlCmd = new SqlCommand(script, sqlConnection))
{
sqlConnection.Open();
sqlCmd.ExecuteNonQuery();
sqlConnection.Close();
}
}
using (var server = new KestrellTestServer())
{
var serverHandler = new RequestDelegate(async context =>
{
conf.Add(fixture.Tables);
conf.ConflictResolutionPolicy = ConflictResolutionPolicy.ClientWins;
serverProvider.SetConfiguration(conf);
proxyServerProvider.SerializationFormat = conf.SerializationFormat;
await proxyServerProvider.HandleRequestAsync(context);
});
var clientHandler = new ResponseDelegate(async(serviceUri) =>
{
proxyClientProvider.ServiceUri = new Uri(serviceUri);
proxyClientProvider.SerializationFormat = conf.SerializationFormat;
var session = await agent.SynchronizeAsync();
// check statistics
Assert.Equal(0, session.TotalChangesDownloaded);
Assert.Equal(1, session.TotalChangesUploaded);
Assert.Equal(1, session.TotalSyncConflicts);
});
await server.Run(serverHandler, clientHandler);
}
string expectedRes = string.Empty;
using (var sqlConnection = new SqlConnection(fixture.ServerConnectionString))
{
var script = $@"Select Title from [ServiceTickets] Where ServiceTicketID='{id.ToString()}'";
using (var sqlCmd = new SqlCommand(script, sqlConnection))
{
sqlConnection.Open();
expectedRes = sqlCmd.ExecuteScalar() as string;
sqlConnection.Close();
}
}
// check good title on client
Assert.Equal("Conflict Line Client", expectedRes);
}
public async Task ConflictUpdateUpdateClientWins(SyncConfiguration conf)
{
var id = Guid.NewGuid().ToString();
using (var sqlConnection = new SqlConnection(fixture.Client1ConnectionString))
{
var script = $@"INSERT [ServiceTickets]
([ServiceTicketID], [Title], [Description], [StatusValue], [EscalationLevel], [Opened], [Closed], [CustomerID])
VALUES
(N'{id}', N'Line for conflict', N'Description client', 1, 0, getdate(), NULL, 1)";
using (var sqlCmd = new SqlCommand(script, sqlConnection))
{
sqlConnection.Open();
sqlCmd.ExecuteNonQuery();
sqlConnection.Close();
}
}
using (var server = new KestrellTestServer())
{
var serverHandler = new RequestDelegate(async context =>
{
conf.Add(fixture.Tables);
serverProvider.SetConfiguration(conf);
proxyServerProvider.SerializationFormat = conf.SerializationFormat;
await proxyServerProvider.HandleRequestAsync(context);
});
var clientHandler = new ResponseDelegate(async(serviceUri) =>
{
proxyClientProvider.ServiceUri = new Uri(serviceUri);
proxyClientProvider.SerializationFormat = conf.SerializationFormat;
var session = await agent.SynchronizeAsync();
// check statistics
Assert.Equal(0, session.TotalChangesDownloaded);
Assert.Equal(1, session.TotalChangesUploaded);
Assert.Equal(0, session.TotalSyncConflicts);
});
await server.Run(serverHandler, clientHandler);
}
using (var sqlConnection = new SqlConnection(fixture.Client1ConnectionString))
{
var script = $@"Update [ServiceTickets]
Set Title = 'Updated from Client'
Where ServiceTicketId = '{id}'";
using (var sqlCmd = new SqlCommand(script, sqlConnection))
{
sqlConnection.Open();
sqlCmd.ExecuteNonQuery();
sqlConnection.Close();
}
}
using (var sqlConnection = new SqlConnection(fixture.ServerConnectionString))
{
var script = $@"Update [ServiceTickets]
Set Title = 'Updated from Server'
Where ServiceTicketId = '{id}'";
using (var sqlCmd = new SqlCommand(script, sqlConnection))
{
sqlConnection.Open();
sqlCmd.ExecuteNonQuery();
sqlConnection.Close();
}
}
using (var server = new KestrellTestServer())
{
var serverHandler = new RequestDelegate(async context =>
{
conf.Add(fixture.Tables);
serverProvider.SetConfiguration(conf);
proxyServerProvider.SerializationFormat = conf.SerializationFormat;
// Since we move to server side, it's server to handle errors
serverProvider.ApplyChangedFailed += (s, args) =>
{
args.Action = ApplyAction.RetryWithForceWrite;
};
await proxyServerProvider.HandleRequestAsync(context);
});
var clientHandler = new ResponseDelegate(async(serviceUri) =>
{
proxyClientProvider.ServiceUri = new Uri(serviceUri);
proxyClientProvider.SerializationFormat = conf.SerializationFormat;
SyncContext session = null;
await Assert.RaisesAsync <ApplyChangeFailedEventArgs>(
h => serverProvider.ApplyChangedFailed += h,
h => serverProvider.ApplyChangedFailed -= h, async() =>
{
session = await agent.SynchronizeAsync();
});
// check statistics
Assert.Equal(0, session.TotalChangesDownloaded);
Assert.Equal(1, session.TotalChangesUploaded);
Assert.Equal(1, session.TotalSyncConflicts);
});
await server.Run(serverHandler, clientHandler);
}
string expectedRes = string.Empty;
using (var sqlConnection = new SqlConnection(fixture.ServerConnectionString))
{
var script = $@"Select Title from [ServiceTickets] Where ServiceTicketID='{id}'";
using (var sqlCmd = new SqlCommand(script, sqlConnection))
{
sqlConnection.Open();
expectedRes = sqlCmd.ExecuteScalar() as string;
sqlConnection.Close();
}
}
// check good title on client
Assert.Equal("Updated from Client", expectedRes);
}
public async Task UpdateFromClient(SyncConfiguration conf)
{
Guid newId = Guid.NewGuid();
var insertRowScript =
$@"INSERT INTO [ServiceTickets] ([ServiceTicketID], [Title], [Description], [StatusValue], [EscalationLevel], [Opened], [Closed], [CustomerID])
VALUES ('{newId.ToString()}', 'Insert One Row in SQLite client', 'Description Insert One Row', 1, 0, datetime('now'), NULL, 1)";
using (var sqlConnection = new SQLiteConnection(fixture.ClientSQLiteConnectionString))
{
using (var sqlCmd = new SQLiteCommand(insertRowScript, sqlConnection))
{
sqlConnection.Open();
sqlCmd.ExecuteNonQuery();
sqlConnection.Close();
}
}
using (var server = new KestrellTestServer())
{
var serverHandler = new RequestDelegate(async context =>
{
conf.Add(fixture.Tables);
serverProvider.SetConfiguration(conf);
proxyServerProvider.SerializationFormat = conf.SerializationFormat;
await proxyServerProvider.HandleRequestAsync(context);
});
var clientHandler = new ResponseDelegate(async(serviceUri) =>
{
proxyClientProvider.ServiceUri = new Uri(serviceUri);
proxyClientProvider.SerializationFormat = conf.SerializationFormat;
var session = await agent.SynchronizeAsync();
Assert.Equal(0, session.TotalChangesDownloaded);
Assert.Equal(1, session.TotalChangesUploaded);
});
await server.Run(serverHandler, clientHandler);
}
var updateRowScript =
$@" Update [ServiceTickets] Set [Title] = 'Updated from SQLite Client side !' Where ServiceTicketId = '{newId.ToString()}'";
using (var sqlConnection = new SQLiteConnection(fixture.ClientSQLiteConnectionString))
{
using (var sqlCmd = new SQLiteCommand(updateRowScript, sqlConnection))
{
sqlConnection.Open();
sqlCmd.ExecuteNonQuery();
sqlConnection.Close();
}
}
using (var server = new KestrellTestServer())
{
var serverHandler = new RequestDelegate(async context =>
{
conf.Add(fixture.Tables);
serverProvider.SetConfiguration(conf);
proxyServerProvider.SerializationFormat = conf.SerializationFormat;
await proxyServerProvider.HandleRequestAsync(context);
});
var clientHandler = new ResponseDelegate(async(serviceUri) =>
{
proxyClientProvider.ServiceUri = new Uri(serviceUri);
proxyClientProvider.SerializationFormat = conf.SerializationFormat;
var session = await agent.SynchronizeAsync();
Assert.Equal(0, session.TotalChangesDownloaded);
Assert.Equal(1, session.TotalChangesUploaded);
});
await server.Run(serverHandler, clientHandler);
}
}
public async Task ConflictUpdateUpdateServerWins(SyncConfiguration conf)
{
Guid updateConflictId = Guid.NewGuid();
using (var sqlConnection = new SqliteConnection(fixture.ClientSqliteConnectionString))
{
var script = $@"INSERT INTO [ServiceTickets]
([ServiceTicketID], [Title], [Description], [StatusValue], [EscalationLevel], [Opened], [Closed], [CustomerID])
VALUES
(@id, 'Line Client', 'Description client', 1, 0, datetime('now'), NULL, 1)";
using (var sqlCmd = new SqliteCommand(script, sqlConnection))
{
sqlCmd.Parameters.AddWithValue("@id", updateConflictId);
sqlConnection.Open();
sqlCmd.ExecuteNonQuery();
sqlConnection.Close();
}
}
using (var server = new KestrellTestServer())
{
var serverHandler = new RequestDelegate(async context =>
{
conf.Add(fixture.Tables);
serverProvider.SetConfiguration(conf);
proxyServerProvider.SerializationFormat = conf.SerializationFormat;
await proxyServerProvider.HandleRequestAsync(context);
});
var clientHandler = new ResponseDelegate(async(serviceUri) =>
{
proxyClientProvider.ServiceUri = new Uri(serviceUri);
proxyClientProvider.SerializationFormat = conf.SerializationFormat;
var session = await agent.SynchronizeAsync();
// check statistics
Assert.Equal(0, session.TotalChangesDownloaded);
Assert.Equal(1, session.TotalChangesUploaded);
Assert.Equal(0, session.TotalSyncConflicts);
});
await server.Run(serverHandler, clientHandler);
}
using (var sqlConnection = new SqliteConnection(fixture.ClientSqliteConnectionString))
{
var script = $@"Update [ServiceTickets]
Set Title = 'Updated from Client'
Where ServiceTicketId = @id";
using (var sqlCmd = new SqliteCommand(script, sqlConnection))
{
sqlCmd.Parameters.AddWithValue("@id", updateConflictId);
sqlConnection.Open();
sqlCmd.ExecuteNonQuery();
sqlConnection.Close();
}
}
using (var sqlConnection = new SqlConnection(fixture.ServerConnectionString))
{
var script = $@"Update [ServiceTickets]
Set Title = 'Updated from Server'
Where ServiceTicketId = '{updateConflictId.ToString()}'";
using (var sqlCmd = new SqlCommand(script, sqlConnection))
{
sqlConnection.Open();
sqlCmd.ExecuteNonQuery();
sqlConnection.Close();
}
}
using (var server = new KestrellTestServer())
{
var serverHandler = new RequestDelegate(async context =>
{
conf.Add(fixture.Tables);
serverProvider.SetConfiguration(conf);
proxyServerProvider.SerializationFormat = conf.SerializationFormat;
await proxyServerProvider.HandleRequestAsync(context);
});
var clientHandler = new ResponseDelegate(async(serviceUri) =>
{
proxyClientProvider.ServiceUri = new Uri(serviceUri);
proxyClientProvider.SerializationFormat = conf.SerializationFormat;
var session = await agent.SynchronizeAsync();
// check statistics
Assert.Equal(1, session.TotalChangesDownloaded);
Assert.Equal(1, session.TotalChangesUploaded);
Assert.Equal(1, session.TotalSyncConflicts);
});
await server.Run(serverHandler, clientHandler);
}
string expectedRes = string.Empty;
using (var sqlConnection = new SqliteConnection(fixture.ClientSqliteConnectionString))
{
var script = $@"Select Title from [ServiceTickets]
Where ServiceTicketID=@id";
using (var sqlCmd = new SqliteCommand(script, sqlConnection))
{
sqlCmd.Parameters.AddWithValue("@id", updateConflictId);
sqlConnection.Open();
expectedRes = sqlCmd.ExecuteScalar() as string;
sqlConnection.Close();
}
}
// check good title on client
Assert.Equal("Updated from Server", expectedRes);
}
