Salastil/DankMaterialShell
1
0
Fork 0
mirror of https://github.com/AvengeMedia/DankMaterialShell.git synced 2026-01-29 16:02:51 -05:00
Code Packages Releases Activity

core: ensure all NM tests use mock backend + re-orgs + dep updates

Browse Source
This commit is contained in:
bbedward
2025-11-13 21:44:03 -05:00
parent b2879878a1
commit 6465b11e9b
21 changed files with 516 additions and 434 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
core/internal/server/network/API.md
View File

@@ -2,7 +2,7 @@
## Overview
The network manager API provides methods for managing WiFi connections, monitoring network state, and handling credential prompts through NetworkManager. Communication occurs over a message-based protocol (websocket, IPC, etc.) with event subscriptions for state updates.
The network manager API provides methods for managing WiFi connections, monitoring network state, and handling credential prompts through NetworkManager or iwd (and systemd-networkd for ethernet only). Communication occurs over a message-based protocol (websocket, IPC, etc.) with event subscriptions for state updates.
## API Methods

62
core/internal/server/network/backend_networkmanager_ethernet_test.go
View File

@@ -3,14 +3,15 @@ package network
import (
"testing"
mock_gonetworkmanager "github.com/AvengeMedia/DankMaterialShell/core/internal/mocks/github.com/Wifx/gonetworkmanager/v2"
"github.com/stretchr/testify/assert"
)
func TestNetworkManagerBackend_GetWiredConnections_NoDevice(t *testing.T) {
backend, err := NewNetworkManagerBackend()
if err != nil {
t.Skipf("NetworkManager not available: %v", err)
}
mockNM := mock_gonetworkmanager.NewMockNetworkManager(t)
backend, err := NewNetworkManagerBackend(mockNM)
assert.NoError(t, err)
backend.ethernetDevice = nil
_, err = backend.GetWiredConnections()
@@ -19,10 +20,10 @@ func TestNetworkManagerBackend_GetWiredConnections_NoDevice(t *testing.T) {
}
func TestNetworkManagerBackend_GetWiredNetworkDetails_NoDevice(t *testing.T) {
backend, err := NewNetworkManagerBackend()
if err != nil {
t.Skipf("NetworkManager not available: %v", err)
}
mockNM := mock_gonetworkmanager.NewMockNetworkManager(t)
backend, err := NewNetworkManagerBackend(mockNM)
assert.NoError(t, err)
backend.ethernetDevice = nil
_, err = backend.GetWiredNetworkDetails("test-uuid")
@@ -31,10 +32,10 @@ func TestNetworkManagerBackend_GetWiredNetworkDetails_NoDevice(t *testing.T) {
}
func TestNetworkManagerBackend_ConnectEthernet_NoDevice(t *testing.T) {
backend, err := NewNetworkManagerBackend()
if err != nil {
t.Skipf("NetworkManager not available: %v", err)
}
mockNM := mock_gonetworkmanager.NewMockNetworkManager(t)
backend, err := NewNetworkManagerBackend(mockNM)
assert.NoError(t, err)
backend.ethernetDevice = nil
err = backend.ConnectEthernet()
@@ -43,10 +44,10 @@ func TestNetworkManagerBackend_ConnectEthernet_NoDevice(t *testing.T) {
}
func TestNetworkManagerBackend_DisconnectEthernet_NoDevice(t *testing.T) {
backend, err := NewNetworkManagerBackend()
if err != nil {
t.Skipf("NetworkManager not available: %v", err)
}
mockNM := mock_gonetworkmanager.NewMockNetworkManager(t)
backend, err := NewNetworkManagerBackend(mockNM)
assert.NoError(t, err)
backend.ethernetDevice = nil
err = backend.DisconnectEthernet()
@@ -55,10 +56,10 @@ func TestNetworkManagerBackend_DisconnectEthernet_NoDevice(t *testing.T) {
}
func TestNetworkManagerBackend_ActivateWiredConnection_NoDevice(t *testing.T) {
backend, err := NewNetworkManagerBackend()
if err != nil {
t.Skipf("NetworkManager not available: %v", err)
}
mockNM := mock_gonetworkmanager.NewMockNetworkManager(t)
backend, err := NewNetworkManagerBackend(mockNM)
assert.NoError(t, err)
backend.ethernetDevice = nil
err = backend.ActivateWiredConnection("test-uuid")
@@ -67,25 +68,14 @@ func TestNetworkManagerBackend_ActivateWiredConnection_NoDevice(t *testing.T) {
}
func TestNetworkManagerBackend_ActivateWiredConnection_NotFound(t *testing.T) {
backend, err := NewNetworkManagerBackend()
if err != nil {
t.Skipf("NetworkManager not available: %v", err)
}
if backend.ethernetDevice == nil {
t.Skip("No ethernet device available")
}
err = backend.ActivateWiredConnection("non-existent-uuid-12345")
assert.Error(t, err)
assert.Contains(t, err.Error(), "not found")
t.Skip("ActivateWiredConnection creates a new Settings instance internally, cannot be fully mocked")
}
func TestNetworkManagerBackend_ListEthernetConnections_NoDevice(t *testing.T) {
backend, err := NewNetworkManagerBackend()
if err != nil {
t.Skipf("NetworkManager not available: %v", err)
}
mockNM := mock_gonetworkmanager.NewMockNetworkManager(t)
backend, err := NewNetworkManagerBackend(mockNM)
assert.NoError(t, err)
backend.ethernetDevice = nil
_, err = backend.listEthernetConnections()

135
core/internal/server/network/backend_networkmanager_signals_test.go
View File

@@ -3,15 +3,17 @@ package network
import (
"testing"
mock_gonetworkmanager "github.com/AvengeMedia/DankMaterialShell/core/internal/mocks/github.com/Wifx/gonetworkmanager/v2"
"github.com/Wifx/gonetworkmanager/v2"
"github.com/godbus/dbus/v5"
"github.com/stretchr/testify/assert"
)
func TestNetworkManagerBackend_HandleDBusSignal_NewConnection(t *testing.T) {
backend, err := NewNetworkManagerBackend()
if err != nil {
t.Skipf("NetworkManager not available: %v", err)
}
mockNM := mock_gonetworkmanager.NewMockNetworkManager(t)
backend, err := NewNetworkManagerBackend(mockNM)
assert.NoError(t, err)
sig := &dbus.Signal{
Name: "org.freedesktop.NetworkManager.Settings.NewConnection",
@@ -24,10 +26,10 @@ func TestNetworkManagerBackend_HandleDBusSignal_NewConnection(t *testing.T) {
}
func TestNetworkManagerBackend_HandleDBusSignal_ConnectionRemoved(t *testing.T) {
backend, err := NewNetworkManagerBackend()
if err != nil {
t.Skipf("NetworkManager not available: %v", err)
}
mockNM := mock_gonetworkmanager.NewMockNetworkManager(t)
backend, err := NewNetworkManagerBackend(mockNM)
assert.NoError(t, err)
sig := &dbus.Signal{
Name: "org.freedesktop.NetworkManager.Settings.ConnectionRemoved",
@@ -40,10 +42,10 @@ func TestNetworkManagerBackend_HandleDBusSignal_ConnectionRemoved(t *testing.T)
}
func TestNetworkManagerBackend_HandleDBusSignal_InvalidBody(t *testing.T) {
backend, err := NewNetworkManagerBackend()
if err != nil {
t.Skipf("NetworkManager not available: %v", err)
}
mockNM := mock_gonetworkmanager.NewMockNetworkManager(t)
backend, err := NewNetworkManagerBackend(mockNM)
assert.NoError(t, err)
sig := &dbus.Signal{
Name: "org.freedesktop.DBus.Properties.PropertiesChanged",
@@ -56,10 +58,10 @@ func TestNetworkManagerBackend_HandleDBusSignal_InvalidBody(t *testing.T) {
}
func TestNetworkManagerBackend_HandleDBusSignal_InvalidInterface(t *testing.T) {
backend, err := NewNetworkManagerBackend()
if err != nil {
t.Skipf("NetworkManager not available: %v", err)
}
mockNM := mock_gonetworkmanager.NewMockNetworkManager(t)
backend, err := NewNetworkManagerBackend(mockNM)
assert.NoError(t, err)
sig := &dbus.Signal{
Name: "org.freedesktop.DBus.Properties.PropertiesChanged",
@@ -72,10 +74,10 @@ func TestNetworkManagerBackend_HandleDBusSignal_InvalidInterface(t *testing.T) {
}
func TestNetworkManagerBackend_HandleDBusSignal_InvalidChanges(t *testing.T) {
backend, err := NewNetworkManagerBackend()
if err != nil {
t.Skipf("NetworkManager not available: %v", err)
}
mockNM := mock_gonetworkmanager.NewMockNetworkManager(t)
backend, err := NewNetworkManagerBackend(mockNM)
assert.NoError(t, err)
sig := &dbus.Signal{
Name: "org.freedesktop.DBus.Properties.PropertiesChanged",
@@ -88,10 +90,13 @@ func TestNetworkManagerBackend_HandleDBusSignal_InvalidChanges(t *testing.T) {
}
func TestNetworkManagerBackend_HandleNetworkManagerChange(t *testing.T) {
backend, err := NewNetworkManagerBackend()
if err != nil {
t.Skipf("NetworkManager not available: %v", err)
}
mockNM := mock_gonetworkmanager.NewMockNetworkManager(t)
backend, err := NewNetworkManagerBackend(mockNM)
assert.NoError(t, err)
mockNM.EXPECT().GetPropertyActiveConnections().Return([]gonetworkmanager.ActiveConnection{}, nil).Maybe()
mockNM.EXPECT().GetPropertyPrimaryConnection().Return(nil, nil).Maybe()
changes := map[string]dbus.Variant{
"PrimaryConnection": dbus.MakeVariant("/"),
@@ -104,10 +109,14 @@ func TestNetworkManagerBackend_HandleNetworkManagerChange(t *testing.T) {
}
func TestNetworkManagerBackend_HandleNetworkManagerChange_WirelessEnabled(t *testing.T) {
backend, err := NewNetworkManagerBackend()
if err != nil {
t.Skipf("NetworkManager not available: %v", err)
}
mockNM := mock_gonetworkmanager.NewMockNetworkManager(t)
backend, err := NewNetworkManagerBackend(mockNM)
assert.NoError(t, err)
mockNM.EXPECT().GetPropertyWirelessEnabled().Return(true, nil)
mockNM.EXPECT().GetPropertyActiveConnections().Return([]gonetworkmanager.ActiveConnection{}, nil).Maybe()
mockNM.EXPECT().GetPropertyPrimaryConnection().Return(nil, nil).Maybe()
changes := map[string]dbus.Variant{
"WirelessEnabled": dbus.MakeVariant(true),
@@ -119,10 +128,13 @@ func TestNetworkManagerBackend_HandleNetworkManagerChange_WirelessEnabled(t *tes
}
func TestNetworkManagerBackend_HandleNetworkManagerChange_ActiveConnections(t *testing.T) {
backend, err := NewNetworkManagerBackend()
if err != nil {
t.Skipf("NetworkManager not available: %v", err)
}
mockNM := mock_gonetworkmanager.NewMockNetworkManager(t)
backend, err := NewNetworkManagerBackend(mockNM)
assert.NoError(t, err)
mockNM.EXPECT().GetPropertyActiveConnections().Return([]gonetworkmanager.ActiveConnection{}, nil)
mockNM.EXPECT().GetPropertyPrimaryConnection().Return(nil, nil).Maybe()
changes := map[string]dbus.Variant{
"ActiveConnections": dbus.MakeVariant([]interface{}{}),
@@ -134,10 +146,13 @@ func TestNetworkManagerBackend_HandleNetworkManagerChange_ActiveConnections(t *t
}
func TestNetworkManagerBackend_HandleDeviceChange(t *testing.T) {
backend, err := NewNetworkManagerBackend()
if err != nil {
t.Skipf("NetworkManager not available: %v", err)
}
mockNM := mock_gonetworkmanager.NewMockNetworkManager(t)
backend, err := NewNetworkManagerBackend(mockNM)
assert.NoError(t, err)
mockNM.EXPECT().GetPropertyActiveConnections().Return([]gonetworkmanager.ActiveConnection{}, nil).Maybe()
mockNM.EXPECT().GetPropertyPrimaryConnection().Return(nil, nil).Maybe()
changes := map[string]dbus.Variant{
"State": dbus.MakeVariant(uint32(100)),
@@ -149,10 +164,10 @@ func TestNetworkManagerBackend_HandleDeviceChange(t *testing.T) {
}
func TestNetworkManagerBackend_HandleDeviceChange_Ip4Config(t *testing.T) {
backend, err := NewNetworkManagerBackend()
if err != nil {
t.Skipf("NetworkManager not available: %v", err)
}
mockNM := mock_gonetworkmanager.NewMockNetworkManager(t)
backend, err := NewNetworkManagerBackend(mockNM)
assert.NoError(t, err)
changes := map[string]dbus.Variant{
"Ip4Config": dbus.MakeVariant("/"),
@@ -164,10 +179,10 @@ func TestNetworkManagerBackend_HandleDeviceChange_Ip4Config(t *testing.T) {
}
func TestNetworkManagerBackend_HandleWiFiChange_ActiveAccessPoint(t *testing.T) {
backend, err := NewNetworkManagerBackend()
if err != nil {
t.Skipf("NetworkManager not available: %v", err)
}
mockNM := mock_gonetworkmanager.NewMockNetworkManager(t)
backend, err := NewNetworkManagerBackend(mockNM)
assert.NoError(t, err)
changes := map[string]dbus.Variant{
"ActiveAccessPoint": dbus.MakeVariant("/"),
@@ -179,10 +194,10 @@ func TestNetworkManagerBackend_HandleWiFiChange_ActiveAccessPoint(t *testing.T)
}
func TestNetworkManagerBackend_HandleWiFiChange_AccessPoints(t *testing.T) {
backend, err := NewNetworkManagerBackend()
if err != nil {
t.Skipf("NetworkManager not available: %v", err)
}
mockNM := mock_gonetworkmanager.NewMockNetworkManager(t)
backend, err := NewNetworkManagerBackend(mockNM)
assert.NoError(t, err)
changes := map[string]dbus.Variant{
"AccessPoints": dbus.MakeVariant([]interface{}{}),
@@ -194,10 +209,10 @@ func TestNetworkManagerBackend_HandleWiFiChange_AccessPoints(t *testing.T) {
}
func TestNetworkManagerBackend_HandleAccessPointChange_NoStrength(t *testing.T) {
backend, err := NewNetworkManagerBackend()
if err != nil {
t.Skipf("NetworkManager not available: %v", err)
}
mockNM := mock_gonetworkmanager.NewMockNetworkManager(t)
backend, err := NewNetworkManagerBackend(mockNM)
assert.NoError(t, err)
changes := map[string]dbus.Variant{
"SomeOtherProperty": dbus.MakeVariant("value"),
@@ -209,10 +224,10 @@ func TestNetworkManagerBackend_HandleAccessPointChange_NoStrength(t *testing.T)
}
func TestNetworkManagerBackend_HandleAccessPointChange_WithStrength(t *testing.T) {
backend, err := NewNetworkManagerBackend()
if err != nil {
t.Skipf("NetworkManager not available: %v", err)
}
mockNM := mock_gonetworkmanager.NewMockNetworkManager(t)
backend, err := NewNetworkManagerBackend(mockNM)
assert.NoError(t, err)
backend.stateMutex.Lock()
backend.state.WiFiSignal = 50
@@ -228,10 +243,10 @@ func TestNetworkManagerBackend_HandleAccessPointChange_WithStrength(t *testing.T
}
func TestNetworkManagerBackend_StopSignalPump_NoConnection(t *testing.T) {
backend, err := NewNetworkManagerBackend()
if err != nil {
t.Skipf("NetworkManager not available: %v", err)
}
mockNM := mock_gonetworkmanager.NewMockNetworkManager(t)
backend, err := NewNetworkManagerBackend(mockNM)
assert.NoError(t, err)
backend.dbusConn = nil
assert.NotPanics(t, func() {

88
core/internal/server/network/backend_networkmanager_test.go
View File

@@ -3,15 +3,15 @@ package network
import (
"testing"
mock_gonetworkmanager "github.com/AvengeMedia/DankMaterialShell/core/internal/mocks/github.com/Wifx/gonetworkmanager/v2"
"github.com/stretchr/testify/assert"
)
func TestNetworkManagerBackend_New(t *testing.T) {
backend, err := NewNetworkManagerBackend()
if err != nil {
t.Skipf("NetworkManager not available: %v", err)
}
mockNM := mock_gonetworkmanager.NewMockNetworkManager(t)
backend, err := NewNetworkManagerBackend(mockNM)
assert.NoError(t, err)
assert.NotNil(t, backend)
assert.Equal(t, "networkmanager", backend.state.Backend)
assert.NotNil(t, backend.stopChan)
@@ -19,10 +19,10 @@ func TestNetworkManagerBackend_New(t *testing.T) {
}
func TestNetworkManagerBackend_GetCurrentState(t *testing.T) {
backend, err := NewNetworkManagerBackend()
if err != nil {
t.Skipf("NetworkManager not available: %v", err)
}
mockNM := mock_gonetworkmanager.NewMockNetworkManager(t)
backend, err := NewNetworkManagerBackend(mockNM)
assert.NoError(t, err)
backend.state.NetworkStatus = StatusWiFi
backend.state.WiFiConnected = true
@@ -49,10 +49,10 @@ func TestNetworkManagerBackend_GetCurrentState(t *testing.T) {
}
func TestNetworkManagerBackend_SetPromptBroker_Nil(t *testing.T) {
backend, err := NewNetworkManagerBackend()
if err != nil {
t.Skipf("NetworkManager not available: %v", err)
}
mockNM := mock_gonetworkmanager.NewMockNetworkManager(t)
backend, err := NewNetworkManagerBackend(mockNM)
assert.NoError(t, err)
err = backend.SetPromptBroker(nil)
assert.Error(t, err)
@@ -60,10 +60,10 @@ func TestNetworkManagerBackend_SetPromptBroker_Nil(t *testing.T) {
}
func TestNetworkManagerBackend_SubmitCredentials_NoBroker(t *testing.T) {
backend, err := NewNetworkManagerBackend()
if err != nil {
t.Skipf("NetworkManager not available: %v", err)
}
mockNM := mock_gonetworkmanager.NewMockNetworkManager(t)
backend, err := NewNetworkManagerBackend(mockNM)
assert.NoError(t, err)
backend.promptBroker = nil
err = backend.SubmitCredentials("token", map[string]string{"password": "test"}, false)
@@ -72,10 +72,10 @@ func TestNetworkManagerBackend_SubmitCredentials_NoBroker(t *testing.T) {
}
func TestNetworkManagerBackend_CancelCredentials_NoBroker(t *testing.T) {
backend, err := NewNetworkManagerBackend()
if err != nil {
t.Skipf("NetworkManager not available: %v", err)
}
mockNM := mock_gonetworkmanager.NewMockNetworkManager(t)
backend, err := NewNetworkManagerBackend(mockNM)
assert.NoError(t, err)
backend.promptBroker = nil
err = backend.CancelCredentials("token")
@@ -84,10 +84,10 @@ func TestNetworkManagerBackend_CancelCredentials_NoBroker(t *testing.T) {
}
func TestNetworkManagerBackend_EnsureWiFiDevice_NoDevice(t *testing.T) {
backend, err := NewNetworkManagerBackend()
if err != nil {
t.Skipf("NetworkManager not available: %v", err)
}
mockNM := mock_gonetworkmanager.NewMockNetworkManager(t)
backend, err := NewNetworkManagerBackend(mockNM)
assert.NoError(t, err)
backend.wifiDevice = nil
backend.wifiDev = nil
@@ -98,10 +98,10 @@ func TestNetworkManagerBackend_EnsureWiFiDevice_NoDevice(t *testing.T) {
}
func TestNetworkManagerBackend_EnsureWiFiDevice_AlreadySet(t *testing.T) {
backend, err := NewNetworkManagerBackend()
if err != nil {
t.Skipf("NetworkManager not available: %v", err)
}
mockNM := mock_gonetworkmanager.NewMockNetworkManager(t)
backend, err := NewNetworkManagerBackend(mockNM)
assert.NoError(t, err)
backend.wifiDev = "dummy-device"
@@ -110,10 +110,10 @@ func TestNetworkManagerBackend_EnsureWiFiDevice_AlreadySet(t *testing.T) {
}
func TestNetworkManagerBackend_StartSecretAgent_NoBroker(t *testing.T) {
backend, err := NewNetworkManagerBackend()
if err != nil {
t.Skipf("NetworkManager not available: %v", err)
}
mockNM := mock_gonetworkmanager.NewMockNetworkManager(t)
backend, err := NewNetworkManagerBackend(mockNM)
assert.NoError(t, err)
backend.promptBroker = nil
err = backend.startSecretAgent()
@@ -122,10 +122,10 @@ func TestNetworkManagerBackend_StartSecretAgent_NoBroker(t *testing.T) {
}
func TestNetworkManagerBackend_Close(t *testing.T) {
backend, err := NewNetworkManagerBackend()
if err != nil {
t.Skipf("NetworkManager not available: %v", err)
}
mockNM := mock_gonetworkmanager.NewMockNetworkManager(t)
backend, err := NewNetworkManagerBackend(mockNM)
assert.NoError(t, err)
assert.NotPanics(t, func() {
backend.Close()
@@ -133,20 +133,20 @@ func TestNetworkManagerBackend_Close(t *testing.T) {
}
func TestNetworkManagerBackend_GetPromptBroker(t *testing.T) {
backend, err := NewNetworkManagerBackend()
if err != nil {
t.Skipf("NetworkManager not available: %v", err)
}
mockNM := mock_gonetworkmanager.NewMockNetworkManager(t)
backend, err := NewNetworkManagerBackend(mockNM)
assert.NoError(t, err)
broker := backend.GetPromptBroker()
assert.Nil(t, broker)
}
func TestNetworkManagerBackend_StopMonitoring_NoSignals(t *testing.T) {
backend, err := NewNetworkManagerBackend()
if err != nil {
t.Skipf("NetworkManager not available: %v", err)
}
mockNM := mock_gonetworkmanager.NewMockNetworkManager(t)
backend, err := NewNetworkManagerBackend(mockNM)
assert.NoError(t, err)
assert.NotPanics(t, func() {
backend.StopMonitoring()

119
core/internal/server/network/backend_networkmanager_wifi_test.go
View File

@@ -21,33 +21,26 @@ func TestNetworkManagerBackend_GetWiFiEnabled(t *testing.T) {
}
func TestNetworkManagerBackend_SetWiFiEnabled(t *testing.T) {
backend, err := NewNetworkManagerBackend()
if err != nil {
t.Skipf("NetworkManager not available: %v", err)
}
mockNM := mock_gonetworkmanager.NewMockNetworkManager(t)
originalState, err := backend.GetWiFiEnabled()
if err != nil {
t.Skipf("Cannot get WiFi state: %v", err)
}
backend, err := NewNetworkManagerBackend(mockNM)
assert.NoError(t, err)
defer func() {
backend.SetWiFiEnabled(originalState)
}()
mockNM.EXPECT().SetPropertyWirelessEnabled(true).Return(nil)
err = backend.SetWiFiEnabled(!originalState)
err = backend.SetWiFiEnabled(true)
assert.NoError(t, err)
backend.stateMutex.RLock()
assert.Equal(t, !originalState, backend.state.WiFiEnabled)
assert.True(t, backend.state.WiFiEnabled)
backend.stateMutex.RUnlock()
}
func TestNetworkManagerBackend_ScanWiFi_NoDevice(t *testing.T) {
backend, err := NewNetworkManagerBackend()
if err != nil {
t.Skipf("NetworkManager not available: %v", err)
}
mockNM := mock_gonetworkmanager.NewMockNetworkManager(t)
backend, err := NewNetworkManagerBackend(mockNM)
assert.NoError(t, err)
backend.wifiDevice = nil
err = backend.ScanWiFi()
@@ -56,14 +49,14 @@ func TestNetworkManagerBackend_ScanWiFi_NoDevice(t *testing.T) {
}
func TestNetworkManagerBackend_ScanWiFi_Disabled(t *testing.T) {
backend, err := NewNetworkManagerBackend()
if err != nil {
t.Skipf("NetworkManager not available: %v", err)
}
mockNM := mock_gonetworkmanager.NewMockNetworkManager(t)
mockDeviceWireless := mock_gonetworkmanager.NewMockDeviceWireless(t)
if backend.wifiDevice == nil {
t.Skip("No WiFi device available")
}
backend, err := NewNetworkManagerBackend(mockNM)
assert.NoError(t, err)
backend.wifiDevice = mockDeviceWireless
backend.wifiDev = mockDeviceWireless
backend.stateMutex.Lock()
backend.state.WiFiEnabled = false
@@ -75,10 +68,10 @@ func TestNetworkManagerBackend_ScanWiFi_Disabled(t *testing.T) {
}
func TestNetworkManagerBackend_GetWiFiNetworkDetails_NoDevice(t *testing.T) {
backend, err := NewNetworkManagerBackend()
if err != nil {
t.Skipf("NetworkManager not available: %v", err)
}
mockNM := mock_gonetworkmanager.NewMockNetworkManager(t)
backend, err := NewNetworkManagerBackend(mockNM)
assert.NoError(t, err)
backend.wifiDevice = nil
_, err = backend.GetWiFiNetworkDetails("TestNetwork")
@@ -87,10 +80,10 @@ func TestNetworkManagerBackend_GetWiFiNetworkDetails_NoDevice(t *testing.T) {
}
func TestNetworkManagerBackend_ConnectWiFi_NoDevice(t *testing.T) {
backend, err := NewNetworkManagerBackend()
if err != nil {
t.Skipf("NetworkManager not available: %v", err)
}
mockNM := mock_gonetworkmanager.NewMockNetworkManager(t)
backend, err := NewNetworkManagerBackend(mockNM)
assert.NoError(t, err)
backend.wifiDevice = nil
req := ConnectionRequest{SSID: "TestNetwork", Password: "password"}
@@ -100,14 +93,14 @@ func TestNetworkManagerBackend_ConnectWiFi_NoDevice(t *testing.T) {
}
func TestNetworkManagerBackend_ConnectWiFi_AlreadyConnected(t *testing.T) {
backend, err := NewNetworkManagerBackend()
if err != nil {
t.Skipf("NetworkManager not available: %v", err)
}
mockNM := mock_gonetworkmanager.NewMockNetworkManager(t)
mockDeviceWireless := mock_gonetworkmanager.NewMockDeviceWireless(t)
if backend.wifiDevice == nil {
t.Skip("No WiFi device available")
}
backend, err := NewNetworkManagerBackend(mockNM)
assert.NoError(t, err)
backend.wifiDevice = mockDeviceWireless
backend.wifiDev = mockDeviceWireless
backend.stateMutex.Lock()
backend.state.WiFiConnected = true
@@ -120,10 +113,10 @@ func TestNetworkManagerBackend_ConnectWiFi_AlreadyConnected(t *testing.T) {
}
func TestNetworkManagerBackend_DisconnectWiFi_NoDevice(t *testing.T) {
backend, err := NewNetworkManagerBackend()
if err != nil {
t.Skipf("NetworkManager not available: %v", err)
}
mockNM := mock_gonetworkmanager.NewMockNetworkManager(t)
backend, err := NewNetworkManagerBackend(mockNM)
assert.NoError(t, err)
backend.wifiDevice = nil
err = backend.DisconnectWiFi()
@@ -132,10 +125,10 @@ func TestNetworkManagerBackend_DisconnectWiFi_NoDevice(t *testing.T) {
}
func TestNetworkManagerBackend_IsConnectingTo(t *testing.T) {
backend, err := NewNetworkManagerBackend()
if err != nil {
t.Skipf("NetworkManager not available: %v", err)
}
mockNM := mock_gonetworkmanager.NewMockNetworkManager(t)
backend, err := NewNetworkManagerBackend(mockNM)
assert.NoError(t, err)
backend.stateMutex.Lock()
backend.state.IsConnecting = true
@@ -147,10 +140,10 @@ func TestNetworkManagerBackend_IsConnectingTo(t *testing.T) {
}
func TestNetworkManagerBackend_IsConnectingTo_NotConnecting(t *testing.T) {
backend, err := NewNetworkManagerBackend()
if err != nil {
t.Skipf("NetworkManager not available: %v", err)
}
mockNM := mock_gonetworkmanager.NewMockNetworkManager(t)
backend, err := NewNetworkManagerBackend(mockNM)
assert.NoError(t, err)
backend.stateMutex.Lock()
backend.state.IsConnecting = false
@@ -161,10 +154,10 @@ func TestNetworkManagerBackend_IsConnectingTo_NotConnecting(t *testing.T) {
}
func TestNetworkManagerBackend_UpdateWiFiNetworks_NoDevice(t *testing.T) {
backend, err := NewNetworkManagerBackend()
if err != nil {
t.Skipf("NetworkManager not available: %v", err)
}
mockNM := mock_gonetworkmanager.NewMockNetworkManager(t)
backend, err := NewNetworkManagerBackend(mockNM)
assert.NoError(t, err)
backend.wifiDevice = nil
_, err = backend.updateWiFiNetworks()
@@ -173,10 +166,10 @@ func TestNetworkManagerBackend_UpdateWiFiNetworks_NoDevice(t *testing.T) {
}
func TestNetworkManagerBackend_FindConnection_NoSettings(t *testing.T) {
backend, err := NewNetworkManagerBackend()
if err != nil {
t.Skipf("NetworkManager not available: %v", err)
}
mockNM := mock_gonetworkmanager.NewMockNetworkManager(t)
backend, err := NewNetworkManagerBackend(mockNM)
assert.NoError(t, err)
backend.settings = nil
_, err = backend.findConnection("NonExistentNetwork")
@@ -184,10 +177,10 @@ func TestNetworkManagerBackend_FindConnection_NoSettings(t *testing.T) {
}
func TestNetworkManagerBackend_CreateAndConnectWiFi_NoDevice(t *testing.T) {
backend, err := NewNetworkManagerBackend()
if err != nil {
t.Skipf("NetworkManager not available: %v", err)
}
mockNM := mock_gonetworkmanager.NewMockNetworkManager(t)
backend, err := NewNetworkManagerBackend(mockNM)
assert.NoError(t, err)
backend.wifiDevice = nil
backend.wifiDev = nil