public void NullFilterTest()
{
var filter1 = new FindFilter();
var filter2 = new FindFilter();
foreach (var field in Enum.GetValues(typeof(StringField)).Cast <StringField>())
{
filter1.KeyIsNull(field);
filter2.KeyIsNotNull(field);
}
foreach (var field in Enum.GetValues(typeof(NumberField)).Cast <NumberField>())
{
filter1.KeyIsNull(field);
filter2.KeyIsNotNull(field);
}
using var provider = new CryptoProvider();
var transformer = new DtoTransformer(provider, new HashUtils("envId", false, Encoding.UTF8));
Assert.IsTrue(JsonEquals(JsonFilterNull,
JsonConvert.SerializeObject(transformer.TransformFilter(filter1), s_jsonSettings)));
Assert.IsTrue(JsonEquals(JsonFilterNotNull,
JsonConvert.SerializeObject(transformer.TransformFilter(filter2), s_jsonSettings)));
}
public void GetFilterWithNonHashingModeTest()
{
using var cryptoManager = new CryptoProvider();
var hashProvider = new HashUtils(EnvId, false, Encoding.UTF8);
var transformer = new DtoTransformer(cryptoManager, hashProvider, false);
var filter = new FindFilter()
.KeyEq(StringField.RecordKey, "some record key")
.KeyEq(StringField.Key1, "some value of key1");
var filterContainer = transformer.TransformFilter(filter);
var jsonSettings = new JsonSerializerSettings
{
ContractResolver = new DefaultContractResolver {
NamingStrategy = new SnakeCaseNamingStrategy()
},
Formatting = Formatting.None,
NullValueHandling = NullValueHandling.Ignore,
DefaultValueHandling = DefaultValueHandling.Include
};
var json = JsonConvert.SerializeObject(filterContainer, jsonSettings);
Assert.AreEqual("{\"filter\":{\"record_key\":[\"2ab632ee5ebf3af90be1ae6accea46d99843fdc4676bb29a376919fa9c530364\"]," +
"\"key1\":[\"some value of key1\"]}," +
"\"options\":{\"limit\":100,\"offset\":0}}",
json);
}
public void TransformFindFilterTest()
{
using var cryptoManager = new CryptoProvider();
var hashProvider = new HashUtils(EnvId, false, Encoding.UTF8);
var transformer = new DtoTransformer(cryptoManager, hashProvider);
var filter = new FindFilter()
.KeyEq(StringField.Key1, "value1")
.KeyEq(NumberField.Version, 0);
var jsonSettings = new JsonSerializerSettings
{
ContractResolver = new DefaultContractResolver {
NamingStrategy = new SnakeCaseNamingStrategy()
},
Formatting = Formatting.None,
NullValueHandling = NullValueHandling.Ignore,
DefaultValueHandling = DefaultValueHandling.Include
};
var transformFilter = transformer.TransformFilter(filter);
Assert.IsTrue(FindFilterTest.JsonEquals(
"{\"filter\":{\"key1\":[\"327c84457a2ff2c6da36314dc0ffb3216a283570a5c4654d5f51947e74742cf0\"]," +
"\"version\":[0]},\"options\":{\"limit\":100,\"offset\":0}}",
JsonConvert.SerializeObject(transformFilter, jsonSettings)));
}
public void FindIllegalOptionsTest()
{
var config = new StorageConfig(endPoint: "http://localhost:" + Port, apiKey: "apiKey",
environmentId: "envId");
using var storage = Storage.NewStorage(config);
var exception = Assert.Throws <StorageClientException>(() =>
new FindFilter().KeyEq(NumberField.Version, 0).LimitAndOffset(10000));
Assert.IsNotNull(exception);
Assert.AreEqual("Illegal limit at filter. Expected value must be in range [1..100], but was 10000",
exception.Message);
exception = Assert.Throws <StorageClientException>(() =>
new FindFilter().KeyEq(NumberField.Version, 0).LimitAndOffset(-1));
Assert.IsNotNull(exception);
Assert.AreEqual("Illegal limit at filter. Expected value must be in range [1..100], but was -1",
exception.Message);
exception = Assert.Throws <StorageClientException>(() =>
new FindFilter().KeyEq(NumberField.Version, 0).LimitAndOffset(50, -1));
Assert.IsNotNull(exception);
Assert.AreEqual("Offset must be more than 0", exception.Message);
var filter = new FindFilter()
.KeyEq(NumberField.Version, 0);
var clientException = Assert.ThrowsAsync <StorageClientException>(() => storage.FindAsync(null, filter));
Assert.AreEqual("Country code is null", clientException.Message);
}
public void FindOneNothingFoundTest()
{
const string response = "{\n" +
" \"data\": [\n" +
" ],\n" +
" \"meta\": {\n" +
" \"count\": 0,\n" +
" \"limit\": 100,\n" +
" \"offset\": 0,\n" +
" \"total\": 0\n" +
" }\n" +
"}";
var server = new FakeHttpServer(Port, new[] { new FakeHttpServerResponse(200, response) });
server.Start();
var config = new StorageConfig(endPoint: "http://localhost:" + Port, apiKey: "apiKey",
environmentId: "envId");
using var storage = Storage.NewStorage(config);
var filter = new FindFilter()
.KeyEq(NumberField.Version, 0);
var foundedRecord = storage.FindOneAsync("country", filter).Result;
Assert.Null(foundedRecord);
server.Stop();
}
/// <summary>
/// Return the Traffic Incidents along a given route
/// </summary>
/// <param name="route">a route</param>
/// <param name="distance">a double representing the distance from the route for which
/// you want incidents reports</param>
/// <returns>FindResults</returns>
public FindResults GetTrafficIncident(Route route, Double distance)
{
FindResults foundResults;
try
{
if (route == null)
{
throw new System.ArgumentNullException("End location cannot be null");
}
FindFilter ff = new FindFilter();
ff.EntityTypeName = "TrafficIncident";
FindNearRouteSpecification spec = new FindNearRouteSpecification();
spec.DataSourceName = "MapPointTravel.TrafficIncidents";
spec.Distance = distance; //show all incidents within 1 mile of the route
spec.Route = route; //arg passed in
spec.Filter = ff;
foundResults = new FindResults();
foundResults = theMapPointFindService.FindNearRoute(spec);
}
catch (ArgumentNullException e)
{
throw e; // rethrow for app to handle
}
catch (Exception e)
{
throw e; // rethrow for app to handle
}
return(foundResults);
}
public void SearchKeysNegativeTest()
{
var exception = Assert.Throws <StorageClientException>(() =>
{
var unused = new FindFilter()
.KeyEq(StringField.Key1, "some record key")
.SearchKeysLike("some regex value");
});
Assert.AreEqual("'SearchKeys' can't be used in conjunction with regular 'Key1...Key20' lookup",
exception.Message);
exception = Assert.Throws <StorageClientException>(() =>
{
var unused = new FindFilter()
.SearchKeysLike("some regex value")
.KeyEq(StringField.Key1, "some record key");
});
Assert.AreEqual("'SearchKeys' can't be used in conjunction with regular 'Key1...Key20' lookup",
exception.Message);
exception = Assert.Throws <StorageClientException>(() =>
{
var unused = new FindFilter()
.SearchKeysLike("some regex value")
.KeyIsNull(StringField.Key1);
});
Assert.AreEqual("'SearchKeys' can't be used in conjunction with regular 'Key1...Key20' lookup",
exception.Message);
exception = Assert.Throws <StorageClientException>(() =>
{
var unused = new FindFilter()
.SearchKeysLike("some regex value")
.KeyIsNotNull(StringField.Key1);
});
Assert.AreEqual("'SearchKeys' can't be used in conjunction with regular 'Key1...Key20' lookup",
exception.Message);
exception = Assert.Throws <StorageClientException>(() =>
{
var unused = new FindFilter()
.SearchKeysLike("12");
});
Assert.AreEqual("Invalid length for filter 'SearchKeys', expected string with length [3..200]chars",
exception.Message);
exception = Assert.Throws <StorageClientException>(() =>
{
//> 200 chars
var unused = new FindFilter()
.SearchKeysLike(
"78923641892340823482348239237482342384237849-37834-2748923-17348912-378934892347839190283019283" +
"78923641892340823482348239237482342384237849-37834-2748923-17348912-378934892347839190283019283" +
"78923641892340823482348239237482342384237849-37834-2748923-17348912-378934892347839190283019283");
});
Assert.AreEqual("Invalid length for filter 'SearchKeys', expected string with length [3..200]chars",
exception.Message);
}
public void SortingNegativeTest()
{
var filter = new FindFilter().KeyEq(NumberField.RangeKey1, 1);
filter.SortBy(SortField.Key1, SortOrder.Asc);
var ex = Assert.Throws <StorageClientException>(() => filter.SortBy(SortField.Key1, SortOrder.Asc));
Assert.AreEqual("Field Key1 is already in sorting list", ex.Message);
}
public async Task FindAdvancedTest(IStorage storage)
{
Assert.NotNull(storage);
var value1 = s_iterationId + PostfixBatch1 + storage.GetHashCode();
var value2 = s_iterationId + PostfixBatch2 + storage.GetHashCode();
var filter = new FindFilter()
.KeyEq(StringField.RecordKey, value1, value2)
.SortBy(SortField.RangeKey1, SortOrder.Asc);
var findResult = await storage.FindAsync(_country, filter).ConfigureAwait(true);
Assert.NotNull(findResult);
Assert.AreEqual(2, findResult.Count);
var record1 = findResult.Records[0];
var record2 = findResult.Records[1];
Assert.IsTrue(record1.RangeKey1 <= record2.RangeKey1);
filter = new FindFilter()
.KeyEq(StringField.RecordKey, value1, value2)
.SortBy(SortField.RangeKey1, SortOrder.Desc);
findResult = await storage.FindAsync(_country, filter).ConfigureAwait(true);
Assert.NotNull(findResult);
Assert.AreEqual(2, findResult.Count);
record1 = findResult.Records[0];
record2 = findResult.Records[1];
Assert.IsTrue(record1.RangeKey1 >= record2.RangeKey1);
var value3 = s_iterationId + storage.GetHashCode();
filter = new FindFilter()
.KeyEq(StringField.RecordKey, value1, value2, value3)
.KeyIsNotNull(StringField.Key1);
findResult = await storage.FindAsync(_country, filter).ConfigureAwait(true);
Assert.NotNull(findResult);
Assert.AreEqual(1, findResult.Count);
Assert.IsNotNull(findResult.Records[0].Key1);
filter = new FindFilter()
.KeyEq(StringField.RecordKey, value1, value2, value3)
.KeyIsNull(StringField.Key1);
findResult = await storage.FindAsync(_country, filter).ConfigureAwait(true);
Assert.NotNull(findResult);
Assert.AreEqual(2, findResult.Count);
Assert.IsNull(findResult.Records[0].Key1);
Assert.IsNull(findResult.Records[1].Key1);
filter = new FindFilter()
.KeyEq(StringField.RecordKey, value1, value2, value3)
.KeyGreater(NumberField.RangeKey2, 1);
findResult = await storage.FindAsync(_country, filter).ConfigureAwait(true);
Assert.NotNull(findResult);
Assert.AreEqual(3, findResult.Count);
}
public async Task FindWithSearchKeysTest()
{
var filter = new FindFilter()
.KeyEq(StringField.RecordKey, s_iterationId + s_storage6.GetHashCode())
.SearchKeysLike((Key1 + s_iterationId).Substring(2));
var foundedRecord = await s_storage6.FindOneAsync(_country, filter).ConfigureAwait(true);
Assert.AreEqual(s_iterationId + s_storage6.GetHashCode(), foundedRecord.RecordKey);
Assert.AreEqual(Key1 + s_iterationId, foundedRecord.Key1);
}
public async Task <FindResult> FindAsync(string country, FindFilter filter)
{
s_helper.Check <StorageClientException>(filter == null, Messages.DtoTransformer.s_errNullFilter);
#pragma warning disable CA1062
var transferFindResult = await _dao.FindRecordsAsync(country?.ToLowerInvariant(),
_transformer.TransformFilter(filter))
.ConfigureAwait(false);
#pragma warning restore CA1062ƒ
return(_transformer.GetFindResult(transferFindResult));
}
public void AllFieldsFilterTest()
{
var filter = new FindFilter()
.KeyEq(StringField.RecordKey, "rec_key")
.KeyEq(StringField.ParentKey, "par_key")
.KeyEq(StringField.ProfileKey, "prof_key")
.KeyEq(StringField.ServiceKey1, "serv1_key")
.KeyEq(StringField.ServiceKey2, "serv2_key")
.KeyEq(StringField.Key1, "_key1")
.KeyEq(StringField.Key2, "_key2")
.KeyEq(StringField.Key3, "_key3")
.KeyEq(StringField.Key4, "_key4")
.KeyEq(StringField.Key5, "_key5")
.KeyEq(StringField.Key6, "_key6")
.KeyEq(StringField.Key7, "_key7")
.KeyEq(StringField.Key8, "_key8")
.KeyEq(StringField.Key9, "_key9")
.KeyEq(StringField.Key10, "_key10")
.KeyEq(StringField.Key11, "_key11")
.KeyEq(StringField.Key12, "_key12")
.KeyEq(StringField.Key13, "_key13")
.KeyEq(StringField.Key14, "_key14")
.KeyEq(StringField.Key15, "_key15")
.KeyEq(StringField.Key16, "_key16")
.KeyEq(StringField.Key17, "_key17")
.KeyEq(StringField.Key18, "_key18")
.KeyEq(StringField.Key19, "_key19")
.KeyEq(StringField.Key20, "_key20")
.KeyEq(NumberField.Version, 123)
.KeyEq(NumberField.RangeKey1, 1)
.KeyEq(NumberField.RangeKey2, 2)
.KeyEq(NumberField.RangeKey3, 3)
.KeyEq(NumberField.RangeKey4, 4)
.KeyEq(NumberField.RangeKey5, 5)
.KeyEq(NumberField.RangeKey6, 6)
.KeyEq(NumberField.RangeKey7, 7)
.KeyEq(NumberField.RangeKey8, 8)
.KeyEq(NumberField.RangeKey9, 9)
.KeyEq(NumberField.RangeKey10, 10);
using var provider = new CryptoProvider();
var transformer = new DtoTransformer(provider, new HashUtils("envId", false, Encoding.UTF8));
Assert.IsTrue(JsonEquals(JsonFilterRegular,
JsonConvert.SerializeObject(transformer.TransformFilter(filter), s_jsonSettings)));
transformer = new DtoTransformer(provider, new HashUtils("envId", true, Encoding.UTF8));
Assert.IsTrue(JsonEquals(JsonFilterNormalizeKeys,
JsonConvert.SerializeObject(transformer.TransformFilter(filter), s_jsonSettings)));
transformer = new DtoTransformer(provider, new HashUtils("envId", false, Encoding.UTF8), false);
Assert.IsTrue(JsonEquals(JsonFilterNonHashing,
JsonConvert.SerializeObject(transformer.TransformFilter(filter), s_jsonSettings)));
}
public void StringKeyNotEqTest()
{
using var provider = new CryptoProvider();
var transformer = new DtoTransformer(provider, new HashUtils("envId", false, Encoding.UTF8));
var filter = new FindFilter()
.KeyNotEq(StringField.Key1, "value1", "value2");
Assert.AreEqual(
"{\"filter\":{\"key1\":{\"$not\":[\"327c84457a2ff2c6da36314dc0ffb3216a283570a5c4654d5f51947e74742cf0\"," +
"\"04a29359b09bb94b4d6d923fc169c125b3b5253aac37c405dc5f5241535627b4\"]}}," +
"\"options\":{\"limit\":100,\"offset\":0}}",
JsonConvert.SerializeObject(transformer.TransformFilter(filter), s_jsonSettings));
}
public async Task FindOneRecordTest(IStorage storage)
{
Assert.NotNull(storage);
var filter = new FindFilter()
.KeyEq(StringField.RecordKey, s_iterationId + storage.GetHashCode())
.KeyEq(StringField.Key1, Key1 + s_iterationId)
.KeyNotEq(NumberField.Version, 100500);
var foundedRecord = await storage.FindOneAsync(_country, filter).ConfigureAwait(true);
Assert.AreEqual(s_iterationId + storage.GetHashCode(), foundedRecord.RecordKey);
Assert.AreEqual(Key1 + s_iterationId, foundedRecord.Key1);
Assert.AreNotEqual(100500, foundedRecord.Version);
}
public void KeyLessAndGreaterTest()
{
using var provider = new CryptoProvider();
var transformer = new DtoTransformer(provider, new HashUtils("envId", false, Encoding.UTF8));
var filter = new FindFilter()
.KeyGreater(NumberField.RangeKey1, 1)
.KeyGreater(NumberField.RangeKey2, 2, false)
.KeyLess(NumberField.RangeKey3, 3)
.KeyLess(NumberField.RangeKey4, 4, false);
Assert.AreEqual("{\"filter\":{\"range_key1\":{\"$gte\":1},\"range_key2\":{\"$gt\":2}," +
"\"range_key3\":{\"$lte\":3},\"range_key4\":{\"$lt\":4}}," +
"\"options\":{\"limit\":100,\"offset\":0}}",
JsonConvert.SerializeObject(transformer.TransformFilter(filter), s_jsonSettings));
}
public async Task <Record> FindOneAsync(string country, FindFilter filter)
{
var batch = await FindAsync(country, filter?.LimitAndOffset(1))
.ConfigureAwait(false);
var records = batch.Records;
if (records.Count != 0)
{
return(records[0]);
}
s_log.Warn(Messages.Storage.s_warnNothingWasFound);
return(null);
}
public void KeyBetweenTest()
{
using var provider = new CryptoProvider();
var transformer = new DtoTransformer(provider, new HashUtils("envId", false, Encoding.UTF8));
var filter = new FindFilter()
.KeyBetween(NumberField.RangeKey1, 1L, 2L)
.KeyBetween(NumberField.RangeKey2, 3L, 4L, true, false)
.KeyBetween(NumberField.RangeKey3, 5L, 6L, false, false)
.KeyBetween(NumberField.RangeKey4, 7L, 8L, false);
Assert.AreEqual(
"{\"filter\":{\"range_key1\":{\"$gte\":1,\"$lte\":2},\"range_key2\":{\"$gte\":3,\"$lt\":4}," +
"\"range_key3\":{\"$gt\":5,\"$lt\":6},\"range_key4\":{\"$gt\":7,\"$lte\":8}}," +
"\"options\":{\"limit\":100,\"offset\":0}}",
JsonConvert.SerializeObject(transformer.TransformFilter(filter), s_jsonSettings));
}
public void SearchKeysTest()
{
using var provider = new CryptoProvider();
var transformer = new DtoTransformer(provider, new HashUtils("envId", false, Encoding.UTF8));
var filter = new FindFilter()
.KeyEq(StringField.RecordKey, "some record key")
.SearchKeysLike("some regex value")
.KeyEq(NumberField.RangeKey1, 1)
.KeyNotEq(StringField.ProfileKey, "some profile key");
Assert.IsTrue(JsonEquals(
"{\"filter\":{\"record_key\":[\"2ab632ee5ebf3af90be1ae6accea46d99843fdc4676bb29a376919fa9c530364\"]," +
"\"profile_key\":{\"$not\":[\"3075bffaf3d67f04c2ab25a53ae970d25350bf7abe63f977aeaa29366baf38fa\"]}," +
"\"range_key1\":[1]," +
"\"search_keys\":\"some regex value\"}," +
"\"options\":{\"limit\":100,\"offset\":0}}",
JsonConvert.SerializeObject(transformer.TransformFilter(filter), s_jsonSettings)));
}
public void SortingTest()
{
var filter1 = new FindFilter().KeyEq(NumberField.RangeKey1, 1);
var filter2 = new FindFilter().KeyEq(NumberField.RangeKey1, 2);
foreach (var field in Enum.GetValues(typeof(SortField)).Cast <SortField>())
{
filter1.SortBy(field, SortOrder.Asc);
filter2.SortBy(field, SortOrder.Desc);
}
using var provider = new CryptoProvider();
var transformer = new DtoTransformer(provider, new HashUtils("envId", false, Encoding.UTF8));
Assert.IsTrue(JsonEquals(JsonFilterSortingAsc,
JsonConvert.SerializeObject(transformer.TransformFilter(filter1), s_jsonSettings)));
Assert.IsTrue(JsonEquals(JsonFilterSortingDesc,
JsonConvert.SerializeObject(transformer.TransformFilter(filter2), s_jsonSettings)));
}
public void FindOneTestPositiveTest()
{
var server = new FakeHttpServer(Port, new[] { new FakeHttpServerResponse(200, FindResponse) });
server.Start();
var config = new StorageConfig(endPoint: "http://localhost:" + Port, apiKey: "apiKey",
environmentId: "envId");
using var storage = Storage.NewStorage(config);
const string recordKey = "456";
const string body = "body2";
var filter = new FindFilter()
.KeyEq(NumberField.Version, 0);
var foundedRecord = storage.FindOneAsync("country", filter).Result;
Assert.NotNull(foundedRecord);
Assert.AreEqual(body, foundedRecord.Body);
Assert.AreEqual(recordKey, foundedRecord.RecordKey);
server.Stop();
}
public List <FilmViewModel> Find(FindFilter filter, FilmDataServiceClient client)
{
var filmsByDir = client.FindFilmByDirector(filter.DirectorId).Where(x => x.Rate >= filter.Rate).Where(x => x.Year >= filter.Year).ToList();
if (filter.GenreId <= 0)
{
return(filmsByDir.Select(y => FilmDataMapper.getFilmViewModel(y)).ToList());
}
var filmsByGenre = client.FindFilmByGenre(filter.GenreId).Where(x => x.Rate >= filter.Rate).Where(x => x.Year >= filter.Year).ToList();
if (filter.DirectorId <= 0)
{
return(filmsByGenre.Select(y => FilmDataMapper.getFilmViewModel(y)).ToList());
}
List <FilmViewModel> films = filmsByDir.Where(x => filmsByGenre.Any(a => a.Id == x.Id)).Select(y => FilmDataMapper.getFilmViewModel(y)).ToList();
return(films);
}
public TransferFilterContainer TransformFilter(FindFilter filter)
{
var transformedFilters = new Dictionary<string, object>();
#pragma warning disable CA1062
foreach (var entry in filter.NumberFilters)
#pragma warning restore CA1062
{
transformedFilters[_enumMapping[entry.Key]] = entry.Value.ToTransferObject();
}
foreach (var entry in filter.StringFilters)
{
var oneFilter = entry.Value;
if (oneFilter is StringFilter stringFilter)
{
var needHash = _hashSearchKeys || !FindFilter.NonHashedKeyList.Contains(entry.Key);
var hashedValues = stringFilter.Values
.Select(stringFilterValue =>
TransformSearchKey(stringFilterValue, needHash, false))
.ToList();
transformedFilters[_enumMapping[entry.Key]] =
new StringFilter(hashedValues, stringFilter.NotCondition).ToTransferObject();
}
else
{
transformedFilters[_enumMapping[entry.Key]] = oneFilter.ToTransferObject();
}
}
if (filter.SearchKeys != null)
{
transformedFilters[SearchKeys] = filter.SearchKeys;
}
s_helper.Check<StorageClientException>(transformedFilters.Count == 0,
Messages.DtoTransformer.s_errNullFilter);
var sorting = filter.SortingList;
#pragma warning disable CA1308
var transferSorting = sorting.Select(param =>
new Dictionary<string, string> { [_enumMapping[param.Field]] = param.Order.ToString().ToLowerInvariant() }).ToList();
#pragma warning restore CA1308
return new TransferFilterContainer(transformedFilters, filter.Limit, filter.Offset, transferSorting);
}
public void FindNegativeTest()
{
var server =
new FakeHttpServer(Port, new[] { new FakeHttpServerResponse(400, "Some error was happened") });
server.Start();
var config = new StorageConfig(endPoint: "http://localhost:" + Port, apiKey: "apiKey",
environmentId: "envId");
using var storage = Storage.NewStorage(config);
var filter = new FindFilter()
.KeyEq(NumberField.Version, 0);
var exception = Assert.ThrowsAsync <StorageServerException>(() => storage.FindAsync("country", filter));
Assert.IsNotNull(exception);
Assert.IsTrue(exception.Message.Contains(
"Unexpected response: StatusCode: 400, ReasonPhrase: 'Bad Request'",
StringComparison.InvariantCulture));
Assert.IsTrue(exception.Message.Contains("Some error was happened", StringComparison.InvariantCulture));
server.Stop();
}
public async Task <MigrateResult> MigrateAsync(string country, int limit)
{
long?currentVersion = _transformer.SecretKeyAccessor?.Invoke().CurrentSecret.Version;
var notSupported = _transformer.SecretKeyAccessor == null || currentVersion == null;
s_helper.Check <StorageClientException>(notSupported, Messages.Storage.s_errMigrationNotSupported);
s_helper.Check <StorageClientException>(limit < 1, Messages.Storage.s_errWrongMigrationLimit);
var filter = new FindFilter()
.LimitAndOffset(limit)
.KeyNotEq(NumberField.Version, currentVersion.Value);
var findResult = await FindAsync(country, filter).ConfigureAwait(false);
var validRecordCount = findResult.Records.Count;
if (validRecordCount > 0)
{
await BatchWriteAsync(country, findResult.Records).ConfigureAwait(false);
}
return(new MigrateResult(validRecordCount, findResult.Total - validRecordCount, findResult.Errors));
}
public void ClearTest()
{
var filter = new FindFilter()
.KeyEq(StringField.Key1, "1st key")
.KeyEq(NumberField.Version, 3)
.LimitAndOffset(50, 10);
Assert.AreEqual(50, filter.Limit);
Assert.AreEqual(10, filter.Offset);
Assert.AreEqual(StringField.Key1, filter.StringFilters.Keys.First());
Assert.AreEqual("1st key", ((StringFilter)filter.StringFilters.Values.First()).Values[0]);
Assert.AreEqual(NumberField.Version, filter.NumberFilters.Keys.First());
Assert.AreEqual(3, ((NumberFilter)filter.NumberFilters.Values.First()).Values[0]);
filter.Clear();
Assert.AreEqual(100, filter.Limit);
Assert.AreEqual(0, filter.Offset);
Assert.IsEmpty(filter.StringFilters);
Assert.IsEmpty(filter.NumberFilters);
Assert.AreEqual("{\"filter\":{},\"options\":{\"limit\":0,\"offset\":0}}",
JsonConvert.SerializeObject(new TransferFilterContainer(new Dictionary <string, object>(), 0, 0, null),
s_jsonSettings));
}
