| /** |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| package org.apache.fineract.test.stepdef.datatable; |
| |
| import static java.util.function.Function.identity; |
| import static org.apache.fineract.test.helper.ErrorHelper.checkSuccessfulApiCall; |
| import static org.assertj.core.api.Assertions.assertThat; |
| |
| import io.cucumber.datatable.DataTable; |
| import io.cucumber.java.en.Then; |
| import io.cucumber.java.en.When; |
| import java.io.IOException; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.stream.Collectors; |
| import org.apache.commons.lang3.BooleanUtils; |
| import org.apache.fineract.client.models.GetDataTablesResponse; |
| import org.apache.fineract.client.models.PostColumnHeaderData; |
| import org.apache.fineract.client.models.PostDataTablesRequest; |
| import org.apache.fineract.client.models.PostDataTablesResponse; |
| import org.apache.fineract.client.models.ResultsetColumnHeaderData; |
| import org.apache.fineract.client.services.DataTablesApi; |
| import org.apache.fineract.test.data.datatable.DatatableColumnType; |
| import org.apache.fineract.test.data.datatable.DatatableEntityType; |
| import org.apache.fineract.test.data.datatable.DatatableNameGenerator; |
| import org.apache.fineract.test.stepdef.AbstractStepDef; |
| import org.springframework.beans.factory.annotation.Autowired; |
| import retrofit2.Response; |
| |
| public class DatatablesStepDef extends AbstractStepDef { |
| |
| public static final String CREATE_DATATABLE_RESULT_KEY = "CreateDatatableResult"; |
| public static final String DATATABLE_NAME = "DatatableId"; |
| public static final String DATATABLE_QUERY_RESPONSE = "DatatableQueryResponse"; |
| |
| @Autowired |
| private DataTablesApi dataTablesApi; |
| |
| @Autowired |
| private DatatableNameGenerator datatableNameGenerator; |
| |
| @When("A datatable for {string} is created") |
| public void whenDatatableCreated(String entityTypeStr) throws IOException { |
| DatatableEntityType entityType = DatatableEntityType.fromString(entityTypeStr); |
| List<PostColumnHeaderData> columns = createRandomDatatableColumnsRequest(); |
| PostDataTablesRequest request = createDatatableRequest(entityType, columns); |
| |
| Response<PostDataTablesResponse> response = dataTablesApi.createDatatable(request).execute(); |
| checkSuccessfulApiCall(response); |
| |
| PostDataTablesResponse responseBody = response.body(); |
| testContext().set(CREATE_DATATABLE_RESULT_KEY, responseBody); |
| testContext().set(DATATABLE_NAME, responseBody.getResourceIdentifier()); |
| } |
| |
| @When("A datatable for {string} is created with the following extra columns:") |
| public void whenDatatableCreatedWithFollowingExtraColumns(String entityTypeStr, DataTable dataTable) throws IOException { |
| DatatableEntityType entityType = DatatableEntityType.fromString(entityTypeStr); |
| List<List<String>> rows = dataTable.asLists(); |
| List<List<String>> rowsWithoutHeader = rows.subList(1, rows.size()); |
| List<PostColumnHeaderData> columns = createDatatableColumnsRequest(rowsWithoutHeader); |
| PostDataTablesRequest request = createDatatableRequest(entityType, columns); |
| |
| Response<PostDataTablesResponse> response = dataTablesApi.createDatatable(request).execute(); |
| checkSuccessfulApiCall(response); |
| |
| PostDataTablesResponse responseBody = response.body(); |
| testContext().set(CREATE_DATATABLE_RESULT_KEY, responseBody); |
| testContext().set(DATATABLE_NAME, responseBody.getResourceIdentifier()); |
| } |
| |
| private List<PostColumnHeaderData> createDatatableColumnsRequest(List<List<String>> rowsWithoutHeader) { |
| return rowsWithoutHeader.stream().map(row -> { |
| String columnName = row.get(0); |
| DatatableColumnType columnType = DatatableColumnType.fromTypeString(row.get(1)); |
| long columnLength = Long.parseLong(row.get(2)); |
| boolean unique = BooleanUtils.toBoolean(row.get(3)); |
| boolean indexed = BooleanUtils.toBoolean(row.get(4)); |
| |
| PostColumnHeaderData postColumnHeaderData = new PostColumnHeaderData(); |
| postColumnHeaderData.setName(columnName); |
| postColumnHeaderData.setType(columnType.getTypeString()); |
| postColumnHeaderData.setLength(columnLength); |
| postColumnHeaderData.setUnique(unique); |
| postColumnHeaderData.setIndexed(indexed); |
| return postColumnHeaderData; |
| }).collect(Collectors.toList()); |
| } |
| |
| @When("A multirow datatable for {string} is created") |
| public void whenMultirowDatatableCreated(String entityTypeStr) throws IOException { |
| DatatableEntityType entityType = DatatableEntityType.fromString(entityTypeStr); |
| List<PostColumnHeaderData> columns = createRandomDatatableColumnsRequest(); |
| PostDataTablesRequest request = createDatatableRequest(entityType, columns, true); |
| |
| Response<PostDataTablesResponse> response = dataTablesApi.createDatatable(request).execute(); |
| checkSuccessfulApiCall(response); |
| |
| PostDataTablesResponse responseBody = response.body(); |
| testContext().set(CREATE_DATATABLE_RESULT_KEY, responseBody); |
| testContext().set(DATATABLE_NAME, responseBody.getResourceIdentifier()); |
| } |
| |
| private List<PostColumnHeaderData> createRandomDatatableColumnsRequest() { |
| PostColumnHeaderData columnDef = new PostColumnHeaderData(); |
| columnDef.setName("col"); |
| columnDef.setType(DatatableColumnType.NUMBER.getTypeString()); |
| columnDef.setMandatory(false); |
| columnDef.setLength(10L); |
| columnDef.setCode(""); |
| columnDef.setUnique(false); |
| columnDef.setIndexed(false); |
| return List.of(columnDef); |
| } |
| |
| private PostDataTablesRequest createDatatableRequest(DatatableEntityType entityType, List<PostColumnHeaderData> columns) { |
| return createDatatableRequest(entityType, columns, false); |
| } |
| |
| private PostDataTablesRequest createDatatableRequest(DatatableEntityType entityType, List<PostColumnHeaderData> columns, |
| boolean multiRow) { |
| PostDataTablesRequest request = new PostDataTablesRequest(); |
| String datatableName = datatableNameGenerator.generate(entityType); |
| request.setDatatableName(datatableName); |
| request.setApptableName(entityType.getReferencedTableName()); |
| request.setMultiRow(multiRow); |
| request.setColumns(columns); |
| return request; |
| } |
| |
| @Then("The following column definitions match:") |
| public void thenColumnsMatch(DataTable dataTable) throws IOException { |
| String datatableName = testContext().get(DATATABLE_NAME); |
| Response<GetDataTablesResponse> httpResponse = dataTablesApi.getDatatable(datatableName).execute(); |
| checkSuccessfulApiCall(httpResponse); |
| |
| GetDataTablesResponse response = httpResponse.body(); |
| Map<String, ResultsetColumnHeaderData> columnMap = response.getColumnHeaderData().stream() |
| .collect(Collectors.toMap(ResultsetColumnHeaderData::getColumnName, identity())); |
| |
| List<List<String>> rows = dataTable.asLists(); |
| List<List<String>> rowsWithoutHeader = rows.subList(1, rows.size()); |
| |
| for (List<String> row : rowsWithoutHeader) { |
| String columnName = row.get(0); |
| boolean primaryKey = BooleanUtils.toBoolean(row.get(1)); |
| boolean unique = BooleanUtils.toBoolean(row.get(2)); |
| boolean indexed = BooleanUtils.toBoolean(row.get(3)); |
| |
| ResultsetColumnHeaderData columnMetadata = columnMap.get(columnName); |
| assertThat(columnMetadata).withFailMessage("Column [%s] not found on datatable", columnName).isNotNull(); |
| |
| assertThat(columnMetadata.getIsColumnPrimaryKey()) |
| .withFailMessage("Primary key definition for column [%s] does not match", columnName).isEqualTo(primaryKey); |
| assertThat(columnMetadata.getIsColumnUnique()) |
| .withFailMessage("Unique constraint definition for column [%s] does not match", columnName).isEqualTo(unique); |
| assertThat(columnMetadata.getIsColumnIndexed()).withFailMessage("Index definition for column [%s] does not match", columnName) |
| .isEqualTo(indexed); |
| } |
| } |
| |
| @When("The client calls the query endpoint for the created datatable with {string} column filter, and {string} value filter") |
| public void thenColum23nsMatch(String columnFilter, String valueFilter) throws IOException { |
| Response<String> response = dataTablesApi.queryValues(testContext().get(DATATABLE_NAME), columnFilter, valueFilter, columnFilter) |
| .execute(); |
| testContext().set(DATATABLE_QUERY_RESPONSE, response); |
| } |
| |
| @Then("The status of the HTTP response should be {int}") |
| public void thenStatusCodeMatch(int statusCode) { |
| Response<String> response = testContext().get(DATATABLE_QUERY_RESPONSE); |
| assertThat(response.code()).isEqualTo(statusCode); |
| } |
| |
| @Then("The response body should contain the following message: {string}") |
| public void thenColumnsMatch(String json) throws IOException { |
| Response<String> response = testContext().get(DATATABLE_QUERY_RESPONSE); |
| String jsonResponse = response.errorBody().string(); |
| assertThat(jsonResponse).contains(json); |
| } |
| } |