tests.builtin

1 # This program is free software; you can redistribute it and/or modify 2 # it under the terms of the (LGPL) GNU Lesser General Public License as 3 # published by the Free Software Foundation; either version 3 of the 4 # License, or (at your option) any later version. 5 # 6 # This program is distributed in the hope that it will be useful, 7 # but WITHOUT ANY WARRANTY; without even the implied warranty of 8 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 9 # GNU Library Lesser General Public License for more details at 10 # ( http://www.gnu.org/licenses/lgpl.html ). 11 # 12 # You should have received a copy of the GNU Lesser General Public License 13 # along with this program; if not, write to the Free Software 14 # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. 15 # written by: Jeff Ortel ( jortel@redhat.com ) 16 17 import sys 18 sys.path.append('../') 19 import unittest 20 from suds.sax.date import Timezone as Tz 21 from suds.xsd.sxbuiltin import * 22 from unittest import TestCase 23 from tests import * 24 25 setup_logging() 26 27

28 -class Date(XDate):

29 - def __init__(self):

30 pass

31 -class Time(XTime):

32 - def __init__(self):

33 pass

34 -class DateTime(XDateTime):

35 - def __init__(self):

36 pass

37

38 -class DateTest(TestCase):

39

40 - def testSimple(self):

41 ref = dt.date(1941, 12, 7) 42 s = '%.4d-%.2d-%.2d' % (ref.year, ref.month, ref.day) 43 xdate = Date() 44 d = xdate.translate(s) 45 self.assertEqual(d, ref)

46

47 - def testNegativeTimezone(self):

48 self.equalsTimezone(-6)

49

50 - def testPositiveTimezone(self):

51 self.equalsTimezone(6)

52

53 - def testUtcTimezone(self):

54 Timezone.LOCAL = 0 55 ref = dt.date(1941, 12, 7) 56 s = '%.4d-%.2d-%.2dZ' % (ref.year, ref.month, ref.day) 57 xdate = Date() 58 d = xdate.translate(s) 59 self.assertEqual(d, ref)

60

61 - def equalsTimezone(self, tz):

62 Timezone.LOCAL = tz 63 ref = dt.date(1941, 12, 7) 64 s = '%.4d-%.2d-%.2d%+.2d:00' % (ref.year, ref.month, ref.day, tz) 65 xdate = Date() 66 d = xdate.translate(s) 67 self.assertEqual(d, ref)

68 69 70

71 -class TimeTest(TestCase):

72

73 - def testSimple(self):

74 ref = dt.time(10, 30, 22) 75 s = '%.2d:%.2d:%.2d' % (ref.hour, ref.minute, ref.second) 76 xtime = Time() 77 t = xtime.translate(s) 78 self.assertEqual(t, ref)

79

80 - def testSimpleWithShortMicrosecond(self):

81 ref = dt.time(10, 30, 22, 34) 82 s = '%.2d:%.2d:%.2d.%4.d' % (ref.hour, ref.minute, ref.second, ref.microsecond) 83 xtime = Time() 84 t = xtime.translate(s) 85 self.assertEqual(t, ref)

86

87 - def testSimpleWithMicrosecond(self):

88 ref = dt.time(10, 30, 22, 999999) 89 s = '%.2d:%.2d:%.2d.%4.d' % (ref.hour, ref.minute, ref.second, ref.microsecond) 90 xtime = Time() 91 t = xtime.translate(s) 92 self.assertEqual(t, ref)

93

94 - def testSimpleWithLongMicrosecond(self):

95 ref = dt.time(10, 30, 22, 999999) 96 s = '%.2d:%.2d:%.2d.%4.d' % (ref.hour, ref.minute, ref.second, int('999999999')) 97 xtime = Time() 98 t = xtime.translate(s) 99 self.assertEqual(t, ref)

100

101 - def testPositiveTimezone(self):

102 self.equalsTimezone(6)

103

104 - def testNegativeTimezone(self):

105 self.equalsTimezone(-6)

106

107 - def testUtcTimezone(self):

108 Timezone.LOCAL = 0 109 ref = dt.time(10, 30, 22) 110 s = '%.2d:%.2d:%.2dZ' % (ref.hour, ref.minute, ref.second) 111 xtime = Time() 112 t = xtime.translate(s) 113 self.assertEqual(t, ref)

