1
=== modified file 'HACKING'
2
--- HACKING	2012-09-05 16:50:12 +0000
3
+++ HACKING	2012-09-07 12:52:19 +0000
4
@@ -67,7 +67,7 @@
5
67
    <!ELEMENT fields (field+)>
67
    <!ELEMENT fields (field+)>
6
68
    <!ELEMENT field (#PCDATA)>
68
    <!ELEMENT field (#PCDATA)>
7
69
    <!ATTLIST field name CDATA #REQUIRED>
69
    <!ATTLIST field name CDATA #REQUIRED>
9
70
    <!ATTLIST field type (text|int|bool) "text">
70
    <!ATTLIST field type (str|int|bool) "str">
10
71
]>
71
]>
11
72
<loop>
72
<loop>
12
73
    <fields>
73
    <fields>
13
74
74
14
=== modified file 'dashboard/frontend/android_textfield_loop/models/android_textfield_loop.py'
15
--- dashboard/frontend/android_textfield_loop/models/android_textfield_loop.py	2012-09-05 13:07:59 +0000
16
+++ dashboard/frontend/android_textfield_loop/models/android_textfield_loop.py	2012-09-07 12:52:19 +0000
17
@@ -23,6 +23,9 @@
18
23
    class Meta:
23
    class Meta:
19
24
        app_label = 'android_textfield_loop'
24
        app_label = 'android_textfield_loop'
20
25
25
21
26
    # Fields we want in the XML for chaining.
22
27
    XML_INCLUDE_LIST = ['name', 'is_official', 'is_restricted']
23
28
24
26
    def save(self, *args, **kwargs):
29
    def save(self, *args, **kwargs):
25
27
        self.type = self.__class__.__name__
30
        self.type = self.__class__.__name__
26
28
        super(self.__class__, self).save(*args, **kwargs)
31
        super(self.__class__, self).save(*args, **kwargs)
27
29
32
28
=== modified file 'dashboard/frontend/android_textfield_loop/templates/android_textfield_loop_create.html'
29
--- dashboard/frontend/android_textfield_loop/templates/android_textfield_loop_create.html	2012-08-31 15:21:11 +0000
30
+++ dashboard/frontend/android_textfield_loop/templates/android_textfield_loop_create.html	2012-09-07 12:52:19 +0000
31
@@ -6,14 +6,6 @@
32
6
    <form name="{{ form_name }}" action="{% url AndroidTextFieldLoopCreate %}" method="post">
6
    <form name="{{ form_name }}" action="{% url AndroidTextFieldLoopCreate %}" method="post">
33
7
    {% csrf_token %}
7
    {% csrf_token %}
34
8
{% endblock create_form %}
8
{% endblock create_form %}
35
9
36
10
{% if form.non_field_errors %}
37
11
    <div class="form_error">
38
12
        {% for err in form.non_field_errors %}
39
13
            <div class="error_message">{{ err }}</div>
40
14
        {% endfor %}
41
15
    </div>
42
16
{% endif %}
43
17
{{ form.as_p }}
9
{{ form.as_p }}
44
18
        <div><input type="submit" value="Submit" /></div>
10
        <div><input type="submit" value="Submit" /></div>
45
19
    </form>
11
    </form>
46
20
12
47
=== modified file 'dashboard/frontend/android_textfield_loop/tests/test_android_textfield_loop_model.py'
48
--- dashboard/frontend/android_textfield_loop/tests/test_android_textfield_loop_model.py	2012-09-05 13:59:57 +0000
49
+++ dashboard/frontend/android_textfield_loop/tests/test_android_textfield_loop_model.py	2012-09-07 12:52:19 +0000
50
@@ -18,15 +18,16 @@
51
18
from django.test import TestCase
18
from django.test import TestCase
52
19
from frontend.android_textfield_loop.models.android_textfield_loop \
19
from frontend.android_textfield_loop.models.android_textfield_loop \
53
20
    import AndroidTextFieldLoop
20
    import AndroidTextFieldLoop
54
21
from dashboard.lib.xml_fields import XML_START
55
21
22
56
22
23
57
23
class AndroidTextFieldLoopModelTest(TestCase):
24
class AndroidTextFieldLoopModelTest(TestCase):
58
24
25
59
25
    A_NAME = 'a-build'
26
    A_NAME = 'a-build'
60
26
    B_NAME = 'b-build'
27
    B_NAME = 'b-build'
62
27
    VALID_VALUES = 'a=2\nb=3'
28
    VALID_VALUES = u'a=2\nb=3'
63
28
    VALID_LINES = ['a=2', 'b=3']
29
    VALID_LINES = ['a=2', 'b=3']
65
29
    NON_VALID_VALUES = 'a:2\nb=3'
30
    NON_VALID_VALUES = u'a:2\nb=3'
66
30
    NON_VALID_LINES = ['a:2', 'b=3']
31
    NON_VALID_LINES = ['a:2', 'b=3']
67
31
    VALID_DICT = {'a': '2', 'b': '3'}
32
    VALID_DICT = {'a': '2', 'b': '3'}
68
32
33
69
@@ -56,9 +57,17 @@
70
56
57
71
57
    def test_schedule_build(self):
58
    def test_schedule_build(self):
72
58
        build = self.android_loop.schedule_build()
59
        build = self.android_loop.schedule_build()
74
59
        self.assertEqual(build.result_xml, self.VALID_DICT)
60
        expected_out = (XML_START +
75
61
                        '<loop><fields>'
76
62
                        '<field name="a" type="str">2</field>'
77
63
                        '<field name="is_restricted" type="bool">False</field>'
78
64
                        '<field name="b" type="str">3</field>'
79
65
                        '<field name="is_official" type="bool">False</field>'
80
66
                        '<field name="name" type="str">a-build</field>'
81
67
                        '</fields></loop>')
82
68
        self.assertEqual(expected_out, build.result_xml)
83
60
        self.assertEqual(build.status, "success")
69
        self.assertEqual(build.status, "success")
84
61
70
85
62
    def test_schedule_build_invalid(self):
71
    def test_schedule_build_invalid(self):
86
63
        build = self.non_valid_android_loop.schedule_build()
72
        build = self.non_valid_android_loop.schedule_build()
88
64
        self.assertEqual(build.result_xml, {})
73
        self.assertEqual("", build.result_xml)
