public void PASS_CreateFilter()
{
RegexFilter filter = new RegexFilter("field", "pattern");
Assert.IsNotNull(filter);
Assert.AreEqual("field", filter.Field);
Assert.AreEqual("pattern", filter.Pattern);
}
public void PASS_Serialize()
{
RegexFilter filter = new RegexFilter("field", "pattern");
string json = JsonConvert.SerializeObject(filter);
Assert.IsNotNull(json);
string expectedJson = "{\"regexp\":{\"field\":\"pattern\"}}";
Assert.AreEqual(expectedJson, json);
}
public void FAIL_CreateFilter_Pattern()
{
try
{
RegexFilter filter = new RegexFilter("field", null);
Assert.Fail();
}
catch (ArgumentNullException ex)
{
Assert.AreEqual("pattern", ex.ParamName);
}
}
public void PASS_Serialize_Flags()
{
RegexFilter filter = new RegexFilter("field", "pattern")
{
RegexOperatorFlags = new List<RegexOperatorEnum>()
{
RegexOperatorEnum.AnyString,
RegexOperatorEnum.Automaton
}
};
string json = JsonConvert.SerializeObject(filter);
Assert.IsNotNull(json);
string expectedJson = "{\"regexp\":{\"field\":{\"value\":\"pattern\",\"flags\":\"ANYSTRING|AUTOMATON\"}}}";
Assert.AreEqual(expectedJson, json);
}
public void PASS_Serialize_CacheName()
{
RegexFilter filter = new RegexFilter("field", "pattern")
{
CacheName = "name",
Cache = true,
CacheKey = "key"
};
string json = JsonConvert.SerializeObject(filter);
Assert.IsNotNull(json);
string expectedJson = "{\"regexp\":{\"field\":\"pattern\",\"_name\":\"name\",\"_cache\":true,\"_cache_key\":\"key\"}}";
Assert.AreEqual(expectedJson, json);
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
Dictionary<string, object> fieldDict = serializer.Deserialize<Dictionary<string, object>>(reader);
if (fieldDict.ContainsKey(FilterTypeEnum.Regex.ToString()))
fieldDict = JsonConvert.DeserializeObject<Dictionary<string, object>>(fieldDict.First().Value.ToString());
// find the field name
KeyValuePair<string, object> fieldKvp = fieldDict.FirstOrDefault(x => !_KnownFields.Contains(x.Key, StringComparer.OrdinalIgnoreCase));
if (string.IsNullOrWhiteSpace(fieldKvp.Key))
throw new RequiredPropertyMissingException("field");
Dictionary<string, object> internalDict = null;
string field = null;
string pattern = null;
try
{
internalDict = JsonConvert.DeserializeObject<Dictionary<string, object>>(fieldKvp.Value.ToString());
}
catch
{
internalDict = fieldDict;
}
RegexFilter filter = null;
if (internalDict.ContainsKey(_PATTERN))
{
field = fieldDict.First().Key;
pattern = internalDict.GetString(_PATTERN);
filter = new RegexFilter(field, pattern);
if (internalDict.ContainsKey(_FLAGS))
{
string flagsValue = internalDict.GetString(_FLAGS);
if (!string.IsNullOrWhiteSpace(flagsValue))
{
RegexOperatorEnum feature = RegexOperatorEnum.All;
List<RegexOperatorEnum> features = new List<RegexOperatorEnum>();
foreach (string flagValue in flagsValue.Split(_FLAG_DELIMITERS.ToArray(), StringSplitOptions.RemoveEmptyEntries))
{
feature = RegexOperatorEnum.Find(flagValue);
if (feature == null)
throw new Exception("Unable to match " + flagValue + " to a regex operator.");
features.Add(feature);
}
if (features.Any())
filter.RegexOperatorFlags = features;
}
}
}
else
{
field = fieldKvp.Key;
pattern = fieldKvp.Value.ToString();
filter = new RegexFilter(field, pattern);
}
FilterSerializer.DeserializeBaseValues(filter, _CACHE_DEFAULT, internalDict);
filter.CacheName = internalDict.GetStringOrDefault(_CACHE_NAME);
return filter;
}
