diff --git a/.release-please-manifest.json b/.release-please-manifest.json index b8dda9bfc..554e34bbe 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.29.0" + ".": "0.30.0" } \ No newline at end of file diff --git a/.stats.yml b/.stats.yml index 2e67f53d3..e7dc5cc33 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,2 +1,2 @@ configured_endpoints: 65 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/openai-4aa6ee65ba9efc789e05e6a5ef0883b2cadf06def8efd863dbf75e9e233067e1.yml +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/openai-5d30684c3118d049682ea30cdb4dbef39b97d51667da484689193dc40162af32.yml diff --git a/CHANGELOG.md b/CHANGELOG.md index 072ce4dc6..941bb6a63 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,26 @@ # Changelog +## 0.30.0 (2025-02-27) + +Full Changelog: [v0.29.0...v0.30.0](https://github.com/openai/openai-java/compare/v0.29.0...v0.30.0) + +### Features + +* **api:** add gpt-4.5-preview ([#258](https://github.com/openai/openai-java/issues/258)) ([27d1e7f](https://github.com/openai/openai-java/commit/27d1e7f6565ab00161d322bf04a8cb1e70c31694)) + + +### Chores + +* **client:** use deep identity methods for primitive array types ([#255](https://github.com/openai/openai-java/issues/255)) ([fac8678](https://github.com/openai/openai-java/commit/fac86783373355488b81a7a1452bc8ba2a74066f)) +* **internal:** add async service tests ([#253](https://github.com/openai/openai-java/issues/253)) ([147872a](https://github.com/openai/openai-java/commit/147872a570403c78059fb785d9860003a5187583)) +* **internal:** improve sync service tests ([147872a](https://github.com/openai/openai-java/commit/147872a570403c78059fb785d9860003a5187583)) +* **internal:** refactor `ServiceParamsTest` ([#257](https://github.com/openai/openai-java/issues/257)) ([9cb1929](https://github.com/openai/openai-java/commit/9cb19297c372976fa331d5945c028017392b2d5d)) + + +### Documentation + +* readme parameter tweaks ([147872a](https://github.com/openai/openai-java/commit/147872a570403c78059fb785d9860003a5187583)) + ## 0.29.0 (2025-02-26) Full Changelog: [v0.28.0...v0.29.0](https://github.com/openai/openai-java/compare/v0.28.0...v0.29.0) diff --git a/README.md b/README.md index bd358f6ce..f37bcbc53 100644 --- a/README.md +++ b/README.md @@ -9,8 +9,8 @@ -[![Maven Central](https://img.shields.io/maven-central/v/com.openai/openai-java)](https://central.sonatype.com/artifact/com.openai/openai-java/0.29.0) -[![javadoc](https://javadoc.io/badge2/com.openai/openai-java/0.29.0/javadoc.svg)](https://javadoc.io/doc/com.openai/openai-java/0.29.0) +[![Maven Central](https://img.shields.io/maven-central/v/com.openai/openai-java)](https://central.sonatype.com/artifact/com.openai/openai-java/0.30.0) +[![javadoc](https://javadoc.io/badge2/com.openai/openai-java/0.30.0/javadoc.svg)](https://javadoc.io/doc/com.openai/openai-java/0.30.0) @@ -25,7 +25,7 @@ The REST API documentation can be found on [platform.openai.com](https://platfor ### Gradle ```kotlin -implementation("com.openai:openai-java:0.29.0") +implementation("com.openai:openai-java:0.30.0") ``` ### Maven @@ -34,7 +34,7 @@ implementation("com.openai:openai-java:0.29.0") com.openai openai-java - 0.29.0 + 0.30.0 ``` diff --git a/build.gradle.kts b/build.gradle.kts index a7db5098b..52fd836f1 100644 --- a/build.gradle.kts +++ b/build.gradle.kts @@ -8,7 +8,7 @@ repositories { allprojects { group = "com.openai" - version = "0.29.0" // x-release-please-version + version = "0.30.0" // x-release-please-version } subprojects { diff --git a/openai-java-core/src/main/kotlin/com/openai/core/Utils.kt b/openai-java-core/src/main/kotlin/com/openai/core/Utils.kt index e2cfee075..a63ef98b6 100644 --- a/openai-java-core/src/main/kotlin/com/openai/core/Utils.kt +++ b/openai-java-core/src/main/kotlin/com/openai/core/Utils.kt @@ -25,6 +25,42 @@ internal fun , V> SortedMap.toImmutable(): SortedMap.openai.azure.com`. diff --git a/openai-java-core/src/main/kotlin/com/openai/core/Values.kt b/openai-java-core/src/main/kotlin/com/openai/core/Values.kt index 3cb8bf169..9d9ed6e86 100644 --- a/openai-java-core/src/main/kotlin/com/openai/core/Values.kt +++ b/openai-java-core/src/main/kotlin/com/openai/core/Values.kt @@ -470,41 +470,20 @@ internal constructor( val filename: String? = null, ) { - private var hashCode: Int = 0 - - override fun hashCode(): Int { - if (hashCode == 0) { - hashCode = - Objects.hash( - name, - contentType, - filename, - when (value) { - is ByteArray -> value.contentHashCode() - is String -> value - is Boolean -> value - is Long -> value - is Double -> value - else -> value?.hashCode() - }, - ) - } - return hashCode - } - - override fun equals(other: Any?): Boolean { - if (this === other) return true - if (other == null || this.javaClass != other.javaClass) return false + private val hashCode: Int by lazy { contentHash(name, value, contentType, filename) } - other as MultipartFormValue<*> + override fun hashCode(): Int = hashCode - if (name != other.name || contentType != other.contentType || filename != other.filename) - return false - - return when { - value is ByteArray && other.value is ByteArray -> value contentEquals other.value - else -> value?.equals(other.value) ?: (other.value == null) + override fun equals(other: Any?): Boolean { + if (this === other) { + return true } + + return other is MultipartFormValue<*> && + name == other.name && + value contentEquals other.value && + contentType == other.contentType && + filename == other.filename } override fun toString(): String = diff --git a/openai-java-core/src/main/kotlin/com/openai/models/BetaAssistantUpdateParams.kt b/openai-java-core/src/main/kotlin/com/openai/models/BetaAssistantUpdateParams.kt index 7945367b9..b5f6d7448 100644 --- a/openai-java-core/src/main/kotlin/com/openai/models/BetaAssistantUpdateParams.kt +++ b/openai-java-core/src/main/kotlin/com/openai/models/BetaAssistantUpdateParams.kt @@ -1629,6 +1629,10 @@ private constructor( @JvmField val GPT_4O_MINI_2024_07_18 = of("gpt-4o-mini-2024-07-18") + @JvmField val GPT_4_5_PREVIEW = of("gpt-4.5-preview") + + @JvmField val GPT_4_5_PREVIEW_2025_02_27 = of("gpt-4.5-preview-2025-02-27") + @JvmField val GPT_4_TURBO = of("gpt-4-turbo") @JvmField val GPT_4_TURBO_2024_04_09 = of("gpt-4-turbo-2024-04-09") @@ -1680,6 +1684,8 @@ private constructor( GPT_4O_2024_05_13, GPT_4O_MINI, GPT_4O_MINI_2024_07_18, + GPT_4_5_PREVIEW, + GPT_4_5_PREVIEW_2025_02_27, GPT_4_TURBO, GPT_4_TURBO_2024_04_09, GPT_4_0125_PREVIEW, @@ -1720,6 +1726,8 @@ private constructor( GPT_4O_2024_05_13, GPT_4O_MINI, GPT_4O_MINI_2024_07_18, + GPT_4_5_PREVIEW, + GPT_4_5_PREVIEW_2025_02_27, GPT_4_TURBO, GPT_4_TURBO_2024_04_09, GPT_4_0125_PREVIEW, @@ -1761,6 +1769,8 @@ private constructor( GPT_4O_2024_05_13 -> Value.GPT_4O_2024_05_13 GPT_4O_MINI -> Value.GPT_4O_MINI GPT_4O_MINI_2024_07_18 -> Value.GPT_4O_MINI_2024_07_18 + GPT_4_5_PREVIEW -> Value.GPT_4_5_PREVIEW + GPT_4_5_PREVIEW_2025_02_27 -> Value.GPT_4_5_PREVIEW_2025_02_27 GPT_4_TURBO -> Value.GPT_4_TURBO GPT_4_TURBO_2024_04_09 -> Value.GPT_4_TURBO_2024_04_09 GPT_4_0125_PREVIEW -> Value.GPT_4_0125_PREVIEW @@ -1803,6 +1813,8 @@ private constructor( GPT_4O_2024_05_13 -> Known.GPT_4O_2024_05_13 GPT_4O_MINI -> Known.GPT_4O_MINI GPT_4O_MINI_2024_07_18 -> Known.GPT_4O_MINI_2024_07_18 + GPT_4_5_PREVIEW -> Known.GPT_4_5_PREVIEW + GPT_4_5_PREVIEW_2025_02_27 -> Known.GPT_4_5_PREVIEW_2025_02_27 GPT_4_TURBO -> Known.GPT_4_TURBO GPT_4_TURBO_2024_04_09 -> Known.GPT_4_TURBO_2024_04_09 GPT_4_0125_PREVIEW -> Known.GPT_4_0125_PREVIEW diff --git a/openai-java-core/src/main/kotlin/com/openai/models/ChatModel.kt b/openai-java-core/src/main/kotlin/com/openai/models/ChatModel.kt index 4d00da6a6..1478385df 100644 --- a/openai-java-core/src/main/kotlin/com/openai/models/ChatModel.kt +++ b/openai-java-core/src/main/kotlin/com/openai/models/ChatModel.kt @@ -36,6 +36,10 @@ class ChatModel @JsonCreator private constructor(private val value: JsonField Value.O1_PREVIEW_2024_09_12 O1_MINI -> Value.O1_MINI O1_MINI_2024_09_12 -> Value.O1_MINI_2024_09_12 + GPT_4_5_PREVIEW -> Value.GPT_4_5_PREVIEW + GPT_4_5_PREVIEW_2025_02_27 -> Value.GPT_4_5_PREVIEW_2025_02_27 GPT_4O -> Value.GPT_4O GPT_4O_2024_11_20 -> Value.GPT_4O_2024_11_20 GPT_4O_2024_08_06 -> Value.GPT_4O_2024_08_06 @@ -267,6 +277,8 @@ class ChatModel @JsonCreator private constructor(private val value: JsonField Known.O1_PREVIEW_2024_09_12 O1_MINI -> Known.O1_MINI O1_MINI_2024_09_12 -> Known.O1_MINI_2024_09_12 + GPT_4_5_PREVIEW -> Known.GPT_4_5_PREVIEW + GPT_4_5_PREVIEW_2025_02_27 -> Known.GPT_4_5_PREVIEW_2025_02_27 GPT_4O -> Known.GPT_4O GPT_4O_2024_11_20 -> Known.GPT_4O_2024_11_20 GPT_4O_2024_08_06 -> Known.GPT_4O_2024_08_06 diff --git a/openai-java-core/src/main/kotlin/com/openai/models/FileObject.kt b/openai-java-core/src/main/kotlin/com/openai/models/FileObject.kt index e89cc2509..d354428a3 100644 --- a/openai-java-core/src/main/kotlin/com/openai/models/FileObject.kt +++ b/openai-java-core/src/main/kotlin/com/openai/models/FileObject.kt @@ -39,6 +39,9 @@ private constructor( @JsonProperty("status") @ExcludeMissing private val status: JsonField = JsonMissing.of(), + @JsonProperty("expires_at") + @ExcludeMissing + private val expiresAt: JsonField = JsonMissing.of(), @JsonProperty("status_details") @ExcludeMissing private val statusDetails: JsonField = JsonMissing.of(), @@ -72,6 +75,9 @@ private constructor( */ @Deprecated("deprecated") fun status(): Status = status.getRequired("status") + /** The Unix timestamp (in seconds) for when the file will expire. */ + fun expiresAt(): Optional = Optional.ofNullable(expiresAt.getNullable("expires_at")) + /** * Deprecated. For details on why a fine-tuning training file failed validation, see the `error` * field on `fine_tuning.job`. @@ -107,6 +113,9 @@ private constructor( @ExcludeMissing fun _status(): JsonField = status + /** The Unix timestamp (in seconds) for when the file will expire. */ + @JsonProperty("expires_at") @ExcludeMissing fun _expiresAt(): JsonField = expiresAt + /** * Deprecated. For details on why a fine-tuning training file failed validation, see the `error` * field on `fine_tuning.job`. @@ -138,6 +147,7 @@ private constructor( } purpose() status() + expiresAt() statusDetails() validated = true } @@ -159,6 +169,7 @@ private constructor( private var object_: JsonValue = JsonValue.from("file") private var purpose: JsonField? = null private var status: JsonField? = null + private var expiresAt: JsonField = JsonMissing.of() private var statusDetails: JsonField = JsonMissing.of() private var additionalProperties: MutableMap = mutableMapOf() @@ -171,6 +182,7 @@ private constructor( object_ = fileObject.object_ purpose = fileObject.purpose status = fileObject.status + expiresAt = fileObject.expiresAt statusDetails = fileObject.statusDetails additionalProperties = fileObject.additionalProperties.toMutableMap() } @@ -227,6 +239,12 @@ private constructor( @Deprecated("deprecated") fun status(status: JsonField) = apply { this.status = status } + /** The Unix timestamp (in seconds) for when the file will expire. */ + fun expiresAt(expiresAt: Long) = expiresAt(JsonField.of(expiresAt)) + + /** The Unix timestamp (in seconds) for when the file will expire. */ + fun expiresAt(expiresAt: JsonField) = apply { this.expiresAt = expiresAt } + /** * Deprecated. For details on why a fine-tuning training file failed validation, see the * `error` field on `fine_tuning.job`. @@ -271,6 +289,7 @@ private constructor( object_, checkRequired("purpose", purpose), checkRequired("status", status), + expiresAt, statusDetails, additionalProperties.toImmutable(), ) @@ -522,15 +541,15 @@ private constructor( return true } - return /* spotless:off */ other is FileObject && id == other.id && bytes == other.bytes && createdAt == other.createdAt && filename == other.filename && object_ == other.object_ && purpose == other.purpose && status == other.status && statusDetails == other.statusDetails && additionalProperties == other.additionalProperties /* spotless:on */ + return /* spotless:off */ other is FileObject && id == other.id && bytes == other.bytes && createdAt == other.createdAt && filename == other.filename && object_ == other.object_ && purpose == other.purpose && status == other.status && expiresAt == other.expiresAt && statusDetails == other.statusDetails && additionalProperties == other.additionalProperties /* spotless:on */ } /* spotless:off */ - private val hashCode: Int by lazy { Objects.hash(id, bytes, createdAt, filename, object_, purpose, status, statusDetails, additionalProperties) } + private val hashCode: Int by lazy { Objects.hash(id, bytes, createdAt, filename, object_, purpose, status, expiresAt, statusDetails, additionalProperties) } /* spotless:on */ override fun hashCode(): Int = hashCode override fun toString() = - "FileObject{id=$id, bytes=$bytes, createdAt=$createdAt, filename=$filename, object_=$object_, purpose=$purpose, status=$status, statusDetails=$statusDetails, additionalProperties=$additionalProperties}" + "FileObject{id=$id, bytes=$bytes, createdAt=$createdAt, filename=$filename, object_=$object_, purpose=$purpose, status=$status, expiresAt=$expiresAt, statusDetails=$statusDetails, additionalProperties=$additionalProperties}" } diff --git a/openai-java-core/src/main/kotlin/com/openai/models/Upload.kt b/openai-java-core/src/main/kotlin/com/openai/models/Upload.kt index 153473db5..1c2d91320 100644 --- a/openai-java-core/src/main/kotlin/com/openai/models/Upload.kt +++ b/openai-java-core/src/main/kotlin/com/openai/models/Upload.kt @@ -57,7 +57,7 @@ private constructor( /** The Unix timestamp (in seconds) for when the Upload was created. */ fun createdAt(): Long = createdAt.getRequired("created_at") - /** The Unix timestamp (in seconds) for when the Upload was created. */ + /** The Unix timestamp (in seconds) for when the Upload will expire. */ fun expiresAt(): Long = expiresAt.getRequired("expires_at") /** The name of the file to be uploaded. */ @@ -88,7 +88,7 @@ private constructor( /** The Unix timestamp (in seconds) for when the Upload was created. */ @JsonProperty("created_at") @ExcludeMissing fun _createdAt(): JsonField = createdAt - /** The Unix timestamp (in seconds) for when the Upload was created. */ + /** The Unix timestamp (in seconds) for when the Upload will expire. */ @JsonProperty("expires_at") @ExcludeMissing fun _expiresAt(): JsonField = expiresAt /** The name of the file to be uploaded. */ @@ -187,10 +187,10 @@ private constructor( /** The Unix timestamp (in seconds) for when the Upload was created. */ fun createdAt(createdAt: JsonField) = apply { this.createdAt = createdAt } - /** The Unix timestamp (in seconds) for when the Upload was created. */ + /** The Unix timestamp (in seconds) for when the Upload will expire. */ fun expiresAt(expiresAt: Long) = expiresAt(JsonField.of(expiresAt)) - /** The Unix timestamp (in seconds) for when the Upload was created. */ + /** The Unix timestamp (in seconds) for when the Upload will expire. */ fun expiresAt(expiresAt: JsonField) = apply { this.expiresAt = expiresAt } /** The name of the file to be uploaded. */ diff --git a/openai-java-core/src/test/kotlin/com/openai/core/UtilsTest.kt b/openai-java-core/src/test/kotlin/com/openai/core/UtilsTest.kt new file mode 100644 index 000000000..2f3a54ba3 --- /dev/null +++ b/openai-java-core/src/test/kotlin/com/openai/core/UtilsTest.kt @@ -0,0 +1,33 @@ +package com.openai.core + +import org.assertj.core.api.Assertions.assertThat +import org.junit.jupiter.api.Test + +internal class UtilsTest { + @Test + fun contentDeepEquals() { + assertThat(42 contentEquals 42).isTrue() + assertThat(42 contentEquals "Hello World!").isFalse() + assertThat(byteArrayOf(1, 2, 3) contentEquals byteArrayOf(1, 2, 3)).isTrue() + assertThat(byteArrayOf(1, 2, 3) contentEquals byteArrayOf(1, 2, 4)).isFalse() + assertThat( + arrayOf(byteArrayOf(1, 2), byteArrayOf(3)) contentEquals + arrayOf(byteArrayOf(1, 2), byteArrayOf(3)) + ) + .isTrue() + assertThat( + arrayOf(byteArrayOf(1, 2), byteArrayOf(3)) contentEquals + arrayOf(byteArrayOf(1), byteArrayOf(2, 3)) + ) + .isFalse() + } + + @Test + fun contentToString() { + assertThat((42).contentToString()).isEqualTo("42") + assertThat("Hello World!".contentToString()).isEqualTo("Hello World!") + assertThat(byteArrayOf(1, 2, 3).contentToString()).isEqualTo("[1, 2, 3]") + assertThat(arrayOf(byteArrayOf(1, 2), byteArrayOf(3)).contentToString()) + .isEqualTo("[[1, 2], [3]]") + } +} diff --git a/openai-java-core/src/test/kotlin/com/openai/models/FileObjectTest.kt b/openai-java-core/src/test/kotlin/com/openai/models/FileObjectTest.kt index d31bda8c8..ab2999406 100644 --- a/openai-java-core/src/test/kotlin/com/openai/models/FileObjectTest.kt +++ b/openai-java-core/src/test/kotlin/com/openai/models/FileObjectTest.kt @@ -17,6 +17,7 @@ class FileObjectTest { .filename("filename") .purpose(FileObject.Purpose.ASSISTANTS) .status(FileObject.Status.UPLOADED) + .expiresAt(0L) .statusDetails("status_details") .build() assertThat(fileObject).isNotNull @@ -26,6 +27,7 @@ class FileObjectTest { assertThat(fileObject.filename()).isEqualTo("filename") assertThat(fileObject.purpose()).isEqualTo(FileObject.Purpose.ASSISTANTS) assertThat(fileObject.status()).isEqualTo(FileObject.Status.UPLOADED) + assertThat(fileObject.expiresAt()).contains(0L) assertThat(fileObject.statusDetails()).contains("status_details") } } diff --git a/openai-java-core/src/test/kotlin/com/openai/models/UploadTest.kt b/openai-java-core/src/test/kotlin/com/openai/models/UploadTest.kt index 119691cb2..2153b1916 100644 --- a/openai-java-core/src/test/kotlin/com/openai/models/UploadTest.kt +++ b/openai-java-core/src/test/kotlin/com/openai/models/UploadTest.kt @@ -26,6 +26,7 @@ class UploadTest { .filename("filename") .purpose(FileObject.Purpose.ASSISTANTS) .status(FileObject.Status.UPLOADED) + .expiresAt(0L) .statusDetails("status_details") .build() ) @@ -47,6 +48,7 @@ class UploadTest { .filename("filename") .purpose(FileObject.Purpose.ASSISTANTS) .status(FileObject.Status.UPLOADED) + .expiresAt(0L) .statusDetails("status_details") .build() ) diff --git a/openai-java-core/src/test/kotlin/com/openai/services/ServiceParamsTest.kt b/openai-java-core/src/test/kotlin/com/openai/services/ServiceParamsTest.kt index 249b26f23..bc93bc52a 100644 --- a/openai-java-core/src/test/kotlin/com/openai/services/ServiceParamsTest.kt +++ b/openai-java-core/src/test/kotlin/com/openai/services/ServiceParamsTest.kt @@ -2,7 +2,6 @@ package com.openai.services -import com.fasterxml.jackson.databind.json.JsonMapper import com.github.tomakehurst.wiremock.client.WireMock.anyUrl import com.github.tomakehurst.wiremock.client.WireMock.equalTo import com.github.tomakehurst.wiremock.client.WireMock.matchingJsonPath @@ -16,23 +15,16 @@ import com.github.tomakehurst.wiremock.junit5.WireMockTest import com.openai.client.OpenAIClient import com.openai.client.okhttp.OpenAIOkHttpClient import com.openai.core.JsonValue -import com.openai.core.jsonMapper -import com.openai.models.ChatCompletion -import com.openai.models.ChatCompletionAudio import com.openai.models.ChatCompletionAudioParam import com.openai.models.ChatCompletionCreateParams import com.openai.models.ChatCompletionDeveloperMessageParam -import com.openai.models.ChatCompletionMessage -import com.openai.models.ChatCompletionMessageToolCall import com.openai.models.ChatCompletionModality import com.openai.models.ChatCompletionPredictionContent import com.openai.models.ChatCompletionReasoningEffort import com.openai.models.ChatCompletionStreamOptions -import com.openai.models.ChatCompletionTokenLogprob import com.openai.models.ChatCompletionTool import com.openai.models.ChatCompletionToolChoiceOption import com.openai.models.ChatModel -import com.openai.models.CompletionUsage import com.openai.models.FunctionDefinition import com.openai.models.FunctionParameters import com.openai.models.Metadata @@ -41,9 +33,7 @@ import org.junit.jupiter.api.BeforeEach import org.junit.jupiter.api.Test @WireMockTest -class ServiceParamsTest { - - private val JSON_MAPPER: JsonMapper = jsonMapper() +internal class ServiceParamsTest { private lateinit var client: OpenAIClient @@ -51,28 +41,17 @@ class ServiceParamsTest { fun beforeEach(wmRuntimeInfo: WireMockRuntimeInfo) { client = OpenAIOkHttpClient.builder() + .baseUrl(wmRuntimeInfo.httpBaseUrl) .apiKey("My API Key") - .organization("My Organization") - .project("My Project") - .baseUrl(wmRuntimeInfo.getHttpBaseUrl()) .build() } @Test - fun completionsCreateWithAdditionalParams() { - val additionalHeaders = mutableMapOf>() - - additionalHeaders.put("x-test-header", listOf("abc1234")) - - val additionalQueryParams = mutableMapOf>() - - additionalQueryParams.put("test_query_param", listOf("def567")) - - val additionalBodyProperties = mutableMapOf() + fun create() { + val completionService = client.chat().completions() + stubFor(post(anyUrl()).willReturn(ok("{}"))) - additionalBodyProperties.put("testBodyProperty", JsonValue.from("ghi890")) - - val params = + completionService.create( ChatCompletionCreateParams.builder() .addMessage( ChatCompletionDeveloperMessageParam.builder() @@ -146,120 +125,17 @@ class ServiceParamsTest { .topLogprobs(0L) .topP(1.0) .user("user-1234") - .additionalHeaders(additionalHeaders) - .additionalBodyProperties(additionalBodyProperties) - .additionalQueryParams(additionalQueryParams) + .putAdditionalHeader("Secret-Header", "42") + .putAdditionalQueryParam("secret_query_param", "42") + .putAdditionalBodyProperty("secretProperty", JsonValue.from("42")) .build() - - val apiResponse = - ChatCompletion.builder() - .id("id") - .addChoice( - ChatCompletion.Choice.builder() - .finishReason(ChatCompletion.Choice.FinishReason.STOP) - .index(0L) - .logprobs( - ChatCompletion.Choice.Logprobs.builder() - .addContent( - ChatCompletionTokenLogprob.builder() - .token("token") - .addByte(0L) - .logprob(0.0) - .addTopLogprob( - ChatCompletionTokenLogprob.TopLogprob.builder() - .token("token") - .addByte(0L) - .logprob(0.0) - .build() - ) - .build() - ) - .addRefusal( - ChatCompletionTokenLogprob.builder() - .token("token") - .addByte(0L) - .logprob(0.0) - .addTopLogprob( - ChatCompletionTokenLogprob.TopLogprob.builder() - .token("token") - .addByte(0L) - .logprob(0.0) - .build() - ) - .build() - ) - .build() - ) - .message( - ChatCompletionMessage.builder() - .content("content") - .refusal("refusal") - .audio( - ChatCompletionAudio.builder() - .id("id") - .data("data") - .expiresAt(0L) - .transcript("transcript") - .build() - ) - .functionCall( - ChatCompletionMessage.FunctionCall.builder() - .arguments("arguments") - .name("name") - .build() - ) - .addToolCall( - ChatCompletionMessageToolCall.builder() - .id("id") - .function( - ChatCompletionMessageToolCall.Function.builder() - .arguments("arguments") - .name("name") - .build() - ) - .build() - ) - .build() - ) - .build() - ) - .created(0L) - .model("model") - .serviceTier(ChatCompletion.ServiceTier.SCALE) - .systemFingerprint("system_fingerprint") - .usage( - CompletionUsage.builder() - .completionTokens(0L) - .promptTokens(0L) - .totalTokens(0L) - .completionTokensDetails( - CompletionUsage.CompletionTokensDetails.builder() - .acceptedPredictionTokens(0L) - .audioTokens(0L) - .reasoningTokens(0L) - .rejectedPredictionTokens(0L) - .build() - ) - .promptTokensDetails( - CompletionUsage.PromptTokensDetails.builder() - .audioTokens(0L) - .cachedTokens(0L) - .build() - ) - .build() - ) - .build() - - stubFor( - post(anyUrl()) - .withHeader("x-test-header", equalTo("abc1234")) - .withQueryParam("test_query_param", equalTo("def567")) - .withRequestBody(matchingJsonPath("$.testBodyProperty", equalTo("ghi890"))) - .willReturn(ok(JSON_MAPPER.writeValueAsString(apiResponse))) ) - client.chat().completions().create(params) - - verify(postRequestedFor(anyUrl())) + verify( + postRequestedFor(anyUrl()) + .withHeader("Secret-Header", equalTo("42")) + .withQueryParam("secret_query_param", equalTo("42")) + .withRequestBody(matchingJsonPath("$.secretProperty", equalTo("42"))) + ) } } diff --git a/openai-java-core/src/test/kotlin/com/openai/services/async/BatchServiceAsyncTest.kt b/openai-java-core/src/test/kotlin/com/openai/services/async/BatchServiceAsyncTest.kt new file mode 100644 index 000000000..22b10ddae --- /dev/null +++ b/openai-java-core/src/test/kotlin/com/openai/services/async/BatchServiceAsyncTest.kt @@ -0,0 +1,91 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.openai.services.async + +import com.openai.TestServerExtension +import com.openai.client.okhttp.OpenAIOkHttpClientAsync +import com.openai.core.JsonValue +import com.openai.models.BatchCancelParams +import com.openai.models.BatchCreateParams +import com.openai.models.BatchRetrieveParams +import com.openai.models.Metadata +import org.junit.jupiter.api.Test +import org.junit.jupiter.api.extension.ExtendWith + +@ExtendWith(TestServerExtension::class) +class BatchServiceAsyncTest { + + @Test + fun create() { + val client = + OpenAIOkHttpClientAsync.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val batchServiceAsync = client.batches() + + val batchFuture = + batchServiceAsync.create( + BatchCreateParams.builder() + .completionWindow(BatchCreateParams.CompletionWindow._24H) + .endpoint(BatchCreateParams.Endpoint.V1_CHAT_COMPLETIONS) + .inputFileId("input_file_id") + .metadata( + Metadata.builder() + .putAdditionalProperty("foo", JsonValue.from("string")) + .build() + ) + .build() + ) + + val batch = batchFuture.get() + batch.validate() + } + + @Test + fun retrieve() { + val client = + OpenAIOkHttpClientAsync.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val batchServiceAsync = client.batches() + + val batchFuture = + batchServiceAsync.retrieve(BatchRetrieveParams.builder().batchId("batch_id").build()) + + val batch = batchFuture.get() + batch.validate() + } + + @Test + fun list() { + val client = + OpenAIOkHttpClientAsync.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val batchServiceAsync = client.batches() + + val pageFuture = batchServiceAsync.list() + + val page = pageFuture.get() + page.response().validate() + } + + @Test + fun cancel() { + val client = + OpenAIOkHttpClientAsync.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val batchServiceAsync = client.batches() + + val batchFuture = + batchServiceAsync.cancel(BatchCancelParams.builder().batchId("batch_id").build()) + + val batch = batchFuture.get() + batch.validate() + } +} diff --git a/openai-java-core/src/test/kotlin/com/openai/services/async/CompletionServiceAsyncTest.kt b/openai-java-core/src/test/kotlin/com/openai/services/async/CompletionServiceAsyncTest.kt new file mode 100644 index 000000000..93f172fbd --- /dev/null +++ b/openai-java-core/src/test/kotlin/com/openai/services/async/CompletionServiceAsyncTest.kt @@ -0,0 +1,98 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.openai.services.async + +import com.openai.TestServerExtension +import com.openai.client.okhttp.OpenAIOkHttpClientAsync +import com.openai.core.JsonValue +import com.openai.models.ChatCompletionStreamOptions +import com.openai.models.CompletionCreateParams +import org.junit.jupiter.api.Test +import org.junit.jupiter.api.extension.ExtendWith + +@ExtendWith(TestServerExtension::class) +class CompletionServiceAsyncTest { + + @Test + fun create() { + val client = + OpenAIOkHttpClientAsync.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val completionServiceAsync = client.completions() + + val completionFuture = + completionServiceAsync.create( + CompletionCreateParams.builder() + .model(CompletionCreateParams.Model.GPT_3_5_TURBO_INSTRUCT) + .prompt("This is a test.") + .bestOf(0L) + .echo(true) + .frequencyPenalty(-2.0) + .logitBias( + CompletionCreateParams.LogitBias.builder() + .putAdditionalProperty("foo", JsonValue.from(0)) + .build() + ) + .logprobs(0L) + .maxTokens(16L) + .n(1L) + .presencePenalty(-2.0) + .seed(0L) + .stop("\n") + .streamOptions(ChatCompletionStreamOptions.builder().includeUsage(true).build()) + .suffix("test.") + .temperature(1.0) + .topP(1.0) + .user("user-1234") + .build() + ) + + val completion = completionFuture.get() + completion.validate() + } + + @Test + fun createStreaming() { + val client = + OpenAIOkHttpClientAsync.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val completionServiceAsync = client.completions() + + val completionStreamResponse = + completionServiceAsync.createStreaming( + CompletionCreateParams.builder() + .model(CompletionCreateParams.Model.GPT_3_5_TURBO_INSTRUCT) + .prompt("This is a test.") + .bestOf(0L) + .echo(true) + .frequencyPenalty(-2.0) + .logitBias( + CompletionCreateParams.LogitBias.builder() + .putAdditionalProperty("foo", JsonValue.from(0)) + .build() + ) + .logprobs(0L) + .maxTokens(16L) + .n(1L) + .presencePenalty(-2.0) + .seed(0L) + .stop("\n") + .streamOptions(ChatCompletionStreamOptions.builder().includeUsage(true).build()) + .suffix("test.") + .temperature(1.0) + .topP(1.0) + .user("user-1234") + .build() + ) + + val onCompleteFuture = + completionStreamResponse + .subscribe { completion -> completion.validate() } + .onCompleteFuture() + onCompleteFuture.get() + } +} diff --git a/openai-java-core/src/test/kotlin/com/openai/services/async/EmbeddingServiceAsyncTest.kt b/openai-java-core/src/test/kotlin/com/openai/services/async/EmbeddingServiceAsyncTest.kt new file mode 100644 index 000000000..450fc8cb8 --- /dev/null +++ b/openai-java-core/src/test/kotlin/com/openai/services/async/EmbeddingServiceAsyncTest.kt @@ -0,0 +1,38 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.openai.services.async + +import com.openai.TestServerExtension +import com.openai.client.okhttp.OpenAIOkHttpClientAsync +import com.openai.models.EmbeddingCreateParams +import com.openai.models.EmbeddingModel +import org.junit.jupiter.api.Test +import org.junit.jupiter.api.extension.ExtendWith + +@ExtendWith(TestServerExtension::class) +class EmbeddingServiceAsyncTest { + + @Test + fun create() { + val client = + OpenAIOkHttpClientAsync.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val embeddingServiceAsync = client.embeddings() + + val createEmbeddingResponseFuture = + embeddingServiceAsync.create( + EmbeddingCreateParams.builder() + .input("The quick brown fox jumped over the lazy dog") + .model(EmbeddingModel.TEXT_EMBEDDING_ADA_002) + .dimensions(1L) + .encodingFormat(EmbeddingCreateParams.EncodingFormat.FLOAT) + .user("user-1234") + .build() + ) + + val createEmbeddingResponse = createEmbeddingResponseFuture.get() + createEmbeddingResponse.validate() + } +} diff --git a/openai-java-core/src/test/kotlin/com/openai/services/async/FileServiceAsyncTest.kt b/openai-java-core/src/test/kotlin/com/openai/services/async/FileServiceAsyncTest.kt new file mode 100644 index 000000000..1872ceeaf --- /dev/null +++ b/openai-java-core/src/test/kotlin/com/openai/services/async/FileServiceAsyncTest.kt @@ -0,0 +1,87 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.openai.services.async + +import com.github.tomakehurst.wiremock.client.WireMock.anyUrl +import com.github.tomakehurst.wiremock.client.WireMock.get +import com.github.tomakehurst.wiremock.client.WireMock.ok +import com.github.tomakehurst.wiremock.client.WireMock.stubFor +import com.github.tomakehurst.wiremock.junit5.WireMockRuntimeInfo +import com.github.tomakehurst.wiremock.junit5.WireMockTest +import com.openai.TestServerExtension +import com.openai.client.okhttp.OpenAIOkHttpClientAsync +import com.openai.models.FileContentParams +import com.openai.models.FileDeleteParams +import com.openai.models.FileRetrieveParams +import org.assertj.core.api.Assertions.assertThat +import org.junit.jupiter.api.Test +import org.junit.jupiter.api.extension.ExtendWith + +@ExtendWith(TestServerExtension::class) +@WireMockTest +class FileServiceAsyncTest { + + @Test + fun retrieve() { + val client = + OpenAIOkHttpClientAsync.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val fileServiceAsync = client.files() + + val fileObjectFuture = + fileServiceAsync.retrieve(FileRetrieveParams.builder().fileId("file_id").build()) + + val fileObject = fileObjectFuture.get() + fileObject.validate() + } + + @Test + fun list() { + val client = + OpenAIOkHttpClientAsync.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val fileServiceAsync = client.files() + + val pageFuture = fileServiceAsync.list() + + val page = pageFuture.get() + page.response().validate() + } + + @Test + fun delete() { + val client = + OpenAIOkHttpClientAsync.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val fileServiceAsync = client.files() + + val fileDeletedFuture = + fileServiceAsync.delete(FileDeleteParams.builder().fileId("file_id").build()) + + val fileDeleted = fileDeletedFuture.get() + fileDeleted.validate() + } + + @Test + fun content(wmRuntimeInfo: WireMockRuntimeInfo) { + val client = + OpenAIOkHttpClientAsync.builder() + .baseUrl(wmRuntimeInfo.httpBaseUrl) + .apiKey("My API Key") + .build() + val fileServiceAsync = client.files() + stubFor(get(anyUrl()).willReturn(ok().withBody("abc"))) + + val responseFuture = + fileServiceAsync.content(FileContentParams.builder().fileId("file_id").build()) + + val response = responseFuture.get() + assertThat(response.body()).hasContent("abc") + } +} diff --git a/openai-java-core/src/test/kotlin/com/openai/services/async/ImageServiceAsyncTest.kt b/openai-java-core/src/test/kotlin/com/openai/services/async/ImageServiceAsyncTest.kt new file mode 100644 index 000000000..481efda86 --- /dev/null +++ b/openai-java-core/src/test/kotlin/com/openai/services/async/ImageServiceAsyncTest.kt @@ -0,0 +1,41 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.openai.services.async + +import com.openai.TestServerExtension +import com.openai.client.okhttp.OpenAIOkHttpClientAsync +import com.openai.models.ImageGenerateParams +import com.openai.models.ImageModel +import org.junit.jupiter.api.Test +import org.junit.jupiter.api.extension.ExtendWith + +@ExtendWith(TestServerExtension::class) +class ImageServiceAsyncTest { + + @Test + fun generate() { + val client = + OpenAIOkHttpClientAsync.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val imageServiceAsync = client.images() + + val imagesResponseFuture = + imageServiceAsync.generate( + ImageGenerateParams.builder() + .prompt("A cute baby sea otter") + .model(ImageModel.DALL_E_2) + .n(1L) + .quality(ImageGenerateParams.Quality.STANDARD) + .responseFormat(ImageGenerateParams.ResponseFormat.URL) + .size(ImageGenerateParams.Size._256X256) + .style(ImageGenerateParams.Style.VIVID) + .user("user-1234") + .build() + ) + + val imagesResponse = imagesResponseFuture.get() + imagesResponse.validate() + } +} diff --git a/openai-java-core/src/test/kotlin/com/openai/services/async/ModelServiceAsyncTest.kt b/openai-java-core/src/test/kotlin/com/openai/services/async/ModelServiceAsyncTest.kt new file mode 100644 index 000000000..8f34abb4c --- /dev/null +++ b/openai-java-core/src/test/kotlin/com/openai/services/async/ModelServiceAsyncTest.kt @@ -0,0 +1,63 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.openai.services.async + +import com.openai.TestServerExtension +import com.openai.client.okhttp.OpenAIOkHttpClientAsync +import com.openai.models.ModelDeleteParams +import com.openai.models.ModelRetrieveParams +import org.junit.jupiter.api.Test +import org.junit.jupiter.api.extension.ExtendWith + +@ExtendWith(TestServerExtension::class) +class ModelServiceAsyncTest { + + @Test + fun retrieve() { + val client = + OpenAIOkHttpClientAsync.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val modelServiceAsync = client.models() + + val modelFuture = + modelServiceAsync.retrieve(ModelRetrieveParams.builder().model("gpt-4o-mini").build()) + + val model = modelFuture.get() + model.validate() + } + + @Test + fun list() { + val client = + OpenAIOkHttpClientAsync.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val modelServiceAsync = client.models() + + val pageFuture = modelServiceAsync.list() + + val page = pageFuture.get() + page.response().validate() + } + + @Test + fun delete() { + val client = + OpenAIOkHttpClientAsync.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val modelServiceAsync = client.models() + + val modelDeletedFuture = + modelServiceAsync.delete( + ModelDeleteParams.builder().model("ft:gpt-4o-mini:acemeco:suffix:abc123").build() + ) + + val modelDeleted = modelDeletedFuture.get() + modelDeleted.validate() + } +} diff --git a/openai-java-core/src/test/kotlin/com/openai/services/async/ModerationServiceAsyncTest.kt b/openai-java-core/src/test/kotlin/com/openai/services/async/ModerationServiceAsyncTest.kt new file mode 100644 index 000000000..f0e6c985f --- /dev/null +++ b/openai-java-core/src/test/kotlin/com/openai/services/async/ModerationServiceAsyncTest.kt @@ -0,0 +1,35 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.openai.services.async + +import com.openai.TestServerExtension +import com.openai.client.okhttp.OpenAIOkHttpClientAsync +import com.openai.models.ModerationCreateParams +import com.openai.models.ModerationModel +import org.junit.jupiter.api.Test +import org.junit.jupiter.api.extension.ExtendWith + +@ExtendWith(TestServerExtension::class) +class ModerationServiceAsyncTest { + + @Test + fun create() { + val client = + OpenAIOkHttpClientAsync.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val moderationServiceAsync = client.moderations() + + val moderationFuture = + moderationServiceAsync.create( + ModerationCreateParams.builder() + .input("I want to kill them.") + .model(ModerationModel.OMNI_MODERATION_LATEST) + .build() + ) + + val moderation = moderationFuture.get() + moderation.validate() + } +} diff --git a/openai-java-core/src/test/kotlin/com/openai/services/async/UploadServiceAsyncTest.kt b/openai-java-core/src/test/kotlin/com/openai/services/async/UploadServiceAsyncTest.kt new file mode 100644 index 000000000..4189e5994 --- /dev/null +++ b/openai-java-core/src/test/kotlin/com/openai/services/async/UploadServiceAsyncTest.kt @@ -0,0 +1,79 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.openai.services.async + +import com.openai.TestServerExtension +import com.openai.client.okhttp.OpenAIOkHttpClientAsync +import com.openai.models.FilePurpose +import com.openai.models.UploadCancelParams +import com.openai.models.UploadCompleteParams +import com.openai.models.UploadCreateParams +import org.junit.jupiter.api.Test +import org.junit.jupiter.api.extension.ExtendWith + +@ExtendWith(TestServerExtension::class) +class UploadServiceAsyncTest { + + @Test + fun create() { + val client = + OpenAIOkHttpClientAsync.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val uploadServiceAsync = client.uploads() + + val uploadFuture = + uploadServiceAsync.create( + UploadCreateParams.builder() + .bytes(0L) + .filename("filename") + .mimeType("mime_type") + .purpose(FilePurpose.ASSISTANTS) + .build() + ) + + val upload = uploadFuture.get() + upload.validate() + } + + @Test + fun cancel() { + val client = + OpenAIOkHttpClientAsync.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val uploadServiceAsync = client.uploads() + + val uploadFuture = + uploadServiceAsync.cancel( + UploadCancelParams.builder().uploadId("upload_abc123").build() + ) + + val upload = uploadFuture.get() + upload.validate() + } + + @Test + fun complete() { + val client = + OpenAIOkHttpClientAsync.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val uploadServiceAsync = client.uploads() + + val uploadFuture = + uploadServiceAsync.complete( + UploadCompleteParams.builder() + .uploadId("upload_abc123") + .addPartId("string") + .md5("md5") + .build() + ) + + val upload = uploadFuture.get() + upload.validate() + } +} diff --git a/openai-java-core/src/test/kotlin/com/openai/services/async/beta/AssistantServiceAsyncTest.kt b/openai-java-core/src/test/kotlin/com/openai/services/async/beta/AssistantServiceAsyncTest.kt new file mode 100644 index 000000000..fdf16455c --- /dev/null +++ b/openai-java-core/src/test/kotlin/com/openai/services/async/beta/AssistantServiceAsyncTest.kt @@ -0,0 +1,185 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.openai.services.async.beta + +import com.openai.TestServerExtension +import com.openai.client.okhttp.OpenAIOkHttpClientAsync +import com.openai.core.JsonValue +import com.openai.models.AutoFileChunkingStrategyParam +import com.openai.models.BetaAssistantCreateParams +import com.openai.models.BetaAssistantDeleteParams +import com.openai.models.BetaAssistantRetrieveParams +import com.openai.models.BetaAssistantUpdateParams +import com.openai.models.ChatModel +import com.openai.models.CodeInterpreterTool +import com.openai.models.Metadata +import org.junit.jupiter.api.Test +import org.junit.jupiter.api.extension.ExtendWith + +@ExtendWith(TestServerExtension::class) +class AssistantServiceAsyncTest { + + @Test + fun create() { + val client = + OpenAIOkHttpClientAsync.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val assistantServiceAsync = client.beta().assistants() + + val assistantFuture = + assistantServiceAsync.create( + BetaAssistantCreateParams.builder() + .model(ChatModel.O3_MINI) + .description("description") + .instructions("instructions") + .metadata( + Metadata.builder() + .putAdditionalProperty("foo", JsonValue.from("string")) + .build() + ) + .name("name") + .reasoningEffort(BetaAssistantCreateParams.ReasoningEffort.LOW) + .responseFormatAuto() + .temperature(1.0) + .toolResources( + BetaAssistantCreateParams.ToolResources.builder() + .codeInterpreter( + BetaAssistantCreateParams.ToolResources.CodeInterpreter.builder() + .addFileId("string") + .build() + ) + .fileSearch( + BetaAssistantCreateParams.ToolResources.FileSearch.builder() + .addVectorStoreId("string") + .addVectorStore( + BetaAssistantCreateParams.ToolResources.FileSearch + .VectorStore + .builder() + .chunkingStrategy( + AutoFileChunkingStrategyParam.builder().build() + ) + .addFileId("string") + .metadata( + Metadata.builder() + .putAdditionalProperty( + "foo", + JsonValue.from("string"), + ) + .build() + ) + .build() + ) + .build() + ) + .build() + ) + .addTool(CodeInterpreterTool.builder().build()) + .topP(1.0) + .build() + ) + + val assistant = assistantFuture.get() + assistant.validate() + } + + @Test + fun retrieve() { + val client = + OpenAIOkHttpClientAsync.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val assistantServiceAsync = client.beta().assistants() + + val assistantFuture = + assistantServiceAsync.retrieve( + BetaAssistantRetrieveParams.builder().assistantId("assistant_id").build() + ) + + val assistant = assistantFuture.get() + assistant.validate() + } + + @Test + fun update() { + val client = + OpenAIOkHttpClientAsync.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val assistantServiceAsync = client.beta().assistants() + + val assistantFuture = + assistantServiceAsync.update( + BetaAssistantUpdateParams.builder() + .assistantId("assistant_id") + .description("description") + .instructions("instructions") + .metadata( + Metadata.builder() + .putAdditionalProperty("foo", JsonValue.from("string")) + .build() + ) + .model(BetaAssistantUpdateParams.Model.O3_MINI) + .name("name") + .reasoningEffort(BetaAssistantUpdateParams.ReasoningEffort.LOW) + .responseFormatAuto() + .temperature(1.0) + .toolResources( + BetaAssistantUpdateParams.ToolResources.builder() + .codeInterpreter( + BetaAssistantUpdateParams.ToolResources.CodeInterpreter.builder() + .addFileId("string") + .build() + ) + .fileSearch( + BetaAssistantUpdateParams.ToolResources.FileSearch.builder() + .addVectorStoreId("string") + .build() + ) + .build() + ) + .addTool(CodeInterpreterTool.builder().build()) + .topP(1.0) + .build() + ) + + val assistant = assistantFuture.get() + assistant.validate() + } + + @Test + fun list() { + val client = + OpenAIOkHttpClientAsync.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val assistantServiceAsync = client.beta().assistants() + + val pageFuture = assistantServiceAsync.list() + + val page = pageFuture.get() + page.response().validate() + } + + @Test + fun delete() { + val client = + OpenAIOkHttpClientAsync.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val assistantServiceAsync = client.beta().assistants() + + val assistantDeletedFuture = + assistantServiceAsync.delete( + BetaAssistantDeleteParams.builder().assistantId("assistant_id").build() + ) + + val assistantDeleted = assistantDeletedFuture.get() + assistantDeleted.validate() + } +} diff --git a/openai-java-core/src/test/kotlin/com/openai/services/async/beta/ThreadServiceAsyncTest.kt b/openai-java-core/src/test/kotlin/com/openai/services/async/beta/ThreadServiceAsyncTest.kt new file mode 100644 index 000000000..8c63d9a6c --- /dev/null +++ b/openai-java-core/src/test/kotlin/com/openai/services/async/beta/ThreadServiceAsyncTest.kt @@ -0,0 +1,409 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.openai.services.async.beta + +import com.openai.TestServerExtension +import com.openai.client.okhttp.OpenAIOkHttpClientAsync +import com.openai.core.JsonValue +import com.openai.models.AssistantToolChoiceOption +import com.openai.models.AutoFileChunkingStrategyParam +import com.openai.models.BetaThreadCreateAndRunParams +import com.openai.models.BetaThreadCreateParams +import com.openai.models.BetaThreadDeleteParams +import com.openai.models.BetaThreadRetrieveParams +import com.openai.models.BetaThreadUpdateParams +import com.openai.models.ChatModel +import com.openai.models.CodeInterpreterTool +import com.openai.models.Metadata +import org.junit.jupiter.api.Test +import org.junit.jupiter.api.extension.ExtendWith + +@ExtendWith(TestServerExtension::class) +class ThreadServiceAsyncTest { + + @Test + fun create() { + val client = + OpenAIOkHttpClientAsync.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val threadServiceAsync = client.beta().threads() + + val threadFuture = + threadServiceAsync.create( + BetaThreadCreateParams.builder() + .addMessage( + BetaThreadCreateParams.Message.builder() + .content("string") + .role(BetaThreadCreateParams.Message.Role.USER) + .addAttachment( + BetaThreadCreateParams.Message.Attachment.builder() + .fileId("file_id") + .addTool(CodeInterpreterTool.builder().build()) + .build() + ) + .metadata( + Metadata.builder() + .putAdditionalProperty("foo", JsonValue.from("string")) + .build() + ) + .build() + ) + .metadata( + Metadata.builder() + .putAdditionalProperty("foo", JsonValue.from("string")) + .build() + ) + .toolResources( + BetaThreadCreateParams.ToolResources.builder() + .codeInterpreter( + BetaThreadCreateParams.ToolResources.CodeInterpreter.builder() + .addFileId("string") + .build() + ) + .fileSearch( + BetaThreadCreateParams.ToolResources.FileSearch.builder() + .addVectorStoreId("string") + .addVectorStore( + BetaThreadCreateParams.ToolResources.FileSearch.VectorStore + .builder() + .chunkingStrategy( + AutoFileChunkingStrategyParam.builder().build() + ) + .addFileId("string") + .metadata( + Metadata.builder() + .putAdditionalProperty( + "foo", + JsonValue.from("string"), + ) + .build() + ) + .build() + ) + .build() + ) + .build() + ) + .build() + ) + + val thread = threadFuture.get() + thread.validate() + } + + @Test + fun retrieve() { + val client = + OpenAIOkHttpClientAsync.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val threadServiceAsync = client.beta().threads() + + val threadFuture = + threadServiceAsync.retrieve( + BetaThreadRetrieveParams.builder().threadId("thread_id").build() + ) + + val thread = threadFuture.get() + thread.validate() + } + + @Test + fun update() { + val client = + OpenAIOkHttpClientAsync.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val threadServiceAsync = client.beta().threads() + + val threadFuture = + threadServiceAsync.update( + BetaThreadUpdateParams.builder() + .threadId("thread_id") + .metadata( + Metadata.builder() + .putAdditionalProperty("foo", JsonValue.from("string")) + .build() + ) + .toolResources( + BetaThreadUpdateParams.ToolResources.builder() + .codeInterpreter( + BetaThreadUpdateParams.ToolResources.CodeInterpreter.builder() + .addFileId("string") + .build() + ) + .fileSearch( + BetaThreadUpdateParams.ToolResources.FileSearch.builder() + .addVectorStoreId("string") + .build() + ) + .build() + ) + .build() + ) + + val thread = threadFuture.get() + thread.validate() + } + + @Test + fun delete() { + val client = + OpenAIOkHttpClientAsync.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val threadServiceAsync = client.beta().threads() + + val threadDeletedFuture = + threadServiceAsync.delete( + BetaThreadDeleteParams.builder().threadId("thread_id").build() + ) + + val threadDeleted = threadDeletedFuture.get() + threadDeleted.validate() + } + + @Test + fun createAndRun() { + val client = + OpenAIOkHttpClientAsync.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val threadServiceAsync = client.beta().threads() + + val runFuture = + threadServiceAsync.createAndRun( + BetaThreadCreateAndRunParams.builder() + .assistantId("assistant_id") + .instructions("instructions") + .maxCompletionTokens(256L) + .maxPromptTokens(256L) + .metadata( + Metadata.builder() + .putAdditionalProperty("foo", JsonValue.from("string")) + .build() + ) + .model(ChatModel.O3_MINI) + .parallelToolCalls(true) + .responseFormatAuto() + .temperature(1.0) + .thread( + BetaThreadCreateAndRunParams.Thread.builder() + .addMessage( + BetaThreadCreateAndRunParams.Thread.Message.builder() + .content("string") + .role(BetaThreadCreateAndRunParams.Thread.Message.Role.USER) + .addAttachment( + BetaThreadCreateAndRunParams.Thread.Message.Attachment + .builder() + .fileId("file_id") + .addTool(CodeInterpreterTool.builder().build()) + .build() + ) + .metadata( + Metadata.builder() + .putAdditionalProperty("foo", JsonValue.from("string")) + .build() + ) + .build() + ) + .metadata( + Metadata.builder() + .putAdditionalProperty("foo", JsonValue.from("string")) + .build() + ) + .toolResources( + BetaThreadCreateAndRunParams.Thread.ToolResources.builder() + .codeInterpreter( + BetaThreadCreateAndRunParams.Thread.ToolResources + .CodeInterpreter + .builder() + .addFileId("string") + .build() + ) + .fileSearch( + BetaThreadCreateAndRunParams.Thread.ToolResources.FileSearch + .builder() + .addVectorStoreId("string") + .addVectorStore( + BetaThreadCreateAndRunParams.Thread.ToolResources + .FileSearch + .VectorStore + .builder() + .chunkingStrategy( + AutoFileChunkingStrategyParam.builder() + .build() + ) + .addFileId("string") + .metadata( + Metadata.builder() + .putAdditionalProperty( + "foo", + JsonValue.from("string"), + ) + .build() + ) + .build() + ) + .build() + ) + .build() + ) + .build() + ) + .toolChoice(AssistantToolChoiceOption.Auto.NONE) + .toolResources( + BetaThreadCreateAndRunParams.ToolResources.builder() + .codeInterpreter( + BetaThreadCreateAndRunParams.ToolResources.CodeInterpreter.builder() + .addFileId("string") + .build() + ) + .fileSearch( + BetaThreadCreateAndRunParams.ToolResources.FileSearch.builder() + .addVectorStoreId("string") + .build() + ) + .build() + ) + .addTool(CodeInterpreterTool.builder().build()) + .topP(1.0) + .truncationStrategy( + BetaThreadCreateAndRunParams.TruncationStrategy.builder() + .type(BetaThreadCreateAndRunParams.TruncationStrategy.Type.AUTO) + .lastMessages(1L) + .build() + ) + .build() + ) + + val run = runFuture.get() + run.validate() + } + + @Test + fun createAndRunStreaming() { + val client = + OpenAIOkHttpClientAsync.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val threadServiceAsync = client.beta().threads() + + val runStreamResponse = + threadServiceAsync.createAndRunStreaming( + BetaThreadCreateAndRunParams.builder() + .assistantId("assistant_id") + .instructions("instructions") + .maxCompletionTokens(256L) + .maxPromptTokens(256L) + .metadata( + Metadata.builder() + .putAdditionalProperty("foo", JsonValue.from("string")) + .build() + ) + .model(ChatModel.O3_MINI) + .parallelToolCalls(true) + .responseFormatAuto() + .temperature(1.0) + .thread( + BetaThreadCreateAndRunParams.Thread.builder() + .addMessage( + BetaThreadCreateAndRunParams.Thread.Message.builder() + .content("string") + .role(BetaThreadCreateAndRunParams.Thread.Message.Role.USER) + .addAttachment( + BetaThreadCreateAndRunParams.Thread.Message.Attachment + .builder() + .fileId("file_id") + .addTool(CodeInterpreterTool.builder().build()) + .build() + ) + .metadata( + Metadata.builder() + .putAdditionalProperty("foo", JsonValue.from("string")) + .build() + ) + .build() + ) + .metadata( + Metadata.builder() + .putAdditionalProperty("foo", JsonValue.from("string")) + .build() + ) + .toolResources( + BetaThreadCreateAndRunParams.Thread.ToolResources.builder() + .codeInterpreter( + BetaThreadCreateAndRunParams.Thread.ToolResources + .CodeInterpreter + .builder() + .addFileId("string") + .build() + ) + .fileSearch( + BetaThreadCreateAndRunParams.Thread.ToolResources.FileSearch + .builder() + .addVectorStoreId("string") + .addVectorStore( + BetaThreadCreateAndRunParams.Thread.ToolResources + .FileSearch + .VectorStore + .builder() + .chunkingStrategy( + AutoFileChunkingStrategyParam.builder() + .build() + ) + .addFileId("string") + .metadata( + Metadata.builder() + .putAdditionalProperty( + "foo", + JsonValue.from("string"), + ) + .build() + ) + .build() + ) + .build() + ) + .build() + ) + .build() + ) + .toolChoice(AssistantToolChoiceOption.Auto.NONE) + .toolResources( + BetaThreadCreateAndRunParams.ToolResources.builder() + .codeInterpreter( + BetaThreadCreateAndRunParams.ToolResources.CodeInterpreter.builder() + .addFileId("string") + .build() + ) + .fileSearch( + BetaThreadCreateAndRunParams.ToolResources.FileSearch.builder() + .addVectorStoreId("string") + .build() + ) + .build() + ) + .addTool(CodeInterpreterTool.builder().build()) + .topP(1.0) + .truncationStrategy( + BetaThreadCreateAndRunParams.TruncationStrategy.builder() + .type(BetaThreadCreateAndRunParams.TruncationStrategy.Type.AUTO) + .lastMessages(1L) + .build() + ) + .build() + ) + + val onCompleteFuture = + runStreamResponse.subscribe { run -> run.validate() }.onCompleteFuture() + onCompleteFuture.get() + } +} diff --git a/openai-java-core/src/test/kotlin/com/openai/services/async/beta/VectorStoreServiceAsyncTest.kt b/openai-java-core/src/test/kotlin/com/openai/services/async/beta/VectorStoreServiceAsyncTest.kt new file mode 100644 index 000000000..13f2a9bba --- /dev/null +++ b/openai-java-core/src/test/kotlin/com/openai/services/async/beta/VectorStoreServiceAsyncTest.kt @@ -0,0 +1,129 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.openai.services.async.beta + +import com.openai.TestServerExtension +import com.openai.client.okhttp.OpenAIOkHttpClientAsync +import com.openai.core.JsonValue +import com.openai.models.AutoFileChunkingStrategyParam +import com.openai.models.BetaVectorStoreCreateParams +import com.openai.models.BetaVectorStoreDeleteParams +import com.openai.models.BetaVectorStoreRetrieveParams +import com.openai.models.BetaVectorStoreUpdateParams +import com.openai.models.Metadata +import org.junit.jupiter.api.Test +import org.junit.jupiter.api.extension.ExtendWith + +@ExtendWith(TestServerExtension::class) +class VectorStoreServiceAsyncTest { + + @Test + fun create() { + val client = + OpenAIOkHttpClientAsync.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val vectorStoreServiceAsync = client.beta().vectorStores() + + val vectorStoreFuture = + vectorStoreServiceAsync.create( + BetaVectorStoreCreateParams.builder() + .chunkingStrategy(AutoFileChunkingStrategyParam.builder().build()) + .expiresAfter( + BetaVectorStoreCreateParams.ExpiresAfter.builder().days(1L).build() + ) + .addFileId("string") + .metadata( + Metadata.builder() + .putAdditionalProperty("foo", JsonValue.from("string")) + .build() + ) + .name("name") + .build() + ) + + val vectorStore = vectorStoreFuture.get() + vectorStore.validate() + } + + @Test + fun retrieve() { + val client = + OpenAIOkHttpClientAsync.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val vectorStoreServiceAsync = client.beta().vectorStores() + + val vectorStoreFuture = + vectorStoreServiceAsync.retrieve( + BetaVectorStoreRetrieveParams.builder().vectorStoreId("vector_store_id").build() + ) + + val vectorStore = vectorStoreFuture.get() + vectorStore.validate() + } + + @Test + fun update() { + val client = + OpenAIOkHttpClientAsync.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val vectorStoreServiceAsync = client.beta().vectorStores() + + val vectorStoreFuture = + vectorStoreServiceAsync.update( + BetaVectorStoreUpdateParams.builder() + .vectorStoreId("vector_store_id") + .expiresAfter( + BetaVectorStoreUpdateParams.ExpiresAfter.builder().days(1L).build() + ) + .metadata( + Metadata.builder() + .putAdditionalProperty("foo", JsonValue.from("string")) + .build() + ) + .name("name") + .build() + ) + + val vectorStore = vectorStoreFuture.get() + vectorStore.validate() + } + + @Test + fun list() { + val client = + OpenAIOkHttpClientAsync.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val vectorStoreServiceAsync = client.beta().vectorStores() + + val pageFuture = vectorStoreServiceAsync.list() + + val page = pageFuture.get() + page.response().validate() + } + + @Test + fun delete() { + val client = + OpenAIOkHttpClientAsync.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val vectorStoreServiceAsync = client.beta().vectorStores() + + val vectorStoreDeletedFuture = + vectorStoreServiceAsync.delete( + BetaVectorStoreDeleteParams.builder().vectorStoreId("vector_store_id").build() + ) + + val vectorStoreDeleted = vectorStoreDeletedFuture.get() + vectorStoreDeleted.validate() + } +} diff --git a/openai-java-core/src/test/kotlin/com/openai/services/async/beta/threads/MessageServiceAsyncTest.kt b/openai-java-core/src/test/kotlin/com/openai/services/async/beta/threads/MessageServiceAsyncTest.kt new file mode 100644 index 000000000..c86a02b6e --- /dev/null +++ b/openai-java-core/src/test/kotlin/com/openai/services/async/beta/threads/MessageServiceAsyncTest.kt @@ -0,0 +1,139 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.openai.services.async.beta.threads + +import com.openai.TestServerExtension +import com.openai.client.okhttp.OpenAIOkHttpClientAsync +import com.openai.core.JsonValue +import com.openai.models.BetaThreadMessageCreateParams +import com.openai.models.BetaThreadMessageDeleteParams +import com.openai.models.BetaThreadMessageListParams +import com.openai.models.BetaThreadMessageRetrieveParams +import com.openai.models.BetaThreadMessageUpdateParams +import com.openai.models.CodeInterpreterTool +import com.openai.models.Metadata +import org.junit.jupiter.api.Test +import org.junit.jupiter.api.extension.ExtendWith + +@ExtendWith(TestServerExtension::class) +class MessageServiceAsyncTest { + + @Test + fun create() { + val client = + OpenAIOkHttpClientAsync.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val messageServiceAsync = client.beta().threads().messages() + + val messageFuture = + messageServiceAsync.create( + BetaThreadMessageCreateParams.builder() + .threadId("thread_id") + .content("string") + .role(BetaThreadMessageCreateParams.Role.USER) + .addAttachment( + BetaThreadMessageCreateParams.Attachment.builder() + .fileId("file_id") + .addTool(CodeInterpreterTool.builder().build()) + .build() + ) + .metadata( + Metadata.builder() + .putAdditionalProperty("foo", JsonValue.from("string")) + .build() + ) + .build() + ) + + val message = messageFuture.get() + message.validate() + } + + @Test + fun retrieve() { + val client = + OpenAIOkHttpClientAsync.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val messageServiceAsync = client.beta().threads().messages() + + val messageFuture = + messageServiceAsync.retrieve( + BetaThreadMessageRetrieveParams.builder() + .threadId("thread_id") + .messageId("message_id") + .build() + ) + + val message = messageFuture.get() + message.validate() + } + + @Test + fun update() { + val client = + OpenAIOkHttpClientAsync.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val messageServiceAsync = client.beta().threads().messages() + + val messageFuture = + messageServiceAsync.update( + BetaThreadMessageUpdateParams.builder() + .threadId("thread_id") + .messageId("message_id") + .metadata( + Metadata.builder() + .putAdditionalProperty("foo", JsonValue.from("string")) + .build() + ) + .build() + ) + + val message = messageFuture.get() + message.validate() + } + + @Test + fun list() { + val client = + OpenAIOkHttpClientAsync.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val messageServiceAsync = client.beta().threads().messages() + + val pageFuture = + messageServiceAsync.list( + BetaThreadMessageListParams.builder().threadId("thread_id").build() + ) + + val page = pageFuture.get() + page.response().validate() + } + + @Test + fun delete() { + val client = + OpenAIOkHttpClientAsync.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val messageServiceAsync = client.beta().threads().messages() + + val messageDeletedFuture = + messageServiceAsync.delete( + BetaThreadMessageDeleteParams.builder() + .threadId("thread_id") + .messageId("message_id") + .build() + ) + + val messageDeleted = messageDeletedFuture.get() + messageDeleted.validate() + } +} diff --git a/openai-java-core/src/test/kotlin/com/openai/services/async/beta/threads/RunServiceAsyncTest.kt b/openai-java-core/src/test/kotlin/com/openai/services/async/beta/threads/RunServiceAsyncTest.kt new file mode 100644 index 000000000..ab64e6992 --- /dev/null +++ b/openai-java-core/src/test/kotlin/com/openai/services/async/beta/threads/RunServiceAsyncTest.kt @@ -0,0 +1,282 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.openai.services.async.beta.threads + +import com.openai.TestServerExtension +import com.openai.client.okhttp.OpenAIOkHttpClientAsync +import com.openai.core.JsonValue +import com.openai.models.AssistantToolChoiceOption +import com.openai.models.BetaThreadRunCancelParams +import com.openai.models.BetaThreadRunCreateParams +import com.openai.models.BetaThreadRunListParams +import com.openai.models.BetaThreadRunRetrieveParams +import com.openai.models.BetaThreadRunSubmitToolOutputsParams +import com.openai.models.BetaThreadRunUpdateParams +import com.openai.models.ChatModel +import com.openai.models.CodeInterpreterTool +import com.openai.models.Metadata +import com.openai.models.RunStepInclude +import org.junit.jupiter.api.Test +import org.junit.jupiter.api.extension.ExtendWith + +@ExtendWith(TestServerExtension::class) +class RunServiceAsyncTest { + + @Test + fun create() { + val client = + OpenAIOkHttpClientAsync.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val runServiceAsync = client.beta().threads().runs() + + val runFuture = + runServiceAsync.create( + BetaThreadRunCreateParams.builder() + .threadId("thread_id") + .addInclude(RunStepInclude.STEP_DETAILS_TOOL_CALLS_FILE_SEARCH_RESULTS_CONTENT) + .assistantId("assistant_id") + .additionalInstructions("additional_instructions") + .addAdditionalMessage( + BetaThreadRunCreateParams.AdditionalMessage.builder() + .content("string") + .role(BetaThreadRunCreateParams.AdditionalMessage.Role.USER) + .addAttachment( + BetaThreadRunCreateParams.AdditionalMessage.Attachment.builder() + .fileId("file_id") + .addTool(CodeInterpreterTool.builder().build()) + .build() + ) + .metadata( + Metadata.builder() + .putAdditionalProperty("foo", JsonValue.from("string")) + .build() + ) + .build() + ) + .instructions("instructions") + .maxCompletionTokens(256L) + .maxPromptTokens(256L) + .metadata( + Metadata.builder() + .putAdditionalProperty("foo", JsonValue.from("string")) + .build() + ) + .model(ChatModel.O3_MINI) + .parallelToolCalls(true) + .reasoningEffort(BetaThreadRunCreateParams.ReasoningEffort.LOW) + .responseFormatAuto() + .temperature(1.0) + .toolChoice(AssistantToolChoiceOption.Auto.NONE) + .addTool(CodeInterpreterTool.builder().build()) + .topP(1.0) + .truncationStrategy( + BetaThreadRunCreateParams.TruncationStrategy.builder() + .type(BetaThreadRunCreateParams.TruncationStrategy.Type.AUTO) + .lastMessages(1L) + .build() + ) + .build() + ) + + val run = runFuture.get() + run.validate() + } + + @Test + fun createStreaming() { + val client = + OpenAIOkHttpClientAsync.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val runServiceAsync = client.beta().threads().runs() + + val runStreamResponse = + runServiceAsync.createStreaming( + BetaThreadRunCreateParams.builder() + .threadId("thread_id") + .addInclude(RunStepInclude.STEP_DETAILS_TOOL_CALLS_FILE_SEARCH_RESULTS_CONTENT) + .assistantId("assistant_id") + .additionalInstructions("additional_instructions") + .addAdditionalMessage( + BetaThreadRunCreateParams.AdditionalMessage.builder() + .content("string") + .role(BetaThreadRunCreateParams.AdditionalMessage.Role.USER) + .addAttachment( + BetaThreadRunCreateParams.AdditionalMessage.Attachment.builder() + .fileId("file_id") + .addTool(CodeInterpreterTool.builder().build()) + .build() + ) + .metadata( + Metadata.builder() + .putAdditionalProperty("foo", JsonValue.from("string")) + .build() + ) + .build() + ) + .instructions("instructions") + .maxCompletionTokens(256L) + .maxPromptTokens(256L) + .metadata( + Metadata.builder() + .putAdditionalProperty("foo", JsonValue.from("string")) + .build() + ) + .model(ChatModel.O3_MINI) + .parallelToolCalls(true) + .reasoningEffort(BetaThreadRunCreateParams.ReasoningEffort.LOW) + .responseFormatAuto() + .temperature(1.0) + .toolChoice(AssistantToolChoiceOption.Auto.NONE) + .addTool(CodeInterpreterTool.builder().build()) + .topP(1.0) + .truncationStrategy( + BetaThreadRunCreateParams.TruncationStrategy.builder() + .type(BetaThreadRunCreateParams.TruncationStrategy.Type.AUTO) + .lastMessages(1L) + .build() + ) + .build() + ) + + val onCompleteFuture = + runStreamResponse.subscribe { run -> run.validate() }.onCompleteFuture() + onCompleteFuture.get() + } + + @Test + fun retrieve() { + val client = + OpenAIOkHttpClientAsync.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val runServiceAsync = client.beta().threads().runs() + + val runFuture = + runServiceAsync.retrieve( + BetaThreadRunRetrieveParams.builder().threadId("thread_id").runId("run_id").build() + ) + + val run = runFuture.get() + run.validate() + } + + @Test + fun update() { + val client = + OpenAIOkHttpClientAsync.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val runServiceAsync = client.beta().threads().runs() + + val runFuture = + runServiceAsync.update( + BetaThreadRunUpdateParams.builder() + .threadId("thread_id") + .runId("run_id") + .metadata( + Metadata.builder() + .putAdditionalProperty("foo", JsonValue.from("string")) + .build() + ) + .build() + ) + + val run = runFuture.get() + run.validate() + } + + @Test + fun list() { + val client = + OpenAIOkHttpClientAsync.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val runServiceAsync = client.beta().threads().runs() + + val pageFuture = + runServiceAsync.list(BetaThreadRunListParams.builder().threadId("thread_id").build()) + + val page = pageFuture.get() + page.response().validate() + } + + @Test + fun cancel() { + val client = + OpenAIOkHttpClientAsync.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val runServiceAsync = client.beta().threads().runs() + + val runFuture = + runServiceAsync.cancel( + BetaThreadRunCancelParams.builder().threadId("thread_id").runId("run_id").build() + ) + + val run = runFuture.get() + run.validate() + } + + @Test + fun submitToolOutputs() { + val client = + OpenAIOkHttpClientAsync.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val runServiceAsync = client.beta().threads().runs() + + val runFuture = + runServiceAsync.submitToolOutputs( + BetaThreadRunSubmitToolOutputsParams.builder() + .threadId("thread_id") + .runId("run_id") + .addToolOutput( + BetaThreadRunSubmitToolOutputsParams.ToolOutput.builder() + .output("output") + .toolCallId("tool_call_id") + .build() + ) + .build() + ) + + val run = runFuture.get() + run.validate() + } + + @Test + fun submitToolOutputsStreaming() { + val client = + OpenAIOkHttpClientAsync.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val runServiceAsync = client.beta().threads().runs() + + val runStreamResponse = + runServiceAsync.submitToolOutputsStreaming( + BetaThreadRunSubmitToolOutputsParams.builder() + .threadId("thread_id") + .runId("run_id") + .addToolOutput( + BetaThreadRunSubmitToolOutputsParams.ToolOutput.builder() + .output("output") + .toolCallId("tool_call_id") + .build() + ) + .build() + ) + + val onCompleteFuture = + runStreamResponse.subscribe { run -> run.validate() }.onCompleteFuture() + onCompleteFuture.get() + } +} diff --git a/openai-java-core/src/test/kotlin/com/openai/services/async/beta/threads/runs/StepServiceAsyncTest.kt b/openai-java-core/src/test/kotlin/com/openai/services/async/beta/threads/runs/StepServiceAsyncTest.kt new file mode 100644 index 000000000..ab055ca77 --- /dev/null +++ b/openai-java-core/src/test/kotlin/com/openai/services/async/beta/threads/runs/StepServiceAsyncTest.kt @@ -0,0 +1,56 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.openai.services.async.beta.threads.runs + +import com.openai.TestServerExtension +import com.openai.client.okhttp.OpenAIOkHttpClientAsync +import com.openai.models.BetaThreadRunStepListParams +import com.openai.models.BetaThreadRunStepRetrieveParams +import com.openai.models.RunStepInclude +import org.junit.jupiter.api.Test +import org.junit.jupiter.api.extension.ExtendWith + +@ExtendWith(TestServerExtension::class) +class StepServiceAsyncTest { + + @Test + fun retrieve() { + val client = + OpenAIOkHttpClientAsync.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val stepServiceAsync = client.beta().threads().runs().steps() + + val runStepFuture = + stepServiceAsync.retrieve( + BetaThreadRunStepRetrieveParams.builder() + .threadId("thread_id") + .runId("run_id") + .stepId("step_id") + .addInclude(RunStepInclude.STEP_DETAILS_TOOL_CALLS_FILE_SEARCH_RESULTS_CONTENT) + .build() + ) + + val runStep = runStepFuture.get() + runStep.validate() + } + + @Test + fun list() { + val client = + OpenAIOkHttpClientAsync.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val stepServiceAsync = client.beta().threads().runs().steps() + + val pageFuture = + stepServiceAsync.list( + BetaThreadRunStepListParams.builder().threadId("thread_id").runId("run_id").build() + ) + + val page = pageFuture.get() + page.response().validate() + } +} diff --git a/openai-java-core/src/test/kotlin/com/openai/services/async/beta/vectorStores/FileBatchServiceAsyncTest.kt b/openai-java-core/src/test/kotlin/com/openai/services/async/beta/vectorStores/FileBatchServiceAsyncTest.kt new file mode 100644 index 000000000..eb6863878 --- /dev/null +++ b/openai-java-core/src/test/kotlin/com/openai/services/async/beta/vectorStores/FileBatchServiceAsyncTest.kt @@ -0,0 +1,102 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.openai.services.async.beta.vectorStores + +import com.openai.TestServerExtension +import com.openai.client.okhttp.OpenAIOkHttpClientAsync +import com.openai.models.AutoFileChunkingStrategyParam +import com.openai.models.BetaVectorStoreFileBatchCancelParams +import com.openai.models.BetaVectorStoreFileBatchCreateParams +import com.openai.models.BetaVectorStoreFileBatchListFilesParams +import com.openai.models.BetaVectorStoreFileBatchRetrieveParams +import org.junit.jupiter.api.Test +import org.junit.jupiter.api.extension.ExtendWith + +@ExtendWith(TestServerExtension::class) +class FileBatchServiceAsyncTest { + + @Test + fun create() { + val client = + OpenAIOkHttpClientAsync.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val fileBatchServiceAsync = client.beta().vectorStores().fileBatches() + + val vectorStoreFileBatchFuture = + fileBatchServiceAsync.create( + BetaVectorStoreFileBatchCreateParams.builder() + .vectorStoreId("vs_abc123") + .addFileId("string") + .chunkingStrategy(AutoFileChunkingStrategyParam.builder().build()) + .build() + ) + + val vectorStoreFileBatch = vectorStoreFileBatchFuture.get() + vectorStoreFileBatch.validate() + } + + @Test + fun retrieve() { + val client = + OpenAIOkHttpClientAsync.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val fileBatchServiceAsync = client.beta().vectorStores().fileBatches() + + val vectorStoreFileBatchFuture = + fileBatchServiceAsync.retrieve( + BetaVectorStoreFileBatchRetrieveParams.builder() + .vectorStoreId("vs_abc123") + .batchId("vsfb_abc123") + .build() + ) + + val vectorStoreFileBatch = vectorStoreFileBatchFuture.get() + vectorStoreFileBatch.validate() + } + + @Test + fun cancel() { + val client = + OpenAIOkHttpClientAsync.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val fileBatchServiceAsync = client.beta().vectorStores().fileBatches() + + val vectorStoreFileBatchFuture = + fileBatchServiceAsync.cancel( + BetaVectorStoreFileBatchCancelParams.builder() + .vectorStoreId("vector_store_id") + .batchId("batch_id") + .build() + ) + + val vectorStoreFileBatch = vectorStoreFileBatchFuture.get() + vectorStoreFileBatch.validate() + } + + @Test + fun listFiles() { + val client = + OpenAIOkHttpClientAsync.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val fileBatchServiceAsync = client.beta().vectorStores().fileBatches() + + val pageFuture = + fileBatchServiceAsync.listFiles( + BetaVectorStoreFileBatchListFilesParams.builder() + .vectorStoreId("vector_store_id") + .batchId("batch_id") + .build() + ) + + val page = pageFuture.get() + page.response().validate() + } +} diff --git a/openai-java-core/src/test/kotlin/com/openai/services/async/beta/vectorStores/FileServiceAsyncTest.kt b/openai-java-core/src/test/kotlin/com/openai/services/async/beta/vectorStores/FileServiceAsyncTest.kt new file mode 100644 index 000000000..dea24f398 --- /dev/null +++ b/openai-java-core/src/test/kotlin/com/openai/services/async/beta/vectorStores/FileServiceAsyncTest.kt @@ -0,0 +1,99 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.openai.services.async.beta.vectorStores + +import com.openai.TestServerExtension +import com.openai.client.okhttp.OpenAIOkHttpClientAsync +import com.openai.models.AutoFileChunkingStrategyParam +import com.openai.models.BetaVectorStoreFileCreateParams +import com.openai.models.BetaVectorStoreFileDeleteParams +import com.openai.models.BetaVectorStoreFileListParams +import com.openai.models.BetaVectorStoreFileRetrieveParams +import org.junit.jupiter.api.Test +import org.junit.jupiter.api.extension.ExtendWith + +@ExtendWith(TestServerExtension::class) +class FileServiceAsyncTest { + + @Test + fun create() { + val client = + OpenAIOkHttpClientAsync.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val fileServiceAsync = client.beta().vectorStores().files() + + val vectorStoreFileFuture = + fileServiceAsync.create( + BetaVectorStoreFileCreateParams.builder() + .vectorStoreId("vs_abc123") + .fileId("file_id") + .chunkingStrategy(AutoFileChunkingStrategyParam.builder().build()) + .build() + ) + + val vectorStoreFile = vectorStoreFileFuture.get() + vectorStoreFile.validate() + } + + @Test + fun retrieve() { + val client = + OpenAIOkHttpClientAsync.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val fileServiceAsync = client.beta().vectorStores().files() + + val vectorStoreFileFuture = + fileServiceAsync.retrieve( + BetaVectorStoreFileRetrieveParams.builder() + .vectorStoreId("vs_abc123") + .fileId("file-abc123") + .build() + ) + + val vectorStoreFile = vectorStoreFileFuture.get() + vectorStoreFile.validate() + } + + @Test + fun list() { + val client = + OpenAIOkHttpClientAsync.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val fileServiceAsync = client.beta().vectorStores().files() + + val pageFuture = + fileServiceAsync.list( + BetaVectorStoreFileListParams.builder().vectorStoreId("vector_store_id").build() + ) + + val page = pageFuture.get() + page.response().validate() + } + + @Test + fun delete() { + val client = + OpenAIOkHttpClientAsync.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val fileServiceAsync = client.beta().vectorStores().files() + + val vectorStoreFileDeletedFuture = + fileServiceAsync.delete( + BetaVectorStoreFileDeleteParams.builder() + .vectorStoreId("vector_store_id") + .fileId("file_id") + .build() + ) + + val vectorStoreFileDeleted = vectorStoreFileDeletedFuture.get() + vectorStoreFileDeleted.validate() + } +} diff --git a/openai-java-core/src/test/kotlin/com/openai/services/async/chat/CompletionServiceAsyncTest.kt b/openai-java-core/src/test/kotlin/com/openai/services/async/chat/CompletionServiceAsyncTest.kt new file mode 100644 index 000000000..72591ccd1 --- /dev/null +++ b/openai-java-core/src/test/kotlin/com/openai/services/async/chat/CompletionServiceAsyncTest.kt @@ -0,0 +1,276 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.openai.services.async.chat + +import com.openai.TestServerExtension +import com.openai.client.okhttp.OpenAIOkHttpClientAsync +import com.openai.core.JsonValue +import com.openai.models.ChatCompletionAudioParam +import com.openai.models.ChatCompletionCreateParams +import com.openai.models.ChatCompletionDeleteParams +import com.openai.models.ChatCompletionDeveloperMessageParam +import com.openai.models.ChatCompletionModality +import com.openai.models.ChatCompletionPredictionContent +import com.openai.models.ChatCompletionReasoningEffort +import com.openai.models.ChatCompletionRetrieveParams +import com.openai.models.ChatCompletionStreamOptions +import com.openai.models.ChatCompletionTool +import com.openai.models.ChatCompletionToolChoiceOption +import com.openai.models.ChatCompletionUpdateParams +import com.openai.models.ChatModel +import com.openai.models.FunctionDefinition +import com.openai.models.FunctionParameters +import com.openai.models.Metadata +import com.openai.models.ResponseFormatText +import org.junit.jupiter.api.Test +import org.junit.jupiter.api.extension.ExtendWith + +@ExtendWith(TestServerExtension::class) +class CompletionServiceAsyncTest { + + @Test + fun create() { + val client = + OpenAIOkHttpClientAsync.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val completionServiceAsync = client.chat().completions() + + val chatCompletionFuture = + completionServiceAsync.create( + ChatCompletionCreateParams.builder() + .addMessage( + ChatCompletionDeveloperMessageParam.builder() + .content("string") + .name("name") + .build() + ) + .model(ChatModel.O3_MINI) + .audio( + ChatCompletionAudioParam.builder() + .format(ChatCompletionAudioParam.Format.WAV) + .voice(ChatCompletionAudioParam.Voice.ALLOY) + .build() + ) + .frequencyPenalty(-2.0) + .functionCall(ChatCompletionCreateParams.FunctionCall.Auto.NONE) + .addFunction( + ChatCompletionCreateParams.Function.builder() + .name("name") + .description("description") + .parameters( + FunctionParameters.builder() + .putAdditionalProperty("foo", JsonValue.from("bar")) + .build() + ) + .build() + ) + .logitBias( + ChatCompletionCreateParams.LogitBias.builder() + .putAdditionalProperty("foo", JsonValue.from(0)) + .build() + ) + .logprobs(true) + .maxCompletionTokens(0L) + .maxTokens(0L) + .metadata( + Metadata.builder() + .putAdditionalProperty("foo", JsonValue.from("string")) + .build() + ) + .addModality(ChatCompletionModality.TEXT) + .n(1L) + .parallelToolCalls(true) + .prediction(ChatCompletionPredictionContent.builder().content("string").build()) + .presencePenalty(-2.0) + .reasoningEffort(ChatCompletionReasoningEffort.LOW) + .responseFormat(ResponseFormatText.builder().build()) + .seed(0L) + .serviceTier(ChatCompletionCreateParams.ServiceTier.AUTO) + .stop("string") + .store(true) + .streamOptions(ChatCompletionStreamOptions.builder().includeUsage(true).build()) + .temperature(1.0) + .toolChoice(ChatCompletionToolChoiceOption.Auto.NONE) + .addTool( + ChatCompletionTool.builder() + .function( + FunctionDefinition.builder() + .name("name") + .description("description") + .parameters( + FunctionParameters.builder() + .putAdditionalProperty("foo", JsonValue.from("bar")) + .build() + ) + .strict(true) + .build() + ) + .build() + ) + .topLogprobs(0L) + .topP(1.0) + .user("user-1234") + .build() + ) + + val chatCompletion = chatCompletionFuture.get() + chatCompletion.validate() + } + + @Test + fun createStreaming() { + val client = + OpenAIOkHttpClientAsync.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val completionServiceAsync = client.chat().completions() + + val chatCompletionStreamResponse = + completionServiceAsync.createStreaming( + ChatCompletionCreateParams.builder() + .addMessage( + ChatCompletionDeveloperMessageParam.builder() + .content("string") + .name("name") + .build() + ) + .model(ChatModel.O3_MINI) + .audio( + ChatCompletionAudioParam.builder() + .format(ChatCompletionAudioParam.Format.WAV) + .voice(ChatCompletionAudioParam.Voice.ALLOY) + .build() + ) + .frequencyPenalty(-2.0) + .functionCall(ChatCompletionCreateParams.FunctionCall.Auto.NONE) + .addFunction( + ChatCompletionCreateParams.Function.builder() + .name("name") + .description("description") + .parameters( + FunctionParameters.builder() + .putAdditionalProperty("foo", JsonValue.from("bar")) + .build() + ) + .build() + ) + .logitBias( + ChatCompletionCreateParams.LogitBias.builder() + .putAdditionalProperty("foo", JsonValue.from(0)) + .build() + ) + .logprobs(true) + .maxCompletionTokens(0L) + .maxTokens(0L) + .metadata( + Metadata.builder() + .putAdditionalProperty("foo", JsonValue.from("string")) + .build() + ) + .addModality(ChatCompletionModality.TEXT) + .n(1L) + .parallelToolCalls(true) + .prediction(ChatCompletionPredictionContent.builder().content("string").build()) + .presencePenalty(-2.0) + .reasoningEffort(ChatCompletionReasoningEffort.LOW) + .responseFormat(ResponseFormatText.builder().build()) + .seed(0L) + .serviceTier(ChatCompletionCreateParams.ServiceTier.AUTO) + .stop("string") + .store(true) + .streamOptions(ChatCompletionStreamOptions.builder().includeUsage(true).build()) + .temperature(1.0) + .toolChoice(ChatCompletionToolChoiceOption.Auto.NONE) + .addTool( + ChatCompletionTool.builder() + .function( + FunctionDefinition.builder() + .name("name") + .description("description") + .parameters( + FunctionParameters.builder() + .putAdditionalProperty("foo", JsonValue.from("bar")) + .build() + ) + .strict(true) + .build() + ) + .build() + ) + .topLogprobs(0L) + .topP(1.0) + .user("user-1234") + .build() + ) + + val onCompleteFuture = + chatCompletionStreamResponse + .subscribe { chatCompletion -> chatCompletion.validate() } + .onCompleteFuture() + onCompleteFuture.get() + } + + @Test + fun retrieve() { + val client = + OpenAIOkHttpClientAsync.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val completionServiceAsync = client.chat().completions() + + val chatCompletionFuture = + completionServiceAsync.retrieve( + ChatCompletionRetrieveParams.builder().completionId("completion_id").build() + ) + + val chatCompletion = chatCompletionFuture.get() + chatCompletion.validate() + } + + @Test + fun update() { + val client = + OpenAIOkHttpClientAsync.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val completionServiceAsync = client.chat().completions() + + val chatCompletionFuture = + completionServiceAsync.update( + ChatCompletionUpdateParams.builder() + .completionId("completion_id") + .metadata( + Metadata.builder() + .putAdditionalProperty("foo", JsonValue.from("string")) + .build() + ) + .build() + ) + + val chatCompletion = chatCompletionFuture.get() + chatCompletion.validate() + } + + @Test + fun delete() { + val client = + OpenAIOkHttpClientAsync.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val completionServiceAsync = client.chat().completions() + + val chatCompletionDeletedFuture = + completionServiceAsync.delete( + ChatCompletionDeleteParams.builder().completionId("completion_id").build() + ) + + val chatCompletionDeleted = chatCompletionDeletedFuture.get() + chatCompletionDeleted.validate() + } +} diff --git a/openai-java-core/src/test/kotlin/com/openai/services/async/chat/completions/MessageServiceAsyncTest.kt b/openai-java-core/src/test/kotlin/com/openai/services/async/chat/completions/MessageServiceAsyncTest.kt new file mode 100644 index 000000000..cbac37539 --- /dev/null +++ b/openai-java-core/src/test/kotlin/com/openai/services/async/chat/completions/MessageServiceAsyncTest.kt @@ -0,0 +1,31 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.openai.services.async.chat.completions + +import com.openai.TestServerExtension +import com.openai.client.okhttp.OpenAIOkHttpClientAsync +import com.openai.models.ChatCompletionMessageListParams +import org.junit.jupiter.api.Test +import org.junit.jupiter.api.extension.ExtendWith + +@ExtendWith(TestServerExtension::class) +class MessageServiceAsyncTest { + + @Test + fun list() { + val client = + OpenAIOkHttpClientAsync.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val messageServiceAsync = client.chat().completions().messages() + + val pageFuture = + messageServiceAsync.list( + ChatCompletionMessageListParams.builder().completionId("completion_id").build() + ) + + val page = pageFuture.get() + page.response().validate() + } +} diff --git a/openai-java-core/src/test/kotlin/com/openai/services/async/fineTuning/JobServiceAsyncTest.kt b/openai-java-core/src/test/kotlin/com/openai/services/async/fineTuning/JobServiceAsyncTest.kt new file mode 100644 index 000000000..c63f30234 --- /dev/null +++ b/openai-java-core/src/test/kotlin/com/openai/services/async/fineTuning/JobServiceAsyncTest.kt @@ -0,0 +1,164 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.openai.services.async.fineTuning + +import com.openai.TestServerExtension +import com.openai.client.okhttp.OpenAIOkHttpClientAsync +import com.openai.models.FineTuningJobCancelParams +import com.openai.models.FineTuningJobCreateParams +import com.openai.models.FineTuningJobListEventsParams +import com.openai.models.FineTuningJobRetrieveParams +import org.junit.jupiter.api.Test +import org.junit.jupiter.api.extension.ExtendWith + +@ExtendWith(TestServerExtension::class) +class JobServiceAsyncTest { + + @Test + fun create() { + val client = + OpenAIOkHttpClientAsync.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val jobServiceAsync = client.fineTuning().jobs() + + val fineTuningJobFuture = + jobServiceAsync.create( + FineTuningJobCreateParams.builder() + .model(FineTuningJobCreateParams.Model.BABBAGE_002) + .trainingFile("file-abc123") + .hyperparameters( + FineTuningJobCreateParams.Hyperparameters.builder() + .batchSizeAuto() + .learningRateMultiplierAuto() + .nEpochsAuto() + .build() + ) + .addIntegration( + FineTuningJobCreateParams.Integration.builder() + .wandb( + FineTuningJobCreateParams.Integration.Wandb.builder() + .project("my-wandb-project") + .entity("entity") + .name("name") + .addTag("custom-tag") + .build() + ) + .build() + ) + .method( + FineTuningJobCreateParams.Method.builder() + .dpo( + FineTuningJobCreateParams.Method.Dpo.builder() + .hyperparameters( + FineTuningJobCreateParams.Method.Dpo.Hyperparameters + .builder() + .batchSizeAuto() + .betaAuto() + .learningRateMultiplierAuto() + .nEpochsAuto() + .build() + ) + .build() + ) + .supervised( + FineTuningJobCreateParams.Method.Supervised.builder() + .hyperparameters( + FineTuningJobCreateParams.Method.Supervised.Hyperparameters + .builder() + .batchSizeAuto() + .learningRateMultiplierAuto() + .nEpochsAuto() + .build() + ) + .build() + ) + .type(FineTuningJobCreateParams.Method.Type.SUPERVISED) + .build() + ) + .seed(42L) + .suffix("x") + .validationFile("file-abc123") + .build() + ) + + val fineTuningJob = fineTuningJobFuture.get() + fineTuningJob.validate() + } + + @Test + fun retrieve() { + val client = + OpenAIOkHttpClientAsync.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val jobServiceAsync = client.fineTuning().jobs() + + val fineTuningJobFuture = + jobServiceAsync.retrieve( + FineTuningJobRetrieveParams.builder() + .fineTuningJobId("ft-AF1WoRqd3aJAHsqc9NY7iL8F") + .build() + ) + + val fineTuningJob = fineTuningJobFuture.get() + fineTuningJob.validate() + } + + @Test + fun list() { + val client = + OpenAIOkHttpClientAsync.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val jobServiceAsync = client.fineTuning().jobs() + + val pageFuture = jobServiceAsync.list() + + val page = pageFuture.get() + page.response().validate() + } + + @Test + fun cancel() { + val client = + OpenAIOkHttpClientAsync.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val jobServiceAsync = client.fineTuning().jobs() + + val fineTuningJobFuture = + jobServiceAsync.cancel( + FineTuningJobCancelParams.builder() + .fineTuningJobId("ft-AF1WoRqd3aJAHsqc9NY7iL8F") + .build() + ) + + val fineTuningJob = fineTuningJobFuture.get() + fineTuningJob.validate() + } + + @Test + fun listEvents() { + val client = + OpenAIOkHttpClientAsync.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val jobServiceAsync = client.fineTuning().jobs() + + val pageFuture = + jobServiceAsync.listEvents( + FineTuningJobListEventsParams.builder() + .fineTuningJobId("ft-AF1WoRqd3aJAHsqc9NY7iL8F") + .build() + ) + + val page = pageFuture.get() + page.response().validate() + } +} diff --git a/openai-java-core/src/test/kotlin/com/openai/services/async/fineTuning/jobs/CheckpointServiceAsyncTest.kt b/openai-java-core/src/test/kotlin/com/openai/services/async/fineTuning/jobs/CheckpointServiceAsyncTest.kt new file mode 100644 index 000000000..c6ed8cd3f --- /dev/null +++ b/openai-java-core/src/test/kotlin/com/openai/services/async/fineTuning/jobs/CheckpointServiceAsyncTest.kt @@ -0,0 +1,33 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.openai.services.async.fineTuning.jobs + +import com.openai.TestServerExtension +import com.openai.client.okhttp.OpenAIOkHttpClientAsync +import com.openai.models.FineTuningJobCheckpointListParams +import org.junit.jupiter.api.Test +import org.junit.jupiter.api.extension.ExtendWith + +@ExtendWith(TestServerExtension::class) +class CheckpointServiceAsyncTest { + + @Test + fun list() { + val client = + OpenAIOkHttpClientAsync.builder() + .baseUrl(TestServerExtension.BASE_URL) + .apiKey("My API Key") + .build() + val checkpointServiceAsync = client.fineTuning().jobs().checkpoints() + + val pageFuture = + checkpointServiceAsync.list( + FineTuningJobCheckpointListParams.builder() + .fineTuningJobId("ft-AF1WoRqd3aJAHsqc9NY7iL8F") + .build() + ) + + val page = pageFuture.get() + page.response().validate() + } +} diff --git a/openai-java-core/src/test/kotlin/com/openai/services/blocking/BatchServiceTest.kt b/openai-java-core/src/test/kotlin/com/openai/services/blocking/BatchServiceTest.kt index 1aa8c4f9a..33621e800 100644 --- a/openai-java-core/src/test/kotlin/com/openai/services/blocking/BatchServiceTest.kt +++ b/openai-java-core/src/test/kotlin/com/openai/services/blocking/BatchServiceTest.kt @@ -16,13 +16,14 @@ import org.junit.jupiter.api.extension.ExtendWith class BatchServiceTest { @Test - fun callCreate() { + fun create() { val client = OpenAIOkHttpClient.builder() .baseUrl(TestServerExtension.BASE_URL) .apiKey("My API Key") .build() val batchService = client.batches() + val batch = batchService.create( BatchCreateParams.builder() @@ -36,46 +37,49 @@ class BatchServiceTest { ) .build() ) - println(batch) + batch.validate() } @Test - fun callRetrieve() { + fun retrieve() { val client = OpenAIOkHttpClient.builder() .baseUrl(TestServerExtension.BASE_URL) .apiKey("My API Key") .build() val batchService = client.batches() + val batch = batchService.retrieve(BatchRetrieveParams.builder().batchId("batch_id").build()) - println(batch) + batch.validate() } @Test - fun callList() { + fun list() { val client = OpenAIOkHttpClient.builder() .baseUrl(TestServerExtension.BASE_URL) .apiKey("My API Key") .build() val batchService = client.batches() - val listBatchesResponse = batchService.list() - println(listBatchesResponse) - listBatchesResponse.data().forEach { it.validate() } + + val page = batchService.list() + + page.response().validate() } @Test - fun callCancel() { + fun cancel() { val client = OpenAIOkHttpClient.builder() .baseUrl(TestServerExtension.BASE_URL) .apiKey("My API Key") .build() val batchService = client.batches() + val batch = batchService.cancel(BatchCancelParams.builder().batchId("batch_id").build()) - println(batch) + batch.validate() } } diff --git a/openai-java-core/src/test/kotlin/com/openai/services/blocking/CompletionServiceTest.kt b/openai-java-core/src/test/kotlin/com/openai/services/blocking/CompletionServiceTest.kt index 55c16983c..1d1ee4569 100644 --- a/openai-java-core/src/test/kotlin/com/openai/services/blocking/CompletionServiceTest.kt +++ b/openai-java-core/src/test/kotlin/com/openai/services/blocking/CompletionServiceTest.kt @@ -14,13 +14,14 @@ import org.junit.jupiter.api.extension.ExtendWith class CompletionServiceTest { @Test - fun callCreate() { + fun create() { val client = OpenAIOkHttpClient.builder() .baseUrl(TestServerExtension.BASE_URL) .apiKey("My API Key") .build() val completionService = client.completions() + val completion = completionService.create( CompletionCreateParams.builder() @@ -47,12 +48,12 @@ class CompletionServiceTest { .user("user-1234") .build() ) - println(completion) + completion.validate() } @Test - fun callCreateStreaming() { + fun createStreaming() { val client = OpenAIOkHttpClient.builder() .baseUrl(TestServerExtension.BASE_URL) @@ -60,7 +61,7 @@ class CompletionServiceTest { .build() val completionService = client.completions() - val completionStream = + val completionStreamResponse = completionService.createStreaming( CompletionCreateParams.builder() .model(CompletionCreateParams.Model.GPT_3_5_TURBO_INSTRUCT) @@ -87,11 +88,8 @@ class CompletionServiceTest { .build() ) - completionStream.use { - completionStream.stream().forEach { - println(it) - it.validate() - } + completionStreamResponse.use { + completionStreamResponse.stream().forEach { completion -> completion.validate() } } } } diff --git a/openai-java-core/src/test/kotlin/com/openai/services/blocking/EmbeddingServiceTest.kt b/openai-java-core/src/test/kotlin/com/openai/services/blocking/EmbeddingServiceTest.kt index 3dae18256..0d31b863e 100644 --- a/openai-java-core/src/test/kotlin/com/openai/services/blocking/EmbeddingServiceTest.kt +++ b/openai-java-core/src/test/kotlin/com/openai/services/blocking/EmbeddingServiceTest.kt @@ -13,13 +13,14 @@ import org.junit.jupiter.api.extension.ExtendWith class EmbeddingServiceTest { @Test - fun callCreate() { + fun create() { val client = OpenAIOkHttpClient.builder() .baseUrl(TestServerExtension.BASE_URL) .apiKey("My API Key") .build() val embeddingService = client.embeddings() + val createEmbeddingResponse = embeddingService.create( EmbeddingCreateParams.builder() @@ -30,7 +31,7 @@ class EmbeddingServiceTest { .user("user-1234") .build() ) - println(createEmbeddingResponse) + createEmbeddingResponse.validate() } } diff --git a/openai-java-core/src/test/kotlin/com/openai/services/blocking/FileServiceTest.kt b/openai-java-core/src/test/kotlin/com/openai/services/blocking/FileServiceTest.kt index b05d66a7c..2efe09046 100644 --- a/openai-java-core/src/test/kotlin/com/openai/services/blocking/FileServiceTest.kt +++ b/openai-java-core/src/test/kotlin/com/openai/services/blocking/FileServiceTest.kt @@ -10,7 +10,6 @@ import com.github.tomakehurst.wiremock.junit5.WireMockRuntimeInfo import com.github.tomakehurst.wiremock.junit5.WireMockTest import com.openai.TestServerExtension import com.openai.client.okhttp.OpenAIOkHttpClient -import com.openai.core.http.HttpResponse import com.openai.models.FileContentParams import com.openai.models.FileDeleteParams import com.openai.models.FileRetrieveParams @@ -23,57 +22,60 @@ import org.junit.jupiter.api.extension.ExtendWith class FileServiceTest { @Test - fun callRetrieve() { + fun retrieve() { val client = OpenAIOkHttpClient.builder() .baseUrl(TestServerExtension.BASE_URL) .apiKey("My API Key") .build() val fileService = client.files() + val fileObject = fileService.retrieve(FileRetrieveParams.builder().fileId("file_id").build()) - println(fileObject) + fileObject.validate() } @Test - fun callList() { + fun list() { val client = OpenAIOkHttpClient.builder() .baseUrl(TestServerExtension.BASE_URL) .apiKey("My API Key") .build() val fileService = client.files() - val listFilesResponse = fileService.list() - println(listFilesResponse) - listFilesResponse.data().forEach { it.validate() } + + val page = fileService.list() + + page.response().validate() } @Test - fun callDelete() { + fun delete() { val client = OpenAIOkHttpClient.builder() .baseUrl(TestServerExtension.BASE_URL) .apiKey("My API Key") .build() val fileService = client.files() + val fileDeleted = fileService.delete(FileDeleteParams.builder().fileId("file_id").build()) - println(fileDeleted) + fileDeleted.validate() } @Test - fun callContent(wmRuntimeInfo: WireMockRuntimeInfo) { + fun content(wmRuntimeInfo: WireMockRuntimeInfo) { val client = OpenAIOkHttpClient.builder() - .baseUrl(wmRuntimeInfo.getHttpBaseUrl()) + .baseUrl(wmRuntimeInfo.httpBaseUrl) .apiKey("My API Key") .build() - stubFor(get(anyUrl()).willReturn(ok().withBody("abc"))) val fileService = client.files() + stubFor(get(anyUrl()).willReturn(ok().withBody("abc"))) + val response = fileService.content(FileContentParams.builder().fileId("file_id").build()) - println(response) - assertThat(response).isInstanceOf(HttpResponse::class.java) + assertThat(response.body()).hasContent("abc") } } diff --git a/openai-java-core/src/test/kotlin/com/openai/services/blocking/ImageServiceTest.kt b/openai-java-core/src/test/kotlin/com/openai/services/blocking/ImageServiceTest.kt index c1ec94e85..817e2edc5 100644 --- a/openai-java-core/src/test/kotlin/com/openai/services/blocking/ImageServiceTest.kt +++ b/openai-java-core/src/test/kotlin/com/openai/services/blocking/ImageServiceTest.kt @@ -13,13 +13,14 @@ import org.junit.jupiter.api.extension.ExtendWith class ImageServiceTest { @Test - fun callGenerate() { + fun generate() { val client = OpenAIOkHttpClient.builder() .baseUrl(TestServerExtension.BASE_URL) .apiKey("My API Key") .build() val imageService = client.images() + val imagesResponse = imageService.generate( ImageGenerateParams.builder() @@ -33,7 +34,7 @@ class ImageServiceTest { .user("user-1234") .build() ) - println(imagesResponse) + imagesResponse.validate() } } diff --git a/openai-java-core/src/test/kotlin/com/openai/services/blocking/ModelServiceTest.kt b/openai-java-core/src/test/kotlin/com/openai/services/blocking/ModelServiceTest.kt index b6551e664..3193e3cc7 100644 --- a/openai-java-core/src/test/kotlin/com/openai/services/blocking/ModelServiceTest.kt +++ b/openai-java-core/src/test/kotlin/com/openai/services/blocking/ModelServiceTest.kt @@ -13,45 +13,48 @@ import org.junit.jupiter.api.extension.ExtendWith class ModelServiceTest { @Test - fun callRetrieve() { + fun retrieve() { val client = OpenAIOkHttpClient.builder() .baseUrl(TestServerExtension.BASE_URL) .apiKey("My API Key") .build() val modelService = client.models() + val model = modelService.retrieve(ModelRetrieveParams.builder().model("gpt-4o-mini").build()) - println(model) + model.validate() } @Test - fun callList() { + fun list() { val client = OpenAIOkHttpClient.builder() .baseUrl(TestServerExtension.BASE_URL) .apiKey("My API Key") .build() val modelService = client.models() - val listModelsResponse = modelService.list() - println(listModelsResponse) - listModelsResponse.data().forEach { it.validate() } + + val page = modelService.list() + + page.response().validate() } @Test - fun callDelete() { + fun delete() { val client = OpenAIOkHttpClient.builder() .baseUrl(TestServerExtension.BASE_URL) .apiKey("My API Key") .build() val modelService = client.models() + val modelDeleted = modelService.delete( ModelDeleteParams.builder().model("ft:gpt-4o-mini:acemeco:suffix:abc123").build() ) - println(modelDeleted) + modelDeleted.validate() } } diff --git a/openai-java-core/src/test/kotlin/com/openai/services/blocking/ModerationServiceTest.kt b/openai-java-core/src/test/kotlin/com/openai/services/blocking/ModerationServiceTest.kt index 30f69f34d..eff4e6cbd 100644 --- a/openai-java-core/src/test/kotlin/com/openai/services/blocking/ModerationServiceTest.kt +++ b/openai-java-core/src/test/kotlin/com/openai/services/blocking/ModerationServiceTest.kt @@ -13,21 +13,22 @@ import org.junit.jupiter.api.extension.ExtendWith class ModerationServiceTest { @Test - fun callCreate() { + fun create() { val client = OpenAIOkHttpClient.builder() .baseUrl(TestServerExtension.BASE_URL) .apiKey("My API Key") .build() val moderationService = client.moderations() - val moderationCreateResponse = + + val moderation = moderationService.create( ModerationCreateParams.builder() .input("I want to kill them.") .model(ModerationModel.OMNI_MODERATION_LATEST) .build() ) - println(moderationCreateResponse) - moderationCreateResponse.validate() + + moderation.validate() } } diff --git a/openai-java-core/src/test/kotlin/com/openai/services/blocking/UploadServiceTest.kt b/openai-java-core/src/test/kotlin/com/openai/services/blocking/UploadServiceTest.kt index 4c6833bb1..879f8bc5d 100644 --- a/openai-java-core/src/test/kotlin/com/openai/services/blocking/UploadServiceTest.kt +++ b/openai-java-core/src/test/kotlin/com/openai/services/blocking/UploadServiceTest.kt @@ -15,13 +15,14 @@ import org.junit.jupiter.api.extension.ExtendWith class UploadServiceTest { @Test - fun callCreate() { + fun create() { val client = OpenAIOkHttpClient.builder() .baseUrl(TestServerExtension.BASE_URL) .apiKey("My API Key") .build() val uploadService = client.uploads() + val upload = uploadService.create( UploadCreateParams.builder() @@ -31,32 +32,34 @@ class UploadServiceTest { .purpose(FilePurpose.ASSISTANTS) .build() ) - println(upload) + upload.validate() } @Test - fun callCancel() { + fun cancel() { val client = OpenAIOkHttpClient.builder() .baseUrl(TestServerExtension.BASE_URL) .apiKey("My API Key") .build() val uploadService = client.uploads() + val upload = uploadService.cancel(UploadCancelParams.builder().uploadId("upload_abc123").build()) - println(upload) + upload.validate() } @Test - fun callComplete() { + fun complete() { val client = OpenAIOkHttpClient.builder() .baseUrl(TestServerExtension.BASE_URL) .apiKey("My API Key") .build() val uploadService = client.uploads() + val upload = uploadService.complete( UploadCompleteParams.builder() @@ -65,7 +68,7 @@ class UploadServiceTest { .md5("md5") .build() ) - println(upload) + upload.validate() } } diff --git a/openai-java-core/src/test/kotlin/com/openai/services/blocking/beta/AssistantServiceTest.kt b/openai-java-core/src/test/kotlin/com/openai/services/blocking/beta/AssistantServiceTest.kt index 942506a6a..7981cbdb8 100644 --- a/openai-java-core/src/test/kotlin/com/openai/services/blocking/beta/AssistantServiceTest.kt +++ b/openai-java-core/src/test/kotlin/com/openai/services/blocking/beta/AssistantServiceTest.kt @@ -20,13 +20,14 @@ import org.junit.jupiter.api.extension.ExtendWith class AssistantServiceTest { @Test - fun callCreate() { + fun create() { val client = OpenAIOkHttpClient.builder() .baseUrl(TestServerExtension.BASE_URL) .apiKey("My API Key") .build() val assistantService = client.beta().assistants() + val assistant = assistantService.create( BetaAssistantCreateParams.builder() @@ -78,34 +79,36 @@ class AssistantServiceTest { .topP(1.0) .build() ) - println(assistant) + assistant.validate() } @Test - fun callRetrieve() { + fun retrieve() { val client = OpenAIOkHttpClient.builder() .baseUrl(TestServerExtension.BASE_URL) .apiKey("My API Key") .build() val assistantService = client.beta().assistants() + val assistant = assistantService.retrieve( BetaAssistantRetrieveParams.builder().assistantId("assistant_id").build() ) - println(assistant) + assistant.validate() } @Test - fun callUpdate() { + fun update() { val client = OpenAIOkHttpClient.builder() .baseUrl(TestServerExtension.BASE_URL) .apiKey("My API Key") .build() val assistantService = client.beta().assistants() + val assistant = assistantService.update( BetaAssistantUpdateParams.builder() @@ -140,36 +143,38 @@ class AssistantServiceTest { .topP(1.0) .build() ) - println(assistant) + assistant.validate() } @Test - fun callList() { + fun list() { val client = OpenAIOkHttpClient.builder() .baseUrl(TestServerExtension.BASE_URL) .apiKey("My API Key") .build() val assistantService = client.beta().assistants() - val listAssistantsResponse = assistantService.list() - println(listAssistantsResponse) - listAssistantsResponse.data().forEach { it.validate() } + + val page = assistantService.list() + + page.response().validate() } @Test - fun callDelete() { + fun delete() { val client = OpenAIOkHttpClient.builder() .baseUrl(TestServerExtension.BASE_URL) .apiKey("My API Key") .build() val assistantService = client.beta().assistants() + val assistantDeleted = assistantService.delete( BetaAssistantDeleteParams.builder().assistantId("assistant_id").build() ) - println(assistantDeleted) + assistantDeleted.validate() } } diff --git a/openai-java-core/src/test/kotlin/com/openai/services/blocking/beta/ThreadServiceTest.kt b/openai-java-core/src/test/kotlin/com/openai/services/blocking/beta/ThreadServiceTest.kt index d04ba9161..3eb2bace0 100644 --- a/openai-java-core/src/test/kotlin/com/openai/services/blocking/beta/ThreadServiceTest.kt +++ b/openai-java-core/src/test/kotlin/com/openai/services/blocking/beta/ThreadServiceTest.kt @@ -22,13 +22,14 @@ import org.junit.jupiter.api.extension.ExtendWith class ThreadServiceTest { @Test - fun callCreate() { + fun create() { val client = OpenAIOkHttpClient.builder() .baseUrl(TestServerExtension.BASE_URL) .apiKey("My API Key") .build() val threadService = client.beta().threads() + val thread = threadService.create( BetaThreadCreateParams.builder() @@ -87,32 +88,34 @@ class ThreadServiceTest { ) .build() ) - println(thread) + thread.validate() } @Test - fun callRetrieve() { + fun retrieve() { val client = OpenAIOkHttpClient.builder() .baseUrl(TestServerExtension.BASE_URL) .apiKey("My API Key") .build() val threadService = client.beta().threads() + val thread = threadService.retrieve(BetaThreadRetrieveParams.builder().threadId("thread_id").build()) - println(thread) + thread.validate() } @Test - fun callUpdate() { + fun update() { val client = OpenAIOkHttpClient.builder() .baseUrl(TestServerExtension.BASE_URL) .apiKey("My API Key") .build() val threadService = client.beta().threads() + val thread = threadService.update( BetaThreadUpdateParams.builder() @@ -138,32 +141,34 @@ class ThreadServiceTest { ) .build() ) - println(thread) + thread.validate() } @Test - fun callDelete() { + fun delete() { val client = OpenAIOkHttpClient.builder() .baseUrl(TestServerExtension.BASE_URL) .apiKey("My API Key") .build() val threadService = client.beta().threads() + val threadDeleted = threadService.delete(BetaThreadDeleteParams.builder().threadId("thread_id").build()) - println(threadDeleted) + threadDeleted.validate() } @Test - fun callCreateAndRun() { + fun createAndRun() { val client = OpenAIOkHttpClient.builder() .baseUrl(TestServerExtension.BASE_URL) .apiKey("My API Key") .build() val threadService = client.beta().threads() + val run = threadService.createAndRun( BetaThreadCreateAndRunParams.builder() @@ -269,12 +274,12 @@ class ThreadServiceTest { ) .build() ) - println(run) + run.validate() } @Test - fun callCreateAndRunStreaming() { + fun createAndRunStreaming() { val client = OpenAIOkHttpClient.builder() .baseUrl(TestServerExtension.BASE_URL) @@ -282,7 +287,7 @@ class ThreadServiceTest { .build() val threadService = client.beta().threads() - val runStream = + val runStreamResponse = threadService.createAndRunStreaming( BetaThreadCreateAndRunParams.builder() .assistantId("assistant_id") @@ -388,11 +393,6 @@ class ThreadServiceTest { .build() ) - runStream.use { - runStream.stream().forEach { - println(it) - it.validate() - } - } + runStreamResponse.use { runStreamResponse.stream().forEach { run -> run.validate() } } } } diff --git a/openai-java-core/src/test/kotlin/com/openai/services/blocking/beta/VectorStoreServiceTest.kt b/openai-java-core/src/test/kotlin/com/openai/services/blocking/beta/VectorStoreServiceTest.kt index 96b75b094..1794925d0 100644 --- a/openai-java-core/src/test/kotlin/com/openai/services/blocking/beta/VectorStoreServiceTest.kt +++ b/openai-java-core/src/test/kotlin/com/openai/services/blocking/beta/VectorStoreServiceTest.kt @@ -18,13 +18,14 @@ import org.junit.jupiter.api.extension.ExtendWith class VectorStoreServiceTest { @Test - fun callCreate() { + fun create() { val client = OpenAIOkHttpClient.builder() .baseUrl(TestServerExtension.BASE_URL) .apiKey("My API Key") .build() val vectorStoreService = client.beta().vectorStores() + val vectorStore = vectorStoreService.create( BetaVectorStoreCreateParams.builder() @@ -41,34 +42,36 @@ class VectorStoreServiceTest { .name("name") .build() ) - println(vectorStore) + vectorStore.validate() } @Test - fun callRetrieve() { + fun retrieve() { val client = OpenAIOkHttpClient.builder() .baseUrl(TestServerExtension.BASE_URL) .apiKey("My API Key") .build() val vectorStoreService = client.beta().vectorStores() + val vectorStore = vectorStoreService.retrieve( BetaVectorStoreRetrieveParams.builder().vectorStoreId("vector_store_id").build() ) - println(vectorStore) + vectorStore.validate() } @Test - fun callUpdate() { + fun update() { val client = OpenAIOkHttpClient.builder() .baseUrl(TestServerExtension.BASE_URL) .apiKey("My API Key") .build() val vectorStoreService = client.beta().vectorStores() + val vectorStore = vectorStoreService.update( BetaVectorStoreUpdateParams.builder() @@ -84,36 +87,38 @@ class VectorStoreServiceTest { .name("name") .build() ) - println(vectorStore) + vectorStore.validate() } @Test - fun callList() { + fun list() { val client = OpenAIOkHttpClient.builder() .baseUrl(TestServerExtension.BASE_URL) .apiKey("My API Key") .build() val vectorStoreService = client.beta().vectorStores() - val listVectorStoresResponse = vectorStoreService.list() - println(listVectorStoresResponse) - listVectorStoresResponse.data().forEach { it.validate() } + + val page = vectorStoreService.list() + + page.response().validate() } @Test - fun callDelete() { + fun delete() { val client = OpenAIOkHttpClient.builder() .baseUrl(TestServerExtension.BASE_URL) .apiKey("My API Key") .build() val vectorStoreService = client.beta().vectorStores() + val vectorStoreDeleted = vectorStoreService.delete( BetaVectorStoreDeleteParams.builder().vectorStoreId("vector_store_id").build() ) - println(vectorStoreDeleted) + vectorStoreDeleted.validate() } } diff --git a/openai-java-core/src/test/kotlin/com/openai/services/blocking/beta/threads/MessageServiceTest.kt b/openai-java-core/src/test/kotlin/com/openai/services/blocking/beta/threads/MessageServiceTest.kt index 5e9a04e55..53f133aa0 100644 --- a/openai-java-core/src/test/kotlin/com/openai/services/blocking/beta/threads/MessageServiceTest.kt +++ b/openai-java-core/src/test/kotlin/com/openai/services/blocking/beta/threads/MessageServiceTest.kt @@ -19,13 +19,14 @@ import org.junit.jupiter.api.extension.ExtendWith class MessageServiceTest { @Test - fun callCreate() { + fun create() { val client = OpenAIOkHttpClient.builder() .baseUrl(TestServerExtension.BASE_URL) .apiKey("My API Key") .build() val messageService = client.beta().threads().messages() + val message = messageService.create( BetaThreadMessageCreateParams.builder() @@ -45,18 +46,19 @@ class MessageServiceTest { ) .build() ) - println(message) + message.validate() } @Test - fun callRetrieve() { + fun retrieve() { val client = OpenAIOkHttpClient.builder() .baseUrl(TestServerExtension.BASE_URL) .apiKey("My API Key") .build() val messageService = client.beta().threads().messages() + val message = messageService.retrieve( BetaThreadMessageRetrieveParams.builder() @@ -64,18 +66,19 @@ class MessageServiceTest { .messageId("message_id") .build() ) - println(message) + message.validate() } @Test - fun callUpdate() { + fun update() { val client = OpenAIOkHttpClient.builder() .baseUrl(TestServerExtension.BASE_URL) .apiKey("My API Key") .build() val messageService = client.beta().threads().messages() + val message = messageService.update( BetaThreadMessageUpdateParams.builder() @@ -88,32 +91,34 @@ class MessageServiceTest { ) .build() ) - println(message) + message.validate() } @Test - fun callList() { + fun list() { val client = OpenAIOkHttpClient.builder() .baseUrl(TestServerExtension.BASE_URL) .apiKey("My API Key") .build() val messageService = client.beta().threads().messages() - val listMessagesResponse = + + val page = messageService.list(BetaThreadMessageListParams.builder().threadId("thread_id").build()) - println(listMessagesResponse) - listMessagesResponse.data().forEach { it.validate() } + + page.response().validate() } @Test - fun callDelete() { + fun delete() { val client = OpenAIOkHttpClient.builder() .baseUrl(TestServerExtension.BASE_URL) .apiKey("My API Key") .build() val messageService = client.beta().threads().messages() + val messageDeleted = messageService.delete( BetaThreadMessageDeleteParams.builder() @@ -121,7 +126,7 @@ class MessageServiceTest { .messageId("message_id") .build() ) - println(messageDeleted) + messageDeleted.validate() } } diff --git a/openai-java-core/src/test/kotlin/com/openai/services/blocking/beta/threads/RunServiceTest.kt b/openai-java-core/src/test/kotlin/com/openai/services/blocking/beta/threads/RunServiceTest.kt index c77223adf..9b34120c7 100644 --- a/openai-java-core/src/test/kotlin/com/openai/services/blocking/beta/threads/RunServiceTest.kt +++ b/openai-java-core/src/test/kotlin/com/openai/services/blocking/beta/threads/RunServiceTest.kt @@ -23,13 +23,14 @@ import org.junit.jupiter.api.extension.ExtendWith class RunServiceTest { @Test - fun callCreate() { + fun create() { val client = OpenAIOkHttpClient.builder() .baseUrl(TestServerExtension.BASE_URL) .apiKey("My API Key") .build() val runService = client.beta().threads().runs() + val run = runService.create( BetaThreadRunCreateParams.builder() @@ -78,12 +79,12 @@ class RunServiceTest { ) .build() ) - println(run) + run.validate() } @Test - fun callCreateStreaming() { + fun createStreaming() { val client = OpenAIOkHttpClient.builder() .baseUrl(TestServerExtension.BASE_URL) @@ -91,7 +92,7 @@ class RunServiceTest { .build() val runService = client.beta().threads().runs() - val runStream = + val runStreamResponse = runService.createStreaming( BetaThreadRunCreateParams.builder() .threadId("thread_id") @@ -140,38 +141,35 @@ class RunServiceTest { .build() ) - runStream.use { - runStream.stream().forEach { - println(it) - it.validate() - } - } + runStreamResponse.use { runStreamResponse.stream().forEach { run -> run.validate() } } } @Test - fun callRetrieve() { + fun retrieve() { val client = OpenAIOkHttpClient.builder() .baseUrl(TestServerExtension.BASE_URL) .apiKey("My API Key") .build() val runService = client.beta().threads().runs() + val run = runService.retrieve( BetaThreadRunRetrieveParams.builder().threadId("thread_id").runId("run_id").build() ) - println(run) + run.validate() } @Test - fun callUpdate() { + fun update() { val client = OpenAIOkHttpClient.builder() .baseUrl(TestServerExtension.BASE_URL) .apiKey("My API Key") .build() val runService = client.beta().threads().runs() + val run = runService.update( BetaThreadRunUpdateParams.builder() @@ -184,48 +182,50 @@ class RunServiceTest { ) .build() ) - println(run) + run.validate() } @Test - fun callList() { + fun list() { val client = OpenAIOkHttpClient.builder() .baseUrl(TestServerExtension.BASE_URL) .apiKey("My API Key") .build() val runService = client.beta().threads().runs() - val listRunsResponse = - runService.list(BetaThreadRunListParams.builder().threadId("thread_id").build()) - println(listRunsResponse) - listRunsResponse.data().forEach { it.validate() } + + val page = runService.list(BetaThreadRunListParams.builder().threadId("thread_id").build()) + + page.response().validate() } @Test - fun callCancel() { + fun cancel() { val client = OpenAIOkHttpClient.builder() .baseUrl(TestServerExtension.BASE_URL) .apiKey("My API Key") .build() val runService = client.beta().threads().runs() + val run = runService.cancel( BetaThreadRunCancelParams.builder().threadId("thread_id").runId("run_id").build() ) - println(run) + run.validate() } @Test - fun callSubmitToolOutputs() { + fun submitToolOutputs() { val client = OpenAIOkHttpClient.builder() .baseUrl(TestServerExtension.BASE_URL) .apiKey("My API Key") .build() val runService = client.beta().threads().runs() + val run = runService.submitToolOutputs( BetaThreadRunSubmitToolOutputsParams.builder() @@ -239,12 +239,12 @@ class RunServiceTest { ) .build() ) - println(run) + run.validate() } @Test - fun callSubmitToolOutputsStreaming() { + fun submitToolOutputsStreaming() { val client = OpenAIOkHttpClient.builder() .baseUrl(TestServerExtension.BASE_URL) @@ -252,7 +252,7 @@ class RunServiceTest { .build() val runService = client.beta().threads().runs() - val runStream = + val runStreamResponse = runService.submitToolOutputsStreaming( BetaThreadRunSubmitToolOutputsParams.builder() .threadId("thread_id") @@ -266,11 +266,6 @@ class RunServiceTest { .build() ) - runStream.use { - runStream.stream().forEach { - println(it) - it.validate() - } - } + runStreamResponse.use { runStreamResponse.stream().forEach { run -> run.validate() } } } } diff --git a/openai-java-core/src/test/kotlin/com/openai/services/blocking/beta/threads/runs/StepServiceTest.kt b/openai-java-core/src/test/kotlin/com/openai/services/blocking/beta/threads/runs/StepServiceTest.kt index 9dde52cdd..0770c3148 100644 --- a/openai-java-core/src/test/kotlin/com/openai/services/blocking/beta/threads/runs/StepServiceTest.kt +++ b/openai-java-core/src/test/kotlin/com/openai/services/blocking/beta/threads/runs/StepServiceTest.kt @@ -14,13 +14,14 @@ import org.junit.jupiter.api.extension.ExtendWith class StepServiceTest { @Test - fun callRetrieve() { + fun retrieve() { val client = OpenAIOkHttpClient.builder() .baseUrl(TestServerExtension.BASE_URL) .apiKey("My API Key") .build() val stepService = client.beta().threads().runs().steps() + val runStep = stepService.retrieve( BetaThreadRunStepRetrieveParams.builder() @@ -30,23 +31,24 @@ class StepServiceTest { .addInclude(RunStepInclude.STEP_DETAILS_TOOL_CALLS_FILE_SEARCH_RESULTS_CONTENT) .build() ) - println(runStep) + runStep.validate() } @Test - fun callList() { + fun list() { val client = OpenAIOkHttpClient.builder() .baseUrl(TestServerExtension.BASE_URL) .apiKey("My API Key") .build() val stepService = client.beta().threads().runs().steps() - val listRunStepsResponse = + + val page = stepService.list( BetaThreadRunStepListParams.builder().threadId("thread_id").runId("run_id").build() ) - println(listRunStepsResponse) - listRunStepsResponse.data().forEach { it.validate() } + + page.response().validate() } } diff --git a/openai-java-core/src/test/kotlin/com/openai/services/blocking/beta/vectorStores/FileBatchServiceTest.kt b/openai-java-core/src/test/kotlin/com/openai/services/blocking/beta/vectorStores/FileBatchServiceTest.kt index ff574d99c..718b32339 100644 --- a/openai-java-core/src/test/kotlin/com/openai/services/blocking/beta/vectorStores/FileBatchServiceTest.kt +++ b/openai-java-core/src/test/kotlin/com/openai/services/blocking/beta/vectorStores/FileBatchServiceTest.kt @@ -16,13 +16,14 @@ import org.junit.jupiter.api.extension.ExtendWith class FileBatchServiceTest { @Test - fun callCreate() { + fun create() { val client = OpenAIOkHttpClient.builder() .baseUrl(TestServerExtension.BASE_URL) .apiKey("My API Key") .build() val fileBatchService = client.beta().vectorStores().fileBatches() + val vectorStoreFileBatch = fileBatchService.create( BetaVectorStoreFileBatchCreateParams.builder() @@ -31,18 +32,19 @@ class FileBatchServiceTest { .chunkingStrategy(AutoFileChunkingStrategyParam.builder().build()) .build() ) - println(vectorStoreFileBatch) + vectorStoreFileBatch.validate() } @Test - fun callRetrieve() { + fun retrieve() { val client = OpenAIOkHttpClient.builder() .baseUrl(TestServerExtension.BASE_URL) .apiKey("My API Key") .build() val fileBatchService = client.beta().vectorStores().fileBatches() + val vectorStoreFileBatch = fileBatchService.retrieve( BetaVectorStoreFileBatchRetrieveParams.builder() @@ -50,18 +52,19 @@ class FileBatchServiceTest { .batchId("vsfb_abc123") .build() ) - println(vectorStoreFileBatch) + vectorStoreFileBatch.validate() } @Test - fun callCancel() { + fun cancel() { val client = OpenAIOkHttpClient.builder() .baseUrl(TestServerExtension.BASE_URL) .apiKey("My API Key") .build() val fileBatchService = client.beta().vectorStores().fileBatches() + val vectorStoreFileBatch = fileBatchService.cancel( BetaVectorStoreFileBatchCancelParams.builder() @@ -69,26 +72,27 @@ class FileBatchServiceTest { .batchId("batch_id") .build() ) - println(vectorStoreFileBatch) + vectorStoreFileBatch.validate() } @Test - fun callListFiles() { + fun listFiles() { val client = OpenAIOkHttpClient.builder() .baseUrl(TestServerExtension.BASE_URL) .apiKey("My API Key") .build() val fileBatchService = client.beta().vectorStores().fileBatches() - val listVectorStoreFilesResponse = + + val page = fileBatchService.listFiles( BetaVectorStoreFileBatchListFilesParams.builder() .vectorStoreId("vector_store_id") .batchId("batch_id") .build() ) - println(listVectorStoreFilesResponse) - listVectorStoreFilesResponse.data().forEach { it.validate() } + + page.response().validate() } } diff --git a/openai-java-core/src/test/kotlin/com/openai/services/blocking/beta/vectorStores/FileServiceTest.kt b/openai-java-core/src/test/kotlin/com/openai/services/blocking/beta/vectorStores/FileServiceTest.kt index 35b95a7c5..ed8e61776 100644 --- a/openai-java-core/src/test/kotlin/com/openai/services/blocking/beta/vectorStores/FileServiceTest.kt +++ b/openai-java-core/src/test/kotlin/com/openai/services/blocking/beta/vectorStores/FileServiceTest.kt @@ -16,13 +16,14 @@ import org.junit.jupiter.api.extension.ExtendWith class FileServiceTest { @Test - fun callCreate() { + fun create() { val client = OpenAIOkHttpClient.builder() .baseUrl(TestServerExtension.BASE_URL) .apiKey("My API Key") .build() val fileService = client.beta().vectorStores().files() + val vectorStoreFile = fileService.create( BetaVectorStoreFileCreateParams.builder() @@ -31,18 +32,19 @@ class FileServiceTest { .chunkingStrategy(AutoFileChunkingStrategyParam.builder().build()) .build() ) - println(vectorStoreFile) + vectorStoreFile.validate() } @Test - fun callRetrieve() { + fun retrieve() { val client = OpenAIOkHttpClient.builder() .baseUrl(TestServerExtension.BASE_URL) .apiKey("My API Key") .build() val fileService = client.beta().vectorStores().files() + val vectorStoreFile = fileService.retrieve( BetaVectorStoreFileRetrieveParams.builder() @@ -50,34 +52,36 @@ class FileServiceTest { .fileId("file-abc123") .build() ) - println(vectorStoreFile) + vectorStoreFile.validate() } @Test - fun callList() { + fun list() { val client = OpenAIOkHttpClient.builder() .baseUrl(TestServerExtension.BASE_URL) .apiKey("My API Key") .build() val fileService = client.beta().vectorStores().files() - val listVectorStoreFilesResponse = + + val page = fileService.list( BetaVectorStoreFileListParams.builder().vectorStoreId("vector_store_id").build() ) - println(listVectorStoreFilesResponse) - listVectorStoreFilesResponse.data().forEach { it.validate() } + + page.response().validate() } @Test - fun callDelete() { + fun delete() { val client = OpenAIOkHttpClient.builder() .baseUrl(TestServerExtension.BASE_URL) .apiKey("My API Key") .build() val fileService = client.beta().vectorStores().files() + val vectorStoreFileDeleted = fileService.delete( BetaVectorStoreFileDeleteParams.builder() @@ -85,7 +89,7 @@ class FileServiceTest { .fileId("file_id") .build() ) - println(vectorStoreFileDeleted) + vectorStoreFileDeleted.validate() } } diff --git a/openai-java-core/src/test/kotlin/com/openai/services/blocking/chat/CompletionServiceTest.kt b/openai-java-core/src/test/kotlin/com/openai/services/blocking/chat/CompletionServiceTest.kt index 857ffb750..bba74f35a 100644 --- a/openai-java-core/src/test/kotlin/com/openai/services/blocking/chat/CompletionServiceTest.kt +++ b/openai-java-core/src/test/kotlin/com/openai/services/blocking/chat/CompletionServiceTest.kt @@ -29,13 +29,14 @@ import org.junit.jupiter.api.extension.ExtendWith class CompletionServiceTest { @Test - fun callCreate() { + fun create() { val client = OpenAIOkHttpClient.builder() .baseUrl(TestServerExtension.BASE_URL) .apiKey("My API Key") .build() val completionService = client.chat().completions() + val chatCompletion = completionService.create( ChatCompletionCreateParams.builder() @@ -113,12 +114,12 @@ class CompletionServiceTest { .user("user-1234") .build() ) - println(chatCompletion) + chatCompletion.validate() } @Test - fun callCreateStreaming() { + fun createStreaming() { val client = OpenAIOkHttpClient.builder() .baseUrl(TestServerExtension.BASE_URL) @@ -126,7 +127,7 @@ class CompletionServiceTest { .build() val completionService = client.chat().completions() - val chatCompletionStream = + val chatCompletionStreamResponse = completionService.createStreaming( ChatCompletionCreateParams.builder() .addMessage( @@ -204,38 +205,39 @@ class CompletionServiceTest { .build() ) - chatCompletionStream.use { - chatCompletionStream.stream().forEach { - println(it) - it.validate() + chatCompletionStreamResponse.use { + chatCompletionStreamResponse.stream().forEach { chatCompletion -> + chatCompletion.validate() } } } @Test - fun callRetrieve() { + fun retrieve() { val client = OpenAIOkHttpClient.builder() .baseUrl(TestServerExtension.BASE_URL) .apiKey("My API Key") .build() val completionService = client.chat().completions() + val chatCompletion = completionService.retrieve( ChatCompletionRetrieveParams.builder().completionId("completion_id").build() ) - println(chatCompletion) + chatCompletion.validate() } @Test - fun callUpdate() { + fun update() { val client = OpenAIOkHttpClient.builder() .baseUrl(TestServerExtension.BASE_URL) .apiKey("My API Key") .build() val completionService = client.chat().completions() + val chatCompletion = completionService.update( ChatCompletionUpdateParams.builder() @@ -247,23 +249,24 @@ class CompletionServiceTest { ) .build() ) - println(chatCompletion) + chatCompletion.validate() } @Test - fun callDelete() { + fun delete() { val client = OpenAIOkHttpClient.builder() .baseUrl(TestServerExtension.BASE_URL) .apiKey("My API Key") .build() val completionService = client.chat().completions() + val chatCompletionDeleted = completionService.delete( ChatCompletionDeleteParams.builder().completionId("completion_id").build() ) - println(chatCompletionDeleted) + chatCompletionDeleted.validate() } } diff --git a/openai-java-core/src/test/kotlin/com/openai/services/blocking/chat/completions/MessageServiceTest.kt b/openai-java-core/src/test/kotlin/com/openai/services/blocking/chat/completions/MessageServiceTest.kt index d03a2576e..d17320d75 100644 --- a/openai-java-core/src/test/kotlin/com/openai/services/blocking/chat/completions/MessageServiceTest.kt +++ b/openai-java-core/src/test/kotlin/com/openai/services/blocking/chat/completions/MessageServiceTest.kt @@ -12,18 +12,19 @@ import org.junit.jupiter.api.extension.ExtendWith class MessageServiceTest { @Test - fun callList() { + fun list() { val client = OpenAIOkHttpClient.builder() .baseUrl(TestServerExtension.BASE_URL) .apiKey("My API Key") .build() val messageService = client.chat().completions().messages() - val chatCompletionMessageList = + + val page = messageService.list( ChatCompletionMessageListParams.builder().completionId("completion_id").build() ) - println(chatCompletionMessageList) - chatCompletionMessageList.data().forEach { it.validate() } + + page.response().validate() } } diff --git a/openai-java-core/src/test/kotlin/com/openai/services/blocking/fineTuning/JobServiceTest.kt b/openai-java-core/src/test/kotlin/com/openai/services/blocking/fineTuning/JobServiceTest.kt index 47bfcb29b..609d966b3 100644 --- a/openai-java-core/src/test/kotlin/com/openai/services/blocking/fineTuning/JobServiceTest.kt +++ b/openai-java-core/src/test/kotlin/com/openai/services/blocking/fineTuning/JobServiceTest.kt @@ -15,13 +15,14 @@ import org.junit.jupiter.api.extension.ExtendWith class JobServiceTest { @Test - fun callCreate() { + fun create() { val client = OpenAIOkHttpClient.builder() .baseUrl(TestServerExtension.BASE_URL) .apiKey("My API Key") .build() val jobService = client.fineTuning().jobs() + val fineTuningJob = jobService.create( FineTuningJobCreateParams.builder() @@ -81,74 +82,78 @@ class JobServiceTest { .validationFile("file-abc123") .build() ) - println(fineTuningJob) + fineTuningJob.validate() } @Test - fun callRetrieve() { + fun retrieve() { val client = OpenAIOkHttpClient.builder() .baseUrl(TestServerExtension.BASE_URL) .apiKey("My API Key") .build() val jobService = client.fineTuning().jobs() + val fineTuningJob = jobService.retrieve( FineTuningJobRetrieveParams.builder() .fineTuningJobId("ft-AF1WoRqd3aJAHsqc9NY7iL8F") .build() ) - println(fineTuningJob) + fineTuningJob.validate() } @Test - fun callList() { + fun list() { val client = OpenAIOkHttpClient.builder() .baseUrl(TestServerExtension.BASE_URL) .apiKey("My API Key") .build() val jobService = client.fineTuning().jobs() - val listPaginatedFineTuningJobsResponse = jobService.list() - println(listPaginatedFineTuningJobsResponse) - listPaginatedFineTuningJobsResponse.data().forEach { it.validate() } + + val page = jobService.list() + + page.response().validate() } @Test - fun callCancel() { + fun cancel() { val client = OpenAIOkHttpClient.builder() .baseUrl(TestServerExtension.BASE_URL) .apiKey("My API Key") .build() val jobService = client.fineTuning().jobs() + val fineTuningJob = jobService.cancel( FineTuningJobCancelParams.builder() .fineTuningJobId("ft-AF1WoRqd3aJAHsqc9NY7iL8F") .build() ) - println(fineTuningJob) + fineTuningJob.validate() } @Test - fun callListEvents() { + fun listEvents() { val client = OpenAIOkHttpClient.builder() .baseUrl(TestServerExtension.BASE_URL) .apiKey("My API Key") .build() val jobService = client.fineTuning().jobs() - val listFineTuningJobEventsResponse = + + val page = jobService.listEvents( FineTuningJobListEventsParams.builder() .fineTuningJobId("ft-AF1WoRqd3aJAHsqc9NY7iL8F") .build() ) - println(listFineTuningJobEventsResponse) - listFineTuningJobEventsResponse.data().forEach { it.validate() } + + page.response().validate() } } diff --git a/openai-java-core/src/test/kotlin/com/openai/services/blocking/fineTuning/jobs/CheckpointServiceTest.kt b/openai-java-core/src/test/kotlin/com/openai/services/blocking/fineTuning/jobs/CheckpointServiceTest.kt index d779133bd..9eba157e1 100644 --- a/openai-java-core/src/test/kotlin/com/openai/services/blocking/fineTuning/jobs/CheckpointServiceTest.kt +++ b/openai-java-core/src/test/kotlin/com/openai/services/blocking/fineTuning/jobs/CheckpointServiceTest.kt @@ -12,20 +12,21 @@ import org.junit.jupiter.api.extension.ExtendWith class CheckpointServiceTest { @Test - fun callList() { + fun list() { val client = OpenAIOkHttpClient.builder() .baseUrl(TestServerExtension.BASE_URL) .apiKey("My API Key") .build() val checkpointService = client.fineTuning().jobs().checkpoints() - val listFineTuningJobCheckpointsResponse = + + val page = checkpointService.list( FineTuningJobCheckpointListParams.builder() .fineTuningJobId("ft-AF1WoRqd3aJAHsqc9NY7iL8F") .build() ) - println(listFineTuningJobCheckpointsResponse) - listFineTuningJobCheckpointsResponse.data().forEach { it.validate() } + + page.response().validate() } }