Exemplo n.º 1
0
def main():
    test_utils.openConnection(False)  # Pruebas en local (remote = False)
    option = None
    session1 = None
    session2 = None
    session_error = "session=session_error"
    user_id1 = "id_test_usuario1"
    user_id2 = "id_test_usuario2"
    user_id_error = "idERROR"
    basepath = "/api/usuarios"

    if len(sys.argv) == 2:
        option = sys.argv[1]

    # PRETESTs: Inicio de sesion con Google+ en el sistema
    # Iniciamos dos sesiones
    token_id_login = "******"
    access_token_login = "******"
    token_id_login2 = "idgoogle2"
    access_token_login2 = "googleTEST2"
    session1 = test_utils.do_login_or_signup("googleplus", token_id_login,
                                             access_token_login, user_id1)
    session2 = test_utils.do_login_or_signup("googleplus", token_id_login2,
                                             access_token_login2, user_id2)

    if option == None:
        params = urllib.urlencode({})

        # TESTs Relativos a la obtención de lista de usuarios
        # TEST 1
        print "TEST 1: Obtener lista de usuarios (sin proporcionar una cookie de sesion)"
        print "Status esperado: 401"
        test_utils.make_request("GET", basepath, params, 401, None)

        # TEST 2
        print "TEST 2: Obtener lista de usuarios (proporcionando una cookie de sesion no válida)"
        print "Status esperado: 400"
        test_utils.make_request("GET",
                                basepath,
                                params,
                                400,
                                session_error,
                                printHeaders=True)

        # TEST 3
        print "TEST 3: Obtener lista de usuarios (proporcionando una cookie de sesion válida)"
        print " Status esperado: 200 (O 204 si la lista de usuarios está vacía)"
        test_utils.make_request("GET", basepath, params, 200, session1)

        # TESTs Relativos a la obtención de información sobre un usuario
        # TEST 4
        print "TEST 4: Obtener info de usuario, proporcionando una cookie de sesión (no existente en el sistema)"
        print "Status esperado: 404"
        request_uri = basepath + "/" + user_id_error
        test_utils.make_request("GET", request_uri, params, 404, session1)

        # TEST 5
        print "TEST 5: Obtener info de usuario, proporcionando una cookie de sesión incorrecta"
        print "Status esperado: 400"
        request_uri = basepath + "/" + user_id1
        test_utils.make_request("GET",
                                request_uri,
                                params,
                                400,
                                session_error,
                                printHeaders=True)

        # TEST 6
        print "TEST 6: Obtener info de usuario, caso obtención de información pública de un usuario en concreto"
        print "(proporcionando una cookie de sesión diferente al recurso usuario solicitado)"
        print "Status esperado: 200"
        request_uri = basepath + "/" + user_id1
        test_utils.make_request("GET", request_uri, params, 200, session2)

        # TEST 7
        print "TEST 7: Obtener info de usuario, caso obtención de información privada de un usuario en concreto"
        print "(cookie de sesión coincide con recurso usuario solicitado)"
        print "Status esperado: 200"
        request_uri = basepath + "/" + user_id1
        test_utils.make_request("GET", request_uri, params, 200, session1)

        # Tests de obtención de info de usuario sin cookie de sesión
        # TEST 8
        print "TEST 8: Obtener info de usuario, sin proporcionar cookie de sesión"
        print "Status esperado: 200 (Respuesta vacía)"
        request_uri = basepath + "/" + user_id1
        test_utils.make_request("GET", request_uri, params, 200, None)

        #TEST 9
        print "TEST 9: Obtener info de un usuario no existente en el sistema, sin proporcionar cookie de sesión"
        print "Status esperado: 404"
        request_uri = basepath + "/" + user_id_error
        test_utils.make_request("GET", request_uri, params, 404, None)

        # TESTs Relativos a la Modificación de información de un usuario en particular
        # TEST 10
        print "TEST 10: Modificar info de usuario 1 (sin cookie de sesión)"
        print "Status esperado: 401"
        request_uri = basepath + "/" + user_id1
        test_utils.make_request("POST", request_uri, params, 401, None)

        # TEST 11
        print "TEST 11: Modificar info de usuario 1 (Con cookie de sesión incorrecta)"
        print "Status esperado: 400"
        request_uri = basepath + "/" + user_id1
        test_utils.make_request("POST",
                                request_uri,
                                params,
                                400,
                                session_error,
                                printHeaders=True)

        # TEST 12
        print "TEST 12: Modificar info de usuario 1 (Con cookie de sesión distinta a la del recurso usuario)"
        print "Status esperado: 401"
        request_uri = basepath + "/" + user_id1
        test_utils.make_request("POST", request_uri, params, 401, session2)

        # TEST 13
        print "TEST 13: Modificar info de usuario no existente en el sistema"
        print "Status esperado: 404"
        request_uri = basepath + "/" + user_id_error
        test_utils.make_request("POST", request_uri, params, 404, session2)

        # TEST 14
        print "TEST 14: Modificar info de usuario 1, caso parámetros incorrectos (Cookie de sesión correcta)"
        print "Status esperado: 304 (El recurso no se modifica)"
        request_uri = basepath + "/" + user_id1
        params = urllib.urlencode({"badParam": "valueERROR"})
        test_utils.make_request("POST", request_uri, params, 304, session1)

        # TEST 15
        print "TEST 15: Modificar info de usuario 1, sin proporcionar parámetros (Cookie de sesión correcta)"
        print "Status esperado: 304 (El recurso no se modifica)"
        params = urllib.urlencode({})
        test_utils.make_request("POST", request_uri, params, 304, session1)

        # TEST 16
        print "TEST 16: Modificar info de usuario, caso modificar todos los campos del usuario 2, cambiando ámbito de email y teléfono a privado"
        print "(cookie de sesión correcta)"
        print "Status esperado: 200 (Se modifican todos los campos del usuario)"
        request_uri = basepath + "/" + user_id2
        params = urllib.urlencode({
            'description': 'Metric Lover',
            'website': 'PicBit.es',
            'image': 'unsplash.com/superCoolImage.jpeg',
            'phone': 911235813,
            'email': '*****@*****.**',
            'private_phone': 'True',
            'private_email': 'True'
        })
        test_utils.make_request("POST", request_uri, params, 200, session2)

        # Comprobamos caso de uso de obtención de información privada de usuario
        # TEST 17
        print "TEST 17: Obtener info de usuario 2, (cookie de sesión distinta al recurso solicitado)"
        print "Status esperado: 200 (No deben aparecer los campos correspondientes al teléfono y email)"
        request_uri = basepath + "/" + user_id2
        params = urllib.urlencode({})
        test_utils.make_request("GET", request_uri, params, 200, session1)

        # TEST 18
        print "TEST 18: Obtener info de usuario 2 (usuario activo solicita su propia información)"
        print "Status esperado: 200"
        # params = urllib.urlencode({})
        test_utils.make_request("GET", request_uri, params, 200, session2)

        # Cambiamos el ámbito de campos de usuario a público
        # TEST 19
        print "TEST 19: Cambiar info de usuario 2, caso cambiar a ámbito privado el email y telefono de usuario (cookie de sesión correcta)"
        print "Status esperado: 200"
        params = urllib.urlencode({
            'private_phone': 'True',
            'private_email': 'True'
        })
        test_utils.make_request("POST", request_uri, params, 200, session2)

        # TEST 20
        print "TEST 20: Obtener lista de usuarios (proporcionando una cookie de sesion válida)"
        print " Status esperado: 200 (el usuario 2 no debe mostrar los campos correspondientes al email y a teléfono)"
        params = urllib.urlencode({})
        test_utils.make_request("GET", basepath, params, 200, session1)

        # POSTESTs: Cierre de sesión con Google+ en el sistema
        request_uri = '/api/oauth/googleplus/logout'
        params = urllib.urlencode({})
        print "POSTEST 1: Logout de usuario 1 en el sistema"
        print "Ignorar el status de este caso"
        test_utils.make_request("POST", request_uri, params, 200, session1,
                                True)

        print "POSTEST 2: Logout de usuario 2 en el sistema"
        print "Ignorar el status de este caso"
        test_utils.make_request("POST", request_uri, params, 200, session2,
                                True)

    elif option == 'borrado':

        # TESTs Relativos a la eliminación de un usuario del sistema
        # TEST 21
        print "TEST 21: Borrar usuario del sistema (cookie de sesión incorrecta)"
        print "Status esperado: 400"
        request_uri = basepath + "/" + user_id1
        params = urllib.urlencode({})
        test_utils.make_request("DELETE",
                                request_uri,
                                params,
                                400,
                                session_error,
                                printHeaders=True)

        # TEST 22
        print "TEST 22: Borrar usuario el sistema (usuario no existente en el sistema)"
        print "Status esperado: 404"
        request_uri = basepath + "/" + user_id_error
        params = urllib.urlencode({})
        test_utils.make_request("DELETE", request_uri, params, 404, session1)

        # TEST 23
        print "TEST 23: Borrar usuario 1 del sistema (cookie de sesión incorrecta)"
        print "Status esperado: 401"
        request_uri = basepath + "/" + user_id1
        params = urllib.urlencode({})
        test_utils.make_request("DELETE", request_uri, params, 401, session2)

        # TEST 24
        print "TEST 24: Borrar usuario 1 del sistema (cookie de sesión correcta)"
        print "Status esperado: 204. La cookie de sesión se invalida y se realiza logout del usuario en el sistema"
        request_uri = basepath + "/" + user_id1
        params = urllib.urlencode({})
        test_utils.make_request("DELETE", request_uri, params, 204, session1)

        # TEST 25
        print "TEST 25: Borrar usuario 1 del sistema (usuario ya borrado del sistema)"
        print "Status esperado: 400 (La cookie proporcionada no corresponde con ningún usuario del sistema)"
        request_uri = basepath + "/" + user_id1
        params = urllib.urlencode({})
        test_utils.make_request("DELETE", request_uri, params, 400, session1)

        # TEST 26
        print "TEST 26: Obtener la lista de usuarios del sistema, para verificar que se ha eliminado el usuario"
        print "Status esperado: 200"
        request_uri = basepath
        params = urllib.urlencode({})
        test_utils.make_request("GET", request_uri, params, 200, session2)

        # TEST 27
        print "TEST 27: Borrar usuario 2 del sistema"
        print "Status esperado: 204"
        request_uri = basepath + "/" + user_id2
        params = urllib.urlencode({})
        test_utils.make_request("DELETE", request_uri, params, 204, session2)

        # TEST 28
        print "TEST 28: Obtener la lista de usuarios del sistema, " + \
        "para verificar que se ha invalidado la cookie de sesión del usuario tras su borrado del sistema"
        print "Status esperado: 400"
        request_uri = basepath
        params = urllib.urlencode({})
        test_utils.make_request("GET", request_uri, params, 400, session2)

    # Cerramos conexión e imprimimos el ratio de test ok vs erróneos
    test_utils.closeConnection()
    test_utils.tests_status()
