From f83605526ede8cd83c43eb71161ebb86c46b8a85 Mon Sep 17 00:00:00 2001 From: winlin Date: Sat, 18 Apr 2026 16:39:56 -0400 Subject: [PATCH] Proxy: Wire up counterfeiter for interface fake generation Add `make generate` plus a counterfeiter tool dependency so test doubles for proxy interfaces can be produced consistently. Introduce the env package's //go:generate directive and its generated envfakes, and document the regenerate step in the srs-develop skill. Co-Authored-By: Claude Opus 4.7 (1M context) --- .openclaw/skills/srs-develop/SKILL.md | 10 +- Makefile | 5 +- go.mod | 9 +- go.sum | 12 + internal/env/envfakes/fake_environment.go | 1422 +++++++++++++++++++++ internal/env/gen.go | 6 + 6 files changed, 1459 insertions(+), 5 deletions(-) create mode 100644 internal/env/envfakes/fake_environment.go create mode 100644 internal/env/gen.go diff --git a/.openclaw/skills/srs-develop/SKILL.md b/.openclaw/skills/srs-develop/SKILL.md index f25622634..d6c840d39 100644 --- a/.openclaw/skills/srs-develop/SKILL.md +++ b/.openclaw/skills/srs-develop/SKILL.md @@ -105,15 +105,19 @@ Only after the user confirms the routing do you proceed to Step 2. **Step 3: Implement and Verify** 1. Implement the code change. -2. Run the proxy unit tests to verify: +2. If you changed or added a Go interface with a `//go:generate go tool counterfeiter ...` directive, regenerate fakes: + ``` + make generate + ``` +3. Run the proxy unit tests to verify: ``` bash scripts/proxy-utest.sh --coverage ``` -3. Run the proxy E2E test (starts proxy + SRS origin, publishes RTMP, verifies playback): +4. Run the proxy E2E test (starts proxy + SRS origin, publishes RTMP, verifies playback): ``` bash scripts/proxy-e2e-test.sh ``` -4. If any tests fail, fix the issues and re-run until all tests pass. +5. If any tests fail, fix the issues and re-run until all tests pass. All script paths are relative to this skill's directory. diff --git a/Makefile b/Makefile index 8921a5619..682f450f5 100644 --- a/Makefile +++ b/Makefile @@ -1,9 +1,12 @@ -.PHONY: all build test fmt clean run +.PHONY: all build test fmt clean run generate all: build build: fmt bin/srs-proxy +generate: + go generate ./... + bin/srs-proxy: cmd/proxy/*.go internal/**/*.go @mkdir -p bin go build -o bin/srs-proxy ./cmd/proxy diff --git a/go.mod b/go.mod index 709a04b48..cf20fa059 100644 --- a/go.mod +++ b/go.mod @@ -1,10 +1,17 @@ module srsx -go 1.24 +go 1.25.0 require github.com/go-redis/redis/v8 v8.11.5 require ( github.com/cespare/xxhash/v2 v2.1.2 // indirect github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect + github.com/maxbrunsfeld/counterfeiter/v6 v6.12.2 // indirect + golang.org/x/mod v0.34.0 // indirect + golang.org/x/sync v0.20.0 // indirect + golang.org/x/text v0.35.0 // indirect + golang.org/x/tools v0.43.0 // indirect ) + +tool github.com/maxbrunsfeld/counterfeiter/v6 diff --git a/go.sum b/go.sum index 17906ec30..372f6a0fd 100644 --- a/go.sum +++ b/go.sum @@ -6,18 +6,30 @@ github.com/fsnotify/fsnotify v1.4.9 h1:hsms1Qyu0jgnwNXIxa+/V/PDsU6CfLf6CNO8H7IWo github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ= github.com/go-redis/redis/v8 v8.11.5 h1:AcZZR7igkdvfVmQTPnu9WE37LRrO/YrBH5zWyjDC0oI= github.com/go-redis/redis/v8 v8.11.5/go.mod h1:gREzHqY1hg6oD9ngVRbLStwAWKhA0FEgq8Jd4h5lpwo= +github.com/maxbrunsfeld/counterfeiter/v6 v6.12.2 h1:V23nK2R2B63g2GhygF9zVGpnigmhvoZoH8d0hrZwMGY= +github.com/maxbrunsfeld/counterfeiter/v6 v6.12.2/go.mod h1:Mr897yU9FmyKaQDPtRlVKibrjz40XXyOHUfyZBPSyZU= github.com/nxadm/tail v1.4.8 h1:nPr65rt6Y5JFSKQO7qToXr7pePgD6Gwiw05lkbyAQTE= github.com/nxadm/tail v1.4.8/go.mod h1:+ncqLTQzXmGhMZNUePPaPqPvBxHAIsmXswZKocGu+AU= github.com/onsi/ginkgo v1.16.5 h1:8xi0RTUf59SOSfEtZMvwTvXYMzG4gV23XVHOZiXNtnE= github.com/onsi/ginkgo v1.16.5/go.mod h1:+E8gABHa3K6zRBolWtd+ROzc/U5bkGt0FwiG042wbpU= github.com/onsi/gomega v1.18.1 h1:M1GfJqGRrBrrGGsbxzV5dqM2U2ApXefZCQpkukxYRLE= github.com/onsi/gomega v1.18.1/go.mod h1:0q+aL8jAiMXy9hbwj2mr5GziHiwhAIQpFmmtT5hitRs= +github.com/onsi/gomega v1.39.1 h1:1IJLAad4zjPn2PsnhH70V4DKRFlrCzGBNrNaru+Vf28= +golang.org/x/mod v0.34.0 h1:xIHgNUUnW6sYkcM5Jleh05DvLOtwc6RitGHbDk4akRI= +golang.org/x/mod v0.34.0/go.mod h1:ykgH52iCZe79kzLLMhyCUzhMci+nQj+0XkbXpNYtVjY= golang.org/x/net v0.0.0-20210428140749-89ef3d95e781 h1:DzZ89McO9/gWPsQXS/FVKAlG02ZjaQ6AlZRBimEYOd0= golang.org/x/net v0.0.0-20210428140749-89ef3d95e781/go.mod h1:OJAsFXCWl8Ukc7SiCT/9KSuxbyM7479/AVlXFRxuMCk= +golang.org/x/net v0.52.0 h1:He/TN1l0e4mmR3QqHMT2Xab3Aj3L9qjbhRm78/6jrW0= +golang.org/x/sync v0.20.0 h1:e0PTpb7pjO8GAtTs2dQ6jYa5BWYlMuX047Dco/pItO4= +golang.org/x/sync v0.20.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0= golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e h1:fLOSk5Q00efkSvAm+4xcoXD+RRmLmmulPn5I3Y9F2EM= golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/text v0.3.6 h1:aRYxNxv6iGQlyVaZmk6ZgYEDa+Jg18DxebPSrd6bg1M= golang.org/x/text v0.3.6/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= +golang.org/x/text v0.35.0 h1:JOVx6vVDFokkpaq1AEptVzLTpDe9KGpj5tR4/X+ybL8= +golang.org/x/text v0.35.0/go.mod h1:khi/HExzZJ2pGnjenulevKNX1W67CUy0AsXcNubPGCA= +golang.org/x/tools v0.43.0 h1:12BdW9CeB3Z+J/I/wj34VMl8X+fEXBxVR90JeMX5E7s= +golang.org/x/tools v0.43.0/go.mod h1:uHkMso649BX2cZK6+RpuIPXS3ho2hZo4FVwfoy1vIk0= gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ= gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw= gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY= diff --git a/internal/env/envfakes/fake_environment.go b/internal/env/envfakes/fake_environment.go new file mode 100644 index 000000000..165ae7a1d --- /dev/null +++ b/internal/env/envfakes/fake_environment.go @@ -0,0 +1,1422 @@ +// Code generated by counterfeiter. DO NOT EDIT. +package envfakes + +import ( + "srsx/internal/env" + "sync" +) + +type FakeEnvironment struct { + DefaultBackendAPIStub func() string + defaultBackendAPIMutex sync.RWMutex + defaultBackendAPIArgsForCall []struct { + } + defaultBackendAPIReturns struct { + result1 string + } + defaultBackendAPIReturnsOnCall map[int]struct { + result1 string + } + DefaultBackendEnabledStub func() string + defaultBackendEnabledMutex sync.RWMutex + defaultBackendEnabledArgsForCall []struct { + } + defaultBackendEnabledReturns struct { + result1 string + } + defaultBackendEnabledReturnsOnCall map[int]struct { + result1 string + } + DefaultBackendHttpStub func() string + defaultBackendHttpMutex sync.RWMutex + defaultBackendHttpArgsForCall []struct { + } + defaultBackendHttpReturns struct { + result1 string + } + defaultBackendHttpReturnsOnCall map[int]struct { + result1 string + } + DefaultBackendIPStub func() string + defaultBackendIPMutex sync.RWMutex + defaultBackendIPArgsForCall []struct { + } + defaultBackendIPReturns struct { + result1 string + } + defaultBackendIPReturnsOnCall map[int]struct { + result1 string + } + DefaultBackendRTCStub func() string + defaultBackendRTCMutex sync.RWMutex + defaultBackendRTCArgsForCall []struct { + } + defaultBackendRTCReturns struct { + result1 string + } + defaultBackendRTCReturnsOnCall map[int]struct { + result1 string + } + DefaultBackendRTMPStub func() string + defaultBackendRTMPMutex sync.RWMutex + defaultBackendRTMPArgsForCall []struct { + } + defaultBackendRTMPReturns struct { + result1 string + } + defaultBackendRTMPReturnsOnCall map[int]struct { + result1 string + } + DefaultBackendSRTStub func() string + defaultBackendSRTMutex sync.RWMutex + defaultBackendSRTArgsForCall []struct { + } + defaultBackendSRTReturns struct { + result1 string + } + defaultBackendSRTReturnsOnCall map[int]struct { + result1 string + } + ForceQuitTimeoutStub func() string + forceQuitTimeoutMutex sync.RWMutex + forceQuitTimeoutArgsForCall []struct { + } + forceQuitTimeoutReturns struct { + result1 string + } + forceQuitTimeoutReturnsOnCall map[int]struct { + result1 string + } + GoPprofStub func() string + goPprofMutex sync.RWMutex + goPprofArgsForCall []struct { + } + goPprofReturns struct { + result1 string + } + goPprofReturnsOnCall map[int]struct { + result1 string + } + GraceQuitTimeoutStub func() string + graceQuitTimeoutMutex sync.RWMutex + graceQuitTimeoutArgsForCall []struct { + } + graceQuitTimeoutReturns struct { + result1 string + } + graceQuitTimeoutReturnsOnCall map[int]struct { + result1 string + } + HttpAPIStub func() string + httpAPIMutex sync.RWMutex + httpAPIArgsForCall []struct { + } + httpAPIReturns struct { + result1 string + } + httpAPIReturnsOnCall map[int]struct { + result1 string + } + HttpServerStub func() string + httpServerMutex sync.RWMutex + httpServerArgsForCall []struct { + } + httpServerReturns struct { + result1 string + } + httpServerReturnsOnCall map[int]struct { + result1 string + } + LoadBalancerTypeStub func() string + loadBalancerTypeMutex sync.RWMutex + loadBalancerTypeArgsForCall []struct { + } + loadBalancerTypeReturns struct { + result1 string + } + loadBalancerTypeReturnsOnCall map[int]struct { + result1 string + } + RedisDBStub func() string + redisDBMutex sync.RWMutex + redisDBArgsForCall []struct { + } + redisDBReturns struct { + result1 string + } + redisDBReturnsOnCall map[int]struct { + result1 string + } + RedisHostStub func() string + redisHostMutex sync.RWMutex + redisHostArgsForCall []struct { + } + redisHostReturns struct { + result1 string + } + redisHostReturnsOnCall map[int]struct { + result1 string + } + RedisPasswordStub func() string + redisPasswordMutex sync.RWMutex + redisPasswordArgsForCall []struct { + } + redisPasswordReturns struct { + result1 string + } + redisPasswordReturnsOnCall map[int]struct { + result1 string + } + RedisPortStub func() string + redisPortMutex sync.RWMutex + redisPortArgsForCall []struct { + } + redisPortReturns struct { + result1 string + } + redisPortReturnsOnCall map[int]struct { + result1 string + } + RtmpServerStub func() string + rtmpServerMutex sync.RWMutex + rtmpServerArgsForCall []struct { + } + rtmpServerReturns struct { + result1 string + } + rtmpServerReturnsOnCall map[int]struct { + result1 string + } + SRTServerStub func() string + sRTServerMutex sync.RWMutex + sRTServerArgsForCall []struct { + } + sRTServerReturns struct { + result1 string + } + sRTServerReturnsOnCall map[int]struct { + result1 string + } + StaticFilesStub func() string + staticFilesMutex sync.RWMutex + staticFilesArgsForCall []struct { + } + staticFilesReturns struct { + result1 string + } + staticFilesReturnsOnCall map[int]struct { + result1 string + } + SystemAPIStub func() string + systemAPIMutex sync.RWMutex + systemAPIArgsForCall []struct { + } + systemAPIReturns struct { + result1 string + } + systemAPIReturnsOnCall map[int]struct { + result1 string + } + WebRTCServerStub func() string + webRTCServerMutex sync.RWMutex + webRTCServerArgsForCall []struct { + } + webRTCServerReturns struct { + result1 string + } + webRTCServerReturnsOnCall map[int]struct { + result1 string + } + invocations map[string][][]interface{} + invocationsMutex sync.RWMutex +} + +func (fake *FakeEnvironment) DefaultBackendAPI() string { + fake.defaultBackendAPIMutex.Lock() + ret, specificReturn := fake.defaultBackendAPIReturnsOnCall[len(fake.defaultBackendAPIArgsForCall)] + fake.defaultBackendAPIArgsForCall = append(fake.defaultBackendAPIArgsForCall, struct { + }{}) + stub := fake.DefaultBackendAPIStub + fakeReturns := fake.defaultBackendAPIReturns + fake.recordInvocation("DefaultBackendAPI", []interface{}{}) + fake.defaultBackendAPIMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeEnvironment) DefaultBackendAPICallCount() int { + fake.defaultBackendAPIMutex.RLock() + defer fake.defaultBackendAPIMutex.RUnlock() + return len(fake.defaultBackendAPIArgsForCall) +} + +func (fake *FakeEnvironment) DefaultBackendAPICalls(stub func() string) { + fake.defaultBackendAPIMutex.Lock() + defer fake.defaultBackendAPIMutex.Unlock() + fake.DefaultBackendAPIStub = stub +} + +func (fake *FakeEnvironment) DefaultBackendAPIReturns(result1 string) { + fake.defaultBackendAPIMutex.Lock() + defer fake.defaultBackendAPIMutex.Unlock() + fake.DefaultBackendAPIStub = nil + fake.defaultBackendAPIReturns = struct { + result1 string + }{result1} +} + +func (fake *FakeEnvironment) DefaultBackendAPIReturnsOnCall(i int, result1 string) { + fake.defaultBackendAPIMutex.Lock() + defer fake.defaultBackendAPIMutex.Unlock() + fake.DefaultBackendAPIStub = nil + if fake.defaultBackendAPIReturnsOnCall == nil { + fake.defaultBackendAPIReturnsOnCall = make(map[int]struct { + result1 string + }) + } + fake.defaultBackendAPIReturnsOnCall[i] = struct { + result1 string + }{result1} +} + +func (fake *FakeEnvironment) DefaultBackendEnabled() string { + fake.defaultBackendEnabledMutex.Lock() + ret, specificReturn := fake.defaultBackendEnabledReturnsOnCall[len(fake.defaultBackendEnabledArgsForCall)] + fake.defaultBackendEnabledArgsForCall = append(fake.defaultBackendEnabledArgsForCall, struct { + }{}) + stub := fake.DefaultBackendEnabledStub + fakeReturns := fake.defaultBackendEnabledReturns + fake.recordInvocation("DefaultBackendEnabled", []interface{}{}) + fake.defaultBackendEnabledMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeEnvironment) DefaultBackendEnabledCallCount() int { + fake.defaultBackendEnabledMutex.RLock() + defer fake.defaultBackendEnabledMutex.RUnlock() + return len(fake.defaultBackendEnabledArgsForCall) +} + +func (fake *FakeEnvironment) DefaultBackendEnabledCalls(stub func() string) { + fake.defaultBackendEnabledMutex.Lock() + defer fake.defaultBackendEnabledMutex.Unlock() + fake.DefaultBackendEnabledStub = stub +} + +func (fake *FakeEnvironment) DefaultBackendEnabledReturns(result1 string) { + fake.defaultBackendEnabledMutex.Lock() + defer fake.defaultBackendEnabledMutex.Unlock() + fake.DefaultBackendEnabledStub = nil + fake.defaultBackendEnabledReturns = struct { + result1 string + }{result1} +} + +func (fake *FakeEnvironment) DefaultBackendEnabledReturnsOnCall(i int, result1 string) { + fake.defaultBackendEnabledMutex.Lock() + defer fake.defaultBackendEnabledMutex.Unlock() + fake.DefaultBackendEnabledStub = nil + if fake.defaultBackendEnabledReturnsOnCall == nil { + fake.defaultBackendEnabledReturnsOnCall = make(map[int]struct { + result1 string + }) + } + fake.defaultBackendEnabledReturnsOnCall[i] = struct { + result1 string + }{result1} +} + +func (fake *FakeEnvironment) DefaultBackendHttp() string { + fake.defaultBackendHttpMutex.Lock() + ret, specificReturn := fake.defaultBackendHttpReturnsOnCall[len(fake.defaultBackendHttpArgsForCall)] + fake.defaultBackendHttpArgsForCall = append(fake.defaultBackendHttpArgsForCall, struct { + }{}) + stub := fake.DefaultBackendHttpStub + fakeReturns := fake.defaultBackendHttpReturns + fake.recordInvocation("DefaultBackendHttp", []interface{}{}) + fake.defaultBackendHttpMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeEnvironment) DefaultBackendHttpCallCount() int { + fake.defaultBackendHttpMutex.RLock() + defer fake.defaultBackendHttpMutex.RUnlock() + return len(fake.defaultBackendHttpArgsForCall) +} + +func (fake *FakeEnvironment) DefaultBackendHttpCalls(stub func() string) { + fake.defaultBackendHttpMutex.Lock() + defer fake.defaultBackendHttpMutex.Unlock() + fake.DefaultBackendHttpStub = stub +} + +func (fake *FakeEnvironment) DefaultBackendHttpReturns(result1 string) { + fake.defaultBackendHttpMutex.Lock() + defer fake.defaultBackendHttpMutex.Unlock() + fake.DefaultBackendHttpStub = nil + fake.defaultBackendHttpReturns = struct { + result1 string + }{result1} +} + +func (fake *FakeEnvironment) DefaultBackendHttpReturnsOnCall(i int, result1 string) { + fake.defaultBackendHttpMutex.Lock() + defer fake.defaultBackendHttpMutex.Unlock() + fake.DefaultBackendHttpStub = nil + if fake.defaultBackendHttpReturnsOnCall == nil { + fake.defaultBackendHttpReturnsOnCall = make(map[int]struct { + result1 string + }) + } + fake.defaultBackendHttpReturnsOnCall[i] = struct { + result1 string + }{result1} +} + +func (fake *FakeEnvironment) DefaultBackendIP() string { + fake.defaultBackendIPMutex.Lock() + ret, specificReturn := fake.defaultBackendIPReturnsOnCall[len(fake.defaultBackendIPArgsForCall)] + fake.defaultBackendIPArgsForCall = append(fake.defaultBackendIPArgsForCall, struct { + }{}) + stub := fake.DefaultBackendIPStub + fakeReturns := fake.defaultBackendIPReturns + fake.recordInvocation("DefaultBackendIP", []interface{}{}) + fake.defaultBackendIPMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeEnvironment) DefaultBackendIPCallCount() int { + fake.defaultBackendIPMutex.RLock() + defer fake.defaultBackendIPMutex.RUnlock() + return len(fake.defaultBackendIPArgsForCall) +} + +func (fake *FakeEnvironment) DefaultBackendIPCalls(stub func() string) { + fake.defaultBackendIPMutex.Lock() + defer fake.defaultBackendIPMutex.Unlock() + fake.DefaultBackendIPStub = stub +} + +func (fake *FakeEnvironment) DefaultBackendIPReturns(result1 string) { + fake.defaultBackendIPMutex.Lock() + defer fake.defaultBackendIPMutex.Unlock() + fake.DefaultBackendIPStub = nil + fake.defaultBackendIPReturns = struct { + result1 string + }{result1} +} + +func (fake *FakeEnvironment) DefaultBackendIPReturnsOnCall(i int, result1 string) { + fake.defaultBackendIPMutex.Lock() + defer fake.defaultBackendIPMutex.Unlock() + fake.DefaultBackendIPStub = nil + if fake.defaultBackendIPReturnsOnCall == nil { + fake.defaultBackendIPReturnsOnCall = make(map[int]struct { + result1 string + }) + } + fake.defaultBackendIPReturnsOnCall[i] = struct { + result1 string + }{result1} +} + +func (fake *FakeEnvironment) DefaultBackendRTC() string { + fake.defaultBackendRTCMutex.Lock() + ret, specificReturn := fake.defaultBackendRTCReturnsOnCall[len(fake.defaultBackendRTCArgsForCall)] + fake.defaultBackendRTCArgsForCall = append(fake.defaultBackendRTCArgsForCall, struct { + }{}) + stub := fake.DefaultBackendRTCStub + fakeReturns := fake.defaultBackendRTCReturns + fake.recordInvocation("DefaultBackendRTC", []interface{}{}) + fake.defaultBackendRTCMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeEnvironment) DefaultBackendRTCCallCount() int { + fake.defaultBackendRTCMutex.RLock() + defer fake.defaultBackendRTCMutex.RUnlock() + return len(fake.defaultBackendRTCArgsForCall) +} + +func (fake *FakeEnvironment) DefaultBackendRTCCalls(stub func() string) { + fake.defaultBackendRTCMutex.Lock() + defer fake.defaultBackendRTCMutex.Unlock() + fake.DefaultBackendRTCStub = stub +} + +func (fake *FakeEnvironment) DefaultBackendRTCReturns(result1 string) { + fake.defaultBackendRTCMutex.Lock() + defer fake.defaultBackendRTCMutex.Unlock() + fake.DefaultBackendRTCStub = nil + fake.defaultBackendRTCReturns = struct { + result1 string + }{result1} +} + +func (fake *FakeEnvironment) DefaultBackendRTCReturnsOnCall(i int, result1 string) { + fake.defaultBackendRTCMutex.Lock() + defer fake.defaultBackendRTCMutex.Unlock() + fake.DefaultBackendRTCStub = nil + if fake.defaultBackendRTCReturnsOnCall == nil { + fake.defaultBackendRTCReturnsOnCall = make(map[int]struct { + result1 string + }) + } + fake.defaultBackendRTCReturnsOnCall[i] = struct { + result1 string + }{result1} +} + +func (fake *FakeEnvironment) DefaultBackendRTMP() string { + fake.defaultBackendRTMPMutex.Lock() + ret, specificReturn := fake.defaultBackendRTMPReturnsOnCall[len(fake.defaultBackendRTMPArgsForCall)] + fake.defaultBackendRTMPArgsForCall = append(fake.defaultBackendRTMPArgsForCall, struct { + }{}) + stub := fake.DefaultBackendRTMPStub + fakeReturns := fake.defaultBackendRTMPReturns + fake.recordInvocation("DefaultBackendRTMP", []interface{}{}) + fake.defaultBackendRTMPMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeEnvironment) DefaultBackendRTMPCallCount() int { + fake.defaultBackendRTMPMutex.RLock() + defer fake.defaultBackendRTMPMutex.RUnlock() + return len(fake.defaultBackendRTMPArgsForCall) +} + +func (fake *FakeEnvironment) DefaultBackendRTMPCalls(stub func() string) { + fake.defaultBackendRTMPMutex.Lock() + defer fake.defaultBackendRTMPMutex.Unlock() + fake.DefaultBackendRTMPStub = stub +} + +func (fake *FakeEnvironment) DefaultBackendRTMPReturns(result1 string) { + fake.defaultBackendRTMPMutex.Lock() + defer fake.defaultBackendRTMPMutex.Unlock() + fake.DefaultBackendRTMPStub = nil + fake.defaultBackendRTMPReturns = struct { + result1 string + }{result1} +} + +func (fake *FakeEnvironment) DefaultBackendRTMPReturnsOnCall(i int, result1 string) { + fake.defaultBackendRTMPMutex.Lock() + defer fake.defaultBackendRTMPMutex.Unlock() + fake.DefaultBackendRTMPStub = nil + if fake.defaultBackendRTMPReturnsOnCall == nil { + fake.defaultBackendRTMPReturnsOnCall = make(map[int]struct { + result1 string + }) + } + fake.defaultBackendRTMPReturnsOnCall[i] = struct { + result1 string + }{result1} +} + +func (fake *FakeEnvironment) DefaultBackendSRT() string { + fake.defaultBackendSRTMutex.Lock() + ret, specificReturn := fake.defaultBackendSRTReturnsOnCall[len(fake.defaultBackendSRTArgsForCall)] + fake.defaultBackendSRTArgsForCall = append(fake.defaultBackendSRTArgsForCall, struct { + }{}) + stub := fake.DefaultBackendSRTStub + fakeReturns := fake.defaultBackendSRTReturns + fake.recordInvocation("DefaultBackendSRT", []interface{}{}) + fake.defaultBackendSRTMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeEnvironment) DefaultBackendSRTCallCount() int { + fake.defaultBackendSRTMutex.RLock() + defer fake.defaultBackendSRTMutex.RUnlock() + return len(fake.defaultBackendSRTArgsForCall) +} + +func (fake *FakeEnvironment) DefaultBackendSRTCalls(stub func() string) { + fake.defaultBackendSRTMutex.Lock() + defer fake.defaultBackendSRTMutex.Unlock() + fake.DefaultBackendSRTStub = stub +} + +func (fake *FakeEnvironment) DefaultBackendSRTReturns(result1 string) { + fake.defaultBackendSRTMutex.Lock() + defer fake.defaultBackendSRTMutex.Unlock() + fake.DefaultBackendSRTStub = nil + fake.defaultBackendSRTReturns = struct { + result1 string + }{result1} +} + +func (fake *FakeEnvironment) DefaultBackendSRTReturnsOnCall(i int, result1 string) { + fake.defaultBackendSRTMutex.Lock() + defer fake.defaultBackendSRTMutex.Unlock() + fake.DefaultBackendSRTStub = nil + if fake.defaultBackendSRTReturnsOnCall == nil { + fake.defaultBackendSRTReturnsOnCall = make(map[int]struct { + result1 string + }) + } + fake.defaultBackendSRTReturnsOnCall[i] = struct { + result1 string + }{result1} +} + +func (fake *FakeEnvironment) ForceQuitTimeout() string { + fake.forceQuitTimeoutMutex.Lock() + ret, specificReturn := fake.forceQuitTimeoutReturnsOnCall[len(fake.forceQuitTimeoutArgsForCall)] + fake.forceQuitTimeoutArgsForCall = append(fake.forceQuitTimeoutArgsForCall, struct { + }{}) + stub := fake.ForceQuitTimeoutStub + fakeReturns := fake.forceQuitTimeoutReturns + fake.recordInvocation("ForceQuitTimeout", []interface{}{}) + fake.forceQuitTimeoutMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeEnvironment) ForceQuitTimeoutCallCount() int { + fake.forceQuitTimeoutMutex.RLock() + defer fake.forceQuitTimeoutMutex.RUnlock() + return len(fake.forceQuitTimeoutArgsForCall) +} + +func (fake *FakeEnvironment) ForceQuitTimeoutCalls(stub func() string) { + fake.forceQuitTimeoutMutex.Lock() + defer fake.forceQuitTimeoutMutex.Unlock() + fake.ForceQuitTimeoutStub = stub +} + +func (fake *FakeEnvironment) ForceQuitTimeoutReturns(result1 string) { + fake.forceQuitTimeoutMutex.Lock() + defer fake.forceQuitTimeoutMutex.Unlock() + fake.ForceQuitTimeoutStub = nil + fake.forceQuitTimeoutReturns = struct { + result1 string + }{result1} +} + +func (fake *FakeEnvironment) ForceQuitTimeoutReturnsOnCall(i int, result1 string) { + fake.forceQuitTimeoutMutex.Lock() + defer fake.forceQuitTimeoutMutex.Unlock() + fake.ForceQuitTimeoutStub = nil + if fake.forceQuitTimeoutReturnsOnCall == nil { + fake.forceQuitTimeoutReturnsOnCall = make(map[int]struct { + result1 string + }) + } + fake.forceQuitTimeoutReturnsOnCall[i] = struct { + result1 string + }{result1} +} + +func (fake *FakeEnvironment) GoPprof() string { + fake.goPprofMutex.Lock() + ret, specificReturn := fake.goPprofReturnsOnCall[len(fake.goPprofArgsForCall)] + fake.goPprofArgsForCall = append(fake.goPprofArgsForCall, struct { + }{}) + stub := fake.GoPprofStub + fakeReturns := fake.goPprofReturns + fake.recordInvocation("GoPprof", []interface{}{}) + fake.goPprofMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeEnvironment) GoPprofCallCount() int { + fake.goPprofMutex.RLock() + defer fake.goPprofMutex.RUnlock() + return len(fake.goPprofArgsForCall) +} + +func (fake *FakeEnvironment) GoPprofCalls(stub func() string) { + fake.goPprofMutex.Lock() + defer fake.goPprofMutex.Unlock() + fake.GoPprofStub = stub +} + +func (fake *FakeEnvironment) GoPprofReturns(result1 string) { + fake.goPprofMutex.Lock() + defer fake.goPprofMutex.Unlock() + fake.GoPprofStub = nil + fake.goPprofReturns = struct { + result1 string + }{result1} +} + +func (fake *FakeEnvironment) GoPprofReturnsOnCall(i int, result1 string) { + fake.goPprofMutex.Lock() + defer fake.goPprofMutex.Unlock() + fake.GoPprofStub = nil + if fake.goPprofReturnsOnCall == nil { + fake.goPprofReturnsOnCall = make(map[int]struct { + result1 string + }) + } + fake.goPprofReturnsOnCall[i] = struct { + result1 string + }{result1} +} + +func (fake *FakeEnvironment) GraceQuitTimeout() string { + fake.graceQuitTimeoutMutex.Lock() + ret, specificReturn := fake.graceQuitTimeoutReturnsOnCall[len(fake.graceQuitTimeoutArgsForCall)] + fake.graceQuitTimeoutArgsForCall = append(fake.graceQuitTimeoutArgsForCall, struct { + }{}) + stub := fake.GraceQuitTimeoutStub + fakeReturns := fake.graceQuitTimeoutReturns + fake.recordInvocation("GraceQuitTimeout", []interface{}{}) + fake.graceQuitTimeoutMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeEnvironment) GraceQuitTimeoutCallCount() int { + fake.graceQuitTimeoutMutex.RLock() + defer fake.graceQuitTimeoutMutex.RUnlock() + return len(fake.graceQuitTimeoutArgsForCall) +} + +func (fake *FakeEnvironment) GraceQuitTimeoutCalls(stub func() string) { + fake.graceQuitTimeoutMutex.Lock() + defer fake.graceQuitTimeoutMutex.Unlock() + fake.GraceQuitTimeoutStub = stub +} + +func (fake *FakeEnvironment) GraceQuitTimeoutReturns(result1 string) { + fake.graceQuitTimeoutMutex.Lock() + defer fake.graceQuitTimeoutMutex.Unlock() + fake.GraceQuitTimeoutStub = nil + fake.graceQuitTimeoutReturns = struct { + result1 string + }{result1} +} + +func (fake *FakeEnvironment) GraceQuitTimeoutReturnsOnCall(i int, result1 string) { + fake.graceQuitTimeoutMutex.Lock() + defer fake.graceQuitTimeoutMutex.Unlock() + fake.GraceQuitTimeoutStub = nil + if fake.graceQuitTimeoutReturnsOnCall == nil { + fake.graceQuitTimeoutReturnsOnCall = make(map[int]struct { + result1 string + }) + } + fake.graceQuitTimeoutReturnsOnCall[i] = struct { + result1 string + }{result1} +} + +func (fake *FakeEnvironment) HttpAPI() string { + fake.httpAPIMutex.Lock() + ret, specificReturn := fake.httpAPIReturnsOnCall[len(fake.httpAPIArgsForCall)] + fake.httpAPIArgsForCall = append(fake.httpAPIArgsForCall, struct { + }{}) + stub := fake.HttpAPIStub + fakeReturns := fake.httpAPIReturns + fake.recordInvocation("HttpAPI", []interface{}{}) + fake.httpAPIMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeEnvironment) HttpAPICallCount() int { + fake.httpAPIMutex.RLock() + defer fake.httpAPIMutex.RUnlock() + return len(fake.httpAPIArgsForCall) +} + +func (fake *FakeEnvironment) HttpAPICalls(stub func() string) { + fake.httpAPIMutex.Lock() + defer fake.httpAPIMutex.Unlock() + fake.HttpAPIStub = stub +} + +func (fake *FakeEnvironment) HttpAPIReturns(result1 string) { + fake.httpAPIMutex.Lock() + defer fake.httpAPIMutex.Unlock() + fake.HttpAPIStub = nil + fake.httpAPIReturns = struct { + result1 string + }{result1} +} + +func (fake *FakeEnvironment) HttpAPIReturnsOnCall(i int, result1 string) { + fake.httpAPIMutex.Lock() + defer fake.httpAPIMutex.Unlock() + fake.HttpAPIStub = nil + if fake.httpAPIReturnsOnCall == nil { + fake.httpAPIReturnsOnCall = make(map[int]struct { + result1 string + }) + } + fake.httpAPIReturnsOnCall[i] = struct { + result1 string + }{result1} +} + +func (fake *FakeEnvironment) HttpServer() string { + fake.httpServerMutex.Lock() + ret, specificReturn := fake.httpServerReturnsOnCall[len(fake.httpServerArgsForCall)] + fake.httpServerArgsForCall = append(fake.httpServerArgsForCall, struct { + }{}) + stub := fake.HttpServerStub + fakeReturns := fake.httpServerReturns + fake.recordInvocation("HttpServer", []interface{}{}) + fake.httpServerMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeEnvironment) HttpServerCallCount() int { + fake.httpServerMutex.RLock() + defer fake.httpServerMutex.RUnlock() + return len(fake.httpServerArgsForCall) +} + +func (fake *FakeEnvironment) HttpServerCalls(stub func() string) { + fake.httpServerMutex.Lock() + defer fake.httpServerMutex.Unlock() + fake.HttpServerStub = stub +} + +func (fake *FakeEnvironment) HttpServerReturns(result1 string) { + fake.httpServerMutex.Lock() + defer fake.httpServerMutex.Unlock() + fake.HttpServerStub = nil + fake.httpServerReturns = struct { + result1 string + }{result1} +} + +func (fake *FakeEnvironment) HttpServerReturnsOnCall(i int, result1 string) { + fake.httpServerMutex.Lock() + defer fake.httpServerMutex.Unlock() + fake.HttpServerStub = nil + if fake.httpServerReturnsOnCall == nil { + fake.httpServerReturnsOnCall = make(map[int]struct { + result1 string + }) + } + fake.httpServerReturnsOnCall[i] = struct { + result1 string + }{result1} +} + +func (fake *FakeEnvironment) LoadBalancerType() string { + fake.loadBalancerTypeMutex.Lock() + ret, specificReturn := fake.loadBalancerTypeReturnsOnCall[len(fake.loadBalancerTypeArgsForCall)] + fake.loadBalancerTypeArgsForCall = append(fake.loadBalancerTypeArgsForCall, struct { + }{}) + stub := fake.LoadBalancerTypeStub + fakeReturns := fake.loadBalancerTypeReturns + fake.recordInvocation("LoadBalancerType", []interface{}{}) + fake.loadBalancerTypeMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeEnvironment) LoadBalancerTypeCallCount() int { + fake.loadBalancerTypeMutex.RLock() + defer fake.loadBalancerTypeMutex.RUnlock() + return len(fake.loadBalancerTypeArgsForCall) +} + +func (fake *FakeEnvironment) LoadBalancerTypeCalls(stub func() string) { + fake.loadBalancerTypeMutex.Lock() + defer fake.loadBalancerTypeMutex.Unlock() + fake.LoadBalancerTypeStub = stub +} + +func (fake *FakeEnvironment) LoadBalancerTypeReturns(result1 string) { + fake.loadBalancerTypeMutex.Lock() + defer fake.loadBalancerTypeMutex.Unlock() + fake.LoadBalancerTypeStub = nil + fake.loadBalancerTypeReturns = struct { + result1 string + }{result1} +} + +func (fake *FakeEnvironment) LoadBalancerTypeReturnsOnCall(i int, result1 string) { + fake.loadBalancerTypeMutex.Lock() + defer fake.loadBalancerTypeMutex.Unlock() + fake.LoadBalancerTypeStub = nil + if fake.loadBalancerTypeReturnsOnCall == nil { + fake.loadBalancerTypeReturnsOnCall = make(map[int]struct { + result1 string + }) + } + fake.loadBalancerTypeReturnsOnCall[i] = struct { + result1 string + }{result1} +} + +func (fake *FakeEnvironment) RedisDB() string { + fake.redisDBMutex.Lock() + ret, specificReturn := fake.redisDBReturnsOnCall[len(fake.redisDBArgsForCall)] + fake.redisDBArgsForCall = append(fake.redisDBArgsForCall, struct { + }{}) + stub := fake.RedisDBStub + fakeReturns := fake.redisDBReturns + fake.recordInvocation("RedisDB", []interface{}{}) + fake.redisDBMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeEnvironment) RedisDBCallCount() int { + fake.redisDBMutex.RLock() + defer fake.redisDBMutex.RUnlock() + return len(fake.redisDBArgsForCall) +} + +func (fake *FakeEnvironment) RedisDBCalls(stub func() string) { + fake.redisDBMutex.Lock() + defer fake.redisDBMutex.Unlock() + fake.RedisDBStub = stub +} + +func (fake *FakeEnvironment) RedisDBReturns(result1 string) { + fake.redisDBMutex.Lock() + defer fake.redisDBMutex.Unlock() + fake.RedisDBStub = nil + fake.redisDBReturns = struct { + result1 string + }{result1} +} + +func (fake *FakeEnvironment) RedisDBReturnsOnCall(i int, result1 string) { + fake.redisDBMutex.Lock() + defer fake.redisDBMutex.Unlock() + fake.RedisDBStub = nil + if fake.redisDBReturnsOnCall == nil { + fake.redisDBReturnsOnCall = make(map[int]struct { + result1 string + }) + } + fake.redisDBReturnsOnCall[i] = struct { + result1 string + }{result1} +} + +func (fake *FakeEnvironment) RedisHost() string { + fake.redisHostMutex.Lock() + ret, specificReturn := fake.redisHostReturnsOnCall[len(fake.redisHostArgsForCall)] + fake.redisHostArgsForCall = append(fake.redisHostArgsForCall, struct { + }{}) + stub := fake.RedisHostStub + fakeReturns := fake.redisHostReturns + fake.recordInvocation("RedisHost", []interface{}{}) + fake.redisHostMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeEnvironment) RedisHostCallCount() int { + fake.redisHostMutex.RLock() + defer fake.redisHostMutex.RUnlock() + return len(fake.redisHostArgsForCall) +} + +func (fake *FakeEnvironment) RedisHostCalls(stub func() string) { + fake.redisHostMutex.Lock() + defer fake.redisHostMutex.Unlock() + fake.RedisHostStub = stub +} + +func (fake *FakeEnvironment) RedisHostReturns(result1 string) { + fake.redisHostMutex.Lock() + defer fake.redisHostMutex.Unlock() + fake.RedisHostStub = nil + fake.redisHostReturns = struct { + result1 string + }{result1} +} + +func (fake *FakeEnvironment) RedisHostReturnsOnCall(i int, result1 string) { + fake.redisHostMutex.Lock() + defer fake.redisHostMutex.Unlock() + fake.RedisHostStub = nil + if fake.redisHostReturnsOnCall == nil { + fake.redisHostReturnsOnCall = make(map[int]struct { + result1 string + }) + } + fake.redisHostReturnsOnCall[i] = struct { + result1 string + }{result1} +} + +func (fake *FakeEnvironment) RedisPassword() string { + fake.redisPasswordMutex.Lock() + ret, specificReturn := fake.redisPasswordReturnsOnCall[len(fake.redisPasswordArgsForCall)] + fake.redisPasswordArgsForCall = append(fake.redisPasswordArgsForCall, struct { + }{}) + stub := fake.RedisPasswordStub + fakeReturns := fake.redisPasswordReturns + fake.recordInvocation("RedisPassword", []interface{}{}) + fake.redisPasswordMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeEnvironment) RedisPasswordCallCount() int { + fake.redisPasswordMutex.RLock() + defer fake.redisPasswordMutex.RUnlock() + return len(fake.redisPasswordArgsForCall) +} + +func (fake *FakeEnvironment) RedisPasswordCalls(stub func() string) { + fake.redisPasswordMutex.Lock() + defer fake.redisPasswordMutex.Unlock() + fake.RedisPasswordStub = stub +} + +func (fake *FakeEnvironment) RedisPasswordReturns(result1 string) { + fake.redisPasswordMutex.Lock() + defer fake.redisPasswordMutex.Unlock() + fake.RedisPasswordStub = nil + fake.redisPasswordReturns = struct { + result1 string + }{result1} +} + +func (fake *FakeEnvironment) RedisPasswordReturnsOnCall(i int, result1 string) { + fake.redisPasswordMutex.Lock() + defer fake.redisPasswordMutex.Unlock() + fake.RedisPasswordStub = nil + if fake.redisPasswordReturnsOnCall == nil { + fake.redisPasswordReturnsOnCall = make(map[int]struct { + result1 string + }) + } + fake.redisPasswordReturnsOnCall[i] = struct { + result1 string + }{result1} +} + +func (fake *FakeEnvironment) RedisPort() string { + fake.redisPortMutex.Lock() + ret, specificReturn := fake.redisPortReturnsOnCall[len(fake.redisPortArgsForCall)] + fake.redisPortArgsForCall = append(fake.redisPortArgsForCall, struct { + }{}) + stub := fake.RedisPortStub + fakeReturns := fake.redisPortReturns + fake.recordInvocation("RedisPort", []interface{}{}) + fake.redisPortMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeEnvironment) RedisPortCallCount() int { + fake.redisPortMutex.RLock() + defer fake.redisPortMutex.RUnlock() + return len(fake.redisPortArgsForCall) +} + +func (fake *FakeEnvironment) RedisPortCalls(stub func() string) { + fake.redisPortMutex.Lock() + defer fake.redisPortMutex.Unlock() + fake.RedisPortStub = stub +} + +func (fake *FakeEnvironment) RedisPortReturns(result1 string) { + fake.redisPortMutex.Lock() + defer fake.redisPortMutex.Unlock() + fake.RedisPortStub = nil + fake.redisPortReturns = struct { + result1 string + }{result1} +} + +func (fake *FakeEnvironment) RedisPortReturnsOnCall(i int, result1 string) { + fake.redisPortMutex.Lock() + defer fake.redisPortMutex.Unlock() + fake.RedisPortStub = nil + if fake.redisPortReturnsOnCall == nil { + fake.redisPortReturnsOnCall = make(map[int]struct { + result1 string + }) + } + fake.redisPortReturnsOnCall[i] = struct { + result1 string + }{result1} +} + +func (fake *FakeEnvironment) RtmpServer() string { + fake.rtmpServerMutex.Lock() + ret, specificReturn := fake.rtmpServerReturnsOnCall[len(fake.rtmpServerArgsForCall)] + fake.rtmpServerArgsForCall = append(fake.rtmpServerArgsForCall, struct { + }{}) + stub := fake.RtmpServerStub + fakeReturns := fake.rtmpServerReturns + fake.recordInvocation("RtmpServer", []interface{}{}) + fake.rtmpServerMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeEnvironment) RtmpServerCallCount() int { + fake.rtmpServerMutex.RLock() + defer fake.rtmpServerMutex.RUnlock() + return len(fake.rtmpServerArgsForCall) +} + +func (fake *FakeEnvironment) RtmpServerCalls(stub func() string) { + fake.rtmpServerMutex.Lock() + defer fake.rtmpServerMutex.Unlock() + fake.RtmpServerStub = stub +} + +func (fake *FakeEnvironment) RtmpServerReturns(result1 string) { + fake.rtmpServerMutex.Lock() + defer fake.rtmpServerMutex.Unlock() + fake.RtmpServerStub = nil + fake.rtmpServerReturns = struct { + result1 string + }{result1} +} + +func (fake *FakeEnvironment) RtmpServerReturnsOnCall(i int, result1 string) { + fake.rtmpServerMutex.Lock() + defer fake.rtmpServerMutex.Unlock() + fake.RtmpServerStub = nil + if fake.rtmpServerReturnsOnCall == nil { + fake.rtmpServerReturnsOnCall = make(map[int]struct { + result1 string + }) + } + fake.rtmpServerReturnsOnCall[i] = struct { + result1 string + }{result1} +} + +func (fake *FakeEnvironment) SRTServer() string { + fake.sRTServerMutex.Lock() + ret, specificReturn := fake.sRTServerReturnsOnCall[len(fake.sRTServerArgsForCall)] + fake.sRTServerArgsForCall = append(fake.sRTServerArgsForCall, struct { + }{}) + stub := fake.SRTServerStub + fakeReturns := fake.sRTServerReturns + fake.recordInvocation("SRTServer", []interface{}{}) + fake.sRTServerMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeEnvironment) SRTServerCallCount() int { + fake.sRTServerMutex.RLock() + defer fake.sRTServerMutex.RUnlock() + return len(fake.sRTServerArgsForCall) +} + +func (fake *FakeEnvironment) SRTServerCalls(stub func() string) { + fake.sRTServerMutex.Lock() + defer fake.sRTServerMutex.Unlock() + fake.SRTServerStub = stub +} + +func (fake *FakeEnvironment) SRTServerReturns(result1 string) { + fake.sRTServerMutex.Lock() + defer fake.sRTServerMutex.Unlock() + fake.SRTServerStub = nil + fake.sRTServerReturns = struct { + result1 string + }{result1} +} + +func (fake *FakeEnvironment) SRTServerReturnsOnCall(i int, result1 string) { + fake.sRTServerMutex.Lock() + defer fake.sRTServerMutex.Unlock() + fake.SRTServerStub = nil + if fake.sRTServerReturnsOnCall == nil { + fake.sRTServerReturnsOnCall = make(map[int]struct { + result1 string + }) + } + fake.sRTServerReturnsOnCall[i] = struct { + result1 string + }{result1} +} + +func (fake *FakeEnvironment) StaticFiles() string { + fake.staticFilesMutex.Lock() + ret, specificReturn := fake.staticFilesReturnsOnCall[len(fake.staticFilesArgsForCall)] + fake.staticFilesArgsForCall = append(fake.staticFilesArgsForCall, struct { + }{}) + stub := fake.StaticFilesStub + fakeReturns := fake.staticFilesReturns + fake.recordInvocation("StaticFiles", []interface{}{}) + fake.staticFilesMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeEnvironment) StaticFilesCallCount() int { + fake.staticFilesMutex.RLock() + defer fake.staticFilesMutex.RUnlock() + return len(fake.staticFilesArgsForCall) +} + +func (fake *FakeEnvironment) StaticFilesCalls(stub func() string) { + fake.staticFilesMutex.Lock() + defer fake.staticFilesMutex.Unlock() + fake.StaticFilesStub = stub +} + +func (fake *FakeEnvironment) StaticFilesReturns(result1 string) { + fake.staticFilesMutex.Lock() + defer fake.staticFilesMutex.Unlock() + fake.StaticFilesStub = nil + fake.staticFilesReturns = struct { + result1 string + }{result1} +} + +func (fake *FakeEnvironment) StaticFilesReturnsOnCall(i int, result1 string) { + fake.staticFilesMutex.Lock() + defer fake.staticFilesMutex.Unlock() + fake.StaticFilesStub = nil + if fake.staticFilesReturnsOnCall == nil { + fake.staticFilesReturnsOnCall = make(map[int]struct { + result1 string + }) + } + fake.staticFilesReturnsOnCall[i] = struct { + result1 string + }{result1} +} + +func (fake *FakeEnvironment) SystemAPI() string { + fake.systemAPIMutex.Lock() + ret, specificReturn := fake.systemAPIReturnsOnCall[len(fake.systemAPIArgsForCall)] + fake.systemAPIArgsForCall = append(fake.systemAPIArgsForCall, struct { + }{}) + stub := fake.SystemAPIStub + fakeReturns := fake.systemAPIReturns + fake.recordInvocation("SystemAPI", []interface{}{}) + fake.systemAPIMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeEnvironment) SystemAPICallCount() int { + fake.systemAPIMutex.RLock() + defer fake.systemAPIMutex.RUnlock() + return len(fake.systemAPIArgsForCall) +} + +func (fake *FakeEnvironment) SystemAPICalls(stub func() string) { + fake.systemAPIMutex.Lock() + defer fake.systemAPIMutex.Unlock() + fake.SystemAPIStub = stub +} + +func (fake *FakeEnvironment) SystemAPIReturns(result1 string) { + fake.systemAPIMutex.Lock() + defer fake.systemAPIMutex.Unlock() + fake.SystemAPIStub = nil + fake.systemAPIReturns = struct { + result1 string + }{result1} +} + +func (fake *FakeEnvironment) SystemAPIReturnsOnCall(i int, result1 string) { + fake.systemAPIMutex.Lock() + defer fake.systemAPIMutex.Unlock() + fake.SystemAPIStub = nil + if fake.systemAPIReturnsOnCall == nil { + fake.systemAPIReturnsOnCall = make(map[int]struct { + result1 string + }) + } + fake.systemAPIReturnsOnCall[i] = struct { + result1 string + }{result1} +} + +func (fake *FakeEnvironment) WebRTCServer() string { + fake.webRTCServerMutex.Lock() + ret, specificReturn := fake.webRTCServerReturnsOnCall[len(fake.webRTCServerArgsForCall)] + fake.webRTCServerArgsForCall = append(fake.webRTCServerArgsForCall, struct { + }{}) + stub := fake.WebRTCServerStub + fakeReturns := fake.webRTCServerReturns + fake.recordInvocation("WebRTCServer", []interface{}{}) + fake.webRTCServerMutex.Unlock() + if stub != nil { + return stub() + } + if specificReturn { + return ret.result1 + } + return fakeReturns.result1 +} + +func (fake *FakeEnvironment) WebRTCServerCallCount() int { + fake.webRTCServerMutex.RLock() + defer fake.webRTCServerMutex.RUnlock() + return len(fake.webRTCServerArgsForCall) +} + +func (fake *FakeEnvironment) WebRTCServerCalls(stub func() string) { + fake.webRTCServerMutex.Lock() + defer fake.webRTCServerMutex.Unlock() + fake.WebRTCServerStub = stub +} + +func (fake *FakeEnvironment) WebRTCServerReturns(result1 string) { + fake.webRTCServerMutex.Lock() + defer fake.webRTCServerMutex.Unlock() + fake.WebRTCServerStub = nil + fake.webRTCServerReturns = struct { + result1 string + }{result1} +} + +func (fake *FakeEnvironment) WebRTCServerReturnsOnCall(i int, result1 string) { + fake.webRTCServerMutex.Lock() + defer fake.webRTCServerMutex.Unlock() + fake.WebRTCServerStub = nil + if fake.webRTCServerReturnsOnCall == nil { + fake.webRTCServerReturnsOnCall = make(map[int]struct { + result1 string + }) + } + fake.webRTCServerReturnsOnCall[i] = struct { + result1 string + }{result1} +} + +func (fake *FakeEnvironment) Invocations() map[string][][]interface{} { + fake.invocationsMutex.RLock() + defer fake.invocationsMutex.RUnlock() + copiedInvocations := map[string][][]interface{}{} + for key, value := range fake.invocations { + copiedInvocations[key] = value + } + return copiedInvocations +} + +func (fake *FakeEnvironment) recordInvocation(key string, args []interface{}) { + fake.invocationsMutex.Lock() + defer fake.invocationsMutex.Unlock() + if fake.invocations == nil { + fake.invocations = map[string][][]interface{}{} + } + if fake.invocations[key] == nil { + fake.invocations[key] = [][]interface{}{} + } + fake.invocations[key] = append(fake.invocations[key], args) +} + +var _ env.Environment = new(FakeEnvironment) diff --git a/internal/env/gen.go b/internal/env/gen.go new file mode 100644 index 000000000..107eee7d2 --- /dev/null +++ b/internal/env/gen.go @@ -0,0 +1,6 @@ +// Copyright (c) 2026 Winlin +// +// SPDX-License-Identifier: MIT +package env + +//go:generate go tool counterfeiter -o envfakes/fake_environment.go . Environment