Exemple #1
0
    def test_update_creates_word_and_inactivates_existing_word(self):
        word_id = self.word.get_id()
        update_url = '/words/{}'.format(word_id)
        self.assertEqual(True, self.word.get_is_active())
        lexeme_form = self.word.get_lexeme_form()
        lexical_class = Word.LEXICAL_CLASSES[0]
        word_data = {
            'lexeme_form': lexeme_form,
            'lexical_class': lexical_class
        }
        response = self.put(update_url, data=word_data)
        self.assertEqual(200, response.status_code)
        word = json.loads(response.data)
        self.assertIsNotNone(word.get('id'))
        self.assertIsNotNone(word.get('date_created'))
        self.assertIsNotNone(word.get('date_modified'))
        self.assertEqual(lexeme_form, word.get('lexeme_form'))
        self.assertEqual(lexical_class, word.get('lexical_class'))
        self.assertNotEqual(word_id, word.get('id'))
        self.assertIsNotNone(word.get('is_active'))

        # Make sure the word was actually updated in the database
        saved_word = WordsService.get_instance().get(int(word.get('id')))
        self.assertEqual(saved_word.get_id(), word.get('id'))
        self.assertEqual(Word.dump_datetime(saved_word.get_date_created()), word.get('date_created'))
        self.assertEqual(Word.dump_datetime(saved_word.get_date_modified()), word.get('date_modified'))
        self.assertEqual(saved_word.get_lexeme_form(), word.get('lexeme_form'))
        self.assertEqual(saved_word.get_lexical_class(), word.get('lexical_class'))
        self.assertEqual(saved_word.get_is_active(), word.get('is_active'))

        # Ensure old lexeme_form template was marked inactive
        old_word = WordsService.get_instance().get(word_id)
        self.assertEqual(False, old_word.get_is_active())
Exemple #2
0
    def test_create_returns_created_status(self):
        create_url = '/words'
        lexeme_form = 'foo'
        lexical_class = Word.LEXICAL_CLASSES[0]
        word_data = {
            'lexeme_form': lexeme_form,
            'lexical_class': lexical_class
        }
        response = self.post(create_url, data=word_data)
        self.assertEqual(201, response.status_code)
        word = json.loads(response.data)
        self.assertIsNotNone(word.get('id'))
        self.assertIsNotNone(word.get('date_created'))
        self.assertIsNotNone(word.get('date_modified'))
        self.assertEqual(lexeme_form, word.get('lexeme_form'))
        self.assertEqual(lexical_class, word.get('lexical_class'))
        self.assertEqual(True, word.get('is_active'))

        # Make sure the word was actually saved to the database
        saved_word = WordsService.get_instance().get(int(word.get('id')))
        self.assertEqual(saved_word.get_id(), word.get('id'))
        self.assertEqual(Word.dump_datetime(saved_word.get_date_created()), word.get('date_created'))
        self.assertEqual(Word.dump_datetime(saved_word.get_date_modified()), word.get('date_modified'))
        self.assertEqual(saved_word.get_lexeme_form(), word.get('lexeme_form'))
        self.assertEqual(saved_word.get_lexical_class(), word.get('lexical_class'))
        self.assertEqual(saved_word.get_is_active(), word.get('is_active'))
Exemple #3
0
def create():
    # Get the input validator
    inputs = CreateInputs(get_inputs())

    # Verify the word creation inputs
    if inputs.validate_on_submit():

        word = Word(inputs.lexeme_form.data, inputs.lexical_class.data)
        try:
            word.save()
            return render_view('words/show', 201, word=word.serialized)
        except Exception as e:
            return render_view('422', 422, errors={e.__class__.__name__: [e.message]}, inputs=inputs.serialized())

    return render_view('422', 422, errors=inputs.errors, inputs=inputs.serialized())
Exemple #4
0
def update(word_id):
    # Get the word
    word = WordsService.get_instance().get(word_id)

    # Verify the word creation inputs
    if word:

        # Get the input validator
        inputs = UpdateInputs(get_inputs())
        combined_inputs = dict(inputs.serialized().items() + {'id': word_id}.items())

        if inputs.validate_on_submit():
            # If we're only marking the word as active or inactive, pass through to the update
            if inputs.is_active.data and \
                    not any([inputs.lexeme_form.data, inputs.lexical_class.data]):
                try:
                    word.update(**get_mixed_dict_from_multidict(get_inputs(), inputs))
                    return render_view('words/show', 200, word=word.serialized)
                except Exception as e:
                    return render_view('422', 422, errors={e.__class__.__name__: [e.message]}, inputs=combined_inputs)

            else:
                word.update(**{'is_active': False})

                lexeme_form = inputs.lexeme_form.data if inputs.lexeme_form.data else word.get_lexeme_form()
                lexical_class = inputs.lexical_class.data if inputs.lexical_class.data else word.get_lexical_class()
                is_active = inputs.is_active.data if inputs.is_active.data else word.get_is_active()

                word = Word(lexeme_form, lexical_class)
                word.set_is_active(is_active)

                try:
                    word.save()
                    return render_view(
                        'words/show', 200, word=word.serialized
                    )
                except Exception as e:
                    return render_view('422', 422, errors={e.__class__.__name__: [e.message]}, inputs=combined_inputs)

        return render_view('422', 422, errors=inputs.errors, inputs=combined_inputs)

    return render_view('422', 422, errors=NOT_FOUND_ERROR, inputs={'id': word_id})
Exemple #5
0
    def test_delete_deletes_word(self):
        delete_url = '/words/{}'.format(self.word.get_id())
        self.assertEqual(True, self.word.get_is_active())
        response = self.delete(delete_url)
        self.assertEqual(200, response.status_code)
        word = json.loads(response.data)
        self.assertIsNotNone(word.get('id'))
        self.assertIsNotNone(word.get('date_created'))
        self.assertIsNotNone(word.get('date_modified'))
        self.assertIsNotNone(word.get('lexeme_form'))
        self.assertIsNotNone(word.get('lexical_class'))
        self.assertEqual(False, word.get('is_active'))

        # Make sure the word was actually updated in the database
        saved_word = WordsService.get_instance().get(int(word.get('id')))
        self.assertEqual(saved_word.get_id(), word.get('id'))
        self.assertEqual(Word.dump_datetime(saved_word.get_date_created()), word.get('date_created'))
        self.assertEqual(Word.dump_datetime(saved_word.get_date_modified()), word.get('date_modified'))
        self.assertEqual(saved_word.get_lexeme_form(), word.get('lexeme_form'))
        self.assertEqual(saved_word.get_lexical_class(), word.get('lexical_class'))
        self.assertEqual(saved_word.get_is_active(), word.get('is_active'))
Exemple #6
0
    def insert_dummy_data(self):
        word = None
        definition_template = None
        definition_filler = None
        for word_data in WORDS:
            word = Word(word_data.get('lexeme_form'), word_data.get('lexical_class'))
            word.save()
            self.NUM_WORDS += 1
            for template_data in word_data.get('definition_templates', []):
                definition_template = DefinitionTemplate(
                    word, template_data.get('definition'), template_data.get('filler_lexical_classes')
                )
                definition_template.save()
                self.NUM_DEFINITION_TEMPLATES += 1
                for filler_data in template_data.get('definition_fillers', []):
                    definition_filler = DefinitionFiller(
                        definition_template, filler_data.get('filler'), filler_data.get('is_dictionary')
                    )
                    definition_filler.save()
                    self.NUM_DEFINITION_FILLERS += 1

        self.word = word
        self.definition_template = definition_template
        self.definition_filler = definition_filler