← Back to branch summary

~flimm/ooo-thumbnailer/releases

« back to all changes in this revision

Viewing changes to test/test.py

  • Committer: David D Lowe
  • Date: 2011-11-12 01:11:57 UTC
  • mfrom: (1.1.33 trunk)
  • Revision ID: daviddlowe.flimm@gmail.com-20111112011157-hjtdnjg7riygpuot
0.5 release.

Show diffs side-by-side

added added

removed removed

Lines of Context:
test/test.py
1
1
#!/usr/bin/env python2.6
2
 
# Copyright 2010 David D Lowe <daviddlowe.flimm@gmail.com>
 
2
# Copyright 2010-2011 David D Lowe <daviddlowe.flimm@gmail.com>
3
3
#      
4
4
# This program is free software; you can redistribute it and/or modify
5
5
# it under the terms of the GNU General Public License as published by
41
41
    parser.add_argument("files", metavar="file", nargs="*",
42
42
        help="document, spreadsheet or presentation to be tested")
43
43
    
44
 
    parser.add_argument("-m","--unoconv_max_size", type=int, metavar="MAX_SIZE",
45
 
        help="OOOTHUMBNAILER_UNOCONV_MAX_SIZE environment variable to be used")
46
 
    
47
 
    parser.add_argument("-t", "--timeout", type=int,
48
 
        help="OOOTHUMBNAILER_TIMEOUT environment variable to be used")
 
44
    parser.add_argument("-t", "--timeout", type=float,
 
45
        help="maximum time allowed to make a thumbnail")
49
46
    
50
47
    parser.add_argument("-d", "--debug", action="store_const", const=True,
51
48
        default=False, help="print debugging information on failed tests")
69
66
            sys.exit(3)
70
67
    else:
71
68
        files = list_of_files()
72
 
    
 
69
 
73
70
    try:
74
 
        if args.unoconv_max_size is None and args.timeout is None:
75
 
            out = os.path.join(os.path.dirname(__file__), "output/")
76
 
            # If no options are specified, run these tests
77
 
            errors = test_files(files, out + "1", 4000000)
78
 
            errors += test_files(files, out + "2", timeout=3)
79
 
            errors += test_files(files, out + "3", 4000000, 3)
80
 
            errors += test_files(files, out + "4")
81
 
            num_of_files = len(files) * 4
 
71
        if args.timeout is None:
 
72
            errors = test_files(files)
82
73
        else:
83
 
            kwargs = {}
84
 
            if args.unoconv_max_size:
85
 
                kwargs["unoconv_max_size"] = args.unoconv_max_size
86
 
            if args.timeout:
87
 
                kwargs["timeout"] = args.timeout
88
 
            errors = test_files(files, **kwargs)
89
 
            num_of_files = len(files)
90
 
                
 
74
            errors = test_files(files, timeout=args.timeout)
 
75
    
91
76
        # End the script
92
77
        if errors == 0:
93
78
            print "Tests were successful"
94
79
        else:
95
80
            print red("%d test%s failed out of %d" % \
96
 
                (errors, "s" if errors != 1 else "", num_of_files))
 
81
                (errors, "s" if errors != 1 else "", len(files)))
97
82
            sys.exit(1)
 
83
 
98
84
    except KeyboardInterrupt:
99
85
        if debug:
100
86
            raise
144
130
    sys.stdout.write(str + " " * (max_length - len(newstr)))
145
131
    sys.stdout.flush()
146
132
 
147
 
def test_files(files, output_directory=None, unoconv_max_size=-1, timeout=-1):
 
133
def test_files(files, output_directory=None, timeout=0.5):
148
134
    """Test all the files passed, printing the results.
149
135
    
150
136
    Returns the number of failed tests (integer).
153
139
    files -- list of document, presentation or spreadsheet filenames
154
140
    output_directory -- path to directory where thumbnails should be 
155
141
                        saved, by default, test/output/
156
 
    unoconv_max_size -- -m command line argument passed
157
 
    timeout -- maximum duration the process may take in seconds
 
142
    timeout -- maximum duration each process may take in seconds
158
143
    
159
144
    """
160
145
    # Prepare output directory
162
147
        output_directory = os.path.join(os.path.dirname(__file__), "output")
163
148
    if not os.path.isdir(output_directory):
164
149
        os.mkdir(output_directory)
 
150
 
165
151
    # Print title of test
166
 
    print green("Testing %d file%s with unoconv_max_size=%d and timeout=%d" \
167
 
        % (len(files), "s" if len(files) != 1 else "", unoconv_max_size,
168
 
        timeout))
 
152
    print green("Testing %d file%s with timeout=%f" \
 
153
        % (len(files), "s" if len(files) != 1 else "", timeout))
 
154
 
169
155
    # Get maximum length of filenames
170
156
    maxlength = -1
171
157
    for file in files:
186
172
        print_column(size_string(os.path.getsize(file)), 6)
187
173
        # Test the file
188
174
        thumbnail = os.path.join(output_directory, file.split("/")[-1] + ".png")
189
 
        time, outcome, success = test_file(file, thumbnail, unoconv_max_size, timeout)
 
175
        time, outcome, success = test_file(file, thumbnail, timeout)
