def test_parsing_tricky_list_of_names(self):
"""Ensure we always get a list."""
tests = [
(('', ''), ([], [])),
(('Hermione Granger', 'Peter Parker'), (['Hermione Granger'],
['Peter Parker'])),
(('Harry,Ron', 'Hermione,Ginny'), (['Harry,Ron'],
['Hermione,Ginny'])),
(('Harry| Ron', 'Hermione |Ginny'), (['Harry', 'Ron'],
['Hermione', 'Ginny'])),
]
expected = {
'slug': '',
'language': '',
'start': None,
'end': None,
'country': '',
'venue': '',
'address': '',
'latitude': None,
'longitude': None,
'reg_key': None,
'instructors': [],
'helpers': [],
'contact': [],
}
for (instructor, helper), (instructors, helpers) in tests:
with self.subTest(people=(instructor, helper)):
metadata = dict(instructor=instructor, helper=helper)
expected['instructors'] = instructors
expected['helpers'] = helpers
self.assertEqual(expected, parse_workshop_metadata(metadata))
def test_parsing_tricky_latitude_longitude(self):
tests = [
('XYZ', (None, None)),
('XYZ, ', (None, None)),
(',-123', (None, -123.0)),
(',', (None, None)),
(None, (None, None)),
]
expected = {
'slug': '',
'language': '',
'start': None,
'end': None,
'country': '',
'venue': '',
'address': '',
'latitude': None,
'longitude': None,
'reg_key': None,
'instructors': [],
'helpers': [],
'contact': [],
}
for latlng, (latitude, longitude) in tests:
with self.subTest(latlng=latlng):
metadata = dict(latlng=latlng)
expected['latitude'] = latitude
expected['longitude'] = longitude
self.assertEqual(expected, parse_workshop_metadata(metadata))
def test_parsing_tricky_country_language(self):
"""Ensure we always get a 2-char string or nothing."""
tests = [
(('Usa', 'English'), ('US', 'EN')),
(('U', 'E'), ('', '')),
(('', ''), ('', '')),
]
expected = {
'slug': '',
'language': '',
'start': None,
'end': None,
'country': '',
'venue': '',
'address': '',
'latitude': None,
'longitude': None,
'reg_key': None,
'instructors': [],
'helpers': [],
'contact': [],
}
for (country, language), (country_exp, language_exp) in tests:
with self.subTest(iso_31661=(country, language)):
metadata = dict(country=country, language=language)
expected['country'] = country_exp
expected['language'] = language_exp
self.assertEqual(expected, parse_workshop_metadata(metadata))
def test_parsing_tricky_dates(self):
"""Test if non-dates don't get parsed."""
tests = [
(('wrong start date', 'wrong end date'), (None, None)),
(('11/19/2015', '11/19/2015'), (None, None)),
]
expected = {
'slug': '',
'language': '',
'start': None,
'end': None,
'country': '',
'venue': '',
'address': '',
'latitude': None,
'longitude': None,
'reg_key': None,
'instructors': [],
'helpers': [],
'contact': [],
}
for (startdate, enddate), (start, end) in tests:
with self.subTest(dates=(startdate, enddate)):
metadata = dict(startdate=startdate, enddate=enddate)
expected['start'] = start
expected['end'] = end
self.assertEqual(expected, parse_workshop_metadata(metadata))
def test_parsing_tricky_country_language(self):
"""Ensure we always get a 2-char string or nothing."""
tests = [
(("Usa", "English"), ("US", "EN")),
(("U", "E"), ("", "")),
(("", ""), ("", "")),
]
expected = {
"slug": "",
"language": "",
"start": None,
"end": None,
"country": "",
"venue": "",
"address": "",
"latitude": None,
"longitude": None,
"reg_key": None,
"instructors": [],
"helpers": [],
"contact": [],
}
for (country, language), (country_exp, language_exp) in tests:
with self.subTest(iso_31661=(country, language)):
metadata = dict(country=country, language=language)
expected["country"] = country_exp
expected["language"] = language_exp
self.assertEqual(expected, parse_workshop_metadata(metadata))
def test_parsing_new_latlng(self):
metadata = {
"slug": "2015-07-13-test",
"startdate": "2015-07-13",
"enddate": "2015-07-14",
"country": "us",
"venue": "Euphoric State University",
"address": "Highway to Heaven 42, Academipolis",
"lat": "36.998977",
"lng": "-109.045173",
"language": "us",
"instructor": "Hermione Granger|Ron Weasley",
"helper": "Peter Parker|Tony Stark|Natasha Romanova",
"contact": "[email protected]|[email protected]",
"eventbrite": "10000000",
}
expected = {
"slug": "2015-07-13-test",
"language": "US",
"start": datetime.date(2015, 7, 13),
"end": datetime.date(2015, 7, 14),
"country": "US",
"venue": "Euphoric State University",
"address": "Highway to Heaven 42, Academipolis",
"latitude": 36.998977,
"longitude": -109.045173,
"reg_key": 10000000,
"instructors": ["Hermione Granger", "Ron Weasley"],
"helpers": ["Peter Parker", "Tony Stark", "Natasha Romanova"],
"contact": ["*****@*****.**", "*****@*****.**"],
}
self.assertEqual(expected, parse_workshop_metadata(metadata))
def test_no_attribute_error_missing_instructors_helpers(self):
"""Regression test: ensure no exception is raised when instructors
or helpers aren't in the metadata or their values are None."""
tests = [
((None, None), ([], [])),
((None, ''), ([], [])),
(('', None), ([], [])),
]
expected = {
'slug': '',
'language': '',
'start': None,
'end': None,
'country': '',
'venue': '',
'address': '',
'latitude': None,
'longitude': None,
'reg_key': None,
'instructors': [],
'helpers': [],
'contact': [],
}
for (instructor, helper), (instructors, helpers) in tests:
with self.subTest(people=(instructor, helper)):
metadata = dict(instructor=instructor, helper=helper)
expected['instructors'] = instructors
expected['helpers'] = helpers
self.assertEqual(expected, parse_workshop_metadata(metadata))
def test_parsing_tricky_eventbrite_id(self):
tests = [
("", None),
("string", None),
(None, None),
]
expected = {
"slug": "",
"language": "",
"start": None,
"end": None,
"country": "",
"venue": "",
"address": "",
"latitude": None,
"longitude": None,
"reg_key": None,
"instructors": [],
"helpers": [],
"contact": [],
}
for eventbrite_id, reg_key in tests:
with self.subTest(eventbrite_id=eventbrite_id):
metadata = dict(eventbrite=eventbrite_id)
expected["reg_key"] = reg_key
self.assertEqual(expected, parse_workshop_metadata(metadata))
def test_no_attribute_error_missing_instructors_helpers(self):
"""Regression test: ensure no exception is raised when instructors
or helpers aren't in the metadata or their values are None."""
tests = [
((None, None), ([], [])),
((None, ""), ([], [])),
(("", None), ([], [])),
]
expected = {
"slug": "",
"language": "",
"start": None,
"end": None,
"country": "",
"venue": "",
"address": "",
"latitude": None,
"longitude": None,
"reg_key": None,
"instructors": [],
"helpers": [],
"contact": [],
}
for (instructor, helper), (instructors, helpers) in tests:
with self.subTest(people=(instructor, helper)):
metadata = dict(instructor=instructor, helper=helper)
expected["instructors"] = instructors
expected["helpers"] = helpers
self.assertEqual(expected, parse_workshop_metadata(metadata))
def test_parsing_tricky_latitude_longitude(self):
tests = [
("XYZ", (None, None)),
("XYZ, ", (None, None)),
(",-123", (None, -123.0)),
(",", (None, None)),
(None, (None, None)),
]
expected = {
"slug": "",
"language": "",
"start": None,
"end": None,
"country": "",
"venue": "",
"address": "",
"latitude": None,
"longitude": None,
"reg_key": None,
"instructors": [],
"helpers": [],
"contact": [],
}
for latlng, (latitude, longitude) in tests:
with self.subTest(latlng=latlng):
metadata = dict(latlng=latlng)
expected["latitude"] = latitude
expected["longitude"] = longitude
self.assertEqual(expected, parse_workshop_metadata(metadata))
def test_parsing_new_latlng(self):
metadata = {
'slug': '2015-07-13-test',
'startdate': '2015-07-13',
'enddate': '2015-07-14',
'country': 'us',
'venue': 'Euphoric State University',
'address': 'Highway to Heaven 42, Academipolis',
'lat': '36.998977',
'lng': '-109.045173',
'language': 'us',
'instructor': 'Hermione Granger|Ron Weasley',
'helper': 'Peter Parker|Tony Stark|Natasha Romanova',
'contact': '[email protected]|[email protected]',
'eventbrite': '10000000',
}
expected = {
'slug': '2015-07-13-test',
'language': 'US',
'start': datetime.date(2015, 7, 13),
'end': datetime.date(2015, 7, 14),
'country': 'US',
'venue': 'Euphoric State University',
'address': 'Highway to Heaven 42, Academipolis',
'latitude': 36.998977,
'longitude': -109.045173,
'reg_key': 10000000,
'instructors': ['Hermione Granger', 'Ron Weasley'],
'helpers': ['Peter Parker', 'Tony Stark', 'Natasha Romanova'],
'contact': ['*****@*****.**', '*****@*****.**'],
}
self.assertEqual(expected, parse_workshop_metadata(metadata))
def test_parsing_tricky_dates(self):
"""Test if non-dates don't get parsed."""
tests = [
(("wrong start date", "wrong end date"), (None, None)),
(("11/19/2015", "11/19/2015"), (None, None)),
]
expected = {
"slug": "",
"language": "",
"start": None,
"end": None,
"country": "",
"venue": "",
"address": "",
"latitude": None,
"longitude": None,
"reg_key": None,
"instructors": [],
"helpers": [],
"contact": [],
}
for (startdate, enddate), (start, end) in tests:
with self.subTest(dates=(startdate, enddate)):
metadata = dict(startdate=startdate, enddate=enddate)
expected["start"] = start
expected["end"] = end
self.assertEqual(expected, parse_workshop_metadata(metadata))
def test_parsing_tricky_eventbrite_id(self):
tests = [
('', None),
('string', None),
(None, None),
]
expected = {
'slug': '',
'language': '',
'start': None,
'end': None,
'country': '',
'venue': '',
'address': '',
'latitude': None,
'longitude': None,
'reg_key': None,
'instructors': [],
'helpers': [],
'contact': [],
}
for eventbrite_id, reg_key in tests:
with self.subTest(eventbrite_id=eventbrite_id):
metadata = dict(eventbrite=eventbrite_id)
expected['reg_key'] = reg_key
self.assertEqual(expected, parse_workshop_metadata(metadata))
def get_form_kwargs(self):
"""Extend form kwargs with `initial` values.
The initial values are read from SelfOrganisedSubmission request
object, and from corresponding workshop page (if it's possible)."""
kwargs = super().get_form_kwargs()
# no matter what, don't show "lessons" field; previously they were shown
# when mix&match was selected
kwargs["show_lessons"] = False
url = self.other_object.workshop_url.strip()
data = {
"url": url,
"host": self.other_object.host_organization()
or self.other_object.institution,
"administrator": Organization.objects.get(domain="self-organized"),
}
try:
metadata = fetch_workshop_metadata(url)
parsed_data = parse_workshop_metadata(metadata)
except (AttributeError, HTTPError, RequestException, WrongWorkshopURL):
# ignore errors, but show warning instead
messages.warning(
self.request,
"Cannot automatically fill the form "
"from provided workshop URL.",
)
else:
# keep working only if no exception occurred
try:
lang = parsed_data["language"].lower()
parsed_data["language"] = Language.objects.get(subtag=lang)
except (KeyError, ValueError, Language.DoesNotExist):
# ignore non-existing
messages.warning(self.request,
"Cannot automatically fill language.")
# it's easier to remove bad value than to leave
# 500 Server Error when the form is rendered
if "language" in parsed_data:
del parsed_data["language"]
data.update(parsed_data)
if "instructors" in data or "helpers" in data:
instructors = data.get("instructors") or ["none"]
helpers = data.get("helpers") or ["none"]
data["comment"] = (f"Instructors: {','.join(instructors)}\n\n"
f"Helpers: {','.join(helpers)}")
initial = super().get_initial()
initial.update(data)
kwargs["initial"] = initial
return kwargs
def test_parsing_empty_metadata(self):
empty_dict = {}
expected = {
'slug': '',
'language': '',
'start': None,
'end': None,
'country': '',
'venue': '',
'address': '',
'latitude': None,
'longitude': None,
'reg_key': None,
'instructors': [],
'helpers': [],
'contact': [],
}
self.assertEqual(expected, parse_workshop_metadata(empty_dict))
def test_parsing_empty_metadata(self):
empty_dict = {}
expected = {
"slug": "",
"language": "",
"start": None,
"end": None,
"country": "",
"venue": "",
"address": "",
"latitude": None,
"longitude": None,
"reg_key": None,
"instructors": [],
"helpers": [],
"contact": [],
}
self.assertEqual(expected, parse_workshop_metadata(empty_dict))
def test_parsing_tricky_list_of_names(self):
"""Ensure we always get a list."""
tests = [
(("", ""), ([], [])),
(
("Hermione Granger", "Peter Parker"),
(["Hermione Granger"], ["Peter Parker"]),
),
(("Harry,Ron", "Hermione,Ginny"), (["Harry,Ron"],
["Hermione,Ginny"])),
(
("Harry| Ron", "Hermione |Ginny"),
(["Harry", "Ron"], ["Hermione", "Ginny"]),
),
]
expected = {
"slug": "",
"language": "",
"start": None,
"end": None,
"country": "",
"venue": "",
"address": "",
"latitude": None,
"longitude": None,
"reg_key": None,
"instructors": [],
"helpers": [],
"contact": [],
}
for (instructor, helper), (instructors, helpers) in tests:
with self.subTest(people=(instructor, helper)):
metadata = dict(instructor=instructor, helper=helper)
expected["instructors"] = instructors
expected["helpers"] = helpers
self.assertEqual(expected, parse_workshop_metadata(metadata))
def empty_metadata(self):
"""Prepare basic, empty metadata."""
return parse_workshop_metadata({})
def get_event_metadata(self, event_url):
"""Get metadata from event (location, instructors, helpers, etc.)."""
metadata = fetch_workshop_metadata(event_url)
# normalize the metadata
metadata = parse_workshop_metadata(metadata)
return metadata
