desc stringlengths 3 26.7k | decl stringlengths 11 7.89k | bodies stringlengths 8 553k |
|---|---|---|
'Test date representation with custom format (=override L10n setting)'
| def testDatetimeRepresentCustomFormat(self):
| settings = current.deployment_settings
assertEqual = self.assertEqual
represent = S3DateTime.datetime_represent
dt = datetime.datetime(2015, 5, 3, 13, 38, 13)
settings.L10n.date_format = '%Y-%m-%d'
settings.L10n.time_format = '%H:%M:%S'
assertEqual(represent(dt), '2015-05-03 13:38:13')
... |
'Test early dates representation (<1900)'
| def testEarlyDateTimeRepresent(self):
| assertEqual = self.assertEqual
represent = S3DateTime.datetime_represent
dt = datetime.datetime(1685, 3, 31, 14, 3, 19)
dtstr = represent(dt)
assertEqual(dtstr, '1685-03-31 14:03:19')
dt = datetime.datetime(1473, 2, 19, 5, 45, 0)
rstr = represent(dt, format='%d-%b-%Y %H:%M')
assert... |
'Verify elimination of microseconds in datetime_represent'
| def testMicrosecondElimination(self):
| assertEqual = self.assertEqual
represent = S3DateTime.datetime_represent
dt = datetime.datetime(2015, 5, 3, 11, 38, 55, 99)
dtstr = represent(dt, format='%m/%d/%y %I:%M %f')
assertEqual(dtstr, '05/03/15 11:38 000000')
|
'Test timezone-naive time representation'
| def testTimeRepresent(self):
| assertEqual = self.assertEqual
represent = S3DateTime.time_represent
value = datetime.time(10, 45)
rstr = represent(value)
assertEqual(rstr, '10:45')
|
'Test timezone-naive datetime representation'
| def testDateTimeRepresent(self):
| assertEqual = self.assertEqual
represent = S3DateTime.time_represent
value = datetime.datetime(1988, 9, 13, 10, 45)
rstr = represent(value)
assertEqual(rstr, '10:45')
|
'Test timezone-aware time representation'
| def testTZAwareTimeRepresent(self):
| assertEqual = self.assertEqual
represent = S3DateTime.time_represent
session = current.session
utc_offset = session.s3.utc_offset
try:
value = datetime.time(10, 45)
session.s3.utc_offset = (+ 2)
rstr = represent(value, utc=True)
assertEqual(rstr, '12:45')
valu... |
'Test timezone-aware datetime representation'
| def testTZAwareDateTimeRepresent(self):
| assertEqual = self.assertEqual
represent = S3DateTime.time_represent
session = current.session
utc_offset = session.s3.utc_offset
try:
value = datetime.datetime(1988, 6, 21, 10, 45)
session.s3.utc_offset = (+ 2)
rstr = represent(value, utc=True)
assertEqual(rstr, '12:... |
'Test time representation with default format'
| def testTimeRepresentDefaultFormat(self):
| settings = current.deployment_settings
time_format = settings.get_L10n_time_format()
assertEqual = self.assertEqual
represent = S3DateTime.time_represent
time = datetime.time(16, 33, 48)
try:
settings.L10n.time_format = '%H.%M.%S'
assertEqual(represent(time), '16.33.48')
... |
'Test time representation with default format'
| def testTimeRepresentCustomFormat(self):
| settings = current.deployment_settings
time_format = settings.get_L10n_time_format()
assertEqual = self.assertEqual
represent = S3DateTime.time_represent
time = datetime.time(16, 33, 48)
try:
settings.L10n.time_format = '%H.%M.%S'
assertEqual(represent(time), '16.33.48')
... |
'Destructive tests for S3DateTime.time_represent'
| def testTimeRepresentDestructive(self):
| assertEqual = self.assertEqual
assertRaises = self.assertRaises
represent = S3DateTime.time_represent
NONE = current.messages['NONE']
rstr = represent(None)
assertEqual(rstr, NONE)
with assertRaises(TypeError):
rstr = represent(15)
with assertRaises(TypeError):
rstr = rep... |
'Custom _parse to set a marker if called'
| def _parse(self, dtstr, dtfmt):
| current.response.s3.calendar_test_parse = self.CALENDAR
return super(S3TestCalendar, self)._parse(dtstr, dtfmt)
|
'Custom _format to set a marker if called'
| def _format(self, dt, dtfmt):
| current.response.s3.calendar_test_format = self.CALENDAR
return super(S3TestCalendar, self)._format(dt, dtfmt)
|
'Custom _gdate to set a marker if called'
| def _gdate(self, timetuple):
| current.response.s3.calendar_test_gdate = self.CALENDAR
return super(S3TestCalendar, self)._gdate(timetuple)
|
'Custom _gdate to set a marker if called'
| def _cdate(self, timetuple):
| current.response.s3.calendar_test_cdate = self.CALENDAR
return super(S3TestCalendar, self)._cdate(timetuple)
|
'Test calendar construction with defaults'
| def testConstructionWithDefaults(self):
| assertEqual = self.assertEqual
assertTrue = self.assertTrue
CALENDAR = S3Calendar.CALENDAR
c = S3Calendar()
assertEqual(c._name, None)
assertEqual(c._calendar, None)
assertEqual(c.name, CALENDAR)
assertTrue((type(c.calendar) is S3Calendar))
|
'Test calendar construction with alternative defaults'
| def testConstructionWithSubclass(self):
| assertEqual = self.assertEqual
assertTrue = self.assertTrue
CALENDAR = 'Test'
settings = current.deployment_settings
settings.L10n.calendar = CALENDAR
assertEqual(settings.get_L10n_calendar(), CALENDAR)
c = S3Calendar()
assertEqual(c._name, None)
assertEqual(c._calendar, None)
c.... |
'Test calendar construction with alternative defaults'
| def testConstructionWithUndefinedSubclass(self):
| assertEqual = self.assertEqual
assertTrue = self.assertTrue
CALENDAR = 'Test'
settings = current.deployment_settings
settings.L10n.calendar = CALENDAR
assertEqual(settings.get_L10n_calendar(), CALENDAR)
c = S3Calendar()
assertEqual(c._name, None)
assertEqual(c._calendar, None)
as... |
'Verify that subclass methods are called'
| def testSubclassing(self):
| assertEqual = self.assertEqual
s3 = current.response.s3
CALENDAR = 'Test'
settings = current.deployment_settings
settings.L10n.calendar = CALENDAR
assertEqual(settings.get_L10n_calendar(), CALENDAR)
c = S3Calendar()
c._calendars[CALENDAR] = S3TestCalendar
s3.calendar_test_parse = Non... |
'Test parsing of date/time strings'
| def testParsing(self):
| c = S3Calendar()
assertEqual = self.assertEqual
parse = c.calendar._parse
tt = parse('2005-04-01T00:00:03', '%Y-%m-%dT%H:%M:%S')
assertEqual(tt[:6], (2005, 4, 1, 0, 0, 3))
tt = parse('01/04/05', '%d/%m/%y')
assertEqual(tt[:6], (2005, 4, 1, 0, 0, 0))
tt = parse('15:34', '%H:%M')
asser... |
'Test parsing of date/time strings (destructive)'
| def testParsingDestructive(self):
| c = S3Calendar()
assertRaises = self.assertRaises
assertEqual = self.assertEqual
parse = c.calendar._parse
with assertRaises(ValueError):
parse('2005-04-01', '%Y-%m-%dT%H:%M:%S')
with assertRaises(ValueError):
parse('1975-30-11 10:30', '%d/%m/%y')
with assertRaises(TypeErr... |
'Test conversion of Gregorian time tuple to calendar time tuple'
| def testCalendarDate(self):
| c = S3Calendar()
convert = c.calendar._cdate
assertEqual = self.assertEqual
tt = (2018, 5, 8, 11, 38, 0)
assertEqual(convert(tt), tt)
|
'Test conversion of calendar time tuple to Gregorian time tuple'
| def testGregorianDate(self):
| c = S3Calendar()
convert = c.calendar._gdate
assertEqual = self.assertEqual
tt = (2018, 5, 8, 11, 38, 0)
assertEqual(convert(tt), tt)
|
'Test S3Calendar.parse_date'
| def testDateParsing(self):
| c = S3Calendar()
parse = c.parse_date
assertEqual = self.assertEqual
dtstr = '1925-11-21'
dt = parse(dtstr)
assertEqual(dt, datetime.date(1925, 11, 21))
settings = current.deployment_settings
date_format = settings.get_L10n_date_format()
try:
settings.L10n.date_format = '%d/%... |
'Test S3Calendar.parse_datetime'
| def testDateTimeParsing(self):
| c = S3Calendar()
parse = c.parse_datetime
assertEqual = self.assertEqual
dtstr = '1925-11-21T13:01:41'
dt = parse(dtstr)
assertEqual(dt, datetime.datetime(1925, 11, 21, 13, 1, 41))
settings = current.deployment_settings
date_format = settings.get_L10n_date_format()
time_format = sett... |
'Test S3Calendar.format_date'
| def testDateFormatting(self):
| c = S3Calendar()
render = c.format_date
assertEqual = self.assertEqual
assertRaises = self.assertRaises
dt = datetime.date(1925, 11, 21)
dtstr = render(dt)
assertEqual(dtstr, '1925-11-21')
settings = current.deployment_settings
date_format = settings.get_L10n_date_format()
try:
... |
'Test S3Calendar.format_datetime'
| def testDateTimeFormatting(self):
| c = S3Calendar()
render = c.format_datetime
assertEqual = self.assertEqual
assertRaises = self.assertRaises
dt = datetime.datetime(1925, 11, 21, 13, 1, 41)
dtstr = render(dt)
assertEqual(dtstr, '1925-11-21T13:01:41')
settings = current.deployment_settings
date_format = settings.get_L... |
'Tests for Gregorian Date to/from Julian Day conversion'
| def testGregorianJDConversion(self):
| test_dates = ((1973, 4, 21, 2441793.5), (1345, 5, 13, 2212443.5), (2017, 11, 8, 2458065.5))
c = S3Calendar()
gregorian_to_jd = c._gregorian_to_jd
jd_to_gregorian = c._jd_to_gregorian
assertEqual = self.assertEqual
for (year, month, day, jd) in test_dates:
assertEqual(gregorian_to_jd(year... |
'Test conversion of Solar Hijri date to JD and Gregorian date
(low-level routines)'
| def testJDConversion(self):
| test_dates = self.test_dates
assertEqual = self.assertEqual
c = S3Calendar('Persian')
gregorian_to_jd = c._gregorian_to_jd
jd_to_gregorian = c._jd_to_gregorian
from_jd = c.calendar.from_jd
to_jd = c.calendar.to_jd
for (gdate, jd, cdate) in test_dates:
jd_ = gregorian_to_jd(gdate[... |
'Test direct conversion between Solar Hijri and Gregorian
timetuples (cdate/gdate)'
| def testCalendarDate(self):
| test_dates = self.test_dates
assertEqual = self.assertEqual
c = S3Calendar('Persian')
to_gregorian = c.calendar._gdate
from_gregorian = c.calendar._cdate
for (gdate, jd, cdate) in test_dates:
timetuple = (cdate[0], cdate[1], cdate[2], 8, 0, 0)
gdate_ = to_gregorian(timetuple)
... |
'Test S3Calendar.parse_date'
| def testDateParsing(self):
| c = S3Calendar('Persian')
parse = c.parse_date
assertEqual = self.assertEqual
dtstr = '1304-08-30'
dt = parse(dtstr)
assertEqual(dt, datetime.date(1925, 11, 21))
settings = current.deployment_settings
date_format = settings.get_L10n_date_format()
try:
settings.L10n.date_forma... |
'Test S3Calendar.parse_datetime'
| def testDateTimeParsing(self):
| c = S3Calendar('Persian')
parse = c.parse_datetime
assertEqual = self.assertEqual
dtstr = '1304-08-30T13:01:41'
dt = parse(dtstr)
assertEqual(dt, datetime.datetime(1925, 11, 21, 13, 1, 41))
settings = current.deployment_settings
date_format = settings.get_L10n_date_format()
time_form... |
'Test S3Calendar.format_date'
| def testDateFormatting(self):
| c = S3Calendar('Persian')
render = c.format_date
assertEqual = self.assertEqual
assertRaises = self.assertRaises
dt = datetime.date(1925, 11, 21)
dtstr = render(dt)
assertEqual(dtstr, '1304-08-30')
settings = current.deployment_settings
date_format = settings.get_L10n_date_format()
... |
'Test S3Calendar.format_datetime'
| def testDateTimeFormatting(self):
| c = S3Calendar('Persian')
render = c.format_datetime
assertEqual = self.assertEqual
assertRaises = self.assertRaises
dt = datetime.datetime(1925, 11, 21, 13, 1, 41)
dtstr = render(dt)
assertEqual(dtstr, '1304-08-30T13:01:41')
settings = current.deployment_settings
date_format = setti... |
'Test conversion of Bikram Samvat date to JD and Gregorian date
(low-level routines)'
| def testJDConversion(self):
| test_dates = self.test_dates
assertEqual = self.assertEqual
c = S3Calendar('Nepali')
gregorian_to_jd = c._gregorian_to_jd
jd_to_gregorian = c._jd_to_gregorian
from_jd = c.calendar.from_jd
to_jd = c.calendar.to_jd
for (gdate, jd, cdate) in test_dates:
jd_ = gregorian_to_jd(gdate[0... |
'Test direct conversion between Bikram Samvat and Gregorian
timetuples (cdate/gdate)'
| def testCalendarDate(self):
| test_dates = self.test_dates
assertEqual = self.assertEqual
c = S3Calendar('Nepali')
to_gregorian = c.calendar._gdate
from_gregorian = c.calendar._cdate
for (gdate, jd, cdate) in test_dates:
timetuple = (cdate[0], cdate[1], cdate[2], 8, 0, 0)
gdate_ = to_gregorian(timetuple)
... |
'Test S3Calendar.parse_date'
| def testDateParsing(self):
| c = S3Calendar('Nepali')
parse = c.parse_date
assertEqual = self.assertEqual
dtstr = '1982-08-06'
dt = parse(dtstr)
assertEqual(dt, datetime.date(1925, 11, 21))
settings = current.deployment_settings
date_format = settings.get_L10n_date_format()
try:
settings.L10n.date_format... |
'Test S3Calendar.parse_datetime'
| def testDateTimeParsing(self):
| c = S3Calendar('Nepali')
parse = c.parse_datetime
assertEqual = self.assertEqual
dtstr = '1982-08-06T13:01:41'
dt = parse(dtstr)
assertEqual(dt, datetime.datetime(1925, 11, 21, 13, 1, 41))
settings = current.deployment_settings
date_format = settings.get_L10n_date_format()
time_forma... |
'Test S3Calendar.format_date'
| def testDateFormatting(self):
| c = S3Calendar('Nepali')
render = c.format_date
assertEqual = self.assertEqual
assertRaises = self.assertRaises
dt = datetime.date(1925, 11, 21)
dtstr = render(dt)
assertEqual(dtstr, '1982-08-06')
settings = current.deployment_settings
date_format = settings.get_L10n_date_format()
... |
'Test S3Calendar.format_datetime'
| def testDateTimeFormatting(self):
| c = S3Calendar('Nepali')
render = c.format_datetime
assertEqual = self.assertEqual
assertRaises = self.assertRaises
dt = datetime.datetime(1925, 11, 21, 13, 1, 41)
dtstr = render(dt)
assertEqual(dtstr, '1982-08-06T13:01:41')
settings = current.deployment_settings
date_format = settin... |
'Test parser construction'
| def testConstruction(self):
| assertRaises = self.assertRaises
c = S3Calendar()
dtfmt = '%Y-%m-%d'
with assertRaises(TypeError):
parser = S3DateTimeParser()
with assertRaises(TypeError):
parser = S3DateTimeParser(c)
with assertRaises(TypeError):
parser = S3DateTimeParser(None, dtfmt)
with assertRa... |
'Test date parsing'
| def testDateParsing(self):
| assertEqual = self.assertEqual
assertRaises = self.assertRaises
now = current.request.utcnow
test_dates = (('%Y-%m-%d', '2009-04-16', (2009, 4, 16, 0, 0, 0)), ('%d.%m.%Y', '1.8.1936', (1936, 8, 1, 0, 0, 0)), ('%d/%m/%y', None, 'TypeError'), ('%d/%m/%y', '16.04.1678', 'ValueError'), ('%d/%m/%Y', '31/04/1... |
'Test date+time parsing'
| def testDateTimeParsing(self):
| assertEqual = self.assertEqual
assertRaises = self.assertRaises
now = current.request.utcnow
test_dates = (('%Y-%m-%d %H:%M:%S', '2009-04-16 13:54:20', (2009, 4, 16, 13, 54, 20)), ('%d.%m.%Y %H:%M', '1.8.1936 15:38', (1936, 8, 1, 15, 38, 0)), ('%d/%m/%Y %H:%M', None, 'TypeError'), ('%d/%m... |
'Test date parsing'
| def testDateParsingPersian(self):
| assertEqual = self.assertEqual
assertRaises = self.assertRaises
now = current.request.utcnow
today = (now.year, now.month, now.day, 0, 0, 0)
c = S3Calendar('Persian')
(cyear, cmonth, cday) = c.calendar._cdate(today)[:3]
test_dates = (('%Y-%m-%d', '1352-02-01', (1352, 2, 1, 0, 0, 0)), ('%d.%m... |
'Test date+time parsing'
| def testDateTimeParsingPersian(self):
| assertEqual = self.assertEqual
assertRaises = self.assertRaises
now = current.request.utcnow
today = (now.year, now.month, now.day, 0, 0, 0)
c = S3Calendar('Persian')
(cyear, cmonth, cday) = c.calendar._cdate(today)[:3]
test_dates = (('%Y-%m-%d %H:%M:%S', '1352-2-1 17:34:20', (1352, 2,... |
'Test filter widget constructor'
| def testInit(self):
| widget = S3FilterWidget(['name', 'organisation_id$name'], option='test option', _class='test-class')
self.assertTrue(('option' in widget.opts))
self.assertTrue(len(widget.opts), 1)
self.assertTrue((widget.opts['option'] == 'test option'))
self.assertTrue(('_class' in widget.attr))
self.ass... |
'Test rendering of the hidden data element'
| def testRender(self):
| widget = S3FilterWidget(['name', 'organisation_id$name'])
widget.widget = (lambda resource, values: '')
resource = current.s3db.resource('org_office')
output = widget(resource, get_vars={})
self.assertTrue(isinstance(output[0], INPUT))
attr = output[0].attributes
t = attr['_type']
self.a... |
'Test construction of the URL query selector for a filter widget'
| def testSelector(self):
| fields = 'name'
s3db = current.s3db
widget = S3FilterWidget()
resource = s3db.resource('org_organisation')
(label, selector) = widget._selector(resource, fields)
self.assertEqual(selector, '~.name')
widget.alias = 'organisation'
(label, selector) = widget._selector(resource, fields)
... |
'Test construction of the URL variable for filter widgets'
| def testVariable(self):
| variable = S3FilterWidget._variable('organisation.name', 'like')
self.assertEqual(variable, 'organisation.name__like')
variable = S3FilterWidget._variable('organisation.name', None)
self.assertEqual(variable, 'organisation.name')
variable = S3FilterWidget._variable('organisation.name', '')
self.... |
'Test extraction of filter widget values from GET vars'
| def testValues(self):
| get_vars = {'test_1': '1', 'test_2': ['1,2', '3']}
values = S3FilterWidget._values(get_vars, 'test_1')
self.assertEqual(len(values), 1)
self.assertTrue(('1' in values))
values = S3FilterWidget._values(get_vars, 'test_2')
self.assertEqual(len(values), 3)
self.assertTrue(('1' in values))
s... |
'Test successful main table validation'
| def testValidateMainTable(self):
| request = self.request
crud = self.resource.crud
jsonstr = '{"name":"TestOrganisation", "acronym":"TO"}'
request.body = StringIO(jsonstr)
output = crud.validate(request)
self.assertTrue(isinstance(output, basestring))
data = json.loads(output)
self.assertTrue(isinstance(data, dict))
... |
'Test error in main table validation'
| def testValidateMainTableError(self):
| request = self.request
crud = self.resource.crud
jsonstr = '{"name":"", "acronym":"TO"}'
request.body = StringIO(jsonstr)
output = crud.validate(request)
self.assertTrue(isinstance(output, basestring))
data = json.loads(output)
self.assertTrue(isinstance(data, dict))
self.assertEq... |
'Test successful component validation'
| def testValidateComponentTable(self):
| request = self.request
crud = self.resource.crud
jsonstr = '{"name":"TestOffice"}'
request.body = StringIO(jsonstr)
request.get_vars['component'] = 'office'
output = crud.validate(request)
self.assertTrue(isinstance(output, basestring))
data = json.loads(output)
self.assertTrue(isins... |
'Test error in component validation'
| def testValidateComponentTableFailure(self):
| request = self.request
crud = self.resource.crud
jsonstr = '{"name":"", "acronym":"test"}'
request.body = StringIO(jsonstr)
request.get_vars['component'] = 'office'
output = crud.validate(request)
self.assertTrue(isinstance(output, basestring))
data = json.loads(output)
self.asser... |
'Check that values get converted into the field type during validation'
| def testTypeConversionFeature(self):
| s3db = current.s3db
resource = s3db.resource('project_organisation')
request = Storage(prefix='project', name='organisation', resource=resource, table=resource.table, tablename=resource.tablename, method='validate', get_vars=Storage(), representation='json', http='GET')
crud = resource.crud
jsonstr ... |
'Test date conversion'
| def testDate(self):
| assertEqual = self.assertEqual
settings = current.deployment_settings
session = current.session
convert = S3TypeConverter._date
settings.L10n.date_format = '%d.%m.%Y'
result = convert('2011-10-01')
assertEqual(result, datetime.date(2011, 10, 1))
result = convert('01.10.2011')
assertE... |
'Test date/time conversion'
| def testDateTime(self):
| assertEqual = self.assertEqual
settings = current.deployment_settings
session = current.session
convert = S3TypeConverter._datetime
settings.L10n.date_format = '%d.%m.%Y'
settings.L10n.time_format = '%H.%M'
result = convert('2011-10-01T16:37:00')
assertEqual(result, datetime.datetime(201... |
'Test has_foreign_key'
| def testHasForeignKey(self):
| ptable = current.s3db.pr_person
self.assertFalse(s3_has_foreign_key(ptable.first_name))
self.assertTrue(s3_has_foreign_key(ptable.pe_id))
htable = current.s3db.hrm_human_resource
self.assertFalse(s3_has_foreign_key(htable.start_date))
self.assertTrue(s3_has_foreign_key(htable.person_id))
|
'Test S3GroupedItems behavior without grouping axis'
| def testNoGrouping(self):
| assertEqual = self.assertEqual
items = [{'name': 'Item1', 'type': 'A'}, {'name': 'Item2', 'type': 'C'}, {'name': 'Item3', 'type': 'D'}, {'name': 'Item4', 'type': 'B'}, {'name': 'Item5', 'type': 'A'}, {'name': 'Item6', 'type': 'D'}, {'name': 'Item7', 'type': 'E'}]
gi = S3GroupedItems(items)
assertEqual(l... |
'Verify that S3GroupedItems accepts single axis-parameter,
and retains the original order of groups'
| def testSingleAxisGrouping(self):
| assertEqual = self.assertEqual
assertTrue = self.assertTrue
assertIn = self.assertIn
items = [{'name': 'Item1', 'type': 'A'}, {'name': 'Item2', 'type': ['C', 'D']}, {'name': 'Item3', 'type': 'D'}, {'name': 'Item4', 'type': 'B'}, {'name': 'Item5', 'type': 'A'}, {'name': 'Item6', 'type': 'D'}, {'name': 'I... |
'Verify S3GroupedItems behavior for multiple grouping axes'
| def testMultiAxisGrouping(self):
| assertEqual = self.assertEqual
assertTrue = self.assertTrue
items = [{'name': 'Item1', 't1': 'A', 't2': '1', 't3': 'X'}, {'name': 'Item2', 't1': 'B', 't2': '2', 't3': 'Y'}, {'name': 'Item3', 't1': 'C', 't2': '3', 't3': 'X'}, {'name': 'Item4', 't1': 'A', 't2': '3', 't3': 'Z'}, {'name': 'Item5', 't1': 'C', 't... |
'Verify that raw values are preferred for grouping,
including fallbacks for missing raw data or invalid type'
| def testRawValuePrecedence(self):
| assertEqual = self.assertEqual
items = [{'name': 'Item1', 'type': 'A', '_row': {'name': 'Item1', 'type': 'X'}}, {'name': 'Item2', 'type': 'C', '_row': {'name': 'Item2', 'type': 'Y'}}, {'name': 'Item3', 'type': 'D', '_row': {'name': 'Item3', 'type': 'Z'}}, {'name': 'Item4', 'type': 'B', '_row': 'test'}, {'name':... |
'Test get_values method'
| def testGetValues(self):
| assertIn = self.assertIn
items = [{'name': 'Item1'}, {'name': 'Item2'}, {'name': 'Item3'}, {'name': 'Item4'}, {'name': 'Item5'}, {'name': 'Item6'}, {'name': 'Item7'}]
gi = S3GroupedItems(items)
values = gi.get_values('name')
for item in items:
assertIn(item['name'], values)
|
'Test aggregation'
| def testAggregate(self):
| assertIn = self.assertIn
assertEqual = self.assertEqual
items = [{'name': 'Item1', 'type': 'A', 'value': 2.6}, {'name': 'Item2', 'type': 'C', 'value': 4.9}, {'name': 'Item3', 'type': 'D', 'value': 7.2}, {'name': 'Item4', 'type': 'B', 'value': 1.5}, {'name': 'Item5', 'type': 'A', 'value': 9.4}, {'name': 'Ite... |
'Test aggregation during construction'
| def testConstructionWithAggregate(self):
| assertIn = self.assertIn
assertEqual = self.assertEqual
items = [{'name': 'Item1', 'type': 'A', 'value': 2.6}, {'name': 'Item2', 'type': 'C', 'value': 4.9}, {'name': 'Item3', 'type': 'D', 'value': 7.2}, {'name': 'Item4', 'type': 'B', 'value': 1.5}, {'name': 'Item5', 'type': 'A', 'value': 9.4}, {'name': 'Ite... |
'Test aggregation method \'count\''
| def testCount(self):
| assertEqual = self.assertEqual
values = ['A', 'B', 'B', 'C']
aggregate = S3GroupAggregate('count', 'Example', values)
assertEqual(aggregate.result, 3)
values = None
aggregate = S3GroupAggregate('count', 'Example', values)
assertEqual(aggregate.result, None)
values = 17
aggregate = S3... |
'Test aggregation method \'sum\''
| def testSum(self):
| assertEqual = self.assertEqual
values = [2, 1.7, 3, 1]
aggregate = S3GroupAggregate('sum', 'Example', values)
assertEqual(aggregate.result, 7.7)
values = []
aggregate = S3GroupAggregate('sum', 'Example', values)
assertEqual(aggregate.result, 0.0)
values = ['1', 'other']
aggregate = S... |
'Test aggregation method \'min\''
| def testMin(self):
| assertEqual = self.assertEqual
values = [2, 1.7, 3, 1]
aggregate = S3GroupAggregate('min', 'Example', values)
assertEqual(aggregate.result, 1)
values = None
aggregate = S3GroupAggregate('min', 'Example', values)
assertEqual(aggregate.result, None)
values = 45
aggregate = S3GroupAggre... |
'Test aggregation method \'max\''
| def testMax(self):
| assertEqual = self.assertEqual
values = [2, 1.7, 3, 1]
aggregate = S3GroupAggregate('max', 'Example', values)
assertEqual(aggregate.result, 3)
values = None
aggregate = S3GroupAggregate('max', 'Example', values)
assertEqual(aggregate.result, None)
values = (lambda : None)
aggregate =... |
'Test aggregation method \'avg\''
| def testAvg(self):
| assertEqual = self.assertEqual
values = [2, 1.7, 3, 1]
aggregate = S3GroupAggregate('avg', 'Example', values)
assertEqual(aggregate.result, 1.925)
values = None
aggregate = S3GroupAggregate('avg', 'Example', values)
assertEqual(aggregate.result, None)
values = ['1', 'other']
aggregat... |
'Test aggregation of aggregates'
| def testAggregate(self):
| assertTrue = self.assertTrue
assertEqual = self.assertEqual
assertRaises = self.assertRaises
values1 = [2, 4, 6, 12]
ga1 = S3GroupAggregate('avg', 'Example', values1)
assertEqual(ga1.result, 6.0)
values2 = [5, 3, 9, 8]
ga2 = S3GroupAggregate('avg', 'Example', values2)
assertEqual(ga2... |
'Test organisation-dependent accessibility of fields'
| def testSetOrgDependentFields(self):
| auth = current.auth
s3db = current.s3db
settings = current.deployment_settings
table = current.s3db.pr_person_details
s = settings.org.get('dependent_fields', None)
settings.org.dependent_fields = {'pr_person_details.mother_name': ['Example Root Org']}
auth.s3_impersonate('admin@exampl... |
'An agent command implemented by the widget'
| @delegated
def command(agent, context):
| config = agent.config
return {'param': ('%s,%s' % (config.get('param'), context.get('param')))}
|
'Some other internal method of the widget'
| def not_delegated():
| raise RuntimeError
|
'Verify execution of delegated widget method'
| def testDelegation(self):
| widget = self.widget
agent = widget.create_agent('agent', config={'param': 'live'})
context = {'param': 'test'}
output = agent.do('command', context)
self.assertIn('param', output)
self.assertEqual(output['param'], 'live,test')
|
'Verify execution of delegated widget method with multiple agents'
| def testDelegationMultipleAgents(self):
| assertIn = self.assertIn
assertEqual = self.assertEqual
num_agents = 4
widget = self.widget
create_agent = widget.create_agent
agents = []
append = agents.append
for i in xrange(num_agents):
agent = create_agent(('agent%s' % i), config={'param': ('live%s' % i)})
append(ag... |
'Verify error handling for delegated widget methods'
| def testInvalidDelegation(self):
| widget = self.widget
agent = widget.create_agent('agent')
with self.assertRaises(NotImplementedError):
agent.do('nonexistent', {})
with self.assertRaises(NotImplementedError):
agent.do('not_delegated', {})
|
'Verify that no URL args give no context command'
| def testWithoutCommand(self):
| request = current.request
request.args = []
context = S3DashboardContext()
self.assertEqual(context.command, None)
|
'Verify that first URL arg gives context command'
| def testWithCommand(self):
| request = current.request
assertEqual = self.assertEqual
request.args = ['test']
context = S3DashboardContext()
assertEqual(context.command, 'test')
request.args = ['skip', 'other']
context = S3DashboardContext()
assertEqual(context.command, 'skip')
|
'Verify that format extension is ignored for command'
| def testCommandWithFormatExtension(self):
| request = current.request
assertEqual = self.assertEqual
request.args = ['test.xml']
context = S3DashboardContext()
assertEqual(context.command, 'test')
|
'Verify there is no default agent'
| def testNoAgent(self):
| request = current.request
assertEqual = self.assertEqual
request._get_vars = Storage()
context = S3DashboardContext()
assertEqual(context.agent, None)
assertEqual(context.bulk, False)
|
'Verify single agent ID is recognized'
| def testSingleAgent(self):
| request = current.request
assertEqual = self.assertEqual
request._get_vars = Storage({'agent': 'widget-1'})
context = S3DashboardContext()
assertEqual(context.agent, 'widget-1')
assertEqual(context.bulk, False)
|
'Verify single agent ID can still be bulk'
| def testSingleAgentBulk(self):
| request = current.request
assertEqual = self.assertEqual
request._get_vars = Storage({'agent': 'widget-1,'})
context = S3DashboardContext()
assertEqual(context.agent, ['widget-1'])
assertEqual(context.bulk, True)
request._get_vars = Storage({'agent': 'widget-1', 'bulk': '1'})
context = S... |
'Verify multiple agent IDs are recognized'
| def testMultiAgent(self):
| request = current.request
assertEqual = self.assertEqual
assertTrue = self.assertTrue
assertIn = self.assertIn
agent_ids = ('widget-1', 'widget-2', 'widget-3')
request._get_vars = Storage({'agent': 'widget-1,widget-2,widget-3'})
context = S3DashboardContext()
assertTrue((type(context.age... |
'Verify S3DashboardContext.http matches request method'
| def testHTTP(self):
| request = current.request
assertEqual = self.assertEqual
for method in ('GET', 'POST', 'DELETE'):
request.env.request_method = method
context = S3DashboardContext()
assertEqual(context.http, method)
|
'Verify S3DashboardContext.http defaults to GET'
| def testHTTPDefault(self):
| current.request.env.request_method = None
context = S3DashboardContext()
self.assertEqual(context.http, 'GET')
|
'Verify S3DashboardContext recognizes URL format extension'
| def testFormatExtension(self):
| request = current.request
request._get_vars = Storage()
assertEqual = self.assertEqual
request.extension = 'json'
request.args = ['command', '1']
context = S3DashboardContext()
assertEqual(context.representation, 'json')
request.extension = 'json'
request.args = ['command.xml', '1']
... |
'Verify S3DashboardContext recognizes URL format query'
| def testFormatQuery(self):
| request = current.request
request.extension = 'html'
request.args = ['command.json']
assertEqual = self.assertEqual
request._get_vars = Storage()
context = S3DashboardContext()
assertEqual(context.representation, 'json')
request._get_vars = Storage({'format': 'xml'})
context = S3Dash... |
'Verify S3DashboardContext falls back to html format'
| def testFormatDefault(self):
| request = current.request
request.extension = None
request.args = []
request._get_vars = Storage()
context = S3DashboardContext()
self.assertEqual(context.representation, 'html')
|
'Verify item pattern to write shared context dict'
| def testSharedWrite(self):
| context = S3DashboardContext()
context['test'] = 'ABC'
self.assertTrue(('test' in context.shared))
self.assertEqual(context.shared['test'], 'ABC')
|
'Verify item pattern to read shared context dict'
| def testSharedRead(self):
| context = S3DashboardContext()
context.shared['test'] = 'XYZ'
self.assertEqual(context['test'], 'XYZ')
with self.assertRaises(KeyError):
context['nonexistent']
|
'Verify get() method to read shared context dict'
| def testSharedGet(self):
| assertEqual = self.assertEqual
context = S3DashboardContext()
context.shared['test'] = 'XYZ'
assertEqual(context.get('test'), 'XYZ')
assertEqual(context.get('nonexistent'), None)
default = (lambda : None)
self.assertTrue((context.get('nonexistent', default) is default))
|
'Verify deletion of shared context items'
| def testSharedDelete(self):
| context = S3DashboardContext()
context.shared['test'] = 'XYZ'
del context['test']
self.assertNotIn('test', context.shared)
with self.assertRaises(KeyError):
del context['test']
|
'Verify attribute access falls back to current request'
| def testAttributeFallback(self):
| request = current.request
assertIn = self.assertIn
assertNotIn = self.assertNotIn
assertTrue = self.assertTrue
fallback = request.args
override = ['override']
context = S3DashboardContext(request)
assertNotIn('args', context.__dict__)
assertTrue((context.args is fallback))
contex... |
'Test delete_super without constraints'
| def testDeleteSuper(self):
| s3db = current.s3db
master_table = s3db.setest_master
record = master_table[self.master_id]
se_id = record.se_id
success = s3db.delete_super(master_table, record)
self.assertTrue(success)
record = master_table[self.master_id]
self.assertEqual(record.se_id, None)
super_table = s3db.se... |
'Test delete_super with CASCADE constraint'
| def testDeleteSuperCascade(self):
| s3db = current.s3db
master_table = s3db.setest_master
record = master_table[self.master_id]
se_id = record.se_id
component_table = s3db.setest_component_cascade
component_id = component_table.insert(se_id=se_id)
component_record = component_table[component_id]
self.assertNotEqual(compone... |
'Test delete_super with SET NULL constraint'
| def testDeleteSuperSetNull(self):
| s3db = current.s3db
master_table = s3db.setest_master
record = master_table[self.master_id]
se_id = record.se_id
component_table = s3db.setest_component_setnull
component_id = component_table.insert(se_id=se_id)
component_record = component_table[component_id]
self.assertNotEqual(compone... |
'Test delete_super with RESTRICT constraint'
| def testDeleteSuperRestrict(self):
| s3db = current.s3db
master_table = s3db.setest_master
record = master_table[self.master_id]
se_id = record.se_id
component_table = s3db.setest_component_restrict
component_id = component_table.insert(se_id=se_id)
component_record = component_table[component_id]
self.assertNotEqual(compon... |
'Test attempted instantiation of nonexistent dynamic table'
| def testDynamicTableInstantiationFailure(self):
| with self.assertRaises(AttributeError):
current.s3db.s3dt_nonexistent
with self.assertRaises(AttributeError):
current.s3db['s3dt_nonexistent']
table = current.s3db.table('s3dt_nonexistent')
self.assertEqual(table, None)
|
'Test instantiation of dynamic tables with S3Model'
| def testDynamicTableInstantiation(self):
| assertEqual = self.assertEqual
assertNotEqual = self.assertNotEqual
assertIn = self.assertIn
assertTrue = self.assertTrue
s3db = current.s3db
table = s3db.table(self.TABLENAME)
assertNotEqual(table, None)
assertTrue((self.TABLENAME in current.db))
fields = table.fields
assertIn('... |
'Test construction of string field'
| def testStringFieldConstruction(self):
| assertEqual = self.assertEqual
assertTrue = self.assertTrue
assertFalse = self.assertFalse
dm = S3DynamicModel(self.TABLENAME)
define_field = dm._field
params = Storage(name='name', field_type='string')
field = define_field(self.TABLENAME, params)
assertEqual(field.name, 'name')
asse... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.