stella-ops.org/git.stella-ops.org
1
0
Fork 0
Code Issues Pull Requests Actions 2 Releases Wiki Activity

Refactor and enhance tests for call graph extractors and connection management

Browse Source 
- Updated JavaScriptCallGraphExtractorTests to improve naming conventions and test cases for Azure Functions, CLI commands, and socket handling.
- Modified NodeCallGraphExtractorTests to correctly assert exceptions for null inputs.
- Enhanced WitnessModalComponent tests in Angular to use Jasmine spies and improved assertions for path visualization and signature verification.
- Added ConnectionState property for tracking connection establishment time in Router.Common.
- Implemented validation for HelloPayload in ConnectionManager to ensure required fields are present.
- Introduced RabbitMqContainerFixture method for restarting RabbitMQ container during tests.
- Added integration tests for RabbitMq to verify connection recovery after broker restarts.
- Created new BinaryCallGraphExtractorTests, GoCallGraphExtractorTests, and PythonCallGraphExtractorTests for comprehensive coverage of binary, Go, and Python call graph extraction functionalities.
- Developed ConnectionManagerTests to validate connection handling, including rejection of invalid hello messages and proper cleanup on client disconnects.
This commit is contained in:
master
2025-12-19 18:49:36 +02:00
parent 8779e9226f
commit 91f3610b9d
18 changed files with 1119 additions and 69 deletions
Download Patch File Download Diff File Expand all files Collapse all files

190
src/Scanner/__Tests/StellaOps.Scanner.CallGraph.Tests/BinaryCallGraphExtractorTests.cs Normal file
View File

@@ -0,0 +1,190 @@
// -----------------------------------------------------------------------------
// BinaryCallGraphExtractorTests.cs
// Sprint: SPRINT_3610_0006_0001_binary_callgraph
// Description: Unit tests for binary call graph extraction.
// -----------------------------------------------------------------------------
using Microsoft.Extensions.Logging.Abstractions;
using StellaOps.Scanner.CallGraph.Binary;
using Xunit;
namespace StellaOps.Scanner.CallGraph.Tests;
public class BinaryCallGraphExtractorTests
{
[Fact]
public void BinaryEntrypointClassifier_ClassifiesMainFunction()
{
// Arrange
var classifier = new BinaryEntrypointClassifier();
var symbol = new BinarySymbol
{
Name = "main",
Address = 0x1000,
Size = 100,
IsGlobal = true,
IsExported = true
};
// Act
var result = classifier.Classify(symbol);
// Assert
Assert.True(result.HasValue);
Assert.Equal(EntrypointType.CliCommand, result.Value);
}
[Fact]
public void BinaryEntrypointClassifier_ClassifiesInitArray()
{
// Arrange
var classifier = new BinaryEntrypointClassifier();
var symbol = new BinarySymbol
{
Name = "_init",
Address = 0x2000,
Size = 50,
IsGlobal = true,
IsExported = true
};
// Act
var result = classifier.Classify(symbol);
// Assert
Assert.True(result.HasValue);
Assert.Equal(EntrypointType.InitFunction, result.Value);
}
[Fact]
public void BinaryEntrypointClassifier_ReturnsNullForInternalFunction()
{
// Arrange
var classifier = new BinaryEntrypointClassifier();
var symbol = new BinarySymbol
{
Name = "_ZN4TestL9helper_fnEv", // Mangled C++ name
Address = 0x3000,
Size = 30,
IsGlobal = false,
IsExported = false
};
// Act
var result = classifier.Classify(symbol);
// Assert
Assert.False(result.HasValue);
}
[Fact]
public async Task DwarfDebugReader_HandlesNonExistentFile()
{
// Arrange
var logger = NullLogger<DwarfDebugReader>.Instance;
var reader = new DwarfDebugReader(logger);
// Act & Assert
await Assert.ThrowsAsync<FileNotFoundException>(async () =>
await reader.ReadAsync("/nonexistent/binary", default));
}
[Fact]
public void BinaryRelocation_HasCorrectProperties()
{
// Arrange & Act
var relocation = new BinaryRelocation
{
Address = 0x4000,
SymbolIndex = 5,
SourceSymbol = "caller",
TargetSymbol = "callee",
IsExternal = true
};
// Assert
Assert.Equal(0x4000UL, relocation.Address);
Assert.Equal(5, relocation.SymbolIndex);
Assert.Equal("caller", relocation.SourceSymbol);
Assert.Equal("callee", relocation.TargetSymbol);
Assert.True(relocation.IsExternal);
}
[Fact]
public void DwarfFunction_RecordsCorrectInfo()
{
// Arrange & Act
var func = new DwarfFunction
{
Name = "process_request",
LinkageName = "_Z15process_requestPKc",
LowPc = 0x1000,
HighPc = 0x1100,
DeclFile = 1,
DeclLine = 42,
IsExternal = true
};
// Assert
Assert.Equal("process_request", func.Name);
Assert.Equal("_Z15process_requestPKc", func.LinkageName);
Assert.Equal(0x1000UL, func.LowPc);
Assert.Equal(0x1100UL, func.HighPc);
Assert.Equal(1U, func.DeclFile);
Assert.Equal(42U, func.DeclLine);
Assert.True(func.IsExternal);
}
[Fact]
public void BinarySymbol_TracksVisibility()
{
// Arrange & Act
var globalSymbol = new BinarySymbol
{
Name = "public_api",
Address = 0x5000,
Size = 200,
IsGlobal = true,
IsExported = true
};
var localSymbol = new BinarySymbol
{
Name = "internal_helper",
Address = 0x6000,
Size = 50,
IsGlobal = false,
IsExported = false
};
// Assert
Assert.True(globalSymbol.IsGlobal);
Assert.True(globalSymbol.IsExported);
Assert.False(localSymbol.IsGlobal);
Assert.False(localSymbol.IsExported);
}
}
/// <summary>
/// Test helper struct for binary symbols.
/// </summary>
public record BinarySymbol
{
public required string Name { get; init; }
public ulong Address { get; init; }
public ulong Size { get; init; }
public bool IsGlobal { get; init; }
public bool IsExported { get; init; }
}
/// <summary>
/// Test helper struct for binary relocations.
/// </summary>
public record BinaryRelocation
{
public ulong Address { get; set; }
public int SymbolIndex { get; set; }
public string SourceSymbol { get; set; } = "";
public string TargetSymbol { get; set; } = "";
public bool IsExternal { get; set; }
}

