def runTest(self):
accumulator = test_util.RecordingProblemAccumulator(self)
problems = ProblemReporter(accumulator)
self.assertEqual(0, util.NonNegIntStringToInt("0", problems))
self.assertEqual(0, util.NonNegIntStringToInt(u"0", problems))
self.assertEqual(1, util.NonNegIntStringToInt("1", problems))
self.assertEqual(2, util.NonNegIntStringToInt("2", problems))
self.assertEqual(10, util.NonNegIntStringToInt("10", problems))
self.assertEqual(
1234567890123456789,
util.NonNegIntStringToInt("1234567890123456789", problems),
)
self.assertRaises(ValueError, util.NonNegIntStringToInt, "", problems)
self.assertRaises(ValueError, util.NonNegIntStringToInt, "-1", problems)
self.assertRaises(ValueError, util.NonNegIntStringToInt, "0x1", problems)
self.assertRaises(ValueError, util.NonNegIntStringToInt, "1.0", problems)
self.assertRaises(ValueError, util.NonNegIntStringToInt, "1e1", problems)
self.assertRaises(ValueError, util.NonNegIntStringToInt, "0x20", problems)
self.assertRaises(ValueError, util.NonNegIntStringToInt, "0b10", problems)
self.assertRaises(TypeError, util.NonNegIntStringToInt, 1, problems)
self.assertRaises(TypeError, util.NonNegIntStringToInt, None, problems)
# These should issue a warning, but otherwise parse successfully
self.assertEqual(1, util.NonNegIntStringToInt("+1", problems))
e = accumulator.PopException("InvalidNonNegativeIntegerValue")
self.assertEqual(1, util.NonNegIntStringToInt("01", problems))
e = accumulator.PopException("InvalidNonNegativeIntegerValue")
self.assertEqual(0, util.NonNegIntStringToInt("00", problems))
e = accumulator.PopException("InvalidNonNegativeIntegerValue")
accumulator.AssertNoMoreExceptions()
def runTest(self):
accumulator = test_util.RecordingProblemAccumulator(self)
problems = ProblemReporter(accumulator)
self.assertAlmostEqual(0, util.FloatStringToFloat("0", problems))
self.assertAlmostEqual(0, util.FloatStringToFloat(u"0", problems))
self.assertAlmostEqual(1, util.FloatStringToFloat("1", problems))
self.assertAlmostEqual(1, util.FloatStringToFloat("1.00000", problems))
self.assertAlmostEqual(1.5, util.FloatStringToFloat("1.500", problems))
self.assertAlmostEqual(-2, util.FloatStringToFloat("-2.0", problems))
self.assertAlmostEqual(-2.5, util.FloatStringToFloat("-2.5", problems))
self.assertRaises(ValueError, util.FloatStringToFloat, ".", problems)
self.assertRaises(ValueError, util.FloatStringToFloat, "0x20",
problems)
self.assertRaises(ValueError, util.FloatStringToFloat, "-0x20",
problems)
self.assertRaises(ValueError, util.FloatStringToFloat, "0b10",
problems)
# These should issue a warning, but otherwise parse successfully
self.assertAlmostEqual(0.001,
util.FloatStringToFloat("1E-3", problems))
e = accumulator.PopException("InvalidFloatValue")
self.assertAlmostEqual(0.001,
util.FloatStringToFloat(".001", problems))
e = accumulator.PopException("InvalidFloatValue")
self.assertAlmostEqual(-0.001,
util.FloatStringToFloat("-.001", problems))
e = accumulator.PopException("InvalidFloatValue")
self.assertAlmostEqual(0, util.FloatStringToFloat("0.", problems))
e = accumulator.PopException("InvalidFloatValue")
accumulator.AssertNoMoreExceptions()
def testValidateDate(self):
accumulator = test_util.RecordingProblemAccumulator(self)
problems = ProblemReporter(accumulator)
self.assertTrue(util.ValidateDate("", "col", problems))
accumulator.AssertNoMoreExceptions()
self.assertTrue(util.ValidateDate("20100801", "col", problems))
accumulator.AssertNoMoreExceptions()
self.assertFalse(util.ValidateDate("20100732", "col", problems))
e = accumulator.PopInvalidValue("col")
accumulator.AssertNoMoreExceptions()
def testValidateTimezone(self):
accumulator = test_util.RecordingProblemAccumulator(self)
problems = ProblemReporter(accumulator)
self.assertTrue(util.ValidateTimezone("", "col", problems))
accumulator.AssertNoMoreExceptions()
self.assertTrue(util.ValidateTimezone("America/Los_Angeles", "col", problems))
accumulator.AssertNoMoreExceptions()
self.assertFalse(util.ValidateTimezone("Switzerland/Wil", "col", problems))
e = accumulator.PopInvalidValue("col")
accumulator.AssertNoMoreExceptions()
def testValidateLanguageCode(self):
accumulator = test_util.RecordingProblemAccumulator(self)
problems = ProblemReporter(accumulator)
self.assertTrue(util.ValidateLanguageCode("", "col", problems))
accumulator.AssertNoMoreExceptions()
self.assertTrue(util.ValidateLanguageCode("de", "col", problems))
accumulator.AssertNoMoreExceptions()
self.assertFalse(util.ValidateLanguageCode("Swiss German", "col", problems))
e = accumulator.PopInvalidValue("col")
accumulator.AssertNoMoreExceptions()
def testValidateURL(self):
accumulator = test_util.RecordingProblemAccumulator(self)
problems = ProblemReporter(accumulator)
self.assertTrue(util.ValidateURL("", "col", problems))
accumulator.AssertNoMoreExceptions()
self.assertTrue(util.ValidateURL("http://www.example.com", "col", problems))
accumulator.AssertNoMoreExceptions()
self.assertFalse(util.ValidateURL("ftp://www.example.com", "col", problems))
e = accumulator.PopInvalidValue("col")
accumulator.AssertNoMoreExceptions()
def testvalidate_date(self):
accumulator = test_util.RecordingProblemAccumulator(self)
problems_in_test = ProblemReporter(accumulator)
self.assertTrue(util.validate_date("", "col", problems_in_test))
accumulator.assert_no_more_exceptions()
self.assertTrue(util.validate_date("20100801", "col",
problems_in_test))
accumulator.assert_no_more_exceptions()
self.assertFalse(
util.validate_date("20100732", "col", problems_in_test))
accumulator.pop_invalid_value("col")
accumulator.assert_no_more_exceptions()
def testValidateTimezone(self):
accumulator = test_util.RecordingProblemAccumulator(self)
problems_in_test = ProblemReporter(accumulator)
self.assertTrue(util.validate_timezone("", "col", problems_in_test))
accumulator.assert_no_more_exceptions()
self.assertTrue(
util.validate_timezone("America/Los_Angeles", "col",
problems_in_test))
accumulator.assert_no_more_exceptions()
self.assertFalse(
util.validate_timezone("Switzerland/Wil", "col", problems_in_test))
accumulator.pop_invalid_value("col")
accumulator.assert_no_more_exceptions()
def testValidateLanguageCode(self):
accumulator = test_util.RecordingProblemAccumulator(self)
problems_in_test = ProblemReporter(accumulator)
self.assertTrue(
util.validate_language_code("", "col", problems_in_test))
accumulator.assert_no_more_exceptions()
self.assertTrue(
util.validate_language_code("de", "col", problems_in_test))
accumulator.assert_no_more_exceptions()
self.assertFalse(
util.validate_language_code("Swiss German", "col",
problems_in_test))
accumulator.pop_invalid_value("col")
accumulator.assert_no_more_exceptions()
def testValidateURL(self):
accumulator = test_util.RecordingProblemAccumulator(self)
problems_in_test = ProblemReporter(accumulator)
self.assertTrue(util.validate_url("", "col", problems_in_test))
accumulator.assert_no_more_exceptions()
self.assertTrue(
util.validate_url("http://www.example.com", "col",
problems_in_test))
accumulator.assert_no_more_exceptions()
self.assertFalse(
util.validate_url("ftp://www.example.com", "col",
problems_in_test))
accumulator.pop_invalid_value("col")
accumulator.assert_no_more_exceptions()
def runTest(self):
accumulator = test_util.RecordingProblemAccumulator(self)
problems_in_test = ProblemReporter(accumulator)
self.assertEqual(0,
util.non_neg_int_string_to_int("0", problems_in_test))
self.assertEqual(
0, util.non_neg_int_string_to_int(u"0", problems_in_test))
self.assertEqual(1,
util.non_neg_int_string_to_int("1", problems_in_test))
self.assertEqual(2,
util.non_neg_int_string_to_int("2", problems_in_test))
self.assertEqual(
10, util.non_neg_int_string_to_int("10", problems_in_test))
self.assertEqual(
1234567890123456789,
util.non_neg_int_string_to_int("1234567890123456789",
problems_in_test))
self.assertRaises(ValueError, util.non_neg_int_string_to_int, "",
problems_in_test)
self.assertRaises(ValueError, util.non_neg_int_string_to_int, "-1",
problems_in_test)
self.assertRaises(ValueError, util.non_neg_int_string_to_int, "0x1",
problems_in_test)
self.assertRaises(ValueError, util.non_neg_int_string_to_int, "1.0",
problems_in_test)
self.assertRaises(ValueError, util.non_neg_int_string_to_int, "1e1",
problems_in_test)
self.assertRaises(ValueError, util.non_neg_int_string_to_int, "0x20",
problems_in_test)
self.assertRaises(ValueError, util.non_neg_int_string_to_int, "0b10",
problems_in_test)
self.assertRaises(TypeError, util.non_neg_int_string_to_int, 1,
problems_in_test)
self.assertRaises(TypeError, util.non_neg_int_string_to_int, None,
problems_in_test)
# These should issue a warning, but otherwise parse successfully
self.assertEqual(
1, util.non_neg_int_string_to_int("+1", problems_in_test))
accumulator.PopException("InvalidNonNegativeIntegerValue")
self.assertEqual(
1, util.non_neg_int_string_to_int("01", problems_in_test))
accumulator.PopException("InvalidNonNegativeIntegerValue")
self.assertEqual(
0, util.non_neg_int_string_to_int("00", problems_in_test))
accumulator.PopException("InvalidNonNegativeIntegerValue")
accumulator.assert_no_more_exceptions()
def runTest(self):
accumulator = test_util.RecordingProblemAccumulator(self)
problems_in_test = ProblemReporter(accumulator)
self.assertAlmostEqual(
0, util.float_string_to_float("0", problems_in_test))
self.assertAlmostEqual(
0, util.float_string_to_float(u"0", problems_in_test))
self.assertAlmostEqual(
1, util.float_string_to_float("1", problems_in_test))
self.assertAlmostEqual(
1, util.float_string_to_float("1.00000", problems_in_test))
self.assertAlmostEqual(
1.5, util.float_string_to_float("1.500", problems_in_test))
self.assertAlmostEqual(
-2, util.float_string_to_float("-2.0", problems_in_test))
self.assertAlmostEqual(
-2.5, util.float_string_to_float("-2.5", problems_in_test))
self.assertRaises(ValueError, util.float_string_to_float, ".",
problems_in_test)
self.assertRaises(ValueError, util.float_string_to_float, "0x20",
problems_in_test)
self.assertRaises(ValueError, util.float_string_to_float, "-0x20",
problems_in_test)
self.assertRaises(ValueError, util.float_string_to_float, "0b10",
problems_in_test)
# These should issue a warning, but otherwise parse successfully
self.assertAlmostEqual(
0.001, util.float_string_to_float("1E-3", problems_in_test))
accumulator.pop_exception("InvalidFloatValue")
self.assertAlmostEqual(
0.001, util.float_string_to_float(".001", problems_in_test))
accumulator.pop_exception("InvalidFloatValue")
self.assertAlmostEqual(
-0.001, util.float_string_to_float("-.001", problems_in_test))
accumulator.pop_exception("InvalidFloatValue")
self.assertAlmostEqual(
0, util.float_string_to_float("0.", problems_in_test))
accumulator.pop_exception("InvalidFloatValue")
accumulator.assert_no_more_exceptions()
def setUp(self):
self.orig_urlopen = urllib.request.urlopen
self.mock = MockURLOpen()
self.accumulator = test_util.RecordingProblemAccumulator(self)
self.problems = ProblemReporter(self.accumulator)
def validate_gtfs():
'''Download and validate the latest static GTFS file.
Returns:
boolean: True if no errors in GTFS.
'''
# get gtfs settings
gtfs_conf = get_gtfs_config()
# Create the `downloads` directory if it doesn't exist
if not os.path.exists(DL_DIR):
os.makedirs(DL_DIR)
# Create the `reports` directory if it doesn't exist
if not os.path.exists(REPORTS_DIR):
os.makedirs(REPORTS_DIR)
# download gtfs
print('Downloading GTFS')
r = requests.get(gtfs_conf.get('gtfs_static_url'), stream=True)
with open(GTFS_FILE_NAME, 'wb') as f:
for chunk in r.iter_content(chunk_size=1024):
if chunk: # filter out keep-alive new chunks
f.write(chunk)
f.flush()
# load gtfs
print('Validating GTFS')
gtfs_factory = GetGtfsFactory()
accumulator = HTMLCountingProblemAccumulator(limit_per_type=50)
problem_reporter = ProblemReporter(accumulator)
loader = gtfs_factory.Loader(GTFS_FILE_NAME, problems=problem_reporter)
schedule = loader.Load()
# validate gtfs
schedule.Validate()
# check for trips with a null value for trip_headsign
for trip in schedule.GetTripList():
if trip.trip_headsign == 'null':
problem_reporter.InvalidValue('trip_headsign',
'null',
type=TYPE_WARNING)
# write GTFS report to file
report_name = 'gtfs_validation_{0}.html'.format(
datetime.now().strftime('%Y-%m-%d %H.%M'))
report_filenmae = os.path.join(REPORTS_DIR, report_name)
with open(report_filenmae, 'w') as f:
accumulator.WriteOutput(GTFS_FILE_NAME, f, schedule, transitfeed)
print('GTFS validation report written to {0}'.format(report_filenmae))
# post-validation
gtfs_validated = True
num_errors = accumulator.ErrorCount()
if num_errors > 0:
gtfs_validated = False
print('{0} errors in GTFS data'.format(num_errors))
num_warnings = accumulator.WarningCount()
if num_warnings > 0:
print('{0} warnings about GTFS data'.format(num_warnings))
if 'ExpirationDate' in accumulator.ProblemListMap(TYPE_WARNING).keys():
start_date, end_date = schedule.GetDateRange()
last_service_day = datetime(*(time.strptime(end_date, "%Y%m%d")[0:6]))
if last_service_day < datetime.now():
print('GTFS Feed has expired.')
gtfs_validated = False
return gtfs_validated
