Esempio n. 1
0
    def test_update_task(self):

        print('test_update')

        model.insert_task(self.task_object_test)

        new_name = 'Hito 3 CC'
        new_max_date = '2018-12-30'

        new_data = {
            'user': self.user,
            'name': new_name,
            'description': self.description,
            'estimation': self.estimation,
            'difficulty': self.difficulty,
            'max_date': new_max_date
        }

        self.assertTrue(model.exist(self.task_id))

        model.update_task(self.task_id, new_data)

        self.assertEqual(model.get_name(self.task_id), new_name)

        self.assertEqual(model.get_max_date(self.task_id), new_max_date)

        model.delete_task(self.task_object_test.task_id)

        self.assertFalse(model.exist(self.task_id))
Esempio n. 2
0
    def test_delete_task(self):

        print('test_delete')

        model.insert_task(self.task_object_test)

        self.assertTrue(model.exist(self.task_id))

        model.delete_task(self.task_id)

        self.assertFalse(model.exist(self.task_id))
Esempio n. 3
0
    def test_4_UPDATE_service(self):

        print('test_UPDATE_service')

        # Definimos la cabecera utilizando el token de acceso
        headers = {
            'content-type': 'application/json',
            'access-token': TestTaskService.token
        }

        #Insertamos al tarea
        model.insert_task(self.task_object_test)

        #Comprobamos que se haya creado dicha tarea
        self.assertTrue(model.exist(self.task_id))

        #Creamos los nuevos datos para asociar a esa tarea

        new_name = "Update task"
        new_estimation = 10
        new_max_date = "2018-12-30"

        post_data = json.dumps({
            "task_id": self.task_id,
            "user": self.user,
            "name": new_name,
            "description": self.description,
            "estimation": new_estimation,
            "difficulty": self.difficulty,
            "max_date": new_max_date
        })

        #Petición POST al servidor
        req = self.app.post('/task', data=post_data, headers=headers)

        #Comprobamos el estado de la respuesta
        self.assertEqual(req.status_code, 200)

        #Comprobamos el tipo de contenido que devuelve la petición GET
        self.assertEqual(req.headers['content-type'], 'application/json')

        #Comprobamos los nuevos datos de dicha tarea
        self.assertEqual(model.get_name(self.task_id), new_name)

        self.assertEqual(model.get_estimation(self.task_id), new_estimation)

        self.assertEqual(model.get_max_date(self.task_id), new_max_date)

        #Eliminamos la tarea de prueba
        model.delete_task(self.task_id)

        #Comprobamos que se ha eliminado la tarea de prueba
        self.assertFalse(model.exist(self.task_id))
Esempio n. 4
0
    def test_3_GET_service(self):

        print('test_GET_service')

        #Petición GET no válida al servidor
        req = self.app.get('/rutaNoValida')

        #Comprobamos el estado de la respuesta
        self.assertEqual(req.status_code, 404)

        #Insertamos la tarea
        model.insert_task(self.task_object_test)

        #Comprobamos que se haya creado dicha tarea
        self.assertTrue(model.exist(self.task_id))

        # Definimos la cabecera utilizando el token de acceso
        headers = {
            'content-type': 'application/json',
            'access-token': TestTaskService.token
        }

        #Petición GET al servidor
        req = self.app.get('/task', headers=headers)
        output = req.data.decode('utf8')
        list = json.loads(output)

        #Comprobamos el estado de la respuesta
        self.assertEqual(req.status_code, 200)

        #Comprobamos el tipo de contenido que devuelve la petición GET
        self.assertEqual(req.headers['content-type'], 'application/json')

        tasks = []

        for x in list['result']:
            result = eval(x)
            tasks.append(result['user'])

        #Comprobamos que el usuario de test está en la lista devuelta por GET
        self.assertTrue(self.user in tasks)

        #Eliminamos la tarea de prueba
        model.delete_task(self.task_id)

        #Comprobamos que se ha eliminado la tarea de prueba
        self.assertFalse(model.exist(self.task_id))
Esempio n. 5
0
    def test_getters(self):

        print('test_getters')

        model.insert_task(self.task_object_test)

        self.assertTrue(model.exist(self.task_id))

        self.assertEqual(model.get_user(self.task_id), self.user)

        self.assertEqual(model.get_name(self.task_id), self.name)

        self.assertEqual(model.get_description(self.task_id), self.description)

        self.assertEqual(model.get_estimation(self.task_id), self.estimation)

        self.assertEqual(model.get_difficulty(self.task_id), self.difficulty)

        self.assertEqual(model.get_max_date(self.task_id), self.max_date)

        model.delete_task(self.task_id)

        self.assertFalse(model.exist(self.task_id))
Esempio n. 6
0
    def test_2_PUT_DELETE_service(self):

        print('test_PUT_DELETE_service')

        # Definimos la cabecera utilizando el token de acceso
        headers = {
            'content-type': 'application/json',
            'access-token': TestTaskService.token
        }

        #Petición PUT al servidor
        req = self.app.put('/task', data=self.put_data, headers=headers)

        print(req.data)
        #Comprobamos el estado de la respuesta
        self.assertEqual(req.status_code, 201)

        output = req.data.decode('utf8')
        result = json.loads(output)

        #Comprobamos que al salida sea insertado
        self.assertTrue(result['result'] == 'inserted')

        #Comprobamos que se haya insertado dicha tarea
        self.assertTrue(model.exist(result['id']))

        #Petición DELETE al servidor para eliminar la tarea

        req = self.app.delete('/task',
                              headers=headers,
                              data=json.dumps({"task_id": result['id']}))

        #Comprobamos el estado de la respuesta
        self.assertEqual(req.status_code, 204)

        #Comprobamos que la tarea se ha eliminado.
        self.assertFalse(model.exist(result['id']))
def manage_task(current_user):
    if request.method == 'GET':
        data_list = model.get_all_tasks()
        return jsonify({'result': data_list})

    elif request.method == 'PUT':
        object_task = Task(request.json['user'], request.json['name'],
                           request.json['description'],
                           request.json['estimation'],
                           request.json['difficulty'],
                           request.json['max_date'])

        if (model.insert_task(object_task)):
            return jsonify({
                'result': 'inserted',
                'id': object_task.task_id
            }), 201
        else:
            return jsonify({'result': 'Error, not inserted'}), 400

    elif request.method == 'DELETE':
        delete_task_id = request.json['task_id']

        if (model.delete_task(delete_task_id)):
            return jsonify({'result': 'deleted'}), 204
        else:
            return jsonify({'result': 'Error, not deleted'}), 204

    elif request.method == 'POST':
        if model.exist(request.json['task_id']):
            new_data = {
                "task_id": request.json['task_id'],
                "user": request.json['user'],
                "name": request.json['name'],
                "description": request.json['description'],
                "estimation": request.json['estimation'],
                "difficulty": request.json['difficulty'],
                "max_date": request.json['max_date']
            }

            model.update_task(request.json['task_id'], new_data)

            return jsonify({'status': "updated", 'result': new_data}), 200

        else:
            return jsonify({'result': 'no content'}), 204