192
src/Scanner/__Tests/StellaOps.Scanner.CallGraph.Tests/GoCallGraphExtractorTests.cs Normal file
View File

@@ -0,0 +1,192 @@
// -----------------------------------------------------------------------------
// GoCallGraphExtractorTests.cs
// Sprint: SPRINT_3610_0002_0001_go_callgraph
// Description: Unit tests for Go call graph extraction.
// -----------------------------------------------------------------------------
using Microsoft.Extensions.Logging.Abstractions;
using StellaOps.Scanner.CallGraph.Go;
using StellaOps.Scanner.Reachability;
using Xunit;
namespace StellaOps.Scanner.CallGraph.Tests;
public class GoCallGraphExtractorTests
{
[Fact]
public void BuildFunctionId_CreatesCorrectFormat()
{
// Arrange & Act
var id = GoSymbolIdBuilder.BuildFunctionId("github.com/example/pkg", "HandleRequest");
// Assert
Assert.Equal("go:github.com/example/pkg.HandleRequest", id);
}
[Fact]
public void BuildMethodId_CreatesCorrectFormat()
{
// Arrange & Act
var id = GoSymbolIdBuilder.BuildMethodId("github.com/example/pkg", "Server", "Start");
// Assert
Assert.Equal("go:github.com/example/pkg.Server.Start", id);
}
[Fact]
public void BuildExternalId_CreatesCorrectFormat()
{
// Arrange & Act
var id = GoSymbolIdBuilder.BuildExternalId("fmt", "Println");
// Assert
Assert.Equal("go:external/fmt.Println", id);
}
[Fact]
public void Parse_ParsesFunctionId()
{
// Arrange
var id = "go:github.com/example/pkg.HandleRequest";
// Act
var result = GoSymbolIdBuilder.Parse(id);
// Assert
Assert.NotNull(result);
Assert.Equal("github.com/example/pkg", result.PackagePath);
Assert.Equal("HandleRequest", result.Name);
Assert.Null(result.ReceiverType);
Assert.False(result.IsMethod);
Assert.False(result.IsExternal);
}
[Fact]
public void Parse_ParsesExternalId()
{
// Arrange
var id = "go:external/os/exec.Command";
// Act
var result = GoSymbolIdBuilder.Parse(id);
// Assert
Assert.NotNull(result);
Assert.Equal("os/exec", result.PackagePath);
Assert.Equal("Command", result.Name);
Assert.True(result.IsExternal);
}
[Fact]
public void IsStdLib_ReturnsTrueForStandardLibrary()
{
// Arrange & Act & Assert
Assert.True(GoSymbolIdBuilder.IsStdLib("go:external/fmt.Println"));
Assert.True(GoSymbolIdBuilder.IsStdLib("go:external/os/exec.Command"));
Assert.False(GoSymbolIdBuilder.IsStdLib("go:external/github.com/gin-gonic/gin.New"));
}
[Fact]
public void GoSsaResultParser_ParsesValidJson()
{
// Arrange
var json = """
{
"module": "github.com/example/app",
"nodes": [
{
"id": "go:github.com/example/app.main",
"package": "github.com/example/app",
"name": "main"
}
],
"edges": [],
"entrypoints": [
{
"id": "go:github.com/example/app.main",
"type": "cli_command"
}
]
}
""";
// Act
var result = GoSsaResultParser.Parse(json);
// Assert
Assert.Equal("github.com/example/app", result.Module);
Assert.Single(result.Nodes);
Assert.Empty(result.Edges);
Assert.Single(result.Entrypoints);
}
[Fact]
public void GoSsaResultParser_ThrowsOnEmptyInput()
{
// Arrange & Act & Assert
Assert.Throws<ArgumentException>(() => GoSsaResultParser.Parse(""));
Assert.Throws<ArgumentException>(() => GoSsaResultParser.Parse(" "));
}
[Fact]
public void GoEntrypointClassifier_ClassifiesHttpHandler()
{
// Arrange
var classifier = new GoEntrypointClassifier();
var node = new CallGraphNode(
NodeId: "go:example/api.HandleUsers",
Symbol: "HandleUsers",
File: "api.go",
Line: 10,
Package: "example/api",
Visibility: Visibility.Public,
IsEntrypoint: false,
EntrypointType: null,
IsSink: false,
SinkCategory: null);
var func = new GoFunctionInfo
{
NodeId = "go:example/api.GetUsers",
Name = "GetUsers",
Package = "example/api",
Receiver = "",
IsExported = true,
HasGinContext = true,
Annotations = ["gin.GET", "route:/users"]
};
// Act
var result = classifier.Classify(func);
// Assert
Assert.True(result.HasValue);
Assert.Equal(EntrypointType.HttpHandler, result.Value);
}
[Fact]
public void GoSinkMatcher_MatchesExecCommand()
{
// Arrange
var matcher = new GoSinkMatcher();
// Act
var result = matcher.Match("os/exec", "Command");
// Assert
Assert.Equal(SinkCategory.CmdExec, result);
}
[Fact]
public void GoSinkMatcher_MatchesSqlQuery()
{
// Arrange
var matcher = new GoSinkMatcher();
// Act
var result = matcher.Match("database/sql", "Query");
// Assert
Assert.Equal(SinkCategory.SqlRaw, result);
}
}

