Joseph Doherty
445 lines
15 KiB
C#
445 lines
15 KiB
C#
using ZB.MOM.WW.ScadaBridge.Commons.Types.Flattening;
|
|
using ZB.MOM.WW.ScadaBridge.TemplateEngine.Validation;
|
|
|
|
namespace ZB.MOM.WW.ScadaBridge.TemplateEngine.Tests.Validation;
|
|
|
|
public class SemanticValidatorTests
|
|
{
|
|
private readonly SemanticValidator _sut = new();
|
|
|
|
[Fact]
|
|
public void Validate_NativeAlarmSource_UnknownConnection_ReturnsError()
|
|
{
|
|
var cfg = new FlattenedConfiguration
|
|
{
|
|
InstanceUniqueName = "Instance1",
|
|
NativeAlarmSources = [new ResolvedNativeAlarmSource { CanonicalName = "P", ConnectionName = "Ghost", SourceReference = "x" }]
|
|
};
|
|
var result = _sut.Validate(cfg, alarmCapableConnectionNames: new HashSet<string> { "RealConn" });
|
|
Assert.Contains(result.Errors, e => e.Category == ValidationCategory.NativeAlarmSourceInvalid);
|
|
}
|
|
|
|
[Fact]
|
|
public void Validate_NativeAlarmSource_EmptySourceRef_ReturnsError()
|
|
{
|
|
var cfg = new FlattenedConfiguration
|
|
{
|
|
InstanceUniqueName = "Instance1",
|
|
NativeAlarmSources = [new ResolvedNativeAlarmSource { CanonicalName = "P", ConnectionName = "RealConn", SourceReference = "" }]
|
|
};
|
|
var result = _sut.Validate(cfg, alarmCapableConnectionNames: new HashSet<string> { "RealConn" });
|
|
Assert.Contains(result.Errors, e => e.Category == ValidationCategory.NativeAlarmSourceInvalid);
|
|
}
|
|
|
|
[Fact]
|
|
public void Validate_NativeAlarmSource_ValidBinding_NoError()
|
|
{
|
|
var cfg = new FlattenedConfiguration
|
|
{
|
|
InstanceUniqueName = "Instance1",
|
|
NativeAlarmSources = [new ResolvedNativeAlarmSource { CanonicalName = "P", ConnectionName = "RealConn", SourceReference = "ns=2;s=T1" }]
|
|
};
|
|
var result = _sut.Validate(cfg, alarmCapableConnectionNames: new HashSet<string> { "RealConn" });
|
|
Assert.DoesNotContain(result.Errors, e => e.Category == ValidationCategory.NativeAlarmSourceInvalid);
|
|
}
|
|
|
|
[Fact]
|
|
public void Validate_CallScriptTargetNotFound_ReturnsError()
|
|
{
|
|
var config = new FlattenedConfiguration
|
|
{
|
|
InstanceUniqueName = "Instance1",
|
|
Scripts =
|
|
[
|
|
new ResolvedScript
|
|
{
|
|
CanonicalName = "Caller",
|
|
Code = "CallScript(\"NonExistent\");"
|
|
}
|
|
]
|
|
};
|
|
|
|
var result = _sut.Validate(config);
|
|
Assert.Contains(result.Errors, e =>
|
|
e.Category == ValidationCategory.CallTargetNotFound &&
|
|
e.Message.Contains("NonExistent"));
|
|
}
|
|
|
|
[Fact]
|
|
public void Validate_CallScriptTargetExists_NoError()
|
|
{
|
|
var config = new FlattenedConfiguration
|
|
{
|
|
InstanceUniqueName = "Instance1",
|
|
Scripts =
|
|
[
|
|
new ResolvedScript { CanonicalName = "Target", Code = "var x = 1;" },
|
|
new ResolvedScript { CanonicalName = "Caller", Code = "CallScript(\"Target\");" }
|
|
]
|
|
};
|
|
|
|
var result = _sut.Validate(config);
|
|
Assert.DoesNotContain(result.Errors, e => e.Category == ValidationCategory.CallTargetNotFound);
|
|
}
|
|
|
|
[Fact]
|
|
public void Validate_CallSharedTargetNotFound_ReturnsError()
|
|
{
|
|
var config = new FlattenedConfiguration
|
|
{
|
|
InstanceUniqueName = "Instance1",
|
|
Scripts =
|
|
[
|
|
new ResolvedScript
|
|
{
|
|
CanonicalName = "Caller",
|
|
Code = "CallShared(\"MissingShared\");"
|
|
}
|
|
]
|
|
};
|
|
|
|
var result = _sut.Validate(config, sharedScripts: []);
|
|
Assert.Contains(result.Errors, e =>
|
|
e.Category == ValidationCategory.CallTargetNotFound &&
|
|
e.Message.Contains("MissingShared"));
|
|
}
|
|
|
|
[Fact]
|
|
public void Validate_CallSharedTargetExists_NoError()
|
|
{
|
|
var config = new FlattenedConfiguration
|
|
{
|
|
InstanceUniqueName = "Instance1",
|
|
Scripts =
|
|
[
|
|
new ResolvedScript { CanonicalName = "Caller", Code = "CallShared(\"Utility\");" }
|
|
]
|
|
};
|
|
|
|
var shared = new List<ResolvedScript>
|
|
{
|
|
new() { CanonicalName = "Utility", Code = "// shared" }
|
|
};
|
|
|
|
var result = _sut.Validate(config, shared);
|
|
Assert.DoesNotContain(result.Errors, e => e.Category == ValidationCategory.CallTargetNotFound);
|
|
}
|
|
|
|
[Fact]
|
|
public void Validate_ParameterCountMismatch_ReturnsError()
|
|
{
|
|
var config = new FlattenedConfiguration
|
|
{
|
|
InstanceUniqueName = "Instance1",
|
|
Scripts =
|
|
[
|
|
new ResolvedScript
|
|
{
|
|
CanonicalName = "Target",
|
|
Code = "var x = 1;",
|
|
ParameterDefinitions = "[{\"name\":\"a\",\"type\":\"Int32\"},{\"name\":\"b\",\"type\":\"String\"}]"
|
|
},
|
|
new ResolvedScript
|
|
{
|
|
CanonicalName = "Caller",
|
|
Code = "CallScript(\"Target\", 42);" // 1 arg but 2 expected
|
|
}
|
|
]
|
|
};
|
|
|
|
var result = _sut.Validate(config);
|
|
Assert.Contains(result.Errors, e => e.Category == ValidationCategory.ParameterMismatch);
|
|
}
|
|
|
|
[Fact]
|
|
public void Validate_RangeViolationOnNonNumeric_ReturnsError()
|
|
{
|
|
var config = new FlattenedConfiguration
|
|
{
|
|
InstanceUniqueName = "Instance1",
|
|
Attributes =
|
|
[
|
|
new ResolvedAttribute { CanonicalName = "Status", DataType = "String" }
|
|
],
|
|
Alarms =
|
|
[
|
|
new ResolvedAlarm
|
|
{
|
|
CanonicalName = "BadAlarm",
|
|
TriggerType = "RangeViolation",
|
|
TriggerConfiguration = "{\"attributeName\":\"Status\"}"
|
|
}
|
|
]
|
|
};
|
|
|
|
var result = _sut.Validate(config);
|
|
Assert.Contains(result.Errors, e => e.Category == ValidationCategory.TriggerOperandType);
|
|
}
|
|
|
|
[Fact]
|
|
public void Validate_RangeViolationOnNumeric_NoError()
|
|
{
|
|
var config = new FlattenedConfiguration
|
|
{
|
|
InstanceUniqueName = "Instance1",
|
|
Attributes =
|
|
[
|
|
new ResolvedAttribute { CanonicalName = "Temp", DataType = "Double" }
|
|
],
|
|
Alarms =
|
|
[
|
|
new ResolvedAlarm
|
|
{
|
|
CanonicalName = "HighTemp",
|
|
TriggerType = "RangeViolation",
|
|
TriggerConfiguration = "{\"attributeName\":\"Temp\"}"
|
|
}
|
|
]
|
|
};
|
|
|
|
var result = _sut.Validate(config);
|
|
Assert.DoesNotContain(result.Errors, e => e.Category == ValidationCategory.TriggerOperandType);
|
|
}
|
|
|
|
[Fact]
|
|
public void Validate_OnTriggerScriptNotFound_ReturnsError()
|
|
{
|
|
var config = new FlattenedConfiguration
|
|
{
|
|
InstanceUniqueName = "Instance1",
|
|
Scripts = [new ResolvedScript { CanonicalName = "OtherScript", Code = "var x = 1;" }],
|
|
Alarms =
|
|
[
|
|
new ResolvedAlarm
|
|
{
|
|
CanonicalName = "Alarm1",
|
|
TriggerType = "ValueMatch",
|
|
OnTriggerScriptCanonicalName = "MissingScript"
|
|
}
|
|
]
|
|
};
|
|
|
|
var result = _sut.Validate(config);
|
|
Assert.Contains(result.Errors, e => e.Category == ValidationCategory.OnTriggerScriptNotFound);
|
|
}
|
|
|
|
[Fact]
|
|
public void Validate_InstanceScriptCallsAlarmOnTrigger_ReturnsError()
|
|
{
|
|
var config = new FlattenedConfiguration
|
|
{
|
|
InstanceUniqueName = "Instance1",
|
|
Scripts =
|
|
[
|
|
new ResolvedScript { CanonicalName = "AlarmHandler", Code = "// alarm handler" },
|
|
new ResolvedScript
|
|
{
|
|
CanonicalName = "RegularScript",
|
|
Code = "CallScript(\"AlarmHandler\");"
|
|
}
|
|
],
|
|
Alarms =
|
|
[
|
|
new ResolvedAlarm
|
|
{
|
|
CanonicalName = "Alarm1",
|
|
TriggerType = "ValueMatch",
|
|
OnTriggerScriptCanonicalName = "AlarmHandler"
|
|
}
|
|
]
|
|
};
|
|
|
|
var result = _sut.Validate(config);
|
|
Assert.Contains(result.Errors, e => e.Category == ValidationCategory.CrossCallViolation);
|
|
}
|
|
|
|
[Fact]
|
|
public void ExtractCallTargets_MultipleCallTypes()
|
|
{
|
|
var code = @"
|
|
var x = CallScript(""Script1"", arg1, arg2);
|
|
CallShared(""Shared1"");
|
|
CallScript(""Script2"");
|
|
";
|
|
|
|
var targets = SemanticValidator.ExtractCallTargets(code);
|
|
|
|
Assert.Equal(3, targets.Count);
|
|
Assert.Contains(targets, t => t.TargetName == "Script1" && !t.IsShared && t.ArgumentCount == 2);
|
|
Assert.Contains(targets, t => t.TargetName == "Shared1" && t.IsShared && t.ArgumentCount == 0);
|
|
Assert.Contains(targets, t => t.TargetName == "Script2" && !t.IsShared && t.ArgumentCount == 0);
|
|
}
|
|
|
|
[Fact]
|
|
public void ParseParameterDefinitions_ValidJson_ReturnsList()
|
|
{
|
|
var json = "[{\"name\":\"a\",\"type\":\"Int32\"},{\"name\":\"b\",\"type\":\"String\"}]";
|
|
var result = SemanticValidator.ParseParameterDefinitions(json);
|
|
|
|
Assert.Equal(2, result.Count);
|
|
Assert.Equal("Int32", result[0]);
|
|
Assert.Equal("String", result[1]);
|
|
}
|
|
|
|
[Fact]
|
|
public void ParseParameterDefinitions_NullOrEmpty_ReturnsEmpty()
|
|
{
|
|
Assert.Empty(SemanticValidator.ParseParameterDefinitions(null));
|
|
Assert.Empty(SemanticValidator.ParseParameterDefinitions(""));
|
|
}
|
|
|
|
// ── HiLo validation ─────────────────────────────────────────────────────
|
|
|
|
private static FlattenedConfiguration HiLoConfig(string attrName, string dataType, string triggerJson) =>
|
|
new()
|
|
{
|
|
InstanceUniqueName = "Instance1",
|
|
Attributes = [new ResolvedAttribute { CanonicalName = attrName, DataType = dataType }],
|
|
Alarms =
|
|
[
|
|
new ResolvedAlarm
|
|
{
|
|
CanonicalName = "Hi/Lo Alarm",
|
|
TriggerType = "HiLo",
|
|
TriggerConfiguration = triggerJson
|
|
}
|
|
]
|
|
};
|
|
|
|
[Fact]
|
|
public void Validate_HiLoOnNonNumericAttribute_ReturnsError()
|
|
{
|
|
var config = HiLoConfig("Status", "String",
|
|
"{\"attributeName\":\"Status\",\"hi\":80}");
|
|
|
|
var result = _sut.Validate(config);
|
|
|
|
Assert.Contains(result.Errors,
|
|
e => e.Category == ValidationCategory.TriggerOperandType
|
|
&& e.Message.Contains("HiLo")
|
|
&& e.Message.Contains("non-numeric"));
|
|
}
|
|
|
|
[Fact]
|
|
public void Validate_HiLoOnNumericAttribute_NoOperandTypeError()
|
|
{
|
|
var config = HiLoConfig("Temp", "Double",
|
|
"{\"attributeName\":\"Temp\",\"hi\":80,\"hiHi\":100}");
|
|
|
|
var result = _sut.Validate(config);
|
|
|
|
Assert.DoesNotContain(result.Errors, e => e.Category == ValidationCategory.TriggerOperandType);
|
|
}
|
|
|
|
[Fact]
|
|
public void Validate_HiLoNoSetpoints_ReturnsWarning()
|
|
{
|
|
// No setpoints means the alarm can never fire — design-time warning.
|
|
var config = HiLoConfig("Temp", "Double",
|
|
"{\"attributeName\":\"Temp\"}");
|
|
|
|
var result = _sut.Validate(config);
|
|
|
|
Assert.Contains(result.Warnings,
|
|
w => w.Category == ValidationCategory.TriggerOperandType
|
|
&& w.Message.Contains("no setpoints"));
|
|
}
|
|
|
|
[Fact]
|
|
public void Validate_HiLoLoLoGreaterThanLo_ReturnsError()
|
|
{
|
|
var config = HiLoConfig("Temp", "Double",
|
|
"{\"attributeName\":\"Temp\",\"loLo\":20,\"lo\":10}");
|
|
|
|
var result = _sut.Validate(config);
|
|
|
|
Assert.Contains(result.Errors,
|
|
e => e.Category == ValidationCategory.TriggerOperandType
|
|
&& e.Message.Contains("LoLo")
|
|
&& e.Message.Contains("Lo"));
|
|
}
|
|
|
|
[Fact]
|
|
public void Validate_HiLoHiGreaterThanHiHi_ReturnsError()
|
|
{
|
|
var config = HiLoConfig("Temp", "Double",
|
|
"{\"attributeName\":\"Temp\",\"hi\":120,\"hiHi\":100}");
|
|
|
|
var result = _sut.Validate(config);
|
|
|
|
Assert.Contains(result.Errors,
|
|
e => e.Category == ValidationCategory.TriggerOperandType
|
|
&& e.Message.Contains("Hi")
|
|
&& e.Message.Contains("HiHi"));
|
|
}
|
|
|
|
[Fact]
|
|
public void Validate_HiLoLowSideOverlapsHighSide_ReturnsError()
|
|
{
|
|
// Lo (50) >= Hi (40) — bands overlap.
|
|
var config = HiLoConfig("Temp", "Double",
|
|
"{\"attributeName\":\"Temp\",\"lo\":50,\"hi\":40}");
|
|
|
|
var result = _sut.Validate(config);
|
|
|
|
Assert.Contains(result.Errors,
|
|
e => e.Category == ValidationCategory.TriggerOperandType
|
|
&& e.Message.Contains("overlap"));
|
|
}
|
|
|
|
[Fact]
|
|
public void Validate_HiLoOnlyHighSideConfigured_NoOrderingError()
|
|
{
|
|
// Only Hi/HiHi configured — no low-side comparison needed.
|
|
var config = HiLoConfig("Temp", "Double",
|
|
"{\"attributeName\":\"Temp\",\"hi\":80,\"hiHi\":100}");
|
|
|
|
var result = _sut.Validate(config);
|
|
|
|
Assert.DoesNotContain(result.Errors,
|
|
e => e.Category == ValidationCategory.TriggerOperandType);
|
|
}
|
|
|
|
[Fact]
|
|
public void Validate_HiLoNegativeDeadband_ReturnsError()
|
|
{
|
|
var config = HiLoConfig("Temp", "Double",
|
|
"{\"attributeName\":\"Temp\",\"hi\":80,\"hiHi\":100,\"hiDeadband\":-1}");
|
|
|
|
var result = _sut.Validate(config);
|
|
|
|
Assert.Contains(result.Errors,
|
|
e => e.Category == ValidationCategory.TriggerOperandType
|
|
&& e.Message.Contains("Hi deadband")
|
|
&& e.Message.Contains("non-negative"));
|
|
}
|
|
|
|
[Fact]
|
|
public void Validate_HiLoZeroDeadband_NoError()
|
|
{
|
|
// Zero deadband is the default (no hysteresis) and must be accepted.
|
|
var config = HiLoConfig("Temp", "Double",
|
|
"{\"attributeName\":\"Temp\",\"hi\":80,\"hiHi\":100,\"hiDeadband\":0,\"hiHiDeadband\":0}");
|
|
|
|
var result = _sut.Validate(config);
|
|
|
|
Assert.DoesNotContain(result.Errors,
|
|
e => e.Category == ValidationCategory.TriggerOperandType);
|
|
}
|
|
|
|
[Fact]
|
|
public void Validate_HiLoValidOrdering_NoErrors()
|
|
{
|
|
// LoLo (-10) < Lo (0) < Hi (90) < HiHi (100) — fully valid.
|
|
var config = HiLoConfig("Temp", "Double",
|
|
"{\"attributeName\":\"Temp\",\"loLo\":-10,\"lo\":0,\"hi\":90,\"hiHi\":100}");
|
|
|
|
var result = _sut.Validate(config);
|
|
|
|
Assert.DoesNotContain(result.Errors,
|
|
e => e.Category == ValidationCategory.TriggerOperandType);
|
|
Assert.DoesNotContain(result.Warnings,
|
|
w => w.Category == ValidationCategory.TriggerOperandType);
|
|
}
|
|
}
|