Exemplo n.º 2
0
def main():
	test_utils.openConnection(False) # Pruebas en local (remote = False)
	option = None
	session1 = None
	session2 = None
	session_error = "session=session_error"
	user_id1 = "id_test_usuario1"
	user_id2 = "id_test_usuario2"
	user_id_error = "idERROR"
	basepath = "/api/usuarios"

	if len(sys.argv) == 2:
		option = sys.argv[1]

	# PRETESTs: Inicio de sesion con Google+ en el sistema
	# Iniciamos dos sesiones
	token_id_login = "******"
	access_token_login = "******"
	token_id_login2 = "idgoogle2"
	access_token_login2 = "googleTEST2"
	session1 = test_utils.do_login_or_signup("googleplus", token_id_login, access_token_login, user_id1)
	session2 = test_utils.do_login_or_signup("googleplus", token_id_login2, access_token_login2, user_id2)

	if option == None:
		params = urllib.urlencode({})

		# TESTs Relativos a la obtención de lista de usuarios
		# TEST 1
		print "TEST 1: Obtener lista de usuarios (sin proporcionar una cookie de sesion)"
		print "Status esperado: 401"
		test_utils.make_request("GET", basepath, params, 401, None)

		# TEST 2
		print "TEST 2: Obtener lista de usuarios (proporcionando una cookie de sesion no válida)"
		print "Status esperado: 400"
		test_utils.make_request("GET", basepath, params, 400, session_error)

		# TEST 3
		print "TEST 3: Obtener lista de usuarios (proporcionando una cookie de sesion válida)"
		print " Status esperado: 200 (O 204 si la lista de usuarios está vacía)"
		test_utils.make_request("GET", basepath, params, 200, session1)

		# TESTs Relativos a la obtención de información sobre un usuario
		# TEST 4
		print "TEST 4: Obtener info de usuario, proporcionando una cookie de sesión (no existente en el sistema)"
		print "Status esperado: 404"
		request_uri = basepath + "/" + user_id_error
		test_utils.make_request("GET", request_uri, params, 404, session1)

		# TEST 5
		print "TEST 5: Obtener info de usuario, caso obtención de información pública de un usuario en concreto"
		print "(proporcionando una cookie de sesión diferente al recurso usuario solicitado)"
		print "Status esperado: 200"
		request_uri = basepath + "/" + user_id1
		test_utils.make_request("GET", request_uri, params, 200, session2)

		# TEST 6
		print "TEST 6: Obtener info de usuario, caso obtención de información privada de un usuario en concreto"
		print "(cookie de sesión coincide con recurso usuario solicitado)"
		print "Status esperado: 200"
		request_uri = basepath + "/" + user_id1
		test_utils.make_request("GET", request_uri, params, 200, session1)

		# Tests de obtención de info de usuario sin cookie de sesión
		# TEST 7
		print "TEST 7: Obtener info de usuario, sin proporcionar cookie de sesión"
		print "Status esperado: 200 (Respuesta vacía)"
		request_uri = basepath + "/" + user_id1
		test_utils.make_request("GET", request_uri, params, 200, None)

		#TEST 8
		print "TEST 8: Obtener info de un usuario no existente en el sistema, sin proporcionar cookie de sesión"
		print "Status esperado: 404"
		request_uri = basepath + "/" + user_id_error
		test_utils.make_request("GET", request_uri, params, 404, None)

		# TESTs Relativos a la Modificación de información de un usuario en particular
		# TEST 9
		print "TEST 9: Modificar info de usuario 1 (sin cookie de sesión)"
		print "Status esperado: 401"
		request_uri = basepath + "/" + user_id1
		test_utils.make_request("POST", request_uri, params, 401, None)

		# TEST 10
		print "TEST 10: Modificar info de usuario 1 (Con cookie de sesión distinta a la del recurso usuario)"
		print "Status esperado: 401"
		request_uri = basepath + "/" + user_id1
		test_utils.make_request("POST", request_uri, params, 401, session2)

		# TEST 11
		print "TEST 11: Modificar info de usuario no existente en el sistema"
		print "Status esperado: 404"
		request_uri = basepath + "/" + user_id_error
		test_utils.make_request("POST", request_uri, params, 404, session2)

		# TEST 12
		print "TEST 12: Modificar info de usuario 1, caso parámetros incorrectos (Cookie de sesión correcta)"
		print "Status esperado: 304 (El recurso no se modifica)"
		request_uri = basepath + "/" + user_id1
		params = urllib.urlencode({"badParam": "valueERROR"})
		test_utils.make_request("POST", request_uri, params, 304, session1)

		# TEST 13
		print "TEST 13: Modificar info de usuario 1, sin proporcionar parámetros (Cookie de sesión correcta)"
		print "Status esperado: 304 (El recurso no se modifica)"
		params = urllib.urlencode({})
		test_utils.make_request("POST", request_uri, params, 304, session1)

		# TEST 14
		print "TEST 14: Modificar info de usuario, caso modificar todos los campos del usuario 2, cambiando ámbito de email y teléfono a privado"
		print "(cookie de sesión correcta)"
		print "Status esperado: 200 (Se modifican todos los campos del usuario)"
		request_uri = basepath + "/" + user_id2
		params = urllib.urlencode({'description': 'Metric Lover',
			'website': 'PicBit.es',
			'image': 'unsplash.com/superCoolImage.jpeg',
			'phone': 911235813,
			'email': '*****@*****.**',
			'private_phone': 'True',
			'private_email': 'True'})
		test_utils.make_request("POST", request_uri, params, 200, session2)

		# Comprobamos caso de uso de obtención de información privada de usuario
		# TEST 15
		print "TEST 15: Obtener info de usuario 2, (cookie de sesión distinta al recurso solicitado)"
		print "Status esperado: 200 (No deben aparecer los campos correspondientes al teléfono y email)"
		request_uri = basepath + "/" + user_id2
		params = urllib.urlencode({})
		test_utils.make_request("GET", request_uri, params, 200, session1)

		# TEST 16
		print "TEST 16: Obtener info de usuario 2 (usuario activo solicita su propia información)"
		print "Status esperado: 200"
		# params = urllib.urlencode({})
		test_utils.make_request("GET", request_uri, params, 200, session2)

		# Cambiamos el ámbito de campos de usuario a público
		# TEST 17
		print "TEST 17: Cambiar info de usuario 2, caso cambiar a ámbito privado el email y telefono de usuario (cookie de sesión correcta)"
		print "Status esperado: 200"
		params = urllib.urlencode({'private_phone': 'True',
			'private_email': 'True'})
		test_utils.make_request("POST", request_uri, params, 200, session2)

		# TEST 18
		print "TEST 18: Obtener lista de usuarios (proporcionando una cookie de sesion válida)"
		print " Status esperado: 200 (el usuario 2 no debe mostrar los campos correspondientes al email y a teléfono)"
		params = urllib.urlencode({})
		test_utils.make_request("GET", basepath, params, 200, session1)

		# POSTESTs: Cierre de sesión con Google+ en el sistema
		request_uri = '/api/oauth/googleplus/logout'
		params = urllib.urlencode({})
		print "POSTEST 1: Logout de usuario 1 en el sistema"
		print "Ignorar el status de este caso"
		test_utils.make_request("POST", request_uri, params, 200, session1, True)

		print "POSTEST 2: Logout de usuario 2 en el sistema"
		print "Ignorar el status de este caso"
		test_utils.make_request("POST", request_uri, params, 200, session2, True)

	elif option == 'borrado':

		# TESTs Relativos a la eliminación de un usuario del sistema
		# TEST 19
		print "TEST 19: Borrar usuario del sistema (cookie de sesión incorrecta)"
		print "Status esperado: 400"
		request_uri = basepath + "/" + user_id1
		params = urllib.urlencode({})
		test_utils.make_request("DELETE", request_uri, params, 400, session_error)

		# TEST 20
		print "TEST 20: Borrar usuario el sistema (usuario no existente en el sistema)"
		print "Status esperado: 404"
		request_uri = basepath + "/" + user_id_error
		params = urllib.urlencode({})
		test_utils.make_request("DELETE", request_uri, params, 404, session1)

		# TEST 21
		print "TEST 21: Borrar usuario 1 del sistema (cookie de sesión incorrecta)"
		print "Status esperado: 401"
		request_uri = basepath + "/" + user_id1
		params = urllib.urlencode({})
		test_utils.make_request("DELETE", request_uri, params, 401, session2)

		# TEST 22
		print "TEST 22: Borrar usuario 1 del sistema (cookie de sesión correcta)"
		print "Status esperado: 204. La cookie de sesión se invalida y se realiza logout del usuario en el sistema"
		request_uri = basepath + "/" + user_id1
		params = urllib.urlencode({})
		test_utils.make_request("DELETE", request_uri, params, 204, session1)

		# TEST 23
		print "TEST 23: Borrar usuario 1 del sistema (usuario ya borrado del sistema)"
		print "Status esperado: 400 (La cookie proporcionada no corresponde con ningún usuario del sistema)"
		request_uri = basepath + "/" + user_id1
		params = urllib.urlencode({})
		test_utils.make_request("DELETE", request_uri, params, 400, session1)

		# TEST 24
		print "TEST 24: Obtener la lista de usuarios del sistema, para verificar que se ha eliminado el usuario"
		print "Status esperado: 200"
		request_uri = basepath
		params = urllib.urlencode({})
		test_utils.make_request("GET", request_uri, params, 200, session2)

		# TEST 25
		print "TEST 25: Borrar usuario 2 del sistema"
		print "Status esperado: 204"
		request_uri = basepath + "/" + user_id2
		params = urllib.urlencode({})
		test_utils.make_request("DELETE", request_uri, params, 204, session2)

		# TEST 26
		print "TEST 26: Obtener la lista de usuarios del sistema, " + \
		"para verificar que se ha invalidado la cookie de sesión del usuario tras su borrado del sistema"
		print "Status esperado: 400"
		request_uri = basepath
		params = urllib.urlencode({})
		test_utils.make_request("GET", request_uri, params, 400, session2)


	# Cerramos conexión e imprimimos el ratio de test ok vs erróneos
	test_utils.closeConnection()
	test_utils.tests_status()
Exemplo n.º 3
0
def main():
    if len(sys.argv) == 2:
        option = sys.argv[1]
        basepath = "/api/componentes"
        option_list = ['subida', 'obtención', 'modificación', 'borrado']
        user_id1 = "id_usuario_test_componentes_1"
        session_error = "session=session_error"
        if option in option_list:
            test_utils.openConnection(
                False)  # Pruebas en local (Remote = False)

            # PRE-TESTs. Login de usuario en el sistema, utilizando Google+
            token_id_login = "******"
            access_token_login = "******"
            session1 = test_utils.do_login_or_signup("googleplus",
                                                     token_id_login,
                                                     access_token_login,
                                                     user_id1)

            if option == "subida":
                request_uri = basepath
                params = urllib.urlencode({})

                # TEST 1
                print "TEST 1: : Obtener la lista de componentes. Debe retornar una lista vacia de componentes"
                print "Status esperado: 204 "
                test_utils.make_request("GET", request_uri, params, 204,
                                        session1, True)

                # TESTs relativos a la operación PUT lista de componentes (Subir un componente al sistema)
                # (TEST comentado: actualmente no se realiza la comprobación de URI correcta)
                # TEST 2
                # print "TEST 2: Subir un componente al sistema, proporcionando una URI incorrecta."
                # print "Status esperado: 404 "
                # params = urllib.urlencode({'url': 'https://github.com/JuanFryS/badURI',
                #            'component_id': 'twitter-timeline',
                #            'description': 'Web component to obtain the timeline of Twitter using Polymer',
                #            'social_network': 'twitter',
                #            'input_type': 'None',
                #            'output_type': 'tweet',
                #            'versions': 'stable'
                # })
                # test_utils.make_request("PUT", request_uri, params, 404, session1)

                # TEST 3
                print "TEST 3: Subir un componente al sistema, proporcionando un parametro erróneo (red social)."
                print "Status esperado: 400 "
                params = urllib.urlencode({
                    'url': 'https://github.com/JuanFryS/twitter-timeline',
                    'component_id': 'twitter-timeline',
                    'description':
                    'Web component to obtain the timeline of Twitter using Polymer',
                    'social_network': 'RedError',
                    'input_type': 'None',
                    'output_type': 'tweet',
                    'versions': 'stable'
                })
                test_utils.make_request("PUT", request_uri, params, 400, None)

                # TEST 4
                print "TEST 4: Subir un componente al sistema, proporcionando menos parámetros de los necesarios."
                print "Status esperado: 400 "
                params = urllib.urlencode({
                    'url': 'https://github.com/JuanFryS/twitter-timeline',
                    'component_id': 'twitter-timeline',
                    'description':
                    'Web component to obtain the timeline of Twitter using Polymer',
                    'social_network': 'twitter',
                    'input_type': 'None'
                })
                test_utils.make_request("PUT", request_uri, params, 400, None)

                # TEST 5
                print "TEST 5: Subir un componente al sistema, proporcionando una lista de versiones que no contiene la version 'stable'"
                print "Status esperado: 400 "
                params = urllib.urlencode(
                    {
                        'url': 'https://github.com/JuanFryS/twitter-timeline',
                        'component_id': 'twitter-timeline',
                        'description':
                        'Web component to obtain the timeline of Twitter using Polymer',
                        'social_network': 'twitter',
                        'input_type': 'None',
                        'versions': "badVersion1",
                        'versions': "badVersion2"
                    },
                    doseq=True)
                test_utils.make_request("PUT", request_uri, params, 400, None)

                # TEST 6
                print "TEST 6: Subir un componente al sistema, proporcionando un valor incorrecto para el parámetro 'predetermined'"
                print "Status esperado: 400 "
                params = urllib.urlencode(
                    {
                        'url': 'https://github.com/JuanFryS/twitter-timeline',
                        'component_id': 'twitter-timeline',
                        'description':
                        'Web component to obtain the timeline of Twitter using Polymer',
                        'social_network': 'twitter',
                        'input_type': 'None',
                        'versions': "stable",
                        'predetermined': "badValue"
                    },
                    doseq=True)
                test_utils.make_request("PUT", request_uri, params, 400, None)

                # Subimos dos componentes al sistema
                # TEST 7
                print "TEST 7: Subir un componente al sistema (componente 1). Este componente tiene una sola version. No es predeterminado"
                print "Status esperado: 201 "
                params = urllib.urlencode({
                    'url': 'https://github.com/JuanFryS/twitter-timeline',
                    'component_id': 'twitter-timeline',
                    'description':
                    'Web component to obtain the timeline of Twitter using Polymer',
                    'social_network': 'twitter',
                    'input_type': 'None',
                    'output_type': 'tweet',
                    'versions': 'stable'
                })
                test_utils.make_request("PUT", request_uri, params, 201, None)

                # TEST 8: Subir un componente al sistema (componente 2).
                print "TEST 8: Subir un componente al sistema (componente 2). Este componente tiene dos versiones. Es predeterminado"
                print "Status esperado: 201 "
                # request_uri = basepath
                versions_list = ["stable", "usability_defects"]
                params = urllib.urlencode(
                    {
                        'url':
                        'https://github.com/JuanFryS/instagram-timeline',
                        'component_id': 'instagram-timeline',
                        'description':
                        'Web component to obtain the timeline of the social network Instagram using Polymer',
                        'social_network': 'instagram',
                        'input_type': 'None',
                        'output_type': 'photo',
                        'versions': versions_list,
                        'predetermined': "True"
                    },
                    doseq=True)
                test_utils.make_request("PUT", request_uri, params, 201, None)

                # TEST 9: Subir un componente al sistema (componente 3).
                print "TEST 9: Subir un componente al sistema (componente 3). Este componente tiene dos versiones. No es predeterminado (se especifica en la petición)"
                print "Status esperado: 201 "
                # request_uri = basepath
                versions_list = ["stable", "usability_defects"]
                params = urllib.urlencode(
                    {
                        'url':
                        'https://github.com/JuanFryS/instagram-timeline',
                        'component_id': 'google-inbox',
                        'description':
                        'Web component to obtain mails from your gmail account',
                        'social_network': 'googleplus',
                        'input_type': 'None',
                        'output_type': 'text',
                        'versions': versions_list,
                        'predetermined': "False"
                    },
                    doseq=True)
                test_utils.make_request("PUT", request_uri, params, 201, None)

                # TEST 10
                print "TEST 10: Subida de un componente repetido al sistema (componente 2)."
                print "Status esperado: 403 "
                params = urllib.urlencode(
                    {
                        'url':
                        'https://github.com/JuanFryS/instagram-timeline',
                        'component_id': 'instagram-timeline',
                        'description':
                        'New description to the web component (Description changed in TEST 7)',
                        'social_network': 'instagram',
                        'input_type': 'None',
                        'output_type': 'photo',
                        'versions': versions_list,
                        'predetermined': "True"
                    },
                    doseq=True)
                test_utils.make_request("PUT", request_uri, params, 403, None)

            elif option == "obtención":
                # TESTs relativos al método GET Lista de componentes
                request_uri = basepath
                params = urllib.urlencode({})

                # TEST 10
                print "TEST 10: Obtener la lista de componentes, sin proporcionar una cookie de sesión"
                print "Status esperado: 401 "
                test_utils.make_request("GET", request_uri, params, 401, None)

                # TEST 11
                print "TEST 11: Obtener la lista de componentes, proporcionando una cookie de sesión no válida"
                print "Status esperado: 400"
                test_utils.make_request("GET",
                                        request_uri,
                                        params,
                                        400,
                                        session_error,
                                        printHeaders=True)

                # TEST 12
                print "TEST 12: Obtener la lista de componentes, proporcionando una cookie de sesion (Sin parámetros)"
                print "Status esperado: 200"
                test_utils.make_request("GET", request_uri, params, 200,
                                        session1)

                # Casos de obtención de lista de componentes, aplicando criterios de filtrado
                # TEST 13
                print "TEST 13: Obtener la lista de componentes, proporcionando una cookie de sesion"
                print "(parámetro de filtrado por red social)"
                print "Status esperado: 200"
                request_uri = basepath + "?social_network=twitter"
                test_utils.make_request("GET", request_uri, params, 200,
                                        session1)

                # TEST 14
                print "TEST 14: Obtener la lista de componentes, proporcionando una cookie de sesion"
                print "(formato de lista completo)"
                print "Status esperado: 200"
                request_uri = basepath + "?format=complete"
                test_utils.make_request("GET", request_uri, params, 200,
                                        session1)

                # TESTs relativos al metodo GET Componente (obtener info de un componente en particular)
                # TEST 15
                print "TEST 15: Obtener información sobre componente 1, sin proporcionar cookie de usuario"
                print "Status esperado: 401"
                request_uri = basepath + '/twitter-timeline'
                test_utils.make_request("GET", request_uri, params, 401, None)

                # TEST 16
                print "TEST 16: Obtener información sobre el componente 1, proporcionando una cookie de sesión incorrecta"
                print "Status esperado: 400"
                request_uri = basepath + '/twitter-timeline'
                test_utils.make_request("GET",
                                        request_uri,
                                        params,
                                        400,
                                        session_error,
                                        printHeaders=True)

                # TEST 17
                print "TEST 17: Obtener información sobre un componente no existente en el sistema"
                print "Status esperado: 404"
                request_uri = basepath + '/componenteERROR'
                test_utils.make_request("GET", request_uri, params, 404,
                                        session1)

                # TEST 18
                print "TEST 18: Obtener información sobre el componente 1"
                print "Status esperado: 200"
                request_uri = basepath + '/twitter-timeline'
                test_utils.make_request("GET", request_uri, params, 200,
                                        session1)

                # TEST 19
                print "TEST 19: Obtener información sobre el componente 2."
                print "Se especifica formato completo, pero se retornará el formato reducido,"
                print " ya que el componente está incluido en el conjunto de componentes del usuario"
                print "Status esperado: 200"
                request_uri = basepath + '/instagram-timeline?format=complete'
                test_utils.make_request("GET", request_uri, params, 200,
                                        session1)

            elif option == "modificación":
                params = urllib.urlencode({})
                # TESTs relativos al método POST Componente (modificar info de un componente)
                # TEST 20
                print "TEST 20: Modificar información sobre un componente, sin proporcionar una cookie de sesión"
                print "Status esperado: 401"
                request_uri = basepath + '/twitter-timeline'
                test_utils.make_request("POST", request_uri, params, 401, None)

                # TEST 21
                print "TEST 21: Modificar información sobre el componente 1, proporcionando una cookie de sesión incorrecta"
                print "Status esperado: 400"
                request_uri = basepath + '/twitter-timeline'
                params = urllib.urlencode({'x_axis': 200, 'y_axis': 250})
                test_utils.make_request("POST",
                                        request_uri,
                                        params,
                                        400,
                                        session_error,
                                        printHeaders=True)

                # TEST 22
                print "TEST 22: Modificar información sobre el componente 1 (Valor incorrecto para parámetro X)"
                print "Status esperado: 400"
                request_uri = basepath + '/twitter-timeline'
                params = urllib.urlencode({'x_axis': 'string', 'y_axis': 250})
                test_utils.make_request("POST", request_uri, params, 400,
                                        session1)

                # TEST 23
                print "TEST 23: Modificar información sobre el componente 2 (Valor incorrecto para parámetro Rating, mayor que 5)"
                print "Status esperado: 400"
                request_uri = basepath + '/instagram-timeline'
                params = urllib.urlencode({'rating': 6})
                test_utils.make_request("POST", request_uri, params, 400,
                                        session1)

                # TEST 24
                print "TEST 24: Modificar información sobre el componente 1, caso cambiar posición del componente y rating incorrecto " + \
                 "(x:300, y:300, rating: 7.5)"
                print "Status esperado: 400"
                request_uri = basepath + '/twitter-timeline'
                params = urllib.urlencode({
                    'x_axis': 300,
                    'y_axis': 300,
                    'rating': 7.5
                })
                test_utils.make_request("POST", request_uri, params, 400,
                                        session1)

                # TEST 25
                print "TEST 25: Modificar información sobre el componente 1, caso cambiar posición del componente" + \
                " (x:150, y:250, listening: string)"
                print "Status esperado: 200"
                request_uri = basepath + '/twitter-timeline'
                params = urllib.urlencode({
                    'x_axis': 150,
                    'y_axis': 250,
                    'listening': 'string'
                })
                test_utils.make_request("POST", request_uri, params, 200,
                                        session1)

                # TEST 26
                print "TEST 26: Modificar información sobre el componente 2, caso cambiar valoración, sobre un componente que no es propiedad del usuario (Rating: 4.5)"
                print "Status esperado: 400"
                request_uri = basepath + '/twitter-timeline'
                params = urllib.urlencode({'rating': 4.5})
                test_utils.make_request("POST", request_uri, params, 400,
                                        session1)

                # TEST 27
                print "TEST 27: Obtención de la lista de componentes del sistema, para verificar "
                print "que se ha modificado la información solicitada en las anteriores pruebas"
                print "Status esperado: 200"
                request_uri = basepath + "?format=complete"
                params = urllib.urlencode({})
                test_utils.make_request("GET", request_uri, params, 200,
                                        session1)

            elif option == 'borrado':
                params = urllib.urlencode({})
                # TESTs relativos al método DELETE Componente

                # TEST 25
                print "TEST 25: Borrar componente no existente en el sistema"
                print "Status esperado: 404 "
                request_uri = basepath + '/componenteERROR?scope=global'
                test_utils.make_request("DELETE", request_uri, params, 404,
                                        None)

                # TEST 26
                print "TEST 26: Borrar componente 1 del sistema"
                print "Status esperado: 204 "
                request_uri = basepath + '/twitter-timeline?scope=global'
                test_utils.make_request("DELETE", request_uri, params, 204,
                                        None)

                # TEST 27
                print "TEST 27: Borrar componente 1 del sistema (el componente se había borrado previamente) "
                print "Status esperado: 404 "
                # request_uri = basepath + '/twitter-timeline?scope=global'
                test_utils.make_request("DELETE", request_uri, params, 404,
                                        None)

                # TEST 28
                print "TEST 28: Borrar componente 2 del sistema"
                print "Status esperado: 204 "
                request_uri = basepath + '/instagram-timeline?scope=global'
                test_utils.make_request("DELETE", request_uri, params, 204,
                                        None)

            # Realizamos logout en el sistema, tras llevar a cabo las pruebas
            # POST-TEST 1: Hacer logout en el sistema mediante googleplus
            request_uri = "/api/oauth/googleplus/logout"
            print "POST-TEST 1: Haciendo petición POST a " + request_uri + " (logout)\n Ignorar el status de este caso"
            params = urllib.urlencode({})
            test_utils.make_request("POST",
                                    request_uri,
                                    params,
                                    200,
                                    session1,
                                    preTest=True)
            test_utils.tests_status()
            test_utils.closeConnection()
        else:
            print "Error: Parámetro incorrecto"
            print "Uso: python api_componentes_tester.py {subida|obtención|modificación|borrado}"

    else:
        print "Error: es obligatorio proporcionar un parámetro válido para indicar que funcionalidad u operación se pretende testear"
        print "Uso: python api_componentes_tester.py {subida|obtención|modificación|borrado}"