89
65
74
90
=== modified file 'dashboard/frontend/models/loop.py'
91
--- dashboard/frontend/models/loop.py	2012-09-04 14:51:52 +0000
92
+++ dashboard/frontend/models/loop.py	2012-09-07 12:52:19 +0000
93
@@ -44,7 +44,7 @@
94
44
    # List of fields to be excluded by default from the base64 encoded config.
44
    # List of fields to be excluded by default from the base64 encoded config.
95
45
    # If a subclass needs different fields, it is necessary to override this
45
    # If a subclass needs different fields, it is necessary to override this
96
46
    # variable.
46
    # variable.
98
47
    EXCLUDE_LIST = ['id', 'name', 'server', 'loop_ptr']
47
    EXCLUDE_LIST = ['id', 'server', 'loop_ptr', 'next_loop', 'name', 'type']
99
48
48
100
49
    def __init__(self, *args, **kwargs):
49
    def __init__(self, *args, **kwargs):
101
50
        self.log = Logger.getClassLogger(self)
50
        self.log = Logger.getClassLogger(self)
102
@@ -79,13 +79,37 @@
103
79
            pass
79
            pass
104
80
        return build
80
        return build
105
81
81
107
82
    def json(self):
82
    def json(self, include=None, exclude=None):
108
83
        """Return Loop in a format suitable for serialization as JSON. The
83
        """Return Loop in a format suitable for serialization as JSON. The
110
84
        method is called without underscores to be callabel from Django
84
        method is called without underscores to be callable from Django
111
85
        templates.
85
        templates.
112
86
113
87
        :param include: the list of fields to be included
114
88
        :type include list
115
89
        :param exclude: the list of fields to be excluded
116
90
        :return A dictionary of the model fields
117
86
        """
91
        """
118
87
        from django.forms.models import model_to_dict
92
        from django.forms.models import model_to_dict
120
88
        return model_to_dict(self)
93
        # XXX
121
94
        # This method will not return all the fields, even if they are in the
122
95
        # include list. This is true for fields like 'type', that are set as
123
96
        # 'editable=False'. Since that is a parameter for the form, and we are
124
97
        # using a function from there, it applies here too.
125
98
        return model_to_dict(self, include, exclude)
126
99
127
100
    def dict_for_xml(self, include=None, exclude=None):
128
101
        """
129
102
        Get a dictionary representation of this loop to be serialized into an
130
103
        XML form for chaining loop.
131
104
132
105
        :param include: the list of fields to be included
133
106
        :type include list
134
107
        :param exclude: the list of fields to be excluded
135
108
        :return A dictionary with the fields to be serialized.
136
109
        """
137
110
        # Done in this way, calling self.json, since we have it, but if we
138
111
        # change the json representation, this needs to be changed as well.
139
112
        return self.json(include, exclude)
140
89
113
141
90
    @staticmethod
114
    @staticmethod
142
91
    def can_chain_into():
115
    def can_chain_into():
143
92
116
144
=== modified file 'dashboard/frontend/models/loop_build.py'
145
--- dashboard/frontend/models/loop_build.py	2012-09-05 13:23:05 +0000
146
+++ dashboard/frontend/models/loop_build.py	2012-09-07 12:52:19 +0000
147
@@ -18,6 +18,7 @@
148
18
18
149
19
from django.db import models
19
from django.db import models
150
20
from frontend.models.loop import Loop
20
from frontend.models.loop import Loop
151
21
from dashboard.lib.xml_to_dict import XmlToDict
152
21
22
153
22
23
154
23
class LoopBuild(models.Model):
24
class LoopBuild(models.Model):
155
@@ -47,3 +48,15 @@
156
47
            else:
48
            else:
157
48
                self.build_number = 1
49
                self.build_number = 1
158
49
        super(LoopBuild, self).save(*args, **kwargs)
50
        super(LoopBuild, self).save(*args, **kwargs)
159
51
160
52
    def get_build_result(self):
161
53
        """
162
54
        Returns a Python dictionary representation of the build XML stored.
163
55
164
56
        :return A dictionary of the XML result.
165
57
        """
166
58
        dict_result = {}
167
59
        if self.result_xml:
168
60
            xml_to_dict = XmlToDict(self.result_xml)
169
61
            dict_result = xml_to_dict.tree_to_dict()
170
62
        return dict_result
171
50
63
172
=== modified file 'dashboard/frontend/models/textfield_loop.py'
173
--- dashboard/frontend/models/textfield_loop.py	2012-09-05 13:59:57 +0000
174
+++ dashboard/frontend/models/textfield_loop.py	2012-09-07 12:52:19 +0000
175
@@ -17,6 +17,7 @@
176
17
17
177
18
from django.db import models
18
from django.db import models
178
19
from frontend.models.loop import Loop
19
from frontend.models.loop import Loop
179
20
from dashboard.lib.xml_to_dict import DictToXml
180
20
21
181
21
22
182
22
# Default delimiter to separate values from keys in the text field.
23
# Default delimiter to separate values from keys in the text field.
183
@@ -39,6 +40,11 @@
184
39
40
185
40
    values = models.TextField()
41
    values = models.TextField()
186
41
42
187
43
    # List of fields to be included and excluded from serialization.
188
44
    # Each subclass should override these two variables.
189
45
    XML_INCLUDE_LIST = None
190
46
    XML_EXCLUDE_LIST = None
191
47
192
42
    def schedule_build(self, parameters=None):
48
    def schedule_build(self, parameters=None):
193
43
        from frontend.models.loop_build import LoopBuild
49
        from frontend.models.loop_build import LoopBuild
194
44
        build = LoopBuild()
50
        build = LoopBuild()
195
@@ -46,7 +52,7 @@
196
46
        build.duration = 0.00
52
        build.duration = 0.00
197
47
53
198
48
        try:
54
        try:
200
49
            build.result_xml = self.values_to_dict()
55
            build.result_xml = self.values_to_xml()
201
50
            build.status = 'success'
56
            build.status = 'success'
202
51
        except:
57
        except:
203
52
            build.status = 'failure'
58
            build.status = 'failure'
204
@@ -54,15 +60,24 @@
205
54
        build.save()
60
        build.save()
206
55
        return build
61
        return build
207
56
62
209
57
    def values_to_dict(self):
63
    def values_to_dict(self, valid=None, lines=None):
210
58
        """
64
        """