114

115 - def equalsTimezone(self, tz):

116 Timezone.LOCAL = tz 117 ref = dt.time(10, 30, 22) 118 s = self.strTime(ref.hour, ref.minute, ref.second, tz) 119 xtime = Time() 120 t = xtime.translate(s) 121 self.assertEqual(t, ref)

122

123 - def testConvertNegativeToGreaterNegative(self):

124 Timezone.LOCAL = -6 125 ref = dt.time(10, 30, 22) 126 s = self.strTime(ref.hour, ref.minute, ref.second, -5) 127 xtime = Time() 128 t = xtime.translate(s) 129 self.assertEqual(ref.hour-1, t.hour) 130 self.assertEqual(ref.minute, t.minute) 131 self.assertEqual(ref.second, t.second)

132

133 - def testConvertNegativeToLesserNegative(self):

134 Timezone.LOCAL = -5 135 ref = dt.time(10, 30, 22) 136 s = self.strTime(ref.hour, ref.minute, ref.second, -6) 137 xtime = Time() 138 t = xtime.translate(s) 139 self.assertEqual(ref.hour+1, t.hour) 140 self.assertEqual(ref.minute, t.minute) 141 self.assertEqual(ref.second, t.second)

142

143 - def testConvertPositiveToGreaterPositive(self):

144 Timezone.LOCAL = 3 145 ref = dt.time(10, 30, 22) 146 s = self.strTime(ref.hour, ref.minute, ref.second, 2) 147 xtime = Time() 148 t = xtime.translate(s) 149 self.assertEqual(ref.hour+1, t.hour) 150 self.assertEqual(ref.minute, t.minute) 151 self.assertEqual(ref.second, t.second)

152

153 - def testConvertPositiveToLesserPositive(self):

154 Timezone.LOCAL = 2 155 ref = dt.time(10, 30, 22) 156 s = self.strTime(ref.hour, ref.minute, ref.second, 3) 157 xtime = Time() 158 t = xtime.translate(s) 159 self.assertEqual(ref.hour-1, t.hour) 160 self.assertEqual(ref.minute, t.minute) 161 self.assertEqual(ref.second, t.second)

162

163 - def testConvertPositiveToNegative(self):

164 Timezone.LOCAL = -6 165 ref = dt.time(10, 30, 22) 166 s = self.strTime(ref.hour, ref.minute, ref.second, 3) 167 xtime = Time() 168 t = xtime.translate(s) 169 self.assertEqual(ref.hour-9, t.hour) 170 self.assertEqual(ref.minute, t.minute) 171 self.assertEqual(ref.second, t.second)

172

173 - def testConvertNegativeToPositive(self):

174 Timezone.LOCAL = 3 175 ref = dt.time(10, 30, 22) 176 s = self.strTime(ref.hour, ref.minute, ref.second, -6) 177 xtime = Time() 178 t = xtime.translate(s) 179 self.assertEqual(ref.hour+9, t.hour) 180 self.assertEqual(ref.minute, t.minute) 181 self.assertEqual(ref.second, t.second)

182

183 - def testConvertNegativeToUtc(self):

184 Timezone.LOCAL = 0 185 ref = dt.time(10, 30, 22) 186 s = self.strTime(ref.hour, ref.minute, ref.second, -6) 187 xtime = Time() 188 t = xtime.translate(s) 189 self.assertEqual(ref.hour+6, t.hour) 190 self.assertEqual(ref.minute, t.minute) 191 self.assertEqual(ref.second, t.second)

192

193 - def testConvertPositiveToUtc(self):

194 Timezone.LOCAL = 0 195 ref = dt.time(10, 30, 22) 196 s = self.strTime(ref.hour, ref.minute, ref.second, 3) 197 xtime = Time() 198 t = xtime.translate(s) 199 self.assertEqual(ref.hour-3, t.hour) 200 self.assertEqual(ref.minute, t.minute) 201 self.assertEqual(ref.second, t.second)

202

203 - def testConvertUtcToPositive(self):