def main():
	if len(sys.argv) == 2:
		option = sys.argv[1]
		basepath = "/api/componentes"
		option_list = ['subida', 'obtención', 'modificación', 'borrado']
		user_id1 = "id_usuario_test_componentes_1"
		if option in option_list:
			test_utils.openConnection(False) # Pruebas en local (Remote = False)

			# PRE-TESTs. Login de usuario en el sistema, utilizando Google+
			token_id_login = "******"
			access_token_login = "******"
			session1 = test_utils.do_login_or_signup("googleplus", token_id_login, access_token_login, user_id1)

			if option == "subida":
				request_uri = basepath
				params = urllib.urlencode({})

				# TEST 1
				print "TEST 1: : Obtener la lista de componentes. Debe retornar una lista vacia de componentes"
				print "Status esperado: 204 "
				test_utils.make_request("GET", request_uri, params, 204, session1, True)

				# TESTs relativos a la operación PUT lista de componentes (Subir un componente al sistema)
				# (TEST comentado: actualmente no se realiza la comprobación de URI correcta)
				# TEST 2
				# print "TEST 2: Subir un componente al sistema, proporcionando una URI incorrecta."
				# print "Status esperado: 404 "
				# params = urllib.urlencode({'url': 'https://github.com/JuanFryS/badURI',
			 #            'component_id': 'twitter-timeline',
			 #            'description': 'Web component to obtain the timeline of Twitter using Polymer',
			 #            'social_network': 'twitter',
			 #            'input_type': 'None',
			 #            'output_type': 'tweet',
			 #            'versions': 'stable'
				# })
				# test_utils.make_request("PUT", request_uri, params, 404, session1)

				# TEST 3
				print "TEST 3: Subir un componente al sistema, proporcionando un parametro erróneo (red social)."
				print "Status esperado: 400 "
				params = urllib.urlencode({'url': 'https://github.com/JuanFryS/twitter-timeline',
			            'component_id': 'twitter-timeline',
			            'description': 'Web component to obtain the timeline of Twitter using Polymer',
			            'social_network': 'RedError' ,
			            'input_type': 'None',
			            'output_type': 'tweet',
			            'versions': 'stable'
				})
				test_utils.make_request("PUT", request_uri, params, 400, None)

				# TEST 4
				print "TEST 4: Subir un componente al sistema, proporcionando menos parámetros de los necesarios."
				print "Status esperado: 400 "
				params = urllib.urlencode({'url': 'https://github.com/JuanFryS/twitter-timeline',
			            'component_id': 'twitter-timeline',
			            'description': 'Web component to obtain the timeline of Twitter using Polymer',
			            'social_network': 'twitter' ,
			            'input_type': 'None'
				})
				test_utils.make_request("PUT", request_uri, params, 400, None)

				# TEST 5
				print "TEST 5: Subir un componente al sistema, proporcionando una lista de versiones que no contiene la version 'stable'"
				print "Status esperado: 400 "
				params = urllib.urlencode({'url': 'https://github.com/JuanFryS/twitter-timeline',
			            'component_id': 'twitter-timeline',
			            'description': 'Web component to obtain the timeline of Twitter using Polymer',
			            'social_network': 'twitter' ,
			            'input_type': 'None',
			            'versions': "badVersion1",
			            'versions': "badVersion2"
				}, doseq=True)
				test_utils.make_request("PUT", request_uri, params, 400, None)

				# TEST 6
				print "TEST 6: Subir un componente al sistema, proporcionando un valor incorrecto para el parámetro 'predetermined'"
				print "Status esperado: 400 "
				params = urllib.urlencode({'url': 'https://github.com/JuanFryS/twitter-timeline',
			            'component_id': 'twitter-timeline',
			            'description': 'Web component to obtain the timeline of Twitter using Polymer',
			            'social_network': 'twitter' ,
			            'input_type': 'None',
			            'versions': "stable",
			            'predetermined': "badValue"
				}, doseq=True)
				test_utils.make_request("PUT", request_uri, params, 400, None)

				# Subimos dos componentes al sistema
				# TEST 7
				print "TEST 7: Subir un componente al sistema (componente 1). Este componente tiene una sola version. No es predeterminado"
				print "Status esperado: 201 "
				params = urllib.urlencode({'url': 'https://github.com/JuanFryS/twitter-timeline',
			            'component_id': 'twitter-timeline',
			            'description': 'Web component to obtain the timeline of Twitter using Polymer',
			            'social_network': 'twitter' ,
			            'input_type': 'None',
			            'output_type': 'tweet',
			            'versions': 'stable'
				})
				test_utils.make_request("PUT", request_uri, params, 201, None)

				# TEST 8: Subir un componente al sistema (componente 2).
				print "TEST 8: Subir un componente al sistema (componente 2). Este componente tiene dos versiones. Es predeterminado"
				print "Status esperado: 201 "
				# request_uri = basepath
				versions_list = ["stable", "usability_defects"]
				params = urllib.urlencode({'url': 'https://github.com/JuanFryS/instagram-timeline',
			            'component_id': 'instagram-timeline',
			            'description': 'Web component to obtain the timeline of the social network Instagram using Polymer',
			            'social_network': 'instagram',
			            'input_type': 'None',
			            'output_type': 'photo',
			            'versions': versions_list,
			            'predetermined': "True"
				}, doseq=True)
				test_utils.make_request("PUT", request_uri, params, 201, None)

				# TEST 9: Subir un componente al sistema (componente 3).
				print "TEST 9: Subir un componente al sistema (componente 3). Este componente tiene dos versiones. No es predeterminado (se especifica en la petición)"
				print "Status esperado: 201 "
				# request_uri = basepath
				versions_list = ["stable", "usability_defects"]
				params = urllib.urlencode({'url': 'https://github.com/JuanFryS/instagram-timeline',
			            'component_id': 'google-inbox',
			            'description': 'Web component to obtain mails from your gmail account',
			            'social_network': 'googleplus',
			            'input_type': 'None',
			            'output_type': 'text',
			            'versions': versions_list,
			            'predetermined': "False"
				}, doseq=True)
				test_utils.make_request("PUT", request_uri, params, 201, None)

				# TEST 10
				print "TEST 10: Subida de un componente repetido al sistema (componente 2)."
				print "Status esperado: 403 "
				params = urllib.urlencode({'url': 'https://github.com/JuanFryS/instagram-timeline',
			            'component_id': 'instagram-timeline',
			            'description': 'New description to the web component (Description changed in TEST 7)',
			            'social_network': 'instagram',
			            'input_type': 'None',
			            'output_type': 'photo',
			            'versions': versions_list,
			            'predetermined': "True"
				}, doseq=True)
				test_utils.make_request("PUT", request_uri, params, 403, None)

			elif option == "obtención":
				# TESTs relativos al método GET Lista de componentes
				request_uri = basepath
				params = urllib.urlencode({})

				# TEST 10
				print "TEST 10: Obtener la lista de componentes, sin proporcionar una cookie de sesion"
				print "Status esperado: 401 "
				test_utils.make_request("GET", request_uri, params, 401, None)

				# TEST 11
				print "TEST 11: Obtener la lista de componentes, proporcionando una cookie de sesion (Sin parámetros)"
				print "Status esperado: 200"
				test_utils.make_request("GET", request_uri, params, 200, session1)

				# Casos de obtención de lista de componentes, aplicando criterios de filtrado
				# TEST 12
				print "TEST 12: Obtener la lista de componentes, proporcionando una cookie de sesion"
				print "(parámetro de filtrado por red social)"
				print "Status esperado: 200"
				request_uri = basepath + "?social_network=twitter"
				test_utils.make_request("GET", request_uri, params, 200, session1)

				# TEST 13
				print "TEST 13: Obtener la lista de componentes, proporcionando una cookie de sesion"
				print "(formato de lista completo)"
				print "Status esperado: 200"
				request_uri = basepath + "?format=complete"
				test_utils.make_request("GET", request_uri, params, 200, session1)

				# TESTs relativos al metodo GET Componente (obtener info de un componente en particular)
				# TEST 14
				print "TEST 14: Obtener información sobre componente 1, sin proporcionar cookie de usuario"
				print "Status esperado: 401"
				request_uri = basepath + '/twitter-timeline'
				test_utils.make_request("GET", request_uri, params, 401, None)

				# TEST 15
				print "TEST 15: Obtener información sobre un componente no existente en el sistema"
				print "Status esperado: 404"
				request_uri = basepath + '/componenteERROR'
				test_utils.make_request("GET", request_uri, params, 404, session1)

				# TEST 16
				print "TEST 16: Obtener información sobre el componente 1"
				print "Status esperado: 200"
				request_uri = basepath + '/twitter-timeline'
				test_utils.make_request("GET", request_uri, params, 200, session1)

				# TEST 17
				print "TEST 17: Obtener información sobre el componente 2."
				print "Se especifica formato completo, pero se retornará el formato reducido,"
				print " ya que el componente está incluido en el conjunto de componentes del usuario"
				print "Status esperado: 200"
				request_uri = basepath + '/instagram-timeline?format=complete'
				test_utils.make_request("GET", request_uri, params, 200, session1)

			elif option == "modificación":
				# TESTs relativos al método POST Componente (modificar info de un componente)
				# TEST 18
				print "TEST 18: Modificar información sobre un componente, sin proporcionar una cookie de sesión"
				print "Status esperado: 401"
				request_uri = basepath + '/twitter-timeline'
				test_utils.make_request("POST", request_uri, params, 401, None)

				# TEST 19
				print "TEST 19: Modificar información sobre el componente 1 (Valor incorrecto para parámetro X)"
				print "Status esperado: 400"
				request_uri = basepath + '/twitter-timeline'
				params = urllib.urlencode({'x_axis': 'string',
						'y_axis': 250})
				test_utils.make_request("POST", request_uri, params, 400, session1)

				# TEST 20
				print "TEST 20: Modificar información sobre el componente 2 (Valor incorrecto para parámetro Rating, mayor que 5)"
				print "Status esperado: 400"
				request_uri = basepath + '/instagram-timeline'
				params = urllib.urlencode({'rating': 6})
				test_utils.make_request("POST", request_uri, params, 400, session1)

				# TEST 21
				print "TEST 21: Modificar información sobre el componente 1, caso cambiar posición del componente y rating incorrecto " + \
				 "(x:300, y:300, rating: 7.5)"
				print "Status esperado: 400"
				request_uri = basepath + '/twitter-timeline'
				params = urllib.urlencode({'x_axis': 300,
						'y_axis': 300, 'rating':7.5})
				test_utils.make_request("POST", request_uri, params, 400, session1)

				# TEST 22
				print "TEST 22: Modificar información sobre el componente 1, caso cambiar posición del componente" + \
				" (x:150, y:250, listening: string)"
				print "Status esperado: 200"
				request_uri = basepath + '/twitter-timeline'
				params = urllib.urlencode({'x_axis': 150,
						'y_axis': 250, 'listening': 'string'})
				test_utils.make_request("POST", request_uri, params, 200, session1)

				# TEST 23
				print "TEST 23: Modificar información sobre el componente 2, caso cambiar valoración, sobre un componente que no es propiedad del usuario (Rating: 4.5)"
				print "Status esperado: 400"
				request_uri = basepath + '/twitter-timeline'
				params = urllib.urlencode({'rating': 4.5})
				test_utils.make_request("POST", request_uri, params, 400, session1)

				# TEST 24
				print "TEST 24: Obtención de la lista de componentes del sistema, para verificar "
				print "que se ha modificado la información solicitada en las anteriores pruebas"
				print "Status esperado: 200"
				request_uri = basepath + "?format=complete"
				params = urllib.urlencode({})
				test_utils.make_request("GET", request_uri, params, 200, session1)

			elif option == 'borrado':
				params = urllib.urlencode({})
				# TESTs relativos al método DELETE Componente

				# TEST 25
				print "TEST 25: Borrar componente no existente en el sistema "
				print "Status esperado: 404 "
				request_uri = basepath + '/componenteERROR?scope=global'
				test_utils.make_request("DELETE", request_uri, params, 404, None)

				# TEST 26
				print "TEST 26: Borrar componente 1 del sistema"
				print "Status esperado: 204 "
				request_uri = basepath + '/twitter-timeline?scope=global'
				test_utils.make_request("DELETE", request_uri, params, 204, None)

				# TEST 27
				print "TEST 27: Borrar componente 1 del sistema (el componente se había borrado previamente) "
				print "Status esperado: 404 "
				# request_uri = basepath + '/twitter-timeline?scope=global'
				test_utils.make_request("DELETE", request_uri, params, 404, None)

				# TEST 28
				print "TEST 28: Borrar componente 2 del sistema"
				print "Status esperado: 204 "
				request_uri = basepath + '/instagram-timeline?scope=global'
				test_utils.make_request("DELETE", request_uri, params, 204, None)

			# Realizamos logout en el sistema, tras llevar a cabo las pruebas
			# POST-TEST 1: Hacer logout en el sistema mediante googleplus
			request_uri = "/api/oauth/googleplus/logout"
			print "POST-TEST 1: Haciendo petición POST a " + request_uri + " (logout)\n Ignorar el status de este caso"
			params = urllib.urlencode({})
			test_utils.make_request("POST", request_uri, params, 200, session1, preTest=True)
			test_utils.tests_status()
			test_utils.closeConnection()
		else:
			print "Error: Parámetro incorrecto"
			print "Uso: python api_componentes_tester.py {subida|obtención|modificación|borrado}"

	else:
		print "Error: es obligatorio proporcionar un parámetro válido para indicar que funcionalidad u operación se pretende testear"
		print "Uso: python api_componentes_tester.py {subida|obtención|modificación|borrado}"
