SutHandler (evomaster-client-java-controller 2.0.0 API)

All Known Implementing Classes:

EmbeddedSutController, ExternalSutController, SutController
```
public interface SutHandler
```
Base interface used to control the System Under Test (SUT) from the generated tests. Needed base functionalities are for example, starting/stopping the SUT, and reset its state.

Method Summary

All Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`InsertionResultsDto`	`execInsertionsIntoDatabase(List<InsertionDto> insertions, InsertionResultsDto... previous)` Execute the given data insertions into the database (if any)
`MongoInsertionResultsDto`	`execInsertionsIntoMongoDatabase(List<MongoInsertionDto> insertions)`
`default Object`	`executeRPCEndpoint(String json)` execute an RPC endpoint with evomaster driver
`default void`	`extractRPCSchema()` execute an RPC endpoint with evomaster driver
`List<DbSpecification>`	`getDbSpecifications()` If the system under test (SUT) uses a SQL database, we need to have a configured DbSpecification to access/reset it.
`default Object`	`getMongoConnection()`
`default Object`	`getRPCClient(String interfaceName)` return an instance of a client of an RPC service.
`default boolean`	`handleLocalAuthenticationSetup(String authenticationInfo)` authentication setup might be handled locally.
`default boolean`	`mockDatabasesWithCustomizedHandling(String mockDatabaseObjectDtos, boolean enabled)` a method to employ customized mocking for database
`default boolean`	`mockRPCExternalServicesWithCustomizedHandling(String externalServiceDtos, boolean enabled)` a method to employ customized mocking of RPC based external services
`default void`	`registerOrExecuteInitSqlCommandsIfNeeded()` register or execute specified SQL script for initalizing data in database
`default boolean`	`resetCustomizedMethodForMockObject()` a method to reset mocked external services with customized method
`default void`	`resetDatabase(List<String> tablesToClean)` reset database if the smart db cleaning is employed
`void`	`resetStateOfSUT()` Make sure the SUT is in a clean state (eg, reset data in database).
`default void`	`setupForGeneratedTest()` There might be different settings based on when the SUT is run during the search of EvoMaster, and when it is later started in the generated tests.
`String`	`startSut()` Start a new instance of the SUT.
`void`	`stopSut()` Stop the SUT.

- Method Detail
  - setupForGeneratedTest
```
default void setupForGeneratedTest()
```
    There might be different settings based on when the SUT is run during the search of EvoMaster, and when it is later started in the generated tests.
  - startSut
```
String startSut()
```
    Start a new instance of the SUT.
    
    This method must be blocking until the SUT is initialized.
    
    How this method is implemented depends on the library/framework in which the application is written. For example, in Spring applications you can use something like: SpringApplication.run()
    
    Returns:
    
    the base URL of the running SUT, eg "http://localhost:8080"
  - stopSut
```
void stopSut()
```
    Stop the SUT.
    
    How to implement this method depends on the library/framework in which the application is written. For example, in Spring applications you can save in a variable the ConfigurableApplicationContext returned when starting the application, and then call stop() on it here.
  - resetStateOfSUT
```
void resetStateOfSUT()
```
    Make sure the SUT is in a clean state (eg, reset data in database).
    
    A possible (likely very inefficient) way to implement this would be to call stopSUT followed by startSUT.
    
    When dealing with databases, you can look at the utility functions from the class DbCleaner. How to access the database depends on the application. To access a java.sql.Connection, in Spring applications you can use something like: ctx.getBean(JdbcTemplate.class).getDataSource().getConnection().
  - execInsertionsIntoDatabase
```
InsertionResultsDto execInsertionsIntoDatabase(List<InsertionDto> insertions,
                                               InsertionResultsDto... previous)
```
    Execute the given data insertions into the database (if any)
    
    Parameters:
    
    insertions - DTOs for each insertion to execute
    
    previous - an array of insertion results which were executed before this execution
    
    Returns:
    
    insertion execution results
  - execInsertionsIntoMongoDatabase
```
MongoInsertionResultsDto execInsertionsIntoMongoDatabase(List<MongoInsertionDto> insertions)
```
  - getRPCClient
```
default Object getRPCClient(String interfaceName)
```
    return an instance of a client of an RPC service.
    
    This method must be blocking until the SUT is initialized.
    
    This method is only required when the problem is RPC for the moment, otherwise return null
    might change string interfaceName to class interface
    
    Parameters:
    
    interfaceName - a full name of an interface
    
    Returns:
    
    a client which could send requests to the interface
  - executeRPCEndpoint
