Function TestConcurrentRouter_ConcurrentReads

router_concurrent_test.go:33–93

(t *testing.T)

}

func TestConcurrentRouter_ConcurrentReads(t *testing.T) {
	router := NewConcurrentRouter(NewRouter(RouterConfig{}))

	testPaths := []string{"/route1", "/route2", "/route3", "/route4", "/route5"}
	for _, path := range testPaths {
		_, err := router.Add(Route{
			Method:  http.MethodGet,
			Path:    path,
			Handler: handlerFunc,
		})
		if err != nil {
			t.Fatal(err)
		}
	}

	// Launch 10 goroutines for concurrent reads
	var wg sync.WaitGroup
	var routeCallCount atomic.Int64
	var routesCallCount atomic.Int64

	numGoroutines := 10
	routeCallsPerGoroutine := 50
	routesCallsPerGoroutine := 20

	for i := range numGoroutines {
		wg.Add(1)
		go func(goroutineID int) {
			defer wg.Done()

			// Call Route() 50 times
			for j := range routeCallsPerGoroutine {
				path := testPaths[j%len(testPaths)]
				req := httptest.NewRequest(http.MethodGet, path, nil)
				rec := httptest.NewRecorder()
				c := newContext(req, rec, nil)

				handler := router.Route(c)
				if handler != nil {
					routeCallCount.Add(1)
				}
			}

			// Call Routes() 20 times
			for range routesCallsPerGoroutine {
				routes := router.Routes()
				if len(routes) == 5 {
					routesCallCount.Add(1)
				}
			}
		}(i)
	}

	wg.Wait()

	// Verify all operations succeeded
	expectedRouteCalls := int64(numGoroutines * routeCallsPerGoroutine)
	expectedRoutesCalls := int64(numGoroutines * routesCallsPerGoroutine)