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')
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 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_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_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 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 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 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_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_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_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']
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 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 setUp(self): dset = Dataset(user='******', name='test') dset.save()
class EditView(CalculatorView): @requires_login def get(self, dset_name): self.dset_name = dset_name if self._need_to_change_dset_user(): self._change_dset_user() return self._edit_get_html() def _need_to_change_dset_user(self): try: return session.pop('save_new_user') except KeyError: return False def _change_dset_user(self): dset = get_dset(self.dset_name) dset.user = get_username() dset.save() flash("Saved %s as %s!" % (dset.name, dset.user)) def _edit_get_html(self): return render_template('tableaux.html') @init_tableaux_form_on_self @validates_tableaux_form def post(self, dset_name): self.dset_name = dset_name if self._is_cancelling_edit(): return self._cancel_edit_html() else: return self._successful_edit_html() def _is_cancelling_edit(self): return self.submit == "Cancel editing" def _cancel_edit_html(self): flash("Canceled editing %s" % self.dset_name) return redirect(url_for("users.account", username=get_username())) def _successful_edit_html(self): self._delete_old_version() self._save_new_version() return self._generate_redirect() 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 _save_new_version(self): self.dset.classical = not self.is_submitting_to_all_grammars() self.dset.save() def _generate_redirect(self): if self.is_submitting_to_entailments(): redirect_url = url_for('grammars.entailments', dset_name=self.dset.name) else: redirect_url = url_for('grammars.grammars', dset_name=self.dset.name, sort_value=0, page=0, classical=self.dset.classical, sort_by='rank_volume') return redirect(redirect_url) def get_redisplay_html(self): return render_template( 'tableaux.html', form=self.form, active='calculator', t_order=False, dset_name=self.form.name, edit=True )
def setUp(self): dset = Dataset(user='******', name='blank') self.url = None dset.save()
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 add_dset(): dset = Dataset(name='blank', user='******') dset.save()
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 make_entailment_dset(self, name, calculated, visualized): dset = Dataset(name=name, user="******") dset.entailments_calculated = calculated dset.entailments_visualized = visualized dset.save()