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)); }