Commit 5fc2ebef2ca03e91117f0673d8d8a29139ea9b88

  • avatar
  • Patrick Stählin <pstaehlin @futu…lab.ch>
  • Fri Jul 23 11:52:10 CEST 2010
Factored common parts out into a fixture
tests/eventtests.cpp
(161 / 316)
  
11/*
2 Copyright (c) 2009 digitalSTROM.org, Zurich, Switzerland
2 Copyright (c) 2009, 2010 digitalSTROM.org, Zurich, Switzerland
33
44 Author: Patrick Staehlin, futureLAB AG <pstaehlin@futurelab.ch>
55
……
4646
4747BOOST_AUTO_TEST_SUITE(Events)
4848
49BOOST_AUTO_TEST_CASE(testSimpleEvent) {
50 EventQueue queue(2);
51 EventRunner runner;
52 EventInterpreter interpreter(NULL);
53 interpreter.setEventQueue(&queue);
54 interpreter.setEventRunner(&runner);
55 interpreter.run();
49class NonRunningFixture {
50public:
51 NonRunningFixture() {
52 m_pQueue.reset(new EventQueue(2));
53 m_pRunner.reset(new EventRunner());
54 m_pEventInterpreter.reset(new EventInterpreter(NULL));
55 m_pEventInterpreter->setEventQueue(m_pQueue.get());
56 m_pEventInterpreter->setEventRunner(m_pRunner.get());
57 m_pQueue->setEventRunner(m_pRunner.get());
58 m_pRunner->setEventQueue(m_pQueue.get());
59 m_pEventInterpreter->initialize();
60 }
5661
62protected:
63 boost::shared_ptr<EventQueue> m_pQueue;
64 boost::shared_ptr<EventRunner> m_pRunner;
65 boost::shared_ptr<EventInterpreter> m_pEventInterpreter;
66};
67
68class Fixture : public NonRunningFixture {
69public:
70 Fixture() {
71 m_pEventInterpreter->run();
72 }
73
74 ~Fixture() {
75 m_pQueue->shutdown();
76 m_pEventInterpreter->terminate();
77 sleepMS(5);
78 }
79};
80
81
82BOOST_FIXTURE_TEST_CASE(testSimpleEvent, Fixture) {
5783 boost::shared_ptr<Event> pEvent(new Event("event1"));
5884
59 queue.pushEvent(pEvent);
85 m_pQueue->pushEvent(pEvent);
6086
6187 sleepMS(5);
6288
63 BOOST_CHECK_EQUAL(interpreter.getEventsProcessed(), 1);
89 BOOST_CHECK_EQUAL(m_pEventInterpreter->getEventsProcessed(), 1);
6490
6591 pEvent.reset(new Event("event2"));
6692
67 queue.pushEvent(pEvent);
93 m_pQueue->pushEvent(pEvent);
6894
6995 sleepMS(5);
7096
71 BOOST_CHECK_EQUAL(interpreter.getEventsProcessed(), 2);
72
73 queue.shutdown();
74 interpreter.terminate();
75 sleepMS(5);
97 BOOST_CHECK_EQUAL(m_pEventInterpreter->getEventsProcessed(), 2);
7698} // testSimpleEvent
7799
78BOOST_AUTO_TEST_CASE(testSubscription) {
79 EventQueue queue(2);
80 EventRunner runner;
81 EventInterpreter interpreter(NULL);
82 interpreter.setEventQueue(&queue);
83 interpreter.setEventRunner(&runner);
84 EventInterpreterPlugin* plugin = new EventInterpreterPluginRaiseEvent(&interpreter);
85 interpreter.addPlugin(plugin);
100BOOST_FIXTURE_TEST_CASE(testSubscription, Fixture) {
101 EventInterpreterPlugin* plugin = new EventInterpreterPluginRaiseEvent(m_pEventInterpreter.get());
102 m_pEventInterpreter->addPlugin(plugin);
86103
87 interpreter.run();
88
89104 boost::shared_ptr<Event> pEvent(new Event("my_event"));
90105
91106 boost::shared_ptr<SubscriptionOptions> opts(new SubscriptionOptions());
92107 opts->setParameter("event_name", "event1");
93108 opts->setParameter("test_override", "always testing");
94109 opts->setParameter("test2_default", "defaults to that");
95 boost::shared_ptr<EventSubscription> subscription(new EventSubscription("my_event", "raise_event", interpreter, opts));
96 interpreter.subscribe(subscription);
110 boost::shared_ptr<EventSubscription> subscription(new EventSubscription("my_event", "raise_event", *m_pEventInterpreter, opts));
111 m_pEventInterpreter->subscribe(subscription);
97112
98 queue.pushEvent(pEvent);
113 m_pQueue->pushEvent(pEvent);
99114
100115 sleepMS(5);
101116
102 BOOST_CHECK_EQUAL(interpreter.getEventsProcessed(), 2);
117 BOOST_CHECK_EQUAL(m_pEventInterpreter->getEventsProcessed(), 2);
103118
104119 pEvent.reset(new Event("event2"));
105120
106 queue.pushEvent(pEvent);
121 m_pQueue->pushEvent(pEvent);
107122
108123 sleepMS(5);
109124
110 BOOST_CHECK_EQUAL(interpreter.getEventsProcessed(), 3);
111
112 queue.shutdown();
113 interpreter.terminate();
114 sleepMS(5);
125 BOOST_CHECK_EQUAL(m_pEventInterpreter->getEventsProcessed(), 3);
115126} // testSubscription
116127
117BOOST_AUTO_TEST_CASE(testEmptySubscriptionXML) {
118 EventQueue queue;
119 EventInterpreter interpreter(NULL);
120 interpreter.setEventQueue(&queue);
121 interpreter.initialize();
128BOOST_FIXTURE_TEST_CASE(testEmptySubscriptionXML, NonRunningFixture) {
129 BOOST_CHECK_EQUAL(m_pEventInterpreter->getNumberOfSubscriptions(), 0);
122130
123 BOOST_CHECK_EQUAL(interpreter.getNumberOfSubscriptions(), 0);
124
125131 std::string fileName = getTempDir() + "/testsubscriptions_empty.xml";
126132 std::ofstream ofs(fileName.c_str());
127133 ofs << "<?xml version=\"1.0\"?>\n<subscriptions version=\"1\">\n</subscriptions>";
128134 ofs.close();
129135
130 interpreter.loadFromXML(fileName);
136 m_pEventInterpreter->loadFromXML(fileName);
131137
132 BOOST_CHECK_EQUAL(interpreter.getNumberOfSubscriptions(), 0);
138 BOOST_CHECK_EQUAL(m_pEventInterpreter->getNumberOfSubscriptions(), 0);
133139 boost::filesystem::remove_all(fileName);
134140} // testEmptySubscriptionXML
135141
136BOOST_AUTO_TEST_CASE(testNonExistingXML) {
137 EventInterpreter interpreter(NULL);
138 interpreter.initialize();
142BOOST_FIXTURE_TEST_CASE(testNonExistingXML, NonRunningFixture) {
143 BOOST_CHECK_EQUAL(m_pEventInterpreter->getNumberOfSubscriptions(), 0);
139144
140 BOOST_CHECK_EQUAL(interpreter.getNumberOfSubscriptions(), 0);
141
142145 try {
143 interpreter.loadFromXML("data/iwillnever_be_a_subscription.xml");
146 m_pEventInterpreter->loadFromXML("data/iwillnever_be_a_subscription.xml");
144147 } catch(std::runtime_error& e) {
145148 }
146149
147 BOOST_CHECK_EQUAL(interpreter.getNumberOfSubscriptions(), 0);
150 BOOST_CHECK_EQUAL(m_pEventInterpreter->getNumberOfSubscriptions(), 0);
148151} // testNonExistingXML
149152
150BOOST_AUTO_TEST_CASE(testSubscriptionXML) {
151 EventQueue queue(2);
152 EventRunner runner;
153 EventInterpreter interpreter(NULL);
154 interpreter.setEventQueue(&queue);
155 interpreter.setEventRunner(&runner);
156 queue.setEventRunner(&runner);
157 runner.setEventQueue(&queue);
158 EventInterpreterPlugin* plugin = new EventInterpreterPluginRaiseEvent(&interpreter);
159 interpreter.addPlugin(plugin);
153BOOST_FIXTURE_TEST_CASE(testSubscriptionXML, Fixture) {
154 EventInterpreterPlugin* plugin = new EventInterpreterPluginRaiseEvent(m_pEventInterpreter.get());
155 m_pEventInterpreter->addPlugin(plugin);
160156
161 BOOST_CHECK_EQUAL(interpreter.getNumberOfSubscriptions(), 0);
157 BOOST_CHECK_EQUAL(m_pEventInterpreter->getNumberOfSubscriptions(), 0);
162158
163159 std::string fileName = getTempDir() + "/testsubscriptions.xml";
164160 std::ofstream ofs(fileName.c_str());
……
174174 "</subscriptions>\n";
175175 ofs.close();
176176
177 interpreter.loadFromXML(fileName);
177 m_pEventInterpreter->loadFromXML(fileName);
178178
179 BOOST_CHECK_EQUAL(interpreter.getNumberOfSubscriptions(), 2);
179 BOOST_CHECK_EQUAL(m_pEventInterpreter->getNumberOfSubscriptions(), 2);
180180
181 BOOST_CHECK_EQUAL(interpreter.getEventsProcessed(), 0);
181 BOOST_CHECK_EQUAL(m_pEventInterpreter->getEventsProcessed(), 0);
182182
183 interpreter.run();
183 BOOST_CHECK_EQUAL(m_pEventInterpreter->getEventsProcessed(), 0);
184184
185 sleepMS(5);
186
187 BOOST_CHECK_EQUAL(interpreter.getEventsProcessed(), 0);
188
189185 boost::shared_ptr<Event> evt(new Event("event1"));
190 queue.pushEvent(evt);
186 m_pQueue->pushEvent(evt);
191187
192188 sleepMS(5);
193189
194 runner.runOnce();
190 m_pRunner->runOnce();
195191
196192 sleepMS(1200);
197193
198 BOOST_CHECK_EQUAL(interpreter.getEventsProcessed(), 2);
194 BOOST_CHECK_EQUAL(m_pEventInterpreter->getEventsProcessed(), 2);
199195
200 queue.shutdown();
201 interpreter.terminate();
202 sleepMS(5);
203196 boost::filesystem::remove_all(fileName);
204197} // testSubscriptionXML
205198
206BOOST_AUTO_TEST_CASE(testDS485Events) {
207 EventQueue queue(5);
208 EventRunner runner;
209 EventInterpreter interpreter(NULL);
210 interpreter.setEventQueue(&queue);
211 interpreter.setEventRunner(&runner);
212 queue.setEventRunner(&runner);
213 runner.setEventQueue(&queue);
214
199BOOST_FIXTURE_TEST_CASE(testDS485Events, Fixture) {
215200 ModelMaintenance maintenance(NULL);
216201 Apartment apt(NULL);
217202 maintenance.setApartment(&apt);
……
224224 dev4.setShortAddress(4);
225225
226226
227 EventInterpreterPlugin* plugin = new EventInterpreterPluginRaiseEvent(&interpreter);
228 interpreter.addPlugin(plugin);
229 plugin = new EventInterpreterPluginDS485(apt, &proxy, &interpreter);
230 interpreter.addPlugin(plugin);
227 EventInterpreterPlugin* plugin = new EventInterpreterPluginRaiseEvent(m_pEventInterpreter.get());
228 m_pEventInterpreter->addPlugin(plugin);
229 plugin = new EventInterpreterPluginDS485(apt, &proxy, m_pEventInterpreter.get());
230 m_pEventInterpreter->addPlugin(plugin);
231231
232 BOOST_CHECK_EQUAL(interpreter.getNumberOfSubscriptions(), 0);
232 BOOST_CHECK_EQUAL(m_pEventInterpreter->getNumberOfSubscriptions(), 0);
233233
234234 std::string fileName = getTempDir() + "/testsubscriptions_DS485.xml";
235235 std::ofstream ofs(fileName.c_str());
……
244244 "</subscriptions>\n";
245245 ofs.close();
246246
247 interpreter.loadFromXML(fileName);
247 m_pEventInterpreter->loadFromXML(fileName);
248 boost::filesystem::remove_all(fileName);
248249
249 BOOST_CHECK_EQUAL(interpreter.getNumberOfSubscriptions(), 1);
250 BOOST_CHECK_EQUAL(m_pEventInterpreter->getNumberOfSubscriptions(), 1);
250251
251 BOOST_CHECK_EQUAL(interpreter.getEventsProcessed(), 0);
252 BOOST_CHECK_EQUAL(m_pEventInterpreter->getEventsProcessed(), 0);
252253
253 interpreter.run();
254
255254 sleepMS(5);
256255
257 BOOST_CHECK_EQUAL(interpreter.getEventsProcessed(), 0);
256 BOOST_CHECK_EQUAL(m_pEventInterpreter->getEventsProcessed(), 0);
258257
259258 boost::shared_ptr<Event> evt(new Event("brighter", &apt.getZone(0)));
260259 evt->setLocation("dev1");
261 queue.pushEvent(evt);
260 m_pQueue->pushEvent(evt);
262261
263262 sleepMS(5);
264263
265 runner.runOnce();
266
267 sleepMS(5);
268
269 BOOST_CHECK_EQUAL(interpreter.getEventsProcessed(), 1);
270
271 queue.shutdown();
272 interpreter.terminate();
273 sleepMS(5);
274 boost::filesystem::remove_all(fileName);
264 BOOST_CHECK_EQUAL(m_pEventInterpreter->getEventsProcessed(), 1);
275265} // testDS485Events
276266
277267BOOST_AUTO_TEST_CASE(testEventHandlerJavascriptDoesntLeakExceptionsWithNonexistingFile) {
……
276276 plugin->handleEvent(evt, subscription);
277277} // testEventHandlerJavascriptDoesntLeakExceptionsWithNonexistingFile
278278
279BOOST_AUTO_TEST_CASE(testRemovingSubscription) {
280 EventQueue queue(2);
281 EventRunner runner;
282 EventInterpreter interpreter(NULL);
283 interpreter.setEventQueue(&queue);
284 interpreter.setEventRunner(&runner);
285 EventInterpreterPlugin* plugin = new EventInterpreterPluginRaiseEvent(&interpreter);
286 interpreter.addPlugin(plugin);
279BOOST_FIXTURE_TEST_CASE(testRemovingSubscription, Fixture) {
280 EventInterpreterPlugin* plugin = new EventInterpreterPluginRaiseEvent(m_pEventInterpreter.get());
281 m_pEventInterpreter->addPlugin(plugin);
287282
288 interpreter.run();
289
290283 boost::shared_ptr<Event> pEvent(new Event("my_event"));
291284
292285 boost::shared_ptr<SubscriptionOptions> opts(new SubscriptionOptions());
293286 opts->setParameter("event_name", "event1");
294 boost::shared_ptr<EventSubscription> subscription(new EventSubscription("my_event", "raise_event", interpreter, opts));
295 interpreter.subscribe(subscription);
287 boost::shared_ptr<EventSubscription> subscription(new EventSubscription("my_event", "raise_event", *m_pEventInterpreter, opts));
288 m_pEventInterpreter->subscribe(subscription);
296289
297 queue.pushEvent(pEvent);
290 m_pQueue->pushEvent(pEvent);
298291
299292 sleepMS(5);
300293
301 BOOST_CHECK_EQUAL(interpreter.getEventsProcessed(), 2);
294 BOOST_CHECK_EQUAL(m_pEventInterpreter->getEventsProcessed(), 2);
302295
303 interpreter.unsubscribe(subscription->getID());
296 m_pEventInterpreter->unsubscribe(subscription->getID());
304297
305 queue.pushEvent(pEvent);
298 m_pQueue->pushEvent(pEvent);
306299
307300 sleepMS(5);
308301
309 BOOST_CHECK_EQUAL(interpreter.getEventsProcessed(), 3);
310
311 queue.shutdown();
312 interpreter.terminate();
313 sleepMS(5);
302 BOOST_CHECK_EQUAL(m_pEventInterpreter->getEventsProcessed(), 3);
314303} // testRemovingSubscription
315304
316305BOOST_AUTO_TEST_CASE(testUniqueEventsWork) {
……
394394 BOOST_CHECK_EQUAL(eventFromQueue.getEvent()->getPropertyByName("time"), "+2");
395395} // testUniqueEventsOverwritesTimeProperty
396396
397BOOST_AUTO_TEST_CASE(testEventCollector) {
398 EventQueue queue(1);
399 EventRunner runner;
400 EventInterpreter interpreter(NULL);
401 interpreter.setEventQueue(&queue);
402 interpreter.setEventRunner(&runner);
403 EventInterpreterInternalRelay* relay = new EventInterpreterInternalRelay(&interpreter);
404 interpreter.addPlugin(relay);
397BOOST_FIXTURE_TEST_CASE(testEventCollector, Fixture) {
398 EventInterpreterInternalRelay* relay = new EventInterpreterInternalRelay(m_pEventInterpreter.get());
399 m_pEventInterpreter->addPlugin(relay);
405400
406 interpreter.run();
407
408401 EventCollector collector(*relay);
409402 std::string subscriptionID = collector.subscribeTo("my_event");
410403
411404 boost::shared_ptr<Event> pEvent(new Event("my_event"));
412 queue.pushEvent(pEvent);
405 m_pQueue->pushEvent(pEvent);
413406
414407 sleepMS(5);
415408
416 BOOST_CHECK_EQUAL(interpreter.getEventsProcessed(), 1);
409 BOOST_CHECK_EQUAL(m_pEventInterpreter->getEventsProcessed(), 1);
417410
418411 BOOST_CHECK_EQUAL(collector.hasEvent(), true);
419412
……
414414 BOOST_CHECK_EQUAL(evt.getName(), "my_event");
415415
416416 pEvent.reset(new Event("event2"));
417 queue.pushEvent(pEvent);
417 m_pQueue->pushEvent(pEvent);
418418
419419 sleepMS(5);
420420
421 BOOST_CHECK_EQUAL(interpreter.getEventsProcessed(), 2);
421 BOOST_CHECK_EQUAL(m_pEventInterpreter->getEventsProcessed(), 2);
422422
423423 BOOST_CHECK_EQUAL(collector.hasEvent(), false);
424424
425425 collector.unsubscribeFrom(subscriptionID);
426426
427427 pEvent.reset(new Event("my_event"));
428 queue.pushEvent(pEvent);
428 m_pQueue->pushEvent(pEvent);
429429
430430 sleepMS(5);
431431
432 BOOST_CHECK_EQUAL(interpreter.getEventsProcessed(), 3);
432 BOOST_CHECK_EQUAL(m_pEventInterpreter->getEventsProcessed(), 3);
433433
434434 BOOST_CHECK_EQUAL(collector.hasEvent(), false);
435
436 queue.shutdown();
437 interpreter.terminate();
438 sleepMS(5);
439435} // testEventCollector
440436
441437class InternalEventRelayTester {
……
455455 int m_Counter;
456456}; // InternalEventRelayTester
457457
458BOOST_AUTO_TEST_CASE(testInternalEventRelay) {
459 EventQueue queue(2);
460 EventRunner runner;
461 EventInterpreter interpreter(NULL);
462 interpreter.setEventQueue(&queue);
463 interpreter.setEventRunner(&runner);
464 EventInterpreterInternalRelay* relay = new EventInterpreterInternalRelay(&interpreter);
465 interpreter.addPlugin(relay);
458BOOST_FIXTURE_TEST_CASE(testInternalEventRelay, Fixture) {
459 EventInterpreterInternalRelay* relay = new EventInterpreterInternalRelay(m_pEventInterpreter.get());
460 m_pEventInterpreter->addPlugin(relay);
466461
467 interpreter.run();
468
469462 InternalEventRelayTarget target(*relay);
470463 boost::shared_ptr<EventSubscription> subscriptionOne(
471464 new dss::EventSubscription(
472465 "one",
473466 EventInterpreterInternalRelay::getPluginName(),
474 interpreter,
467 *m_pEventInterpreter,
475468 boost::shared_ptr<SubscriptionOptions>())
476469 );
477470 target.subscribeTo(subscriptionOne);
……
472472 new dss::EventSubscription(
473473 "two",
474474 EventInterpreterInternalRelay::getPluginName(),
475 interpreter,
475 *m_pEventInterpreter,
476476 boost::shared_ptr<SubscriptionOptions>())
477477 );
478478 target.subscribeTo(subscriptionTwo);
……
481481 target.setCallback(boost::bind(&InternalEventRelayTester::onEvent, &tester, _1, _2));
482482
483483 boost::shared_ptr<Event> pEvent(new Event("one"));
484 queue.pushEvent(pEvent);
484 m_pQueue->pushEvent(pEvent);
485485
486486 sleepMS(10);
487487
488 BOOST_CHECK_EQUAL(interpreter.getEventsProcessed(), 1);
488 BOOST_CHECK_EQUAL(m_pEventInterpreter->getEventsProcessed(), 1);
489489 BOOST_CHECK_EQUAL(tester.getCounter(), 1);
490490
491 queue.pushEvent(pEvent);
491 m_pQueue->pushEvent(pEvent);
492492
493493 sleepMS(10);
494494
495 BOOST_CHECK_EQUAL(interpreter.getEventsProcessed(), 2);
495 BOOST_CHECK_EQUAL(m_pEventInterpreter->getEventsProcessed(), 2);
496496 BOOST_CHECK_EQUAL(tester.getCounter(), 2);
497497
498498 pEvent.reset(new Event("two"));
499 queue.pushEvent(pEvent);
499 m_pQueue->pushEvent(pEvent);
500500
501501 sleepMS(10);
502502
503 BOOST_CHECK_EQUAL(interpreter.getEventsProcessed(), 3);
503 BOOST_CHECK_EQUAL(m_pEventInterpreter->getEventsProcessed(), 3);
504504 BOOST_CHECK_EQUAL(tester.getCounter(), 4);
505
506 queue.shutdown();
507 interpreter.terminate();
508 sleepMS(10);
509505}
510506
511507class InternalEventRelayCollector {
……
519519 boost::shared_ptr<Event> m_pCoughtEvent;
520520}; // InternalEventRelayTester
521521
522BOOST_AUTO_TEST_CASE(testOverrideOnlyOverrides) {
523 EventQueue queue(2);
524 EventRunner runner;
525 EventInterpreter interpreter(NULL);
526 interpreter.setEventQueue(&queue);
527 interpreter.setEventRunner(&runner);
528 EventInterpreterInternalRelay* relay = new EventInterpreterInternalRelay(&interpreter);
529 interpreter.addPlugin(relay);
530 EventInterpreterPluginRaiseEvent* plugin = new EventInterpreterPluginRaiseEvent(&interpreter);
531 interpreter.addPlugin(plugin);
522class RelayEventFixture : public Fixture {
523public:
524 static const std::string kReraisedName;
532525
533 interpreter.run();
526 RelayEventFixture() {
527 m_pRelay = new EventInterpreterInternalRelay(m_pEventInterpreter.get());
528 m_pEventInterpreter->addPlugin(m_pRelay);
529 EventInterpreterPluginRaiseEvent* plugin = new EventInterpreterPluginRaiseEvent(m_pEventInterpreter.get());
530 m_pEventInterpreter->addPlugin(plugin);
531 m_pTarget.reset( new InternalEventRelayTarget(*m_pRelay));
532 m_pSubscription.reset(
533 new dss::EventSubscription(
534 kReraisedName,
535 EventInterpreterInternalRelay::getPluginName(),
536 *m_pEventInterpreter,
537 boost::shared_ptr<SubscriptionOptions>())
538 );
534539
535 const std::string kReraisedName = "reraised_event";
536 InternalEventRelayTarget target(*relay);
537 boost::shared_ptr<EventSubscription> subscriptionOne(
538 new dss::EventSubscription(
539 kReraisedName,
540 EventInterpreterInternalRelay::getPluginName(),
541 interpreter,
542 boost::shared_ptr<SubscriptionOptions>())
543 );
540 m_pTarget->subscribeTo(m_pSubscription);
544541
542 m_pTarget->setCallback(boost::bind(&InternalEventRelayCollector::onEvent, &m_Tester, _1, _2));
543 }
544protected:
545 EventInterpreterInternalRelay* m_pRelay;
546 boost::shared_ptr<InternalEventRelayTarget> m_pTarget;
547 boost::shared_ptr<EventSubscription> m_pSubscription;
548 InternalEventRelayCollector m_Tester;
549};
550
551const std::string RelayEventFixture::kReraisedName = "reraised_event";
552
553BOOST_FIXTURE_TEST_CASE(testOverrideOnlyOverrides, RelayEventFixture) {
545554 boost::shared_ptr<SubscriptionOptions> opts(new SubscriptionOptions());
546555 opts->setParameter("event_name", kReraisedName);
547556 opts->setParameter("test_override", "always testing");
548 boost::shared_ptr<EventSubscription> subscription(new EventSubscription("my_event", "raise_event", interpreter, opts));
549 interpreter.subscribe(subscription);
557 boost::shared_ptr<EventSubscription> subscription(new EventSubscription("my_event", "raise_event", *m_pEventInterpreter, opts));
558 m_pEventInterpreter->subscribe(subscription);
550559
551 target.subscribeTo(subscriptionOne);
552
553 InternalEventRelayCollector tester;
554 target.setCallback(boost::bind(&InternalEventRelayCollector::onEvent, &tester, _1, _2));
555
556560 boost::shared_ptr<Event> pEvent(new Event("my_event"));
557 queue.pushEvent(pEvent);
561 m_pQueue->pushEvent(pEvent);
558562
559563 sleepMS(10);
560564
561 BOOST_CHECK_EQUAL(interpreter.getEventsProcessed(), 2);
562 BOOST_CHECK(tester.getCoughtEvent()->getPropertyByName("test").empty());
563
564 queue.shutdown();
565 interpreter.terminate();
566 sleepMS(10);
565 BOOST_CHECK_EQUAL(m_pEventInterpreter->getEventsProcessed(), 2);
566 BOOST_CHECK(m_Tester.getCoughtEvent()->getPropertyByName("test").empty());
567567}
568568
569BOOST_AUTO_TEST_CASE(testOverrideOverrides) {
570 EventQueue queue(2);
571 EventRunner runner;
572 EventInterpreter interpreter(NULL);
573 interpreter.setEventQueue(&queue);
574 interpreter.setEventRunner(&runner);
575 EventInterpreterInternalRelay* relay = new EventInterpreterInternalRelay(&interpreter);
576 interpreter.addPlugin(relay);
577 EventInterpreterPluginRaiseEvent* plugin = new EventInterpreterPluginRaiseEvent(&interpreter);
578 interpreter.addPlugin(plugin);
579
580 interpreter.run();
581
582 const std::string kReraisedName = "reraised_event";
583 InternalEventRelayTarget target(*relay);
584 boost::shared_ptr<EventSubscription> subscriptionOne(
585 new dss::EventSubscription(
586 kReraisedName,
587 EventInterpreterInternalRelay::getPluginName(),
588 interpreter,
589 boost::shared_ptr<SubscriptionOptions>())
590 );
591
569BOOST_FIXTURE_TEST_CASE(testOverrideOverrides, RelayEventFixture) {
592570 boost::shared_ptr<SubscriptionOptions> opts(new SubscriptionOptions());
593571 opts->setParameter("event_name", kReraisedName);
594572 const std::string kTestValue = "always testing";
595573 opts->setParameter("test_override", kTestValue);
596 boost::shared_ptr<EventSubscription> subscription(new EventSubscription("my_event", "raise_event", interpreter, opts));
597 interpreter.subscribe(subscription);
574 boost::shared_ptr<EventSubscription> subscription(new EventSubscription("my_event", "raise_event", *m_pEventInterpreter, opts));
575 m_pEventInterpreter->subscribe(subscription);
598576
599 target.subscribeTo(subscriptionOne);
600
601 InternalEventRelayCollector tester;
602 target.setCallback(boost::bind(&InternalEventRelayCollector::onEvent, &tester, _1, _2));
603
604577 boost::shared_ptr<Event> pEvent(new Event("my_event"));
605578 pEvent->setProperty("test", "bla");
606 queue.pushEvent(pEvent);
579 m_pQueue->pushEvent(pEvent);
607580
608581 sleepMS(10);
609582
610 BOOST_CHECK_EQUAL(interpreter.getEventsProcessed(), 2);
611 BOOST_CHECK_EQUAL(tester.getCoughtEvent()->getPropertyByName("test"), kTestValue);
612
613 queue.shutdown();
614 interpreter.terminate();
615 sleepMS(10);
583 BOOST_CHECK_EQUAL(m_pEventInterpreter->getEventsProcessed(), 2);
584 BOOST_CHECK_EQUAL(m_Tester.getCoughtEvent()->getPropertyByName("test"), kTestValue);
616585}
617586
618BOOST_AUTO_TEST_CASE(testDefaultDoesntOverride) {
619 EventQueue queue(2);
620 EventRunner runner;
621 EventInterpreter interpreter(NULL);
622 interpreter.setEventQueue(&queue);
623 interpreter.setEventRunner(&runner);
624 EventInterpreterInternalRelay* relay = new EventInterpreterInternalRelay(&interpreter);
625 interpreter.addPlugin(relay);
626 EventInterpreterPluginRaiseEvent* plugin = new EventInterpreterPluginRaiseEvent(&interpreter);
627 interpreter.addPlugin(plugin);
628
629 interpreter.run();
630
631 const std::string kReraisedName = "reraised_event";
632 InternalEventRelayTarget target(*relay);
633 boost::shared_ptr<EventSubscription> subscriptionOne(
634 new dss::EventSubscription(
635 kReraisedName,
636 EventInterpreterInternalRelay::getPluginName(),
637 interpreter,
638 boost::shared_ptr<SubscriptionOptions>())
639 );
640
587BOOST_FIXTURE_TEST_CASE(testDefaultDoesntOverride, RelayEventFixture) {
641588 boost::shared_ptr<SubscriptionOptions> opts(new SubscriptionOptions());
642589 opts->setParameter("event_name", kReraisedName);
643590 const std::string kTestValue = "always testing";
644591 opts->setParameter("test_default", kTestValue);
645 boost::shared_ptr<EventSubscription> subscription(new EventSubscription("my_event", "raise_event", interpreter, opts));
646 interpreter.subscribe(subscription);
592 boost::shared_ptr<EventSubscription> subscription(new EventSubscription("my_event", "raise_event", *m_pEventInterpreter, opts));
593 m_pEventInterpreter->subscribe(subscription);
647594
648 target.subscribeTo(subscriptionOne);
649
650 InternalEventRelayCollector tester;
651 target.setCallback(boost::bind(&InternalEventRelayCollector::onEvent, &tester, _1, _2));
652
653595 boost::shared_ptr<Event> pEvent(new Event("my_event"));
654596 const std::string kOriginalValue = "bla";
655597 pEvent->setProperty("test", kOriginalValue);
656 queue.pushEvent(pEvent);
598 m_pQueue->pushEvent(pEvent);
657599
658600 sleepMS(10);
659601
660 BOOST_CHECK_EQUAL(interpreter.getEventsProcessed(), 2);
661 BOOST_CHECK_EQUAL(tester.getCoughtEvent()->getPropertyByName("test"), kOriginalValue);
662
663 queue.shutdown();
664 interpreter.terminate();
665 sleepMS(10);
602 BOOST_CHECK_EQUAL(m_pEventInterpreter->getEventsProcessed(), 2);
603 BOOST_CHECK_EQUAL(m_Tester.getCoughtEvent()->getPropertyByName("test"), kOriginalValue);
666604}
667605
668BOOST_AUTO_TEST_CASE(testDefaultSetsDefault) {
669 EventQueue queue(2);
670 EventRunner runner;
671 EventInterpreter interpreter(NULL);
672 interpreter.setEventQueue(&queue);
673 interpreter.setEventRunner(&runner);
674 EventInterpreterInternalRelay* relay = new EventInterpreterInternalRelay(&interpreter);
675 interpreter.addPlugin(relay);
676 EventInterpreterPluginRaiseEvent* plugin = new EventInterpreterPluginRaiseEvent(&interpreter);
677 interpreter.addPlugin(plugin);
678
679 interpreter.run();
680
681 const std::string kReraisedName = "reraised_event";
682 InternalEventRelayTarget target(*relay);
683 boost::shared_ptr<EventSubscription> subscriptionOne(
684 new dss::EventSubscription(
685 kReraisedName,
686 EventInterpreterInternalRelay::getPluginName(),
687 interpreter,
688 boost::shared_ptr<SubscriptionOptions>())
689 );
690
606BOOST_FIXTURE_TEST_CASE(testDefaultSetsDefault, RelayEventFixture) {
691607 boost::shared_ptr<SubscriptionOptions> opts(new SubscriptionOptions());
692608 opts->setParameter("event_name", kReraisedName);
693609 const std::string kTestValue = "always testing";
694610 opts->setParameter("test_default", kTestValue);
695 boost::shared_ptr<EventSubscription> subscription(new EventSubscription("my_event", "raise_event", interpreter, opts));
696 interpreter.subscribe(subscription);
611 boost::shared_ptr<EventSubscription> subscription(new EventSubscription("my_event", "raise_event", *m_pEventInterpreter, opts));
612 m_pEventInterpreter->subscribe(subscription);
697613
698 target.subscribeTo(subscriptionOne);
699
700 InternalEventRelayCollector tester;
701 target.setCallback(boost::bind(&InternalEventRelayCollector::onEvent, &tester, _1, _2));
702
703614 boost::shared_ptr<Event> pEvent(new Event("my_event"));
704615 const std::string kOriginalValue = "bla";
705 queue.pushEvent(pEvent);
616 m_pQueue->pushEvent(pEvent);
706617
707618 sleepMS(10);
708619
709 BOOST_CHECK_EQUAL(interpreter.getEventsProcessed(), 2);
710 BOOST_CHECK_EQUAL(tester.getCoughtEvent()->getPropertyByName("test"), kTestValue);
711
712 queue.shutdown();
713 interpreter.terminate();
714 sleepMS(10);
620 BOOST_CHECK_EQUAL(m_pEventInterpreter->getEventsProcessed(), 2);
621 BOOST_CHECK_EQUAL(m_Tester.getCoughtEvent()->getPropertyByName("test"), kTestValue);
715622}
716623
717624BOOST_AUTO_TEST_SUITE_END()