From 0f4521047ee4092cb3ae56b318117c9b68d2bcbe Mon Sep 17 00:00:00 2001 From: Savolro Date: Fri, 6 Sep 2024 16:47:21 +0300 Subject: [PATCH] Cleanup usage of daemon.NewRPC() Signed-off-by: Savolro --- cmd/daemon/main.go | 1 - daemon/jobs_test.go | 133 ++----------- daemon/rpc.go | 2 - daemon/rpc_connect_test.go | 251 ++++++++----------------- daemon/{helper_test.go => rpc_test.go} | 48 ++++- 5 files changed, 148 insertions(+), 287 deletions(-) rename daemon/{helper_test.go => rpc_test.go} (90%) diff --git a/cmd/daemon/main.go b/cmd/daemon/main.go index 683413d1..8c73bf30 100644 --- a/cmd/daemon/main.go +++ b/cmd/daemon/main.go @@ -445,7 +445,6 @@ func main() { repoAPI, core.NewOAuth2(httpClientWithRotator, daemon.BaseURL), Version, - fw, daemonEvents, vpnFactory, &endpointResolver, diff --git a/daemon/jobs_test.go b/daemon/jobs_test.go index 01d47d9f..af71e2e6 100644 --- a/daemon/jobs_test.go +++ b/daemon/jobs_test.go @@ -4,7 +4,6 @@ import ( "context" "errors" "fmt" - "net/http" "net/netip" "testing" "time" @@ -17,18 +16,12 @@ import ( "github.com/NordSecurity/nordvpn-linux/core" "github.com/NordSecurity/nordvpn-linux/core/mesh" daemonevents "github.com/NordSecurity/nordvpn-linux/daemon/events" - "github.com/NordSecurity/nordvpn-linux/daemon/response" "github.com/NordSecurity/nordvpn-linux/daemon/vpn" "github.com/NordSecurity/nordvpn-linux/events/subs" - "github.com/NordSecurity/nordvpn-linux/internal" "github.com/NordSecurity/nordvpn-linux/meshnet" - "github.com/NordSecurity/nordvpn-linux/networker" "github.com/NordSecurity/nordvpn-linux/sharedctx" "github.com/NordSecurity/nordvpn-linux/test/category" "github.com/NordSecurity/nordvpn-linux/test/mock" - testcore "github.com/NordSecurity/nordvpn-linux/test/mock/core" - testfirewall "github.com/NordSecurity/nordvpn-linux/test/mock/firewall" - testnetworker "github.com/NordSecurity/nordvpn-linux/test/mock/networker" testnorduser "github.com/NordSecurity/nordvpn-linux/test/mock/norduser/service" ) @@ -52,80 +45,32 @@ func TestStartAutoConnect(t *testing.T) { tests := []struct { name string - cfg config.Manager - authChecker auth.Checker - serversAPI core.ServersAPI - netw networker.Networker expectError bool + setup func(*RPC) }{ { name: "not logged-in", - cfg: newMockConfigManager(), - authChecker: &failingLoginChecker{}, - serversAPI: &mockServersAPI{}, - netw: &testnetworker.Mock{}, + setup: func(rpc *RPC) { rpc.ac = failingLoginChecker{} }, expectError: false, }, { name: "config load fail", - cfg: &failingConfigManager{}, - authChecker: &workingLoginChecker{}, - serversAPI: &mockServersAPI{}, - netw: testnetworker.Failing{}, + setup: func(rpc *RPC) { rpc.cm = failingConfigManager{} }, expectError: true, }, { name: "failing servers API", - cfg: newMockConfigManager(), - authChecker: &workingLoginChecker{}, - serversAPI: &mockFailingServersAPI{}, - netw: &testnetworker.Mock{}, + setup: func(rpc *RPC) { rpc.serversAPI = &mockFailingServersAPI{} }, expectError: false, }, } for _, test := range tests { t.Run(test.name, func(t *testing.T) { - cm := test.cfg - dm := testNewDataManager() - api := core.NewDefaultAPI( - "1.0.0", - "", - http.DefaultClient, - response.NoopValidator{}, - ) - - netw := &testnetworker.Mock{} - - rpc := NewRPC( - internal.Development, - test.authChecker, - cm, - dm, - api, - test.serversAPI, - &testcore.CredentialsAPIMock{}, - testNewCDNAPI(), - testNewRepoAPI(), - &mockAuthenticationAPI{}, - "1.0.0", - &testfirewall.FirewallMock{}, - daemonevents.NewEventsEmpty(), - func(config.Technology) (vpn.VPN, error) { - return &mock.WorkingVPN{}, nil - }, - newEndpointResolverMock(netip.MustParseAddr("127.0.0.1")), - netw, - &subs.Subject[string]{}, - &mock.DNSGetter{Names: []string{"1.1.1.1"}}, - nil, - &mockAnalytics{}, - &testnorduser.MockNorduserCombinedService{}, - &RegistryMock{}, - nil, - sharedctx.New(), - ) - + rpc := testRPC() + if test.setup != nil { + test.setup(rpc) + } err := rpc.StartAutoConnect(mockTimeout) if test.expectError { assert.Error(t, err) @@ -214,31 +159,21 @@ func TestStartAutoMeshnet(t *testing.T) { cfg config.Manager authChecker auth.Checker serversAPI core.ServersAPI - netw networker.Networker expectError bool }{ { name: "not logged-in", - cfg: newMockConfigManager(), authChecker: &failingLoginChecker{}, - serversAPI: &mockServersAPI{}, - netw: &testnetworker.Mock{}, expectError: true, }, { name: "config load fail", cfg: &failingConfigManager{}, - authChecker: &workingLoginChecker{}, - serversAPI: &mockServersAPI{}, - netw: &testnetworker.Mock{}, expectError: true, }, { name: "failing servers API", - cfg: newMockConfigManager(), - authChecker: &workingLoginChecker{}, serversAPI: &mockFailingServersAPI{}, - netw: &testnetworker.Mock{}, expectError: false, }, { @@ -248,54 +183,26 @@ func TestStartAutoMeshnet(t *testing.T) { cm.c.Mesh = false return cm }(), - authChecker: &workingLoginChecker{}, - serversAPI: &mockFailingServersAPI{}, - netw: &testnetworker.Mock{}, expectError: true, }, } for _, test := range tests { t.Run(test.name, func(t *testing.T) { - api := core.NewDefaultAPI( - "1.0.0", - "", - http.DefaultClient, - response.NoopValidator{}, - ) - - rpc := NewRPC( - internal.Development, - test.authChecker, - test.cfg, - testNewDataManager(), - api, - test.serversAPI, - &testcore.CredentialsAPIMock{}, - testNewCDNAPI(), - testNewRepoAPI(), - &mockAuthenticationAPI{}, - "1.0.0", - &testfirewall.FirewallMock{}, - daemonevents.NewEventsEmpty(), - func(config.Technology) (vpn.VPN, error) { - return &mock.WorkingVPN{}, nil - }, - newEndpointResolverMock(netip.MustParseAddr("127.0.0.1")), - test.netw, - &subs.Subject[string]{}, - &mock.DNSGetter{Names: []string{"1.1.1.1"}}, - nil, - &mockAnalytics{}, - &testnorduser.MockNorduserCombinedService{}, - &RegistryMock{}, - nil, - sharedctx.New(), - ) + rpc := testRPC() + if test.cfg != nil { + rpc.cm = test.cfg + } + if test.authChecker != nil { + rpc.ac = test.authChecker + } + if test.serversAPI != nil { + rpc.serversAPI = test.serversAPI + } meshService := meshnet.NewServer( - test.authChecker, - test.cfg, + rpc.ac, + rpc.cm, &meshRenewChecker{}, &invitationsAPI{}, &meshNetworker{}, diff --git a/daemon/rpc.go b/daemon/rpc.go index 81e20a39..e864fb3f 100644 --- a/daemon/rpc.go +++ b/daemon/rpc.go @@ -12,7 +12,6 @@ import ( "github.com/NordSecurity/nordvpn-linux/core/mesh" "github.com/NordSecurity/nordvpn-linux/daemon/dns" daemonevents "github.com/NordSecurity/nordvpn-linux/daemon/events" - "github.com/NordSecurity/nordvpn-linux/daemon/firewall" "github.com/NordSecurity/nordvpn-linux/daemon/pb" "github.com/NordSecurity/nordvpn-linux/daemon/state" "github.com/NordSecurity/nordvpn-linux/events" @@ -72,7 +71,6 @@ func NewRPC( repo *RepoAPI, authentication core.Authentication, version string, - fw firewall.Service, events *daemonevents.Events, factory FactoryFunc, endpointResolver network.EndpointResolver, diff --git a/daemon/rpc_connect_test.go b/daemon/rpc_connect_test.go index df1444cf..591da038 100644 --- a/daemon/rpc_connect_test.go +++ b/daemon/rpc_connect_test.go @@ -2,7 +2,6 @@ package daemon import ( "errors" - "net/http" "net/netip" "testing" "time" @@ -10,21 +9,12 @@ import ( "github.com/NordSecurity/nordvpn-linux/auth" "github.com/NordSecurity/nordvpn-linux/config" "github.com/NordSecurity/nordvpn-linux/core" - daemonevents "github.com/NordSecurity/nordvpn-linux/daemon/events" - "github.com/NordSecurity/nordvpn-linux/daemon/firewall" "github.com/NordSecurity/nordvpn-linux/daemon/pb" - "github.com/NordSecurity/nordvpn-linux/daemon/response" "github.com/NordSecurity/nordvpn-linux/daemon/vpn" - "github.com/NordSecurity/nordvpn-linux/events/subs" "github.com/NordSecurity/nordvpn-linux/internal" - "github.com/NordSecurity/nordvpn-linux/networker" - "github.com/NordSecurity/nordvpn-linux/sharedctx" "github.com/NordSecurity/nordvpn-linux/test/category" "github.com/NordSecurity/nordvpn-linux/test/mock" - testcore "github.com/NordSecurity/nordvpn-linux/test/mock/core" - testfirewall "github.com/NordSecurity/nordvpn-linux/test/mock/firewall" testnetworker "github.com/NordSecurity/nordvpn-linux/test/mock/networker" - testnorduser "github.com/NordSecurity/nordvpn-linux/test/mock/norduser/service" "github.com/stretchr/testify/assert" ) @@ -89,55 +79,49 @@ func TestRpcConnect(t *testing.T) { defer testsCleanup() tests := []struct { - name string - serverGroup string - serverTag string - factory FactoryFunc - netw networker.Networker - fw firewall.Service - checker auth.Checker - resp int64 - expectedError error + name string + serverGroup string + serverTag string + factory FactoryFunc + resp int64 + setup func(*RPC) }{ { name: "Quick connect works", factory: func(config.Technology) (vpn.VPN, error) { return &mock.WorkingVPN{}, nil }, - netw: &testnetworker.Mock{}, - fw: &testfirewall.FirewallMock{}, - checker: &workingLoginChecker{}, - resp: internal.CodeConnected, + resp: internal.CodeConnected, }, { name: "Fail for broken Networker and VPN", factory: func(config.Technology) (vpn.VPN, error) { return &mock.FailingVPN{}, nil }, - netw: testnetworker.Failing{}, - fw: &testfirewall.FirewallMock{}, - checker: &workingLoginChecker{}, - resp: internal.CodeFailure, + setup: func(rpc *RPC) { + rpc.netw = testnetworker.Failing{} + }, + resp: internal.CodeFailure, }, { - name: "fFail when VPN subscription is expired", + name: "Fail when VPN subscription is expired", factory: func(config.Technology) (vpn.VPN, error) { return &mock.WorkingVPN{}, nil }, - netw: &testnetworker.Mock{}, - fw: &testfirewall.FirewallMock{}, - checker: &workingLoginChecker{isVPNExpired: true}, - resp: internal.CodeAccountExpired, + setup: func(rpc *RPC) { + rpc.ac = &workingLoginChecker{isVPNExpired: true} + }, + resp: internal.CodeAccountExpired, }, { name: "Fail when VPN subscription API calls fails", factory: func(config.Technology) (vpn.VPN, error) { return &mock.WorkingVPN{}, nil }, - netw: &testnetworker.Mock{}, - fw: &testfirewall.FirewallMock{}, - checker: &workingLoginChecker{vpnErr: errors.New("test error")}, - resp: internal.CodeTokenRenewError, + setup: func(rpc *RPC) { + rpc.ac = &workingLoginChecker{vpnErr: errors.New("test error")} + }, + resp: internal.CodeTokenRenewError, }, { name: "Connects using country name", @@ -145,10 +129,7 @@ func TestRpcConnect(t *testing.T) { factory: func(config.Technology) (vpn.VPN, error) { return &mock.WorkingVPN{}, nil }, - netw: &testnetworker.Mock{}, - fw: &testfirewall.FirewallMock{}, - checker: &workingLoginChecker{}, - resp: internal.CodeConnected, + resp: internal.CodeConnected, }, { name: "Connects using country name + city name", @@ -156,10 +137,7 @@ func TestRpcConnect(t *testing.T) { factory: func(config.Technology) (vpn.VPN, error) { return &mock.WorkingVPN{}, nil }, - netw: &testnetworker.Mock{}, - fw: &testfirewall.FirewallMock{}, - checker: &workingLoginChecker{}, - resp: internal.CodeConnected, + resp: internal.CodeConnected, }, { name: "Connects for city name", @@ -167,10 +145,7 @@ func TestRpcConnect(t *testing.T) { factory: func(config.Technology) (vpn.VPN, error) { return &mock.WorkingVPN{}, nil }, - netw: &testnetworker.Mock{}, - fw: &testfirewall.FirewallMock{}, - checker: &workingLoginChecker{}, - resp: internal.CodeConnected, + resp: internal.CodeConnected, }, { name: "Connects using country code + city name", @@ -178,10 +153,7 @@ func TestRpcConnect(t *testing.T) { factory: func(config.Technology) (vpn.VPN, error) { return &mock.WorkingVPN{}, nil }, - netw: &testnetworker.Mock{}, - fw: &testfirewall.FirewallMock{}, - checker: &workingLoginChecker{}, - resp: internal.CodeConnected, + resp: internal.CodeConnected, }, { name: "Connects using country code", @@ -189,10 +161,7 @@ func TestRpcConnect(t *testing.T) { factory: func(config.Technology) (vpn.VPN, error) { return &mock.WorkingVPN{}, nil }, - netw: &testnetworker.Mock{}, - fw: &testfirewall.FirewallMock{}, - checker: &workingLoginChecker{}, - resp: internal.CodeConnected, + resp: internal.CodeConnected, }, { name: "Dedicated IP group connect works", @@ -200,11 +169,13 @@ func TestRpcConnect(t *testing.T) { factory: func(config.Technology) (vpn.VPN, error) { return &mock.WorkingVPN{}, nil }, - netw: &testnetworker.Mock{}, - fw: &testfirewall.FirewallMock{}, - checker: &workingLoginChecker{ - isDedicatedIPExpired: false, - dedicatedIPService: []auth.DedicatedIPService{{ExpiresAt: "", ServerID: 7}}, + setup: func(rpc *RPC) { + rpc.ac = &workingLoginChecker{ + isDedicatedIPExpired: false, + dedicatedIPService: []auth.DedicatedIPService{ + {ExpiresAt: "", ServerID: 7}, + }, + } }, resp: internal.CodeConnected, }, @@ -214,11 +185,13 @@ func TestRpcConnect(t *testing.T) { factory: func(config.Technology) (vpn.VPN, error) { return &mock.WorkingVPN{}, nil }, - netw: &testnetworker.Mock{}, - fw: &testfirewall.FirewallMock{}, - checker: &workingLoginChecker{ - isDedicatedIPExpired: false, - dedicatedIPService: []auth.DedicatedIPService{{ExpiresAt: "", ServerID: 7}}, + setup: func(rpc *RPC) { + rpc.ac = &workingLoginChecker{ + isDedicatedIPExpired: false, + dedicatedIPService: []auth.DedicatedIPService{ + {ExpiresAt: "", ServerID: 7}, + }, + } }, resp: internal.CodeConnected, }, @@ -228,10 +201,10 @@ func TestRpcConnect(t *testing.T) { factory: func(config.Technology) (vpn.VPN, error) { return &mock.WorkingVPN{}, nil }, - netw: &testnetworker.Mock{}, - fw: &testfirewall.FirewallMock{}, - checker: &workingLoginChecker{isDedicatedIPExpired: true}, - resp: internal.CodeDedicatedIPRenewError, + setup: func(rpc *RPC) { + rpc.ac = &workingLoginChecker{isDedicatedIPExpired: true} + }, + resp: internal.CodeDedicatedIPRenewError, }, { name: "fails for Dedicated IP when API fails", @@ -239,10 +212,11 @@ func TestRpcConnect(t *testing.T) { factory: func(config.Technology) (vpn.VPN, error) { return &mock.WorkingVPN{}, nil }, - netw: &testnetworker.Mock{}, - fw: &testfirewall.FirewallMock{}, - checker: &workingLoginChecker{isDedicatedIPExpired: true}, - resp: internal.CodeDedicatedIPRenewError, + setup: func(rpc *RPC) { + rpc.ac = &workingLoginChecker{ + dedicatedIPErr: errors.New("error"), + } + }, }, { name: "fails when server not into Dedicated IP servers list", @@ -250,11 +224,14 @@ func TestRpcConnect(t *testing.T) { factory: func(config.Technology) (vpn.VPN, error) { return &mock.WorkingVPN{}, nil }, - netw: &testnetworker.Mock{}, - fw: &testfirewall.FirewallMock{}, - checker: &workingLoginChecker{ - isDedicatedIPExpired: false, - dedicatedIPService: []auth.DedicatedIPService{{ExpiresAt: "", ServerID: 7}}, + + setup: func(rpc *RPC) { + rpc.ac = &workingLoginChecker{ + isDedicatedIPExpired: false, + dedicatedIPService: []auth.DedicatedIPService{ + {ExpiresAt: "", ServerID: 7}, + }, + } }, resp: internal.CodeDedicatedIPNoServer, }, @@ -264,67 +241,42 @@ func TestRpcConnect(t *testing.T) { factory: func(config.Technology) (vpn.VPN, error) { return &mock.WorkingVPN{}, nil }, - netw: &testnetworker.Mock{}, - fw: &testfirewall.FirewallMock{}, - checker: &workingLoginChecker{ - isDedicatedIPExpired: false, - dedicatedIPService: []auth.DedicatedIPService{{ExpiresAt: "", ServerID: auth.NoServerSelected}}, + setup: func(rpc *RPC) { + rpc.ac = &workingLoginChecker{ + isDedicatedIPExpired: false, + dedicatedIPService: []auth.DedicatedIPService{ + {ExpiresAt: "", ServerID: auth.NoServerSelected}, + }, + } }, resp: internal.CodeDedicatedIPServiceButNoServers, }, } for _, test := range tests { - // run each test using working API for servers list and using local cached servers list + // run each test using working API for servers list and using local cached servers + // list servers := map[string]core.ServersAPI{ "Remote": mockServersAPI{}, "Local": mockFailingServersAPI{}, } for key, serversAPI := range servers { t.Run(test.name+" "+key, func(t *testing.T) { - cm := newMockConfigManager() - tokenData := cm.c.TokensData[cm.c.AutoConnectData.ID] - tokenData.TokenExpiry = time.Now().Add(time.Hour * 1).Format(internal.ServerDateFormat) - tokenData.ServiceExpiry = time.Now().Add(time.Hour * 1).Format(internal.ServerDateFormat) - cm.c.TokensData[cm.c.AutoConnectData.ID] = tokenData - dm := testNewDataManager() - dm.SetServersData(time.Now(), serversList(), "") - api := core.NewDefaultAPI( - "", - "", - http.DefaultClient, - response.NoopValidator{}, - ) - rpc := NewRPC( - internal.Development, - test.checker, - cm, - dm, - api, - serversAPI, - &testcore.CredentialsAPIMock{}, - testNewCDNAPI(), - testNewRepoAPI(), - &mockAuthenticationAPI{}, - "1.0.0", - test.fw, - daemonevents.NewEventsEmpty(), - test.factory, - newEndpointResolverMock(netip.MustParseAddr("127.0.0.1")), - test.netw, - &subs.Subject[string]{}, - &mock.DNSGetter{Names: []string{"1.1.1.1"}}, - nil, - &mockAnalytics{}, - &testnorduser.MockNorduserCombinedService{}, - &RegistryMock{}, - nil, - sharedctx.New(), - ) + rpc := testRPC() + rpc.serversAPI = serversAPI + if test.setup != nil { + test.setup(rpc) + } server := &mockRPCServer{} - err := rpc.Connect(&pb.ConnectRequest{ServerGroup: test.serverGroup, ServerTag: test.serverTag}, server) - assert.Equal(t, test.expectedError, err) - if err == nil { + err := rpc.Connect(&pb.ConnectRequest{ + ServerGroup: test.serverGroup, + ServerTag: test.serverTag, + }, server) + if test.resp == internal.CodeConnected { + assert.NoError(t, err) + } else if test.resp == 0 { + assert.ErrorIs(t, internal.ErrUnhandled, err) + } else { assert.Equal(t, test.resp, server.msg.Type) } }) @@ -335,54 +287,13 @@ func TestRpcConnect(t *testing.T) { func TestRpcReconnect(t *testing.T) { category.Set(t, category.Route) - var fail bool - factory := func(config.Technology) (vpn.VPN, error) { - if fail { - fail = false - return &mock.FailingVPN{}, nil - } - fail = true - return &mock.WorkingVPN{}, nil - } - cm := newMockConfigManager() tokenData := cm.c.TokensData[cm.c.AutoConnectData.ID] tokenData.TokenExpiry = time.Now().Add(time.Hour * 1).Format(internal.ServerDateFormat) tokenData.ServiceExpiry = time.Now().Add(time.Hour * 1).Format(internal.ServerDateFormat) cm.c.TokensData[cm.c.AutoConnectData.ID] = tokenData - dm := testNewDataManager() - api := core.NewDefaultAPI( - "", - "", - http.DefaultClient, - response.NoopValidator{}, - ) - rpc := NewRPC( - internal.Development, - &workingLoginChecker{}, - cm, - dm, - api, - &mockServersAPI{}, - &testcore.CredentialsAPIMock{}, - testNewCDNAPI(), - testNewRepoAPI(), - &mockAuthenticationAPI{}, - "1.0.0", - &testfirewall.FirewallMock{}, - daemonevents.NewEventsEmpty(), - factory, - newEndpointResolverMock(netip.MustParseAddr("127.0.0.1")), - &testnetworker.Mock{}, - &subs.Subject[string]{}, - &mock.DNSGetter{Names: []string{"1.1.1.1"}}, - nil, - &mockAnalytics{}, - &testnorduser.MockNorduserCombinedService{}, - &RegistryMock{}, - nil, - sharedctx.New(), - ) + + rpc := testRPC() err := rpc.Connect(&pb.ConnectRequest{}, &mockRPCServer{}) assert.NoError(t, err) diff --git a/daemon/helper_test.go b/daemon/rpc_test.go similarity index 90% rename from daemon/helper_test.go rename to daemon/rpc_test.go index 8f206179..e27e55d5 100644 --- a/daemon/helper_test.go +++ b/daemon/rpc_test.go @@ -7,6 +7,7 @@ import ( "log" "net" "net/http" + "net/netip" "os" "strconv" "strings" @@ -16,8 +17,16 @@ import ( "github.com/NordSecurity/nordvpn-linux/config" "github.com/NordSecurity/nordvpn-linux/core" "github.com/NordSecurity/nordvpn-linux/daemon/events" + daemonevents "github.com/NordSecurity/nordvpn-linux/daemon/events" + "github.com/NordSecurity/nordvpn-linux/daemon/response" + "github.com/NordSecurity/nordvpn-linux/daemon/vpn" + "github.com/NordSecurity/nordvpn-linux/events/subs" "github.com/NordSecurity/nordvpn-linux/internal" + "github.com/NordSecurity/nordvpn-linux/sharedctx" "github.com/NordSecurity/nordvpn-linux/test/mock" + testcore "github.com/NordSecurity/nordvpn-linux/test/mock/core" + testnetworker "github.com/NordSecurity/nordvpn-linux/test/mock/networker" + testnorduser "github.com/NordSecurity/nordvpn-linux/test/mock/norduser/service" "golang.org/x/crypto/ssh" ) @@ -39,7 +48,6 @@ const ( TestVersionRpm = "testrpmparse" TestUserCreateJSON = "usercreate.json" TestUserCredentialsJSON = "usercredentials.json" - TestBadUserCreateJSON = "badusercreate.json" TestPlansJSON = "plans.json" ) @@ -56,6 +64,44 @@ type Handler struct { var privateKey *rsa.PrivateKey var publicKey ssh.PublicKey +func testRPC() *RPC { + api := core.NewDefaultAPI( + "1.0.0", + "", + http.DefaultClient, + response.NoopValidator{}, + ) + dm := testNewDataManager() + dm.SetServersData(time.Now(), serversList(), "") + return NewRPC( + internal.Development, + &workingLoginChecker{}, + newMockConfigManager(), + dm, + api, + &mockServersAPI{}, + &testcore.CredentialsAPIMock{}, + testNewCDNAPI(), + testNewRepoAPI(), + &mockAuthenticationAPI{}, + "1.0.0", + daemonevents.NewEventsEmpty(), + func(config.Technology) (vpn.VPN, error) { + return &mock.WorkingVPN{}, nil + }, + newEndpointResolverMock(netip.MustParseAddr("127.0.0.1")), + &testnetworker.Mock{}, + &subs.Subject[string]{}, + &mock.DNSGetter{Names: []string{"1.1.1.1"}}, + nil, + &mockAnalytics{}, + &testnorduser.MockNorduserCombinedService{}, + &RegistryMock{}, + nil, + sharedctx.New(), + ) +} + func TestMain(m *testing.M) { // make local servers for functions relying on API servers := make([]*http.Server, 0)