```
default Object executeRPCEndpoint(String json)
                           throws Exception
```
    execute an RPC endpoint with evomaster driver
    
    Parameters:
    
    json - contains info of an RPC endpoint
    
    Returns:
    
    value returned by this execution. it is nullable.
    
    Throws:
    
    Exception
  - extractRPCSchema
```
default void extractRPCSchema()
```
    execute an RPC endpoint with evomaster driver
    TODO remove this later if we do not use test generation with driver
  - handleLocalAuthenticationSetup
```
default boolean handleLocalAuthenticationSetup(String authenticationInfo)
```
    authentication setup might be handled locally. then we provide this interface to define it.
    
    Parameters:
    
    authenticationInfo - info for the authentication setup
    
    Returns:
    
    if the authentication is set up successfully
  - getDbSpecifications
```
List<DbSpecification> getDbSpecifications()
```
    If the system under test (SUT) uses a SQL database, we need to have a configured DbSpecification to access/reset it.
    
    When accessing a Connection object to reset the state of the application, we suggest to save it to field (eg when starting the application), and set such field with DbSpecification.connection. This connection object will be used by EvoMaster to analyze the state of the database to create better test cases.
    
    To handle db in the context of testing, there might be a need to initialize data into database with a sql script. such info could be specified with DbSpecification.dbType
    
    With EvoMaster, we also support a smart DB cleaner by removing all data in tables which has been accessed after each test. In order to achieve this, we requires user to set a set of info such as database type with DbSpecification.dbType, schema name with DbSpecification.schemaNames (TODO might remove later). In addition, we also provide an option (default is true) to configure if such cleaner is preferred with DbSpecification.employSmartDbClean.
    
    Returns:
    
    null if the SUT does not use any SQL database
  - getMongoConnection
```
default Object getMongoConnection()
```
  - registerOrExecuteInitSqlCommandsIfNeeded
```
default void registerOrExecuteInitSqlCommandsIfNeeded()
```
    register or execute specified SQL script for initalizing data in database
  - resetDatabase
```
default void resetDatabase(List<String> tablesToClean)
```
    reset database if the smart db cleaning is employed
  - resetCustomizedMethodForMockObject
```
default boolean resetCustomizedMethodForMockObject()
```
    a method to reset mocked external services with customized method
  - mockRPCExternalServicesWithCustomizedHandling
```
default boolean mockRPCExternalServicesWithCustomizedHandling(String externalServiceDtos,
                                                              boolean enabled)
```
    a method to employ customized mocking of RPC based external services
    
    Parameters:
    
    externalServiceDtos - contains info about how to setup responses with json format, note that the json should be able to be converted to a list of MockRPCExternalServiceDto
    
    enabled - reflect to enable (set it true) or disable (set it false) the specified external service dtos. Note that null [externalServiceDtos] with false [enabled] means that all existing external service setup should be disabled.
    
    Returns:
    
    whether the mocked instance starts successfully,
  - mockDatabasesWithCustomizedHandling
```
default boolean mockDatabasesWithCustomizedHandling(String mockDatabaseObjectDtos,
                                                    boolean enabled)
```
    a method to employ customized mocking for database
    
    Parameters:
    
    mockDatabaseObjectDtos - contains info about how to set up mock object for databases with json format, note that the json should be able to be converted to a list of MockDatabaseDto
    
    enabled - reflect to enable (set it true) or disable (set it false) the specified mock object Note that null [mockDatabaseObjectDtos] with false [enabled] means that all existing mock objects for databases should be disabled.
    
    Returns:
    
    whether the mocked instance starts successfully,

Interface SutHandler

Method Summary

Method Detail

setupForGeneratedTest

startSut

stopSut

resetStateOfSUT

execInsertionsIntoDatabase

execInsertionsIntoMongoDatabase

getRPCClient

executeRPCEndpoint

extractRPCSchema

handleLocalAuthenticationSetup

getDbSpecifications

getMongoConnection

registerOrExecuteInitSqlCommandsIfNeeded

resetDatabase

resetCustomizedMethodForMockObject

mockRPCExternalServicesWithCustomizedHandling

mockDatabasesWithCustomizedHandling