def main():
    components_basepath = "/api/componentes"
    users_basepath = "/api/usuarios"
    session1 = None
    session2 = None
    session_error = "session=session_error"
    user_id1 = "id_usuario_dashboard_1"
    user_id2 = "id_usuario_dashboard_2"

    # Sets the option param
    option = None
    if len(sys.argv) == 2:
        option = sys.argv[1]

    if option in [
            "dashboard", "dashboard_borrado", "dashboard_predeterminados",
            "dashboard_versionado"
    ]:
        # We open the connection with the server
        test_utils.openConnection(
            False)  # Realizamos pruebas en local (remote=False)

        # Iniciamos sesión con dos usuarios en el sistema
        token_id_login = "******"
        access_token_login = "******"
        token_id_login2 = "id_component_users_test_token2"
        access_token_login2 = "googleTEST2"
        session1 = test_utils.do_login_or_signup("googleplus", token_id_login,
                                                 access_token_login, user_id1)
        session2 = test_utils.do_login_or_signup("googleplus", token_id_login2,
                                                 access_token_login2, user_id2)

        # PRE-TESTs. Añadimos un componente, utilizado en las pruebas
        print "PRETEST 3: Subir un componente al sistema (para asegurarnos de que existe en el sistema)."
        print "Componente no predeterminado, con 2 versiones. Id: linkedin-timeline"
        print "Ignorar el status de salida de este TEST"
        print "Status esperado: 201 "
        versions_list = [
            "stable", "usability_defects", "accuracy_defects",
            "latency_defects"
        ]
        params = urllib.urlencode(
            {
                'url': 'https://github.com/JuanFryS/linkedin-timeline',
                'component_id': 'linkedin-timeline',
                'description':
                'Web component to obtain the timeline of the social network Linkedin using Polymer',
                'social_network': 'linkedin',
                'input_type': 'None',
                'output_type': 'posts',
                'versions': versions_list,
                'predetermined': 'False'
            },
            doseq=True)
        test_utils.make_request("PUT",
                                components_basepath,
                                params,
                                201,
                                None,
                                preTest=True)

        # PRETEST
        print "PRETEST 4: Añadimos credenciales de linkedin al perfil de usuario 2"
        print "Status esperado: 201"
        request_uri = "/api/oauth/linkedin/credenciales"
        params = urllib.urlencode({
            'token_id': "token_linkedin",
            'access_token': "access_token_linkedin"
        })
        test_utils.make_request("PUT",
                                request_uri,
                                params,
                                201,
                                session2,
                                preTest=True)

        if option == "dashboard":

            # TESTs relativos a la modificación de info de usuario (añadir un componente al usuario)
            # TEST 1
            print "TEST 1: Modificar info de usuario, caso añadir un componente al dashboard del usuario 1 (El componente no existe en el sistema)"
            print "Status esperado: 304 (El recurso no se modifica)"
            request_uri = users_basepath + "/" + user_id1
            params = urllib.urlencode({'component': 'componenteError'})
            test_utils.make_request("POST", request_uri, params, 304, session1)

            # TEST 2
            print "TEST 2: Modificar info de usuario, caso añadir un componente al dashboard del usuario 1 (Cookie de sesión correcta)"
            print "El usuario no tiene añadidas credenciales de linkedin, por lo que no se le añade el componente"
            print "Status esperado: 304"
            params = urllib.urlencode({'component': 'linkedin-timeline'})
            test_utils.make_request("POST", request_uri, params, 304, session1)

            # TEST 3
            print "TEST 3: Modificar info de usuario, caso añadir un componente al dashboard del usuario 2 (Cookie de sesión correcta)"
            print "Status esperado: 200"
            request_uri = users_basepath + "/" + user_id2
            params = urllib.urlencode({'component': 'linkedin-timeline'})
            test_utils.make_request("POST", request_uri, params, 200, session2)

            # TESTs relativos a la obtención de componentes de usuario
            # TEST 4
            print "TEST 4: Obtener la lista de componentes del usuario1, proporcionando una cookie de sesion"
            print "(parámetro de filtrado por usuario)"
            print "Status esperado: 204 (El usuario no tiene componentes añadidos a su dashboard)"
            request_uri = components_basepath + "?filter=user"
            params = urllib.urlencode({})
            test_utils.make_request("GET", request_uri, params, 204, session1)

            # TEST 5
            print "TEST 5: Obtener la lista de componentes del usuario2, proporcionando una cookie de sesion"
            print "(parámetro de filtrado por usuario)"
            print "Status esperado: 200"
            request_uri = components_basepath + "?filter=user"
            params = urllib.urlencode({})
            test_utils.make_request("GET", request_uri, params, 200, session2)

            # TEST 6
            print "TEST 6: Obtener la lista de componentes del usuario 2, proporcionando una cookie de sesion"
            print "(Combinamos el parámetro de filtrado por red social y el filtrado por usuario con el formato de lista reducido)"
            print "Status esperado: 204 (El usuario no tiene componentes de la red social Twitter)"
            request_uri = components_basepath + "?social_network=twitter&filter=user&list_format=reduced"
            test_utils.make_request("GET", request_uri, params, 204, session1)

            # TEST 7
            print "TEST 7: Obtener la lista de componentes del usuario 2, proporcionando una cookie de sesion"
            print "(Combinamos el parámetro de filtrado por red social y el filtrado por usuario con el formato de lista reducido)"
            print "En este caso obtenemos los componentes de linkedin del usuario"
            print "Status esperado: 200"
            request_uri = components_basepath + "?social_network=linkedin&filter=user&list_format=reduced"
            test_utils.make_request("GET", request_uri, params, 200, session2)

            # TEST 8
            print "TEST 8: Obtener la lista de componentes, proporcionando una cookie de sesion"
            print "(Combinamos el parámetro de filtrado por red social y el filtrado por usuario con el formato de lista completo)"
            print "Status esperado: 204"
            request_uri = components_basepath + "?social_network=linkedin&filter=user&list_format=complete"
            test_utils.make_request("GET", request_uri, params, 204, session1)

            # TEST 9
            print "TEST 9: Obtener info de usuario 1"
            print "Status esperado: 200"
            request_uri = users_basepath + "/" + user_id1
            test_utils.make_request("GET", request_uri, params, 200, session1)

            # TEST 10
            print "TEST 9: Obtener info de usuario 1, con formato de lista de componentes detallado"
            print "Status esperado: 200"
            request_uri = users_basepath + "/" + user_id1 + "?component_info=detailed"
            test_utils.make_request("GET", request_uri, params, 200, session1)

        elif option == 'dashboard_borrado':
            component_rel_uri = "/linkedin-timeline"

            # PRETEST 5
            print "PRETEST 5: Añadimos el componente al dashboard de usuario 2, si no está añadido ya"
            print "Status esperado: 200 (Ignorar status de este caso)"
            request_uri = users_basepath + "/" + user_id2
            params = urllib.urlencode({'component': 'linkedin-timeline'})
            test_utils.make_request("POST",
                                    request_uri,
                                    params,
                                    200,
                                    session2,
                                    preTest=True)

            # PRETEST 6
            print "PRETEST 6: Obtenemos la info de usuario, con objeto de ver los componentes que tiene incluidos en su dashboard"
            print "Status esperado: 200"
            request_uri = users_basepath + "/" + user_id2 + "?component_info=detailed"
            params = urllib.urlencode({})
            test_utils.make_request("GET",
                                    request_uri,
                                    params,
                                    200,
                                    session2,
                                    preTest=True)

            # TESTs relativos al borrado de componentes de usuario
            # Pruebas de casos de error
            # TEST 11
            print "TEST 11: Borrar el componente del usuario, sin cookie"
            print "Status esperado: 401"
            request_uri = components_basepath + component_rel_uri
            test_utils.make_request("DELETE", request_uri, params, 401, None)

            # TEST 12
            print "TEST 12: Borrar el componente del usuario, proporcionando una cookie incorrecta"
            print "Status esperado: 400"
            request_uri = components_basepath + component_rel_uri
            test_utils.make_request("DELETE",
                                    request_uri,
                                    params,
                                    400,
                                    session_error,
                                    printHeaders=True)

            # printH 13
            print "TEST 13: Borrar el componente del usuario, a un componente que no existe"
            print "Status esperado: 400"
            request_uri = components_basepath + "/component_error"
            test_utils.make_request("DELETE", request_uri, params, 400,
                                    session_error)

            # Casos de éxito
            # TEST 14
            print "TEST 14: Eliminar componente del usuario 2, con cookie de sesión correcta"
            print "Status esperado: 200"
            request_uri = components_basepath + component_rel_uri
            test_utils.make_request("DELETE", request_uri, params, 200,
                                    session2)

            # TEST 15
            print "TEST 15: Obtener info de usuario 2"
            print "(No debe aparecer el componente eliminado en la lista de componentes de usuario)"
            print "Status esperado: 200"
            request_uri = users_basepath + "/" + user_id2
            test_utils.make_request("GET", request_uri, params, 200, session2)

            # TEST 16
            print "TEST 16: Volver a añadir el componente"
            print "Status esperado: 200"
            request_uri = users_basepath + "/" + user_id2
            params = urllib.urlencode({'component': 'linkedin-timeline'})
            test_utils.make_request("POST", request_uri, params, 200, session2)

            # TEST 17
            print "TEST 17: Eliminar el componente del dashboard del usuario 1"
            print "Status esperado: 200"
            params = urllib.urlencode({})
            request_uri = components_basepath + component_rel_uri + "?scope=user"
            test_utils.make_request("DELETE", request_uri, params, 200,
                                    session2)

            # TEST 18
            print "TEST 18: Obtener lista filtrada de componentes (filter=user), proporcionando la cookie de sesión del usuario 1"
            print "(No debe aparecer el componente eliminado)"
            print "Status esperado: 204"
            request_uri = components_basepath + "?filter=user&list_format=complete"
            test_utils.make_request("GET", request_uri, params, 204, session2)

            # TEST 19
            print "TEST 19: Intentar eliminar el componente del dashboard del usuario 1, estando eliminado ya"
            print "Status esperado: 404"
            request_uri = components_basepath + component_rel_uri + "?scope=user"
            test_utils.make_request("DELETE", request_uri, params, 404,
                                    session2)

            # TEST 20
            print "TEST 20: Obtener info sobre el componente"
            print "(Para verificar que no se ha eliminado por error el componente general)"
            print "Status esperado: 200"
            request_uri = components_basepath + component_rel_uri
            test_utils.make_request("GET", request_uri, params, 200, session2)

        elif option == 'dashboard_predeterminados':
            user_id3 = "id_usuario3"
            user_id4 = "id_usuario4"
            user_id5 = "id_usuario5"
            session3 = None
            session4 = None
            session5 = None

            # PRETESTs 5 y 6: Añadimos los componentes que se van a añadir de forma predeterminada al dashboard de usuario (Si no están añadidos ya)
            print "PRETEST 5: Subir un componente predeterminado al sistema (insignia-fb-prededeterminada)."
            print "Status esperado: 201 "
            request_uri = "/api/componentes"
            version_list = ['stable', 'usability_defects', 'latency_defects']
            params = urllib.urlencode(
                {
                    'url':
                    'https://github.com/JuanFryS/insignia-fb-prededeterminada',
                    'component_id': 'insignia-fb-predetermined',
                    'description':
                    'Web component to show the user profile in Facebook using Polymer',
                    'social_network': 'facebook',
                    'input_type': 'None',
                    'output_type': 'post',
                    'versions': version_list,
                    'predetermined': "True"
                },
                doseq=True)
            test_utils.make_request("PUT",
                                    request_uri,
                                    params,
                                    201,
                                    None,
                                    preTest=True)

            print "PRETEST 6: Subir un componente predeterminado al sistema (fb-timeline)."
            print "Este componente tiene varias versiones definidas"
            print "Status esperado: 201 "
            params = urllib.urlencode(
                {
                    'url':
                    'https://github.com/JuanFryS/fb-timeline-predetermined',
                    'component_id': 'fb-timeline-predetermined',
                    'description':
                    'Web component to obtain the timeline of Facebook using Polymer',
                    'social_network': 'facebook',
                    'input_type': 'None',
                    'output_type': 'post',
                    'versions': version_list,
                    'predetermined': "True"
                },
                doseq=True)
            test_utils.make_request("PUT",
                                    request_uri,
                                    params,
                                    201,
                                    None,
                                    preTest=True)

            # PRETEST 7
            print "PRETEST 7: Añadimos un componente cualquiera al sistema (No predeterminado)"
            print "Status esperado: 201 "
            params = urllib.urlencode(
                {
                    'url': 'https://github.com/JuanFryS/fb-messages',
                    'component_id': 'fb-messages',
                    'description':
                    'Web component to obtain messages from your facebook account',
                    'social_network': 'facebook',
                    'input_type': 'None',
                    'output_type': 'text',
                    'versions': versions_list,
                    'predetermined': "False"
                },
                doseq=True)
            test_utils.make_request("PUT",
                                    request_uri,
                                    params,
                                    201,
                                    None,
                                    preTest=True)

            # PRETEST 21: Creamos un nuevo usuario en el sistema (Realizando login mediante facebook)
            request_uri = "/api/oauth/facebook/signup"
            print "PRETEST 21: Signup de usuario 3 en el sistema\n Ignorar el status de este caso"
            print "Probaremos que al añadir un nuevo usuario al sistema, se le añadan los componentes predeterminados"
            print "Ignorar el status de salida de este TEST"
            print "Status esperado: 201 "
            token_id_login = "******"
            access_token_login = "******"
            params = urllib.urlencode({
                'token_id': token_id_login,
                'access_token': access_token_login,
                'user_identifier': user_id3
            })
            session3 = test_utils.make_request("POST", request_uri, params,
                                               201, None, True)

            # PRETEST 22: Creamos un nuevo usuario en el sistema (Realizando login mediante facebook)
            print "PRETEST 22: Signup de usuario 4 en el sistema\n Ignorar el status de este caso"
            print "Probaremos que al añadir un nuevo usuario al sistema, se le añadan los componentes predeterminados"
            print "Ignorar el status de salida de este TEST"
            print "Status esperado: 201 "
            token_id_login = "******"
            access_token_login = "******"
            params = urllib.urlencode({
                'token_id': token_id_login,
                'access_token': access_token_login,
                'user_identifier': user_id4
            })
            session4 = test_utils.make_request("POST", request_uri, params,
                                               201, None, True)

            # PRETEST 23: Creamos un nuevo usuario en el sistema (Realizando login mediante googleplus)
            print "PRETEST 23: Signup de usuario 5 en el sistema\n Ignorar el status de este caso"
            print "Probaremos que al añadir un nuevo usuario al sistema, se le añadan los componentes predeterminados"
            print "Ignorar el status de salida de este TEST"
            print "Status esperado: 201 "
            token_id_login = "******"
            access_token_login = "******"
            params = urllib.urlencode({
                'token_id': token_id_login,
                'access_token': access_token_login,
                'user_identifier': user_id5
            })
            session5 = test_utils.make_request("POST", request_uri, params,
                                               201, None, True)

            # TEST 24
            print "TEST 24: Intentamos añadir un componente predeterminado al usuario 3"
            print "Status esperado: 304 (Ya estaba añadido anteriormente)"
            request_uri = users_basepath + "/" + user_id3
            params = urllib.urlencode(
                {'component': 'insignia-fb-prededetermined'})
            test_utils.make_request("POST", request_uri, params, 304, session3)

            # TEST 25: Añadimos un componente cualquiera al usuario
            print "TEST 25: Añadimos un componente cualquiera al usuario 3"
            print "Status esperado: 200"
            request_uri = users_basepath + "/" + user_id3
            params = urllib.urlencode({'component': 'fb-messages'})
            test_utils.make_request("POST",
                                    request_uri,
                                    params,
                                    200,
                                    session3,
                                    preTest=True)

            # Tests de obtención de componentes de usuario
            params = urllib.urlencode({})
            request_uri = components_basepath + "?filter=user&list_format=complete"

            # TEST 26
            print "TEST 26: Listamos los detalles sobre los componentes de usuario 3."
            print "(Deben aparecer los componentes predeterminados y el añadido)"
            print "Status esperado: 200"
            test_utils.make_request("GET", request_uri, params, 200, session3)

            # TEST 27
            print "TEST 27: Listamos los detalles sobre los componentes de usuario 4."
            print "(Deben aparecer los componentes predeterminados)"
            print "Status esperado: 200"
            test_utils.make_request("GET", request_uri, params, 200, session4)

            # TEST 28
            print "TEST 28: Listamos los detalles sobre los componentes de usuario 5."
            print "(Deben aparecer los componentes predeterminados)"
            print "Status esperado: 200"
            test_utils.make_request("GET", request_uri, params, 200, session5)

            # Cerramos las tres sesiones iniciadas en esta opcion de testeo
            test_utils.do_logout("googleplus", session3)
            test_utils.do_logout("googleplus", session4)
            test_utils.do_logout("googleplus", session5)

        # Opcion para probar el Round-Robin implementado para el versionado de componentes
        elif option == "dashboard_versionado":
            # Declaracion de variables auxiliares
            user_id3 = "id_usuario3"
            user_id4 = "id_usuario4"
            user_id5 = "id_usuario5"
            user_id6 = "id_usuario6"

            session3 = None
            session4 = None
            session5 = None
            session6 = None

            token_id_login3 = "id_component_users_test_token3"
            token_id_login4 = "id_component_users_test_token4"
            token_id_login5 = "id_component_users_test_token5"
            token_id_login6 = "id_component_users_test_token6"

            access_token_login3 = "googleTEST3"
            access_token_login4 = "googleTEST4"
            access_token_login5 = "googleTEST5"
            access_token_login6 = "googleTEST6"

            # Login / Sign-up en el sistema de los usuarios de prueba
            session3 = test_utils.do_login_or_signup("googleplus",
                                                     token_id_login3,
                                                     access_token_login3,
                                                     user_id3)
            session4 = test_utils.do_login_or_signup("googleplus",
                                                     token_id_login4,
                                                     access_token_login4,
                                                     user_id4)
            session5 = test_utils.do_login_or_signup("googleplus",
                                                     token_id_login5,
                                                     access_token_login5,
                                                     user_id5)
            session6 = test_utils.do_login_or_signup("googleplus",
                                                     token_id_login6,
                                                     access_token_login6,
                                                     user_id6)
            print "################### PRUEBAS VERSIONADO ######################"
            print "PRETEST: Añadimos un componente con tres versiones al sistema"
            version_list = ['stable', 'usability_defects', 'latency_defects']
            print "PRETEST 7: Añadimos un componente cualquiera al sistema (No predeterminado)"
            print "Status esperado: 201 "
            request_uri = "/api/componentes"
            params = urllib.urlencode(
                {
                    'url': 'https://github.com/JuanFryS/google-posts',
                    'component_id': 'google-posts',
                    'description':
                    'Web component to obtain your google plus timeline',
                    'social_network': 'googleplus',
                    'input_type': 'None',
                    'output_type': 'text',
                    'versions': version_list,
                    'predetermined': "False"
                },
                doseq=True)
            test_utils.make_request("PUT",
                                    request_uri,
                                    params,
                                    201,
                                    None,
                                    preTest=True)

            print "TEST 29: Añadimos el componente al usuario 3"
            print "Status esperado: 200"
            request_uri = users_basepath + "/" + user_id3
            params = urllib.urlencode({'component': 'google-posts'})
            test_utils.make_request("POST",
                                    request_uri,
                                    params,
                                    200,
                                    session3,
                                    preTest=False)

            print "TEST 30: Añadimos el componente al usuario 4"
            print "Status esperado: 200"
            request_uri = users_basepath + "/" + user_id4
            params = urllib.urlencode({'component': 'google-posts'})
            test_utils.make_request("POST",
                                    request_uri,
                                    params,
                                    200,
                                    session4,
                                    preTest=False)

            print "TEST 31: Añadimos el componente al usuario 5"
            print "Status esperado: 200"
            request_uri = users_basepath + "/" + user_id5
            params = urllib.urlencode({'component': 'google-posts'})
            test_utils.make_request("POST",
                                    request_uri,
                                    params,
                                    200,
                                    session5,
                                    preTest=False)

            print "TEST 32: Añadimos el componente al usuario 6"
            print "Status esperado: 200"
            request_uri = users_basepath + "/" + user_id6
            params = urllib.urlencode({'component': 'google-posts'})
            test_utils.make_request("POST",
                                    request_uri,
                                    params,
                                    200,
                                    session6,
                                    preTest=False)

            print "TEST 33: Obtenemos la información sobre el usuario 3"
            print "Status esperado: 200 (Comprobar si se le ha asignado la versión correcta)"
            request_uri = users_basepath + "/" + user_id3 + "?component_info=detailed"
            params = urllib.urlencode({})
            test_utils.make_request("GET",
                                    request_uri,
                                    params,
                                    200,
                                    session3,
                                    preTest=False)

            print "TEST 34: Obtenemos la información sobre el usuario 4"
            print "Status esperado: 200 (Comprobar si se le ha asignado la versión correcta)"
            request_uri = users_basepath + "/" + user_id4 + "?component_info=detailed"
            params = urllib.urlencode({})
            test_utils.make_request("GET",
                                    request_uri,
                                    params,
                                    200,
                                    session4,
                                    preTest=False)

            print "TEST 35: Obtenemos la información sobre el usuario 5"
            print "Status esperado: 200 (Comprobar si se le ha asignado la versión correcta)"
            request_uri = users_basepath + "/" + user_id5 + "?component_info=detailed"
            params = urllib.urlencode({})
            test_utils.make_request("GET",
                                    request_uri,
                                    params,
                                    200,
                                    session5,
                                    preTest=False)

            print "TEST 36: Obtenemos la información sobre el usuario 6"
            print "Status esperado: 200 (Comprobar si se le ha asignado la versión correcta)"
            request_uri = users_basepath + "/" + user_id6 + "?component_info=detailed"
            params = urllib.urlencode({})
            test_utils.make_request("GET",
                                    request_uri,
                                    params,
                                    200,
                                    session6,
                                    preTest=False)

            # Cerramos las tres sesiones iniciadas en esta opcion de testeo
            test_utils.do_logout("googleplus", session3)
            test_utils.do_logout("googleplus", session4)
            test_utils.do_logout("googleplus", session5)
            test_utils.do_logout("googleplus", session6)

        # Cerramos todas las sesiones iniciadas en los tests
        test_utils.do_logout("googleplus", session1)
        test_utils.do_logout("googleplus", session2)

        # Cerramos conexión e imprimimos el ratio de test ok vs erróneos
        test_utils.closeConnection()
        test_utils.tests_status()

    elif option == "help":
        print "Script para hacer pruebas a la API de Componentes y Usuarios de PicBit, en conjunto (funcionalidades de alto nivel) "
        print "(api/componentes y api/usuarios)"
        print "Uso: python api_componentes_usuarios_tester.py [dashboard | dashboard_borrado | dashboard_predeterminados | dashboard_versionado | help]"
    else:
        print "ERROR: opción incorrecta"
        print "Uso: python api_componentes_usuarios_tester.py [dashboard | dashboard_borrado | dashboard_predeterminados | dashboard_versionado | help]"
