← Back to branch summary

~launchpad-results/launchpad-results/trunk

« back to all changes in this revision

Viewing changes to lib/lpresults/tracker/schema/test/patch_1.py

  • Committer: Marc Tardif
  • Date: 2012-03-21 22:32:04 UTC
  • Revision ID: marc.tardif@canonical.com-20120321223204-8g7mvzzwmh8ifbrt
Added support for getting systems from a person (LP #899361)

Show diffs side-by-side

added added

removed removed

Lines of Context:
lib/lpresults/tracker/schema/test/patch_1.py
 
1
# Copyright 2010-2011 Canonical Ltd.  This software is licensed under the
 
2
# GNU Affero General Public License version 3 (see the file LICENSE).
 
3
 
 
4
"""
 
5
Added support for inserting test runs backwards in time.
 
6
"""
 
7
 
 
8
statements = [
 
9
"""DROP FUNCTION next_distroseries_sequence(INTEGER)""",
 
10
"""DROP FUNCTION next_projectseries_sequence(INTEGER)""",
 
11
"""DROP TRIGGER testresult_delete_after_trigger ON testresult""",
 
12
"""DROP FUNCTION testresult_delete_after()""",
 
13
"""
 
14
CREATE OR REPLACE FUNCTION testrun_insert_before() RETURNS TRIGGER
 
15
LANGUAGE plpgsql AS
 
16
$$
 
17
BEGIN
 
18
    IF NEW.distro_series IS NOT NULL THEN
 
19
        UPDATE distroseriestwin SET counter = counter + 1
 
20
            WHERE id = NEW.distro_series RETURNING counter INTO NEW.sequence;
 
21
    ELSIF NEW.project_series IS NOT NULL THEN
 
22
        UPDATE projectseriestwin SET counter = counter + 1
 
23
            WHERE id = NEW.project_series RETURNING counter INTO NEW.sequence;
 
24
    END IF;
 
25
 
 
26
    RETURN NEW;
 
27
END
 
28
$$
 
29
""",
 
30
"""
 
31
CREATE OR REPLACE FUNCTION testrun_insert_after() RETURNS TRIGGER
 
32
LANGUAGE plpgsql AS
 
33
$$
 
34
BEGIN
 
35
    INSERT INTO testresult (
 
36
            test_case,
 
37
            status,
 
38
            output,
 
39
            date_created,
 
40
            date_deleted)
 
41
        SELECT
 
42
                testresult.test_case,
 
43
                testresult.status,
 
44
                testresult.output,
 
45
                MIN(testrun.date_created),
 
46
                testresult.date_deleted
 
47
            FROM testresult
 
48
            JOIN testrun
 
49
                ON testrun.date_created > NEW.date_created
 
50
                AND testrun.date_created < testresult.date_deleted
 
51
            WHERE testresult.date_created < NEW.date_created
 
52
            AND CASE WHEN NEW.distro_series IS NOT NULL THEN
 
53
                    testrun.distro_series = NEW.distro_series
 
54
                ELSE
 
55
                    testrun.project_series = NEW.project_series
 
56
                END
 
57
            GROUP BY
 
58
                testresult.test_case,
 
59
                testresult.status,
 
60
                testresult.output,
 
61
                testresult.date_deleted;
 
62
 
 
63
    UPDATE testresult
 
64
        SET date_deleted = NEW.date_created
 
65
        FROM testcase
 
66
        WHERE testresult.date_created < NEW.date_created
 
67
        AND testresult.date_deleted > NEW.date_created
 
68
        AND testresult.test_case = testcase.id
 
69
        AND CASE WHEN NEW.distro_series IS NOT NULL THEN
 
70
                testcase.distro_series = NEW.distro_series
 
71
            ELSE
 
72
                testcase.project_series = NEW.project_series
 
73
            END;
 
74
 
 
75
    RETURN NEW;
 
76
END
 
77
$$
 
78
""",
 
79
"""
 
80
DROP TRIGGER testrun_insert_after_trigger
 
81
    ON testrun
 
82
""",
 
83
"""
 
84
CREATE TRIGGER testrun_insert_after_trigger
 
85
    AFTER INSERT ON testrun
 
86
    FOR EACH ROW
 
87
    EXECUTE PROCEDURE testrun_insert_after()
 
88
""",
 
89
"""
 
90
CREATE FUNCTION testrun_update_before() RETURNS TRIGGER
 
91
LANGUAGE plpgsql AS
 
92
$$
 
93
BEGIN
 
94
    IF OLD.distro_series <> NEW.distro_series THEN
 
95
        RAISE EXCEPTION 'Cannot update distro_series';
 
96
    ELSIF OLD.project_series <> NEW.project_series THEN
 
97
        RAISE EXCEPTION 'Cannot update project_series';
 
98
    ELSIF OLD.date_created <> NEW.date_created THEN
 
99
        RAISE EXCEPTION 'Cannot update project_series';
 
100
    ELSE
 
101
        RETURN NEW;
 
102
    END IF;
 
103
END;
 
104
$$
 
105
""",
 
106
"""
 
107
GRANT EXECUTE
 
108
    ON FUNCTION testrun_update_before()
 
109
    TO lpresults
 
110
""",
 
111
"""
 
112
CREATE TRIGGER testrun_update_before_trigger
 
113
    BEFORE UPDATE ON testrun
 
114
    FOR EACH ROW
 
115
    EXECUTE PROCEDURE testrun_update_before()
 
116
""",
 
117
"""
 
118
CREATE FUNCTION testrun_delete_after() RETURNS TRIGGER
 
119
LANGUAGE plpgsql AS
 
120
$$
 
121
DECLARE
 
122
    next_testrun RECORD;
 
123
BEGIN
 
124
    SELECT
 
125
        INTO next_testrun
 
126
            testrun.date_created
 
127
        FROM testrun
 
128
        WHERE testrun.date_created > OLD.date_created
 
129
        AND CASE WHEN OLD.distro_series IS NOT NULL THEN
 
130
                testrun.distro_series = OLD.distro_series
 
131
            ELSE
 
132
                testrun.project_series = OLD.project_series
 
133
            END
 
134
        ORDER BY testrun.date_created ASC LIMIT 1;
 
135
 
 
136
    -- Between
 
137
    IF next_testrun.date_created IS NOT NULL THEN
 
138
        UPDATE testresult tr1
 
139
            SET date_deleted = tr2.date_deleted
 
140
            FROM testresult tr2, testcase tc
 
141
            WHERE tr1.test_case = tr2.test_case
 
142
            AND tr1.status = tr2.status
 
143
            AND decode(md5(tr1.output), 'hex') = decode(md5(tr2.output), 'hex')
 
144
            AND tr1.date_deleted = OLD.date_created
 
145
            AND tr2.date_created = next_testrun.date_created
 
146
            AND tr1.test_case = tc.id
 
147
            AND CASE WHEN OLD.distro_series IS NOT NULL THEN
 
148
                    tc.distro_series = OLD.distro_series
 
149
                ELSE
 
150
                    tc.project_series = OLD.project_series
 
151
                END;
 
152
        IF FOUND THEN
 
153
            DELETE FROM testresult tr2
 
154
                USING testresult tr1, testcase tc
 
155
                WHERE (
 
156
                    tr1.test_case = tr2.test_case
 
157
                    AND tr1.status = tr2.status
 
158
                    AND decode(md5(tr1.output), 'hex')
 
159
                        = decode(md5(tr2.output), 'hex')
 
160
                    AND tr2.date_created = next_testrun.date_created)
 
161
                OR (
 
162
                    tr2.date_created = OLD.date_created
 
163
                    AND tr2.date_deleted = next_testrun.date_created)
 
164
                AND tr1.test_case = tc.id
 
165
                AND CASE WHEN OLD.distro_series IS NOT NULL THEN
 
166
                        tc.distro_series = OLD.distro_series
 
167
                    ELSE
 
168
                        tc.project_series = OLD.project_series
 
169
                    END;
 
170
        ELSE
 
171
            DELETE FROM testresult tr
 
172
                USING testcase tc
 
173
                WHERE tr.date_created = OLD.date_created
 
174
                AND tr.date_deleted = next_testrun.date_created
 
175
                AND tr.test_case = tc.id
 
176
                AND CASE WHEN OLD.distro_series IS NOT NULL THEN
 
177
                        tc.distro_series = OLD.distro_series
 
178
                    ELSE
 
179
                        tc.project_series = OLD.project_series
 
180
                    END;
 
181
        END IF;
 
182
 
 
183
        -- After
 
184
        UPDATE testresult tr
 
185
            SET date_created = next_testrun.date_created
 
186
            FROM testcase
 
187
            WHERE tr.date_created = OLD.date_created
 
188
            AND tr.test_case = testcase.id
 
189
            AND CASE WHEN OLD.distro_series IS NOT NULL THEN
 
190
                    testcase.distro_series = OLD.distro_series
 
191
                ELSE
 
192
                    testcase.project_series = OLD.project_series
 
193
                END;
 
194
    ELSE
 
195
        next_testrun.date_created = '3000-01-01';
 
196
        DELETE FROM testresult tr
 
197
            USING testcase tc
 
198
            WHERE tr.date_created = OLD.date_created
 
199
            AND tr.test_case = tc.id
 
200
            AND CASE WHEN OLD.distro_series IS NOT NULL THEN
 
201
                    tc.distro_series = OLD.distro_series
 
202
                ELSE
 
203
                    tc.project_series = OLD.project_series
 
204
                END;
 
205
    END IF;
 
206
 
 
207
    -- Before
 
208
    UPDATE testresult tr
 
209
        SET date_deleted = next_testrun.date_created
 
210
        FROM testcase tc
 
211
        WHERE tr.date_deleted = OLD.date_created
 
212
        AND tr.test_case = tc.id
 
213
        AND CASE WHEN OLD.distro_series IS NOT NULL THEN
 
214
                tc.distro_series = OLD.distro_series
 
215
            ELSE
 
216
                tc.project_series = OLD.project_series
 
217
            END;
 
218
 
 
219
    RETURN OLD;
 
220
END;
 
221
$$
 
222
""",
 
223
"""
 
224
GRANT EXECUTE
 
225
    ON FUNCTION testrun_delete_after()
 
226
    TO lpresults
 
227
""",
 
228
"""
 
229
CREATE TRIGGER testrun_delete_after_trigger
 
230
    AFTER DELETE ON testrun
 
231
    FOR EACH ROW
 
232
    EXECUTE PROCEDURE testrun_delete_after()
 
233
""",
 
234
"""
 
235
CREATE OR REPLACE FUNCTION testresult_insert_before() RETURNS TRIGGER
 
236
LANGUAGE plpgsql AS
 
237
$$
 
238
DECLARE
 
239
    next_date_created DATE;
 
240
    next_testrun DATE;
 
241
    previous_date_deleted DATE;
 
242
BEGIN
 
243
    IF NEW.date_deleted < '3000-01-01' THEN
 
244
        RETURN NEW;
 
245
    END IF;
 
246
 
 
247
    SELECT INTO next_testrun
 
248
            CASE WHEN MIN(date_created) > NEW.date_created
 
249
            THEN MIN(date_created)
 
250
            ELSE MIN(date_deleted)
 
251
            END
 
252
        FROM testresult tr
 
253
        JOIN testcase tc1
 
254
            ON tr.test_case = tc1.id
 
255
        JOIN testcase tc2
 
256
            ON tc1.distro_series IS NOT DISTINCT FROM tc2.distro_series
 
257
            AND tc1.project_series IS NOT DISTINCT FROM tc2.project_series
 
258
        WHERE date_deleted > NEW.date_created
 
259
        AND tc2.id = NEW.test_case;
 
260
    IF next_testrun < '3000-01-01' THEN
 
261
        -- Set date created of next test result.
 
262
        UPDATE testresult
 
263
            SET date_created = CASE
 
264
                WHEN testresult.status = NEW.status
 
265
                    AND testresult.output = NEW.output
 
266
                    AND testresult.date_created <> NEW.date_created
 
267
                THEN NEW.date_created
 
268
                ELSE next_testrun
 
269
                END
 
270
            WHERE testresult.test_case = NEW.test_case
 
271
            AND testresult.date_created <= next_testrun
 
272
            AND testresult.date_created >= NEW.date_created
 
273
            RETURNING date_created INTO next_date_created;
 
274
        IF next_date_created != NEW.date_created THEN
 
275
            next_date_created := next_testrun;
 
276
            NEW.date_deleted := next_testrun;
 
277
        END IF;
 
278
    ELSE
 
279
        next_date_created := '3000-01-01';
 
280
    END IF;
 
281
 
 
282
    -- Set date deleted of previous test result.
 
283
    UPDATE testresult
 
284
        SET date_deleted = CASE
 
285
            WHEN testresult.status = NEW.status
 
286
                AND testresult.output = NEW.output
 
287
            THEN next_date_created
 
288
            ELSE NEW.date_created
 
289
            END
 
290
        WHERE testresult.test_case = NEW.test_case
 
291
        AND testresult.date_created <= NEW.date_created
 
292
        AND testresult.date_deleted >= NEW.date_created
 
293
        RETURNING date_deleted INTO previous_date_deleted;
 
294
    IF previous_date_deleted = next_date_created THEN
 
295
        IF next_date_created = NEW.date_created THEN
 
296
            DELETE FROM testresult
 
297
                WHERE test_case = NEW.test_case
 
298
                AND testresult.date_created = next_testrun;
 
299
        END IF;
 
300
        RETURN NULL;
 
301
    ELSIF next_date_created = NEW.date_created
 
302
          AND previous_date_deleted IS NOT NULL THEN
 
303
        RETURN NULL;
 
304
    END IF;
 
305
 
 
306
    RETURN NEW;
 
307
END;
 
308
$$
 
309
""",
 
310
"""
 
311
CREATE OR REPLACE FUNCTION testresult_update_before() RETURNS TRIGGER
 
312
LANGUAGE plpgsql AS
 
313
$$
 
314
BEGIN
 
315
    IF OLD.test_case <> NEW.test_case THEN
 
316
        RAISE EXCEPTION 'Cannot update test_case';
 
317
    ELSIF OLD.status <> NEW.status THEN
 
318
        RAISE EXCEPTION 'Cannot update status';
 
319
    ELSIF OLD.output <> NEW.output THEN
 
320
        RAISE EXCEPTION 'Cannot update output';
 
321
    ELSIF NEW.date_deleted = NEW.date_created THEN
 
322
        DELETE FROM testresult
 
323
            WHERE test_case = OLD.test_case
 
324
            AND date_created = OLD.date_created;
 
325
        RETURN NULL;
 
326
    ELSE
 
327
        RETURN NEW;
 
328
    END IF;
 
329
END;
 
330
$$
 
331
""",
 
332
]
 
333
 
 
334
 
 
335
def apply(store):
 
336
    print __doc__
 
337
    for statement in statements:
 
338
        store.execute(statement)