iLoveElysia/UE5-cyberHuman
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
main
UE5-cyberHuman/Plugins/OpenAi/Source/OpenAITestRunner/Private/FuncLib.spec.cpp

528 lines
31 KiB
C++
Raw Permalink Normal View History

backup
2025-04-07 18:31:41 -07:00
// OpenAI, Copyright LifeEXE. All Rights Reserved.
#if WITH_AUTOMATION_TESTS
#include "CoreMinimal.h"
#include "Misc/AutomationTest.h"
#include "FuncLib/OpenAIFuncLib.h"
#include "FuncLib/FileSystemFuncLib.h"
#include "Provider/RequestTypes.h"
#include "TestUtils.h"
DEFINE_SPEC(FOpenAIFuncLib, "OpenAI",
EAutomationTestFlags::ApplicationContextMask | EAutomationTestFlags::ProductFilter | EAutomationTestFlags::HighPriority);
void FOpenAIFuncLib::Define()
{
Describe("OpenAIFuncLib",
[this]()
{
It("AllModelToStringShouldReturnCorrectValue",
[this]()
{
TestTrueExpr(UOpenAIFuncLib::OpenAIAllModelToString(EAllModelEnum::Whisper_1).Equals("whisper-1"));
TestTrueExpr(UOpenAIFuncLib::OpenAIAllModelToString(EAllModelEnum::GPT_3_5_Turbo_0301).Equals("gpt-3.5-turbo-0301"));
TestTrueExpr(UOpenAIFuncLib::OpenAIAllModelToString(EAllModelEnum::GPT_3_5_Turbo).Equals("gpt-3.5-turbo"));
TestTrueExpr(
UOpenAIFuncLib::OpenAIAllModelToString(EAllModelEnum::GPT_3_5_Turbo_16k_0613).Equals("gpt-3.5-turbo-16k-0613"));
TestTrueExpr(UOpenAIFuncLib::OpenAIAllModelToString(EAllModelEnum::GPT_3_5_Turbo_16k).Equals("gpt-3.5-turbo-16k"));
TestTrueExpr(UOpenAIFuncLib::OpenAIAllModelToString(EAllModelEnum::GPT_3_5_Turbo_0613).Equals("gpt-3.5-turbo-0613"));
TestTrueExpr(UOpenAIFuncLib::OpenAIAllModelToString(EAllModelEnum::GPT_3_5_Turbo_Instruct_0914)
.Equals("gpt-3.5-turbo-instruct-0914"));
TestTrueExpr(
UOpenAIFuncLib::OpenAIAllModelToString(EAllModelEnum::GPT_3_5_Turbo_Instruct).Equals("gpt-3.5-turbo-instruct"));
TestTrueExpr(
UOpenAIFuncLib::OpenAIAllModelToString(EAllModelEnum::Text_Embedding_Ada_002).Equals("text-embedding-ada-002"));
TestTrueExpr(UOpenAIFuncLib::OpenAIAllModelToString(EAllModelEnum::GPT_4).Equals("gpt-4"));
TestTrueExpr(UOpenAIFuncLib::OpenAIAllModelToString(EAllModelEnum::GPT_4_0314).Equals("gpt-4-0314"));
TestTrueExpr(UOpenAIFuncLib::OpenAIAllModelToString(EAllModelEnum::GPT_4_0613).Equals("gpt-4-0613"));
TestTrueExpr(UOpenAIFuncLib::OpenAIAllModelToString(EAllModelEnum::DALL_E_2).Equals("dall-e-2"));
TestTrueExpr(UOpenAIFuncLib::OpenAIAllModelToString(EAllModelEnum::DALL_E_3).Equals("dall-e-3"));
TestTrueExpr(UOpenAIFuncLib::OpenAIAllModelToString(EAllModelEnum::GPT_4_1106_Preview).Equals("gpt-4-1106-preview"));
TestTrueExpr(
UOpenAIFuncLib::OpenAIAllModelToString(EAllModelEnum::GPT_4_Vision_Preview).Equals("gpt-4-vision-preview"));
TestTrueExpr(UOpenAIFuncLib::OpenAIAllModelToString(EAllModelEnum::GPT_3_5_Turbo_1106).Equals("gpt-3.5-turbo-1106"));
TestTrueExpr(UOpenAIFuncLib::OpenAIAllModelToString(EAllModelEnum::TTS_1).Equals("tts-1"));
TestTrueExpr(UOpenAIFuncLib::OpenAIAllModelToString(EAllModelEnum::TTS_1_HD).Equals("tts-1-hd"));
TestTrueExpr(UOpenAIFuncLib::OpenAIAllModelToString(EAllModelEnum::TTS_1_1106).Equals("tts-1-1106"));
TestTrueExpr(UOpenAIFuncLib::OpenAIAllModelToString(EAllModelEnum::TTS_1_HD_1106).Equals("tts-1-hd-1106"));
TestTrueExpr(
UOpenAIFuncLib::OpenAIAllModelToString(EAllModelEnum::Text_Embedding_3_Large).Equals("text-embedding-3-large"));
TestTrueExpr(UOpenAIFuncLib::OpenAIAllModelToString(EAllModelEnum::GPT_4_32K_0314).Equals("gpt-4-32k-0314"));
TestTrueExpr(UOpenAIFuncLib::OpenAIAllModelToString(EAllModelEnum::GPT_3_5_Turbo_0125).Equals("gpt-3.5-turbo-0125"));
TestTrueExpr(
UOpenAIFuncLib::OpenAIAllModelToString(EAllModelEnum::Text_Embedding_3_Small).Equals("text-embedding-3-small"));
TestTrueExpr(UOpenAIFuncLib::OpenAIAllModelToString(EAllModelEnum::GPT_4_0125_Preview).Equals("gpt-4-0125-preview"));
TestTrueExpr(UOpenAIFuncLib::OpenAIAllModelToString(EAllModelEnum::GPT_4_Turbo_Preview).Equals("gpt-4-turbo-preview"));
TestTrueExpr(UOpenAIFuncLib::OpenAIAllModelToString(EAllModelEnum::GPT_4O_2024_05_13).Equals("gpt-4o-2024-05-13"));
TestTrueExpr(UOpenAIFuncLib::OpenAIAllModelToString(EAllModelEnum::GPT_4O).Equals("gpt-4o"));
TestTrueExpr(
UOpenAIFuncLib::OpenAIAllModelToString(EAllModelEnum::GPT_4_Turbo_2024_04_09).Equals("gpt-4-turbo-2024-04-09"));
TestTrueExpr(UOpenAIFuncLib::OpenAIAllModelToString(EAllModelEnum::GPT_4_Turbo).Equals("gpt-4-turbo"));
TestTrueExpr(UOpenAIFuncLib::OpenAIAllModelToString(EAllModelEnum::GPT_4_1106_Vision_Preview)
.Equals("gpt-4-1106-vision-preview"));
});
It("OpenAIMainModelToStringShouldReturnCorrectValue",
[this]()
{
TestTrueExpr(UOpenAIFuncLib::OpenAIMainModelToString(EMainModelEnum::GPT_3_5_Turbo_0301).Equals("gpt-3.5-turbo-0301"));
TestTrueExpr(UOpenAIFuncLib::OpenAIMainModelToString(EMainModelEnum::GPT_3_5_Turbo).Equals("gpt-3.5-turbo"));
TestTrueExpr(UOpenAIFuncLib::OpenAIMainModelToString(EMainModelEnum::GPT_4O).Equals("gpt-4o"));
TestTrueExpr(UOpenAIFuncLib::OpenAIMainModelToString(EMainModelEnum::GPT_4).Equals("gpt-4"));
TestTrueExpr(UOpenAIFuncLib::OpenAIMainModelToString(EMainModelEnum::GPT_4_0314).Equals("gpt-4-0314"));
TestTrueExpr(UOpenAIFuncLib::OpenAIMainModelToString(EMainModelEnum::GPT_4_0613).Equals("gpt-4-0613"));
TestTrueExpr(UOpenAIFuncLib::OpenAIMainModelToString(EMainModelEnum::GPT_4_1106_Preview).Equals("gpt-4-1106-preview"));
TestTrueExpr(
UOpenAIFuncLib::OpenAIMainModelToString(EMainModelEnum::GPT_4_Vision_Preview).Equals("gpt-4-vision-preview"));
TestTrueExpr(
UOpenAIFuncLib::OpenAIMainModelToString(EMainModelEnum::GPT_3_5_Turbo_Instruct).Equals("gpt-3.5-turbo-instruct"));
});
It("OpenAIModerationModelToStringShouldReturnCorrectValue",
[this]()
{
TestTrueExpr(UOpenAIFuncLib::OpenAIModerationModelToString(EModerationsModelEnum::Text_Moderation_Latest)
.Equals("text-moderation-latest"));
TestTrueExpr(UOpenAIFuncLib::OpenAIModerationModelToString(EModerationsModelEnum::Text_Moderation_Stable)
.Equals("text-moderation-stable"));
});
It("OpenAIAudioModelToStringShouldReturnCorrectValue",
[this]() { TestTrueExpr(UOpenAIFuncLib::OpenAIAudioModelToString(EAudioModel::Whisper_1).Equals("whisper-1")); });
It("OpenAITTSModelToStringShouldReturnCorrectValue",
[this]()
{
TestTrueExpr(UOpenAIFuncLib::OpenAITTSModelToString(ETTSModel::TTS_1).Equals("tts-1"));
TestTrueExpr(UOpenAIFuncLib::OpenAITTSModelToString(ETTSModel::TTS_1_HD).Equals("tts-1-hd"));
});
It("OpenAIVoiceToStringShouldReturnCorrectValue",
[this]()
{
TestTrueExpr(UOpenAIFuncLib::OpenAIVoiceToString(EVoice::Alloy).Equals("alloy"));
TestTrueExpr(UOpenAIFuncLib::OpenAIVoiceToString(EVoice::Echo).Equals("echo"));
TestTrueExpr(UOpenAIFuncLib::OpenAIVoiceToString(EVoice::Fable).Equals("fable"));
TestTrueExpr(UOpenAIFuncLib::OpenAIVoiceToString(EVoice::Nova).Equals("nova"));
TestTrueExpr(UOpenAIFuncLib::OpenAIVoiceToString(EVoice::Onyx).Equals("onyx"));
TestTrueExpr(UOpenAIFuncLib::OpenAIVoiceToString(EVoice::Shimmer).Equals("shimmer"));
});
It("OpenAITTSAudioFormatToStringShouldReturnCorrectValue",
[this]()
{
TestTrueExpr(UOpenAIFuncLib::OpenAITTSAudioFormatToString(ETTSAudioFormat::AAC).Equals("aac"));
TestTrueExpr(UOpenAIFuncLib::OpenAITTSAudioFormatToString(ETTSAudioFormat::FLAC).Equals("flac"));
TestTrueExpr(UOpenAIFuncLib::OpenAITTSAudioFormatToString(ETTSAudioFormat::MP3).Equals("mp3"));
TestTrueExpr(UOpenAIFuncLib::OpenAITTSAudioFormatToString(ETTSAudioFormat::OPUS).Equals("opus"));
});
It("OpenAIImageModelToStringShouldReturnCorrectValue",
[this]()
{
TestTrueExpr(UOpenAIFuncLib::OpenAIImageModelToString(EImageModelEnum::DALL_E_2).Equals("dall-e-2"));
TestTrueExpr(UOpenAIFuncLib::OpenAIImageModelToString(EImageModelEnum::DALL_E_3).Equals("dall-e-3"));
});
It("StringToOpenAIImageModelShouldReturnCorrectValue",
[this]()
{
TestTrueExpr(UOpenAIFuncLib::StringToOpenAIImageModel("dall-e-2") == EImageModelEnum::DALL_E_2);
TestTrueExpr(UOpenAIFuncLib::StringToOpenAIImageModel("dall-e-3") == EImageModelEnum::DALL_E_3);
});
It("StringToOpenAIImageSizeDalle2ShouldReturnCorrectValue",
[this]()
{
TestTrueExpr(UOpenAIFuncLib::StringToOpenAIImageSizeDalle2("256x256") == EImageSizeDalle2::Size_256x256);
TestTrueExpr(UOpenAIFuncLib::StringToOpenAIImageSizeDalle2("512x512") == EImageSizeDalle2::Size_512x512);
TestTrueExpr(UOpenAIFuncLib::StringToOpenAIImageSizeDalle2("1024x1024") == EImageSizeDalle2::Size_1024x1024);
});
It("StringToOpenAIImageSizeDalle3ShouldReturnCorrectValue",
[this]()
{
TestTrueExpr(UOpenAIFuncLib::StringToOpenAIImageSizeDalle3("1024x1024") == EImageSizeDalle3::Size_1024x1024);
TestTrueExpr(UOpenAIFuncLib::StringToOpenAIImageSizeDalle3("1024x1792") == EImageSizeDalle3::Size_1024x1792);
TestTrueExpr(UOpenAIFuncLib::StringToOpenAIImageSizeDalle3("1792x1024") == EImageSizeDalle3::Size_1792x1024);
});
It("StringToOpenAIImageFormatShouldReturnCorrectValue",
[this]()
{
TestTrueExpr(UOpenAIFuncLib::StringToOpenAIImageFormat("url") == EOpenAIImageFormat::URL);
TestTrueExpr(UOpenAIFuncLib::StringToOpenAIImageFormat("b64_json") == EOpenAIImageFormat::B64_JSON);
});
It("StringToOpenAIImageQualityShouldReturnCorrectValue",
[this]()
{
TestTrueExpr(UOpenAIFuncLib::StringToOpenAIImageQuality("hd") == EOpenAIImageQuality::HD);
TestTrueExpr(UOpenAIFuncLib::StringToOpenAIImageQuality("standard") == EOpenAIImageQuality::Standard);
});
It("StringToOpenAIImageStyleShouldReturnCorrectValue",
[this]()
{
TestTrueExpr(UOpenAIFuncLib::StringToOpenAIImageStyle("natural") == EOpenAIImageStyle::Natural);
TestTrueExpr(UOpenAIFuncLib::StringToOpenAIImageStyle("vivid") == EOpenAIImageStyle::Vivid);
});
It("OpenAIImageSizeDalle2ToStringShouldReturnCorrectValue",
[this]()
{
TestTrueExpr(UOpenAIFuncLib::OpenAIImageSizeDalle2ToString(EImageSizeDalle2::Size_256x256).Equals("256x256"));
TestTrueExpr(UOpenAIFuncLib::OpenAIImageSizeDalle2ToString(EImageSizeDalle2::Size_512x512).Equals("512x512"));
TestTrueExpr(UOpenAIFuncLib::OpenAIImageSizeDalle2ToString(EImageSizeDalle2::Size_1024x1024).Equals("1024x1024"));
});
It("OpenAIImageSizeDalle3ToStringShouldReturnCorrectValue",
[this]()
{
TestTrueExpr(UOpenAIFuncLib::OpenAIImageSizeDalle3ToString(EImageSizeDalle3::Size_1024x1024).Equals("1024x1024"));
TestTrueExpr(UOpenAIFuncLib::OpenAIImageSizeDalle3ToString(EImageSizeDalle3::Size_1024x1792).Equals("1024x1792"));
TestTrueExpr(UOpenAIFuncLib::OpenAIImageSizeDalle3ToString(EImageSizeDalle3::Size_1792x1024).Equals("1792x1024"));
});
It("OpenAIImageFormatToStringShouldReturnCorrectValue",
[this]()
{
TestTrueExpr(UOpenAIFuncLib::OpenAIImageFormatToString(EOpenAIImageFormat::URL).Equals("url"));
TestTrueExpr(UOpenAIFuncLib::OpenAIImageFormatToString(EOpenAIImageFormat::B64_JSON).Equals("b64_json"));
});
It("OpenAIImageStyleToStringShouldReturnCorrectValue",
[this]()
{
TestTrueExpr(UOpenAIFuncLib::OpenAIImageStyleToString(EOpenAIImageStyle::Natural).Equals("natural"));
TestTrueExpr(UOpenAIFuncLib::OpenAIImageStyleToString(EOpenAIImageStyle::Vivid).Equals("vivid"));
});
It("OpenAIImageQualityToStringShouldReturnCorrectValue",
[this]()
{
TestTrueExpr(UOpenAIFuncLib::OpenAIImageQualityToString(EOpenAIImageQuality::HD).Equals("hd"));
TestTrueExpr(UOpenAIFuncLib::OpenAIImageQualityToString(EOpenAIImageQuality::Standard).Equals("standard"));
});
It("OpenAIRoleToStringShouldReturnCorrectValue",
[this]()
{
TestTrueExpr(UOpenAIFuncLib::OpenAIRoleToString(ERole::System).Equals("system"));
TestTrueExpr(UOpenAIFuncLib::OpenAIRoleToString(ERole::User).Equals("user"));
TestTrueExpr(UOpenAIFuncLib::OpenAIRoleToString(ERole::Assistant).Equals("assistant"));
TestTrueExpr(UOpenAIFuncLib::OpenAIRoleToString(ERole::Function).Equals("function"));
TestTrueExpr(UOpenAIFuncLib::OpenAIRoleToString(ERole::Tool).Equals("tool"));
});
It("StringToOpenAIRoleShouldReturnCorrectValue",
[this]()
{
TestTrueExpr(UOpenAIFuncLib::StringToOpenAIRole("system") == ERole::System);
TestTrueExpr(UOpenAIFuncLib::StringToOpenAIRole("user") == ERole::User);
TestTrueExpr(UOpenAIFuncLib::StringToOpenAIRole("assistant") == ERole::Assistant);
TestTrueExpr(UOpenAIFuncLib::StringToOpenAIRole("function") == ERole::Function);
TestTrueExpr(UOpenAIFuncLib::StringToOpenAIRole("tool") == ERole::Tool);
});
It("OpenAIFinishReasonToStringShouldReturnCorrectValue",
[this]()
{
TestTrueExpr(UOpenAIFuncLib::OpenAIFinishReasonToString(EOpenAIFinishReason::Stop).Equals("stop"));
TestTrueExpr(UOpenAIFuncLib::OpenAIFinishReasonToString(EOpenAIFinishReason::Length).Equals("length"));
TestTrueExpr(UOpenAIFuncLib::OpenAIFinishReasonToString(EOpenAIFinishReason::Tool_Calls).Equals("tool_calls"));
TestTrueExpr(UOpenAIFuncLib::OpenAIFinishReasonToString(EOpenAIFinishReason::Content_Filter).Equals("content_filter"));
TestTrueExpr(UOpenAIFuncLib::OpenAIFinishReasonToString(EOpenAIFinishReason::Null).Equals(""));
});
It("StringToOpenAIFinishReasonShouldReturnCorrectValue",
[this]()
{
TestTrueExpr(UOpenAIFuncLib::StringToOpenAIFinishReason("stop") == EOpenAIFinishReason::Stop);
TestTrueExpr(UOpenAIFuncLib::StringToOpenAIFinishReason("length") == EOpenAIFinishReason::Length);
TestTrueExpr(UOpenAIFuncLib::StringToOpenAIFinishReason("tool_calls") == EOpenAIFinishReason::Tool_Calls);
TestTrueExpr(UOpenAIFuncLib::StringToOpenAIFinishReason("content_filter") == EOpenAIFinishReason::Content_Filter);
TestTrueExpr(UOpenAIFuncLib::StringToOpenAIFinishReason("") == EOpenAIFinishReason::Null);
});
It("APITokensCanBeLoadedFromFile",
[this]()
{
const FString FilePath = OpenAI::Tests::TestUtils::FileFullPath("OpenAIAuth.ini");
const FOpenAIAuth Auth = UOpenAIFuncLib::LoadAPITokensFromFile(FilePath);
TestTrueExpr(Auth.APIKey.Equals("sk-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"));
TestTrueExpr(Auth.OrganizationID.Equals("org-xxxxxxxxxxxxxxxxxxxxxxxx"));
TestTrueExpr(Auth.ProjectID.Equals("proj_xxxxxxxxxxxxxxxxxxxxxxxxxxxx"));
});
It("OpenAIAudioTranscriptToStringShouldReturnCorrectValue",
[this]()
{
TestTrueExpr(UOpenAIFuncLib::OpenAIAudioTranscriptToString(ETranscriptFormat::JSON).Equals("json"));
TestTrueExpr(UOpenAIFuncLib::OpenAIAudioTranscriptToString(ETranscriptFormat::Text).Equals("text"));
TestTrueExpr(UOpenAIFuncLib::OpenAIAudioTranscriptToString(ETranscriptFormat::Str).Equals("str"));
TestTrueExpr(UOpenAIFuncLib::OpenAIAudioTranscriptToString(ETranscriptFormat::Verbose_JSON).Equals("verbose_json"));
TestTrueExpr(UOpenAIFuncLib::OpenAIAudioTranscriptToString(ETranscriptFormat::Vtt).Equals("vtt"));
});
It("OpenAIEmbeddingsEncodingFormatToStringShouldReturnCorrectValue",
[this]()
{
TestTrueExpr(UOpenAIFuncLib::OpenAIEmbeddingsEncodingFormatToString(EEmbeddingsEncodingFormat::Float).Equals("float"));
TestTrueExpr(
UOpenAIFuncLib::OpenAIEmbeddingsEncodingFormatToString(EEmbeddingsEncodingFormat::Base64).Equals("base64"));
});
It("OpenAIChatResponseFormatToStringShouldReturnCorrectValue",
[this]()
{
TestTrueExpr(UOpenAIFuncLib::OpenAIChatResponseFormatToString(EChatResponseFormat::Text).Equals("text"));
TestTrueExpr(UOpenAIFuncLib::OpenAIChatResponseFormatToString(EChatResponseFormat::JSON_Object).Equals("json_object"));
});
It("OpenAIModelToStringShouldReturnCorrectValue",
[this]()
{
FOpenAIModel OpenAIModel;
OpenAIModel.ID = "openAIID";
OpenAIModel.Object = "obj";
OpenAIModel.Created = 9999;
OpenAIModel.Owned_By = "owned_by";
OpenAIModel.Root = "openAIID";
OpenAIModel.Parent = "openAIID";
const FString ModelsStr = UOpenAIFuncLib::OpenAIModelToString(OpenAIModel);
FString ExpectedStr = "id: openAIID\n";
ExpectedStr.Append("object: obj\n")
.Append("created: 9999\n")
.Append("owned_by: owned_by\n")
.Append("root: openAIID\n")
.Append("parent: openAIID\n");
TestTrueExpr(ModelsStr.Equals(ExpectedStr));
});
It("OpenAIMessageContentTypeToStringShouldReturnCorrectValue",
[this]()
{
TestTrueExpr(UOpenAIFuncLib::OpenAIMessageContentTypeToString(EMessageContentType::Text).Equals("text"));
TestTrueExpr(UOpenAIFuncLib::OpenAIMessageContentTypeToString(EMessageContentType::Image_URL).Equals("image_url"));
});
It("BoolToStringShouldReturnCorrectValue",
[this]()
{
TestTrueExpr(UOpenAIFuncLib::BoolToString(true).Equals("true"));
TestTrueExpr(UOpenAIFuncLib::BoolToString(false).Equals("false"));
});
It("OpenAIModerationsToStringReturnsCorrectValue",
[this]()
{
FModerationResults ModerationResults;
ModerationResults.Categories = FModerationCategories{true, false, true, false, true, false, true};
ModerationResults.Category_Scores = FModerationScores{0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7};
ModerationResults.Flagged = true;
FString ExpectedStr = "hate: true\n";
ExpectedStr.Append("hate/threatening: false\n");
ExpectedStr.Append("self-harm: true\n");
ExpectedStr.Append("sexual: false\n");
ExpectedStr.Append("sexual/minors: true\n");
ExpectedStr.Append("violence: false\n");
ExpectedStr.Append("violence/graphic: true\n\n");
ExpectedStr.Append("hate: 0.100000\n");
ExpectedStr.Append("hate/threatening: 0.200000\n");
ExpectedStr.Append("self-harm: 0.300000\n");
ExpectedStr.Append("sexual: 0.400000\n");
ExpectedStr.Append("sexual/minors: 0.500000\n");
ExpectedStr.Append("violence: 0.600000\n");
ExpectedStr.Append("violence/graphic: 0.700000\n\n");
ExpectedStr.Append("flagged: true");
const FString Out = UOpenAIFuncLib::OpenAIModerationsToString(ModerationResults);
TestTrueExpr(ExpectedStr.Equals(Out));
});
It("ErrorCodesShouldBeReturnedCorectly",
[this]()
{
TestTrueExpr(UOpenAIFuncLib::GetErrorCode("") == EOpenAIResponseError::Unknown);
TestTrueExpr(UOpenAIFuncLib::GetErrorCode("Unknown message") == EOpenAIResponseError::Unknown);
TestTrueExpr(UOpenAIFuncLib::GetErrorCode("You have a ConnectionError") == EOpenAIResponseError::NetworkError);
TestTrueExpr(
UOpenAIFuncLib::GetErrorCode("{\"error\":{\"message\":\"\",\"type\":\"invalid_request_error\",\"param\":null,"
"\"code\":\"invalid_api_key\"}}") == EOpenAIResponseError::InvalidAPIKey);
TestTrueExpr(
UOpenAIFuncLib::GetErrorCode("{\"error\":{\"message\":\"\",\"type\":\"invalid_request_error\",\"param\":null,"
"\"code\":\"model_not_found\"}}") == EOpenAIResponseError::ModelNotFound);
TestTrueExpr(
UOpenAIFuncLib::GetErrorCode(
"{\"error\":{\"message\":\"\",\"type\":\"invalid_request_error\",\"param\":null,\"code\":\"invalid\"}}") ==
EOpenAIResponseError::Unknown);
});
It("ErrorMessagesShouldBeReturnedCorectly",
[this]()
{
TestTrueExpr(UOpenAIFuncLib::GetErrorMessage("").IsEmpty());
TestTrueExpr(UOpenAIFuncLib::GetErrorMessage("Not a valid JSON message").IsEmpty());
TestTrueExpr(UOpenAIFuncLib::GetErrorMessage(
"{\"error\":{\"message\":\"invalid API key\",\"type\":\"invalid_request_error\",\"param\":null,"
"\"code\":\"invalid_api_key\"}}")
.Equals("invalid API key"));
TestTrueExpr(UOpenAIFuncLib::GetErrorMessage("{\"error\":{\"type\":\"invalid_request_error\",\"param\":null,"
"\"code\":\"invalid_api_key\"}}")
.IsEmpty());
});
It("OpenAIResponseErrorToStringShouldReturnCorrectValue",
[this]()
{
TestTrueExpr(UOpenAIFuncLib::ResponseErrorToString(EOpenAIResponseError::InvalidAPIKey).Equals("Invalid API key"));
TestTrueExpr(UOpenAIFuncLib::ResponseErrorToString(EOpenAIResponseError::NetworkError).Equals("Network error"));
TestTrueExpr(UOpenAIFuncLib::ResponseErrorToString(EOpenAIResponseError::ModelNotFound).Equals("Model not found"));
TestTrueExpr(UOpenAIFuncLib::ResponseErrorToString(EOpenAIResponseError::Unknown).Equals("Unknown error"));
});
It("WhiteSpacesShouldBeRemovedCorrectly",
[this]()
{
const FString NormalString = "Hello, how are you?";
TestTrueExpr(UOpenAIFuncLib::RemoveWhiteSpaces(NormalString).Equals(NormalString));
const FString StringWithWhiteSpaces = "Hello\t, \nhow are you\r?";
TestTrueExpr(UOpenAIFuncLib::RemoveWhiteSpaces(StringWithWhiteSpaces).Equals(NormalString));
});
It("StringWithValidJsonShouldMakeConversionCorrectly",
[this]()
{
const FString String = "{\"object\":\"list\"}";
TSharedPtr<FJsonObject> JsonObject;
TestTrueExpr(UOpenAIFuncLib::StringToJson(String, JsonObject));
TestTrueExpr(JsonObject->GetStringField("object").Equals("list"));
});
It("JsonToStringShouldMakeConversionCorrectly",
[this]()
{
TSharedPtr<FJsonObject> JsonObject = MakeShareable(new FJsonObject());
JsonObject->SetStringField("String", "value");
JsonObject->SetStringField("STrinG_NEW", "VALUE");
TSharedPtr<FJsonObject> JsonSubObject = MakeShareable(new FJsonObject());
JsonSubObject->SetStringField("SUBObJect", "vaLue");
JsonObject->SetObjectField("ObjecT_NEW", JsonSubObject);
FString String;
TestTrueExpr(UOpenAIFuncLib::JsonToString(JsonObject, String));
const FString ResultString = UOpenAIFuncLib::RemoveWhiteSpaces(String);
TestTrueExpr(
ResultString.Equals("{\"string\": \"value\",\"string_new\": \"VALUE\",\"object_new\":{\"subobject\": \"vaLue\"}}"));
});
It("URLWithQueryCanBECreatedCorrectly",
[this]()
{
OpenAI::QueryPairs QueryArgs;
QueryArgs.Add(MakeTuple("param1", "value1"));
QueryArgs.Add(MakeTuple("param2", "value2"));
const auto ResultURL = UOpenAIFuncLib::MakeURLWithQuery("https://myapi.com", QueryArgs);
TestTrueExpr(ResultURL.Equals("https://myapi.com?param1=value1&param2=value2"));
});
It("APISecretCanBeLoadedByName",
[this]()
{
OpenAI::ServiceSecrets Secrets;
Secrets.Add(MakeTuple("ApiKey1", "adsgsfhgsgfhg"));
Secrets.Add(MakeTuple("ApiKey2", "kjhtlkjgkghl"));
Secrets.Add(MakeTuple("ApiKey3", "ghkjfyifkfhjkfhjgkj"));
FString FoundApiKey;
TestTrueExpr(UOpenAIFuncLib::LoadSecretByName(Secrets, "ApiKey2", FoundApiKey));
TestTrueExpr(FoundApiKey.Equals("kjhtlkjgkghl"));
});
It("ServiceSecretsCanBeLoadedFromFile",
[this]()
{
const FString FilePath = OpenAI::Tests::TestUtils::FileFullPath("OnlineServicesAuth.ini");
const OpenAI::ServiceSecrets Secrets = UOpenAIFuncLib::LoadServiceSecretsFromFile(FilePath);
TestTrueExpr(Secrets[0].Key.Equals("key1"));
TestTrueExpr(Secrets[0].Value.Equals("KeYvAlUe1"));
TestTrueExpr(Secrets[1].Key.Equals("key2"));
TestTrueExpr(Secrets[1].Value.Equals("KeYvAlUe2"));
});
});
Describe("FileSystemFuncLib",
[this]()
{
It("GetFileExtensionsShouldReturnCorrectValue",
[this]()
{
TestTrueExpr(
UFileSystemFuncLib::GetFileExtensions(EFileType::Image).Equals("ImageFiles (png, jpg, jpeg)|*.png;*.jpg;*.jpeg"));
TestTrueExpr(
UFileSystemFuncLib::GetFileExtensions(EFileType::Media)
.Equals("MediaFiles (mp3, mp4, mpeg, m4a, mpga, wav, webm)|*.mp3;*.mp4;*.mpeg;*.m4a;*.mpga;*.wav;*.webm"));
});
It("ChatHistoryMightBeSavedToTheFile",
[this]()
{
const FString FilePath = FPaths::ProjectPluginsDir().Append("OpenAI/Source/OpenAITestRunner/Data/History.txt");
const TArray<FMessage> History = {FMessage{"user", "hello!"}, FMessage{"assistant", "hello bro!"}};
const FString ModelName = "gpt-4";
TestTrueExpr(UFileSystemFuncLib::SaveChatHistoryToFile(History, ModelName, FilePath));
TArray<FString> FileLines;
if (!FFileHelper::LoadFileToStringArray(FileLines, *FilePath))
{
AddError("Failed loading file");
}
TestTrueExpr(FileLines.Num() == 4);
TestTrueExpr(FileLines[0].Equals(FString::Printf(TEXT("[model]: %s"), *ModelName)));
TestTrueExpr(FileLines[2].Equals("[user]: hello!"));
TestTrueExpr(FileLines[3].Equals("[assistant]: hello bro!"));
IFileManager::Get().Delete(*FilePath);
});
});
Describe("FineTuningQueryParameters",
[this]()
{
It("ShouldBeEmptyIfNotSet",
[this]()
{
const FFineTuningQueryParameters Parameters;
TestTrueExpr(Parameters.ToQuery().IsEmpty());
});
It("ShouldBECorrectIfOneParamIsSet",
[this]()
{
FFineTuningQueryParameters Parameters;
Parameters.After = "event-id";
TestTrueExpr(Parameters.ToQuery().Equals("?after=event-id"));
});
It("ShouldBECorrectIfTwoParamsAreSet",
[this]()
{
FFineTuningQueryParameters Parameters;
Parameters.After = "event-id";
Parameters.Limit = 20;
TestTrueExpr(Parameters.ToQuery().Equals("?after=event-id&limit=20"));
});
});
}
#endif
Reference in New Issue Copy Permalink