204 Timezone.LOCAL = 3 205 ref = dt.time(10, 30, 22) 206 s = '%.2d:%.2d:%.2dZ' % (ref.hour, ref.minute, ref.second) 207 xtime = Time() 208 t = xtime.translate(s) 209 self.assertEqual(ref.hour+3, t.hour) 210 self.assertEqual(ref.minute, t.minute) 211 self.assertEqual(ref.second, t.second)

212

213 - def testConvertUtcToNegative(self):

214 Timezone.LOCAL = -6 215 ref = dt.time(10, 30, 22) 216 s = '%.2d:%.2d:%.2dZ' % (ref.hour, ref.minute, ref.second) 217 xtime = Time() 218 t = xtime.translate(s) 219 self.assertEqual(ref.hour-6, t.hour) 220 self.assertEqual(ref.minute, t.minute) 221 self.assertEqual(ref.second, t.second)

222

223 - def strTime(self, h, m, s, offset):

224 return '%.2d:%.2d:%.2d%+.2d:00' % (h, m, s, offset)

225 226

227 -class DateTimeTest(TestCase):

228

229 - def testSimple(self):

230 ref = dt.datetime(1941, 12, 7, 10, 30, 22) 231 s = '%.4d-%.2d-%.2dT%.2d:%.2d:%.2d' \ 232 % (ref.year, 233 ref.month, 234 ref.day, 235 ref.hour, 236 ref.minute, 237 ref.second) 238 xdt = DateTime() 239 t = xdt.translate(s) 240 self.assertEqual(t, ref)

241

242 - def testOverflow(self):

243 ref = dt.datetime(1, 1, 1, 0, 0, 0) 244 s = '%.4d-%.2d-%.2dT%.2d:%.2d:%.2dZ' \ 245 % (ref.year, 246 ref.month, 247 ref.day, 248 ref.hour, 249 ref.minute, 250 ref.second) 251 xdt = DateTime() 252 t = xdt.translate(s) 253 self.assertEqual(t, ref)

254

255 - def testSimpleWithMicrosecond(self):

256 ref = dt.datetime(1941, 12, 7, 10, 30, 22, 454) 257 s = '%.4d-%.2d-%.2dT%.2d:%.2d:%.2d.%.4d' \ 258 % (ref.year, 259 ref.month, 260 ref.day, 261 ref.hour, 262 ref.minute, 263 ref.second, 264 ref.microsecond) 265 xdt = DateTime() 266 t = xdt.translate(s) 267 self.assertEqual(t, ref)

268

269 - def testPositiveTimezone(self):

270 self.equalsTimezone(6)

271

272 - def testNegativeTimezone(self):

273 self.equalsTimezone(-6)

274

275 - def testUtcTimezone(self):

276 Timezone.LOCAL = 0 277 ref = dt.datetime(1941, 12, 7, 10, 30, 22) 278 s = '%.4d-%.2d-%.2dT%.2d:%.2d:%.2d' \ 279 % (ref.year, 280 ref.month, 281 ref.day, 282 ref.hour, 283 ref.minute, 284 ref.second) 285 xdt = DateTime() 286 t = xdt.translate(s) 287 self.assertEqual(t, ref)

288

289 - def equalsTimezone(self, tz):

290 Timezone.LOCAL = tz 291 ref = dt.datetime(1941, 12, 7, 10, 30, 22) 292 s = self.strDateTime( 293 ref.year, 294 ref.month, 295 ref.day, 296 ref.hour, 297 ref.minute, 298 ref.second, 299 tz) 300 xdt = DateTime() 301 t = xdt.translate(s) 302 self.assertEqual(t, ref)

303

304 - def testConvertNegativeToGreaterNegative(self):

305 Timezone.LOCAL = -6 306 ref = dt.datetime(1941, 12, 7, 10, 30, 22) 307 s = self.strDateTime( 308 ref.year, 309 ref.month, 310 ref.day, 311 ref.hour, 312 ref.minute, 313 ref.second, 314 -5) 315 xdt = DateTime() 316 t = xdt.translate(s) 317 self.assertEqual(ref.year, t.year) 318 self.assertEqual(ref.month, t.month) 319 self.assertEqual(ref.day, t.day) 320 self.assertEqual(ref.hour-1, t.hour) 321 self.assertEqual(ref.minute, t.minute) 322 self.assertEqual(ref.second, t.second)

323

324 - def testConvertNegativeToLesserNegative(self):

