netwerk/wifi/gtest/TestWifiMonitor.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
   5  * You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "gtest/gtest.h"
   8 #include "gmock/gmock.h"
   9 #include "nsIWifiListener.h"
  10 #include "nsWifiMonitor.h"
  11 #include "nsWifiAccessPoint.h"
  12 #include "WifiScanner.h"
  13 #include "nsCOMPtr.h"
  14 #include "mozilla/Preferences.h"
  15 #include "mozilla/Services.h"
  16 #include "nsIObserverService.h"
  17 #include "nsINetworkLinkService.h"
  18 #include "mozilla/SpinEventLoopUntil.h"
  19 #include "nsNetCID.h"
  20 #include "nsServiceManagerUtils.h"
  21
  22 #if defined(XP_WIN) && defined(_M_IX86)
  23 #  include <objbase.h>  // STDMETHODCALLTYPE
  24 #endif
  25
  26 // Tests that wifi scanning happens on the right network change events,
  27 // and that wifi-scan polling is operable on mobile networks.
  28
  29 using ::testing::AtLeast;
  30 using ::testing::Cardinality;
  31 using ::testing::Exactly;
  32 using ::testing::MockFunction;
  33 using ::testing::Sequence;
  34
  35 static mozilla::LazyLogModule gLog("TestWifiMonitor");
  36 #define LOGI(x) MOZ_LOG(gLog, mozilla::LogLevel::Info, x)
  37 #define LOGD(x) MOZ_LOG(gLog, mozilla::LogLevel::Debug, x)
  38
  39 namespace mozilla {
  40
  41 // Timeout if update not received from wifi scanner thread.
  42 static const uint32_t kWifiScanTestResultTimeoutMs = 100;
  43 static const uint32_t kTestWifiScanIntervalMs = 10;
  44
  45 // ID counter, used to make sure each call to GetAccessPointsFromWLAN
  46 // returns "new" access points.
  47 static int gCurrentId = 0;
  48
  49 static uint32_t gNumScanResults = 0;
  50
  51 struct LinkTypeMobility {
  52   const char* mLinkType;
  53   bool mIsMobile;
  54 };
  55
  56 class MockWifiScanner : public WifiScanner {
  57  public:
  58   MOCK_METHOD(nsresult, GetAccessPointsFromWLAN,
  59               (nsTArray<RefPtr<nsIWifiAccessPoint>> & aAccessPoints),
  60               (override));
  61 };
  62
  63 class MockWifiListener : public nsIWifiListener {
  64   virtual ~MockWifiListener() = default;
  65
  66  public:
  67   NS_DECL_THREADSAFE_ISUPPORTS
  68 #if defined(XP_WIN) && defined(_M_IX86)
  69   MOCK_METHOD(nsresult, OnChange,
  70               (const nsTArray<RefPtr<nsIWifiAccessPoint>>& accessPoints),
  71               (override, Calltype(STDMETHODCALLTYPE)));
  72   MOCK_METHOD(nsresult, OnError, (nsresult error),
  73               (override, Calltype(STDMETHODCALLTYPE)));
  74 #else
  75   MOCK_METHOD(nsresult, OnChange,
  76               (const nsTArray<RefPtr<nsIWifiAccessPoint>>& accessPoints),
  77               (override));
  78   MOCK_METHOD(nsresult, OnError, (nsresult error), (override));
  79 #endif
  80 };
  81
  82 NS_IMPL_ISUPPORTS(MockWifiListener, nsIWifiListener)
  83
  84 class TestWifiMonitor : public ::testing::Test {
  85  public:
  86   TestWifiMonitor() {
  87     mObs = mozilla::services::GetObserverService();
  88     MOZ_RELEASE_ASSERT(mObs);
  89
  90     nsresult rv;
  91     nsCOMPtr<nsINetworkLinkService> nls =
  92         do_GetService(NS_NETWORK_LINK_SERVICE_CONTRACTID, &rv);
  93     EXPECT_TRUE(NS_SUCCEEDED(rv));
  94     EXPECT_TRUE(nls);
  95     rv = nls->GetLinkType(&mOrigLinkType);
  96     EXPECT_TRUE(NS_SUCCEEDED(rv));
  97     rv = nls->GetIsLinkUp(&mOrigIsLinkUp);
  98     EXPECT_TRUE(NS_SUCCEEDED(rv));
  99     rv = nls->GetLinkStatusKnown(&mOrigLinkStatusKnown);
 100     EXPECT_TRUE(NS_SUCCEEDED(rv));
 101
 102     // Reduce wifi-polling interval.  0 turns polling off.
 103     mOldScanInterval = Preferences::GetInt(WIFI_SCAN_INTERVAL_MS_PREF);
 104     Preferences::SetInt(WIFI_SCAN_INTERVAL_MS_PREF, kTestWifiScanIntervalMs);
 105   }
 106
 107   ~TestWifiMonitor() {
 108     Preferences::SetInt(WIFI_SCAN_INTERVAL_MS_PREF, mOldScanInterval);
 109
 110     // Restore network link type
 111     const char* linkType = nullptr;
 112     switch (mOrigLinkType) {
 113       case nsINetworkLinkService::LINK_TYPE_UNKNOWN:
 114         linkType = NS_NETWORK_LINK_TYPE_UNKNOWN;
 115         break;
 116       case nsINetworkLinkService::LINK_TYPE_ETHERNET:
 117         linkType = NS_NETWORK_LINK_TYPE_ETHERNET;
 118         break;
 119       case nsINetworkLinkService::LINK_TYPE_USB:
 120         linkType = NS_NETWORK_LINK_TYPE_USB;
 121         break;
 122       case nsINetworkLinkService::LINK_TYPE_WIFI:
 123         linkType = NS_NETWORK_LINK_TYPE_WIFI;
 124         break;
 125       case nsINetworkLinkService::LINK_TYPE_MOBILE:
 126         linkType = NS_NETWORK_LINK_TYPE_MOBILE;
 127         break;
 128       case nsINetworkLinkService::LINK_TYPE_WIMAX:
 129         linkType = NS_NETWORK_LINK_TYPE_WIMAX;
 130         break;
 131     }
 132     EXPECT_TRUE(linkType);
 133     mObs->NotifyObservers(nullptr, NS_NETWORK_LINK_TYPE_TOPIC,
 134                           NS_ConvertUTF8toUTF16(linkType).get());
 135
 136     const char* linkStatus = nullptr;
 137     if (mOrigLinkStatusKnown) {
 138       if (mOrigIsLinkUp) {
 139         linkStatus = NS_NETWORK_LINK_DATA_UP;
 140       } else {
 141         linkStatus = NS_NETWORK_LINK_DATA_DOWN;
 142       }
 143     } else {
 144       linkStatus = NS_NETWORK_LINK_DATA_UNKNOWN;
 145     }
 146     EXPECT_TRUE(linkStatus);
 147     mObs->NotifyObservers(nullptr, NS_NETWORK_LINK_TOPIC,
 148                           NS_ConvertUTF8toUTF16(linkStatus).get());
 149   }
 150
 151  protected:
 152   bool WaitForScanResults() {
 153     // Wait for kWifiScanTestResultTimeoutMs to allow async calls to complete.
 154     bool timedout = false;
 155     RefPtr<CancelableRunnable> timer = NS_NewCancelableRunnableFunction(
 156         "WaitForScanResults Timeout", [&] { timedout = true; });
 157     NS_DelayedDispatchToCurrentThread(do_AddRef(timer),
 158                                       kWifiScanTestResultTimeoutMs);
 159
 160     mozilla::SpinEventLoopUntil("TestWifiMonitor::WaitForScanResults"_ns,
 161                                 [&]() { return timedout; });
 162
 163     timer->Cancel();
 164     return true;
 165   }
 166
 167   void CreateObjects() {
 168     mWifiMonitor = MakeRefPtr<nsWifiMonitor>(MakeUnique<MockWifiScanner>());
 169     EXPECT_TRUE(!mWifiMonitor->IsPolling());
 170
 171     // Start with ETHERNET network type to avoid always polling at test start.
 172     mObs->NotifyObservers(
 173         nullptr, NS_NETWORK_LINK_TYPE_TOPIC,
 174         NS_ConvertUTF8toUTF16(NS_NETWORK_LINK_TYPE_ETHERNET).get());
 175
 176     mWifiListener = new MockWifiListener();
 177     LOGI(("monitor: %p | scanner: %p | listener: %p", mWifiMonitor.get(),
 178           mWifiMonitor->mWifiScanner.get(), mWifiListener.get()));
 179   }
 180
 181   void DestroyObjects() {
 182     ::testing::Mock::VerifyAndClearExpectations(
 183         mWifiMonitor->mWifiScanner.get());
 184     ::testing::Mock::VerifyAndClearExpectations(mWifiListener.get());
 185
 186     // Manually disconnect observers so that the monitor can be destroyed.
 187     // In the browser, this would be done on xpcom-shutdown but that is sent
 188     // after the tests run, which is too late to avoid a gtest memory-leak
 189     // error.
 190     mWifiMonitor->Close();
 191
 192     mWifiMonitor = nullptr;
 193     mWifiListener = nullptr;
 194     gCurrentId = 0;
 195   }
 196
 197   void StartWatching(bool aRequestPolling) {
 198     LOGD(("StartWatching | aRequestPolling: %s | nScanResults: %u",
 199           aRequestPolling ? "true" : "false", gNumScanResults));
 200     EXPECT_TRUE(NS_SUCCEEDED(
 201         mWifiMonitor->StartWatching(mWifiListener, aRequestPolling)));
 202     WaitForScanResults();
 203   }
 204
 205   void NotifyOfNetworkEvent(const char* aTopic, const char16_t* aData) {
 206     LOGD(("NotifyOfNetworkEvent: (%s, %s) | nScanResults: %u", aTopic,
 207           NS_ConvertUTF16toUTF8(aData).get(), gNumScanResults));
 208     EXPECT_TRUE(NS_SUCCEEDED(mObs->NotifyObservers(nullptr, aTopic, aData)));
 209     WaitForScanResults();
 210   }
 211
 212   void StopWatching() {
 213     LOGD(("StopWatching | nScanResults: %u", gNumScanResults));
 214     EXPECT_TRUE(NS_SUCCEEDED(mWifiMonitor->StopWatching(mWifiListener)));
 215     WaitForScanResults();
 216   }
 217
 218   struct MockCallSequences {
 219     Sequence mGetAccessPointsSeq;
 220     Sequence mOnChangeSeq;
 221     Sequence mOnErrorSeq;
 222   };
 223
 224   void AddMockObjectChecks(const Cardinality& aScanCardinality,
 225                            MockCallSequences& aSeqs) {
 226     // Only add WillRepeatedly handler if scans is more than 0, to avoid a
 227     // VERY LOUD gtest warning.
 228     if (aScanCardinality.IsSaturatedByCallCount(0)) {
 229       EXPECT_CALL(
 230           *static_cast<MockWifiScanner*>(mWifiMonitor->mWifiScanner.get()),
 231           GetAccessPointsFromWLAN)
 232           .Times(aScanCardinality)
 233           .InSequence(aSeqs.mGetAccessPointsSeq);
 234
 235       EXPECT_CALL(*mWifiListener, OnChange)
 236           .Times(aScanCardinality)
 237           .InSequence(aSeqs.mOnChangeSeq);
 238     } else {
 239       EXPECT_CALL(
 240           *static_cast<MockWifiScanner*>(mWifiMonitor->mWifiScanner.get()),
 241           GetAccessPointsFromWLAN)
 242           .Times(aScanCardinality)
 243           .InSequence(aSeqs.mGetAccessPointsSeq)
 244           .WillRepeatedly(
 245               [](nsTArray<RefPtr<nsIWifiAccessPoint>>& aAccessPoints) {
 246                 EXPECT_TRUE(!NS_IsMainThread());
 247                 EXPECT_TRUE(aAccessPoints.IsEmpty());
 248                 nsWifiAccessPoint* ap = new nsWifiAccessPoint();
 249                 // Signal will be unique so we won't match the prior access
 250                 // point list.
 251                 ap->mSignal = gCurrentId++;
 252                 aAccessPoints.AppendElement(RefPtr(ap));
 253                 return NS_OK;
 254               });
 255
 256       EXPECT_CALL(*mWifiListener, OnChange)
 257           .Times(aScanCardinality)
 258           .InSequence(aSeqs.mOnChangeSeq)
 259           .WillRepeatedly(
 260               [](const nsTArray<RefPtr<nsIWifiAccessPoint>>& aAccessPoints) {
 261                 EXPECT_TRUE(NS_IsMainThread());
 262                 EXPECT_EQ(aAccessPoints.Length(), 1u);
 263                 ++gNumScanResults;
 264                 return NS_OK;
 265               });
 266     }
 267
 268     EXPECT_CALL(*mWifiListener, OnError).Times(0).InSequence(aSeqs.mOnErrorSeq);
 269   }
 270
 271   void AddStartWatchingCheck(bool aShouldPoll, MockCallSequences& aSeqs) {
 272     AddMockObjectChecks(aShouldPoll ? AtLeast(1) : Exactly(1), aSeqs);
 273   }
 274
 275   void AddNetworkEventCheck(const Cardinality& aScanCardinality,
 276                             MockCallSequences& aSeqs) {
 277     AddMockObjectChecks(aScanCardinality, aSeqs);
 278   }
 279
 280   void AddStopWatchingCheck(bool aShouldPoll, MockCallSequences& aSeqs) {
 281     // When polling, we may get stray scan + OnChange calls asynchronously
 282     // before stopping.  We may also get scan calls after stopping.
 283     // We check that the calls actually stopped in ConfirmStoppedCheck.
 284     AddMockObjectChecks(aShouldPoll ? AtLeast(0) : Exactly(0), aSeqs);
 285   }
 286
 287   void AddConfirmStoppedCheck(MockCallSequences& aSeqs) {
 288     AddMockObjectChecks(Exactly(0), aSeqs);
 289   }
 290
 291   // A Checkpoint is just a mocked function taking an int.  It will serve
 292   // as a temporal barrier that requires all expectations before it to be
 293   // satisfied and retired (meaning they won't be used in matches anymore).
 294   class Checkpoint {
 295    public:
 296     void Check(uint32_t aId, MockCallSequences& aSeqs) {
 297       EXPECT_CALL(mFn, Call(aId))
 298           .InSequence(aSeqs.mGetAccessPointsSeq, aSeqs.mOnChangeSeq,
 299                       aSeqs.mOnErrorSeq);
 300     }
 301
 302     void Reach(uint32_t aId) { mFn.Call(aId); }
 303
 304    private:
 305     MockFunction<void(uint32_t)> mFn;
 306   };
 307
 308   // A single test is StartWatching, NotifyOfNetworkEvent, and StopWatching.
 309   void RunSingleTest(bool aRequestPolling, bool aShouldPoll,
 310                      const Cardinality& aScanCardinality, const char* aTopic,
 311                      const char16_t* aData) {
 312     LOGI(("RunSingleTest: <%s, %s> | requestPolling: %s | shouldPoll: %s",
 313           aTopic, NS_ConvertUTF16toUTF8(aData).get(),
 314           aRequestPolling ? "true" : "false", aShouldPoll ? "true" : "false"));
 315     MOZ_RELEASE_ASSERT(aShouldPoll || !aRequestPolling);
 316
 317     CreateObjects();
 318
 319     Checkpoint checkpoint;
 320     {
 321       // gmock expectations are asynchronous by default.  Sequence objects
 322       // are used here to require that expectations occur in the specified
 323       // (partial) order.
 324       MockCallSequences seqs;
 325
 326       AddStartWatchingCheck(aShouldPoll, seqs);
 327       checkpoint.Check(1, seqs);
 328
 329       AddNetworkEventCheck(aScanCardinality, seqs);
 330       checkpoint.Check(2, seqs);
 331
 332       AddStopWatchingCheck(aShouldPoll, seqs);
 333       checkpoint.Check(3, seqs);
 334
 335       AddConfirmStoppedCheck(seqs);
 336     }
 337
 338     // Now run the test on the mock objects.
 339     StartWatching(aRequestPolling);
 340     checkpoint.Reach(1);
 341     EXPECT_EQ(mWifiMonitor->IsPolling(), aRequestPolling);
 342
 343     NotifyOfNetworkEvent(aTopic, aData);
 344     checkpoint.Reach(2);
 345     EXPECT_EQ(mWifiMonitor->IsPolling(), aShouldPoll);
 346
 347     StopWatching();
 348     checkpoint.Reach(3);
 349     EXPECT_TRUE(!mWifiMonitor->IsPolling());
 350
 351     // Wait for extraneous calls as a way to confirm it has stopped.
 352     WaitForScanResults();
 353
 354     DestroyObjects();
 355   }
 356
 357   void CheckMessages(bool aRequestPolling) {
 358     // NS_NETWORK_LINK_TOPIC messages should cause a new scan.
 359     const char* kLinkTopicDatas[] = {
 360         NS_NETWORK_LINK_DATA_UP, NS_NETWORK_LINK_DATA_DOWN,
 361         NS_NETWORK_LINK_DATA_CHANGED, NS_NETWORK_LINK_DATA_UNKNOWN};
 362
 363     for (const auto& data : kLinkTopicDatas) {
 364       RunSingleTest(aRequestPolling, aRequestPolling,
 365                     aRequestPolling ? AtLeast(2) : Exactly(1),
 366                     NS_NETWORK_LINK_TOPIC, NS_ConvertUTF8toUTF16(data).get());
 367     }
 368
 369     // NS_NETWORK_LINK_TYPE_TOPIC should cause wifi scan polling iff the topic
 370     // says we have switched to a mobile network (LINK_TYPE_MOBILE or
 371     // LINK_TYPE_WIMAX) or we are polling the wifi-scanner (aShouldPoll).
 372     const LinkTypeMobility kLinkTypeTopicDatas[] = {
 373         {NS_NETWORK_LINK_TYPE_UNKNOWN, true /* mIsMobile */},
 374         {NS_NETWORK_LINK_TYPE_ETHERNET, false},
 375         {NS_NETWORK_LINK_TYPE_USB, false},
 376         {NS_NETWORK_LINK_TYPE_WIFI, false},
 377         {NS_NETWORK_LINK_TYPE_WIMAX, true},
 378         {NS_NETWORK_LINK_TYPE_MOBILE, true}};
 379
 380     for (const auto& data : kLinkTypeTopicDatas) {
 381       bool shouldPoll = (aRequestPolling || data.mIsMobile);
 382       RunSingleTest(aRequestPolling, shouldPoll,
 383                     shouldPoll ? AtLeast(2) : Exactly(0),
 384                     NS_NETWORK_LINK_TYPE_TOPIC,
 385                     NS_ConvertUTF8toUTF16(data.mLinkType).get());
 386     }
 387   }
 388
 389   RefPtr<nsWifiMonitor> mWifiMonitor;
 390   nsCOMPtr<nsIObserverService> mObs;
 391
 392   RefPtr<MockWifiListener> mWifiListener;
 393
 394   int mOldScanInterval;
 395   uint32_t mOrigLinkType = 0;
 396   bool mOrigIsLinkUp = false;
 397   bool mOrigLinkStatusKnown = false;
 398 };
 399
 400 TEST_F(TestWifiMonitor, WifiScanNoPolling) { CheckMessages(false); }
 401
 402 TEST_F(TestWifiMonitor, WifiScanPolling) { CheckMessages(true); }
 403
 404 }  // namespace mozilla