def main():
	components_basepath = "/api/componentes"
	users_basepath = "/api/usuarios"
	session1 = None
	session2 = None
	session_error = "session=session_error"
	user_id1 = "id_usuario_dashboard_1"
	user_id2 = "id_usuario_dashboard_2"

	# Sets the option param
	option = None
	if len(sys.argv) == 2:
		option = sys.argv[1]


	if option in ["dashboard", "dashboard_borrado", "dashboard_predeterminados"]:
		# We open the connection with the server
		test_utils.openConnection(False) # Realizamos pruebas en local (remote=False)

		# Iniciamos sesión con dos usuarios en el sistema
		token_id_login = "******"
		access_token_login = "******"
		token_id_login2 = "id_component_users_test_token2"
		access_token_login2 = "googleTEST2"
		session1 = test_utils.do_login_or_signup("googleplus", token_id_login, access_token_login, user_id1)
		session2 = test_utils.do_login_or_signup("googleplus", token_id_login2, access_token_login2, user_id2)

		# PRE-TESTs. Añadimos dos componentes a utilizar en las pruebas
		print "PRETEST 3: Subir un componente al sistema (para asegurarnos de que existe en el sistema)."
		print "Componente no predeterminado. Id: linkedin-timeline"
		print "Ignorar el status de salida de este TEST"
		print "Status esperado: 201 "
		params = urllib.urlencode({'url': 'https://github.com/JuanFryS/linkedin-timeline',
	            'component_id': 'linkedin-timeline',
	            'description': 'Web component to obtain the timeline of the social network Linkedin using Polymer',
	            'social_network': 'linkedin',
	            'input_type': 'None',
	            'output_type': 'photo',
	            'versions': 'stable',
	            'predetermined': 'False'
		})
		test_utils.make_request("PUT", components_basepath, params, 201, None, preTest=True)


		if option == "dashboard":

			# TESTs relativos a la modificación de info de usuario (añadir un componente al usuario)
			# TEST 1
			print "TEST 1: Modificar info de usuario, caso añadir un componente al dashboard del usuario 1 (El componente no existe en el sistema)"
			print "Status esperado: 304 (El recurso no se modifica)"
			request_uri = users_basepath + "/" + user_id1
			params = urllib.urlencode({'component': 'componenteError'})
			test_utils.make_request("POST", request_uri, params, 304, session1)

			# TEST 2
			print "TEST 2: Modificar info de usuario, caso añadir un componente al dashboard del usuario 1 (Cookie de sesión correcta)"
			print "Status esperado: 200"
			params = urllib.urlencode({'component': 'linkedin-timeline'})
			test_utils.make_request("POST", request_uri, params, 200, session1)

			# TEST 3
			print "TEST 3: Modificar info de usuario, caso añadir un componente al dashboard del usuario 2 (Cookie de sesión correcta)"
			print "Status esperado: 200"
			request_uri = users_basepath + "/" + user_id2
			params = urllib.urlencode({'component': 'linkedin-timeline'})
			test_utils.make_request("POST", request_uri, params, 200, session2)

			# TESTs relativos a la obtención de componentes de usuario
			# TEST 4
			print "TEST 4: Obtener la lista de componentes, proporcionando una cookie de sesion"
			print "(parámetro de filtrado por usuario)"
			print "Status esperado: 200"
			request_uri = components_basepath + "?filter=user"
			params = urllib.urlencode({})
			test_utils.make_request("GET", request_uri, params, 200, session1)

			# TEST 5
			print "TEST 5: Obtener la lista de componentes, proporcionando una cookie de sesion"
			print "(Combinamos el parámetro de filtrado por red social y el filtrado por usuario con el formato de lista reducido)"
			print "Status esperado: 204 (El usuario no tiene componentes de la red social Twitter)"
			request_uri = components_basepath + "?social_network=twitter&filter=user&list_format=reduced"
			test_utils.make_request("GET", request_uri, params, 204, session1)

			# TEST 6
			print "TEST 6: Obtener la lista de componentes, proporcionando una cookie de sesion"
			print "(Combinamos el parámetro de filtrado por red social y el filtrado por usuario con el formato de lista reducido)"
			print "En este caso obtenemos los componentes de instagram del usuario"
			print "Status esperado: 200"
			request_uri = components_basepath + "?social_network=linkedin&filter=user&list_format=reduced"
			test_utils.make_request("GET", request_uri, params, 200, session1)

			# TEST 7
			print "TEST 7: Obtener la lista de componentes, proporcionando una cookie de sesion"
			print "(Combinamos el parámetro de filtrado por red social y el filtrado por usuario con el formato de lista completo)"
			print "Status esperado: 200"
			request_uri = components_basepath + "?social_network=linkedin&filter=user&list_format=complete"
			test_utils.make_request("GET", request_uri, params, 200, session1)

			# TEST 8
			print "TEST 8: Obtener info de usuario"
			print "Status esperado: 200"
			request_uri = users_basepath + "/" + user_id1
			test_utils.make_request("GET", request_uri, params, 200, session1)

			# TEST 9
			print "TEST 9: Obtener info de usuario, con formato de lista de componentes detallado"
			print "Status esperado: 200"
			request_uri = users_basepath + "/" + user_id1 + "?component_info=detailed"
			test_utils.make_request("GET", request_uri, params, 200, session1)

		elif option == 'dashboard_borrado':
			component_rel_uri = "/linkedin-timeline"

			# PRETEST 4
			print "PRETEST 4: Añadimos el componente al dashboard de usuario, si no está añadido ya"
			print "Status esperado: 200 (Ignorar status de este caso)"
			request_uri = users_basepath + "/" + user_id1
			params = urllib.urlencode({'component': 'linkedin-timeline'})
			test_utils.make_request("POST", request_uri, params, 200, session1, preTest=True)

			# PRETEST 5
			print "PRETEST 5: Obtenemos la info de usuario, con objeto de ver los componentes que tiene incluidos en su dashboard"
			print "Status esperado: 200"
			request_uri = users_basepath + "/" + user_id1 + "?component_info=detailed"
			params = urllib.urlencode({})
			test_utils.make_request("GET", request_uri, params, 200, session1, preTest=True)

			# TESTs relativos al borrado de componentes de usuario
			# Pruebas de casos de error
			# TEST 10
			print "TEST 10: Borrar el componente del usuario, sin cookie"
			print "Status esperado: 401"
			request_uri = components_basepath + component_rel_uri
			test_utils.make_request("DELETE", request_uri, params, 401, None)

			# TEST 11
			print "TEST 11: Borrar el componente del usuario, proporcionando una cookie incorrecta"
			print "Status esperado: 400"
			request_uri = components_basepath + component_rel_uri
			test_utils.make_request("DELETE", request_uri, params, 400, session_error)

			# TEST 12
			print "TEST 12: Borrar el componente del usuario, a un componente que no existe"
			print "Status esperado: 400"
			request_uri = components_basepath + "/component_error"
			test_utils.make_request("DELETE", request_uri, params, 400, session_error)

			# Casos de éxito
			# TEST 13
			print "TEST 13: Eliminar componente del usuario 1, con cookie de sesión correcta"
			print "Status esperado: 200"
			request_uri = components_basepath + component_rel_uri
			test_utils.make_request("DELETE", request_uri, params, 200, session1)

			# TEST 14
			print "TEST 14: Obtener info de usuario 1"
			print "(No debe aparecer el componente eliminado en la lista de componentes de usuario)"
			print "Status esperado: 200"
			request_uri = users_basepath + "/" + user_id1
			test_utils.make_request("GET", request_uri, params, 200, session1)

			# TEST 15
			print "TEST 15: Volver a añadir el componente"
			print "Status esperado: 200"
			request_uri = users_basepath + "/" + user_id1
			params = urllib.urlencode({'component': 'linkedin-timeline'})
			test_utils.make_request("POST", request_uri, params, 200, session1)

			# TEST 16
			print "TEST 16: Eliminar el componente del dashboard del usuario 1"
			print "Status esperado: 200"
			params = urllib.urlencode({})
			request_uri = components_basepath + component_rel_uri + "?scope=user"
			test_utils.make_request("DELETE", request_uri, params, 200, session1)

			# TEST 17
			print "TEST 17: Obtener lista filtrada de componentes (filter=user), proporcionando la cookie de sesión del usuario 1"
			print "(No debe aparecer el componente eliminado)"
			print "Status esperado: 204"
			request_uri = components_basepath + "?filter=user&list_format=complete"
			test_utils.make_request("GET", request_uri, params, 204, session1)

			# TEST 18
			print "TEST 18: Intentar eliminar el componente del dashboard del usuario 1, estando eliminado ya"
			print "Status esperado: 404"
			request_uri = components_basepath + component_rel_uri + "?scope=user"
			test_utils.make_request("DELETE", request_uri, params, 404, session1)

			# TEST 19
			print "TEST 19: Obtener info sobre el componente"
			print "(Para verificar que no se ha eliminado por error el componente general)"
			print "Status esperado: 200"
			request_uri = components_basepath + component_rel_uri
			test_utils.make_request("GET", request_uri, params, 200, session1)


		elif option == 'dashboard_predeterminados':
			user_id3 = "id_usuario3"
			session3 = None

			# PRETESTs 4 y 5: Añadimos los componentes que se van a añadir de forma predeterminada al dashboard de usuario (Si no están añadidos ya)
			print "PRETEST 4: Subir un componente predeterminado al sistema (insignia-fb-prededeterminada)."
			print "Status esperado: 201 "
			request_uri = "/api/componentes"
			params = urllib.urlencode({'url': 'https://github.com/JuanFryS/insignia-fb-prededeterminada',
		            'component_id': 'insignia-fb-prededeterminada',
		            'description': 'Web component to obtain the timeline of Twitter using Polymer',
		            'social_network': 'facebook' ,
		            'input_type': 'None',
		            'output_type': 'post',
		            'versions': 'stable',
		            'predetermined': "True"
			})
			test_utils.make_request("PUT", request_uri, params, 201, None, preTest=True)

			# PRETEST 6
			print "PRETEST 6: Añadimos un componente cualquiera al sistema (No predeterminado)"
			print "Status esperado: 201 "
			versions_list = ["stable", "usability_defects"]
			params = urllib.urlencode({'url': 'https://github.com/JuanFryS/google-inbox',
		            'component_id': 'google-inbox',
		            'description': 'Web component to obtain mails from your gmail account',
		            'social_network': 'googleplus',
		            'input_type': 'None',
		            'output_type': 'text',
		            'versions': versions_list,
		            'predetermined': "False"
			}, doseq=True)
			test_utils.make_request("PUT", request_uri, params, 201, None, preTest=True)

			# TEST 20: Creamos un nuevo usuario en el sistema (Realizando login mediante googleplus)
			request_uri = "/api/oauth/googleplus/signup"
			print "TEST 20: Login de usuario 1 en el sistema\n Ignorar el status de este caso"
			print "Ignorar el status de salida de este TEST"
			print "Status esperado: 201 "
			token_id_login = "******"
			access_token_login = "******"
			params = urllib.urlencode({'token_id': token_id_login, 'access_token': access_token_login,
			 'user_identifier': user_id3 })
			session3 = test_utils.make_request("POST", request_uri, params, 201, None, True)

			# TEST 21
			print "TEST 21: Intentamos añadir un componente predeterminado al usuario"
			print "Status esperado: 304 (Ya estaba añadido anteriormente)"
			request_uri = users_basepath + "/" + user_id3
			params = urllib.urlencode({'component': 'insignia-fb-prededeterminada'})
			test_utils.make_request("POST", request_uri, params, 304, session3)

			# TEST 22: Añadimos un componente cualquiera al usuario
			print "TEST 22: Añadimos un componente cualquiera al usuario"
			print "Status esperado: 200"
			request_uri = users_basepath + "/" + user_id3
			params = urllib.urlencode({'component': 'google-inbox'})
			test_utils.make_request("POST", request_uri, params, 200, session3, preTest=True)

			# TEST 23
			print "TEST 23: Listamos los detalles sobre los componentes de usuario."
			print "(Deben aparecer los componentes predeterminados y el añadido)"
			print "Status esperado: 200"
			params = urllib.urlencode({})
			request_uri = components_basepath + "?filter=user&list_format=complete"
			test_utils.make_request("GET", request_uri, params, 200, session3)

		# POST-TESTs. Logout de usuario en el sistema
		request_uri = '/api/oauth/googleplus/logout'
		params = urllib.urlencode({})
		print "POSTEST 1: Logout de usuario 1 en el sistema"
		print "Ignorar el status de este caso"
		test_utils.make_request("POST", request_uri, params, 200, session1, True)

		# Cerramos conexión e imprimimos el ratio de test ok vs erróneos
		test_utils.closeConnection()
		test_utils.tests_status()

	elif option == "help":
		print "Script para hacer pruebas a la API de Componentes y Usuarios de PicBit, en conjunto (funcionalidades de alto nivel) "
		print "(api/componentes y api/usuarios)"
		print "Uso: python api_componentes_usuarios_tester.py [dashboard | dashboard_borrado | dashboard_predeterminados| help]"