190
176
        # Print the outcome
191
177
        print_column(time, 14)
192
178
        print outcome
195
181
    print "\n",
196
182
    return errors
197
183
 
198
 
def test_file(file, output, unoconv_max_size, timeout):
 
184
def test_file(file, output, timeout):
199
185
    """Test ooo-thumbnailer with the file.
200
186
    
201
187
    Returns a three-tuple: (time, outcome, success)
206
192
    Keyword arguments:
207
193
    file -- document, presentation or spreadsheet (string)
208
194
    output -- path to thumbnail
209
 
    unoconv_max_size -- -m command line argument passed
210
195
    timeout -- maximum duration the process may take in seconds
211
196
    
212
197
    """
214
199
    if os.path.exists(output):
215
200
        os.remove(output)
216
201
    
217
 
    # Run ooo-thumbnailer with specified file and options, timed with
218
 
    # time application
219
 
    env = os.environ
220
 
    env["OOOTHUMBNAILER_UNOCONV_MAX_SIZE"] = str(int(unoconv_max_size))
221
 
    env["OOOTHUMBNAILER_TIMEOUT"] = str(int(timeout))
 
202
    # Run ooo-thumbnailer with specified file and options
222
203
    command = []
223
 
    if timeout > 0:
224
 
        command.extend(["/usr/bin/timeout", str(timeout)])
225
204
    global debug
226
205
    if debug:
227
206
        command.extend(["bash", "-x"])
228
207
    command.append(SCRIPT)
229
 
    if unoconv_max_size > 0:
230
 
        command.extend(["-m", str(unoconv_max_size)])
231
208
    command.extend([file, output, "128"])
232
209
    
233
210
    time1 = get_time()
234
211
    process = subprocess.Popen(command,
235
 
        stdout=subprocess.PIPE, stderr=subprocess.PIPE,
236
 
        env=env)
 
212
        stdout=subprocess.PIPE, stderr=subprocess.PIPE)
237
213
    
238
214
    stdout, stderr = process.communicate()
239
 
    time2 = get_time()
240
 
    time = time2 - time1
241
 
    
 
215
 
242
216
    # Avoid zombies:
243
217
    process.wait()
244
218
    process.poll()
245
219
    
 
220
    time2 = get_time()
 
221
    time = time2 - time1
 
222
    
246
223
    # Determine results
247
224
    success = False
248
225
    if process.returncode == 0 and os.path.exists(output):
249
 
        # Check to see if unoconv_max_size was obeyed or not
250
 
        if unoconv_max_size > 0 and is_file_in_microsoft_format(file) \
251
 
        and not is_file_with_thumbnail(file) \
252
 
        and os.path.getsize(file) > unoconv_max_size:
253
 
            outcome = red("Ignored unoconv_max_size")
254
 
        # Check to see if timeout was obeyed or not
255
 
        elif timeout > 0 and time > timeout + 0.05:
256
 
            outcome = red("Ignored timeout")
 
226
        # Successful error code and thumbnail has been created
 
227
 
 
228
        # Check to see if result was unexpectedly slow
 
229
        if time > timeout and is_file_with_thumbnail(file):
 
230
            outcome = red("Thumbnail created, but unexpectedly slow")
257
231
        else:
258
 
            # Successful error code and thumbnail has been created
259
 
            # Check to see if result was unexpectedly slow
260
 
            if time > 3 and is_file_with_thumbnail(file):
261
 
                outcome = red("Thumbnail created, but unexpectedly slow")
262
 
            else:
263
 
                outcome = green("Success: thumbnail created")
264
 
                success = True
 
232
            outcome = green("Success: thumbnail created")
 
233
            success = True
 
234
 
265
235
    elif process.returncode == 0:
266
236
        # Successful error code but thumbnail file does not exist
267
237
        outcome = red("Thumbnail not found, but errorcode is 0")
268
 
    elif unoconv_max_size > 0 and process.returncode == 9:
269
 
        # Error code 9 indicates that file was too large
270
 
        if is_file_in_microsoft_format(file) \
271
 
        and not is_file_with_thumbnail(file) \
272
 
        and os.path.getsize(file) >= unoconv_max_size:
273
 
            outcome = green("Success: skipped because too large")
274
 
            success = True
275
 
        else:
276
 
            outcome = red("Skipped when it shouldn't have")
277
 
    elif timeout > 0 and process.returncode == 137 or process.returncode == -9:
278
 
        # Error code 8 indicates that the script timed out
279
 
        if time >= timeout:
280
 
            if time >= 3 and is_file_with_thumbnail(file):
281
 
                outcome = red("Timed out, but this operation should have been quick")
282
 
            else:
283
 
                outcome = green("Success: timed out")
284
 
                success = True
285
 
        else:
286
 
            outcome = red("Timed out too early")
 
238
 
287
239
    else:
288
240
        outcome = red("Failed (code:%d)" % process.returncode)
 
241
 
289
242
    if debug and not success:
290
243
        outcome = outcome + "\n" + str(command) + "\n" + stdout + "\n" + stderr
 
244
 
291
245
    return "%0.2f seconds" % time, outcome, success
292
246
 
293
247
def is_file_in_microsoft_format(file):