325 Timezone.LOCAL = -5 326 ref = dt.datetime(1941, 12, 7, 10, 30, 22) 327 s = self.strDateTime( 328 ref.year, 329 ref.month, 330 ref.day, 331 ref.hour, 332 ref.minute, 333 ref.second, 334 -6) 335 xdt = DateTime() 336 t = xdt.translate(s) 337 self.assertEqual(ref.year, t.year) 338 self.assertEqual(ref.month, t.month) 339 self.assertEqual(ref.day, t.day) 340 self.assertEqual(ref.hour+1, t.hour) 341 self.assertEqual(ref.minute, t.minute) 342 self.assertEqual(ref.second, t.second)

343

344 - def testConvertPositiveToGreaterPositive(self):

345 Timezone.LOCAL = 3 346 ref = dt.datetime(1941, 12, 7, 10, 30, 22) 347 s = self.strDateTime( 348 ref.year, 349 ref.month, 350 ref.day, 351 ref.hour, 352 ref.minute, 353 ref.second, 354 2) 355 xdt = DateTime() 356 t = xdt.translate(s) 357 self.assertEqual(ref.year, t.year) 358 self.assertEqual(ref.month, t.month) 359 self.assertEqual(ref.day, t.day) 360 self.assertEqual(ref.hour+1, t.hour) 361 self.assertEqual(ref.minute, t.minute) 362 self.assertEqual(ref.second, t.second)

363

364 - def testConvertPositiveToLesserPositive(self):

365 Timezone.LOCAL = 2 366 ref = dt.datetime(1941, 12, 7, 10, 30, 22) 367 s = self.strDateTime( 368 ref.year, 369 ref.month, 370 ref.day, 371 ref.hour, 372 ref.minute, 373 ref.second, 374 3) 375 xdt = DateTime() 376 t = xdt.translate(s) 377 self.assertEqual(ref.year, t.year) 378 self.assertEqual(ref.month, t.month) 379 self.assertEqual(ref.day, t.day) 380 self.assertEqual(ref.hour-1, t.hour) 381 self.assertEqual(ref.minute, t.minute) 382 self.assertEqual(ref.second, t.second)

383

384 - def testConvertPositiveToNegative(self):

385 Timezone.LOCAL = -6 386 ref = dt.datetime(1941, 12, 7, 10, 30, 22) 387 s = self.strDateTime( 388 ref.year, 389 ref.month, 390 ref.day, 391 ref.hour, 392 ref.minute, 393 ref.second, 394 3) 395 xdt = DateTime() 396 t = xdt.translate(s) 397 self.assertEqual(ref.year, t.year) 398 self.assertEqual(ref.month, t.month) 399 self.assertEqual(ref.day, t.day) 400 self.assertEqual(ref.hour-9, t.hour) 401 self.assertEqual(ref.minute, t.minute) 402 self.assertEqual(ref.second, t.second)

403

404 - def testConvertNegativeToPositive(self):

405 Timezone.LOCAL = 3 406 ref = dt.datetime(1941, 12, 7, 10, 30, 22) 407 s = self.strDateTime( 408 ref.year, 409 ref.month, 410 ref.day, 411 ref.hour, 412 ref.minute, 413 ref.second, 414 -6) 415 xdt = DateTime() 416 t = xdt.translate(s) 417 self.assertEqual(ref.year, t.year) 418 self.assertEqual(ref.month, t.month) 419 self.assertEqual(ref.day, t.day) 420 self.assertEqual(ref.hour+9, t.hour) 421 self.assertEqual(ref.minute, t.minute) 422 self.assertEqual(ref.second, t.second)

423

424 - def testConvertNegativeToUtc(self):

425 Timezone.LOCAL = 0 426 ref = dt.datetime(1941, 12, 7, 10, 30, 22) 427 s = self.strDateTime( 428 ref.year, 429 ref.month, 430 ref.day, 431 ref.hour, 432 ref.minute, 433 ref.second, 434 -6) 435 xdt = DateTime() 436 t = xdt.translate(s) 437 self.assertEqual(ref.year, t.year) 438 self.assertEqual(ref.month, t.month) 439 self.assertEqual(ref.day, t.day) 440 self.assertEqual(ref.hour+6, t.hour) 441 self.assertEqual(ref.minute, t.minute) 442 self.assertEqual(ref.second, t.second)