211
59
        Returns a dictionary representation of the values inserted. The
65
        Returns a dictionary representation of the values inserted. The
212
60
        key<>value pairs are split on DEFAULT_DELIMITER.
66
        key<>value pairs are split on DEFAULT_DELIMITER.
213
61
67
215
62
        :return A dictionary of the values inserted.
68
        The default parameters are used for a second iteration of this function
216
69
        if we do not want to parse again the lines, but we only want to get the
217
70
        dictionary.
218
71
219
72
        :param valid: If the lines are valid or not.
220
73
        :type valid bool
221
74
        :param lines: The list of lines in the text field.
222
75
        :type lines list
223
76
        :return A dictionary of the values inserted in the text field.
224
63
        """
77
        """
225
64
        text_to_dict = {}
78
        text_to_dict = {}
227
65
        valid, lines = self.valid_values(self.values)
79
        if valid is None and lines is None:
228
80
            valid, lines = self.valid_values(self.values)
229
66
81
230
67
        if valid:
82
        if valid:
231
68
            for line in lines:
83
            for line in lines:
232
@@ -79,7 +94,7 @@
233
79
94
234
80
        :param values: the string with all the key<>value pairs, separated with
95
        :param values: the string with all the key<>value pairs, separated with
235
81
        a newline character.
96
        a newline character.
237
82
        :type str
97
        :type values unicode
238
83
        :return a boolean for the validity, and the list of lines.
98
        :return a boolean for the validity, and the list of lines.
239
84
        """
99
        """
240
85
        valid = True
100
        valid = True
241
@@ -91,3 +106,21 @@
242
91
                valid = False
106
                valid = False
243
92
                break
107
                break
244
93
        return valid, lines
108
        return valid, lines
245
109
246
110
    def values_to_xml(self):
247
111
        """
248
112
        Converts the necessary values into an XML tree.
249
113
250
114
        :return The XML tree as a string, or an empty string if the inserted
251
115
        values are not valid.
252
116
        """
253
117
        xml_string = ""
254
118
        valid, lines = self.valid_values(self.values)
255
119
        if valid:
256
120
            values = self.values_to_dict(valid, lines)
257
121
            other_values = self.dict_for_xml(include=self.XML_INCLUDE_LIST,
258
122
                                             exclude=self.XML_EXCLUDE_LIST)
259
123
            if other_values:
260
124
                values.update(other_values)
261
125
            xml_string = DictToXml(values).dict_to_tree()
262
126
        return xml_string
263
94
127
264
=== modified file 'dashboard/frontend/tests/__init__.py'
265
--- dashboard/frontend/tests/__init__.py	2012-09-03 08:18:10 +0000
266
+++ dashboard/frontend/tests/__init__.py	2012-09-07 12:52:19 +0000
267
@@ -2,6 +2,7 @@
268
2
from dashboard.frontend.tests.test_models import *
2
from dashboard.frontend.tests.test_models import *
269
3
from dashboard.frontend.tests.test_clientresponse import *
3
from dashboard.frontend.tests.test_clientresponse import *
270
4
from dashboard.frontend.tests.test_custom_commands import *
4
from dashboard.frontend.tests.test_custom_commands import *
271
5
from dashboard.frontend.tests.test_xml_to_dict import *
272
5
6
273
6
7
274
7
#starts the test suite
8
#starts the test suite
275
@@ -14,4 +15,6 @@
276
14
           'LoopTests': LoopTest,
15
           'LoopTests': LoopTest,
277
15
           'ClientResponseTests': ClientResponseTests,
16
           'ClientResponseTests': ClientResponseTests,
278
16
           'JenkinsCommandTest': JenkinsCommandTest,
17
           'JenkinsCommandTest': JenkinsCommandTest,
279
18
           'XmlToDictTest': XmlToDictTest,
280
19
           'DictToXmlTest': DictToXmlTest,
281
17
           }
20
           }
282
18
21
283
=== modified file 'dashboard/frontend/tests/test_models.py'
284
--- dashboard/frontend/tests/test_models.py	2012-09-04 11:56:22 +0000
285
+++ dashboard/frontend/tests/test_models.py	2012-09-07 12:52:19 +0000
286
@@ -26,6 +26,7 @@
287
26
  import AndroidTextFieldLoop
26
  import AndroidTextFieldLoop
288
27
from lib.model_getter import ModelGetter
27
from lib.model_getter import ModelGetter
289
28
28
290
29
291
29
class LoopTest(TestCase):
30
class LoopTest(TestCase):
292
30
31
293
31
    def setUp(self):
32
    def setUp(self):
294
@@ -42,6 +43,11 @@
295
42
        self.android_loop.build_type = "build-android"
43
        self.android_loop.build_type = "build-android"
296
43
        self.android_loop.save()
44
        self.android_loop.save()
297
44
45
298
46
        self.loop = Loop()
299
47
        self.loop.name = 'a-loop'
300
48
        self.loop.type = Loop.__class__.__name__
301
49
        self.loop.save()
302
50
303
45
    def test_get_child_object(self):
51
    def test_get_child_object(self):
304
46
        loop = Loop.objects.get(id=1)
52
        loop = Loop.objects.get(id=1)
305
47
        self.assertEqual("testjob_integration", loop.get_child_object().name)
53
        self.assertEqual("testjob_integration", loop.get_child_object().name)
306
@@ -49,7 +55,6 @@
307
49
        self.assertEqual("IntegrationLoop",
55
        self.assertEqual("IntegrationLoop",
308
50
                         loop.get_child_object().__class__.__name__)
56
                         loop.get_child_object().__class__.__name__)
309
51
57
310
52
311
53
    def test_get_all_chainable_integration_empty(self):
58
    def test_get_all_chainable_integration_empty(self):
312
54
        chainable_loops = IntegrationLoop.get_all_chainable()
59
        chainable_loops = IntegrationLoop.get_all_chainable()
313
55
        # Integration loop does not have any chainable loops
60
        # Integration loop does not have any chainable loops
314
@@ -64,3 +69,26 @@
315
64
    def test_model_getter_unique_model(self):
69
    def test_model_getter_unique_model(self):
316
65
        all_models = [model.__name__ for model in get_models()]
70
        all_models = [model.__name__ for model in get_models()]
317
66
        self.assertTrue(len(all_models) == len(set(all_models)))
71
        self.assertTrue(len(all_models) == len(set(all_models)))
