File indexing completed on 2024-04-14 03:57:28

 /*
     SPDX-FileCopyrightText: 2014 Jan Grulich <jgrulich@redhat.com>
 
     SPDX-License-Identifier: LGPL-2.1-only OR LGPL-3.0-only OR LicenseRef-KDE-Accepted-LGPL
 */
 
 #include "activeconnectiontest.h"
 
 #include "device.h"
 #include "manager.h"
 #include "settings.h"
 #include "settings/ipv4setting.h"
 #include "settings/ipv6setting.h"
 #include "settings/wiredsetting.h"
 
 #include "fakenetwork/settings.h"
 #include "fakenetwork/wireddevice.h"
 
 #include <QSignalSpy>
 #include <QTest>
 
 void ActiveConnectionTest::initTestCase()
 {
     fakeNetwork = new FakeNetwork();
 
     WiredDevice *device = new WiredDevice();
     /* Device properties */
     device->setAutoconnect(true);
     device->setCapabilities(3);
     device->setDeviceType(1);
     device->setDriver(QLatin1String("e1000e"));
     device->setDriverVersion(QLatin1String("2.3.2-k"));
     device->setFirmwareMissing(false);
     device->setFirmwareVersion(QLatin1String("0.13-3"));
     device->setInterface(QLatin1String("em1"));
     device->setInterfaceFlags(NetworkManager::Device::Interfaceflag::Up);
     device->setManaged(true);
     device->setUdi(QLatin1String("/sys/devices/pci0000:00/0000:00:19.0/net/em1"));
 
     /* Wired device properties */
     device->setCarrier(true);
     device->setHwAddress(QLatin1String("F0:DE:F1:FB:30:C1"));
     device->setPermanentHwAddress(QLatin1String("F0:DE:F1:FB:30:C1"));
 
     fakeNetwork->addDevice(device);
 
     NetworkManager::ConnectionSettings::Ptr connectionSettings =
         NetworkManager::ConnectionSettings::Ptr(new NetworkManager::ConnectionSettings(NetworkManager::ConnectionSettings::Wired));
     connectionSettings->setId("Wired connection");
     connectionSettings->setUuid(QLatin1String("39af79a5-b053-4893-9378-7342a5a30d06"));
     NetworkManager::Ipv4Setting::Ptr ipv4Setting = connectionSettings->setting(NetworkManager::Setting::Ipv4).dynamicCast<NetworkManager::Ipv4Setting>();
     ipv4Setting->setInitialized(true);
     ipv4Setting->setMethod(NetworkManager::Ipv4Setting::Automatic);
     NetworkManager::Ipv6Setting::Ptr ipv6Setting = connectionSettings->setting(NetworkManager::Setting::Ipv6).dynamicCast<NetworkManager::Ipv6Setting>();
     ipv6Setting->setInitialized(true);
     ipv6Setting->setMethod(NetworkManager::Ipv6Setting::Automatic);
     NetworkManager::WiredSetting::Ptr wiredSetting = connectionSettings->setting(NetworkManager::Setting::Wired).dynamicCast<NetworkManager::WiredSetting>();
     wiredSetting->setInitialized(true);
     // Something needs to be set to not use default values, when using default values we get an empty map
     wiredSetting->setSpeed(100);
 
     NetworkManager::Device::Ptr wiredDevice = NetworkManager::networkInterfaces().first().objectCast<NetworkManager::Device>();
     QSignalSpy availableConnectionAppearedSpy(wiredDevice.data(), SIGNAL(availableConnectionAppeared(QString)));
     NetworkManager::addConnection(connectionSettings->toMap());
     QVERIFY(availableConnectionAppearedSpy.wait());
 }
 
 void ActiveConnectionTest::testActiveConnection()
 {
     qRegisterMetaType<NetworkManager::ActiveConnection::State>("NetworkManager::ActiveConnection::State");
     qRegisterMetaType<NetworkManager::ActiveConnection::Reason>("NetworkManager::ActiveConnection::Reason");
     qRegisterMetaType<NetworkManager::Device::State>("NetworkManager::Device::State");
     qRegisterMetaType<NetworkManager::Device::StateChangeReason>("NetworkManager::Device::StateChangeReason");
     qRegisterMetaType<NetworkManager::Connectivity>("NetworkManager::Connectivity");
     qRegisterMetaType<NetworkManager::Status>("NetworkManager::Status");
 
     NetworkManager::Device::Ptr device = NetworkManager::networkInterfaces().first();
     QSignalSpy deviceActiveConnectionChangedSpy(device.data(), SIGNAL(activeConnectionChanged()));
     QSignalSpy deviceIpInterfaceChangedSpy(device.data(), SIGNAL(ipInterfaceChanged()));
     QSignalSpy deviceStateChangedSpy(
         device.data(),
         SIGNAL(stateChanged(NetworkManager::Device::State, NetworkManager::Device::State, NetworkManager::Device::StateChangeReason)));
 
     NetworkManager::Connection::Ptr connection = device->availableConnections().first();
 
     QSignalSpy activeConnectionAddedSpy(NetworkManager::notifier(), SIGNAL(activeConnectionAdded(QString)));
     QSignalSpy activatingConnectionChangedSpy(NetworkManager::notifier(), SIGNAL(activatingConnectionChanged(QString)));
     QSignalSpy connectivityChangedSpy(NetworkManager::notifier(), SIGNAL(connectivityChanged(NetworkManager::Connectivity)));
     QSignalSpy primaryConnectionChangedSpy(NetworkManager::notifier(), SIGNAL(primaryConnectionChanged(QString)));
     QSignalSpy stateChangedSpy(NetworkManager::notifier(), SIGNAL(statusChanged(NetworkManager::Status)));
 
     NetworkManager::activateConnection(connection->path(), device->uni(), QString());
     QVERIFY(activeConnectionAddedSpy.wait());
 
     NetworkManager::ActiveConnection::Ptr activeConnection = NetworkManager::findActiveConnection(activeConnectionAddedSpy.at(0).at(0).toString());
     QSignalSpy activeConnectionStateChangedSpy(activeConnection.data(), SIGNAL(stateChanged(NetworkManager::ActiveConnection::State)));
     QSignalSpy activeConnectionStateChangedReasonSpy(
         activeConnection.data(),
         SIGNAL(stateChangedReason(NetworkManager::ActiveConnection::State, NetworkManager::ActiveConnection::Reason)));
 
     QCOMPARE(activeConnection->devices().first(), device->uni());
     QCOMPARE(activeConnection->state(), NetworkManager::ActiveConnection::Activating);
     QCOMPARE(activeConnection->uuid(), connection->uuid());
 
     QCOMPARE(NetworkManager::activatingConnection()->uuid(), connection->uuid());
 
     // Wait until device goes through all states (PREPARE, CONFIG, NEED_AUTH, IP_CONFIG, IP_CHECK, ACTIVATED)
     QTest::qWait(800);
 
     QCOMPARE(activeConnectionStateChangedSpy.count(), 1);
     QCOMPARE(activeConnectionStateChangedReasonSpy.count(), 1);
 
     QCOMPARE(deviceStateChangedSpy.count(), 6);
     QCOMPARE(device->ipInterfaceName(), device->interfaceName());
     QCOMPARE(device->state(), NetworkManager::Device::Activated);
     QCOMPARE(deviceActiveConnectionChangedSpy.count(), 1);
     QCOMPARE(deviceIpInterfaceChangedSpy.count(), 1);
 
     QCOMPARE(NetworkManager::connectivity(), NetworkManager::Full);
     QCOMPARE(NetworkManager::primaryConnection()->uuid(), connection->uuid());
     QCOMPARE(NetworkManager::status(), NetworkManager::Status::Connected);
     QCOMPARE(activatingConnectionChangedSpy.count(), 2);
     QCOMPARE(connectivityChangedSpy.count(), 1);
     QCOMPARE(primaryConnectionChangedSpy.count(), 1);
     QCOMPARE(stateChangedSpy.count(), 1);
 
     NetworkManager::deactivateConnection(activeConnection->path());
 
     // Wait until we are disconnected
     QTest::qWait(300);
 
     QVERIFY(device->ipInterfaceName().isEmpty());
     QCOMPARE(device->state(), NetworkManager::Device::Disconnected);
 
     QCOMPARE(NetworkManager::activeConnections().count(), 0);
     QCOMPARE(NetworkManager::connectivity(), NetworkManager::NoConnectivity);
     QVERIFY(NetworkManager::primaryConnection().isNull());
     QCOMPARE(NetworkManager::status(), NetworkManager::Disconnected);
 }
 
 QTEST_MAIN(ActiveConnectionTest)
 
 #include "moc_activeconnectiontest.cpp"