def make_cv_dset():
data = ot.data.cv_dset
data['name'] = 'cv_dset'
dset = Dataset(data=data, data_is_from_form=False)
dset.save()
mod['dset'] = dset
mod['data'] = data['candidates']
def test_duplicate_dset(self):
dset = Dataset(name='blank', user='******')
dset.save()
data = create_valid_empty_tableaux_data(self)
response = self.client.post(url_for('tools.calculator'), data=data)
self.assert_200(response)
self.assert_template_used('tableaux.html')
assert "name already exists" in response.data
def test_duplicate_name(self):
dset = Dataset(user=login_data['username'], name='blank-copy')
dset.save()
with self.client:
login(self.client)
response = self.client.get(self.url)
self.assert_redirects(response,
url_for('users.account',
username=login_data['username']))
def make_voweldset():
data = {
'constraints': ['c1', 'c2', 'c3', 'c4'],
'candidates': ot.data.voweldset,
'name': 'voweldset'
}
dset = Dataset(data=data, data_is_from_form=False)
dset.save()
mod['dset'] = dset
mod['data'] = data
def setUp(self):
self.bad_classical_values = set(['poop', 1, None])
self.good_classical_values = set([True, False])
self.bad_page_values = set([-1, None, "poop"])
self.good_page_values = set([0, 1])
self.bad_sort_by_values = set([0, "nope", None])
self.good_sort_by_values = set(["rank_volume", "size"])
dset = Dataset(user='******', name='blank')
dset.save()
def test_retry_and_not_finished(self):
dset = Dataset(name='blank', user='******')
dset.global_stats_calculated = False
dset.save()
response = self.client.get(url_for('grammars.global_stats_calculated',
dset_name='blank', sort_value=0,
sort_by='size', page=0,
classical=False))
data = json.loads(response.data)
self.assert_200(response)
assert data['retry']
assert not data['finished']
def test_logged_in_valid_post(self):
data = create_valid_empty_tableaux_data(self)
with self.client:
login(self.client)
response = self.client.post(url_for('tools.example_edit'),
data=data)
self.assert_status(response, 302)
assert "classical=False" in response.location
guest_dsets = Dataset.objects(user='******')
user_dsets = Dataset.objects(user=login_data['username'])
assert len(guest_dsets) == 2
assert len(user_dsets) == 1
def test_not_finished(self):
dset = Dataset(name='blank', username='******')
dset.grammar_stats_calculated = False
dset.save()
response = self.client.get(url_for(
'grammars.grammar_stats_calculated', dset_name='blank',
sort_value=0, page=0, classical=False, sort_by='rank_volume'
))
self.assert_200(response)
data = json.loads(response.data)
assert data['retry']
assert len(data) == 1
def test_duplicate_save_name(self):
# should keep getting strings until it finds a unique one
dset_name = "Kiparsky-tmp-0"
dset = Dataset(user=login_data['username'], name=dset_name)
dset.save()
data = create_valid_empty_tableaux_data(self)
data['name'] = "Kiparsky"
with self.client:
login(self.client)
response = self.client.post(url_for('tools.example_edit'),
data=data)
self.assert_status(response, 302)
assert "Kiparsky-tmp-1" in response.location
def test_logged_in(self):
with self.client:
login(self.client)
response = self.client.get(self.url)
self.assert_redirects(response, url_for('tools.edit',
dset_name='blank-copy'))
user_dsets = Dataset.objects(user=login_data['username'])
assert len(user_dsets) == 2
def _create_dset_for_editing(self):
self.dset = Dataset(data=self.form.data, data_is_from_form=True)
self.dset.remove_old_files()
self.dset.user = get_username()
self.dset.name = self._create_temporary_dset_name()
self.dset.id = None # to get a new id when saved
self.dset.classical = not self.is_submitting_to_all_grammars()
self.dset.save()
def test_valid_empty_dataset_gets_random_name(self):
data = create_valid_empty_tableaux_data(self)
data.pop("name")
response = self.client.post(url_for('tools.calculator'), data=data)
self.assert_status(response, 302)
dsets = Dataset.objects(user='******')
assert len(dsets) == 3
delete_bad_datasets()
def get(self, username):
if get_username() != username:
flash("Log in to view your account")
return redirect(url_for("users.login"))
else:
user = User.objects.get_or_404(username=username)
dsets = Dataset.objects(user=user.username)
return render_template("account.html", user=user, dsets=dsets)
def test_no_grammars_exist(self, mock_make_grammar_info):
dset = Dataset(name='blank', user='******')
dset.global_stats_calculated = True
dset.classical = False
dset.grammar_navbar['lengths'] = []
dset.global_stats = {
'grams': "[]",
'num_poots': 0,
'num_total_poots': 19,
'percent_poots': 0.0,
'num_cots': 0,
'num_total_cots': 6,
'percent_cots': 0.0
}
dset.save()
response = self.client.get(url_for(
'grammars.global_stats_calculated', dset_name='blank',
sort_value=0, classical=False, page=0, sort_by='size'
))
print(response.data)
self.assert_200(response)
data = json.loads(response.data)
assert not data['need_redirect']
assert data['finished']
assert not data['retry']
assert not data['grammars_exist']
assert not mock_make_grammar_info.called
def test_no_redirect_html_response(self, mock_make_grammar_info):
dset = Dataset(name='blank', user='******')
dset.global_stats_calculated = True
dset.classical = False
dset.grammar_navbar['lengths'] = [1, 3, 6]
dset.global_stats = {
'grams': "[frozenset([(1, 2)]), frozenset([2, 3])]",
'num_poots': 5,
'num_total_poots': 19,
'percent_poots': 5.0/19,
'num_cots': 2,
'num_total_cots': 6,
'percent_cots': 2.0/6
}
dset.save()
response = self.client.get(url_for(
'grammars.global_stats_calculated', dset_name='blank',
sort_value=6, classical=False, page=0, sort_by='size'
))
self.assert_200(response)
print response.data
data = json.loads(response.data)
assert not data['need_redirect']
assert data['finished']
assert not data['retry']
assert data['html_str']
assert data['grammar_stat_url']
mock_make_grammar_info.assert_called_with('blank')
class ExampleEditView(CalculatorView):
def get(self):
# TODO get example to render and edit without logging in
return redirect(url_for('.edit', dset_name="Kiparsky"))
@init_tableaux_form_on_self
@validates_tableaux_form
def post(self):
self._create_dset_for_editing()
self.prepare_to_change_dset_user()
return redirect(self._generate_redirect_url())
def _create_dset_for_editing(self):
self.dset = Dataset(data=self.form.data, data_is_from_form=True)
self.dset.remove_old_files()
self.dset.user = get_username()
self.dset.name = self._create_temporary_dset_name()
self.dset.id = None # to get a new id when saved
self.dset.classical = not self.is_submitting_to_all_grammars()
self.dset.save()
def _generate_redirect_url(self):
return url_for(
'grammars.grammars', dset_name=self.dset.name, sort_value=0,
page=0, classical=self.dset.classical, sort_by='rank_volume'
)
def _create_temporary_dset_name(self):
# keep trying strings until you get a unique one
temp_name = self._get_temp_name_attempt()
while Dataset.objects(name=temp_name, user=get_username()):
temp_name = self._get_temp_name_attempt()
return temp_name
def _get_temp_name_attempt(self):
return self.dset.name + '-tmp-' + self.make_unique_random_dset_name()
def get_redisplay_html(self):
return render_template(
'tableaux.html', form=self.form, active='calculator',
dset_name="Kiparsky", edit=True
)
class TestEntailment(OTOrderBaseCase):
def tearDown(self):
delete_bad_datasets()
def init_dset(self):
self.dset_name = 'blank'
self.dset = Dataset(name=self.dset_name, user='******')
self.dset.classical = False
self.dset.save()
@mock.patch('rankomatic.worker_jobs.calculate_entailments')
def test_get(self, mock_calculate_entailments):
self.init_dset()
response = self.client.get(url_for('grammars.entailments',
dset_name=self.dset_name))
self.assert_200(response)
assert "Entailments" in response.data
mock_calculate_entailments.assert_called_with(self.dset_name)
self.assert_template_used('entailments.html')
def test_finished(self):
classical = False
page = 0
sort_by = 'size'
sort_value = 1
dset_name = 'blank'
username = '******'
dset = Dataset(name=dset_name, user=username)
dset.grammar_navbar = {
'min_ind': 0,
'max_ind': 1,
'lengths': [1, 3, 6],
'num_rank_grams': 2
}
dset.grammar_stats_calculated = True
dset.grammar_info = structures.grammar_info
dset.save()
response = self.client.get(url_for(
'grammars.grammar_stats_calculated', classical=classical,
page=page, sort_value=sort_value, dset_name=dset_name,
sort_by=sort_by
))
self.assert_200(response)
data = json.loads(response.data)
assert not data['retry']
assert "(C1, C2)" in data['html_str']
assert len(data) == 2
self.assert_template_used('display_grammars.html')
def test_unlogged_in_valid_post(self):
data = create_valid_empty_tableaux_data(self)
with self.client:
response = self.client.post(url_for('tools.example_edit'),
data=data)
self.assert_status(response, 302)
guest_dsets = Dataset.objects(user='******')
assert len(guest_dsets) == 3
try:
session['redirect_url']
except KeyError:
assert False
else:
assert True
def post(self):
data = json.loads(request.data)
try:
data['apriori_ranking'] = json.dumps(data['apriori_ranking'])
except KeyError:
data['apriori_ranking'] = '[]'
dset = Dataset(data, data_is_from_form=True)
dset.user = get_username()
try:
old_dset = get_dset(dset.name)
old_dset.remove_old_files()
old_dset.delete()
except HTTPException:
pass
try:
dset.save()
except:
abort(422)
return 'successfully saved'
def test_successful_signup(self):
#import pdb; pdb.set_trace()
response = self.client.post(url_for('users.signup'),
data={'username': '******',
'password': '******',
'password_conf': 'password'})
self.assert_redirects(response, url_for('users.login'))
user = User.objects.get(username='******')
dsets = Dataset.objects(user=user.username)
assert user.username == 'jane'
assert user.is_password_valid('password')
assert len(dsets) == 2
for dset in dsets:
dset.delete()
user.delete()
def test_redirect_because_no_grams(self):
dset = Dataset(name='blank', user='******')
dset.global_stats_calculated = True
dset.classical = False
dset.grammar_navbar['lengths'] = [1, 3, 6]
dset.global_stats['grams'] = "[]"
dset.save()
response = self.client.get(url_for('grammars.global_stats_calculated',
dset_name='blank', sort_value=0,
classical=False, page=0,
sort_by='size'))
self.assert_200(response)
data = json.loads(response.data)
assert not data['finished']
assert not data['retry']
assert data['need_redirect']
assert "/6?" in data['redirect_url']
def _delete_old_version(self):
self.dset = Dataset(data=self.form.data, data_is_from_form=True)
old_dset = get_dset(self.dset_name)
self.dset.user = old_dset.user
old_dset.delete()
self.dset.remove_old_files()
def _create_temporary_dset_name(self):
# keep trying strings until you get a unique one
temp_name = self._get_temp_name_attempt()
while Dataset.objects(name=temp_name, user=get_username()):
temp_name = self._get_temp_name_attempt()
return temp_name
def setUp(self):
dset = Dataset(user='******', name='blank')
self.url = None
dset.save()
def delete_bad_datasets():
dsets = [d for d in Dataset.objects() if is_bad_dset(d)]
for dset in dsets:
dset.delete()
class CalculatorView(MethodView):
"""Displays the calculator form and its POST logic"""
def get(self):
return render_template('tableaux.html', form=TableauxForm(),
active='calculator', t_order=False)
@init_tableaux_form_on_self
@validates_tableaux_form
def post(self):
self._initialize_dset()
if self.dset_save_is_successful():
self.prepare_to_change_dset_user()
return self._successful_post_html()
else:
return self._unsuccessful_post_html()
def _unsuccessful_post_html(self):
self.form.errors['form'] = "A dataset with that name already exists"
return self.redisplay_form()
def _successful_post_html(self):
redirect_url = self._generate_redirect_url()
return redirect(redirect_url)
def prepare_to_change_dset_user(self):
if not is_logged_in():
redirect_url = url_for(".edit", dset_name=self.dset.name)
session['redirect_url'] = redirect_url
message = '<a href="/login/">Log in</a> to save this dataset'
flash(Markup(message))
session['save_new_user'] = True
def _generate_redirect_url(self):
if self.is_submitting_to_all_grammars():
return self._get_all_grammar_url()
elif self.is_submitting_to_entailments():
return self._get_entailment_url()
else:
return self._get_classical_grammar_url()
def is_submitting_to_all_grammars(self):
return self.submit == "All grammars"
def _get_all_grammar_url(self):
return url_for(
'grammars.grammars', dset_name=urllib.quote(self.dset.name),
sort_value=0, page=0, classical=False, sort_by='rank_volume'
)
def is_submitting_to_entailments(self):
return self.submit == "Entailments"
def _get_entailment_url(self):
return url_for(
'grammars.entailments', dset_name=urllib.quote(self.dset.name)
)
def _get_classical_grammar_url(self):
return url_for(
'grammars.grammars', dset_name=self.dset.name, sort_value=0,
page=0, classical=True, sort_by='rank_volume'
)
def get_redisplay_html(self):
return render_template(
'tableaux.html', form=self.form, active='calculator'
)
def _initialize_dset(self):
self.dset = Dataset(
data=self.form.data, data_is_from_form=True, user=get_username()
)
if not self.dset.name:
self.dset.name = self.make_unique_random_dset_name()
def make_unique_random_dset_name(self):
# keep trying until you get something not in the database
random_name = self._random_name_attempt()
while Dataset.objects(name=random_name, user=get_username()):
random_name = self._random_name_attempt()
return random_name
def _random_name_attempt(self):
chars = string.digits + string.letters
namelist = [random.choice(chars) for i in xrange(10)]
return "".join(namelist)
def dset_save_is_successful(self):
try:
self.dset.save()
except MongoInsertError:
return False
return True
def redisplay_form(self):
for e in self.form.get_errors():
flash(e)
return self.get_redisplay_html()
def test_make_unique_random_dset_name(self):
dset = Dataset(user='******', name='0000000000')
dset.save()
with self.app.test_request_context():
name = CalculatorView().make_unique_random_dset_name()
assert name == "1111111111"
def make_entailment_dset(self, name, calculated, visualized):
dset = Dataset(name=name, user="******")
dset.entailments_calculated = calculated
dset.entailments_visualized = visualized
dset.save()
def init_dset(self):
self.dset_name = 'blank'
self.dset = Dataset(name=self.dset_name, user='******')
self.dset.classical = False
self.dset.save()