318
72
319
73
    def test_model_json(self):
320
74
        expected_out = {'next_loop': None, 'name': 'a-loop', 'server': None,
321
75
                        'is_restricted': False, 'is_official': False, 'id': 3}
322
76
        self.assertEqual(expected_out, self.loop.json())
323
77
324
78
    def test_model_dict_for_xml(self):
325
79
        expected_out = {'next_loop': None, 'name': 'a-loop', 'server': None,
326
80
                        'is_restricted': False, 'is_official': False, 'id': 3}
327
81
        self.assertEqual(expected_out, self.loop.dict_for_xml())
328
82
329
83
    def test_model_dict_for_xml_with_include(self):
330
84
        include_list = ['name', 'is_restricted']
331
85
        expected_out = {'name': 'a-loop', 'is_restricted': False}
332
86
        self.assertEqual(expected_out,
333
87
                         self.loop.dict_for_xml(include=include_list))
334
88
335
89
    def test_model_dict_for_xml_with_exclude(self):
336
90
        exclude_list = ['is_restricted', 'name']
337
91
        expected_out = {'next_loop': None, 'server': None,
338
92
                        'is_official': False, 'id': 3}
339
93
        self.assertEqual(expected_out,
340
94
                         self.loop.dict_for_xml(exclude=exclude_list))
341
67
95
342
=== added file 'dashboard/frontend/tests/test_xml_to_dict.py'
343
--- dashboard/frontend/tests/test_xml_to_dict.py	1970-01-01 00:00:00 +0000
344
+++ dashboard/frontend/tests/test_xml_to_dict.py	2012-09-07 12:52:19 +0000
345
@@ -0,0 +1,293 @@
346
1
# Copyright (C) 2012 Linaro
347
2
#
348
3
# This file is part of linaro-ci-dashboard.
349
4
#
350
5
# linaro-ci-dashboard is free software: you can redistribute it and/or modify
351
6
# it under the terms of the GNU Affero General Public License as published by
352
7
# the Free Software Foundation, either version 3 of the License, or
353
8
# (at your option) any later version.
354
9
#
355
10
# linaro-ci-dashboard is distributed in the hope that it will be useful,
356
11
# but WITHOUT ANY WARRANTY; without even the implied warranty of
357
12
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
358
13
# GNU Affero General Public License for more details.
359
14
#
360
15
# You should have received a copy of the GNU Affero General Public License
361
16
# along with linaro-ci-dashboard.  If not, see <http://www.gnu.org/licenses/>.
362
17
363
18
from django.test import TestCase
364
19
import os
365
20
from dashboard.lib.xml_to_dict import (
366
21
    XmlToDict,
367
22
    DictToXml
368
23
)
369
24
from dashboard.lib.xml_fields import (
370
25
    LOOP_ELEMENT,
371
26
    FIELDS_ELEMENT,
372
27
    TYPE_ATTR,
373
28
    NAME_ATTR,
374
29
    XML_START,
375
30
    INT_TYPE,
376
31
    BOOL_TYPE,
377
32
    STR_TYPE,
378
33
)
379
34
380
35
381
36
# XML tags
382
37
ROOT_TAG_OPEN = '<loop>'
383
38
ROOT_TAG_CLOSE = '</loop>'
384
39
FIELDS_TAG_OPEN = '<fields>'
385
40
FIELDS_TAG_CLOSE = '</fields>'
386
41
VALID_FIELD = '<field name="%(field_name)s">%(field_value)s</field>'
387
42
VALID_FIELD_WITH_TYPE = ('<field name="%(field_name)s" '
388
43
                         'type="%(field_type)s">%(field_value)s</field>')
389
44
390
45
# Field names, types and values used as defaults for the tests.
391
46
LOOP_TYPE_VAL = 'text-build'
392
47
LOOP_NAME_VAL = 'build-test'
393
48
BUILD_TYPE = 'build_type'
394
49
BUILD_TYPE_VAL = 'build-android'
395
50
REPO_QUIET = 'repo_quiet'
396
51
REPO_QUIET_VAL = True
397
52
BUILD_FS_IMAGE = 'build_fs_image'
398
53
BUILD_FS_IMAGE_VAL = False
399
54
MAKE_JOBS = 'make_jobs'
400
55
MAKE_JOBS_VAL = 2
401
56
402
57
NEWLINE = os.linesep
403
58
# Used to create the needed dictionary for fields creation.
404
59
# The dictionary has to be:
405
60
# {FIELD_NAME: value, FIELD_VALUE: value [, FIELD_TYPE: value]}
406
61
# FIELD_TYPE is optional.
407
62
FIELD_NAME = 'field_name'
408
63
FIELD_VALUE = 'field_value'
409
64
FIELD_TYPE = 'field_type'
410
65
411
66
FIELDS = [
412
67
        {FIELD_NAME: BUILD_TYPE, FIELD_VALUE: BUILD_TYPE_VAL},
413
68
        {FIELD_NAME: REPO_QUIET, FIELD_TYPE: BOOL_TYPE,
414
69
         FIELD_VALUE: REPO_QUIET_VAL},
415
70
        {FIELD_NAME: BUILD_FS_IMAGE, FIELD_TYPE: BOOL_TYPE,
416
71
         FIELD_VALUE: BUILD_FS_IMAGE_VAL},
417
72
        {FIELD_NAME: MAKE_JOBS, FIELD_TYPE: INT_TYPE,
418
73
         FIELD_VALUE: MAKE_JOBS_VAL},
419
74
        {FIELD_NAME: NAME_ATTR, FIELD_VALUE: LOOP_NAME_VAL},
420
75
        {FIELD_NAME: TYPE_ATTR, FIELD_VALUE: LOOP_TYPE_VAL}
421
76
]
422
77
423
78
VALID_START = XML_START + ROOT_TAG_OPEN
424
79
VALID_CLOSE = ROOT_TAG_CLOSE
425
80
426
81
427
82
def create_xml_fields(fields_list):
428
83
    """
429
84
    Support functions to create the <fields><field>... hierarchy.
430
85
431
86
    :param fields_list: the list of fields to create. Each field has to be
432
87
    a dictionary with FIELD_NAME, FIELD_VALUE and optional FIELD_TYPE keys.
433
88
    :type fields_list list
434
89
    """
435
90
    assert isinstance(fields_list, list)
