Added test clean up, PAT token to openapi generation (#52)

* Added test clean up, PAT token to openapi generation

* Fixed return, removed unnecessary print

Author: nicholas-chiu

.github/workflows/openapi.yml

@@ -35,6 +35,7 @@ jobs:
       - name: Create Pull Request
         uses: peter-evans/[email protected]
         with:
+          token: ${{ secrets.GHA_REPO_DISPATCH_TOKEN }}
           commit-message: Regenerates API Bindings
           title: "OpenAPI: Regenerates API Bindings"
           body: |

workflow_tests/test_create_content.py

@@ -8,12 +8,6 @@
 
 load_dotenv()
 
-configuration = lilt.Configuration(
-    host=os.environ["API_HOST"],
-    api_key={
-        "key": os.environ["API_KEY"]
-    }
-)
 
 sign_cases = [
     "none",
@@ -174,17 +168,35 @@ def assert_response(create_content_obj, expected):
     assert template_params.summary == expected["template_params"]["summary"]
 
 
-@pytest.mark.parametrize("sign_case", sign_cases)
-def test_sign(sign_case):
+@pytest.fixture(scope="module")
+def client():
+    configuration = lilt.Configuration(
+        host=os.environ["API_HOST"], api_key={"key": os.environ["API_KEY"]}
+    )
     api_client = lilt.ApiClient(configuration)
+    commit = os.environ.get("GIT_COMMIT_SHA", "no_version_available")
+    api_client.user_agent = f"lilt-python-e2e-tests/{commit}"
+    return api_client
+
+
+@pytest.fixture(scope="module")
+def create_api(client):
+    return lilt.CreateApi(client)
+
 
-    # Sign terms and conditions
-    api_instance = lilt.CreateApi(api_client)
+@pytest.fixture(scope="function")
+def sign(create_api):
+    signed_agreement = lilt.CreateConverterConfigParameters(True)
+    return create_api.sign_lilt_create_terms(signed_agreement)
+
+
+@pytest.mark.parametrize("sign_case", sign_cases)
+def test_sign(sign_case, create_api):
     sign = get_sign(sign_case)
 
     try:
         signed_agreement = lilt.CreateConverterConfigParameters(sign)
-        api_response = api_instance.sign_lilt_create_terms(signed_agreement)
+        api_response = create_api.sign_lilt_create_terms(signed_agreement)
         assert api_response.signed_agreement == bool(sign)
     except ValueError as e:
         print("Exception when calling CreateApi->sign_lilt_create_terms: %s\n" % e)
@@ -193,14 +205,8 @@ def test_sign(sign_case):
 
 
 @pytest.mark.parametrize("char_case", generate_content_char_cases)
-def test_create_content_chars(char_case):
-    api_client = lilt.ApiClient(configuration)
-
-    # Sign agreement
-    api_instance = lilt.CreateApi(api_client)
-    signed_agreement = lilt.CreateConverterConfigParameters(True)
-    api_response = api_instance.sign_lilt_create_terms(signed_agreement)
-    assert api_response.signed_agreement
+def test_create_content_chars(create_api, sign, char_case):
+    assert sign.signed_agreement
 
     # Generate content
     template_params = lilt.LiltCreateContentTemplateParams(
@@ -219,22 +225,18 @@ def test_create_content_chars(char_case):
         preferences=preferences
     )
 
-    api_instance.generate_lilt_create_content(request_body)
+    create_api.generate_lilt_create_content(request_body)
     time.sleep(5)
-    api_response = api_instance.get_lilt_create_content()
+    api_response = create_api.get_lilt_create_content()
     latest_content = api_response.contents[-1]
     assert_response(latest_content, expected_chars(char_case))
 
+    create_api.delete_lilt_create_content(latest_content.id)
 
-@pytest.mark.parametrize("section_case", generate_content_sections_cases)
-def test_create_content_sections(section_case):
-    api_client = lilt.ApiClient(configuration)
 
-    # Sign agreement
-    api_instance = lilt.CreateApi(api_client)
-    signed_agreement = lilt.CreateConverterConfigParameters(True)
-    api_response = api_instance.sign_lilt_create_terms(signed_agreement)
-    assert api_response.signed_agreement
+@pytest.mark.parametrize("section_case", generate_content_sections_cases)
+def test_create_content_sections(create_api, sign, section_case):
+    assert sign.signed_agreement
 
     # Generate content
     template_params = lilt.LiltCreateContentTemplateParams(
@@ -253,8 +255,10 @@ def test_create_content_sections(section_case):
         preferences=preferences
     )
 
-    api_instance.generate_lilt_create_content(request_body)
+    create_api.generate_lilt_create_content(request_body)
     time.sleep(5)
-    api_response = api_instance.get_lilt_create_content()
+    api_response = create_api.get_lilt_create_content()
     latest_content = api_response.contents[-1]
     assert_response(latest_content, expected_section(section_case))
+
+    create_api.delete_lilt_create_content(latest_content.id)

workflow_tests/test_data_source.py

@@ -13,13 +13,6 @@
 load_dotenv()
 
 
-configuration = lilt.Configuration(
-    host=os.environ["API_HOST"],
-    api_key={
-        "key": os.environ["API_KEY"]
-    }
-)
-
 create_data_source_cases = [
     "none_src",
     "none_trg",
@@ -205,26 +198,36 @@ def assert_query_response(query_object, expected):
     assert query_object.source == expected["source"]
     assert query_object.target == expected["target"]
 
+@pytest.fixture(scope="module")
+def client():
+    configuration = lilt.Configuration(
+        host=os.environ["API_HOST"], api_key={"key": os.environ["API_KEY"]}
+    )
+    api_client = lilt.ApiClient(configuration)
+    commit = os.environ.get("GIT_COMMIT_SHA", "no_version_available")
+    api_client.user_agent = f"lilt-python-e2e-tests/{commit}"
+    return api_client
+
+
+@pytest.fixture(scope="module")
+def memories_api(client):
+    return lilt.MemoriesApi(client)
+
 
 @retry(
     retry=retry_if_result(lambda is_processing: is_processing == 1),
     stop=stop_after_delay(2 * 60),
     wait=wait_exponential()
 )
-def monitor_file_import(api_instance, memory_id):
-    api_response = api_instance.get_memory()
+def monitor_file_import(memories_api, memory_id):
+    api_response = memories_api.get_memory()
     is_processing = api_response[0].is_processing
     print(f"is_processing: {is_processing}")
     return is_processing
 
 
 @pytest.mark.parametrize("data_source_case", create_data_source_cases)
-def test_create_data_source_workflow(data_source_case):
-    api_client = lilt.ApiClient(configuration)
-
-    # Create data source
-    api_instance = lilt.MemoriesApi(api_client)
-
+def test_create_data_source_workflow(memories_api, data_source_case):
     try:
         data_source_parameters = get_data_source_parameters(data_source_case)
         body = lilt.MemoryCreateParameters(
@@ -242,9 +245,11 @@ def test_create_data_source_workflow(data_source_case):
             raise e
 
     try:
-        api_response = api_instance.create_memory(body)
+        api_response = memories_api.create_memory(body)
         pprint(api_response)
         assert_data_source_response(api_response, get_expected_data_source(data_source_case))
+
+        memories_api.delete_memory(api_response.id)
     except ApiException as e:
         print("Exception when calling MemoriesApi->create_memory: %s\n" % e)
         if data_source_case == "unsupported_languages":
@@ -253,12 +258,8 @@ def test_create_data_source_workflow(data_source_case):
             raise e
 
 
-@pytest.mark.parametrize("tmx_file_case", tmx_file_cases)
-def test_upload_tmx_file_workflow(tmx_file_case):
-    api_client = lilt.ApiClient(configuration)
-
-    # Create data source
-    api_instance = lilt.MemoriesApi(api_client)
+@pytest.fixture(scope="function")
+def create_fr_to_en_memory(memories_api):
     data_source_parameters = get_data_source_parameters("fr_to_en")
     body = lilt.MemoryCreateParameters(
         name=data_source_parameters["name"],
@@ -267,20 +268,26 @@ def test_upload_tmx_file_workflow(tmx_file_case):
         srclocale=data_source_parameters["srclocale"],
         trglocale=data_source_parameters["trglocale"]
     )
-    api_response = api_instance.create_memory(body)
+    api_response = memories_api.create_memory(body)
     assert_data_source_response(api_response, get_expected_data_source("fr_to_en"))
-    memory_id = api_response.id
+    print(f"Memory ID: {api_response.id}")
+    yield api_response
+    memories_api.delete_memory(api_response.id)
+
+
+@pytest.mark.parametrize("tmx_file_case", tmx_file_cases)
+def test_upload_tmx_file_workflow(memories_api, create_fr_to_en_memory, tmx_file_case):
+    memory_id = create_fr_to_en_memory.id
     print(f"Memory ID: {memory_id}")
 
     # Upload file
-    print(os.getcwd())
     tmx_settings = get_tmx_settings(tmx_file_case)
     upload_file = open(tmx_settings["body"], "rb")
     body = upload_file.read()
     print("-----FILE START-----")
     print(body)
     print("-----FILE END-----")
-    api_response = api_instance.import_memory_file(
+    api_response = memories_api.import_memory_file(
         memory_id=memory_id,
         name=tmx_settings["name"],
         body=body
@@ -290,13 +297,14 @@ def test_upload_tmx_file_workflow(tmx_file_case):
     assert api_response.is_processing == 1
 
     # Monitor file import
-    is_processing = monitor_file_import(api_instance, memory_id)
+    is_processing = monitor_file_import(memories_api, memory_id)
 
     # Query memory
     query = "chatte"
-    api_response = api_instance.query_memory(memory_id, query)
+    api_response = memories_api.query_memory(memory_id, query)
     if tmx_file_case == "wrong_data":
         assert api_response == []
     else:
         assert len(api_response) > 0
         assert_query_response(api_response[0], get_expected_query())
+

workflow_tests/test_instant_translate.py

@@ -9,13 +9,6 @@
 
 load_dotenv()
 
-configuration = lilt.Configuration(
-    host=os.environ["API_HOST"],
-    api_key={
-        "key": os.environ["API_KEY"]
-    }
-)
-
 test_cases = [
     "fr_to_en"
 ]
@@ -41,44 +34,63 @@ def assert_translate_response(response, file_id, memory_id):
     assert response.created_at is not None
 
 
+@pytest.fixture(scope="module")
+def client():
+    configuration = lilt.Configuration(
+        host=os.environ["API_HOST"], api_key={"key": os.environ["API_KEY"]}
+    )
+    api_client = lilt.ApiClient(configuration)
+    commit = os.environ.get("GIT_COMMIT_SHA", "no_version_available")
+    api_client.user_agent = f"lilt-python-e2e-tests/{commit}"
+    return api_client
+
+
+@pytest.fixture(scope="module")
+def files_api(client):
+    return lilt.FilesApi(client)
+
+@pytest.fixture(scope="module")
+def translate_api(client):
+    return lilt.TranslateApi(client)
+
+
 @retry(
     retry=retry_if_result(lambda status: status != "ReadyForDownload"),
     stop=stop_after_delay(2 * 60),
     wait=wait_exponential()
 )
-def monitor_file_translation(translate_instance, translation_id, file_id, memory_id):
-    api_response = translate_instance.monitor_file_translation(translation_ids=translation_id)
+def monitor_file_translation(translate_api, translation_id, file_id, memory_id):
+    api_response = translate_api.monitor_file_translation(translation_ids=translation_id)
     translation_response = api_response[0]
     translation_status = translation_response.status
     print(f"STATUS: {translation_status}")
     assert_translate_response(translation_response, file_id, memory_id)
     return translation_status
 
-
-@pytest.mark.parametrize("test_case", test_cases)
-def test_instant_translate_workflow(test_case):
-    api_client = lilt.ApiClient(configuration)
-
-    # Upload file
-    files_instance = lilt.FilesApi(api_client)
+@pytest.fixture(scope="module")
+def upload_file(files_api):
     name = "translate-fr_to_en.txt"
     upload_file = open(f"{translate_file_path}/translate-fr_to_en.txt", "rb")
     body = upload_file.read()
 
-    api_response = files_instance.upload_file(
+    api_response = files_api.upload_file(
         name,
         body
     )
     assert_upload_response(api_response)
-    file_id = api_response.id
+    yield api_response
+    files_api.delete_file(api_response.id)
+
+
+@pytest.mark.parametrize("test_case", test_cases)
+def test_instant_translate_workflow(upload_file, translate_api, test_case):
+    file_id = upload_file.id
 
-    # Translate file
-    translate_instance = lilt.TranslateApi(api_client)
     memory_id = STAGING_MEMORY_ID
     print(f"FILE ID: {file_id}")
     print(f"MEMORY ID: {memory_id}")
 
-    api_response = translate_instance.batch_translate_file(file_id, memory_id)
+    api_response = translate_api.batch_translate_file(file_id, memory_id)
     translation_response = api_response[0]
     translation_id = translation_response.id
     translation_status = translation_response.status
@@ -87,7 +99,7 @@ def test_instant_translate_workflow(test_case):
     # Monitor translation
     try:
         translation_status = monitor_file_translation(
-            translate_instance,
+            translate_api,
             translation_id,
             file_id,
             memory_id
@@ -98,6 +110,6 @@ def test_instant_translate_workflow(test_case):
         print("Translation exceeding time limit. Switching to finished translation.")
 
     # Download translated file
-    api_response = translate_instance.download_file(translation_id)
+    api_response = translate_api.download_file(translation_id)
     assert "cat" in api_response
     assert "hello" in api_response.lower()

workflow_tests/test_verified_translate.py

@@ -73,9 +73,18 @@ def job(api, memory, uploaded_file):
     api.delete_job(response.id)
 
 
+@retry(
+    retry=retry_if_result(lambda jobs: len(jobs) == 0),
+    stop=stop_after_delay(2 * 60),
+    wait=wait_exponential(),
+)
+def wait_for_job_creation(api, job_id):
+    api.deliver_job(job_id)
+    return api.retrieve_all_jobs(is_delivered="true", is_archived="false")
+
+
 def test_verified_translate_monitor_job_status(api, job):
-    api.deliver_job(job.id)
-    jobs = api.retrieve_all_jobs(is_delivered="true", is_archived="false")
+    jobs = wait_for_job_creation(api, job.id)
     assert len(jobs) > 0