443

444 - def testConvertPositiveToUtc(self):

445 Timezone.LOCAL = 0 446 ref = dt.datetime(1941, 12, 7, 10, 30, 22) 447 s = self.strDateTime( 448 ref.year, 449 ref.month, 450 ref.day, 451 ref.hour, 452 ref.minute, 453 ref.second, 454 3) 455 xdt = DateTime() 456 t = xdt.translate(s) 457 self.assertEqual(ref.year, t.year) 458 self.assertEqual(ref.month, t.month) 459 self.assertEqual(ref.day, t.day) 460 self.assertEqual(ref.hour-3, t.hour) 461 self.assertEqual(ref.minute, t.minute) 462 self.assertEqual(ref.second, t.second)

463

464 - def testConvertUtcToPositive(self):

465 Timezone.LOCAL = 3 466 ref = dt.datetime(1941, 12, 7, 10, 30, 22) 467 s = '%.4d-%.2d-%.2dT%.2d:%.2d:%.2dZ' \ 468 % (ref.year, 469 ref.month, 470 ref.day, 471 ref.hour, 472 ref.minute, 473 ref.second) 474 xdt = DateTime() 475 t = xdt.translate(s) 476 self.assertEqual(ref.year, t.year) 477 self.assertEqual(ref.month, t.month) 478 self.assertEqual(ref.day, t.day) 479 self.assertEqual(ref.hour+3, t.hour) 480 self.assertEqual(ref.minute, t.minute) 481 self.assertEqual(ref.second, t.second)

482

483 - def testConvertUtcToNegative(self):

484 Timezone.LOCAL = -6 485 ref = dt.datetime(1941, 12, 7, 10, 30, 22) 486 s = '%.4d-%.2d-%.2dT%.2d:%.2d:%.2dZ' \ 487 % (ref.year, 488 ref.month, 489 ref.day, 490 ref.hour, 491 ref.minute, 492 ref.second) 493 xdt = DateTime() 494 t = xdt.translate(s) 495 self.assertEqual(ref.year, t.year) 496 self.assertEqual(ref.month, t.month) 497 self.assertEqual(ref.day, t.day) 498 self.assertEqual(ref.hour-6, t.hour) 499 self.assertEqual(ref.minute, t.minute) 500 self.assertEqual(ref.second, t.second)

501

502 - def testConvertNegativeToGreaterNegativeAndPreviousDay(self):

503 Timezone.LOCAL = -6 504 ref = dt.datetime(1941, 12, 7, 0, 30, 22) 505 s = self.strDateTime( 506 ref.year, 507 ref.month, 508 ref.day, 509 ref.hour, 510 ref.minute, 511 ref.second, 512 -5) 513 xdt = DateTime() 514 t = xdt.translate(s) 515 self.assertEqual(ref.year, t.year) 516 self.assertEqual(ref.month, t.month) 517 self.assertEqual(6, t.day) 518 self.assertEqual(23, t.hour) 519 self.assertEqual(ref.minute, t.minute) 520 self.assertEqual(ref.second, t.second)

521

522 - def testConvertNegativeToLesserNegativeAndNextDay(self):

523 Timezone.LOCAL = -5 524 ref = dt.datetime(1941, 12, 7, 23, 30, 22) 525 s = self.strDateTime( 526 ref.year, 527 ref.month, 528 ref.day, 529 ref.hour, 530 ref.minute, 531 ref.second, 532 -6) 533 xdt = DateTime() 534 t = xdt.translate(s) 535 self.assertEqual(ref.year, t.year) 536 self.assertEqual(ref.month, t.month) 537 self.assertEqual(8, t.day) 538 self.assertEqual(0, t.hour) 539 self.assertEqual(ref.minute, t.minute) 540 self.assertEqual(ref.second, t.second)

541

542 - def strDateTime(self, Y, M, D, h, m, s, offset):

543 s = '%.4d-%.2d-%.2dT%.2d:%.2d:%.2d%+.2d:00' \ 544 % (Y, M, D, h, m, s, offset) 545 return s

546 547 548 if __name__ == '__main__': 549 unittest.main() 550

Source Code for Module tests.builtin