Function TestClient_WorkspaceUpdates

vpn/client_test.go:31–221

(t *testing.T)

)

func TestClient_WorkspaceUpdates(t *testing.T) {
	t.Parallel()

	userID := uuid.UUID{1}
	wsID := uuid.UUID{2}
	peerID := uuid.UUID{3}
	agentID := uuid.UUID{4}

	testCases := []struct {
		name                string
		agentConnectionInfo workspacesdk.AgentConnectionInfo
		hostnames           []string
	}{
		{
			name: "empty",
			agentConnectionInfo: workspacesdk.AgentConnectionInfo{
				DERPMap: &tailcfg.DERPMap{},
			},
			hostnames: []string{"wrk.coder.", "agnt.wrk.me.coder.", "agnt.wrk.rootbeer.coder."},
		},
		{
			name: "suffix",
			agentConnectionInfo: workspacesdk.AgentConnectionInfo{
				HostnameSuffix: "float",
				DERPMap:        &tailcfg.DERPMap{},
			},
			hostnames: []string{"wrk.float.", "agnt.wrk.me.float.", "agnt.wrk.rootbeer.float."},
		},
	}
	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			t.Parallel()

			ctx := testutil.Context(t, testutil.WaitShort)
			logger := testutil.Logger(t)

			fCoord := tailnettest.NewFakeCoordinator()
			var coord tailnet.Coordinator = fCoord
			coordPtr := atomic.Pointer[tailnet.Coordinator]{}
			coordPtr.Store(&coord)
			ctrl := gomock.NewController(t)
			mProvider := tailnettest.NewMockWorkspaceUpdatesProvider(ctrl)

			mSub := tailnettest.NewMockSubscription(ctrl)
			outUpdateCh := make(chan *proto.WorkspaceUpdate, 1)
			inUpdateCh := make(chan tailnet.WorkspaceUpdate, 1)
			mProvider.EXPECT().Subscribe(gomock.Any(), userID).Times(1).Return(mSub, nil)
			mSub.EXPECT().Updates().MinTimes(1).Return(outUpdateCh)
			mSub.EXPECT().Close().Times(1).Return(nil)

			svc, err := tailnet.NewClientService(tailnet.ClientServiceOptions{
				Logger:                   logger,
				CoordPtr:                 &coordPtr,
				DERPMapUpdateFrequency:   time.Hour,
				DERPMapFn:                func() *tailcfg.DERPMap { return &tailcfg.DERPMap{} },
				WorkspaceUpdatesProvider: mProvider,
				ResumeTokenProvider:      tailnet.NewInsecureTestResumeTokenProvider(),
			})