private void InitializeRequestFilter(IRequestFilter requestFilter)
{
var factory = new RuleFactory();
foreach (var item in appSettings.AllowedUrlRegexps)
{
var rule = factory.CreateRule(FilterRuleType.Regex);
rule.Initialize(new FilterRuleSettings {
Expression = item, Result = FilterResult.Allow
});
requestFilter.Load(rule);
}
foreach (var item in appSettings.AllowedUrls)
{
var rule = factory.CreateRule(FilterRuleType.Simplified);
rule.Initialize(new FilterRuleSettings {
Expression = item, Result = FilterResult.Allow
});
requestFilter.Load(rule);
}
if (requestFilter.Process(new Request {
Url = startUrl
}) != FilterResult.Allow)
{
var rule = factory.CreateRule(FilterRuleType.Simplified);
rule.Initialize(new FilterRuleSettings {
Expression = startUrl, Result = FilterResult.Allow
});
requestFilter.Load(rule);
logger.Debug($"Automatically created filter rule to allow start URL '{startUrl}'.");
}
}
private void InitializeRequestFilter(IRequestFilter requestFilter)
{
if (settings.Filter.ProcessContentRequests || settings.Filter.ProcessMainRequests)
{
var factory = new RuleFactory();
foreach (var settings in settings.Filter.Rules)
{
var rule = factory.CreateRule(settings.Type);
rule.Initialize(settings);
requestFilter.Load(rule);
}
logger.Debug($"Initialized request filter with {settings.Filter.Rules.Count} rule(s).");
if (requestFilter.Process(new Request {
Url = settings.StartUrl
}) != FilterResult.Allow)
{
var rule = factory.CreateRule(FilterRuleType.Simplified);
rule.Initialize(new FilterRuleSettings {
Expression = settings.StartUrl, Result = FilterResult.Allow
});
requestFilter.Load(rule);
logger.Debug($"Automatically created filter rule to allow start URL{(WindowSettings.UrlPolicy.CanLog() ? $" '{settings.StartUrl}'" : "")}.");
}
}
}
private void InitializeControl()
{
var contextMenuHandler = new ContextMenuHandler();
var displayHandler = new DisplayHandler();
var downloadLogger = logger.CloneFor($"{nameof(DownloadHandler)} {Id}");
var downloadHandler = new DownloadHandler(appConfig, settings, downloadLogger);
var keyboardHandler = new KeyboardHandler();
var lifeSpanHandler = new LifeSpanHandler();
var requestFilter = new RequestFilter();
var requestLogger = logger.CloneFor($"{nameof(RequestHandler)} {Id}");
var requestHandler = new RequestHandler(appConfig, settings.Filter, requestFilter, requestLogger, text);
displayHandler.FaviconChanged += DisplayHandler_FaviconChanged;
displayHandler.ProgressChanged += DisplayHandler_ProgressChanged;
downloadHandler.ConfigurationDownloadRequested += DownloadHandler_ConfigurationDownloadRequested;
keyboardHandler.ReloadRequested += ReloadRequested;
keyboardHandler.ZoomInRequested += ZoomInRequested;
keyboardHandler.ZoomOutRequested += ZoomOutRequested;
keyboardHandler.ZoomResetRequested += ZoomResetRequested;
lifeSpanHandler.PopupRequested += LifeSpanHandler_PopupRequested;
requestHandler.RequestBlocked += RequestHandler_RequestBlocked;
if (settings.Filter.ProcessContentRequests || settings.Filter.ProcessMainRequests)
{
var factory = new RuleFactory();
foreach (var settings in settings.Filter.Rules)
{
var rule = factory.CreateRule(settings.Type);
rule.Initialize(settings);
requestFilter.Load(rule);
}
logger.Debug($"Initialized request filter with {settings.Filter.Rules.Count} rule(s).");
}
control = new BrowserControl(contextMenuHandler, displayHandler, downloadHandler, keyboardHandler, lifeSpanHandler, requestHandler, url);
control.AddressChanged += Control_AddressChanged;
control.LoadingStateChanged += Control_LoadingStateChanged;
control.TitleChanged += Control_TitleChanged;
control.Initialize();
logger.Debug("Initialized browser control.");
}
/// <summary>
/// Main entry-point for this application.
/// </summary>
static void Main()
{
// Create a SettingsHelper instance by calling SettingsHelper
// .NewConfiguration, as you see here, for each plug-in, if that
// is the scenario you are working on, or for each application,
// where you want to log data. It will help to make sure that
// changes to the configuration in one plug-in don't interfere
// with another NLog configuration for another plug-in.
var newConfiguration = SettingsHelper.NewConfiguration("NLogConfigTest",
"YoderZone");
// You will need to create at least one target and one rule. The factory
// classes in NLogConfig can help with both.
var fileTarget = FileTargetFactory.CreateFileTarget("TestLog",
"Test${shortdate}.log", newConfiguration);
// The loggerNamePattern in CreateRule must match the name of the
// Logger that will save messages for this rule. Usually the logger will
// be named the same as the class it has been created in. In this test
// for example the name of the Logger is "YoderZone.NLogConfig.Text.Program."
// You can give it any name you wish, but remember to configure a pattern
// to match its name in the rule.
var loggingRule = RuleFactory.CreateRule("YoderZone.NLogConfig.Test.*",
fileTarget);
// The targets and rules need to be added to the SettingsHelper
// instance created with the NewConfiguration command. Set the
// deferUpdate parameter to true for all additions until the last one.
// When the last addition occurs, the SettingsHelper instance will
// update NLog so it knows about the new settings.
newConfiguration.AddTarget(fileTarget, true);
newConfiguration.AddRule("TestLog", loggingRule);
// Then use the Logger in the class as you would normally by
// calling its methods so send logging messages.
logger.Debug("Debug");
logger.Error("Error");
logger.Info("Info");
}
public void SelectRuleType(int type)
{
rule = RuleFactory.CreateRule(type);
}
public void MustCreateCorrectRules()
{
Assert.IsInstanceOfType(sut.CreateRule(FilterRuleType.Regex), typeof(RegexRule));
Assert.IsInstanceOfType(sut.CreateRule(FilterRuleType.Simplified), typeof(SimplifiedRule));
}
public void CreateRule_GivenRuleDataModelWithComposedNodeAndChildNodesOfEachDataType_ReturnsRuleInstance()
{
// Arrange
dynamic content = new ExpandoObject();
content.Prop1 = 123;
content.Prop2 = "Sample string";
content.Prop3 = 500.34m;
ValueConditionNodeDataModel integerConditionNodeDataModel = new ValueConditionNodeDataModel
{
ConditionType = "SampleIntegerCondition",
DataType = DataTypes.Integer,
LogicalOperator = LogicalOperators.Eval,
Operand = 20,
Operator = Operators.GreaterThan
};
ValueConditionNodeDataModel stringConditionNodeDataModel = new ValueConditionNodeDataModel
{
ConditionType = "SampleStringCondition",
DataType = DataTypes.String,
LogicalOperator = LogicalOperators.Eval,
Operand = "TEST",
Operator = Operators.Equal
};
ValueConditionNodeDataModel decimalConditionNodeDataModel = new ValueConditionNodeDataModel
{
ConditionType = "SampleDecimalCondition",
DataType = DataTypes.Decimal,
LogicalOperator = LogicalOperators.Eval,
Operand = 50.3m,
Operator = Operators.LesserThanOrEqual
};
ValueConditionNodeDataModel booleanConditionNodeDataModel = new ValueConditionNodeDataModel
{
ConditionType = "SampleBooleanCondition",
DataType = DataTypes.Boolean,
LogicalOperator = LogicalOperators.Eval,
Operand = true,
Operator = Operators.NotEqual
};
RuleDataModel ruleDataModel = new RuleDataModel
{
Content = content,
ContentType = "ContentTypeSample",
DateBegin = new System.DateTime(2020, 1, 1),
DateEnd = null,
Id = ObjectId.GenerateNewId(),
Name = "My rule used for testing purposes",
Priority = 1,
RootCondition = new ComposedConditionNodeDataModel
{
LogicalOperator = LogicalOperators.And,
ChildConditionNodes = new ConditionNodeDataModel[]
{
integerConditionNodeDataModel,
stringConditionNodeDataModel,
decimalConditionNodeDataModel,
booleanConditionNodeDataModel
}
}
};
IContentSerializationProvider <ContentType> contentSerializationProvider = Mock.Of <IContentSerializationProvider <ContentType> >();
RuleFactory <ContentType, ConditionType> ruleFactory = new RuleFactory <ContentType, ConditionType>(contentSerializationProvider);
// Act
Rule <ContentType, ConditionType> rule = ruleFactory.CreateRule(ruleDataModel);
// Assert
rule.Should().NotBeNull();
rule.ContentContainer.Should().NotBeNull()
.And.BeOfType <SerializedContentContainer <ContentType> >();
rule.DateBegin.Should().Be(ruleDataModel.DateBegin);
rule.DateEnd.Should().BeNull();
rule.Name.Should().Be(ruleDataModel.Name);
rule.Priority.Should().Be(ruleDataModel.Priority);
rule.RootCondition.Should().BeOfType <ComposedConditionNode <ConditionType> >();
ComposedConditionNode <ConditionType> composedConditionNode = rule.RootCondition.As <ComposedConditionNode <ConditionType> >();
composedConditionNode.LogicalOperator.Should().Be(LogicalOperators.And);
composedConditionNode.ChildConditionNodes.Should().HaveCount(4);
IEnumerable <IntegerConditionNode <ConditionType> > integerConditionNodes = composedConditionNode.ChildConditionNodes.OfType <IntegerConditionNode <ConditionType> >();
integerConditionNodes.Should().HaveCount(1);
IntegerConditionNode <ConditionType> integerConditionNode = integerConditionNodes.First();
integerConditionNode.Should().NotBeNull();
integerConditionNode.ConditionType.Should().Match <ConditionType>(x => x == Enum.Parse <ConditionType>(integerConditionNodeDataModel.ConditionType));
integerConditionNode.DataType.Should().Be(integerConditionNodeDataModel.DataType);
integerConditionNode.LogicalOperator.Should().Be(integerConditionNodeDataModel.LogicalOperator);
integerConditionNode.Operand.Should().Match(x => object.Equals(x, integerConditionNodeDataModel.Operand));
integerConditionNode.Operator.Should().Be(integerConditionNodeDataModel.Operator);
IEnumerable <StringConditionNode <ConditionType> > stringConditionNodes = composedConditionNode.ChildConditionNodes.OfType <StringConditionNode <ConditionType> >();
stringConditionNodes.Should().HaveCount(1);
StringConditionNode <ConditionType> stringConditionNode = stringConditionNodes.First();
stringConditionNode.Should().NotBeNull();
stringConditionNode.ConditionType.Should().Match <ConditionType>(x => x == Enum.Parse <ConditionType>(stringConditionNodeDataModel.ConditionType));
stringConditionNode.DataType.Should().Be(stringConditionNodeDataModel.DataType);
stringConditionNode.LogicalOperator.Should().Be(stringConditionNodeDataModel.LogicalOperator);
stringConditionNode.Operand.Should().Match(x => object.Equals(x, stringConditionNodeDataModel.Operand));
stringConditionNode.Operator.Should().Be(stringConditionNodeDataModel.Operator);
IEnumerable <DecimalConditionNode <ConditionType> > decimalConditionNodes = composedConditionNode.ChildConditionNodes.OfType <DecimalConditionNode <ConditionType> >();
decimalConditionNodes.Should().HaveCount(1);
DecimalConditionNode <ConditionType> decimalConditionNode = decimalConditionNodes.First();
decimalConditionNode.Should().NotBeNull();
decimalConditionNode.ConditionType.Should().Match <ConditionType>(x => x == Enum.Parse <ConditionType>(decimalConditionNodeDataModel.ConditionType));
decimalConditionNode.DataType.Should().Be(decimalConditionNodeDataModel.DataType);
decimalConditionNode.LogicalOperator.Should().Be(decimalConditionNodeDataModel.LogicalOperator);
decimalConditionNode.Operand.Should().Match(x => object.Equals(x, decimalConditionNodeDataModel.Operand));
decimalConditionNode.Operator.Should().Be(decimalConditionNodeDataModel.Operator);
IEnumerable <BooleanConditionNode <ConditionType> > booleanConditionNodes = composedConditionNode.ChildConditionNodes.OfType <BooleanConditionNode <ConditionType> >();
booleanConditionNodes.Should().HaveCount(1);
BooleanConditionNode <ConditionType> booleanConditionNode = booleanConditionNodes.First();
booleanConditionNode.Should().NotBeNull();
booleanConditionNode.ConditionType.Should().Match <ConditionType>(x => x == Enum.Parse <ConditionType>(booleanConditionNodeDataModel.ConditionType));
booleanConditionNode.DataType.Should().Be(booleanConditionNodeDataModel.DataType);
booleanConditionNode.LogicalOperator.Should().Be(booleanConditionNodeDataModel.LogicalOperator);
booleanConditionNode.Operand.Should().Be(Convert.ToBoolean(booleanConditionNodeDataModel.Operand));
booleanConditionNode.Operator.Should().Be(booleanConditionNodeDataModel.Operator);
}
public void CreateRule_GivenRuleWithComposedNodeAndChildNodesOfEachDataType_ReturnsRuleDataModelInstance()
{
// Arrange
dynamic content = new ExpandoObject();
content.Prop1 = 123;
content.Prop2 = "Sample string";
content.Prop3 = 500.34m;
IContentSerializer contentSerializer = Mock.Of <IContentSerializer>();
Mock.Get(contentSerializer)
.Setup(x => x.Deserialize(It.IsAny <object>(), It.IsAny <Type>()))
.Returns((object)content);
IContentSerializationProvider <ContentType> contentSerializationProvider = Mock.Of <IContentSerializationProvider <ContentType> >();
Mock.Get(contentSerializationProvider)
.Setup(x => x.GetContentSerializer(ContentType.ContentTypeSample))
.Returns(contentSerializer);
BooleanConditionNode <ConditionType> booleanConditionNode = null;
DecimalConditionNode <ConditionType> decimalConditionNode = null;
IntegerConditionNode <ConditionType> integerConditionNode = null;
StringConditionNode <ConditionType> stringConditionNode = null;
Rule <ContentType, ConditionType> rule1 = RuleBuilder.NewRule <ContentType, ConditionType>()
.WithName("My rule used for testing purposes")
.WithDateBegin(new DateTime(2020, 1, 1))
.WithPriority(1)
.WithSerializedContent(ContentType.ContentTypeSample, (object)content, contentSerializationProvider)
.WithCondition(cnb => cnb.AsComposed()
.WithLogicalOperator(LogicalOperators.And)
.AddCondition(cnb1 => booleanConditionNode = cnb1.AsValued(ConditionType.SampleBooleanCondition)
.OfDataType <bool>()
.WithComparisonOperator(Operators.NotEqual)
.SetOperand(true)
.Build() as BooleanConditionNode <ConditionType>)
.AddCondition(cnb1 => decimalConditionNode = cnb1.AsValued(ConditionType.SampleDecimalCondition)
.OfDataType <decimal>()
.WithComparisonOperator(Operators.LesserThanOrEqual)
.SetOperand(50.3m)
.Build() as DecimalConditionNode <ConditionType>)
.AddCondition(cnb1 => integerConditionNode = cnb1.AsValued(ConditionType.SampleIntegerCondition)
.OfDataType <int>()
.WithComparisonOperator(Operators.GreaterThan)
.SetOperand(20)
.Build() as IntegerConditionNode <ConditionType>)
.AddCondition(cnb1 => stringConditionNode = cnb1.AsValued(ConditionType.SampleStringCondition)
.OfDataType <string>()
.WithComparisonOperator(Operators.Equal)
.SetOperand("TEST")
.Build() as StringConditionNode <ConditionType>)
.Build())
.Build().Rule;
RuleFactory <ContentType, ConditionType> ruleFactory = new RuleFactory <ContentType, ConditionType>(contentSerializationProvider);
// Act
RuleDataModel rule = ruleFactory.CreateRule(rule1);
// Assert
rule.Should().NotBeNull();
object content1 = rule.Content;
content1.Should().NotBeNull()
.And.BeSameAs(content);
rule.DateBegin.Should().Be(rule.DateBegin);
rule.DateEnd.Should().BeNull();
rule.Name.Should().Be(rule.Name);
rule.Priority.Should().Be(rule.Priority);
rule.RootCondition.Should().BeOfType <ComposedConditionNodeDataModel>();
ComposedConditionNodeDataModel composedConditionNodeDataModel = rule.RootCondition.As <ComposedConditionNodeDataModel>();
composedConditionNodeDataModel.LogicalOperator.Should().Be(LogicalOperators.And);
composedConditionNodeDataModel.ChildConditionNodes.Should().HaveCount(4);
IEnumerable <ValueConditionNodeDataModel> valueConditionNodeDataModels = composedConditionNodeDataModel.ChildConditionNodes.OfType <ValueConditionNodeDataModel>();
valueConditionNodeDataModels.Should().HaveCount(4);
ValueConditionNodeDataModel integerConditionNodeDataModel = valueConditionNodeDataModels.First(v => v.DataType == DataTypes.Integer);
integerConditionNodeDataModel.Should().NotBeNull();
integerConditionNodeDataModel.ConditionType.Should().Match <string>(x => integerConditionNode.ConditionType == Enum.Parse <ConditionType>(x));
integerConditionNodeDataModel.DataType.Should().Be(integerConditionNode.DataType);
integerConditionNodeDataModel.LogicalOperator.Should().Be(integerConditionNode.LogicalOperator);
integerConditionNodeDataModel.Operand.Should().Match(x => object.Equals(x, integerConditionNode.Operand));
integerConditionNodeDataModel.Operator.Should().Be(integerConditionNode.Operator);
ValueConditionNodeDataModel stringConditionNodeDataModel = valueConditionNodeDataModels.First(v => v.DataType == DataTypes.String);
stringConditionNodeDataModel.Should().NotBeNull();
stringConditionNodeDataModel.ConditionType.Should().Match <string>(x => stringConditionNode.ConditionType == Enum.Parse <ConditionType>(x));
stringConditionNodeDataModel.DataType.Should().Be(stringConditionNode.DataType);
stringConditionNodeDataModel.LogicalOperator.Should().Be(stringConditionNode.LogicalOperator);
stringConditionNodeDataModel.Operand.Should().Match(x => object.Equals(x, stringConditionNode.Operand));
stringConditionNodeDataModel.Operator.Should().Be(stringConditionNode.Operator);
ValueConditionNodeDataModel decimalConditionNodeDataModel = valueConditionNodeDataModels.First(v => v.DataType == DataTypes.Decimal);
decimalConditionNodeDataModel.Should().NotBeNull();
decimalConditionNodeDataModel.ConditionType.Should().Match <string>(x => decimalConditionNode.ConditionType == Enum.Parse <ConditionType>(x));
decimalConditionNodeDataModel.DataType.Should().Be(decimalConditionNode.DataType);
decimalConditionNodeDataModel.LogicalOperator.Should().Be(decimalConditionNode.LogicalOperator);
decimalConditionNodeDataModel.Operand.Should().Match(x => object.Equals(x, decimalConditionNode.Operand));
decimalConditionNodeDataModel.Operator.Should().Be(decimalConditionNode.Operator);
ValueConditionNodeDataModel booleanConditionNodeDataModel = valueConditionNodeDataModels.First(v => v.DataType == DataTypes.Boolean);
booleanConditionNodeDataModel.Should().NotBeNull();
booleanConditionNodeDataModel.ConditionType.Should().Match <string>(x => booleanConditionNode.ConditionType == Enum.Parse <ConditionType>(x));
booleanConditionNodeDataModel.DataType.Should().Be(booleanConditionNode.DataType);
booleanConditionNodeDataModel.LogicalOperator.Should().Be(booleanConditionNode.LogicalOperator);
booleanConditionNodeDataModel.Operand.Should().Be(Convert.ToBoolean(booleanConditionNode.Operand));
booleanConditionNodeDataModel.Operator.Should().Be(booleanConditionNode.Operator);
}
public void CreateRule_GivenNullRuleDataModel_ThrowsArgumentNullException()
{
// Arrange
RuleDataModel ruleDataModel = null;
IContentSerializationProvider <ContentType> contentSerializationProvider = Mock.Of <IContentSerializationProvider <ContentType> >();
RuleFactory <ContentType, ConditionType> ruleFactory = new RuleFactory <ContentType, ConditionType>(contentSerializationProvider);
// Act
ArgumentNullException argumentNullException = Assert.Throws <ArgumentNullException>(() => ruleFactory.CreateRule(ruleDataModel));
// Assert
argumentNullException.Should().NotBeNull();
argumentNullException.ParamName.Should().Be(nameof(ruleDataModel));
}
public void CreateRule_GivenNullRule_ThrowsArgumentNullException()
{
// Arrange
Rule <ContentType, ConditionType> rule = null;
RuleFactory <ContentType, ConditionType> ruleFactory = new RuleFactory <ContentType, ConditionType>();
// Act
ArgumentNullException argumentNullException = Assert.Throws <ArgumentNullException>(() => ruleFactory.CreateRule(rule));
// Assert
argumentNullException.Should().NotBeNull();
argumentNullException.ParamName.Should().Be(nameof(rule));
}
public void CreateRule_GivenInvalidRuleName_ThrowsInvalidRuleException()
{
// Arrange
dynamic content = new ExpandoObject();
content.Prop1 = 123;
content.Prop2 = "Sample string";
content.Prop3 = 500.34m;
RuleDataModel <ContentType, ConditionType> ruleDataModel = new RuleDataModel <ContentType, ConditionType>
{
Content = content,
ContentType = ContentType.ContentTypeSample,
DateBegin = new DateTime(2020, 1, 1),
DateEnd = null,
Name = null,
Priority = 1,
RootCondition = null
};
RuleFactory <ContentType, ConditionType> ruleFactory = new RuleFactory <ContentType, ConditionType>();
// Act
InvalidRuleException invalidRuleException = Assert.Throws <InvalidRuleException>(() => ruleFactory.CreateRule(ruleDataModel));
// Assert
invalidRuleException.Should().NotBeNull();
invalidRuleException.Errors.Should().NotBeEmpty();
invalidRuleException.Errors.Should().Contain("'Name' must not be empty.");
}
