mirror of
https://github.com/hanzoai/livekit.git
synced 2026-10-30 18:29:34 +00:00
zeekay
e9292da479
This fork lived at github.com/hanzoai/livekit but still declared
`module github.com/livekit/livekit-server`, so all 505 self-references pointed
at upstream. A fork that does not own its module path is the exact thing the
owned-module-paths rule exists to prevent: every import line in every consumer
carries someone else's brand, and `go get` resolves to their code, not ours.
module + 505 self-imports github.com/livekit/livekit-server -> github.com/hanzoai/livekit
KV client github.com/redis/go-redis/v9 -> github.com/hanzokv/go/v9
message bus github.com/livekit/psrpc -> github.com/hanzoai/psrpc
psrpc had to be forked (hanzoai/psrpc, Apache-2.0) because its bus is typed
against the KV client — the same shape redsync had for hanzoai/git.
DELIBERATELY NOT FORKED: github.com/livekit/{protocol,mediatransportutil,
mageutil} keep their addresses. Only `protocol` still reaches go-redis, through
a single file (redis/redis.go) out of 305. Forking an 11.5MB core wire-protocol
library that this server must track in lockstep — and that upstream pushed
yesterday — to change one file trades a tidy dependency graph for permanent
divergence on the fastest-moving dependency here. So one indirect
github.com/redis/go-redis entry remains, via livekit/protocol/redis, and that
is the correct place for it to live.
289 lines
8.5 KiB
Go
289 lines
8.5 KiB
Go
// Code generated by counterfeiter. DO NOT EDIT.
|
|
package servicefakes
|
|
|
|
import (
|
|
"context"
|
|
"sync"
|
|
|
|
"github.com/hanzoai/livekit/pkg/service"
|
|
"github.com/livekit/protocol/livekit"
|
|
)
|
|
|
|
type FakeServiceStore struct {
|
|
ListRoomsStub func(context.Context, []livekit.RoomName) ([]*livekit.Room, error)
|
|
listRoomsMutex sync.RWMutex
|
|
listRoomsArgsForCall []struct {
|
|
arg1 context.Context
|
|
arg2 []livekit.RoomName
|
|
}
|
|
listRoomsReturns struct {
|
|
result1 []*livekit.Room
|
|
result2 error
|
|
}
|
|
listRoomsReturnsOnCall map[int]struct {
|
|
result1 []*livekit.Room
|
|
result2 error
|
|
}
|
|
LoadRoomStub func(context.Context, livekit.RoomName, bool) (*livekit.Room, *livekit.RoomInternal, error)
|
|
loadRoomMutex sync.RWMutex
|
|
loadRoomArgsForCall []struct {
|
|
arg1 context.Context
|
|
arg2 livekit.RoomName
|
|
arg3 bool
|
|
}
|
|
loadRoomReturns struct {
|
|
result1 *livekit.Room
|
|
result2 *livekit.RoomInternal
|
|
result3 error
|
|
}
|
|
loadRoomReturnsOnCall map[int]struct {
|
|
result1 *livekit.Room
|
|
result2 *livekit.RoomInternal
|
|
result3 error
|
|
}
|
|
RoomExistsStub func(context.Context, livekit.RoomName) (bool, error)
|
|
roomExistsMutex sync.RWMutex
|
|
roomExistsArgsForCall []struct {
|
|
arg1 context.Context
|
|
arg2 livekit.RoomName
|
|
}
|
|
roomExistsReturns struct {
|
|
result1 bool
|
|
result2 error
|
|
}
|
|
roomExistsReturnsOnCall map[int]struct {
|
|
result1 bool
|
|
result2 error
|
|
}
|
|
invocations map[string][][]interface{}
|
|
invocationsMutex sync.RWMutex
|
|
}
|
|
|
|
func (fake *FakeServiceStore) ListRooms(arg1 context.Context, arg2 []livekit.RoomName) ([]*livekit.Room, error) {
|
|
var arg2Copy []livekit.RoomName
|
|
if arg2 != nil {
|
|
arg2Copy = make([]livekit.RoomName, len(arg2))
|
|
copy(arg2Copy, arg2)
|
|
}
|
|
fake.listRoomsMutex.Lock()
|
|
ret, specificReturn := fake.listRoomsReturnsOnCall[len(fake.listRoomsArgsForCall)]
|
|
fake.listRoomsArgsForCall = append(fake.listRoomsArgsForCall, struct {
|
|
arg1 context.Context
|
|
arg2 []livekit.RoomName
|
|
}{arg1, arg2Copy})
|
|
stub := fake.ListRoomsStub
|
|
fakeReturns := fake.listRoomsReturns
|
|
fake.recordInvocation("ListRooms", []interface{}{arg1, arg2Copy})
|
|
fake.listRoomsMutex.Unlock()
|
|
if stub != nil {
|
|
return stub(arg1, arg2)
|
|
}
|
|
if specificReturn {
|
|
return ret.result1, ret.result2
|
|
}
|
|
return fakeReturns.result1, fakeReturns.result2
|
|
}
|
|
|
|
func (fake *FakeServiceStore) ListRoomsCallCount() int {
|
|
fake.listRoomsMutex.RLock()
|
|
defer fake.listRoomsMutex.RUnlock()
|
|
return len(fake.listRoomsArgsForCall)
|
|
}
|
|
|
|
func (fake *FakeServiceStore) ListRoomsCalls(stub func(context.Context, []livekit.RoomName) ([]*livekit.Room, error)) {
|
|
fake.listRoomsMutex.Lock()
|
|
defer fake.listRoomsMutex.Unlock()
|
|
fake.ListRoomsStub = stub
|
|
}
|
|
|
|
func (fake *FakeServiceStore) ListRoomsArgsForCall(i int) (context.Context, []livekit.RoomName) {
|
|
fake.listRoomsMutex.RLock()
|
|
defer fake.listRoomsMutex.RUnlock()
|
|
argsForCall := fake.listRoomsArgsForCall[i]
|
|
return argsForCall.arg1, argsForCall.arg2
|
|
}
|
|
|
|
func (fake *FakeServiceStore) ListRoomsReturns(result1 []*livekit.Room, result2 error) {
|
|
fake.listRoomsMutex.Lock()
|
|
defer fake.listRoomsMutex.Unlock()
|
|
fake.ListRoomsStub = nil
|
|
fake.listRoomsReturns = struct {
|
|
result1 []*livekit.Room
|
|
result2 error
|
|
}{result1, result2}
|
|
}
|
|
|
|
func (fake *FakeServiceStore) ListRoomsReturnsOnCall(i int, result1 []*livekit.Room, result2 error) {
|
|
fake.listRoomsMutex.Lock()
|
|
defer fake.listRoomsMutex.Unlock()
|
|
fake.ListRoomsStub = nil
|
|
if fake.listRoomsReturnsOnCall == nil {
|
|
fake.listRoomsReturnsOnCall = make(map[int]struct {
|
|
result1 []*livekit.Room
|
|
result2 error
|
|
})
|
|
}
|
|
fake.listRoomsReturnsOnCall[i] = struct {
|
|
result1 []*livekit.Room
|
|
result2 error
|
|
}{result1, result2}
|
|
}
|
|
|
|
func (fake *FakeServiceStore) LoadRoom(arg1 context.Context, arg2 livekit.RoomName, arg3 bool) (*livekit.Room, *livekit.RoomInternal, error) {
|
|
fake.loadRoomMutex.Lock()
|
|
ret, specificReturn := fake.loadRoomReturnsOnCall[len(fake.loadRoomArgsForCall)]
|
|
fake.loadRoomArgsForCall = append(fake.loadRoomArgsForCall, struct {
|
|
arg1 context.Context
|
|
arg2 livekit.RoomName
|
|
arg3 bool
|
|
}{arg1, arg2, arg3})
|
|
stub := fake.LoadRoomStub
|
|
fakeReturns := fake.loadRoomReturns
|
|
fake.recordInvocation("LoadRoom", []interface{}{arg1, arg2, arg3})
|
|
fake.loadRoomMutex.Unlock()
|
|
if stub != nil {
|
|
return stub(arg1, arg2, arg3)
|
|
}
|
|
if specificReturn {
|
|
return ret.result1, ret.result2, ret.result3
|
|
}
|
|
return fakeReturns.result1, fakeReturns.result2, fakeReturns.result3
|
|
}
|
|
|
|
func (fake *FakeServiceStore) LoadRoomCallCount() int {
|
|
fake.loadRoomMutex.RLock()
|
|
defer fake.loadRoomMutex.RUnlock()
|
|
return len(fake.loadRoomArgsForCall)
|
|
}
|
|
|
|
func (fake *FakeServiceStore) LoadRoomCalls(stub func(context.Context, livekit.RoomName, bool) (*livekit.Room, *livekit.RoomInternal, error)) {
|
|
fake.loadRoomMutex.Lock()
|
|
defer fake.loadRoomMutex.Unlock()
|
|
fake.LoadRoomStub = stub
|
|
}
|
|
|
|
func (fake *FakeServiceStore) LoadRoomArgsForCall(i int) (context.Context, livekit.RoomName, bool) {
|
|
fake.loadRoomMutex.RLock()
|
|
defer fake.loadRoomMutex.RUnlock()
|
|
argsForCall := fake.loadRoomArgsForCall[i]
|
|
return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3
|
|
}
|
|
|
|
func (fake *FakeServiceStore) LoadRoomReturns(result1 *livekit.Room, result2 *livekit.RoomInternal, result3 error) {
|
|
fake.loadRoomMutex.Lock()
|
|
defer fake.loadRoomMutex.Unlock()
|
|
fake.LoadRoomStub = nil
|
|
fake.loadRoomReturns = struct {
|
|
result1 *livekit.Room
|
|
result2 *livekit.RoomInternal
|
|
result3 error
|
|
}{result1, result2, result3}
|
|
}
|
|
|
|
func (fake *FakeServiceStore) LoadRoomReturnsOnCall(i int, result1 *livekit.Room, result2 *livekit.RoomInternal, result3 error) {
|
|
fake.loadRoomMutex.Lock()
|
|
defer fake.loadRoomMutex.Unlock()
|
|
fake.LoadRoomStub = nil
|
|
if fake.loadRoomReturnsOnCall == nil {
|
|
fake.loadRoomReturnsOnCall = make(map[int]struct {
|
|
result1 *livekit.Room
|
|
result2 *livekit.RoomInternal
|
|
result3 error
|
|
})
|
|
}
|
|
fake.loadRoomReturnsOnCall[i] = struct {
|
|
result1 *livekit.Room
|
|
result2 *livekit.RoomInternal
|
|
result3 error
|
|
}{result1, result2, result3}
|
|
}
|
|
|
|
func (fake *FakeServiceStore) RoomExists(arg1 context.Context, arg2 livekit.RoomName) (bool, error) {
|
|
fake.roomExistsMutex.Lock()
|
|
ret, specificReturn := fake.roomExistsReturnsOnCall[len(fake.roomExistsArgsForCall)]
|
|
fake.roomExistsArgsForCall = append(fake.roomExistsArgsForCall, struct {
|
|
arg1 context.Context
|
|
arg2 livekit.RoomName
|
|
}{arg1, arg2})
|
|
stub := fake.RoomExistsStub
|
|
fakeReturns := fake.roomExistsReturns
|
|
fake.recordInvocation("RoomExists", []interface{}{arg1, arg2})
|
|
fake.roomExistsMutex.Unlock()
|
|
if stub != nil {
|
|
return stub(arg1, arg2)
|
|
}
|
|
if specificReturn {
|
|
return ret.result1, ret.result2
|
|
}
|
|
return fakeReturns.result1, fakeReturns.result2
|
|
}
|
|
|
|
func (fake *FakeServiceStore) RoomExistsCallCount() int {
|
|
fake.roomExistsMutex.RLock()
|
|
defer fake.roomExistsMutex.RUnlock()
|
|
return len(fake.roomExistsArgsForCall)
|
|
}
|
|
|
|
func (fake *FakeServiceStore) RoomExistsCalls(stub func(context.Context, livekit.RoomName) (bool, error)) {
|
|
fake.roomExistsMutex.Lock()
|
|
defer fake.roomExistsMutex.Unlock()
|
|
fake.RoomExistsStub = stub
|
|
}
|
|
|
|
func (fake *FakeServiceStore) RoomExistsArgsForCall(i int) (context.Context, livekit.RoomName) {
|
|
fake.roomExistsMutex.RLock()
|
|
defer fake.roomExistsMutex.RUnlock()
|
|
argsForCall := fake.roomExistsArgsForCall[i]
|
|
return argsForCall.arg1, argsForCall.arg2
|
|
}
|
|
|
|
func (fake *FakeServiceStore) RoomExistsReturns(result1 bool, result2 error) {
|
|
fake.roomExistsMutex.Lock()
|
|
defer fake.roomExistsMutex.Unlock()
|
|
fake.RoomExistsStub = nil
|
|
fake.roomExistsReturns = struct {
|
|
result1 bool
|
|
result2 error
|
|
}{result1, result2}
|
|
}
|
|
|
|
func (fake *FakeServiceStore) RoomExistsReturnsOnCall(i int, result1 bool, result2 error) {
|
|
fake.roomExistsMutex.Lock()
|
|
defer fake.roomExistsMutex.Unlock()
|
|
fake.RoomExistsStub = nil
|
|
if fake.roomExistsReturnsOnCall == nil {
|
|
fake.roomExistsReturnsOnCall = make(map[int]struct {
|
|
result1 bool
|
|
result2 error
|
|
})
|
|
}
|
|
fake.roomExistsReturnsOnCall[i] = struct {
|
|
result1 bool
|
|
result2 error
|
|
}{result1, result2}
|
|
}
|
|
|
|
func (fake *FakeServiceStore) 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 *FakeServiceStore) 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 _ service.ServiceStore = new(FakeServiceStore)
|