-
Notifications
You must be signed in to change notification settings - Fork 13
/
Copy pathindex.html
executable file
·3690 lines (3413 loc) · 310 KB
/
index.html
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<meta name="generator" content="pandoc">
<title>The Learn'd Developer: Design Patterns - </title>
<!--[if lt IE 9]>
<script src="http://html5shim.googlecode.com/svn/trunk/html5.js"></script>
<![endif]-->
<style type="text/css">
q { quotes: "“" "”" "‘" "’"; }
</style>
<style type="text/css">
table.sourceCode, tr.sourceCode, td.lineNumbers, td.sourceCode {
margin: 0; padding: 0; vertical-align: baseline; border: none; }
table.sourceCode { width: 100%; }
td.lineNumbers { text-align: right; padding-right: 4px; padding-left: 4px; color: #aaaaaa; border-right: 1px solid #aaaaaa; }
td.sourceCode { padding-left: 5px; }
code > span.kw { color: #007020; font-weight: bold; }
code > span.dt { color: #902000; }
code > span.dv { color: #40a070; }
code > span.bn { color: #40a070; }
code > span.fl { color: #40a070; }
code > span.ch { color: #4070a0; }
code > span.st { color: #4070a0; }
code > span.co { color: #60a0b0; font-style: italic; }
code > span.ot { color: #007020; }
code > span.al { color: #ff0000; font-weight: bold; }
code > span.fu { color: #06287e; }
code > span.er { color: #ff0000; font-weight: bold; }
</style>
<link rel="stylesheet" href="style.css">
<meta name="viewport" content="width=device-width">
</head>
<body>
<p>
<h1>The Learn'd Developer: Design Patterns</h1>
<h3>By Rob Levin</h3>
<h3><a href="http://twitter.com/roblevintennis">@roblevintennis</a></h3>
<h3>Github: <a href="https://github.com/roblevintennis">https://github.com/roblevintennis</a></h3>
</p>
<nav id="TOC">
<ul>
<li><a href="#preface">Preface</a></li>
<li><a href="#introduction">Introduction</a><ul>
<li><a href="#tdd">TDD</a></li>
<li><a href="#design-patterns">Design Patterns</a><ul>
<li><a href="#pattern-structures">Pattern Structures</a></li>
</ul></li>
</ul></li>
<li><a href="#observer-pattern">Observer Pattern</a><ul>
<li><a href="#overview">Overview</a></li>
<li><a href="#observer-pattern-class-diagram">Observer Pattern Class Diagram</a></li>
<li><a href="#implementing-observer-pattern-using-tdd">Implementing Observer Pattern using TDD</a><ul>
<li><a href="#refactoring">Refactoring</a></li>
<li><a href="#a-slight-detour-what-should-i-test">A Slight Detour: What should I test?</a><ul>
<li><a href="#structured-basis-testing">Structured Basis Testing</a></li>
<li><a href="#boundary-conditions-testing">Boundary Conditions Testing</a></li>
<li><a href="#known-error-testing">Known Error Testing</a></li>
<li><a href="#data-flow-testing">Data-Flow Testing</a></li>
<li><a href="#cross-checking">Cross Checking</a></li>
</ul></li>
<li><a href="#testing-both-the-happy-and-sad-paths">Testing both the <q>happy</q> and <q>sad</q> paths</a></li>
<li><a href="#implementing-observers">Implementing Observers</a></li>
</ul></li>
<li><a href="#final-implementation">Final Implementation</a><ul>
<li><a href="#observertests.php">ObserverTests.php</a></li>
<li><a href="#observer.php">Observer.php</a></li>
</ul></li>
<li><a href="#considerations">Considerations</a><ul>
<li><a href="#spl">SPL</a></li>
<li><a href="#push-vs.pull">Push vs. Pull</a></li>
<li><a href="#pitfalls">Pitfalls</a></li>
<li><a href="#example-uses">Example Uses</a></li>
</ul></li>
<li><a href="#exercises">Exercises</a></li>
<li><a href="#summary">Summary</a></li>
</ul></li>
<li><a href="#object-oriented-principles">Object Oriented Principles</a><ul>
<li><a href="#abstraction">Abstraction</a></li>
<li><a href="#class">Class</a></li>
<li><a href="#interface">Interface</a></li>
<li><a href="#dynamic-binding">Dynamic Binding</a></li>
<li><a href="#inheritance">Inheritance</a></li>
<li><a href="#encapsulation">Encapsulation</a></li>
<li><a href="#polymorphism">Polymorphism</a></li>
<li><a href="#s.o.l.i.d.-principles">S.O.L.I.D. Principles</a></li>
<li><a href="#srp-the-single-responsibility-principle">SRP: The Single Responsibility Principle</a></li>
<li><a href="#openclosed-principle">Open/Closed Principle</a></li>
<li><a href="#liskov-substitution-principle">Liskov Substitution Principle</a></li>
<li><a href="#interface-segregation-principle">Interface Segregation Principle</a></li>
<li><a href="#dependency-inversion-principle">Dependency Inversion Principle</a></li>
</ul></li>
<li><a href="#decorator-pattern">Decorator Pattern</a><ul>
<li><a href="#overview-1">Overview</a></li>
<li><a href="#decorator-pattern-class-diagram">Decorator Pattern Class Diagram</a></li>
<li><a href="#decorator-pattern-implementation">Decorator Pattern Implementation</a><ul>
<li><a href="#java-implementation">Java Implementation</a></li>
<li><a href="#php-implementation">PHP Implementation</a></li>
</ul></li>
<li><a href="#considerations-1">Considerations</a><ul>
<li><a href="#decorator-vs.inheritance">Decorator vs. Inheritance</a></li>
<li><a href="#transparency">Transparency</a></li>
</ul></li>
<li><a href="#pitfalls-1">Pitfalls</a></li>
<li><a href="#exercises-1">Exercises</a></li>
</ul></li>
<li><a href="#factory-pattern">Factory Pattern</a><ul>
<li><a href="#overview-2">Overview</a></li>
<li><a href="#factory-method">Factory Method</a><ul>
<li><a href="#factory-method-variations">Factory Method Variations</a></li>
<li><a href="#pitfalls-2">Pitfalls</a><ul>
<li><a href="#layers-of-indirection">Layers of indirection:</a></li>
<li><a href="#conditional-code">Conditional code:</a></li>
<li><a href="#complicated">Complicated:</a></li>
</ul></li>
</ul></li>
<li><a href="#abstract-factory">Abstract Factory</a><ul>
<li><a href="#pitfalls-3">Pitfalls</a><ul>
<li><a href="#adding-new-components">Adding new components:</a></li>
<li><a href="#complexity">Complexity:</a></li>
</ul></li>
</ul></li>
<li><a href="#static-factory">Static Factory</a><ul>
<li><a href="#pitfalls-4">Pitfalls</a></li>
</ul></li>
<li><a href="#final-thoughts">Final Thoughts</a></li>
</ul></li>
<li><a href="#singleton-pattern">Singleton Pattern</a><ul>
<li><a href="#overview-3">Overview</a></li>
<li><a href="#implementation">Implementation</a></li>
</ul></li>
<li><a href="#builder-pattern">Builder Pattern</a><ul>
<li><a href="#overview-4">Overview</a></li>
<li><a href="#participants-and-collaborations">Participants and Collaborations</a></li>
<li><a href="#implementation-1">Implementation</a><ul>
<li><a href="#implementation-2">Implementation</a></li>
</ul></li>
<li><a href="#pitfalls-5">Pitfalls</a></li>
<li><a href="#summary-1">Summary</a></li>
</ul></li>
<li><a href="#command-pattern">Command Pattern</a><ul>
<li><a href="#overview-5">Overview</a><ul>
<li><a href="#implementation-3">Implementation</a></li>
<li><a href="#the-very-simplest-command-pattern-implementation">The <q>Very Simplest</q> Command Pattern Implementation</a></li>
<li><a href="#naming-conventions">Naming Conventions</a></li>
</ul></li>
<li><a href="#example-a-user-interface-toolkit">Example: A user interface toolkit</a><ul>
<li><a href="#designing-on-the-go">Designing <q>on the go</q></a></li>
<li><a href="#implementation-4">Implementation</a></li>
<li><a href="#code-walk-through">Code walk-through</a></li>
</ul></li>
</ul></li>
<li><a href="#template-pattern">Template Pattern</a><ul>
<li><a href="#overview-6">Overview</a></li>
<li><a href="#hollywood-principle">Hollywood Principle</a></li>
<li><a href="#features">Features</a></li>
<li><a href="#hooks">Hooks</a></li>
<li><a href="#participants">Participants</a></li>
<li><a href="#implementation-5">Implementation</a></li>
<li><a href="#example-audio-decoder">Example: Audio Decoder</a></li>
<li><a href="#exercises-2">Exercises</a></li>
<li><a href="#pitfalls-6">Pitfalls</a></li>
<li><a href="#summary-2">Summary</a></li>
</ul></li>
<li><a href="#strategy-pattern">Strategy Pattern</a><ul>
<li><a href="#overview-7">Overview</a></li>
<li><a href="#features-1">Features</a></li>
<li><a href="#participants-1">Participants</a></li>
<li><a href="#implementation-6">Implementation</a></li>
<li><a href="#pitfalls-7">Pitfalls</a></li>
<li><a href="#summary-3">Summary</a></li>
</ul></li>
<li><a href="#state-pattern">State Pattern</a><ul>
<li><a href="#overview-8">Overview</a></li>
<li><a href="#participants-and-collaborations-1">Participants and Collaborations</a></li>
<li><a href="#design-process">Design Process</a><ul>
<li><a href="#states">States</a></li>
<li><a href="#actions">Actions</a></li>
<li><a href="#putting-it-all-together">Putting it all together</a></li>
</ul></li>
<li><a href="#case-study-audio-application">Case Study: Audio Application</a><ul>
<li><a href="#implementation-7">Implementation</a></li>
</ul></li>
<li><a href="#other-use-cases">Other Use Cases</a></li>
<li><a href="#exercises-3">Exercises</a></li>
<li><a href="#benefits">Benefits</a></li>
<li><a href="#issues">Issues</a></li>
<li><a href="#summary-4">Summary</a></li>
</ul></li>
<li><a href="#composite-pattern">Composite Pattern</a><ul>
<li><a href="#overview-9">Overview</a></li>
<li><a href="#implementation-8">Implementation</a></li>
<li><a href="#issues-1">Issues</a></li>
<li><a href="#summary-5">Summary</a></li>
</ul></li>
</ul>
</nav>
<h1 id="preface"><a href="#TOC">Preface</a></h1>
<p>I decided to write this book because I thought it would be interesting to cover Design Patterns using a test-driven approach—I’m a sucker for <q>killing two birds with one stone</q>. Because of this choice, the chapter on Observer pattern serves dual purposes with a particular focus on getting the reader up to speed on TDD basics. More advanced TDD topics like proper use of <em>test doubles</em>, writing testable code, etc., will not be addressed (although I try to provide links for further investigation where appropriate). All this said, the primary subject of this book is not TDD, it’s Design Patterns! Also, please be forwarned that we will not be able to be particularly rigorous in our test coverage and will likely be omitting a lot of defensive code that would be required of a <q>real system</q>. I have chosen understandibility over robustness for an obvious reason—I don’t want the reader to get lost in details that don’t really pertain to the point being made. This is a fairly typical approach, but I apologize in advanced if I somehow insult your sensibilities!</p>
<p><strong>Programming Languages</strong></p>
<p>Most of the examples will be in Java, PHP, and JavaScript, but some might use other languages. This should be fine since:</p>
<ul>
<li>TDD and Design Patterns should be language agnostic</li>
<li>The examples will be simple enough to follow (even if in an unfamiliar language)</li>
</ul>
<p><strong>Resources</strong></p>
<p>I’ve generally listed any resources as clickable web links that you can learn more from, or, as links to where you might purchase the book that I’m referencing.</p>
<p><strong>Line breaks in code</strong></p>
<p>I’ve taken the liberty of purposely wrapping long lines that won’t fit within the width of the page.</p>
<p><em>Also, I’ve found that the generated code samples for PHP do not show up correctly unless I start and end the sample code blocks out with corresponding PHP opening and closing tags. So that’s why every darn PHP code snippet has these!</em></p>
<p><strong>Contributions</strong></p>
<p>I am definitely open to collaborative authorship (hey, I did put it on github!), provided that other authors follow the general style and spirit of the book. At some point, I’ll try to define this all in a more concrete way. If you do want to contribute, you’ll probably want to have a good look at the commented Makefile, and also notice the use of <q>extra lines</q> between code samples. I’ve managed to find workarounds for the somewhat finicky pandoc/docbook tool-chain (and I’m thankful that it works at all since these tools really make life so much easier!)</p>
<p><strong>Special acknowledgement</strong></p>
<p>I feel obliged to commend Addy Osmani on his countless community contributions, particularly in developer education, and acknowledge that seeing the impact of his work inspired me to write myself. Also, the book: <a href="https://github.com/addyosmani">Essential JS Design Patterns</a> is where I shamelessly lifted the pandoc build process being used here!</p>
<h1 id="introduction"><a href="#TOC">Introduction</a></h1>
<p><strong>Why should we study design patterns?</strong></p>
<p>As design patterns help us to use object-oriented best practices, it is useful to already have some meaningful experience in object oriented programming before attempting a deep study of design patterns. In fact, we have seen some try to dissuade a study of design patterns until the reader has reached an architect or designer skill level (whatever exactly that means). Obviously, the more prerequisite knowledge you have, the faster and you’ll be able to grasp difficult abstract concepts; so perhaps there’s some truth to the level of readiness that’s ideal.</p>
<p>However, we would assert that you need not yet be an object oriented master to benefit from an initial study of design patterns. In fact, object oriented and good design go hand in hand—therefore, studying good design should reinforce your understanding of some object oriented concepts. Examples of design pattern implementations show object-oriented best practices <q>in action</q>, and, since many of us learn best by example, the study of the two at the same time just might be complimentary.</p>
<p>Before reading this book, please take some of the following disclaimers and suggestions in to account:</p>
<ul>
<li>design patterns are an ongoing study; you’ll likely learn new things when you return to the material at a later date</li>
<li>therefore, assume that you’ll need to return to the materials at later stages of your career</li>
<li>if we don’t explain something in a way that gets through to you, don’t give up; try to look at a few similar examples on the web, or in other design pattern books, and look for the similarities—it’ll start to make sense!</li>
<li>Our goal is simply to <q>get your feet wet</q> with design patterns and not to cover them exhaustively.</li>
</ul>
<h3 id="tdd"><a href="#TOC">TDD</a></h3>
<p>As we have stated, TDD is <em>not</em> the focus of this book, just an approach we’ve used to examine design patterns. However, unlike the majority of the book, the next chapter on Observer pattern <strong>does</strong> try to act as a sort of <q>TDD: up and running</q> tutorial—we painstakingly examine a TDD session (as we implement the Observer pattern) and go through each test case one by one in order to quickly bring you up to speed in TDD.</p>
<p><em>If you already have a lot of experience doing test-driven development, you may be <q>put off</q> by the verbosity of that chapter. Feel free to jump ahead, and, rest assured that subsequent chapters will be much more <q>to the point</q>.</em></p>
<h3 id="design-patterns"><a href="#TOC">Design Patterns</a></h3>
<p>We would be remiss not to mention the pioneers known as the <em>Gang of Four</em> who, with their book <a href="http://en.wikipedia.org/wiki/Design_Patterns">Design Patterns: Elements of Reusable Object-Oriented Software</a>, described several reusable patterns that can be used to solve common recurring software design dilemnas.</p>
<p>We will discuss several, but not all, of the <a href="http://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612/ref=pd_bxgy_b_text_y">GoF</a> patterns, since they lay the framework from which new design patterns have evolved. As every pattern has its pros and cons, we will list the ones we’ve noticed as applicable. As we cover each particular pattern, we will not be adhering to any rigid <em>pattern structures</em> like those presented in the following section. Our goal is to distill the material in an accessible way. Hence, we advise you to view this book as a supplementary material on the subject.</p>
<h4 id="pattern-structures"><a href="#TOC">Pattern Structures</a></h4>
<p>Formal design pattern descriptions are known to adhere to certain well-defined <em>pattern structures</em>. <a href="http://en.wikipedia.org/wiki/Christopher_Alexander">Christopher Alexandar</a> is an architecture academic who, while pioneering the whole design pattern concept in the first place, provided the <a href="http://c2.com/cgi/wiki?AlexandrianForm">Alexandrian Form</a>. The <em>Gang of Four</em> uses the <a href="http://c2.com/ppr/about/portland.html">Portland Form</a> (which includes no less than: <em>intent, motivation, applicability, structure, implementation, sample code, known uses, and related patterns sections</em>).</p>
<h1 id="observer-pattern"><a href="#TOC">Observer Pattern</a></h1>
<p><strong>Tip:</strong> <em>This is a long chapter that goes through the TDD process with a fine tooth comb. If you’re already comfortable with TDD, feel free to <a href="#final-implementation">skip to the bottom</a> to see the implementation.</em></p>
<h2 id="overview"><a href="#TOC">Overview</a></h2>
<p>Wikipedia describes the <a href="http://en.wikipedia.org/wiki/Observer_pattern" title="Observer Pattern - Wikipedia">Observer Pattern</a> as follows:</p>
<blockquote>
<p>The observer pattern is a software design pattern in which an object, called the subject, maintains a list of its dependents, called observers, and notifies them automatically of any state changes, usually by calling one of their methods…</p>
</blockquote>
<p>There are many event based systems that are quite <a href="https://github.com/millermedeiros/js-signals/wiki/Comparison-between-different-Observer-Pattern-implementations">similar</a> in spirit to the Observer pattern such as: <a href="http://en.wikipedia.org/wiki/Publish%E2%80%93subscribe_pattern">Pub/Sub</a>, <a href="https://github.com/joyent/node/blob/master/lib/events.js">EventEmitter</a> (<a href="https://github.com/joyent/node">node.js</a>), <a href="https://developer.apple.com/library/mac/#documentation/Cocoa/Reference/Foundation/Classes/NSNotificationCenter_Class/Reference/Reference.html">NSNotification</a> (<a href="https://developer.apple.com/technologies/mac/cocoa.html">Cocoa</a>), etc. These all have in common the ability to dynamically notify one to many interested parties via some sort of broadcast mechanism. In the case of the Observer, a <em>subject</em> calls the <code>update</code> method of one to many <em>boserver</em> instances (it does this without needing to know anything specific about these parties other than that they implement a common interface to recieve said notifications). In object oriented circles, this decoupled use of composition and interfaces is called <a href="http://en.wikipedia.org/wiki/Design_Patterns#Introduction.2C_Chapter_1"><em>programming to an interface not an implementation</em></a>. This is a key object oriented principle that allows us to maintain orthogonality in our systems.</p>
<p>Another feature of this pattern is that observers can be added or removed at runtime—thus providing a means to <q>hot swap</q> components easily when needed.</p>
<p>At its core the pattern involves the following steps:</p>
<ol type="1">
<li><p>Allow <em>observers</em> to register (and also unregister) to recieve notifications.</p></li>
<li><p>Keep these observer instances in a suitable data structure such as a <em>List</em> or <em>Array</em>.</p></li>
<li><p>When state changes (e.g. a new article is published, a user logs in, a track is played, etc.) these observers are notified by the <em>subject</em> who calls an interface defined <code>update</code> method on each of the observers.</p></li>
</ol>
<h2 id="observer-pattern-class-diagram"><a href="#TOC">Observer Pattern Class Diagram</a></h2>
<p>The following is a class diagram that represents the Observer Pattern we’ll be discussing in this chapter:</p>
<figure>
<img src="img/observer.png" title="Observer Pattern UML Class Diagram" alt="Observer Pattern Class Diagram"><figcaption>Observer Pattern Class Diagram</figcaption>
</figure>
<p><em>Note that there can be 1..* concrete subjects or observers.</em></p>
<h2 id="implementing-observer-pattern-using-tdd"><a href="#TOC">Implementing Observer Pattern using TDD</a></h2>
<p>Let’s use TDD to implement this pattern. Specifically, we’ll be writing <a href="http://en.wikipedia.org/wiki/Unit_testing">unit tests</a> to test our Observer Pattern implementation as an isolated unit. Please be forwarned that I’ll start out going through each and every <q>Red, Green, Refactor</q> cycle (so you can get a feel for this process), but will eventually start to condense things as we move forward. We’ll be using the <a href="http://www.phpunit.de/manual/current/en/index.html">phpunit framework</a> for this chapter so make sure you have that installed if you’d like to follow along.</p>
<pre class="sourceCode php"><code class="sourceCode php"><span class="kw"><?php</span>
<span class="kw">require_once</span><span class="ot">(</span><span class="st">'Observer.php'</span><span class="ot">);</span>
<span class="kw">class</span> ObserverTests <span class="kw">extends</span> PHPUnit_Framework_TestCase
{
<span class="kw">public</span> <span class="kw">function</span> testSubscribing<span class="ot">()</span>
{
<span class="kw">$publisher</span> = <span class="kw">new</span> Subject<span class="ot">();</span>
}
}
<span class="kw">?></span></code></pre>
<p>And when we run phpunit we get:</p>
<pre class="sourceCode bash"><code class="sourceCode bash">$ phpunit ObserverTest.php <span class="co"># outputs:</span>
Fatal error: Class <span class="st">'Subject'</span> not found <span class="kw">in</span>
/Users/rlevin/programming/labs/BOOK/research/observer/ObserverTests.php on line 8</code></pre>
<p>So now we add the appropriate minimal code to get it green:</p>
<pre class="sourceCode php"><code class="sourceCode php"><span class="kw"><?php</span>
<span class="kw">abstract</span> <span class="kw">class</span> Subject
{
}
<span class="kw">class</span> ConcreteSubject <span class="kw">extends</span> Subject
{
}</code></pre>
<p>And then we move on to finishing up our spec:</p>
<pre class="sourceCode php"><code class="sourceCode php"><span class="kw"><?php</span>
<span class="kw">class</span> ObserverTests <span class="kw">extends</span> PHPUnit_Framework_TestCase
{
<span class="kw">public</span> <span class="kw">function</span> testSubscribing<span class="ot">()</span>
{
<span class="kw">$observer</span> = <span class="fu">array</span><span class="ot">();</span>
<span class="kw">$subject</span> = <span class="kw">new</span> ConcreteSubject<span class="ot">();</span>
<span class="kw">$subject</span>->register<span class="ot">(</span><span class="kw">$observer</span><span class="ot">);</span>
<span class="kw">$this</span>->assertEquals<span class="ot">(</span><span class="dv">1</span><span class="ot">,</span> <span class="kw">$subject</span>->getNumberOfObservers<span class="ot">(),</span>
<span class="st">"Subscriber should have 1 observer when 1 registered."</span><span class="ot">);</span>
}
}
<span class="kw">?></span></code></pre>
<p>Running phpunit again:</p>
<pre class="sourceCode bash"><code class="sourceCode bash">$ phpunit ObserverTest.php <span class="co"># outputs:</span>
Fatal error: Call to undefined method <span class="fu">ConcreteSubject::register()</span> <span class="kw">in</span>
/Users/rlevin/programming/labs/BOOK/research/observer/ObserverTests.php on line 10</code></pre>
<p>So we add the two methods:</p>
<pre class="sourceCode php"><code class="sourceCode php"><span class="kw"><?php</span>
<span class="kw">public</span> <span class="kw">function</span> register<span class="ot">(</span><span class="kw">$observer</span><span class="ot">)</span>
{
}
<span class="kw">public</span> <span class="kw">function</span> getNumberOfObservers<span class="ot">()</span>
{
}
<span class="kw">?></span></code></pre>
<p>And get following:</p>
<pre class="sourceCode bash"><code class="sourceCode bash">$ phpunit ObserverTests.php
Should be 1 observer when 1 added.
Failed asserting that null matches expected 1.</code></pre>
<p>So we need to create the data structure to hold our list of observers:</p>
<pre class="sourceCode php"><code class="sourceCode php"><span class="kw"><?php</span>
<span class="kw">abstract</span> <span class="kw">class</span> Subject
{
}
<span class="kw">class</span> ConcreteSubject <span class="kw">extends</span> Subject
{
<span class="kw">private</span> <span class="kw">$observers</span> = <span class="fu">array</span><span class="ot">();</span>
<span class="kw">public</span> <span class="kw">function</span> register<span class="ot">(</span><span class="kw">$observer</span><span class="ot">)</span>
{
<span class="fu">array_push</span><span class="ot">(</span><span class="kw">$this</span>->observers<span class="ot">,</span> <span class="kw">$observer</span><span class="ot">);</span>
}
<span class="kw">public</span> <span class="kw">function</span> getNumberOfObservers<span class="ot">()</span>
{
<span class="kw">return</span> <span class="fu">count</span><span class="ot">(</span><span class="kw">$this</span>->observers<span class="ot">);</span>
}
}
<span class="kw">?></span></code></pre>
<h3 id="refactoring"><a href="#TOC">Refactoring</a></h3>
<p>So now that we have our first test spec defined (and we’re all green), we can take a step back and think about what in this code could be better. This is called <strong>refactoring</strong> (or <a href="http://en.wikipedia.org/wiki/Code_refactoring">Code Refactoring</a>). Note that we only start refactoring when our tests are green.</p>
<p>So, is there something about this code that strikes you as odd? It should! We have an abstract class but we’re not defining any abstract methods. In this case, the <em>register</em> method is really part of our Subject interface so we should add that abstract method to Subject:</p>
<pre class="sourceCode php"><code class="sourceCode php"><span class="kw"><?php</span>
<span class="kw">abstract</span> <span class="kw">class</span> Subject
{
<span class="kw">abstract</span> <span class="kw">public</span> <span class="kw">function</span> register<span class="ot">(</span><span class="kw">$observer</span><span class="ot">);</span>
<span class="co">// abstract public function unregister($observer);</span>
}
<span class="kw">?></span></code></pre>
<p>Notice that we take the liberty of also adding the <code>unregister</code> abstract method, but we comment it out since we want to maintain a fairly fast <q>iterative rhythm</q>.</p>
<p>You may have also noticed that we made a pretend observer object (we could have used a <a href="http://en.wikipedia.org/wiki/Mock_object">fake object</a>, but in this case we knew we’d soon be implementing real observers). Let’s get rid of that and create a very simple but real observer now:</p>
<pre class="sourceCode php"><code class="sourceCode php"><span class="kw"><?php</span>
<span class="kw">public</span> <span class="kw">function</span> testSubscribing<span class="ot">()</span>
{
<span class="kw">$observer</span> = <span class="kw">new</span> ConcreteObserver<span class="ot">();</span>
<span class="st">...</span>
<span class="kw">?></span></code></pre>
<p>And we get a failure saying it’s not defined so…</p>
<pre class="sourceCode php"><code class="sourceCode php"><span class="kw"><?php</span>
<span class="kw">interface</span> iObserver
{
}
<span class="kw">class</span> ConcreteObserver <span class="kw">implements</span> iObserver
{
}
<span class="kw">?></span></code></pre>
<p>Ok, so we’ve proven that we can push an object on to a PHP array. <q>Big deal!</q>, you say. Sure, but we now have the benifit of having some test coverage to build on top of as we introduce more <q>exciting</q> features.</p>
<p><strong><q>Hot swapping</q> components</strong></p>
<p>One of the features of Observer pattern is the ability for observers to attach and detach themselves at runtime. There are many uses for this, but let’s say you wanted to temporarily re-route a minimal production logging system with a more verbose logging system to track down an issue. Rather than taking down the whole system, you could simply swap out the ProductionLogger observer and swap in a VerboseLogger simply calling <em>unregister</em> and <em>register</em> respectively. Then, upon fixing the issue, you could do the reverse, and thus, swap the components back as they were.</p>
<p>So let’s get to work on that <em>unregister</em> method…</p>
<pre class="sourceCode php"><code class="sourceCode php"><span class="kw"><?php</span>
<span class="kw">public</span> <span class="kw">function</span> testUnsubscribing<span class="ot">()</span>
{
<span class="kw">$observer1</span> = <span class="kw">new</span> ConcreteObserver<span class="ot">();</span>
<span class="kw">$observer2</span> = <span class="kw">new</span> ConcreteObserver<span class="ot">();</span>
<span class="kw">$subject</span> = <span class="kw">new</span> ConcreteSubject<span class="ot">();</span>
<span class="kw">$subject</span>->register<span class="ot">(</span><span class="kw">$observer1</span><span class="ot">);</span>
<span class="kw">$subject</span>->register<span class="ot">(</span><span class="kw">$observer2</span><span class="ot">);</span>
<span class="kw">$this</span>->assertEquals<span class="ot">(</span><span class="dv">2</span><span class="ot">,</span> <span class="kw">$subject</span>->getNumberOfObservers<span class="ot">(),</span>
<span class="st">"Should be 2 observers when 2 added."</span><span class="ot">);</span>
<span class="kw">$subject</span>->unregister<span class="ot">(</span><span class="kw">$observer1</span><span class="ot">);</span>
<span class="kw">$this</span>->assertEquals<span class="ot">(</span><span class="dv">1</span><span class="ot">,</span> <span class="kw">$subject</span>->getNumberOfObservers<span class="ot">(),</span>
<span class="st">"Should be 1 observer when 1 when one removed."</span><span class="ot">);</span>
}
<span class="kw">?></span></code></pre>
<p>Of course we get:</p>
<pre class="sourceCode bash"><code class="sourceCode bash">**Fatal error: Call to undefined method <span class="fu">ConcreteSubject::unregister()</span></code></pre>
<p><em>At this point I’m not going to be listing every step (like when we define a class or method when we have an undefined test error just to get the test to pass) but, if you’re following along, remember to take small steps between coding and running your tests.</em></p>
<p>We need to define an <em>unregister</em> method which we do as follows:</p>
<pre class="sourceCode php"><code class="sourceCode php"><span class="kw"><?php</span>
<span class="kw">public</span> <span class="kw">function</span> unregister<span class="ot">(</span><span class="kw">$observer</span><span class="ot">)</span>
{
<span class="kw">foreach</span> <span class="ot">(</span><span class="kw">$this</span>->observers <span class="kw">as</span> <span class="kw">$k</span> => <span class="kw">$v</span><span class="ot">)</span>
{
<span class="kw">if</span> <span class="ot">(</span><span class="kw">$observer</span> == <span class="kw">$v</span><span class="ot">)</span>
{
<span class="fu">unset</span> <span class="ot">(</span><span class="kw">$this</span>->observers<span class="ot">[</span><span class="kw">$k</span><span class="ot">]);</span>
<span class="kw">return</span> <span class="kw">true</span><span class="ot">;</span>
}
}
<span class="kw">return</span> <span class="kw">false</span><span class="ot">;</span>
}
<span class="kw">?></span></code></pre>
<p>And we’re all green again. Our implementation so far is:</p>
<pre class="sourceCode php"><code class="sourceCode php"><span class="kw"><?php</span>
<span class="kw">abstract</span> <span class="kw">class</span> Subject
{
<span class="kw">abstract</span> <span class="kw">public</span> <span class="kw">function</span> register<span class="ot">(</span><span class="kw">$observer</span><span class="ot">);</span>
<span class="kw">abstract</span> <span class="kw">public</span> <span class="kw">function</span> unregister<span class="ot">(</span><span class="kw">$observer</span><span class="ot">);</span>
}
<span class="kw">class</span> ConcreteSubject <span class="kw">extends</span> Subject
{
<span class="kw">private</span> <span class="kw">$observers</span> = <span class="fu">array</span><span class="ot">();</span>
<span class="kw">public</span> <span class="kw">function</span> register<span class="ot">(</span><span class="kw">$observer</span><span class="ot">)</span>
{
<span class="fu">array_push</span><span class="ot">(</span><span class="kw">$this</span>->observers<span class="ot">,</span> <span class="kw">$observer</span><span class="ot">);</span>
}
<span class="kw">public</span> <span class="kw">function</span> unregister<span class="ot">(</span><span class="kw">$observer</span><span class="ot">)</span>
{
<span class="kw">foreach</span> <span class="ot">(</span><span class="kw">$this</span>->observers <span class="kw">as</span> <span class="kw">$k</span> => <span class="kw">$v</span><span class="ot">)</span>
{
<span class="kw">if</span> <span class="ot">(</span><span class="kw">$observer</span> == <span class="kw">$v</span><span class="ot">)</span>
{
<span class="fu">unset</span> <span class="ot">(</span><span class="kw">$this</span>->observers<span class="ot">[</span><span class="kw">$k</span><span class="ot">]);</span>
<span class="kw">return</span> <span class="kw">true</span><span class="ot">;</span>
}
}
<span class="kw">return</span> <span class="kw">false</span><span class="ot">;</span>
}
<span class="kw">public</span> <span class="kw">function</span> getNumberOfObservers<span class="ot">()</span>
{
<span class="kw">return</span> <span class="fu">count</span><span class="ot">(</span><span class="kw">$this</span>->observers<span class="ot">);</span>
}
}
<span class="kw">interface</span> iObserver
{
}
<span class="kw">class</span> ConcreteObserver <span class="kw">implements</span> iObserver
{
}
<span class="kw">?></span></code></pre>
<p><strong>Refactoring Pull Up</strong></p>
<p>At this point, it’s debatable whether Subject should be abstract or an interface since we aren’t supplying any default behavior. Having a quick look, it seems we can <a href="http://en.wikipedia.org/wiki/Pull_Up_refactoring"><q>pull up</q></a> the getNumberOfObservers method. We pull it up into our abstract Subject class as follows:</p>
<pre class="sourceCode php"><code class="sourceCode php"><span class="kw"><?php</span>
<span class="kw">abstract</span> <span class="kw">class</span> Subject
{
<span class="kw">protected</span> <span class="kw">$observers</span> = <span class="fu">array</span><span class="ot">();</span>
<span class="kw">abstract</span> <span class="kw">public</span> <span class="kw">function</span> register<span class="ot">(</span><span class="kw">$observer</span><span class="ot">);</span>
<span class="kw">abstract</span> <span class="kw">public</span> <span class="kw">function</span> unregister<span class="ot">(</span><span class="kw">$observer</span><span class="ot">);</span>
<span class="kw">public</span> <span class="kw">function</span> getNumberOfObservers<span class="ot">()</span>
{
<span class="kw">return</span> <span class="fu">count</span><span class="ot">(</span><span class="kw">$this</span>->observers<span class="ot">);</span>
}
}
<span class="kw">?></span></code></pre>
<p><em>Note that getNumberOfObservers is a method that I took the liberty of creating to make the Subject more testable. It’s not actually part of the Observer pattern.</em></p>
<p><strong>DRY (don’t repeat yourself)</strong></p>
<p>Ok, that looks better but I don’t like our <code>testUnsubscribing</code> spec. It’s too long for such a simple test and also, if you look caefully at <code>testSubscribing</code>, you’ll see that we have duplicate code breaking the <a href="http://www.artima.com/intv/dry.html">DRY Principle</a>. Essentially, the DRY principle states that we want to avoid duplication since that requires us to maintain duplicate code bases in parallel.</p>
<p><strong>Setup and Teardown</strong></p>
<p>We can pull that duplicate code up in to a setUp method (setUp is used to set up state before each test case run; as expected, tearDown executes just after each test case run). Doing so will mean we have to go through and change our references from the local to class level like so:</p>
<pre class="sourceCode php"><code class="sourceCode php"><span class="kw"><?php</span>
<span class="kw">require_once</span><span class="ot">(</span><span class="st">'Observer.php'</span><span class="ot">);</span>
<span class="kw">class</span> ObserverTests <span class="kw">extends</span> PHPUnit_Framework_TestCase
{
<span class="kw">private</span> <span class="kw">$observer</span> = <span class="kw">null</span><span class="ot">;</span>
<span class="kw">private</span> <span class="kw">$observer2</span> = <span class="kw">null</span><span class="ot">;</span>
<span class="kw">private</span> <span class="kw">$subject</span> = <span class="kw">null</span><span class="ot">;</span>
<span class="kw">public</span> <span class="kw">function</span> setUp<span class="ot">()</span>
{
<span class="kw">$this</span>->observer = <span class="kw">new</span> ConcreteObserver<span class="ot">();</span>
<span class="kw">$this</span>->observer2 = <span class="kw">new</span> ConcreteObserver<span class="ot">();</span>
<span class="kw">$this</span>->subject = <span class="kw">new</span> ConcreteSubject<span class="ot">();</span>
}
<span class="kw">public</span> <span class="kw">function</span> tearDown<span class="ot">()</span>
{
<span class="kw">$this</span>->observer = <span class="kw">null</span><span class="ot">;</span>
<span class="kw">$this</span>->observer2 = <span class="kw">null</span><span class="ot">;</span>
<span class="kw">$this</span>->subject = <span class="kw">null</span><span class="ot">;</span>
}
<span class="kw">public</span> <span class="kw">function</span> testSubscribing<span class="ot">()</span>
{
<span class="kw">$observers</span> = <span class="kw">$this</span>->registerMany<span class="ot">(</span><span class="dv">1</span><span class="ot">);</span>
<span class="kw">$this</span>->assertEquals<span class="ot">(</span><span class="dv">1</span><span class="ot">,</span> <span class="kw">$this</span>->subject->getNumberOfObservers<span class="ot">(),</span>
<span class="st">"Subscriber should have 1 observer when 1 observer registered."</span><span class="ot">);</span>
}
<span class="kw">public</span> <span class="kw">function</span> testUnsubscribing<span class="ot">()</span>
{
<span class="kw">$this</span>->subject->register<span class="ot">(</span><span class="kw">$this</span>->observer<span class="ot">);</span>
<span class="kw">$this</span>->subject->register<span class="ot">(</span><span class="kw">$this</span>->observer2<span class="ot">);</span>
<span class="kw">$this</span>->assertEquals<span class="ot">(</span><span class="dv">2</span><span class="ot">,</span> <span class="kw">$this</span>->subject->getNumberOfObservers<span class="ot">(),</span>
<span class="st">"Should be 2 observers when 2 added."</span><span class="ot">);</span>
<span class="kw">$this</span>->subject->unregister<span class="ot">(</span><span class="kw">$this</span>->observer<span class="ot">);</span>
<span class="kw">$this</span>->assertEquals<span class="ot">(</span><span class="dv">1</span><span class="ot">,</span> <span class="kw">$this</span>->subject->getNumberOfObservers<span class="ot">(),</span>
<span class="st">"Should be 1 observer when 1 when one removed."</span><span class="ot">);</span>
}
}
<span class="kw">?></span></code></pre>
<p>You should now notice that—since our last refactoring—the test case has become much more readable and easy to understand. Thus we didn’t just reduce duplication (but more importantly) made our tests <a href="http://en.wikipedia.org/wiki/Self-documenting">self documenting</a>.</p>
<p>For this exercise, we’re using phpunit’s setUp/tearDown combination (similar to JUnit if you’re a Java developer), but you’ll see other similar hooks in other frameworks like beforeEach/afterEach (<a href="http://pivotal.github.com/jasmine/">Jasmine</a>), begin/done (<a href="http://qunitjs.com/">QUnit</a>), etc. These methods are called just before and after each test case allowng you to set up (and tear down) state. This ensures that each test is ran in isolation not depending on any leftover state from previous test case runs.</p>
<p><strong>Helpers</strong></p>
<p>I’d like to do one more refactoring before moving on—I’m not happy with the way we’re registering our observers within each test case. Let us try moving that code in to a helper function:</p>
<pre class="sourceCode php"><code class="sourceCode php"><span class="kw"><?php</span>
<span class="kw">public</span> <span class="kw">function</span> testUnsubscribing<span class="ot">()</span>
{
<span class="kw">$observers</span> = <span class="kw">$this</span>->registerMany<span class="ot">(</span><span class="dv">5</span><span class="ot">);</span>
<span class="st">...</span>
<span class="kw">private</span> <span class="kw">function</span> registerMany<span class="ot">(</span><span class="kw">$n</span><span class="ot">)</span>
{
<span class="kw">$observers</span> = <span class="fu">array</span><span class="ot">();</span>
<span class="kw">foreach</span> <span class="ot">(</span><span class="fu">range</span><span class="ot">(</span><span class="dv">0</span><span class="ot">,</span> <span class="kw">$n</span><span class="dv">-1</span><span class="ot">)</span> <span class="kw">as</span> <span class="kw">$key</span><span class="ot">)</span> {
<span class="kw">$observers</span><span class="ot">[</span><span class="kw">$key</span><span class="ot">]</span> = <span class="kw">new</span> ConcreteObserver<span class="ot">();</span>
<span class="kw">$this</span>->subject->register<span class="ot">(</span><span class="kw">$observers</span><span class="ot">[</span><span class="kw">$key</span><span class="ot">]);</span>
}
<span class="kw">return</span> <span class="kw">$observers</span><span class="ot">;</span>
}
}
<span class="kw">?></span></code></pre>
<p><em>The above helper method is a direct lift from the <strong>rollMany</strong> helper function in the famous bowling game kata. If you haven’t heard of it you should take a quick look at <a href="http://butunclebob.com/ArticleS.UncleBob.TheBowlingGameKata">Uncle Bob’s Bowling Game Kata</a>. Read the short article and perhaps schedule time in your calendar to go through the power point presentation step by step. Better yet, play with the kata using your favorite language(s) in your <q>spare time</q>…it’s quite instructive. Here’s an example of using <a href="http://www.phpunit.de/manual/current/en/behaviour-driven-development.html#behaviour-driven-development.bowlinggame-example">phpunit with BDD to solve Bowling Game</a>.</em></p>
<h3 id="a-slight-detour-what-should-i-test"><a href="#TOC">A Slight Detour: What should I test?</a></h3>
<p>Determining just what to test is a difficult task but here are some general guidelines to help with that process.</p>
<h4 id="structured-basis-testing"><a href="#TOC">Structured Basis Testing</a></h4>
<p>The main idea of <a href="http://www.testingstandards.co.uk/living_glossary.htm#S">Structured Basis Testing</a> is that your test cases, for a particular peice of code, are derived from the code’s logic and you try to have tests in place for every possible branch. So at it’s simplest:</p>
<pre class="sourceCode php"><code class="sourceCode php"><span class="kw"><?php</span>
<span class="kw">function</span> foo<span class="ot">()</span> { <span class="co">// count 1 for the function itself</span>
<span class="kw">if</span> <span class="ot">(</span>something<span class="ot">)</span> { <span class="co">// count 2 for this condition</span>
<span class="co">// ...</span>
} <span class="kw">else</span> <span class="kw">if</span> <span class="ot">(</span>somethingElse<span class="ot">)</span> { <span class="co">// count 3 for this condition</span>
<span class="co">// ...</span>
}
<span class="co">// We count one for function itself because this might be</span>
<span class="co">// all that's executed if neither above are truthy!</span>
<span class="kw">return</span> <span class="kw">true</span><span class="ot">;</span>
}
<span class="kw">?></span></code></pre>
<p>This is also sometimes referred to as <em>logic coverage testing</em>. The programmer’s tome <a href="http://www.cc2e.com/Default.aspx">Code Complete 2</a> discusses this in depth in it’s <em>Chapter 22: Developer Testing</em>.</p>
<h4 id="boundary-conditions-testing"><a href="#TOC">Boundary Conditions Testing</a></h4>
<p><a href="http://www.informit.com/store/practice-of-programming-9780201615869">The Practice of Programming</a> tells us that we should:</p>
<blockquote>
<p>Test code at its boundaries…The idea is that most bugs occur at boundaries.</p>
</blockquote>
<p>When you test production code that can take a range of valid values, use just below minimum, minimum, maximum, and just below and exceeding maximum values. This takes discipline and time (but given that boundaries are likely places where errors creep up) it’s well worth the effort.</p>
<p><em>Also keep in mind that there might be compound boundaries when 2 or more variables interact. An obvious example is when you multiply two numbers. In this case, you have the potential to inadvertantly exceed the maximum value.</em></p>
<h4 id="known-error-testing"><a href="#TOC">Known Error Testing</a></h4>
<p>Is there an area that is likely to be problemattic? If so, make sure to test for that area.</p>
<p>An example might be if you were to implement a <q>time picker</q>. Setting aside time zone and daylight savings concerns, we’d want heavy coverage on times known to be error prone such as: 00:00, 12:00am, 12:00pm (keep in mind the user’s time format might be 12 or 24 hour format!) In addition, you may also want to use: 23:59, 11:59pm, 11:59am, 00:01, 12:01am, 12:01pm, etc.</p>
<h4 id="data-flow-testing"><a href="#TOC">Data-Flow Testing</a></h4>
<p>This is also discussed in the <a href="http://www.cc2e.com/Default.aspx">Code Complete 2</a> book, and you should turn to that resource for more in depth coverage. However, essentially, data-flow testing provides that <em>data usage</em> is just as problemattic as control flow, and that you therefore need to take into account of the various possible states your data structures might be in (e.g. Defined, Used, Killed, Entered, Exited, etc.) Data flow testing is beyond the scope of this book but you can read more in <a href="http://www.cs.swan.ac.uk/~csmarkus/CS339/dissertations/NewM.pdf">this paper</a> if you’re interested.</p>
<h4 id="cross-checking"><a href="#TOC">Cross Checking</a></h4>
<p>If you have to implement something that’s been reliably implemented elsewhere, you may be able to <em>cross check</em> your results against the existing implementation:</p>
<pre class="sourceCode java"><code class="sourceCode java">actual = MyMath.<span class="fu">squareRoot</span>(n);
expected = Math.<span class="fu">sqrt</span>(n);
<span class="fu">assertEquals</span>(actual, expected,
<span class="st">"My implementation of square root should be same as Java's"</span>);</code></pre>
<p><em>In this chapter, we are focusing on using TDD to unit test our Observer implementation thus leaving out many other important types of testing: <a href="http://en.wikipedia.org/wiki/Integration_testing">Integration Testing</a>, <a href="http://en.wikipedia.org/wiki/System_testing">Systems Testing</a>, <a href="http://en.wikipedia.org/wiki/Stress_testing">Stress Testing</a>, etc. In a real system, you will ideally have a suite of complimentary tests that include all of the aformentioned within an <a href="http://en.wikipedia.org/wiki/Continuous_integration">Continuous Integration System</a>. You should also consider using a tool to measure your <a href="http://martinfowler.com/bliki/TestCoverage.html">test code coverage</a>.</em></p>
<h3 id="testing-both-the-happy-and-sad-paths"><a href="#TOC">Testing both the <q>happy</q> and <q>sad</q> paths</a></h3>
<p>Gary Bernhardt, of <a href="https://www.destroyallsoftware.com">Destroy All Software</a>, uses <q>happy</q> and <q>sad</q> to describe the normal and abnormal code paths. At minimum, both of these paths—sometimes also called the nominal and non-nominal paths (but I like Gary’s happy/sad better!)—should get proper test coverage. Perhaps so far we’ve been a bit too joyful!</p>
<pre class="sourceCode php"><code class="sourceCode php"><span class="kw"><?php</span>
<span class="kw">public</span> <span class="kw">function</span> testSubscribingWithFalsy<span class="ot">()</span>
{
<span class="kw">$observers</span> = <span class="kw">$this</span>->subject->register<span class="ot">(</span><span class="kw">null</span><span class="ot">);</span>
<span class="kw">$this</span>->assertEquals<span class="ot">(</span><span class="dv">0</span><span class="ot">,</span> <span class="kw">$this</span>->subject->getNumberOfObservers<span class="ot">(),</span>
<span class="st">"Should be 0 observers if register called with a falsy."</span><span class="ot">);</span>
}
<span class="kw">?></span></code></pre>
<p>Which results in:</p>
<pre class="sourceCode bash"><code class="sourceCode bash">Failed asserting that 1 matches expected 0.</code></pre>
<p>So we change our system under test to be:</p>
<pre class="sourceCode php"><code class="sourceCode php"><span class="kw"><?php</span>
<span class="kw">public</span> <span class="kw">function</span> register<span class="ot">(</span><span class="kw">$observer</span><span class="ot">)</span>
{
<span class="kw">if</span> <span class="ot">(</span>!<span class="fu">empty</span><span class="ot">(</span>\<span class="kw">$observer</span><span class="ot">))</span>
{
<span class="kw">$this</span>->observers<span class="ot">[]</span> = <span class="kw">$observer</span><span class="ot">;</span>
}
}
<span class="kw">?></span></code></pre>
<p>And we’re back to passing. However, not only could we pass in falsy arguments, but we might also pass in a non-observer as well. So we need to defend against that as well:</p>
<pre class="sourceCode php"><code class="sourceCode php"><span class="kw"><?php</span>
<span class="kw">public</span> <span class="kw">function</span> testSubscribingWithNonObserver<span class="ot">()</span>
{
<span class="kw">$nonObserver</span> = <span class="st">"I'm not a legal observer!"</span><span class="ot">;</span>
<span class="kw">$observers</span> = <span class="kw">$this</span>->subject->register<span class="ot">(</span><span class="kw">$nonObserver</span><span class="ot">);</span>
<span class="kw">$this</span>->assertEquals<span class="ot">(</span><span class="dv">0</span><span class="ot">,</span> <span class="kw">$this</span>->subject->getNumberOfObservers<span class="ot">(),</span>
<span class="st">"Should be 0 observers if register called with a falsy."</span><span class="ot">);</span>
}
<span class="kw">?></span></code></pre>
<p>Obviously, we need some type hinting help here and so we try to change our abstract Subject’s interface to be like:</p>
<pre class="sourceCode php"><code class="sourceCode php"><span class="kw"><?php</span>
<span class="kw">abstract</span> <span class="kw">public</span> <span class="kw">function</span> register<span class="ot">(</span>iObserver <span class="kw">$observer</span><span class="ot">);</span>
<span class="kw">abstract</span> <span class="kw">public</span> <span class="kw">function</span> unregister<span class="ot">(</span>iObserver <span class="kw">$observer</span><span class="ot">);</span>
<span class="kw">?></span></code></pre>
<p>But doing this results in the following goliath error output:</p>
<pre class="sourceCode bash"><code class="sourceCode bash">1) ObserverTests::testSubscribingWithFalsy
Argument 1 passed to <span class="fu">ConcreteSubject::register()</span>
must implement interface iObserver, null given...
2) ObserverTests::testSubscribingWithNonObserver
Argument 1 passed to <span class="fu">ConcreteSubject::register()</span>
must implement interface iObserver, string given...
...</code></pre>
<p>But if we look carefully at these errors, we see that the type hinting is actually doing it’s job thus disallowing us to pass both NULL and String to register! Let’s remove the following two test cases:</p>
<pre class="sourceCode php"><code class="sourceCode php"> // public function testSubscribingWithFalsy()
// {
// $observers = $this->subject->register(null);
// $this->assertEquals(0, $this->subject->getNumberOfObservers(),
// "Should be 0 observers when register called with a falsy.");
// }
// public function testSubscribingWithNonObserver()
// {
// $nonObserver = "I'm not a legal observer";
// $observers = $this->subject->register($nonObserver);
// $this->assertEquals(0, $this->subject->getNumberOfObservers(),
// "Should be 0 observers when register called with a falsy.");
// }</code></pre>
<p>After said removal, we’re back to passing again, and we’ve made our production code easier to read:</p>
<pre class="sourceCode php"><code class="sourceCode php"><span class="kw"><?php</span>
<span class="kw">public</span> <span class="kw">function</span> register<span class="ot">(</span>iObserver <span class="kw">$observer</span><span class="ot">)</span>
{
<span class="kw">$this</span>->observers<span class="ot">[]</span> = <span class="kw">$observer</span><span class="ot">;</span>
}
<span class="kw">?></span></code></pre>
<p>Obviously, in a real system we’d need to think of other <q>sad paths</q>, but it’s interesting to note that the mere process of testing has helped us to remove needless code. For example, we don’t have to add code like:</p>
<pre class="sourceCode php"><code class="sourceCode php"> if (is_object($newSubject) &&
$newSubject instanceof Subject) {
...</code></pre>
<p>Let’s continue to look for other possible <q>sad paths</q>:</p>
<pre class="sourceCode php"><code class="sourceCode php"><span class="kw"><?php</span>
<span class="kw">public</span> <span class="kw">function</span> testUnsubscribingWhenNone<span class="ot">()</span>
{
<span class="kw">$actual</span> = <span class="kw">$this</span>->subject->unregister<span class="ot">(</span><span class="kw">new</span> ConcreteObserver<span class="ot">());</span>
<span class="kw">$this</span>->assertEquals<span class="ot">(</span><span class="kw">false</span><span class="ot">,</span> <span class="kw">$actual</span><span class="ot">,</span>
<span class="st">"Unregister returned status should be false if no observers"</span><span class="ot">);</span>
}
<span class="kw">public</span> <span class="kw">function</span> testGetNumberObserversWhenNone<span class="ot">()</span>
{
<span class="kw">$this</span>->assertEquals<span class="ot">(</span><span class="dv">0</span><span class="ot">,</span> <span class="kw">$this</span>->subject->getNumberOfObservers<span class="ot">(),</span>
<span class="st">"Should be 0 observers when none."</span><span class="ot">);</span>
}
<span class="kw">?></span></code></pre>
<p>We try the above and they both pass without any changes. Since the getNumberOfObservers is really just a helper to facilitate testing (and is quite simple), let’s remove that test. We only want <q>useful</q> tests.</p>
<p>Before we can implement our observers we need to add a capability to the subject. In order to be useful, we need to be able to set and get some sort of meaningful data from the Subject. Let’s do that now:</p>
<pre class="sourceCode php"><code class="sourceCode php"><span class="kw"><?php</span>
<span class="kw">public</span> <span class="kw">function</span> testSubjectShouldHoldState<span class="ot">()</span>
{
<span class="kw">$stateAsString</span> = <span class="st">"some state"</span><span class="ot">;</span>
<span class="kw">$this</span>->subject->setState<span class="ot">(</span><span class="kw">$stateAsString</span><span class="ot">);</span>
<span class="kw">$actual</span> = <span class="kw">$this</span>->subject->getState<span class="ot">();</span>
<span class="kw">$this</span>->assertEquals<span class="ot">(</span><span class="kw">$stateAsString</span><span class="ot">,</span> <span class="kw">$actual</span><span class="ot">,</span>
<span class="st">"Should get/set state as string"</span><span class="ot">);</span>
<span class="kw">$stateAsArray</span> = <span class="fu">array</span><span class="ot">(</span><span class="st">'foo'</span> => <span class="st">'foo val'</span><span class="ot">);</span>
<span class="kw">$this</span>->subject->setState<span class="ot">(</span><span class="kw">$stateAsArray</span><span class="ot">);</span>
<span class="kw">$actual</span> = <span class="kw">$this</span>->subject->getState<span class="ot">();</span>
<span class="kw">$this</span>->assertSame<span class="ot">(</span><span class="kw">$stateAsArray</span><span class="ot">,</span> <span class="kw">$actual</span><span class="ot">,</span>
<span class="st">"Should get/set state as array"</span><span class="ot">);</span>
}
<span class="kw">?></span></code></pre>
<p>And the obvious implementation:</p>
<pre class="sourceCode php"><code class="sourceCode php"><span class="kw"><?php</span>
<span class="kw">public</span> <span class="kw">function</span> setState<span class="ot">(</span><span class="kw">$state</span><span class="ot">)</span>
{
<span class="kw">$this</span>->state = <span class="kw">$state</span><span class="ot">;</span>
}
<span class="kw">public</span> <span class="kw">function</span> getState<span class="ot">()</span>
{
<span class="kw">return</span> <span class="kw">$this</span>->state<span class="ot">;</span>
}
<span class="kw">?></span></code></pre>
<p>I’m not pleased with the length of the test case and don’t think it’s too useful to test both for types String and Array. It was the first time through but not for repeatable test suite runs. So I’ll remove the String part leaving just:</p>
<pre class="sourceCode php"><code class="sourceCode php"><span class="kw"><?php</span>
<span class="kw">public</span> <span class="kw">function</span> testSubjectShouldHoldState<span class="ot">()</span>
{
<span class="kw">$stateAsArray</span> = <span class="fu">array</span><span class="ot">(</span><span class="st">'foo'</span> => <span class="st">'foo val'</span><span class="ot">);</span>
<span class="kw">$this</span>->subject->setState<span class="ot">(</span><span class="kw">$stateAsArray</span><span class="ot">);</span>
<span class="kw">$actual</span> = <span class="kw">$this</span>->subject->getState<span class="ot">();</span>
<span class="kw">$this</span>->assertSame<span class="ot">(</span><span class="kw">$stateAsArray</span><span class="ot">,</span> <span class="kw">$actual</span><span class="ot">,</span>
<span class="st">"Should get/set state as array"</span><span class="ot">);</span>
}
<span class="kw">?></span></code></pre>
<p>Again, we want readable and meaningful tests so we sometimes have to make these sorts of judgement calls, and I’m going to favor brevity in this case.</p>
<p>Now that we have a way to hold state, we can start implementing our observer interface:</p>
<pre class="sourceCode php"><code class="sourceCode php"><span class="kw"><?php</span>
<span class="kw">public</span> <span class="kw">function</span> testObserverGetsNotified<span class="ot">()</span>
{
<span class="kw">$subject</span> = <span class="kw">new</span> ConcreteSubject<span class="ot">();</span>
<span class="kw">$observer</span> = <span class="kw">new</span> ConcreteObserver<span class="ot">(</span><span class="kw">$subject</span><span class="ot">);</span>
<span class="kw">$state</span> = <span class="st">'yogabbagabba'</span><span class="ot">;</span>
<span class="kw">$subject</span>->setState<span class="ot">(</span><span class="kw">$state</span><span class="ot">);</span>
<span class="kw">$this</span>->assertEquals<span class="ot">(</span><span class="kw">$state</span><span class="ot">,</span> <span class="kw">$observer</span>->getState<span class="ot">(),</span>
<span class="st">"Setting state in subject notifies observer"</span><span class="ot">);</span>
}
<span class="kw">?></span></code></pre>
<p>And then:</p>
<pre class="sourceCode php"><code class="sourceCode php"><span class="kw"><?php</span>
<span class="kw">interface</span> iObserver
{
<span class="kw">public</span> <span class="kw">function</span> update <span class="ot">(</span>iSubject <span class="kw">$subject</span><span class="ot">);</span>
}
<span class="kw">class</span> ConcreteObserver <span class="kw">implements</span> iObserver
{
<span class="kw">private</span> <span class="kw">$state</span><span class="ot">;</span>
<span class="kw">public</span> <span class="kw">function</span> update <span class="ot">(</span>iSubject <span class="kw">$subject</span><span class="ot">)</span>
{
<span class="kw">$this</span>->state = <span class="kw">$subject</span>->getState<span class="ot">();</span>
}
<span class="kw">public</span> <span class="kw">function</span> getState<span class="ot">()</span>
{
<span class="kw">return</span> <span class="kw">$this</span>->state<span class="ot">;</span>
}
}
<span class="kw">?></span></code></pre>
<p>Resulting in:</p>
<pre class="sourceCode bash"><code class="sourceCode bash">1) ObserverTests::testObserverGetsNotified
Setting state <span class="kw">in</span> subject notifies observer
Failed asserting that null matches expected <span class="st">'yogabbagabba'</span>.</code></pre>
<p>Our observer looks ok, but it’s likely not getting notified (duh, we didn’t implement that yet!)…</p>
<h3 id="implementing-observers"><a href="#TOC">Implementing Observers</a></h3>
<p>So we’re at a sort of critical point here. We’ve implemented quite a bit of code, and we still have more (the notify observers routine for example). Moreover, we can feel our blood pressure rise and our confidence level dropping. What to do? Simply back up a step. Get those tests green again!</p>
<pre class="sourceCode php"><code class="sourceCode php"> // public function testObserverGetsNotified()
// {
// $subject = new ConcreteSubject();
// $observer = new ConcreteObserver($subject);
// $state = 'yogabbagabba';
// $subject->setState($state);
// $this->assertEquals($state, $observer->getState(),
// "Setting state in subject notifies observer");
// }</code></pre>
<p>We’ve simply commented out our last test case, re-ran our tests and we’re green:</p>
<pre class="sourceCode bash"><code class="sourceCode bash">OK, but incomplete or skipped tests!
Tests: 6, Assertions: 6, Incomplete: 1.</code></pre>
<p>We can take a deep breath feeling reassured that we haven’t created a 30 minute debugging session for ourselves. Also note that we’ve left the <q>partially implemented</q> changes in our production code. So we’ve actually made some progress given that, so far, we haven’t caused a regression. We’ll take a bit of a risk, and leave those change in while we implement notifications:</p>
<pre class="sourceCode php"><code class="sourceCode php"><span class="kw"><?php</span>
<span class="kw">public</span> <span class="kw">function</span> testObserverGetsNotified<span class="ot">()</span>
{
<span class="kw">$this</span>->subject->register<span class="ot">(</span><span class="kw">$this</span>->observer<span class="ot">);</span>
<span class="kw">$state</span> = <span class="st">'yogabbagabba'</span><span class="ot">;</span>
<span class="kw">$this</span>->subject->setState<span class="ot">(</span><span class="kw">$state</span><span class="ot">);</span>
<span class="kw">$this</span>->subject->notify<span class="ot">();</span>
<span class="kw">$this</span>->assertEquals<span class="ot">(</span><span class="kw">$state</span><span class="ot">,</span> <span class="kw">$this</span>->observer->getState<span class="ot">(),</span>
<span class="st">"Setting state in subject notifies observer"</span><span class="ot">);</span>
}
<span class="kw">?></span></code></pre>
<p>This was derived from the test case we commented out earlier. If it’s not obvious, we’ve defined $this->observer in setUp. Here’s our full implementation so far:</p>
<pre class="sourceCode php"><code class="sourceCode php"><span class="kw"><?php</span>
<span class="kw">abstract</span> <span class="kw">class</span> Subject
{
<span class="kw">protected</span> <span class="kw">$observers</span><span class="ot">;</span>
<span class="kw">protected</span> <span class="kw">$state</span><span class="ot">;</span>
<span class="kw">abstract</span> <span class="kw">public</span> <span class="kw">function</span> register<span class="ot">(</span>iObserver <span class="kw">$observer</span><span class="ot">);</span>
<span class="kw">abstract</span> <span class="kw">public</span> <span class="kw">function</span> unregister<span class="ot">(</span>iObserver <span class="kw">$observer</span><span class="ot">);</span>
<span class="kw">public</span> <span class="kw">function</span> getNumberOfObservers<span class="ot">()</span>
{
<span class="kw">return</span> <span class="fu">count</span><span class="ot">(</span><span class="kw">$this</span>->observers<span class="ot">);</span>
}
}
<span class="kw">class</span> ConcreteSubject <span class="kw">extends</span> Subject
{
<span class="kw">public</span> <span class="kw">function</span> <span class="fu">__construct</span><span class="ot">()</span>
{
<span class="kw">$this</span>->observers = <span class="fu">array</span><span class="ot">();</span>
}
<span class="kw">public</span> <span class="kw">function</span> register<span class="ot">(</span>iObserver <span class="kw">$observer</span><span class="ot">)</span>
{
<span class="kw">$this</span>->observers<span class="ot">[]</span> = <span class="kw">$observer</span><span class="ot">;</span>
}
<span class="kw">public</span> <span class="kw">function</span> unregister<span class="ot">(</span>iObserver <span class="kw">$observer</span><span class="ot">)</span>
{
<span class="kw">foreach</span> <span class="ot">(</span><span class="kw">$this</span>->observers <span class="kw">as</span> <span class="kw">$k</span> => <span class="kw">$v</span><span class="ot">)</span>
{
<span class="kw">if</span> <span class="ot">(</span><span class="kw">$observer</span> == <span class="kw">$v</span><span class="ot">)</span>
{
<span class="fu">unset</span> <span class="ot">(</span><span class="kw">$this</span>->observers<span class="ot">[</span><span class="kw">$k</span><span class="ot">]);</span>
<span class="kw">return</span> <span class="kw">true</span><span class="ot">;</span>
}
}
<span class="kw">return</span> <span class="kw">false</span><span class="ot">;</span>
}
<span class="kw">public</span> <span class="kw">function</span> notify<span class="ot">()</span>
{
<span class="kw">foreach</span> <span class="ot">(</span><span class="kw">$this</span>->observers <span class="kw">as</span> <span class="kw">$observer</span><span class="ot">)</span> {
<span class="kw">$observer</span>->update<span class="ot">(</span><span class="kw">$this</span><span class="ot">);</span>
}
}
<span class="kw">public</span> <span class="kw">function</span> setState<span class="ot">(</span><span class="kw">$state</span><span class="ot">)</span>
{
<span class="kw">$this</span>->state = <span class="kw">$state</span><span class="ot">;</span>
}
<span class="kw">public</span> <span class="kw">function</span> getState<span class="ot">()</span>
{
<span class="kw">return</span> <span class="kw">$this</span>->state<span class="ot">;</span>
}
}
<span class="kw">interface</span> iObserver
{
<span class="kw">public</span> <span class="kw">function</span> update <span class="ot">(</span>Subject <span class="kw">$subject</span><span class="ot">);</span>
}
<span class="kw">class</span> ConcreteObserver <span class="kw">implements</span> iObserver
{
<span class="kw">private</span> <span class="kw">$state</span> = <span class="kw">null</span><span class="ot">;</span>
<span class="kw">public</span> <span class="kw">function</span> update <span class="ot">(</span>Subject <span class="kw">$subject</span><span class="ot">)</span>
{
<span class="kw">$this</span>->state = <span class="kw">$subject</span>->getState<span class="ot">();</span>
}
<span class="kw">public</span> <span class="kw">function</span> getState<span class="ot">()</span>
{
<span class="kw">return</span> <span class="kw">$this</span>->state<span class="ot">;</span>
}
}
<span class="kw">?></span> </code></pre>
<p>Notice that by using a sprinkle of <a href="http://php.net/manual/en/language.oop5.typehinting.php">type hinting</a>, we don’t have to resort to using things <a href="http://php.net/manual/en/function.method-exists.php">method_exists</a> checks to determine if the subject passed into <em>update</em> actually has a <em>getState</em> method…it can be safely assumed since <em>Subject</em> defines that as an abstract (thus required) method.</p>
<p><strong>Unique observers</strong> We’d like to prevent an exact observer instance getting included in our subject’s observer <em>List</em> twice. There are several approaches we could take to solve this, but let’s go with adding an id property to each observer instance and then utilizing <code>array_unique</code>.</p>
<p>First the ID part:</p>
<pre class="sourceCode php"><code class="sourceCode php"><span class="kw"><?php</span>
<span class="co">// we add this test</span>
<span class="kw">public</span> <span class="kw">function</span> testObserversHaveIds<span class="ot">()</span>
{
<span class="kw">$this</span>->assertNotNull<span class="ot">(</span><span class="kw">$this</span>->observer->getID<span class="ot">());</span>
}
<span class="co">// and we add this to observer:</span>
<span class="kw">private</span> <span class="kw">$state</span> = <span class="kw">null</span><span class="ot">;</span>
<span class="kw">private</span> <span class="kw">$id</span><span class="ot">;</span>
<span class="kw">public</span> <span class="kw">function</span> <span class="fu">__construct</span><span class="ot">()</span>
{
<span class="kw">$this</span>->state = <span class="kw">null</span><span class="ot">;</span>
<span class="kw">$this</span>->id = <span class="fu">uniqid</span> <span class="ot">(</span><span class="fu">rand</span><span class="ot">(),</span> <span class="kw">true</span><span class="ot">);</span>
}
<span class="kw">public</span> <span class="kw">function</span> getID<span class="ot">()</span>
{
<span class="kw">return</span> <span class="kw">$this</span>->id<span class="ot">;</span>
}
<span class="kw">?></span></code></pre>
<p>Now that our observers have IDs, we can have our subject enforce uniqueness in <em>register</em>. First let’s see this fail:</p>
<pre class="sourceCode php"><code class="sourceCode php"><span class="kw"><?php</span>
<span class="kw">public</span> <span class="kw">function</span> testAddingDuplicates<span class="ot">()</span>
{
<span class="kw">$this</span>->subject->register<span class="ot">(</span><span class="kw">$this</span>->observer<span class="ot">);</span>
<span class="kw">$this</span>->subject->register<span class="ot">(</span><span class="kw">$this</span>->observer<span class="ot">);</span>
<span class="kw">$this</span>->assertEquals<span class="ot">(</span><span class="dv">1</span><span class="ot">,</span> <span class="kw">$this</span>->subject->getNumberOfObservers<span class="ot">(),</span>
<span class="st">"Should only add a particular observer instance once"</span><span class="ot">);</span>
}
<span class="kw">?></span></code></pre>
<p>This results in:</p>
<pre class="sourceCode bash"><code class="sourceCode bash">1) ObserverTests::testAddingDuplicates
Should only add observer once
Failed asserting that 2 matches expected 1.</code></pre>
<p>In order to use <code>array_unique</code>we need to first implement a <code>__toString</code> in our observer.</p>
<p>We first comment out <code>testAddingDuplicates</code>, verify our tests are again passing, add the <code><strong>toString</code> method, and once more verify our tests are still passing. After safely adding <code></strong>toString</code>, we uncomment testAddingDuplicates and continue onwards on our mission to disallow duplicates. All we have to at this point is to call <code>array_unique</code> when we register our observers like so:</p>
<pre class="sourceCode php"><code class="sourceCode php"><span class="kw"><?php</span>
<span class="kw">public</span> <span class="kw">function</span> register<span class="ot">(</span>iObserver <span class="kw">$observer</span><span class="ot">)</span>
{
<span class="kw">$this</span>->observers<span class="ot">[]</span> = <span class="kw">$observer</span><span class="ot">;</span>
<span class="kw">$this</span>->observers = <span class="fu">array_unique</span><span class="ot">(</span><span class="kw">$this</span>->observers<span class="ot">);</span>
}
<span class="kw">?></span></code></pre>
<p>Our test is now passing and we’ve ensured all our observers are, in fact, unique instances.</p>
<h2 id="final-implementation"><a href="#TOC">Final Implementation</a></h2>
<p>At this point, we have a fairly complete Observer implementation that could be further extended easily should we so desire.</p>
<h4 id="observertests.php"><a href="#TOC">ObserverTests.php</a></h4>
<pre class="sourceCode php"><code class="sourceCode php"><span class="kw"><?php</span>
<span class="kw">require_once</span><span class="ot">(</span><span class="st">'Observer.php'</span><span class="ot">);</span>
<span class="kw">class</span> ObserverTests <span class="kw">extends</span> PHPUnit_Framework_TestCase
{
<span class="kw">private</span> <span class="kw">$subject</span> = <span class="kw">null</span><span class="ot">;</span>
<span class="kw">private</span> <span class="kw">$observer</span> = <span class="kw">null</span><span class="ot">;</span>
<span class="kw">public</span> <span class="kw">function</span> setUp<span class="ot">()</span>
{
<span class="kw">$this</span>->subject = <span class="kw">new</span> ConcreteSubject<span class="ot">();</span>
<span class="kw">$this</span>->observer = <span class="kw">new</span> ConcreteObserver<span class="ot">(</span><span class="kw">$this</span>->subject<span class="ot">);</span>
}
<span class="kw">public</span> <span class="kw">function</span> tearDown<span class="ot">()</span>
{
<span class="kw">$this</span>->subject = <span class="kw">null</span><span class="ot">;</span>
<span class="kw">$this</span>->observer = <span class="kw">null</span><span class="ot">;</span>
}
<span class="kw">public</span> <span class="kw">function</span> testSubscribing<span class="ot">()</span>
{
<span class="kw">$observers</span> = <span class="kw">$this</span>->registerMany<span class="ot">(</span><span class="dv">1</span><span class="ot">);</span>
<span class="kw">$this</span>->assertEquals<span class="ot">(</span><span class="dv">1</span><span class="ot">,</span> <span class="kw">$this</span>->subject->getNumberOfObservers<span class="ot">(),</span>
<span class="st">"Subscriber should have 1 observer when 1 observer registered."</span><span class="ot">);</span>
}
<span class="kw">public</span> <span class="kw">function</span> testUnsubscribing<span class="ot">()</span>
{
<span class="kw">$observers</span> = <span class="kw">$this</span>->registerMany<span class="ot">(</span><span class="dv">5</span><span class="ot">);</span>
<span class="kw">$this</span>->assertEquals<span class="ot">(</span><span class="dv">5</span><span class="ot">,</span> <span class="kw">$this</span>->subject->getNumberOfObservers<span class="ot">(),</span>
<span class="st">"Should be 5 observers when 5 added."</span><span class="ot">);</span>
<span class="kw">$this</span>->subject->unregister<span class="ot">(</span><span class="kw">$observers</span><span class="ot">[</span><span class="dv">0</span><span class="ot">]);</span>
<span class="kw">$this</span>->assertEquals<span class="ot">(</span><span class="dv">4</span><span class="ot">,</span> <span class="kw">$this</span>->subject->getNumberOfObservers<span class="ot">(),</span>
<span class="st">"Should be 4 observers when 1 when one removed."</span><span class="ot">);</span>
}
<span class="kw">public</span> <span class="kw">function</span> testUnsubscribingWhenNone<span class="ot">()</span>
{
<span class="kw">$actual</span> = <span class="kw">$this</span>->subject->unregister<span class="ot">(</span><span class="kw">new</span> ConcreteObserver<span class="ot">());</span>
<span class="kw">$this</span>->assertEquals<span class="ot">(</span><span class="kw">false</span><span class="ot">,</span> <span class="kw">$actual</span><span class="ot">,</span>
<span class="st">"Unregister returned status should be false if no observers"</span><span class="ot">);</span>
}
<span class="kw">public</span> <span class="kw">function</span> testSubjectShouldHoldState<span class="ot">()</span>
{
<span class="kw">$stateAsArray</span> = <span class="fu">array</span><span class="ot">(</span><span class="st">'foo'</span> => <span class="st">'foo val'</span><span class="ot">);</span>
<span class="kw">$this</span>->subject->setState<span class="ot">(</span><span class="kw">$stateAsArray</span><span class="ot">);</span>
<span class="kw">$actual</span> = <span class="kw">$this</span>->subject->getState<span class="ot">();</span>
<span class="kw">$this</span>->assertSame<span class="ot">(</span><span class="kw">$stateAsArray</span><span class="ot">,</span> <span class="kw">$actual</span><span class="ot">,</span>
<span class="st">"Should get/set state as array"</span><span class="ot">);</span>
}
<span class="kw">public</span> <span class="kw">function</span> testCreateObserver<span class="ot">()</span>
{
<span class="kw">$actual</span> = <span class="kw">new</span> ConcreteObserver<span class="ot">(</span><span class="kw">new</span> ConcreteSubject<span class="ot">());</span>
<span class="kw">$this</span>->assertNotNull<span class="ot">(</span><span class="kw">$actual</span><span class="ot">,</span> <span class="st">"Should create observer"</span><span class="ot">);</span>
}
<span class="kw">public</span> <span class="kw">function</span> testObserverGetsNotified<span class="ot">()</span>
{
<span class="kw">$this</span>->subject->register<span class="ot">(</span><span class="kw">$this</span>->observer<span class="ot">);</span>
<span class="kw">$state</span> = <span class="st">'yogabbagabba'</span><span class="ot">;</span>
<span class="kw">$this</span>->subject->setState<span class="ot">(</span><span class="kw">$state</span><span class="ot">);</span>
<span class="kw">$this</span>->subject->notify<span class="ot">();</span>
<span class="kw">$this</span>->assertEquals<span class="ot">(</span><span class="kw">$state</span><span class="ot">,</span> <span class="kw">$this</span>->observer->getState<span class="ot">(),</span>
<span class="st">"Setting state in subject notifies observer"</span><span class="ot">);</span>
}
<span class="kw">public</span> <span class="kw">function</span> testObserversHaveIds<span class="ot">()</span>
{
<span class="kw">$this</span>->assertNotNull<span class="ot">(</span><span class="kw">$this</span>->observer->getID<span class="ot">());</span>
}
<span class="kw">public</span> <span class="kw">function</span> testAddingDuplicates<span class="ot">()</span>
{
<span class="kw">$this</span>->subject->register<span class="ot">(</span><span class="kw">$this</span>->observer<span class="ot">);</span>
<span class="kw">$this</span>->subject->register<span class="ot">(</span><span class="kw">$this</span>->observer<span class="ot">);</span>
<span class="kw">$this</span>->assertEquals<span class="ot">(</span><span class="dv">1</span><span class="ot">,</span> <span class="kw">$this</span>->subject->getNumberOfObservers<span class="ot">(),</span>
<span class="st">"Should only add a particular observer instance once"</span><span class="ot">);</span>
}
<span class="kw">private</span> <span class="kw">function</span> registerMany<span class="ot">(</span><span class="kw">$n</span><span class="ot">)</span>
{
<span class="kw">$observers</span> = <span class="fu">array</span><span class="ot">();</span>
<span class="kw">foreach</span> <span class="ot">(</span><span class="fu">range</span><span class="ot">(</span><span class="dv">0</span><span class="ot">,</span> <span class="kw">$n</span><span class="dv">-1</span><span class="ot">)</span> <span class="kw">as</span> <span class="kw">$key</span><span class="ot">)</span> {
<span class="kw">$observers</span><span class="ot">[</span><span class="kw">$key</span><span class="ot">]</span> = <span class="kw">new</span> ConcreteObserver<span class="ot">();</span>
<span class="kw">$this</span>->subject->register<span class="ot">(</span><span class="kw">$observers</span><span class="ot">[</span><span class="kw">$key</span><span class="ot">]);</span>
}
<span class="kw">return</span> <span class="kw">$observers</span><span class="ot">;</span>
}
}
<span class="kw">?></span></code></pre>
<h4 id="observer.php"><a href="#TOC">Observer.php</a></h4>
<pre class="sourceCode php"><code class="sourceCode php"><span class="kw"><?php</span>
<span class="kw">abstract</span> <span class="kw">class</span> Subject
{
<span class="kw">protected</span> <span class="kw">$observers</span><span class="ot">;</span>
<span class="kw">protected</span> <span class="kw">$state</span><span class="ot">;</span>
<span class="kw">abstract</span> <span class="kw">public</span> <span class="kw">function</span> register<span class="ot">(</span>iObserver <span class="kw">$observer</span><span class="ot">);</span>
<span class="kw">abstract</span> <span class="kw">public</span> <span class="kw">function</span> unregister<span class="ot">(</span>iObserver <span class="kw">$observer</span><span class="ot">);</span>
<span class="kw">abstract</span> <span class="kw">public</span> <span class="kw">function</span> notify<span class="ot">();</span>
<span class="kw">public</span> <span class="kw">function</span> getNumberOfObservers<span class="ot">()</span>
{
<span class="kw">return</span> <span class="fu">count</span><span class="ot">(</span><span class="kw">$this</span>->observers<span class="ot">);</span>
}
}
<span class="kw">class</span> ConcreteSubject <span class="kw">extends</span> Subject
{
<span class="kw">public</span> <span class="kw">function</span> <span class="fu">__construct</span><span class="ot">()</span>
{
<span class="kw">$this</span>->observers = <span class="fu">array</span><span class="ot">();</span>
}
<span class="kw">public</span> <span class="kw">function</span> register<span class="ot">(</span>iObserver <span class="kw">$observer</span><span class="ot">)</span>
{
<span class="kw">$this</span>->observers<span class="ot">[]</span> = <span class="kw">$observer</span><span class="ot">;</span>
<span class="kw">$this</span>->observers = <span class="fu">array_unique</span><span class="ot">(</span><span class="kw">$this</span>->observers<span class="ot">);</span>
}
<span class="kw">public</span> <span class="kw">function</span> unregister<span class="ot">(</span>iObserver <span class="kw">$observer</span><span class="ot">)</span>
{
<span class="kw">foreach</span> <span class="ot">(</span><span class="kw">$this</span>->observers <span class="kw">as</span> <span class="kw">$k</span> => <span class="kw">$v</span><span class="ot">)</span>
{
<span class="kw">if</span> <span class="ot">(</span><span class="kw">$observer</span> == <span class="kw">$v</span><span class="ot">)</span>
{
<span class="fu">unset</span> <span class="ot">(</span><span class="kw">$this</span>->observers<span class="ot">[</span><span class="kw">$k</span><span class="ot">]);</span>
<span class="kw">return</span> <span class="kw">true</span><span class="ot">;</span>
}
}
<span class="kw">return</span> <span class="kw">false</span><span class="ot">;</span>
}
<span class="kw">public</span> <span class="kw">function</span> notify<span class="ot">()</span>
{
<span class="kw">foreach</span> <span class="ot">(</span><span class="kw">$this</span>->observers <span class="kw">as</span> <span class="kw">$observer</span><span class="ot">)</span> {
<span class="kw">$observer</span>->update<span class="ot">(</span><span class="kw">$this</span><span class="ot">);</span>
}
}
<span class="kw">public</span> <span class="kw">function</span> setState<span class="ot">(</span><span class="kw">$state</span><span class="ot">)</span>