Joseph Doherty
466 lines
17 KiB
C#
466 lines
17 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 ValidationServiceTests
|
|
{
|
|
private readonly ValidationService _sut = new();
|
|
|
|
[Fact]
|
|
public void Validate_ValidConfig_ReturnsSuccess()
|
|
{
|
|
var config = new FlattenedConfiguration
|
|
{
|
|
InstanceUniqueName = "Instance1",
|
|
Attributes = [new ResolvedAttribute { CanonicalName = "Temp", Value = "25", DataType = "Double" }],
|
|
Scripts = [new ResolvedScript { CanonicalName = "Monitor", Code = "var x = 1;" }]
|
|
};
|
|
|
|
var result = _sut.Validate(config);
|
|
Assert.True(result.IsValid);
|
|
}
|
|
|
|
[Fact]
|
|
public void Validate_EmptyInstanceName_ReturnsError()
|
|
{
|
|
var config = new FlattenedConfiguration
|
|
{
|
|
InstanceUniqueName = "",
|
|
Attributes = [new ResolvedAttribute { CanonicalName = "Temp", DataType = "Double" }]
|
|
};
|
|
|
|
var result = _sut.Validate(config);
|
|
Assert.False(result.IsValid);
|
|
Assert.Contains(result.Errors, e => e.Category == ValidationCategory.FlatteningFailure);
|
|
}
|
|
|
|
[Fact]
|
|
public void Validate_NamingCollision_ReturnsError()
|
|
{
|
|
var config = new FlattenedConfiguration
|
|
{
|
|
InstanceUniqueName = "Instance1",
|
|
Attributes =
|
|
[
|
|
new ResolvedAttribute { CanonicalName = "Temp", DataType = "Double" },
|
|
new ResolvedAttribute { CanonicalName = "Temp", DataType = "Int32" } // Duplicate!
|
|
]
|
|
};
|
|
|
|
var result = _sut.Validate(config);
|
|
Assert.False(result.IsValid);
|
|
Assert.Contains(result.Errors, e => e.Category == ValidationCategory.NamingCollision);
|
|
}
|
|
|
|
[Fact]
|
|
public void Validate_ForbiddenApi_ReturnsCompilationError()
|
|
{
|
|
var config = new FlattenedConfiguration
|
|
{
|
|
InstanceUniqueName = "Instance1",
|
|
Scripts =
|
|
[
|
|
new ResolvedScript
|
|
{
|
|
CanonicalName = "BadScript",
|
|
Code = "System.IO.File.ReadAllText(\"secret.txt\");"
|
|
}
|
|
]
|
|
};
|
|
|
|
var result = _sut.Validate(config);
|
|
Assert.False(result.IsValid);
|
|
Assert.Contains(result.Errors, e => e.Category == ValidationCategory.ScriptCompilation);
|
|
}
|
|
|
|
[Fact]
|
|
public void Validate_MismatchedBraces_ReturnsCompilationError()
|
|
{
|
|
var config = new FlattenedConfiguration
|
|
{
|
|
InstanceUniqueName = "Instance1",
|
|
Scripts =
|
|
[
|
|
new ResolvedScript { CanonicalName = "Bad", Code = "if (true) {" }
|
|
]
|
|
};
|
|
|
|
var result = _sut.Validate(config);
|
|
Assert.False(result.IsValid);
|
|
Assert.Contains(result.Errors, e => e.Category == ValidationCategory.ScriptCompilation);
|
|
}
|
|
|
|
[Fact]
|
|
public void Validate_AlarmReferencesMissingAttribute_ReturnsError()
|
|
{
|
|
var config = new FlattenedConfiguration
|
|
{
|
|
InstanceUniqueName = "Instance1",
|
|
Attributes = [new ResolvedAttribute { CanonicalName = "Temp", DataType = "Double" }],
|
|
Alarms =
|
|
[
|
|
new ResolvedAlarm
|
|
{
|
|
CanonicalName = "HighPressure",
|
|
TriggerType = "RangeViolation",
|
|
TriggerConfiguration = "{\"attributeName\":\"Pressure\"}" // Pressure doesn't exist
|
|
}
|
|
]
|
|
};
|
|
|
|
var result = _sut.Validate(config);
|
|
Assert.False(result.IsValid);
|
|
Assert.Contains(result.Errors, e => e.Category == ValidationCategory.AlarmTriggerReference);
|
|
}
|
|
|
|
[Fact]
|
|
public void Validate_AlarmReferencesExistingAttribute_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);
|
|
// Should not have alarm trigger reference errors
|
|
Assert.DoesNotContain(result.Errors, e => e.Category == ValidationCategory.AlarmTriggerReference);
|
|
}
|
|
|
|
[Fact]
|
|
public void Validate_ScriptTriggerReferencesMissingAttribute_ReturnsError()
|
|
{
|
|
var config = new FlattenedConfiguration
|
|
{
|
|
InstanceUniqueName = "Instance1",
|
|
Attributes = [new ResolvedAttribute { CanonicalName = "Temp", DataType = "Double" }],
|
|
Scripts =
|
|
[
|
|
new ResolvedScript
|
|
{
|
|
CanonicalName = "OnChange",
|
|
Code = "var x = 1;",
|
|
TriggerConfiguration = "{\"attributeName\":\"Missing\"}"
|
|
}
|
|
]
|
|
};
|
|
|
|
var result = _sut.Validate(config);
|
|
Assert.False(result.IsValid);
|
|
Assert.Contains(result.Errors, e => e.Category == ValidationCategory.ScriptTriggerReference);
|
|
}
|
|
|
|
[Fact]
|
|
public void Validate_UnboundDataSourceAttribute_DesignTime_ReturnsWarningNotError()
|
|
{
|
|
// M2.8 (#23): at template design time (the default, enforceConnectionBindings:false)
|
|
// a data-sourced attribute is legitimately unbound — bindings are set later at
|
|
// instance/deploy time. So this must stay a non-blocking WARNING and IsValid true.
|
|
var config = new FlattenedConfiguration
|
|
{
|
|
InstanceUniqueName = "Instance1",
|
|
Attributes =
|
|
[
|
|
new ResolvedAttribute
|
|
{
|
|
CanonicalName = "Temp",
|
|
DataType = "Double",
|
|
DataSourceReference = "ns=2;s=Temp",
|
|
BoundDataConnectionId = null // No binding!
|
|
}
|
|
]
|
|
};
|
|
|
|
var result = _sut.Validate(config);
|
|
Assert.Contains(result.Warnings, w => w.Category == ValidationCategory.ConnectionBinding);
|
|
Assert.DoesNotContain(result.Errors, e => e.Category == ValidationCategory.ConnectionBinding);
|
|
Assert.True(result.IsValid);
|
|
}
|
|
|
|
[Fact]
|
|
public void Validate_UnboundDataSourceAttribute_DeployTime_ReturnsErrorAndBlocks()
|
|
{
|
|
// M2.8 (#23): the deploy path opts in (enforceConnectionBindings:true). A data-sourced
|
|
// attribute with no binding now gates the deployment as an ERROR (IsValid false).
|
|
var config = new FlattenedConfiguration
|
|
{
|
|
InstanceUniqueName = "Instance1",
|
|
Attributes =
|
|
[
|
|
new ResolvedAttribute
|
|
{
|
|
CanonicalName = "Temp",
|
|
DataType = "Double",
|
|
DataSourceReference = "ns=2;s=Temp",
|
|
BoundDataConnectionId = null // No binding!
|
|
}
|
|
]
|
|
};
|
|
|
|
var result = _sut.Validate(config, enforceConnectionBindings: true);
|
|
Assert.Contains(result.Errors, e => e.Category == ValidationCategory.ConnectionBinding);
|
|
Assert.False(result.IsValid);
|
|
}
|
|
|
|
[Fact]
|
|
public void Validate_StaticAttributeWithoutBinding_DeployTime_NoBindingError()
|
|
{
|
|
// M2.8 (#23): only DATA-SOURCED attributes require a binding. A static attribute
|
|
// (DataSourceReference == null) must remain OK even under deploy-time enforcement.
|
|
var config = new FlattenedConfiguration
|
|
{
|
|
InstanceUniqueName = "Instance1",
|
|
Attributes =
|
|
[
|
|
new ResolvedAttribute
|
|
{
|
|
CanonicalName = "Setpoint",
|
|
DataType = "Double",
|
|
Value = "42",
|
|
DataSourceReference = null,
|
|
BoundDataConnectionId = null
|
|
}
|
|
]
|
|
};
|
|
|
|
var result = _sut.Validate(config, enforceConnectionBindings: true);
|
|
Assert.DoesNotContain(result.Errors, e => e.Category == ValidationCategory.ConnectionBinding);
|
|
Assert.True(result.IsValid);
|
|
}
|
|
|
|
[Fact]
|
|
public void Validate_BoundToExistingSiteConnection_DeployTime_NoBindingError()
|
|
{
|
|
// M2.8 (#23): a data-sourced attribute bound to a connection that exists at the
|
|
// target site passes the binding gate.
|
|
var config = new FlattenedConfiguration
|
|
{
|
|
InstanceUniqueName = "Instance1",
|
|
Attributes =
|
|
[
|
|
new ResolvedAttribute
|
|
{
|
|
CanonicalName = "Temp",
|
|
DataType = "Double",
|
|
DataSourceReference = "ns=2;s=Temp",
|
|
BoundDataConnectionId = 7,
|
|
BoundDataConnectionName = "PlantBus"
|
|
}
|
|
]
|
|
};
|
|
|
|
var result = _sut.Validate(
|
|
config,
|
|
enforceConnectionBindings: true,
|
|
siteConnectionNames: new HashSet<string>(StringComparer.Ordinal) { "PlantBus" });
|
|
|
|
Assert.DoesNotContain(result.Errors, e => e.Category == ValidationCategory.ConnectionBinding);
|
|
Assert.True(result.IsValid);
|
|
}
|
|
|
|
[Fact]
|
|
public void Validate_BoundToNonExistentSiteConnection_DeployTime_ReturnsError()
|
|
{
|
|
// M2.8 (#23): a binding pointing at a connection that does NOT exist on the
|
|
// target site is an ERROR that blocks deployment.
|
|
var config = new FlattenedConfiguration
|
|
{
|
|
InstanceUniqueName = "Instance1",
|
|
Attributes =
|
|
[
|
|
new ResolvedAttribute
|
|
{
|
|
CanonicalName = "Temp",
|
|
DataType = "Double",
|
|
DataSourceReference = "ns=2;s=Temp",
|
|
BoundDataConnectionId = 99,
|
|
BoundDataConnectionName = "GhostBus"
|
|
}
|
|
]
|
|
};
|
|
|
|
var result = _sut.Validate(
|
|
config,
|
|
enforceConnectionBindings: true,
|
|
siteConnectionNames: new HashSet<string>(StringComparer.Ordinal) { "PlantBus" });
|
|
|
|
Assert.Contains(result.Errors, e => e.Category == ValidationCategory.ConnectionBinding);
|
|
Assert.False(result.IsValid);
|
|
}
|
|
|
|
[Fact]
|
|
public void Validate_BoundAttributeWithNoSiteSet_DeployTime_ExistsAtSiteCheckIsInert()
|
|
{
|
|
// M2.8 (#23): when siteConnectionNames is null the "exists at site" half of the
|
|
// binding check stays inert — a properly-bound data-sourced attribute must NOT
|
|
// produce a ConnectionBinding error, even under deploy-time enforcement.
|
|
// This pins the contract: passing enforce:true + siteConnectionNames:null is safe
|
|
// (e.g. when the caller doesn't have a site connection set available yet).
|
|
var config = new FlattenedConfiguration
|
|
{
|
|
InstanceUniqueName = "Instance1",
|
|
Attributes =
|
|
[
|
|
new ResolvedAttribute
|
|
{
|
|
CanonicalName = "Temp",
|
|
DataType = "Double",
|
|
DataSourceReference = "ns=2;s=Temp",
|
|
BoundDataConnectionId = 7,
|
|
BoundDataConnectionName = "PlantBus"
|
|
}
|
|
]
|
|
};
|
|
|
|
var result = _sut.Validate(config, enforceConnectionBindings: true, siteConnectionNames: null);
|
|
|
|
Assert.DoesNotContain(result.Errors, e => e.Category == ValidationCategory.ConnectionBinding);
|
|
Assert.True(result.IsValid);
|
|
}
|
|
|
|
[Fact]
|
|
public void Validate_EmptyConfig_ReturnsWarning()
|
|
{
|
|
var config = new FlattenedConfiguration { InstanceUniqueName = "Instance1" };
|
|
|
|
var result = _sut.Validate(config);
|
|
Assert.Contains(result.Warnings, w => w.Category == ValidationCategory.FlatteningFailure);
|
|
}
|
|
|
|
// --- M9-T28a: per-trigger AnalysisKind (Advisory default | Strict escalates) ---
|
|
// The only currently-advisory finding in CheckExpressionTrigger is the blank/empty
|
|
// expression (which "will never fire"). Advisory keeps it a non-blocking warning;
|
|
// Strict promotes it to a deploy-blocking error. The kind rides the existing
|
|
// trigger-config JSON ({"expression":"...","analysisKind":"Strict"}) — no migration.
|
|
|
|
[Fact]
|
|
public void Validate_ExpressionTrigger_BlankExpression_AdvisoryDefault_WarnsButPasses()
|
|
{
|
|
// No analysisKind in the config → Advisory (today's behavior): a blank expression
|
|
// is a non-blocking warning, validation still passes.
|
|
var config = new FlattenedConfiguration
|
|
{
|
|
InstanceUniqueName = "Instance1",
|
|
Alarms =
|
|
[
|
|
new ResolvedAlarm
|
|
{
|
|
CanonicalName = "BlankAlarm",
|
|
TriggerType = "Expression",
|
|
TriggerConfiguration = "{\"expression\":\"\"}"
|
|
}
|
|
]
|
|
};
|
|
|
|
var result = _sut.Validate(config);
|
|
Assert.Contains(result.Warnings, w => w.Category == ValidationCategory.AlarmTriggerReference);
|
|
Assert.DoesNotContain(result.Errors, e => e.Category == ValidationCategory.AlarmTriggerReference);
|
|
Assert.True(result.IsValid);
|
|
}
|
|
|
|
[Fact]
|
|
public void Validate_ExpressionTrigger_BlankExpression_StrictKind_FailsWithError()
|
|
{
|
|
// analysisKind:"Strict" promotes the blank-expression advisory to a deploy-blocking error.
|
|
var config = new FlattenedConfiguration
|
|
{
|
|
InstanceUniqueName = "Instance1",
|
|
Alarms =
|
|
[
|
|
new ResolvedAlarm
|
|
{
|
|
CanonicalName = "BlankAlarm",
|
|
TriggerType = "Expression",
|
|
TriggerConfiguration = "{\"expression\":\"\",\"analysisKind\":\"Strict\"}"
|
|
}
|
|
]
|
|
};
|
|
|
|
var result = _sut.Validate(config);
|
|
Assert.Contains(result.Errors, e => e.Category == ValidationCategory.AlarmTriggerReference);
|
|
Assert.DoesNotContain(result.Warnings, w => w.Category == ValidationCategory.AlarmTriggerReference);
|
|
Assert.False(result.IsValid);
|
|
}
|
|
|
|
[Fact]
|
|
public void Validate_ScriptExpressionTrigger_BlankExpression_StrictKind_FailsWithError()
|
|
{
|
|
// Strict escalation also applies to script expression triggers (mirrors the alarm path).
|
|
var config = new FlattenedConfiguration
|
|
{
|
|
InstanceUniqueName = "Instance1",
|
|
Scripts =
|
|
[
|
|
new ResolvedScript
|
|
{
|
|
CanonicalName = "BlankScript",
|
|
Code = "var x = 1;",
|
|
TriggerType = "Expression",
|
|
TriggerConfiguration = "{\"expression\":\" \",\"analysisKind\":\"Strict\"}"
|
|
}
|
|
]
|
|
};
|
|
|
|
var result = _sut.Validate(config);
|
|
Assert.Contains(result.Errors, e => e.Category == ValidationCategory.ScriptTriggerReference);
|
|
Assert.False(result.IsValid);
|
|
}
|
|
|
|
[Fact]
|
|
public void Validate_ExpressionTrigger_ValidExpression_PassesUnderBothKinds()
|
|
{
|
|
// A genuinely valid expression must pass clean under Advisory AND Strict —
|
|
// Strict only escalates the currently-advisory findings, it does not invent new ones.
|
|
var attributes = new[]
|
|
{
|
|
new ResolvedAttribute { CanonicalName = "Temp", Value = "25", DataType = "Double" }
|
|
};
|
|
|
|
var advisory = new FlattenedConfiguration
|
|
{
|
|
InstanceUniqueName = "Instance1",
|
|
Attributes = attributes,
|
|
Alarms =
|
|
[
|
|
new ResolvedAlarm
|
|
{
|
|
CanonicalName = "HighTemp",
|
|
TriggerType = "Expression",
|
|
TriggerConfiguration = "{\"expression\":\"(double)Attributes[\\\"Temp\\\"] > 50\"}"
|
|
}
|
|
]
|
|
};
|
|
|
|
var strict = advisory with
|
|
{
|
|
Alarms =
|
|
[
|
|
new ResolvedAlarm
|
|
{
|
|
CanonicalName = "HighTemp",
|
|
TriggerType = "Expression",
|
|
TriggerConfiguration = "{\"expression\":\"(double)Attributes[\\\"Temp\\\"] > 50\",\"analysisKind\":\"Strict\"}"
|
|
}
|
|
]
|
|
};
|
|
|
|
var advisoryResult = _sut.Validate(advisory);
|
|
var strictResult = _sut.Validate(strict);
|
|
|
|
Assert.DoesNotContain(advisoryResult.Errors, e => e.Category == ValidationCategory.AlarmTriggerReference);
|
|
Assert.DoesNotContain(advisoryResult.Warnings, w => w.Category == ValidationCategory.AlarmTriggerReference);
|
|
Assert.DoesNotContain(strictResult.Errors, e => e.Category == ValidationCategory.AlarmTriggerReference);
|
|
Assert.DoesNotContain(strictResult.Warnings, w => w.Category == ValidationCategory.AlarmTriggerReference);
|
|
}
|
|
}
|