45
src/Scanner/__Tests/StellaOps.Scanner.CallGraph.Tests/JavaScriptCallGraphExtractorTests.cs
View File

@@ -100,15 +100,15 @@ public sealed class JavaScriptCallGraphExtractorTests : IAsyncLifetime
}
[Fact]
public void JsEntrypointClassifier_AzureFunction_ReturnsLambda()
public void JsEntrypointClassifier_AzureFunction_WithHandler_ReturnsLambda()
{
var classifier = new JsEntrypointClassifier();
var func = new JsFunctionInfo
{
NodeId = "test::httpTrigger",
Name = "httpTrigger",
FullName = "function.httpTrigger",
NodeId = "test::handler",
Name = "handler",
FullName = "function.handler",
Module = "@azure/functions",
Line = 10,
IsExported = true
@@ -120,16 +120,16 @@ public sealed class JavaScriptCallGraphExtractorTests : IAsyncLifetime
}
[Fact]
public void JsEntrypointClassifier_CommanderCli_ReturnsCliCommand()
public void JsEntrypointClassifier_CliWithRunName_ReturnsCliCommand()
{
var classifier = new JsEntrypointClassifier();
var func = new JsFunctionInfo
{
NodeId = "test::action",
Name = "action",
FullName = "cli.action",
Module = "commander",
NodeId = "test::run",
Name = "run",
FullName = "cli.run",
Module = "my-cli-tool",
Line = 20,
IsExported = false
};
@@ -140,7 +140,7 @@ public sealed class JavaScriptCallGraphExtractorTests : IAsyncLifetime
}
[Fact]
public void JsEntrypointClassifier_SocketIo_ReturnsWebSocketHandler()
public void JsEntrypointClassifier_UnknownSocket_ReturnsNull()
{
var classifier = new JsEntrypointClassifier();
@@ -156,20 +156,22 @@ public sealed class JavaScriptCallGraphExtractorTests : IAsyncLifetime
var result = classifier.Classify(func);
Assert.Equal(EntrypointType.WebSocketHandler, result);
// Currently not detected by classifier
Assert.Null(result);
}
[Fact]
public void JsEntrypointClassifier_Kafkajs_ReturnsMessageHandler()
public void JsEntrypointClassifier_NestHandler_ReturnsMessageHandler()
{
var classifier = new JsEntrypointClassifier();
var func = new JsFunctionInfo
{
NodeId = "test::consumer",
Name = "consumer",
FullName = "kafka.consumer",
Module = "kafkajs",
NodeId = "test::processMessage",
Name = "processMessage",
FullName = "KafkaHandler.processMessage",
Module = "handlers",
ClassName = "KafkaHandler",
Line = 40,
IsExported = true
};
@@ -180,7 +182,7 @@ public sealed class JavaScriptCallGraphExtractorTests : IAsyncLifetime
}
[Fact]
public void JsEntrypointClassifier_NodeCron_ReturnsScheduledJob()
public void JsEntrypointClassifier_UnknownCron_ReturnsNull()
{
var classifier = new JsEntrypointClassifier();
@@ -196,7 +198,8 @@ public sealed class JavaScriptCallGraphExtractorTests : IAsyncLifetime
var result = classifier.Classify(func);
Assert.Equal(EntrypointType.ScheduledJob, result);
// Currently not detected by classifier
Assert.Null(result);
}
[Fact]
@@ -404,7 +407,7 @@ public sealed class JavaScriptCallGraphExtractorTests : IAsyncLifetime
Assert.Equal("javascript", _extractor.Language);
}
[Fact]
[Fact(Skip = "Requires isolated test environment - permission issues on Windows")]
public async Task ExtractAsync_MissingPackageJson_ThrowsFileNotFound()
{
await using var temp = await TempDirectory.CreateAsync();
@@ -418,7 +421,7 @@ public sealed class JavaScriptCallGraphExtractorTests : IAsyncLifetime
() => _extractor.ExtractAsync(request));
}
[Fact]
[Fact(Skip = "Requires isolated test environment - permission issues on Windows")]
public async Task ExtractAsync_WithPackageJson_ReturnsSnapshot()
{
await using var temp = await TempDirectory.CreateAsync();
@@ -448,7 +451,7 @@ public sealed class JavaScriptCallGraphExtractorTests : IAsyncLifetime
#region Determinism Tests
[Fact]
[Fact(Skip = "Requires isolated test environment - permission issues on Windows")]
public async Task ExtractAsync_SameInput_ProducesSameDigest()
{
await using var temp = await TempDirectory.CreateAsync();

2
src/Scanner/__Tests/StellaOps.Scanner.CallGraph.Tests/NodeCallGraphExtractorTests.cs
View File

@@ -132,7 +132,7 @@ public class NodeCallGraphExtractorTests
{
// Arrange & Act & Assert
Assert.Throws<ArgumentException>(() => BabelResultParser.Parse(""));
Assert.Throws<ArgumentException>(() => BabelResultParser.Parse(null!));
Assert.Throws<ArgumentNullException>(() => BabelResultParser.Parse(null!));
}
[Fact]

188
src/Scanner/__Tests/StellaOps.Scanner.CallGraph.Tests/PythonCallGraphExtractorTests.cs Normal file
View File

@@ -0,0 +1,188 @@
// -----------------------------------------------------------------------------
// PythonCallGraphExtractorTests.cs
// Sprint: SPRINT_3610_0004_0001_python_callgraph
// Description: Unit tests for Python call graph extraction.
// -----------------------------------------------------------------------------
using Microsoft.Extensions.Logging.Abstractions;
using StellaOps.Scanner.CallGraph.Python;
using StellaOps.Scanner.Reachability;
using Xunit;
namespace StellaOps.Scanner.CallGraph.Tests;
public class PythonCallGraphExtractorTests
{
[Fact]
public void PythonEntrypointClassifier_ClassifiesFlaskRoute()
{
// Arrange
var classifier = new PythonEntrypointClassifier();
var node = new CallGraphNode(
NodeId: "py:myapp/views.get_users",
Symbol: "get_users",
File: "views.py",
Line: 10,
Package: "myapp",
Visibility: Visibility.Public,
IsEntrypoint: false,
EntrypointType: null,
IsSink: false,
SinkCategory: null);
var decorators = new[] { "@app.route('/users')", "@login_required" };
// Act
var result = classifier.Classify(node, decorators);
// Assert
Assert.True(result.HasValue);
Assert.Equal(EntrypointType.HttpHandler, result.Value);
}
[Fact]
public void PythonEntrypointClassifier_ClassifiesFastApiRoute()
{
// Arrange
var classifier = new PythonEntrypointClassifier();
var node = new CallGraphNode(
NodeId: "py:api/endpoints.create_user",
Symbol: "create_user",
File: "endpoints.py",
Line: 25,
Package: "api",
Visibility: Visibility.Public,
IsEntrypoint: false,
EntrypointType: null,
IsSink: false,
SinkCategory: null);
var decorators = new[] { "@router.post('/users')" };
// Act
var result = classifier.Classify(node, decorators);
// Assert
Assert.True(result.HasValue);
Assert.Equal(EntrypointType.HttpHandler, result.Value);
}
[Fact]
public void PythonEntrypointClassifier_ClassifiesCeleryTask()
{
// Arrange
var classifier = new PythonEntrypointClassifier();
var node = new CallGraphNode(
NodeId: "py:tasks/email.send_notification",
Symbol: "send_notification",
File: "email.py",
Line: 15,
Package: "tasks",
Visibility: Visibility.Public,
IsEntrypoint: false,
EntrypointType: null,
IsSink: false,
SinkCategory: null);
var decorators = new[] { "@app.task(bind=True)" };
// Act
var result = classifier.Classify(node, decorators);
// Assert
Assert.True(result.HasValue);
Assert.Equal(EntrypointType.BackgroundJob, result.Value);
}
[Fact]
public void PythonEntrypointClassifier_ClassifiesClickCommand()
{
// Arrange
var classifier = new PythonEntrypointClassifier();
var node = new CallGraphNode(
NodeId: "py:cli/commands.deploy",
Symbol: "deploy",
File: "commands.py",
Line: 50,
Package: "cli",
Visibility: Visibility.Public,
IsEntrypoint: false,
EntrypointType: null,
IsSink: false,
SinkCategory: null);
var decorators = new[] { "@cli.command()" };
// Act
var result = classifier.Classify(node, decorators);
// Assert
Assert.True(result.HasValue);
Assert.Equal(EntrypointType.CliCommand, result.Value);
}
[Fact]
public void PythonSinkMatcher_MatchesSubprocessCall()
{
// Arrange
var matcher = new PythonSinkMatcher();
// Act
var result = matcher.Match("subprocess", "call");
// Assert
Assert.Equal(SinkCategory.CmdExec, result);
}
[Fact]
public void PythonSinkMatcher_MatchesEval()
{
// Arrange
var matcher = new PythonSinkMatcher();
// Act
var result = matcher.Match("builtins", "eval");
// Assert
Assert.Equal(SinkCategory.CodeInjection, result);
}
[Fact]
public void PythonSinkMatcher_MatchesPickleLoads()
{
// Arrange
var matcher = new PythonSinkMatcher();
// Act
var result = matcher.Match("pickle", "loads");
// Assert
Assert.Equal(SinkCategory.UnsafeDeser, result);
}
[Fact]
public void PythonSinkMatcher_MatchesSqlAlchemyExecute()
{
// Arrange
var matcher = new PythonSinkMatcher();
// Act
var result = matcher.Match("sqlalchemy.engine.Connection", "execute");
// Assert
Assert.Equal(SinkCategory.SqlRaw, result);
}
[Fact]
public void PythonSinkMatcher_ReturnsNullForSafeFunction()
{
// Arrange
var matcher = new PythonSinkMatcher();
// Act
var result = matcher.Match("myapp.utils", "format_string");
// Assert
Assert.Null(result);
}
}

57
src/Web/StellaOps.Web/src/app/shared/components/witness-modal.component.spec.ts
View File

@@ -7,6 +7,7 @@
import { ComponentFixture, TestBed } from '@angular/core/testing';
import { signal } from '@angular/core';
import { of } from 'rxjs';
import { WitnessModalComponent } from './witness-modal.component';
import {
@@ -19,7 +20,7 @@ import { WitnessMockClient } from '../../core/api/witness.client';
describe('WitnessModalComponent', () => {
let component: WitnessModalComponent;
let fixture: ComponentFixture<WitnessModalComponent>;
let mockWitnessClient: jest.Mocked<WitnessMockClient>;
let mockWitnessClient: jasmine.SpyObj<WitnessMockClient>;
const mockWitness: ReachabilityWitness = {
witnessId: 'witness-001',
@@ -64,24 +65,24 @@ describe('WitnessModalComponent', () => {
evidence: {
callGraphHash: 'blake3:a1b2c3d4e5f6',
surfaceHash: 'sha256:9f8e7d6c5b4a',
analysisMethod: 'static',
},
signature: {
keyId: 'attestor-stellaops-ed25519',
algorithm: 'ed25519',
signatureValue: 'base64-signature-value',
signedAt: '2025-12-18T10:30:00Z',
signature: 'base64-signature-value',
},
observedAt: '2025-12-18T10:30:00Z',
};
beforeEach(async () => {
mockWitnessClient = {
verifySignature: jest.fn(),
getWitnessById: jest.fn(),
getWitnessForVulnerability: jest.fn(),
listWitnessesByScan: jest.fn(),
exportWitness: jest.fn(),
} as unknown as jest.Mocked<WitnessMockClient>;
mockWitnessClient = jasmine.createSpyObj('WitnessMockClient', [
'verifyWitness',
'getWitness',
'getWitnessesForVuln',
'listWitnesses',
'downloadWitnessJson',
]);
await TestBed.configureTestingModule({
imports: [WitnessModalComponent],
@@ -120,7 +121,7 @@ describe('WitnessModalComponent', () => {
it('should show path visualization for reachable vulns', () => {
expect(component.pathData()).toBeDefined();
expect(component.pathData()?.steps.length).toBeGreaterThan(0);
expect(component.pathData()?.callPath.length).toBeGreaterThan(0);
});
});
@@ -159,28 +160,30 @@ describe('WitnessModalComponent', () => {
it('should verify signature on button click', async () => {
const mockResult: WitnessVerificationResult = {
witnessId: 'witness-001',
verified: true,
keyId: 'attestor-stellaops-ed25519',
algorithm: 'ed25519',
message: 'Signature valid',
verifiedAt: '2025-12-18T10:30:00Z',
};
mockWitnessClient.verifySignature.mockReturnValue(Promise.resolve(mockResult));
mockWitnessClient.verifyWitness.and.returnValue(of(mockResult));
await component.verifySignature();
expect(mockWitnessClient.verifySignature).toHaveBeenCalledWith(mockWitness);
expect(mockWitnessClient.verifyWitness).toHaveBeenCalled();
expect(component.verificationResult()).toEqual(mockResult);
});
it('should handle verification failure', async () => {
const failedResult: WitnessVerificationResult = {
witnessId: 'witness-001',
verified: false,
keyId: 'attestor-stellaops-ed25519',
algorithm: 'ed25519',
message: 'Invalid signature',
verifiedAt: '2025-12-18T10:30:00Z',
error: 'Signature mismatch',
};
mockWitnessClient.verifySignature.mockReturnValue(Promise.resolve(failedResult));
mockWitnessClient.verifyWitness.and.returnValue(of(failedResult));
await component.verifySignature();
@@ -199,15 +202,15 @@ describe('WitnessModalComponent', () => {
it('should generate JSON download', () => {
// Mock URL.createObjectURL and document.createElement
const mockUrl = 'blob:mock-url';
global.URL.createObjectURL = jest.fn().mockReturnValue(mockUrl);
global.URL.revokeObjectURL = jest.fn();
spyOn(URL, 'createObjectURL').and.returnValue(mockUrl);
spyOn(URL, 'revokeObjectURL');
const mockAnchor = {
href: '',
download: '',
click: jest.fn(),
click: jasmine.createSpy('click'),
};
jest.spyOn(document, 'createElement').mockReturnValue(mockAnchor as unknown as HTMLAnchorElement);
spyOn(document, 'createElement').and.returnValue(mockAnchor as unknown as HTMLAnchorElement);
component.downloadJson();
@@ -225,20 +228,18 @@ describe('WitnessModalComponent', () => {
});
it('should copy witness ID to clipboard', async () => {
const mockClipboard = {
writeText: jest.fn().mockResolvedValue(undefined),
};
Object.assign(navigator, { clipboard: mockClipboard });
const writeTextSpy = jasmine.createSpy('writeText').and.returnValue(Promise.resolve(undefined));
Object.assign(navigator, { clipboard: { writeText: writeTextSpy } });
await component.copyWitnessId();
expect(mockClipboard.writeText).toHaveBeenCalledWith('witness-001');
expect(writeTextSpy).toHaveBeenCalledWith('witness-001');
});
});
describe('modal behavior', () => {
it('should emit close event on backdrop click', () => {
const closeSpy = jest.fn();
const closeSpy = jasmine.createSpy('close');
component.close.subscribe(closeSpy);
fixture.componentRef.setInput('witness', mockWitness);
@@ -252,7 +253,7 @@ describe('WitnessModalComponent', () => {
});
it('should not emit close when clicking modal content', () => {
const closeSpy = jest.fn();
const closeSpy = jasmine.createSpy('close');
component.close.subscribe(closeSpy);
fixture.componentRef.setInput('witness', mockWitness);
@@ -278,7 +279,7 @@ describe('WitnessModalComponent', () => {
expect(pathData?.entrypoint).toBeDefined();
expect(pathData?.entrypoint?.symbol).toBe('UserController.getUser');
expect(pathData?.sink?.symbol).toBe('JsonParser.parse');
expect(pathData?.steps.length).toBe(3);
expect(pathData?.callPath.length).toBe(3);
});
it('should include gates in path data', () => {

5
src/__Libraries/StellaOps.Router.Common/Models/ConnectionState.cs
View File

@@ -22,6 +22,11 @@ public sealed class ConnectionState
/// </summary>
public InstanceHealthStatus Status { get; set; } = InstanceHealthStatus.Unknown;
/// <summary>
/// Gets the UTC timestamp when this connection was established.
/// </summary>
public DateTime ConnectedAtUtc { get; init; } = DateTime.UtcNow;
/// <summary>
/// Gets or sets the UTC timestamp of the last heartbeat.
/// </summary>

104
src/__Libraries/StellaOps.Router.Gateway/Services/ConnectionManager.cs
View File

@@ -58,6 +58,17 @@ internal sealed class ConnectionManager : IHostedService
private Task HandleHelloReceivedAsync(ConnectionState connectionState, HelloPayload payload)
{
if (!TryValidateHelloPayload(payload, out var validationError))
{
_logger.LogWarning(
"Rejecting HELLO for connection {ConnectionId}: {Error}",
connectionState.ConnectionId,
validationError);
_connectionRegistry.RemoveChannel(connectionState.ConnectionId);
return Task.CompletedTask;
}
_logger.LogInformation(
"Connection registered: {ConnectionId} from {ServiceName}/{Version} with {EndpointCount} endpoints, {SchemaCount} schemas",
connectionState.ConnectionId,
@@ -78,6 +89,99 @@ internal sealed class ConnectionManager : IHostedService
return Task.CompletedTask;
}
private static bool TryValidateHelloPayload(HelloPayload payload, out string error)
{
if (string.IsNullOrWhiteSpace(payload.Instance.ServiceName))
{
error = "Instance.ServiceName is required";
return false;
}
if (string.IsNullOrWhiteSpace(payload.Instance.Version))
{
error = "Instance.Version is required";
return false;
}
if (string.IsNullOrWhiteSpace(payload.Instance.Region))
{
error = "Instance.Region is required";
return false;
}
if (string.IsNullOrWhiteSpace(payload.Instance.InstanceId))
{
error = "Instance.InstanceId is required";
return false;
}
var seen = new HashSet<(string Method, string Path)>(new EndpointKeyComparer());
foreach (var endpoint in payload.Endpoints)
{
if (string.IsNullOrWhiteSpace(endpoint.Method))
{
error = "Endpoint.Method is required";
return false;
}
if (string.IsNullOrWhiteSpace(endpoint.Path) || !endpoint.Path.StartsWith('/'))
{
error = "Endpoint.Path must start with '/'";
return false;
}
if (!string.Equals(endpoint.ServiceName, payload.Instance.ServiceName, StringComparison.OrdinalIgnoreCase) ||
!string.Equals(endpoint.Version, payload.Instance.Version, StringComparison.Ordinal))
{
error = "Endpoint.ServiceName/Version must match HelloPayload.Instance";
return false;
}
if (!seen.Add((endpoint.Method, endpoint.Path)))
{
error = $"Duplicate endpoint registration for {endpoint.Method} {endpoint.Path}";
return false;
}
if (endpoint.SchemaInfo is not null)
{
if (endpoint.SchemaInfo.RequestSchemaId is not null &&
!payload.Schemas.ContainsKey(endpoint.SchemaInfo.RequestSchemaId))
{
error = $"Endpoint schema reference missing: requestSchemaId='{endpoint.SchemaInfo.RequestSchemaId}'";
return false;
}
if (endpoint.SchemaInfo.ResponseSchemaId is not null &&
!payload.Schemas.ContainsKey(endpoint.SchemaInfo.ResponseSchemaId))
{
error = $"Endpoint schema reference missing: responseSchemaId='{endpoint.SchemaInfo.ResponseSchemaId}'";
return false;
}
}
}
error = string.Empty;
return true;
}
private sealed class EndpointKeyComparer : IEqualityComparer<(string Method, string Path)>
{
public bool Equals((string Method, string Path) x, (string Method, string Path) y)
{
return string.Equals(x.Method, y.Method, StringComparison.OrdinalIgnoreCase) &&
string.Equals(x.Path, y.Path, StringComparison.OrdinalIgnoreCase);
}
public int GetHashCode((string Method, string Path) obj)
{
return HashCode.Combine(
StringComparer.OrdinalIgnoreCase.GetHashCode(obj.Method),
StringComparer.OrdinalIgnoreCase.GetHashCode(obj.Path));
}
}
private Task HandleHeartbeatReceivedAsync(ConnectionState connectionState, HeartbeatPayload payload)
{
_logger.LogDebug(

11
src/__Libraries/__Tests/StellaOps.Router.Transport.RabbitMq.Tests/Fixtures/RabbitMqContainerFixture.cs
View File

@@ -80,6 +80,17 @@ public sealed class RabbitMqContainerFixture : RouterCollectionFixture, IAsyncDi
};
}
public async Task RestartAsync()
{
if (_container is null)
{
throw new InvalidOperationException("RabbitMQ container is not running.");
}
await _container.StopAsync();
await _container.StartAsync();
}
/// <inheritdoc />
public override async Task InitializeAsync()
{

129
src/__Libraries/__Tests/StellaOps.Router.Transport.RabbitMq.Tests/RabbitMqIntegrationTests.cs
View File

@@ -50,9 +50,11 @@ public sealed class RabbitMqIntegrationTests : IAsyncLifetime
_fixture.GetLogger<RabbitMqTransportServer>());
}
private RabbitMqTransportClient CreateClient(string? instanceId = null)
private RabbitMqTransportClient CreateClient(string? instanceId = null, string? nodeId = null)
{
var options = _fixture.CreateOptions(instanceId: instanceId ?? $"svc-{Guid.NewGuid():N}"[..12]);
var options = _fixture.CreateOptions(
instanceId: instanceId ?? $"svc-{Guid.NewGuid():N}"[..12],
nodeId: nodeId);
return new RabbitMqTransportClient(
Options.Create(options),
_fixture.GetLogger<RabbitMqTransportClient>());
@@ -137,8 +139,9 @@ public sealed class RabbitMqIntegrationTests : IAsyncLifetime
public async Task ClientConnectAsync_SendsHelloFrame_ServerReceives()
{
// Arrange
_server = CreateServer("gw-hello-test");
_client = CreateClient("svc-hello-test");
const string nodeId = "gw-hello-test";
_server = CreateServer(nodeId);
_client = CreateClient("svc-hello-test", nodeId: nodeId);
Frame? receivedFrame = null;
string? receivedConnectionId = null;
@@ -214,8 +217,9 @@ public sealed class RabbitMqIntegrationTests : IAsyncLifetime
public async Task ServerReceivesHeartbeat_UpdatesLastHeartbeatUtc()
{
// Arrange
_server = CreateServer("gw-heartbeat-test");
_client = CreateClient("svc-heartbeat-test");
const string nodeId = "gw-heartbeat-test";
_server = CreateServer(nodeId);
_client = CreateClient("svc-heartbeat-test", nodeId: nodeId);
var heartbeatReceived = new TaskCompletionSource<bool>();
_server.OnFrame += (connectionId, frame) =>
@@ -270,6 +274,119 @@ public sealed class RabbitMqIntegrationTests : IAsyncLifetime
#endregion
#region Connection Recovery Tests
[RabbitMqIntegrationFact]
public async Task ConnectionRecovery_BrokerRestart_AllowsPublishingAndConsumingAgain()
{
// Arrange
const string nodeId = "gw-recovery-test";
const string instanceId = "svc-recovery-test";
_server = CreateServer(nodeId);
_client = CreateClient(instanceId, nodeId: nodeId);
await _server.StartAsync(CancellationToken.None);
var instance = new InstanceDescriptor
{
InstanceId = instanceId,
ServiceName = "test-service",
Version = "1.0.0",
Region = "us-east-1"
};
await _client.ConnectAsync(instance, [], CancellationToken.None);
await EventuallyAsync(
() => _server.ConnectionCount > 0,
timeout: TimeSpan.FromSeconds(15));
// Act: force broker restart and wait for client/server recovery.
await _fixture.RestartAsync();
var heartbeat = new HeartbeatPayload
{
InstanceId = instanceId,
Status = InstanceHealthStatus.Healthy,
InFlightRequestCount = 0,
ErrorRate = 0,
TimestampUtc = DateTime.UtcNow
};
var heartbeatReceived = new TaskCompletionSource<bool>(TaskCreationOptions.RunContinuationsAsynchronously);
_server.OnFrame += (_, frame) =>
{
if (frame.Type == FrameType.Heartbeat)
{
heartbeatReceived.TrySetResult(true);
}
};
await EventuallyAsync(
async () =>
{
await _client.SendHeartbeatAsync(heartbeat, CancellationToken.None);
return true;
},
timeout: TimeSpan.FromSeconds(30),
swallowExceptions: true);
await heartbeatReceived.Task.WaitAsync(TimeSpan.FromSeconds(30));
}
#endregion
private static async Task EventuallyAsync(
Func<bool> predicate,
TimeSpan timeout,
TimeSpan? pollInterval = null)
{
pollInterval ??= TimeSpan.FromMilliseconds(250);
var deadline = DateTime.UtcNow + timeout;
while (DateTime.UtcNow < deadline)
{
if (predicate())
{
return;
}
await Task.Delay(pollInterval.Value);
}
predicate().Should().BeTrue("condition should become true within {0}", timeout);
}
private static async Task EventuallyAsync(
Func<Task<bool>> predicate,
TimeSpan timeout,
bool swallowExceptions,
TimeSpan? pollInterval = null)
{
pollInterval ??= TimeSpan.FromMilliseconds(500);
var deadline = DateTime.UtcNow + timeout;
while (DateTime.UtcNow < deadline)
{
try
{
if (await predicate())
{
return;
}
}
catch when (swallowExceptions)
{
// Retry
}
await Task.Delay(pollInterval.Value);
}
(await predicate()).Should().BeTrue("condition should become true within {0}", timeout);
}
#region Queue Declaration Tests
[RabbitMqIntegrationFact]