def test_foma_access_Shell(self):
foma_shell = None
try:
foma_shell = foma_access(self.path_to_model)
except NullFomaTransducerException as e:
logger.info("Failed to initialize foma-access", exc_info=True)
fin = open(self.testFile, 'r')
c = -1
for line in fin:
c = c + 1
try:
down_string = line.strip()
logger.info("foma-shell: {0}: In: {1}".format(str(c), down_string))
res = foma_shell.down(down_string)
for r in res:
logger.info(" out: {0}".format(r))
logger.info("-")
except Exception as e:
logger.error("Error in TestBindingsFomaAccessPython: " + e)
fin.close()
def test_valid_pn_combo_or_400(self):
'''
Must not allow invalid pn combo.
I.e 1st, 2nd, 2nd + inclusive pros may not
co-occur.
'''
valid_args = [{
"root": self.purple_verb_tags[0],
'agent': combo[0],
"aff-option": self.non_perfective_options[0]['tag'],
"patient": combo[1]
} for combo in self.valid_pro_combinations]
invalid_args = [{
"root": self.purple_verb_tags[0],
'agent': combo[0],
"aff-option": self.non_perfective_options[0]['tag'],
"patient": combo[1]
} for combo in self.invalid_pro_combinations]
for arg in invalid_args:
with self.assertRaises(BadRequest):
tag = self.return_tag(arg)
logger.error(tag)
for arg in valid_args:
tag = self.return_tag(arg)[0]['fst']
self.assertTrue(self.valid_tag(tag))
def test_affix_slugs(self):
'''
All affix tags should be properly formed slugs
'''
for x in self.affix_data:
try:
self.assertTrue(x['tag'] == slugify(x['tag']))
except AssertionError:
logger.error("The tag " + x['tag'] + " does not equal its slugified version " + slugify(x['tag']) )
def test_verb_slugs(self):
'''
All tags should be properly formed slugs
'''
for v in self.verb_data:
try:
self.assertTrue(v['tag'] == slugify(v['tag']))
except AssertionError:
logger.error("The tag " + v['tag'] +
" does not equal its slugified version " +
slugify(v['tag']))
def test_remove_long_stress(self):
for pair in self.longstress:
old = pair[0]
expected = pair[1]
new = self.util_cmp.remove_long_stress(pair[1])
msg = "test_remove_long_stress: old: " + old + \
" new: " + new + " (expected: " + expected + ")"
logger.info(msg)
if (new != expected):
logger.error(msg)
self.fail(msg)
def test_compare_ignore_stress(self):
for triple in self.compare_allstress:
s1 = triple[0]
s2 = triple[1]
ifSameExp = triple[2]
ifSame = self.util_cmp.compare_ignore_stress(s1, s2)
msg = "test_compare_ignore_stress: s1: " + s1 + ", s2: " + s2 + ", ifSameExp: " + str(ifSameExp) + ", " \
"ifSame: " + str(ifSame)
if ifSame is ifSameExp:
logger.info(msg)
else:
logger.error(msg)
self.fail(msg)
def test_error_response_code_405_with_disallowed_methods(self):
'''
Ensure all disallowed methods return 405s
'''
for rt in self.routes_no_fst_no_args:
try:
r = requests.delete(self.host + rt)
self.assertEqual(r.status_code, 405)
logger.info("'DELETE' method on route " + self.host + rt + " returned " + str(r.status_code))
r = requests.put(self.host + rt)
self.assertEqual(r.status_code, 405)
logger.info("'PUT' method on route " + self.host + rt + " returned " + str(r.status_code))
r = requests.post(self.host + rt)
self.assertEqual(r.status_code, 405)
logger.info("'POST' method on route " + self.host + rt + " returned " + str(r.status_code))
except AssertionError:
logger.warning("Route " + self.host + rt + " returned " + str(r.status_code))
except:
logger.error("Couldn't connect. Is flask running?")
def test_routes_and_servers(self):
'''
All servers in spec should be reachable
'''
for host in self.servers:
logger.info("Testing with host %s", host)
for route in self.routes_with_args:
try:
r = requests.get(host + route,
headers=self.headers,
timeout=self.timeout)
t = r.elapsed.total_seconds()
try:
self.assertEqual(r.status_code, 200)
logger.info("Server at " + host + route +
" responded in " + str(t) +
" seconds, with a " + str(r.status_code) +
" status code.")
except:
logger.error("Server at " + host + route +
" responded in " + str(t) +
" seconds, with a " + str(r.status_code) +
" status code.")
except requests.exceptions.ReadTimeout:
logger.error("Server at " + host + route +
" timed out after " + str(self.timeout) +
" seconds.")
except requests.exceptions.ConnectTimeout:
logger.error("Server at " + host + route +
" could not connect and timed out after " +
str(self.timeout) + " seconds.")
def test_TransducerDirectly(self):
try:
self.transducer = FST.load(self.path_to_model)
except Exception as e:
logger.error("Could not initialize a Foma FST. path_to_model: {}".format(
self.path_to_model) + e)
fin = open(self.testFile, 'r')
c = -1
for line in fin:
c = c + 1
try:
down_string = line.strip()
logger.info("Direct: {0}: In: {1}".format(str(c), down_string))
res = self.transducer.apply_down(down_string)
for r in res:
logger.info(" out: {0}".format(r))
logger.info("-")
except Exception as e:
logger.error("Error in TestBindingDirect: " + e)
fin.close()
def test_wrong_theta_role(self):
'''
If agent combined with blue verb, or patient combined with red verb,
response should be a 400
'''
blue_params = {
'verb': self.all_blue_verb_tags[0],
'aff-option': 'defpast',
'agent': self.first_pers_tag
}
red_params = {
'verb': self.all_red_verb_tags[0],
'aff-option': 'defpast',
'patient': self.first_pers_tag
}
for host in self.servers:
try:
r_blue = requests.get(host + self.route,
params=blue_params,
headers=self.headers)
self.assertEqual(r_blue.status_code, 400)
logger.info("Request to " + r_blue.url + " returned " +
str(r_blue.status_code))
except Exception as e:
logger.error("Request to " + host + self.route +
f" returned {e}")
try:
r_red = requests.get(host + self.route,
params=red_params,
headers=self.headers)
self.assertEqual(r_red.status_code, 400)
logger.info("Request to " + r_red.url + " returned " +
str(r_red.status_code))
except Exception as e:
logger.error("Request to " + host + self.route +
f" returned {e}")
def test_response_code(self):
'''
Ensure all routes return 200
'''
for rt in self.routes_no_fst_no_args:
try:
r = requests.get(self.host + rt)
self.assertEqual(r.status_code, 200)
logger.info("Route " + self.host + rt + " returned " +
str(r.status_code))
except:
logger.error("Couldn't connect. Is flask running?")
for rt in self.routes_no_args:
try:
r = requests.get(self.host + rt)
self.assertEqual(r.status_code, 200)
logger.info("Route " + self.host + rt + " returned " +
str(r.status_code))
except AssertionError:
logger.error("Route " + self.host + rt + " returned " +
str(r.status_code) + ". Is the FST running?")
except:
logger.error("Couldn't connect. Is flask running?")
def test_error_response_code_404_with_non_existant_args(self):
'''
Ensure all non-existant args return 404
'''
for ep in self.routes_only_args:
if "/verb" in ep:
rt = re.sub(self.arg_match, self.non_existant_tag, ep)
try:
r = requests.get(self.host + rt)
self.assertEqual(r.status_code, 404)
logger.info("Non-existant arg on route " + self.host + rt + " returned " + str(r.status_code))
except AssertionError:
logger.error("Route " + self.host + rt + " returned " + str(r.status_code))
except:
logger.error("Couldn't connect. Is flask running?")
elif "/aff-option" in ep:
rt = re.sub(self.arg_match, self.non_existant_tag, ep)
try:
r = requests.get(self.host + rt)
self.assertEqual(r.status_code, 404)
logger.info("Non-existant arg on route " + self.host + rt + " returned " + str(r.status_code))
except AssertionError:
logger.error("Route " + self.host + rt + " returned " + str(r.status_code))
except:
logger.error("Couldn't connect. Is flask running?")
elif "/affix" in ep:
rt = re.sub(self.arg_match, self.non_existant_tag, ep)
try:
r = requests.get(self.host + rt)
self.assertEqual(r.status_code, 404)
logger.info("Non-existant arg on route " + self.host + rt + " returned " + str(r.status_code))
except AssertionError:
logger.error("Route " + self.host + rt + " returned " + str(r.status_code))
except:
logger.error("Couldn't connect. Is flask running?")
elif "/pronoun" in ep:
rt = re.sub(self.arg_match, self.non_existant_tag, ep)
try:
r = requests.get(self.host + rt)
self.assertEqual(r.status_code, 404)
logger.info("Non-existant arg on route " + self.host + rt + " returned " + str(r.status_code))
except AssertionError:
logger.error("Route " + self.host + rt + " returned " + str(r.status_code))
except:
logger.error("Couldn't connect. Is flask running?")
elif "/conjugations":
rt = re.sub(self.arg_match, self.non_existant_tag, ep)
try:
r = requests.get(self.host + rt)
self.assertEqual(r.status_code, 404)
logger.info("Non-existant arg on route " + self.host + rt + " returned " + str(r.status_code))
except AssertionError:
logger.error("Route " + self.host + rt + " returned " + str(r.status_code))
except:
logger.error("Couldn't connect. Is flask running?")
else:
logger.warning("Route " + self.host + ep + " was registered, but not tested.")
def test_response_code_with_args(self):
'''
Ensure all args return 200
'''
for ep in self.routes_only_args:
if "/verb" in ep:
for x in self.all_verb_tags:
rt = re.sub(self.arg_match, x, ep)
try:
r = requests.get(self.host + rt)
self.assertEqual(r.status_code, 200)
except AssertionError:
logger.error("Route " + self.host + rt + " returned " +
str(r.status_code) +
". Is the FST running?")
except:
logger.error("Couldn't connect. Is flask running?")
logger.info("Successfully tested " +
str(len(self.all_verb_tags)) +
" verb resources at route " + self.host + ep +
" .")
elif "/aff-option" in ep:
for x in self.all_affopt_tags:
rt = re.sub(self.arg_match, x, ep)
try:
r = requests.get(self.host + rt)
self.assertEqual(r.status_code, 200)
except AssertionError:
logger.error("Route " + self.host + rt + " returned " +
str(r.status_code) +
". Is the FST running?")
except:
logger.error("Couldn't connect. Is flask running?")
logger.info("Successfully tested " +
str(len(self.all_affopt_tags)) +
" affix option resources at route " + self.host +
ep + ".")
elif "/affix" in ep:
for x in self.all_affix_tags:
rt = re.sub(self.arg_match, x, ep)
try:
r = requests.get(self.host + rt)
self.assertEqual(r.status_code, 200)
except AssertionError:
logger.error("Route " + self.host + rt + " returned " +
str(r.status_code) +
". Is the FST running?")
except:
logger.error("Couldn't connect. Is flask running?")
logger.info("Successfully tested " +
str(len(self.all_affix_tags)) +
" affix resources at route " + self.host + ep +
".")
elif "/pronoun" in ep:
for x in self.all_pronoun_tags:
rt = re.sub(self.arg_match, x, ep)
try:
r = requests.get(self.host + rt)
self.assertEqual(r.status_code, 200)
except AssertionError:
logger.error("Route " + self.host + rt + " returned " +
str(r.status_code) +
". Is the FST running?")
except:
logger.error("Couldn't connect. Is flask running?")
logger.info("Successfully tested " +
str(len(self.all_pronoun_tags)) +
" pronoun resources at route " + self.host + ep +
".")
elif "/conjugations":
logger.debug("Passing conjugations args for other test")
pass
else:
logger.warning("Route " + ep +
" was registered, but not tested.")
import os
from importlib import import_module
from wordweaver.data import DEFAULT_LANG
from wordweaver.data import __file__ as DATAROOT
from wordweaver.log import logger
DATA_DIR = os.path.dirname(DATAROOT)
WWLANG = os.environ.get("WWLANG", DEFAULT_LANG)
if os.path.exists(os.path.join(DATA_DIR, WWLANG)):
module = import_module(f"wordweaver.data.{WWLANG}.models")
Option = module.Option
Pronoun = module.Pronoun
Verb = module.Verb
Response = module.Response
ResponseObject = module.ResponseObject
Tier = module.Tier
else:
logger.error(f"""Can't find '{WWLANG}', are you sure you 'WWLANG' is
defined in your environment?""")
