src/xwalk/application/browser/application_event_router_unittest.cc

   1 // Copyright (c) 2013 Intel Corporation. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "content/public/test/test_browser_thread_bundle.h"
   6 #include "testing/gtest/include/gtest/gtest.h"
   7 #include "xwalk/application/browser/application_event_manager.h"
   8 #include "xwalk/application/browser/application_event_router.h"
   9 #include "xwalk/application/browser/event_observer.h"
  10
  11 namespace xwalk {
  12 namespace application {
  13
  14 namespace {
  15
  16 const char kMockEvent0[] = "MOCK_EVENT_0";
  17 const char kMockEvent1[] = "MOCK_EVENT_1";
  18 const char kMockAppId0[] = "mock_app_0";
  19
  20 std::vector<std::string> g_call_sequence;
  21
  22 class MockEventObserver : public EventObserver {
  23  public:
  24   explicit MockEventObserver(ApplicationEventManager* manager)
  25     : EventObserver(manager) {
  26   }
  27
  28   virtual void Observe(const std::string& app_id,
  29                        scoped_refptr<Event> event) OVERRIDE {
  30     if (event->name() == kMockEvent0 || event->name() == kMockEvent1) {
  31       HandleEvent(app_id, event);
  32       return;
  33     }
  34     NOTREACHED();
  35   }
  36
  37   void HandleEvent(const std::string& app_id, scoped_refptr<Event> event) {
  38     std::string call_info = __FUNCTION__;
  39     call_info += "," + app_id + "," + event->name();
  40     g_call_sequence.push_back(call_info);
  41   }
  42 };
  43
  44 }  // namespace
  45
  46 class ApplicationEventRouterTest : public testing::Test {
  47  public:
  48   virtual void SetUp() OVERRIDE {
  49     dummy_event_manager_.reset(new ApplicationEventManager());
  50     router_.reset(new ApplicationEventRouter(kMockAppId0));
  51   }
  52
  53   void SendEventToApp(const std::string& event_name) {
  54     scoped_refptr<Event> event = Event::CreateEvent(
  55         event_name, scoped_ptr<base::ListValue>(new base::ListValue()));
  56     router_->ProcessEvent(event);
  57   }
  58
  59   int GetObserverCount(const std::string& event_name) {
  60     ApplicationEventRouter::ObserverListMap::iterator it =
  61         router_->observers_.find(event_name);
  62     if (it == router_->observers_.end() || !it->second->might_have_observers())
  63       return 0;
  64     ObserverList<EventObserver>::Iterator ob_it(*it->second);
  65     int count = 0;
  66     while (ob_it.GetNext() != NULL)
  67       ++count;
  68     return count;
  69   }
  70
  71   int GetRegisteredEventCount() {
  72     return router_->observers_.size();
  73   }
  74
  75  protected:
  76   scoped_ptr<ApplicationEventManager> dummy_event_manager_;
  77   scoped_ptr<ApplicationEventRouter> router_;
  78
  79  private:
  80   content::TestBrowserThreadBundle thread_bundle_;
  81 };
  82
  83
  84 TEST_F(ApplicationEventRouterTest, AttachObserver) {
  85   MockEventObserver observer(dummy_event_manager_.get());
  86
  87   router_->AttachObserver(kMockEvent0, &observer);
  88   ASSERT_EQ(GetObserverCount(kMockEvent0), 1);
  89
  90   router_->AttachObserver(kMockEvent1, &observer);
  91   ASSERT_EQ(GetRegisteredEventCount(), 2);
  92   ASSERT_EQ(GetObserverCount(kMockEvent1), 1);
  93 }
  94
  95 TEST_F(ApplicationEventRouterTest, DetachObserverFromEvent) {
  96   MockEventObserver observer1(dummy_event_manager_.get());
  97   MockEventObserver observer2(dummy_event_manager_.get());
  98
  99   router_->AttachObserver(kMockEvent0, &observer1);
 100   ASSERT_EQ(GetObserverCount(kMockEvent0), 1);
 101   router_->AttachObserver(kMockEvent0, &observer2);
 102   ASSERT_EQ(GetObserverCount(kMockEvent0), 2);
 103
 104   router_->DetachObserver(kMockEvent0, &observer1);
 105   ASSERT_EQ(GetObserverCount(kMockEvent0), 1);
 106
 107   // Removing non-exist observer from router must not crash.
 108   router_->DetachObserver(kMockEvent0, &observer1);
 109   ASSERT_EQ(GetObserverCount(kMockEvent0), 1);
 110
 111   router_->DetachObserver(kMockEvent0, &observer2);
 112   ASSERT_EQ(GetObserverCount(kMockEvent0), 0);
 113   ASSERT_EQ(GetRegisteredEventCount(), 0);
 114 }
 115
 116 TEST_F(ApplicationEventRouterTest, DetachObservers) {
 117   MockEventObserver observer1(dummy_event_manager_.get());
 118   MockEventObserver observer2(dummy_event_manager_.get());
 119   MockEventObserver observer3(dummy_event_manager_.get());
 120   router_->AttachObserver(kMockEvent0, &observer1);
 121   router_->AttachObserver(kMockEvent1, &observer1);
 122   router_->AttachObserver(kMockEvent1, &observer2);
 123   router_->AttachObserver(kMockEvent0, &observer3);
 124   router_->AttachObserver(kMockEvent1, &observer3);
 125   ASSERT_EQ(GetObserverCount(kMockEvent0), 2);
 126   ASSERT_EQ(GetObserverCount(kMockEvent1), 3);
 127
 128   router_->DetachObserver(&observer1);
 129   ASSERT_EQ(GetObserverCount(kMockEvent0), 1);
 130   ASSERT_EQ(GetObserverCount(kMockEvent1), 2);
 131
 132   router_->DetachAllObservers();
 133   ASSERT_EQ(GetObserverCount(kMockEvent0), 0);
 134   ASSERT_EQ(GetObserverCount(kMockEvent1), 0);
 135   ASSERT_EQ(GetRegisteredEventCount(), 0);
 136 }
 137
 138 // Dispatch event which has multiple observers, all observers should be
 139 // notified.
 140 TEST_F(ApplicationEventRouterTest, EventDispatch) {
 141   MockEventObserver observer1(dummy_event_manager_.get());
 142   MockEventObserver observer2(dummy_event_manager_.get());
 143   MockEventObserver observer3(dummy_event_manager_.get());
 144   g_call_sequence.clear();
 145   router_->AttachObserver(kMockEvent0, &observer1);
 146   router_->AttachObserver(kMockEvent0, &observer2);
 147   router_->AttachObserver(kMockEvent0, &observer3);
 148
 149   SendEventToApp(kMockEvent0);
 150   ASSERT_EQ(g_call_sequence.size(), 3);
 151 }
 152
 153 }  // namespace application
 154 }  // namespace xwalk