diff --git a/README.md b/README.md index a7edf96f..73bbc758 100644 --- a/README.md +++ b/README.md @@ -8,13 +8,11 @@ The Finch Java SDK provides convenient access to the Finch REST API from applications written in Java. It includes helper classes with helpful types and documentation for every request and response property. -This package is currently in beta (pre-v1.0.0). We expect some breaking changes to rarely-used areas of the SDK, and appreciate your [feedback](https://www.github.com/Finch-API/finch-api-java/issues). - The Finch Java SDK is similar to the Finch Kotlin SDK but with minor differences that make it more ergonomic for use in Java, such as `Optional` instead of nullable values, `Stream` instead of `Sequence`, and `CompletableFuture` instead of suspend functions. ## Documentation -The API documentation can be found [here](https://developer.tryfinch.com/). +The API documentation can be found [in the Finch Documentation Center](https://developer.tryfinch.com/). --- @@ -79,30 +77,30 @@ Read the documentation for more configuration options. ### Example: creating a resource -To create a new hris directory, first use the `HrisDirectoryListIndividualsParams` builder to specify attributes, -then pass that to the `listIndividuals` method of the `directory` service. +To create a new hris directory, first use the `HrisDirectoryListParams` builder to specify attributes, +then pass that to the `list` method of the `directory` service. ```java -import com.tryfinch.api.models.HrisDirectoryListIndividualsPage; -import com.tryfinch.api.models.HrisDirectoryListIndividualsParams; +import com.tryfinch.api.models.HrisDirectoryListPage; +import com.tryfinch.api.models.HrisDirectoryListParams; import com.tryfinch.api.models.Page; -HrisDirectoryListIndividualsParams params = HrisDirectoryListIndividualsParams.builder() +HrisDirectoryListParams params = HrisDirectoryListParams.builder() .candidateId("") .build(); -HrisDirectoryListIndividualsPage hrisDirectory = client.directory().listIndividuals(params); +HrisDirectoryListPage hrisDirectory = client.directory().list(params); ``` ### Example: listing resources -The Finch API provides a `listIndividuals` method to get a paginated list of directory. +The Finch API provides a `list` method to get a paginated list of directory. You can retrieve the first page by: ```java import com.tryfinch.api.models.IndividualInDirectory; import com.tryfinch.api.models.Page; -HrisDirectoryListIndividualsPage page = client.directory().listIndividuals(); +HrisDirectoryListPage page = client.directory().list(); for (IndividualInDirectory directory : page.individuals()) { System.out.println(directory); } @@ -118,14 +116,14 @@ See [Pagination](#pagination) below for more information on transparently workin To make a request to the Finch API, you generally build an instance of the appropriate `Params` class. -In [Example: creating a resource](#example-creating-a-resource) above, we used the `HrisDirectoryListIndividualsParams.builder()` to pass to -the `listIndividuals` method of the `directory` service. +In [Example: creating a resource](#example-creating-a-resource) above, we used the `HrisDirectoryListParams.builder()` to pass to +the `list` method of the `directory` service. Sometimes, the API may support other properties that are not yet supported in the Java SDK types. In that case, you can attach them using the `putAdditionalProperty` method. ```java -HrisDirectoryListIndividualsParams params = HrisDirectoryListIndividualsParams.builder() +HrisDirectoryListParams params = HrisDirectoryListParams.builder() // ... normal properties .putAdditionalProperty("secret_param", "4242") .build(); @@ -138,7 +136,7 @@ HrisDirectoryListIndividualsParams params = HrisDirectoryListIndividualsParams.b When receiving a response, the Finch Java SDK will deserialize it into instances of the typed model classes. In rare cases, the API may return a response property that doesn't match the expected Java type. If you directly access the mistaken property, the SDK will throw an unchecked `FinchInvalidDataException` at runtime. If you would prefer to check in advance that that response is completely well-typed, call `.validate()` on the returned model. ```java -HrisDirectoryListIndividualsPage hrisDirectory = client.directory().listIndividuals().validate(); +HrisDirectoryListPage hrisDirectory = client.directory().list().validate(); ``` ### Response properties as JSON @@ -187,13 +185,13 @@ which automatically handles fetching more pages for you: ```java // As an Iterable: -HrisDirectoryListIndividualsPage page = client.directory().listIndividuals(params); +HrisDirectoryListPage page = client.directory().list(params); for (IndividualInDirectory directory : page.autoPager()) { System.out.println(directory); }; // As a Stream: -client.directory().listIndividuals(params).autoPager().stream() +client.directory().list(params).autoPager().stream() .limit(50) .forEach(directory -> System.out.println(directory)); ``` @@ -202,7 +200,7 @@ client.directory().listIndividuals(params).autoPager().stream() ```java // Using forEach, which returns CompletableFuture: -asyncClient.directory().listIndividuals(params).autoPager() +asyncClient.directory().list(params).autoPager() .forEach(directory -> System.out.println(directory), executor); ``` @@ -214,7 +212,7 @@ A page of results has a `data()` method to fetch the list of objects, as well as `hasNextPage`, `getNextPage`, and `getNextPageParams` methods to help with pagination. ```java -HrisDirectoryListIndividualsPage page = client.directory().listIndividuals(params); +HrisDirectoryListPage page = client.directory().list(params); while (page != null) { for (IndividualInDirectory directory : page.individuals()) { System.out.println(directory); @@ -301,3 +299,14 @@ FinchClient client = FinchOkHttpClient.builder() )) .build(); ``` + +## Semantic Versioning + +This package generally follows [SemVer](https://semver.org/spec/v2.0.0.html) conventions, though certain backwards-incompatible changes may be released as minor versions: + +1. Changes to library internals which are technically public but not intended or documented for external use. _(Please open a GitHub issue to let us know if you are relying on such internals)_. +2. Changes that we do not expect to impact the vast majority of users in practice. + +We take backwards-compatibility seriously and work hard to ensure you can rely on a smooth upgrade experience. + +We are keen for your feedback; please open an [issue](https://www.github.com/Finch-API/finch-api-java/issues) with questions, bugs, or suggestions. diff --git a/finch-java-core/src/main/kotlin/com/tryfinch/api/models/BenfitContribution.kt b/finch-java-core/src/main/kotlin/com/tryfinch/api/models/BenefitContribution.kt similarity index 89% rename from finch-java-core/src/main/kotlin/com/tryfinch/api/models/BenfitContribution.kt rename to finch-java-core/src/main/kotlin/com/tryfinch/api/models/BenefitContribution.kt index 39239dce..0cb18aeb 100644 --- a/finch-java-core/src/main/kotlin/com/tryfinch/api/models/BenfitContribution.kt +++ b/finch-java-core/src/main/kotlin/com/tryfinch/api/models/BenefitContribution.kt @@ -17,9 +17,9 @@ import com.tryfinch.api.errors.FinchInvalidDataException import java.util.Objects import java.util.Optional -@JsonDeserialize(builder = BenfitContribution.Builder::class) +@JsonDeserialize(builder = BenefitContribution.Builder::class) @NoAutoDetect -class BenfitContribution +class BenefitContribution private constructor( private val type: JsonField, private val amount: JsonField, @@ -46,7 +46,7 @@ private constructor( @ExcludeMissing fun _additionalProperties(): Map = additionalProperties - fun validate(): BenfitContribution = apply { + fun validate(): BenefitContribution = apply { if (!validated) { type() amount() @@ -61,7 +61,7 @@ private constructor( return true } - return other is BenfitContribution && + return other is BenefitContribution && this.type == other.type && this.amount == other.amount && this.additionalProperties == other.additionalProperties @@ -80,7 +80,7 @@ private constructor( } override fun toString() = - "BenfitContribution{type=$type, amount=$amount, additionalProperties=$additionalProperties}" + "BenefitContribution{type=$type, amount=$amount, additionalProperties=$additionalProperties}" companion object { @@ -94,10 +94,10 @@ private constructor( private var additionalProperties: MutableMap = mutableMapOf() @JvmSynthetic - internal fun from(benfitContribution: BenfitContribution) = apply { - this.type = benfitContribution.type - this.amount = benfitContribution.amount - additionalProperties(benfitContribution.additionalProperties) + internal fun from(benefitContribution: BenefitContribution) = apply { + this.type = benefitContribution.type + this.amount = benefitContribution.amount + additionalProperties(benefitContribution.additionalProperties) } /** Contribution type. */ @@ -130,8 +130,8 @@ private constructor( this.additionalProperties.putAll(additionalProperties) } - fun build(): BenfitContribution = - BenfitContribution( + fun build(): BenefitContribution = + BenefitContribution( type, amount, additionalProperties.toUnmodifiable(), diff --git a/finch-java-core/src/main/kotlin/com/tryfinch/api/models/CompanyBenefit.kt b/finch-java-core/src/main/kotlin/com/tryfinch/api/models/CompanyBenefit.kt index 44725771..4e052d42 100644 --- a/finch-java-core/src/main/kotlin/com/tryfinch/api/models/CompanyBenefit.kt +++ b/finch-java-core/src/main/kotlin/com/tryfinch/api/models/CompanyBenefit.kt @@ -23,8 +23,8 @@ private constructor( private val type: JsonField, private val description: JsonField, private val frequency: JsonField, - private val companyContribution: JsonField, - private val employeeDeduction: JsonField, + private val companyContribution: JsonField, + private val employeeDeduction: JsonField, private val additionalProperties: Map, ) { @@ -43,10 +43,10 @@ private constructor( fun frequency(): Optional = Optional.ofNullable(frequency.getNullable("frequency")) - fun companyContribution(): Optional = + fun companyContribution(): Optional = Optional.ofNullable(companyContribution.getNullable("company_contribution")) - fun employeeDeduction(): Optional = + fun employeeDeduction(): Optional = Optional.ofNullable(employeeDeduction.getNullable("employee_deduction")) @JsonProperty("benefit_id") @ExcludeMissing fun _benefitId() = benefitId @@ -127,8 +127,8 @@ private constructor( private var type: JsonField = JsonMissing.of() private var description: JsonField = JsonMissing.of() private var frequency: JsonField = JsonMissing.of() - private var companyContribution: JsonField = JsonMissing.of() - private var employeeDeduction: JsonField = JsonMissing.of() + private var companyContribution: JsonField = JsonMissing.of() + private var employeeDeduction: JsonField = JsonMissing.of() private var additionalProperties: MutableMap = mutableMapOf() @JvmSynthetic @@ -168,21 +168,21 @@ private constructor( @ExcludeMissing fun frequency(frequency: JsonField) = apply { this.frequency = frequency } - fun companyContribution(companyContribution: BenfitContribution) = + fun companyContribution(companyContribution: BenefitContribution) = companyContribution(JsonField.of(companyContribution)) @JsonProperty("company_contribution") @ExcludeMissing - fun companyContribution(companyContribution: JsonField) = apply { + fun companyContribution(companyContribution: JsonField) = apply { this.companyContribution = companyContribution } - fun employeeDeduction(employeeDeduction: BenfitContribution) = + fun employeeDeduction(employeeDeduction: BenefitContribution) = employeeDeduction(JsonField.of(employeeDeduction)) @JsonProperty("employee_deduction") @ExcludeMissing - fun employeeDeduction(employeeDeduction: JsonField) = apply { + fun employeeDeduction(employeeDeduction: JsonField) = apply { this.employeeDeduction = employeeDeduction } diff --git a/finch-java-core/src/main/kotlin/com/tryfinch/api/models/HrisDirectoryListPage.kt b/finch-java-core/src/main/kotlin/com/tryfinch/api/models/HrisDirectoryListPage.kt new file mode 100644 index 00000000..4661a39f --- /dev/null +++ b/finch-java-core/src/main/kotlin/com/tryfinch/api/models/HrisDirectoryListPage.kt @@ -0,0 +1,224 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.tryfinch.api.models + +import com.fasterxml.jackson.annotation.JsonAnyGetter +import com.fasterxml.jackson.annotation.JsonAnySetter +import com.fasterxml.jackson.annotation.JsonProperty +import com.fasterxml.jackson.databind.annotation.JsonDeserialize +import com.tryfinch.api.core.ExcludeMissing +import com.tryfinch.api.core.JsonField +import com.tryfinch.api.core.JsonMissing +import com.tryfinch.api.core.JsonValue +import com.tryfinch.api.core.NoAutoDetect +import com.tryfinch.api.core.toUnmodifiable +import com.tryfinch.api.services.blocking.hris.DirectoryService +import java.util.Objects +import java.util.Optional +import java.util.stream.Stream +import java.util.stream.StreamSupport + +class HrisDirectoryListPage +private constructor( + private val directoryService: DirectoryService, + private val params: HrisDirectoryListParams, + private val response: Response, +) { + + fun response(): Response = response + + fun individuals(): List = response().individuals() + + fun paging(): Paging = response().paging() + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return other is HrisDirectoryListPage && + this.directoryService == other.directoryService && + this.params == other.params && + this.response == other.response + } + + override fun hashCode(): Int { + return Objects.hash( + directoryService, + params, + response, + ) + } + + override fun toString() = + "HrisDirectoryListPage{directoryService=$directoryService, params=$params, response=$response}" + + fun hasNextPage(): Boolean { + if (individuals().isEmpty()) { + return false + } + + return paging().offset().orElse(0) + individuals().count() < + paging().count().orElse(Long.MAX_VALUE) + } + + fun getNextPageParams(): Optional { + if (!hasNextPage()) { + return Optional.empty() + } + + return Optional.of( + HrisDirectoryListParams.builder() + .from(params) + .offset(paging().offset().orElse(0) + individuals().count()) + .build() + ) + } + + fun getNextPage(): Optional { + return getNextPageParams().map { directoryService.list(it) } + } + + fun autoPager(): AutoPager = AutoPager(this) + + companion object { + + @JvmStatic + fun of( + directoryService: DirectoryService, + params: HrisDirectoryListParams, + response: Response + ) = + HrisDirectoryListPage( + directoryService, + params, + response, + ) + } + + @JsonDeserialize(builder = Response.Builder::class) + @NoAutoDetect + class Response + constructor( + private val individuals: JsonField>, + private val paging: JsonField, + private val additionalProperties: Map, + ) { + + private var validated: Boolean = false + + fun individuals(): List = + individuals.getNullable("individuals") ?: listOf() + + fun paging(): Paging = paging.getRequired("paging") + + @JsonProperty("individuals") + fun _individuals(): Optional>> = + Optional.ofNullable(individuals) + + @JsonProperty("paging") + fun _paging(): Optional> = Optional.ofNullable(paging) + + @JsonAnyGetter + @ExcludeMissing + fun _additionalProperties(): Map = additionalProperties + + fun validate(): Response = apply { + if (!validated) { + individuals().map { it.validate() } + paging().validate() + validated = true + } + } + + fun toBuilder() = Builder().from(this) + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return other is Response && + this.individuals == other.individuals && + this.paging == other.paging && + this.additionalProperties == other.additionalProperties + } + + override fun hashCode(): Int { + return Objects.hash( + individuals, + paging, + additionalProperties, + ) + } + + override fun toString() = + "HrisDirectoryListPage.Response{individuals=$individuals, paging=$paging, additionalProperties=$additionalProperties}" + + companion object { + + @JvmStatic fun builder() = Builder() + } + + class Builder { + + private var individuals: JsonField> = JsonMissing.of() + private var paging: JsonField = JsonMissing.of() + private var additionalProperties: MutableMap = mutableMapOf() + + @JvmSynthetic + internal fun from(page: Response) = apply { + this.individuals = page.individuals + this.paging = page.paging + this.additionalProperties.putAll(page.additionalProperties) + } + + fun individuals(individuals: List) = + individuals(JsonField.of(individuals)) + + @JsonProperty("individuals") + fun individuals(individuals: JsonField>) = apply { + this.individuals = individuals + } + + fun paging(paging: Paging) = paging(JsonField.of(paging)) + + @JsonProperty("paging") + fun paging(paging: JsonField) = apply { this.paging = paging } + + @JsonAnySetter + fun putAdditionalProperty(key: String, value: JsonValue) = apply { + this.additionalProperties.put(key, value) + } + + fun build() = + Response( + individuals, + paging, + additionalProperties.toUnmodifiable(), + ) + } + } + + class AutoPager + constructor( + private val firstPage: HrisDirectoryListPage, + ) : Iterable { + + override fun iterator(): Iterator = iterator { + var page = firstPage + var index = 0 + while (true) { + while (index < page.individuals().size) { + yield(page.individuals()[index++]) + } + page = page.getNextPage().orElse(null) ?: break + index = 0 + } + } + + fun stream(): Stream { + return StreamSupport.stream(spliterator(), false) + } + } +} diff --git a/finch-java-core/src/main/kotlin/com/tryfinch/api/models/HrisDirectoryListPageAsync.kt b/finch-java-core/src/main/kotlin/com/tryfinch/api/models/HrisDirectoryListPageAsync.kt new file mode 100644 index 00000000..153a7a30 --- /dev/null +++ b/finch-java-core/src/main/kotlin/com/tryfinch/api/models/HrisDirectoryListPageAsync.kt @@ -0,0 +1,237 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.tryfinch.api.models + +import com.fasterxml.jackson.annotation.JsonAnyGetter +import com.fasterxml.jackson.annotation.JsonAnySetter +import com.fasterxml.jackson.annotation.JsonProperty +import com.fasterxml.jackson.databind.annotation.JsonDeserialize +import com.tryfinch.api.core.ExcludeMissing +import com.tryfinch.api.core.JsonField +import com.tryfinch.api.core.JsonMissing +import com.tryfinch.api.core.JsonValue +import com.tryfinch.api.core.NoAutoDetect +import com.tryfinch.api.core.toUnmodifiable +import com.tryfinch.api.services.async.hris.DirectoryServiceAsync +import java.util.Objects +import java.util.Optional +import java.util.concurrent.CompletableFuture +import java.util.concurrent.Executor +import java.util.function.Predicate + +class HrisDirectoryListPageAsync +private constructor( + private val directoryService: DirectoryServiceAsync, + private val params: HrisDirectoryListParams, + private val response: Response, +) { + + fun response(): Response = response + + fun individuals(): List = response().individuals() + + fun paging(): Paging = response().paging() + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return other is HrisDirectoryListPageAsync && + this.directoryService == other.directoryService && + this.params == other.params && + this.response == other.response + } + + override fun hashCode(): Int { + return Objects.hash( + directoryService, + params, + response, + ) + } + + override fun toString() = + "HrisDirectoryListPageAsync{directoryService=$directoryService, params=$params, response=$response}" + + fun hasNextPage(): Boolean { + if (individuals().isEmpty()) { + return false + } + + return paging().offset().orElse(0) + individuals().count() < + paging().count().orElse(Long.MAX_VALUE) + } + + fun getNextPageParams(): Optional { + if (!hasNextPage()) { + return Optional.empty() + } + + return Optional.of( + HrisDirectoryListParams.builder() + .from(params) + .offset(paging().offset().orElse(0) + individuals().count()) + .build() + ) + } + + fun getNextPage(): CompletableFuture> { + return getNextPageParams() + .map { directoryService.list(it).thenApply { Optional.of(it) } } + .orElseGet { CompletableFuture.completedFuture(Optional.empty()) } + } + + fun autoPager(): AutoPager = AutoPager(this) + + companion object { + + @JvmStatic + fun of( + directoryService: DirectoryServiceAsync, + params: HrisDirectoryListParams, + response: Response + ) = + HrisDirectoryListPageAsync( + directoryService, + params, + response, + ) + } + + @JsonDeserialize(builder = Response.Builder::class) + @NoAutoDetect + class Response + constructor( + private val individuals: JsonField>, + private val paging: JsonField, + private val additionalProperties: Map, + ) { + + private var validated: Boolean = false + + fun individuals(): List = + individuals.getNullable("individuals") ?: listOf() + + fun paging(): Paging = paging.getRequired("paging") + + @JsonProperty("individuals") + fun _individuals(): Optional>> = + Optional.ofNullable(individuals) + + @JsonProperty("paging") + fun _paging(): Optional> = Optional.ofNullable(paging) + + @JsonAnyGetter + @ExcludeMissing + fun _additionalProperties(): Map = additionalProperties + + fun validate(): Response = apply { + if (!validated) { + individuals().map { it.validate() } + paging().validate() + validated = true + } + } + + fun toBuilder() = Builder().from(this) + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return other is Response && + this.individuals == other.individuals && + this.paging == other.paging && + this.additionalProperties == other.additionalProperties + } + + override fun hashCode(): Int { + return Objects.hash( + individuals, + paging, + additionalProperties, + ) + } + + override fun toString() = + "HrisDirectoryListPageAsync.Response{individuals=$individuals, paging=$paging, additionalProperties=$additionalProperties}" + + companion object { + + @JvmStatic fun builder() = Builder() + } + + class Builder { + + private var individuals: JsonField> = JsonMissing.of() + private var paging: JsonField = JsonMissing.of() + private var additionalProperties: MutableMap = mutableMapOf() + + @JvmSynthetic + internal fun from(page: Response) = apply { + this.individuals = page.individuals + this.paging = page.paging + this.additionalProperties.putAll(page.additionalProperties) + } + + fun individuals(individuals: List) = + individuals(JsonField.of(individuals)) + + @JsonProperty("individuals") + fun individuals(individuals: JsonField>) = apply { + this.individuals = individuals + } + + fun paging(paging: Paging) = paging(JsonField.of(paging)) + + @JsonProperty("paging") + fun paging(paging: JsonField) = apply { this.paging = paging } + + @JsonAnySetter + fun putAdditionalProperty(key: String, value: JsonValue) = apply { + this.additionalProperties.put(key, value) + } + + fun build() = + Response( + individuals, + paging, + additionalProperties.toUnmodifiable(), + ) + } + } + + class AutoPager + constructor( + private val firstPage: HrisDirectoryListPageAsync, + ) { + + fun forEach( + action: Predicate, + executor: Executor + ): CompletableFuture { + fun CompletableFuture>.forEach( + action: (IndividualInDirectory) -> Boolean, + executor: Executor + ): CompletableFuture = + thenComposeAsync( + { page -> + page + .filter { it.individuals().all(action) } + .map { it.getNextPage().forEach(action, executor) } + .orElseGet { CompletableFuture.completedFuture(null) } + }, + executor + ) + return CompletableFuture.completedFuture(Optional.of(firstPage)) + .forEach(action::test, executor) + } + + fun toList(executor: Executor): CompletableFuture> { + val values = mutableListOf() + return forEach(values::add, executor).thenApply { values } + } + } +} diff --git a/finch-java-core/src/main/kotlin/com/tryfinch/api/models/HrisDirectoryListParams.kt b/finch-java-core/src/main/kotlin/com/tryfinch/api/models/HrisDirectoryListParams.kt new file mode 100644 index 00000000..8af057ec --- /dev/null +++ b/finch-java-core/src/main/kotlin/com/tryfinch/api/models/HrisDirectoryListParams.kt @@ -0,0 +1,139 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.tryfinch.api.models + +import com.tryfinch.api.core.NoAutoDetect +import com.tryfinch.api.core.toUnmodifiable +import com.tryfinch.api.models.* +import java.util.Objects +import java.util.Optional + +class HrisDirectoryListParams +constructor( + private val limit: Long?, + private val offset: Long?, + private val additionalQueryParams: Map>, + private val additionalHeaders: Map>, +) { + + fun limit(): Optional = Optional.ofNullable(limit) + + fun offset(): Optional = Optional.ofNullable(offset) + + @JvmSynthetic + internal fun getQueryParams(): Map> { + val params = mutableMapOf>() + this.limit?.let { params.put("limit", listOf(it.toString())) } + this.offset?.let { params.put("offset", listOf(it.toString())) } + params.putAll(additionalQueryParams) + return params.toUnmodifiable() + } + + @JvmSynthetic internal fun getHeaders(): Map> = additionalHeaders + + fun _additionalQueryParams(): Map> = additionalQueryParams + + fun _additionalHeaders(): Map> = additionalHeaders + + override fun equals(other: Any?): Boolean { + if (this === other) { + return true + } + + return other is HrisDirectoryListParams && + this.limit == other.limit && + this.offset == other.offset && + this.additionalQueryParams == other.additionalQueryParams && + this.additionalHeaders == other.additionalHeaders + } + + override fun hashCode(): Int { + return Objects.hash( + limit, + offset, + additionalQueryParams, + additionalHeaders, + ) + } + + override fun toString() = + "HrisDirectoryListParams{limit=$limit, offset=$offset, additionalQueryParams=$additionalQueryParams, additionalHeaders=$additionalHeaders}" + + fun toBuilder() = Builder().from(this) + + companion object { + + @JvmStatic fun builder() = Builder() + } + + @NoAutoDetect + class Builder { + + private var limit: Long? = null + private var offset: Long? = null + private var additionalQueryParams: MutableMap> = mutableMapOf() + private var additionalHeaders: MutableMap> = mutableMapOf() + + @JvmSynthetic + internal fun from(hrisDirectoryListParams: HrisDirectoryListParams) = apply { + this.limit = hrisDirectoryListParams.limit + this.offset = hrisDirectoryListParams.offset + additionalQueryParams(hrisDirectoryListParams.additionalQueryParams) + additionalHeaders(hrisDirectoryListParams.additionalHeaders) + } + + /** Number of employees to return (defaults to all) */ + fun limit(limit: Long) = apply { this.limit = limit } + + /** Index to start from (defaults to 0) */ + fun offset(offset: Long) = apply { this.offset = offset } + + fun additionalQueryParams(additionalQueryParams: Map>) = apply { + this.additionalQueryParams.clear() + putAllQueryParams(additionalQueryParams) + } + + fun putQueryParam(name: String, value: String) = apply { + this.additionalQueryParams.getOrPut(name) { mutableListOf() }.add(value) + } + + fun putQueryParams(name: String, values: Iterable) = apply { + this.additionalQueryParams.getOrPut(name) { mutableListOf() }.addAll(values) + } + + fun putAllQueryParams(additionalQueryParams: Map>) = apply { + additionalQueryParams.forEach(this::putQueryParams) + } + + fun removeQueryParam(name: String) = apply { + this.additionalQueryParams.put(name, mutableListOf()) + } + + fun additionalHeaders(additionalHeaders: Map>) = apply { + this.additionalHeaders.clear() + putAllHeaders(additionalHeaders) + } + + fun putHeader(name: String, value: String) = apply { + this.additionalHeaders.getOrPut(name) { mutableListOf() }.add(value) + } + + fun putHeaders(name: String, values: Iterable) = apply { + this.additionalHeaders.getOrPut(name) { mutableListOf() }.addAll(values) + } + + fun putAllHeaders(additionalHeaders: Map>) = apply { + additionalHeaders.forEach(this::putHeaders) + } + + fun removeHeader(name: String) = apply { this.additionalHeaders.put(name, mutableListOf()) } + + fun build(): HrisDirectoryListParams = + HrisDirectoryListParams( + limit, + offset, + additionalQueryParams.mapValues { it.value.toUnmodifiable() }.toUnmodifiable(), + additionalHeaders.mapValues { it.value.toUnmodifiable() }.toUnmodifiable(), + ) + } +} diff --git a/finch-java-core/src/main/kotlin/com/tryfinch/api/models/IndividualBenefit.kt b/finch-java-core/src/main/kotlin/com/tryfinch/api/models/IndividualBenefit.kt index 3b0ced49..d043c4b1 100644 --- a/finch-java-core/src/main/kotlin/com/tryfinch/api/models/IndividualBenefit.kt +++ b/finch-java-core/src/main/kotlin/com/tryfinch/api/models/IndividualBenefit.kt @@ -154,8 +154,8 @@ private constructor( @NoAutoDetect class Body private constructor( - private val employeeDeduction: JsonField, - private val companyContribution: JsonField, + private val employeeDeduction: JsonField, + private val companyContribution: JsonField, private val annualMaximum: JsonField, private val catchUp: JsonField, private val hsaContributionLimit: JsonField, @@ -166,10 +166,10 @@ private constructor( private var hashCode: Int = 0 - fun employeeDeduction(): Optional = + fun employeeDeduction(): Optional = Optional.ofNullable(employeeDeduction.getNullable("employee_deduction")) - fun companyContribution(): Optional = + fun companyContribution(): Optional = Optional.ofNullable(companyContribution.getNullable("company_contribution")) /** If the benefit supports annual maximum, the amount in cents for this individual. */ @@ -264,8 +264,8 @@ private constructor( class Builder { - private var employeeDeduction: JsonField = JsonMissing.of() - private var companyContribution: JsonField = JsonMissing.of() + private var employeeDeduction: JsonField = JsonMissing.of() + private var companyContribution: JsonField = JsonMissing.of() private var annualMaximum: JsonField = JsonMissing.of() private var catchUp: JsonField = JsonMissing.of() private var hsaContributionLimit: JsonField = JsonMissing.of() @@ -281,21 +281,21 @@ private constructor( additionalProperties(body.additionalProperties) } - fun employeeDeduction(employeeDeduction: BenfitContribution) = + fun employeeDeduction(employeeDeduction: BenefitContribution) = employeeDeduction(JsonField.of(employeeDeduction)) @JsonProperty("employee_deduction") @ExcludeMissing - fun employeeDeduction(employeeDeduction: JsonField) = apply { + fun employeeDeduction(employeeDeduction: JsonField) = apply { this.employeeDeduction = employeeDeduction } - fun companyContribution(companyContribution: BenfitContribution) = + fun companyContribution(companyContribution: BenefitContribution) = companyContribution(JsonField.of(companyContribution)) @JsonProperty("company_contribution") @ExcludeMissing - fun companyContribution(companyContribution: JsonField) = apply { + fun companyContribution(companyContribution: JsonField) = apply { this.companyContribution = companyContribution } diff --git a/finch-java-core/src/main/kotlin/com/tryfinch/api/services/async/hris/DirectoryServiceAsync.kt b/finch-java-core/src/main/kotlin/com/tryfinch/api/services/async/hris/DirectoryServiceAsync.kt index 60056b37..a61173f8 100644 --- a/finch-java-core/src/main/kotlin/com/tryfinch/api/services/async/hris/DirectoryServiceAsync.kt +++ b/finch-java-core/src/main/kotlin/com/tryfinch/api/services/async/hris/DirectoryServiceAsync.kt @@ -7,12 +7,22 @@ package com.tryfinch.api.services.async.hris import com.tryfinch.api.core.RequestOptions import com.tryfinch.api.models.HrisDirectoryListIndividualsPageAsync import com.tryfinch.api.models.HrisDirectoryListIndividualsParams +import com.tryfinch.api.models.HrisDirectoryListPageAsync +import com.tryfinch.api.models.HrisDirectoryListParams import java.util.concurrent.CompletableFuture interface DirectoryServiceAsync { /** Read company directory and organization structure */ @JvmOverloads + fun list( + params: HrisDirectoryListParams, + requestOptions: RequestOptions = RequestOptions.none() + ): CompletableFuture + + /** Read company directory and organization structure */ + @JvmOverloads + @Deprecated("use `list` instead") fun listIndividuals( params: HrisDirectoryListIndividualsParams, requestOptions: RequestOptions = RequestOptions.none() diff --git a/finch-java-core/src/main/kotlin/com/tryfinch/api/services/async/hris/DirectoryServiceAsyncImpl.kt b/finch-java-core/src/main/kotlin/com/tryfinch/api/services/async/hris/DirectoryServiceAsyncImpl.kt index b234bd1d..3d856932 100644 --- a/finch-java-core/src/main/kotlin/com/tryfinch/api/services/async/hris/DirectoryServiceAsyncImpl.kt +++ b/finch-java-core/src/main/kotlin/com/tryfinch/api/services/async/hris/DirectoryServiceAsyncImpl.kt @@ -10,6 +10,8 @@ import com.tryfinch.api.core.http.HttpResponse.Handler import com.tryfinch.api.errors.FinchError import com.tryfinch.api.models.HrisDirectoryListIndividualsPageAsync import com.tryfinch.api.models.HrisDirectoryListIndividualsParams +import com.tryfinch.api.models.HrisDirectoryListPageAsync +import com.tryfinch.api.models.HrisDirectoryListParams import com.tryfinch.api.services.errorHandler import com.tryfinch.api.services.jsonHandler import com.tryfinch.api.services.withErrorHandler @@ -22,11 +24,42 @@ constructor( private val errorHandler: Handler = errorHandler(clientOptions.jsonMapper) + private val listHandler: Handler = + jsonHandler(clientOptions.jsonMapper) + .withErrorHandler(errorHandler) + + /** Read company directory and organization structure */ + override fun list( + params: HrisDirectoryListParams, + requestOptions: RequestOptions + ): CompletableFuture { + val request = + HttpRequest.builder() + .method(HttpMethod.GET) + .addPathSegments("employer", "directory") + .putAllQueryParams(params.getQueryParams()) + .putAllHeaders(clientOptions.headers) + .putAllHeaders(params.getHeaders()) + .build() + return clientOptions.httpClient.executeAsync(request, requestOptions).thenApply { response + -> + response + .use { listHandler.handle(it) } + .apply { + if (requestOptions.responseValidation ?: clientOptions.responseValidation) { + validate() + } + } + .let { HrisDirectoryListPageAsync.of(this, params, it) } + } + } + private val listIndividualsHandler: Handler = jsonHandler(clientOptions.jsonMapper) .withErrorHandler(errorHandler) /** Read company directory and organization structure */ + @Deprecated("use `list` instead") override fun listIndividuals( params: HrisDirectoryListIndividualsParams, requestOptions: RequestOptions diff --git a/finch-java-core/src/main/kotlin/com/tryfinch/api/services/blocking/hris/DirectoryService.kt b/finch-java-core/src/main/kotlin/com/tryfinch/api/services/blocking/hris/DirectoryService.kt index a98a3927..6add41c8 100644 --- a/finch-java-core/src/main/kotlin/com/tryfinch/api/services/blocking/hris/DirectoryService.kt +++ b/finch-java-core/src/main/kotlin/com/tryfinch/api/services/blocking/hris/DirectoryService.kt @@ -7,11 +7,21 @@ package com.tryfinch.api.services.blocking.hris import com.tryfinch.api.core.RequestOptions import com.tryfinch.api.models.HrisDirectoryListIndividualsPage import com.tryfinch.api.models.HrisDirectoryListIndividualsParams +import com.tryfinch.api.models.HrisDirectoryListPage +import com.tryfinch.api.models.HrisDirectoryListParams interface DirectoryService { /** Read company directory and organization structure */ @JvmOverloads + fun list( + params: HrisDirectoryListParams, + requestOptions: RequestOptions = RequestOptions.none() + ): HrisDirectoryListPage + + /** Read company directory and organization structure */ + @JvmOverloads + @Deprecated("use `list` instead") fun listIndividuals( params: HrisDirectoryListIndividualsParams, requestOptions: RequestOptions = RequestOptions.none() diff --git a/finch-java-core/src/main/kotlin/com/tryfinch/api/services/blocking/hris/DirectoryServiceImpl.kt b/finch-java-core/src/main/kotlin/com/tryfinch/api/services/blocking/hris/DirectoryServiceImpl.kt index 2fc2a89b..fb4e3b5a 100644 --- a/finch-java-core/src/main/kotlin/com/tryfinch/api/services/blocking/hris/DirectoryServiceImpl.kt +++ b/finch-java-core/src/main/kotlin/com/tryfinch/api/services/blocking/hris/DirectoryServiceImpl.kt @@ -10,6 +10,8 @@ import com.tryfinch.api.core.http.HttpResponse.Handler import com.tryfinch.api.errors.FinchError import com.tryfinch.api.models.HrisDirectoryListIndividualsPage import com.tryfinch.api.models.HrisDirectoryListIndividualsParams +import com.tryfinch.api.models.HrisDirectoryListPage +import com.tryfinch.api.models.HrisDirectoryListParams import com.tryfinch.api.services.errorHandler import com.tryfinch.api.services.jsonHandler import com.tryfinch.api.services.withErrorHandler @@ -21,11 +23,41 @@ constructor( private val errorHandler: Handler = errorHandler(clientOptions.jsonMapper) + private val listHandler: Handler = + jsonHandler(clientOptions.jsonMapper) + .withErrorHandler(errorHandler) + + /** Read company directory and organization structure */ + override fun list( + params: HrisDirectoryListParams, + requestOptions: RequestOptions + ): HrisDirectoryListPage { + val request = + HttpRequest.builder() + .method(HttpMethod.GET) + .addPathSegments("employer", "directory") + .putAllQueryParams(params.getQueryParams()) + .putAllHeaders(clientOptions.headers) + .putAllHeaders(params.getHeaders()) + .build() + return clientOptions.httpClient.execute(request, requestOptions).let { response -> + response + .use { listHandler.handle(it) } + .apply { + if (requestOptions.responseValidation ?: clientOptions.responseValidation) { + validate() + } + } + .let { HrisDirectoryListPage.of(this, params, it) } + } + } + private val listIndividualsHandler: Handler = jsonHandler(clientOptions.jsonMapper) .withErrorHandler(errorHandler) /** Read company directory and organization structure */ + @Deprecated("use `list` instead") override fun listIndividuals( params: HrisDirectoryListIndividualsParams, requestOptions: RequestOptions diff --git a/finch-java-core/src/test/kotlin/com/tryfinch/api/models/BenefitContributionTest.kt b/finch-java-core/src/test/kotlin/com/tryfinch/api/models/BenefitContributionTest.kt new file mode 100644 index 00000000..f03a3aab --- /dev/null +++ b/finch-java-core/src/test/kotlin/com/tryfinch/api/models/BenefitContributionTest.kt @@ -0,0 +1,18 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.tryfinch.api.models + +import org.assertj.core.api.Assertions.assertThat +import org.junit.jupiter.api.Test + +class BenefitContributionTest { + + @Test + fun createBenefitContribution() { + val benefitContribution = + BenefitContribution.builder().amount(123L).type(BenefitContribution.Type.FIXED).build() + assertThat(benefitContribution).isNotNull + assertThat(benefitContribution.amount()).contains(123L) + assertThat(benefitContribution.type()).contains(BenefitContribution.Type.FIXED) + } +} diff --git a/finch-java-core/src/test/kotlin/com/tryfinch/api/models/BenfitContributionTest.kt b/finch-java-core/src/test/kotlin/com/tryfinch/api/models/BenfitContributionTest.kt deleted file mode 100644 index 8a0cf627..00000000 --- a/finch-java-core/src/test/kotlin/com/tryfinch/api/models/BenfitContributionTest.kt +++ /dev/null @@ -1,18 +0,0 @@ -// File generated from our OpenAPI spec by Stainless. - -package com.tryfinch.api.models - -import org.assertj.core.api.Assertions.assertThat -import org.junit.jupiter.api.Test - -class BenfitContributionTest { - - @Test - fun createBenfitContribution() { - val benfitContribution = - BenfitContribution.builder().amount(123L).type(BenfitContribution.Type.FIXED).build() - assertThat(benfitContribution).isNotNull - assertThat(benfitContribution.amount()).contains(123L) - assertThat(benfitContribution.type()).contains(BenfitContribution.Type.FIXED) - } -} diff --git a/finch-java-core/src/test/kotlin/com/tryfinch/api/models/CompanyBenefitTest.kt b/finch-java-core/src/test/kotlin/com/tryfinch/api/models/CompanyBenefitTest.kt index 5b62d58d..4315737b 100644 --- a/finch-java-core/src/test/kotlin/com/tryfinch/api/models/CompanyBenefitTest.kt +++ b/finch-java-core/src/test/kotlin/com/tryfinch/api/models/CompanyBenefitTest.kt @@ -13,16 +13,16 @@ class CompanyBenefitTest { CompanyBenefit.builder() .benefitId("string") .companyContribution( - BenfitContribution.builder() + BenefitContribution.builder() .amount(123L) - .type(BenfitContribution.Type.FIXED) + .type(BenefitContribution.Type.FIXED) .build() ) .description("string") .employeeDeduction( - BenfitContribution.builder() + BenefitContribution.builder() .amount(123L) - .type(BenfitContribution.Type.FIXED) + .type(BenefitContribution.Type.FIXED) .build() ) .frequency(BenefitFrequency.ONE_TIME) @@ -32,17 +32,17 @@ class CompanyBenefitTest { assertThat(companyBenefit.benefitId()).isEqualTo("string") assertThat(companyBenefit.companyContribution()) .contains( - BenfitContribution.builder() + BenefitContribution.builder() .amount(123L) - .type(BenfitContribution.Type.FIXED) + .type(BenefitContribution.Type.FIXED) .build() ) assertThat(companyBenefit.description()).contains("string") assertThat(companyBenefit.employeeDeduction()) .contains( - BenfitContribution.builder() + BenefitContribution.builder() .amount(123L) - .type(BenfitContribution.Type.FIXED) + .type(BenefitContribution.Type.FIXED) .build() ) assertThat(companyBenefit.frequency()).contains(BenefitFrequency.ONE_TIME) diff --git a/finch-java-core/src/test/kotlin/com/tryfinch/api/models/HrisDirectoryListParamsTest.kt b/finch-java-core/src/test/kotlin/com/tryfinch/api/models/HrisDirectoryListParamsTest.kt new file mode 100644 index 00000000..4c80b233 --- /dev/null +++ b/finch-java-core/src/test/kotlin/com/tryfinch/api/models/HrisDirectoryListParamsTest.kt @@ -0,0 +1,31 @@ +// File generated from our OpenAPI spec by Stainless. + +package com.tryfinch.api.models + +import com.tryfinch.api.models.* +import org.assertj.core.api.Assertions.assertThat +import org.junit.jupiter.api.Test + +class HrisDirectoryListParamsTest { + + @Test + fun createHrisDirectoryListParams() { + HrisDirectoryListParams.builder().limit(123L).offset(123L).build() + } + + @Test + fun getQueryParams() { + val params = HrisDirectoryListParams.builder().limit(123L).offset(123L).build() + val expected = mutableMapOf>() + expected.put("limit", listOf("123")) + expected.put("offset", listOf("123")) + assertThat(params.getQueryParams()).isEqualTo(expected) + } + + @Test + fun getQueryParamsWithoutOptionalFields() { + val params = HrisDirectoryListParams.builder().build() + val expected = mutableMapOf>() + assertThat(params.getQueryParams()).isEqualTo(expected) + } +} diff --git a/finch-java-core/src/test/kotlin/com/tryfinch/api/models/IndividualBenefitTest.kt b/finch-java-core/src/test/kotlin/com/tryfinch/api/models/IndividualBenefitTest.kt index 9c2b358d..eeeb6bb3 100644 --- a/finch-java-core/src/test/kotlin/com/tryfinch/api/models/IndividualBenefitTest.kt +++ b/finch-java-core/src/test/kotlin/com/tryfinch/api/models/IndividualBenefitTest.kt @@ -16,15 +16,15 @@ class IndividualBenefitTest { .annualMaximum(123L) .catchUp(true) .companyContribution( - BenfitContribution.builder() + BenefitContribution.builder() .amount(123L) - .type(BenfitContribution.Type.FIXED) + .type(BenefitContribution.Type.FIXED) .build() ) .employeeDeduction( - BenfitContribution.builder() + BenefitContribution.builder() .amount(123L) - .type(BenfitContribution.Type.FIXED) + .type(BenefitContribution.Type.FIXED) .build() ) .hsaContributionLimit( @@ -42,15 +42,15 @@ class IndividualBenefitTest { .annualMaximum(123L) .catchUp(true) .companyContribution( - BenfitContribution.builder() + BenefitContribution.builder() .amount(123L) - .type(BenfitContribution.Type.FIXED) + .type(BenefitContribution.Type.FIXED) .build() ) .employeeDeduction( - BenfitContribution.builder() + BenefitContribution.builder() .amount(123L) - .type(BenfitContribution.Type.FIXED) + .type(BenefitContribution.Type.FIXED) .build() ) .hsaContributionLimit(IndividualBenefit.Body.HsaContributionLimit.INDIVIDUAL) diff --git a/finch-java-core/src/test/kotlin/com/tryfinch/api/services/ErrorHandlingTest.kt b/finch-java-core/src/test/kotlin/com/tryfinch/api/services/ErrorHandlingTest.kt index 14182d3e..df584a6a 100644 --- a/finch-java-core/src/test/kotlin/com/tryfinch/api/services/ErrorHandlingTest.kt +++ b/finch-java-core/src/test/kotlin/com/tryfinch/api/services/ErrorHandlingTest.kt @@ -27,8 +27,8 @@ import com.tryfinch.api.errors.UnauthorizedException import com.tryfinch.api.errors.UnexpectedStatusCodeException import com.tryfinch.api.errors.UnprocessableEntityException import com.tryfinch.api.models.* -import com.tryfinch.api.models.HrisDirectoryListIndividualsPage -import com.tryfinch.api.models.HrisDirectoryListIndividualsParams +import com.tryfinch.api.models.HrisDirectoryListPage +import com.tryfinch.api.models.HrisDirectoryListParams import org.assertj.core.api.Assertions.assertThat import org.assertj.core.api.Assertions.assertThatThrownBy import org.assertj.core.api.InstanceOfAssertFactories @@ -61,16 +61,16 @@ class ErrorHandlingTest { } @Test - fun directoryListIndividuals200() { + fun directoryList200() { val service = client.hris().directory() - val params = HrisDirectoryListIndividualsParams.builder().limit(123L).offset(123L).build() + val params = HrisDirectoryListParams.builder().limit(123L).offset(123L).build() val expected = - HrisDirectoryListIndividualsPage.of( + HrisDirectoryListPage.of( service, params, - HrisDirectoryListIndividualsPage.Response.builder() + HrisDirectoryListPage.Response.builder() .individuals( listOf( IndividualInDirectory.builder() @@ -98,110 +98,109 @@ class ErrorHandlingTest { stubFor(get(anyUrl()).willReturn(ok().withBody(toJson(expected.response())))) - assertThat(client.hris().directory().listIndividuals(params).response()) - .isEqualTo(expected.response()) + assertThat(client.hris().directory().list(params).response()).isEqualTo(expected.response()) } @Test - fun directoryListIndividuals400() { - val params = HrisDirectoryListIndividualsParams.builder().limit(123L).offset(123L).build() + fun directoryList400() { + val params = HrisDirectoryListParams.builder().limit(123L).offset(123L).build() stubFor( get(anyUrl()) .willReturn(status(400).withHeader("Foo", "Bar").withBody(toJson(FINCH_ERROR))) ) - assertThatThrownBy({ client.hris().directory().listIndividuals(params) }) + assertThatThrownBy({ client.hris().directory().list(params) }) .satisfies({ e -> assertBadRequest(e, ImmutableListMultimap.of("Foo", "Bar"), FINCH_ERROR) }) } @Test - fun directoryListIndividuals401() { - val params = HrisDirectoryListIndividualsParams.builder().limit(123L).offset(123L).build() + fun directoryList401() { + val params = HrisDirectoryListParams.builder().limit(123L).offset(123L).build() stubFor( get(anyUrl()) .willReturn(status(401).withHeader("Foo", "Bar").withBody(toJson(FINCH_ERROR))) ) - assertThatThrownBy({ client.hris().directory().listIndividuals(params) }) + assertThatThrownBy({ client.hris().directory().list(params) }) .satisfies({ e -> assertUnauthorized(e, ImmutableListMultimap.of("Foo", "Bar"), FINCH_ERROR) }) } @Test - fun directoryListIndividuals403() { - val params = HrisDirectoryListIndividualsParams.builder().limit(123L).offset(123L).build() + fun directoryList403() { + val params = HrisDirectoryListParams.builder().limit(123L).offset(123L).build() stubFor( get(anyUrl()) .willReturn(status(403).withHeader("Foo", "Bar").withBody(toJson(FINCH_ERROR))) ) - assertThatThrownBy({ client.hris().directory().listIndividuals(params) }) + assertThatThrownBy({ client.hris().directory().list(params) }) .satisfies({ e -> assertPermissionDenied(e, ImmutableListMultimap.of("Foo", "Bar"), FINCH_ERROR) }) } @Test - fun directoryListIndividuals404() { - val params = HrisDirectoryListIndividualsParams.builder().limit(123L).offset(123L).build() + fun directoryList404() { + val params = HrisDirectoryListParams.builder().limit(123L).offset(123L).build() stubFor( get(anyUrl()) .willReturn(status(404).withHeader("Foo", "Bar").withBody(toJson(FINCH_ERROR))) ) - assertThatThrownBy({ client.hris().directory().listIndividuals(params) }) + assertThatThrownBy({ client.hris().directory().list(params) }) .satisfies({ e -> assertNotFound(e, ImmutableListMultimap.of("Foo", "Bar"), FINCH_ERROR) }) } @Test - fun directoryListIndividuals422() { - val params = HrisDirectoryListIndividualsParams.builder().limit(123L).offset(123L).build() + fun directoryList422() { + val params = HrisDirectoryListParams.builder().limit(123L).offset(123L).build() stubFor( get(anyUrl()) .willReturn(status(422).withHeader("Foo", "Bar").withBody(toJson(FINCH_ERROR))) ) - assertThatThrownBy({ client.hris().directory().listIndividuals(params) }) + assertThatThrownBy({ client.hris().directory().list(params) }) .satisfies({ e -> assertUnprocessableEntity(e, ImmutableListMultimap.of("Foo", "Bar"), FINCH_ERROR) }) } @Test - fun directoryListIndividuals429() { - val params = HrisDirectoryListIndividualsParams.builder().limit(123L).offset(123L).build() + fun directoryList429() { + val params = HrisDirectoryListParams.builder().limit(123L).offset(123L).build() stubFor( get(anyUrl()) .willReturn(status(429).withHeader("Foo", "Bar").withBody(toJson(FINCH_ERROR))) ) - assertThatThrownBy({ client.hris().directory().listIndividuals(params) }) + assertThatThrownBy({ client.hris().directory().list(params) }) .satisfies({ e -> assertRateLimit(e, ImmutableListMultimap.of("Foo", "Bar"), FINCH_ERROR) }) } @Test - fun directoryListIndividuals500() { - val params = HrisDirectoryListIndividualsParams.builder().limit(123L).offset(123L).build() + fun directoryList500() { + val params = HrisDirectoryListParams.builder().limit(123L).offset(123L).build() stubFor( get(anyUrl()) .willReturn(status(500).withHeader("Foo", "Bar").withBody(toJson(FINCH_ERROR))) ) - assertThatThrownBy({ client.hris().directory().listIndividuals(params) }) + assertThatThrownBy({ client.hris().directory().list(params) }) .satisfies({ e -> assertInternalServer(e, ImmutableListMultimap.of("Foo", "Bar"), FINCH_ERROR) }) @@ -209,14 +208,14 @@ class ErrorHandlingTest { @Test fun unexpectedStatusCode() { - val params = HrisDirectoryListIndividualsParams.builder().limit(123L).offset(123L).build() + val params = HrisDirectoryListParams.builder().limit(123L).offset(123L).build() stubFor( get(anyUrl()) .willReturn(status(999).withHeader("Foo", "Bar").withBody(toJson(FINCH_ERROR))) ) - assertThatThrownBy({ client.hris().directory().listIndividuals(params) }) + assertThatThrownBy({ client.hris().directory().list(params) }) .satisfies({ e -> assertUnexpectedStatusCodeException( e, @@ -229,11 +228,11 @@ class ErrorHandlingTest { @Test fun invalidBody() { - val params = HrisDirectoryListIndividualsParams.builder().limit(123L).offset(123L).build() + val params = HrisDirectoryListParams.builder().limit(123L).offset(123L).build() stubFor(get(anyUrl()).willReturn(status(200).withBody("Not JSON"))) - assertThatThrownBy({ client.hris().directory().listIndividuals(params) }) + assertThatThrownBy({ client.hris().directory().list(params) }) .satisfies({ e -> assertThat(e) .isInstanceOf(FinchException::class.java) @@ -243,11 +242,11 @@ class ErrorHandlingTest { @Test fun invalidErrorBody() { - val params = HrisDirectoryListIndividualsParams.builder().limit(123L).offset(123L).build() + val params = HrisDirectoryListParams.builder().limit(123L).offset(123L).build() stubFor(get(anyUrl()).willReturn(status(400).withBody("Not JSON"))) - assertThatThrownBy({ client.hris().directory().listIndividuals(params) }) + assertThatThrownBy({ client.hris().directory().list(params) }) .satisfies({ e -> assertBadRequest(e, ImmutableListMultimap.of(), FinchError.builder().build()) }) diff --git a/finch-java-core/src/test/kotlin/com/tryfinch/api/services/ServiceParamsTest.kt b/finch-java-core/src/test/kotlin/com/tryfinch/api/services/ServiceParamsTest.kt index 4b8ca84a..b023c779 100644 --- a/finch-java-core/src/test/kotlin/com/tryfinch/api/services/ServiceParamsTest.kt +++ b/finch-java-core/src/test/kotlin/com/tryfinch/api/services/ServiceParamsTest.kt @@ -16,8 +16,8 @@ import com.tryfinch.api.client.FinchClient import com.tryfinch.api.client.okhttp.FinchOkHttpClient import com.tryfinch.api.core.jsonMapper import com.tryfinch.api.models.* -import com.tryfinch.api.models.HrisDirectoryListIndividualsPage -import com.tryfinch.api.models.HrisDirectoryListIndividualsParams +import com.tryfinch.api.models.HrisDirectoryListPage +import com.tryfinch.api.models.HrisDirectoryListParams import org.junit.jupiter.api.BeforeEach import org.junit.jupiter.api.Test @@ -43,7 +43,7 @@ class ServiceParamsTest { } @Test - fun hrisDirectoryListIndividualsWithAdditionalParams() { + fun hrisDirectoryListWithAdditionalParams() { val additionalHeaders = mutableMapOf>() additionalHeaders.put("x-test-header", listOf("abc1234")) @@ -53,7 +53,7 @@ class ServiceParamsTest { additionalQueryParams.put("test_query_param", listOf("def567")) val params = - HrisDirectoryListIndividualsParams.builder() + HrisDirectoryListParams.builder() .limit(123L) .offset(123L) .additionalHeaders(additionalHeaders) @@ -61,7 +61,7 @@ class ServiceParamsTest { .build() val apiResponse = - HrisDirectoryListIndividualsPage.Response.builder() + HrisDirectoryListPage.Response.builder() .individuals( listOf( IndividualInDirectory.builder() @@ -91,7 +91,7 @@ class ServiceParamsTest { .willReturn(ok(JSON_MAPPER.writeValueAsString(apiResponse))) ) - client.hris().directory().listIndividuals(params) + client.hris().directory().list(params) verify(getRequestedFor(anyUrl())) } diff --git a/finch-java-core/src/test/kotlin/com/tryfinch/api/services/blocking/hris/DirectoryServiceTest.kt b/finch-java-core/src/test/kotlin/com/tryfinch/api/services/blocking/hris/DirectoryServiceTest.kt index caa14082..a056129d 100644 --- a/finch-java-core/src/test/kotlin/com/tryfinch/api/services/blocking/hris/DirectoryServiceTest.kt +++ b/finch-java-core/src/test/kotlin/com/tryfinch/api/services/blocking/hris/DirectoryServiceTest.kt @@ -6,12 +6,26 @@ import com.tryfinch.api.TestServerExtension import com.tryfinch.api.client.okhttp.FinchOkHttpClient import com.tryfinch.api.models.* import com.tryfinch.api.models.HrisDirectoryListIndividualsParams +import com.tryfinch.api.models.HrisDirectoryListParams import org.junit.jupiter.api.Test import org.junit.jupiter.api.extension.ExtendWith @ExtendWith(TestServerExtension::class) class DirectoryServiceTest { + @Test + fun callList() { + val client = + FinchOkHttpClient.builder() + .baseUrl(TestServerExtension.BASE_URL) + .accessToken("test-api-key") + .build() + val directoryService = client.hris().directory() + val getDirectoryResponse = directoryService.list(HrisDirectoryListParams.builder().build()) + println(getDirectoryResponse) + getDirectoryResponse.individuals().forEach { it.validate() } + } + @Test fun callListIndividuals() { val client = @@ -20,6 +34,7 @@ class DirectoryServiceTest { .accessToken("test-api-key") .build() val directoryService = client.hris().directory() + @Suppress("DEPRECATION") val getDirectoryResponse = directoryService.listIndividuals(HrisDirectoryListIndividualsParams.builder().build()) println(getDirectoryResponse)