436
91
    fields_xml = FIELDS_TAG_OPEN
437
92
438
93
    for field in fields_list:
439
94
        if field.get(FIELD_TYPE, None) is not None:
440
95
            fields_xml += VALID_FIELD_WITH_TYPE % field
441
96
        else:
442
97
            fields_xml += VALID_FIELD % field
443
98
    fields_xml += FIELDS_TAG_CLOSE
444
99
    return fields_xml
445
100
446
101
447
102
class XmlToDictTest(TestCase):
448
103
    """
449
104
    Test class for the conversion from XML to Python dictionary.
450
105
    The XML specification is taken from the HACKING file.
451
106
    """
452
107
453
108
    def setUp(self):
454
109
        super(XmlToDictTest, self).setUp()
455
110
        self.xml_string = VALID_START
456
111
        self.xml_string += create_xml_fields(FIELDS)
457
112
        self.xml_string += VALID_CLOSE
458
113
        self.xml_to_dict = XmlToDict(self.xml_string)
459
114
460
115
    def test_get_element_from_root(self):
461
116
        """
462
117
        Tests retrieval of the elements in the XML tree, but the root.
463
118
        """
464
119
        self.assertEqual(self.xml_to_dict.get_elements_from_root()[0].tag,
465
120
                         FIELDS_ELEMENT)
466
121
467
122
    def test_get_element_by_name_correct(self):
468
123
        """Tests retrieving of an element with a correct name."""
469
124
        self.assertEqual(FIELDS_ELEMENT,
470
125
                         self.xml_to_dict.get_element_by_name(
471
126
                             FIELDS_ELEMENT).tag)
472
127
473
128
    def test_get_element_by_name_wrong(self):
474
129
        """ Tests retrieving of an element with a wrong name."""
475
130
        self.assertEqual(None,
476
131
                         self.xml_to_dict.get_element_by_name('wrong'))
477
132
478
133
    def test_elements_to_dict(self):
479
134
        """
480
135
        Tests creation of a dictionary with multiple elements.
481
136
        """
482
137
        expected_output = {MAKE_JOBS: MAKE_JOBS_VAL,
483
138
                           BUILD_TYPE: BUILD_TYPE_VAL,
484
139
                           BUILD_FS_IMAGE: BUILD_FS_IMAGE_VAL,
485
140
                           REPO_QUIET: REPO_QUIET_VAL,
486
141
                           NAME_ATTR: LOOP_NAME_VAL,
487
142
                           TYPE_ATTR: LOOP_TYPE_VAL}
488
143
        element = self.xml_to_dict.get_element_by_name(FIELDS_ELEMENT)
489
144
        self.assertEqual(expected_output,
490
145
                         self.xml_to_dict.element_to_dict(element))
491
146
492
147
    def test_bool_true_conversion(self):
493
148
        """
494
149
        Tests the True bool conversion.
495
150
        """
496
151
        expected_out = {'a-field': True}
497
152
        for value in ['1', 1, 'y', 'Yes', True, 'True']:
498
153
            local_xml = VALID_START
499
154
            fields_list = [{FIELD_NAME: 'a-field',
500
155
                            FIELD_TYPE: BOOL_TYPE,
501
156
                            FIELD_VALUE: value}]
502
157
            local_xml += create_xml_fields(fields_list)
503
158
            local_xml += VALID_CLOSE
504
159
            local_xml_to_dict = XmlToDict(local_xml)
505
160
            element = local_xml_to_dict.get_element_by_name(FIELDS_ELEMENT)
506
161
            self.assertEqual(expected_out,
507
162
                             local_xml_to_dict.element_to_dict(element))
508
163
509
164
    def test_bool_false_conversion(self):
510
165
        """
511
166
        Tests the False bool conversion.
512
167
        """
513
168
        expected_out = {'a-field': False}
514
169
        for value in ['n', 0, 42, 'Yep', 'No', False, 'False', '?']:
515
170
            local_xml = VALID_START
516
171
            fields_list = [{FIELD_NAME: 'a-field',
517
172
                            FIELD_TYPE: BOOL_TYPE,
518
173
                            FIELD_VALUE: value}]
519
174
            local_xml += create_xml_fields(fields_list)
520
175
            local_xml += VALID_CLOSE
521
176
            local_xml_to_dict = XmlToDict(local_xml)
522
177
            element = local_xml_to_dict.get_element_by_name(FIELDS_ELEMENT)
523
178
            self.assertEqual(expected_out,
524
179
                             local_xml_to_dict.element_to_dict(element))
525
180
526
181
    def test_int_conversion(self):
527
182
        """
528
183
        Tests the int conversion.
529
184
        """
530
185
        expected_out = {'a-field': 42}
531
186
        for value in [42, '42', '42           ', '   42']:
532
187
            local_xml = VALID_START
533
188
            fields_list = [{FIELD_NAME: 'a-field',
534
189
                            FIELD_TYPE: INT_TYPE,
535
190
                            FIELD_VALUE: value}]
536
191
            local_xml += create_xml_fields(fields_list)
537
192
            local_xml += VALID_CLOSE
538
193
            local_xml_to_dict = XmlToDict(local_xml)
539
194
            element = local_xml_to_dict.get_element_by_name(FIELDS_ELEMENT)
540
195
            self.assertEqual(expected_out,
541
196
                             local_xml_to_dict.element_to_dict(element))
542
197
543
198
    def test_str_conversion(self):
544
199
        """
545
200
        Tests the str conversion.
546
201
        """
547
202
        expected_out = {'a-field': '42'}
548
203
        for value in [42, '42', '42           ', '   42']:
549
204
            local_xml = VALID_START
550
205
            fields_list = [{FIELD_NAME: 'a-field',
551
206
                            FIELD_VALUE: value}]
552
207
            local_xml += create_xml_fields(fields_list)
553
208
            local_xml += VALID_CLOSE
554
209
            local_xml_to_dict = XmlToDict(local_xml)
555
210
            element = local_xml_to_dict.get_element_by_name(FIELDS_ELEMENT)
556
211
            self.assertEqual(expected_out,
557
212
                             local_xml_to_dict.element_to_dict(element))
558
213
559
214
    def test_tree_to_dict(self):
560
215
        """
561
216
        Tests the conversion of a dictionary into a full XML tree.
562
217
        """
563
218
        expected_output = {
564
219
            REPO_QUIET: REPO_QUIET_VAL,
565
220
            NAME_ATTR: LOOP_NAME_VAL,
566
221
            MAKE_JOBS: MAKE_JOBS_VAL,
567
222
            TYPE_ATTR: LOOP_TYPE_VAL,
568
223
            BUILD_TYPE: BUILD_TYPE_VAL,
569
224
            BUILD_FS_IMAGE: BUILD_FS_IMAGE_VAL
570
225
        }
571
226
        self.assertEqual(expected_output, self.xml_to_dict.tree_to_dict())
572
227
573
228
    def test_get_root_name(self):
574
229
        """
575
230
        Tests retrieving of the root element.
576
231
        """
577
232
        self.assertEqual(self.xml_to_dict.get_root(), LOOP_ELEMENT)
578
233
579
234
    def test_get_root_attributes(self):
580
235
        """
581
236
        Tests retrieving of the root attributes.
582
237
        """
583
238
        self.assertEqual({}, self.xml_to_dict.get_root_attributes())
584
239
585
240
586
241
class DictToXmlTest(TestCase):
587
242
    """
588
243
    Test class for the conversion from Python dictionary into XML.
589
244
    The XML specification is taken from the HACKING file.
590
245
    """
591
246
592
247
    FIELDS_LIST = [
593
248
            {FIELD_NAME: MAKE_JOBS, FIELD_VALUE: MAKE_JOBS_VAL,
594
249
             FIELD_TYPE: INT_TYPE},
595
250
            {FIELD_NAME: TYPE_ATTR, FIELD_VALUE: LOOP_TYPE_VAL,
596
251
             FIELD_TYPE: STR_TYPE},
597
252
            {FIELD_NAME: NAME_ATTR, FIELD_VALUE: LOOP_NAME_VAL,
598
253
             FIELD_TYPE: STR_TYPE},
599
254
    ]
600
255
601
256
    VALID_DICT = {
602
257
        NAME_ATTR: LOOP_NAME_VAL, TYPE_ATTR: LOOP_TYPE_VAL,
603
258
        MAKE_JOBS: MAKE_JOBS_VAL
604
259
    }
605
260
606
261
    def setUp(self):
607
262
        super(DictToXmlTest, self).setUp()
608
263
        self.valid_xml = VALID_START
609
264
        self.valid_xml += create_xml_fields(self.FIELDS_LIST)
610
265
        self.valid_xml += VALID_CLOSE
611
266
        self.dict_to_xml = DictToXml(self.VALID_DICT)
612
267
613
268
    def test_dict_to_tree(self):
614
269
        """
615
270
        Tests dictionary to XML conversion.
616
271
        """
617
272
        self.assertEqual(self.valid_xml, self.dict_to_xml.dict_to_tree())
618
273
619
274
    def test_dict_to_tree_with_bool(self):
620
275
        """
621
276
        Tests dictionary to XML conversion, with a bool inside, ElementTree
622
277
        does not cope very well with bool type.
623
278
        """
624
279
        fields = [
625
280
                {FIELD_NAME: REPO_QUIET, FIELD_VALUE: REPO_QUIET_VAL,
626
281
                 FIELD_TYPE: BOOL_TYPE},
627
282
                {FIELD_NAME: TYPE_ATTR, FIELD_VALUE: LOOP_TYPE_VAL,
628
283
                 FIELD_TYPE: STR_TYPE},
629
284
                {FIELD_NAME: NAME_ATTR, FIELD_VALUE: LOOP_NAME_VAL,
630
285
                 FIELD_TYPE: STR_TYPE},
631
286
        ]
632
287
        dictionary = {TYPE_ATTR: LOOP_TYPE_VAL, NAME_ATTR: LOOP_NAME_VAL,
633
288
                      REPO_QUIET: REPO_QUIET_VAL}
634
289
        dict_2_xml = DictToXml(dictionary)
635
290
        xml_string = VALID_START
636
291
        xml_string += create_xml_fields(fields)
637
292
        xml_string += VALID_CLOSE
638
293
        self.assertEqual(xml_string, dict_2_xml.dict_to_tree())
639
0
294
640
=== modified file 'dashboard/lib/template.py'
641
--- dashboard/lib/template.py	2012-08-22 14:44:49 +0000
642
+++ dashboard/lib/template.py	2012-09-07 12:52:19 +0000
643
@@ -16,6 +16,7 @@
644
16
# along with linaro-ci-dashboard.  If not, see <http://www.gnu.org/licenses/>.
16
# along with linaro-ci-dashboard.  If not, see <http://www.gnu.org/licenses/>.
645
17
# Django settings for dashboard project.
17
# Django settings for dashboard project.
646
18
18
647
19
648
19
class AbstractTemplate(object):
20
class AbstractTemplate(object):
649
20
    "Template class interface."
21
    "Template class interface."
650
21
22
651
22
23
652
=== added file 'dashboard/lib/xml_fields.py'
653
--- dashboard/lib/xml_fields.py	1970-01-01 00:00:00 +0000
654
+++ dashboard/lib/xml_fields.py	2012-09-07 12:52:19 +0000
655
@@ -0,0 +1,47 @@
656
1
# Copyright (C) 2012 Linaro
657
2
#
658
3
# This file is part of linaro-ci-dashboard.
659
4
#
660
5
# linaro-ci-dashboard is free software: you can redistribute it and/or modify
661
6
# it under the terms of the GNU Affero General Public License as published by
662
7
# the Free Software Foundation, either version 3 of the License, or
663
8
# (at your option) any later version.
664
9
#
665
10
# linaro-ci-dashboard is distributed in the hope that it will be useful,
666
11
# but WITHOUT ANY WARRANTY; without even the implied warranty of
667
12
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
668
13
# GNU Affero General Public License for more details.
669
14
#
670
15
# You should have received a copy of the GNU Affero General Public License
671
16
# along with linaro-ci-dashboard.  If not, see <http://www.gnu.org/licenses/>.
672
17
# Django settings for dashboard project.
673
18
674
19
# The file contains all the necessary elements, tags and everything else
675
20
# related to the XML representation of a chain-build.
676
21
677
22
# All the XML valid elements.
678
23
FIELD_ELEMENT = 'field'
679
24
FIELDS_ELEMENT = 'fields'
680
25
LOOP_ELEMENT = 'loop'
681
26
DESCRIPTION_ELEMENT = 'description'
682
27
683
28
# All the XML attributes.
684
29
NAME_ATTR = 'name'
685
30
TYPE_ATTR = 'type'
686
31
687
32
# The valid types for element values.
688
33
BOOL_TYPE = 'bool'
689
34
INT_TYPE = 'int'
690
35
STR_TYPE = 'str'
691
36
VALID_TYPES = [BOOL_TYPE, INT_TYPE, STR_TYPE]
692
37
693
38
# List of valid values considered as boolean True.
694
39
VALID_TRUES = ['1', 'y', 'yes', 'Yes', 'True', 'true']
695
40
696
41
# This is the start of the XML file. The DTD, if updated, needs to be updated
697
42
# also in the HACKING file. This one is taken from the HACKING file.
698
43
XML_START = ('<?xml version="1.0" encoding="UTF-8"?><!DOCTYPE loop '
699
44
             '[<!ELEMENT loop (description?,fields)><!ELEMENT description '
700
45
             '(#PCDATA)><!ELEMENT fields (field+)><!ELEMENT field '
701
46
             '(#PCDATA)><!ATTLIST field name CDATA #REQUIRED>'
702
47
             '<!ATTLIST field type (str|int|bool) "str">]>')
703
0
48
704
=== added file 'dashboard/lib/xml_to_dict.py'
705
--- dashboard/lib/xml_to_dict.py	1970-01-01 00:00:00 +0000
706
+++ dashboard/lib/xml_to_dict.py	2012-09-07 12:52:19 +0000
707
@@ -0,0 +1,253 @@
708
1
# Copyright (C) 2012 Linaro
709
2
#
710
3
# This file is part of linaro-ci-dashboard.
711
4
#
712
5
# linaro-ci-dashboard is free software: you can redistribute it and/or modify
713
6
# it under the terms of the GNU Affero General Public License as published by
714
7
# the Free Software Foundation, either version 3 of the License, or
715
8
# (at your option) any later version.
716
9
#
717
10
# linaro-ci-dashboard is distributed in the hope that it will be useful,
718
11
# but WITHOUT ANY WARRANTY; without even the implied warranty of
719
12
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
720
13
# GNU Affero General Public License for more details.
721
14
#
722
15
# You should have received a copy of the GNU Affero General Public License
723
16
# along with linaro-ci-dashboard.  If not, see <http://www.gnu.org/licenses/>.
724
17
# Django settings for dashboard project.
725
18
726
19
import xml.etree.ElementTree as ET
727
20
from dashboard.lib.xml_fields import *
728
21
729
22
730
23
class XmlToDictException(Exception):
731
24
    """
732
25
    Exception for the XmlToDict class.
733
26
    """
734
27
735
28
736
29
class DictToXmlException(Exception):
737
30
    """
738
31
    Exception fro the DictToXml class.
739
32
    """
740
33
741
34
742
35
class XmlToDict(object):
743
36
    """
744
37
    Class to convert an XML string into a Python dictionary.
745
38
    This applies to the XML as defined for the loop chaining.
746
39
747
40
    Simple usage:
748
41
        xml_2_dict = XmlToDict(xml_string).tree_to_dict()
749
42
    """
750
43
751
44
    def __init__(self, xml):
752
45
        """
753
46
        Initialize the XmlToDict class.
754
47
755
48
        :param xml: The XML tree as a string.
756
49
        :type xml str
757
50
        """
758
51
        if not isinstance(xml, str):
759
52
            raise XmlToDictException("Type of parameter is not 'str', "
760
53
                                     "got '%s' instead." % type(xml).__name__)
761
54
        super(XmlToDict, self).__init__()
762
55
        self.tree = ET.fromstring(xml)
763
56
764
57
    def get_root(self):
765
58
        """
766
59
        Returns the name of the root of the XML tree.
767
60
        :return The name of the root element.
768
61
        """
769
62
        return self.tree.tag
770
63
771
64
    def get_root_attributes(self):
772
65
        """
773
66
        Returns a dictionary containing the attributes of the root element.
774
67
775
68
        :return A dictionary with the attributes of the root element.
776
69
        """
777
70
        root_attr = {}
778
71
        for item in self.tree.items():
779
72
            root_attr[item[0]] = item[1]
780
73
        return root_attr
781
74
782
75
    def get_elements_from_root(self):
783
76
        """
784
77
        Returns the list of elements of the XML tree starting from the root.
785
78
        :return A list with Element instances.
786
79
        """
787
80
        return list(self.tree)
788
81
789
82
    def get_element_by_name(self, name):
790
83
        """
791
84
        Returns an element from the XML tree by its name.
792
85
        :param name: the name of the element to get.
793
86
        :type name str
794
87
        :return An Element instance, None if not found.
795
88
        """
796
89
        return self.tree.find(name)
797
90
798
91
    def element_to_dict(self, element):
799
92
        """
800
93
        Returns a dictionary representation of the provided XML element.
801
94
802
95
        :param element: The Element to convert.
803
96
        :type element Element
804
97
        :return The dictionary representation of element.
805
98
        """
806
99
        if not isinstance(element, ET.Element):
807
100
            raise XmlToDictException("Type of parameter is not 'Element', "
808
101
                                     "got '%s' instead" %
809
102
                                     type(element).__name__)
810
103
        element_dict = {}
811
104
        element_tag = element.tag
812
105
        element_text = element.text
813
106
814
107
        if element_text:
815
108
            element_text = self._check_element_text(element_text)
816
109
817
110
        attributes = element.items()
818
111
        children = list(element)
819
112
820
113
        # Special case for XML 'field' tag.
821
114
        # 'field' tag must have a value and at least 'name' attribute set.
822
115
        if element_tag == FIELD_ELEMENT:
823
116
            if attributes:
824
117
                element_name = element.get(NAME_ATTR)
825
118
                element_type = element.get(TYPE_ATTR)
826
119
                # Convert the value into the specified type.
827
120
                value = self.convert_to_type(element_type, element.text)
828
121
                element_dict[element_name] = value
829
122
        else:
830
123
            if attributes:
831
124
                # Other case, we store all attributes as key<>value, plus also
832
125
                # the tag name and its value if OK.
833
126
                # There might be name collisions if XML is not well done.
834
127
                for attribute in attributes:
835
128
                    element_dict[attribute[0]] = attribute[1]
836
129
                if element_text:
837
130
                    element_dict[element_tag] = element_text
838
131
            elif element_text:
839
132
                element_dict[element_tag] = element_text
840
133
        if children:
841
134
            for child in children:
842
135
                element_dict.update(self.element_to_dict(child))
843
136
        return element_dict
844
137
845
138
    def _check_element_text(self, text):
846
139
        """
847
140
        Check that the value contained in an XML element is valid, meaning it
848
141
        is not an empty space, a newline. In these cases, we return None since
849
142
        we do not want to have that element in the final dictionary.
850
143
851
144
        :param text: The value contained between opening and closing XML tag.
852
145
        :type text str
853
146
        :return None if text is empty spaces or newlines, text otherwise.
854
147
        """
855
148
        # We do this since when we get nested elements, there might be 'valid'
856
149
        # characters, like newlines or empty spaces, between the opening and
857
150
        # closing tags, but we do not want to have such fields in the resulting
858
151
        # dictionary.
859
152
        import os
860
153
        text = str(text).strip()
861
154
        if text == os.linesep or len(text) == 0:
862
155
            text = None
863
156
        return text
864
157
865
158
    def convert_to_type(self, value_type, value):
866
159
        """
867
160
        Converts a value of an XML element into the provided type. If type is
868
161
        None, tha value is converted into a string.
869
162
870
163
        :param value_type: The type of the resulting value.
871
164
        :type value_type str
872
165
        :param value: The value associated with the XML element.
873
166
        :return The value converted into the specified type.
874
167
        """
875
168
        converted = str(value).strip()
876
169
        if value_type == BOOL_TYPE:
877
170
            if converted in VALID_TRUES:
878
171
                converted = True
879
172
            else:
880
173
                converted = False
881
174
        elif value_type == INT_TYPE:
882
175
            converted = int(converted)
883
176
884
177
        return converted
885
178
886
179
    def tree_to_dict(self):
887
180
        """
888
181
        Create a dictionary out of the XML tree.
889
182
890
183
        :return A python dictionary of the XML tree.
891
184
        """
892
185
        tree_dict = {}
893
186
894
187
        root_dict = self.get_root_attributes()
895
188
        elements_dict = {}
896
189
        for element in self.get_elements_from_root():
897
190
            elements_dict.update(self.element_to_dict(element))
898
191
899
192
        if root_dict:
900
193
            tree_dict.update(root_dict)
901
194
902
195
        if elements_dict:
903
196
            if tree_dict:
904
197
                tree_dict.update(elements_dict)
905
198
            else:
906
199
                tree_dict = elements_dict
907
200
908
201
        return tree_dict
909
202
910
203
911
204
class DictToXml(object):
912
205
    """
913
206
    Class to convert a Python dictionary into an XML string .
914
207
915
208
    Simple usage:
916
209
        dict_2_xml = DictToXml(dictionary).dict_to_tree()
917
210
    """
918
211
919
212
    def __init__(self, dictionary):
920
213
        """
921
214
        Initialize the DictToXml class.
922
215
923
216
        :param dictionary: The dictionary to convert.
924
217
        :type dictionary dict
925
218
        """
926
219
        if not isinstance(dictionary, dict):
927
220
            raise DictToXmlException("Type of parameter is not 'dict, "
928
221
                                     "got '%s' instead." %
929
222
                                     type(dictionary).__name__)
930
223
        super(DictToXml, self).__init__()
931
224
        self.dictionary = dictionary
932
225
933
226
    def dict_to_tree(self):
934
227
        """
935
228
        Create an XML tree out of the provided dictionary. The XML structure
936
229
        is defined in the HACKING file.
937
230
938
231
        :return A string with the XML representation of the dictionary.
939
232
        """
940
233
        dict_to_xml = XML_START
941
234
942
235
        loop = ET.Element(LOOP_ELEMENT)
943
236
        fields = ET.SubElement(loop, FIELDS_ELEMENT)
944
237
        for key, value in self.dictionary.iteritems():
945
238
            # Get the type of the value. If it comes from Django, everything
946
239
            # will be unicode type, we default to 'str'.
947
240
            # TODO maybe have a mappings of fields<>type?
948
241
            value_type = type(value).__name__
949
242
            if not value_type in VALID_TYPES:
950
243
                value_type = STR_TYPE
951
244
            attrib = {NAME_ATTR: key, TYPE_ATTR: value_type}
952
245
            field = ET.SubElement(fields, FIELD_ELEMENT, attrib)
953
246
            # ElementTree cannot serialize boolean types.
954
247
            field.text = str(value)
955
248
956
249
        # Dump the XML and add it to the valid start with its DTD.
957
250
        xml_dump = ET.tostring(loop)
958
251
        dict_to_xml += xml_dump
959
252
960
253
        return dict_to_xml
Status:	Merged
Approved by:	Stevan Radaković on 2012-09-07
Approved revision:	52
Merged at revision:	41
Proposed branch:	lp:~milo/linaro-ci-dashboard/xml-to-dict
Merge into:	lp:linaro-ci-dashboard
Diff against target:	960 lines (+722/-23) 13 files modified HACKING (+1/-1) dashboard/frontend/android_textfield_loop/models/android_textfield_loop.py (+3/-0) dashboard/frontend/android_textfield_loop/templates/android_textfield_loop_create.html (+0/-8) dashboard/frontend/android_textfield_loop/tests/test_android_textfield_loop_model.py (+13/-4) dashboard/frontend/models/loop.py (+28/-4) dashboard/frontend/models/loop_build.py (+13/-0) dashboard/frontend/models/textfield_loop.py (+38/-5) dashboard/frontend/tests/__init__.py (+3/-0) dashboard/frontend/tests/test_models.py (+29/-1) dashboard/frontend/tests/test_xml_to_dict.py (+293/-0) dashboard/lib/template.py (+1/-0) dashboard/lib/xml_fields.py (+47/-0) dashboard/lib/xml_to_dict.py (+253/-0)
To merge this branch:	bzr merge lp:~milo/linaro-ci-dashboard/xml-to-dict
Related bugs:	Link a bug report
Reviewer	Date Requested	Status
Stevan Radaković	2012-09-06	Approve on 2012-09-07
Linaro Infrastructure	2012-09-06	Pending
Данило Шеган	2012-09-06	Pending
Review via email: mp+123053@code.launchpad.net