Exemplo n.º 7
0
def main():
    network_list = [
        "facebook", "stackoverflow", "instagram", "linkedin", "googleplus"
    ]

    if len(sys.argv) >= 2:
        social_network = sys.argv[1]
    else:
        social_network = ''
    option = None
    basePath = "/api/oauth/" + social_network

    if len(sys.argv) == 3:
        option = sys.argv[2]

    if social_network in network_list:
        # Conexion con el servidor
        test_utils.openConnection(False)  # Pruebas en local(remote=False)

        if social_network == "googleplus" or social_network == "facebook":
            session1 = None
            session2 = None
            old_session = None
            token_id1 = "id" + social_network
            token_id2 = "id" + social_network + "2"
            user_id1 = "user" + social_network + "1"
            user_id2 = "user" + social_network + "2"
            access_token2 = social_network + "2TEST"
            # Si no se especifica una opción, se realizan las pruebas relativas al sign-up, login,
            # obtención de credenciales y logout
            if option == None:
                # TESTs relativos a los casos de sign-up en el sistema
                # TEST 1: Sign up de usuario 1 en el sistema
                request_uri = basePath + "/signup"
                print "TEST 1: Sign up de usuario 1 en el sistema"
                print "Status esperado: 201"
                access_token = social_network + "TEST1"
                params = urllib.urlencode({
                    'token_id': token_id1,
                    'access_token': access_token,
                    'user_identifier': user_id1
                })
                session1 = test_utils.make_request("POST", request_uri, params,
                                                   201, None, True)

                # TEST 2
                request_uri = basePath + "/signup"
                print "TEST 2: Sign up repetido de usuario1 (error 400)"
                print "Status esperado: 400"
                access_token = social_network + "TEST2"
                params = urllib.urlencode({
                    'token_id': token_id1,
                    'access_token': access_token,
                    'user_identifier': user_id1
                })
                test_utils.make_request("POST", request_uri, params, 400, None)

                # TEST 4
                print "TEST 4: Sign up de usuario 2 con un identificador de usuario ya en uso en el sistema"
                print "Status esperado: 400"
                params = urllib.urlencode({
                    'token_id': token_id2,
                    'access_token': access_token,
                    'user_identifier': user_id1
                })
                test_utils.make_request("POST", request_uri, params, 400, None)

                # TEST 5
                print "TEST 5: Sign up de usuario 2 en el sistema (caso correcto)"
                print "Status esperado: 201"
                params = urllib.urlencode({
                    'token_id': token_id2,
                    'access_token': access_token,
                    'user_identifier': user_id2
                })
                session2 = test_utils.make_request("POST", request_uri, params,
                                                   201, None, True)

                # TEST 6
                request_uri = basePath + "/credenciales/" + token_id1
                print "TEST 6:  obtenemos credenciales de usuario 1, para comprobar que podemos acceder a recursos de usuario"
                print "Status esperado: 200"
                params = urllib.urlencode({})
                test_utils.make_request("GET", request_uri, params, 200,
                                        session1)

                # TEST 7
                request_uri = basePath + "/logout"
                print "TEST 7: Logout de usuario 1 en el sistema"
                print "Status esperado: 200"
                test_utils.make_request("POST", request_uri, params, 200,
                                        session1)

                # TEST 8
                print "TEST 8: Logout de usuario 2 en el sistema"
                print "Status esperado: 200"
                test_utils.make_request("POST", request_uri, params, 200,
                                        session2)

                #Tests relativos a los casos de Login
                session1 = None
                session2 = None
                # TEST 9
                request_uri = basePath + "/login"
                print "TEST 9: Login de sesión correcto (usuario 1)"
                print "Status esperado: 200"
                access_token = social_network + "TEST"
                params = urllib.urlencode({
                    'token_id': token_id1,
                    'access_token': access_token
                })
                session1 = test_utils.make_request("POST", request_uri, params,
                                                   200, None, True)

                # TEST 10
                print "TEST 10: Login de sesion iniciada anteriormente (usuario1)"
                print "Con esta prueba pretendemos ver si la cookie que devuelve en un login repetido es la misma que en el login inicial"
                print "Status esperado: 200"
                access_token = social_network + "ModifyTEST"
                params = urllib.urlencode({
                    'token_id': token_id1,
                    'access_token': access_token
                })
                old_session = session1
                session1 = test_utils.make_request("POST", request_uri, params,
                                                   200, None, True)

                # TEST 11
                request_uri = basePath + "/credenciales/" + token_id1
                print "TEST 11: Obtenemos credenciales con una sesion invalidada"
                print "Status esperado: 400 (la cookie proporcionada no es correcta)"
                params = urllib.urlencode({})
                test_utils.make_request("GET",
                                        request_uri,
                                        params,
                                        400,
                                        old_session,
                                        printHeaders=True)

                # Tests relativos al método GET de credenciales
                # Obtener credenciales sin cookie
                # TEST 12
                request_uri = basePath + "/credenciales/" + token_id1
                print "TEST 12: Obtener credenciales sin cookie de sesion"
                print "Status esperado: 200 (Retorna únicamente el id de usuario propietario de las credenciales)"
                params = urllib.urlencode({})
                test_utils.make_request("GET", request_uri, params, 200, None)

                # TEST 13
                # Obtener credenciales con cookie
                request_uri = basePath + "/credenciales/" + token_id2
                print "TEST 13: Obtener credenciales con cookie de sesion, a una credencial que no es propiedad del usuario"
                print "Status esperado: 200 (Solo retorna el id de usuario propietario del token)"
                params = urllib.urlencode({})
                test_utils.make_request("GET", request_uri, params, 200,
                                        session1)

                # Obtener credenciales con cookie
                # TEST 14
                request_uri = basePath + "/credenciales/" + token_id1
                print "TEST 14: Obtener credenciales con cookie de sesion, a una credencial propiedad del usuario"
                print "Status esperado: 200"
                params = urllib.urlencode({})
                test_utils.make_request("GET", request_uri, params, 200,
                                        session1)

                #Tests relativos a Logouts
                # TEST 15
                request_uri = basePath + "/logout"
                print "TEST 15: Logout sin cookie de sesion"
                print "Status esperado: 401"
                params = urllib.urlencode({})
                test_utils.make_request("POST", request_uri, params, 401, None)

                # TEST 16
                # Logout con cookie antigua / incorrecta
                request_uri = basePath + "/logout"
                print "TEST 16: Logout con cookie de sesión antigua"
                print "Status esperado: 400"
                params = urllib.urlencode({})
                test_utils.make_request("POST",
                                        request_uri,
                                        params,
                                        400,
                                        old_session,
                                        printHeaders=True)

                # TEST 17
                # Se desloguea el usuario logueado (usuario1)
                print "TEST 17: Logout con cookie de sesion (usuario1)"
                print "Status esperado: 200"
                test_utils.make_request("POST", request_uri, params, 200,
                                        session1)

                # Hacemos un flujo de login, obtención credenciales y logout para verificar que se realiza correctamente
                # TEST 18
                # Login (prueba de nueva sesión y actualizar credenciales)
                request_uri = basePath + "/login"
                print "TEST 18: Prueba de nueva sesión y actualizar credenciales (usuario 1)"
                print "Status esperado: 200"
                access_token = social_network + "TEST18"
                params = urllib.urlencode({
                    'token_id': token_id1,
                    'access_token': access_token
                })
                session1 = test_utils.make_request("POST", request_uri, params,
                                                   200, None)

                # TEST 19
                # Obtener credenciales con cookie antigua
                request_uri = basePath + "/credenciales/" + token_id1
                print "TEST 19: Obtener credenciales con cookie de sesión antigua"
                print "Status esperado: 400"
                params = urllib.urlencode({})
                test_utils.make_request("GET",
                                        request_uri,
                                        params,
                                        400,
                                        old_session,
                                        printHeaders=True)

                # TEST 20
                # Logout sin cookie
                request_uri = basePath + "/logout"
                print "TEST 20: Logout sin cookie de sesion"
                print "Status esperado: 401"
                params = urllib.urlencode({})
                test_utils.make_request("POST", request_uri, params, 401, None)

                # TEST 21
                # Se desloguea el usuario logueado (usuario1)
                print "TEST 21: Logout con cookie de sesion (usuario1)"
                print "Status esperado: 200"
                test_utils.make_request("POST", request_uri, params, 200,
                                        session1)

                print "TESTs finalizados. Comprobar las entidades de tipo Usuario y Token almacenadas en datastore"
                print "NOTA: para obtener los resultados esperados en estas pruebas, es necesario ejecutar el script con la BBDD vacía",
                print "(o en su defecto, sin los usuarios 1 y 2)"

            elif option == "borrado":
                session_error = "session=session_error"
                # PRE-TEST 1: Login en el sistema de usuario de prueba 1
                access_token = social_network + "tokenTODELETE1"
                session1 = test_utils.do_login_or_signup(
                    social_network, token_id1, access_token, user_id1)

                # PRE-TEST 2: Login en el sistema de usuario de prueba 2
                access_token = social_network + "tokenTODELETE2"
                session2 = test_utils.do_login_or_signup(
                    social_network, token_id2, access_token, user_id2)

                # TEST 21
                # Borrar credenciales de usuarios de prueba2
                request_uri = basePath + "/credenciales/" + token_id2
                print "TEST 21: Borrar creedenciales sin cookie de sesión"
                print "Status esperado: 401"
                params = urllib.urlencode({})
                test_utils.make_request("DELETE", request_uri, params, 401,
                                        None)

                # TEST 22
                # Borrar credenciales de usuarios de prueba2 con cookie de sesión incorrecta
                request_uri = basePath + "/credenciales/" + token_id2
                print "TEST 21: Borrar creedenciales con cookie de sesión incorrecta"
                print "Status esperado: 400"
                params = urllib.urlencode({})
                test_utils.make_request("DELETE",
                                        request_uri,
                                        params,
                                        400,
                                        session_error,
                                        printHeaders=True)

                # TEST 23
                # Borrar credenciales de usuario de prueba1 (Estando logeado)
                request_uri = basePath + "/credenciales/" + token_id1
                print "TEST 23: Borrado de credenciales estando logeado (usuario 1)"
                print "Status esperado: 403 (Es el único token de login en el sistema)"
                params = urllib.urlencode({})
                test_utils.make_request("DELETE", request_uri, params, 403,
                                        session1)

                # TEST 24
                # Borrar credenciales de usuario de prueba2 (Con una cookie incorrecta)
                request_uri = basePath + "/credenciales/" + token_id2
                print "TEST 24: Borrado de credenciales estando logeado, pero sin ser propietario de las mismas"
                print "Status esperado: 401 (Es el único token de login en el sistema)"
                params = urllib.urlencode({})
                test_utils.make_request("DELETE", request_uri, params, 401,
                                        session1)

                # TEST 25
                # Borrar credenciales de usuario de prueba2 (Estando logeado)
                request_uri = basePath + "/credenciales/" + token_id2
                print "TEST 25: Borrado de credenciales estando logeado"
                print "Status esperado: 403"
                params = urllib.urlencode({})
                test_utils.make_request("DELETE", request_uri, params, 403,
                                        session2)

                # TEST 26
                # Borrar credenciales de usuario de prueba 2 por segunda vez (Caso de error)
                request_uri = basePath + "/" + token_id2
                print "TEST 26: Intento de borrado por segunda vez (credenciales de usuario 2)"
                print "Status esperado: 404"
                params = urllib.urlencode({})
                test_utils.make_request("DELETE", request_uri, params, 404,
                                        session2)

                # POST-TEST 1: Realizar logout en el sistema (usuario 1)
                request_uri = basePath + "/logout"
                print "POST-TEST 1: Logout de usuario 1 con cookie de sesión"
                print "Status esperado: 200"
                # Se desloguea el usuario logueado en el PRE TEST 1
                test_utils.make_request("POST", request_uri, params, 200,
                                        session1)

                # POST-TEST 2: Realizar logout en el sistema (usuario 2)
                request_uri = basePath + "/logout"
                print "POST-TEST 2: Logout de usuario 2 con cookie de sesión"
                print "Status esperado: 200"
                # Se desloguea el usuario logueado en el PRE TEST 2
                test_utils.make_request("POST", request_uri, params, 200,
                                        session2)

                print "\nTESTs finalizados. Comprobar el borrado de las entidades de tipo Token en datastore"

        elif social_network == "stackoverflow" or social_network == "instagram" or social_network == "linkedin":
            session1 = None
            session2 = None
            token_id1 = "TOKENid" + social_network
            access_token1 = social_network + "TEST"
            token_id2 = "idERROR" + social_network + "2"
            user_id1 = "userTESTING1"
            user_id2 = "userTESTING2"
            session_error = "session=sessionError"

            # Iniciamos dos sesiones distintas en googleplus para realizar las pruebas
            # PRE-TEST 1: Login en el sistema de usuario de prueba 1
            token_id_login = "******"
            access_token_login = "******"
            session1 = test_utils.do_login_or_signup("googleplus",
                                                     token_id_login,
                                                     access_token_login,
                                                     user_id1)

            # PRE-TEST 2: Login en el sistema de usuario de prueba 2
            token_id_login2 = "idgoogle2"
            access_token_login2 = "googleTEST2"
            session2 = test_utils.do_login_or_signup("googleplus",
                                                     token_id_login2,
                                                     access_token_login2,
                                                     user_id2)

            if option == None:
                # Tests a la API seleccionada
                # TESTs relativos a la creacion/actualizacion de credenciales (POST /api/oauth/{social_network})
                # TEST 1
                # Añadir credenciales nuevas al sistema (Sin cookie de sesion)
                request_uri = "/api/oauth/" + social_network + "/credenciales"
                print "TEST 1: Añadir nuevo par de credenciales, sin cookie de sesión"
                print "Status esperado: 401"
                params = urllib.urlencode({
                    'token_id': token_id1,
                    'access_token': access_token1
                })
                test_utils.make_request("PUT", request_uri, params, 401, None)

                # TEST 2
                print "TEST 2: Añadir nuevo par de credenciales, con cookie de sesión incorrecta"
                print "Status esperado: 400"
                params = urllib.urlencode({
                    'token_id': token_id1,
                    'access_token': access_token1
                })
                test_utils.make_request("PUT",
                                        request_uri,
                                        params,
                                        400,
                                        session_error,
                                        printHeaders=True)

                # TEST 3
                print "TEST 3: Añadir nuevo par de credenciales proporcionando un solo parámetro"
                print "Status esperado: 400"
                params = urllib.urlencode({'token_id': token_id1})
                test_utils.make_request("PUT", request_uri, params, 400,
                                        session1)

                # TEST 4
                print "TEST 4: Añadir nuevo par de credenciales"
                print "Status esperado: 201"
                access_token1 = social_network + "ModifyTEST"
                params = urllib.urlencode({
                    'token_id': token_id1,
                    'access_token': access_token1
                })
                test_utils.make_request("PUT", request_uri, params, 201,
                                        session1)

                # TEST 5
                print "TEST 5: Añadir par de credenciales repetido"
                print "Status esperado: 400"
                access_token1 = social_network + "ModifyTEST"
                params = urllib.urlencode({
                    'token_id': token_id1,
                    'access_token': access_token1
                })
                test_utils.make_request("PUT", request_uri, params, 400,
                                        session1)

                # TEST 6
                print "TEST 6: Actualizar par de credenciales con cookie de sesión incorrecta"
                print "Status esperado: 400"
                request_uri = "/api/oauth/" + social_network + "/credenciales/" + token_id1
                access_token1 = social_network + "ModifyTEST"
                params = urllib.urlencode({'access_token': access_token1})
                test_utils.make_request("POST",
                                        request_uri,
                                        params,
                                        400,
                                        session_error,
                                        printHeaders=True)

                # TEST 7
                print "TEST 7: Actualizar par de credenciales con cookie de sesión de otro usuario"
                print "Status esperado: 403"
                params = urllib.urlencode({
                    'token_id': token_id1,
                    'access_token': access_token1
                })
                test_utils.make_request("POST", request_uri, params, 403,
                                        session2)

                # TEST 8
                print "TEST 8: Actualizar par de credenciales"
                print "Status esperado: 200"
                params = urllib.urlencode({'access_token': access_token1})
                test_utils.make_request("POST", request_uri, params, 200,
                                        session1)

                # TEST relativos a la obtencion de credenciales (GET /api/oauth/{social_network}/credenciales/{token_id})
                # TEST 9
                # Get (Sin cookie)
                request_uri = "/api/oauth/" + social_network + "/credenciales/" + token_id1
                print "TEST 9: Obtener credenciales sin cookie de sesión"
                print "Status esperado: 200 (Retorna el propietario de las credenciales)"
                params = urllib.urlencode({})
                test_utils.make_request("GET", request_uri, params, 200, None)

                # TEST 10
                # TODO Get (Con Cookie)
                print "TEST 10: Obtener credenciales con cookie"
                print "Status esperado: 200"
                params = urllib.urlencode({})
                test_utils.make_request("GET", request_uri, params, 200,
                                        session1)

                # TEST 11
                # TODO GET credenciales (Con una cookie de sesion incorrecta)
                print "TEST 11: Obtener credenciales con cookie incorrecta"
                print "Status esperado: 400"
                params = urllib.urlencode({})
                test_utils.make_request("GET",
                                        request_uri,
                                        params,
                                        400,
                                        session_error,
                                        printHeaders=True)

                # TEST 12
                # TODO GET credenciales (Cookie de sesion correcta, a un token id no existente en el sistema)
                request_uri = "/api/oauth/" + social_network + "/credenciales/tokenERROR"
                print "TEST 12: Intento de obtener un token no existente en el sistema"
                print "Status esperado: 404"
                params = urllib.urlencode({})
                test_utils.make_request("GET", request_uri, params, 404,
                                        session1)

            elif option == 'borrado':

                # TEST 13
                # Borrar credenciales de usuarios de prueba 1
                request_uri = basePath + "/credenciales/" + token_id1
                print "TEST 13: Borrar creedenciales sin cookie de sesión"
                print "Status esperado: 401"
                params = urllib.urlencode({})
                test_utils.make_request("DELETE", request_uri, params, 401,
                                        None)

                # TEST 14
                # Borrar credenciales de usuario de prueba1 (Con una cookie incorrecta)
                request_uri = basePath + "/credenciales/" + token_id1
                print "TEST 14: Borrado de credenciales estando logeado, pero sin ser propietario de las mismas"
                print "Status esperado: 401"
                params = urllib.urlencode({})
                test_utils.make_request("DELETE", request_uri, params, 401,
                                        session2)

                # TEST 15
                # Borrar credenciales de usuario de prueba1 (Estando logeado)
                request_uri = basePath + "/credenciales/" + token_id1
                print "TEST 15: Borrado de credenciales estando logeado (usuario 1)"
                print "Status esperado: 204"
                params = urllib.urlencode({})
                test_utils.make_request("DELETE", request_uri, params, 204,
                                        session1)

                # TEST 16
                # Borrar credenciales de usuario de prueba 2 por segunda vez (Caso de error)
                request_uri = basePath + "/credenciales/" + token_id2
                print "TEST 16: Intento de borrado por segunda vez (credenciales de usuario 2)"
                print "Status esperado: 404"
                params = urllib.urlencode({})
                test_utils.make_request("DELETE", request_uri, params, 404,
                                        session2)

            # POST-TESTs
            # Se realiza logout de los usuarios que iniciaron sesión de cara a las pruebas
            test_utils.do_logout("googleplus", session1)
            test_utils.do_logout("googleplus", session2)

            print "\nTESTs finalizados. Comprobar las entidades de tipo Usuario y Token almacenadas en datastore"
        else:
            print "Error: es obligatorio proporcionar un parámetro válido para indicar que red social se pretende testear"
            print "Uso: python api_oauth_tester.py {googleplus|stackoverflow|facebook|instagram|linkedin|twitter} [borrado]"
        # Cerramos conexión
        test_utils.tests_status()
        test_utils.closeConnection()

    elif social_network == "help":
        print "Script para hacer pruebas a la API de Oauth de PicBit (api/oauth/{social_network})"
        print "Uso: api_oauth_tester {facebook | googleplus | stackoverflow | instagram | linkedin} [borrado]"
