diff --git a/Config/DefaultUnrealOpenAI.ini b/Config/DefaultUnrealOpenAI.ini index 21700ca..60f4590 100644 --- a/Config/DefaultUnrealOpenAI.ini +++ b/Config/DefaultUnrealOpenAI.ini @@ -5,4 +5,34 @@ +ClassRedirects=(OldName="/Script/UnrealOpenAI.DeleteFineTuneModelResultsProxy",NewName="/Script/UnrealOpenAI.DeleteFineTuneModelProxy") +FunctionRedirects=(OldName="/Script/UnrealOpenAI.UnrealOpenAIUtils.ConvertToTexture2D",NewName="/Script/UnrealOpenAI.UnrealOpenAIUtils.ConvertBytesToTexture2D") +PropertyRedirects=(OldName="/Script/UnrealOpenAI.FunctionalTestPawn.CompletionFunctionalTest",NewName="/Script/UnrealOpenAI.FunctionalTestPawn.CreateCompletionFunctionalTest") -+FunctionRedirects=(OldName="/Script/UnrealOpenAI.FunctionalTestPawn.StartCompletionTest",NewName="/Script/UnrealOpenAI.FunctionalTestPawn.StartCreateCompletionTest") \ No newline at end of file ++FunctionRedirects=(OldName="/Script/UnrealOpenAI.FunctionalTestPawn.StartCompletionTest",NewName="/Script/UnrealOpenAI.FunctionalTestPawn.StartCreateCompletionTest") ++ClassRedirects=(OldName="/Script/UnrealOpenAI.ModerationFunctionalTest",NewName="/Script/UnrealOpenAI.ModerationsFunctionalTest") ++FunctionRedirects=(OldName="/Script/UnrealOpenAI.FunctionalTestPawn.StartCreateFilesTest",NewName="/Script/UnrealOpenAI.FunctionalTestPawn.StartCreateFilesURLTest") ++ClassRedirects=(OldName="/Script/UnrealOpenAI.CreateFilesURLFunctionalTest",NewName="/Script/UnrealOpenAI.FilesFunctionalTest") ++FunctionRedirects=(OldName="/Script/UnrealOpenAI.FunctionalTestPawn.StartCreateFilesURLTest",NewName="/Script/UnrealOpenAI.FunctionalTestPawn.StartCreateFilesTest") ++FunctionRedirects=(OldName="/Script/UnrealOpenAI.FunctionalTestPawn.OnFilesSuccess",NewName="/Script/UnrealOpenAI.FunctionalTestPawn.OnCreateFileSuccess") ++FunctionRedirects=(OldName="/Script/UnrealOpenAI.FunctionalTestPawn.OnFilesFailure",NewName="/Script/UnrealOpenAI.FunctionalTestPawn.OnCreateFileFailure") ++FunctionRedirects=(OldName="/Script/UnrealOpenAI.FunctionalTestPawn.StartCreateFilesTest",NewName="/Script/UnrealOpenAI.FunctionalTestPawn.StartCreateFileTest") ++ClassRedirects=(OldName="/Script/UnrealOpenAI.CreateFilesFunctionalTest",NewName="/Script/UnrealOpenAI.FilesFunctionalTest") ++PropertyRedirects=(OldName="/Script/UnrealOpenAI.FunctionalTestPawn.CreateFilesFunctionalTest",NewName="/Script/UnrealOpenAI.FunctionalTestPawn.CreateFileFunctionalTest") ++ClassRedirects=(OldName="/Script/UnrealOpenAI.CreateCompletionFunctionalTest",NewName="/Script/UnrealOpenAI.CompletionsFunctionalTest") ++PropertyRedirects=(OldName="/Script/UnrealOpenAI.FunctionalTestPawn.CreateCompletionFunctionalTest",NewName="/Script/UnrealOpenAI.FunctionalTestPawn.CompletionFunctionalTest") ++ClassRedirects=(OldName="/Script/UnrealOpenAI.CompletionFunctionalTest",NewName="/Script/UnrealOpenAI.CompletionsFunctionalTest") ++PropertyRedirects=(OldName="/Script/UnrealOpenAI.FunctionalTestPawn.CompletionFunctionalTest",NewName="/Script/UnrealOpenAI.FunctionalTestPawn.CompletionsFunctionalTest") ++FunctionRedirects=(OldName="/Script/UnrealOpenAI.FunctionalTestPawn.StartCreateCompletionTest",NewName="/Script/UnrealOpenAI.FunctionalTestPawn.StartCompletionsTest") ++ClassRedirects=(OldName="/Script/UnrealOpenAI.CreateEditsFunctionalTest",NewName="/Script/UnrealOpenAI.EditsFunctionalTest") ++PropertyRedirects=(OldName="/Script/UnrealOpenAI.FunctionalTestPawn.CreateEditsFunctionalTest",NewName="/Script/UnrealOpenAI.FunctionalTestPawn.EditsFunctionalTest") ++FunctionRedirects=(OldName="/Script/UnrealOpenAI.FunctionalTestPawn.StartCreateEditsTest",NewName="/Script/UnrealOpenAI.FunctionalTestPawn.StartEditsTest") ++ClassRedirects=(OldName="/Script/UnrealOpenAI.CreateEmbeddingsFunctionalTest",NewName="/Script/UnrealOpenAI.EmbeddingsFunctionalTest") ++PropertyRedirects=(OldName="/Script/UnrealOpenAI.FunctionalTestPawn.CreateEmbeddingsFunctionalTest",NewName="/Script/UnrealOpenAI.FunctionalTestPawn.EmbeddingsFunctionalTest") ++FunctionRedirects=(OldName="/Script/UnrealOpenAI.FunctionalTestPawn.StartCreateEmbeddingsTest",NewName="/Script/UnrealOpenAI.FunctionalTestPawn.StartEmbeddingsTest") ++ClassRedirects=(OldName="/Script/UnrealOpenAI.CreateModerationFunctionalTest",NewName="/Script/UnrealOpenAI.ModerationsFunctionalTest") ++PropertyRedirects=(OldName="/Script/UnrealOpenAI.FunctionalTestPawn.CreateModerationFunctionalTest",NewName="/Script/UnrealOpenAI.FunctionalTestPawn.ModerationsFunctionalTest") ++FunctionRedirects=(OldName="/Script/UnrealOpenAI.FunctionalTestPawn.StartCreateModerationTest",NewName="/Script/UnrealOpenAI.FunctionalTestPawn.StartModerationsTest") ++ClassRedirects=(OldName="/Script/UnrealOpenAI.CreateFileFunctionalTest",NewName="/Script/UnrealOpenAI.FilesFunctionalTest") ++PropertyRedirects=(OldName="/Script/UnrealOpenAI.FunctionalTestPawn.CreateFileFunctionalTest",NewName="/Script/UnrealOpenAI.FunctionalTestPawn.FilesFunctionalTest") ++FunctionRedirects=(OldName="/Script/UnrealOpenAI.FilesFunctionalTest.OnFileUploadComplete",NewName="/Script/UnrealOpenAI.FilesFunctionalTest.OnFileUploadTestComplete") ++FunctionRedirects=(OldName="/Script/UnrealOpenAI.FunctionalTestPawn.StartListFileTest",NewName="/Script/UnrealOpenAI.FunctionalTestPawn.StartListFilesTest") ++FunctionRedirects=(OldName="/Script/UnrealOpenAI.FunctionalTestPawn.OnGetImageFromURLSuccess",NewName="/Script/UnrealOpenAI.FunctionalTestPawn.OnGetCreateImageFromURLSuccess") ++FunctionRedirects=(OldName="/Script/UnrealOpenAI.FunctionalTestPawn.OnGetImageFromURLFailure",NewName="/Script/UnrealOpenAI.FunctionalTestPawn.OnGetCreateImageFromURLFailure") ++FunctionRedirects=(OldName="/Script/UnrealOpenAI.FunctionalTestPawn.OnGetCreateEditImageFromURLSuccess",NewName="/Script/UnrealOpenAI.FunctionalTestPawn.OnGetCreateImageEditFromURLSuccess") \ No newline at end of file diff --git a/Content/Maps/_Sandbox/BP_SandboxPawn.uasset b/Content/Maps/_Sandbox/BP_SandboxPawn.uasset index 9d0707c..80cb666 100644 Binary files a/Content/Maps/_Sandbox/BP_SandboxPawn.uasset and b/Content/Maps/_Sandbox/BP_SandboxPawn.uasset differ diff --git a/Content/Test/TestMap.umap b/Content/Test/TestMap.umap index 24b6c2d..7ca588c 100644 Binary files a/Content/Test/TestMap.umap and b/Content/Test/TestMap.umap differ diff --git a/Content/Test/pool_empty.png b/Content/Test/pool_empty.png new file mode 100644 index 0000000..97ae32e Binary files /dev/null and b/Content/Test/pool_empty.png differ diff --git a/Content/Test/pool_mask.png b/Content/Test/pool_mask.png new file mode 100644 index 0000000..baab469 Binary files /dev/null and b/Content/Test/pool_mask.png differ diff --git a/Content/Test/training.jsonl b/Content/Test/training.jsonl new file mode 100644 index 0000000..9eded80 --- /dev/null +++ b/Content/Test/training.jsonl @@ -0,0 +1,3 @@ +{"prompt": "Hi", "completion": ", how are you?"} +{"prompt": "Hi", "completion": "there!"} +{"prompt": "Hi", "completion": ", nice to meet you!"} diff --git a/Source/UnrealOpenAI/Private/Tests/Actors/FunctionalTestPawn.cpp b/Source/UnrealOpenAI/Private/Tests/Actors/FunctionalTestPawn.cpp index fd237d0..cf0cab9 100644 --- a/Source/UnrealOpenAI/Private/Tests/Actors/FunctionalTestPawn.cpp +++ b/Source/UnrealOpenAI/Private/Tests/Actors/FunctionalTestPawn.cpp @@ -6,9 +6,14 @@ #include "Proxies/CompletionProxies.h" #include "Proxies/EditsProxies.h" #include "Proxies/EmbeddingsProxies.h" +#include "Proxies/FilesProxies.h" +#include "Proxies/ImageProxies.h" +#include "Proxies/ModerationProxies.h" #include "Tests/FunctionalTests/CompletionFunctionalTest.h" #include "Tests/FunctionalTests/EditsFunctionalTest.h" #include "Tests/FunctionalTests/EmbeddingsFunctionalTest.h" +#include "Utils/UnrealOpenAIUtils.h" +#include "Utils/Utils.h" AFunctionalTestPawn::AFunctionalTestPawn() @@ -17,21 +22,21 @@ AFunctionalTestPawn::AFunctionalTestPawn() } -void AFunctionalTestPawn::StartCreateCompletionTest(FString Prompt) +void AFunctionalTestPawn::StartCompletionsTest(FString Prompt) { - if (!CreateCompletionFunctionalTest) + if (!CompletionsFunctionalTest) return; if (Prompt.IsEmpty() || Prompt.Len() <= 0 || Prompt == TEXT("")) { - CreateCompletionFunctionalTest->FailTest(TEXT("Prompt is empty")); + CompletionsFunctionalTest->FailTest(TEXT("Prompt is empty")); } const auto Proxy = UCreateCompletionRequestProxy::CreateCompletion(this, Prompt, ECompletionModel::ECM_Davinci); if (!Proxy) { - CreateCompletionFunctionalTest->FailTest(TEXT("Failed to create completion request proxy")); + CompletionsFunctionalTest->FailTest(TEXT("Failed to create completion request proxy")); return; } @@ -46,44 +51,44 @@ void AFunctionalTestPawn::OnCompletionSuccess(FCreateCompletionResponse Response { if (JSONString.IsEmpty()) { - CreateCompletionFunctionalTest->FailTest(TEXT("No JSON String returned")); + CompletionsFunctionalTest->FailTest(TEXT("No JSON String returned")); return; } if (!Error.IsEmpty()) { - CreateCompletionFunctionalTest->FailTest(TEXT("Error returned")); + CompletionsFunctionalTest->FailTest(TEXT("Error returned")); return; } if (Response.choices[0].text.IsEmpty()) { - CreateCompletionFunctionalTest->FailTest(TEXT("No response text returned")); + CompletionsFunctionalTest->FailTest(TEXT("No response text returned")); return; } - CreateCompletionFunctionalTest->PassTest(FString::Printf(TEXT("Response text returned %s"), *Response.choices[0].text)); + CompletionsFunctionalTest->PassTest(FString::Printf(TEXT("Response text returned %s"), *Response.choices[0].text)); } void AFunctionalTestPawn::OnCompletionFailure(FCreateCompletionResponse Response, FString JSONString, FString Error) { - CreateCompletionFunctionalTest->FailTest(TEXT("Should not fire failure delegate")); + CompletionsFunctionalTest->FailTest(TEXT("Should not fire failure delegate - OnCompletionFailure")); } -void AFunctionalTestPawn::StartCreateEditsTest(FString Input, FString Instruction) +void AFunctionalTestPawn::StartEditsTest(FString Input, FString Instruction) { - if (!CreateEditsFunctionalTest) + if (!EditsFunctionalTest) return; if (Input.IsEmpty() || Input.Len() <= 0 || Input == TEXT("")) { - CreateEditsFunctionalTest->FailTest(TEXT("Input is empty")); + EditsFunctionalTest->FailTest(TEXT("Input is empty")); return; } if (Instruction.IsEmpty() || Instruction.Len() <= 0 || Instruction == TEXT("")) { - CreateEditsFunctionalTest->FailTest(TEXT("Instruction is empty")); + EditsFunctionalTest->FailTest(TEXT("Instruction is empty")); return; } @@ -91,7 +96,7 @@ void AFunctionalTestPawn::StartCreateEditsTest(FString Input, FString Instructio if (!Proxy) { - CreateEditsFunctionalTest->FailTest(TEXT("Failed to create edits request proxy")); + EditsFunctionalTest->FailTest(TEXT("Failed to create edits request proxy")); return; } @@ -105,39 +110,39 @@ void AFunctionalTestPawn::OnEditsSuccess(FCreateEditsResponse Response, FString { if (JSONString.IsEmpty()) { - CreateEditsFunctionalTest->FailTest(TEXT("No JSON String returned")); + EditsFunctionalTest->FailTest(TEXT("No JSON String returned")); return; } if (!Error.IsEmpty()) { - CreateEditsFunctionalTest->FailTest(TEXT("Error returned")); + EditsFunctionalTest->FailTest(TEXT("Error returned")); return; } if (Response.choices[0].text.IsEmpty()) { - CreateEditsFunctionalTest->FailTest(TEXT("No response text returned")); + EditsFunctionalTest->FailTest(TEXT("No response text returned")); return; } - CreateEditsFunctionalTest->PassTest(FString::Printf(TEXT("Response text returned %s"), *Response.choices[0].text)); + EditsFunctionalTest->PassTest(FString::Printf(TEXT("Response text returned %s"), *Response.choices[0].text)); } void AFunctionalTestPawn::OnEditsFailure(FCreateEditsResponse Response, FString JSONString, FString Error) { - CreateEditsFunctionalTest->FailTest(TEXT("Should not fire failure delegate")); + EditsFunctionalTest->FailTest(TEXT("Should not fire failure delegate - OnEditsFailure")); } -void AFunctionalTestPawn::StartCreateEmbeddingsTest(FString Input) +void AFunctionalTestPawn::StartEmbeddingsTest(FString Input) { - if (!CreateEmbeddingsFunctionalTest) + if (!EmbeddingsFunctionalTest) { return; } if (Input.IsEmpty() || Input.Len() <= 0 || Input == TEXT("")) { - CreateEmbeddingsFunctionalTest->FailTest(TEXT("Input is empty")); + EmbeddingsFunctionalTest->FailTest(TEXT("Input is empty")); return; } @@ -145,7 +150,7 @@ void AFunctionalTestPawn::StartCreateEmbeddingsTest(FString Input) if (!Proxy) { - CreateEmbeddingsFunctionalTest->FailTest(TEXT("Failed to create embeddings request proxy")); + EmbeddingsFunctionalTest->FailTest(TEXT("Failed to create embeddings request proxy")); return; } @@ -159,26 +164,989 @@ void AFunctionalTestPawn::OnEmbeddingsSuccess(FCreateEmbeddingsResponse Response { if (JSONString.IsEmpty()) { - CreateEmbeddingsFunctionalTest->FailTest(TEXT("No JSON String returned")); + EmbeddingsFunctionalTest->FailTest(TEXT("No JSON String returned")); return; } if (!Error.IsEmpty()) { - CreateEmbeddingsFunctionalTest->FailTest(TEXT("Error returned")); + EmbeddingsFunctionalTest->FailTest(TEXT("Error returned")); return; } if (Response.data.Num() < 0) { - CreateEmbeddingsFunctionalTest->FailTest(TEXT("No response data returned")); + EmbeddingsFunctionalTest->FailTest(TEXT("No response data returned")); return; } - CreateEmbeddingsFunctionalTest->PassTest(FString::Printf(TEXT("Response data returned with length of %d"), Response.data.Num())); + EmbeddingsFunctionalTest->PassTest(FString::Printf(TEXT("Response data returned with length of %d"), Response.data.Num())); } void AFunctionalTestPawn::OnEmbeddingsFailure(FCreateEmbeddingsResponse Response, FString JSONString, FString Error) { - CreateEmbeddingsFunctionalTest->FailTest(TEXT("Should not fire failure delegate")); + EmbeddingsFunctionalTest->FailTest(TEXT("Should not fire failure delegate - OnEmbeddingsFailure")); +} + +void AFunctionalTestPawn::StartModerationsTest(FString Input) +{ + if (!ModerationsFunctionalTest) + { + return; + } + + if (Input.IsEmpty() || Input.Len() <= 0 || Input == TEXT("")) + { + ModerationsFunctionalTest->FailTest(TEXT("Input is empty")); + return; + } + + const auto Proxy = UCreateModerationRequestProxy::CreateModerationRequest(this, Input, EModerationModels::EMM_Stable); + + if (!Proxy) + { + ModerationsFunctionalTest->FailTest(TEXT("Failed to create moderation request proxy")); + return; + } + + Proxy->OnSuccess.AddDynamic(this, &AFunctionalTestPawn::OnModerationSuccess); + Proxy->OnFailure.AddDynamic(this, &AFunctionalTestPawn::OnModerationFailure); + + Proxy->Activate(); +} + +void AFunctionalTestPawn::OnModerationSuccess(FCreateModerationResponse Response, FString JSONString, FString Error) +{ + if (JSONString.IsEmpty()) + { + ModerationsFunctionalTest->FailTest(TEXT("No JSON String returned")); + return; + } + + if (!Error.IsEmpty()) + { + ModerationsFunctionalTest->FailTest(TEXT("Error returned")); + return; + } + + if (!Response.results[0].flagged) + { + ModerationsFunctionalTest->FailTest(TEXT("Response is not flagged as expected")); + return; + } + + ModerationsFunctionalTest->PassTest(TEXT("Response is flagged correctly")); +} + +void AFunctionalTestPawn::OnModerationFailure(FCreateModerationResponse Response, FString JSONString, FString Error) +{ + ModerationsFunctionalTest->FailTest(TEXT("Should not fire failure delegate - OnModerationFailure")); +} + +void AFunctionalTestPawn::StartCreateFileTest(const FString TestFilePath) +{ + if (!FilesFunctionalTest) + { + return; + } + + if (TestFilePath.IsEmpty() || TestFilePath.Len() <= 0 || TestFilePath == TEXT("")) + { + FilesFunctionalTest->FailTest(TEXT("Input is empty")); + return; + } + + FFileToLoad FileToLoad; + TArray FileResult; + FFileHelper::LoadFileToArray(FileResult, *TestFilePath); + FileToLoad.FileData = FileResult; + FileToLoad.FileName = FPaths::GetCleanFilename(TestFilePath); + FileToLoad.FileExtension = FPaths::GetExtension(TestFilePath); + + if (FileResult.Num() <= 0) + { + FilesFunctionalTest->FailTest(TEXT("Failed to load file")); + return; + } + + if (FileToLoad.FileName != TEXT("training.jsonl")) + { + FilesFunctionalTest->FailTest(TEXT("File name is not correct, should be test.jsonl; check if the test.jsonl is present inside Plugins/UnrealOpenAI/Content/Test/")); + return; + } + + if (FileToLoad.FileExtension != TEXT("jsonl")) + { + FilesFunctionalTest->FailTest(TEXT("File extension is not correct, should be jsonl; check if the test.jsonl is present inside Plugins/UnrealOpenAI/Content/Test/")); + return; + } + + const auto Proxy = UUploadFileRequestProxy::UploadFileRequest(this, FileToLoad, TEXT("fine-tune")); + + if (!Proxy) + { + FilesFunctionalTest->FailTest(TEXT("Failed to create upload files request proxy")); + return; + } + + Proxy->OnSuccess.AddDynamic(this, &AFunctionalTestPawn::OnCreateFileSuccess); + Proxy->OnFailure.AddDynamic(this, &AFunctionalTestPawn::OnCreateFileFailure); + + Proxy->Activate(); +} + +void AFunctionalTestPawn::OnCreateFileSuccess(FFileResponse Response, FString JSONString, FString Error) +{ + if (JSONString.IsEmpty()) + { + FilesFunctionalTest->FailTest(TEXT("No JSON String returned")); + return; + } + + if (!Error.IsEmpty()) + { + FilesFunctionalTest->FailTest(TEXT("Error returned")); + return; + } + + if (Response.id.IsEmpty()) + { + FilesFunctionalTest->FailTest(TEXT("Response id is empty")); + return; + } + + FilesFunctionalTest->OnFileUploadTestComplete(); +} + +void AFunctionalTestPawn::OnCreateFileFailure(FFileResponse Response, FString JSONString, FString Error) +{ + FilesFunctionalTest->FailTest(TEXT("Should not fire failure delegate - OnCreateFileFailure")); +} + +void AFunctionalTestPawn::StartListFilesTest() +{ + if (!FilesFunctionalTest) + { + return; + } + + const auto Proxy = UListFilesRequestProxy::ListFilesRequest(this); + + if (!Proxy) + { + FilesFunctionalTest->FailTest(TEXT("Failed to create list files request proxy")); + return; + } + + Proxy->OnSuccess.AddDynamic(this, &AFunctionalTestPawn::OnListFileSuccess); + Proxy->OnFailure.AddDynamic(this, &AFunctionalTestPawn::OnListFileFailure); + + Proxy->Activate(); +} + +void AFunctionalTestPawn::OnListFileSuccess(FListFilesResponse Response, FString JSONString, FString Error) +{ + if (JSONString.IsEmpty()) + { + FilesFunctionalTest->FailTest(TEXT("No JSON String returned")); + return; + } + + if (!Error.IsEmpty()) + { + FilesFunctionalTest->FailTest(TEXT("Error returned")); + return; + } + + if (Response.data.Num() <= 0) + { + FilesFunctionalTest->FailTest(TEXT("No files listed")); + return; + } + + FilesFunctionalTest->OnListFilesTestComplete(Response.data[0].id); +} + +void AFunctionalTestPawn::OnListFileFailure(FListFilesResponse Response, FString JSONString, FString Error) +{ + FilesFunctionalTest->FailTest(TEXT("Should not fire failure delegate - OnListFileFailure")); +} + +void AFunctionalTestPawn::StartRetrieveFileTest(FString ID) +{ + if (!FilesFunctionalTest) + { + return; + } + + if (ID.IsEmpty()) + { + FilesFunctionalTest->FailTest(TEXT("ID is empty")); + return; + } + + FileID = ID; + + const auto Proxy = URetrieveFileRequestProxy::RetrieveFileRequest(this, ID); + + if (!Proxy) + { + FilesFunctionalTest->FailTest(TEXT("Failed to create retrieve file request proxy")); + return; + } + + Proxy->OnSuccess.AddDynamic(this, &AFunctionalTestPawn::OnRetrieveFileSuccess); + Proxy->OnFailure.AddDynamic(this, &AFunctionalTestPawn::OnRetrieveFileFailure); + + Proxy->Activate(); +} + +void AFunctionalTestPawn::OnRetrieveFileSuccess(FFileResponse Response, FString JSONString, FString Error) +{ + if (JSONString.IsEmpty()) + { + FilesFunctionalTest->FailTest(TEXT("No JSON String returned")); + return; + } + + if (!Error.IsEmpty()) + { + FilesFunctionalTest->FailTest(TEXT("Error returned")); + return; + } + + if (Response.id.IsEmpty()) + { + FilesFunctionalTest->FailTest(TEXT("Response id is empty")); + return; + } + + if (!Response.id.Equals(FileID)) + { + FilesFunctionalTest->FailTest(TEXT("Response id is not the same as the requested id")); + return; + } + + FilesFunctionalTest->OnRetrieveFileTestComplete(FileID); +} + +void AFunctionalTestPawn::OnRetrieveFileFailure(FFileResponse Response, FString JSONString, FString Error) +{ + FilesFunctionalTest->FailTest(TEXT("Should not fire failure delegate - OnRetrieveFileFailure")); +} + +void AFunctionalTestPawn::StartDeleteFileTest(FString ID) +{ + if (!FilesFunctionalTest) + { + return; + } + + if (ID.IsEmpty()) + { + FilesFunctionalTest->FailTest(TEXT("ID is empty")); + return; + } + + FileID = ID; + + const auto Proxy = UDeleteFileRequestProxy::DeleteFileRequest(this, ID); + + if (!Proxy) + { + FilesFunctionalTest->FailTest(TEXT("Failed to create delete file request proxy")); + return; + } + + Proxy->OnSuccess.AddDynamic(this, &AFunctionalTestPawn::OnDeleteFileSuccess); + Proxy->OnFailure.AddDynamic(this, &AFunctionalTestPawn::OnDeleteFileFailure); + + Proxy->Activate(); +} + +void AFunctionalTestPawn::OnDeleteFileSuccess(FDeleteResponse Response, FString JSONString, FString Error) +{ + if (JSONString.IsEmpty()) + { + FilesFunctionalTest->FailTest(TEXT("No JSON String returned")); + return; + } + + if (!Error.IsEmpty()) + { + FilesFunctionalTest->FailTest(TEXT("Error returned")); + return; + } + + if (Response.id.IsEmpty()) + { + FilesFunctionalTest->FailTest(TEXT("Response id is empty")); + return; + } + + if (!Response.id.Equals(FileID)) + { + FilesFunctionalTest->FailTest(TEXT("Response id is not the same as the requested id")); + return; + } + + FilesFunctionalTest->OnDeleteFileTestComplete(); +} + +void AFunctionalTestPawn::OnDeleteFileFailure(FDeleteResponse Response, FString JSONString, FString Error) +{ + FilesFunctionalTest->FailTest(TEXT("Should not fire failure delegate - OnDeleteFileFailure")); +} + +void AFunctionalTestPawn::StartCreateImageURLTest(FString Prompt) +{ + if (!ImageURLFunctionalTest) + { + return; + } + + if (Prompt.IsEmpty()) + { + ImageURLFunctionalTest->FailTest(TEXT("Prompt is empty")); + return; + } + + const auto Proxy = UCreateImageRequestURL::CreateImageURL(this, Prompt, EImageSize::EIS_256); + + if (!Proxy) + { + ImageURLFunctionalTest->FailTest(TEXT("Failed to create create image url request proxy")); + return; + } + + Proxy->OnSuccess.AddDynamic(this, &AFunctionalTestPawn::OnCreateImageURLSuccess); + Proxy->OnFailure.AddDynamic(this, &AFunctionalTestPawn::OnCreateImageURLFailure); + + Proxy->Activate(); +} + +void AFunctionalTestPawn::OnCreateImageURLSuccess(FCreateImageResponseURL Response, FString JSONString, FString Error) +{ + if (JSONString.IsEmpty()) + { + ImageURLFunctionalTest->FailTest(TEXT("No JSON String returned")); + return; + } + + if (!Error.IsEmpty()) + { + ImageURLFunctionalTest->FailTest(TEXT("Error returned")); + return; + } + + if (Response.data.Num() <= 0) + { + ImageURLFunctionalTest->FailTest(TEXT("Response data is empty")); + return; + } + + if (Response.data[0].url.IsEmpty()) + { + ImageURLFunctionalTest->FailTest(TEXT("Response url is empty")); + return; + } + + const auto GetImageFromURLProxy = UUnrealOpenAIUtilsGetImageFromURL::GetImageFromURL(this, Response.data[0].url); + + if (!GetImageFromURLProxy) + { + FilesFunctionalTest->FailTest(TEXT("Failed to create get image from url request proxy")); + return; + } + + GetImageFromURLProxy->OnSuccess.AddDynamic(this, &AFunctionalTestPawn::OnGetCreateImageFromURLSuccess); + + GetImageFromURLProxy->OnFailure.AddDynamic(this, &AFunctionalTestPawn::OnGetCreateImageFromURLFailure); + + GetImageFromURLProxy->Activate(); +} + +void AFunctionalTestPawn::OnCreateImageURLFailure(FCreateImageResponseURL Response, FString JSONString, FString Error) +{ + ImageURLFunctionalTest->FailTest(TEXT("Should not fire failure delegate - OnCreateImageURLFailure")); +} + +void AFunctionalTestPawn::OnGetCreateImageFromURLSuccess(UTexture2D* Texture2D) +{ + if (!Texture2D) + { + ImageURLFunctionalTest->FailTest(TEXT("Texture2D is null")); + return; + } + + ImageURLFunctionalTest->OnCreateImageURLTestComplete(); +} + +void AFunctionalTestPawn::OnGetCreateImageFromURLFailure(UTexture2D* Texture2D) +{ + ImageURLFunctionalTest->FailTest(TEXT("Should not fire failure delegate - OnGetCreateImageFromURLFailure")); +} + +void AFunctionalTestPawn::StartCreateImageEditURLTest(FString ImagePath, FString MaskPath, FString Prompt) +{ + if (!ImageURLFunctionalTest) + { + return; + } + + if (ImagePath.IsEmpty()) + { + ImageURLFunctionalTest->FailTest(TEXT("Image path is empty")); + return; + } + + if (MaskPath.IsEmpty()) + { + ImageURLFunctionalTest->FailTest(TEXT("Mask path is empty")); + return; + } + + if (Prompt.IsEmpty()) + { + ImageURLFunctionalTest->FailTest(TEXT("Prompt is empty")); + } + + FFileToLoad ImageFile; + TArray ImageResult; + FFileHelper::LoadFileToArray(ImageResult, *ImagePath); + ImageFile.FileData = ImageResult; + ImageFile.FileName = FPaths::GetCleanFilename(ImagePath); + ImageFile.FileExtension = FPaths::GetExtension(ImagePath); + + if (ImageResult.Num() <= 0) + { + ImageURLFunctionalTest->FailTest(TEXT("Failed to load image file")); + return; + } + + if (ImageFile.FileName != TEXT("pool_empty.png")) + { + ImageURLFunctionalTest->FailTest(TEXT("File name is not correct, should be pool_empty.png; check if the pool_empty.png is present inside Plugins/UnrealOpenAI/Content/Test/")); + return; + } + + if (ImageFile.FileExtension != TEXT("png")) + { + ImageURLFunctionalTest->FailTest(TEXT("File extension is not correct, should be png; check if the pool_empty.png is present inside Plugins/UnrealOpenAI/Content/Test/")); + return; + } + + FFileToLoad MaskFile; + TArray MaskResult; + FFileHelper::LoadFileToArray(MaskResult, *MaskPath); + MaskFile.FileData = MaskResult; + MaskFile.FileName = FPaths::GetCleanFilename(MaskPath); + MaskFile.FileExtension = FPaths::GetExtension(MaskPath); + + if (MaskResult.Num() <= 0) + { + ImageURLFunctionalTest->FailTest(TEXT("Failed to load mask file")); + return; + } + + if (MaskFile.FileName != TEXT("pool_mask.png")) + { + ImageURLFunctionalTest->FailTest(TEXT("File name is not correct, should be pool_mask.png; check if the pool_empty.png is present inside Plugins/UnrealOpenAI/Content/Test/")); + return; + } + + if (MaskFile.FileExtension != TEXT("png")) + { + ImageURLFunctionalTest->FailTest(TEXT("File extension is not correct, should be png; check if the pool_mask.png is present inside Plugins/UnrealOpenAI/Content/Test/")); + return; + } + + const auto Proxy = UCreateImageEditRequestURL::CreateImageEditURL(this, ImageFile, MaskFile, Prompt, EImageSize::EIS_256); + + if (!Proxy) + { + ImageURLFunctionalTest->FailTest(TEXT("Failed to create create image edit url request proxy")); + return; + } + + Proxy->OnSuccess.AddDynamic(this, &AFunctionalTestPawn::OnCreateImageEditURLSuccess); + Proxy->OnFailure.AddDynamic(this, &AFunctionalTestPawn::OnCreateImageEditURLFailure); + + Proxy->Activate(); +} + +void AFunctionalTestPawn::OnCreateImageEditURLSuccess(FCreateImageResponseURL ResponseURL, FString JSONString, + FString Error) +{ + if (JSONString.IsEmpty()) + { + ImageURLFunctionalTest->FailTest(TEXT("No JSON String returned")); + return; + } + + if (!Error.IsEmpty()) + { + ImageURLFunctionalTest->FailTest(TEXT("Error returned")); + return; + } + + if (ResponseURL.data.Num() <= 0) + { + ImageURLFunctionalTest->FailTest(TEXT("Response data is empty")); + return; + } + + if (ResponseURL.data[0].url.IsEmpty()) + { + ImageURLFunctionalTest->FailTest(TEXT("Response url is empty")); + return; + } + + const auto GetImageFromURLProxy = UUnrealOpenAIUtilsGetImageFromURL::GetImageFromURL(this, ResponseURL.data[0].url); + + if (!GetImageFromURLProxy) + { + ImageURLFunctionalTest->FailTest(TEXT("Failed to create get image from url request proxy")); + return; + } + + GetImageFromURLProxy->OnSuccess.AddDynamic(this, &AFunctionalTestPawn::OnGetCreateImageEditFromURLSuccess); + + GetImageFromURLProxy->OnFailure.AddDynamic(this, &AFunctionalTestPawn::OnGetCreateImageEditFromURLFailure); + + GetImageFromURLProxy->Activate(); +} + +void AFunctionalTestPawn::OnCreateImageEditURLFailure(FCreateImageResponseURL ResponseURL, FString JSONString, + FString Error) +{ + ImageURLFunctionalTest->FailTest(TEXT("Should not fire failure delegate - OnCreateImageEditURLFailure")); +} + +void AFunctionalTestPawn::OnGetCreateImageEditFromURLSuccess(UTexture2D* Texture2D) +{ + if (!Texture2D) + { + ImageURLFunctionalTest->FailTest(TEXT("Texture2D is null")); + return; + } + + ImageURLFunctionalTest->OnCreateImageEditURLTestComplete(); +} + +void AFunctionalTestPawn::OnGetCreateImageEditFromURLFailure(UTexture2D* Texture2D) +{ + ImageURLFunctionalTest->FailTest(TEXT("Should not fire failure delegate - OnGetCreateImageEditFromURLFailure")); +} + +void AFunctionalTestPawn::StartCreateImageEditVariationURLTest(FString ImagePath) +{ + if (!ImageURLFunctionalTest) + { + return; + } + + if (ImagePath.IsEmpty()) + { + ImageURLFunctionalTest->FailTest(TEXT("Image path is empty")); + return; + } + + FFileToLoad ImageFile; + TArray ImageResult; + FFileHelper::LoadFileToArray(ImageResult, *ImagePath); + ImageFile.FileData = ImageResult; + ImageFile.FileName = FPaths::GetCleanFilename(ImagePath); + ImageFile.FileExtension = FPaths::GetExtension(ImagePath); + + if (ImageResult.Num() <= 0) + { + ImageURLFunctionalTest->FailTest(TEXT("Failed to load image file")); + return; + } + + if (ImageFile.FileName != TEXT("pool_empty.png")) + { + ImageURLFunctionalTest->FailTest(TEXT("File name is not correct, should be pool_empty.png; check if the pool_empty.png is present inside Plugins/UnrealOpenAI/Content/Test/")); + return; + } + + if (ImageFile.FileExtension != TEXT("png")) + { + ImageURLFunctionalTest->FailTest(TEXT("File extension is not correct, should be png; check if the pool_empty.png is present inside Plugins/UnrealOpenAI/Content/Test/")); + return; + } + + const auto Proxy = UCreateImageVariationRequestURL::CreateImageVariationURL(this, ImageFile, EImageSize::EIS_256); + + if (!Proxy) + { + ImageURLFunctionalTest->FailTest(TEXT("Failed to create create image edit variation url request proxy")); + return; + } + + Proxy->OnSuccess.AddDynamic(this, &AFunctionalTestPawn::OnCreateImageEditVariationURLSuccess); + Proxy->OnFailure.AddDynamic(this, &AFunctionalTestPawn::OnCreateImageEditVariationURLFailure); + + Proxy->Activate(); +} + +void AFunctionalTestPawn::OnCreateImageEditVariationURLSuccess(FCreateImageResponseURL ResponseURL, FString JSONString, + FString Error) +{ + if (JSONString.IsEmpty()) + { + ImageURLFunctionalTest->FailTest(TEXT("No JSON String returned")); + return; + } + + if (!Error.IsEmpty()) + { + ImageURLFunctionalTest->FailTest(TEXT("Error returned")); + return; + } + + if (ResponseURL.data.Num() <= 0) + { + ImageURLFunctionalTest->FailTest(TEXT("Response data is empty")); + return; + } + + if (ResponseURL.data[0].url.IsEmpty()) + { + ImageURLFunctionalTest->FailTest(TEXT("Response url is empty")); + return; + } + + const auto GetImageFromURLProxy = UUnrealOpenAIUtilsGetImageFromURL::GetImageFromURL(this, ResponseURL.data[0].url); + + if (!GetImageFromURLProxy) + { + ImageURLFunctionalTest->FailTest(TEXT("Failed to create get image from url request proxy")); + return; + } + + GetImageFromURLProxy->OnSuccess.AddDynamic(this, &AFunctionalTestPawn::OnGetCreateImageEditVariationFromURLSuccess); + + GetImageFromURLProxy->OnFailure.AddDynamic(this, &AFunctionalTestPawn::OnGetCreateImageEditVariationFromURLFailure); + + GetImageFromURLProxy->Activate(); +} + +void AFunctionalTestPawn::OnCreateImageEditVariationURLFailure(FCreateImageResponseURL ResponseURL, FString JSONString, + FString Error) +{ + ImageURLFunctionalTest->FailTest(TEXT("Should not fire failure delegate - OnCreateImageEditVariationURLFailure")); +} + +void AFunctionalTestPawn::OnGetCreateImageEditVariationFromURLSuccess(UTexture2D* Texture2D) +{ + if (!Texture2D) + { + ImageURLFunctionalTest->FailTest(TEXT("Texture2D is null")); + return; + } + + ImageURLFunctionalTest->OnCreateImageEditVariationURLTestComplete(); +} + +void AFunctionalTestPawn::OnGetCreateImageEditVariationFromURLFailure(UTexture2D* Texture2D) +{ + ImageURLFunctionalTest->FailTest(TEXT("Should not fire failure delegate - OnGetCreateImageEditVariationFromURLFailure")); +} + +void AFunctionalTestPawn::StartCreateImageBase64Test(FString Prompt) +{ + if (!ImageBase64FunctionalTest) + { + return; + } + + if (Prompt.IsEmpty()) + { + ImageBase64FunctionalTest->FailTest(TEXT("Prompt is empty")); + return; + } + + const auto Proxy = UCreateImageRequestBase64JSON::CreateImageBase64JSON(this, Prompt, EImageSize::EIS_256); + + if (!Proxy) + { + ImageBase64FunctionalTest->FailTest(TEXT("Failed to create create image base64 request proxy")); + return; + } + + Proxy->OnSuccess.AddDynamic(this, &AFunctionalTestPawn::OnCreateImageBase64Success); + Proxy->OnFailure.AddDynamic(this, &AFunctionalTestPawn::OnCreateImageBase64Failure); + + Proxy->Activate(); +} + +void AFunctionalTestPawn::OnCreateImageBase64Success(FCreateImageResponseBase64JSON Response, FString JSONString, + FString Error) +{ + if (JSONString.IsEmpty()) + { + ImageBase64FunctionalTest->FailTest(TEXT("No JSON String returned")); + return; + } + + if (!Error.IsEmpty()) + { + ImageBase64FunctionalTest->FailTest(TEXT("Error returned")); + return; + } + + if (Response.data.Num() <= 0) + { + ImageBase64FunctionalTest->FailTest(TEXT("Response data is empty")); + return; + } + + if (Response.data[0].b64_json.IsEmpty()) + { + ImageBase64FunctionalTest->FailTest(TEXT("Response base64 is empty")); + return; + } + + UTexture2D* OutTexture; + if (!UUnrealOpenAIUtils::ConvertBase64ToTexture2D(Response.data[0].b64_json, OutTexture)) + { + ImageBase64FunctionalTest->FailTest(TEXT("Failed to convert base64 to texture2d")); + return; + } + + if (!OutTexture) + { + ImageBase64FunctionalTest->FailTest(TEXT("OutTexture is null")); + return; + } + + ImageBase64FunctionalTest->OnCreateImageBase64TestComplete(); +} + +void AFunctionalTestPawn::OnCreateImageBase64Failure(FCreateImageResponseBase64JSON Response, FString JSONString, + FString Error) +{ + ImageBase64FunctionalTest->FailTest(TEXT("Should not fire failure delegate - OnCreateImageBase64Failure")); +} + +void AFunctionalTestPawn::StartCreateImageEditBase64Test(FString ImagePath, FString MaskPath, const FString Prompt) +{ + if (!ImageBase64FunctionalTest) + { + return; + } + + if (Prompt.IsEmpty()) + { + ImageBase64FunctionalTest->FailTest(TEXT("Prompt is empty")); + return; + } + + FFileToLoad ImageFile; + TArray ImageResult; + FFileHelper::LoadFileToArray(ImageResult, *ImagePath); + ImageFile.FileData = ImageResult; + ImageFile.FileName = FPaths::GetCleanFilename(ImagePath); + ImageFile.FileExtension = FPaths::GetExtension(ImagePath); + + if (ImageResult.Num() <= 0) + { + ImageURLFunctionalTest->FailTest(TEXT("Failed to load image file")); + return; + } + + if (ImageFile.FileName != TEXT("pool_empty.png")) + { + ImageURLFunctionalTest->FailTest(TEXT("File name is not correct, should be pool_empty.png; check if the pool_empty.png is present inside Plugins/UnrealOpenAI/Content/Test/")); + return; + } + + if (ImageFile.FileExtension != TEXT("png")) + { + ImageURLFunctionalTest->FailTest(TEXT("File extension is not correct, should be png; check if the pool_empty.png is present inside Plugins/UnrealOpenAI/Content/Test/")); + return; + } + + FFileToLoad MaskFile; + TArray MaskResult; + FFileHelper::LoadFileToArray(MaskResult, *MaskPath); + MaskFile.FileData = MaskResult; + MaskFile.FileName = FPaths::GetCleanFilename(MaskPath); + MaskFile.FileExtension = FPaths::GetExtension(MaskPath); + + if (MaskResult.Num() <= 0) + { + ImageURLFunctionalTest->FailTest(TEXT("Failed to load mask file")); + return; + } + + if (MaskFile.FileName != TEXT("pool_mask.png")) + { + ImageURLFunctionalTest->FailTest(TEXT("File name is not correct, should be pool_mask.png; check if the pool_empty.png is present inside Plugins/UnrealOpenAI/Content/Test/")); + return; + } + + if (MaskFile.FileExtension != TEXT("png")) + { + ImageURLFunctionalTest->FailTest(TEXT("File extension is not correct, should be png; check if the pool_mask.png is present inside Plugins/UnrealOpenAI/Content/Test/")); + return; + } + + const auto Proxy = UCreateImageEditRequestBase64JSON::CreateImageEditJSON(this, ImageFile, MaskFile, Prompt, EImageSize::EIS_256); + + if (!Proxy) + { + ImageBase64FunctionalTest->FailTest(TEXT("Failed to create create image edit base64 request proxy")); + return; + } + + Proxy->OnSuccess.AddDynamic(this, &AFunctionalTestPawn::OnCreateImageEditBase64Success); + Proxy->OnFailure.AddDynamic(this, &AFunctionalTestPawn::OnCreateImageEditBase64Failure); + + Proxy->Activate(); +} + +void AFunctionalTestPawn::OnCreateImageEditBase64Success(FCreateImageResponseBase64JSON Response, + FString JSONString, FString Error) +{ + if (JSONString.IsEmpty()) + { + ImageBase64FunctionalTest->FailTest(TEXT("No JSON String returned")); + return; + } + + if (!Error.IsEmpty()) + { + ImageBase64FunctionalTest->FailTest(TEXT("Error returned")); + return; + } + + if (Response.data.Num() <= 0) + { + ImageBase64FunctionalTest->FailTest(TEXT("Response data is empty")); + return; + } + + if (Response.data[0].b64_json.IsEmpty()) + { + ImageBase64FunctionalTest->FailTest(TEXT("Response base64 is empty")); + return; + } + + UTexture2D* OutTexture; + if (!UUnrealOpenAIUtils::ConvertBase64ToTexture2D(Response.data[0].b64_json, OutTexture)) + { + ImageBase64FunctionalTest->FailTest(TEXT("Failed to convert base64 to texture2d")); + return; + } + + if (!OutTexture) + { + ImageBase64FunctionalTest->FailTest(TEXT("OutTexture is null")); + return; + } + + ImageBase64FunctionalTest->OnCreateImageEditBase64TestComplete(); +} + +void AFunctionalTestPawn::OnCreateImageEditBase64Failure(FCreateImageResponseBase64JSON ResponseBase64JSON, + FString JSONString, FString Error) +{ + ImageBase64FunctionalTest->FailTest(TEXT("Should not fire failure delegate - OnCreateImageEditBase64Failure")); +} + +void AFunctionalTestPawn::StartCreateImageEditVariationBase64Test(FString ImagePath) +{ + if (!ImageBase64FunctionalTest) + { + return; + } + + FFileToLoad ImageFile; + TArray ImageResult; + FFileHelper::LoadFileToArray(ImageResult, *ImagePath); + ImageFile.FileData = ImageResult; + ImageFile.FileName = FPaths::GetCleanFilename(ImagePath); + ImageFile.FileExtension = FPaths::GetExtension(ImagePath); + + if (ImageResult.Num() <= 0) + { + ImageURLFunctionalTest->FailTest(TEXT("Failed to load image file")); + return; + } + + if (ImageFile.FileName != TEXT("pool_empty.png")) + { + ImageURLFunctionalTest->FailTest(TEXT("File name is not correct, should be pool_empty.png; check if the pool_empty.png is present inside Plugins/UnrealOpenAI/Content/Test/")); + return; + } + + if (ImageFile.FileExtension != TEXT("png")) + { + ImageURLFunctionalTest->FailTest(TEXT("File extension is not correct, should be png; check if the pool_empty.png is present inside Plugins/UnrealOpenAI/Content/Test/")); + return; + } + + const auto Proxy = UCreateImageVariationRequestBase64JSON::CreateImageVariationJSON(this, ImageFile, EImageSize::EIS_256); + + if (!Proxy) + { + ImageBase64FunctionalTest->FailTest(TEXT("Failed to create create image edit variation base64 request proxy")); + return; + } + + Proxy->OnSuccess.AddDynamic(this, &AFunctionalTestPawn::OnCreateImageEditVariationBase64Success); + Proxy->OnFailure.AddDynamic(this, &AFunctionalTestPawn::OnCreateImageEditVariationBase64Failure); + + Proxy->Activate(); +} + +void AFunctionalTestPawn::OnCreateImageEditVariationBase64Success(FCreateImageResponseBase64JSON ResponseBase64JSON, + FString JSONString, FString Error) +{ + if (JSONString.IsEmpty()) + { + ImageBase64FunctionalTest->FailTest(TEXT("No JSON String returned")); + return; + } + + if (!Error.IsEmpty()) + { + ImageBase64FunctionalTest->FailTest(TEXT("Error returned")); + return; + } + + if (ResponseBase64JSON.data.Num() <= 0) + { + ImageBase64FunctionalTest->FailTest(TEXT("Response data is empty")); + return; + } + + if (ResponseBase64JSON.data[0].b64_json.IsEmpty()) + { + ImageBase64FunctionalTest->FailTest(TEXT("Response base64 is empty")); + return; + } + + UTexture2D* OutTexture; + if (!UUnrealOpenAIUtils::ConvertBase64ToTexture2D(ResponseBase64JSON.data[0].b64_json, OutTexture)) + { + ImageBase64FunctionalTest->FailTest(TEXT("Failed to convert base64 to texture2d")); + return; + } + + if (!OutTexture) + { + ImageBase64FunctionalTest->FailTest(TEXT("OutTexture is null")); + return; + } + + ImageBase64FunctionalTest->OnCreateImageEditVariationBase64TestComplete(); +} + +void AFunctionalTestPawn::OnCreateImageEditVariationBase64Failure(FCreateImageResponseBase64JSON ResponseBase64JSON, FString JSONString, FString Error) +{ + ImageBase64FunctionalTest->FailTest(TEXT("Should not fire failure delegate - OnCreateImageEditVariationBase64Failure")); } diff --git a/Source/UnrealOpenAI/Private/Tests/FunctionalTests/CompletionFunctionalTest.cpp b/Source/UnrealOpenAI/Private/Tests/FunctionalTests/CompletionFunctionalTest.cpp index 2a2185d..05317e6 100644 --- a/Source/UnrealOpenAI/Private/Tests/FunctionalTests/CompletionFunctionalTest.cpp +++ b/Source/UnrealOpenAI/Private/Tests/FunctionalTests/CompletionFunctionalTest.cpp @@ -5,12 +5,12 @@ #include "Tests/Actors/FunctionalTestPawn.h" -ACreateCompletionFunctionalTest::ACreateCompletionFunctionalTest() +ACompletionsFunctionalTest::ACompletionsFunctionalTest() { PrimaryActorTick.bCanEverTick = false; } -void ACreateCompletionFunctionalTest::OnTestStartHandler() +void ACompletionsFunctionalTest::OnTestStartHandler() { Super::OnTestStartHandler(); if (!TestPawn) @@ -19,7 +19,7 @@ void ACreateCompletionFunctionalTest::OnTestStartHandler() return; } - TestPawn->CreateCompletionFunctionalTest = this; + TestPawn->CompletionsFunctionalTest = this; - TestPawn->StartCreateCompletionTest("Say this is a test"); + TestPawn->StartCompletionsTest("Say this is a test"); } \ No newline at end of file diff --git a/Source/UnrealOpenAI/Private/Tests/FunctionalTests/EditsFunctionalTest.cpp b/Source/UnrealOpenAI/Private/Tests/FunctionalTests/EditsFunctionalTest.cpp index 8281b79..8d453b3 100644 --- a/Source/UnrealOpenAI/Private/Tests/FunctionalTests/EditsFunctionalTest.cpp +++ b/Source/UnrealOpenAI/Private/Tests/FunctionalTests/EditsFunctionalTest.cpp @@ -5,12 +5,12 @@ #include "Tests/Actors/FunctionalTestPawn.h" -ACreateEditsFunctionalTest::ACreateEditsFunctionalTest() +AEditsFunctionalTest::AEditsFunctionalTest() { PrimaryActorTick.bCanEverTick = false; } -void ACreateEditsFunctionalTest::OnTestStartHandler() +void AEditsFunctionalTest::OnTestStartHandler() { Super::OnTestStartHandler(); @@ -20,7 +20,7 @@ void ACreateEditsFunctionalTest::OnTestStartHandler() return; } - TestPawn->CreateEditsFunctionalTest = this; + TestPawn->EditsFunctionalTest = this; - TestPawn->StartCreateEditsTest("What day of the wek is it?", "Fix the spelling mistakes"); + TestPawn->StartEditsTest("What day of the wek is it?", "Fix the spelling mistakes"); } diff --git a/Source/UnrealOpenAI/Private/Tests/FunctionalTests/EmbeddingsFunctionalTest.cpp b/Source/UnrealOpenAI/Private/Tests/FunctionalTests/EmbeddingsFunctionalTest.cpp index 193a21f..9706a09 100644 --- a/Source/UnrealOpenAI/Private/Tests/FunctionalTests/EmbeddingsFunctionalTest.cpp +++ b/Source/UnrealOpenAI/Private/Tests/FunctionalTests/EmbeddingsFunctionalTest.cpp @@ -6,12 +6,12 @@ #include "Tests/Actors/FunctionalTestPawn.h" -ACreateEmbeddingsFunctionalTest::ACreateEmbeddingsFunctionalTest() +AEmbeddingsFunctionalTest::AEmbeddingsFunctionalTest() { PrimaryActorTick.bCanEverTick = false; } -void ACreateEmbeddingsFunctionalTest::OnTestStartHandler() +void AEmbeddingsFunctionalTest::OnTestStartHandler() { Super::OnTestStartHandler(); @@ -21,9 +21,9 @@ void ACreateEmbeddingsFunctionalTest::OnTestStartHandler() return; } - TestPawn->CreateEmbeddingsFunctionalTest = this; + TestPawn->EmbeddingsFunctionalTest = this; - TestPawn->StartCreateEmbeddingsTest(TEXT("The food was delicious and the waiter...")); + TestPawn->StartEmbeddingsTest(TEXT("The food was delicious and the waiter...")); } diff --git a/Source/UnrealOpenAI/Private/Tests/FunctionalTests/FilesFunctionalTest.cpp b/Source/UnrealOpenAI/Private/Tests/FunctionalTests/FilesFunctionalTest.cpp new file mode 100644 index 0000000..cf3bf50 --- /dev/null +++ b/Source/UnrealOpenAI/Private/Tests/FunctionalTests/FilesFunctionalTest.cpp @@ -0,0 +1,49 @@ +// Created, maintained by Vanan A. - rezonated @ github.com + + +#include "Tests/FunctionalTests/FilesFunctionalTest.h" + +#include "Kismet/KismetSystemLibrary.h" +#include "Tests/Actors/FunctionalTestPawn.h" + +AFilesFunctionalTest::AFilesFunctionalTest() +{ + PrimaryActorTick.bCanEverTick = false; +} + +void AFilesFunctionalTest::OnTestStartHandler() +{ + Super::OnTestStartHandler(); + + if (!TestPawn) + { + FailTest("TestPawn is not set"); + return; + } + + TestPawn->FilesFunctionalTest = this; + + TestPawn->StartCreateFileTest(FString::Printf(TEXT("%sPlugins/UnrealOpenAI/Content/Test/training.jsonl"), *UKismetSystemLibrary::GetProjectDirectory())); +} + +void AFilesFunctionalTest::OnFileUploadTestComplete() +{ + TestPawn->StartListFilesTest(); +} + +void AFilesFunctionalTest::OnListFilesTestComplete(FString ID) +{ + TestPawn->StartRetrieveFileTest(ID); +} + +void AFilesFunctionalTest::OnRetrieveFileTestComplete(FString ID) +{ + // Skip retrieve file content test for now due to it being a paid feature + + TestPawn->StartDeleteFileTest(ID); +} + +void AFilesFunctionalTest::OnDeleteFileTestComplete() +{ + FinishTest(EFunctionalTestResult::Succeeded, "All files functional tests passed"); +} \ No newline at end of file diff --git a/Source/UnrealOpenAI/Private/Tests/FunctionalTests/ImageBase64FunctionalTest.cpp b/Source/UnrealOpenAI/Private/Tests/FunctionalTests/ImageBase64FunctionalTest.cpp new file mode 100644 index 0000000..d1ad28f --- /dev/null +++ b/Source/UnrealOpenAI/Private/Tests/FunctionalTests/ImageBase64FunctionalTest.cpp @@ -0,0 +1,42 @@ +// Created, maintained by Vanan A. - rezonated @ github.com + + +#include "Tests/FunctionalTests/ImageBase64FunctionalTest.h" + +#include "Tests/Actors/FunctionalTestPawn.h" + +AImageBase64FunctionalTest::AImageBase64FunctionalTest() +{ + PrimaryActorTick.bCanEverTick = false; +} + +void AImageBase64FunctionalTest::OnTestStartHandler() +{ + Super::OnTestStartHandler(); + + if (!TestPawn) + { + FailTest("TestPawn is not set"); + return; + } + + TestPawn->ImageBase64FunctionalTest = this; + + TestPawn->StartCreateImageBase64Test(TEXT("A cute baby sea otter")); +} + +void AImageBase64FunctionalTest::OnCreateImageBase64TestComplete() +{ + TestPawn->StartCreateImageEditBase64Test(FString::Printf(TEXT("%spool_empty.png"), *PluginTestDir), FString::Printf(TEXT("%spool_mask.png"), *PluginTestDir),TEXT("Flamingo")); +} + +void AImageBase64FunctionalTest::OnCreateImageEditBase64TestComplete() +{ + TestPawn->StartCreateImageEditVariationBase64Test(FString::Printf(TEXT("%spool_empty.png"), *PluginTestDir)); +} + +void AImageBase64FunctionalTest::OnCreateImageEditVariationBase64TestComplete() +{ + FinishTest(EFunctionalTestResult::Succeeded, "All tests passed"); +} + diff --git a/Source/UnrealOpenAI/Private/Tests/FunctionalTests/ImageURLFunctionalTest.cpp b/Source/UnrealOpenAI/Private/Tests/FunctionalTests/ImageURLFunctionalTest.cpp new file mode 100644 index 0000000..72ad9d0 --- /dev/null +++ b/Source/UnrealOpenAI/Private/Tests/FunctionalTests/ImageURLFunctionalTest.cpp @@ -0,0 +1,42 @@ +// Created, maintained by Vanan A. - rezonated @ github.com + + +#include "Tests/FunctionalTests/ImageURLFunctionalTest.h" + +#include "Kismet/KismetSystemLibrary.h" +#include "Tests/Actors/FunctionalTestPawn.h" + +AImageURLFunctionalTest::AImageURLFunctionalTest() +{ + PrimaryActorTick.bCanEverTick = false; +} + +void AImageURLFunctionalTest::OnTestStartHandler() +{ + Super::OnTestStartHandler(); + + if (!TestPawn) + { + FailTest("TestPawn is not set"); + return; + } + + TestPawn->ImageURLFunctionalTest = this; + + TestPawn->StartCreateImageURLTest(TEXT("A cute baby sea otter")); +} + +void AImageURLFunctionalTest::OnCreateImageURLTestComplete() +{ + TestPawn->StartCreateImageEditURLTest(FString::Printf(TEXT("%spool_empty.png"), *PluginTestDir), FString::Printf(TEXT("%spool_mask.png"), *PluginTestDir),TEXT("Flamingo")); +} + +void AImageURLFunctionalTest::OnCreateImageEditURLTestComplete() +{ + TestPawn->StartCreateImageEditVariationURLTest(FString::Printf(TEXT("%spool_empty.png"), *PluginTestDir)); +} + +void AImageURLFunctionalTest::OnCreateImageEditVariationURLTestComplete() +{ + FinishTest(EFunctionalTestResult::Succeeded, "All tests passed"); +} diff --git a/Source/UnrealOpenAI/Private/Tests/FunctionalTests/ModerationsFunctionalTest.cpp b/Source/UnrealOpenAI/Private/Tests/FunctionalTests/ModerationsFunctionalTest.cpp new file mode 100644 index 0000000..2571c13 --- /dev/null +++ b/Source/UnrealOpenAI/Private/Tests/FunctionalTests/ModerationsFunctionalTest.cpp @@ -0,0 +1,26 @@ +// Created, maintained by Vanan A. - rezonated @ github.com + + +#include "Tests/FunctionalTests/ModerationsFunctionalTest.h" + +#include "Tests/Actors/FunctionalTestPawn.h" + +AModerationsFunctionalTest::AModerationsFunctionalTest() +{ + PrimaryActorTick.bCanEverTick = false; +} + +void AModerationsFunctionalTest::OnTestStartHandler() +{ + Super::OnTestStartHandler(); + + if (!TestPawn) + { + FailTest("TestPawn is not set"); + return; + } + + TestPawn->ModerationsFunctionalTest = this; + + TestPawn->StartModerationsTest("I want to kill them"); +} diff --git a/Source/UnrealOpenAI/Private/Tests/FunctionalTests/OpenAIFunctionalTestBase.cpp b/Source/UnrealOpenAI/Private/Tests/FunctionalTests/OpenAIFunctionalTestBase.cpp index 809d325..f5b9590 100644 --- a/Source/UnrealOpenAI/Private/Tests/FunctionalTests/OpenAIFunctionalTestBase.cpp +++ b/Source/UnrealOpenAI/Private/Tests/FunctionalTests/OpenAIFunctionalTestBase.cpp @@ -14,8 +14,6 @@ AOpenAIFunctionalTestBase::AOpenAIFunctionalTestBase() void AOpenAIFunctionalTestBase::OnTestPrepareHandler() { - PrintDebugLogAndOnScreen("OnTestPrepareHandler"); - StartTest(); } @@ -23,8 +21,6 @@ void AOpenAIFunctionalTestBase::BeginPlay() { Super::BeginPlay(); - PrintDebugLogAndOnScreen("BeginPlay"); - OnTestPrepare.AddDynamic(this, &AOpenAIFunctionalTestBase::OnTestPrepareHandler); OnTestStart.AddDynamic(this, &AOpenAIFunctionalTestBase::OnTestStartHandler); @@ -32,14 +28,12 @@ void AOpenAIFunctionalTestBase::BeginPlay() void AOpenAIFunctionalTestBase::OnTestStartHandler() { - PrintDebugLogAndOnScreen("Test started"); + } void AOpenAIFunctionalTestBase::PrepareTest() { Super::PrepareTest(); - - PrintDebugLogAndOnScreen("PrepareTest"); } bool AOpenAIFunctionalTestBase::IsReady_Implementation() @@ -50,8 +44,16 @@ bool AOpenAIFunctionalTestBase::IsReady_Implementation() void AOpenAIFunctionalTestBase::StartTest() { Super::StartTest(); +} + +void AOpenAIFunctionalTestBase::FinishTest(EFunctionalTestResult TestResult, const FString& Message) +{ + Super::FinishTest(TestResult, Message); + + PrintDebugLogAndOnScreen(TestResult == EFunctionalTestResult::Succeeded ? "Test passed" : "Test failed"); + PrintDebugLogAndOnScreen(Message); - PrintDebugLogAndOnScreen("StartTest"); + Destroy(); } void AOpenAIFunctionalTestBase::FailTest(FString Message) diff --git a/Source/UnrealOpenAI/Public/Proxies/ImageProxies.h b/Source/UnrealOpenAI/Public/Proxies/ImageProxies.h index 2bbf407..0bd2eed 100644 --- a/Source/UnrealOpenAI/Public/Proxies/ImageProxies.h +++ b/Source/UnrealOpenAI/Public/Proxies/ImageProxies.h @@ -121,14 +121,15 @@ UCLASS() class UNREALOPENAI_API UCreateImageVariationRequestURL : public UOnlineBlueprintCallProxyBase { GENERATED_BODY() + + +public: UPROPERTY(BlueprintAssignable) FCreateImageVariationRequestCallbackSignatureURL OnSuccess; UPROPERTY(BlueprintAssignable) FCreateImageVariationRequestCallbackSignatureURL OnFailure; - -public: virtual void Activate() override; UFUNCTION(BlueprintCallable, meta=(BlueprintInternalUseOnly = "true", WorldContext = "WorldContextObject"), Category = "UnrealOpenAI | Image") diff --git a/Source/UnrealOpenAI/Public/Tests/Actors/FunctionalTestPawn.h b/Source/UnrealOpenAI/Public/Tests/Actors/FunctionalTestPawn.h index ec9d936..44cbf04 100644 --- a/Source/UnrealOpenAI/Public/Tests/Actors/FunctionalTestPawn.h +++ b/Source/UnrealOpenAI/Public/Tests/Actors/FunctionalTestPawn.h @@ -6,7 +6,14 @@ #include "DataTypes/CompletionDataTypes.h" #include "DataTypes/EditsDataTypes.h" #include "DataTypes/EmbeddingsDataTypes.h" +#include "DataTypes/FilesDataTypes.h" +#include "DataTypes/ImageDataTypes.h" +#include "DataTypes/ModerationDataTypes.h" #include "GameFramework/Pawn.h" +#include "Tests/FunctionalTests/FilesFunctionalTest.h" +#include "Tests/FunctionalTests/ImageBase64FunctionalTest.h" +#include "Tests/FunctionalTests/ImageURLFunctionalTest.h" +#include "Tests/FunctionalTests/ModerationsFunctionalTest.h" #include "FunctionalTestPawn.generated.h" UCLASS() @@ -21,10 +28,10 @@ class UNREALOPENAI_API AFunctionalTestPawn : public APawn #pragma region Completion UPROPERTY() - class ACreateCompletionFunctionalTest* CreateCompletionFunctionalTest; + class ACompletionsFunctionalTest* CompletionsFunctionalTest; UFUNCTION() - void StartCreateCompletionTest(FString Prompt); + void StartCompletionsTest(FString Prompt); UFUNCTION() void OnCompletionSuccess(FCreateCompletionResponse Response, FString JSONString, FString Error); @@ -37,10 +44,10 @@ class UNREALOPENAI_API AFunctionalTestPawn : public APawn #pragma region Edits UPROPERTY() - class ACreateEditsFunctionalTest* CreateEditsFunctionalTest; + class AEditsFunctionalTest* EditsFunctionalTest; UFUNCTION() - void StartCreateEditsTest(FString Input, FString Instruction); + void StartEditsTest(FString Input, FString Instruction); UFUNCTION() void OnEditsSuccess(FCreateEditsResponse Response, FString JSONString, FString Error); @@ -53,16 +60,162 @@ class UNREALOPENAI_API AFunctionalTestPawn : public APawn #pragma region Embeddings UPROPERTY() - class ACreateEmbeddingsFunctionalTest* CreateEmbeddingsFunctionalTest; + class AEmbeddingsFunctionalTest* EmbeddingsFunctionalTest; UFUNCTION() - void StartCreateEmbeddingsTest(FString Input); + void StartEmbeddingsTest(FString Input); UFUNCTION() void OnEmbeddingsSuccess(FCreateEmbeddingsResponse Response, FString JSONString, FString Error); UFUNCTION() void OnEmbeddingsFailure(FCreateEmbeddingsResponse Response, FString JSONString, FString Error); -#pragma endregion +#pragma endregion + +#pragma region Moderation + + UPROPERTY() + AModerationsFunctionalTest* ModerationsFunctionalTest; + + UFUNCTION() + void StartModerationsTest(FString Input); + + UFUNCTION() + void OnModerationSuccess(FCreateModerationResponse Response, FString JSONString, FString Error); + + UFUNCTION() + void OnModerationFailure(FCreateModerationResponse Response, FString JSONString, FString Error); + +#pragma endregion + +#pragma region Files + + UPROPERTY() + AFilesFunctionalTest* FilesFunctionalTest; + + UFUNCTION() + void StartCreateFileTest(const FString TestFilePath); + + UFUNCTION() + void OnCreateFileSuccess(FFileResponse Response, FString JSONString, FString Error); + + UFUNCTION() + void OnCreateFileFailure(FFileResponse Response, FString JSONString, FString Error); + + UFUNCTION() + void StartListFilesTest(); + + UFUNCTION() + void OnListFileSuccess(FListFilesResponse Response, FString JSONString, FString Error); + + UFUNCTION() + void OnListFileFailure(FListFilesResponse Response, FString JSONString, FString Error); + + UFUNCTION() + void StartRetrieveFileTest(FString ID); + + FString FileID; + + UFUNCTION() + void OnRetrieveFileSuccess(FFileResponse Response, FString JSONString, FString Error); + + UFUNCTION() + void OnRetrieveFileFailure(FFileResponse Response, FString JSONString, FString Error); + + UFUNCTION() + void StartDeleteFileTest(FString ID); + + UFUNCTION() + void OnDeleteFileSuccess(FDeleteResponse Response, FString JSONString, FString Error); + + UFUNCTION() + void OnDeleteFileFailure(FDeleteResponse Response, FString JSONString, FString Error); + +#pragma endregion + +#pragma region Image URL + + UPROPERTY() + AImageURLFunctionalTest* ImageURLFunctionalTest; + + UFUNCTION() + void StartCreateImageURLTest(FString Prompt); + + UFUNCTION() + void OnCreateImageURLSuccess(FCreateImageResponseURL Response, FString JSONString, FString Error); + + UFUNCTION() + void OnCreateImageURLFailure(FCreateImageResponseURL Response, FString JSONString, FString Error); + + UFUNCTION() + void OnGetCreateImageFromURLSuccess(UTexture2D* Texture2D); + + UFUNCTION() + void OnGetCreateImageFromURLFailure(UTexture2D* Texture2D); + + UFUNCTION() + void StartCreateImageEditURLTest(FString ImagePath, FString MaskPath, FString Prompt); + + UFUNCTION() + void OnCreateImageEditURLSuccess(FCreateImageResponseURL ResponseURL, FString JSONString, FString Error); + + UFUNCTION() + void OnCreateImageEditURLFailure(FCreateImageResponseURL ResponseURL, FString JSONString, FString Error); + + UFUNCTION() + void OnGetCreateImageEditFromURLSuccess(UTexture2D* Texture2D); + + UFUNCTION() + void OnGetCreateImageEditFromURLFailure(UTexture2D* Texture2D); + + UFUNCTION() + void StartCreateImageEditVariationURLTest(FString ImagePath); + + UFUNCTION() + void OnCreateImageEditVariationURLSuccess(FCreateImageResponseURL ResponseURL, FString JSONString, FString Error); + + UFUNCTION() + void OnCreateImageEditVariationURLFailure(FCreateImageResponseURL ResponseURL, FString JSONString, FString Error); + + UFUNCTION() + void OnGetCreateImageEditVariationFromURLSuccess(UTexture2D* Texture2D); + + UFUNCTION() + void OnGetCreateImageEditVariationFromURLFailure(UTexture2D* Texture2D); + +#pragma endregion + +#pragma region Image Base64 + + UPROPERTY() + AImageBase64FunctionalTest* ImageBase64FunctionalTest; + UFUNCTION() + void StartCreateImageBase64Test(FString Prompt); + + UFUNCTION() + void OnCreateImageBase64Success(FCreateImageResponseBase64JSON Response, FString JSONString, FString Error); + + UFUNCTION() + void OnCreateImageBase64Failure(FCreateImageResponseBase64JSON Response, FString JSONString, FString Error); + + UFUNCTION() + void StartCreateImageEditBase64Test(FString ImagePath, FString MaskPath, const FString Prompt); + + UFUNCTION() + void OnCreateImageEditBase64Success(FCreateImageResponseBase64JSON Response, FString JSONString, FString Error); + + UFUNCTION() + void OnCreateImageEditBase64Failure(FCreateImageResponseBase64JSON ResponseBase64JSON, FString JSONString, FString Error); + + UFUNCTION() + void StartCreateImageEditVariationBase64Test(FString ImagePath); + + UFUNCTION() + void OnCreateImageEditVariationBase64Success(FCreateImageResponseBase64JSON ResponseBase64JSON, FString JSONString, FString Error); + + UFUNCTION() + void OnCreateImageEditVariationBase64Failure(FCreateImageResponseBase64JSON ResponseBase64JSON, FString JSONString, FString Error); + +#pragma endregion }; diff --git a/Source/UnrealOpenAI/Public/Tests/FunctionalTests/CompletionFunctionalTest.h b/Source/UnrealOpenAI/Public/Tests/FunctionalTests/CompletionFunctionalTest.h index b04542b..17ff494 100644 --- a/Source/UnrealOpenAI/Public/Tests/FunctionalTests/CompletionFunctionalTest.h +++ b/Source/UnrealOpenAI/Public/Tests/FunctionalTests/CompletionFunctionalTest.h @@ -10,13 +10,13 @@ * */ UCLASS() -class UNREALOPENAI_API ACreateCompletionFunctionalTest : public AOpenAIFunctionalTestBase +class UNREALOPENAI_API ACompletionsFunctionalTest : public AOpenAIFunctionalTestBase { GENERATED_BODY() public: - ACreateCompletionFunctionalTest(); + ACompletionsFunctionalTest(); virtual void OnTestStartHandler() override; diff --git a/Source/UnrealOpenAI/Public/Tests/FunctionalTests/EditsFunctionalTest.h b/Source/UnrealOpenAI/Public/Tests/FunctionalTests/EditsFunctionalTest.h index 85ac740..5c5e107 100644 --- a/Source/UnrealOpenAI/Public/Tests/FunctionalTests/EditsFunctionalTest.h +++ b/Source/UnrealOpenAI/Public/Tests/FunctionalTests/EditsFunctionalTest.h @@ -11,12 +11,12 @@ * */ UCLASS() -class UNREALOPENAI_API ACreateEditsFunctionalTest : public AOpenAIFunctionalTestBase +class UNREALOPENAI_API AEditsFunctionalTest : public AOpenAIFunctionalTestBase { GENERATED_BODY() public: - ACreateEditsFunctionalTest(); + AEditsFunctionalTest(); virtual void OnTestStartHandler() override; diff --git a/Source/UnrealOpenAI/Public/Tests/FunctionalTests/EmbeddingsFunctionalTest.h b/Source/UnrealOpenAI/Public/Tests/FunctionalTests/EmbeddingsFunctionalTest.h index 18a09d6..6be4fb0 100644 --- a/Source/UnrealOpenAI/Public/Tests/FunctionalTests/EmbeddingsFunctionalTest.h +++ b/Source/UnrealOpenAI/Public/Tests/FunctionalTests/EmbeddingsFunctionalTest.h @@ -8,12 +8,12 @@ #include "EmbeddingsFunctionalTest.generated.h" UCLASS() -class UNREALOPENAI_API ACreateEmbeddingsFunctionalTest : public AOpenAIFunctionalTestBase +class UNREALOPENAI_API AEmbeddingsFunctionalTest : public AOpenAIFunctionalTestBase { GENERATED_BODY() public: - ACreateEmbeddingsFunctionalTest(); + AEmbeddingsFunctionalTest(); virtual void OnTestStartHandler() override; diff --git a/Source/UnrealOpenAI/Public/Tests/FunctionalTests/FilesFunctionalTest.h b/Source/UnrealOpenAI/Public/Tests/FunctionalTests/FilesFunctionalTest.h new file mode 100644 index 0000000..0e6d3bd --- /dev/null +++ b/Source/UnrealOpenAI/Public/Tests/FunctionalTests/FilesFunctionalTest.h @@ -0,0 +1,35 @@ +// Created, maintained by Vanan A. - rezonated @ github.com + +#pragma once + +#include "CoreMinimal.h" +#include "Tests/FunctionalTests/OpenAIFunctionalTestBase.h" +#include "FilesFunctionalTest.generated.h" + +/** + * + */ +UCLASS() +class UNREALOPENAI_API AFilesFunctionalTest : public AOpenAIFunctionalTestBase +{ + GENERATED_BODY() +public: + AFilesFunctionalTest(); + + virtual void OnTestStartHandler() override; + + UPROPERTY(EditAnywhere, BlueprintReadOnly, Category="Open AI - Files") + class AFunctionalTestPawn* TestPawn; + + UFUNCTION() + void OnFileUploadTestComplete(); + + UFUNCTION() + void OnListFilesTestComplete(FString ID); + + UFUNCTION() + void OnRetrieveFileTestComplete(FString ID); + + UFUNCTION() + void OnDeleteFileTestComplete(); +}; diff --git a/Source/UnrealOpenAI/Public/Tests/FunctionalTests/ImageBase64FunctionalTest.h b/Source/UnrealOpenAI/Public/Tests/FunctionalTests/ImageBase64FunctionalTest.h new file mode 100644 index 0000000..15020c7 --- /dev/null +++ b/Source/UnrealOpenAI/Public/Tests/FunctionalTests/ImageBase64FunctionalTest.h @@ -0,0 +1,36 @@ +// Created, maintained by Vanan A. - rezonated @ github.com + +#pragma once + +#include "CoreMinimal.h" +#include "Kismet/KismetSystemLibrary.h" +#include "Tests/FunctionalTests/OpenAIFunctionalTestBase.h" +#include "ImageBase64FunctionalTest.generated.h" + +/** + * + */ +UCLASS() +class UNREALOPENAI_API AImageBase64FunctionalTest : public AOpenAIFunctionalTestBase +{ + GENERATED_BODY() + +public: + AImageBase64FunctionalTest(); + + virtual void OnTestStartHandler() override; + + UPROPERTY(EditAnywhere, BlueprintReadOnly, Category="Open AI - Edits") + class AFunctionalTestPawn* TestPawn; + + inline static const auto PluginTestDir = FString::Printf(TEXT("%sPlugins/UnrealOpenAI/Content/Test/"), *UKismetSystemLibrary::GetProjectDirectory()); + + UFUNCTION() + void OnCreateImageBase64TestComplete(); + + UFUNCTION() + void OnCreateImageEditBase64TestComplete(); + + UFUNCTION() + void OnCreateImageEditVariationBase64TestComplete(); +}; diff --git a/Source/UnrealOpenAI/Public/Tests/FunctionalTests/ImageURLFunctionalTest.h b/Source/UnrealOpenAI/Public/Tests/FunctionalTests/ImageURLFunctionalTest.h new file mode 100644 index 0000000..01f9973 --- /dev/null +++ b/Source/UnrealOpenAI/Public/Tests/FunctionalTests/ImageURLFunctionalTest.h @@ -0,0 +1,36 @@ +// Created, maintained by Vanan A. - rezonated @ github.com + +#pragma once + +#include "CoreMinimal.h" +#include "Kismet/KismetSystemLibrary.h" +#include "Tests/FunctionalTests/OpenAIFunctionalTestBase.h" +#include "ImageURLFunctionalTest.generated.h" + +/** + * + */ +UCLASS() +class UNREALOPENAI_API AImageURLFunctionalTest : public AOpenAIFunctionalTestBase +{ + GENERATED_BODY() + +public: + AImageURLFunctionalTest(); + + virtual void OnTestStartHandler() override; + + UPROPERTY(EditAnywhere, BlueprintReadOnly, Category="Open AI - Edits") + class AFunctionalTestPawn* TestPawn; + + inline static const auto PluginTestDir = FString::Printf(TEXT("%sPlugins/UnrealOpenAI/Content/Test/"), *UKismetSystemLibrary::GetProjectDirectory()); + + UFUNCTION() + void OnCreateImageURLTestComplete(); + + UFUNCTION() + void OnCreateImageEditURLTestComplete(); + + UFUNCTION() + void OnCreateImageEditVariationURLTestComplete(); +}; diff --git a/Source/UnrealOpenAI/Public/Tests/FunctionalTests/ModerationsFunctionalTest.h b/Source/UnrealOpenAI/Public/Tests/FunctionalTests/ModerationsFunctionalTest.h new file mode 100644 index 0000000..74bf992 --- /dev/null +++ b/Source/UnrealOpenAI/Public/Tests/FunctionalTests/ModerationsFunctionalTest.h @@ -0,0 +1,23 @@ +// Created, maintained by Vanan A. - rezonated @ github.com + +#pragma once + +#include "CoreMinimal.h" +#include "OpenAIFunctionalTestBase.h" +#include "ModerationsFunctionalTest.generated.h" + +/** + * + */ +UCLASS() +class UNREALOPENAI_API AModerationsFunctionalTest : public AOpenAIFunctionalTestBase +{ + GENERATED_BODY() +public: + AModerationsFunctionalTest(); + + virtual void OnTestStartHandler() override; + + UPROPERTY(EditAnywhere, BlueprintReadOnly, Category="Open AI - Moderation") + class AFunctionalTestPawn* TestPawn; +}; diff --git a/Source/UnrealOpenAI/Public/Tests/FunctionalTests/OpenAIFunctionalTestBase.h b/Source/UnrealOpenAI/Public/Tests/FunctionalTests/OpenAIFunctionalTestBase.h index 2320b36..b8ada82 100644 --- a/Source/UnrealOpenAI/Public/Tests/FunctionalTests/OpenAIFunctionalTestBase.h +++ b/Source/UnrealOpenAI/Public/Tests/FunctionalTests/OpenAIFunctionalTestBase.h @@ -30,6 +30,8 @@ class UNREALOPENAI_API AOpenAIFunctionalTestBase : public AFunctionalTest virtual void StartTest() override; + virtual void FinishTest(EFunctionalTestResult TestResult, const FString& Message) override; + UFUNCTION() virtual void FailTest(FString Message);