# tests.py import subprocess import json import os from django.test import TestCase from django.conf import settings from PIL import Image from lorem_text import lorem import random import string class PanelAPITests(TestCase): def run_httpie_command(self, command): result = subprocess.run(command, shell=True, capture_output=True, text=True) return result.stdout, result.stderr, result.returncode def setUp(self): # Get http_domain from settings self.http_domain = settings.TEST_HTTP_DOMAIN or 'http://127.0.0.1:8000' # Login and get the token email = settings.TEST_USER_EMAIL or 'default_email@test.com' password = settings.TEST_USER_PASSWORD or 'default_password' login_command = f"http POST {self.http_domain}/auth/register/login/ email='{email}' password='{password}'" login_stdout, login_stderr, login_returncode = self.run_httpie_command(login_command) self.assertEqual(login_returncode, 0, f"Login failed: {login_stderr}") login_response = json.loads(login_stdout) self.token = login_response['access_token'] self.refresh_token = login_response['refresh_token'] self.test_usuario_create() def tearDown(self): # Logout and blacklist the token logout_command = f"http POST {self.http_domain}/auth/register/logout/ token='{self.token}'" logout_stdout, logout_stderr, logout_returncode = self.run_httpie_command(logout_command) self.assertEqual(logout_returncode, 0, f"Logout failed: {logout_stderr}") self.assertIn("Token blacklisted successfully", logout_stdout) def create_test_image(self, file_path, size=(100, 100)): # Create a simple image for testing image = Image.new('RGB', size, color=(73, 109, 137)) image.save(file_path) return file_path def generate_random_string(self, length=10, use_digits=True, use_uppercase=True): chars = string.ascii_lowercase if use_digits: chars += string.digits if use_uppercase: chars += string.ascii_uppercase return ''.join(random.choices(chars, k=length)) def generate_lorem_text(self, length=100): return lorem.words(length) def generate_fake_email(self): return f"{self.generate_random_string(10)}@test.com" def generate_fake_phone(self): return ''.join(random.choices(string.digits, k=10)) ### Create Users Tests def test_usuario_create(self, user_type=None): ### Generate random data to create a user random_email = ''.join(random.choices(string.ascii_lowercase, k=10)) + '@test.com' random_password = ''.join(random.choices(string.ascii_lowercase + string.ascii_uppercase + string.digits, k=10)) random_telefone = ''.join(random.choices(string.digits, k=10)) random_first_name = ''.join(random.choices(string.ascii_lowercase + string.ascii_uppercase, k=10)) random_last_name = ''.join(random.choices(string.ascii_lowercase + string.ascii_uppercase, k=10)) ### User Admin ### if user_type == 'admin' or user_type is None: create_command = f"http -A bearer -a {self.token} -f POST {self.http_domain}/accounts/usuarios/ email='{random_email}' password='{random_password}' categoria='admin' first_name='{random_first_name}' last_name='{random_last_name}' telefone='{random_telefone}'" create_stdout, create_stderr, create_returncode = self.run_httpie_command(create_command) self.assertEqual(create_returncode, 0, f"Create failed: {create_stderr}") create_response = json.loads(create_stdout) #print(f"Create response Admin: {create_response['results']['id']}") self.assertIn('id', create_response['results'], "Create response does not contain ID") # Store user ID for subsequent tests self.new_user_admin_id = create_response['results']['id'] ### Generate random data to create a user random_email = ''.join(random.choices(string.ascii_lowercase, k=10)) + '@test.com' random_password = ''.join(random.choices(string.ascii_lowercase + string.ascii_uppercase + string.digits, k=10)) random_telefone = ''.join(random.choices(string.digits, k=10)) random_first_name = ''.join(random.choices(string.ascii_lowercase + string.ascii_uppercase, k=10)) random_last_name = ''.join(random.choices(string.ascii_lowercase + string.ascii_uppercase, k=10)) ### User Cliente ### if user_type == 'cliente' or user_type is None: create_command = f"http -A bearer -a {self.token} -f POST {self.http_domain}/accounts/usuarios/ email='{random_email}' password='{random_password}' categoria='cliente' first_name='{random_first_name}' last_name='{random_last_name}' telefone='{random_telefone}'" create_stdout, create_stderr, create_returncode = self.run_httpie_command(create_command) self.assertEqual(create_returncode, 0, f"Create failed: {create_stderr}") create_response = json.loads(create_stdout) #print(f"Create response Cliente: {create_response}") self.assertIn('id', create_response['results'], "Create response does not contain ID") # Store user ID for subsequent tests self.new_user_cliente_id = create_response['results']['id'] # Favoritos Tests def test_favoritos_crud_operations(self): cliente_id = self.new_user_cliente_id ### Get any imovel from v1/properties_nested/ list_command = f"http GET {self.http_domain}/v1/properties_nested?page_size=2" list_stdout, list_stderr, list_returncode = self.run_httpie_command(list_command) self.assertEqual(list_returncode, 0, f"Properties list failed: {list_stderr}") create_response = json.loads(list_stdout) imovel_id = create_response['results'][0]['id'] new_imovel_id = create_response['results'][1]['id'] ### Get any imovel from v1/types list_command = f"http GET {self.http_domain}/v1/types?page_size=2" list_stdout, list_stderr, list_returncode = self.run_httpie_command(list_command) self.assertEqual(list_returncode, 0, f"Types list failed: {list_stderr}") create_response = json.loads(list_stdout) tipo_imovel_id = create_response['results'][0]['id'] new_tipo_imovel_id = create_response['results'][1]['id'] # Create create_command = f"http -A bearer -a {self.token} POST {self.http_domain}/panel/favoritos/ cliente='{cliente_id}' tipo_imovel='{tipo_imovel_id}' imovel='{imovel_id}'" create_stdout, create_stderr, create_returncode = self.run_httpie_command(create_command) self.assertEqual(create_returncode, 0, f"Favoritos create failed: {create_stderr}") create_response = json.loads(create_stdout) #print(f"Create response for test_favoritos_crud_operations: {create_response}") favorito_id = create_response['results']['id'] # List list_command = f"http -A bearer -a {self.token} GET {self.http_domain}/panel/favoritos/" list_stdout, list_stderr, list_returncode = self.run_httpie_command(list_command) self.assertEqual(list_returncode, 0, f"Favoritos list failed: {list_stderr}") # Retrieve retrieve_command = f"http -A bearer -a {self.token} GET {self.http_domain}/panel/favoritos/{favorito_id}/" retrieve_stdout, retrieve_stderr, retrieve_returncode = self.run_httpie_command(retrieve_command) self.assertEqual(retrieve_returncode, 0, f"Favoritos retrieve failed: {retrieve_stderr}") # Update update_command = f"http -A bearer -a {self.token} PUT {self.http_domain}/panel/favoritos/{favorito_id}/ cliente='{cliente_id}' tipo_imovel='{new_tipo_imovel_id}' imovel='{new_imovel_id}'" update_stdout, update_stderr, update_returncode = self.run_httpie_command(update_command) self.assertEqual(update_returncode, 0, f"Favoritos update failed: {update_stderr}") # Delete delete_command = f"http -A bearer -a {self.token} DELETE {self.http_domain}/panel/favoritos/{favorito_id}/" delete_stdout, delete_stderr, delete_returncode = self.run_httpie_command(delete_command) self.assertEqual(delete_returncode, 0, f"Favoritos delete failed: {delete_stderr}") self.assertEqual(delete_stdout.strip(), '', "Delete response should be empty for 204 No Content") # Contatos Cliente Tests def test_contatos_cliente_crud_operations(self): cliente_id = self.new_user_cliente_id ### Get any tipo_imovel(type) from v1/properties_nested/ list_command = f"http -A bearer -a {self.token} GET {self.http_domain}/v1/properties_nested?page_size=2" list_stdout, list_stderr, list_returncode = self.run_httpie_command(list_command) self.assertEqual(list_returncode, 0, f"Properties list failed: {list_stderr}") create_response = json.loads(list_stdout) imovel_id = create_response['results'][0]['id'] new_imovel_id = create_response['results'][1]['id'] ### Get any imovel from v1/types list_command = f"http GET {self.http_domain}/v1/types?page_size=2" list_stdout, list_stderr, list_returncode = self.run_httpie_command(list_command) self.assertEqual(list_returncode, 0, f"Types list failed: {list_stderr}") create_response = json.loads(list_stdout) tipo_imovel_id = create_response['results'][0]['id'] new_tipo_imovel_id = create_response['results'][1]['id'] # Create mensagem = self.generate_lorem_text(50) create_command = f"http -A bearer -a {self.token} POST {self.http_domain}/panel/contatos-cliente/ cliente='{cliente_id}' tipo_imovel='{tipo_imovel_id}' imovel='{imovel_id}' mensagem='{mensagem}'" create_stdout, create_stderr, create_returncode = self.run_httpie_command(create_command) self.assertEqual(create_returncode, 0, f"Contatos Cliente create failed: {create_stderr}") create_response = json.loads(create_stdout) contato_id = create_response['results']['id'] # List list_command = f"http -A bearer -a {self.token} GET {self.http_domain}/panel/contatos-cliente/" list_stdout, list_stderr, list_returncode = self.run_httpie_command(list_command) self.assertEqual(list_returncode, 0, f"Contatos Cliente list failed: {list_stderr}") # Retrieve retrieve_command = f"http -A bearer -a {self.token} GET {self.http_domain}/panel/contatos-cliente/{contato_id}/" retrieve_stdout, retrieve_stderr, retrieve_returncode = self.run_httpie_command(retrieve_command) self.assertEqual(retrieve_returncode, 0, f"Contatos Cliente retrieve failed: {retrieve_stderr}") # Update new_mensagem = self.generate_lorem_text(100) update_command = f"http -A bearer -a {self.token} PUT {self.http_domain}/panel/contatos-cliente/{contato_id}/ cliente='{cliente_id}' tipo_imovel='{new_tipo_imovel_id}' imovel='{new_imovel_id}' mensagem='{new_mensagem}'" update_stdout, update_stderr, update_returncode = self.run_httpie_command(update_command) self.assertEqual(update_returncode, 0, f"Contatos Cliente update failed: {update_stderr}") # Delete delete_command = f"http -A bearer -a {self.token} DELETE {self.http_domain}/panel/contatos-cliente/{contato_id}/" delete_stdout, delete_stderr, delete_returncode = self.run_httpie_command(delete_command) self.assertEqual(delete_returncode, 0, f"Contatos Cliente delete failed: {delete_stderr}") self.assertEqual(delete_stdout.strip(), '', "Delete response should be empty for 204 No Content") # Categorias Tests def test_categorias_crud_operations(self): # Create test_image_path = self.create_test_image('test_categoria.jpg') create_command = f"http -A bearer -a {self.token} -f POST {self.http_domain}/panel/categorias/ nome='Empresas' ordem=1 imagem@'{test_image_path}'" create_stdout, create_stderr, create_returncode = self.run_httpie_command(create_command) os.remove(test_image_path) # Clean up the test image file self.assertEqual(create_returncode, 0, f"Categorias create failed: {create_stderr}") create_response = json.loads(create_stdout) self.categoria_id = create_response['results']['id'] # List list_command = f"http -A bearer -a {self.token} GET {self.http_domain}/panel/categorias/" list_stdout, list_stderr, list_returncode = self.run_httpie_command(list_command) self.assertEqual(list_returncode, 0, f"Categorias list failed: {list_stderr}") # Retrieve retrieve_command = f"http -A bearer -a {self.token} GET {self.http_domain}/panel/categorias/{self.categoria_id}/" retrieve_stdout, retrieve_stderr, retrieve_returncode = self.run_httpie_command(retrieve_command) self.assertEqual(retrieve_returncode, 0, f"Categorias retrieve failed: {retrieve_stderr}") # Update test_image_path = self.create_test_image('test_categoria_update.jpg') update_command = f"http -A bearer -a {self.token} -f PUT {self.http_domain}/panel/categorias/{self.categoria_id}/ nome='Empresas2' ordem=2 imagem@'{test_image_path}'" update_stdout, update_stderr, update_returncode = self.run_httpie_command(update_command) os.remove(test_image_path) # Clean up the test image file self.assertEqual(update_returncode, 0, f"Categorias update failed: {update_stderr}") # Posts Tests def test_posts_crud_operations(self): ### verify if self.categoria_id from test_categorias_crud_operations() if not hasattr(self, 'categoria_id'): self.test_categorias_crud_operations() categoria_id = self.categoria_id autor_id = self.new_user_admin_id # Create titulo = self.generate_lorem_text(5) conteudo = self.generate_lorem_text(100) subtitulo = self.generate_lorem_text(10) tags = self.generate_lorem_text(5) create_command = f"http -A bearer -a {self.token} POST {self.http_domain}/panel/posts/ autor='{autor_id}' titulo='{titulo}' data='2024-06-17 15:06:07' categorias=['{categoria_id}'] conteudo='{conteudo}' tags='{tags}' subtitulo='{subtitulo}'" create_stdout, create_stderr, create_returncode = self.run_httpie_command(create_command) self.assertEqual(create_returncode, 0, f"Posts create failed: {create_stderr}") create_response = json.loads(create_stdout) self.post_id = create_response['results']['id'] # List list_command = f"http -A bearer -a {self.token} GET {self.http_domain}/panel/posts/" list_stdout, list_stderr, list_returncode = self.run_httpie_command(list_command) self.assertEqual(list_returncode, 0, f"Posts list failed: {list_stderr}") # Retrieve retrieve_command = f"http -A bearer -a {self.token} GET {self.http_domain}/panel/posts/{self.post_id}/" retrieve_stdout, retrieve_stderr, retrieve_returncode = self.run_httpie_command(retrieve_command) self.assertEqual(retrieve_returncode, 0, f"Posts retrieve failed: {retrieve_stderr}") # Update new_titulo = self.generate_lorem_text(5) new_conteudo = self.generate_lorem_text(100) new_subtitulo = self.generate_lorem_text(10) new_tags = self.generate_lorem_text(5) update_command = f"http -A bearer -a {self.token} PUT {self.http_domain}/panel/posts/{self.post_id}/ autor='{autor_id}' titulo='{new_titulo}' data='2024-06-17 14:55:11' categorias=['{categoria_id}'] conteudo='{new_conteudo}' tags='{new_tags}' subtitulo='{new_subtitulo}'" update_stdout, update_stderr, update_returncode = self.run_httpie_command(update_command) self.assertEqual(update_returncode, 0, f"Posts update failed: {update_stderr}") # Banner Mosaico Tests def test_banners_mosaicos_crud_operations(self): if not hasattr(self, 'post_id'): self.test_posts_crud_operations() post_id = self.post_id # Create test_image_path = self.create_test_image('test_banner.jpg') create_command = f"http -A bearer -a {self.token} -f POST {self.http_domain}/panel/banners-mosaicos/ ordem=1 posts=['{post_id}'] template@'{test_image_path}'" create_stdout, create_stderr, create_returncode = self.run_httpie_command(create_command) os.remove(test_image_path) # Clean up the test image file self.assertEqual(create_returncode, 0, f"Banners Mosaicos create failed: {create_stderr}") create_response = json.loads(create_stdout) banner_id = create_response['results']['id'] # List list_command = f"http -A bearer -a {self.token} GET {self.http_domain}/panel/banners-mosaicos/" list_stdout, list_stderr, list_returncode = self.run_httpie_command(list_command) self.assertEqual(list_returncode, 0, f"Banners Mosaicos list failed: {list_stderr}") # Retrieve retrieve_command = f"http -A bearer -a {self.token} GET {self.http_domain}/panel/banners-mosaicos/{banner_id}/" retrieve_stdout, retrieve_stderr, retrieve_returncode = self.run_httpie_command(retrieve_command) self.assertEqual(retrieve_returncode, 0, f"Banners Mosaicos retrieve failed: {retrieve_stderr}") # Update test_image_path = self.create_test_image('test_banner_update.jpg') update_command = f"http -A bearer -a {self.token} -f PUT {self.http_domain}/panel/banners-mosaicos/{banner_id}/ ordem=4 posts=['{post_id}'] template@'{test_image_path}'" update_stdout, update_stderr, update_returncode = self.run_httpie_command(update_command) os.remove(test_image_path) # Clean up the test image file self.assertEqual(update_returncode, 0, f"Banners Mosaicos update failed: {update_stderr}") # Delete delete_command = f"http -A bearer -a {self.token} DELETE {self.http_domain}/panel/banners-mosaicos/{banner_id}/" delete_stdout, delete_stderr, delete_returncode = self.run_httpie_command(delete_command) self.assertEqual(delete_returncode, 0, f"Banners Mosaicos delete failed: {delete_stderr}") self.assertEqual(delete_stdout.strip(), '', "Delete response should be empty for 204 No Content") # Simulações Tests def test_simulacoes_crud_operations(self): # Create email = self.generate_fake_email() nome = self.generate_random_string() telefone = self.generate_fake_phone() create_command = f"http -A bearer -a {self.token} POST {self.http_domain}/panel/simulacoes/ email='{email}' nome='{nome}' telefone='{telefone}' entrada_disponivel='85456.98' tipo='valor_parcelas' valor_maximo_parcelas='12452.24'" create_stdout, create_stderr, create_returncode = self.run_httpie_command(create_command) self.assertEqual(create_returncode, 0, f"Simulações create failed: {create_stderr}") create_response = json.loads(create_stdout) simulacao_id = create_response['results']['id'] # List list_command = f"http -A bearer -a {self.token} GET {self.http_domain}/panel/simulacoes/" list_stdout, list_stderr, list_returncode = self.run_httpie_command(list_command) self.assertEqual(list_returncode, 0, f"Simulações list failed: {list_stderr}") # Retrieve retrieve_command = f"http -A bearer -a {self.token} GET {self.http_domain}/panel/simulacoes/{simulacao_id}/" retrieve_stdout, retrieve_stderr, retrieve_returncode = self.run_httpie_command(retrieve_command) self.assertEqual(retrieve_returncode, 0, f"Simulações retrieve failed: {retrieve_stderr}") # Update new_email = self.generate_fake_email() new_nome = self.generate_random_string() new_telefone = self.generate_fake_phone() update_command = f"http -A bearer -a {self.token} PUT {self.http_domain}/panel/simulacoes/{simulacao_id}/ email='{new_email}' entrada_disponivel='97653.12' fgts='78567.91' nome='{new_nome}' renda_familiar_mensal='26567.34' telefone='{new_telefone}' tipo='renda_familiar'" update_stdout, update_stderr, update_returncode = self.run_httpie_command(update_command) self.assertEqual(update_returncode, 0, f"Simulações update failed: {update_stderr}") # Delete delete_command = f"http -A bearer -a {self.token} DELETE {self.http_domain}/panel/simulacoes/{simulacao_id}/" delete_stdout, delete_stderr, delete_returncode = self.run_httpie_command(delete_command) self.assertEqual(delete_returncode, 0, f"Simulações delete failed: {delete_stderr}") self.assertEqual(delete_stdout.strip(), '', "Delete response should be empty for 204 No Content") # Assuntos Tests def test_assuntos_crud_operations(self): # Create email = self.generate_fake_email() nome = self.generate_random_string() create_command = f"http -A bearer -a {self.token} POST {self.http_domain}/panel/assuntos/ email='{email}' nome='{nome}'" create_stdout, create_stderr, create_returncode = self.run_httpie_command(create_command) self.assertEqual(create_returncode, 0, f"Assuntos create failed: {create_stderr}") create_response = json.loads(create_stdout) #print(f"Create response for test_assuntos_crud_operations: {create_response}") self.assunto_id = create_response['results']['id'] # List list_command = f"http -A bearer -a {self.token} GET {self.http_domain}/panel/assuntos/" list_stdout, list_stderr, list_returncode = self.run_httpie_command(list_command) self.assertEqual(list_returncode, 0, f"Assuntos list failed: {list_stderr}") # Retrieve retrieve_command = f"http -A bearer -a {self.token} GET {self.http_domain}/panel/assuntos/{self.assunto_id}/" retrieve_stdout, retrieve_stderr, retrieve_returncode = self.run_httpie_command(retrieve_command) self.assertEqual(retrieve_returncode, 0, f"Assuntos retrieve failed: {retrieve_stderr}") # Update new_email = self.generate_fake_email() new_nome = self.generate_random_string() update_command = f"http -A bearer -a {self.token} PUT {self.http_domain}/panel/assuntos/{self.assunto_id}/ email='{new_email}' nome='{new_nome}'" update_stdout, update_stderr, update_returncode = self.run_httpie_command(update_command) self.assertEqual(update_returncode, 0, f"Assuntos update failed: {update_stderr}") # Contatos Tests def test_contatos_crud_operations(self): if not hasattr(self, 'assunto_id'): self.test_assuntos_crud_operations() assunto_id = self.assunto_id # Create nome = self.generate_random_string() email = self.generate_fake_email() telefone = self.generate_fake_phone() cidade = "Vila Velha" estado = "Espírito Santo" mensagem = self.generate_lorem_text(20) create_command = f"http -A bearer -a {self.token} POST {self.http_domain}/panel/contatos/ nome='{nome}' email='{email}' telefone='{telefone}' cidade='{cidade}' estado='{estado}' mensagem='{mensagem}' assunto='{assunto_id}'" create_stdout, create_stderr, create_returncode = self.run_httpie_command(create_command) self.assertEqual(create_returncode, 0, f"Contatos create failed: {create_stderr}") create_response = json.loads(create_stdout) #print(f"Create response for test_contatos_crud_operations: {create_response}") contato_id = create_response['results']['id'] # List list_command = f"http -A bearer -a {self.token} GET {self.http_domain}/panel/contatos/" list_stdout, list_stderr, list_returncode = self.run_httpie_command(list_command) self.assertEqual(list_returncode, 0, f"Contatos list failed: {list_stderr}") # Retrieve retrieve_command = f"http -A bearer -a {self.token} GET {self.http_domain}/panel/contatos/{contato_id}/" retrieve_stdout, retrieve_stderr, retrieve_returncode = self.run_httpie_command(retrieve_command) self.assertEqual(retrieve_returncode, 0, f"Contatos retrieve failed: {retrieve_stderr}") # Update new_nome = self.generate_random_string() new_email = self.generate_fake_email() new_telefone = self.generate_fake_phone() new_cidade = "Santo Amaro" new_estado = "São Paulo" new_mensagem = self.generate_lorem_text(30) update_command = f"http -A bearer -a {self.token} PUT {self.http_domain}/panel/contatos/{contato_id}/ nome='{new_nome}' email='{new_email}' telefone='{new_telefone}' cidade='{new_cidade}' estado='{new_estado}' mensagem='{new_mensagem}' assunto='{assunto_id}'" update_stdout, update_stderr, update_returncode = self.run_httpie_command(update_command) self.assertEqual(update_returncode, 0, f"Contatos update failed: {update_stderr}") # Delete delete_command = f"http -A bearer -a {self.token} DELETE {self.http_domain}/panel/contatos/{contato_id}/" delete_stdout, delete_stderr, delete_returncode = self.run_httpie_command(delete_command) self.assertEqual(delete_returncode, 0, f"Contatos delete failed: {delete_stderr}") self.assertEqual(delete_stdout.strip(), '', "Delete response should be empty for 204 No Content") # Imprensa Tests def test_imprensa_crud_operations(self): # Create texto = self.generate_lorem_text(200) create_command = f"http -A bearer -a {self.token} POST {self.http_domain}/panel/imprensa/ texto='{texto}'" #print(f"Create command for test_imprensa_crud_operations: {create_command}") create_stdout, create_stderr, create_returncode = self.run_httpie_command(create_command) self.assertEqual(create_returncode, 0, f"Imprensa create failed: {create_stderr}") create_response = json.loads(create_stdout) #print(f"Create response for test_imprensa_crud_operations: {create_response}") imprensa_id = create_response['results']['id'] # List list_command = f"http -A bearer -a {self.token} GET {self.http_domain}/panel/imprensa/" list_stdout, list_stderr, list_returncode = self.run_httpie_command(list_command) self.assertEqual(list_returncode, 0, f"Imprensa list failed: {list_stderr}") # Retrieve retrieve_command = f"http -A bearer -a {self.token} GET {self.http_domain}/panel/imprensa/{imprensa_id}/" retrieve_stdout, retrieve_stderr, retrieve_returncode = self.run_httpie_command(retrieve_command) self.assertEqual(retrieve_returncode, 0, f"Imprensa retrieve failed: {retrieve_stderr}") # Update new_texto = self.generate_lorem_text(250) update_command = f"http -A bearer -a {self.token} PUT {self.http_domain}/panel/imprensa/{imprensa_id}/ texto='{new_texto}'" update_stdout, update_stderr, update_returncode = self.run_httpie_command(update_command) self.assertEqual(update_returncode, 0, f"Imprensa update failed: {update_stderr}") # Delete delete_command = f"http -A bearer -a {self.token} DELETE {self.http_domain}/panel/imprensa/{imprensa_id}/" delete_stdout, delete_stderr, delete_returncode = self.run_httpie_command(delete_command) self.assertEqual(delete_returncode, 0, f"Imprensa delete failed: {delete_stderr}") self.assertEqual(delete_stdout.strip(), '', "Delete response should be empty for 204 No Content") # Assuntos Ouvidoria Tests def test_assuntos_ouvidoria_crud_operations(self): # Create email = self.generate_fake_email() nome = self.generate_random_string() create_command = f"http -A bearer -a {self.token} POST {self.http_domain}/panel/assuntos-ouvidoria/ email='{email}' nome='{nome}'" create_stdout, create_stderr, create_returncode = self.run_httpie_command(create_command) self.assertEqual(create_returncode, 0, f"Assuntos Ouvidoria create failed: {create_stderr}") create_response = json.loads(create_stdout) #print(f"Create response for test_assuntos_ouvidoria_crud_operations: {create_response}") self.assunto_ouvidoria_id = create_response['results']['id'] # List list_command = f"http -A bearer -a {self.token} GET {self.http_domain}/panel/assuntos-ouvidoria/" list_stdout, list_stderr, list_returncode = self.run_httpie_command(list_command) self.assertEqual(list_returncode, 0, f"Assuntos Ouvidoria list failed: {list_stderr}") # Retrieve retrieve_command = f"http -A bearer -a {self.token} GET {self.http_domain}/panel/assuntos-ouvidoria/{self.assunto_ouvidoria_id}/" retrieve_stdout, retrieve_stderr, retrieve_returncode = self.run_httpie_command(retrieve_command) self.assertEqual(retrieve_returncode, 0, f"Assuntos Ouvidoria retrieve failed: {retrieve_stderr}") # Update new_email = self.generate_fake_email() new_nome = self.generate_random_string() update_command = f"http -A bearer -a {self.token} PUT {self.http_domain}/panel/assuntos-ouvidoria/{self.assunto_ouvidoria_id}/ email='{new_email}' nome='{new_nome}'" update_stdout, update_stderr, update_returncode = self.run_httpie_command(update_command) self.assertEqual(update_returncode, 0, f"Assuntos Ouvidoria update failed: {update_stderr}") # Ouvidoria Tests def test_ouvidoria_crud_operations(self): if not hasattr(self, 'assunto_ouvidoria_id'): self.test_assuntos_ouvidoria_crud_operations() assunto_ouvidoria_id = self.assunto_ouvidoria_id # Create nome = self.generate_random_string() email = self.generate_fake_email() telefone = self.generate_fake_phone() cidade = "Vila Velha" estado = "Espírito Santo" mensagem = self.generate_lorem_text(20) create_command = f"http -A bearer -a {self.token} POST {self.http_domain}/panel/ouvidoria/ assunto='{assunto_ouvidoria_id}' nome='{nome}' email='{email}' telefone='{telefone}' cidade='{cidade}' estado='{estado}' mensagem='{mensagem}'" create_stdout, create_stderr, create_returncode = self.run_httpie_command(create_command) self.assertEqual(create_returncode, 0, f"Ouvidoria create failed: {create_stderr}") create_response = json.loads(create_stdout) ouvidoria_id = create_response['results']['id'] # List list_command = f"http -A bearer -a {self.token} GET {self.http_domain}/panel/ouvidoria/" list_stdout, list_stderr, list_returncode = self.run_httpie_command(list_command) self.assertEqual(list_returncode, 0, f"Ouvidoria list failed: {list_stderr}") # Retrieve retrieve_command = f"http -A bearer -a {self.token} GET {self.http_domain}/panel/ouvidoria/{ouvidoria_id}/" retrieve_stdout, retrieve_stderr, retrieve_returncode = self.run_httpie_command(retrieve_command) self.assertEqual(retrieve_returncode, 0, f"Ouvidoria retrieve failed: {retrieve_stderr}") # Update new_nome = self.generate_random_string() new_email = self.generate_fake_email() new_telefone = self.generate_fake_phone() new_cidade = "Santo Amaro" new_estado = "São Paulo" new_mensagem = self.generate_lorem_text(30) update_command = f"http -A bearer -a {self.token} PUT {self.http_domain}/panel/ouvidoria/{ouvidoria_id}/ assunto='{assunto_ouvidoria_id}' nome='{new_nome}' email='{new_email}' telefone='{new_telefone}' cidade='{new_cidade}' estado='{new_estado}' mensagem='{new_mensagem}'" update_stdout, update_stderr, update_returncode = self.run_httpie_command(update_command) self.assertEqual(update_returncode, 0, f"Ouvidoria update failed: {update_stderr}") # Delete delete_command = f"http -A bearer -a {self.token} DELETE {self.http_domain}/panel/ouvidoria/{ouvidoria_id}/" delete_stdout, delete_stderr, delete_returncode = self.run_httpie_command(delete_command) self.assertEqual(delete_returncode, 0, f"Ouvidoria delete failed: {delete_stderr}") self.assertEqual(delete_stdout.strip(), '', "Delete response should be empty for 204 No Content") # Grupos Perguntas Frequentes Tests def test_grupos_perguntas_frequentes_crud_operations(self): # Create nome = "Grupo Ouvidoria Teste 1" ordem = 1 create_command = f"http -A bearer -a {self.token} POST {self.http_domain}/panel/grupos-perguntas-frequentes/ nome='{nome}' ordem='{ordem}'" create_stdout, create_stderr, create_returncode = self.run_httpie_command(create_command) self.assertEqual(create_returncode, 0, f"Grupos Perguntas Frequentes create failed: {create_stderr}") create_response = json.loads(create_stdout) self.grupo_id = create_response['results']['id'] # List list_command = f"http -A bearer -a {self.token} GET {self.http_domain}/panel/grupos-perguntas-frequentes/" list_stdout, list_stderr, list_returncode = self.run_httpie_command(list_command) self.assertEqual(list_returncode, 0, f"Grupos Perguntas Frequentes list failed: {list_stderr}") # Retrieve retrieve_command = f"http -A bearer -a {self.token} GET {self.http_domain}/panel/grupos-perguntas-frequentes/{self.grupo_id}/" retrieve_stdout, retrieve_stderr, retrieve_returncode = self.run_httpie_command(retrieve_command) self.assertEqual(retrieve_returncode, 0, f"Grupos Perguntas Frequentes retrieve failed: {retrieve_stderr}") # Update new_nome = "Grupo Pergunta Frequente 2" new_ordem = 2 update_command = f"http -A bearer -a {self.token} PUT {self.http_domain}/panel/grupos-perguntas-frequentes/{self.grupo_id}/ nome='{new_nome}' ordem={new_ordem}" update_stdout, update_stderr, update_returncode = self.run_httpie_command(update_command) self.assertEqual(update_returncode, 0, f"Grupos Perguntas Frequentes update failed: {update_stderr}") # Perguntas Frequentes Tests def test_perguntas_frequentes_crud_operations(self): if not hasattr(self, 'grupo_id'): self.test_grupos_perguntas_frequentes_crud_operations() grupo_id = self.grupo_id # Create pergunta = self.generate_lorem_text(10) resposta = self.generate_lorem_text(20) create_command = f"http -A bearer -a {self.token} POST {self.http_domain}/panel/perguntas-frequentes/ grupo='{grupo_id}' ordem=1 pergunta='{pergunta}' resposta='{resposta}'" create_stdout, create_stderr, create_returncode = self.run_httpie_command(create_command) self.assertEqual(create_returncode, 0, f"Perguntas Frequentes create failed: {create_stderr}") create_response = json.loads(create_stdout) pergunta_id = create_response['results']['id'] # List list_command = f"http -A bearer -a {self.token} GET {self.http_domain}/panel/perguntas-frequentes/" list_stdout, list_stderr, list_returncode = self.run_httpie_command(list_command) self.assertEqual(list_returncode, 0, f"Perguntas Frequentes list failed: {list_stderr}") # Retrieve retrieve_command = f"http -A bearer -a {self.token} GET {self.http_domain}/panel/perguntas-frequentes/{pergunta_id}/" retrieve_stdout, retrieve_stderr, retrieve_returncode = self.run_httpie_command(retrieve_command) self.assertEqual(retrieve_returncode, 0, f"Perguntas Frequentes retrieve failed: {retrieve_stderr}") # Update new_pergunta = self.generate_lorem_text(10) new_resposta = self.generate_lorem_text(20) update_command = f"http -A bearer -a {self.token} PUT {self.http_domain}/panel/perguntas-frequentes/{pergunta_id}/ grupo='{grupo_id}' ordem=2 pergunta='{new_pergunta}' resposta='{new_resposta}'" update_stdout, update_stderr, update_returncode = self.run_httpie_command(update_command) self.assertEqual(update_returncode, 0, f"Perguntas Frequentes update failed: {update_stderr}") # Delete delete_command = f"http -A bearer -a {self.token} DELETE {self.http_domain}/panel/perguntas-frequentes/{pergunta_id}/" delete_stdout, delete_stderr, delete_returncode = self.run_httpie_command(delete_command) self.assertEqual(delete_returncode, 0, f"Perguntas Frequentes delete failed: {delete_stderr}") self.assertEqual(delete_stdout.strip(), '', "Delete response should be empty for 204 No Content") # Porque Remax Tests def test_porque_remax_crud_operations(self): # Create texto = self.generate_lorem_text(200) create_command = f"http -A bearer -a {self.token} POST {self.http_domain}/panel/porque-remax/ texto='{texto}'" create_stdout, create_stderr, create_returncode = self.run_httpie_command(create_command) self.assertEqual(create_returncode, 0, f"Porque Remax create failed: {create_stderr}") create_response = json.loads(create_stdout) porque_remax_id = create_response['results']['id'] # List list_command = f"http -A bearer -a {self.token} GET {self.http_domain}/panel/porque-remax/" list_stdout, list_stderr, list_returncode = self.run_httpie_command(list_command) self.assertEqual(list_returncode, 0, f"Porque Remax list failed: {list_stderr}") # Retrieve retrieve_command = f"http -A bearer -a {self.token} GET {self.http_domain}/panel/porque-remax/{porque_remax_id}/" retrieve_stdout, retrieve_stderr, retrieve_returncode = self.run_httpie_command(retrieve_command) self.assertEqual(retrieve_returncode, 0, f"Porque Remax retrieve failed: {retrieve_stderr}") # Update new_texto = self.generate_lorem_text(250) update_command = f"http -A bearer -a {self.token} PUT {self.http_domain}/panel/porque-remax/{porque_remax_id}/ texto='{new_texto}'" update_stdout, update_stderr, update_returncode = self.run_httpie_command(update_command) self.assertEqual(update_returncode, 0, f"Porque Remax update failed: {update_stderr}") # Delete delete_command = f"http -A bearer -a {self.token} DELETE {self.http_domain}/panel/porque-remax/{porque_remax_id}/" delete_stdout, delete_stderr, delete_returncode = self.run_httpie_command(delete_command) self.assertEqual(delete_returncode, 0, f"Porque Remax delete failed: {delete_stderr}") self.assertEqual(delete_stdout.strip(), '', "Delete response should be empty for 204 No Content") # Remax no Brasil Tests def test_remax_no_brasil_crud_operations(self): ### Get any agencia(offices), corretor(agents), imovel_exclusivo(property) from v1/properties_nested/ list_command = f"http -A bearer -a {self.token} GET {self.http_domain}/v1/properties_nested?page_size=2" list_stdout, list_stderr, list_returncode = self.run_httpie_command(list_command) self.assertEqual(list_returncode, 0, f"Properties list failed: {list_stderr}") create_response = json.loads(list_stdout) imovel_id = create_response['results'][0]['id'] new_imovel_id = create_response['results'][1]['id'] ### Get any agencia from v1/offices list_command = f"http GET {self.http_domain}/v1/offices?page_size=2" list_stdout, list_stderr, list_returncode = self.run_httpie_command(list_command) self.assertEqual(list_returncode, 0, f"Offices list failed: {list_stderr}") create_response = json.loads(list_stdout) agencia_id = create_response['results'][0]['id'] new_agencia_id = create_response['results'][1]['id'] ### Get any corretor from v1/agents list_command = f"http GET {self.http_domain}/v1/agents?page_size=2" list_stdout, list_stderr, list_returncode = self.run_httpie_command(list_command) self.assertEqual(list_returncode, 0, f"Agents list failed: {list_stderr}") create_response = json.loads(list_stdout) corretor_id = create_response['results'][0]['id'] new_corretor_id = create_response['results'][1]['id'] # Create texto = self.generate_lorem_text(200) texto_simplificado = self.generate_lorem_text(50) create_command = f"http -A bearer -a {self.token} POST {self.http_domain}/panel/remax-no-brasil/ texto='{texto}' texto_simplificado='{texto_simplificado}' agencias=['{agencia_id}'] corretores=['{corretor_id}'] imoveis_exclusivos=['{imovel_id}']" create_stdout, create_stderr, create_returncode = self.run_httpie_command(create_command) self.assertEqual(create_returncode, 0, f"Remax no Brasil create failed: {create_stderr}") create_response = json.loads(create_stdout) remax_brasil_id = create_response['results']['id'] # List list_command = f"http -A bearer -a {self.token} GET {self.http_domain}/panel/remax-no-brasil/" list_stdout, list_stderr, list_returncode = self.run_httpie_command(list_command) self.assertEqual(list_returncode, 0, f"Remax no Brasil list failed: {list_stderr}") # Retrieve retrieve_command = f"http -A bearer -a {self.token} GET {self.http_domain}/panel/remax-no-brasil/{remax_brasil_id}/" retrieve_stdout, retrieve_stderr, retrieve_returncode = self.run_httpie_command(retrieve_command) self.assertEqual(retrieve_returncode, 0, f"Remax no Brasil retrieve failed: {retrieve_stderr}") # Update new_texto = self.generate_lorem_text(250) new_texto_simplificado = self.generate_lorem_text(60) update_command = f"http -A bearer -a {self.token} PUT {self.http_domain}/panel/remax-no-brasil/{remax_brasil_id}/ texto='{new_texto}' texto_simplificado='{new_texto_simplificado}' agencias=['{new_agencia_id}'] corretores=['{new_corretor_id}'] imoveis_exclusivos=['{new_imovel_id}']" update_stdout, update_stderr, update_returncode = self.run_httpie_command(update_command) self.assertEqual(update_returncode, 0, f"Remax no Brasil update failed: {update_stderr}") # Delete delete_command = f"http -A bearer -a {self.token} DELETE {self.http_domain}/panel/remax-no-brasil/{remax_brasil_id}/" delete_stdout, delete_stderr, delete_returncode = self.run_httpie_command(delete_command) self.assertEqual(delete_returncode, 0, f"Remax no Brasil delete failed: {delete_stderr}") self.assertEqual(delete_stdout.strip(), '', "Delete response should be empty for 204 No Content") # Reconhecimentos Tests def test_reconhecimentos_crud_operations(self): # Create selo = "Selo Teste" titulo = "Titulo Teste" create_command = f"http -A bearer -a {self.token} POST {self.http_domain}/panel/reconhecimentos/ ordem=1 selo='{selo}' titulo='{titulo}' status=true" create_stdout, create_stderr, create_returncode = self.run_httpie_command(create_command) self.assertEqual(create_returncode, 0, f"Reconhecimentos create failed: {create_stderr}") create_response = json.loads(create_stdout) reconhecimento_id = create_response['results']['id'] # List list_command = f"http -A bearer -a {self.token} GET {self.http_domain}/panel/reconhecimentos/" list_stdout, list_stderr, list_returncode = self.run_httpie_command(list_command) self.assertEqual(list_returncode, 0, f"Reconhecimentos list failed: {list_stderr}") # Retrieve retrieve_command = f"http -A bearer -a {self.token} GET {self.http_domain}/panel/reconhecimentos/{reconhecimento_id}/" retrieve_stdout, retrieve_stderr, retrieve_returncode = self.run_httpie_command(retrieve_command) self.assertEqual(retrieve_returncode, 0, f"Reconhecimentos retrieve failed: {retrieve_stderr}") # Update new_selo = "Selo Teste 2" new_titulo = "Titulo Teste 2" update_command = f"http -A bearer -a {self.token} PUT {self.http_domain}/panel/reconhecimentos/{reconhecimento_id}/ ordem=2 selo='{new_selo}' titulo='{new_titulo}' status=false" update_stdout, update_stderr, update_returncode = self.run_httpie_command(update_command) self.assertEqual(update_returncode, 0, f"Reconhecimentos update failed: {update_stderr}") # Delete delete_command = f"http -A bearer -a {self.token} DELETE {self.http_domain}/panel/reconhecimentos/{reconhecimento_id}/" delete_stdout, delete_stderr, delete_returncode = self.run_httpie_command(delete_command) self.assertEqual(delete_returncode, 0, f"Reconhecimentos delete failed: {delete_stderr}") self.assertEqual(delete_stdout.strip(), '', "Delete response should be empty for 204 No Content") # Remax no Mundo Tests def test_remax_no_mundo_crud_operations(self): # Create texto = self.generate_lorem_text(200) texto_simplificado = self.generate_lorem_text(50) create_command = f"http -A bearer -a {self.token} POST {self.http_domain}/panel/remax-no-mundo/ texto='{texto}' texto_simplificado='{texto_simplificado}'" create_stdout, create_stderr, create_returncode = self.run_httpie_command(create_command) self.assertEqual(create_returncode, 0, f"Remax no Mundo create failed: {create_stderr}") create_response = json.loads(create_stdout) remax_mundo_id = create_response['results']['id'] # List list_command = f"http -A bearer -a {self.token} GET {self.http_domain}/panel/remax-no-mundo/" list_stdout, list_stderr, list_returncode = self.run_httpie_command(list_command) self.assertEqual(list_returncode, 0, f"Remax no Mundo list failed: {list_stderr}") # Retrieve retrieve_command = f"http -A bearer -a {self.token} GET {self.http_domain}/panel/remax-no-mundo/{remax_mundo_id}/" retrieve_stdout, retrieve_stderr, retrieve_returncode = self.run_httpie_command(retrieve_command) self.assertEqual(retrieve_returncode, 0, f"Remax no Mundo retrieve failed: {retrieve_stderr}") # Update new_texto = self.generate_lorem_text(250) new_texto_simplificado = self.generate_lorem_text(60) update_command = f"http -A bearer -a {self.token} PUT {self.http_domain}/panel/remax-no-mundo/{remax_mundo_id}/ texto='{new_texto}' texto_simplificado='{new_texto_simplificado}'" update_stdout, update_stderr, update_returncode = self.run_httpie_command(update_command) self.assertEqual(update_returncode, 0, f"Remax no Mundo update failed: {update_stderr}") # Delete delete_command = f"http -A bearer -a {self.token} DELETE {self.http_domain}/panel/remax-no-mundo/{remax_mundo_id}/" delete_stdout, delete_stderr, delete_returncode = self.run_httpie_command(delete_command) self.assertEqual(delete_returncode, 0, f"Remax no Mundo delete failed: {delete_stderr}") self.assertEqual(delete_stdout.strip(), '', "Delete response should be empty for 204 No Content") # Universidade Tests def test_universidade_crud_operations(self): # Create texto = self.generate_lorem_text(200) create_command = f"http -A bearer -a {self.token} POST {self.http_domain}/panel/universidade/ texto='{texto}'" create_stdout, create_stderr, create_returncode = self.run_httpie_command(create_command) self.assertEqual(create_returncode, 0, f"Universidade create failed: {create_stderr}") create_response = json.loads(create_stdout) universidade_id = create_response['results']['id'] # List list_command = f"http -A bearer -a {self.token} GET {self.http_domain}/panel/universidade/" list_stdout, list_stderr, list_returncode = self.run_httpie_command(list_command) self.assertEqual(list_returncode, 0, f"Universidade list failed: {list_stderr}") # Retrieve retrieve_command = f"http -A bearer -a {self.token} GET {self.http_domain}/panel/universidade/{universidade_id}/" retrieve_stdout, retrieve_stderr, retrieve_returncode = self.run_httpie_command(retrieve_command) self.assertEqual(retrieve_returncode, 0, f"Universidade retrieve failed: {retrieve_stderr}") # Update new_texto = self.generate_lorem_text(250) update_command = f"http -A bearer -a {self.token} PUT {self.http_domain}/panel/universidade/{universidade_id}/ texto='{new_texto}'" update_stdout, update_stderr, update_returncode = self.run_httpie_command(update_command) self.assertEqual(update_returncode, 0, f"Universidade update failed: {update_stderr}") # Delete delete_command = f"http -A bearer -a {self.token} DELETE {self.http_domain}/panel/universidade/{universidade_id}/" delete_stdout, delete_stderr, delete_returncode = self.run_httpie_command(delete_command) self.assertEqual(delete_returncode, 0, f"Universidade delete failed: {delete_stderr}") self.assertEqual(delete_stdout.strip(), '', "Delete response should be empty for 204 No Content") # Parceiros Tests def test_parceiros_crud_operations(self): # Create texto = self.generate_lorem_text(200) create_command = f"http -A bearer -a {self.token} POST {self.http_domain}/panel/parceiros/ texto='{texto}'" create_stdout, create_stderr, create_returncode = self.run_httpie_command(create_command) self.assertEqual(create_returncode, 0, f"Parceiros create failed: {create_stderr}") create_response = json.loads(create_stdout) parceiro_id = create_response['results']['id'] # List list_command = f"http -A bearer -a {self.token} GET {self.http_domain}/panel/parceiros/" list_stdout, list_stderr, list_returncode = self.run_httpie_command(list_command) self.assertEqual(list_returncode, 0, f"Parceiros list failed: {list_stderr}") # Retrieve retrieve_command = f"http -A bearer -a {self.token} GET {self.http_domain}/panel/parceiros/{parceiro_id}/" retrieve_stdout, retrieve_stderr, retrieve_returncode = self.run_httpie_command(retrieve_command) self.assertEqual(retrieve_returncode, 0, f"Parceiros retrieve failed: {retrieve_stderr}") # Update new_texto = self.generate_lorem_text(250) update_command = f"http -A bearer -a {self.token} PUT {self.http_domain}/panel/parceiros/{parceiro_id}/ texto='{new_texto}'" update_stdout, update_stderr, update_returncode = self.run_httpie_command(update_command) self.assertEqual(update_returncode, 0, f"Parceiros update failed: {update_stderr}") # Delete delete_command = f"http -A bearer -a {self.token} DELETE {self.http_domain}/panel/parceiros/{parceiro_id}/" delete_stdout, delete_stderr, delete_returncode = self.run_httpie_command(delete_command) self.assertEqual(delete_returncode, 0, f"Parceiros delete failed: {delete_stderr}") self.assertEqual(delete_stdout.strip(), '', "Delete response should be empty for 204 No Content") # Relação Investidores Tests def test_relacao_investidores_crud_operations(self): # Create texto = self.generate_lorem_text(200) create_command = f"http -A bearer -a {self.token} POST {self.http_domain}/panel/relacao-investidores/ texto='{texto}'" create_stdout, create_stderr, create_returncode = self.run_httpie_command(create_command) self.assertEqual(create_returncode, 0, f"Relação Investidores create failed: {create_stderr}") create_response = json.loads(create_stdout) relacao_investidores_id = create_response['results']['id'] # List list_command = f"http -A bearer -a {self.token} GET {self.http_domain}/panel/relacao-investidores/" list_stdout, list_stderr, list_returncode = self.run_httpie_command(list_command) self.assertEqual(list_returncode, 0, f"Relação Investidores list failed: {list_stderr}") # Retrieve retrieve_command = f"http -A bearer -a {self.token} GET {self.http_domain}/panel/relacao-investidores/{relacao_investidores_id}/" retrieve_stdout, retrieve_stderr, retrieve_returncode = self.run_httpie_command(retrieve_command) self.assertEqual(retrieve_returncode, 0, f"Relação Investidores retrieve failed: {retrieve_stderr}") # Update new_texto = self.generate_lorem_text(250) update_command = f"http -A bearer -a {self.token} PUT {self.http_domain}/panel/relacao-investidores/{relacao_investidores_id}/ texto='{new_texto}'" update_stdout, update_stderr, update_returncode = self.run_httpie_command(update_command) self.assertEqual(update_returncode, 0, f"Relação Investidores update failed: {update_stderr}") # Delete delete_command = f"http -A bearer -a {self.token} DELETE {self.http_domain}/panel/relacao-investidores/{relacao_investidores_id}/" delete_stdout, delete_stderr, delete_returncode = self.run_httpie_command(delete_command) self.assertEqual(delete_returncode, 0, f"Relação Investidores delete failed: {delete_stderr}") self.assertEqual(delete_stdout.strip(), '', "Delete response should be empty for 204 No Content") ############################################################# def test_grupo_pergunta_frequente_delete(self): if not hasattr(self, 'grupo_id'): self.test_grupos_perguntas_frequentes_crud_operations() grupo_id = self.grupo_id # Delete delete_command = f"http -A bearer -a {self.token} DELETE {self.http_domain}/panel/grupos-perguntas-frequentes/{grupo_id}/" delete_stdout, delete_stderr, delete_returncode = self.run_httpie_command(delete_command) self.assertEqual(delete_returncode, 0, f"Grupos Perguntas Frequentes delete failed: {delete_stderr}") self.assertEqual(delete_stdout.strip(), '', "Delete response should be empty for 204 No Content") ############################################################## def test_assuntos_ouvidoria_delete(self): if not hasattr(self, 'assunto_ouvidoria_id'): self.test_assuntos_ouvidoria_crud_operations() assunto_ouvidoria_id = self.assunto_ouvidoria_id # Delete delete_command = f"http -A bearer -a {self.token} DELETE {self.http_domain}/panel/assuntos-ouvidoria/{assunto_ouvidoria_id}/" delete_stdout, delete_stderr, delete_returncode = self.run_httpie_command(delete_command) self.assertEqual(delete_returncode, 0, f"Assuntos Ouvidoria delete failed: {delete_stderr}") self.assertEqual(delete_stdout.strip(), '', "Delete response should be empty for 204 No Content") ############################################################### ### Assuntos Delete ### def test_assuntos_delete(self): if not hasattr(self, 'assunto_id'): self.test_assuntos_crud_operations() assunto_id = self.assunto_id # Delete delete_command = f"http -A bearer -a {self.token} DELETE {self.http_domain}/panel/assuntos/{assunto_id}/" delete_stdout, delete_stderr, delete_returncode = self.run_httpie_command(delete_command) self.assertEqual(delete_returncode, 0, f"Assuntos delete failed: {delete_stderr}") self.assertEqual(delete_stdout.strip(), '', "Delete response should be empty for 204 No Content") ################################################################ ### Posts Delete #### def test_posts_delete(self): if not hasattr(self, 'post_id'): self.test_posts_crud_operations() post_id = self.post_id # Delete delete_command = f"http -A bearer -a {self.token} DELETE {self.http_domain}/panel/posts/{post_id}/" delete_stdout, delete_stderr, delete_returncode = self.run_httpie_command(delete_command) self.assertEqual(delete_returncode, 0, f"Posts delete failed: {delete_stderr}") ############################################################### ### Categorias Delete ### def test_categorias_delete(self): if not hasattr(self, 'categoria_id'): self.test_categorias_crud_operations() categoria_id = self.categoria_id # Delete delete_command = f"http -A bearer -a {self.token} DELETE {self.http_domain}/panel/categorias/{categoria_id}/" delete_stdout, delete_stderr, delete_returncode = self.run_httpie_command(delete_command) self.assertEqual(delete_returncode, 0, f"Categorias delete failed: {delete_stderr}") self.assertEqual(delete_stdout.strip(), '', "Delete response should be empty for 204 No Content") ##################################################################################################################### ### Users Delete ### def test_usuario_delete(self): if not hasattr(self, 'new_user_admin_id'): self.test_usuario_create(user_type='admin') # Create a new user admin if not already created if not hasattr(self, 'new_user_cliente_id'): self.test_usuario_create(user_type='cliente') # Create a new user cliente if not already created user_admin_id = self.new_user_admin_id # Use the created user's ID user_cliente_id = self.new_user_cliente_id ### User Admin ### if user_admin_id is not None: delete_command = f"http -A bearer -a {self.token} DELETE {self.http_domain}/accounts/usuarios/{user_admin_id}/" delete_stdout, delete_stderr, delete_returncode = self.run_httpie_command(delete_command) self.assertEqual(delete_returncode, 0, f"Delete failed: {delete_stderr}") self.assertEqual(delete_stdout.strip(), '', "Delete response should be empty for 204 No Content") ### User Cliente ### if user_cliente_id is not None: delete_command = f"http -A bearer -a {self.token} DELETE {self.http_domain}/accounts/usuarios/{user_cliente_id}/" delete_stdout, delete_stderr, delete_returncode = self.run_httpie_command(delete_command) self.assertEqual(delete_returncode, 0, f"Delete failed: {delete_stderr}") self.assertEqual(delete_stdout.strip(), '', "Delete response should be empty for 204 No Content")