def test_index_returns_definition_templates_for_word(self): index_url = '/definition_templates' word_id = self.word.get_id() query_string = {'word_id': word_id} response = self.get(index_url, query_string=query_string) self.assertEqual(200, response.status_code) definition_templates = json.loads(response.data) definition_templates_from_db = DefinitionTemplatesService.get_instance().get_list_by_word(word_id) all_definition_templates = DefinitionTemplatesService.get_instance().get_list() self.assertTrue(len(definition_templates) > 0) self.assertTrue(len(definition_templates) < len(all_definition_templates)) self.assertEqual(len(definition_templates_from_db), len(definition_templates))
def test_create_returns_created_status(self): create_url = '/definition_templates' word = self.definition_template.get_word() word_id = word.get_id() definition = self.definition_template.get_definition() filler_lexical_classes = self.definition_template.get_filler_lexical_classes() definition_template_data = { 'word_id': word_id, 'definition': definition, 'filler_lexical_classes': filler_lexical_classes } response = self.post(create_url, data=definition_template_data) self.assertEqual(201, response.status_code) definition_template = json.loads(response.data) self.assertIsNotNone(definition_template.get('id')) self.assertIsNotNone(definition_template.get('date_created')) self.assertIsNotNone(definition_template.get('date_modified')) self.assertEqual(word.serialized, definition_template.get('word')) self.assertEqual(definition, definition_template.get('definition')) self.assertEqual(filler_lexical_classes, definition_template.get('filler_lexical_classes')) self.assertEqual(True, definition_template.get('is_active')) # Make sure the definition_template was actually saved to the database saved_definition_template = DefinitionTemplatesService.get_instance().get(int(definition_template.get('id'))) self.assertEqual(saved_definition_template.get_id(), definition_template.get('id')) self.assertEqual(DefinitionTemplate.dump_datetime(saved_definition_template.get_date_created()), definition_template.get('date_created')) self.assertEqual(DefinitionTemplate.dump_datetime(saved_definition_template.get_date_modified()), definition_template.get('date_modified')) self.assertEqual(saved_definition_template.get_word().get_id(), definition_template.get('word').get('id')) self.assertEqual(saved_definition_template.get_definition(), definition_template.get('definition')) self.assertEqual(saved_definition_template.get_filler_lexical_classes(), definition_template.get('filler_lexical_classes')) self.assertEqual(saved_definition_template.get_is_active(), definition_template.get('is_active'))
def show(definition_template_id): """ Request: {} Response [422] (definition_template with definition_template_id doesn't exist): { "errors": { "DefinitionTemplateNotFound": [ "Unable to find DefinitionTemplate" ] }, "inputs": { "id": "definition_template_id" } } Response [200] (success): { "id": "current value", "date_created": "current value", "date_modified": "current value", "word": "current value", "definition": "current value", "filler_lexical_classes": "current value", "is_active": "current value" } """ # Get the definition_template definition_template = DefinitionTemplatesService.get_instance().get(definition_template_id) if definition_template: return render_view('definition_templates/show', 200, definition_template=definition_template.serialized) return render_view('422', 422, errors=NOT_FOUND_ERROR, inputs={'id': definition_template_id})
def test_index_returns_offset_definition_templates_for_word(self): index_url = '/definition_templates' word_id = self.word.get_id() definition_templates_from_db = DefinitionTemplatesService.get_instance().get_list_by_word(word_id) offset = int(len(definition_templates_from_db) / 2) query_string = {'word_id': word_id, 'offset': offset} response = self.get(index_url, query_string=query_string) self.assertEqual(200, response.status_code) definition_templates = json.loads(response.data) self.assertEqual(len(definition_templates_from_db) - offset, len(definition_templates))
def delete(definition_template_id): """ Request: {} Response [422] (definition_template with definition_template_id doesn't exist): { "errors": { "DefinitionTemplateNotFound": [ "Unable to find DefinitionTemplate" ] }, "inputs": { "id": "definition_template_id" } } Response [422] (save failure - unable to set definition_template as inactive): { "errors": { "IntegrityError": [ "Reason saving to the db failed" ] }, "inputs": { "id": "definition_template_id" } } Response [200] (success): { "id": "current value", "date_created": "current value", "date_modified": "current value", "word": "current value", "definition": "current value", "filler_lexical_classes": "current value", "is_active": "current value" } """ # Get the definition_template definition_template = DefinitionTemplatesService.get_instance().get(definition_template_id) # Verify the definition_template creation inputs if definition_template: try: definition_template.update(**{'is_active': False}) return render_view('definition_templates/show', 200, definition_template=definition_template.serialized) except Exception as e: return render_view( '422', 422, errors={e.__class__.__name__: [e.message]}, inputs={'id': definition_template_id} ) return render_view('422', 422, errors=NOT_FOUND_ERROR, inputs={'id': definition_template_id})
def test_update_creates_definition_template_and_inactivates_existing_definition_template(self): definition_template_id = self.definition_template.get_id() update_url = '/definition_templates/{}'.format(definition_template_id) self.assertEqual(True, self.definition_template.get_is_active()) word_id = self.definition_template.get_word().get_id() definition = self.definition_template.get_definition() filler_lexical_classes = self.definition_template.get_filler_lexical_classes() definition_template_data = { 'word_id': word_id, 'definition': definition } response = self.put(update_url, data=definition_template_data) self.assertEqual(200, response.status_code) definition_template = json.loads(response.data) self.assertIsNotNone(definition_template.get('id')) self.assertIsNotNone(definition_template.get('date_created')) self.assertIsNotNone(definition_template.get('date_modified')) self.assertEqual(word_id, definition_template.get('word').get('id')) self.assertEqual(definition, definition_template.get('definition')) self.assertEqual(filler_lexical_classes, definition_template.get('filler_lexical_classes')) self.assertNotEqual(definition_template_id, definition_template.get('id')) self.assertIsNotNone(definition_template.get('is_active')) # Make sure the definition_template was actually updated in the database saved_definition_template = DefinitionTemplatesService.get_instance().get(int(definition_template.get('id'))) self.assertEqual(saved_definition_template.get_id(), definition_template.get('id')) self.assertEqual(DefinitionTemplate.dump_datetime(saved_definition_template.get_date_created()), definition_template.get('date_created')) self.assertEqual(DefinitionTemplate.dump_datetime(saved_definition_template.get_date_modified()), definition_template.get('date_modified')) self.assertEqual(saved_definition_template.get_word().get_id(), definition_template.get('word').get('id')) self.assertEqual(saved_definition_template.get_definition(), definition_template.get('definition')) self.assertEqual(saved_definition_template.get_filler_lexical_classes(), definition_template.get('filler_lexical_classes')) self.assertEqual(saved_definition_template.get_is_active(), definition_template.get('is_active')) # Ensure old definition template was marked inactive old_definition_template = DefinitionTemplatesService.get_instance().get(definition_template_id) self.assertEqual(False, old_definition_template.get_is_active())
def test_delete_deletes_definition_template(self): delete_url = '/definition_templates/{}'.format(self.definition_template.get_id()) self.assertEqual(True, self.definition_template.get_is_active()) response = self.delete(delete_url) self.assertEqual(200, response.status_code) definition_template = json.loads(response.data) self.assertIsNotNone(definition_template.get('id')) self.assertIsNotNone(definition_template.get('date_created')) self.assertIsNotNone(definition_template.get('date_modified')) self.assertIsNotNone(definition_template.get('word')) self.assertIsNotNone(definition_template.get('definition')) self.assertIsNotNone(definition_template.get('filler_lexical_classes')) self.assertEqual(False, definition_template.get('is_active')) # Make sure the definition_template was actually updated in the database saved_definition_template = DefinitionTemplatesService.get_instance().get(int(definition_template.get('id'))) self.assertEqual(saved_definition_template.get_id(), definition_template.get('id')) self.assertEqual(DefinitionTemplate.dump_datetime(saved_definition_template.get_date_created()), definition_template.get('date_created')) self.assertEqual(DefinitionTemplate.dump_datetime(saved_definition_template.get_date_modified()), definition_template.get('date_modified')) self.assertEqual(saved_definition_template.get_word().get_id(), definition_template.get('word').get('id')) self.assertEqual(saved_definition_template.get_definition(), definition_template.get('definition')) self.assertEqual(saved_definition_template.get_filler_lexical_classes(), definition_template.get('filler_lexical_classes')) self.assertEqual(saved_definition_template.get_is_active(), definition_template.get('is_active'))
def update(definition_filler_id): """ Request: { "definition_template_id": "definition_template_id", "filler": "filler", "is_dictionary": "is_dictionary", "is_active": "is_active" } Response [422] (definition_filler with definition_filler_id doesn't exist): { "errors": { "DefinitionFillerNotFound": [ "Unable to find DefinitionFiller" ] }, "inputs": { "id": "definition_filler_id" } } Response [422] (invalid parameters): { "errors": { "name of parameter that failed validation": [ "Reason for validation failure" ], "name of another parameter that failed validation": [ "Reason for validation failure" ], }, "inputs": { "id": "definition_filler_id", "definition_template_id": "value passed in. empty string if missing", "filler": "value passed in. empty string if missing", "is_dictionary": "value passed in. empty string if missing", "is_active": "value passed in. empty string if missing" } } Response [422] (definition_template with definition_template_id doesn't exist): { "errors": { "DefinitionTemplateNotFound": [ "Unable to find the specified DefinitionTemplate" ] }, "inputs": { "id": "definition_filler_id", "definition_template_id": "value passed in. empty string if missing", "filler": "value passed in. empty string if missing", "is_dictionary": "value passed in. empty string if missing", "is_active": "value passed in. empty string if missing" } } Response [422] (save failure - invalid filler array length): { "errors": { "AttributeError": [ "There are {} filler but {} filler lexical classes. These values must be the same" ] }, "inputs": { "id": "definition_filler_id", "definition_template_id": "value passed in. empty string if missing", "filler": "value passed in. empty string if missing", "is_dictionary": "value passed in. empty string if missing", "is_active": "value passed in. empty string if missing" } } Response [422] (save failure): { "errors": { "IntegrityError": [ "Reason saving to the db failed" ] }, "inputs": { "id": "definition_filler_id", "definition_template_id": "value passed in. empty string if missing", "filler": "value passed in. empty string if missing", "is_dictionary": "value passed in. empty string if missing", "is_active": "value passed in. empty string if missing" } } Response [200] (success): { "id": "current value", "date_created": "current value", "date_modified": "current value", "definition_template": "current value", "filler": "current value", "is_dictionary": "current value", "is_active": "current value" } """ # Get the definition_filler definition_filler = DefinitionFillersService.get_instance().get(definition_filler_id) # Verify the definition_filler creation inputs if definition_filler: # Get the input validator inputs = UpdateInputs(get_inputs()) combined_inputs = dict(inputs.serialized().items() + {'id': definition_filler_id}.items()) # Hack to deal with WTForms requirement that list inputs be validated against a list of choices filler = get_mixed_dict_from_multidict(get_inputs()).get('filler', []) inputs.filler.choices = [(fill, fill) for fill in filler] if inputs.validate_on_submit(): # If we're only marking the filler as active or inactive, pass through to the update if inputs.is_active.data and \ not any([inputs.definition_template_id.data, inputs.filler.data, inputs.is_dictionary.data]): try: definition_filler.update(**get_mixed_dict_from_multidict(get_inputs(), inputs)) return render_view( 'definition_fillers/show', 200, definition_filler=definition_filler.serialized ) except Exception as e: return render_view('422', 422, errors={e.__class__.__name__: [e.message]}, inputs=combined_inputs) # If we're trying to change the filler, mark the old filler # as inactive and create a new one with the new parameters else: definition_filler.update(**{'is_active': False}) definition_template = DefinitionTemplatesService.get_instance().get( inputs.definition_template_id.data ) if inputs.definition_template_id.data else definition_filler.get_definition_template() filler = inputs.filler.data if inputs.filler.data else definition_filler.get_filler() is_dictionary = inputs.is_dictionary.data \ if inputs.is_dictionary.data else definition_filler.get_is_dictionary() is_active = inputs.is_active.data if inputs.is_active.data else definition_filler.get_is_active() if definition_template: try: definition_filler = DefinitionFiller(definition_template, filler, is_dictionary) definition_filler.set_is_active(is_active) definition_filler.save() return render_view( 'definition_fillers/show', 200, definition_filler=definition_filler.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=DEFINITION_TEMPLATE_NOT_FOUND_ERROR, inputs=inputs.serialized()) return render_view('422', 422, errors=inputs.errors, inputs=combined_inputs) return render_view('422', 422, errors=NOT_FOUND_ERROR, inputs={'id': definition_filler_id})
def create(): """ Request: { "definition_template_id": "definition_template_id", "filler": "filler", "is_dictionary": "is_dictionary" } Response [422] (invalid parameters): { "errors": { "name of parameter that failed validation": [ "Reason for validation failure" ], "name of another parameter that failed validation": [ "Reason for validation failure" ], }, "inputs": { "definition_template_id": "value passed in. empty string if missing", "filler": "value passed in. empty string if missing", "is_dictionary": "value passed in. empty string if missing" } } Response [422] (definition_template with definition_template_id doesn't exist): { "errors": { "DefinitionTemplateNotFound": [ "Unable to find the specified DefinitionTemplate" ] }, "inputs": { "definition_template_id": "value passed in. empty string if missing", "filler": "value passed in. empty string if missing", "is_dictionary": "value passed in. empty string if missing" } } Response [422] (save failure): { "errors": { "IntegrityError": [ "Reason saving to the db failed" ] }, "inputs": { "definition_template_id": "value passed in. empty string if missing", "filler": "value passed in. empty string if missing", "is_dictionary": "value passed in. empty string if missing" } } Response [422] (save failure - invalid filler array length): { "errors": { "AttributeError": [ "There are {} filler but {} filler lexical classes. These values must be the same" ] }, "inputs": { "definition_template_id": "value passed in. empty string if missing", "filler": "value passed in. empty string if missing", "is_dictionary": "value passed in. empty string if missing" } } Response [200] (success): { "id": "current value", "date_created": "current value", "date_modified": "current value", "definition_template": "current value", "filler": "current value", "is_dictionary": "current value", "is_active": "current value" } """ # Get the input validator inputs = CreateInputs(get_inputs()) # Hack to deal with WTForms requirement that list inputs be validated against a list of choices filler = get_mixed_dict_from_multidict(get_inputs()).get('filler', []) inputs.filler.choices = [(fill, fill) for fill in filler] # Verify the definition_filler creation inputs if inputs.validate_on_submit(): definition_template = DefinitionTemplatesService.get_instance().get(inputs.definition_template_id.data) if definition_template: try: definition_filler = DefinitionFiller(definition_template, inputs.filler.data, inputs.is_dictionary.data) definition_filler.save() return render_view('definition_fillers/show', 201, definition_filler=definition_filler.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=DEFINITION_TEMPLATE_NOT_FOUND_ERROR, inputs=inputs.serialized()) return render_view('422', 422, errors=inputs.errors, inputs=inputs.serialized())
def index(): """ Request: { "offset": "offset", "limit": "limit", "word_id": "word_id" } Response [422] (invalid parameters): { "errors": { "name of parameter that failed validation": [ "Reason for validation failure" ], "name of another parameter that failed validation": [ "Reason for validation failure" ], }, "inputs": { "offset": "value passed in. empty string if missing", "limit": "value passed in. empty string if missing", "word_id": "value passed in. empty string if missing" } } Response [200] (success): [ { "id": "current value", "date_created": "current value", "date_modified": "current value", "word": "current value", "definition": "current value", "filler_lexical_classes": "current value", "is_active": "current value" }, { "id": "current value", "date_created": "current value", "date_modified": "current value", "word": "current value", "definition": "current value", "filler_lexical_classes": "current value", "is_active": "current value" }, ... ] """ # Get the input validator inputs = ListInputs(get_inputs()) # Verify the list inputs if inputs.validate(): if inputs.word_id.data: definition_templates = DefinitionTemplatesService.get_instance().get_list_by_word( inputs.word_id.data, inputs.limit.data, inputs.offset.data ) else: definition_templates = DefinitionTemplatesService.get_instance().get_list( inputs.limit.data, inputs.offset.data ) return render_view( 'definition_templates/index', 200, definition_templates={ definition_template.get_id(): definition_template.serialized for definition_template in definition_templates } ) return render_view('422', 422, errors=inputs.errors, inputs=inputs.serialized())
def update(definition_template_id): """ Request: { "word_id": "word_id", "definition": "definition", "filler_lexical_classes": "filler_lexical_classes", "is_active": "is_active" } Response [422] (definition_template with definition_template_id doesn't exist): { "errors": { "DefinitionTemplateNotFound": [ "Unable to find DefinitionTemplate" ] }, "inputs": { "id": "definition_template_id" } } Response [422] (invalid parameters): { "errors": { "name of parameter that failed validation": [ "Reason for validation failure" ], "name of another parameter that failed validation": [ "Reason for validation failure" ], }, "inputs": { "id": "definition_template_id", "word_id": "value passed in. empty string if missing", "definition": "value passed in. empty string if missing", "filler_lexical_classes": "value passed in. empty string if missing", "is_active": "value passed in. empty string if missing" } } Response [422] (word with word_id doesn't exist): { "errors": { "WordNotFound": [ "Unable to find the specified Word" ] }, "inputs": { "id": "definition_template_id", "word_id": "value passed in. empty string if missing", "definition": "value passed in. empty string if missing", "filler_lexical_classes": "value passed in. empty string if missing", "is_active": "value passed in. empty string if missing" } } Response [422] (save failure - invalid filler_lexical_classes length): { "errors": { "AttributeError": [ "There are {} filler lexical classes but {} fillers. These values must be the same." ] }, "inputs": { "id": "definition_template_id", "word_id": "value passed in. empty string if missing", "definition": "value passed in. empty string if missing", "filler_lexical_classes": "value passed in. empty string if missing", "is_active": "value passed in. empty string if missing" } } Response [422] (save failure - invalid filler_lexical_classes value): { "errors": { "AttributeError": [ "Cannot set the filler lexical classes to a value other than one of: {}" ] }, "inputs": { "id": "definition_template_id", "word_id": "value passed in. empty string if missing", "definition": "value passed in. empty string if missing", "filler_lexical_classes": "value passed in. empty string if missing", "is_active": "value passed in. empty string if missing" } } Response [422] (save failure): { "errors": { "IntegrityError": [ "Reason saving to the db failed" ] }, "inputs": { "id": "definition_template_id", "word_id": "value passed in. empty string if missing", "definition": "value passed in. empty string if missing", "filler_lexical_classes": "value passed in. empty string if missing", "is_active": "value passed in. empty string if missing" } } Response [200] (success): { "id": "current value", "date_created": "current value", "date_modified": "current value", "word": "current value", "definition": "current value", "filler_lexical_classes": "current value", "is_active": "current value" } """ # Get the definition_template definition_template = DefinitionTemplatesService.get_instance().get(definition_template_id) # Verify the definition_template creation inputs if definition_template: # Get the input validator inputs = UpdateInputs(get_inputs()) combined_inputs = dict(inputs.serialized().items() + {'id': definition_template_id}.items()) if inputs.validate_on_submit(): # If we're only marking the definition as active or inactive, pass through to the update if inputs.is_active.data and \ not any([inputs.word_id.data, inputs.definition.data, inputs.filler_lexical_classes.data]): try: definition_template.update(**get_mixed_dict_from_multidict(get_inputs(), inputs)) return render_view( 'definition_templates/show', 200, definition_template=definition_template.serialized ) except Exception as e: return render_view('422', 422, errors={e.__class__.__name__: [e.message]}, inputs=combined_inputs) # Otherwise, if we're trying to change the definition, mark the old # definition as inactive and create a new one with the new parameters else: definition_template.update(**{'is_active': False}) word = WordsService.get_instance().get(inputs.word_id.data) \ if inputs.word_id.data else definition_template.get_word() definition = inputs.definition.data if inputs.definition.data else definition_template.get_definition() filler_lexical_classes = inputs.filler_lexical_classes.data \ if inputs.filler_lexical_classes.data else definition_template.get_filler_lexical_classes() is_active = inputs.is_active.data if inputs.is_active.data else definition_template.get_is_active() if word: try: definition_template = DefinitionTemplate(word, definition, filler_lexical_classes) definition_template.set_is_active(is_active) definition_template.save() return render_view( 'definition_templates/show', 200, definition_template=definition_template.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=WORD_NOT_FOUND_ERROR, inputs=inputs.serialized()) return render_view('422', 422, errors=inputs.errors, inputs=combined_inputs) return render_view('422', 422, errors=NOT_FOUND_ERROR, inputs={'id': definition_template_id})