Exemplo n.º 8
0
def main():
	network_list = ["facebook", "stackoverflow", "instagram", "linkedin", "googleplus"]

	if len(sys.argv) >= 2:
		social_network = sys.argv[1]
	else:
		social_network = ''
	option = None
	basePath = "/api/oauth/" + social_network

	if len(sys.argv) == 3:
		option = sys.argv[2]

	if social_network in network_list:
		# Conexion con el servidor
		test_utils.openConnection(False) # Pruebas en local(remote=False)

		if social_network == "googleplus" or social_network=="facebook":
			session1 = None
			session2 = None
			old_session = None
			token_id1 = "id" + social_network
			token_id2 = "id" + social_network + "2"
			user_id1 = "user" + social_network + "1"
			user_id2 = "user" + social_network + "2"
			access_token2 = social_network + "2TEST"
			# Si no se especifica una opción, se realizan las pruebas relativas al sign-up, login,
			# obtención de credenciales y logout
			if option == None:
				# TESTs relativos a los casos de sign-up en el sistema
				# TEST 1: Sign up de usuario 1 en el sistema
				request_uri = basePath + "/signup"
				print "TEST 1: Sign up de usuario 1 en el sistema"
				print "Status esperado: 201"
				access_token = social_network + "TEST1"
				params = urllib.urlencode({'token_id': token_id1, 'access_token': access_token,
					'user_identifier': user_id1})
				session1 = test_utils.make_request("POST", request_uri, params, 201, None, True)

				# TEST 2
				request_uri = basePath + "/signup"
				print "TEST 2: Sign up repetido de usuario1 (error 400)"
				print "Status esperado: 400"
				access_token = social_network + "TEST1"
				params = urllib.urlencode({'token_id': token_id1, 'access_token': access_token,
					'user_identifier': user_id1})
				test_utils.make_request("POST", request_uri, params, 400, None)

				# TEST 3
				request_uri = basePath + "/signup"
				access_token = social_network + "TEST2"
				print "TEST 3: Sign up de usuario proporcionando un token_id ya registrado en el sistema"
				print "Status esperado: 400"
				params = urllib.urlencode({'token_id': token_id1, 'access_token': access_token,
					'user_identifier': user_id1})
				test_utils.make_request("POST", request_uri, params, 400, None)

				# TEST 4
				print "TEST 4: Sign up de usuario 2 con un identificador de usuario ya en uso en el sistema"
				print "Status esperado: 400"
				params = urllib.urlencode({'token_id': token_id2, 'access_token': access_token,
					'user_identifier': user_id1})
				test_utils.make_request("POST", request_uri, params, 400, None)

				# TEST 5
				print "TEST 5: Sign up de usuario 2 en el sistema (caso correcto)"
				print "Status esperado: 201"
				params = urllib.urlencode({'token_id': token_id2, 'access_token': access_token,
					'user_identifier': user_id2})
				session2 = test_utils.make_request("POST", request_uri, params, 201, None, True)

				# TEST 6
				request_uri = basePath + "/credenciales/" + token_id1
				print "TEST 6:  obtenemos credenciales de usuario 1, para comprobar que podemos acceder a recursos de usuario"
				print "Status esperado: 200"
				params = urllib.urlencode({})
				test_utils.make_request("GET", request_uri, params, 200, session1)

				# TEST 7
				request_uri = basePath + "/logout"
				print "TEST 7: Logout de usuario 1 en el sistema"
				print "Status esperado: 200"
				test_utils.make_request("POST", request_uri, params, 200, session1)

				# TEST 8
				print "TEST 8: Logout de usuario 2 en el sistema"
				print "Status esperado: 200"
				test_utils.make_request("POST", request_uri, params, 200, session2)

				#Tests relativos a los casos de Login
				session1 = None
				session2 = None
				# TEST 9
				request_uri = basePath + "/login"
				print "TEST 9: Login de sesión correcto (usuario 1)"
				print "Status esperado: 200"
				access_token = social_network + "TEST"
				params = urllib.urlencode({'token_id': token_id1, 'access_token': access_token})
				session1 = test_utils.make_request("POST", request_uri, params, 200, None, True)

				# TEST 10
				print "TEST 10: Login de sesion iniciada anteriormente (usuario1)"
				print "Con esta prueba pretendemos ver si la cookie que devuelve en un login repetido es la misma que en el login inicial"
				print "Status esperado: 200"
				access_token = social_network + "ModifyTEST"
				params = urllib.urlencode({'token_id': token_id1, 'access_token': access_token})
				old_session = session1
				session1 = test_utils.make_request("POST", request_uri, params, 200, None, True)

				# TEST 11
				request_uri = basePath + "/credenciales/" + token_id1
				print "TEST 11: Obtenemos credenciales con una sesion invalidada"
				print "Status esperado: 400 (la cookie proporcionada no es correcta)"
				params = urllib.urlencode({})
				test_utils.make_request("GET", request_uri, params, 400, old_session)

				# Tests relativos al método GET de credenciales
				# Obtener credenciales sin cookie
				# TEST 12
				request_uri = basePath + "/credenciales/" + token_id1
				print "TEST 12: Obtener credenciales sin cookie de sesion"
				print "Status esperado: 200 (Retorna únicamente el id de usuario propietario de las credenciales)"
				params = urllib.urlencode({})
				test_utils.make_request("GET", request_uri, params, 200, None)

				# TEST 13
				# Obtener credenciales con cookie
				request_uri = basePath + "/credenciales/" + token_id2
				print "TEST 13: Obtener credenciales con cookie de sesion, a una credencial que no es propiedad del usuario"
				print "Status esperado: 200 (Solo retorna el id de usuario propietario del token)"
				params = urllib.urlencode({})
				test_utils.make_request("GET", request_uri, params, 200, session1)

				# Obtener credenciales con cookie
				# TEST 14
				request_uri = basePath + "/credenciales/" + token_id1
				print "TEST 14: Obtener credenciales con cookie de sesion, a una credencial propiedad del usuario"
				print "Status esperado: 200"
				params = urllib.urlencode({})
				test_utils.make_request("GET", request_uri, params, 200, session1)

				#Logouts
				# TEST 15
				request_uri = basePath + "/logout"
				print "TEST 15: Logout sin cookie de sesion"
				print "Status esperado: 401"
				params = urllib.urlencode({})
				test_utils.make_request("POST", request_uri, params, 401, None)

				# TEST 16
				# Se desloguea el usuario logueado (usuario1)
				print "TEST 16: Logout con cookie de sesion (usuario1)"
				print "Status esperado: 200"
				test_utils.make_request("POST", request_uri, params, 200, session1)

				# TEST 17
				# Login (prueba de nueva sesión y actualizar credenciales)
				request_uri = basePath + "/login"
				print "TEST 17: Prueba de nueva sesión y actualizar credenciales (usuario 1)"
				print "Status esperado: 200"
				access_token = social_network + "Modify2TEST"
				params = urllib.urlencode({'token_id': token_id1, 'access_token': access_token})
				test_utils.make_request("POST", request_uri, params, 200, None)

				# TEST 18
				# Obtener credenciales con cookie antigua
				request_uri = basePath + "/credenciales/" + token_id1
				print "TEST 18: Obtener credenciales con cookie de sesión antigua"
				print "Status esperado: 400"
				params = urllib.urlencode({})
				test_utils.make_request("GET", request_uri, params, 400, session1)

				# TEST 19
				# Logout con cookie antigua
				request_uri = basePath + "/logout"
				print "TEST 19: Logout sin cookie de sesion"
				print "Status esperado: 401"
				params = urllib.urlencode({})
				test_utils.make_request("POST", request_uri, params, 401, None)

				# TEST 20
				# Logout con cookie antigua / incorrecta
				request_uri = basePath + "/logout"
				print "TEST 20: Logout con cookie de sesión antigua"
				print "Status esperado: 400"
				params = urllib.urlencode({})
				test_utils.make_request("POST", request_uri, params, 400, session1)

				print "TESTs finalizados. Comprobar las entidades de tipo Usuario y Token almacenadas en datastore"
				print "NOTA: para obtener los resultados esperados en estas pruebas, es necesario ejecutar el script con la BBDD vacía",
				print "(o en su defecto, sin los usuarios 1 y 2)"

			elif option == "borrado":
				# PRE-TEST 1: Login en el sistema de usuario de prueba 1
				request_uri = basePath + "/login"
				print "PRE-TEST 1: Login en el sistema de usuario de prueba 1"
				print "Status esperado: 200"
				access_token = social_network + "tokenTODELETE1"
				params = urllib.urlencode({'token_id': token_id1, 'access_token': access_token})
				session1 = test_utils.make_request("POST", request_uri, params, 200, None)

				# PRE-TEST 2: Login en el sistema de usuario de prueba 2
				request_uri = basePath + "/login"
				print "PRE-TEST 2: Login en el sistema de usuario de prueba 1"
				print "Status esperado: 200"
				access_token = social_network + "tokenTODELETE2"
				params = urllib.urlencode({'token_id': token_id2, 'access_token': access_token})
				session2 = test_utils.make_request("POST", request_uri, params, 200, None)

				# TEST 21
				# Borrar credenciales de usuarios de prueba2
				request_uri = basePath + "/credenciales/" + token_id2
				print "TEST 21: Borrar creedenciales sin cookie de sesión"
				print "Status esperado: 401"
				params = urllib.urlencode({})
				test_utils.make_request("DELETE", request_uri, params, 401, None)

				# TEST 22
				# Borrar credenciales de usuario de prueba1 (Estando logeado)
				request_uri = basePath + "/credenciales/" + token_id1
				print "TEST 22: Borrado de credenciales estando logeado (usuario 1)"
				print "Status esperado: 403 (Es el único token de login en el sistema)"
				params = urllib.urlencode({})
				test_utils.make_request("DELETE", request_uri, params, 403, session1)

				# TEST 23
				# Borrar credenciales de usuario de prueba2 (Con una cookie incorrecta)
				request_uri = basePath + "/credenciales/" + token_id2
				print "TEST 23: Borrado de credenciales estando logeado, pero sin ser propietario de las mismas"
				print "Status esperado: 401 (Es el único token de login en el sistema)"
				params = urllib.urlencode({})
				test_utils.make_request("DELETE", request_uri, params, 401, session1)

				# TEST 24
				# Borrar credenciales de usuario de prueba2 (Estando logeado)
				request_uri = basePath + "/credenciales/" + token_id2
				print "TEST 24: Borrado de credenciales estando logeado"
				print "Status esperado: 403"
				params = urllib.urlencode({})
				test_utils.make_request("DELETE", request_uri, params, 403, session2)

				# TEST 25
				# Borrar credenciales de usuario de prueba 2 por segunda vez (Caso de error)
				request_uri = basePath + "/" + token_id2
				print "TEST 25: Intento de borrado por segunda vez (credenciales de usuario 2)"
				print "Status esperado: 404"
				params = urllib.urlencode({})
				test_utils.make_request("DELETE", request_uri, params, 404, session2)

				# POST-TEST 1: Realizar logout en el sistema (usuario 1)
				request_uri = basePath + "/logout"
				print "POST-TEST 1: Logout de usuario 1 con cookie de sesión"
				print "Status esperado: 200"
				# Se desloguea el usuario logueado en el PRE TEST 1
				test_utils.make_request("POST", request_uri, params, 200, session1)

				# POST-TEST 2: Realizar logout en el sistema (usuario 2)
				request_uri = basePath + "/logout"
				print "POST-TEST 2: Logout de usuario 2 con cookie de sesión"
				print "Status esperado: 200"
				# Se desloguea el usuario logueado en el PRE TEST 2
				test_utils.make_request("POST", request_uri, params, 200, session2)

				print "\nTESTs finalizados. Comprobar el borrado de las entidades de tipo Token en datastore"

		elif social_network=="stackoverflow" or social_network=="instagram" or social_network=="linkedin":
			session1 = None
			session2 = None
			token_id1 = "TOKENid" + social_network
			access_token1 = social_network + "TEST"
			token_id2 = "idERROR" + social_network + "2"
			user_id1 = "userTESTING1"
			user_id2 = "userTESTING2"
			session_error = "session=sessionError"

			# Iniciamos dos sesiones distintas en googleplus para realizar las pruebas
			request_uri = "/api/oauth/googleplus/login"
			print "PRETEST 1: Login de usuario 1 por Googleplus\n Ignorar el status de este caso"
			token_id_login = "******"
			access_token_login = "******"
			params = urllib.urlencode({'token_id': token_id_login, 'access_token': access_token_login})
			session1 = test_utils.make_request("POST", request_uri, params, 200, None)

			print "PRETEST 1: Login de usuario 1 por Googleplus\n Ignorar el status de este caso"
			token_id_login2 = "idgoogle2"
			access_token_login2 = "googleTEST2"
			params = urllib.urlencode({'token_id': token_id_login2, 'access_token': access_token_login2})
			session2 = test_utils.make_request("POST", request_uri, params, 200, None)

			if option == None:
				# Tests a la API seleccionada
				# TESTs relativos a la creacion/actualizacion de credenciales (POST /api/oauth/{social_network})
				# TEST 1
				# Añadir credenciales nuevas al sistema (Sin cookie de sesion)
				request_uri = "/api/oauth/" + social_network
				print "TEST 1: Añadir nuevo par de credenciales, sin cookie de sesión"
				print "Status esperado: 401"
				params = urllib.urlencode({'token_id': token_id1, 'access_token':access_token1})
				test_utils.make_request("POST", request_uri, params, 401, None)

				# TEST 2
				print "TEST 2: Añadir nuevo par de credenciales"
				print "Status esperado: 201"
				access_token1 = social_network + "ModifyTEST"
				params = urllib.urlencode({'token_id': token_id1, 'access_token':access_token1})
				test_utils.make_request("POST", request_uri, params, 201, session1)

				# TEST 3
				print "TEST 3: Actualizar par de credenciales"
				print "Status esperado: 200"
				access_token1 = social_network + "ModifyTEST"
				params = urllib.urlencode({'token_id': token_id1, 'access_token':"ToKenMODIFICADO"})
				test_utils.make_request("POST", request_uri, params, 200, session1)

				# TEST 4
				print "TEST 4: Actualizar par de credenciales con cookie de sesión incorrecta"
				print "Status esperado: 400"
				access_token1 = social_network + "ModifyTEST"
				params = urllib.urlencode({'token_id': token_id1, 'access_token':access_token1})
				test_utils.make_request("POST", request_uri, params, 400, session_error)

				# TEST 5
				print "TEST 5: Actualizar credenciales proporcionando un solo parámetro"
				print "Status esperado: 400"
				params = urllib.urlencode({'token_id': token_id2})
				test_utils.make_request("POST", request_uri, params, 400, session1)

				# TEST relativos a la obtencion de credenciales (GET /api/oauth/{social_network}/{token_id})
				# TEST 6
				# Get (Sin cookie)
				request_uri = "/api/oauth/" + social_network + "/credenciales/" + token_id1
				print "TEST 6: Obtener credenciales sin cookie de sesión"
				print "Status esperado: 200 (Retorna el propietario de las credenciales)"
				params = urllib.urlencode({})
				test_utils.make_request("GET", request_uri, params, 200, None)

				# TEST 7
				# TODO Get (Con Cookie)
				print "TEST 7: Obtener credenciales con cookie"
				print "Status esperado: 200"
				params = urllib.urlencode({})
				test_utils.make_request("GET", request_uri, params, 200, session1)

				# TEST 8
				# TODO GET credenciales (Con una cookie de sesion incorrecta)
				print "TEST 8: Obtener credenciales con cookie incorrecta"
				print "Status esperado: 400"
				params = urllib.urlencode({})
				test_utils.make_request("GET", request_uri, params, 400, session_error)

				# TEST 9
				# TODO GET credenciales (Cookie de sesion correcta, a un token id no existente en el sistema)
				request_uri = "/api/oauth/" + social_network + "/credenciales/tokenERROR"
				print "TEST 9: Intento de obtener un token no existente en el sistema"
				print "Status esperado: 404"
				params = urllib.urlencode({})
				test_utils.make_request("GET", request_uri, params, 404, session1)

			elif option == 'borrado':

				# TEST 10
				# Borrar credenciales de usuarios de prueba 1
				request_uri = basePath + "/credenciales/" + token_id1
				print "TEST 10: Borrar creedenciales sin cookie de sesión"
				print "Status esperado: 401"
				params = urllib.urlencode({})
				test_utils.make_request("DELETE", request_uri, params, 401, None)

				# TEST 11
				# Borrar credenciales de usuario de prueba1 (Con una cookie incorrecta)
				request_uri = basePath + "/credenciales/" + token_id1
				print "TEST 11: Borrado de credenciales estando logeado, pero sin ser propietario de las mismas"
				print "Status esperado: 401"
				params = urllib.urlencode({})
				test_utils.make_request("DELETE", request_uri, params, 401, session2)

				# TEST 12
				# Borrar credenciales de usuario de prueba1 (Estando logeado)
				request_uri = basePath + "/credenciales/" + token_id1
				print "TEST 12: Borrado de credenciales estando logeado (usuario 1)"
				print "Status esperado: 204"
				params = urllib.urlencode({})
				test_utils.make_request("DELETE", request_uri, params, 204, session1)

				# TEST 14
				# Borrar credenciales de usuario de prueba 2 por segunda vez (Caso de error)
				request_uri = basePath + "/credenciales/" + token_id2
				print "TEST 14: Intento de borrado por segunda vez (credenciales de usuario 2)"
				print "Status esperado: 404"
				params = urllib.urlencode({})
				test_utils.make_request("DELETE", request_uri, params, 404, session2)


			# POST-TEST 1: Realizar logout en el sistema (usuario 1)
			# Se desloguea el usuario logueado en el PRE TEST 1

			request_uri = "/api/oauth/googleplus/logout"
			print "POST-TEST 1: Logout de usuario 1 con cookie de sesión"
			print "Status esperado: 200"
			test_utils.make_request("POST", request_uri, params,200, session1, preTest=True)



			print "\nTESTs finalizados. Comprobar las entidades de tipo Usuario y Token almacenadas en datastore"
		else:
			print "Error: es obligatorio proporcionar un parámetro válido para indicar que red social se pretende testear"
			print "Uso: python api_oauth_tester.py {googleplus|stackoverflow|facebook|instagram|linkedin|twitter} [borrado]"
		# Cerramos conexión
		test_utils.tests_status()
		test_utils.closeConnection()

	elif social_network == "help":
		print "Script para hacer pruebas a la API de Oauth de PicBit (api/oauth/{social_network})"
		print "Uso: api_oauth_tester {facebook | googleplus | stackoverflow | instagram | linkedin} [borrado]"