中介模式

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
"""http://dpip.testingperspective.com/?p=28"""

import time 


class TC:
    def __init__(self):                         
        self._tm = tm                         
        self._bProblem = 0             

    def setup(self):                         
        print("Setting up the Test")                         
        time.sleep(1)                         
        self._tm.prepareReporting()   

    def execute(self):                         
        if not self._bProblem:                                      
            print("Executing the test")                                      
            time.sleep(1)                         
        else:                                      
            print("Problem in setup. Test not executed.")             

    def tearDown(self):                         
        if not self._bProblem:                                      
            print("Tearing down")                                      
            time.sleep(1)                                      
            self._tm.publishReport()                         
        else:                                      
            print("Test not executed. No tear down required.")             

    def setTM(self, TM):
        self._tm = tm             

    def setProblem(self, value):                         
        self._bProblem = value 


class Reporter:
    def __init__(self):                         
        self._tm = None             

    def prepare(self):                         
        print("Reporter Class is preparing to report the results")                         
        time.sleep(1)             

    def report(self):                         
        print("Reporting the results of Test")                         
        time.sleep(1)             

    def setTM(self, TM):
        self._tm = tm 


class DB:
    def __init__(self):                         
        self._tm = None             

    def insert(self):                         
        print("Inserting the execution begin status in the Database")                         
        time.sleep(1)                         
        #Following code is to simulate a communication from DB to TC                         
        import random                         
        if random.randrange(1, 4) == 3:
            return -1             

    def update(self):                         
        print("Updating the test results in Database")                         
        time.sleep(1)             

    def setTM(self, TM):
        self._tm = tm 


class TestManager:
    def __init__(self):                         
        self._reporter = None                         
        self._db = None                         
        self._tc = None             

    def prepareReporting(self):                         
        rvalue = self._db.insert()                         
        if rvalue == -1:                                      
            self._tc.setProblem(1)                                      
            self._reporter.prepare()             

    def setReporter(self, reporter):                         
        self._reporter = reporter             

    def setDB(self, db):                         
        self._db = db             

    def publishReport(self):                         
        self._db.update()                         
        rvalue = self._reporter.report()             

    def setTC(self, tc):
        self._tc = tc 


if __name__ == '__main__':             
    reporter = Reporter()             
    db = DB()             
    tm = TestManager()             
    tm.setReporter(reporter)             
    tm.setDB(db)             
    reporter.setTM(tm)             
    db.setTM(tm)             
    # For simplification we are looping on the same test.             
    # Practically, it could be about various unique test classes and their
    # objects
    while (True):                         
        tc = TC()                         
        tc.setTM(tm)                         
        tm.setTC(tc)                         
        tc.setup()                         
        tc.execute()                         
        tc.tearDown()