Function TestConcurrentRouter_ConcurrentReadWrite

router_concurrent_test.go:141–216

(t *testing.T)

}

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

	initialPaths := []string{"/read1", "/read2", "/read3"}
	for _, path := range initialPaths {
		_, err := router.Add(Route{Method: http.MethodGet, Path: path, Handler: handlerFunc})
		if err != nil {
			t.Fatal(err)
		}
	}

	var wg sync.WaitGroup
	var routeCallCount atomic.Int64
	var addCallCount atomic.Int64
	var routesCallCount atomic.Int64

	// Launch 4 reader goroutines: call Route() 100 times each
	for range 4 {
		wg.Go(func() {
			for j := range 100 {
				path := initialPaths[j%len(initialPaths)]

				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)
				}
			}
		})
	}

	// Launch 2 writer goroutines: call Add() 20 times each
	for i := range 2 {
		wg.Add(1)
		go func(goroutineID int) {
			defer wg.Done()
			for j := range 20 {
				path := fmt.Sprintf("/write-g%d-n%d", goroutineID, j)
				_, err := router.Add(Route{
					Method:  http.MethodGet,
					Path:    path,
					Handler: handlerFunc,
				})
				if err == nil {
					addCallCount.Add(1)
				}
			}
		}(i)
	}

	// Launch 2 inspector goroutines: call Routes() 50 times each
	for range 2 {
		wg.Go(func() {
			for range 50 {
				routes := router.Routes()