Set up the APIMatic CLI. Generate SDKs and API Developer Portals right from your command line.
Validate your API definitions against 1000+ validation and lint rules and auto-fix violations using this free VS Code Extension.
Learn how API definitions can be converted into any of the 15 supported API specification formats via GUI or APIMatic API.
| Value | Change |
true |
``` csharp
public ApiResponse |
false (default) |
``` csharp public Models.ServerResponse GetData() ``` |
| Value | Change |
true |
``` java
public ApiResponse |
false (default) |
``` java public ServerResponse getData() ``` |
| Value | Change |
true |
``` php public function getData(): ApiResponse ``` |
false (default) |
``` php public function getData(): ServerResponse ``` |
| Value | Change |
true |
``` python def get_data(): """ Returns: ApiResponse: An object with the response value as well as other useful information such as status codes and headers. """ ``` |
false (default) |
``` python def get_data(): """ Returns: ServerResponse: Response from the API. """ ``` |
| Value | Change |
true |
``` ruby # @return [ApiResponse] response instance that also includes other useful information such as status codes and headers. def get_data() ``` |
false (default) |
``` ruby # @return [ServerResponse] response from the API call def get_data() ``` |
| Value | Change |
true |
```csharp try { dynamic result = await echoController.CreateJsonEchoAsync(input); } catch (ApiException e){}; ``` |
false (default) |
```csharp try { dynamic result = await echoController.JsonEchoAsync(input); } catch (ApiException e){}; ``` |
| Value | Change |
true |
```java // highlight-next-line echoController.createJsonEchoAsync(input).thenAccept(result -> { // TODO success callback handler }).exceptionally(exception -> { // TODO failure callback handler return null; }); ``` |
false (default) |
```java // highlight-next-line echoController.jsonEchoAsync(input).thenAccept(result -> { // TODO success callback handler }).exceptionally(exception -> { // TODO failure callback handler return null; }); ``` |
| Value | Change |
true |
```php $result = $mEchoController->createJsonEcho($input); ``` |
false (default) |
```php $result = $mEchoController->jsonEcho($input); ``` |
| Value | Change |
true |
```python result = echo_controller.create_json_echo(input) ``` |
false (default) |
```python result = echo_controller.json_echo(input) ``` |
| Value | Change |
true |
```ruby result = echo_controller.create_json_echo(input) ``` |
false (default) |
```ruby result = echo_controller.json_echo(input) ``` |
| Value | Change |
true |
```ts const { result, ...httpResponse } = await echoController.createJsonEcho(input); ``` |
false (default) |
```ts const { result, ...httpResponse } = await echoController.jsonEcho(input); ``` |
| Value | Change |
true |
```go apiResponse, err := EchoController.CreateJsonEcho(input) ``` |
false (default) |
```go apiResponse, err := EchoController.JsonEcho(input) ``` |
| Value | Change |
true |
 |
false (default) |
 |
| Value | Change |
true |
```csharp public Models.ServerResponse PostData(Models.PostDataInput input) ``` |
false (default) |
```csharp public Models.ServerResponse PostData(bool unSet, bool setToNull, string field, Models.MyData data) ``` |
| Value | Change |
true |
```java public ServerResponse postData(final PostDataInput input) ``` |
false (default) |
```java public ServerResponse postData(final bool unSet, final bool setToNull, final string field, final MyData data) ``` |
| Value | Change |
true |
```php public function postData(array $options): ServerResponse ``` |
false (default) |
```php public function postData(bool $mUnSet, bool $setToNull, string $field, MyData $data): ServerResponse ``` |
| Value | Change |
true |
```python def post_data(self, options=dict()) ``` |
false (default) |
```python def post_data(self, un_set, set_to_null, field, data) ``` |
| Value | Change |
true |
```ruby def post_data(options = {}) ``` |
false (default) |
```ruby def post_data(un_set, set_to_null, field, data) ``` |
| Value | Change |
true |
```ts
async postData({
unSet,
setToNull,
field,
data,
}: {
unSet: boolean,
setToNull: boolean,
field: string,
data: MyData,
},
requestOptions?: RequestOptions
): Promise |
false (default) |
```ts
async postData(
unSet: boolean,
setToNull: boolean,
field: string,
data: MyData,
requestOptions?: RequestOptions
): Promise |
| Value | Change |
true |
```go type SendNumberInput struct { Number int Number1 *int } func (q *NumbersController) SendNumber( ctx context.Context, input SendNumberInput) ( models.ApiResponse[models.ServerResponse], error) ``` |
false (default) |
```go func (q *NumbersController) SendNumber( ctx context.Context, number int, number1 *int) ( models.ApiResponse[models.ServerResponse], error) ``` |
| Value | Change |
true |
 |
false (default) |
 |
