feat(websocket): add WebSocket Helper with RFC 6455 compliance
Add comprehensive WebSocket support for v-hono framework, inspired by Hono.js WebSocket Helper. Features: - upgrade_websocket() function for WebSocket route handlers - Event-based callbacks: on_open, on_message, on_close, on_error - WSContext with send(), send_bytes(), send_json(), close() methods - Connection state tracking (connecting, open, closing, closed) - Configurable options: ping_interval, max_message_size, timeout, protocols - Subprotocol negotiation support - Ping/pong keep-alive handling - Message size validation with 1009 close code - Integration with picoev and uSockets backends Protocol Compliance: - RFC 6455 compliant handshake with Sec-WebSocket-Accept computation - Frame encoding/decoding with proper masking - Close handshake with status codes and reasons - Text and binary message frame support Testing: - 13 property-based test files with 82 tests total - Validates handshake, frame encoding, masking, JSON round-trip - Tests context preservation, route patterns, connection state - All existing tests pass (no regressions) Files added: - websocket.v: Core WebSocket implementation - examples/websocket_demo.v: Chat room example - examples/websocket_test.html: Browser test client - tests/test_websocket_*.v: Property-based tests Files modified: - app.v: Add ws() method for WebSocket routes - middleware.v: Export WebSocket types and functions - picoev_server.v: WebSocket upgrade detection - usockets_server.v: WebSocket upgrade detection - README.md: WebSocket documentation
This commit is contained in:
meiseayoung
@@ -0,0 +1,475 @@
|
||||
// test_websocket_route_patterns.v - Property test for WebSocket route pattern support
|
||||
// Feature: websocket-helper, Property 3: Route Pattern Support
|
||||
// Validates: Requirements 1.5
|
||||
//
|
||||
// *For any* WebSocket route registered with path parameters (e.g., /ws/:room/:id),
|
||||
// when a matching request arrives, the handler SHALL receive a WSContext with
|
||||
// correctly extracted parameter values.
|
||||
module main
|
||||
|
||||
import rand
|
||||
import time
|
||||
import regex
|
||||
|
||||
const test_iterations = 100
|
||||
|
||||
struct PropertyTestStats {
|
||||
mut:
|
||||
total_tests int
|
||||
passed_tests int
|
||||
failed_tests int
|
||||
}
|
||||
|
||||
fn (mut stats PropertyTestStats) run_property_test(test_name string, test_func fn () bool) {
|
||||
stats.total_tests++
|
||||
print('🔬 ${test_name}... ')
|
||||
|
||||
if test_func() {
|
||||
stats.passed_tests++
|
||||
println('✅')
|
||||
} else {
|
||||
stats.failed_tests++
|
||||
println('❌')
|
||||
}
|
||||
}
|
||||
|
||||
fn (stats PropertyTestStats) print_summary() {
|
||||
println('\n=== WebSocket Route Pattern Property Test Summary ===')
|
||||
println('Total tests: ${stats.total_tests}')
|
||||
println('Passed: ${stats.passed_tests}')
|
||||
println('Failed: ${stats.failed_tests}')
|
||||
|
||||
if stats.failed_tests == 0 {
|
||||
println('🎉 All property tests passed!')
|
||||
} else {
|
||||
println('⚠️ ${stats.failed_tests} property test(s) failed')
|
||||
}
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// Route Parameter Extraction (simplified from router.v)
|
||||
// ============================================================================
|
||||
|
||||
// Extract parameter names from a route pattern
|
||||
fn extract_param_names(pattern string) []string {
|
||||
mut param_names := []string{}
|
||||
mut param_reg := regex.regex_opt(r':[a-zA-Z_][a-zA-Z0-9_]*') or { return param_names }
|
||||
all_params := param_reg.find_all_str(pattern)
|
||||
for param in all_params {
|
||||
param_names << param[1..] // Remove the colon
|
||||
}
|
||||
return param_names
|
||||
}
|
||||
|
||||
// Convert route pattern to regex and extract params from actual path
|
||||
fn match_route_pattern(pattern string, actual_path string) ?map[string]string {
|
||||
if !pattern.contains(':') {
|
||||
// Static route - no params
|
||||
if pattern == actual_path {
|
||||
return map[string]string{}
|
||||
}
|
||||
return none
|
||||
}
|
||||
|
||||
// Extract parameter names
|
||||
param_names := extract_param_names(pattern)
|
||||
|
||||
// Build regex pattern
|
||||
mut regex_pattern := pattern
|
||||
|
||||
// Escape special regex characters
|
||||
special_chars := ['?', '+', '.', '(', ')', '[', ']', '{', '}', '^', '\$', '|']
|
||||
for ch in special_chars {
|
||||
regex_pattern = regex_pattern.replace(ch, '\\${ch}')
|
||||
}
|
||||
|
||||
// Replace :param with capture groups
|
||||
mut param_reg := regex.regex_opt(r':[a-zA-Z_][a-zA-Z0-9_]*') or { return none }
|
||||
regex_pattern = param_reg.replace_by_fn(regex_pattern, fn (re regex.RE, in_txt string, start int, end int) string {
|
||||
param_name := in_txt[start + 1..end]
|
||||
return '(?P<${param_name}>[^/]+)'
|
||||
})
|
||||
|
||||
// Add anchors
|
||||
regex_pattern = '^${regex_pattern}\$'
|
||||
|
||||
// Compile and match
|
||||
mut compiled := regex.regex_opt(regex_pattern) or { return none }
|
||||
if !compiled.matches_string(actual_path) {
|
||||
return none
|
||||
}
|
||||
|
||||
// Extract parameter values
|
||||
mut params := map[string]string{}
|
||||
for param_name in param_names {
|
||||
value := compiled.get_group_by_name(actual_path, param_name)
|
||||
params[param_name] = value
|
||||
}
|
||||
|
||||
return params
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// Random Data Generators
|
||||
// ============================================================================
|
||||
|
||||
fn generate_random_param_name() string {
|
||||
chars := 'abcdefghijklmnopqrstuvwxyz'
|
||||
len := rand.int_in_range(3, 10) or { 5 }
|
||||
mut result := ''
|
||||
for _ in 0 .. len {
|
||||
idx := rand.int_in_range(0, chars.len) or { 0 }
|
||||
result += chars[idx].ascii_str()
|
||||
}
|
||||
return result
|
||||
}
|
||||
|
||||
fn generate_random_param_value() string {
|
||||
chars := 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_-'
|
||||
len := rand.int_in_range(1, 20) or { 5 }
|
||||
mut result := ''
|
||||
for _ in 0 .. len {
|
||||
idx := rand.int_in_range(0, chars.len) or { 0 }
|
||||
result += chars[idx].ascii_str()
|
||||
}
|
||||
return result
|
||||
}
|
||||
|
||||
fn generate_random_static_segment() string {
|
||||
chars := 'abcdefghijklmnopqrstuvwxyz'
|
||||
len := rand.int_in_range(2, 10) or { 5 }
|
||||
mut result := ''
|
||||
for _ in 0 .. len {
|
||||
idx := rand.int_in_range(0, chars.len) or { 0 }
|
||||
result += chars[idx].ascii_str()
|
||||
}
|
||||
return result
|
||||
}
|
||||
|
||||
// Generate a random route pattern with parameters
|
||||
fn generate_random_route_pattern() (string, []string) {
|
||||
num_segments := rand.int_in_range(2, 6) or { 3 }
|
||||
mut segments := []string{}
|
||||
mut param_names := []string{}
|
||||
|
||||
// First segment is always static (like /ws or /api)
|
||||
segments << generate_random_static_segment()
|
||||
|
||||
for _ in 1 .. num_segments {
|
||||
// Randomly decide if this segment is a parameter or static
|
||||
is_param := rand.int_in_range(0, 2) or { 0 } == 1
|
||||
|
||||
if is_param {
|
||||
param_name := generate_random_param_name()
|
||||
// Ensure unique param names
|
||||
if param_name !in param_names {
|
||||
param_names << param_name
|
||||
segments << ':${param_name}'
|
||||
} else {
|
||||
segments << generate_random_static_segment()
|
||||
}
|
||||
} else {
|
||||
segments << generate_random_static_segment()
|
||||
}
|
||||
}
|
||||
|
||||
pattern := '/' + segments.join('/')
|
||||
return pattern, param_names
|
||||
}
|
||||
|
||||
// Generate an actual path that matches a pattern with specific values
|
||||
fn generate_matching_path(pattern string, param_values map[string]string) string {
|
||||
mut path := pattern
|
||||
for name, value in param_values {
|
||||
path = path.replace(':${name}', value)
|
||||
}
|
||||
return path
|
||||
}
|
||||
|
||||
// ============================================================================
|
||||
// Property 3: Route Pattern Support
|
||||
// Feature: websocket-helper, Property 3: Route Pattern Support
|
||||
// Validates: Requirements 1.5
|
||||
//
|
||||
// *For any* WebSocket route registered with path parameters (e.g., /ws/:room/:id),
|
||||
// when a matching request arrives, the handler SHALL receive a WSContext with
|
||||
// correctly extracted parameter values.
|
||||
// ============================================================================
|
||||
|
||||
// Test single parameter extraction
|
||||
fn test_property_3_single_param() bool {
|
||||
rand.seed([u32(time.now().unix()), u32(12345)])
|
||||
|
||||
for i in 0 .. test_iterations {
|
||||
// Generate a pattern with one parameter
|
||||
param_name := generate_random_param_name()
|
||||
prefix := generate_random_static_segment()
|
||||
pattern := '/${prefix}/:${param_name}'
|
||||
|
||||
// Generate a random value for the parameter
|
||||
param_value := generate_random_param_value()
|
||||
actual_path := '/${prefix}/${param_value}'
|
||||
|
||||
// Extract parameters
|
||||
params := match_route_pattern(pattern, actual_path) or {
|
||||
println(' Iteration ${i}: Pattern did not match')
|
||||
println(' Pattern: ${pattern}')
|
||||
println(' Path: ${actual_path}')
|
||||
return false
|
||||
}
|
||||
|
||||
// Verify parameter was extracted correctly
|
||||
if param_name !in params {
|
||||
println(' Iteration ${i}: Parameter not found: ${param_name}')
|
||||
return false
|
||||
}
|
||||
|
||||
if params[param_name] != param_value {
|
||||
println(' Iteration ${i}: Parameter value mismatch')
|
||||
println(' Expected: ${param_value}')
|
||||
println(' Got: ${params[param_name]}')
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
return true
|
||||
}
|
||||
|
||||
// Test multiple parameter extraction
|
||||
fn test_property_3_multiple_params() bool {
|
||||
rand.seed([u32(time.now().unix()), u32(23456)])
|
||||
|
||||
for i in 0 .. test_iterations {
|
||||
// Generate a pattern with multiple parameters
|
||||
pattern, param_names := generate_random_route_pattern()
|
||||
|
||||
// Skip if no parameters were generated
|
||||
if param_names.len == 0 {
|
||||
continue
|
||||
}
|
||||
|
||||
// Generate random values for each parameter
|
||||
mut expected_values := map[string]string{}
|
||||
for name in param_names {
|
||||
expected_values[name] = generate_random_param_value()
|
||||
}
|
||||
|
||||
// Generate the actual path
|
||||
actual_path := generate_matching_path(pattern, expected_values)
|
||||
|
||||
// Extract parameters
|
||||
params := match_route_pattern(pattern, actual_path) or {
|
||||
println(' Iteration ${i}: Pattern did not match')
|
||||
println(' Pattern: ${pattern}')
|
||||
println(' Path: ${actual_path}')
|
||||
return false
|
||||
}
|
||||
|
||||
// Verify all parameters were extracted correctly
|
||||
for name, expected_value in expected_values {
|
||||
if name !in params {
|
||||
println(' Iteration ${i}: Parameter not found: ${name}')
|
||||
return false
|
||||
}
|
||||
|
||||
if params[name] != expected_value {
|
||||
println(' Iteration ${i}: Parameter value mismatch for ${name}')
|
||||
println(' Expected: ${expected_value}')
|
||||
println(' Got: ${params[name]}')
|
||||
return false
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return true
|
||||
}
|
||||
|
||||
// Test common WebSocket route patterns
|
||||
fn test_property_3_common_patterns() bool {
|
||||
// Test common WebSocket route patterns
|
||||
patterns := ['/ws/:room', '/ws/:room/:user', '/api/ws/:id', '/chat/:room/user/:userId', '/v1/ws/:tenant/:channel']
|
||||
paths := ['/ws/general', '/ws/chat/alice', '/api/ws/12345', '/chat/lobby/user/u123', '/v1/ws/acme/notifications']
|
||||
expected_keys := [['room'], ['room', 'user'], ['id'], ['room', 'userId'], ['tenant', 'channel']]
|
||||
expected_values := [['general'], ['chat', 'alice'], ['12345'], ['lobby', 'u123'], ['acme', 'notifications']]
|
||||
|
||||
for i, pattern in patterns {
|
||||
path := paths[i]
|
||||
keys := expected_keys[i]
|
||||
values := expected_values[i]
|
||||
|
||||
params := match_route_pattern(pattern, path) or {
|
||||
println(' Pattern did not match: ${pattern} vs ${path}')
|
||||
return false
|
||||
}
|
||||
|
||||
for j, name in keys {
|
||||
expected_value := values[j]
|
||||
if name !in params {
|
||||
println(' Parameter not found: ${name}')
|
||||
return false
|
||||
}
|
||||
if params[name] != expected_value {
|
||||
println(' Parameter mismatch for ${name}: expected ${expected_value}, got ${params[name]}')
|
||||
return false
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return true
|
||||
}
|
||||
|
||||
// Test that non-matching paths don't extract params
|
||||
fn test_property_3_non_matching_paths() bool {
|
||||
rand.seed([u32(time.now().unix()), u32(34567)])
|
||||
|
||||
for i in 0 .. test_iterations {
|
||||
// Generate a pattern
|
||||
pattern, _ := generate_random_route_pattern()
|
||||
|
||||
// Generate a completely different path
|
||||
different_pattern, _ := generate_random_route_pattern()
|
||||
mut different_values := map[string]string{}
|
||||
different_param_names := extract_param_names(different_pattern)
|
||||
for name in different_param_names {
|
||||
different_values[name] = generate_random_param_value()
|
||||
}
|
||||
different_path := generate_matching_path(different_pattern, different_values)
|
||||
|
||||
// Try to match - should fail if patterns are different
|
||||
if pattern != different_pattern {
|
||||
result := match_route_pattern(pattern, different_path)
|
||||
// It's okay if it matches by coincidence, but if it does,
|
||||
// the params should still be valid extractions
|
||||
if result != none {
|
||||
// Verify the extracted params are valid (non-empty)
|
||||
for _, value in result {
|
||||
if value.len == 0 {
|
||||
println(' Iteration ${i}: Empty parameter value extracted')
|
||||
return false
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return true
|
||||
}
|
||||
|
||||
// Test parameter extraction preserves special characters in values
|
||||
fn test_property_3_special_values() bool {
|
||||
// Test that parameter values with allowed special characters are preserved
|
||||
patterns := ['/ws/:room', '/ws/:room', '/ws/:id', '/chat/:room/:user']
|
||||
paths := ['/ws/room-123', '/ws/room_456', '/ws/ABC123xyz', '/chat/my-room/user_1']
|
||||
expected_keys := [['room'], ['room'], ['id'], ['room', 'user']]
|
||||
expected_values := [['room-123'], ['room_456'], ['ABC123xyz'], ['my-room', 'user_1']]
|
||||
|
||||
for i, pattern in patterns {
|
||||
path := paths[i]
|
||||
keys := expected_keys[i]
|
||||
values := expected_values[i]
|
||||
|
||||
params := match_route_pattern(pattern, path) or {
|
||||
println(' Pattern did not match: ${pattern} vs ${path}')
|
||||
return false
|
||||
}
|
||||
|
||||
for j, name in keys {
|
||||
expected_value := values[j]
|
||||
if params[name] != expected_value {
|
||||
println(' Parameter mismatch for ${name}: expected ${expected_value}, got ${params[name]}')
|
||||
return false
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return true
|
||||
}
|
||||
|
||||
// Test static routes (no parameters)
|
||||
fn test_property_3_static_routes() bool {
|
||||
rand.seed([u32(time.now().unix()), u32(45678)])
|
||||
|
||||
for i in 0 .. test_iterations {
|
||||
// Generate a static route (no parameters)
|
||||
num_segments := rand.int_in_range(1, 5) or { 2 }
|
||||
mut segments := []string{}
|
||||
for _ in 0 .. num_segments {
|
||||
segments << generate_random_static_segment()
|
||||
}
|
||||
pattern := '/' + segments.join('/')
|
||||
|
||||
// Match against itself
|
||||
params := match_route_pattern(pattern, pattern) or {
|
||||
println(' Iteration ${i}: Static pattern did not match itself')
|
||||
println(' Pattern: ${pattern}')
|
||||
return false
|
||||
}
|
||||
|
||||
// Static routes should have no parameters
|
||||
if params.len != 0 {
|
||||
println(' Iteration ${i}: Static route should have no params')
|
||||
println(' Got: ${params}')
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
return true
|
||||
}
|
||||
|
||||
// Test parameter count matches
|
||||
fn test_property_3_param_count() bool {
|
||||
rand.seed([u32(time.now().unix()), u32(56789)])
|
||||
|
||||
for i in 0 .. test_iterations {
|
||||
// Generate a pattern with known number of parameters
|
||||
pattern, param_names := generate_random_route_pattern()
|
||||
|
||||
// Generate values
|
||||
mut values := map[string]string{}
|
||||
for name in param_names {
|
||||
values[name] = generate_random_param_value()
|
||||
}
|
||||
|
||||
actual_path := generate_matching_path(pattern, values)
|
||||
|
||||
params := match_route_pattern(pattern, actual_path) or {
|
||||
// If no params in pattern, this is expected for static routes
|
||||
if param_names.len == 0 {
|
||||
continue
|
||||
}
|
||||
println(' Iteration ${i}: Pattern did not match')
|
||||
return false
|
||||
}
|
||||
|
||||
// Verify param count matches
|
||||
if params.len != param_names.len {
|
||||
println(' Iteration ${i}: Param count mismatch')
|
||||
println(' Expected: ${param_names.len}')
|
||||
println(' Got: ${params.len}')
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
return true
|
||||
}
|
||||
|
||||
fn main() {
|
||||
println('🚀 Starting WebSocket Route Pattern Property Tests...')
|
||||
println('Each property test runs ${test_iterations} iterations\n')
|
||||
|
||||
mut stats := PropertyTestStats{}
|
||||
|
||||
// Run property tests
|
||||
// Feature: websocket-helper, Property 3: Route Pattern Support
|
||||
// Validates: Requirements 1.5
|
||||
stats.run_property_test('Property 3.1: Single Parameter Extraction', test_property_3_single_param)
|
||||
stats.run_property_test('Property 3.2: Multiple Parameters Extraction', test_property_3_multiple_params)
|
||||
stats.run_property_test('Property 3.3: Common WebSocket Patterns', test_property_3_common_patterns)
|
||||
stats.run_property_test('Property 3.4: Non-Matching Paths', test_property_3_non_matching_paths)
|
||||
stats.run_property_test('Property 3.5: Special Characters in Values', test_property_3_special_values)
|
||||
stats.run_property_test('Property 3.6: Static Routes', test_property_3_static_routes)
|
||||
stats.run_property_test('Property 3.7: Parameter Count Matches', test_property_3_param_count)
|
||||
|
||||
// Print test summary
|
||||
stats.print_summary()
|
||||
}
|
||||
Reference in New Issue
Block a user