| Value | Change |
true |
```ruby result = echo_controller.json_echo(input: input) ``` |
false (default) |
```ruby result = echo_controller.json_echo(input) ``` |
| Value | Change |
true |
```php $apiResponse = $client->getPaymentsApi()->getTransactions(); if ($apiResponse->isError()) { $error = $apiResponse->getResult(); if ($error instanceof CustomAlphaException) { echo "CustomAlphaException: $error"; } elseif ($error instanceof CustomBetaException) { echo "CustomBetaException: $error"; } } ``` |
false (default) |
```php $apiResponse = $client->getPaymentsApi()->getTransactions(); if ($apiResponse->isError()) { $error = $apiResponse->getResult(); echo "Untyped raw response body: $error"; } ``` |
| Value | Change |
true |
```csharp StudentResult body = new StudentResult { Email = "student616@oxford.ac.uk", ["Theory Of Automata"] = 82.1, ["Computational complexity"] = 72.5, ["Functional programming"] = 78.3, }; ``` |
false (default) |
```csharp StudentResult body = new StudentResult { Email = "student616@oxford.ac.uk", }; ``` |
| Value | Change |
true |
```java StudentResult body = new StudentResult.Builder( "student616@oxford.ac.uk" ) .additionalProperty("Theory Of Automata", 82.1D) .additionalProperty("Computational complexity", 72.5D) .additionalProperty("Functional programming", 78.3D) .build(); ``` |
false (default) |
```java StudentResult body = new StudentResult.Builder( "student616@oxford.ac.uk" ) .build(); ``` |
| Value | Change |
true |
```php $body = StudentResultBuilder::init( 'student616@oxford.ac.uk' ) ->additionalProperty('Theory Of Automata', 82.1) ->additionalProperty('Computational complexity', 72.5) ->additionalProperty('Functional programming', 78.3) ->build(); ``` |
false (default) |
```php $body = StudentResultBuilder::init( 'student616@oxford.ac.uk' )->build(); ``` |
| Value | Change |
true |
```python body = StudentResult( email='student616@oxford.ac.uk', additional_properties={ 'Theory Of Automata': 82.1, 'Computational complexity': 72.5, 'Functional programming': 78.3 } ) ``` |
false (default) |
```python body = StudentResult( email='student616@oxford.ac.uk' ) ``` |
| Value | Change |
true |
```ruby body = StudentResult.new( 'student616@oxford.ac.uk', { 'Theory Of Automata': 82.1, 'Computational complexity': 72.5, 'Functional programming': 78.3 } ) ``` |
false (default) |
```ruby body = StudentResult.new( 'student616@oxford.ac.uk' ) ``` |
| Value | Change |
true |
```ts const body: StudentResult = { email: 'student616@oxford.ac.uk', additionalProperties: { 'Theory Of Automata': 82.1, 'Computational complexity': 72.5, 'Functional programming': 78.3 }, }; ``` |
false (default) |
```ts const body: StudentResult = { email: 'student616@oxford.ac.uk', }; ``` |
| Value | Change |
true |
```go body := models.StudentResult{ Email: "student616@oxford.ac.uk", AdditionalProperties: map[string]float64{ "Theory Of Automata": float64(82.1), "Computational complexity": float64(72.5), "Functional programming": float64(78.3), }, } ``` |
false (default) |
```go body := models.StudentResult{ Email: "student616@oxford.ac.uk", } ``` |
| Value | Change |
true |
```csharp PersonModel result = await responseTypesController.GetModelAsync(); ``` |
false (default) |
```csharp Person result = await responseTypesController.GetModelAsync(); ``` |
| Value | Change |
true |
```java
CompletableFuture |
false (default) |
```java
CompletableFuture |
| Value | Change |
true |
```php function sendDeleteBody(DeleteBodyModel $body): ServerResponseModel ``` |
false (default) |
```php function sendDeleteBody(DeleteBody $body): ServerResponse ``` |
| Value | Change |
true |
```python from tester.models.person import PersonModel ``` |
false (default) |
```python from tester.models.person import Person ``` |
| Value | Change |
true |
```ruby body = DeleteBodyModel.from_hash(APIHelper.json_deserialize( '{"name":" ","field":"QA"}', false)) ``` |
false (default) |
```ruby body = DeleteBody.from_hash(APIHelper.json_deserialize( '{"name":" ","field":"QA"}', false)) ``` |
| Value | Change |
true |
```ts
async queryEcho(
queryParameters?: Record |
false (default) |
```ts
async queryEcho(
queryParameters?: Record |
| Value | Change |
true |
```ruby class User def initialize(name:, email:) @name = name @email = email end end user = User.new(email: "bob@example.com", name: "Bob") ``` |
false (default) |
```ruby class User def initialize(name, email) @name = name @email = email end end user = User.new("Alice", "alice@example.com") ``` |
| Value | Change |
true |
```csharp
public class User
{
/// |
false (default) |
```csharp
public class User
{
/// |
| Value | Change |
true (default) |
```csharp
public Models.ServerResponse PostStringEnumArray(
List |
false |
```csharp
public Models.ServerResponse PostStringEnumArray(List |
| Value | Change |
true (default) |
```java
public ServerResponse postStringEnumArray(final List |
false |
```java
public ServerResponse postStringEnumArray(final List |
| Value | Change |
true (default) |
```python days = [ Days.SUNDAY, Days.MONDAY, Days.TUESDAY ] result = body_params_controller.send_string_enum_array(days) ``` |
false |
```python days = [ 'Sunday', 'Monday', 'Tuesday' ] result = body_params_controller.send_string_enum_array(days) ``` |
| Value | Change |
true (default) |
```typescript
async postStringEnumArray(days: Days[], requestOptions?: RequestOptions): Promise |
false |
```typescript
async postStringEnumArray(days: string[], requestOptions?: RequestOptions): Promise |
| Value | Change |
true (default) |
``` csharp
// highlight-start
var suites = new List |
false |
``` csharp
// highlight-start
var suites = new List |
| Value | Change |
true (default) |
``` java
// highlight-start
List |
false |
``` java
// highlight-start
List |
| Value | Change |
true (default) |
``` php // highlight-next-line $suites = [Models\SuiteCodeEnum::HEARTS]; $result = $queryParamController->integerEnumArray($suites); ``` |
false |
``` php // highlight-next-line $suites = [Models\SuiteCode::HEARTS]; $result = $queryParamController->integerEnumArray($suites); ``` |
| Value | Change |
true (default) |
```python #highlight-next-line suites = [SuiteCodeEnum.HEARTS] result = query_param_controller.integer_enum_array(suites) ``` |
false |
```python #highlight-next-line suites = [SuiteCode.HEARTS] result = query_param_controller.integer_enum_array(suites) ``` |
| Value | Change |
true (default) |
```ruby // highlight-next-line suites = [SuiteCodeEnum::HEARTS] result = query_param_controller.integer_enum_array(suites) ``` |
false |
```ruby // highlight-next-line suites = [SuiteCode::HEARTS] result = query_param_controller.integer_enum_array(suites) ``` |
| Value | Change |
true (default) |
``` typescript const modelWorkingDays: DaysEnum[] = ['Thursday', 'Wednesday', 'Tuesday']; ``` |
false |
``` typescript const modelWorkingDays: Days[] = ['Thursday', 'Wednesday', 'Tuesday']; ``` |
| Value | Change |
true (default) |
``` go days := []models.DaysEnum{ "Tuesday", "Saturday", "Wednesday" } ``` |
false |
``` go days := []models.Days{ "Tuesday", "Saturday", "Wednesday" } ``` |
| Value | Change |
true (default) |
```curl curl -X GET -G \ --url 'http://localhost:3000/response/date' \ // highlight-next-line -H 'Accept: application/json' \ -d 'array=true' ``` |
false |
```curl curl -X GET -G \ --url 'http://localhost:3000/response/date' \ -d 'array=true' ``` |
| Value | Change |
| Default | ``` csharp // highlight-start Tester.Standard.TesterClient client = new Tester.Standard.TesterClient.Builder() .Environment(Tester.Standard.Environment.Testing) // highlight-end .Port("80") .Suites(SuiteCodeEnum.Hearts) .Build(); ``` |
| Configured | ``` csharp // highlight-start MyProject.Standard.MyProjectClient client = new MyProject.Standard.MyProjectClient.Builder() .Environment(MyProject.Standard.Environment.Testing) // highlight-end .Port("80") .Suites(SuiteCodeEnum.Hearts) .Build(); ``` |
| Value | Change |
| Default | ``` java // highlight-next-line TesterClient client = new TesterClient.Builder() .httpClientConfig(configBuilder -> configBuilder .timeout(0)) .environment(Environment.TESTING) ``` |
| Configured | ``` java // highlight-next-line MyProjectClient client = new MyProjectClient.Builder() .httpClientConfig(configBuilder -> configBuilder .timeout(0)) .environment(Environment.TESTING) ``` |
| Value | Change |
| Default | ``` php // highlight-next-line $client = TesterLib\TesterClientBuilder::init() ->environment('testing') ->port('80') ->suites(Models\SuiteCodeEnum::HEARTS) ``` |
| Configured | ``` php // highlight-next-line $client = MyProjectLib\MyProjectClientBuilder::init() ->environment('testing') ->port('80') ->suites(Models\SuiteCodeEnum::HEARTS); ``` |
| Value | Change |
| Default | ```python #highlight-start from tester.tester_client import TesterClient from tester.configuration import Environment client = TesterClient( # highlight-end environment=Environment.TESTING, port = '80', suites = SuiteCodeEnum.HEARTS,) ``` |
| Configured | ```python #highlight-start from myproject.my_project_client import MyProjectClient from myproject.configuration import Environment client = MyProjectClient( #highlight-end environment=Environment.TESTING, port = '80', suites = SuiteCodeEnum.HEARTS,) ``` |
| Value | Change |
| Default | ``` ruby // highlight-next-line client = Tester::Client.new( environment: Environment::TESTING, port: '80', suites: SuiteCodeEnum::HEARTS, ) ``` |
| Configured | ``` ruby // highlight-next-line client = MyProject::Client.new( environment: Environment::TESTING, port: '80', suites: SuiteCodeEnum::HEARTS, ) ``` |
| Value | Change |
| Default | ``` go // highlight-next-line config := tester.ConfigurationFactory( tester.WithEnvironment("testing"), tester.WithPort("3000"), tester.WithSuites(4), ) client := tester.NewClient(config) ``` |
| Configured | ``` go // highlight-next-line config := myproject.ConfigurationFactory( myproject.WithEnvironment("testing"), myproject.WithPort("3000"), myproject.WithSuites(4), ) client := myproject.NewClient(config) ``` |
| Value | Change |
| Default | ``` csharp // highlight-next-line Tester.Standard.TesterClient client = new Tester.Standard.TesterClient.Builder() .Environment(Tester.Standard.Environment.Testing) .Port("80") .Suites(SuiteCodeEnum.Hearts) .Build(); ``` |
| Configured | ``` csharp // highlight-next-line OrgNamespace.TesterClient client = new Root.TesterClient.Builder() .Environment(Root.Environment.Testing) .Port("80") .Suites(SuiteCodeEnum.Hearts) .Build(); ``` |
| Value | Change |
| Default | ```java Object input = localhost3000.ApiHelper.deserialize("{\"key1\":\"val1\",\"key2\":\"val2\"}"); ``` |
| Configured | ```java Object input = Root.ApiHelper.deserialize("{\"key1\":\"val1\",\"key2\":\"val2\"}"); ``` |
| Value | Change |
| Default | ``` php // highlight-next-line $client = TesterLib\TesterClientBuilder::init() ->environment('testing') ->build(); ``` |
| Configured | ``` php // highlight-next-line $client = Apimatic\TesterClientBuilder::init() ->environment('testing') ->build(); ``` |
| Value | Change |
true (default) |
``` csharp try { // highlight-next-line await responseTypesController.GetContentTypeHeadersAsync(); } catch (ApiException e){}; ``` |
false |
``` csharp try { // highlight-next-line await responseTypes.GetContentTypeHeadersAsync(); } catch (ApiException e){}; ``` |
| Value | Change |
true (default) |
``` java // highlight-next-line responseTypesController.getContentTypeHeadersAsync().thenAccept(result -> { // TODO success callback handler }).exceptionally(exception -> { // TODO failure callback handler return null; }); ``` |
false |
``` java // highlight-next-line responseTypes.getContentTypeHeadersAsync().thenAccept(result -> { // TODO success callback handler }).exceptionally(exception -> { // TODO failure callback handler return null; }); ``` |
| Value | Change |
true (default) |
``` php $responseTypesController->getContentTypeHeaders(); ``` |
false |
``` php $responseTypes->getContentTypeHeaders(); ``` |
| Value | Change |
true (default) |
``` python result = response_types_controller.get_content_type_headers() print(result) ``` |
false |
``` python result = response_types.get_content_type_headers() print(result) ``` |
| Value | Change |
true (default) |
``` ruby response_types_controller.get_content_type_headers ``` |
false |
``` ruby response_types.get_content_type_headers ``` |
| Value | Change |
true (default) |
``` ts const { result, ...httpResponse } = await responseTypesController.getContentTypeHeaders(); ``` |
false |
``` ts const { result, ...httpResponse } = await responseTypes.getContentTypeHeaders(); ``` |
| Value | Change |
true (default) |
``` go resp, err := ResponseTypesController.GetContentTypeHeaders() ``` |
false |
``` go resp, err := ResponseTypes.GetContentTypeHeaders() ``` |
| Value | Change |
| Default | ``` csharp dynamic result = await echoController.JsonEchoAsync(input); ``` |
| Configured | ``` csharp dynamic result = await echoApi.JsonEchoAsync(input); ``` |
| Value | Change |
| Default | ``` java // highlight-next-line echoController.jsonEchoAsync(input).thenAccept(result -> { // TODO success callback handler }).exceptionally(exception -> { // TODO failure callback handler return null; }); ``` |
| Configured | ``` java // highlight-next-line echoApi.jsonEchoAsync(input).thenAccept(result -> { // TODO success callback handler }).exceptionally(exception -> { // TODO failure callback handler return null; }); ``` |
| Value | Change |
| Default | ``` php $result = $mEchoController->jsonEcho($input); ``` |
| Configured | ``` php $result = $mEchoApi->jsonEcho($input); ``` |
| Value | Change |
| Default | ``` python result = echo_controller.json_echo(input) ``` |
| Configured | ``` python result = echo_api.json_echo(input) ``` |
| Value | Change |
| Default | ``` ruby result = echo_controller.json_echo(input) ``` |
| Configured | ``` ruby result = echo_api.json_echo(input) ``` |
| Value | Change |
| Default | ``` ts const { result, ...httpResponse } = await echoController.jsonEcho(input); ``` |
| Configured | ``` ts const { result, ...httpResponse } = await echoApi.jsonEcho(input); ``` |
| Value | Change |
| Default | ``` go apiResponse, err := EchoController.JsonEcho(input) ``` |
| Configured | ``` go apiResponse, err := EchoApi.JsonEcho(input) ``` |
| Value | Change |
true |
```csharp IBodyParamsController bodyParamsController = client.BodyParamsController; ``` |
false (default) |
```csharp BodyParamsController bodyParamsController = client.BodyParamsController; ``` |
| Value | Change |
true |
```csharp public final class TesterClient implements TesterClientInterface { responseTypes = new DefaultResponseTypesController(globalConfig); formParams = new DefaultFormParamsController(globalConfig); bodyParams = new DefaultBodyParamsController(globalConfig); errorCodes = new DefaultErrorCodesController(globalConfig); } ``` |
false (default) |
```java public final class TesterClient implements Configuration { responseTypes = new ResponseTypesController(globalConfig); formParams = new FormParamsController(globalConfig); bodyParams = new BodyParamsController(globalConfig); errorCodes = new ErrorCodesController(globalConfig); } ``` |
| Value | Change |
| Default | ```python #highlight-next-line from tester.tester_client import TesterClient from tester.configuration import Environment #highlight-next-line client = TesterClient( environment=Environment.TESTING, port = '80', suites = SuiteCodeEnum.HEARTS,) ``` |
| Configured | ```python #highlight-next-line from tester.interface import Interface from tester.configuration import Environment #highlight-next-line client = Interface( environment=Environment.TESTING, port = '80', suites = SuiteCodeEnum.HEARTS,) ``` |
| Value | Change |
true |
``` csharp SdkClient client = new SdkClient.Builder() .CcgAuth( new CcgAuthModel.Builder( "clientId", "clientSecret" ).Build()) .Build(); ``` |
false (default) |
``` csharp SdkClient client = new SdkClient.Builder() .ClientCredentialsAuth( new ClientCredentialsAuthModel.Builder( "clientId", "clientSecret" ).Build()) .Build(); ``` |
| Value | Change |
true |
``` java SDKClient client = new SDKClient.Builder() .ccgAuth(new CcgAuthModel.Builder( "clientId", "clientSecret" ) .build()) .build(); ``` |
false (default) |
``` java SDKClient client = new SDKClient.Builder() .clientCredentialsAuth(new ClientCredentialsAuthModel.Builder( "clientId", "clientSecret" ) .build()) .build(); ``` |
| Value | Change |
true |
``` php $client = SDKClientBuilder::init() ->ccgAuthCredentials( CcgAuthCredentialsBuilder::init( 'clientId', 'clientSecret' ) ) ->build(); ``` |
false (default) |
``` php $client = SDKClientBuilder::init() ->clientCredentialsAuthCredentials( ClientCredentialsAuthCredentialsBuilder::init( 'clientId', 'clientSecret' ) ) ->build(); ``` |
| Value | Change |
true |
``` python client = SDKClient( ccg_auth_credentials=CcgAuthCredentials( o_auth_client_id='clientId', o_auth_client_secret='clientSecret' ) ) ``` |
false (default) |
``` python client = SDKClient( client_credentials_auth_credentials=ClientCredentialsAuthCredentials( o_auth_client_id='clientId', o_auth_client_secret='clientSecret' ) ) ``` |
| Value | Change |
true |
``` ruby client = SDKClient.new( ccg_auth_credentials: CcgAuthCredentials.new( o_auth_client_id: 'clientId', o_auth_client_secret: 'clientSecret' ) ) ``` |
false (default) |
``` ruby client = SDKClient.new( client_credentials_auth_credentials: ClientCredentialsAuthCredentials.new( o_auth_client_id: 'clientId', o_auth_client_secret: 'clientSecret' ) ) ``` |
| Value | Change |
true |
``` ts const client = new SDKClient({ ccgAuthCredentials: { oAuthClientId: 'OAuthClientId', oAuthClientSecret: 'OAuthClientSecret', }, }); ``` |
false (default) |
``` ts const client = new SDKClient({ clientCredentialsAuthCredentials: { oAuthClientId: 'OAuthClientId', oAuthClientSecret: 'OAuthClientSecret', }, }); ``` |
| Value | Change |
true |
``` go client := sdkclient.NewClient( sdkclient.CreateConfiguration( sdkclient.WithCcgAuthCredentials( sdkclient.NewCcgAuthCredentials( "clientId", "clientSecret", ), ), ), ) ``` |
false (default) |
``` go client := sdkclient.NewClient( sdkclient.CreateConfiguration( sdkclient.WithClientCredentialsAuthCredentials( sdkclient.NewClientCredentialsAuthCredentials( "clientId", "clientSecret", ), ), ), ) ``` |
| Value | Change |
| Default | ```csharp public Models.Pet GetPetById(long petId) ``` |
| Configured | ```csharp public Models.Pet GetPetById(long petid) ``` |
| Value | Change |
| Default | ```java public Pet getPetById(final long petId) ``` |
| Configured | ```java public Pet getPetById(final long petid) ``` |
| Value | Change |
| Default | ```php public function getPetById(int $petId): Pet ``` |
| Configured | ```php public function getPetById(int $petid): Pet ``` |
| Value | Change |
| Default | ```python def get_pet_by_id(self, pet_id) ``` |
| Configured | ```python def get_pet_by_id(self, petid) ``` |
| Value | Change |
| Default | ```ruby def get_pet_by_id(pet_id) ``` |
| Configured | ```ruby def get_pet_by_id(petid) ``` |
| Value | Change |
| Default |
```typescript
async getPetById(
petId: bigint,
requestOptions?: RequestOptions
): Promise |
| Configured |
```typescript
async getPetById(
petid: bigint,
requestOptions?: RequestOptions
): Promise |
| Value | Change |
| Default | ```go func (p *PetController) GetPetById(petId int64) ( https.ApiResponse[models.Pet], error) ``` |
| Configured | ```go func (p *PetController) GetPetById(petid int64) ( https.ApiResponse[models.Pet], error) ``` |
| Value | Change |
Asynchronous (default) |
``` csharp EmployeeComp result = await responseTypesController.ReturnEmployeeModelAsync(); ``` |
Synchronous |
``` csharp EmployeeComp result = responseTypesController.ReturnEmployeeModel(); ``` |
| Value | Change |
Asynchronous (default) |
``` java responseTypesController.returnEmployeeModelAsync().thenAccept(result -> { // TODO success callback handler System.out.println(result); }).exceptionally(exception -> { // TODO failure callback handler exception.printStackTrace(); return null; }); ``` |
Synchronous (default) |
``` java try { EmployeeComp result = responseTypesController.returnEmployeeModel(); System.out.println(result); } catch (ApiException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } ``` |
| Value | Change |
true |
``` csharp SdkClient client = new SdkClient.Builder() .LoggingConfig(config => config .LogLevel(LogLevel.Information) .RequestConfig(reqConfig => reqConfig .Body(true) .IncludeHeaders("Content-Type", "Content-Encoding")) .ResponseConfig(respConfig => respConfig .Headers(true) .ExcludeHeaders("X-Powered-By")) ) .Build(); ``` |
false (default) |
``` csharp SdkClient client = new SdkClient.Builder() .Build(); ``` |
| Value | Change |
true |
``` java SDKClient client = new SDKClient.Builder() .loggingConfig(builder -> builder .level(Level.DEBUG) .requestConfig(reqConfig -> reqConfig .body(true) .includeHeaders("Content-Type", "Content-Encoding")) .responseConfig(resConfig -> resConfig .headers(true) .excludeHeaders("X-Powered-By"))) .build(); ``` |
false (default) |
``` java SDKClient client = new SDKClient.Builder() .build(); ``` |
| Value | Change |
true |
``` php $client = SdkClientBuilder::init() ->loggingConfiguration( LoggingConfigurationBuilder::init() ->level(LogLevel::INFO) ->requestConfiguration( RequestLoggingConfigurationBuilder::init() ->body(true) ->includeHeaders('Content-Type', 'Content-Encoding') ) ->responseConfiguration( ResponseLoggingConfigurationBuilder::init() ->headers(true) ->excludeHeaders('X-Powered-By') ) ) ->build(); ``` |
false (default) |
``` php $client = SdkClientBuilder::init() ->build(); ``` |
| Value | Change |
true |
``` python client = SDKClient( logging_configuration=LoggingConfiguration( log_level=logging.INFO, request_logging_config=RequestLoggingConfiguration( log_body=True, headers_to_include=['Content-Type', 'Content-Encoding'] ), response_logging_config=ResponseLoggingConfiguration( log_headers=True, headers_to_exclude=['X-Powered-By'] ) ) ) ``` |
false (default) |
``` python client = SDKClient() ``` |
| Value | Change |
true |
``` ruby client = SDKClient.new( logging_configuration: LoggingConfiguration.new( log_level: Logger::INFO, request_logging_config: RequestLoggingConfiguration.new( log_body: true, headers_to_include: %w[Content-Type Content-Encoding] ), response_logging_config: ResponseLoggingConfiguration.new( log_headers: true, headers_to_exclude: ['X-Powered-By'] ) ) ) ``` |
false (default) |
``` ruby client = SDKClient.new ``` |
| Value | Change |
true |
``` ts const client = new SDKClient({ logging: { logLevel: LogLevel.Debug, logRequest: { logBody: true, headersToInclude: ["Content-Type", "Content-Encoding"] }, logResponse: { logHeaders: true, headersToExclude: ["X-Powered-By"] } } }); ``` |
false (default) |
``` ts const client = new SDKClient(); ``` |
| Value | Change |
true |
``` go config := CreateConfigurationFromEnvironment( WithLoggerConfiguration( WithLevel("info"), WithRequestConfiguration( WithRequestBody(true), WithIncludeRequestHeaders("Content-Type", "Content-Encoding"), ), WithResponseConfiguration( WithResponseHeaders(true), WithExcludeResponseHeaders("X-Powered-By"), ), ), ) client := NewClient(config) ``` |
false (default) |
``` go config := CreateConfigurationFromEnvironment() client := NewClient(config) ``` |
| character. For example, variableName=value1|value2 assigns the values `value1` and `value2` to the `variableName` variable. |
#### Usage
To use this feature, you need to specify an `ArraySerialization` value. By default, its value is set to `Indexed`.
```json
"info": {
...,
"x-codegen-settings": {
"ArraySerialization": "Indexed"
}
}
```
#### Language Support
| C# | Java | PHP | Python | Ruby | TS | Go |
| ------------------ | ------------------ | ------------------ | ------------------ | ------------------ | ------------------ | ------------------ |
| :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: |
## Enable JSON Pass Through for Any
Use this setting to decide whether JSON should be passed through any type in the SDK.
#### Usage
To use this feature, you need to specify a `Boolean` value. By default, its value is set to `false`.
```json
"info": {
...,
"x-codegen-settings": {
"EnableJsonPassThroughForAny": false
}
}
```
#### Language Support
| C# | Java | PHP | Python | Ruby | TS | Go |
| ------------------ | ------------------ | ------------------ | ------------------ | ------------------ | ------------------ | ------------------ |
| :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :x: |
#### Change in SDK
Configuring this setting has the following effect on the generated SDK:
| Value | Change |
true |
```csharp JsonObject body = JsonObject.FromJsonString("{\"key1\":\"val1\",\"key2\":\"val2\"}"); ServerResponse result = await controller.SendSchemaasBodyAsync(body); ``` |
false (default) |
```csharp object body = ApiHelper.JsonDeserialize |
| Value | Change |
true |
```java JsonObject body = JsonObject.fromJsonString("{\"key1\":\"val1\",\"key2\":\"val2\"}"); jsonObjController.sendSchemaasBodyAsync(body).thenAccept(result -> { // TODO success callback handler System.out.println(result); }).exceptionally(exception -> { // TODO failure callback handler exception.printStackTrace(); return null; }); ``` |
false (default) |
```java Object body = ApiHelper.deserialize("{\"key1\":\"val1\",\"key2\":\"val2\"}"); jsonObjController.sendSchemaasBodyAsync(body).thenAccept(result -> { // TODO success callback handler System.out.println(result); }).exceptionally(exception -> { // TODO failure callback handler exception.printStackTrace(); return null; }); ``` |
| Value | Change |
true |
```php $body = '{"key1":"val1","key2":"val2"}'; $result = $jsonObjController->sendSchemaasBody($body); ``` |
false (default) |
```php $body =[ "key1" => "val1", "key2" => "val2" ]; $result = $jsonObjController->sendSchemaasBody($body); ``` |
| Value | Change |
true |
```python def send_schemaas_body(self, body): """ Args: body (dict): This will be sent in body """ # Here the body should be a dictionary type body = {"key1":"val1","key2":"val2"} ``` |
false (default) |
```python def send_schemaas_body(self, body): """ Args: body (object): This will be sent in body """ # Here the body can have any value: body = 'Any Value' ``` |
| Value | Change |
true |
```ruby # Send Schema as Body # @param [Hash] body Required parameter: Example: # @return [ServerResponse] response from the API call def send_schemaas_body(body) // Here body should be a Hash type: body = { 'key1' => 'val1', 'key2' => 'val2' } ``` |
false (default) |
```ruby # Send Schema as Body # @param [Object] body Required parameter: Example: # @return [ServerResponse] response from the API call def send_schemaas_body(body) // Here the body can have any value: body = 'Any Value' ``` |
| Value | Change |
true |
```ts
async sendSchemaasBody(body: Record |
false (default) |
```ts
async sendSchemaasBody(body: unknown): Promise |
| Value | Change |
| Default | ``` csharp ``` |
| Configured | ``` csharp ``` |
| Value | Change |
| Default | ``` java ``` |
| Configured | ``` java ``` |
| Value | Change |
| Default | ``` php /* * PetStore * * This file was automatically generated by APIMATIC v3.0 ( https://www.apimatic.io ). */ ``` |
| Configured | ``` php /* * PetStore * * This file was automatically generated for Tech Corp by APIMATIC v3.0 ( https://www.apimatic.io ). */ ``` |
| Value | Change |
| Default | ``` python """ PetStore This file was automatically generated by APIMATIC v3.0 ( https://www.apimatic.io ). """ ``` |
| Configured | ``` python """ PetStore This file was automatically generated for Tech Corp by APIMATIC v3.0 ( https://www.apimatic.io ). """ ``` |
| Value | Change |
| Default | ``` ts /** * PetStore * * This file was automatically generated by APIMATIC v3.0 ( https://www.apimatic.io ). */ ``` |
| Configured | ``` ts /** * PetStore * * This file was automatically generated for Tech Corp by APIMATIC v3.0 ( https://www.apimatic.io ). */ ``` |
| Value | Change |
| Default | ``` go /* Package swaggerpetstore This file was automatically generated by APIMATIC v3.0 ( https://www.apimatic.io ). */ ``` |
| Configured | ``` go /* Package swaggerpetstore This file was automatically generated for Tech Corp by APIMATIC v3.0 ( https://www.apimatic.io ). */ ``` |
| Value | Change |
true |
Run the following command from your project directory to install the package from npm: ```typescript npm install container ``` |
false (default) |
Run the following command from your project directory to install the package from npm: ```typescript npm install container@2.0.1 ``` |
| Value | Change |
true |
 |
false (default) |
 |
| Value | Change |
| Configured (see Usage Details) |  |
| (default) |  |
| Value | Change |
true |
```csharp
/// |
false (default) |
```csharp
/// |
| Value | Change |
true (default) |
```ts const client = new Client({ basicAuthUsername: "Username", // Deprecated basicAuthPassword: "Password", // Deprecated basicAuthCredentials: { username: "Username", password: "Password", }, }); ``` |
false |
```ts const client = new Client({ basicAuthCredentials: { username: "Username", password: "Password", }, }); ``` |
| Value | Change |
true (default) |
```java SdkClient client = new SdkClient.Builder() .basicAuthCredentials("Username", "Password") // Deprecated .basicAuthCredentials( new BasicAuthModel.Builder( "Username", "Password" ) .build()) .build(); ``` |
false |
```java SdkClient client = new SdkClient.Builder() .basicAuthCredentials( new BasicAuthModel.Builder( "Username", "Password" ) .build()) .build(); ``` |
| Value | Change |
true (default) |
```python client = SdkClient( basic_auth_user_name='BasicAuthUserName', # Deprecated basic_auth_password='BasicAuthPassword', # Deprecated basic_auth_credentials=BasicAuthCredentials( username='Username', password='Password' ) ) ``` |
false |
```python client = SdkClient( basic_auth_credentials=BasicAuthCredentials( username='Username', password='Password' ) ) ``` |
| Value | Change |
true (default) |
```php $client = SdkClientBuilder::init() ->basicAuthUserName('BasicAuthUserName') // Deprecated ->basicAuthPassword('BasicAuthPassword') // Deprecated ->basicAuthCredentials( BasicAuthCredentialsBuilder::init( 'Username', 'Password' ) ) ->build(); ``` |
false |
```php $client = SdkClientBuilder::init() ->basicAuthCredentials( BasicAuthCredentialsBuilder::init( 'Username', 'Password' ) ) ->build(); ``` |
| Value | Change |
true (default) |
```csharp SdkClient client = new SdkClient.Builder() .BasicAuthCredentials("BasicAuthUserName", "BasicAuthPassword") // Deprecated .BasicAuthCredentials( new BasicAuthModel.Builder( "Username", "Password" ) .Build()) .Build(); ``` |
false |
```csharp SdkClient client = new SdkClient.Builder() .BasicAuthCredentials( new BasicAuthModel.Builder( "Username", "Password" ) .Build()) .Build(); ``` |
| Value | Change |
true (default) |
```ruby client = Sdk::Client.new( basic_auth_user_name: 'BasicAuthUserName', # Deprecated basic_auth_password: 'BasicAuthPassword', # Deprecated basic_auth_credentials: BasicAuthCredentials.new( username: 'Username', password: 'Password' ) ) ``` |
false |
```ruby client = Sdk::Client.new( basic_auth_credentials: BasicAuthCredentials.new( username: 'Username', password: 'Password' ) ) ``` |
| Value | Change |
true |
```csharp // highlight-next-line DateTimeOffset datetime = DateTime.ParseExact( "2023-03-13T12:52:32.123Z", "yyyy'-'MM'-'dd'T'HH':'mm':'ss.FFFFFFFK", provider: CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind); ``` |
false (default) |
``` csharp // highlight-next-line DateTime datetime = DateTime.ParseExact( "2023-03-13T12:52:32.123Z", "yyyy'-'MM'-'dd'T'HH':'mm':'ss.FFFFFFFK", provider: CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind); ``` |
| Value | Change |
true |
```java ZonedDateTime datetime = DateTimeHelper.fromRfc8601DateTime("2023-03-13T12:52:32.123Z"); ``` |
false (default) |
```java LocalDateTime datetime = DateTimeHelper.fromRfc8601DateTime("2023-03-13T12:52:32.123Z"); ``` |
The Value MUST correspond with the type of the endpoint parameter.
| Flag | Description | | ----------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | **Is Null** | If this flag is enabled or a required parameter isn't provided an input value, the input parameter is given a null or zero value according to the type of the input. | Some examples of name value pairs are as below: | Name | Value | | ---------------- | ------------------------------------------ | | someInteger | `1231` | | someString | `Hello, world!` | | someIntegerArray | `[1,2,3,4,5]` | | someBoolean | `true` | | someModel | `{"name":"Bob","age":22,"uploadCount":12}` | | someEnumeration | `[123,22,125]` | :::note If the endpoint has optional query parameters enabled then such type of parameters can be provided within the input parameters by preceding the Name with asterisk (\*). Similarly, if the endpoint has optional field parameters enabled then such type of parameters can be provided within the input parameters by preceding the Name with a plus sign (+). ::: ### Calculate Endpoint Test Case Example As already discussed, the Calculate endpoint contains 3 parameters. Their names will already be listed in the **Name** of the parameters. You need to just specify their values and decide whether to disable/enable **Is Null** flag.  In the above, we specified the values for the parameters. We've disabled the **Is Null** for all the parameters as we don't want them to take null values as input. ## Step 4: Specify Header Status  This section lets you set header status code for the expected response. ### Status CodeThis refers to the expected status code of the response. The expected status can be given an exact value such as "200" or a range of values such as "20X."
As an example, a value of "20X" will match any status between 200 - 208 (inclusive) which are all valid HTTP status codes. Other possible HTTP status ranges are "30X," "4XX," and "41X." Note that only valid HTTP code values within each range will be checked. ### Calculate Endpoint Test Case Example We expect the status code to be 200 if the operation is successful, hence we input the value 200. ## Step 5: Specify Expected Headers If the expected headers are specified the response is tested to see if it contains these headers.
Just like with input parameters, we need to specify “Name-Value” pairs to specify header values. | Flag | Description | | ----------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Check Value** | The test case will check the values of all expected headers. This flag, if enabled, won't only check the presence of a header in the response with the same name as mentioned in the **Name** field but will also check that the value of that response header is the same as specified in the expected header value. | | **Allow Extra Headers** | If this flag is disabled, it will cause the test case to fail if the response contains other headers than those listed in the expected headers list. | ### Calculate Endpoint Test Case Example  For our Calculate endpoint test case, we will keep the expected headers empty. ## Step 6: Specify Expected Body  The expected body helps verify if the response body matches with the one specified. ### Expected BodyWhatever you expect the response to be, you input that into the Expected Body box.
This could be as simple as a number, some string or can be complex like an array or some valid JSON, etc. There are two flags related to testing arrays: | Flag | Description | | --------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | **Check array order** | If enabled, this will involve ensuring that the response body contains the array elements in the same order as the expected body. | | **Check array count** | If enabled, this will ensure that the response body contains the same number of elements in the array as does the expected body. | :::note If both the flags are enabled then the arrays will be strictly checked for equality, that is, their order as well as matching lengths. ::: ### Body Match Mode This is a dropdown menu which enlists various modes supported by APIMatic for body matching. What modes are applicable will depend on the response type of the endpoint. The modes are: | Match Mode | Valid for Types | Description | | --------------- | --------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `NONE` | All | The expected body is ignored and the response body isn't tested. | | `NATIVE` | Number, Long, Precision, Boolean and DateTime | Tests the response body as a primitive type using a simple equality test. Response must match exactly except in case of arrays where array ordering and strictness can be controlled via other options. | | `KEYS` | Enumerations and Arrays of Number, Long, Precision, Boolean and DateTime types | Checks whether the response body contains the same keys as those specified in the expected body. The keys provided can be a subset of the response being received. If any key is absent in the response body, the test fails. The test generated will perform deep checking which means if the response object contains nested objects, their keys will also be tested. | | `KEYSANDVALUES` | Models, Dynamic and Arrays of Number, Long, Precision, Boolean and DateTime types | Same as the KEYS mode except values are tested as well. The values must match. Since the deep comparison is performed, nested objects must also contain the correct values. In case of nested arrays, their ordering and strictness depends on the provided options. | | `RAW` | All | The response body is compared with the expected body via simple string checking. In case of Binary response, byte-by-byte comparison is performed. The expected body takes a URI path to a remote file to compare with the Binary response, which must be valid URI path. | #### Example 1 of Body Match Modes “KEYS,” “KEYSANDVALUES”: Expected body: ```json { "name": "bob", "address": { "city": "ABC" } } ``` Response body: ```json { "name": "bob", "age": 100, "alive": true, "address": { "city": "ABC", "postcode": "21333" } } ``` - This will pass for both `KEYS` and `KEYSANDVALUES` mode. :::note Response body that passes `KEYSANDVALUES` mode for a given expected body will also pass `KEYS` mode. ::: #### Example 2 of Body Match Modes “KEYS,” “KEYSANDVALUES”: Expected body: ```json { "name": "xxxx", "address": { "city": "aaaaa" } } ``` Response body: ```json { "name": "bob", "age": 100, "alive": true, "address": { "city": "ABC", "postcode": "21333" } } ``` - This passes for `KEYS` mode. - This fails for `KEYSANDVALUES` mode. #### Example 3 of Body Match Modes “KEYS,” “KEYSANDVALUES” and Array flags: Expected body: ```json { "name": "bob", "workingDays": ["Tuesday", "Monday"] } ``` Response body: ```json { "name": "bob", "age": 100, "alive": true, "workingDays": ["Monday", "Tuesday", "Wednesday"] } ``` - This passed for `KEYS` and `KEYSANDVALUES` mode only if both `ExpectedArrayCheckCount` and `ExpectedArrayOrderedMatching` are `false`. #### Example 4 of Body Match Modes “KEYS,” “KEYSANDVALUES” and Array flags: Expected body: ```json [ { "name": "alice" }, { "name": "bob" } ] ``` Response body: ```json [ { "name": "frank", "age": 100, "alive": true }, { "name": "alice", "age": 70, "alive": true }, { "name": "bob", "age": 90, "alive": false } ] ``` - This passed for `KEYS` and `KEYSANDVALUES` mode only if both `ExpectedArrayCheckCount` and `ExpectedArrayOrderedMatching` are `false`. :::note Each object from the expected body is checked for presence in response body. Note that two objects from expected body may match the same object from response body if they're subsets of that object. ::: #### Example 5 of Body Match Modes “KEYS,” “KEYSANDVALUES” and Array flags: Expected body: ```json [ { "name": "bob" }, { "name": "alice" } ] ``` Response body: ```json [ { "name": "alice", "age": 70, "alive": true }, { "name": "bob", "age": 90, "alive": false } ] ``` - This passed for `KEYS` and `KEYSANDVALUES` mode if ExpectedArrayCheckCount is `true` or `false`. - This fails for `KEYSANDVALUES` mode if `ExpectedArrayOrderedMatching` is `true`. :::note In case of an object array, the elements will be compared using the subset method, that is, either `KEYSANDVALUES` or `KEYS`. For primitives, simple equality comparison is used. ::: ### Calculate Endpoint Test Case Example  We expect the result of 2+3 as 5 hence the **Expected body** is given as “5.” The body matching should perform a simple string comparison between the body of the response and **Expected Body** to check if it contains the number “5.” This behavior matches with the mode `NATIVE` hence the mode chosen in `NATIVE`. ## Step 7: Save your Test Case Just click on “Save Test Case” present on top of the sticky header (or at the top of the Test Settings page) and your test case along with all the settings will be saved.  Congratulations! You have now successfully defined your first test case for your endpoint. To learn more on how to generate and run these test cases please refer to the [Run Your First Test Case](testing/running-test-case.md) --- # Running a Test Case Source: https://docs.apimatic.io/testing/running-test-case/ Now that you have successfully defined test cases, we will now guide you on how to run these test cases in order to test your endpoints. ## Generate your SDK Click on the box as shown in the figure below to generate your code.  Choose the platform of your choice:  For our example we will be choosing the Windows platform to generate a Portable Class Library in C#.  Once the code generation is successful download the Zip file.  You will see a **Calculator-CSharp** zip file. Extract its files in the same folder.  You will have something similar inside the extracted folder:  Open the **Calculator.sln** file in Visual Studio. ## Run the Test Case Using NUnit in Visual Studio In order to run the test case in Visual Studio you need to have NUnit 3.0 installed. Rebuild your solution and open **Test Explorer**.  If the build was successful, you will see our test case **TestTestSum** listed in the Test Explorer.  Click on **Run All** to run the test. You will see the statistics displayed about the number of tests that passed or failed and the time taken, etc.  Congratulations! You successfully ran your first test case! --- # Testing Frameworks Source: https://docs.apimatic.io/testing/testing-frameworks/ Below, we will highlight some of the testing frameworks available per language. You can utilize these when making use of the test generation feature. ## C\# For C#, you can either generate a Portable Class Library (PCL) or a Universal Windows Platform (UWP) library at the time of SDK generation. The Portable Class Library (PCL) can run on range of platforms such as Windows, Silverlight and Windows Phone. In order to run the test cases generated along with the library, you require a testing framework. One such framework is “NUnit” whose current release version is 3.0. If you use Visual Studio you can easily install it using the Extension Manager.  After a successful build of the generated solution in Visual Studio, you can run the tests from the Test Explorer and a generated report will tell you various statistics including the number of tests that passed or failed.  The Universal Windows Platform (UWP) library also supports many of the Windows platforms including but not limited to Windows 10, Windows 10 Mobile, Xbox One etc. The unit testing framework you can use for running the test cases generated along with this library is MSTest. Just like NUnit, MSTest also allows the tests to be run from within Visual Studio. ## Android You can generate a gradle based Android library from your API definition. You can then use it inside an IDE like Android Studio (that comes with Gradle) or a command line based gradle build system. An Android library compiles into an Android Archive (AAR) file that you can use as a dependency for an Android app module. The generated tests are defined as JUnit tests. JUnit is the most popular and widely-used unit testing framework for Java. You can navigate from within Android Studio to run these generated tests which internally makes use of the Android JUnit runner. The tests are instrumented tests that run on the emulator/hardware. ## Java The generated Java SDK is actually a java library which can be used with JRE7. You can use an IDE like Eclipse equipped with Maven to utilize this library e.g. this Java library can be added as a dependency for a Java project. To run the generated tests you require a testing framework. For Java, the most widely used framework is JUnit which not only acts as a framework but also as a runner. Inside Eclipse, you would need to select the library project and then choose to run the JUnit tests.  This will run all the tests present in the “tests” directory and display relevant statistics.  ## Objective C Generation of SDK for IOS will generate a Cocoa Touch Static Library which is a static library in Objective-C. The advantage of generating a static library is that it supports iOS versions as old as iOS 6. You can run the generated tests from within an IDE like “xCode”. It provides its users with capabilities for extensive software testing. It consists of a built-in test framework called “XCTest” which allows for smooth running of the generated tests. ## PHP When you generate an SDK for PHP you will obtain a PHP library that is based on PHP version 5.3 or greater and also requires Composer dependency manager. You can use this library as a dependency in your project. The test cases generated during SDK generation can be run using a testing framework like PHPUnit. ## Python SDK generation in Python results in a Python package compatible with Python 2.7.x and Python 3.x, which uses PIP as the dependency manager. A famous testing framework is “unittest” which is python’s xUnit style framework. It is a test module that comes bundled with the Python standard library. “nose” extends “unittest” to make testing easier as it provides automatic test discovery. For our generated SDK, “unittest” is used as the testing framework and “nose” is used as the test runner. Invoking a simple command “nosetests” on the SDK will help run the tests. ## Ruby SDK generation in Ruby results in a Ruby Gem based on Ruby version 2.0.0 or greater. The tests automatically generated can be run using a testing framework like Test::Unit that includes the appropriate test runners. ## NodeJS SDK Generation in NodeJS creates a Node based library which can be included in the project. Dependencies need to be resolved by using npm. The SDK already comes with a **package.json** file which contains information about all the dependencies. Running `npm install` from the command line will resolve all dependencies. For tests, Mocha is used as the testing framework. Mocha is coupled with Chai as the assertion library for tests. Mocha acts as the test runner for test cases generated with the SDK. Tests can easily be run from the command line by typing `mocha --recursive` from the SDK's root folder. ## Go SDK Generation in Go creates a Go client library which can be included in the project. For tests, the native Go package `testing` is used as the testing framework. Tests can easily be run from the command line by running `go test` from the SDK's test folder. --- # Configure Test Case Generation Settings Source: https://docs.apimatic.io/testing/configure-test-case-generation/ You can import your API definition file along with a [Metadata file](manage-apis/apimatic-metadata.md) that will allow you to configure test case generation for your API. Details on the available test case generation settings in the UI can be viewed [here](/web-dashboard-retired). The same configurations can be made using the Metadata file [Test Generation Settings Object](#test-generation-settings-object) as follows: **Example** ```json { "TestGenSettings": { "Configuration": {}, "TestTimeout": 30, "PrecisionDelta": 0.01 } } ``` ## Test Generation Settings Object **Name** : TestGenSettings The available properties and their respective types are as follows: | Setting | Type | Purpose | | ------- | ---- | ------- | | TestTimeout | Integer | Number of seconds after which the test should timeout. | | PrecisionDelta | Float | Number of decimal places to cover when comparing precision types in test. For example, a precision delta of 0.1 would mean that all precisions will be compared to 1 decimal place only. | | Environment | String | Environment to use when running tests. The name of the environment must exactly match with the name of a pre-defined environment in the API definition. | | Configuration | [Configuration Parameters Object](#configuration-parameters-object) | The configuration parameters allows you to provide initialization values for Configuration file for use in the test environment. | ### Configuration Parameters Object The configuration parameters object allows you to provide initialization values in the form of key-value pairs for the Configuration file which will be used in the test environment, for example, you may specify a new URL for `baseUri` parameter. This can be useful if you require to test your endpoint responses from a sandbox environment instead of a real environment (which would otherwise make use of `baseUri` described in the API Description). Similarly, you can also define values for test authentication parameters within these configuration parameters. #### Example ``` "Configuration": { "baseUri": "http://example.com", "apikey": "972938472934234" } ``` --- # Troubleshooting Tests Source: https://docs.apimatic.io/testing/test-faq/ Here are answers to some frequently asked questions regarding the test generation feature: 1. **I am getting the error "The test input for parameter (parameter Name) in test case (Testcase Name) is invalid". What should I do?** Please verify that the value you have specified for this parameter is indeed a valid value for the type of the parameter you defined in the endpoint definition. E.g. if your parameter is defined to be a `Number` and the test value you are giving it is a string then the validation will fail and you will get this error. 2. **I am getting the error "Test input (parameter Name) does not correspond to an endpoint parameter in test case (Testcase Name)". What should I do?** Please ensure that the endpoint for which you are defining the test case indeed contains a definition of a parameter with that name. If not, please define that parameter in the endpoint definition and then try again. 3. **I am getting the warning "Query params/ Field params are provided in test (Testcase Name) when endpoint does not allow it". What is causing this warning?** You seem to have defined some query parameters or field parameters in your input parameters of the test case even though you did not enable the use of these parameters in your endpoint definition. Please enable the Query parameters using the **Allow dynamic query params** and enable the Field parameters using the **Allow dynamic form fields** in the endpoint definition. 4. **I am getting the error "Body match mode (Mode Name) is not allowed for response of type (Type Name) in test case (Test Case Name) ". What should I do?** A particular body match mode may not be applicable to responses of certain types. In such a case you will encounter this error. To refer to the modes available for a particular response type, please refer to [Step 6: Specify Expected Body](testing/defining-test-case.md#step-6-specify-expected-body). --- # SDK Features Overview Source: https://docs.apimatic.io/generate-sdks/sdk-features/ APIMatic offers SDK Generation for your APIs to help accelerate the API consumption process. These SDKs generated aren't just a mapping of the API onto the SDK. They contain additional functionality that adheres to the best coding practices to make the SDKs as robust and fault-tolerant as possible. The features and their description are shown in the table below: | Feature | Description | |--------------------------------------------------------------| ----------- | | Access to HTTP Response Data | SDKs created can now also return the HTTP response information like response headers, status code and body on API calls. | | Additional Model Properties | APIMatic CodeGen allows adding additional properties to models, enhancing the flexibility and customization of the generated SDKs. For more details on this feature, refer to [Additional Model Properties](sdk-features/additional-model-properties.md). | | Array Serialization Formats | This feature supports various array serialization formats, enabling developers to handle arrays in different ways as per their API requirements. For more details on this feature, refer to [Array Serialization Formats](sdk-features/array-serialization-formats.md). | | Async Operations | For languages that support asynchronous operations, SDKs provide asynchronous methods to call endpoints to fully utilize the potential of async programming paradigm. | | Auto Refresh OAuth 2.0 Tokens | This feature allows the SDK to automatically refresh OAuth 2.0 tokens, ensuring seamless authentication without manual intervention. For more details on this feature, refer to [Auto Refresh OAuth 2.0 Tokens](sdk-features/auto-refresh-oauth-2-tokens.md). | | Client Initialization from Environment | This feature enables automatic client initialization using environment variables, allowing developers to configure SDK settings without hardcoded values. This simplifies deployment across different environments. For more details on this feature, refer to [Client Initialization from Environment](sdk-features/client-initialization-from-environment.md). | | Code Samples and Usage Examples for Every Endpoint and Model | All SDKs have detailed documentation on all endpoints and models. The documentation provides code samples for the endpoints by dynamically populating dummy data needed for an endpoint call. | | Code Style Compliant SDKs | All SDKs follow coding style conventions and best practices making the SDKs code consistent, reliable and maintainable. | | Configurable HTTP Clients | Developers can provide their own instance of the HTTP client during client initialization. This gives them the ability to override default configurations used by our SDKs. For more details on this feature, refer to [Configurable HTTP Clients](sdk-features/configurable-http-clients.md). | | Custom Error Messages | APIMatic CodeGen allows defining custom errors against 4XX - 5XX HTTP response codes. You can use this feature to define meaningful information to failed calls. For more details on this feature, refer to [Custom Error Messages](sdk-features/custom-error-messages.md). | | Deprecating API Endpoints | An endpoint that's marked as deprecated will result in a compiler warning or a notice logged to the console when the endpoint method is called by the SDK user. This feature helps developers identify and migrate from deprecated endpoints using clear messages and compiler warnings. For more details on this feature, refer to [Deprecating API Endpoints](sdk-features/deprecating-api-endpoints.md). | | Dynamic Error Messages | Dynamic error messages allow you to define template messages that are populated with data at runtime. Through this feature, users can figure out the exact reason behind the failed call and debug accordingly. For more details on this feature, refer to [Dynamic Error Messages](sdk-features/dynamic-error-messages.md). | | Extendable Interfaces | SDKs can be configured to generate interfaces for controller classes. These interfaces can be used to extend the functionality of the SDKs. | | Getting Started ReadMe's with all SDKs | All SDKs come bundled with a comprehensive ReadMe that contains information about environments, configuration, authentication and code samples to initialize the client. Also a step by step guide on setting up the SDK in a popular IDE has been given. | | Handle Cancellation of API calls | SDKs support cancellation of API calls during the API call execution. | | Immutable Client | Client classes of all the SDKs are designed using the immutable design pattern. This gives developers the assurity that once the client has been instantiated, no method call would mutate its state. | | Inheritance and Polymorphism with AllOf | This feature supports the AllOf constructs in API specifications, providing flexibility in combining multiple schema definitions. For more details on this feature, refer to [Inheritance and Polymorphism with AllOf](sdk-features/inheritance-and-polymorphism-with-all-of.md). | | Logging | APIMatic CodeGen includes logging capabilities to help developers debug and monitor the SDKs behavior. This feature provides detailed logs of API requests and responses. For more details on this feature, refer to [Logging](sdk-features/logging.md). | | Multiple Authentication | This feature supports multiple authentication methods, allowing developers to implement various authentication schemes in their SDKs. For more details on this feature, refer to [Multiple Authentication](sdk-features/multiple-authentication.md). | | Multipart Requests | You can send JSON-encoded data in a multipart request by setting the encoding of the parameter as JSON in your API definition. | | OAuth Support and Utility Methods | All SDKs support popular OAuth 2.0 flows and provide utility methods to generate or refresh access tokens. For more details on this feature, refer to [OAuth 2.0 Support](sdk-features/oauth-2-support.md). | | OneOf and AnyOf | This feature supports the OneOf and AnyOf constructs in API specifications, providing flexibility in handling different data types. For more details on this feature, refer to [OneOf and AnyOf](sdk-features/oneOf-and-anyOf.md). | | Optional and Nullable Properties | APIMatic CodeGen supports optional and nullable Properties, allowing developers to handle optional data in their API requests and responses. For more details on this feature, refer to [Optional and Nullable Properties](sdk-features/optional-nullable-properties.md). | | Pagination | APIMatic CodeGen supports pagination, allowing developers to handle paginated data in their API responses. For more details on this feature, refer to [Pagination](sdk-features/pagination.md).| | Proxy configuration support | APIMatic CodeGen supports proxy configuration, enabling developers to route API requests through a proxy server. For more details on this feature, refer to [Proxy Configuration Support](sdk-features/proxy-configuration-support.md).| | Request Parameter Collections | This feature enables the SDK to collect parameters for endpoints, simplifying the process of making API calls with multiple parameters. For more details on this feature, refer to [Request Parameter Collections](sdk-features/request-parameter-collections.md). | | Retries with Exponential Backoff | If an API call fails due to network problems, it's retried with an exponentially increasing wait time up to a maximum retry count specified by the user. This is particularly helpful during temporary network outages. For more details on this feature, refer to [Retries with Exponential Backoff](sdk-features/retries-with-exponential-backoff.md).| | Schema Constraints | Generated models carry OpenAPI schema constraints as declarative .NET validation attributes, so you can validate requests and responses using standard .NET validation. For more details on this feature, refer to [Schema Constraints](sdk-features/schema-constraints.md). | | Server-Sent Events (SSE) Streaming | APIMatic CodeGen supports streaming API responses over Server-Sent Events, exposing them as a typed, async-iterable stream that yields decoded events as they arrive. For more details on this feature, refer to [Server-Sent Events (SSE) Streaming](sdk-features/server-sent-events-streaming.md). | | Thread Safe Operations | SDKs are designed to handle concurrent API calls in a thread safe manner. | | Webhooks and Callbacks | APIMatic CodeGen supports webhooks and callbacks functionality, enabling developers to handle real-time notifications and event-driven API interactions. For more details on this feature, refer to [Webhooks and Callbacks](sdk-features/webhooks-and-callbacks.md). | --- # Additional Model Properties Source: https://docs.apimatic.io/generate-sdks/sdk-features/additional-model-properties/ import Tabs from '@theme/Tabs'; import TabItem from '@theme/TabItem'; APIMatic SDKs provide support for the JSON Schema `additionalProperties` keyword, which controls how additional properties(those not defined in `properties` or `patternProperties`) are handled. This enables SDKs to handle dynamic or unpredictable data structures in API requests and responses. ### Configure Additional Model Properties To leverage additional properties in your SDKs, enable the [`ExtendedAdditionalPropertiesSupport`](/generate-sdks/customize-sdks/codegen-settings/model-settings/#extended-additional-properties-support) Code Generation setting while generating your SDKs. Additional properties can be defined in OpenAPI definitions using the `additionalProperties` keyword, as demonstrated below: ```yaml components: schemas: StudentResult: type: object required: - email properties: email: type: string format: email additionalProperties: type: number ``` In this example, the **StudentResult** model defines a required **email** property of type **string**. Additionally, it supports any number of **additionalProperties** where keys are **strings**, and values are **number**. ### Usage in SDK After configuring your API definition, the generated SDK will expose these additional properties with type safety. For instance: #### SDK Request Examples Here’s how an object of type **StudentResult** can be initialized: